OpenGLCore/ugluVector.pas

unit ugluVector;

{ Package:      OpenGLCore
  Prefix:       glu - OpenGL Utils
  Beschreibung: diese Unit enthält Vektor-Typen und Methoden um diese zu erstellen und zu manipulieren }

{$mode objfpc}{$H+}

interface

uses
  Classes, SysUtils, {$IFNDEF OPENGL_ES}dglOpenGL{$ELSE}dglOpenGLES{$ENDIF};

type
  //Vektortypen
  TgluVector2ub = TGLVectorub2;
  TgluVector3ub = TGLVectorub3;
  TgluVector4ub = TGLVectorub4;

  TgluVector2i = TGLVectori2;
  TgluVector3i = TGLVectori3;
  TgluVector4i = TGLVectori4;

  TgluVector2e = array[0..1] of GLenum;
  TgluVector3e = array[0..2] of GLenum;
  TgluVector4e = array[0..3] of GLenum;

  TgluVector2f = TGLVectorf2;
  TgluVector3f = TGLVectorf3;
  TgluVector4f = TGLVectorf4;

  TgluVector2d = TGLVectord2;
  TgluVector3d = TGLVectord3;
  TgluVector4d = TGLVectord4;

  TgluVector2p = TGLVectorp2;
  TgluVector3p = TGLVectorp3;
  TgluVector4p = TGLVectorp4;

  TgluPlanef = TgluVector4f;

  TgluVector3fArr8 = array[0..7] of TgluVector4f;
  TgluRayf = packed record
    p, v: TgluVector3f;
  end;

  TgluRecord2ub = packed record
    case Integer of
      0: (x, y: gluByte);
      1: (s, t: gluByte);
      2: (u, v: gluByte);
      3: (vec: TgluVector2ub);
  end;
  TgluRecord3ub = packed record
    case Integer of
      0: (x, y, z: gluByte);
      1: (r, g, b: gluByte);
      2: (u, v, w: gluByte);
      3: (vec: TgluVector3ub);
  end;
  TgluRecord4ub = packed record
    case Integer of
      0: (x, y, z, w: gluByte);
      1: (r, g, b, a: gluByte);
      2: (vec: TgluVector4ub);
  end;

  TgluRecord2i = packed record
    case Integer of
      0: (x, y: glInt);
      1: (s, t: glInt);
      2: (u, v: glInt);
      3: (vec: TgluVector2i);
  end;
  TgluRecord3i = packed record
    case Integer of
      0: (x, y, z: glInt);
      1: (r, g, b: glInt);
      2: (u, v, w: glInt);
      3: (vec: TgluVector3i);
  end;
  TgluRecord4i = packed record
    case Integer of
      0: (x, y, z, w: glInt);
      1: (r, g, b, a: glInt);
      2: (vec: TgluVector4i);
  end;

  TgluRecord2f = packed record
    case Integer of
      0: (x, y: glFloat);
      1: (s, t: glFloat);
      2: (u, v: glFloat);
      3: (vec: TgluVector2f);
  end;
  TgluRecord3f = packed record
    case Integer of
      0: (x, y, z: glFloat);
      1: (r, g, b: glFloat);
      2: (u, v, w: glFloat);
      3: (vec: TgluVector3f);
  end;
  TgluRecord4f = packed record
    case Integer of
      0: (x, y, z, w: glFloat);
      1: (r, g, b, a: glFloat);
      2: (vec4: TgluVector4f);
      3: (vec3: TgluVector3f);
  end;

  TgluRecord2d = packed record
    case Integer of
      0: (x, y: glDouble);
      1: (s, t: glDouble);
      2: (u, v: glDouble);
      3: (vec: TgluVector2d);
  end;
  TgluRecord3d = packed record
    case Integer of
      0: (x, y, z: glDouble);
      1: (r, g, b: glDouble);
      2: (u, v, w: glDouble);
      3: (vec: TgluVector3d);
  end;
  TgluRecord4d = packed record
    case Integer of
      0: (x, y, z, w: glDouble);
      1: (r, g, b, a: glDouble);
      2: (vec: TgluVector4d);
  end;

  //VectorPointer
  PgluVector2i = ^TgluVector2i;
  PgluVector3i = ^TgluVector3i;
  PgluVector4i = ^TgluVector4i;

  PgluVector2e = ^TgluVector2e;
  PgluVector3e = ^TgluVector3e;
  PgluVector4e = ^TgluVector4e;

  PgluVector2ub = ^TgluVector2ub;
  PgluVector3ub = ^TgluVector3ub;
  PgluVector4ub = ^TgluVector4ub;

  PgluVector2f = ^TgluVector2f;
  PgluVector3f = ^TgluVector3f;
  PgluVector4f = ^TgluVector4f;

  PgluVector2d = ^TgluVector2d;
  PgluVector3d = ^TgluVector3d;
  PgluVector4d = ^TgluVector4d;

  PgluVector2p = ^TgluVector2p;
  PgluVector3p = ^TgluVector3p;
  PgluVector4p = ^TgluVector4p;

  TVectorColor = -$7FFFFFFF-1..$7FFFFFFF;

  //Stream: Lese- und Schreibfunktionen
  procedure gluVector2fWrite(const vec: TgluVector2f; const aStream: TStream);
  procedure gluVector3fWrite(const vec: TgluVector3f; const aStream: TStream);
  procedure gluVector4fWrite(const vec: TgluVector4f; const aStream: TStream);
  function  gluVector2fRead(const aStream: TStream): TgluVector2f;
  function  gluVector3fRead(const aStream: TStream): TgluVector3f;
  function  gluVector4fRead(const aStream: TStream): TgluVector4f;

  //Vektor Konstruktoren
  function gluVector4f(const X, Y, Z, W: Single): TgluVector4f;
  function gluVector4f(const aVec: TgluVector3f; const W: Single): TgluVector4f;
  function gluVector4f(const aVec: TgluVector2f; const Z, W: Single): TgluVector4f;
  function gluVector4d(const X, Y, Z, W: Single): TgluVector4d;
  function gluVector3f(const X, Y, Z: Single): TgluVector3f; overload;
  function gluVector3f(const v: TgluVector4f): TgluVector3f; overload;
  function gluVector3f(const v: TgluVector2f; const z: Single): TgluVector3f; overload;
  function gluVector3f(const p1, p2: TgluVector3f): TgluVector3f; overload;
  function gluVector2f(const X, Y: Single): TgluVector2f;
  function gluVector2f(const v3: TgluVector3f): TgluVector2f;
  function gluVector2f(const v4: TgluVector4f): TgluVector2f;
  function gluVector4i(const W, X, Y, Z: Integer): TgluVector4i;
  function gluVector2i(const X, Y: Integer): TgluVector2i;
  function gluVector2e(const X, Y: GLenum): TgluVector2e;
  function gluVector3e(const X, Y, Z: GLenum): TgluVector3e;
  function gluVector4e(const X, Y, Z, W: GLenum): TgluVector4e;

  //Vektorfunktionen
  function gluVectorNormalize(const v: TgluVector4f): TgluVector4f; overload;
  function gluVectorNormalize(const v: TgluVector3f): TgluVector3f; overload;
  function gluVectorNormalize(const v: TgluVector2f): TgluVector2f; overload;
  function gluVectorLength(const v: TgluVector3f): Single; overload;
  function gluVectorLength(const v: TgluVector2f): Single; overload;
  function gluVectorProduct(const v1, v2: TgluVector3f): TgluVector3f;
  function gluVectorScalar(const v1, v2: TgluVector4f): Single; overload;
  function gluVectorScalar(const v1, v2: TgluVector3f): Single; overload;
  function gluVectorScalar(const v1, v2: TgluVector2f): Single; overload;
  function gluVectorAngle(const v1, v2: TgluVector3f): Single; overload;
  function gluVectorAngle(const v1, v2: TgluVector2f): Single; overload;
  function gluVectorAngle2(const v1, v2: TgluVector2f): Single;
  function gluVectorEquals(const v1, v2: TgluVector2f): Boolean; overload;
  function gluVectorEquals(const v1, v2: TgluVector3f): Boolean; overload;
  function gluVectorEquals(const v1, v2: TgluVector4f): Boolean; overload;
  function gluVectorMult(const v: TgluVector2f; const s: Single): TgluVector2f;
  function gluVectorMult(const v: TgluVector3f; const s: Single): TgluVector3f;
  function gluVectorMult(const v: TgluVector4f; const s: Single): TgluVector4f;
  function gluVectorDivide(const v: TgluVector3f; const s: Single): TgluVector3f;
  function gluVectorClamp(const v: TgluVector3f; const aMin, aMax: Single): TgluVector3f; overload;
  function gluVectorClamp(const v: TgluVector4f; const aMin, aMax: Single): TgluVector4f; overload;
  function gluVectorAdd(const v1, v2: TgluVector3f): TgluVector3f;
  function gluVectorSubtract(const v1, v2: TgluVector3f): TgluVector3f;
  function gluVectorAdd(const v1, v2: TgluVector2f): TgluVector2f;
  function gluVectorSubtract(const v1, v2: TgluVector2f): TgluVector2f;
  procedure gluVectorOrthoNormalize(var reference, tangent: TgluVector3f);
  function gluGetAbsCoord(const v: TgluVector3f): TgluVector3f;

  //Ebnenfunktionen
  function gluPlanef(const p1, p2, p3: TgluVector3f): TgluPlanef;
  function gluPlanef(const n, p: TgluVector3f): TgluPlanef;
  function gluPlaneNormalize(const p: TgluPlanef): TgluPlanef;
  function gluPlaneCrossRay(const aPlane: TgluPlanef; const aRay: TgluRayf; out aPoint: TgluVector3f): Boolean;

  //Rayfunktionen
  function gluRayf(const p, v: TgluVector3f): TgluRayf;
  function gluRayNormalize(const r: TgluRayf): TgluRayf;
  function gluRayPoint(const r: TgluRayf; const lambda: Single): TgluVector3f;

  //Vektor Aus- und Eingaben
  function gluVector4fToStr(const v: TgluVector4f; const round: Integer = 3): String;
  function gluVector3fToStr(const v: TgluVector3f; const round: Integer = 3): String;
  function gluVector2fToStr(const v: TgluVector2f; const round: Integer = 3): String;
  function gluTryStrToVector4f(str: String; out aVec: TgluVector4f): Boolean;
  function gluTryStrToVector3f(str: String; out aVec: TgluVector3f): Boolean;
  function gluTryStrToVector2f(str: String; out aVec: TgluVector2f): Boolean;
  function gluStrToVector4f(str: String): TgluVector4f;
  function gluStrToVector3f(str: String): TgluVector3f;
  function gluStrToVector2f(str: String): TgluVector2f;
  function gluVector4iToStr(const v: TgluVector4i): String;
  function gluVector3iToStr(const v: TgluVector3i): String;
  function gluVector2iToStr(const v: TgluVector2i): String;
  function gluStrToVector4i(const str: String): TgluVector4i;
  function gluStrToVector3i(const str: String): TgluVector3i;
  function gluStrToVector2i(const str: String): TgluVector2i;
  function gluVectorToColor(const v: TgluVector4f): TVectorColor; overload;
  function gluVectorToColor(const v: TgluVector3f): TVectorColor; overload;
  function gluColorToVector3f(const c: TVectorColor): TgluVector3f;
  function gluColorToVector4f(const c: TVectorColor; const a: Single): TgluVector4f;
  function gluVectorHSVColor(v: TgluVector3f): TgluVector3f; overload;
  function gluVectorHSVColor(v: TgluVector4f): TgluVector4f; overload;

  operator >< (const v1, v2: TgluVector3f): TgluVector3f; inline;

  operator * (const v1, v2: TgluVector4f): Single; inline; overload;
  operator * (const v1, v2: TgluVector3f): Single; inline; overload;
  operator * (const v1, v2: TgluVector2f): Single; inline; overload;

  operator * (const v: TgluVector2f; const s: Single): TgluVector2f; inline; overload;
  operator * (const v: TgluVector3f; const s: Single): TgluVector3f; inline; overload;
  operator * (const v: TgluVector4f; const s: Single): TgluVector4f; inline; overload;

  operator * (const s: Single; const v: TgluVector2f): TgluVector2f; inline; overload;
  operator * (const s: Single; const v: TgluVector3f): TgluVector3f; inline; overload;
  operator * (const s: Single; const v: TgluVector4f): TgluVector4f; inline; overload;

  operator / (const v: TgluVector3f; const s: Single): TgluVector3f; inline; overload;

  operator = (const v1, v2: TgluVector2f): Boolean; inline; overload;
  operator = (const v1, v2: TgluVector3f): Boolean; inline; overload;
  operator = (const v1, v2: TgluVector4f): Boolean; inline; overload;

  operator + (const v1, v2: TgluVector3f): TgluVector3f; inline;
  operator - (const v1, v2: TgluVector3f): TgluVector3f; inline;

  operator + (const v1, v2: TgluVector2f): TgluVector2f; inline;
  operator - (const v1, v2: TgluVector2f): TgluVector2f; inline;

