oxnewtonutils.pas

Newton Game Dynamic 1.52 Delphi下基于GLScene的OpenGL游戏开发控件。功能非常强大和易于使用。 Advanced physics engine for re

begin
  V[0]:= DegToRad( V[0] );
  V[1]:= DegToRad( V[1] );
  V[2]:= DegToRad( V[2] );
  cr:= cos( V[0] );
  sr:= sin( V[0] );
  cp:= cos( V[1] );
  sp:= sin( V[1] );
  cy:= cos( V[2] );
  sy:= sin( V[2] );
  M[0,0]:= cp * cy;
  M[1,0]:= cp * sy;
  M[2,0]:= -sp;
  srsp:= sr * sp;
  crsp:= cr * sp;
  M[0,1]:= srsp * cy-cr * sy ;
  M[1,1]:= srsp * sy+cr * cy ;
  M[2,1]:= sr * cp ;
  M[0,2]:= crsp * cy+sr * sy ;
  M[1,2]:= crsp * sy-sr * cy ;
  M[2,2]:= cr * cp ;
end;
{******************************************************************************}
// [15-9-2007]: Utils last change by Dave Gravel.                            //
{******************************************************************************}
function oxVLength(const x, y : Float) : Float; overload;
begin
  Result:=Sqrt(x*x+y*y);
end;
{******************************************************************************}
// [15-9-2007]: Utils last change by Dave Gravel.                            //
{******************************************************************************}
function oxVLength(const x, y, z : Float) : Float; overload;
begin
   Result:=Sqrt(x*x+y*y+z*z);
end;
{******************************************************************************}
// [15-9-2007]: Utils last change by Dave Gravel.                            //
{******************************************************************************}
function oxVLength(const v : TOXVector3) : Float; overload;
begin
  Result:=Sqrt(oxVNorm(v));
end;
{******************************************************************************}
// [15-9-2007]: Utils last change by Dave Gravel.                            //
{******************************************************************************}
function oxVLength(const v : TOXVector4) : Float; overload;
begin
  Result:=Sqrt(oxVNorm(v));
end;
{******************************************************************************}
// [15-9-2007]: Utils last change by Dave Gravel.                            //
{******************************************************************************}
function oxVLength(const v : array of Float) : Float; overload;
var
   i : Integer;
begin
   Result:=0;
   for i:=Low(V) to High(V) do
      Result:=Result+Sqr(V[i]);
   Result:=Sqrt(Result);
end;
{******************************************************************************}
// [15-9-2007]: Utils last change by Dave Gravel.                            //
{******************************************************************************}
function oxVNormalize( const v : TOXVector3 ) : TOXVector3; overload;
var
  invLen: Float;
begin
   invLen:= RSqrt( oxVNorm( v ) );
   Result[0]:=v[0]*invLen;
   Result[1]:=v[1]*invLen;
   Result[2]:=v[2]*invLen;
end;
{******************************************************************************}
// [15-9-2007]: Utils last change by Dave Gravel.                            //
{******************************************************************************}
function oxVNormalize( const v : TOXVector4 ) : TOXVector4; overload;
var
   invLen : Float;
begin
   invLen:=RSqrt(oxVNorm(v));
   Result[0]:=v[0]*invLen;
   Result[1]:=v[1]*invLen;
   Result[2]:=v[2]*invLen;
   Result[3]:=0;
end;
{******************************************************************************}
// [15-9-2007]: Utils last change by Dave Gravel.                            //
{******************************************************************************}
procedure oxMSetTransform( var M: TOXMatrix; V: TOXVector3 );
begin
  M[3][0]:= V[0];
  M[3][1]:= V[1];
  M[3][2]:= V[2];
end;
{******************************************************************************}
// [15-9-2007]: Utils last change by Dave Gravel.                            //
{******************************************************************************}
procedure oxMSetColumn( var M: TOXMatrix; pColumn: Byte; pVect: TOXVector4 );
begin
  M[pColumn, 0]:= pVect[0];
  M[pColumn, 1]:= pVect[1];
  M[pColumn, 2]:= pVect[2];
  M[pColumn, 3]:= pVect[3];
