unit uPSI_VectorGeometry;
{
This file has been generated by UnitParser v0.7, written by M. Knight
and updated by NP. v/d Spek and George Birbilis. 
Source Code from Carlo Kok has been used to implement various sections of
UnitParser. Components of ROPS are used in the construction of UnitParser,
code implementing the class wrapper is taken from Carlo Kok's conv utility

}
interface
 
uses
   SysUtils
  ,Classes
  ,uPSComponent
  ,uPSRuntime
  ,uPSCompiler
  ;
 
type 
(*----------------------------------------------------------------------------*)
  TPSImport_VectorGeometry = class(TPSPlugin)
  protected
    procedure CompileImport1(CompExec: TPSScript); override;
    procedure ExecImport1(CompExec: TPSScript; const ri: TPSRuntimeClassImporter); override;
  end;
 
 
{ compile-time registration functions }
procedure SIRegister_VectorGeometry(CL: TPSPascalCompiler);

{ run-time registration functions }
procedure RIRegister_VectorGeometry_Routines(S: TPSExec);

procedure Register;

implementation


uses
   GLCrossPlatform
  ,GLVectorTypes
  ,GLVectorGeometry
  ;


procedure Register;
begin
  RegisterComponents('GLS ROPS', [TPSImport_VectorGeometry]);
end;

(* === compile-time registration functions === *)
(*----------------------------------------------------------------------------*)
procedure SIRegister_VectorGeometry(CL: TPSPascalCompiler);
begin
{
  CL.AddTypeS('PByte', '^Byte // will not work');
  CL.AddTypeS('PWord', '^Word // will not work');
  CL.AddTypeS('PInteger', '^Integer // will not work');
  CL.AddTypeS('PCardinal', '^Cardinal // will not work');
  CL.AddTypeS('PSingle', '^Single // will not work');
  CL.AddTypeS('PDouble', '^Double // will not work');
  CL.AddTypeS('PExtended', '^Extended // will not work');
  CL.AddTypeS('PPointer', '^Pointer // will not work');
  CL.AddTypeS('PFloat', '^Single // will not work');
  CL.AddTypeS('PTexPoint', '^TTexPoint // will not work');
}
  CL.AddTypeS('TTexPoint', 'record S : Single; T : Single; end');
{
  CL.AddTypeS('PByteVector', '^TByteVector // will not work');
  CL.AddTypeS('PByteArray', 'PByteVector');
  CL.AddTypeS('PWordVector', '^TWordVector // will not work');
  CL.AddTypeS('PIntegerVector', '^TIntegerVector // will not work');
  CL.AddTypeS('PIntegerArray', 'PIntegerVector');
  CL.AddTypeS('PFloatVector', '^TFloatVector // will not work');
  CL.AddTypeS('PFloatArray', 'PFloatVector');
  CL.AddTypeS('PSingleArray', 'PFloatArray');
}
  CL.AddTypeS('TSingleArray', 'array of Single');
{
  CL.AddTypeS('PDoubleVector', '^TDoubleVector // will not work');
  CL.AddTypeS('PDoubleArray', 'PDoubleVector');
  CL.AddTypeS('PExtendedVector', '^TExtendedVector // will not work');
  CL.AddTypeS('PExtendedArray', 'PExtendedVector');
  CL.AddTypeS('PPointerVector', '^TPointerVector // will not work');
  CL.AddTypeS('PPointerArray', 'PPointerVector');
  CL.AddTypeS('PCardinalVector', '^TCardinalVector // will not work');
  CL.AddTypeS('PCardinalArray', 'PCardinalVector');
  CL.AddTypeS('PHomogeneousByteVector', '^THomogeneousByteVector // will not wo'
   +'rk');
}
  CL.AddTypeS('THomogeneousByteVector', 'TVector4b');
//  CL.AddTypeS('PHomogeneousWordVector', '^THomogeneousWordVector // will not wo'
//   +'rk');
  CL.AddTypeS('THomogeneousWordVector', 'TVector4w');
//  CL.AddTypeS('PHomogeneousIntVector', '^THomogeneousIntVector // will not work');
  CL.AddTypeS('THomogeneousIntVector', 'TVector4i');
//  CL.AddTypeS('PHomogeneousFltVector', '^THomogeneousFltVector // will not work');
  CL.AddTypeS('THomogeneousFltVector', 'TVector4f');
//  CL.AddTypeS('PHomogeneousDblVector', '^THomogeneousDblVector // will not work');
  CL.AddTypeS('THomogeneousDblVector', 'TVector4d');
//  CL.AddTypeS('PHomogeneousExtVector', '^THomogeneousExtVector // will not work');
  CL.AddTypeS('THomogeneousExtVector', 'TVector4e');
//  CL.AddTypeS('PHomogeneousPtrVector', '^THomogeneousPtrVector // will not work');
//  CL.AddTypeS('THomogeneousPtrVector', 'TVector4p');
//  CL.AddTypeS('PAffineByteVector', '^TAffineByteVector // will not work');
  CL.AddTypeS('TAffineByteVector', 'TVector3b');
//  CL.AddTypeS('PAffineWordVector', '^TAffineWordVector // will not work');
  CL.AddTypeS('TAffineWordVector', 'TVector3w');
//  CL.AddTypeS('PAffineIntVector', '^TAffineIntVector // will not work');
  CL.AddTypeS('TAffineIntVector', 'TVector3i');
//  CL.AddTypeS('PAffineFltVector', '^TAffineFltVector // will not work');
  CL.AddTypeS('TAffineFltVector', 'TVector3f');
//  CL.AddTypeS('PAffineDblVector', '^TAffineDblVector // will not work');
  CL.AddTypeS('TAffineDblVector', 'TVector3d');
//  CL.AddTypeS('PAffineExtVector', '^TAffineExtVector // will not work');
  CL.AddTypeS('TAffineExtVector', 'TVector3e');
//  CL.AddTypeS('PAffinePtrVector', '^TAffinePtrVector // will not work');
//  CL.AddTypeS('TAffinePtrVector', 'TVector3p');
//  CL.AddTypeS('PVector', '^TVector // will not work');
  CL.AddTypeS('TVector', 'THomogeneousFltVector');
//  CL.AddTypeS('PHomogeneousVector', '^THomogeneousVector // will not work');
  CL.AddTypeS('THomogeneousVector', 'THomogeneousFltVector');
//  CL.AddTypeS('PAffineVector', '^TAffineVector // will not work');
  CL.AddTypeS('TAffineVector', 'TVector3f');
//  CL.AddTypeS('PVertex', '^TVertex // will not work');
  CL.AddTypeS('TVertex', 'TAffineVector');
//  CL.AddTypeS('PAffineVectorArray', '^TAffineVectorArray // will not work');
//  CL.AddTypeS('PVectorArray', '^TVectorArray // will not work');
//  CL.AddTypeS('PTexPointArray', '^TTexPointArray // will not work');
  CL.AddTypeS('THomogeneousByteMatrix', 'TMatrix4b');
  CL.AddTypeS('THomogeneousIntMatrix', 'TMatrix4i');
  CL.AddTypeS('THomogeneousFltMatrix', 'TMatrix4f');
  CL.AddTypeS('THomogeneousDblMatrix', 'TMatrix4d');
  CL.AddTypeS('TAffineByteMatrix', 'TMatrix3b');
  CL.AddTypeS('TAffineIntMatrix', 'TMatrix3i');
  CL.AddTypeS('TAffineFltMatrix', 'TMatrix3f');
  CL.AddTypeS('TAffineDblMatrix', 'TMatrix3d');
//  CL.AddTypeS('PMatrix', '^TMatrix // will not work');
  CL.AddTypeS('TMatrix', 'THomogeneousFltMatrix');
//  CL.AddTypeS('PMatrixArray', '^TMatrixArray // will not work');
//  CL.AddTypeS('PHomogeneousMatrix', '^THomogeneousMatrix // will not work');
  CL.AddTypeS('THomogeneousMatrix', 'THomogeneousFltMatrix');
//  CL.AddTypeS('PAffineMatrix', '^TAffineMatrix // will not work');
  CL.AddTypeS('TAffineMatrix', 'TAffineFltMatrix');
  CL.AddTypeS('THmgPlane', 'TVector');
  CL.AddTypeS('TDoubleHmgPlane', 'THomogeneousDblVector');
//  CL.AddTypeS('PQuaternion', '^TQuaternion // will not work');
  CL.AddTypeS('TQuaternion', 'record ImagPart : TAffineVector; RealPart : Singl'
   +'e; end');