const
  gluVectorNull : TgluVector3f = (0,0,0);
  gluVectorUnitX: TgluVector3f = (1,0,0);
  gluVectorUnitY: TgluVector3f = (0,1,0);
  gluVectorUnitZ: TgluVector3f = (0,0,1);

implementation

uses
  Math;

operator >< (const v1, v2: TgluVector3f): TgluVector3f;
begin
  result := gluVectorProduct(v1, v2);
end;

operator * (const v1, v2: TgluVector4f): Single;
begin
  result := gluVectorScalar(v1, v2);
end;

operator * (const v1, v2: TgluVector3f): Single;
begin
  result := gluVectorScalar(v1, v2);
end;

operator * (const v1, v2: TgluVector2f): Single;
begin
  result := gluVectorScalar(v1, v2);
end;

operator * (const v: TgluVector2f; const s: Single): TgluVector2f;
begin
  result := gluVectorMult(v, s);
end;

operator * (const v: TgluVector3f; const s: Single): TgluVector3f;
begin
  result := gluVectorMult(v, s);
end;

operator * (const v: TgluVector4f; const s: Single): TgluVector4f;
begin
  result := gluVectorMult(v, s);
end;

operator * (const s: Single; const v: TgluVector2f): TgluVector2f;
begin
  result := gluVectorMult(v, s);