end;
{******************************************************************************}
// [15-9-2007]: Utils last change by Dave Gravel.                            //
{******************************************************************************}
function oxMSetCompound( obj1: TGLBaseSceneObject; obj2: TGLBaseSceneObject ): TOXMatrix;
var
  mat: TOXMatrix;
begin
  mat:= oxMFToMD( obj1.AbsoluteMatrix );
  mat:= oxMMultiply( mat, oxMFToMD( obj2.InvAbsoluteMatrix ) );
  result:= mat;
end;
{******************************************************************************}
// [15-9-2007]: Utils last change by Dave Gravel.                            //
{******************************************************************************}
function oxMGrammSchmidt( const aDir : TOXVector3 ): TOXMatrix;
var
  LUp: TOXVector4;
  LRight: TOXVector4;
  LFront: TOXVector4;
Begin
  LFront := oxV4Make( aDir[0], aDir[1], aDir[2], 0 );
  LFront := oxVScale( LFront, 1.0 / sqrt( oxVDotProduct( LFront, LFront ) ) );
  if abs( LFront[2] ) > 0.577 then
    LRight:= oxVCrossProduct( LFront, oxV4Make( -LFront[1], LFront[2], 0, 0 ) )
  else
    LRight:= oxVCrossProduct( LFront, oxV4Make( -LFront[1], LFront[0], 0, 0 ) );
  LRight:= oxVScale( LRight, 1.0 / sqrt( oxVDotProduct( LRight, LRight ) ) );
  LUp:= oxVCrossProduct( LRight, LFront );
  LFront[3]:= 0;
  LUp[3]:= 0;
  LRight[3]:= 0;
  oxMSetColumn( Result, 0, LFront );
  oxMSetColumn( Result, 1, LUp );
  oxMSetColumn( Result, 2, LRight );
  oxMSetColumn( Result, 3, oxV4Make( 0, 0, 0, 1 ) );
end;
{******************************************************************************}
// [15-9-2007]: Utils last change by Dave Gravel.                            //
{******************************************************************************}
procedure oxMRotateToV( const M: TOXMatrix; var pVect: TOXVector3 );
var
 vec: TOXVector3;
begin
  vec[0]:= pVect[0] * M[0,0] + pVect[1] * M[1,0] + pVect[2] * M[2,0];
  vec[1]:= pVect[0] * M[0,1] + pVect[1] * M[1,1] + pVect[2] * M[2,1];
  vec[2]:= pVect[0] * M[0,2] + pVect[1] * M[1,2] + pVect[2] * M[2,2];
  pVect[0]:= vec[0];
  pVect[1]:= vec[1];
  pVect[2]:= vec[2];
end;
{******************************************************************************}
// [15-9-2007]: Utils last change by Dave Gravel.                            //
{******************************************************************************}
function oxMUntransformV( const M: TOXMatrix; V: TOXVector3 ): TOXVector3;
begin
  V:= oxV3Make( V[0] -M[3,0], V[1] -M[3,1], V[2] -M[3,2] );
  V:= oxV3Make( oxVDotProduct( V, oxV3Make( M[0,0], M[0,1], M[0,2] ) ),
                              oxVDotProduct( V, oxV3Make( M[1,0], M[1,1], M[1,2] ) ),
                              oxVDotProduct( V, oxV3Make( M[2,0], M[2,1], M[2,2] ) ) );
  Result:= V;
end;
{******************************************************************************}
// [15-9-2007]: Utils last change by Dave Gravel.                            //
{******************************************************************************}
function oxMTansformV( const M: TOXMatrix; V: TOXVector3 ): TOXVector3;
begin
  oxMRotateToV( M, V );
  Result:= oxV3Make( V[0] + M[3,0], V[1] + M[3,1], V[2] + M[3,2] );
end;
{******************************************************************************}
// [15-9-2007]: Utils last change by Dave Gravel.                            //
{******************************************************************************}
function oxMUnRotateV(const M : TOXMatrix; pVect : TOXVector3) : TOXVector3;
var
  V: TOXVector3;
begin
  V:= oxV3Make( oxVDotProduct( V, oxV3Make( M[0] ) ),
                              oxVDotProduct( V, oxV3Make( M[1] ) ),
                              oxVDotProduct( V, oxV3Make( M[2] ) ) );
  Result:= V;