//  CL.AddTypeS('PQuaternionArray', '^TQuaternionArray // will not work');
  CL.AddTypeS('TRectangle', 'record Left : Integer; Top : Integer; Width : Inte'
   +'ger; Height : Integer; end');
  CL.AddTypeS('TFrustum', 'record pLeft : THmgPlane; pTop : THmgPlane; pRight :'
   +' THmgPlane; pBottom : THmgPlane; pNear : THmgPlane; pFar : THmgPlane; end');
  CL.AddTypeS('TTransType', '( ttScaleX, ttScaleY, ttScaleZ, ttShearXY, ttShear'
   +'XZ, ttShearYZ, ttRotateX, ttRotateY, ttRotateZ, ttTranslateX, ttTranslateY'
   +', ttTranslateZ, ttPerspectiveX, ttPerspectiveY, ttPerspectiveZ, ttPerspect'
   +'iveW )');
  CL.AddTypeS('TRenderContextClippingInfo', 'record origin : TVector; clippingD'
   +'irection : TVector; viewPortRadius : Single; farClippingDistance : Single;'
   +' frustum : TFrustum; end');

 CL.AddTypeS('TPackedRotationMatrix', 'array [0..2] of SmallInt');

 CL.AddConstantN('EPSILON','Single').setExtended( 1e-40);
 CL.AddConstantN('EPSILON2','Single').setExtended( 1e-30);

 CL.AddDelphiFunction('Function TexPointMake( const s, t : Single) : TTexPoint');
{
 CL.AddDelphiFunction('Function AffineVectorMake2( const x, y, z : Single) : TAffineVector;');
 CL.AddDelphiFunction('Function AffineVectorMake3( const v : TVector) : TAffineVector;');
 CL.AddDelphiFunction('Procedure SetAffineVector2( var v : TAffineVector; const x, y, z : Single);');
 CL.AddDelphiFunction('Procedure SetVector2( var v : TAffineVector; const x, y, z : Single);');
 CL.AddDelphiFunction('Procedure SetVector3( var v : TAffineVector; const vSrc : TVector);');
 CL.AddDelphiFunction('Procedure SetVector4( var v : TAffineVector; const vSrc : TAffineVector);');
 CL.AddDelphiFunction('Procedure SetVector5( var v : TAffineDblVector; const vSrc : TAffineVector);');
 CL.AddDelphiFunction('Procedure SetVector6( var v : TAffineDblVector; const vSrc : TVector);');
 CL.AddDelphiFunction('Function VectorMake2( const v : TAffineVector; w : Single) : TVector;');
 CL.AddDelphiFunction('Function VectorMake3( const x, y, z : Single; w : Single) : TVector;');
 CL.AddDelphiFunction('Function PointMake2( const x, y, z : Single) : TVector;');
 CL.AddDelphiFunction('Function PointMake3( const v : TAffineVector) : TVector;');
 CL.AddDelphiFunction('Function PointMake4( const v : TVector) : TVector;');
 CL.AddDelphiFunction('Procedure SetVector2( var v : TVector; const x, y, z : Single; w : Single);');
 CL.AddDelphiFunction('Procedure SetVector3( var v : TVector; const av : TAffineVector; w : Single);');
 CL.AddDelphiFunction('Procedure SetVector4( var v : TVector; const vSrc : TVector);');
 CL.AddDelphiFunction('Procedure MakePoint2( var v : TVector; const x, y, z : Single);');
 CL.AddDelphiFunction('Procedure MakePoint3( var v : TVector; const av : TAffineVector);');
 CL.AddDelphiFunction('Procedure MakePoint4( var v : TVector; const av : TVector);');
 CL.AddDelphiFunction('Procedure MakeVector2( var v : TAffineVector; const x, y, z : Single);');
 CL.AddDelphiFunction('Procedure MakeVector3( var v : TVector; const x, y, z : Single);');
 CL.AddDelphiFunction('Procedure MakeVector4( var v : TVector; const av : TAffineVector);');
 CL.AddDelphiFunction('Procedure MakeVector5( var v : TVector; const av : TVector);');
 CL.AddDelphiFunction('Procedure RstVector2( var v : TAffineVector);');
 CL.AddDelphiFunction('Procedure RstVector3( var v : TVector);');
 CL.AddDelphiFunction('Function VectorEquals2( const V1, V2 : TVector2f) : Boolean;');
 CL.AddDelphiFunction('Function VectorEquals3( const V1, V2 : TVector2i) : Boolean;');
 CL.AddDelphiFunction('Function VectorEquals4( const V1, V2 : TVector2d) : Boolean;');
 CL.AddDelphiFunction('Function VectorEquals5( const V1, V2 : TVector2s) : Boolean;');
 CL.AddDelphiFunction('Function VectorEquals6( const V1, V2 : TVector2b) : Boolean;');
 CL.AddDelphiFunction('Function VectorEquals7( const V1, V2 : TVector3i) : Boolean;');
 CL.AddDelphiFunction('Function VectorEquals8( const V1, V2 : TVector3d) : Boolean;');
 CL.AddDelphiFunction('Function VectorEquals9( const V1, V2 : TVector3s) : Boolean;');
 CL.AddDelphiFunction('Function VectorEquals10( const V1, V2 : TVector3b) : Boolean;');
 CL.AddDelphiFunction('Function VectorEquals11( const V1, V2 : TVector4i) : Boolean;');
 CL.AddDelphiFunction('Function VectorEquals12( const V1, V2 : TVector4d) : Boolean;');
 CL.AddDelphiFunction('Function VectorEquals13( const V1, V2 : TVector4s) : Boolean;');
 CL.AddDelphiFunction('Function VectorEquals14( const V1, V2 : TVector4b) : Boolean;');
 CL.AddDelphiFunction('Function MatrixEquals2( const Matrix1, Matrix2 : TMatrix3f) : Boolean;');
 CL.AddDelphiFunction('Function MatrixEquals3( const Matrix1, Matrix2 : TMatrix3i) : Boolean;');
 CL.AddDelphiFunction('Function MatrixEquals4( const Matrix1, Matrix2 : TMatrix3d) : Boolean;');
 CL.AddDelphiFunction('Function MatrixEquals5( const Matrix1, Matrix2 : TMatrix3s) : Boolean;');
 CL.AddDelphiFunction('Function MatrixEquals6( const Matrix1, Matrix2 : TMatrix3b) : Boolean;');
 CL.AddDelphiFunction('Function MatrixEquals7( const Matrix1, Matrix2 : TMatrix4f) : Boolean;');
 CL.AddDelphiFunction('Function MatrixEquals8( const Matrix1, Matrix2 : TMatrix4i) : Boolean;');
 CL.AddDelphiFunction('Function MatrixEquals( const Matrix1, Matrix2 : TMatrix4d) : Boolean;');
 CL.AddDelphiFunction('Function MatrixEquals9( const Matrix1, Matrix2 : TMatrix4s) : Boolean;');
 CL.AddDelphiFunction('Function MatrixEquals10( const Matrix1, Matrix2 : TMatrix4b) : Boolean;');
 CL.AddDelphiFunction('Function Vector2fMake2( const X, Y : Single) : TVector2f;');
 CL.AddDelphiFunction('Function Vector2iMake3( const X, Y : Longint) : TVector2i;');
 CL.AddDelphiFunction('Function Vector2sMake4( const X, Y : Smallint) : TVector2s;');
 CL.AddDelphiFunction('Function Vector2dMake5( const X, Y : Double) : TVector2d;');
 CL.AddDelphiFunction('Function Vector2bMake6( const X, Y : Byte) : TVector2b;');
 CL.AddDelphiFunction('Function Vector2fMake7( const Vector : TVector3f) : TVector2f;');
 CL.AddDelphiFunction('Function Vector2iMake8( const Vector : TVector3i) : TVector2i;');
 CL.AddDelphiFunction('Function Vector2sMake9( const Vector : TVector3s) : TVector2s;');
 CL.AddDelphiFunction('Function Vector2dMake10( const Vector : TVector3d) : TVector2d;');
 CL.AddDelphiFunction('Function Vector2bMake( const Vector : TVector3b) : TVector2b;');
 CL.AddDelphiFunction('Function Vector2fMake( const Vector : TVector4f) : TVector2f;');
 CL.AddDelphiFunction('Function Vector2iMake( const Vector : TVector4i) : TVector2i;');
 CL.AddDelphiFunction('Function Vector2sMake( const Vector : TVector4s) : TVector2s;');
 CL.AddDelphiFunction('Function Vector2dMake( const Vector : TVector4d) : TVector2d;');
 CL.AddDelphiFunction('Function Vector2bMake( const Vector : TVector4b) : TVector2b;');
 CL.AddDelphiFunction('Function Vector3fMake( const X : Single; const Y : Single; const Z : Single) : TVector3f;');
 CL.AddDelphiFunction('Function Vector3iMake( const X : Longint; const Y : Longint; const Z : Longint) : TVector3i;');
 CL.AddDelphiFunction('Function Vector3sMake( const X : Smallint; const Y : Smallint; const Z : Smallint) : TVector3s;');
 CL.AddDelphiFunction('Function Vector3dMake( const X : Double; const Y : Double; const Z : Double) : TVector3d;');
 CL.AddDelphiFunction('Function Vector3bMake( const X : Byte; const Y : Byte; const Z : Byte) : TVector3b;');
 CL.AddDelphiFunction('Function Vector3fMake( const Vector : TVector2f; const Z : Single) : TVector3f;');
 CL.AddDelphiFunction('Function Vector3iMake( const Vector : TVector2i; const Z : Longint) : TVector3i;');
 CL.AddDelphiFunction('Function Vector3sMake( const Vector : TVector2s; const Z : Smallint) : TVector3s;');
 CL.AddDelphiFunction('Function Vector3dMake( const Vector : TVector2d; const Z : Double) : TVector3d;');
 CL.AddDelphiFunction('Function Vector3bMake( const Vector : TVector2b; const Z : Byte) : TVector3b;');
 CL.AddDelphiFunction('Function Vector3fMake( const Vector : TVector4f) : TVector3f;');
 CL.AddDelphiFunction('Function Vector3iMake( const Vector : TVector4i) : TVector3i;');
 CL.AddDelphiFunction('Function Vector3sMake( const Vector : TVector4s) : TVector3s;');
 CL.AddDelphiFunction('Function Vector3dMake( const Vector : TVector4d) : TVector3d;');
 CL.AddDelphiFunction('Function Vector3bMake( const Vector : TVector4b) : TVector3b;');
 CL.AddDelphiFunction('Function Vector4fMake( const X : Single; const Y : Single; const Z : Single; const W : Single) : TVector4f;');
 CL.AddDelphiFunction('Function Vector4iMake( const X : Longint; const Y : Longint; const Z : Longint; const W : Longint) : TVector4i;');
 CL.AddDelphiFunction('Function Vector4sMake( const X : Smallint; const Y : Smallint; const Z : Smallint; const W : Smallint) : TVector4s;');
 CL.AddDelphiFunction('Function Vector4dMake( const X : Double; const Y : Double; const Z : Double; const W : Double) : TVector4d;');
 CL.AddDelphiFunction('Function Vector4bMake( const X : Byte; const Y : Byte; const Z : Byte; const W : Byte) : TVector4b;');
 CL.AddDelphiFunction('Function Vector4fMake( const Vector : TVector3f; const W : Single) : TVector4f;');
 CL.AddDelphiFunction('Function Vector4iMake( const Vector : TVector3i; const W : Longint) : TVector4i;');
 CL.AddDelphiFunction('Function Vector4sMake( const Vector : TVector3s; const W : Smallint) : TVector4s;');
 CL.AddDelphiFunction('Function Vector4dMake( const Vector : TVector3d; const W : Double) : TVector4d;');
 CL.AddDelphiFunction('Function Vector4bMake( const Vector : TVector3b; const W : Byte) : TVector4b;');
 CL.AddDelphiFunction('Function Vector4fMake( const Vector : TVector2f; const Z : Single; const W : Single) : TVector4f;');
 CL.AddDelphiFunction('Function Vector4iMake( const Vector : TVector2i; const Z : Longint; const W : Longint) : TVector4i;');
 CL.AddDelphiFunction('Function Vector4sMake( const Vector : TVector2s; const Z : Smallint; const W : Smallint) : TVector4s;');
 CL.AddDelphiFunction('Function Vector4dMake( const Vector : TVector2d; const Z : Double; const W : Double) : TVector4d;');
 CL.AddDelphiFunction('Function Vector4bMake( const Vector : TVector2b; const Z : Byte; const W : Byte) : TVector4b;');
 CL.AddDelphiFunction('Function VectorMoreThen( const SourceVector, ComparedVector : TVector3f) : Boolean;');
 CL.AddDelphiFunction('Function VectorMoreEqualThen( const SourceVector, ComparedVector : TVector3f) : Boolean;');
 CL.AddDelphiFunction('Function VectorLessThen( const SourceVector, ComparedVector : TVector3f) : Boolean;');
 CL.AddDelphiFunction('Function VectorLessEqualThen( const SourceVector, ComparedVector : TVector3f) : Boolean;');
 CL.AddDelphiFunction('Function VectorMoreThen( const SourceVector, ComparedVector : TVector4f) : Boolean;');
 CL.AddDelphiFunction('Function VectorMoreEqualThen( const SourceVector, ComparedVector : TVector4f) : Boolean;');
 CL.AddDelphiFunction('Function VectorLessThen( const SourceVector, ComparedVector : TVector4f) : Boolean;');
 CL.AddDelphiFunction('Function VectorLessEqualThen( const SourceVector, ComparedVector : TVector4f) : Boolean;');
 CL.AddDelphiFunction('Function VectorMoreThen( const SourceVector, ComparedVector : TVector3i) : Boolean;');
 CL.AddDelphiFunction('Function VectorMoreEqualThen( const SourceVector, ComparedVector : TVector3i) : Boolean;');
 CL.AddDelphiFunction('Function VectorLessThen( const SourceVector, ComparedVector : TVector3i) : Boolean;');
 CL.AddDelphiFunction('Function VectorLessEqualThen( const SourceVector, ComparedVector : TVector3i) : Boolean;');
 CL.AddDelphiFunction('Function VectorMoreThen( const SourceVector, ComparedVector : TVector4i) : Boolean;');
 CL.AddDelphiFunction('Function VectorMoreEqualThen( const SourceVector, ComparedVector : TVector4i) : Boolean;');
 CL.AddDelphiFunction('Function VectorLessThen( const SourceVector, ComparedVector : TVector4i) : Boolean;');
 CL.AddDelphiFunction('Function VectorLessEqualThen( const SourceVector, ComparedVector : TVector4i) : Boolean;');
 CL.AddDelphiFunction('Function VectorMoreThen( const SourceVector, ComparedVector : TVector3s) : Boolean;');
 CL.AddDelphiFunction('Function VectorMoreEqualThen( const SourceVector, ComparedVector : TVector3s) : Boolean;');
 CL.AddDelphiFunction('Function VectorLessThen( const SourceVector, ComparedVector : TVector3s) : Boolean;');
 CL.AddDelphiFunction('Function VectorLessEqualThen( const SourceVector, ComparedVector : TVector3s) : Boolean;');
 CL.AddDelphiFunction('Function VectorMoreThen( const SourceVector, ComparedVector : TVector4s) : Boolean;');
 CL.AddDelphiFunction('Function VectorMoreEqualThen( const SourceVector, ComparedVector : TVector4s) : Boolean;');
 CL.AddDelphiFunction('Function VectorLessThen( const SourceVector, ComparedVector : TVector4s) : Boolean;');
 CL.AddDelphiFunction('Function VectorLessEqualThen( const SourceVector, ComparedVector : TVector4s) : Boolean;');
 CL.AddDelphiFunction('Function VectorMoreThen( const SourceVector : TVector3f; const ComparedNumber : Single) : Boolean;');
 CL.AddDelphiFunction('Function VectorMoreEqualThen( const SourceVector : TVector3f; const ComparedNumber : Single) : Boolean;');
 CL.AddDelphiFunction('Function VectorLessThen( const SourceVector : TVector3f; const ComparedNumber : Single) : Boolean;');
 CL.AddDelphiFunction('Function VectorLessEqualThen( const SourceVector : TVector3f; const ComparedNumber : Single) : Boolean;');
 CL.AddDelphiFunction('Function VectorMoreThen( const SourceVector : TVector4f; const ComparedNumber : Single) : Boolean;');
 CL.AddDelphiFunction('Function VectorMoreEqualThen( const SourceVector : TVector4f; const ComparedNumber : Single) : Boolean;');
 CL.AddDelphiFunction('Function VectorLessThen( const SourceVector : TVector4f; const ComparedNumber : Single) : Boolean;');
 CL.AddDelphiFunction('Function VectorLessEqualThen( const SourceVector : TVector4f; const ComparedNumber : Single) : Boolean;');
 CL.AddDelphiFunction('Function VectorMoreThen( const SourceVector : TVector3i; const ComparedNumber : Single) : Boolean;');
 CL.AddDelphiFunction('Function VectorMoreEqualThen( const SourceVector : TVector3i; const ComparedNumber : Single) : Boolean;');
 CL.AddDelphiFunction('Function VectorLessThen( const SourceVector : TVector3i; const ComparedNumber : Single) : Boolean;');
 CL.AddDelphiFunction('Function VectorLessEqualThen( const SourceVector : TVector3i; const ComparedNumber : Single) : Boolean;');
 CL.AddDelphiFunction('Function VectorMoreThen( const SourceVector : TVector4i; const ComparedNumber : Single) : Boolean;');
 CL.AddDelphiFunction('Function VectorMoreEqualThen( const SourceVector : TVector4i; const ComparedNumber : Single) : Boolean;');
 CL.AddDelphiFunction('Function VectorLessThen( const SourceVector : TVector4i; const ComparedNumber : Single) : Boolean;');
 CL.AddDelphiFunction('Function VectorLessEqualThen( const SourceVector : TVector4i; const ComparedNumber : Single) : Boolean;');
 CL.AddDelphiFunction('Function VectorMoreThen( const SourceVector : TVector3s; const ComparedNumber : Single) : Boolean;');
 CL.AddDelphiFunction('Function VectorMoreEqualThen( const SourceVector : TVector3s; const ComparedNumber : Single) : Boolean;');
 CL.AddDelphiFunction('Function VectorLessThen( const SourceVector : TVector3s; const ComparedNumber : Single) : Boolean;');
 CL.AddDelphiFunction('Function VectorLessEqualThen( const SourceVector : TVector3s; const ComparedNumber : Single) : Boolean;');
 CL.AddDelphiFunction('Function VectorMoreThen( const SourceVector : TVector4s; const ComparedNumber : Single) : Boolean;');
 CL.AddDelphiFunction('Function VectorMoreEqualThen( const SourceVector : TVector4s; const ComparedNumber : Single) : Boolean;');
 CL.AddDelphiFunction('Function VectorLessThen( const SourceVector : TVector4s; const ComparedNumber : Single) : Boolean;');
 CL.AddDelphiFunction('Function VectorLessEqualThen( const SourceVector : TVector4s; const ComparedNumber : Single) : Boolean;');
 CL.AddDelphiFunction('Function VectorAdd( const v1, v2 : TAffineVector) : TAffineVector;');
 CL.AddDelphiFunction('Procedure VectorAdd( const v1, v2 : TAffineVector; var vr : TAffineVector);');
 CL.AddDelphiFunction('Procedure VectorAdd( const v1, v2 : TAffineVector; vr : PAffineVector);');
 CL.AddDelphiFunction('Function VectorAdd( const v1, v2 : TVector) : TVector;');
 CL.AddDelphiFunction('Procedure VectorAdd( const v1, v2 : TVector; var vr : TVector);');
 CL.AddDelphiFunction('Function VectorAdd( const v : TAffineVector; const f : Single) : TAffineVector;');
 CL.AddDelphiFunction('Function VectorAdd( const v : TVector; const f : Single) : TVector;');
 CL.AddDelphiFunction('Procedure AddVector( var v1 : TAffineVector; const v2 : TAffineVector);');
 CL.AddDelphiFunction('Procedure AddVector( var v1 : TAffineVector; const v2 : TVector);');
 CL.AddDelphiFunction('Procedure AddVector( var v1 : TVector; const v2 : TVector);');
 CL.AddDelphiFunction('Procedure AddVector( var v : TAffineVector; const f : Single);');
 CL.AddDelphiFunction('Procedure AddVector( var v : TVector; const f : Single);');
 CL.AddDelphiFunction('Procedure TexPointArrayAdd( const src : PTexPointArray; const delta : TTexPoint; const nb : Integer; dest : PTexPointArray);');
 CL.AddDelphiFunction('Procedure TexPointArrayScaleAndAdd( const src : PTexPointArray; const delta : TTexPoint; const nb : Integer; const scale : TTexPoint; dest : PTexPointArray);');
 CL.AddDelphiFunction('Procedure VectorArrayAdd( const src : PAffineVectorArray; const delta : TAffineVector; const nb : Integer; dest : PAffineVectorArray);');
 CL.AddDelphiFunction('Function VectorSubtract( const V1, V2 : TAffineVector) : TAffineVector;');
 CL.AddDelphiFunction('Procedure VectorSubtract( const v1, v2 : TAffineVector; var result : TAffineVector);');
 CL.AddDelphiFunction('Procedure VectorSubtract( const v1, v2 : TAffineVector; var result : TVector);');
 CL.AddDelphiFunction('Procedure VectorSubtract( const v1 : TVector; v2 : TAffineVector; var result : TVector);');
 CL.AddDelphiFunction('Function VectorSubtract( const V1, V2 : TVector) : TVector;');
 CL.AddDelphiFunction('Procedure VectorSubtract( const v1, v2 : TVector; var result : TVector);');
 CL.AddDelphiFunction('Procedure VectorSubtract( const v1, v2 : TVector; var result : TAffineVector);');
 CL.AddDelphiFunction('Function VectorSubtract( const v1 : TAffineVector; delta : Single) : TAffineVector;');
 CL.AddDelphiFunction('Function VectorSubtract( const v1 : TVector; delta : Single) : TVector;');
 CL.AddDelphiFunction('Procedure SubtractVector( var V1 : TAffineVector; const V2 : TAffineVector);');
 CL.AddDelphiFunction('Procedure SubtractVector( var V1 : TVector; const V2 : TVector);');
 CL.AddDelphiFunction('Procedure CombineVector( var vr : TAffineVector; const v : TAffineVector; var f : Single);');
 CL.AddDelphiFunction('Procedure CombineVector( var vr : TAffineVector; const v : TAffineVector; pf : PFloat);');
 CL.AddDelphiFunction('Function TexPointCombine( const t1, t2 : TTexPoint; f1, f2 : Single) : TTexPoint');
 CL.AddDelphiFunction('Function VectorCombine( const V1, V2 : TAffineVector; const F1, F2 : Single) : TAffineVector;');
 CL.AddDelphiFunction('Function VectorCombine3( const V1, V2, V3 : TAffineVector; const F1, F2, F3 : Single) : TAffineVector;');
 CL.AddDelphiFunction('Procedure VectorCombine3( const V1, V2, V3 : TAffineVector; const F1, F2, F3 : Single; var vr : TAffineVector);');
 CL.AddDelphiFunction('Procedure CombineVector( var vr : TVector; const v : TVector; var f : Single);');
 CL.AddDelphiFunction('Procedure CombineVector( var vr : TVector; const v : TAffineVector; var f : Single);');
 CL.AddDelphiFunction('Function VectorCombine( const V1, V2 : TVector; const F1, F2 : Single) : TVector;');
 CL.AddDelphiFunction('Function VectorCombine( const V1 : TVector; const V2 : TAffineVector; const F1, F2 : Single) : TVector;');
 CL.AddDelphiFunction('Procedure VectorCombine( const V1 : TVector; const V2 : TAffineVector; const F1, F2 : Single; var vr : TVector);');
 CL.AddDelphiFunction('Procedure VectorCombine( const V1, V2 : TVector; const F1, F2 : Single; var vr : TVector);');
 CL.AddDelphiFunction('Procedure VectorCombine( const V1, V2 : TVector; const F2 : Single; var vr : TVector);');
 CL.AddDelphiFunction('Function VectorCombine3( const V1, V2, V3 : TVector; const F1, F2, F3 : Single) : TVector;');
 CL.AddDelphiFunction('Procedure VectorCombine3( const V1, V2, V3 : TVector; const F1, F2, F3 : Single; var vr : TVector);');
 CL.AddDelphiFunction('Function VectorDotProduct( const V1, V2 : TAffineVector) : Single;');
 CL.AddDelphiFunction('Function VectorDotProduct( const V1, V2 : TVector) : Single;');
 CL.AddDelphiFunction('Function VectorDotProduct( const V1 : TVector; const V2 : TAffineVector) : Single;');
 CL.AddDelphiFunction('Function PointProject( const p, origin, direction : TAffineVector) : Single;');
 CL.AddDelphiFunction('Function PointProject( const p, origin, direction : TVector) : Single;');
 CL.AddDelphiFunction('Function VectorCrossProduct( const V1, V2 : TAffineVector) : TAffineVector;');
 CL.AddDelphiFunction('Function VectorCrossProduct( const V1, V2 : TVector) : TVector;');
 CL.AddDelphiFunction('Procedure VectorCrossProduct( const v1, v2 : TVector; var vr : TVector);');
 CL.AddDelphiFunction('Procedure VectorCrossProduct( const v1, v2 : TAffineVector; var vr : TVector);');
 CL.AddDelphiFunction('Procedure VectorCrossProduct( const v1, v2 : TVector; var vr : TAffineVector);');
 CL.AddDelphiFunction('Procedure VectorCrossProduct( const v1, v2 : TAffineVector; var vr : TAffineVector);');
 CL.AddDelphiFunction('Function Lerp( const start, stop, t : Single) : Single');
 CL.AddDelphiFunction('Function AngleLerp( start, stop, t : Single) : Single');
 CL.AddDelphiFunction('Function MatrixLerp( const m1, m2 : TMatrix; const Delta : Single) : TMatrix');
 CL.AddDelphiFunction('Function DistanceBetweenAngles( angle1, angle2 : Single) : Single');
 CL.AddDelphiFunction('Function TexPointLerp( const t1, t2 : TTexPoint; t : Single) : TTexPoint;');
 CL.AddDelphiFunction('Function VectorLerp( const v1, v2 : TAffineVector; t : Single) : TAffineVector;');
 CL.AddDelphiFunction('Procedure VectorLerp( const v1, v2 : TAffineVector; t : Single; var vr : TAffineVector);');
 CL.AddDelphiFunction('Function VectorLerp( const v1, v2 : TVector; t : Single) : TVector;');
 CL.AddDelphiFunction('Procedure VectorLerp( const v1, v2 : TVector; t : Single; var vr : TVector);');
 CL.AddDelphiFunction('Function VectorAngleLerp( const v1, v2 : TAffineVector; t : Single) : TAffineVector;');
 CL.AddDelphiFunction('Function VectorAngleCombine( const v1, v2 : TAffineVector; f : Single) : TAffineVector;');
 CL.AddDelphiFunction('Procedure VectorArrayLerp( const src1, src2 : PVectorArray; t : Single; n : Integer; dest : PVectorArray);');
 CL.AddDelphiFunction('Procedure VectorArrayLerp( const src1, src2 : PAffineVectorArray; t : Single; n : Integer; dest : PAffineVectorArray);');
}
  CL.AddTypeS('TGLInterpolationType', '( itLinear, itPower, itSin, itSinAlt, it'
   +'Tan, itLn, itExp )');

 CL.AddDelphiFunction('Function InterpolatePower( const Start, Stop, Delta : Single; const DistortionDegree : Single) : Single');
 CL.AddDelphiFunction('Function InterpolateLn( const Start, Stop, Delta : Single; const DistortionDegree : Single) : Single');
 CL.AddDelphiFunction('Function InterpolateSin( const Start, Stop, Delta : Single) : Single');
 CL.AddDelphiFunction('Function InterpolateTan( const Start, Stop, Delta : Single) : Single');
 CL.AddDelphiFunction('Function InterpolateSinAlt( const Start, Stop, Delta : Single) : Single');
 CL.AddDelphiFunction('Function InterpolateCombinedFastPower( const OriginalStart, OriginalStop, OriginalCurrent : Single; const TargetStart, TargetStop : Single; const DistortionDegree : Single) : Single');
 CL.AddDelphiFunction('Function InterpolateCombinedSafe( const OriginalStart, OriginalStop, OriginalCurrent : Single; const TargetStart, TargetStop : Single; const DistortionDegree : Single; const InterpolationType : TGLInterpolationType) : Single');
 CL.AddDelphiFunction('Function InterpolateCombinedFast( const OriginalStart, OriginalStop, OriginalCurrent : Single; const TargetStart, TargetStop : Single; const DistortionDegree : Single; const InterpolationType : TGLInterpolationType) : Single');
 CL.AddDelphiFunction('Function InterpolateCombined( const Start, Stop, Delta : Single; const DistortionDegree : Single; const InterpolationType : TGLInterpolationType) : Single');
{
 CL.AddDelphiFunction('Function VectorLength( const x, y : Single) : Single;');
 CL.AddDelphiFunction('Function VectorLength( const x, y, z : Single) : Single;');
 CL.AddDelphiFunction('Function VectorLength( const v : TAffineVector) : Single;');
 CL.AddDelphiFunction('Function VectorLength( const v : TVector) : Single;');
 CL.AddDelphiFunction('Function VectorLength( const v : array of Single) : Single;');
 CL.AddDelphiFunction('Function VectorNorm( const x, y : Single) : Single;');
 CL.AddDelphiFunction('Function VectorNorm( const v : TAffineVector) : Single;');
 CL.AddDelphiFunction('Function VectorNorm( const v : TVector) : Single;');
 CL.AddDelphiFunction('Function VectorNorm( var V : array of Single) : Single;');
 CL.AddDelphiFunction('Procedure NormalizeVector( var v : TAffineVector);');
 CL.AddDelphiFunction('Procedure NormalizeVector( var v : TVector);');
 CL.AddDelphiFunction('Function VectorNormalize( const v : TAffineVector) : TAffineVector;');
 CL.AddDelphiFunction('Function VectorNormalize( const v : TVector) : TVector;');
 CL.AddDelphiFunction('Procedure NormalizeVectorArray( list : PAffineVectorArray; n : Integer);');
 CL.AddDelphiFunction('Function VectorAngleCosine( const V1, V2 : TAffineVector) : Single');
 CL.AddDelphiFunction('Function VectorNegate( const v : TAffineVector) : TAffineVector;');
 CL.AddDelphiFunction('Function VectorNegate( const v : TVector) : TVector;');
 CL.AddDelphiFunction('Procedure NegateVector( var V : TAffineVector);');
 CL.AddDelphiFunction('Procedure NegateVector( var V : TVector);');
 CL.AddDelphiFunction('Procedure NegateVector( var V : array of Single);');
 CL.AddDelphiFunction('Procedure ScaleVector( var v : TAffineVector; factor : Single);');
 CL.AddDelphiFunction('Procedure ScaleVector( var v : TAffineVector; const factor : TAffineVector);');
 CL.AddDelphiFunction('Procedure ScaleVector( var v : TVector; factor : Single);');
 CL.AddDelphiFunction('Procedure ScaleVector( var v : TVector; const factor : TVector);');
 CL.AddDelphiFunction('Function VectorScale( const v : TAffineVector; factor : Single) : TAffineVector;');
 CL.AddDelphiFunction('Procedure VectorScale( const v : TAffineVector; factor : Single; var vr : TAffineVector);');
 CL.AddDelphiFunction('Function VectorScale( const v : TVector; factor : Single) : TVector;');
 CL.AddDelphiFunction('Procedure VectorScale( const v : TVector; factor : Single; var vr : TVector);');
 CL.AddDelphiFunction('Procedure VectorScale( const v : TVector; factor : Single; var vr : TAffineVector);');
 CL.AddDelphiFunction('Procedure DivideVector( var v : TVector; const divider : TVector);');
 CL.AddDelphiFunction('Function TexpointEquals( const p1, p2 : TTexpoint) : Boolean');
 CL.AddDelphiFunction('Function RectEquals( const Rect1, Rect2 : TRect) : Boolean');
 CL.AddDelphiFunction('Function VectorEquals( const V1, V2 : TVector) : Boolean;');
 CL.AddDelphiFunction('Function VectorEquals( const V1, V2 : TAffineVector) : Boolean;');
 CL.AddDelphiFunction('Function AffineVectorEquals( const V1, V2 : TVector) : Boolean;');
 CL.AddDelphiFunction('Function VectorIsNull( const v : TVector) : Boolean;');
 CL.AddDelphiFunction('Function VectorIsNull( const v : TAffineVector) : Boolean;');
 CL.AddDelphiFunction('Function VectorSpacing( const v1, v2 : TTexPoint) : Single;');
 CL.AddDelphiFunction('Function VectorSpacing( const v1, v2 : TAffineVector) : Single;');
 CL.AddDelphiFunction('Function VectorSpacing( const v1, v2 : TVector) : Single;');
 CL.AddDelphiFunction('Function VectorDistance( const v1, v2 : TAffineVector) : Single;');
 CL.AddDelphiFunction('Function VectorDistance( const v1, v2 : TVector) : Single;');
 CL.AddDelphiFunction('Function VectorDistance2( const v1, v2 : TAffineVector) : Single;');
 CL.AddDelphiFunction('Function VectorDistance2( const v1, v2 : TVector) : Single;');
 CL.AddDelphiFunction('Function VectorPerpendicular( const V, N : TAffineVector) : TAffineVector');
 CL.AddDelphiFunction('Function VectorReflect( const V, N : TAffineVector) : TAffineVector');
 CL.AddDelphiFunction('Procedure RotateVector( var vector : TVector; const axis : TAffineVector; angle : Single);');
 CL.AddDelphiFunction('Procedure RotateVector( var vector : TVector; const axis : TVector; angle : Single);');
 CL.AddDelphiFunction('Procedure RotateVectorAroundY( var v : TAffineVector; alpha : Single)');
 CL.AddDelphiFunction('Function VectorRotateAroundX( const v : TAffineVector; alpha : Single) : TAffineVector;');
 CL.AddDelphiFunction('Function VectorRotateAroundY( const v : TAffineVector; alpha : Single) : TAffineVector;');
 CL.AddDelphiFunction('Procedure VectorRotateAroundY( const v : TAffineVector; alpha : Single; var vr : TAffineVector);');
 CL.AddDelphiFunction('Function VectorRotateAroundZ( const v : TAffineVector; alpha : Single) : TAffineVector;');
 CL.AddDelphiFunction('Procedure AbsVector( var v : TVector);');
 CL.AddDelphiFunction('Procedure AbsVector( var v : TAffineVector);');
 CL.AddDelphiFunction('Function VectorAbs( const v : TVector) : TVector;');
 CL.AddDelphiFunction('Function VectorAbs( const v : TAffineVector) : TAffineVector;');
 CL.AddDelphiFunction('Procedure SetMatrix( var dest : THomogeneousDblMatrix; const src : TMatrix);');
 CL.AddDelphiFunction('Procedure SetMatrix( var dest : TAffineMatrix; const src : TMatrix);');
 CL.AddDelphiFunction('Procedure SetMatrix( var dest : TMatrix; const src : TAffineMatrix);');
 CL.AddDelphiFunction('Procedure SetMatrixRow( var dest : TMatrix; rowNb : Integer; const aRow : TVector);');
 CL.AddDelphiFunction('Function CreateScaleMatrix( const v : TAffineVector) : TMatrix;');
 CL.AddDelphiFunction('Function CreateScaleMatrix( const v : TVector) : TMatrix;');
 CL.AddDelphiFunction('Function CreateTranslationMatrix( const V : TAffineVector) : TMatrix;');
 CL.AddDelphiFunction('Function CreateTranslationMatrix( const V : TVector) : TMatrix;');
 CL.AddDelphiFunction('Function CreateScaleAndTranslationMatrix( const scale, offset : TVector) : TMatrix;');
 CL.AddDelphiFunction('Function CreateRotationMatrixX( const sine, cosine : Single) : TMatrix;');
 CL.AddDelphiFunction('Function CreateRotationMatrixX( const angle : Single) : TMatrix;');
 CL.AddDelphiFunction('Function CreateRotationMatrixY( const sine, cosine : Single) : TMatrix;');
 CL.AddDelphiFunction('Function CreateRotationMatrixY( const angle : Single) : TMatrix;');
 CL.AddDelphiFunction('Function CreateRotationMatrixZ( const sine, cosine : Single) : TMatrix;');
 CL.AddDelphiFunction('Function CreateRotationMatrixZ( const angle : Single) : TMatrix;');
 CL.AddDelphiFunction('Function CreateRotationMatrix( const anAxis : TAffineVector; angle : Single) : TMatrix;');
 CL.AddDelphiFunction('Function CreateRotationMatrix( const anAxis : TVector; angle : Single) : TMatrix;');
 CL.AddDelphiFunction('Function CreateAffineRotationMatrix( const anAxis : TAffineVector; angle : Single) : TAffineMatrix');
 CL.AddDelphiFunction('Function MatrixMultiply( const M1, M2 : TAffineMatrix) : TAffineMatrix;');
 CL.AddDelphiFunction('Function MatrixMultiply( const M1, M2 : TMatrix) : TMatrix;');
 CL.AddDelphiFunction('Procedure MatrixMultiply( const M1, M2 : TMatrix; var MResult : TMatrix);');
 CL.AddDelphiFunction('Function VectorTransform( const V : TVector; const M : TMatrix) : TVector;');
 CL.AddDelphiFunction('Function VectorTransform( const V : TVector; const M : TAffineMatrix) : TVector;');
 CL.AddDelphiFunction('Function VectorTransform( const V : TAffineVector; const M : TMatrix) : TAffineVector;');
 CL.AddDelphiFunction('Function VectorTransform( const V : TAffineVector; const M : TAffineMatrix) : TAffineVector;');
 CL.AddDelphiFunction('Function MatrixDeterminant( const M : TAffineMatrix) : Single;');
 CL.AddDelphiFunction('Function MatrixDeterminant( const M : TMatrix) : Single;');
 CL.AddDelphiFunction('Procedure AdjointMatrix( var M : TMatrix);');
 CL.AddDelphiFunction('Procedure AdjointMatrix( var M : TAffineMatrix);');
 CL.AddDelphiFunction('Procedure ScaleMatrix( var M : TAffineMatrix; const factor : Single);');
 CL.AddDelphiFunction('Procedure ScaleMatrix( var M : TMatrix; const factor : Single);');
 CL.AddDelphiFunction('Procedure TranslateMatrix( var M : TMatrix; const v : TAffineVector);');
 CL.AddDelphiFunction('Procedure TranslateMatrix( var M : TMatrix; const v : TVector);');
 CL.AddDelphiFunction('Procedure NormalizeMatrix( var M : TMatrix)');
 CL.AddDelphiFunction('Procedure TransposeMatrix( var M : TAffineMatrix);');
 CL.AddDelphiFunction('Procedure TransposeMatrix( var M : TMatrix);');
 CL.AddDelphiFunction('Procedure InvertMatrix( var M : TMatrix);');
 CL.AddDelphiFunction('Procedure InvertMatrix( var M : TAffineMatrix);');
 CL.AddDelphiFunction('Function AnglePreservingMatrixInvert( const mat : TMatrix) : TMatrix');
 CL.AddDelphiFunction('Function MatrixDecompose( const M : TMatrix; var Tran : TTransformations) : Boolean');
 CL.AddDelphiFunction('Function PlaneMake( const p1, p2, p3 : TAffineVector) : THmgPlane;');
 CL.AddDelphiFunction('Function PlaneMake( const p1, p2, p3 : TVector) : THmgPlane;');
 CL.AddDelphiFunction('Function PlaneMake( const point, normal : TAffineVector) : THmgPlane;');
 CL.AddDelphiFunction('Function PlaneMake( const point, normal : TVector) : THmgPlane;');
 CL.AddDelphiFunction('Procedure SetPlane( var dest : TDoubleHmgPlane; const src : THmgPlane)');
 CL.AddDelphiFunction('Procedure NormalizePlane( var plane : THmgPlane)');
 CL.AddDelphiFunction('Function PlaneEvaluatePoint( const plane : THmgPlane; const point : TAffineVector) : Single;');
 CL.AddDelphiFunction('Function PlaneEvaluatePoint( const plane : THmgPlane; const point : TVector) : Single;');
 CL.AddDelphiFunction('Function CalcPlaneNormal( const p1, p2, p3 : TAffineVector) : TAffineVector;');
 CL.AddDelphiFunction('Procedure CalcPlaneNormal( const p1, p2, p3 : TAffineVector; var vr : TAffineVector);');
 CL.AddDelphiFunction('Procedure CalcPlaneNormal( const p1, p2, p3 : TVector; var vr : TAffineVector);');
 CL.AddDelphiFunction('Function PointIsInHalfSpace( const point, planePoint, planeNormal : TVector) : Boolean;');
 CL.AddDelphiFunction('Function PointIsInHalfSpace( const point, planePoint, planeNormal : TAffineVector) : Boolean;');
 CL.AddDelphiFunction('Function PointPlaneDistance( const point, planePoint, planeNormal : TVector) : Single;');
 CL.AddDelphiFunction('Function PointPlaneDistance( const point, planePoint, planeNormal : TAffineVector) : Single;');
 CL.AddDelphiFunction('Function PointSegmentClosestPoint( const point, segmentStart, segmentStop : TAffineVector) : TAffineVector');
 CL.AddDelphiFunction('Function PointSegmentDistance( const point, segmentStart, segmentStop : TAffineVector) : single');
 CL.AddDelphiFunction('Function PointLineClosestPoint( const point, linePoint, lineDirection : TAffineVector) : TAffineVector');
 CL.AddDelphiFunction('Function PointLineDistance( const point, linePoint, lineDirection : TAffineVector) : Single');
 CL.AddDelphiFunction('Procedure SegmentSegmentClosestPoint( const S0Start, S0Stop, S1Start, S1Stop : TAffineVector; var Segment0Closest, Segment1Closest : TAffineVector)');
 CL.AddDelphiFunction('Function SegmentSegmentDistance( const S0Start, S0Stop, S1Start, S1Stop : TAffineVector) : single');
  CL.AddTypeS('TEulerOrder', '( eulXYZ, eulXZY, eulYXZ, eulYZX, eulZXY, eulZYX '
   +')');
 CL.AddDelphiFunction('Function QuaternionMake( const Imag : array of Single; Real : Single) : TQuaternion');
 CL.AddDelphiFunction('Function QuaternionConjugate( const Q : TQuaternion) : TQuaternion');
 CL.AddDelphiFunction('Function QuaternionMagnitude( const Q : TQuaternion) : Single');
 CL.AddDelphiFunction('Procedure NormalizeQuaternion( var Q : TQuaternion)');
 CL.AddDelphiFunction('Function QuaternionFromPoints( const V1, V2 : TAffineVector) : TQuaternion');
 CL.AddDelphiFunction('Procedure QuaternionToPoints( const Q : TQuaternion; var ArcFrom, ArcTo : TAffineVector)');
 CL.AddDelphiFunction('Function QuaternionFromMatrix( const mat : TMatrix) : TQuaternion');
 CL.AddDelphiFunction('Function QuaternionToMatrix( quat : TQuaternion) : TMatrix');
 CL.AddDelphiFunction('Function QuaternionToAffineMatrix( quat : TQuaternion) : TAffineMatrix');
 CL.AddDelphiFunction('Function QuaternionFromAngleAxis( const angle : Single; const axis : TAffineVector) : TQuaternion');
 CL.AddDelphiFunction('Function QuaternionFromRollPitchYaw( const r, p, y : Single) : TQuaternion');
 CL.AddDelphiFunction('Function QuaternionFromEuler( const x, y, z : Single; eulerOrder : TEulerOrder) : TQuaternion');
 CL.AddDelphiFunction('Function QuaternionMultiply( const qL, qR : TQuaternion) : TQuaternion');
 CL.AddDelphiFunction('Function QuaternionSlerp( const QStart, QEnd : TQuaternion; Spin : Integer; t : Single) : TQuaternion;');
 CL.AddDelphiFunction('Function QuaternionSlerp( const source, dest : TQuaternion; const t : Single) : TQuaternion;');
 CL.AddDelphiFunction('Function LnXP1( X : Extended) : Extended');
 CL.AddDelphiFunction('Function Log10( X : Extended) : Extended');
 CL.AddDelphiFunction('Function Log2( X : Extended) : Extended;');
 CL.AddDelphiFunction('Function Log2( X : Single) : Single;');
 CL.AddDelphiFunction('Function LogN( Base, X : Extended) : Extended');
 CL.AddDelphiFunction('Function IntPower( Base : Extended; Exponent : Integer) : Extended');
 CL.AddDelphiFunction('Function Power( const Base, Exponent : Single) : Single;');
 CL.AddDelphiFunction('Function Power( Base : Single; Exponent : Integer) : Single;');
 CL.AddDelphiFunction('Function DegToRad( const Degrees : Extended) : Extended;');
 CL.AddDelphiFunction('Function DegToRad( const Degrees : Single) : Single;');
 CL.AddDelphiFunction('Function RadToDeg( const Radians : Extended) : Extended;');
 CL.AddDelphiFunction('Function RadToDeg( const Radians : Single) : Single;');
 CL.AddDelphiFunction('Function NormalizeAngle( angle : Single) : Single');
 CL.AddDelphiFunction('Function NormalizeDegAngle( angle : Single) : Single');
 CL.AddDelphiFunction('Procedure SinCos( const Theta : Extended; var Sin, Cos : Extended);');
 CL.AddDelphiFunction('Procedure SinCos( const Theta : Double; var Sin, Cos : Double);');
 CL.AddDelphiFunction('Procedure SinCos( const Theta : Single; var Sin, Cos : Single);');
 CL.AddDelphiFunction('Procedure SinCos( const theta, radius : Double; var Sin, Cos : Extended);');
 CL.AddDelphiFunction('Procedure SinCos( const theta, radius : Double; var Sin, Cos : Double);');
 CL.AddDelphiFunction('Procedure SinCos( const theta, radius : Single; var Sin, Cos : Single);');
 CL.AddDelphiFunction('Procedure PrepareSinCosCache( var s, c : array of Single; startAngle, stopAngle : Single)');
 CL.AddDelphiFunction('Function ArcCos( const X : Extended) : Extended;');
 CL.AddDelphiFunction('Function ArcCos( const x : Single) : Single;');
 CL.AddDelphiFunction('Function ArcSin( const X : Extended) : Extended;');
 CL.AddDelphiFunction('Function ArcSin( const X : Single) : Single;');
 CL.AddDelphiFunction('Function ArcTan2( const Y, X : Extended) : Extended;');
 CL.AddDelphiFunction('Function ArcTan2( const Y, X : Single) : Single;');
 CL.AddDelphiFunction('Function FastArcTan2( y, x : Single) : Single');
 CL.AddDelphiFunction('Function Tan( const X : Extended) : Extended;');
 CL.AddDelphiFunction('Function Tan( const X : Single) : Single;');
 CL.AddDelphiFunction('Function CoTan( const X : Extended) : Extended;');
 CL.AddDelphiFunction('Function CoTan( const X : Single) : Single;');
 CL.AddDelphiFunction('Function Sinh( const x : Single) : Single;');
 CL.AddDelphiFunction('Function Sinh( const x : Double) : Double;');
 CL.AddDelphiFunction('Function Cosh( const x : Single) : Single;');
 CL.AddDelphiFunction('Function Cosh( const x : Double) : Double;');
 CL.AddDelphiFunction('Function RSqrt( v : Single) : Single');
 CL.AddDelphiFunction('Function RLength( x, y : Single) : Single');
 CL.AddDelphiFunction('Function ISqrt( i : Integer) : Integer');
 CL.AddDelphiFunction('Function ILength( x, y : Integer) : Integer;');
 CL.AddDelphiFunction('Function ILength( x, y, z : Integer) : Integer;');
 CL.AddDelphiFunction('Procedure RegisterBasedExp');
 CL.AddDelphiFunction('Procedure RandomPointOnSphere( var p : TAffineVector)');
 CL.AddDelphiFunction('Function RoundInt( v : Single) : Single;');
 CL.AddDelphiFunction('Function RoundInt( v : Extended) : Extended;');
 CL.AddDelphiFunction('Function Trunc( v : Single) : Integer;');
 CL.AddDelphiFunction('Function Trunc64( v : Extended) : Int64;');
 CL.AddDelphiFunction('Function Int( v : Single) : Single;');
 CL.AddDelphiFunction('Function Int( v : Extended) : Extended;');
 CL.AddDelphiFunction('Function Frac( v : Single) : Single;');
 CL.AddDelphiFunction('Function Frac( v : Extended) : Extended;');
 CL.AddDelphiFunction('Function Round( v : Single) : Integer;');
 CL.AddDelphiFunction('Function Round64( v : Single) : Int64;');
 CL.AddDelphiFunction('Function Round64( v : Extended) : Int64;');
 CL.AddDelphiFunction('Function Trunc( X : Extended) : Int64');
 CL.AddDelphiFunction('Function Round( X : Extended) : Int64');
 CL.AddDelphiFunction('Function Frac( X : Extended) : Extended');
 CL.AddDelphiFunction('Function Ceil( v : Single) : Integer;');
 CL.AddDelphiFunction('Function Ceil64( v : Extended) : Int64;');
 CL.AddDelphiFunction('Function Floor( v : Single) : Integer;');
 CL.AddDelphiFunction('Function Floor64( v : Extended) : Int64;');
 CL.AddDelphiFunction('Function ScaleAndRound( i : Integer; var s : Single) : Integer');
 CL.AddDelphiFunction('Function Sign( x : Single) : Integer');
 CL.AddDelphiFunction('Function IsInRange( const x, a, b : Single) : Boolean;');
 CL.AddDelphiFunction('Function IsInRange( const x, a, b : Double) : Boolean;');
 CL.AddDelphiFunction('Function IsInCube( const p, d : TAffineVector) : Boolean;');
 CL.AddDelphiFunction('Function IsInCube( const p, d : TVector) : Boolean;');
 CL.AddDelphiFunction('Function MinFloat( values : PSingleArray; nbItems : Integer) : Single;');
 CL.AddDelphiFunction('Function MinFloat( values : PDoubleArray; nbItems : Integer) : Double;');
 CL.AddDelphiFunction('Function MinFloat( values : PExtendedArray; nbItems : Integer) : Extended;');
 CL.AddDelphiFunction('Function MinFloat( const v1, v2 : Single) : Single;');
 CL.AddDelphiFunction('Function MinFloat( const v : array of Single) : Single;');
 CL.AddDelphiFunction('Function MinFloat( const v1, v2 : Extended) : Extended;');
 CL.AddDelphiFunction('Function MinFloat( const v1, v2, v3 : Single) : Single;');
 CL.AddDelphiFunction('Function MinFloat( const v1, v2, v3 : Extended) : Extended;');
 CL.AddDelphiFunction('Function MaxFloat( values : PSingleArray; nbItems : Integer) : Single;');
 CL.AddDelphiFunction('Function MaxFloat( values : PDoubleArray; nbItems : Integer) : Double;');
 CL.AddDelphiFunction('Function MaxFloat( values : PExtendedArray; nbItems : Integer) : Extended;');
 CL.AddDelphiFunction('Function MaxFloat( const v : array of Single) : Single;');
 CL.AddDelphiFunction('Function MaxFloat( const v1, v2 : Single) : Single;');
 CL.AddDelphiFunction('Function MaxFloat( const v1, v2 : Extended) : Extended;');
 CL.AddDelphiFunction('Function MaxFloat( const v1, v2, v3 : Single) : Single;');
 CL.AddDelphiFunction('Function MaxFloat( const v1, v2, v3 : Extended) : Extended;');
}
 CL.AddDelphiFunction('Function MinFloat( const v1, v2 : Double) : Double;');
 CL.AddDelphiFunction('Function MinFloat3( const v1, v2, v3 : Double) : Double;');
 CL.AddDelphiFunction('Function MaxFloat( const v1, v2 : Double) : Double;');
 CL.AddDelphiFunction('Function MaxFloat3( const v1, v2, v3 : Double) : Double;');
 CL.AddDelphiFunction('Function MinInteger( const v1, v2 : Integer) : Integer;');
 CL.AddDelphiFunction('Function MaxInteger( const v1, v2 : Integer) : Integer;');
 CL.AddDelphiFunction('Function MinCardinal( const v1, v2 : Cardinal) : Cardinal;');
 CL.AddDelphiFunction('Function MaxCardinal( const v1, v2 : Cardinal) : Cardinal;');

 CL.AddDelphiFunction('Function TriangleArea( const p1, p2, p3 : TAffineVector) : Single;');
