Unit CastleVectors

Description

Uses

Classes, Interfaces, Objects and Records

Functions and Procedures

Types

Constants

Variables

Description

Vector and matrix types and basic geometric operations.

Various routines in this unit perform operations on geometric objects, like spheres and line segments. Here's an outline how do we represent various geometric objects:

Point in 3D is a TVector3.
Plane in 3D is a TVector4. Such vector [A, B, C, D] defines a surface that consists of all points satisfying equation A * x + B * y + C * z + D = 0. At least one of A, B, C must be different than zero.
Vector [A, B, C] is called PlaneDir in many places. It is called PlaneNormal when it's guaranteed (or required to be) normalized, i.e. scaled to have length 1.
Line in 3D space is represented by two TVector3 values: Line0 and LineVector. They determine a line consisting of all points that can be calculated as Line0 + R * LineVector where R is any real value.
LineVector must not be a zero vector.
Line in 2D space is sometimes represented as two TVector2 values called Line0 and LineVector (analogously like line in 3D).
And sometimes it's represented as one TVector3 value: [A, B, C], where line consists of all points satisfying A * x + B * y + C = 0. At least one of A, B must be different than zero.
A tunnel is an object that you get by moving a sphere along the line segment. In other words, this is like a cylinder, but ends with two hemispheres. The tunnel is represented in this unit as two points Tunnel1, Tunnel2 (this defines a line segment) and a TunnelRadius.
A ray is defined just like a line: two vectors RayOrigin and RayDirection, RayDirection must be nonzero. Ray consists of all points RayOrigin + R * RayDirection for R being any real value >= 0.
An axis-aligned plane in 3D is a plane parallel to one of the three basic planes. This is a plane defined by the equation X = Const or Y = Count or Z = Const. Such plane is represented as PlaneConstCoord integer value equal to 0, 1 or 2 and PlaneConstValue.
Note that you can always represent the same plane using a more general plane 3D equation, just take
```
Plane[0..2 / PlaneConstCoord] = 0,
Plane[PlaneConstCoord] = -1,
Plane[3] = PlaneConstValue.
```
A line segment (often referred to as just segment) is represented by two points Pos1 and Pos2. For some routines the order of points Pos1 and Pos2 is significant (but this is always explicitly stated in the interface, so don't worry).
Sometimes line segment is also represented as Segment0 and SegmentVector, this consists of all points Segment0 + SegmentVector * t for t in [0..1]. SegmentVector must not be a zero vector.
Conversion between the two representations above is trivial, just take Pos1 = Segment0 and Pos2 = Segment0 + SegmentVector.

Requirements of the geometric objects:

In descriptions of the geometric objects above, you can see some requirements, e.g. "the triangle must not be degenerated (equivalent to a line segment)", "RayDirection must not be a zero vector", etc. These requirements are generally not checked by routines in this unit (for the sake of speed) and passing wrong values to many of the routines may lead to exceptions (like an arithmetic exception) or nonsensible results. So try to make sure that the values you pass satisfy the requirements.

However, wrong input values should never lead to exceptions that would be a security risk, like access violations or range check errors. As these exceptions could be uncatched in some situations, and then allow accessing a memory that otherwise should not be accessed, so we protect from this. Sometimes you simply cannot guarantee for 100% that input values are correct, because the floating-point operations are inherently not precise.

About floating-point precision:

As floating-point operations are never precise, when comparing floating-point values we always use some epsilon to "tolerate" some small differences.
This epsilon is either done through the standard Math.SameValue and Math.IsZero or by using our own SingleEpsilon and DoubleEpsilon constants (they are equal to standard Math unit epsilon values). The floating-point vector and matrix comparison methods, like TVector3.Equals and TVector3.IsZero, compare with such epsilon.
If you really want to compare things precisely, use methods like TVector3.PerfectlyEquals or TVector3.IsPerfectlyZero.
For collision-detecting routines, the general strategy in case of uncertainty (when we're not sure whether there is a collision or the objects are just very very close to each other) is to say that there is a collision.
This means that we may detect a collision when in fact the precise mathematical calculation says that there is no collision.
This approach should be suitable for most use cases.

Uses

Overview

Classes, Interfaces, Objects and Records

Name	Description
Packed Record `TVector2Byte`	Vector of 2 Byte values.
Packed Record `TVector3Byte`	Vector of 3 Byte values.
Packed Record `TVector4Byte`	Vector of 4 Byte values.
Packed Record `TVector2Integer`	Vector of 2 Integer values.
Packed Record `TVector3Integer`	Vector of 3 Integer values.
Packed Record `TVector4Integer`	Vector of 4 Integer values.
Record `TVector2Cardinal`	Vector of 2 Cardinal values.
Record `TVector3Cardinal`	Vector of 3 Cardinal values.
Record `TVector4Cardinal`	Vector of 4 Cardinal values.
Record `TVector2SmallInt`	Vector of 2 SmallInt values.
Class `TVector2List`	List of TVector2.
Class `TVector3List`	List of TVector3.
Class `TVector4List`	List of TVector4.
Class `TVector4IntegerList`	List of TVector4Integer.
Class `TMatrix3List`	List of TMatrix3.
Class `TMatrix4List`	List of TMatrix4.
Class `TVector2DoubleList`	List of TVector2Double.
Class `TVector3DoubleList`	List of TVector3Double.
Class `TVector4DoubleList`	List of TVector4Double.
Class `TMatrix3DoubleList`	List of TMatrix3Double.
Class `TMatrix4DoubleList`	List of TMatrix4Double.
Packed Record `TVector4Pointer`	Vector of 4 Pointers.
Class `EPlanesParallel`
Class `ELinesParallel`
Class `TCastleVector2Persistent`	TVector2 record represented as a TPersistent descendant, to be able to visually edit it (in Lazarus and Delphi visual designer, and Castle Game Engine visual designer) and to serialize it.
Class `TCastleVector3Persistent`	TVector3 record represented as a TPersistent descendant, to be able to visually edit it (in Lazarus and Delphi visual designer, and Castle Game Engine visual designer) and to serialize it.
Class `TCastleVector4Persistent`	TVector4 record represented as a TPersistent descendant, to be able to visually edit it (in Lazarus and Delphi visual designer, and Castle Game Engine visual designer) and to serialize it.
Class `TSerializationProcessVectorsHelper`	Helper methods you can use from TCastleComponent.CustomSerialization to manage reading/writing of vectors.
Record `TTransformation`	Describe transformation in a way comfortable to apply it in both ways.
Class `TTransformationList`
Class `TBorder`	Configurable border size for TCastleUserInterface.Border.

Functions and Procedures

function Vector2(const X, Y: Single): TVector2; overload; inline;

function Vector2(const V: TVector2Double): TVector2; overload; inline;

function Vector2Double(const X, Y: Double): TVector2Double; inline;

function Vector3(const X, Y, Z: Single): TVector3; overload; inline;

function Vector3(const V: TVector2; const Z: Single): TVector3; overload; inline;

function Vector3(const V: TVector3Double): TVector3; overload; inline;

function Vector3Double(const X, Y, Z: Double): TVector3Double; overload; inline;

function Vector3Double(const V: TVector3): TVector3Double; overload; inline;

function Vector4(const X, Y, Z, W: Single): TVector4; overload; inline;

function Vector4(const V: TVector3; const W: Single): TVector4; overload; inline;

function Vector4(const V: TVector2; const Z, W: Single): TVector4; overload; inline;

function Vector4(const V: TVector4Double): TVector4; overload; inline;

function Vector4Double(const X, Y, Z, W: Double): TVector4Double; overload; inline;

function Vector4Double(const V: TVector4): TVector4Double; overload; inline;

function Matrix3(const V: TMatrix3Double): TMatrix3;

function Matrix4(const V: TMatrix4Double): TMatrix4;

function Matrix3Double(const V: TMatrix3): TMatrix3Double;

function Matrix4Double(const V: TMatrix4): TMatrix4Double;

function Vector2FromStr(const S: string): TVector2;

function Vector3FromStr(const S: string): TVector3;

function Vector4FromStr(const S: string): TVector4;

function Lerp(const A: Single; const V1, V2: TVector2): TVector2; overload; inline;

function Lerp(const A: Single; const V1, V2: TVector3): TVector3; overload; inline;

function Lerp(const A: Single; const V1, V2: TVector4): TVector4; overload; inline;

function Lerp(const A: Single; const M1, M2: TMatrix2): TMatrix2; overload; inline;

function Lerp(const A: Single; const M1, M2: TMatrix3): TMatrix3; overload; inline;

function Lerp(const A: Single; const M1, M2: TMatrix4): TMatrix4; overload; inline;

function Lerp(const A: Double; const V1, V2: TVector2Double): TVector2Double; overload; inline;

function Lerp(const A: Double; const V1, V2: TVector3Double): TVector3Double; overload; inline;

function Lerp(const A: Double; const V1, V2: TVector4Double): TVector4Double; overload; inline;

function Lerp(const A: Double; const M1, M2: TMatrix2Double): TMatrix2Double; overload; inline;

function Lerp(const A: Double; const M1, M2: TMatrix3Double): TMatrix3Double; overload; inline;

function Lerp(const A: Double; const M1, M2: TMatrix4Double): TMatrix4Double; overload; inline;

function TryInverseHarder(const M: TMatrix4; out MInverse: TMatrix4): boolean;

function CosAngleBetweenVectors(const V1, V2: TVector3): Single; overload;

function CosAngleBetweenNormals(const V1, V2: TVector3): Single; overload;

function AngleRadBetweenVectors(const V1, V2: TVector3): Single; overload;

function AngleRadBetweenNormals(const V1, V2: TVector3): Single; overload;

function RotationAngleRadBetweenVectors(const V1, V2: TVector3): Single; overload;

function RotationAngleRadBetweenVectors(const V1, V2, Cross: TVector3): Single; overload;

function RotatePointAroundAxisRad(const Angle: Single; const Point: TVector3; const Axis: TVector3): TVector3; overload;

function RotatePointAroundAxisDeg(const Angle: Single; const Point: TVector3; const Axis: TVector3): TVector3; overload; deprecated 'use radians for everything throughout CGE';

function RotatePointAroundAxis90(const Point: TVector3; const Axis: TVector3): TVector3;

function RotatePointAroundAxisMinus90(const Point: TVector3; const Axis: TVector3): TVector3;

function RotatePointAroundAxis(const AxisAngle: TVector4; const Point: TVector3): TVector3;

function MaxVectorCoord(const V: TVector2): integer; overload;

function MaxVectorCoord(const V: TVector3): T3DAxis; overload;

function MaxVectorCoord(const V: TVector4): integer; overload;

function MaxAbsVectorCoord(const V: TVector2): integer; overload;

function MaxAbsVectorCoord(const V: TVector3): T3DAxis; overload;

function MaxAbsVectorCoord(const V: TVector4): integer; overload;

function MinVectorCoord(const V: TVector3): T3DAxis; overload;

procedure SortAbsVectorCoord(const V: TVector3; out Max, Middle, Min: T3DAxis); overload;

function PlaneDirInDirection(const Plane: TVector4; const Direction: TVector3): TVector3; overload;

function PlaneDirInDirection(const PlaneDir, Direction: TVector3): TVector3; overload;

function PlaneDirNotInDirection(const Plane: TVector4; const Direction: TVector3): TVector3; overload;

function PlaneDirNotInDirection(const PlaneDir, Direction: TVector3): TVector3; overload;

function SwapEndian(const V: TVector2): TVector2; overload;

function SwapEndian(const V: TVector3): TVector3; overload;

function SwapEndian(const V: TVector4): TVector4; overload;

function LEtoN(const V: TVector2): TVector2; overload;

function LEtoN(const V: TVector3): TVector3; overload;

function LEtoN(const V: TVector4): TVector4; overload;

function BEtoN(const V: TVector2): TVector2; overload;

function BEtoN(const V: TVector3): TVector3; overload;

function BEtoN(const V: TVector4): TVector4; overload;

function NtoLE(const V: TVector2): TVector2; overload;

function NtoLE(const V: TVector3): TVector3; overload;

function NtoLE(const V: TVector4): TVector4; overload;

function NtoBE(const V: TVector2): TVector2; overload;

function NtoBE(const V: TVector3): TVector3; overload;

function NtoBE(const V: TVector4): TVector4; overload;

procedure SwapValues(var V1, V2: TVector2); overload;

procedure SwapValues(var V1, V2: TVector3); overload;

procedure SwapValues(var V1, V2: TVector4); overload;

procedure NormalizePlaneVar(var V: TVector4); overload;

procedure TwoPlanesIntersectionLine(const Plane0, Plane1: TVector4; out Line0, LineVector: TVector3); overload;

function Lines2DIntersection(const Line0, Line1: TVector3): TVector2; overload;

function ThreePlanesIntersectionPoint( const Plane0, Plane1, Plane2: TVector4): TVector3; overload;

function PlaneMove(const Plane: TVector4; const Move: TVector3): TVector4; overload;

procedure PlaneMoveVar(var Plane: TVector4; const Move: TVector3); overload;

function PlaneAntiMove(const Plane: TVector4; const Move: TVector3): TVector4; overload;

function VectorsSamePlaneDirections(const V1, V2: TVector3; const Plane: TVector4): boolean; overload;

function VectorsSamePlaneDirections(const V1, V2: TVector3; const PlaneDir: TVector3): boolean; overload;

function PointsSamePlaneSides(const p1, p2: TVector3; const Plane: TVector4): boolean; overload;

function PointsDistance(const V1, V2: TVector2): Single; overload;

function PointsDistance(const V1, V2: TVector3): Single; overload;

function PointsDistanceSqr(const V1, V2: TVector2): Single; overload;

function PointsDistanceSqr(const V1, V2: TVector3): Single; overload;

function PointsDistance2DSqr(const V1, V2: TVector3; const IgnoreIndex: Integer): Single; overload;

function VectorsPerp(const V1, V2: TVector3): boolean; overload;

function VectorsParallel(const V1, V2: TVector3): boolean; overload;

procedure MakeVectorsAngleRadOnTheirPlane(var v1: TVector3; const v2: TVector3; const AngleRad: Single; const ResultWhenParallel: TVector3); overload;

procedure MakeVectorsOrthoOnTheirPlane(var v1: TVector3; const v2: TVector3); overload;

function MakeVectorOrthogonal(const V1, V2: TVector3): TVector3;

function AnyOrthogonalVector(const V: TVector2): TVector2; overload;

function AnyOrthogonalVector(const V: TVector3): TVector3; overload;

function IsLineParallelToPlane(const lineVector: TVector3; const plane: TVector4): boolean; overload;

function IsLineParallelToSimplePlane(const lineVector: TVector3; const PlaneConstCoord: T3DAxis): boolean; overload;

function AreParallelVectorsSameDirection( const Vector1, Vector2: TVector3): boolean; overload;

function PointOnPlaneClosestToPoint(const plane: TVector4; const point: TVector3): TVector3; overload;

function PointToPlaneDistanceSqr(const Point: TVector3; const Plane: TVector4): Single; overload;

function PointToNormalizedPlaneDistance(const Point: TVector3; const Plane: TVector4): Single; overload;

function PointToPlaneDistance(const Point: TVector3; const Plane: TVector4): Single; overload;

function PointToSimplePlaneDistance(const point: TVector3; const PlaneConstCoord: T3DAxis; const PlaneConstValue: Single): Single; overload;

function PointOnLineClosestToPoint(const line0, lineVector, point: TVector2): TVector2; overload;

function PointOnLineClosestToPoint(const line0, lineVector, point: TVector3): TVector3; overload;

function PointToLineDistanceSqr(const point, line0, lineVector: TVector3): Single; overload;

function TryPlaneLineIntersection(out intersection: TVector3; const plane: TVector4; const line0, lineVector: TVector3): boolean; overload;

function TryPlaneLineIntersection(out t: Single; const plane: TVector4; const line0, lineVector: TVector3): boolean; overload;

function TrySimplePlaneRayIntersection(out Intersection: TVector3; const PlaneConstCoord: T3DAxis; const PlaneConstValue: Single; const RayOrigin, RayDirection: TVector3): boolean; overload;

function TrySimplePlaneRayIntersection(out Intersection: TVector3; out T: Single; const PlaneConstCoord: T3DAxis; const PlaneConstValue: Single; const RayOrigin, RayDirection: TVector3): boolean; overload;

function TrySimplePlaneRayIntersection(out T: Single; const PlaneConstCoord: T3DAxis; const PlaneConstValue: Single; const RayOrigin, RayDirection: TVector3): boolean; overload;

function TryPlaneRayIntersection(out Intersection: TVector3; const Plane: TVector4; const RayOrigin, RayDirection: TVector3): boolean; overload;

function TryPlaneRayIntersection(out Intersection: TVector3; out T: Single; const Plane: TVector4; const RayOrigin, RayDirection: TVector3): boolean; overload;

function TrySimplePlaneSegmentIntersection( out Intersection: TVector3; const PlaneConstCoord: T3DAxis; const PlaneConstValue: Single; const Pos1, Pos2: TVector3): boolean; overload;

function TrySimplePlaneSegmentIntersection( out Intersection: TVector3; out T: Single; const PlaneConstCoord: T3DAxis; const PlaneConstValue: Single; const Pos1, Pos2: TVector3): boolean; overload;

function TrySimplePlaneSegmentIntersection( out T: Single; const PlaneConstCoord: T3DAxis; const PlaneConstValue: Single; const Pos1, Pos2: TVector3): boolean; overload;

function TryPlaneSegmentDirIntersection(out Intersection: TVector3; const Plane: TVector4; const Segment0, SegmentVector: TVector3): boolean; overload;

function TryPlaneSegmentDirIntersection(out Intersection: TVector3; out T: Single; const Plane: TVector4; const Segment0, SegmentVector: TVector3): boolean; overload;

function IsPointOnSegmentLineWithinSegment(const intersection, pos1, pos2: TVector2): boolean; overload;

function IsPointOnSegmentLineWithinSegment(const intersection, pos1, pos2: TVector3): boolean; overload;

function Line2DFrom2Points(const P1, P2: TVector2): TVector3;

function LineOfTwoDifferentPoints2D(const P1, P2: TVector2): TVector3; deprecated 'use Line2DFrom2Points';

function Line2DFromOriginVector(const Line0, LineVector: TVector2): TVector3;

function PointToSegmentDistanceSqr(const point, pos1, pos2: TVector3): Single; overload;

function PlaneTransform(const Plane: TVector4; const Matrix: TMatrix4): TVector4;

function IsTunnelSphereCollision(const Tunnel1, Tunnel2: TVector3; const TunnelRadius: Single; const SphereCenter: TVector3; const SphereRadius: Single): boolean; overload;

function IsSpheresCollision(const Sphere1Center: TVector3; const Sphere1Radius: Single; const Sphere2Center: TVector3; const Sphere2Radius: Single): boolean; overload;

function IsSegmentSphereCollision(const pos1, pos2, SphereCenter: TVector3; const SphereRadius: Single): boolean; overload;

function TrySphereRayIntersection(out Intersection: TVector3; const SphereCenter: TVector3; const SphereRadius: Single; const RayOrigin, RayDirection: TVector3): boolean; overload;

function TryCylinderRayIntersection(out Intersection: TVector3; const CylinderAxisOrigin, CylinderAxis: TVector3; const CylinderRadius: Single; const RayOrigin, RayDirection: TVector3): boolean; overload;

function PointOnLineClosestToLine( out Intersection: TVector3; const Line1Origin, Line1Vector, Line2Origin, Line2Vector: TVector3): Boolean;

function TranslationMatrix(const X, Y, Z: Single): TMatrix4; overload;

function TranslationMatrix(const Transl: TVector3): TMatrix4; overload;

procedure TranslationMatrices(const X, Y, Z: Single; out Matrix, InvertedMatrix: TMatrix4); overload;

procedure TranslationMatrices(const Transl: TVector3; out Matrix, InvertedMatrix: TMatrix4); overload;

function TranslationFromMatrix(const M: TMatrix4): TVector3;

procedure MultMatrixTranslation(var M: TMatrix4; const Transl: TVector3); overload;

procedure MultMatricesTranslation(var M, MInvert: TMatrix4; const Transl: TVector3); overload;

function TransformToCoordsMatrix(const NewX, NewY, NewZ: TVector3): TMatrix4; overload;

function TransformToCoordsMatrix(const NewOrigin, NewX, NewY, NewZ: TVector3): TMatrix4; overload;

function TransformToCoordsNoScaleMatrix(const NewOrigin, NewX, NewY, NewZ: TVector3): TMatrix4; overload;

function TransformFromCoordsMatrix(const OldX, OldY, OldZ: TVector3): TMatrix4; overload;

function TransformFromCoordsMatrix(const OldOrigin, OldX, OldY, OldZ: TVector3): TMatrix4; overload;

function TransformFromCoordsNoScaleMatrix(const OldOrigin, OldX, OldY, OldZ: TVector3): TMatrix4; overload;

procedure TransformCoordsMatrices(const NewX, NewY, NewZ: TVector3; out ToCoords, FromCoords: TMatrix4); overload;

function TransformToCoords(const V, NewX, NewY, NewZ: TVector3): TVector3;

function LookAtMatrix(const Eye, Center, Up: TVector3): TMatrix4; overload;

function LookDirMatrix(const Eye, Dir, Up: TVector3): TMatrix4; overload;

function LookDirMatrix(const Eye, Dir, Side, Up: TVector3): TMatrix4; overload;

function FastLookDirMatrix(const Direction, Up: TVector3): TMatrix4;

function InverseFastLookDirMatrix(const Direction, Up: TVector3): TMatrix4;

function ModelViewToNormalMatrix(const M: TMatrix4): TMatrix3;

function VectorMultTransposedSameVector(const V: TVector3): TMatrix4;

function ScalingMatrix(const ScaleFactor: TVector3): TMatrix4;

procedure ScalingMatrices(const ScaleFactor: TVector3; InvertedMatrixIdentityIfNotExists: boolean; out Matrix, InvertedMatrix: TMatrix4);

function RotationMatrix(const AxisAngle: TVector4): TMatrix4; overload;

function RotationMatrixRad(const AngleRad: Single; const Axis: TVector3): TMatrix4; overload;

function RotationMatrixDeg(const AngleDeg: Single; const Axis: TVector3): TMatrix4; overload; deprecated 'use radians for everything throughout CGE';

function RotationMatrixRad(const AngleRad: Single; const AxisX, AxisY, AxisZ: Single): TMatrix4; overload;

function RotationMatrixDeg(const AngleDeg: Single; const AxisX, AxisY, AxisZ: Single): TMatrix4; overload; deprecated 'use radians for everything throughout CGE';

procedure RotationMatricesRad(const AngleRad: Single; const Axis: TVector3; out Matrix, InvertedMatrix: TMatrix4); overload;

procedure RotationMatricesRad(const AxisAngle: TVector4; out Matrix, InvertedMatrix: TMatrix4); overload;

function RotationNegate(const Rotation: TVector4): TVector4;

function RotatePoint2D(const Point: TVector2; const AngleRad: Single): TVector2;

function Approximate3DScale(const X, Y, Z: Single): Single; overload;

function Approximate3DScale(const V: TVector3): Single; overload;

function Approximate3DScale(const M: TMatrix4): Single; overload;

function Approximate2DScale(const X, Y: Single): Single; overload;

function Approximate2DScale(const V: TVector2): Single; overload;

function SmoothTowards(const Source, Target, SecondsPassed, Speed: Single): Single; overload;

function SmoothTowards(const Source, Target: TVector2; const SecondsPassed, Speed: Single): TVector2; overload;

function SmoothTowards(const Source, Target: TVector3; const SecondsPassed, Speed: Single): TVector3; overload;

function ThreePlanesIntersectionPointDouble( const Plane0, Plane1, Plane2: TVector4Double): TVector3Double; overload;

function Vector2Byte(const X, Y: Byte): TVector2Byte; overload; inline;

function Vector3Byte(const X, Y, Z: Byte): TVector3Byte; overload; inline;

function Vector4Byte(const X, Y, Z, W: Byte): TVector4Byte; overload; inline;

function Vector2Byte(const V: TVector2): TVector2Byte; overload;

function Vector3Byte(const V: TVector3): TVector3Byte; overload;

function Vector4Byte(const V: TVector4): TVector4Byte; overload;

function Vector2(const V: TVector2Byte): TVector2; overload;

function Vector3(const V: TVector3Byte): TVector3; overload;

function Vector4(const V: TVector4Byte): TVector4; overload;

function Lerp(const A: Single; const V1, V2: TVector2Byte): TVector2Byte; overload; inline;

function Lerp(const A: Single; const V1, V2: TVector3Byte): TVector3Byte; overload; inline;

function Lerp(const A: Single; const V1, V2: TVector4Byte): TVector4Byte; overload; inline;

function Vector2Integer(const X, Y: Integer): TVector2Integer; inline;

function Vector3Integer(const X, Y, Z: Integer): TVector3Integer; inline;

function Vector4Integer(const X, Y, Z, W: Integer): TVector4Integer; inline;

function Vector2(const V: TVector2Integer): TVector2; overload; inline;

function Vector2Cardinal(const X, Y: Cardinal): TVector2Cardinal; inline;

function Vector3Cardinal(const X, Y, Z: Cardinal): TVector3Cardinal; inline;

function Vector4Cardinal(const X, Y, Z, W: Cardinal): TVector4Cardinal; inline;

function Vector2SmallInt(const X, Y: SmallInt): TVector2SmallInt; inline;

function Vector2Single(const X, Y: Single): TVector2; overload; deprecated 'use Vector2';

function Vector2Single(const V: TVector2Double): TVector2; overload; deprecated 'use Vector2';

function Vector3Single(const X, Y, Z: Single): TVector3; overload; deprecated 'use Vector3';

function Vector3Single(const V: TVector2; const Z: Single): TVector3; overload; deprecated 'use Vector3';

function Vector3Single(const V: TVector3Double): TVector3; overload; deprecated 'use Vector3';

function Vector4Single(const X, Y, Z, W: Single): TVector4; overload; deprecated 'use Vector4';

function Vector4Single(const V: TVector3; const W: Single): TVector4; overload; deprecated 'use Vector4';

function Vector4Single(const V: TVector4Double): TVector4; overload; deprecated 'use Vector4';

function FloatsEqual(const A, B: Single): boolean; overload; deprecated 'use Math.SameValue';

function FloatsEqual(const A, B: Single; const Epsilon: Single): boolean; overload; deprecated 'use Math.SameValue';

function FloatToNiceStr(const A: Single): string; overload; deprecated 'use Format(''%f'', [Value])';

function FloatToRawStr(const A: Single): string; overload; deprecated 'use Format(''%g'', [Value])';

function Zero(const A: Single): boolean; overload; deprecated 'use Math.IsZero';

function VectorAdd(const V1, V2: TVector2): TVector2; overload; deprecated 'use V1 + V2';

function VectorAdd(const V1, V2: TVector3): TVector3; overload; deprecated 'use V1 + V2';

function VectorAdd(const V1, V2: TVector4): TVector4; overload; deprecated 'use V1 + V2';

function VectorSubtract(const V1, V2: TVector2): TVector2; overload; deprecated 'use V1 - V2';

function VectorSubtract(const V1, V2: TVector3): TVector3; overload; deprecated 'use V1 - V2';

function VectorSubtract(const V1, V2: TVector4): TVector4; overload; deprecated 'use V1 - V2';

function VectorMultiplyComponents(const V1, V2: TVector2): TVector2; overload; deprecated 'use V1 * V2';

function VectorMultiplyComponents(const V1, V2: TVector3): TVector3; overload; deprecated 'use V1 * V2';

function VectorMultiplyComponents(const V1, V2: TVector4): TVector4; overload; deprecated 'use V1 * V2';

function VectorProduct(const V1, V2: TVector3): TVector3; overload; deprecated 'use TVector3.CrossProduct';

function Normalized(const V: TVector2): TVector2; overload; deprecated 'use V.Normalize method';

function Normalized(const V: TVector3): TVector3; overload; deprecated 'use V.Normalize method';

procedure NormalizeVar(var V: TVector2); overload; deprecated 'use V := V.Normalize';

procedure NormalizeVar(var V: TVector3); overload; deprecated 'use V := V.Normalize';

function MatrixMult(const M1, M2: TMatrix4): TMatrix4; overload; deprecated 'use * operator to multiply matrices';

function MatrixMultPoint(const M: TMatrix4; const P: TVector2): TVector2; overload; deprecated 'use M.MultPoint method';

function MatrixMultPoint(const M: TMatrix4; const P: TVector3): TVector3; overload; deprecated 'use M.MultPoint method';

function MatrixMultDirection(const M: TMatrix4; const P: TVector2): TVector2; overload; deprecated 'use M.MultDirection method';

function MatrixMultDirection(const M: TMatrix4; const P: TVector3): TVector3; overload; deprecated 'use M.MultDirection method';

function VectorLenSqr(const V: TVector2): Single; overload; deprecated 'use V.LengthSqr';

function VectorLenSqr(const V: TVector3): Single; overload; deprecated 'use V.LengthSqr';

function VectorLenSqr(const V: TVector4): Single; overload; deprecated 'use V.LengthSqr';

function VectorLen(const V: TVector2): Single; overload; deprecated 'use V.Length';

function VectorLen(const V: TVector3): Single; overload; deprecated 'use V.Length';

function VectorLen(const V: TVector4): Single; overload; deprecated 'use V.Length';

function VectorAverage(const V: TVector3): Single; overload; deprecated 'use V.Average';

function VectorToRawStr(const V: TVector2): string; overload; deprecated 'use V.ToRawString';

function VectorToRawStr(const V: TVector3): string; overload; deprecated 'use V.ToRawString';

function VectorToRawStr(const V: TVector4): string; overload; deprecated 'use V.ToRawString';

function VectorToNiceStr(const V: TVector2): string; overload; deprecated 'use V.ToString';

function VectorToNiceStr(const V: TVector3): string; overload; deprecated 'use V.ToString';

function VectorToNiceStr(const V: TVector4): string; overload; deprecated 'use V.ToString';

function VectorToNiceStr(const V: TVector2Integer): string; overload; deprecated 'use V.ToString';

function VectorToNiceStr(const V: TVector3Integer): string; overload; deprecated 'use V.ToString';

function VectorToNiceStr(const V: TVector4Integer): string; overload; deprecated 'use V.ToString';

function VectorToNiceStr(const V: TVector2Cardinal): string; overload; deprecated 'use V.ToString';

function VectorToNiceStr(const V: TVector3Cardinal): string; overload; deprecated 'use V.ToString';

function VectorToNiceStr(const V: TVector4Cardinal): string; overload; deprecated 'use V.ToString';

function VectorToNiceStr(const V: TVector2Byte): string; overload; deprecated 'use V.ToString';

function VectorToNiceStr(const V: TVector3Byte): string; overload; deprecated 'use V.ToString';

function VectorToNiceStr(const V: TVector4Byte): string; overload; deprecated 'use V.ToString';

function ZeroVector(const V: TVector2): boolean; overload; deprecated 'use V.IsZero';

function ZeroVector(const V: TVector3): boolean; overload; deprecated 'use V.IsZero';

function ZeroVector(const V: TVector4): boolean; overload; deprecated 'use V.IsZero';

function ZeroVector(const V: TVector2Byte): boolean; overload; deprecated 'use V.IsZero';

function ZeroVector(const V: TVector3Byte): boolean; overload; deprecated 'use V.IsZero';

function ZeroVector(const V: TVector4Byte): boolean; overload; deprecated 'use V.IsZero';

function ZeroVector(const V: TVector2Integer): boolean; overload; deprecated 'use V.IsZero';

function ZeroVector(const V: TVector3Integer): boolean; overload; deprecated 'use V.IsZero';

function ZeroVector(const V: TVector4Integer): boolean; overload; deprecated 'use V.IsZero';

function ZeroVector(const V: TVector2Cardinal): boolean; overload; deprecated 'use V.IsZero';

function ZeroVector(const V: TVector3Cardinal): boolean; overload; deprecated 'use V.IsZero';

function ZeroVector(const V: TVector4Cardinal): boolean; overload; deprecated 'use V.IsZero';

function PerfectlyZeroVector(const V: TVector2): boolean; overload; deprecated 'use V.IsPerfectlyZero';

function PerfectlyZeroVector(const V: TVector3): boolean; overload; deprecated 'use V.IsPerfectlyZero';

function PerfectlyZeroVector(const V: TVector4): boolean; overload; deprecated 'use V.IsPerfectlyZero';

function VectorAdjustToLength(const V: TVector2; const NewLength: Single): TVector2; overload; deprecated 'use V.AdjustToLength';

function VectorAdjustToLength(const V: TVector3; const NewLength: Single): TVector3; overload; deprecated 'use V.AdjustToLength';

function VectorAdjustToLength(const V: TVector4; const NewLength: Single): TVector4; overload; deprecated 'use V.AdjustToLength';

function Vector2SingleFromStr(const S: string): TVector2; overload; deprecated 'use Vector2FromStr';

function Vector3SingleFromStr(const s: string): TVector3; overload; deprecated 'use Vector3FromStr';

function Vector4SingleFromStr(const S: string): TVector4; overload; deprecated 'use Vector4FromStr';

function VectorDotProduct(const V1, V2: TVector2): Single; overload; deprecated 'use TVector2.DotProduct(V1, V2)';

function VectorDotProduct(const V1, V2: TVector3): Single; overload; deprecated 'use TVector3.DotProduct(V1, V2)';

function VectorDotProduct(const V1, V2: TVector4): Single; overload; deprecated 'use TVector4.DotProduct(V1, V2)';

function VectorsEqual(const V1, V2: TVector2): boolean; overload; deprecated 'use TVector2.Equals(V1, V2)';

function VectorsEqual(const V1, V2: TVector3): boolean; overload; deprecated 'use TVector3.Equals(V1, V2)';

function VectorsEqual(const V1, V2: TVector4): boolean; overload; deprecated 'use TVector4.Equals(V1, V2)';

function VectorsEqual(const V1, V2: TVector2; const Epsilon: Single): boolean; overload; deprecated 'use TVector2.Equals(V1, V2, Epsilon)';

function VectorsEqual(const V1, V2: TVector3; const Epsilon: Single): boolean; overload; deprecated 'use TVector3.Equals(V1, V2, Epsilon)';

function VectorsEqual(const V1, V2: TVector4; const Epsilon: Single): boolean; overload; deprecated 'use TVector4.Equals(V1, V2, Epsilon)';

function VectorsPerfectlyEqual(const V1, V2: TVector2): boolean; overload; deprecated 'use TVector2.PerfectlyEquals(V1, V2)';

function VectorsPerfectlyEqual(const V1, V2: TVector3): boolean; overload; deprecated 'use TVector3.PerfectlyEquals(V1, V2)';

function VectorsPerfectlyEqual(const V1, V2: TVector4): boolean; overload; deprecated 'use TVector4.PerfectlyEquals(V1, V2)';

function VectorsPerfectlyEqual(const V1, V2: TVector2Byte): boolean; overload; deprecated 'use TVector2Byte.Equals(V1, V2)';

function VectorsPerfectlyEqual(const V1, V2: TVector3Byte): boolean; overload; deprecated 'use TVector3Byte.Equals(V1, V2)';

function VectorsPerfectlyEqual(const V1, V2: TVector4Byte): boolean; overload; deprecated 'use TVector4Byte.Equals(V1, V2)';

function VectorsPerfectlyEqual(const V1, V2: TVector2Integer): boolean; overload; deprecated 'use TVector2Integer.Equals(V1, V2)';

function VectorsPerfectlyEqual(const V1, V2: TVector3Integer): boolean; overload; deprecated 'use TVector3Integer.Equals(V1, V2)';

function VectorsPerfectlyEqual(const V1, V2: TVector4Integer): boolean; overload; deprecated 'use TVector4Integer.Equals(V1, V2)';

function VectorsPerfectlyEqual(const V1, V2: TVector2Cardinal): boolean; overload; deprecated 'use TVector2Cardinal.Equals(V1, V2)';

function VectorsPerfectlyEqual(const V1, V2: TVector3Cardinal): boolean; overload; deprecated 'use TVector3Cardinal.Equals(V1, V2)';

function VectorsPerfectlyEqual(const V1, V2: TVector4Cardinal): boolean; overload; deprecated 'use TVector4Cardinal.Equals(V1, V2)';

function TryMatrixInverse(const M: TMatrix2; out MInverse: TMatrix2): boolean; overload; overload; deprecated 'use TMatrix2.TryInverse';

function TryMatrixInverse(const M: TMatrix3; out MInverse: TMatrix3): boolean; overload; overload; deprecated 'use TMatrix3.TryInverse';

function TryMatrixInverse(const M: TMatrix4; out MInverse: TMatrix4): boolean; overload; overload; deprecated 'use TMatrix4.TryInverse';

function MatrixToRawStr(const M: TMatrix2; const LineIndent: string): string; overload; overload; deprecated 'use TMatrix2.ToRawString';

function MatrixToRawStr(const M: TMatrix3; const LineIndent: string): string; overload; overload; deprecated 'use TMatrix3.ToRawString';

function MatrixToRawStr(const M: TMatrix4; const LineIndent: string): string; overload; overload; deprecated 'use TMatrix4.ToRawString';

function MatrixToNiceStr(const M: TMatrix2; const LineIndent: string): string; overload; overload; deprecated 'use TMatrix2.ToString';

function MatrixToNiceStr(const M: TMatrix3; const LineIndent: string): string; overload; overload; deprecated 'use TMatrix3.ToString';

function MatrixToNiceStr(const M: TMatrix4; const LineIndent: string): string; overload; overload; deprecated 'use TMatrix4.ToString';

function MatricesPerfectlyEqual(const V1, V2: TMatrix2): boolean; overload; deprecated 'use TMatrix2.PerfectlyEquals(V1, V2)';

function MatricesPerfectlyEqual(const V1, V2: TMatrix3): boolean; overload; deprecated 'use TMatrix3.PerfectlyEquals(V1, V2)';

function MatricesPerfectlyEqual(const V1, V2: TMatrix4): boolean; overload; deprecated 'use TMatrix4.PerfectlyEquals(V1, V2)';

function MatrixRow(const M: TMatrix2; const Row: Integer): TVector2; overload; overload; deprecated 'use TMatrix2.Rows[Row]';

function MatrixRow(const M: TMatrix3; const Row: Integer): TVector3; overload; overload; deprecated 'use TMatrix3.Rows[Row]';

function MatrixRow(const M: TMatrix4; const Row: Integer): TVector4; overload; overload; deprecated 'use TMatrix4.Rows[Row]';

function Vector2SingleCut(const V: TVector3): TVector2; overload; deprecated 'use V.XY';

function Vector3SingleCut(const V: TVector4): TVector3; overload; deprecated 'use V.XYZ';

function Matrix3Single(const V: TMatrix3Double): TMatrix3; overload; deprecated 'use Matrix3';

function Matrix4Single(const V: TMatrix4Double): TMatrix4; overload; deprecated 'use Matrix4';

Types

TVector2 = CastleVectorsInternalSingle.TGenericVector2;

PVector2 = ˆTVector2;

TVector2Double = CastleVectorsInternalDouble.TGenericVector2;

PVector2Double = ˆTVector2Double;

TVector3 = CastleVectorsInternalSingle.TGenericVector3;

PVector3 = ˆTVector3;

TVector3Double = CastleVectorsInternalDouble.TGenericVector3;

PVector3Double = ˆTVector3Double;

TVector4 = CastleVectorsInternalSingle.TGenericVector4;

PVector4 = ˆTVector4;

TVector4Double = CastleVectorsInternalDouble.TGenericVector4;

PVector4Double = ˆTVector4Double;

TMatrix2 = CastleVectorsInternalSingle.TGenericMatrix2;

PMatrix2 = ˆTMatrix2;

TMatrix2Double = CastleVectorsInternalDouble.TGenericMatrix2;

PMatrix2Double = ˆTMatrix2Double;

TMatrix3 = CastleVectorsInternalSingle.TGenericMatrix3;

PMatrix3 = ˆTMatrix3;

TMatrix3Double = CastleVectorsInternalDouble.TGenericMatrix3;

PMatrix3Double = ˆTMatrix3Double;

TMatrix4 = CastleVectorsInternalSingle.TGenericMatrix4;

PMatrix4 = ˆTMatrix4;

TMatrix4Double = CastleVectorsInternalDouble.TGenericMatrix4;

PMatrix4Double = ˆTMatrix4Double;

TVector2Array = packed array [0..MaxInt div SizeOf(TVector2) - 1] of TVector2;

PVector2Array = ˆTVector2Array;

TVector3Array = packed array [0..MaxInt div SizeOf(TVector3) - 1] of TVector3;

PVector3Array = ˆTVector3Array;

TVector4Array = packed array [0..MaxInt div SizeOf(TVector4) - 1] of TVector4;

PVector4Array = ˆTVector4Array;

TGetVertexFromIndexFunc = function (Index: integer): TVector3 of object;

PVector2Byte = ˆTVector2Byte;

PVector3Byte = ˆTVector3Byte;

PVector4Byte = ˆTVector4Byte;

TVector2ByteArray = packed array [0..MaxInt div SizeOf(TVector2Byte)-1] of TVector2Byte;

PVector2ByteArray = ˆTVector2ByteArray;

TVector3ByteArray = packed array [0..MaxInt div SizeOf(TVector3Byte)-1] of TVector3Byte;

PVector3ByteArray = ˆTVector3ByteArray;

TVector4ByteArray = packed array [0..MaxInt div SizeOf(TVector4Byte)-1] of TVector4Byte;

PVector4ByteArray = ˆTVector4ByteArray;

PVector2Integer = ˆTVector2Integer;

PVector3Integer = ˆTVector3Integer;

PVector4Integer = ˆTVector4Integer;

TVector2IntegerArray = packed array [0..MaxInt div SizeOf(TVector2Integer)-1] of TVector2Integer;

PVector2IntegerArray = ˆTVector2IntegerArray;

TVector3IntegerArray = packed array [0..MaxInt div SizeOf(TVector3Integer)-1] of TVector3Integer;

PVector3IntegerArray = ˆTVector3IntegerArray;

TVector4IntegerArray = packed array [0..MaxInt div SizeOf(TVector4Integer)-1] of TVector4Integer;

PVector4IntegerArray = ˆTVector4IntegerArray;

PVector2Cardinal = ˆTVector2Cardinal;

PVector3Cardinal = ˆTVector3Cardinal;

PVector4Cardinal = ˆTVector4Cardinal;

TVector2CardinalArray = packed array [0..MaxInt div SizeOf(TVector2Cardinal)-1] of TVector2Cardinal;

PVector2CardinalArray = ˆTVector2CardinalArray;

TVector3CardinalArray = packed array [0..MaxInt div SizeOf(TVector3Cardinal)-1] of TVector3Cardinal;

PVector3CardinalArray = ˆTVector3CardinalArray;

TVector4CardinalArray = packed array [0..MaxInt div SizeOf(TVector4Cardinal)-1] of TVector4Cardinal;

PVector4CardinalArray = ˆTVector4CardinalArray;

PVector2SmallInt = ˆTVector2SmallInt;

TVector2SmallIntList = specialize TStructList<TVector2SmallInt>;

TVector3CardinalList = specialize TStructList<TVector3Cardinal>;

TVector2Single = TVector2 deprecated;

TVector3Single = TVector3 deprecated;

TVector4Single = TVector4 deprecated;

TMatrix2Single = TMatrix2 deprecated;

TMatrix3Single = TMatrix3 deprecated;

TMatrix4Single = TMatrix4 deprecated;

TVector2SingleList = TVector2List deprecated;

TVector3SingleList = TVector3List deprecated;

TVector4SingleList = TVector4List deprecated;

TMatrix3SingleList = TMatrix3List deprecated;

TMatrix4SingleList = TMatrix4List deprecated;

TVector3LongInt = TVector3Integer deprecated;

PVector2Single = PVector2 deprecated;

PVector3Single = PVector3 deprecated;

PVector4Single = PVector4 deprecated;

PMatrix2Single = PMatrix2 deprecated;

PMatrix3Single = PMatrix3 deprecated;

PMatrix4Single = PMatrix4 deprecated;

PVector3LongInt = PVector3Integer deprecated;

TGetVector2Event = function: TVector2 of object;

TSetVector2Event = procedure (const Value: TVector2) of object;

TGetVector3Event = function: TVector3 of object;

TSetVector3Event = procedure (const Value: TVector3) of object;

TGetVector4Event = function: TVector4 of object;

TSetVector4Event = procedure (const Value: TVector4) of object;

PTransformation = ˆTTransformation;

Constants

ZeroVector2Single: TVector2 = (X: 0; Y: 0) deprecated 'use TVector2.Zero';

ZeroVector3Single: TVector3 = (X: 0; Y: 0; Z: 0) deprecated 'use TVector3.Zero';

ZeroVector4Single: TVector4 = (X: 0; Y: 0; Z: 0; W: 0) deprecated 'use TVector4.Zero';

ZeroVector2Double: TVector2Double = (X: 0; Y: 0) deprecated 'use TVector2Double.Zero';

ZeroVector3Double: TVector3Double = (X: 0; Y: 0; Z: 0) deprecated 'use TVector3Double.Zero';

ZeroVector4Double: TVector4Double = (X: 0; Y: 0; Z: 0; W: 0) deprecated 'use TVector4Double.Zero';

ZeroVector2Byte: TVector2Byte = (X: 0; Y: 0) deprecated 'use TVector2Byte.Zero';

ZeroVector3Byte: TVector3Byte = (X: 0; Y: 0; Z: 0) deprecated 'use TVector3Byte.Zero';

ZeroVector4Byte: TVector4Byte = (X: 0; Y: 0; Z: 0; W: 0) deprecated 'use TVector4Byte.Zero';

ZeroVector2Integer: TVector2Integer = (X: 0; Y: 0) deprecated 'use TVector2Integer.Zero';

ZeroVector3Integer: TVector3Integer = (X: 0; Y: 0; Z: 0) deprecated 'use TVector3Integer.Zero';

ZeroVector4Integer: TVector4Integer = (X: 0; Y: 0; Z: 0; W: 0) deprecated 'use TVector4Integer.Zero';

ZeroVector2Cardinal: TVector2Cardinal = (X: 0; Y: 0) deprecated 'use TVector2Cardinal.Zero';

ZeroVector3Cardinal: TVector3Cardinal = (X: 0; Y: 0; Z: 0) deprecated 'use TVector3Cardinal.Zero';

ZeroVector4Cardinal: TVector4Cardinal = (X: 0; Y: 0; Z: 0; W: 0) deprecated 'use TVector4Cardinal.Zero';

ZeroMatrix2Single: TMatrix2 = (Data: ((0, 0), (0, 0))) deprecated 'use TMatrix2.Zero';

ZeroMatrix3Single: TMatrix3 = (Data: ((0, 0, 0), (0, 0, 0), (0, 0, 0))) deprecated 'use TMatrix3.Zero';

ZeroMatrix4Single: TMatrix4 = (Data: ((0, 0, 0, 0), (0, 0, 0, 0), (0, 0, 0, 0), (0, 0, 0, 0))) deprecated 'use TMatrix4.Zero';

ZeroMatrix2Double: TMatrix2Double = (Data: ((0, 0), (0, 0))) deprecated 'use TMatrix2Double.Zero';

ZeroMatrix3Double: TMatrix3Double = (Data: ((0, 0, 0), (0, 0, 0), (0, 0, 0))) deprecated 'use TMatrix3Double.Zero';

ZeroMatrix4Double: TMatrix4Double = (Data: ((0, 0, 0, 0), (0, 0, 0, 0), (0, 0, 0, 0), (0, 0, 0, 0))) deprecated 'use TMatrix4Double.Zero';

IdentityMatrix2Single: TMatrix2 = (Data: ((1, 0), (0, 1))) deprecated 'use TMatrix2.Identity';

IdentityMatrix3Single: TMatrix3 = (Data: ((1, 0, 0), (0, 1, 0), (0, 0, 1))) deprecated 'use TMatrix3.Identity';

IdentityMatrix4Single: TMatrix4 = (Data: ((1, 0, 0, 0), (0, 1, 0, 0), (0, 0, 1, 0), (0, 0, 0, 1))) deprecated 'use TMatrix4.Identity';

IdentityMatrix2Double: TMatrix2Double = (Data: ((1, 0), (0, 1))) deprecated 'use TMatrix2Double.Identity';

IdentityMatrix3Double: TMatrix3Double = (Data: ((1, 0, 0), (0, 1, 0), (0, 0, 1))) deprecated 'use TMatrix3Double.Identity';

IdentityMatrix4Double: TMatrix4Double = (Data: ((1, 0, 0, 0), (0, 1, 0, 0), (0, 0, 1, 0), (0, 0, 0, 1))) deprecated 'use TMatrix4Double.Identity';

UnitVector2Single: array [TVector2.TIndex] of TVector2 = (
    (X: 1; Y: 0),
    (X: 0; Y: 1)
  ) deprecated 'use TVector2.One';

UnitVector3Single: array [TVector3.TIndex] of TVector3 = (
    (X: 1; Y: 0; Z: 0),
    (X: 0; Y: 1; Z: 0),
    (X: 0; Y: 0; Z: 1)
  ) deprecated 'use TVector3.One';

UnitVector4Single: array [TVector4.TIndex] of TVector4 = (
    (X: 1; Y: 0; Z: 0; W: 0),
    (X: 0; Y: 1; Z: 0; W: 0),
    (X: 0; Y: 0; Z: 1; W: 0),
    (X: 0; Y: 0; Z: 0; W: 1)
  ) deprecated 'use TVector4.One';

SingleEpsilon = 1E-4;

DoubleEpsilon = 1E-12;

SingleEqualityEpsilon = SingleEpsilon deprecated 'use SingleEpsilon';

DoubleEqualityEpsilon = DoubleEpsilon deprecated 'use DoubleEpsilon';

ExtendedEqualityEpsilon = 1E-16 deprecated 'use only Math functions, like SameValue and IsZero, to operate on Extended type; CastleVectors unit does not deal with Extended type anymore';

Description

Functions and Procedures

function Vector2(const X, Y: Single): TVector2; overload; inline;

Construct an initialized TVector2 value.

function Vector2(const V: TVector2Double): TVector2; overload; inline;

function Vector2Double(const X, Y: Double): TVector2Double; inline;

Construct an initialized TVector2Double value.

function Vector3(const X, Y, Z: Single): TVector3; overload; inline;

Construct an initialized TVector3 value.

function Vector3(const V: TVector2; const Z: Single): TVector3; overload; inline;

function Vector3(const V: TVector3Double): TVector3; overload; inline;

function Vector3Double(const X, Y, Z: Double): TVector3Double; overload; inline;

Construct an initialized TVector3Double value.

function Vector3Double(const V: TVector3): TVector3Double; overload; inline;

function Vector4(const X, Y, Z, W: Single): TVector4; overload; inline;

Construct an initialized TVector4 value.

function Vector4(const V: TVector3; const W: Single): TVector4; overload; inline;

function Vector4(const V: TVector2; const Z, W: Single): TVector4; overload; inline;

function Vector4(const V: TVector4Double): TVector4; overload; inline;

function Vector4Double(const X, Y, Z, W: Double): TVector4Double; overload; inline;

Construct an initialized TVector4Double value.

function Vector4Double(const V: TVector4): TVector4Double; overload; inline;

function Matrix3(const V: TMatrix3Double): TMatrix3;

Convert between Double-precision and Single-precision matrix.

function Matrix4(const V: TMatrix4Double): TMatrix4;

function Matrix3Double(const V: TMatrix3): TMatrix3Double;

function Matrix4Double(const V: TMatrix4): TMatrix4Double;

function Vector2FromStr(const S: string): TVector2;

Convert string to vector. Each component is simply parsed by StrToFloatDot, and components must be separated by whitespace (see WhiteSpaces constant). This is a reverse of TVector2.ToString, TVector3.ToString, TVector4.ToString methods.

Exceptions raised

EConvertError: In case of problems during conversion (invalid float or unexpected string end or expected but missed string end).

function Vector3FromStr(const S: string): TVector3;

function Vector4FromStr(const S: string): TVector4;

function Lerp(const A: Single; const V1, V2: TVector2): TVector2; overload; inline;

Linear interpolation between two vector values. Returns (1-A) * V1 + A * V2.

So:

A = 0 gives V1,
A = 1 gives V2,
values between are interpolated,
values outside are extrapolated.