end;
{******************************************************************************}
// [15-9-2007]: Utils last change by Dave Gravel.                            //
{******************************************************************************}
function NormalRefraction( var v: TVector3f ): single;
var l: single;
begin
  l:= sqrt( v[0] * v[0] + v[1] * v[1] + v[2] * v[2] );
  if ( l > 0 ) then begin
    v[0]:= v[0] / l;
    v[1]:= v[1] / l;
    v[2]:= v[2] / l;
  end;
  result:= l;
end;
{******************************************************************************}
// [15-9-2007]: oxVehicleLoadQ3Skin Utils last change by Dave Gravel.        //
{******************************************************************************}
procedure oxVehicleLoadQ3Skin( FileName: string; FreeForm: TGLFreeForm );
const
  ExtList: array[0..3] of string = ( '.jpg', '.jpeg', '.tga', '.bmp' );
var
  SkinStrings,
  temp: TStrings;
  i, j: integer;
  libmat: TGLLibMaterial;
  mesh: TMeshObject;
  texture,
  textureNoDir: string;
  textureFound,
  meshFound: Boolean;
  function GetMeshObjectByName( MeshObjects: TMeshObjectList; Name: string; var mesh: TMeshObject ): Boolean;
  var
    i: integer;
  begin
    Result:= False;
    if ( trim( Name ) = '' ) or not Assigned( MeshObjects ) then
      exit;
    for i:=0 to MeshObjects.Count-1 do begin
      if MeshObjects[i].Name = Name then begin
        mesh:= MeshObjects[i];
        Result:= True;
        break;
      end;
    end;
  end;
begin
  if ( not FileExists( FileName ) ) or ( not Assigned( FreeForm ) ) then exit;
  if ( not Assigned( FreeForm.MaterialLibrary ) ) then exit;
  SkinStrings:= TStringList.Create;
  temp:= TStringList.Create;
  temp.LoadFromFile( FileName );
  for i:=0 to temp.Count-1 do begin
    SkinStrings.CommaText:= temp.Strings[i];
    if SkinStrings.Count > 1 then begin
      libmat:= FreeForm.MaterialLibrary.Materials.GetLibMaterialByName( SkinStrings.Strings[1] );
      meshFound:= GetMeshObjectByName( FreeForm.MeshObjects, SkinStrings.Strings[0], mesh );
      if meshFound then begin
        if not Assigned( libmat ) then begin
          libmat:= FreeForm.MaterialLibrary.Materials.Add;
          libmat.Name:= SkinStrings.Strings[1];
          textureFound:= False;
          for j:=0 to Length( ExtList )-1 do begin
            texture:= StringReplace( SkinStrings.Strings[1],'/','\',[rfReplaceAll] );
            texture:= ChangeFileExt( texture,ExtList[j] );
            if FileExists( texture ) then begin
              libmat.Material.Texture.Image.LoadFromFile( texture );
              libmat.Material.Texture.Disabled:= False;
              textureFound:= True;
            end else begin
              textureNoDir:= ExtractFileName( texture );
              if FileExists( textureNoDir ) then begin
                libmat.Material.Texture.Image.LoadFromFile( textureNoDir );
                libmat.Material.Texture.Disabled:= False;
                textureFound:= True;
              end;
            end;
            if textureFound then break;
          end;
        end;
        for j:= 0 to mesh.FaceGroups.Count-1 do
          mesh.FaceGroups[j].MaterialName:= libmat.Name;
      end;
    end;
  end;
  temp.Free;
  SkinStrings.Free;
end;
{******************************************************************************}
// [15-9-2007]: TOXNewtonJoint Utils last change by Dave Gravel.             //
{******************************************************************************}
constructor TOXNewtonJoint.Create( AOwner: TComponent );
begin
  inherited create( AOwner );
  FJoint:= nil;
  FJointChildPin:= TGLCoordinates.CreateInitialized( Self, VectorMake( 0, 0, 1 ), csVector );
  FJointParentPin:= TGLCoordinates.CreateInitialized( Self, VectorMake( 0, 0, 1 ), csVector );
end;
{******************************************************************************}
// [15-9-2007]: TOXNewtonJoint last change by Dave Gravel.                   //
{******************************************************************************}
procedure TOXNewtonJoint.Notification(AComponent: TComponent; Operation: TOperation);
begin
   if ( Operation = opRe