// CL.AddDelphiFunction('Function PolygonArea( const p : PAffineVectorArray; nSides : Integer) : Single;');
 CL.AddDelphiFunction('Function TriangleSignedArea( const p1, p2, p3 : TAffineVector) : Single;');
// CL.AddDelphiFunction('Function PolygonSignedArea( const p : PAffineVectorArray; nSides : Integer) : Single;');
{
 CL.AddDelphiFunction('Procedure ScaleFloatArray( values : PSingleArray; nb : Integer; var factor : Single);');
 CL.AddDelphiFunction('Procedure ScaleFloatArray( var values : TSingleArray; factor : Single);');
 CL.AddDelphiFunction('Procedure OffsetFloatArray( values : PSingleArray; nb : Integer; var delta : Single);');
 CL.AddDelphiFunction('Procedure OffsetFloatArray( var values : array of Single; delta : Single);');
 CL.AddDelphiFunction('Procedure OffsetFloatArray( valuesDest, valuesDelta : PSingleArray; nb : Integer);');
 CL.AddDelphiFunction('Function MaxXYZComponent( const v : TVector) : Single;');
 CL.AddDelphiFunction('Function MaxXYZComponent( const v : TAffineVector) : single;');
 CL.AddDelphiFunction('Function MinXYZComponent( const v : TVector) : Single;');
 CL.AddDelphiFunction('Function MinXYZComponent( const v : TAffineVector) : single;');
 CL.AddDelphiFunction('Function MaxAbsXYZComponent( v : TVector) : Single');
 CL.AddDelphiFunction('Function MinAbsXYZComponent( v : TVector) : Single');
 CL.AddDelphiFunction('Procedure MaxVector( var v : TVector; const v1 : TVector);');
 CL.AddDelphiFunction('Procedure MaxVector( var v : TAffineVector; const v1 : TAffineVector);');
 CL.AddDelphiFunction('Procedure MinVector( var v : TVector; const v1 : TVector);');
 CL.AddDelphiFunction('Procedure MinVector( var v : TAffineVector; const v1 : TAffineVector);');
 CL.AddDelphiFunction('Procedure SortArrayAscending( var a : array of Extended)');
 CL.AddDelphiFunction('Function ClampValue( const aValue, aMin, aMax : Single) : Single;');
 CL.AddDelphiFunction('Function ClampValue( const aValue, aMin : Single) : Single;');
 CL.AddDelphiFunction('Function GeometryOptimizationMode : String');
 CL.AddDelphiFunction('Procedure BeginFPUOnlySection');
 CL.AddDelphiFunction('Procedure EndFPUOnlySection');
 CL.AddDelphiFunction('Function ConvertRotation( const Angles : TAffineVector) : TVector');
 CL.AddDelphiFunction('Function MakeAffineDblVector( var v : array of Double) : TAffineDblVector');
 CL.AddDelphiFunction('Function MakeDblVector( var v : array of Double) : THomogeneousDblVector');
 CL.AddDelphiFunction('Function VectorAffineDblToFlt( const v : TAffineDblVector) : TAffineVector');
 CL.AddDelphiFunction('Function VectorDblToFlt( const v : THomogeneousDblVector) : THomogeneousVector');
 CL.AddDelphiFunction('Function VectorAffineFltToDbl( const v : TAffineVector) : TAffineDblVector');
 CL.AddDelphiFunction('Function VectorFltToDbl( const v : TVector) : THomogeneousDblVector');
 CL.AddDelphiFunction('Function PointInPolygon( var xp, yp : array of Single; x, y : Single) : Boolean');
 CL.AddDelphiFunction('Procedure DivMod( Dividend : Integer; Divisor : Word; var Result, Remainder : Word)');
 CL.AddDelphiFunction('Function Turn( const Matrix : TMatrix; angle : Single) : TMatrix;');
 CL.AddDelphiFunction('Function Turn( const Matrix : TMatrix; const MasterUp : TAffineVector; Angle : Single) : TMatrix;');
 CL.AddDelphiFunction('Function Pitch( const Matrix : TMatrix; Angle : Single) : TMatrix;');
 CL.AddDelphiFunction('Function Pitch( const Matrix : TMatrix; const MasterRight : TAffineVector; Angle : Single) : TMatrix;');
 CL.AddDelphiFunction('Function Roll( const Matrix : TMatrix; Angle : Single) : TMatrix;');
 CL.AddDelphiFunction('Function Roll( const Matrix : TMatrix; const MasterDirection : TAffineVector; Angle : Single) : TMatrix;');
 CL.AddDelphiFunction('Function IntersectLinePlane( const point, direction : TVector; const plane : THmgPlane; intersectPoint : PVector) : Integer;');
 CL.AddDelphiFunction('Function IntersectTriangleBox( const p1, p2, p3, aMinExtent, aMaxExtent : TAffineVector) : Boolean');
 CL.AddDelphiFunction('Function IntersectSphereBox( const SpherePos : TVector; const SphereRadius : Single; const BoxMatrix : TMatrix; const BoxScale : TAffineVector; intersectPoint : PAffineVector; normal : PAffineVector; depth : PSingle) : Boolean');
 CL.AddDelphiFunction('Function RayCastPlaneIntersect( const rayStart, rayVector : TVector; const planePoint, planeNormal : TVector; intersectPoint : PVector) : Boolean;');
 CL.AddDelphiFunction('Function RayCastPlaneXZIntersect( const rayStart, rayVector : TVector; const planeY : Single; intersectPoint : PVector) : Boolean;');
 CL.AddDelphiFunction('Function RayCastTriangleIntersect( const rayStart, rayVector : TVector; const p1, p2, p3 : TAffineVector; intersectPoint : PVector; intersectNormal : PVector) : Boolean;');
 CL.AddDelphiFunction('Function RayCastMinDistToPoint( const rayStart, rayVector : TVector; const point : TVector) : Single');
 CL.AddDelphiFunction('Function RayCastIntersectsSphere( const rayStart, rayVector : TVector; const sphereCenter : TVector; const sphereRadius : Single) : Boolean;');
 CL.AddDelphiFunction('Function RayCastSphereIntersect( const rayStart, rayVector : TVector; const sphereCenter : TVector; const sphereRadius : Single; var i1, i2 : TVector) : Integer;');
 CL.AddDelphiFunction('Function RayCastBoxIntersect( const rayStart, rayVector, aMinExtent, aMaxExtent : TAffineVector; intersectPoint : PAffineVector) : Boolean');
 CL.AddDelphiFunction('Function SphereVisibleRadius( distance, radius : Single) : Single');
 CL.AddDelphiFunction('Function ExtractFrustumFromModelViewProjection( const modelViewProj : TMatrix) : TFrustum');
 CL.AddDelphiFunction('Function IsVolumeClipped( const objPos : TVector; const objRadius : Single; const rcci : TRenderContextClippingInfo) : Boolean;');
 CL.AddDelphiFunction('Function IsVolumeClipped( const objPos : TAffineVector; const objRadius : Single; const rcci : TRenderContextClippingInfo) : Boolean;');
 CL.AddDelphiFunction('Function IsVolumeClipped( const min, max : TAffineVector; const rcci : TRenderContextClippingInfo) : Boolean;');
}
 CL.AddDelphiFunction('Function IsVolumeClipped( const objPos : TAffineVector; const objRadius : Single; const Frustum : TFrustum) : Boolean;');
 CL.AddDelphiFunction('Function MakeParallelProjectionMatrix( const plane : THmgPlane; const dir : TVector) : TMatrix');
 CL.AddDelphiFunction('Function MakeShadowMatrix( const planePoint, planeNormal, lightPos : TVector) : TMatrix');
 CL.AddDelphiFunction('Function MakeReflectionMatrix( const planePoint, planeNormal : TAffineVector) : TMatrix');
 CL.AddDelphiFunction('Function PackRotationMatrix( const mat : TMatrix) : TPackedRotationMatrix');
 CL.AddDelphiFunction('Function UnPackRotationMatrix( const packedMatrix : TPackedRotationMatrix) : TMatrix');

 CL.AddConstantN('cPI','Single').setExtended( 3.141592654);
 CL.AddConstantN('cPIdiv180','Single').setExtended( 0.017453292);
 CL.AddConstantN('c180divPI','Single').setExtended( 57.29577951);
 CL.AddConstantN('c2PI','Single').setExtended( 6.283185307);
 CL.AddConstantN('cPIdiv2','Single').setExtended( 1.570796326);
 CL.AddConstantN('cPIdiv4','Single').setExtended( 0.785398163);
 CL.AddConstantN('c3PIdiv4','Single').setExtended( 2.35619449);
 CL.AddConstantN('cInv2PI','Single').setExtended( 1 / 6.283185307);
 CL.AddConstantN('cInv360','Single').setExtended( 1 / 360);
 CL.AddConstantN('c180','Single').setExtended( 180);
 CL.AddConstantN('c360','Single').setExtended( 360);
 CL.AddConstantN('cOneHalf','Single').setExtended( 0.5);
 CL.AddConstantN('cLn10','Single').setExtended( 2.302585093);
 CL.AddConstantN('MinSingle','Extended').setExtended( 1.5e-45);
 CL.AddConstantN('MaxSingle','Extended').setExtended( 3.4e+38);
 CL.AddConstantN('MinDouble','Extended').setExtended( 5.0e-324);
 CL.AddConstantN('MaxDouble','Extended').setExtended( 1.7e+308);
 CL.AddConstantN('MinExtended','Extended').setExtended( 3.4e-4932);
 CL.AddConstantN('MaxExtended','Extended').setExtended( 1.1e+4932);
 CL.AddConstantN('MinComp','Extended').setExtended( - 9.223372036854775807e+18);
 CL.AddConstantN('MaxComp','Extended').setExtended( 9.223372036854775807e+18);
