oxnewtonutils.pas

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

begin
   Result[0]:=v[0]*factor;
   Result[1]:=v[1]*factor;
   Result[2]:=v[2]*factor;
   Result[3]:=v[3]*factor;
end;
{******************************************************************************}
// [15-9-2007]: Utils last change by Dave Gravel.                            //
{******************************************************************************}
function oxVScale( const v: TOXVector3; factor : Float ): TOXVector3; overload;
begin
   Result[0]:=v[0]*factor;
   Result[1]:=v[1]*factor;
   Result[2]:=v[2]*factor;
end;
{******************************************************************************}
// [15-9-2007]: Utils last change by Dave Gravel.                            //
{******************************************************************************}
function oxV3Make( const x, y, z : Float) : TOXVector3; overload;
begin
  Result[0]:=x;
  Result[1]:=y;
  Result[2]:=z;
end;
{******************************************************************************}
// [15-9-2007]: Utils last change by Dave Gravel.                            //
{******************************************************************************}
function oxVAdd( const v1, v2 : TOXVector4 ): TOXVector4;
begin
   Result[0]:=v1[0]+v2[0];
   Result[1]:=v1[1]+v2[1];
   Result[2]:=v1[2]+v2[2];
   Result[3]:=v1[3]+v2[3];
end;
{******************************************************************************}
// [15-9-2007]: Utils last change by Dave Gravel.                            //
{******************************************************************************}
function oxVAdd( const v1, v2 : TOXVector3 ) : TOXVector3;
begin
   Result[0]:=v1[0]+v2[0];
   Result[1]:=v1[1]+v2[1];
   Result[2]:=v1[2]+v2[2];
end;
{******************************************************************************}
// [15-9-2007]: Utils last change by Dave Gravel.                            //
{******************************************************************************}
function oxV3Make( const v : TOXVector4 ) : TOXVector3; overload;
begin
  Result[0]:=v[0];
  Result[1]:=v[1];
  Result[2]:=v[2];
end;
{******************************************************************************}
// [15-9-2007]: Utils last change by Dave Gravel.                            //
{******************************************************************************}
procedure oxInvertM( var M : TOXMatrix );   
var
  det: Float;
begin
  det:= oxMDeterminant( M );
  if Abs( Det ) < EPSILON then
    M:= oxIdentityM
  else begin
    oxAdjointM( M );
    oxScaleM( M, 1 / det );
  end;
end;
{******************************************************************************}
// [15-9-2007]: Utils last change by Dave Gravel.                            //
{******************************************************************************}
function oxV4Make( const x, y, z : Float; w : Float = 0 ) : TOXVector4; overload;
begin
	Result[0]:=x;
	Result[1]:=y;
	Result[2]:=z;
	Result[3]:=w;
end;
{******************************************************************************}
// [15-9-2007]: Utils last change by Dave Gravel.                            //
{******************************************************************************}
function oxV4Make(const v : TOXVector3; w : Float = 0) : TOXVector4; overload;
begin
	Result[0]:=v[0];
	Result[1]:=v[1];
	Result[2]:=v[2];
	Result[3]:=w;
end;
{******************************************************************************}
// [15-9-2007]: Utils last change by Dave Gravel.                            //
{******************************************************************************}
function oxMDeterminant( const M: TOXMatrix ): Float;
begin
  Result:= M[0, 0]*oxMDetInternal(M[1, 1], M[2, 1], M[3, 1], M[1, 2], M[2, 2], M[3, 2], M[1, 3], M[2, 3], M[3, 3])
          -M[0, 1]*oxMDetInternal(M[1, 0], M[2, 0], M[3, 0], M[1, 2], M[2, 2], M[3, 2], M[1, 3], M[2, 3], M[3, 3])
          +M[0, 2]*oxMDetInternal(M[1, 0], M[2, 0], M[3, 0], M[1, 1], M[2, 1], M[3, 1], M[1, 3], M[2, 3], M[3, 3])
          -M[0, 3]*oxMDetInternal(M[1, 0], M[2, 0], M[3, 0], M[1, 1], M[2, 1], M[3, 1], M[1, 2], M[2, 2], M[3, 2]);