end;

operator * (const s: Single; const v: TgluVector3f): TgluVector3f;
begin
  result := gluVectorMult(v, s);
end;

operator * (const s: Single; const v: TgluVector4f): TgluVector4f;
begin
  result := gluVectorMult(v, s);
end;

operator / (const v: TgluVector3f; const s: Single): TgluVector3f;
begin
  result := gluVectorDivide(v, s);
end;

operator = (const v1, v2: TgluVector2f): Boolean;
begin
  result := gluVectorEquals(v1, v2);
end;

operator = (const v1, v2: TgluVector3f): Boolean;
begin
  result := gluVectorEquals(v1, v2);
end;

operator = (const v1, v2: TgluVector4f): Boolean;
begin
  result := gluVectorEquals(v1, v2);
end;

operator + (const v1, v2: TgluVector3f): TgluVector3f;
begin
  result := gluVectorAdd(v1, v2);
end;

operator - (const v1, v2: TgluVector3f): TgluVector3f;
begin
  result := gluVectorSubtract(v1, v2);
end;

operator + (const v1, v2: TgluVector2f): TgluVector2f;
begin
  result := gluVectorAdd(v1, v2);
end;

operator - (const v1, v2: TgluVector2f): TgluVector2f;
begin
  result := gluVectorSubtract(v1, v2);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//speichert einen Vector in einem Stream