end;

(* === run-time registration functions === *)

(*----------------------------------------------------------------------------*)
Function RayCastSphereIntersect_P( const rayStart, rayVector : TVector; const sphereCenter : TVector; const sphereRadius : Single; var i1, i2 : TVector) : Integer;
Begin Result := GLVectorGeometry.RayCastSphereIntersect(rayStart, rayVector, sphereCenter, sphereRadius, i1, i2); END;

(*----------------------------------------------------------------------------*)
Function RayCastIntersectsSphere_P( const rayStart, rayVector : TVector; const sphereCenter : TVector; const sphereRadius : Single) : Boolean;
Begin Result := GLVectorGeometry.RayCastIntersectsSphere(rayStart, rayVector, sphereCenter, sphereRadius); END;

(*----------------------------------------------------------------------------*)
Function RayCastTriangleIntersect_P( const rayStart, rayVector : TVector; const p1, p2, p3 : TAffineVector; intersectPoint : PVector; intersectNormal : PVector) : Boolean;
Begin Result := GLVectorGeometry.RayCastTriangleIntersect(rayStart, rayVector, p1, p2, p3, intersectPoint, intersectNormal); END;

(*----------------------------------------------------------------------------*)
Function RayCastPlaneXZIntersect_P( const rayStart, rayVector : TVector; const planeY : Single; intersectPoint : PVector) : Boolean;
Begin Result := GLVectorGeometry.RayCastPlaneXZIntersect(rayStart, rayVector, planeY, intersectPoint); END;