end;
{******************************************************************************}
// [15-9-2007]: Utils last change by Dave Gravel.                            //
{******************************************************************************}
function oxCreateRotationM( const anAxis : TOXVector3; angle : Float ) : TOXMatrix; overload;
var
   axis : TOXVector3;
   cosine, sine, one_minus_cosine : Float;
begin
   SinCos(angle, sine, cosine);
   one_minus_cosine:=1-cosine;
   axis:=oxVNormalize(anAxis);

   Result[xX, xX]:=(one_minus_cosine * axis[0] * axis[0]) + cosine;
   Result[xX, xY]:=(one_minus_cosine * axis[0] * axis[1]) - (axis[2] * sine);
   Result[xX, xZ]:=(one_minus_cosine * axis[2] * axis[0]) + (axis[1] * sine);
   Result[xX, xW]:=0;

   Result[xY, xX]:=(one_minus_cosine * axis[0] * axis[1]) + (axis[2] * sine);
   Result[xY, xY]:=(one_minus_cosine * axis[1] * axis[1]) + cosine;
   Result[xY, xZ]:=(one_minus_cosine * axis[1] * axis[2]) - (axis[0] * sine);
   Result[xY, xW]:=0;

   Result[xZ, xX]:=(one_minus_cosine * axis[2] * axis[0]) - (axis[1] * sine);
   Result[xZ, xY]:=(one_minus_cosine * axis[1] * axis[2]) + (axis[0] * sine);
   Result[xZ, xZ]:=(one_minus_cosine * axis[2] * axis[2]) + cosine;
   Result[xZ, xW]:=0;

   Result[xW, xX]:=0;
   Result[xW, xY]:=0;
   Result[xW, xZ]:=0;
   Result[xW, xW]:=1;
end;
{******************************************************************************}
// [15-9-2007]: Utils last change by Dave Gravel.                            //
{******************************************************************************}
function oxVTransform( const V: TOXVector4; const M: TOXMatrix ): TOXVector4; overload;
begin
  Result[xX]:=V[xX] * M[xX, xX] + V[xY] * M[xY, xX] + V[xZ] * M[xZ, xX] + V[xW] * M[xW, xX];
  Result[xY]:=V[xX] * M[xX, xY] + V[xY] * M[xY, xY] + V[xZ] * M[xZ, xY] + V[xW] * M[xW, xY];
  Result[xZ]:=V[xX] * M[xX, xZ] + V[xY] * M[xY, xZ] + V[xZ] * M[xZ, xZ] + V[xW] * M[xW, xZ];
  Result[xW]:=V[xX] * M[xX, xW] + V[xY] * M[xY, xW] + V[xZ] * M[xZ, xW] + V[xW] * M[xW, xW];
end;
{******************************************************************************}
// [15-9-2007]: Utils last change by Dave Gravel.                            //
{******************************************************************************}
function oxVTransform( const V: TOXVector3; const M: TOXMatrix ): TOXVector3; overload;
begin
  Result[xX]:=V[xX] * M[xX, xX] + V[xY] * M[xY, xX] + V[xZ] * M[xZ, xX] + M[xW, xX];
  Result[xY]:=V[xX] * M[xX, xY] + V[xY] * M[xY, xY] + V[xZ] * M[xZ, xY] + M[xW, xY];
  Result[xZ]:=V[xX] * M[xX, xZ] + V[xY] * M[xY, xZ] + V[xZ] * M[xZ, xZ] + M[xW, xZ];
end;
{******************************************************************************}
// [15-9-2007]: Utils last change by Dave Gravel.                            //
{******************************************************************************}
function oxVNorm(const x, y : Float) : Float; overload;
begin
  Result:=Sqr(x)+Sqr(y);
end;
{******************************************************************************}
// [15-9-2007]: Utils last change by Dave Gravel.                            //
{******************************************************************************}
function oxVNorm(const v : TOXVector3) : Float; overload;
begin
  Result:=v[0]*v[0]+v[1]*v[1]+v[2]*v[2];
end;
{******************************************************************************}
// [15-9-2007]: Utils last change by Dave Gravel.                            //
{******************************************************************************}
function oxVNorm(const v : TOXVector4) : Float; overload;
begin
  Result:=v[0]*v[0]+v[1]*v[1]+v[2]*v[2];