//@vec: Vector die gespeichert werden soll;
//@aStream: Stream in dem gespeichert werden soll;
procedure gluVector2fWrite(const vec: TgluVector2f; const aStream: TStream);
begin
  aStream.Write(vec[0], SizeOf(vec));
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//speichert einen Vector in einem Stream
//@vec: Vector die gespeichert werden soll;
//@aStream: Stream in dem gespeichert werden soll;
procedure gluVector3fWrite(const vec: TgluVector3f; const aStream: TStream);
begin
  aStream.Write(vec[0], SizeOf(vec));
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//speichert einen Vector in einem Stream
//@vec: Vector die gespeichert werden soll;
//@aStream: Stream in dem gespeichert werden soll;
procedure gluVector4fWrite(const vec: TgluVector4f; const aStream: TStream);
begin
  aStream.Write(vec[0], SizeOf(vec));
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//ließt einen Vector aus einem Stream
//@aStream: Stream aus dem gelesen werden soll;
//@result: gelesene Werte des Vectors;
//@throw: Exception;
function  gluVector2fRead(const aStream: TStream): TgluVector2f;
begin
  if aStream.Read(result{%H-}, SizeOf(result)) < SizeOf(result) then
    raise Exception.Create('gluVector2fRead - unexpected stream size');
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//ließt einen Vector aus einem Stream
//@aStream: Stream aus dem gelesen werden soll;
//@result: gelesene Werte des Vectors;
//@throw: Exception;
function gluVector3fRead(const aStream: TStream): TgluVector3f;
begin
  if aStream.Read(result{%H-}, SizeOf(result)) < SizeOf(result) then
    raise Exception.Create('gluVector3fRead - unexpected stream size');
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//ließt einen Vector aus einem Stream
//@aStream: Stream aus dem gelesen werden soll;
//@result: gelesene Werte des Vectors;
//@throw: Exception;
function gluVector4fRead(const aStream: TStream): TgluVector4f;
begin
  if aStream.Read(result{%H-}, SizeOf(result)) < SizeOf(result) then
    raise Exception.Create('gluVector4fRead - unexpected stream size');
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//erstellt einen Vector
//@W: 1. Wert im Vector;
//@X: 2. Wert im Vector;
//@Y: 3. Wert im Vector;
//@Z: 4. Wert im Vector;
function gluVector4f(const X,Y,Z,W: Single): TgluVector4f;
begin
  result[0] := X;
  result[1] := Y;
  result[2] := Z;
  result[3] := W;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function gluVector4f(const aVec: TgluVector3f; const W: Single): TgluVector4f;
begin
  PgluVector3f(@result[0])^ := aVec;
  result[3] := W;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function gluVector4f(const aVec: TgluVector2f; const Z, W: Single): TgluVector4f;
begin
  PgluVector2f(@result[0])^ := aVec;
  result[2] := Z;
  result[3] := W;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//erstellt einen Vector
//@W: 1. Wert im Vector;
//@X: 2. Wert im Vector;
//@Y: 3. Wert im Vector;
//@Z: 4. Wert im Vector;
function gluVector4d(const X,Y,Z,W: Single): TgluVector4d;
begin
  result[0] := X;
  result[1] := Y;
  result[2] := Z;
  result[3] := W;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//erstellt einen Vector
//@X: 1. Wert im Vector;
//@Y: 2. Wert im Vector;
//@Z: 3. Wert im Vector;
function gluVector3f(const X,Y,Z: Single): TgluVector3f;
begin
  result[0] := X;
  result[1] := Y;
  result[2] := Z;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//erstellt einen Vector
//@v: 4-Komponenten Vektor aus dem der Vektor erstellt werden soll;
function gluVector3f(const v: TgluVector4f): TgluVector3f;
begin
  result := PgluVector3f(@v[0])^;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function gluVector3f(const v: TgluVector2f; const z: Single): TgluVector3f;
begin
  result[0] := v[0];
  result[1] := v[1];
  result[2] := z;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//erzeugt einen Vektor aus 2 Punkten
//@p1: Punkt 1;
//@p2: Punkt 2;
//@result: Vektor zwischen den Punkten
function gluVector3f(const p1, p2: TgluVector3f): TgluVector3f;
var
  i: Integer;
begin
  for i := 0 to 2 do
    result[i] := p2[i] - p1[i];
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//erstellt einen Vector
//@X: 1. Wert im Vector;
//@Y: 2. Wert im Vector;
function gluVector2f(const X,Y: Single): TgluVector2f;
begin
  result[0] := X;
  result[1] := Y;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function gluVector2f(const v3: TgluVector3f): TgluVector2f;
begin
  result[0] := v3[0];
  result[1] := v3[1];
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function gluVector2f(const v4: TgluVector4f): TgluVector2f;
begin
  result[0] := v4[0];
  result[1] := v4[1];
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//erstellt einen Vector
//@W: 1. Wert im Vector;
//@X: 2. Wert im Vector;
//@Y: 3. Wert im Vector;
//@Z: 4. Wert im Vector;
function  gluVector4i(const W, X, Y, Z: Integer): TgluVector4i;
begin
  result[0] := W;
  result[1] := X;
  result[2] := Y;
  result[3] := Z;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//erstellt einen Vector