(*----------------------------------------------------------------------------*)
Function RayCastPlaneIntersect_P( const rayStart, rayVector : TVector; const planePoint, planeNormal : TVector; intersectPoint : PVector) : Boolean;
Begin Result := GLVectorGeometry.RayCastPlaneIntersect(rayStart, rayVector, planePoint, planeNormal, intersectPoint); END;

(*----------------------------------------------------------------------------*)
Function IntersectLinePlane_P( const point, direction : TVector; const plane : THmgPlane; intersectPoint : PVector) : Integer;
Begin Result := GLVectorGeometry.IntersectLinePlane(point, direction, plane, intersectPoint); END;
(*----------------------------------------------------------------------------*)
Procedure MaxVector_P( var v : TAffineVector; const v1 : TAffineVector);
Begin GLVectorGeometry.MaxVector(v, v1); END;

(*----------------------------------------------------------------------------*)
Function MinXYZComponent_P( const v : TAffineVector) : single;
Begin Result := GLVectorGeometry.MinXYZComponent(v); END;

(*----------------------------------------------------------------------------*)
Function MaxXYZComponent_P( const v : TAffineVector) : single;
Begin Result := GLVectorGeometry.MaxXYZComponent(v); END;

(*----------------------------------------------------------------------------*)
Procedure OffsetFloatArray_P( valuesDest, valuesDelta : PSingleArray; nb : Integer);
Begin GLVectorGeometry.OffsetFloatArray(valuesDest, valuesDelta, nb); END;

(*----------------------------------------------------------------------------*)
Procedure ScaleFloatArray_P( var values : TSingleArray; factor : Single);
Begin GLVectorGeometry.ScaleFloatArray(values, factor); END;

(*----------------------------------------------------------------------------*)
Function PolygonSignedArea_P( const p : PAffineVectorArray; nSides : Integer) : Single;
Begin Result := GLVectorGeometry.PolygonSignedArea(p, nSides); END;

(*----------------------------------------------------------------------------*)
Function TriangleSignedArea_P( const p1, p2, p3 : TAffineVector) : Single;
Begin Result := GLVectorGeometry.TriangleSignedArea(p1, p2, p3); END;

(*----------------------------------------------------------------------------*)
Function PolygonArea_P( const p : PAffineVectorArray; nSides : Integer) : Single;
Begin Result := GLVectorGeometry.PolygonArea(p, nSides); END;

(*----------------------------------------------------------------------------*)
Function TriangleArea_P( const p1, p2, p3 : TAffineVector) : Single;
Begin Result := GLVectorGeometry.TriangleArea(p1, p2, p3); END;

(*----------------------------------------------------------------------------*)
Function MaxInteger_P( const v1, v2 : Integer) : Integer;
Begin Result := GLVectorGeometry.MaxInteger(v1, v2); END;

(*-------------------_---------------------------------------------------------*)
Function MinInteger_P( const v1, v2 : Integer) : Integer;
Begin Result := GLVectorGeometry.MinInteger(v1, v2); END;
(*----------------------------------------------------------------------------*)

Function MaxCardinal_P( const v1, v2 : Cardinal) : Cardinal;
Begin Result := GLVectorGeometry.MaxInteger(v1, v2); END;

(*----------------------------------------------------------------------------*)
Function MinCardinal_P( const v1, v2 : Cardinal) : Cardinal;
Begin Result := GLVectorGeometry.MinInteger(v1, v2); END;



(*----------------------------------------------------------------------------*)
Function MaxFloat2_P( const v1, v2 : Double) : Double;
Begin Result := GLVectorGeometry.MaxFloat(v1, v2); END;

(*----------------------------------------------------------------------------*)
Function MinFloat2_P( const v1, v2 : Double) : Double;
Begin Result := GLVectorGeometry.MinFloat(v1, v2); END;

(*----------------------------------------------------------------------------*)
Function MaxFloat3_P( const v1, v2, v3 : Double) : Double;
Begin Result := GLVectorGeometry.MaxFloat(v1, v2, v3); END;

(*----------------------------------------------------------------------------*)
Function MinFloat3_P( const v1, v2, v3 : Double) : Double;
Begin Result := GLVectorGeometry.MinFloat(v1, v2, v3); END;



(*----------------------------------------------------------------------------*)
Function IsInCube_P( const p, d : TVector) : Boolean;
Begin Result := GLVectorGeometry.IsInCube(p, d); END;

Function IsInRange_P( const x, a, b : Double) : Boolean;
Begin Result := GLVectorGeometry.IsInRange(x, a, b); END;


(*----------------------------------------------------------------------------*)
Function Floor64_P( v : Extended) : Int64;
Begin Result := GLVectorGeometry.Floor64(v); END;

(*----------------------------------------------------------------------------*)
Function Floor_P( v : Single) : Integer;
Begin Result := GLVectorGeometry.Floor(v); END;

(*----------------------------------------------------------------------------*)
Function Ceil64_P( v : Extended) : Int64;
Begin Result := GLVectorGeometry.Ceil64(v); END;

(*----------------------------------------------------------------------------*)
Function Ceil_P( v : Single) : Integer;
Begin Result := GLVectorGeometry.Ceil(v); END;

(*----------------------------------------------------------------------------*)
Function Round64_P( v : Extended) : Int64;
Begin Result := GLVectorGeometry.Round64(v); END;

(*----------------------------------------------------------------------------*)
Function Round_P( v : Single) : Integer;
Begin Result := GLVectorGeometry.Round(v); END;

(*----------------------------------------------------------------------------*)
Function Frac_P( v : Extended) : Extended;
Begin Result := GLVectorGeometry.Frac(v); END;

(*----------------------------------------------------------------------------*)
Function Int_P( v : Extended) : Extended;
Begin Result := GLVectorGeometry.Int(v); END;

(*----------------------------------------------------------------------------*)
Function Trunc64_P( v : Extended) : Int64;
Begin Result := GLVectorGeometry.Trunc64(v); END;

(*----------------------------------------------------------------------------*)
Function Trunc_P( v : Single) : Integer;
Begin Result := GLVectorGeometry.Trunc(v); END;

(*----------------------------------------------------------------------------*)
Function RoundInt_P( v : Extended) : Extended;
Begin Result := GLVectorGeometry.RoundInt(v); END;

(*----------------------------------------------------------------------------*)
Function ILength_P( x, y, z : Integer) : Integer;
Begin Result := GLVectorGeometry.ILength(x, y, z); END;

(*----------------------------------------------------------------------------*)
Function Cosh_P( const x : Double) : Double;
Begin Result := GLVectorGeometry.Cosh(x); END;

(*----------------------------------------------------------------------------*)
Function Sinh_P( const x : Double) : Double;
Begin Result := GLVectorGeometry.Sinh(x); END;


(*----------------------------------------------------------------------------*)
Function CoTan_P( const X : Single) : Single;
Begin Result := GLVectorGeometry.CoTan(X); END;


(*----------------------------------------------------------------------------*)
Function Tan_P( const X : Single) : Single;
Begin Result := GLVectorGeometry.Tan(X); END;

(*----------------------------------------------------------------------------*)
Function ArcTan2_P( const Y, X : Single) : Single;
Begin Result := GLVectorGeometry.ArcTan2(Y, X); END;


Function ArcSin_P( const X : Single) : Single;
Begin Result := GLVectorGeometry.ArcSin(X); END;


(*----------------------------------------------------------------------------*)
Function ArcCos_P( const x : Single) : Single;
Begin Result := GLVectorGeometry.ArcCos(x); END;


(*----------------------------------------------------------------------------*)
Procedure SinCos_P( const theta, radius : Single; var Sin, Cos : Single);
Begin GLVectorGeometry.SinCos(theta, radius, Sin, Cos); END;

(*----------------------------------------------------------------------------*)
Function RadToDeg_P( const Radians : Single) : Single;
Begin Result := GLVectorGeometry.RadToDeg(Radians); END;

(*----------------------------------------------------------------------------*)
Function DegToRad_P( const Degrees : Single) : Single;
Begin Result := GLVectorGeometry.DegToRad(Degrees); END;

(*----------------------------------------------------------------------------*)
Function Power_P( Base : Single; Exponent : Integer) : Single;
Begin Result := GLVectorGeometry.Power(Base, Exponent); END;

(*----------------------------------------------------------------------------*)
Function Log2_P( X : Single) : Single;
Begin Result := GLVectorGeometry.Log2(X); END;


(*----------------------------------------------------------------------------*)
Function QuaternionSlerp_P( const source, dest : TQuaternion; const t : Single) : TQuaternion;
Begin Result := GLVectorGeometry.QuaternionSlerp(source, dest, t); END;

(*----------------------------------------------------------------------------*)
Function PointPlaneDistance_P( const point, planePoint, planeNormal : TAffineVector) : Single;
Begin Result := GLVectorGeometry.PointPlaneDistance(point, planePoint, planeNormal); END;

(*----------------------------------------------------------------------------*)
Function PointIsInHalfSpace_P( const point, planePoint, planeNormal : TAffineVector) : Boolean;
Begin Result := GLVectorGeometry.PointIsInHalfSpace(point, planePoint, planeNormal); END;

(*----------------------------------------------------------------------------*)
Procedure CalcPlaneNormal_P( const p1, p2, p3 : TVector; var vr : TAffineVector);
Begin GLVectorGeometry.CalcPlaneNormal(p1, p2, p3, vr); END;
(*----------------------------------------------------------------------------*)
Function PlaneEvaluatePoint_P( const plane : THmgPlane; const point : TVector) : Single;
Begin Result := GLVectorGeometry.PlaneEvaluatePoint(plane, point); END;

