DGL • Thema anzeigen

usefull???

Moderator: DGL-Team

Seite 1 von 1

[ 3 Beiträge ]

Druckansicht

Vorheriges Thema | Nächstes Thema

Autor

Nachricht

noeska

Betreff des Beitrags: usefull???

Verfasst: Mi Apr 07, 2004 18:19

DGL Member

Registriert: Di Jul 01, 2003 18:59
Beiträge: 887
Wohnort: (The Netherlands)
Programmiersprache: fpc/delphi/java/c#

Sometimes you have to do things differently, like making a vector an object.

Let me know what you think.

Code:

 
{*******************************************************}
{                                                       }
{                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.
 

And an example:

Code:

 
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.
 

PS: there may be potential memory leaks on passing a tvector3d and not freeing that one afterwards....

_________________
http://3das.noeska.com - create adventure games without programming

Nach oben

Mars

Betreff des Beitrags:

Verfasst: Do Apr 08, 2004 09:10

DGL Member

Registriert: Fr Dez 13, 2002 12:18
Beiträge: 1063

Looks ok to me - if you want to get really fancy, you could declare it as custom variant, and use operator overloading for it :wink:

However, since vector routines tend to be called quite often, I'd rather keep the data in records and use VectorXXX routines, since there is a bit of overhead by dereferencing the pointer to the object instance if you use a TVector3D, as well as a implicit "self" parameter in methods.

Besides: using your TVector3D data type, it would be quite difficult (if not to say impossible) to declare tables for vertex arrays or vbos.

_________________
Viel Spaß beim Programmieren,
Mars
http://www.basegraph.com/

Nach oben

LarsMiddendorf

Betreff des Beitrags:

Verfasst: Do Apr 08, 2004 10:56

DGL Member

Registriert: Sa Dez 28, 2002 11:13
Beiträge: 2244

I don't think that a reference type is the best solution for vertices, because it make copying data much more complicated. The new Delphi 8 for .Net allows methods and operators in records. The old TP objects are value types like records and also allow methods,but according to the Delphi Help they should not be used anymore.

Nach oben

Seite 1 von 1

[ 3 Beiträge ]

Foren-Übersicht » English » English Programming Forum

Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 2 Gäste

Du darfst keine neuen Themen in diesem Forum erstellen.
Du darfst keine Antworten zu Themen in diesem Forum erstellen.
Du darfst deine Beiträge in diesem Forum nicht ändern.
Du darfst deine Beiträge in diesem Forum nicht löschen.
Du darfst keine Dateianhänge in diesem Forum erstellen.