//@W: 1. Wert im Vector;
//@X: 2. Wert im Vector;
//@Y: 3. Wert im Vector;
//@Z: 4. Wert im Vector;
function  gluVector2i(const X, Y: Integer): TgluVector2i;
begin
  result[0] := X;
  result[1] := Y;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function gluVector2e(const X, Y: GLenum): TgluVector2e;
begin
  result[0] := X;
  result[1] := Y;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function gluVector3e(const X, Y, Z: GLenum): TgluVector3e;
begin
  result[0] := X;
  result[1] := Y;
  result[2] := Z;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function gluVector4e(const X, Y, Z, W: GLenum): TgluVector4e;
begin
  result[0] := X;
  result[1] := Y;
  result[2] := Z;
  result[3] := W;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function gluVectorNormalize(const v: TgluVector4f): TgluVector4f;
begin
  result := v;
  if (result[3] <> 0) then
    result := gluVectorMult(result, result[3]);
  PgluVector3f(@result[0])^ := gluVectorNormalize(PgluVector3f(@result[0])^);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Normalisiert einen Vector
//@v: Vector der normalisiert werden soll;
//@result: normalisierter Vector;
function gluVectorNormalize(const v: TgluVector3f): TgluVector3f;
var len: Single;
begin
  len := gluVectorLength(v);
  if (len > 0) then begin
    result[0] := v[0]/len;
    result[1] := v[1]/len;
    result[2] := v[2]/len;
  end;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Normalisiert einen Vector
//@v: Vector der normalisiert werden soll;
//@result: normalisierter Vector;
function gluVectorNormalize(const v: TgluVector2f): TgluVector2f;
var len: Single;
begin
  len := gluVectorLength(v);
  result[0] := v[0]/len;
  result[1] := v[1]/len;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//berechnet die Länge eines Vectors
//@v: Vector dessen Länge berechnet werden soll;
//@result: Lange des Vectors;
function gluVectorLength(const v: TgluVector3f): Single;
begin
  result := SQRT(SQR(v[0])+SQR(v[1])+SQR(v[2]));
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//berechnet die Länge eines Vectors
//@v: Vector dessen Länge berechnet werden soll;
//@result: Lange des Vectors;
function gluVectorLength(const v: TgluVector2f): Single;
begin
  result := SQRT(SQR(v[0])+SQR(v[1]));
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Berechnet das VektorProdukt aus den Übergebenen Vektoren
//@v1: 1. Vektor;
//@v2: 2. Vektor;
//@result: Vektor des Vektorprodukts aus v1 und v2;
function gluVectorProduct(const v1, v2: TgluVector3f): TgluVector3f;
begin
  result[0] := v1[1]*v2[2] - v1[2]*v2[1];
  result[1] := v1[2]*v2[0] - v1[0]*v2[2];
  result[2] := v1[0]*v2[1] - v1[1]*v2[0];
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Berechnet das Skalarprodukt der übergebenen Vektoren
//@v1: 1. vektor;
//@v2: 2. Vektor;
//@result: Skalprodukt aus v1 und v2;
function gluVectorScalar(const v1, v2: TgluVector4f): Single; overload;
begin
  result := v1[0]*v2[0] + v1[1]*v2[1] + v1[2]*v2[2] + v1[3]*v2[3];
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Berechnet das Skalarprodukt der übergebenen Vektoren
//@v1: 1. vektor;
//@v2: 2. Vektor;
//@result: Skalprodukt aus v1 und v2;
function gluVectorScalar(const v1, v2: TgluVector3f): Single;
begin
  result := v1[0]*v2[0] + v1[1]*v2[1] + v1[2]*v2[2];
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Berechnet das Skalarprodukt der übergebenen Vektoren
//@v1: 1. vektor;
//@v2: 2. Vektor;
//@result: Skalprodukt aus v1 und v2;
function gluVectorScalar(const v1, v2: TgluVector2f): Single;
begin
  result := v1[0]*v2[0] + v1[1]*v2[1];
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Berechnet den Winkel zwischen den übergebenen Vectoren
//@v1: 1. vektor;
//@v2: 2. Vektor;
//@result: Winkel zwischen v1 und v2;
function gluVectorAngle(const v1, v2: TgluVector3f): Single;
begin
  result := ArcCos(gluVectorScalar(v1, v2)/(gluVectorLength(v1)*gluVectorLength(v2)));
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Berechnet den Winkel zwischen den übergebenen Vectoren
//@v1: 1. vektor;
//@v2: 2. Vektor;
//@result: Winkel zwischen v1 und v2 im Bereich: (0°; 180°);
function gluVectorAngle(const v1, v2: TgluVector2f): Single;
begin
  result := ArcCos(gluVectorScalar(v1, v2)/(gluVectorLength(v1)*gluVectorLength(v2)));
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Berechnet den Winkel zwischen den übergebenen Vectoren
//@v1: 1. vektor;
//@v2: 2. Vektor;
//@result: Winkel zwischen v1 und v2 im Bereich: [-180°; 180°) ;
function gluVectorAngle2(const v1, v2: TgluVector2f): Single;
begin
  result := arctan2(
    v2[0] * v1[1] - v2[1] * v1[0],
    v2[0] * v1[0] + v2[1] * v1[1]);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function gluVectorEquals(const v1, v2: TgluVector2f): Boolean;