end;
{******************************************************************************}
// [15-9-2007]: Utils last change by Dave Gravel.                            //
{******************************************************************************}
function oxVNorm(var V: array of Float) : Float; overload;
var
   i : Integer;
begin
   Result:=0;
   for i:=Low(v) to High(v) do
      Result:=Result+v[i]*v[i];
end;
{******************************************************************************}
// [15-9-2007]: Utils last change by Dave Gravel.                            //
{******************************************************************************}
function oxCreateRotationM( const anAxis : TOXVector4; angle : Float ) : TOXMatrix; overload;
begin
   Result:= oxCreateRotationM( POXVector3( @anAxis )^, angle );
end;
{******************************************************************************}
// [15-9-2007]: Utils last change by Dave Gravel.                            //
{******************************************************************************}
procedure oxScaleM( var M: TOXMatrix; const factor: Float );
var
   i : Integer;
begin
   for i:=0 to 3 do begin
      M[I, 0]:=M[I, 0] * Factor;
      M[I, 1]:=M[I, 1] * Factor;
      M[I, 2]:=M[I, 2] * Factor;
      M[I, 3]:=M[I, 3] * Factor;
   end;
end;
{******************************************************************************}
// [15-9-2007]: Utils last change by Dave Gravel.                            //
{******************************************************************************}
function oxMDetInternal( const a1, a2, a3, b1, b2, b3, c1, c2, c3: Float ): Float;
// internal version for the determinant of a 3x3 matrix
begin
  Result:=  a1 * (b2 * c3 - b3 * c2)
          - b1 * (a2 * c3 - a3 * c2)
          + c1 * (a2 * b3 - a3 * b2);
end;
{******************************************************************************}
// [15-9-2007]: Utils last change by Dave Gravel.                            //
{******************************************************************************}
procedure oxAdjointM( var M : TOXMatrix );
var
   a1, a2, a3, a4,
   b1, b2, b3, b4,
   c1, c2, c3, c4,
   d1, d2, d3, d4: Float;
begin
    a1:= M[0, 0]; b1:= M[0, 1];
    c1:= M[0, 2]; d1:= M[0, 3];
    a2:= M[1, 0]; b2:= M[1, 1];
    c2:= M[1, 2]; d2:= M[1, 3];
    a3:= M[2, 0]; b3:= M[2, 1];
    c3:= M[2, 2]; d3:= M[2, 3];
    a4:= M[3, 0]; b4:= M[3, 1];
    c4:= M[3, 2]; d4:= M[3, 3];

    // row column labeling reversed since we transpose rows & columns
    M[0, 0]:= oxMDetInternal(b2, b3, b4, c2, c3, c4, d2, d3, d4);
    M[1, 0]:=-oxMDetInternal(a2, a3, a4, c2, c3, c4, d2, d3, d4);
    M[2, 0]:= oxMDetInternal(a2, a3, a4, b2, b3, b4, d2, d3, d4);
    M[3, 0]:=-oxMDetInternal(a2, a3, a4, b2, b3, b4, c2, c3, c4);

    M[0, 1]:=-oxMDetInternal(b1, b3, b4, c1, c3, c4, d1, d3, d4);
    M[1, 1]:= oxMDetInternal(a1, a3, a4, c1, c3, c4, d1, d3, d4);
    M[2, 1]:=-oxMDetInternal(a1, a3, a4, b1, b3, b4, d1, d3, d4);
    M[3, 1]:= oxMDetInternal(a1, a3, a4, b1, b3, b4, c1, c3, c4);

    M[0, 2]:= oxMDetInternal(b1, b2, b4, c1, c2, c4, d1, d2, d4);
    M[1, 2]:=-oxMDetInternal(a1, a2, a4, c1, c2, c4, d1, d2, d4);
    M[2, 2]:= oxMDetInternal(a1, a2, a4, b1, b2, b4, d1, d2, d4);
    M[3, 2]:=-oxMDetInternal(a1, a2, a4, b1, b2, b4, c1, c2, c4);

    M[0, 3]:=-oxMDetInternal(b1, b2, b3, c1, c2, c3, d1, d2, d3);
    M[1, 3]:= oxMDetInternal(a1, a2, a3, c1, c2, c3, d1, d2, d3);
    M[2, 3]:=-oxMDetInternal(a1, a2, a3, b1, b2, b3, d1, d2, d3);
    M[3, 3]:= oxMDetInternal(a1, a2, a3, b1, b2, b3, c1, c2, c3);
