{*******************************************************}

{                                                       }

{                Vector Object Library                  }

{                                                       }

{              Copyright (c) 2004 Noeska                }

{                                                       }

{*******************************************************}

 

unit glVector;

 

interface

 

uses classes, windows;

 

type

  TRandomFunc = (rNegoneToOne, rZeroToOne); // (-1..1) (0..1)

 

  TVector3D = class(TObject)

  private

    Fx: single;

    Fy: single;

    Fz: single;

    function  GetNormalized: TVector3d; //same as above but return a new vector

    function  GetLength: single; //returns the length of a vector

  protected

  public

    constructor Create; reintroduce; overload;

    constructor Create(vx,vy,vz: single); reintroduce; overload;

    destructor Destroy; reintroduce;

    property x: single read Fx write Fx;

    property y: single read Fy write Fy;

    property z: single read Fz write Fz;

    procedure Assign(v: TVector3D); reintroduce; //set x,y,z from other vector

    procedure Add(v: TVector3D); //Addition

    procedure Sub(v: TVector3D); //Subtraction

    procedure Mul(value: single); //Scale by Multiplication

    procedure Divide(value: single); //Scale by Division

    function  Dot(v: TVector3D): single; //Dot product (angle between 2 vectors)

    function  Cross(v: TVector3D): TVector3D; //Cross product (perpendicular vector)

    procedure Negative; //flips positive and negative

    procedure Normalize; //make the vector have a length of 1 but keep direction

    property  Normalized: TVector3D read GetNormalized; //as above but returns a new vector

    property  Length: single read GetLength; //length of vector

    property  Magnitude: single read GetLength; //length of vector

    procedure Rand(value: TRandomFunc); //fills vector  with random values

  end;

 

implementation

 

  constructor TVector3D.Create;

  begin

    inherited Create();

    Fx:=0.0;

    Fy:=0.0;

    Fz:=0.0;

  end;

 

  constructor TVector3D.Create(vx,vy,vz: single);

  begin

    inherited Create();

    Fx:=vx;

    Fy:=vy;

    Fz:=vz;

  end;

 

  destructor TVector3D.Destroy;

  begin

    if normalized <> nil then normalized.free; //free's the normalized property if not done from application

    inherited Destroy();

  end;

 

  procedure TVector3D.Assign(v: TVector3D);

  begin

    Fx:=v.x;

    Fy:=v.y;

    Fz:=v.z;

  end;

 

  procedure TVector3D.Add(v: TVector3D);

  begin

    Fx:=Fx+v.x;

    Fy:=Fy+v.y;

    Fz:=Fz+v.z;

  end;

 

  procedure TVector3D.Sub(v: TVector3D);

  begin

    Fx:=Fx-v.x;

    Fy:=Fy-v.y;

    Fz:=Fz-v.z;

  end;

 

  procedure TVector3D.Mul(value: single);

  begin

    Fx:=Fx*value;

    Fy:=Fy*value;

    Fz:=Fz*value;

  end;

 

  procedure TVector3D.Divide(value: single);

  begin

    Fx:=Fx/value;

    Fy:=Fy/value;

    Fz:=Fz/value;

  end;

 

  function TVector3D.Dot(v: TVector3D): single;

  begin

    result:= Fx*v.x+Fy*v.y+Fz*v.z;

  end;

 

  function TVector3D.Cross(v: TVector3D): TVector3D;

  begin

    result:= TVector3D.Create();

    result.x:= Fy*v.z-Fz*v.y;

    result.y:= Fz*v.x-Fx*v.z;

    result.z:= Fx*v.y-Fy*v.x;

  end;

 

  procedure TVector3D.Negative;

  begin

    Fx:=-Fx;

    Fy:=-Fy;

    Fz:=-Fz;

  end;

 

  function TVector3D.GetLength: single;

  begin

    result := sqrt(Fx*Fx + Fy*Fy + Fz*Fz);

  end;

 

  procedure TVector3d.normalize;

  var

    tmplength: single;

  begin

    tmplength:=GetLength;

    if tmplength <> 0 then

    begin

      Fx:=Fx / tmplength;

      Fy:=Fy / tmplength;

      Fz:=Fz / tmplength;

    end;

  end;

 

  function TVector3d.GetNormalized;

  var

    tmplength: single;

  begin

    result:=nil;

    tmplength:=Length;

    if tmplength <> 0 then

    begin

      if normalized <> nil then normalized.free; //free's the normalized property if not done from application

      result:=TVector3d.Create();

      result.x:=Fx / tmplength;

      result.y:=Fy / tmplength;

      result.z:=Fz / tmplength;

    end;

  end;

 

  function RandNegOneToOne: single;

  begin

    result := -1.0+(random / 16383.0);

  end;

 

  function RandZeroToOne: single;

  begin

    result := (random / 32767.0);

  end;

 

  procedure TVector3d.Rand(value: TRandomFunc);

  begin

    if value=rNegOneToOne then

    begin

      Fx:=RandNegOneToOne;

      Fy:=RandNegOneToOne;

      Fz:=RandNegOneToOne;

      Normalize;

    end;

 

    if value=rZeroToOne then

    begin

      Fx:=RandZeroToOne;

      Fy:=RandZeroToOne;

      Fz:=RandZeroToOne;

      Normalize;

    end;

  end;

 