begin
  result := (v1[0] = v2[0]) and (v1[1] = v2[1]);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function gluVectorEquals(const v1, v2: TgluVector3f): Boolean;
begin
  result := (v1[2] = v2[2]) and gluVectorEquals(PgluVector2f(@v1[0])^, PgluVector2f(@v2[0])^);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function gluVectorEquals(const v1, v2: TgluVector4f): Boolean;
begin
  result := (v1[3] = v2[3]) and gluVectorEquals(PgluVector3f(@v1[0])^, PgluVector3f(@v2[0])^);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function gluVectorMult(const v: TgluVector2f; const s: Single): TgluVector2f;
begin
  result[0] := v[0] * s;
  result[1] := v[1] * s;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//multipliziert den Vektor mit einem Skalar
//@v: Vektor der multipliziert werden soll;
//@s: Skalar;
//@result: Elementweise multiplizierter Vektor;
function gluVectorMult(const v: TgluVector3f; const s: Single): TgluVector3f;
var
  i: Integer;
begin
  for i := 0 to 2 do
    result[i] := v[i] * s;
end;

function gluVectorMult(const v: TgluVector4f; const s: Single): TgluVector4f;
var
  i: Integer;
begin
  for i := 0 to 3 do
    result[i] := v[i] * s;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function gluVectorDivide(const v: TgluVector3f; const s: Single): TgluVector3f;
var
  i: Integer;
begin
  for i := 0 to 3 do
    result[i] := v[i] / s;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function gluVectorClamp(const v: TgluVector3f; const aMin, aMax: Single): TgluVector3f;
var i: Integer;
begin
  for i := 0 to High(v) do
    result[i] := Min(Max(v[i], aMin), aMax);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function gluVectorClamp(const v: TgluVector4f; const aMin, aMax: Single): TgluVector4f;
var i: Integer;
begin
  for i := 0 to High(v) do
    result[i] := Min(Max(v[i], aMin), aMax);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//addiert zwei Vektoren
//@v1: Vektor 1;
//@v2: Vektor 2;
//@result: elementweise Summe der beiden Vektoren;
function gluVectorAdd(const v1, v2: TgluVector3f): TgluVector3f;
var
  i: Integer;
begin
  for i := 0 to 2 do
    result[i] := v1[i] + v2[i];
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//subtrahiert zwei Vektoren
//@v1: Vektor 1;
//@v2: Vektor 2;
//@result: elementweise Differenz der beiden Vektoren;
function gluVectorSubtract(const v1, v2: TgluVector3f): TgluVector3f;
var
  i: Integer;
begin
  for i := 0 to 2 do
    result[i] := v1[i] - v2[i];
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function gluVectorAdd(const v1, v2: TgluVector2f): TgluVector2f;
begin
  result[0] := v1[0] + v2[0];
  result[1] := v1[1] + v2[1];
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function gluVectorSubtract(const v1, v2: TgluVector2f): TgluVector2f;
begin
  result[0] := v1[0] - v2[0];
  result[1] := v1[1] - v2[1];
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Verändert die Vektoren so, dass sie orthogonal und normalisiert sind, bleibt dabei in der gleichen Ebene
//@v1: Vektor 1;
//@v2: Vektor 2;
procedure gluVectorOrthoNormalize(var reference, tangent: TgluVector3f);
var
  proj: TgluVector3f;
begin
  reference:= gluVectorNormalize(reference);

  proj:= gluVectorMult(reference, gluVectorScalar(tangent, reference));
  tangent:= gluVectorSubtract(tangent, proj);
  tangent:= gluVectorNormalize(tangent);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//rechnet den übergebenen Vector in absolute (matrixunabhängige) Raumkoordinaten um
//@v: Vector dessen absolute Koordinaten bestimmt werden sollen;
//@result: absolute Raumkoordianten des Vectors v;
function gluGetAbsCoord(const v: TgluVector3f): TgluVector3f;
var
  v4: TgluVector4f;
  sum: Single;
  i, j: Integer;
  m: array[0..3, 0..3] of GLfloat;
begin
  for i := 0 to 2 do
    v4[i] := v[i];
  v4[3] := 1;
  glGetFloatv(GL_MODELVIEW_MATRIX, @m[0, 0]);
  for i := 0 to 2 do begin
    sum := 0;
    for j := 0 to 3 do begin
      sum := sum + m[j, i]*v4[j];
    end;
    result[i] := sum;
  end;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//berechnet eine Ebene die durch 3 Punkte bestimmt wird
//@p1: Punkt 1;
//@p2: Punkt 2, Punkt auf dem der Normalenvekrtor steht;
//@p3: Punkt 3;
//@result: Parameter der Ebene (0, 1, 2: Normalvektor; 3: Abstand);
function gluPlanef(const p1, p2, p3: TgluVector3f): TgluPlanef;
var
  n, v1, v2: TgluVector3f;
begin
  v1 := gluVector3f(p2, p1);
  v2 := gluVector3f(p2, p3);
  n := gluVectorProduct(v1, v2);
  result := gluPlanef(n, p2);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function gluPlanef(const n, p: TgluVector3f): TgluPlanef;
var
  d: Single;
begin
  d := gluVectorScalar(n, p);
  PgluVector3f(@result)^ := n;
  result[3] := -d;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//normalisiert die Parameter einer Ebene