end;
{******************************************************************************}
// [15-9-2007]: Utils last change by Dave Gravel.                            //
{******************************************************************************}
function oxMMultiply( const M1, M2: TOXMatrix ): TOXMatrix;
begin
      Result[0,0]:=M1[0,0]*M2[0,0]+M1[0,1]*M2[1,0]+M1[0,2]*M2[2,0]+M1[0,3]*M2[3,0];
      Result[0,1]:=M1[0,0]*M2[0,1]+M1[0,1]*M2[1,1]+M1[0,2]*M2[2,1]+M1[0,3]*M2[3,1];
      Result[0,2]:=M1[0,0]*M2[0,2]+M1[0,1]*M2[1,2]+M1[0,2]*M2[2,2]+M1[0,3]*M2[3,2];
      Result[0,3]:=M1[0,0]*M2[0,3]+M1[0,1]*M2[1,3]+M1[0,2]*M2[2,3]+M1[0,3]*M2[3,3];
      Result[1,0]:=M1[1,0]*M2[0,0]+M1[1,1]*M2[1,0]+M1[1,2]*M2[2,0]+M1[1,3]*M2[3,0];
      Result[1,1]:=M1[1,0]*M2[0,1]+M1[1,1]*M2[1,1]+M1[1,2]*M2[2,1]+M1[1,3]*M2[3,1];
      Result[1,2]:=M1[1,0]*M2[0,2]+M1[1,1]*M2[1,2]+M1[1,2]*M2[2,2]+M1[1,3]*M2[3,2];
      Result[1,3]:=M1[1,0]*M2[0,3]+M1[1,1]*M2[1,3]+M1[1,2]*M2[2,3]+M1[1,3]*M2[3,3];
      Result[2,0]:=M1[2,0]*M2[0,0]+M1[2,1]*M2[1,0]+M1[2,2]*M2[2,0]+M1[2,3]*M2[3,0];
      Result[2,1]:=M1[2,0]*M2[0,1]+M1[2,1]*M2[1,1]+M1[2,2]*M2[2,1]+M1[2,3]*M2[3,1];
      Result[2,2]:=M1[2,0]*M2[0,2]+M1[2,1]*M2[1,2]+M1[2,2]*M2[2,2]+M1[2,3]*M2[3,2];
      Result[2,3]:=M1[2,0]*M2[0,3]+M1[2,1]*M2[1,3]+M1[2,2]*M2[2,3]+M1[2,3]*M2[3,3];
      Result[3,0]:=M1[3,0]*M2[0,0]+M1[3,1]*M2[1,0]+M1[3,2]*M2[2,0]+M1[3,3]*M2[3,0];
      Result[3,1]:=M1[3,0]*M2[0,1]+M1[3,1]*M2[1,1]+M1[3,2]*M2[2,1]+M1[3,3]*M2[3,1];
      Result[3,2]:=M1[3,0]*M2[0,2]+M1[3,1]*M2[1,2]+M1[3,2]*M2[2,2]+M1[3,3]*M2[3,2];
      Result[3,3]:=M1[3,0]*M2[0,3]+M1[3,1]*M2[1,3]+M1[3,2]*M2[2,3]+M1[3,3]*M2[3,3];
end;
{******************************************************************************}
// [15-9-2007]: Utils last change by Dave Gravel.                            //
{******************************************************************************}
function oxMRotateV( const M: TOXMatrix; pVect: TOXVector3 ): TOXVector3;
var
  vec: array [0..2] of Float;
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];
  result:= pVect;
end;
{******************************************************************************}
// [15-9-2007]: Utils last change by Dave Gravel.                            //
{******************************************************************************}
procedure oxMSetRotation( var M: TOXMatrix; V: TOXVector3 );
var
  cr , sr , cp , sp , cy , sy , srsp , crsp: Float;