(*----------------------------------------------------------------------------*)
Function PlaneMake_P( const p1, p2, p3 : TAffineVector) : THmgPlane;
Begin Result := GLVectorGeometry.PlaneMake(p1, p2, p3); END;

(*----------------------------------------------------------------------------*)
Procedure InvertMatrix_P( var M : TAffineMatrix);
Begin GLVectorGeometry.InvertMatrix(M); END;

(*----------------------------------------------------------------------------*)
Procedure TransposeMatrix_P( var M : TAffineMatrix);
Begin GLVectorGeometry.TransposeMatrix(M); END;

(*----------------------------------------------------------------------------*)
Procedure TranslateMatrix_P( var M : TMatrix; const v : TVector);
Begin GLVectorGeometry.TranslateMatrix(M, v); END;

(*----------------------------------------------------------------------------*)
Procedure ScaleMatrix_P( var M : TMatrix; const factor : Single);
Begin GLVectorGeometry.ScaleMatrix(M, factor); END;

(*----------------------------------------------------------------------------*)
Procedure AdjointMatrix_P( var M : TAffineMatrix);
Begin GLVectorGeometry.AdjointMatrix(M); END;

(*----------------------------------------------------------------------------*)
Function MatrixDeterminant_P( const M : TMatrix) : Single;
Begin Result := GLVectorGeometry.MatrixDeterminant(M); END;

(*----------------------------------------------------------------------------*)
Function VectorTransform_P( const V : TAffineVector; const M : TAffineMatrix) : TAffineVector;
Begin Result := GLVectorGeometry.VectorTransform(V, M); END;

(*----------------------------------------------------------------------------*)
Function MatrixMultiply_P( const M1, M2 : TAffineMatrix) : TAffineMatrix;
Begin Result := GLVectorGeometry.MatrixMultiply(M1, M2); END;

(*----------------------------------------------------------------------------*)
Function CreateRotationMatrix_P( const anAxis : TVector; angle : Single) : TMatrix;
Begin Result := GLVectorGeometry.CreateRotationMatrix(anAxis, angle); END;

(*----------------------------------------------------------------------------*)
Procedure SetMatrix_P( var dest : THomogeneousDblMatrix; const src : TMatrix);
Begin GLVectorGeometry.SetMatrix(dest, src); END;

(*----------------------------------------------------------------------------*)
Function VectorAbs_P( const v : TAffineVector) : TAffineVector;
Begin Result := GLVectorGeometry.VectorAbs(v); END;


(*----------------------------------------------------------------------------*)
Procedure AbsVector_P( var v : TAffineVector);
Begin GLVectorGeometry.AbsVector(v); END;

(*----------------------------------------------------------------------------*)
Procedure ScaleVector_P( var v : TVector; const factor : TVector);
Begin GLVectorGeometry.ScaleVector(v, factor); END;