//@p: Parameter der Ebene;
//@result: normalisierte Prameter der Ebene;
function gluPlaneNormalize(const p: TgluPlanef): TgluPlanef;
var
  m: Single;
  i: Integer;
begin
  m := Sqrt(Sqr(p[0]) + Sqr(p[1]) + Sqr(p[2]));
  for i := 0 to 3 do
    result[i] := p[i] / m;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function gluPlaneCrossRay(const aPlane: TgluPlanef; const aRay: TgluRayf; out aPoint: TgluVector3f): Boolean;
var
  lambda, real: Double;
  i: Integer;
begin
  result := false;
  lambda := 0;
  real   := 0;
  for i := 0 to 2 do begin
    lambda := lambda + aRay.v[i] * aPlane[i];
    real   := real   + aRay.p[i] * aPlane[i];
  end;
  if (lambda = 0) then begin
    aPoint := gluVector3f(0, 0, 0);
    exit;
  end;
  lambda := (aPlane[3] - real) / lambda;
  aPoint := gluRayPoint(aRay, -lambda);
  result := true;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function gluRayf(const p, v: TgluVector3f): TgluRayf;
begin
  result.p := p;
  result.v := v;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function gluRayNormalize(const r: TgluRayf): TgluRayf;
begin
  result.p := r.p;
  result.v := gluVectorNormalize(r.v);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function gluRayPoint(const r: TgluRayf; const lambda: Single): TgluVector3f;
begin
  result := gluVectorAdd(r.p, gluVectorMult(r.v, lambda));
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//schriebt die Werte des Vektors in einen String
//@v: Vektor der in einen String umgewandelt werden soll;
//@round: Anzahl der Stellen auf die gerundet werden soll;
//@result: String mit den erten des Vektors;
function gluVector4fToStr(const v: TgluVector4f; const round: Integer): String;
var
  f: TFormatSettings;
begin
  f.DecimalSeparator := '.';
  if (round >= 0) then
    result := Format('%.*f; %.*f; %.*f; %.*f;', [round, v[0], round, v[1], round, v[2], round, v[3]], f)
  else
    result := Format('%f; %f; %f; %f;', [v[0], v[1], v[2], v[3]], f);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//schriebt die Werte des Vektors in einen String
//@v: Vektor der in einen String umgewandelt werden soll;
//@round: Anzahl der Stellen auf die gerundet werden soll;
//@result: String mit den erten des Vektors;
function gluVector3fToStr(const v: TgluVector3f; const round: Integer): String;
var
  f: TFormatSettings;
begin
  f.DecimalSeparator := '.';
  if (round >= 0) then
    result := Format('%.*f; %.*f; %.*f;', [round, v[0], round, v[1], round, v[2]], f)
  else
    result := Format('%f; %f; %f;', [v[0], v[1], v[2]], f);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//schriebt die Werte des Vektors in einen String
//@v: Vektor der in einen String umgewandelt werden soll;
//@round: Anzahl der Stellen auf die gerundet werden soll;
//@result: String mit den erten des Vektors;
function gluVector2fToStr(const v: TgluVector2f; const round: Integer): String;
var
  f: TFormatSettings;
begin
  f.DecimalSeparator := '.';
  if (round >= 0) then
    result := Format('%.*f; %.*f;', [round, v[0], round, v[1]], f)
  else
    result := Format('%f; %f;', [v[0], v[1]], f);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function gluStrToVectorIntern(str: String; const aAbortOnFailure: Boolean; out aVec: TgluVector4f): Boolean;
var
  i, j, p, l: Integer;
  s: String;
  format: TFormatSettings;
  v: Single;
begin
  result := false;
  FillChar(aVec{%H-}, SizeOf(aVec), 0);
  FillChar(format{%H-}, SizeOf(format), 0);
  format.DecimalSeparator := '.';
  if (Length(str) > 0) and (str[Length(str)] <> ';') then
    str := str + ';';
  j := 0;
  i := 1;
  p := 1;
  l := Length(str);
  while (i <= l) do begin
    if str[i] = ';' then begin
      s := Trim(copy(str, p, i-p));
      if not TryStrToFloat(s, v, format) then begin
        if aAbortOnFailure then
          exit;
        v := 0;
      end;
      aVec[j] := v;
      inc(j);
      p := i+1;
    end;
    inc(i);
  end;
  result := true;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function gluTryStrToVector4f(str: String; out aVec: TgluVector4f): Boolean;
begin
  result := gluStrToVectorIntern(str, true, aVec);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function gluTryStrToVector3f(str: String; out aVec: TgluVector3f): Boolean;
var
  v: TgluVector4f;
begin
  if (Length(str) > 0) and (str[Length(str)] <> ';') then
    str := str + ';';
  result := gluTryStrToVector4f(str+'0;', v);
  aVec := PgluVector3f(@v[0])^;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function gluTryStrToVector2f(str: String; out aVec: TgluVector2f): Boolean;
var
  v: TgluVector4f;
begin
  if (Length(str) > 0) and (str[Length(str)] <> ';') then
    str := str + ';';
  result := gluTryStrToVector4f(str+'0;0;', v);
  aVec := PgluVector2f(@v[0])^;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//wandelt einen String in einen Vektor um
//@str: String der in den Vektor umgewandelt werden soll;
//@result: Vektor mit den Datein aus dem String;
function gluStrToVector4f(str: String): TgluVector4f;
begin
  gluStrToVectorIntern(str, false, result);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//wandelt einen String in einen Vektor um
