Unit CastleVectors

Description

Uses

Classes, Interfaces, Objects and Records

Functions and Procedures

Types

Constants

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.

Source: base/castlevectors.pas (line 148).

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 `TVector3IntegerList`	List of TVector3Integer.
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`
Record `TTransformationSimple`	Simplified version of TTransformation, that does not store InverseTransform and Scale.
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';

IdentityTransformation: TTransformation = (
    Transform: (Data: (
      (1, 0, 0, 0),
      (0, 1, 0, 0),
      (0, 0, 1, 0),
      (0, 0, 0, 1)
    ));
    InverseTransform: (Data: (
      (1, 0, 0, 0),
      (0, 1, 0, 0),
      (0, 0, 1, 0),
      (0, 0, 0, 1)
    ));
    Scale: 1;
    UniformScale: true
  );

Description

Functions and Procedures

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

Construct an initialized TVector2 value.

Source: base/castlevectors_float.inc (line 61).

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

This item has no description.

Source: base/castlevectors_float.inc (line 62).

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

Construct an initialized TVector2Double value.

Source: base/castlevectors_float.inc (line 65).

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

Construct an initialized TVector3 value.

Source: base/castlevectors_float.inc (line 68).

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

This item has no description.

Source: base/castlevectors_float.inc (line 69).

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

This item has no description.

Source: base/castlevectors_float.inc (line 70).

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

Construct an initialized TVector3Double value.

Source: base/castlevectors_float.inc (line 73).

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

This item has no description.

Source: base/castlevectors_float.inc (line 74).

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

Construct an initialized TVector4 value.

Source: base/castlevectors_float.inc (line 77).

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

This item has no description.

Source: base/castlevectors_float.inc (line 78).

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

This item has no description.

Source: base/castlevectors_float.inc (line 79).

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

This item has no description.

Source: base/castlevectors_float.inc (line 80).

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

Construct an initialized TVector4Double value.

Source: base/castlevectors_float.inc (line 83).

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

This item has no description.

Source: base/castlevectors_float.inc (line 84).

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

This item has no description.

Source: base/castlevectors_float.inc (line 85).

function Matrix3(const V: TMatrix3Double): TMatrix3;

Convert between Double-precision and Single-precision matrix.

Source: base/castlevectors_float.inc (line 88).

function Matrix4(const V: TMatrix4Double): TMatrix4;

This item has no description.

Source: base/castlevectors_float.inc (line 89).

function Matrix3Double(const V: TMatrix3): TMatrix3Double;

This item has no description.

Source: base/castlevectors_float.inc (line 90).

function Matrix4Double(const V: TMatrix4): TMatrix4Double;

This item has no description.

Source: base/castlevectors_float.inc (line 91).

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).

Source: base/castlevectors_float.inc (line 104).

function Vector3FromStr(const S: string): TVector3;

This item has no description.

Source: base/castlevectors_float.inc (line 105).

function Vector4FromStr(const S: string): TVector4;

This item has no description.

Source: base/castlevectors_float.inc (line 106).

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.

Source: base/castlevectors_float.inc (line 123).

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

This item has no description.

Source: base/castlevectors_float.inc (line 124).

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

This item has no description.

Source: base/castlevectors_float.inc (line 125).

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

This item has no description.

Source: base/castlevectors_float.inc (line 126).

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

This item has no description.

Source: base/castlevectors_float.inc (line 127).

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

This item has no description.

Source: base/castlevectors_float.inc (line 128).

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

This item has no description.

Source: base/castlevectors_float.inc (line 130).

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

This item has no description.

Source: base/castlevectors_float.inc (line 131).

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

This item has no description.

Source: base/castlevectors_float.inc (line 132).

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

This item has no description.

Source: base/castlevectors_float.inc (line 133).

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

This item has no description.

Source: base/castlevectors_float.inc (line 134).

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

This item has no description.

Source: base/castlevectors_float.inc (line 135).

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

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

Source: base/castlevectors_float.inc (line 139).

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.

Source: base/castlevectors_single.inc (line 33).

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

This item has no description.

Source: base/castlevectors_single.inc (line 34).

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.

Source: base/castlevectors_single.inc (line 47).

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

This item has no description.

Source: base/castlevectors_single.inc (line 48).

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.

Source: base/castlevectors_single.inc (line 63).

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.

Source: base/castlevectors_single.inc (line 85).

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.

Source: base/castlevectors_single.inc (line 110).

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.

Source: base/castlevectors_single.inc (line 111).

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.

Source: base/castlevectors_single.inc (line 117).

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.

Source: base/castlevectors_single.inc (line 121).

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.

Source: base/castlevectors_single.inc (line 126).

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.

Source: base/castlevectors_single.inc (line 133).

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

This item has no description.

Source: base/castlevectors_single.inc (line 134).

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

This item has no description.

Source: base/castlevectors_single.inc (line 135).

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

This item has no description.

Source: base/castlevectors_single.inc (line 136).

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

This item has no description.

Source: base/castlevectors_single.inc (line 137).

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

This item has no description.

Source: base/castlevectors_single.inc (line 138).

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

This item has no description.

Source: base/castlevectors_single.inc (line 141).

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

This item has no description.

Source: base/castlevectors_single.inc (line 142).

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

This item has no description.

Source: base/castlevectors_single.inc (line 143).

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

This item has no description.

Source: base/castlevectors_single.inc (line 145).

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

This item has no description.

Source: base/castlevectors_single.inc (line 147).

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).

Source: base/castlevectors_single.inc (line 167).

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

This item has no description.

Source: base/castlevectors_single.inc (line 168).

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

This item has no description.

Source: base/castlevectors_single.inc (line 169).

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

This item has no description.

Source: base/castlevectors_single.inc (line 170).

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

Endianess swapping for vectors.

Source: base/castlevectors_single.inc (line 174).

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

This item has no description.

Source: base/castlevectors_single.inc (line 175).

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

This item has no description.

Source: base/castlevectors_single.inc (line 176).

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

Endianess conversion for vectors (little endian to native).

Source: base/castlevectors_single.inc (line 179).

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

This item has no description.

Source: base/castlevectors_single.inc (line 180).

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

This item has no description.

Source: base/castlevectors_single.inc (line 181).

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

Endianess conversion for vectors (big endian to native).

Source: base/castlevectors_single.inc (line 184).

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

This item has no description.

Source: base/castlevectors_single.inc (line 185).

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

This item has no description.

Source: base/castlevectors_single.inc (line 186).

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

Endianess conversion for vectors (native to little endian).

Source: base/castlevectors_single.inc (line 189).

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

This item has no description.

Source: base/castlevectors_single.inc (line 190).

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

This item has no description.

Source: base/castlevectors_single.inc (line 191).

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

Endianess conversion for vectors (native to big endian).

Source: base/castlevectors_single.inc (line 194).

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

This item has no description.

Source: base/castlevectors_single.inc (line 195).

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

This item has no description.

Source: base/castlevectors_single.inc (line 196).

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

Replace contents of 2 variables.

Source: base/castlevectors_single.inc (line 199).

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

This item has no description.

Source: base/castlevectors_single.inc (line 200).

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

This item has no description.

Source: base/castlevectors_single.inc (line 201).

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.

Source: base/castlevectors_single.inc (line 211).

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

Intersection of two 3D planes.

Exceptions raised

EPlanesParallel: If planes are parallel.

Source: base/castlevectors_single.inc (line 216).

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

Source: base/castlevectors_single.inc (line 225).

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.

Source: base/castlevectors_single.inc (line 232).

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).

Source: base/castlevectors_single.inc (line 250).

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

This item has no description.

Source: base/castlevectors_single.inc (line 253).

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

This item has no description.

Source: base/castlevectors_single.inc (line 255).

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.

Source: base/castlevectors_single.inc (line 264).

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

This item has no description.

Source: base/castlevectors_single.inc (line 265).

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.

Source: base/castlevectors_single.inc (line 271).

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

This item has no description.

Source: base/castlevectors_single.inc (line 274).

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

This item has no description.

Source: base/castlevectors_single.inc (line 275).

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

This item has no description.

Source: base/castlevectors_single.inc (line 276).

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

This item has no description.

Source: base/castlevectors_single.inc (line 277).

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).

Source: base/castlevectors_single.inc (line 282).

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

This item has no description.

Source: base/castlevectors_single.inc (line 285).

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.

Source: base/castlevectors_single.inc (line 290).

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.

Source: base/castlevectors_single.inc (line 308).

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).

Source: base/castlevectors_single.inc (line 316).

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.

Source: base/castlevectors_single.inc (line 323).

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.

Source: base/castlevectors_single.inc (line 328).

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

This item has no description.

Source: base/castlevectors_single.inc (line 329).

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

This item has no description.

Source: base/castlevectors_single.inc (line 332).

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

This item has no description.

Source: base/castlevectors_single.inc (line 334).

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.)

Source: base/castlevectors_single.inc (line 343).

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.

Source: base/castlevectors_single.inc (line 349).

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

This item has no description.

Source: base/castlevectors_single.inc (line 352).

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.

Source: base/castlevectors_single.inc (line 360).

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).

Source: base/castlevectors_single.inc (line 371).

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

This item has no description.

Source: base/castlevectors_single.inc (line 375).

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

This item has no description.

Source: base/castlevectors_single.inc (line 378).

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

This item has no description.

Source: base/castlevectors_single.inc (line 379).

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

This item has no description.

Source: base/castlevectors_single.inc (line 381).

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.

Source: base/castlevectors_single.inc (line 394).

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

This item has no description.

Source: base/castlevectors_single.inc (line 396).

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.

Source: base/castlevectors_single.inc (line 411).

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.

Source: base/castlevectors_single.inc (line 414).

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

This item has no description.

Source: base/castlevectors_single.inc (line 417).

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

This item has no description.

Source: base/castlevectors_single.inc (line 421).

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

This item has no description.

Source: base/castlevectors_single.inc (line 423).

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].

Source: base/castlevectors_single.inc (line 438).

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.

Source: base/castlevectors_single.inc (line 442).

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

This item has no description.

Source: base/castlevectors_single.inc (line 446).

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

This item has no description.

Source: base/castlevectors_single.inc (line 451).

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

This item has no description.

Source: base/castlevectors_single.inc (line 453).

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

This item has no description.

Source: base/castlevectors_single.inc (line 457).

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

This item has no description.

Source: base/castlevectors_single.inc (line 458).

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.

Source: base/castlevectors_single.inc (line 463).

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

Warning: this symbol is deprecated: use Line2DFrom2Points

This item has no description.

Source: base/castlevectors_single.inc (line 464).

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.

Source: base/castlevectors_single.inc (line 469).

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

This item has no description.

Source: base/castlevectors_single.inc (line 471).

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.

Source: base/castlevectors_single.inc (line 480).

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

This item has no description.

Source: base/castlevectors_single.inc (line 483).

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

This item has no description.

Source: base/castlevectors_single.inc (line 487).

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

This item has no description.

Source: base/castlevectors_single.inc (line 490).

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

This item has no description.

Source: base/castlevectors_single.inc (line 493).

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.

Source: base/castlevectors_single.inc (line 499).

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.

Source: base/castlevectors_single.inc (line 509).

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.

Source: base/castlevectors_single.inc (line 543).

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

This item has no description.

Source: base/castlevectors_single.inc (line 544).

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

This item has no description.

Source: base/castlevectors_single.inc (line 546).

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

This item has no description.

Source: base/castlevectors_single.inc (line 547).

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.

Source: base/castlevectors_single.inc (line 572).

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

This item has no description.

Source: base/castlevectors_single.inc (line 573).

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.

Source: base/castlevectors_single.inc (line 621).

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

This item has no description.

Source: base/castlevectors_single.inc (line 623).

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

This item has no description.

Source: base/castlevectors_single.inc (line 625).

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

This item has no description.

Source: base/castlevectors_single.inc (line 628).

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

This item has no description.

Source: base/castlevectors_single.inc (line 630).

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

This item has no description.

Source: base/castlevectors_single.inc (line 632).

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).

Source: base/castlevectors_single.inc (line 641).

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.

Source: base/castlevectors_single.inc (line 652).

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.

Source: base/castlevectors_single.inc (line 692).

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

This item has no description.

Source: base/castlevectors_single.inc (line 693).

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

This item has no description.

Source: base/castlevectors_single.inc (line 694).

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.

Source: base/castlevectors_single.inc (line 707).

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

This item has no description.

Source: base/castlevectors_single.inc (line 708).

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.

Source: base/castlevectors_single.inc (line 714).

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.

Source: base/castlevectors_single.inc (line 722).

function ScalingMatrix(const ScaleFactor: TVector3): TMatrix4;

This item has no description.

Source: base/castlevectors_single.inc (line 724).

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

This item has no description.

Source: base/castlevectors_single.inc (line 726).

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

This item has no description.

Source: base/castlevectors_single.inc (line 730).

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

This item has no description.

Source: base/castlevectors_single.inc (line 732).

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.

Source: base/castlevectors_single.inc (line 733).

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

This item has no description.

Source: base/castlevectors_single.inc (line 734).

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.

Source: base/castlevectors_single.inc (line 735).

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

This item has no description.

Source: base/castlevectors_single.inc (line 737).

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

This item has no description.

Source: base/castlevectors_single.inc (line 739).

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.

Source: base/castlevectors_single.inc (line 745).

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

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

Source: base/castlevectors_single.inc (line 749).

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.

Source: base/castlevectors_single.inc (line 763).

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

This item has no description.

Source: base/castlevectors_single.inc (line 764).

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

This item has no description.

Source: base/castlevectors_single.inc (line 765).

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

This item has no description.

Source: base/castlevectors_single.inc (line 767).

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

This item has no description.

Source: base/castlevectors_single.inc (line 768).

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.

Source: base/castlevectors_single.inc (line 788).

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

This item has no description.

Source: base/castlevectors_single.inc (line 790).

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

This item has no description.

Source: base/castlevectors_single.inc (line 792).

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.

Source: base/castlevectors_double.inc (line 26).

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

This item has no description.

Source: base/castlevectors_byte.inc (line 157).

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

This item has no description.

Source: base/castlevectors_byte.inc (line 158).

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

This item has no description.

Source: base/castlevectors_byte.inc (line 159).

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.

Source: base/castlevectors_byte.inc (line 167).

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

This item has no description.

Source: base/castlevectors_byte.inc (line 168).

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

This item has no description.

Source: base/castlevectors_byte.inc (line 169).

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

This item has no description.

Source: base/castlevectors_byte.inc (line 172).

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

This item has no description.

Source: base/castlevectors_byte.inc (line 173).

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

This item has no description.

Source: base/castlevectors_byte.inc (line 174).

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

This item has no description.

Source: base/castlevectors_byte.inc (line 176).

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

This item has no description.

Source: base/castlevectors_byte.inc (line 177).

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

This item has no description.

Source: base/castlevectors_byte.inc (line 178).

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

This item has no description.

Source: base/castlevectors_integer.inc (line 171).

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

This item has no description.

Source: base/castlevectors_integer.inc (line 172).

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

This item has no description.

Source: base/castlevectors_integer.inc (line 173).

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

This item has no description.

Source: base/castlevectors_integer.inc (line 175).

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

This item has no description.

Source: base/castlevectors_cardinal.inc (line 168).

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

This item has no description.

Source: base/castlevectors_cardinal.inc (line 169).

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

This item has no description.

Source: base/castlevectors_cardinal.inc (line 170).

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

This item has no description.

Source: base/castlevectors_smallint.inc (line 55).

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

Warning: this symbol is deprecated: use Vector2

Construct an initialized TVector2 value.

Source: base/castlevectors_compatibility_deprecated.inc (line 101).

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

Warning: this symbol is deprecated: use Vector2

This item has no description.

Source: base/castlevectors_compatibility_deprecated.inc (line 102).

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

Warning: this symbol is deprecated: use Vector3

Construct an initialized TVector3 value.

Source: base/castlevectors_compatibility_deprecated.inc (line 105).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 106).

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

Warning: this symbol is deprecated: use Vector3

This item has no description.

Source: base/castlevectors_compatibility_deprecated.inc (line 107).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 110).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 111).

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

Warning: this symbol is deprecated: use Vector4

This item has no description.

Source: base/castlevectors_compatibility_deprecated.inc (line 112).

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)

Source: base/castlevectors_compatibility_deprecated.inc (line 116).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 117).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 118).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 119).

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

Warning: this symbol is deprecated: use Math.IsZero

This item has no description.

Source: base/castlevectors_compatibility_deprecated.inc (line 120).

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)

Source: base/castlevectors_compatibility_deprecated.inc (line 124).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 125).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 126).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 127).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 128).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 129).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 130).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 131).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 132).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 133).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 134).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 135).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 136).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 137).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 138).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 139).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 140).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 141).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 142).

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

Warning: this symbol is deprecated: use V.LengthSqr

This item has no description.

Source: base/castlevectors_compatibility_deprecated.inc (line 143).

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

Warning: this symbol is deprecated: use V.LengthSqr

This item has no description.

Source: base/castlevectors_compatibility_deprecated.inc (line 144).

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

Warning: this symbol is deprecated: use V.LengthSqr

This item has no description.

Source: base/castlevectors_compatibility_deprecated.inc (line 145).

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

Warning: this symbol is deprecated: use V.Length

This item has no description.

Source: base/castlevectors_compatibility_deprecated.inc (line 146).

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

Warning: this symbol is deprecated: use V.Length

This item has no description.

Source: base/castlevectors_compatibility_deprecated.inc (line 147).

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

Warning: this symbol is deprecated: use V.Length

This item has no description.

Source: base/castlevectors_compatibility_deprecated.inc (line 148).

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

Warning: this symbol is deprecated: use V.Average

This item has no description.

Source: base/castlevectors_compatibility_deprecated.inc (line 149).

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

Warning: this symbol is deprecated: use V.ToRawString

This item has no description.

Source: base/castlevectors_compatibility_deprecated.inc (line 150).

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

Warning: this symbol is deprecated: use V.ToRawString

This item has no description.

Source: base/castlevectors_compatibility_deprecated.inc (line 151).

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

Warning: this symbol is deprecated: use V.ToRawString

This item has no description.

Source: base/castlevectors_compatibility_deprecated.inc (line 152).

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

Warning: this symbol is deprecated: use V.ToString

This item has no description.

Source: base/castlevectors_compatibility_deprecated.inc (line 153).

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

Warning: this symbol is deprecated: use V.ToString

This item has no description.

Source: base/castlevectors_compatibility_deprecated.inc (line 154).

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

Warning: this symbol is deprecated: use V.ToString

This item has no description.

Source: base/castlevectors_compatibility_deprecated.inc (line 155).

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

Warning: this symbol is deprecated: use V.ToString

This item has no description.

Source: base/castlevectors_compatibility_deprecated.inc (line 156).

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

Warning: this symbol is deprecated: use V.ToString

This item has no description.

Source: base/castlevectors_compatibility_deprecated.inc (line 157).

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

Warning: this symbol is deprecated: use V.ToString

This item has no description.

Source: base/castlevectors_compatibility_deprecated.inc (line 158).

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

Warning: this symbol is deprecated: use V.ToString

This item has no description.

Source: base/castlevectors_compatibility_deprecated.inc (line 159).

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

Warning: this symbol is deprecated: use V.ToString

This item has no description.

Source: base/castlevectors_compatibility_deprecated.inc (line 160).

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

Warning: this symbol is deprecated: use V.ToString

This item has no description.

Source: base/castlevectors_compatibility_deprecated.inc (line 161).

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

Warning: this symbol is deprecated: use V.ToString

This item has no description.

Source: base/castlevectors_compatibility_deprecated.inc (line 162).

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

Warning: this symbol is deprecated: use V.ToString

This item has no description.

Source: base/castlevectors_compatibility_deprecated.inc (line 163).

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

Warning: this symbol is deprecated: use V.ToString

This item has no description.

Source: base/castlevectors_compatibility_deprecated.inc (line 164).

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

Warning: this symbol is deprecated: use V.IsZero

This item has no description.

Source: base/castlevectors_compatibility_deprecated.inc (line 165).

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

Warning: this symbol is deprecated: use V.IsZero

This item has no description.

Source: base/castlevectors_compatibility_deprecated.inc (line 166).

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

Warning: this symbol is deprecated: use V.IsZero

This item has no description.

Source: base/castlevectors_compatibility_deprecated.inc (line 167).

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

Warning: this symbol is deprecated: use V.IsZero

This item has no description.

Source: base/castlevectors_compatibility_deprecated.inc (line 168).

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

Warning: this symbol is deprecated: use V.IsZero

This item has no description.

Source: base/castlevectors_compatibility_deprecated.inc (line 169).

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

Warning: this symbol is deprecated: use V.IsZero

This item has no description.

Source: base/castlevectors_compatibility_deprecated.inc (line 170).

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

Warning: this symbol is deprecated: use V.IsZero

This item has no description.

Source: base/castlevectors_compatibility_deprecated.inc (line 171).

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

Warning: this symbol is deprecated: use V.IsZero

This item has no description.

Source: base/castlevectors_compatibility_deprecated.inc (line 172).

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

Warning: this symbol is deprecated: use V.IsZero

This item has no description.

Source: base/castlevectors_compatibility_deprecated.inc (line 173).

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

Warning: this symbol is deprecated: use V.IsZero

This item has no description.

Source: base/castlevectors_compatibility_deprecated.inc (line 174).

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

Warning: this symbol is deprecated: use V.IsZero

This item has no description.

Source: base/castlevectors_compatibility_deprecated.inc (line 175).

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

Warning: this symbol is deprecated: use V.IsZero

This item has no description.

Source: base/castlevectors_compatibility_deprecated.inc (line 176).

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

Warning: this symbol is deprecated: use V.IsPerfectlyZero

This item has no description.

Source: base/castlevectors_compatibility_deprecated.inc (line 177).

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

Warning: this symbol is deprecated: use V.IsPerfectlyZero

This item has no description.

Source: base/castlevectors_compatibility_deprecated.inc (line 178).

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

Warning: this symbol is deprecated: use V.IsPerfectlyZero

This item has no description.

Source: base/castlevectors_compatibility_deprecated.inc (line 179).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 180).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 181).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 182).

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

Warning: this symbol is deprecated: use Vector2FromStr

This item has no description.

Source: base/castlevectors_compatibility_deprecated.inc (line 183).

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

Warning: this symbol is deprecated: use Vector3FromStr

This item has no description.

Source: base/castlevectors_compatibility_deprecated.inc (line 184).

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

Warning: this symbol is deprecated: use Vector4FromStr

This item has no description.

Source: base/castlevectors_compatibility_deprecated.inc (line 185).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 186).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 187).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 188).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 189).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 190).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 191).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 192).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 193).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 194).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 195).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 196).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 197).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 198).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 199).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 200).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 201).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 202).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 203).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 204).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 205).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 206).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 207).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 208).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 209).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 210).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 211).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 212).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 213).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 214).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 215).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 216).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 217).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 218).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 219).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 220).

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.

Source: base/castlevectors_compatibility_deprecated.inc (line 221).

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

Warning: this symbol is deprecated: use V.XY

This item has no description.

Source: base/castlevectors_compatibility_deprecated.inc (line 222).

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

Warning: this symbol is deprecated: use V.XYZ

This item has no description.

Source: base/castlevectors_compatibility_deprecated.inc (line 223).

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

Warning: this symbol is deprecated: use Matrix3

This item has no description.

Source: base/castlevectors_compatibility_deprecated.inc (line 224).

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

Warning: this symbol is deprecated: use Matrix4

This item has no description.

Source: base/castlevectors_compatibility_deprecated.inc (line 225).

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).

Source: base/castlevectors_matrix_decompose.inc (line 27).

function ScaleFromMatrix(const Matrix: TMatrix4): TVector3;

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

Source: base/castlevectors_matrix_decompose.inc (line 32).

function TranslationFromMatrix(const M: TMatrix4): TVector3;

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

Source: base/castlevectors_matrix_decompose.inc (line 36).

Types

TVector2 = CastleVectorsInternalSingle.TGenericVector2;

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

Source: base/castlevectors_float.inc (line 24).

PVector2 = ˆTVector2;

This item has no description.

Source: base/castlevectors_float.inc (line 24).

TVector2Double = CastleVectorsInternalDouble.TGenericVector2;

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

Source: base/castlevectors_float.inc (line 26).

PVector2Double = ˆTVector2Double;

This item has no description.

Source: base/castlevectors_float.inc (line 26).

TVector3 = CastleVectorsInternalSingle.TGenericVector3;

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

Source: base/castlevectors_float.inc (line 29).

PVector3 = ˆTVector3;

This item has no description.

Source: base/castlevectors_float.inc (line 29).

TVector3Double = CastleVectorsInternalDouble.TGenericVector3;

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

Source: base/castlevectors_float.inc (line 31).

PVector3Double = ˆTVector3Double;

This item has no description.

Source: base/castlevectors_float.inc (line 31).

TVector4 = CastleVectorsInternalSingle.TGenericVector4;

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

Source: base/castlevectors_float.inc (line 34).

PVector4 = ˆTVector4;

This item has no description.

Source: base/castlevectors_float.inc (line 34).

TVector4Double = CastleVectorsInternalDouble.TGenericVector4;

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

Source: base/castlevectors_float.inc (line 36).

PVector4Double = ˆTVector4Double;

This item has no description.

Source: base/castlevectors_float.inc (line 36).

TMatrix2 = CastleVectorsInternalSingle.TGenericMatrix2;

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

Source: base/castlevectors_float.inc (line 39).

PMatrix2 = ˆTMatrix2;

This item has no description.

Source: base/castlevectors_float.inc (line 39).

TMatrix2Double = CastleVectorsInternalDouble.TGenericMatrix2;

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

Source: base/castlevectors_float.inc (line 41).

PMatrix2Double = ˆTMatrix2Double;

This item has no description.

Source: base/castlevectors_float.inc (line 41).

TMatrix3 = CastleVectorsInternalSingle.TGenericMatrix3;

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

Source: base/castlevectors_float.inc (line 44).

PMatrix3 = ˆTMatrix3;

This item has no description.

Source: base/castlevectors_float.inc (line 44).

TMatrix3Double = CastleVectorsInternalDouble.TGenericMatrix3;

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

Source: base/castlevectors_float.inc (line 46).

PMatrix3Double = ˆTMatrix3Double;

This item has no description.

Source: base/castlevectors_float.inc (line 46).

TMatrix4 = CastleVectorsInternalSingle.TGenericMatrix4;

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

Source: base/castlevectors_float.inc (line 49).

PMatrix4 = ˆTMatrix4;

This item has no description.

Source: base/castlevectors_float.inc (line 49).

TMatrix4Double = CastleVectorsInternalDouble.TGenericMatrix4;

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

Source: base/castlevectors_float.inc (line 51).

PMatrix4Double = ˆTMatrix4Double;

This item has no description.

Source: base/castlevectors_float.inc (line 51).

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

This item has no description.

Source: base/castlevectors_float.inc (line 53).

PVector2Array = ˆTVector2Array;

This item has no description.

Source: base/castlevectors_float.inc (line 54).

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

This item has no description.

Source: base/castlevectors_float.inc (line 55).

PVector3Array = ˆTVector3Array;

This item has no description.

Source: base/castlevectors_float.inc (line 56).

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

This item has no description.

Source: base/castlevectors_float.inc (line 57).

PVector4Array = ˆTVector4Array;

This item has no description.

Source: base/castlevectors_float.inc (line 58).

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.

Source: base/castlevectors_byte.inc (line 146).

PVector3Byte = ˆTVector3Byte;

This item has no description.

Source: base/castlevectors_byte.inc (line 147).

PVector4Byte = ˆTVector4Byte;

This item has no description.

Source: base/castlevectors_byte.inc (line 148).

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

This item has no description.

Source: base/castlevectors_byte.inc (line 150).

PVector2ByteArray = ˆTVector2ByteArray;

This item has no description.

Source: base/castlevectors_byte.inc (line 151).

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

This item has no description.

Source: base/castlevectors_byte.inc (line 152).

PVector3ByteArray = ˆTVector3ByteArray;

This item has no description.

Source: base/castlevectors_byte.inc (line 153).

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

This item has no description.

Source: base/castlevectors_byte.inc (line 154).

PVector4ByteArray = ˆTVector4ByteArray;

This item has no description.

Source: base/castlevectors_byte.inc (line 155).

PVector2Integer = ˆTVector2Integer;

This item has no description.

Source: base/castlevectors_integer.inc (line 160).

PVector3Integer = ˆTVector3Integer;

This item has no description.

Source: base/castlevectors_integer.inc (line 161).

PVector4Integer = ˆTVector4Integer;

This item has no description.

Source: base/castlevectors_integer.inc (line 162).

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

This item has no description.

Source: base/castlevectors_integer.inc (line 164).

PVector2IntegerArray = ˆTVector2IntegerArray;

This item has no description.

Source: base/castlevectors_integer.inc (line 165).

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

This item has no description.

Source: base/castlevectors_integer.inc (line 166).

PVector3IntegerArray = ˆTVector3IntegerArray;

This item has no description.

Source: base/castlevectors_integer.inc (line 167).

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

This item has no description.

Source: base/castlevectors_integer.inc (line 168).

PVector4IntegerArray = ˆTVector4IntegerArray;

This item has no description.

Source: base/castlevectors_integer.inc (line 169).

PVector2Cardinal = ˆTVector2Cardinal;

This item has no description.

Source: base/castlevectors_cardinal.inc (line 157).

PVector3Cardinal = ˆTVector3Cardinal;

This item has no description.

Source: base/castlevectors_cardinal.inc (line 158).

PVector4Cardinal = ˆTVector4Cardinal;

This item has no description.

Source: base/castlevectors_cardinal.inc (line 159).

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

This item has no description.

Source: base/castlevectors_cardinal.inc (line 161).

PVector2CardinalArray = ˆTVector2CardinalArray;

This item has no description.

Source: base/castlevectors_cardinal.inc (line 162).

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

This item has no description.

Source: base/castlevectors_cardinal.inc (line 163).

PVector3CardinalArray = ˆTVector3CardinalArray;

This item has no description.

Source: base/castlevectors_cardinal.inc (line 164).

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

This item has no description.

Source: base/castlevectors_cardinal.inc (line 165).

PVector4CardinalArray = ˆTVector4CardinalArray;

This item has no description.

Source: base/castlevectors_cardinal.inc (line 166).

PVector2SmallInt = ˆTVector2SmallInt;

This item has no description.

Source: base/castlevectors_smallint.inc (line 53).

TVector2SmallIntList = specialize TStructList<TVector2SmallInt>;

List of TVector2SmallInt.

Source: base/castlevectors_lists.inc (line 184).

TVector3CardinalList = specialize TStructList<TVector3Cardinal>;

List of TVector2Cardinal.

Source: base/castlevectors_lists.inc (line 187).

TVector2Single = TVector2 deprecated;