end.

 

 

program testvector;

{$APPTYPE CONSOLE}

uses

  Classes,

  SysUtils,

  glVector;

 

type

  //the old t3dpoint type

  T3dpoint     = packed record

    x, y, z        :Single;

  end;

  P3dpoint = ^T3dpoint;

 

const aantal= 99999;  //aantal is dutch for 'number of'

 

var

  vectorlist, pointlist: tlist;

  v3d1,v3d2 : tVector3D;

  tmpcount: integer;

  pointptr: P3dpoint;

 

begin

vectorlist:=Tlist.Create;   //used for testing vectors

//pointlist:=Tlist.Create;    //used for testing 3dpoints

 

for tmpcount:=0 to aantal do

begin

vectorlist.Add(TVector3D.Create());

TVector3d(vectorlist.Items[tmpcount]).x:=tmpcount;

 

//new(pointptr);

//pointptr.x:=0.0;

//pointptr.y:=0.0;

//pointptr.z:=0.0;

//pointlist.Add(pointptr);

//P3DPoint(pointlist.Items[tmpcount]).x:=tmpcount;

 

end;

 

v3d1:= TVector3D.Create();

v3d2:= TVector3D.Create(2.0, 0.0, 9.0);

 

writeln(FloatToStr(v3d1.x)+'test tvector3d');

//v3d2.x:=2.0;

//v3d2.y:=0.0;

//v3d2.z:=9.0;

Randomize;

 

v3d1.Rand(rNegOneToOne);

//v3d1.Add(v3d2);

Writeln(FloatToStr(v3d1.x)+'x test tvector3d');

Writeln(FloatToStr(v3d1.y)+'y test tvector3d');

Writeln(FloatToStr(v3d1.z)+'z test tvector3d');

Writeln(FloatToStr(v3d1.length)+'length test tvector3d');

v3d1.Normalize;

Writeln(FloatToStr(v3d1.length)+'length test tvector3d');

v3d2.Assign(v3d1.Normalized);

v3d1.Normalized.Free; //can be a memory leek if not done (how to solve?)

 

for tmpcount:=aantal downto 0 do

begin

  //writeln(floattostr(TVector3d(vectorlist.Items[tmpcount]).x),'test tvector3d');

  TVector3d(vectorlist.Items[tmpcount]).Free;

  vectorlist.Delete(tmpcount);

 

  //writeln(floattostr(P3dpoint(pointlist.Items[tmpcount]).x),'test tpoint3d');

  //dispose(pointlist.Items[tmpcount]);

  //pointlist.Delete(tmpcount);

end;

 

v3d1.Free;

v3d2.Free;

 

vectorlist.Free;

//pointlist.Free;

 

end.