(*----------------------------------------------------------------------------*)
procedure RIRegister_VectorGeometry_Routines(S: TPSExec);
begin
 S.RegisterDelphiFunction(@TexPointMake, 'TexPointMake', cdRegister);
{
 S.RegisterDelphiFunction(@Vector2bMake, 'Vector2bMake', cdRegister);
 S.RegisterDelphiFunction(@Vector2fMake, 'Vector2fMake', cdRegister);
 S.RegisterDelphiFunction(@Vector2iMake, 'Vector2iMake', cdRegister);
 S.RegisterDelphiFunction(@Vector2sMake, 'Vector2sMake', cdRegister);
 S.RegisterDelphiFunction(@Vector2dMake, 'Vector2dMake', cdRegister);
 S.RegisterDelphiFunction(@Vector2bMake, 'Vector2bMake', cdRegister);
 S.RegisterDelphiFunction(@Vector3fMake, 'Vector3fMake', cdRegister);
 S.RegisterDelphiFunction(@Vector3iMake, 'Vector3iMake', cdRegister);
 S.RegisterDelphiFunction(@Vector3sMake, 'Vector3sMake', cdRegister);
 S.RegisterDelphiFunction(@Vector3dMake, 'Vector3dMake', cdRegister);
 S.RegisterDelphiFunction(@Vector3bMake, 'Vector3bMake', cdRegister);
 S.RegisterDelphiFunction(@Vector3fMake, 'Vector3fMake', cdRegister);
 S.RegisterDelphiFunction(@Vector3iMake, 'Vector3iMake', cdRegister);
 S.RegisterDelphiFunction(@Vector3sMake, 'Vector3sMake', cdRegister);
 S.RegisterDelphiFunction(@Vector3dMake, 'Vector3dMake', cdRegister);
 S.RegisterDelphiFunction(@Vector3bMake, 'Vector3bMake', cdRegister);
 S.RegisterDelphiFunction(@Vector3fMake, 'Vector3fMake', cdRegister);
 S.RegisterDelphiFunction(@Vector3iMake, 'Vector3iMake', cdRegister);
 S.RegisterDelphiFunction(@Vector3sMake, 'Vector3sMake', cdRegister);
 S.RegisterDelphiFunction(@Vector3dMake, 'Vector3dMake', cdRegister);
 S.RegisterDelphiFunction(@Vector3bMake, 'Vector3bMake', cdRegister);
 S.RegisterDelphiFunction(@Vector4fMake, 'Vector4fMake', cdRegister);
 S.RegisterDelphiFunction(@Vector4iMake, 'Vector4iMake', cdRegister);
 S.RegisterDelphiFunction(@Vector4sMake, 'Vector4sMake', cdRegister);
 S.RegisterDelphiFunction(@Vector4dMake, 'Vector4dMake', cdRegister);
 S.RegisterDelphiFunction(@Vector4bMake, 'Vector4bMake', cdRegister);
 S.RegisterDelphiFunction(@Vector4fMake, 'Vector4fMake', cdRegister);
 S.RegisterDelphiFunction(@Vector4iMake, 'Vector4iMake', cdRegister);
 S.RegisterDelphiFunction(@Vector4sMake, 'Vector4sMake', cdRegister);
 S.RegisterDelphiFunction(@Vector4dMake, 'Vector4dMake', cdRegister);
 S.RegisterDelphiFunction(@Vector4bMake, 'Vector4bMake', cdRegister);
 S.RegisterDelphiFunction(@Vector4fMake, 'Vector4fMake', cdRegister);
 S.RegisterDelphiFunction(@Vector4iMake, 'Vector4iMake', cdRegister);
 S.RegisterDelphiFunction(@Vector4sMake, 'Vector4sMake', cdRegister);
 S.RegisterDelphiFunction(@Vector4dMake, 'Vector4dMake', cdRegister);
 S.RegisterDelphiFunction(@Vector4bMake, 'Vector4bMake', cdRegister);
 S.RegisterDelphiFunction(@VectorMoreThen, 'VectorMoreThen', cdRegister);
 S.RegisterDelphiFunction(@VectorMoreEqualThen, 'VectorMoreEqualThen', cdRegister);
 S.RegisterDelphiFunction(@VectorLessThen, 'VectorLessThen', cdRegister);
 S.RegisterDelphiFunction(@VectorLessEqualThen, 'VectorLessEqualThen', cdRegister);
 S.RegisterDelphiFunction(@VectorMoreThen, 'VectorMoreThen', cdRegister);
 S.RegisterDelphiFunction(@VectorMoreEqualThen, 'VectorMoreEqualThen', cdRegister);
 S.RegisterDelphiFunction(@VectorLessThen, 'VectorLessThen', cdRegister);
 S.RegisterDelphiFunction(@VectorLessEqualThen, 'VectorLessEqualThen', cdRegister);
 S.RegisterDelphiFunction(@VectorMoreThen, 'VectorMoreThen', cdRegister);
 S.RegisterDelphiFunction(@VectorMoreEqualThen, 'VectorMoreEqualThen', cdRegister);
 S.RegisterDelphiFunction(@VectorLessThen, 'VectorLessThen', cdRegister);
 S.RegisterDelphiFunction(@VectorLessEqualThen, 'VectorLessEqualThen', cdRegister);
 S.RegisterDelphiFunction(@VectorMoreThen, 'VectorMoreThen', cdRegister);
 S.RegisterDelphiFunction(@VectorMoreEqualThen, 'VectorMoreEqualThen', cdRegister);
 S.RegisterDelphiFunction(@VectorLessThen, 'VectorLessThen', cdRegister);
 S.RegisterDelphiFunction(@VectorLessEqualThen, 'VectorLessEqualThen', cdRegister);
 S.RegisterDelphiFunction(@VectorMoreThen, 'VectorMoreThen', cdRegister);
 S.RegisterDelphiFunction(@VectorMoreEqualThen, 'VectorMoreEqualThen', cdRegister);
 S.RegisterDelphiFunction(@VectorLessThen, 'VectorLessThen', cdRegister);
 S.RegisterDelphiFunction(@VectorLessEqualThen, 'VectorLessEqualThen', cdRegister);
 S.RegisterDelphiFunction(@VectorMoreThen, 'VectorMoreThen', cdRegister);
 S.RegisterDelphiFunction(@VectorMoreEqualThen, 'VectorMoreEqualThen', cdRegister);
 S.RegisterDelphiFunction(@VectorLessThen, 'VectorLessThen', cdRegister);
 S.RegisterDelphiFunction(@VectorLessEqualThen, 'VectorLessEqualThen', cdRegister);
 S.RegisterDelphiFunction(@VectorMoreThen, 'VectorMoreThen', cdRegister);
 S.RegisterDelphiFunction(@VectorMoreEqualThen, 'VectorMoreEqualThen', cdRegister);
 S.RegisterDelphiFunction(@VectorLessThen, 'VectorLessThen', cdRegister);
 S.RegisterDelphiFunction(@VectorLessEqualThen, 'VectorLessEqualThen', cdRegister);
 S.RegisterDelphiFunction(@VectorMoreThen, 'VectorMoreThen', cdRegister);
 S.RegisterDelphiFunction(@VectorMoreEqualThen, 'VectorMoreEqualThen', cdRegister);
 S.RegisterDelphiFunction(@VectorLessThen, 'VectorLessThen', cdRegister);
 S.RegisterDelphiFunction(@VectorLessEqualThen, 'VectorLessEqualThen', cdRegister);
 S.RegisterDelphiFunction(@VectorMoreThen, 'VectorMoreThen', cdRegister);
 S.RegisterDelphiFunction(@VectorMoreEqualThen, 'VectorMoreEqualThen', cdRegister);
 S.RegisterDelphiFunction(@VectorLessThen, 'VectorLessThen', cdRegister);
 S.RegisterDelphiFunction(@VectorLessEqualThen, 'VectorLessEqualThen', cdRegister);
 S.RegisterDelphiFunction(@VectorMoreThen, 'VectorMoreThen', cdRegister);
 S.RegisterDelphiFunction(@VectorMoreEqualThen, 'VectorMoreEqualThen', cdRegister);
 S.RegisterDelphiFunction(@VectorLessThen, 'VectorLessThen', cdRegister);
 S.RegisterDelphiFunction(@VectorLessEqualThen, 'VectorLessEqualThen', cdRegister);
 S.RegisterDelphiFunction(@VectorMoreThen, 'VectorMoreThen', cdRegister);
 S.RegisterDelphiFunction(@VectorMoreEqualThen, 'VectorMoreEqualThen', cdRegister);
 S.RegisterDelphiFunction(@VectorLessThen, 'VectorLessThen', cdRegister);
 S.RegisterDelphiFunction(@VectorLessEqualThen, 'VectorLessEqualThen', cdRegister);
 S.RegisterDelphiFunction(@VectorMoreThen, 'VectorMoreThen', cdRegister);
 S.RegisterDelphiFunction(@VectorMoreEqualThen, 'VectorMoreEqualThen', cdRegister);
 S.RegisterDelphiFunction(@VectorLessThen, 'VectorLessThen', cdRegister);
 S.RegisterDelphiFunction(@VectorLessEqualThen, 'VectorLessEqualThen', cdRegister);
 S.RegisterDelphiFunction(@VectorAdd, 'VectorAdd', cdRegister);
 S.RegisterDelphiFunction(@VectorAdd, 'VectorAdd', cdRegister);
 S.RegisterDelphiFunction(@VectorAdd, 'VectorAdd', cdRegister);
 S.RegisterDelphiFunction(@VectorAdd, 'VectorAdd', cdRegister);
 S.RegisterDelphiFunction(@VectorAdd, 'VectorAdd', cdRegister);
 S.RegisterDelphiFunction(@VectorAdd, 'VectorAdd', cdRegister);
 S.RegisterDelphiFunction(@VectorAdd, 'VectorAdd', cdRegister);
 S.RegisterDelphiFunction(@AddVector, 'AddVector', cdRegister);
 S.RegisterDelphiFunction(@AddVector, 'AddVector', cdRegister);
 S.RegisterDelphiFunction(@AddVector, 'AddVector', cdRegister);
 S.RegisterDelphiFunction(@AddVector, 'AddVector', cdRegister);
 S.RegisterDelphiFunction(@AddVector, 'AddVector', cdRegister);
 S.RegisterDelphiFunction(@TexPointArrayAdd, 'TexPointArrayAdd', cdRegister);
 S.RegisterDelphiFunction(@TexPointArrayScaleAndAdd, 'TexPointArrayScaleAndAdd', cdRegister);
 S.RegisterDelphiFunction(@VectorArrayAdd, 'VectorArrayAdd', cdRegister);
 S.RegisterDelphiFunction(@VectorSubtract, 'VectorSubtract', cdRegister);
 S.RegisterDelphiFunction(@VectorSubtract, 'VectorSubtract', cdRegister);
 S.RegisterDelphiFunction(@VectorSubtract, 'VectorSubtract', cdRegister);
 S.RegisterDelphiFunction(@VectorSubtract, 'VectorSubtract', cdRegister);
 S.RegisterDelphiFunction(@VectorSubtract, 'VectorSubtract', cdRegister);
 S.RegisterDelphiFunction(@VectorSubtract, 'VectorSubtract', cdRegister);
 S.RegisterDelphiFunction(@VectorSubtract, 'VectorSubtract', cdRegister);
 S.RegisterDelphiFunction(@VectorSubtract, 'VectorSubtract', cdRegister);
 S.RegisterDelphiFunction(@VectorSubtract, 'VectorSubtract', cdRegister);
 S.RegisterDelphiFunction(@SubtractVector, 'SubtractVector', cdRegister);
 S.RegisterDelphiFunction(@SubtractVector, 'SubtractVector', cdRegister);
 S.RegisterDelphiFunction(@CombineVector, 'CombineVector', cdRegister);
 S.RegisterDelphiFunction(@CombineVector, 'CombineVector', cdRegister);
 S.RegisterDelphiFunction(@TexPointCombine, 'TexPointCombine', cdRegister);
 S.RegisterDelphiFunction(@VectorCombine, 'VectorCombine', cdRegister);
 S.RegisterDelphiFunction(@VectorCombine3, 'VectorCombine3', cdRegister);
 S.RegisterDelphiFunction(@VectorCombine3, 'VectorCombine3', cdRegister);
 S.RegisterDelphiFunction(@CombineVector, 'CombineVector', cdRegister);
 S.RegisterDelphiFunction(@CombineVector, 'CombineVector', cdRegister);
 S.RegisterDelphiFunction(@VectorCombine, 'VectorCombine', cdRegister);
 S.RegisterDelphiFunction(@VectorCombine, 'VectorCombine', cdRegister);
 S.RegisterDelphiFunction(@VectorCombine, 'VectorCombine', cdRegister);
 S.RegisterDelphiFunction(@VectorCombine, 'VectorCombine', cdRegister);
 S.RegisterDelphiFunction(@VectorCombine, 'VectorCombine', cdRegister);
 S.RegisterDelphiFunction(@VectorCombine3, 'VectorCombine3', cdRegister);
 S.RegisterDelphiFunction(@VectorCombine3, 'VectorCombine3', cdRegister);
 S.RegisterDelphiFunction(@VectorDotProduct, 'VectorDotProduct', cdRegister);
 S.RegisterDelphiFunction(@VectorDotProduct, 'VectorDotProduct', cdRegister);
 S.RegisterDelphiFunction(@VectorDotProduct, 'VectorDotProduct', cdRegister);
 S.RegisterDelphiFunction(@PointProject, 'PointProject', cdRegister);
 S.RegisterDelphiFunction(@PointProject, 'PointProject', cdRegister);
 S.RegisterDelphiFunction(@VectorCrossProduct, 'VectorCrossProduct', cdRegister);
 S.RegisterDelphiFunction(@VectorCrossProduct, 'VectorCrossProduct', cdRegister);
 S.RegisterDelphiFunction(@VectorCrossProduct, 'VectorCrossProduct', cdRegister);
 S.RegisterDelphiFunction(@VectorCrossProduct, 'VectorCrossProduct', cdRegister);
 S.RegisterDelphiFunction(@VectorCrossProduct, 'VectorCrossProduct', cdRegister);
 S.RegisterDelphiFunction(@VectorCrossProduct, 'VectorCrossProduct', cdRegister);
 S.RegisterDelphiFunction(@Lerp, 'Lerp', cdRegister);
 S.RegisterDelphiFunction(@AngleLerp, 'AngleLerp', cdRegister);
 S.RegisterDelphiFunction(@MatrixLerp, 'MatrixLerp', cdRegister);
 S.RegisterDelphiFunction(@DistanceBetweenAngles, 'DistanceBetweenAngles', cdRegister);
 S.RegisterDelphiFunction(@TexPointLerp, 'TexPointLerp', cdRegister);
 S.RegisterDelphiFunction(@VectorLerp, 'VectorLerp', cdRegister);
 S.RegisterDelphiFunction(@VectorLerp, 'VectorLerp', cdRegister);
 S.RegisterDelphiFunction(@VectorLerp, 'VectorLerp', cdRegister);
 S.RegisterDelphiFunction(@VectorLerp, 'VectorLerp', cdRegister);
 S.RegisterDelphiFunction(@VectorAngleLerp, 'VectorAngleLerp', cdRegister);
 S.RegisterDelphiFunction(@VectorAngleCombine, 'VectorAngleCombine', cdRegister);
 S.RegisterDelphiFunction(@VectorArrayLerp, 'VectorArrayLerp', cdRegister);
 S.RegisterDelphiFunction(@VectorArrayLerp, 'VectorArrayLerp', cdRegister);
}
 S.RegisterDelphiFunction(@InterpolatePower, 'InterpolatePower', cdRegister);
 S.RegisterDelphiFunction(@InterpolateLn, 'InterpolateLn', cdRegister);
 S.RegisterDelphiFunction(@InterpolateSin, 'InterpolateSin', cdRegister);
 S.RegisterDelphiFunction(@InterpolateTan, 'InterpolateTan', cdRegister);
 S.RegisterDelphiFunction(@InterpolateSinAlt, 'InterpolateSinAlt', cdRegister);
 S.RegisterDelphiFunction(@InterpolateCombinedFastPower, 'InterpolateCombinedFastPower', cdRegister);
 S.RegisterDelphiFunction(@InterpolateCombinedSafe, 'InterpolateCombinedSafe', cdRegister);
 S.RegisterDelphiFunction(@InterpolateCombinedFast, 'InterpolateCombinedFast', cdRegister);
 S.RegisterDelphiFunction(@InterpolateCombined, 'InterpolateCombined', cdRegister);
{
 S.RegisterDelphiFunction(@VectorLength, 'VectorLength', cdRegister);
 S.RegisterDelphiFunction(@VectorLength, 'VectorLength', cdRegister);
 S.RegisterDelphiFunction(@VectorLength, 'VectorLength', cdRegister);
 S.RegisterDelphiFunction(@VectorLength, 'VectorLength', cdRegister);
 S.RegisterDelphiFunction(@VectorLength, 'VectorLength', cdRegister);
 S.RegisterDelphiFunction(@VectorNorm, 'VectorNorm', cdRegister);
 S.RegisterDelphiFunction(@VectorNorm, 'VectorNorm', cdRegister);
 S.RegisterDelphiFunction(@VectorNorm, 'VectorNorm', cdRegister);
 S.RegisterDelphiFunction(@VectorNorm, 'VectorNorm', cdRegister);
 S.RegisterDelphiFunction(@NormalizeVector, 'NormalizeVector', cdRegister);
 S.RegisterDelphiFunction(@NormalizeVector, 'NormalizeVector', cdRegister);
 S.RegisterDelphiFunction(@VectorNormalize, 'VectorNormalize', cdRegister);
 S.RegisterDelphiFunction(@VectorNormalize, 'VectorNormalize', cdRegister);
 S.RegisterDelphiFunction(@NormalizeVectorArray, 'NormalizeVectorArray', cdRegister);
 S.RegisterDelphiFunction(@VectorAngleCosine, 'VectorAngleCosine', cdRegister);
 S.RegisterDelphiFunction(@VectorNegate, 'VectorNegate', cdRegister);
 S.RegisterDelphiFunction(@VectorNegate, 'VectorNegate', cdRegister);
 S.RegisterDelphiFunction(@NegateVector, 'NegateVector', cdRegister);
 S.RegisterDelphiFunction(@NegateVector, 'NegateVector', cdRegister);
 S.RegisterDelphiFunction(@NegateVector, 'NegateVector', cdRegister);
 S.RegisterDelphiFunction(@ScaleVector, 'ScaleVector', cdRegister);
 S.RegisterDelphiFunction(@ScaleVector, 'ScaleVector', cdRegister);
 S.RegisterDelphiFunction(@ScaleVector, 'ScaleVector', cdRegister);
 S.RegisterDelphiFunction(@ScaleVector, 'ScaleVector', cdRegister);
 S.RegisterDelphiFunction(@VectorScale, 'VectorScale', cdRegister);
 S.RegisterDelphiFunction(@VectorScale, 'VectorScale', cdRegister);
 S.RegisterDelphiFunction(@VectorScale, 'VectorScale', cdRegister);
 S.RegisterDelphiFunction(@VectorScale, 'VectorScale', cdRegister);
 S.RegisterDelphiFunction(@VectorScale, 'VectorScale', cdRegister);
 S.RegisterDelphiFunction(@DivideVector, 'DivideVector', cdRegister);
 S.RegisterDelphiFunction(@TexpointEquals, 'TexpointEquals', cdRegister);
 S.RegisterDelphiFunction(@RectEquals, 'RectEquals', cdRegister);
 S.RegisterDelphiFunction(@VectorEquals, 'VectorEquals', cdRegister);
 S.RegisterDelphiFunction(@VectorEquals, 'VectorEquals', cdRegister);
 S.RegisterDelphiFunction(@AffineVectorEquals, 'AffineVectorEquals', cdRegister);
 S.RegisterDelphiFunction(@VectorIsNull, 'VectorIsNull', cdRegister);
 S.RegisterDelphiFunction(@VectorIsNull, 'VectorIsNull', cdRegister);
 S.RegisterDelphiFunction(@VectorSpacing, 'VectorSpacing', cdRegister);
 S.RegisterDelphiFunction(@VectorSpacing, 'VectorSpacing', cdRegister);
 S.RegisterDelphiFunction(@VectorSpacing, 'VectorSpacing', cdRegister);
 S.RegisterDelphiFunction(@VectorDistance, 'VectorDistance', cdRegister);
 S.RegisterDelphiFunction(@VectorDistance, 'VectorDistance', cdRegister);
 S.RegisterDelphiFunction(@VectorDistance2, 'VectorDistance2', cdRegister);
 S.RegisterDelphiFunction(@VectorDistance2, 'VectorDistance2', cdRegister);
 S.RegisterDelphiFunction(@VectorPerpendicular, 'VectorPerpendicular', cdRegister);
 S.RegisterDelphiFunction(@VectorReflect, 'VectorReflect', cdRegister);
 S.RegisterDelphiFunction(@RotateVector, 'RotateVector', cdRegister);
 S.RegisterDelphiFunction(@RotateVector, 'RotateVector', cdRegister);
 S.RegisterDelphiFunction(@RotateVectorAroundY, 'RotateVectorAroundY', cdRegister);
 S.RegisterDelphiFunction(@VectorRotateAroundX, 'VectorRotateAroundX', cdRegister);
 S.RegisterDelphiFunction(@VectorRotateAroundY, 'VectorRotateAroundY', cdRegister);
 S.RegisterDelphiFunction(@VectorRotateAroundY, 'VectorRotateAroundY', cdRegister);
 S.RegisterDelphiFunction(@VectorRotateAroundZ, 'VectorRotateAroundZ', cdRegister);
 S.RegisterDelphiFunction(@AbsVector, 'AbsVector', cdRegister);
 S.RegisterDelphiFunction(@AbsVector, 'AbsVector', cdRegister);
 S.RegisterDelphiFunction(@VectorAbs, 'VectorAbs', cdRegister);
 S.RegisterDelphiFunction(@VectorAbs, 'VectorAbs', cdRegister);
 S.RegisterDelphiFunction(@SetMatrix, 'SetMatrix', cdRegister);
 S.RegisterDelphiFunction(@SetMatrix, 'SetMatrix', cdRegister);
 S.RegisterDelphiFunction(@SetMatrix, 'SetMatrix', cdRegister);
 S.RegisterDelphiFunction(@SetMatrixRow, 'SetMatrixRow', cdRegister);
 S.RegisterDelphiFunction(@CreateScaleMatrix, 'CreateScaleMatrix', cdRegister);
 S.RegisterDelphiFunction(@CreateScaleMatrix, 'CreateScaleMatrix', cdRegister);
 S.RegisterDelphiFunction(@CreateTranslationMatrix, 'CreateTranslationMatrix', cdRegister);
 S.RegisterDelphiFunction(@CreateTranslationMatrix, 'CreateTranslationMatrix', cdRegister);
 S.RegisterDelphiFunction(@CreateScaleAndTranslationMatrix, 'CreateScaleAndTranslationMatrix', cdRegister);
 S.RegisterDelphiFunction(@CreateRotationMatrixX, 'CreateRotationMatrixX', cdRegister);
 S.RegisterDelphiFunction(@CreateRotationMatrixX, 'CreateRotationMatrixX', cdRegister);
 S.RegisterDelphiFunction(@CreateRotationMatrixY, 'CreateRotationMatrixY', cdRegister);
 S.RegisterDelphiFunction(@CreateRotationMatrixY, 'CreateRotationMatrixY', cdRegister);
 S.RegisterDelphiFunction(@CreateRotationMatrixZ, 'CreateRotationMatrixZ', cdRegister);
 S.RegisterDelphiFunction(@CreateRotationMatrixZ, 'CreateRotationMatrixZ', cdRegister);
 S.RegisterDelphiFunction(@CreateRotationMatrix, 'CreateRotationMatrix', cdRegister);
 S.RegisterDelphiFunction(@CreateRotationMatrix, 'CreateRotationMatrix', cdRegister);
 S.RegisterDelphiFunction(@CreateAffineRotationMatrix, 'CreateAffineRotationMatrix', cdRegister);
 S.RegisterDelphiFunction(@MatrixMultiply, 'MatrixMultiply', cdRegister);
 S.RegisterDelphiFunction(@MatrixMultiply, 'MatrixMultiply', cdRegister);
 S.RegisterDelphiFunction(@MatrixMultiply, 'MatrixMultiply', cdRegister);
 S.RegisterDelphiFunction(@VectorTransform, 'VectorTransform', cdRegister);
 S.RegisterDelphiFunction(@VectorTransform, 'VectorTransform', cdRegister);
 S.RegisterDelphiFunction(@VectorTransform, 'VectorTransform', cdRegister);
 S.RegisterDelphiFunction(@VectorTransform, 'VectorTransform', cdRegister);
 S.RegisterDelphiFunction(@MatrixDeterminant, 'MatrixDeterminant', cdRegister);
 S.RegisterDelphiFunction(@MatrixDeterminant, 'MatrixDeterminant', cdRegister);
 S.RegisterDelphiFunction(@AdjointMatrix, 'AdjointMatrix', cdRegister);
 S.RegisterDelphiFunction(@AdjointMatrix, 'AdjointMatrix', cdRegister);
 S.RegisterDelphiFunction(@ScaleMatrix, 'ScaleMatrix', cdRegister);
 S.RegisterDelphiFunction(@ScaleMatrix, 'ScaleMatrix', cdRegister);
 S.RegisterDelphiFunction(@TranslateMatrix, 'TranslateMatrix', cdRegister);
 S.RegisterDelphiFunction(@TranslateMatrix, 'TranslateMatrix', cdRegister);
 S.RegisterDelphiFunction(@NormalizeMatrix, 'NormalizeMatrix', cdRegister);
 S.RegisterDelphiFunction(@TransposeMatrix, 'TransposeMatrix', cdRegister);
 S.RegisterDelphiFunction(@TransposeMatrix, 'TransposeMatrix', cdRegister);
 S.RegisterDelphiFunction(@InvertMatrix, 'InvertMatrix', cdRegister);
 S.RegisterDelphiFunction(@InvertMatrix, 'InvertMatrix', cdRegister);
 S.RegisterDelphiFunction(@AnglePreservingMatrixInvert, 'AnglePreservingMatrixInvert', cdRegister);
 S.RegisterDelphiFunction(@MatrixDecompose, 'MatrixDecompose', cdRegister);
 S.RegisterDelphiFunction(@PlaneMake, 'PlaneMake', cdRegister);
 S.RegisterDelphiFunction(@PlaneMake, 'PlaneMake', cdRegister);
 S.RegisterDelphiFunction(@PlaneMake, 'PlaneMake', cdRegister);
 S.RegisterDelphiFunction(@PlaneMake, 'PlaneMake', cdRegister);
 S.RegisterDelphiFunction(@SetPlane, 'SetPlane', cdRegister);
 S.RegisterDelphiFunction(@NormalizePlane, 'NormalizePlane', cdRegister);
 S.RegisterDelphiFunction(@PlaneEvaluatePoint, 'PlaneEvaluatePoint', cdRegister);
 S.RegisterDelphiFunction(@PlaneEvaluatePoint, 'PlaneEvaluatePoint', cdRegister);
 S.RegisterDelphiFunction(@CalcPlaneNormal, 'CalcPlaneNormal', cdRegister);
 S.RegisterDelphiFunction(@CalcPlaneNormal, 'CalcPlaneNormal', cdRegister);
 S.RegisterDelphiFunction(@CalcPlaneNormal, 'CalcPlaneNormal', cdRegister);
 S.RegisterDelphiFunction(@PointIsInHalfSpace, 'PointIsInHalfSpace', cdRegister);
 S.RegisterDelphiFunction(@PointIsInHalfSpace, 'PointIsInHalfSpace', cdRegister);
 S.RegisterDelphiFunction(@PointPlaneDistance, 'PointPlaneDistance', cdRegister);
 S.RegisterDelphiFunction(@PointPlaneDistance, 'PointPlaneDistance', cdRegister);
 S.RegisterDelphiFunction(@PointSegmentClosestPoint, 'PointSegmentClosestPoint', cdRegister);
 S.RegisterDelphiFunction(@PointSegmentDistance, 'PointSegmentDistance', cdRegister);
 S.RegisterDelphiFunction(@PointLineClosestPoint, 'PointLineClosestPoint', cdRegister);
 S.RegisterDelphiFunction(@PointLineDistance, 'PointLineDistance', cdRegister);
 S.RegisterDelphiFunction(@SegmentSegmentClosestPoint, 'SegmentSegmentClosestPoint', cdRegister);
 S.RegisterDelphiFunction(@SegmentSegmentDistance, 'SegmentSegmentDistance', cdRegister);
 S.RegisterDelphiFunction(@QuaternionMake, 'QuaternionMake', cdRegister);
 S.RegisterDelphiFunction(@QuaternionConjugate, 'QuaternionConjugate', cdRegister);
 S.RegisterDelphiFunction(@QuaternionMagnitude, 'QuaternionMagnitude', cdRegister);
 S.RegisterDelphiFunction(@NormalizeQuaternion, 'NormalizeQuaternion', cdRegister);
 S.RegisterDelphiFunction(@QuaternionFromPoints, 'QuaternionFromPoints', cdRegister);
 S.RegisterDelphiFunction(@QuaternionToPoints, 'QuaternionToPoints', cdRegister);
 S.RegisterDelphiFunction(@QuaternionFromMatrix, 'QuaternionFromMatrix', cdRegister);
 S.RegisterDelphiFunction(@QuaternionToMatrix, 'QuaternionToMatrix', cdRegister);
 S.RegisterDelphiFunction(@QuaternionToAffineMatrix, 'QuaternionToAffineMatrix', cdRegister);
 S.RegisterDelphiFunction(@QuaternionFromAngleAxis, 'QuaternionFromAngleAxis', cdRegister);
 S.RegisterDelphiFunction(@QuaternionFromRollPitchYaw, 'QuaternionFromRollPitchYaw', cdRegister);
 S.RegisterDelphiFunction(@QuaternionFromEuler, 'QuaternionFromEuler', cdRegister);
 S.RegisterDelphiFunction(@QuaternionMultiply, 'QuaternionMultiply', cdRegister);
 S.RegisterDelphiFunction(@QuaternionSlerp, 'QuaternionSlerp', cdRegister);
 S.RegisterDelphiFunction(@QuaternionSlerp, 'QuaternionSlerp', cdRegister);
 S.RegisterDelphiFunction(@LnXP1, 'LnXP1', cdRegister);
 S.RegisterDelphiFunction(@Log10, 'Log10', cdRegister);
 S.RegisterDelphiFunction(@Log2, 'Log2', cdRegister);
 S.RegisterDelphiFunction(@Log2, 'Log2', cdRegister);
 S.RegisterDelphiFunction(@LogN, 'LogN', cdRegister);
 S.RegisterDelphiFunction(@IntPower, 'IntPower', cdRegister);
 S.RegisterDelphiFunction(@Power, 'Power', cdRegister);
 S.RegisterDelphiFunction(@Power, 'Power', cdRegister);
 S.RegisterDelphiFunction(@DegToRad, 'DegToRad', cdRegister);
 S.RegisterDelphiFunction(@DegToRad, 'DegToRad', cdRegister);
 S.RegisterDelphiFunction(@RadToDeg, 'RadToDeg', cdRegister);
 S.RegisterDelphiFunction(@RadToDeg, 'RadToDeg', cdRegister);
 S.RegisterDelphiFunction(@NormalizeAngle, 'NormalizeAngle', cdRegister);
 S.RegisterDelphiFunction(@NormalizeDegAngle, 'NormalizeDegAngle', cdRegister);
 S.RegisterDelphiFunction(@SinCos, 'SinCos', cdRegister);
 S.RegisterDelphiFunction(@SinCos, 'SinCos', cdRegister);
 S.RegisterDelphiFunction(@SinCos, 'SinCos', cdRegister);
 S.RegisterDelphiFunction(@SinCos, 'SinCos', cdRegister);
 S.RegisterDelphiFunction(@SinCos, 'SinCos', cdRegister);
 S.RegisterDelphiFunction(@SinCos, 'SinCos', cdRegister);
 S.RegisterDelphiFunction(@PrepareSinCosCache, 'PrepareSinCosCache', cdRegister);
 S.RegisterDelphiFunction(@ArcCos, 'ArcCos', cdRegister);
 S.RegisterDelphiFunction(@ArcCos, 'ArcCos', cdRegister);
 S.RegisterDelphiFunction(@ArcSin, 'ArcSin', cdRegister);
 S.RegisterDelphiFunction(@ArcSin, 'ArcSin', cdRegister);
 S.RegisterDelphiFunction(@ArcTan2, 'ArcTan2', cdRegister);
 S.RegisterDelphiFunction(@ArcTan2, 'ArcTan2', cdRegister);
 S.RegisterDelphiFunction(@FastArcTan2, 'FastArcTan2', cdRegister);
 S.RegisterDelphiFunction(@Tan, 'Tan', cdRegister);
 S.RegisterDelphiFunction(@Tan, 'Tan', cdRegister);
 S.RegisterDelphiFunction(@CoTan, 'CoTan', cdRegister);
 S.RegisterDelphiFunction(@CoTan, 'CoTan', cdRegister);
 S.RegisterDelphiFunction(@Sinh, 'Sinh', cdRegister);
 S.RegisterDelphiFunction(@Sinh, 'Sinh', cdRegister);
 S.RegisterDelphiFunction(@Cosh, 'Cosh', cdRegister);
 S.RegisterDelphiFunction(@Cosh, 'Cosh', cdRegister);
 S.RegisterDelphiFunction(@RSqrt, 'RSqrt', cdRegister);
 S.RegisterDelphiFunction(@RLength, 'RLength', cdRegister);
 S.RegisterDelphiFunction(@ISqrt, 'ISqrt', cdRegister);
 S.RegisterDelphiFunction(@ILength, 'ILength', cdRegister);
 S.RegisterDelphiFunction(@ILength, 'ILength', cdRegister);
 S.RegisterDelphiFunction(@RegisterBasedExp, 'RegisterBasedExp', cdRegister);
 S.RegisterDelphiFunction(@RandomPointOnSphere, 'RandomPointOnSphere', cdRegister);
 S.RegisterDelphiFunction(@RoundInt, 'RoundInt', cdRegister);
 S.RegisterDelphiFunction(@RoundInt, 'RoundInt', cdRegister);
 S.RegisterDelphiFunction(@Trunc, 'Trunc', cdRegister);
 S.RegisterDelphiFunction(@Trunc64, 'Trunc64', cdRegister);
 S.RegisterDelphiFunction(@Int, 'Int', cdRegister);
 S.RegisterDelphiFunction(@Int, 'Int', cdRegister);
 S.RegisterDelphiFunction(@Frac, 'Frac', cdRegister);
 S.RegisterDelphiFunction(@Frac, 'Frac', cdRegister);
 S.RegisterDelphiFunction(@Round, 'Round', cdRegister);
 S.RegisterDelphiFunction(@Round64, 'Round64', cdRegister);
 S.RegisterDelphiFunction(@Round64, 'Round64', cdRegister);
 S.RegisterDelphiFunction(@Trunc, 'Trunc', cdRegister);
 S.RegisterDelphiFunction(@Round, 'Round', cdRegister);
 S.RegisterDelphiFunction(@Frac, 'Frac', cdRegister);
 S.RegisterDelphiFunction(@Ceil, 'Ceil', cdRegister);
 S.RegisterDelphiFunction(@Ceil64, 'Ceil64', cdRegister);
 S.RegisterDelphiFunction(@Floor, 'Floor', cdRegister);
 S.RegisterDelphiFunction(@Floor64, 'Floor64', cdRegister);
 S.RegisterDelphiFunction(@ScaleAndRound, 'ScaleAndRound', cdRegister);
 S.RegisterDelphiFunction(@Sign, 'Sign', cdRegister);
 S.RegisterDelphiFunction(@IsInRange, 'IsInRange', cdRegister);
 S.RegisterDelphiFunction(@IsInRange, 'IsInRange', cdRegister);
 S.RegisterDelphiFunction(@IsInCube, 'IsInCube', cdRegister);
 S.RegisterDelphiFunction(@IsInCube, 'IsInCube', cdRegister);
 S.RegisterDelphiFunction(@MinFloat, 'MinFloat', cdRegister);
 S.RegisterDelphiFunction(@MinFloat, 'MinFloat', cdRegister);
 S.RegisterDelphiFunction(@MinFloat, 'MinFloat', cdRegister);
 S.RegisterDelphiFunction(@MinFloat, 'MinFloat', cdRegister);
 S.RegisterDelphiFunction(@MinFloat, 'MinFloat', cdRegister);
 S.RegisterDelphiFunction(@MinFloat, 'MinFloat', cdRegister);
 S.RegisterDelphiFunction(@MinFloat, 'MinFloat', cdRegister);
 S.RegisterDelphiFunction(@MinFloat, 'MinFloat', cdRegister);
 S.RegisterDelphiFunction(@MinFloat, 'MinFloat', cdRegister);
 S.RegisterDelphiFunction(@MaxFloat, 'MaxFloat', cdRegister);
 S.RegisterDelphiFunction(@MaxFloat, 'MaxFloat', cdRegister);
 S.RegisterDelphiFunction(@MaxFloat, 'MaxFloat', cdRegister);
 S.RegisterDelphiFunction(@MaxFloat, 'MaxFloat', cdRegister);
 S.RegisterDelphiFunction(@MaxFloat, 'MaxFloat', cdRegister);
 S.RegisterDelphiFunction(@MaxFloat, 'MaxFloat', cdRegister);
 S.RegisterDelphiFunction(@MaxFloat, 'MaxFloat', cdRegister);
 S.RegisterDelphiFunction(@MaxFloat, 'MaxFloat', cdRegister);
 S.RegisterDelphiFunction(@MaxFloat, 'MaxFloat', cdRegister);
}
 S.RegisterDelphiFunction(@MinFloat2_P, 'MinFloat', cdRegister);
 S.RegisterDelphiFunction(@MaxFloat2_P, 'MaxFloat', cdRegister);
 S.RegisterDelphiFunction(@MinFloat3_P, 'MinFloat3', cdRegister);
 S.RegisterDelphiFunction(@MaxFloat3_P, 'MaxFloat3', cdRegister);
 S.RegisterDelphiFunction(@MinInteger_P, 'MinInteger', cdRegister);
 S.RegisterDelphiFunction(@MaxInteger_P, 'MaxInteger', cdRegister);
 S.RegisterDelphiFunction(@MinCardinal_P, 'MinCardinal', cdRegister);
 S.RegisterDelphiFunction(@MaxCardinal_P, 'MaxCardinal', cdRegister);

 S.RegisterDelphiFunction(@TriangleArea, 'TriangleArea', cdRegister);
