_vector.pas

/* * tesswind.c * This program demonstrates the winding rule polygon * tessellation proper

//******************************************************************************
// _vector.pas unit
// this unit based on public domain source code vector.pas
// by Vashchaev 'viv' Ivan, [e-mail], 02/04/2002)
//
// This unit is freely distributable without licensing fees and is
// provided without guarantee or warrantee expressed or implied. This unit
// is Public Domain. Feel free to use or enhance this code. You can use the
// program for any purpose you see fit.
//
//******************************************************************************
unit _vector;

interface

uses math;

type TVector = record
                x,y,z:single;
               end;

type TVector2D = record
                  u,v:single;
                 end;

function VecPlusVec(v1,v2:TVector):TVector;
function makethis(a,b,c:single):TVector;
function VecMinusVec(v1,v2:TVector):TVector;
function NormalVector(vector1,vector2,vector3:TVector):TVector;
function Normalize(inv:TVector):Tvector;
function Crossvector(vector1,vector2:TVector):Tvector;
function VectorLen(inv:TVector):Single;
function Umnoj(vec:TVector;a:single):TVector;

function PointInsidePolygon(Intersection: TVector; Polygon: array of TVector; VertexCount: Integer): Boolean;

function AngleBetweenVectors(Vector1, Vector2: TVector): Double;

implementation

function DotVector(Vector1, Vector2: TVector): Single;
begin
 Result := (Vector1.X * Vector2.X) + (Vector1.Y * Vector2.Y) + (Vector1.Z * Vector2.Z);
end;


function AngleBetweenVectors(Vector1, Vector2: TVector): Double;
var temp:Single;
begin
temp:=DotVector(Normalize(Vector1), Normalize(Vector2));
 Result:=0;
 if abs(temp)<=1 then
 Result := ArcCos(temp);
// if IsNan(Result) then Result := 0;
//writeln(DotVector(NormalizeVector(Vector1), NormalizeVector(Vector2)));
end;


function SubVector(Vector1, Vector2: TVector): TVector;
begin
 Result.X := Vector1.X - Vector2.X;
 Result.Y := Vector1.Y - Vector2.Y;
 Result.Z := Vector1.Z - Vector2.Z;
end;


function PointInsidePolygon(Intersection: TVector; Polygon: array of TVector; VertexCount: Integer): Boolean;
var i: Integer;
    Angle: Single;
    vA, vB: TVector;
begin
 for i := 0 to VertexCount - 1 do
  begin
   vA := SubVector(Polygon[i], Intersection);
   vB := SubVector(Polygon[(i + 1) mod VertexCount], Intersection);
   Angle := Angle + AngleBetweenVectors(vA, vB);
  end;

 if Angle >= 2 * PI - 0.1 then
  begin
   Result := True;
   Exit;
  end;

 Result := False;
end;


function Umnoj(vec:TVector;a:single):TVector;
begin
result.x:=vec.x*a;
result.y:=vec.y*a;
result.z:=vec.z*a;
end;

function makethis(a,b,c:single):TVector;
//var temp:TVector;
begin
result.x:=a;
result.y:=b;
result.z:=c;
//result:=temp;

end;

function VecMinusVec(v1,v2:TVector):TVector;
//var temp:TVector;
begin
 result.x:=v1.x-v2.x;
 result.y:=v1.y-v2.y;
 result.z:=v1.z-v2.z;
// result:=temp;
end;

function VecPlusVec(v1,v2:TVector):TVector;
//var temp:TVector;
begin
 result.x:=v1.x+v2.x;
 result.y:=v1.y+v2.y;
 result.z:=v1.z+v2.z;
// result:=temp;
end;

////////////////////////////////////////////////////////////////////////
function VectorLen(inv:TVector):Single;
//var vl:single;
begin
 result:=sqrt(inv.x*inv.x+inv.y*inv.y+inv.z*inv.z);
// result:=vl;
end;


////////////////////////////////////////////////////////////////////////
function Crossvector(vector1,vector2:TVector):Tvector;
//var tv:tvector;
begin
 result.X := (Vector1.Y * Vector2.Z) - (Vector1.Z * Vector2.Y);
 result.Y := (Vector1.Z * Vector2.X) - (Vector1.X * Vector2.Z);
 result.Z := (Vector1.X * Vector2.Y) - (Vector1.Y * Vector2.X);
// result:=tv;
end;

////////////////////////////////////////////////////////////////////////
function Normalize(inv:TVector):Tvector;
var vl:single;
    tv:Tvector;
begin
 tv:=inv;
 vl:=sqrt(inv.x*inv.x+inv.y*inv.y+inv.z*inv.z);
 if vl>0 then
  begin
   tv.x:=tv.x/vl;
   tv.y:=tv.y/vl;
   tv.z:=tv.z/vl;
  end;
 result:=tv;
end;

function NormalVector(vector1,vector2,vector3:TVector):TVector;
var v1,v2:tvector;
begin
v1.x:=vector1.x-vector2.x;
v1.y:=vector1.y-vector2.y;
v1.z:=vector1.z-vector2.z;

v2.x:=vector2.x-vector3.x;
v2.y:=vector2.y-vector3.y;
v2.z:=vector2.z-vector3.z;

result:=Normalize(CrossVector(v1,v2));
end;


// This code is public domain, feel free to do with it any descent thing.
end.