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
Record `TViewVectors`	Express a 3D transformation as position, direction and up 3D vectors.
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 `TCastleVector4RotationPersistent`	TCastleVector4Persistent descendant for castle editor to display angle component nicer (as 'Angle (W)' and 'Deg(90)' instead of as 'W' and in radians).
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 Vector4Double(const V: TVector3Double; const W: Double): 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 MinAbsVectorCoord(const V: TVector2): Integer; overload;

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

function MinAbsVectorCoord(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;

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';

procedure MatrixDecompose(const Matrix: TMatrix4; out Translation: TVector3; out Rotation: TVector4; out Scale: TVector3);

function ScaleFromMatrix(const Matrix: TMatrix4): TVector3;

function TranslationFromMatrix(const M: TMatrix4): TVector3;

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;

PVector2Single = PVector2 deprecated;

PVector3Single = PVector3 deprecated;

PVector4Single = PVector4 deprecated;

PMatrix2Single = PMatrix2 deprecated;

PMatrix3Single = PMatrix3 deprecated;

PMatrix4Single = PMatrix4 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

NoScale: TVector3 = (X: 1; Y: 1; Z: 1);

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;

This item has no description.

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;

This item has no description.

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

This item has no description.

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

Construct an initialized TVector3Double value.

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

This item has no description.

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;

This item has no description.

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

This item has no description.

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

This item has no description.

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

Construct an initialized TVector4Double value.

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

This item has no description.

function Vector4Double(const V: TVector3Double; const W: Double): TVector4Double; overload; inline;

This item has no description.

function Matrix3(const V: TMatrix3Double): TMatrix3;

Convert between Double-precision and Single-precision matrix.

function Matrix4(const V: TMatrix4Double): TMatrix4;

This item has no description.

function Matrix3Double(const V: TMatrix3): TMatrix3Double;

This item has no description.

function Matrix4Double(const V: TMatrix4): TMatrix4Double;

This item has no description.

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;

This item has no description.

function Vector4FromStr(const S: string): TVector4;

This item has no description.

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.

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

This item has no description.

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

This item has no description.

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

This item has no description.

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

This item has no description.

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

This item has no description.

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

This item has no description.

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

This item has no description.

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

This item has no description.

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

This item has no description.

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

This item has no description.

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

This item has no description.

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

Try to inverse single-precision matrix using double-precision, if necessary.

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

Cosinus of angle between two vectors.

CosAngleBetweenNormals is a little faster, but must receive normalized (length 1) vectors. This avoids expensive Sqrt inside CosAngleBetweenVectors.

Exceptions raised

EVectorInvalidOp: If V1 or V2 is zero.

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

This item has no description.

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

Angle between two vectors, in radians. Returns always positive angle, between 0 and Pi.

AngleRadBetweenNormals is a little faster, but must receive normalized (length 1) vectors. This avoids expensive Sqrt. See also CosAngleBetweenVectors and CosAngleBetweenNormals to avoid expensive ArcCos.

Exceptions raised

EVectorInvalidOp: If V1 or V2 is zero.

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

This item has no description.

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

Signed angle between two vectors, in radians. As opposed to AngleRadBetweenNormals, this returns a signed angle, between -Pi and Pi.

The resulting angle is guaranteed to be such that rotating (using RotatePointAroundAxisRad) V1 around TVector3.CrossProduct(V1, V2) (cross product V1 x V2) will produce V2. Note: The order or arguments is important (just like it's important for the vector cross product).

Exceptions raised

EVectorInvalidOp: If V1 or V2 is zero.

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

Signed angle between two vectors, in radians. As opposed to AngleRadBetweenNormals, this returns a signed angle, between -Pi and Pi.

The resulting angle is guaranteed to be such that rotating (using RotatePointAroundAxisRad) V1 around vector Cross will produce V2. Note: The order or arguments is important (just like it's important for the vector cross product).

The Cross parameter can only have 2 values: V1 x V2 or V2 x V1. In other words, Cross must be orthogonal to both vectors. So this routine is not much more flexible than the other RotationAngleRadBetweenVectors overload with 2 arguments. Only 2 possible values of Cross are allowed. This overload is mainly useful because it is more efficient, as RotationAngleRadBetweenVectors overload with 2 arguments must just calculate vector cross, but you may have it already available.

Exceptions raised

EVectorInvalidOp: If V1 or V2 is zero.

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

Rotate Point around the Axis by given Angle. Axis does not have to be normalized (it will be normalized internally).

Axis can be an exact zero only if Angle is also an exact zero. This special case is supported to make it easier to initialize stuff. This way by default a vector and an angle can be left filled with zeros (like TCastleTransform.Rotation), and this function will accept them (in effect e.g. TCastleTransform.Direction will be valid). In all other cases, axis must be a non-zero vector.

Note that this is equivalent to constructing a rotation matrix and then using it, like

M := RotationMatrixRad(Angle, Axis);
Result := M.MultPoint(Point);

Except this will be a little faster.

Rotations are done in the same direction as RotationMatrixRad, and as OpenGL.

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

Warning: this symbol is deprecated: use radians for everything throughout CGE

This item has no description.

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

Rotate Point around the Axis by 90 degrees. This is specialized and optimized version of RotatePointAroundAxisRad.

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

Rotate Point around the Axis by -90 degrees. This is specialized and optimized version of RotatePointAroundAxisRad.

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

Rotate Point around the given axis by a given angle. Axis is specified in the first 3 components of AxisAngle, rotation angle (in radians) is specified in the last component of AxisAngle.

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

Which coordinate (0, 1, 2, and eventually 3 for 4D versions) is the largest. When the vector components are equal, the first one "wins", for example if V[0] = V[1] (and are larger than other vector component) we return 0. MaxAbsVectorCoord compares the absolute value of components.

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

This item has no description.

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

This item has no description.

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

This item has no description.

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

This item has no description.

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

This item has no description.

function MinAbsVectorCoord(const V: TVector2): Integer; overload;

This item has no description.

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

This item has no description.

function MinAbsVectorCoord(const V: TVector4): Integer; overload;

This item has no description.

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

This item has no description.

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

This item has no description.

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

Vector orthogonal to plane and pointing in the given direction.

Given a plane equation (or just the first 3 components of this equation), we have vector orthogonal to the plane (just the first 3 components of plane equation). This returns either this vector, or it's negation. It chooses the one that points in the same 3D half-space as given Direction.

When given Direction is paralell to Plane, returns original plane direction, not it's negation.

This really simply returns the first 3 components of plane equation. possibly negated. So e.g. if the plane direction was normalized, result is normalized too.

PlaneDirNotInDirection chooses the direction opposite to given Direction parameter. So it's like PlaneDirInDirection(Plane, -Direction).

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

This item has no description.

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

This item has no description.

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

This item has no description.

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

Endianess swapping for vectors.

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

This item has no description.

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

This item has no description.

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

Endianess conversion for vectors (little endian to native).

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

This item has no description.

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

This item has no description.

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

Endianess conversion for vectors (big endian to native).

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

This item has no description.

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

This item has no description.

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

Endianess conversion for vectors (native to little endian).

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

This item has no description.

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

This item has no description.

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

Endianess conversion for vectors (native to big endian).

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

This item has no description.

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

This item has no description.

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

Replace contents of 2 variables.

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

This item has no description.

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

This item has no description.

procedure NormalizePlaneVar(var V: TVector4); overload;

This normalizes Plane by scaling all four coordinates of Plane so that length of plane vector (taken from 1st three coordinates) is one.

Also, contrary to normal NormalizeVar on 3-component vectors, this will fail with some awful error (like floating point overflow) in case length of plane vector is zero. That's because we know that plane vector must be always non-zero.

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

Intersection of two 3D planes.

Exceptions raised

EPlanesParallel: If planes are parallel.

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

Intersection of two 2D lines. 2D lines are expressed here as a vector of three values (A,B,C), such that Ax+By+C=0 is true for points on the line.

Exceptions raised

ELinesParallel: if lines parallel

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

Intersection of three 3D planes, results in a single 3D point. If the intersection is not a single 3D point, result is undefined, so don't try to use this.

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

Move a plane by a specifed vector. The first three plane numbers (plane normal vector) don't change (so, in particular, if you used the plane to define the half-space, the half-space gets moved as it should).

PlaneAntiMove work like PlaneMove, but they translate by negated Move So it's like PlaneAntiMove(Plane, V) := PlaneMove(Plane, -V), but (very slightly) faster.

This works Ok with invalid planes (1st three components = 0), that is after the move the plane remains invalid (1st three components remain = 0).

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

This item has no description.

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

This item has no description.

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

Check if both directions indicate the same side of given 3D plane. If one direction is parallel to the plane, also returns True. You can specify only the first 3 components of plane equation (PlaneDir), since the 4th component would be ignored anyway.

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

This item has no description.

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

Check if both points are on the same side of given 3D plane. If one of the points is exactly on the plane, also returns True.

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

This item has no description.

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

This item has no description.

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

This item has no description.

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

This item has no description.

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

Distance between points projected on the 2D plane. Projection is done by rejecting IgnoreIndex coordinate (must be 0, 1 or 2).

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

This item has no description.

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

Are the two vectors parallel (one is a scaled version of another). In particular, if one of the vectors is zero, then this is True.

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

Adjust the V1 vector to force given angle between V1 and V2. Vector V1 will be adjusted, such that it has the same length and the 3D plane defined by V1, V2 and (0, 0, 0) is the same.

When vectors are parallel (this includes the case when one of them is zero), we set V1 to ResultWhenParallel.

We make it such that V1 rotated around axis TVector3.CrossProduct(V1, V2) by given angle will result in V2. Note that this means that MakeVectorsAngleRadOnTheirPlane(V1, V2, Angle, ...) results in the same (not reversed) relation between vectors as MakeVectorsAngleRadOnTheirPlane(V2, V1, Angle, ...). That's because you change the arguments order, but also TVector3.CrossProduct sign changes.

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

Adjust the V1 vector to force V1 and V2 to be orthogonal, but keep the 3D plane determined by V1 and V2 unchanged. When vectors are parallel, we set V1 to be AnyOrthogonalVector(V2).

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

Adjust and return the V1 vector to force V1 and V2 to be orthogonal, but keep the 3D plane determined by V1 and V2 unchanged. When vectors are parallel, we return AnyOrthogonalVector(V2).

This is a functional version of MakeVectorsOrthoOnTheirPlane.

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

Return, deterministically, some vector orthogonal to V. When V is non-zero, then the result is non-zero.

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

This item has no description.

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

This item has no description.

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

This item has no description.

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

Assuming that Vector1 and Vector2 are parallel, check do they point in the same direction.

This assumes that both vectors are non-zero. If one of the vectors is zero, the result is undefined — false or true. (but the function will surely not raise some floating point error etc.)

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

Orthogonally project a point on a plane, that is find a closest point to Point lying on a Plane.

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

This item has no description.

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

Distance from a point to a plane (with already normalized direction).

Note: distance of the plane from origin point (0,0,0) may be simply obtained by Abs(Plane[3]) when Plane is Normalized.

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

Distance from a point to a plane.

Note that calculating this costs you one Sqrt (contrary to PointToPlaneDistanceSqr or PointToNormalizedPlaneDistance).

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

This item has no description.

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

This item has no description.

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

This item has no description.

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

This item has no description.

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

Plane and line intersection.

Returns False and doesn't modify Intersection or T when the line is parallel to the plane (this includes the case when the line lies on a plane, so theoretically the whole line is an intersection).

Otherwise, returns True, and calculates 3D intersection point, or calculates T such that 3D intersection = Line0 + LineVector * T. T is always within [0,1] range.

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

This item has no description.

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

Plane and ray intersection.

Returns False and doesn't modify Intersection or T when the ray is parallel to the plane (this includes the case when the ray lies on a plane. Also returns False when the ray would have to point in the opposite direction to hit the plane.

Otherwise, returns True, and calculates 3D intersection point, or calculates T such that 3D intersection = RayOrigin + RayDirection * T. T is always >= 0.

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

This item has no description.

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

This item has no description.

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

This item has no description.

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

This item has no description.

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

Plane and line segment intersection.

Returns False and doesn't modify Intersection or T when the segment is parallel to the plane (this includes the case when the segment lies on a plane. Also returns False when the segment would have to be longer to hit the plane.

Otherwise, returns True, and calculates 3D intersection point, or calculates T such that 3D intersection = Segment0 + SegmentVector * T. T is always in range [0,1].

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

This item has no description.

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

This item has no description.

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

This item has no description.

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

This item has no description.

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

This item has no description.

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

This item has no description.

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

Coefficients of the 2D line equation (Ax + By + C = 0), given 2 different points lying on the line. When the points are equal, this is undefined.

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

Warning: this symbol is deprecated: use Line2DFrom2Points

This item has no description.

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

Coefficients of the 2D line equation (Ax + By + C = 0), given 1 point lying on the line, and non-zero line direction. When LineVector is zero, this is undefined.

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

This item has no description.

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

Transform plane by a matrix.

Exceptions raised

ETransformedResultInvalid: Raised when matrix will transform some point to a direction, or direction to point, in homogeneous coordinates.

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

This item has no description.

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

This item has no description.

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

This item has no description.

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

This item has no description.

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

Intersection between an (infinitely tall) cylinder and a ray.

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

Given two 3D lines (both given as an some point + direction in 3D), calculate closest point on 1st line to the 2nd line. Returns False if lines are parallel, thus is not possible to determine any single closest point.

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

Functions to create common 4x4 matrices used in 3D graphics.

These functions generate the same matrices as old OpenGL fixed-function was using. They work in right-handed coordinate system, just like X3D, glTF and OpenGL.

Functions named Matrices below generate both normal and inverted matrices. For example, function RotationMatrices returns two matrices that you could calculate separately by

        Matrix: = RotationMatrix( Angle, Axis);
InvertedMatrix: = RotationMatrix(-Angle, Axis);

This is useful sometimes, and generating them both at the same time allows for some speedup (for example, calling RotationMatrix twice will calculate sincos of Angle twice).

Note that inverse of scaling matrix will not exist if the ScaleFactor has one of the components zero ! Depending on InvertedMatrixIdentityIfNotExists, this will (if False) raise division by zero exception or (if True) cause the matrix to be set to identity.

Note that rotation matrix (both normal and inverse) is always defined, for Axis = zero both normal and inverse matrices are set to identity.

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

This item has no description.

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

This item has no description.

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

This item has no description.

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

Multiply matrix M by translation matrix.

This is equivalent to M := M * TranslationMatrix(Transl), but it works much faster since TranslationMatrix is a very simple matrix and multiplication by it may be much optimized.

An additional speedup comes from the fact that the result is placed back in M (so on places where M doesn't change (and there's a lot of them for multiplication with translation matrix) there's no useless copying).

MultMatricesTranslation is analogous to calculating both TranslationMatrix(Transl) and it's inverse, and then

M := M * translation;
MInvert := inverted-translation * MInvert;

The idea is that if M represented some translation, and MInvert it's inverse, then after MultMatricesTranslation this will still hold.

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

This item has no description.

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

Transform coordinates to / from a coordinate system. Stuff multiplied by this matrix is supplied in other coordinate system.

The "new" coordinate system (you specify it explicitly for TransformToCoordsMatrix) is the coordinate system in which your 3D stuff is defined. That is, when you supply the points (that will later be multiplied by TransformToCoordsMatrix) you think in the "new" coordinate system. The "old" coordinate system (you specify it explicitly for TransformFromCoordsMatrix) is the coordinate system of stuff after it's multiplied by this matrix.

This may get confusing, so to be more precise:

TransformToCoordsMatrix says how the new coords system looks from the point of view of the old coords system. A stuff lying at (0, 0, 0) in new coord system will be seen at NewOrigin after the transformation (in the old coordinate system). Similarly, direction (0, 1, 0) will be seen as NewY after the transformation.
TransformFromCoordsMatrix is the inverse: how the old system is seen from the new one. If before the transformation you are at OldOrigin, then after the transformation you are at (0, 0, 0). This is natural way to implement LookAtMatrix, LookDirMatrix.

The lengths of directions (New or Old X, Y, Z vectors) are meaningful. These vectors correspond to unit vectors (1, 0, 0), (0, 1, 0) and (0, 0, 1) in the other coordinate system. Supplying here non-normalized vectors will result in scaling.

You can use the "NoScale" versions to have the vectors automatically normalized, thus you waste a little time (on normalizing) but you avoid the scaling.

Overloaded versions without OldOrigin / NewOrigin parameters work like the old/new origin is zero. IOW, the origin of the coordinate system doesn't change in this case.

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

This item has no description.

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

This item has no description.

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

This item has no description.

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

This item has no description.

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

This item has no description.

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

Calculate matrix to convert to given coordinate system (like TransformToCoordsMatrix) and it's inverse (like TransformFromCoordsMatrix).

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

Transform vector into new coordinate space.

Equivalent to TransformToCoordsMatrix(TVector3.Zero, NewX, NewY, NewZ).MultPoint(V). So the origin of new coordinate system is at the same place. You should pass NewX, NewY, NewZ vectors normalized if you want to preserve vector length.

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

Camera matrix to look at the specified point (or along the specified direction). Work according to right-handed coordinate system.

When applied to the scene, they transform it, such that a camera standing at (0, 0, 0) (with dir (0, 0, -1) and up vector (0, 1, 0)), was seeing the same view as if it was standing at Eye (with given Dir and Up vectors).

For LookAtMatrix, looking direction is implicitly given as Center - Eye. Just like gluLookAt.

For the overloaded LookDirMatrix version with Side parameter, we assume that Dir, Side and Up are already normalized and orthogonal to each other.
For the overloaded version without the Side parameter, Dir and Up do not have to normalized. We'll normalize them if needed, so their lengths do not affect the result (just as the distance between Center and Eye points for LookAtMatrix).
Also, Dir and Up do not have to be perfectly orthogonal (we will eventually adjust Up internally to make it orthogonal to Up).
You still must make sure that Dir and Up are not parallel.

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

This item has no description.

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

This item has no description.

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

Calculate LookDirMatrix (or it's inverse), fast.

Has some assumptions that make it run fast:

It assumes camera position is zero.
It assumes that Dir and Up are already normalized and orthogonal.

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

This item has no description.

function ModelViewToNormalMatrix(const M: TMatrix4): TMatrix3;

Convert ModelView matrix to a Normal matrix, just like 3D graphic libraries do. See e.g. http://www.lighthouse3d.com/tutorials/glsl-tutorial/the-normal-matrix/ for explanation why this is necessary, and how it's done.

function VectorMultTransposedSameVector(const V: TVector3): TMatrix4;

Multiply vector by a transposition of the same vector. For 3d vectors, this results in a 3x3 matrix. To put this inside a 4x4 matrix, we fill the last row and column just like for an identity matrix.

This is useful for calculating rotation matrix.

function ScalingMatrix(const ScaleFactor: TVector3): TMatrix4;

This item has no description.

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

This item has no description.

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

This item has no description.

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

This item has no description.

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

Warning: this symbol is deprecated: use radians for everything throughout CGE

This item has no description.

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

This item has no description.

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

Warning: this symbol is deprecated: use radians for everything throughout CGE

This item has no description.

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

This item has no description.

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

This item has no description.

function RotationNegate(const Rotation: TVector4): TVector4;

Negate a rotation expressed as axis-angle (3 components for axis, 1 for angle). This simply negates the 4th vector component.

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

Rotate point in 2D, in a counter-clockwise fashion. AngleRad is in radians.

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

When you really, really must approximate a 3D or 2D scale by a single float. E.g. if your algorithm cannot handle non-uniform 3D or 2D scale, you have to approximate 3D or 2D scale by a single float.

This is similar to an average of X, Y (and Z, in 3D), but it additionally secures in case some of X, Y, Z are negative and some are positive (like scale (-1, 1), common in 2D to flip horizontally).

The overloaded version with matrix argument extracts scale from matrix, just like MatrixDecompose.

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

This item has no description.

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

This item has no description.

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

This item has no description.

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

This item has no description.

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

Smoothly change Source to Target.

The speed decreases as Source is closer to Target, so the animation ends smoothly.

Note: Initially the argument Speed was represented by 2 values: MaxChangeSpeed, MaxDistance: Single The intended meaning of MaxChangeSpeed was the speed with which Source changes to Target, so that MaxChangeSpeed = 1.0 means that it changes in 1 second, MaxChangeSpeed = 0.5 means that it changes in 2 seconds, MaxChangeSpeed = 2 means that it changes in 0.5 seconds.

Later: now it's just Speed. You can just passs Speed = MaxChangeSpeed / MaxDistance to get the same logic as above.

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

This item has no description.

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

This item has no description.

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

Intersection of three 3D planes, results in a single 3D point. If the intersection is not a single 3D point, result is undefined, so don't try to use this.

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

This item has no description.

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

This item has no description.

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

This item has no description.

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

Convert float vectors into byte vectors. Each float component is converted such that float 0.0 (or less) results in byte 0, float 1.0 (or more) results in byte 255. Values between 0.0 and 1.0 are appropriately (linearly) converted into the byte range.

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

This item has no description.

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

This item has no description.

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

This item has no description.

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

This item has no description.

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

This item has no description.

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

This item has no description.

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

This item has no description.

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

This item has no description.

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

This item has no description.

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

This item has no description.

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

This item has no description.

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

This item has no description.

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

This item has no description.

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

This item has no description.

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

This item has no description.

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

This item has no description.

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

Warning: this symbol is deprecated: use Vector2

Construct an initialized TVector2 value.

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

Warning: this symbol is deprecated: use Vector2

This item has no description.

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

Warning: this symbol is deprecated: use Vector3

Construct an initialized TVector3 value.

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

Warning: this symbol is deprecated: use Vector3

This item has no description.

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

Warning: this symbol is deprecated: use Vector3

This item has no description.

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

Warning: this symbol is deprecated: use Vector4

Construct an initialized TVector4 value.

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

Warning: this symbol is deprecated: use Vector4

This item has no description.

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

Warning: this symbol is deprecated: use Vector4

This item has no description.

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

Warning: this symbol is deprecated: use Math.SameValue

Various compatibility functions (on Single)

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

Warning: this symbol is deprecated: use Math.SameValue

This item has no description.

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

Warning: this symbol is deprecated: use Format('%f', [Value])

This item has no description.

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

Warning: this symbol is deprecated: use Format('%g', [Value])

This item has no description.

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

Warning: this symbol is deprecated: use Math.IsZero

This item has no description.

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

Warning: this symbol is deprecated: use V1 + V2

Various compatibility functions (on vectors and matrices)

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

Warning: this symbol is deprecated: use V1 + V2

This item has no description.

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

Warning: this symbol is deprecated: use V1 + V2

This item has no description.

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

Warning: this symbol is deprecated: use V1 - V2

This item has no description.

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

Warning: this symbol is deprecated: use V1 - V2

This item has no description.

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

Warning: this symbol is deprecated: use V1 - V2

This item has no description.

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

Warning: this symbol is deprecated: use V1 * V2

This item has no description.

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

Warning: this symbol is deprecated: use V1 * V2

This item has no description.

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

Warning: this symbol is deprecated: use V1 * V2

This item has no description.

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

Warning: this symbol is deprecated: use TVector3.CrossProduct

This item has no description.

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

Warning: this symbol is deprecated: use V.Normalize method

This item has no description.

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

Warning: this symbol is deprecated: use V.Normalize method

This item has no description.

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

Warning: this symbol is deprecated: use V := V.Normalize

This item has no description.

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

Warning: this symbol is deprecated: use V := V.Normalize

This item has no description.

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

Warning: this symbol is deprecated: use * operator to multiply matrices

This item has no description.

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

Warning: this symbol is deprecated: use M.MultPoint method

This item has no description.

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

Warning: this symbol is deprecated: use M.MultPoint method

This item has no description.

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

Warning: this symbol is deprecated: use M.MultDirection method

This item has no description.

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

Warning: this symbol is deprecated: use M.MultDirection method

This item has no description.

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

Warning: this symbol is deprecated: use V.LengthSqr

This item has no description.

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

Warning: this symbol is deprecated: use V.LengthSqr

This item has no description.

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

Warning: this symbol is deprecated: use V.LengthSqr

This item has no description.

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

Warning: this symbol is deprecated: use V.Length

This item has no description.

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

Warning: this symbol is deprecated: use V.Length

This item has no description.

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

Warning: this symbol is deprecated: use V.Length

This item has no description.

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

Warning: this symbol is deprecated: use V.Average

This item has no description.

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

Warning: this symbol is deprecated: use V.ToRawString

This item has no description.

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

Warning: this symbol is deprecated: use V.ToRawString

This item has no description.

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

Warning: this symbol is deprecated: use V.ToRawString

This item has no description.

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

Warning: this symbol is deprecated: use V.ToString

This item has no description.

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

Warning: this symbol is deprecated: use V.ToString

This item has no description.

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

Warning: this symbol is deprecated: use V.ToString

This item has no description.

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

Warning: this symbol is deprecated: use V.ToString

This item has no description.

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

Warning: this symbol is deprecated: use V.ToString

This item has no description.

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

Warning: this symbol is deprecated: use V.ToString

This item has no description.

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

Warning: this symbol is deprecated: use V.ToString

This item has no description.

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

Warning: this symbol is deprecated: use V.ToString

This item has no description.

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

Warning: this symbol is deprecated: use V.ToString

This item has no description.

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

Warning: this symbol is deprecated: use V.ToString

This item has no description.

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

Warning: this symbol is deprecated: use V.ToString

This item has no description.

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

Warning: this symbol is deprecated: use V.ToString

This item has no description.

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

Warning: this symbol is deprecated: use V.IsZero

This item has no description.

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

Warning: this symbol is deprecated: use V.IsZero

This item has no description.

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

Warning: this symbol is deprecated: use V.IsZero

This item has no description.

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

Warning: this symbol is deprecated: use V.IsZero

This item has no description.

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

Warning: this symbol is deprecated: use V.IsZero

This item has no description.

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

Warning: this symbol is deprecated: use V.IsZero

This item has no description.

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

Warning: this symbol is deprecated: use V.IsZero

This item has no description.

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

Warning: this symbol is deprecated: use V.IsZero

This item has no description.

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

Warning: this symbol is deprecated: use V.IsZero

This item has no description.

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

Warning: this symbol is deprecated: use V.IsZero

This item has no description.

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

Warning: this symbol is deprecated: use V.IsZero

This item has no description.

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

Warning: this symbol is deprecated: use V.IsZero

This item has no description.

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

Warning: this symbol is deprecated: use V.IsPerfectlyZero

This item has no description.

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

Warning: this symbol is deprecated: use V.IsPerfectlyZero

This item has no description.

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

Warning: this symbol is deprecated: use V.IsPerfectlyZero

This item has no description.

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

Warning: this symbol is deprecated: use V.AdjustToLength

This item has no description.

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

Warning: this symbol is deprecated: use V.AdjustToLength

This item has no description.

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

Warning: this symbol is deprecated: use V.AdjustToLength

This item has no description.

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

Warning: this symbol is deprecated: use Vector2FromStr

This item has no description.

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

Warning: this symbol is deprecated: use Vector3FromStr

This item has no description.

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

Warning: this symbol is deprecated: use Vector4FromStr

This item has no description.

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

Warning: this symbol is deprecated: use TVector2.DotProduct(V1, V2)

This item has no description.

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

Warning: this symbol is deprecated: use TVector3.DotProduct(V1, V2)

This item has no description.

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

Warning: this symbol is deprecated: use TVector4.DotProduct(V1, V2)

This item has no description.

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

Warning: this symbol is deprecated: use TVector2.Equals(V1, V2)

This item has no description.

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

Warning: this symbol is deprecated: use TVector3.Equals(V1, V2)

This item has no description.

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

Warning: this symbol is deprecated: use TVector4.Equals(V1, V2)

This item has no description.

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

Warning: this symbol is deprecated: use TVector2.Equals(V1, V2, Epsilon)

This item has no description.

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

Warning: this symbol is deprecated: use TVector3.Equals(V1, V2, Epsilon)

This item has no description.

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

Warning: this symbol is deprecated: use TVector4.Equals(V1, V2, Epsilon)

This item has no description.

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

Warning: this symbol is deprecated: use TVector2.PerfectlyEquals(V1, V2)

This item has no description.

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

Warning: this symbol is deprecated: use TVector3.PerfectlyEquals(V1, V2)

This item has no description.

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

Warning: this symbol is deprecated: use TVector4.PerfectlyEquals(V1, V2)

This item has no description.

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

Warning: this symbol is deprecated: use TVector2Byte.Equals(V1, V2)

This item has no description.

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

Warning: this symbol is deprecated: use TVector3Byte.Equals(V1, V2)

This item has no description.

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

Warning: this symbol is deprecated: use TVector4Byte.Equals(V1, V2)

This item has no description.

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

Warning: this symbol is deprecated: use TVector2Integer.Equals(V1, V2)

This item has no description.

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

Warning: this symbol is deprecated: use TVector3Integer.Equals(V1, V2)

This item has no description.

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

Warning: this symbol is deprecated: use TVector4Integer.Equals(V1, V2)

This item has no description.

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

Warning: this symbol is deprecated: use TVector2Cardinal.Equals(V1, V2)

This item has no description.

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

Warning: this symbol is deprecated: use TVector3Cardinal.Equals(V1, V2)

This item has no description.

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

Warning: this symbol is deprecated: use TVector4Cardinal.Equals(V1, V2)

This item has no description.

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

Warning: this symbol is deprecated: use TMatrix2.TryInverse

This item has no description.

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

Warning: this symbol is deprecated: use TMatrix3.TryInverse

This item has no description.

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

Warning: this symbol is deprecated: use TMatrix4.TryInverse

This item has no description.

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

Warning: this symbol is deprecated: use TMatrix2.ToRawString

This item has no description.

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

Warning: this symbol is deprecated: use TMatrix3.ToRawString

This item has no description.

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

Warning: this symbol is deprecated: use TMatrix4.ToRawString

This item has no description.

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

Warning: this symbol is deprecated: use TMatrix2.ToString

This item has no description.

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

Warning: this symbol is deprecated: use TMatrix3.ToString

This item has no description.

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

Warning: this symbol is deprecated: use TMatrix4.ToString

This item has no description.

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

Warning: this symbol is deprecated: use TMatrix2.PerfectlyEquals(V1, V2)

This item has no description.

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

Warning: this symbol is deprecated: use TMatrix3.PerfectlyEquals(V1, V2)

This item has no description.

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

Warning: this symbol is deprecated: use TMatrix4.PerfectlyEquals(V1, V2)

This item has no description.

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

Warning: this symbol is deprecated: use TMatrix2.Rows[Row]

This item has no description.

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

Warning: this symbol is deprecated: use TMatrix3.Rows[Row]

This item has no description.

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

Warning: this symbol is deprecated: use TMatrix4.Rows[Row]

This item has no description.

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

Warning: this symbol is deprecated: use V.XY

This item has no description.

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

Warning: this symbol is deprecated: use V.XYZ

This item has no description.

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

Warning: this symbol is deprecated: use Matrix3

This item has no description.

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

Warning: this symbol is deprecated: use Matrix4

This item has no description.

procedure MatrixDecompose(const Matrix: TMatrix4; out Translation: TVector3; out Rotation: TVector4; out Scale: TVector3);

Decompose a matrix that is composition of 3D translation, rotation and scale.

The returned Rotation is expressed as an axis-angle (first 3 components are axis, last component is an angle in radians), as usual in our engine (see e.g. TCastleTransform.Rotation).

function ScaleFromMatrix(const Matrix: TMatrix4): TVector3;

Extract scale from matrix. This performs a subset of MatrixDecompose work.

function TranslationFromMatrix(const M: TMatrix4): TVector3;

Extract translation from matrix. This performs a subset of MatrixDecompose work.

Types

TVector2 = CastleVectorsInternalSingle.TGenericVector2;

Vector of 2 floating-point values (Single precision).

PVector2 = ˆTVector2;

This item has no description.

TVector2Double = CastleVectorsInternalDouble.TGenericVector2;

Vector of 2 floating-point values (Double precision).

PVector2Double = ˆTVector2Double;

This item has no description.

TVector3 = CastleVectorsInternalSingle.TGenericVector3;

Vector of 3 floating-point values (Single precision).

PVector3 = ˆTVector3;

This item has no description.

TVector3Double = CastleVectorsInternalDouble.TGenericVector3;

Vector of 3 floating-point values (Double precision).

PVector3Double = ˆTVector3Double;

This item has no description.

TVector4 = CastleVectorsInternalSingle.TGenericVector4;

Vector of 4 floating-point values (Single precision).

PVector4 = ˆTVector4;

This item has no description.

TVector4Double = CastleVectorsInternalDouble.TGenericVector4;

Vector of 4 floating-point values (Double precision).

PVector4Double = ˆTVector4Double;

This item has no description.

TMatrix2 = CastleVectorsInternalSingle.TGenericMatrix2;

2x2 matrix of floating-point values (Single precision).

PMatrix2 = ˆTMatrix2;

This item has no description.

TMatrix2Double = CastleVectorsInternalDouble.TGenericMatrix2;

2x2 matrix of floating-point values (Double precision).

PMatrix2Double = ˆTMatrix2Double;

This item has no description.

TMatrix3 = CastleVectorsInternalSingle.TGenericMatrix3;

3x3 matrix of floating-point values (Single precision).

PMatrix3 = ˆTMatrix3;

This item has no description.

TMatrix3Double = CastleVectorsInternalDouble.TGenericMatrix3;

3x3 matrix of floating-point values (Double precision).

PMatrix3Double = ˆTMatrix3Double;

This item has no description.

TMatrix4 = CastleVectorsInternalSingle.TGenericMatrix4;

4x4 matrix of floating-point values (Single precision).

PMatrix4 = ˆTMatrix4;

This item has no description.

TMatrix4Double = CastleVectorsInternalDouble.TGenericMatrix4;

4x4 matrix of floating-point values (Double precision).

PMatrix4Double = ˆTMatrix4Double;

This item has no description.

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

This item has no description.

PVector2Array = ˆTVector2Array;

This item has no description.

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

This item has no description.

PVector3Array = ˆTVector3Array;

This item has no description.

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

This item has no description.

PVector4Array = ˆTVector4Array;

This item has no description.

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

CastleVectors routines (global functions, procedures) for Single precision of vectors and matrices.

PVector2Byte = ˆTVector2Byte;

This item has no description.

PVector3Byte = ˆTVector3Byte;

This item has no description.

PVector4Byte = ˆTVector4Byte;

This item has no description.

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

This item has no description.

PVector2ByteArray = ˆTVector2ByteArray;

This item has no description.

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

This item has no description.

PVector3ByteArray = ˆTVector3ByteArray;

This item has no description.

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

This item has no description.

PVector4ByteArray = ˆTVector4ByteArray;

This item has no description.

PVector2Integer = ˆTVector2Integer;

This item has no description.

PVector3Integer = ˆTVector3Integer;

This item has no description.

PVector4Integer = ˆTVector4Integer;

This item has no description.

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

This item has no description.

PVector2IntegerArray = ˆTVector2IntegerArray;

This item has no description.

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

This item has no description.

PVector3IntegerArray = ˆTVector3IntegerArray;

This item has no description.

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

This item has no description.

PVector4IntegerArray = ˆTVector4IntegerArray;

This item has no description.

PVector2Cardinal = ˆTVector2Cardinal;

This item has no description.

PVector3Cardinal = ˆTVector3Cardinal;

This item has no description.

PVector4Cardinal = ˆTVector4Cardinal;

This item has no description.

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

This item has no description.

PVector2CardinalArray = ˆTVector2CardinalArray;

This item has no description.

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

This item has no description.

PVector3CardinalArray = ˆTVector3CardinalArray;

This item has no description.

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

This item has no description.

PVector4CardinalArray = ˆTVector4CardinalArray;

This item has no description.

PVector2SmallInt = ˆTVector2SmallInt;

This item has no description.

TVector2SmallIntList = specialize TStructList<TVector2SmallInt>;

List of TVector2SmallInt.

TVector3CardinalList = specialize TStructList<TVector3Cardinal>;

List of TVector2Cardinal.

TVector2Single = TVector2 deprecated;