// S.RegisterDelphiFunction(@PolygonArea, 'PolygonArea', cdRegister);
 S.RegisterDelphiFunction(@TriangleSignedArea, 'TriangleSignedArea', cdRegister);
// S.RegisterDelphiFunction(@PolygonSignedArea, 'PolygonSignedArea', cdRegister);
{
 S.RegisterDelphiFunction(@ScaleFloatArray, 'ScaleFloatArray', cdRegister);
 S.RegisterDelphiFunction(@ScaleFloatArray, 'ScaleFloatArray', cdRegister);
 S.RegisterDelphiFunction(@OffsetFloatArray, 'OffsetFloatArray', cdRegister);
 S.RegisterDelphiFunction(@OffsetFloatArray, 'OffsetFloatArray', cdRegister);
 S.RegisterDelphiFunction(@OffsetFloatArray, 'OffsetFloatArray', cdRegister);
 S.RegisterDelphiFunction(@MaxXYZComponent, 'MaxXYZComponent', cdRegister);
 S.RegisterDelphiFunction(@MaxXYZComponent, 'MaxXYZComponent', cdRegister);
 S.RegisterDelphiFunction(@MinXYZComponent, 'MinXYZComponent', cdRegister);
 S.RegisterDelphiFunction(@MinXYZComponent, 'MinXYZComponent', cdRegister);
 S.RegisterDelphiFunction(@MaxAbsXYZComponent, 'MaxAbsXYZComponent', cdRegister);
 S.RegisterDelphiFunction(@MinAbsXYZComponent, 'MinAbsXYZComponent', cdRegister);
 S.RegisterDelphiFunction(@MaxVector, 'MaxVector', cdRegister);
 S.RegisterDelphiFunction(@MaxVector, 'MaxVector', cdRegister);
 S.RegisterDelphiFunction(@MinVector, 'MinVector', cdRegister);
 S.RegisterDelphiFunction(@MinVector, 'MinVector', cdRegister);
 S.RegisterDelphiFunction(@SortArrayAscending, 'SortArrayAscending', cdRegister);
 S.RegisterDelphiFunction(@ClampValue, 'ClampValue', cdRegister);
 S.RegisterDelphiFunction(@ClampValue, 'ClampValue', cdRegister);
 S.RegisterDelphiFunction(@GeometryOptimizationMode, 'GeometryOptimizationMode', cdRegister);
 S.RegisterDelphiFunction(@BeginFPUOnlySection, 'BeginFPUOnlySection', cdRegister);
 S.RegisterDelphiFunction(@EndFPUOnlySection, 'EndFPUOnlySection', cdRegister);
 S.RegisterDelphiFunction(@ConvertRotation, 'ConvertRotation', cdRegister);
 S.RegisterDelphiFunction(@MakeAffineDblVector, 'MakeAffineDblVector', cdRegister);
 S.RegisterDelphiFunction(@MakeDblVector, 'MakeDblVector', cdRegister);
 S.RegisterDelphiFunction(@VectorAffineDblToFlt, 'VectorAffineDblToFlt', cdRegister);
 S.RegisterDelphiFunction(@VectorDblToFlt, 'VectorDblToFlt', cdRegister);
 S.RegisterDelphiFunction(@VectorAffineFltToDbl, 'VectorAffineFltToDbl', cdRegister);
 S.RegisterDelphiFunction(@VectorFltToDbl, 'VectorFltToDbl', cdRegister);
 S.RegisterDelphiFunction(@PointInPolygon, 'PointInPolygon', cdRegister);
 S.RegisterDelphiFunction(@DivMod, 'DivMod', cdRegister);
 S.RegisterDelphiFunction(@Turn, 'Turn', cdRegister);
 S.RegisterDelphiFunction(@Turn, 'Turn', cdRegister);
 S.RegisterDelphiFunction(@Pitch, 'Pitch', cdRegister);
 S.RegisterDelphiFunction(@Pitch, 'Pitch', cdRegister);
 S.RegisterDelphiFunction(@Roll, 'Roll', cdRegister);
 S.RegisterDelphiFunction(@Roll, 'Roll', cdRegister);
 S.RegisterDelphiFunction(@IntersectLinePlane, 'IntersectLinePlane', cdRegister);
 S.RegisterDelphiFunction(@IntersectTriangleBox, 'IntersectTriangleBox', cdRegister);
 S.RegisterDelphiFunction(@IntersectSphereBox, 'IntersectSphereBox', cdRegister);
 S.RegisterDelphiFunction(@RayCastPlaneIntersect, 'RayCastPlaneIntersect', cdRegister);
 S.RegisterDelphiFunction(@RayCastPlaneXZIntersect, 'RayCastPlaneXZIntersect', cdRegister);
 S.RegisterDelphiFunction(@RayCastTriangleIntersect, 'RayCastTriangleIntersect', cdRegister);
 S.RegisterDelphiFunction(@RayCastMinDistToPoint, 'RayCastMinDistToPoint', cdRegister);
 S.RegisterDelphiFunction(@RayCastIntersectsSphere, 'RayCastIntersectsSphere', cdRegister);
 S.RegisterDelphiFunction(@RayCastSphereIntersect, 'RayCastSphereIntersect', cdRegister);
 S.RegisterDelphiFunction(@RayCastBoxIntersect, 'RayCastBoxIntersect', cdRegister);
 S.RegisterDelphiFunction(@SphereVisibleRadius, 'SphereVisibleRadius', cdRegister);
 S.RegisterDelphiFunction(@ExtractFrustumFromModelViewProjection, 'ExtractFrustumFromModelViewProjection', cdRegister);
 S.RegisterDelphiFunction(@IsVolumeClipped, 'IsVolumeClipped', cdRegister);
 S.RegisterDelphiFunction(@IsVolumeClipped, 'IsVolumeClipped', cdRegister);
 S.RegisterDelphiFunction(@IsVolumeClipped, 'IsVolumeClipped', cdRegister);
}
 S.RegisterDelphiFunction(@IsVolumeClipped, 'IsVolumeClipped', cdRegister);
 S.RegisterDelphiFunction(@MakeParallelProjectionMatrix, 'MakeParallelProjectionMatrix', cdRegister);
 S.RegisterDelphiFunction(@MakeShadowMatrix, 'MakeShadowMatrix', cdRegister);
 S.RegisterDelphiFunction(@MakeReflectionMatrix, 'MakeReflectionMatrix', cdRegister);
 S.RegisterDelphiFunction(@PackRotationMatrix, 'PackRotationMatrix', cdRegister);
 S.RegisterDelphiFunction(@UnPackRotationMatrix, 'UnPackRotationMatrix', cdRegister);
end;

 
 
{ TPSImport_VectorGeometry }
(*----------------------------------------------------------------------------*)
procedure TPSImport_VectorGeometry.CompileImport1(CompExec: TPSScript);
begin
  SIRegister_VectorGeometry(CompExec.Comp);
end;
(*----------------------------------------------------------------------------*)
procedure TPSImport_VectorGeometry.ExecImport1(CompExec: TPSScript; const ri: TPSRuntimeClassImporter);
begin
//  RIRegister_VectorGeometry(ri);
  RIRegister_VectorGeometry_Routines(CompExec.Exec); // comment it if no routines
end;
(*----------------------------------------------------------------------------*)
 
 
end.