//@str: String der in den Vektor umgewandelt werden soll;
//@result: Vektor mit den Datein aus dem String;
function gluStrToVector3f(str: String): TgluVector3f;
var
  v: TgluVector4f;
begin
  if (Length(str) > 0) and (str[Length(str)] <> ';') then
    str := str + ';';
  v := gluStrToVector4f(str+'0;');
  result := PgluVector3f(@v[0])^;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//wandelt einen String in einen Vektor um
//@str: String der in den Vektor umgewandelt werden soll;
//@result: Vektor mit den Datein aus dem String;
function gluStrToVector2f(str: String): TgluVector2f;
var
  v: TgluVector3f;
begin
  if (Length(str) > 0) and (str[Length(str)] <> ';') then
    str := str + ';';
  v := gluStrToVector3f(str+'0;');
  result := PgluVector2f(@v[0])^;
end;

function gluVector4iToStr(const v: TgluVector4i): String;
begin
  Result:= Format('%d;%d;%d;%d;',[v[0],v[1],v[2],v[3]]);
end;

function gluVector3iToStr(const v: TgluVector3i): String;
begin
  Result:= Format('%d;%d;%d;',[v[0],v[1],v[2]]);
end;

function gluVector2iToStr(const v: TgluVector2i): String;
begin
  Result:= Format('%d;%d;',[v[0],v[1]]);
end;

function gluStrToVector4i(const str: String): TgluVector4i;
var
  i, j, p, l: Integer;
  v: integer;
begin
  FillChar(result{%H-}, SizeOf(result), 0);
  j := 0;
  i := 1;
  p := 1;
  l := Length(str);
  while (i <= l) do begin
    if str[i] = ';' then begin
      if not TryStrToInt(copy(str, p, i-p), v) then
        v := 0;
      result[j] := v;
      inc(j);
      p := i+1;
    end;
    inc(i);
  end;
end;

function gluStrToVector3i(const str: String): TgluVector3i;
var
  v: TgluVector4i;
begin
  v := gluStrToVector4i(str+'0;');
  result := PgluVector3i(@v[0])^;
end;

function gluStrToVector2i(const str: String): TgluVector2i;
var
  v: TgluVector3i;
begin
  v := gluStrToVector3i(str+'0;');
  result := PgluVector2i(@v[0])^;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//wandelt einen Vektor in eine Farbe um
//@v: Vektor der umgewandelt werden soll;
//@result: Farbe;
function gluVectorToColor(const v: TgluVector4f): TVectorColor; overload;
begin
  result := gluVectorToColor(PgluVector3f(@v[0])^);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//wandelt einen Vektor in eine Farbe um
//@v: Vektor der umgewandelt werden soll;
//@result: Farbe;
function gluVectorToColor(const v: TgluVector3f): TVectorColor;
var
  r, g, b: Byte;
begin
  r := round(255*v[0]);
  g := round(255*v[1]);
  b := round(255*v[2]);
  result := r + (g shl 8) + (b shl 16);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function gluColorToVector3f(const c: TVectorColor): TgluVector3f;
begin
  result[0] := ( c         and $FF) / 255;
  result[1] := ((c shr  8) and $FF) / 255;
  result[2] := ((c shr 16) and $FF) / 255;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function gluColorToVector4f(const c: TVectorColor; const a: Single): TgluVector4f;
begin
  PgluVector3f(@result[0])^ := gluColorToVector3f(c);
  result[3] := a;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//rechnet eine Farbe im HSV-Farbraum in den RGB-Farbraum um
//@v: Farbe im HSV-Farbraum;
//@result: Farbe im RGB-Farbraum;
function gluVectorHSVColor(v: TgluVector3f): TgluVector3f;
const
  _H = 0;
  _S = 1;
  _V = 2;
var
  h: Integer;
  f, p, q, t: Single;
begin
  v[_H] := 360*v[_H];
//H normieren
  while (v[_H] < 0) do
    v[_H] := v[_H] + 360;
  while (v[_H] > 360) do
    v[_H] := v[_H] - 360;
//V normieren
  if (v[_V] < 0) then
    v[_V] := 0;
  if (v[_V] > 1) then
    v[_V] := 1;

  h := Floor(v[_H] / 60);
  f := v[_H]/60 - h;
  p := v[_V] * (1 - v[_S]);
  q := v[_V] * (1 - v[_S] * f);
  t := v[_V] * (1 - v[_S] * (1 - f));
  case h of
    1: result := gluVector3f(q, v[_V], p);
    2: result := gluVector3f(p, v[_V], t);
    3: result := gluVector3f(p, q, v[_V]);
    4: result := gluVector3f(t, p, v[_V]);
    5: result := gluVector3f(v[_V], p, q);
  else
    result := gluVector3f(v[_V], t, p);
  end;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//rechnet eine Farbe im HSV-Farbraum in den RGB-Farbraum um
//@v: Farbe im HSV-Farbraum;
//@result: Farbe im RGB-Farbraum;
function gluVectorHSVColor(v: TgluVector4f): TgluVector4f;
begin
  PgluVector3f(@result)^ := gluVectorHSVColor(PgluVector3f(@v)^);
  result[3] := v[3];
end;

end.