ugluVector.pas

   1 unit ugluVector;
   2
   3 { Package:      OpenGLCore
   4   Prefix:       glu - OpenGL Utils
   5   Beschreibung: diese Unit enthält Vektor-Typen und Methoden um diese zu erstellen und zu manipulieren }
   6
   7 {$mode objfpc}{$H+}
   8
   9 interface
  10
  11 uses
  12   Classes, SysUtils, {$IFNDEF OPENGL_ES}dglOpenGL{$ELSE}dglOpenGLES{$ENDIF};
  13
  14 type
  15   //Vektortypen
  16   TgluVector2ub = TGLVectorub2;
  17   TgluVector3ub = TGLVectorub3;
  18   TgluVector4ub = TGLVectorub4;
  19
  20   TgluVector2i = TGLVectori2;
  21   TgluVector3i = TGLVectori3;
  22   TgluVector4i = TGLVectori4;
  23
  24   TgluVector2e = array[0..1] of GLenum;
  25   TgluVector3e = array[0..2] of GLenum;
  26   TgluVector4e = array[0..3] of GLenum;
  27
  28   TgluVector2f = TGLVectorf2;
  29   TgluVector3f = TGLVectorf3;
  30   TgluVector4f = TGLVectorf4;
  31
  32   TgluVector2d = TGLVectord2;
  33   TgluVector3d = TGLVectord3;
  34   TgluVector4d = TGLVectord4;
  35
  36   TgluVector2p = TGLVectorp2;
  37   TgluVector3p = TGLVectorp3;
  38   TgluVector4p = TGLVectorp4;
  39
  40   TgluPlanef = TgluVector4f;
  41
  42   TgluVector3fArr8 = array[0..7] of TgluVector4f;
  43   TgluRayf = packed record
  44     p, v: TgluVector3f;
  45   end;
  46
  47   TgluRecord2ub = packed record
  48     case Integer of
  49       0: (x, y: gluByte);
  50       1: (s, t: gluByte);
  51       2: (u, v: gluByte);
  52       3: (vec: TgluVector2ub);
  53   end;
  54   TgluRecord3ub = packed record
  55     case Integer of
  56       0: (x, y, z: gluByte);
  57       1: (r, g, b: gluByte);
  58       2: (u, v, w: gluByte);
  59       3: (vec: TgluVector3ub);
  60   end;
  61   TgluRecord4ub = packed record
  62     case Integer of
  63       0: (x, y, z, w: gluByte);
  64       1: (r, g, b, a: gluByte);
  65       2: (vec: TgluVector4ub);
  66   end;
  67
  68   TgluRecord2i = packed record
  69     case Integer of
  70       0: (x, y: glInt);
  71       1: (s, t: glInt);
  72       2: (u, v: glInt);
  73       3: (vec: TgluVector2i);
  74   end;
  75   TgluRecord3i = packed record
  76     case Integer of
  77       0: (x, y, z: glInt);
  78       1: (r, g, b: glInt);
  79       2: (u, v, w: glInt);
  80       3: (vec: TgluVector3i);
  81   end;
  82   TgluRecord4i = packed record
  83     case Integer of
  84       0: (x, y, z, w: glInt);
  85       1: (r, g, b, a: glInt);
  86       2: (vec: TgluVector4i);
  87   end;
  88
  89   TgluRecord2f = packed record
  90     case Integer of
  91       0: (x, y: glFloat);
  92       1: (s, t: glFloat);
  93       2: (u, v: glFloat);
  94       3: (vec: TgluVector2f);
  95   end;
  96   TgluRecord3f = packed record
  97     case Integer of
  98       0: (x, y, z: glFloat);
  99       1: (r, g, b: glFloat);
 100       2: (u, v, w: glFloat);
 101       3: (vec: TgluVector3f);
 102   end;
 103   TgluRecord4f = packed record
 104     case Integer of
 105       0: (x, y, z, w: glFloat);
 106       1: (r, g, b, a: glFloat);
 107       2: (vec4: TgluVector4f);
 108       3: (vec3: TgluVector3f);
 109   end;
 110
 111   TgluRecord2d = packed record
 112     case Integer of
 113       0: (x, y: glDouble);
 114       1: (s, t: glDouble);
 115       2: (u, v: glDouble);
 116       3: (vec: TgluVector2d);
 117   end;
 118   TgluRecord3d = packed record
 119     case Integer of
 120       0: (x, y, z: glDouble);
 121       1: (r, g, b: glDouble);
 122       2: (u, v, w: glDouble);
 123       3: (vec: TgluVector3d);
 124   end;
 125   TgluRecord4d = packed record
 126     case Integer of
 127       0: (x, y, z, w: glDouble);
 128       1: (r, g, b, a: glDouble);
 129       2: (vec: TgluVector4d);
 130   end;
 131
 132   //VectorPointer
 133   PgluVector2i = ^TgluVector2i;
 134   PgluVector3i = ^TgluVector3i;
 135   PgluVector4i = ^TgluVector4i;
 136
 137   PgluVector2e = ^TgluVector2e;
 138   PgluVector3e = ^TgluVector3e;
 139   PgluVector4e = ^TgluVector4e;
 140
 141   PgluVector2ub = ^TgluVector2ub;
 142   PgluVector3ub = ^TgluVector3ub;
 143   PgluVector4ub = ^TgluVector4ub;
 144
 145   PgluVector2f = ^TgluVector2f;
 146   PgluVector3f = ^TgluVector3f;
 147   PgluVector4f = ^TgluVector4f;
 148
 149   PgluVector2d = ^TgluVector2d;
 150   PgluVector3d = ^TgluVector3d;
 151   PgluVector4d = ^TgluVector4d;
 152
 153   PgluVector2p = ^TgluVector2p;
 154   PgluVector3p = ^TgluVector3p;
 155   PgluVector4p = ^TgluVector4p;
 156
 157   TVectorColor = -$7FFFFFFF-1..$7FFFFFFF;
 158
 159   //Stream: Lese- und Schreibfunktionen
 160   procedure gluVector2fWrite(const vec: TgluVector2f; const aStream: TStream);
 161   procedure gluVector3fWrite(const vec: TgluVector3f; const aStream: TStream);
 162   procedure gluVector4fWrite(const vec: TgluVector4f; const aStream: TStream);
 163   function  gluVector2fRead(const aStream: TStream): TgluVector2f;
 164   function  gluVector3fRead(const aStream: TStream): TgluVector3f;
 165   function  gluVector4fRead(const aStream: TStream): TgluVector4f;
 166
 167   //Vektor Konstruktoren
 168   function gluVector4f(const X, Y, Z, W: Single): TgluVector4f;
 169   function gluVector4f(const aVec: TgluVector3f; const W: Single): TgluVector4f;
 170   function gluVector4d(const X, Y, Z, W: Single): TgluVector4d;
 171   function gluVector3f(const X, Y, Z: Single): TgluVector3f; overload;
 172   function gluVector3f(const v: TgluVector4f): TgluVector3f; overload;
 173   function gluVector3f(const v: TgluVector2f; const z: Single): TgluVector3f; overload;
 174   function gluVector3f(const p1, p2: TgluVector3f): TgluVector3f; overload;
 175   function gluVector2f(const X, Y: Single): TgluVector2f;
 176   function gluVector2f(const v3: TgluVector3f): TgluVector2f;
 177   function gluVector2f(const v4: TgluVector4f): TgluVector2f;
 178   function gluVector4i(const W, X, Y, Z: Integer): TgluVector4i;
 179   function gluVector2i(const X, Y: Integer): TgluVector2i;
 180   function gluVector2e(const X, Y: GLenum): TgluVector2e;
 181   function gluVector3e(const X, Y, Z: GLenum): TgluVector3e;
 182   function gluVector4e(const X, Y, Z, W: GLenum): TgluVector4e;
 183
 184   //Vektorfunktionen
 185   function gluVectorNormalize(const v: TgluVector4f): TgluVector4f; overload;
 186   function gluVectorNormalize(const v: TgluVector3f): TgluVector3f; overload;
 187   function gluVectorNormalize(const v: TgluVector2f): TgluVector2f; overload;
 188   function gluVectorLength(const v: TgluVector3f): Single; overload;
 189   function gluVectorLength(const v: TgluVector2f): Single; overload;
 190   function gluVectorProduct(const v1, v2: TgluVector3f): TgluVector3f;
 191   function gluVectorScalar(const v1, v2: TgluVector4f): Single; overload;
 192   function gluVectorScalar(const v1, v2: TgluVector3f): Single; overload;
 193   function gluVectorScalar(const v1, v2: TgluVector2f): Single; overload;
 194   function gluVectorAngle(const v1, v2: TgluVector3f): Single; overload;
 195   function gluVectorAngle(const v1, v2: TgluVector2f): Single; overload;
 196   function gluVectorEquals(const v1, v2: TgluVector2f): Boolean; overload;
 197   function gluVectorEquals(const v1, v2: TgluVector3f): Boolean; overload;
 198   function gluVectorEquals(const v1, v2: TgluVector4f): Boolean; overload;
 199   function gluVectorMult(const v: TgluVector2f; const s: Single): TgluVector2f;
 200   function gluVectorMult(const v: TgluVector3f; const s: Single): TgluVector3f;
 201   function gluVectorMult(const v: TgluVector4f; const s: Single): TgluVector4f;
 202   function gluVectorDivide(const v: TgluVector3f; const s: Single): TgluVector3f;
 203   function gluVectorClamp(const v: TgluVector3f; const aMin, aMax: Single): TgluVector3f; overload;
 204   function gluVectorClamp(const v: TgluVector4f; const aMin, aMax: Single): TgluVector4f; overload;
 205   function gluVectorAdd(const v1, v2: TgluVector3f): TgluVector3f;
 206   function gluVectorSubtract(const v1, v2: TgluVector3f): TgluVector3f;
 207   procedure gluVectorOrthoNormalize(var reference, tangent: TgluVector3f);
 208   function gluGetAbsCoord(const v: TgluVector3f): TgluVector3f;
 209
 210   //Ebnenfunktionen
 211   function gluPlanef(const p1, p2, p3: TgluVector3f): TgluPlanef;
 212   function gluPlanef(const n, p: TgluVector3f): TgluPlanef;
 213   function gluPlaneNormalize(const p: TgluPlanef): TgluPlanef;
 214   function gluPlaneCrossRay(const aPlane: TgluPlanef; const aRay: TgluRayf; out aPoint: TgluVector3f): Boolean;
 215
 216   //Rayfunktionen
 217   function gluRayf(const p, v: TgluVector3f): TgluRayf;
 218   function gluRayNormalize(const r: TgluRayf): TgluRayf;
 219   function gluRayPoint(const r: TgluRayf; const lambda: Single): TgluVector3f;
 220
 221   //Vektor Aus- und Eingaben
 222   function gluVector4fToStr(const v: TgluVector4f; const round: Integer = 3): String;
 223   function gluVector3fToStr(const v: TgluVector3f; const round: Integer = 3): String;
 224   function gluVector2fToStr(const v: TgluVector2f; const round: Integer = 3): String;
 225   function gluTryStrToVector4f(str: String; out aVec: TgluVector4f): Boolean;
 226   function gluTryStrToVector3f(str: String; out aVec: TgluVector3f): Boolean;
 227   function gluTryStrToVector2f(str: String; out aVec: TgluVector2f): Boolean;
 228   function gluStrToVector4f(str: String): TgluVector4f;
 229   function gluStrToVector3f(str: String): TgluVector3f;
 230   function gluStrToVector2f(str: String): TgluVector2f;
 231   function gluVector4iToStr(const v: TgluVector4i): String;
 232   function gluVector3iToStr(const v: TgluVector3i): String;
 233   function gluVector2iToStr(const v: TgluVector2i): String;
 234   function gluStrToVector4i(const str: String): TgluVector4i;
 235   function gluStrToVector3i(const str: String): TgluVector3i;
 236   function gluStrToVector2i(const str: String): TgluVector2i;
 237   function gluVectorToColor(const v: TgluVector4f): TVectorColor; overload;
 238   function gluVectorToColor(const v: TgluVector3f): TVectorColor; overload;
 239   function gluColorToVector3f(const c: TVectorColor): TgluVector3f;
 240   function gluColorToVector4f(const c: TVectorColor; const a: Single): TgluVector4f;
 241   function gluVectorHSVColor(v: TgluVector3f): TgluVector3f; overload;
 242   function gluVectorHSVColor(v: TgluVector4f): TgluVector4f; overload;
 243
 244   operator >< (const v1, v2: TgluVector3f): TgluVector3f; inline;
 245
 246   operator * (const v1, v2: TgluVector4f): Single; inline; overload;
 247   operator * (const v1, v2: TgluVector3f): Single; inline; overload;
 248   operator * (const v1, v2: TgluVector2f): Single; inline; overload;
 249
 250   operator * (const v: TgluVector2f; const s: Single): TgluVector2f; inline; overload;
 251   operator * (const v: TgluVector3f; const s: Single): TgluVector3f; inline; overload;
 252   operator * (const v: TgluVector4f; const s: Single): TgluVector4f; inline; overload;
 253
 254   operator * (const s: Single; const v: TgluVector2f): TgluVector2f; inline; overload;
 255   operator * (const s: Single; const v: TgluVector3f): TgluVector3f; inline; overload;
 256   operator * (const s: Single; const v: TgluVector4f): TgluVector4f; inline; overload;
 257
 258   operator / (const v: TgluVector3f; const s: Single): TgluVector3f; inline; overload;
 259
 260   operator = (const v1, v2: TgluVector2f): Boolean; inline; overload;
 261   operator = (const v1, v2: TgluVector3f): Boolean; inline; overload;
 262   operator = (const v1, v2: TgluVector4f): Boolean; inline; overload;
 263
 264   operator + (const v1, v2: TgluVector3f): TgluVector3f; inline;
 265   operator - (const v1, v2: TgluVector3f): TgluVector3f; inline;
 266
 267 const
 268   gluVectorNull : TgluVector3f = (0,0,0);
 269   gluVectorUnitX: TgluVector3f = (1,0,0);
 270   gluVectorUnitY: TgluVector3f = (0,1,0);
 271   gluVectorUnitZ: TgluVector3f = (0,0,1);
 272
 273 implementation
 274
 275 uses
 276   Math;
 277
 278 operator >< (const v1, v2: TgluVector3f): TgluVector3f;
 279 begin
 280   result := gluVectorProduct(v1, v2);
 281 end;
 282
 283 operator * (const v1, v2: TgluVector4f): Single;
 284 begin
 285   result := gluVectorScalar(v1, v2);
 286 end;
 287
 288 operator * (const v1, v2: TgluVector3f): Single;
 289 begin
 290   result := gluVectorScalar(v1, v2);
 291 end;
 292
 293 operator * (const v1, v2: TgluVector2f): Single;
 294 begin
 295   result := gluVectorScalar(v1, v2);
 296 end;
 297
 298 operator * (const v: TgluVector2f; const s: Single): TgluVector2f;
 299 begin
 300   result := gluVectorMult(v, s);
 301 end;
 302
 303 operator * (const v: TgluVector3f; const s: Single): TgluVector3f;
 304 begin
 305   result := gluVectorMult(v, s);
 306 end;
 307
 308 operator * (const v: TgluVector4f; const s: Single): TgluVector4f;
 309 begin
 310   result := gluVectorMult(v, s);
 311 end;
 312
 313 operator * (const s: Single; const v: TgluVector2f): TgluVector2f;
 314 begin
 315   result := gluVectorMult(v, s);
 316 end;
 317
 318 operator * (const s: Single; const v: TgluVector3f): TgluVector3f;
 319 begin
 320   result := gluVectorMult(v, s);
 321 end;
 322
 323 operator * (const s: Single; const v: TgluVector4f): TgluVector4f;
 324 begin
 325   result := gluVectorMult(v, s);
 326 end;
 327
 328 operator / (const v: TgluVector3f; const s: Single): TgluVector3f;
 329 begin
 330   result := gluVectorDivide(v, s);
 331 end;
 332
 333 operator = (const v1, v2: TgluVector2f): Boolean;
 334 begin
 335   result := gluVectorEquals(v1, v2);
 336 end;
 337
 338 operator = (const v1, v2: TgluVector3f): Boolean;
 339 begin
 340   result := gluVectorEquals(v1, v2);
 341 end;
 342
 343 operator = (const v1, v2: TgluVector4f): Boolean;
 344 begin
 345   result := gluVectorEquals(v1, v2);
 346 end;
 347
 348 operator + (const v1, v2: TgluVector3f): TgluVector3f;
 349 begin
 350   result := gluVectorAdd(v1, v2);
 351 end;
 352
 353 operator - (const v1, v2: TgluVector3f): TgluVector3f;
 354 begin
 355   result := gluVectorSubtract(v1, v2);
 356 end;
 357
 358 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 359 //speichert einen Vector in einem Stream
 360 //@vec: Vector die gespeichert werden soll;
 361 //@aStream: Stream in dem gespeichert werden soll;
 362 procedure gluVector2fWrite(const vec: TgluVector2f; const aStream: TStream);
 363 begin
 364   aStream.Write(vec[0], SizeOf(vec));
 365 end;
 366
 367 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 368 //speichert einen Vector in einem Stream
 369 //@vec: Vector die gespeichert werden soll;
 370 //@aStream: Stream in dem gespeichert werden soll;
 371 procedure gluVector3fWrite(const vec: TgluVector3f; const aStream: TStream);
 372 begin
 373   aStream.Write(vec[0], SizeOf(vec));
 374 end;
 375
 376 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 377 //speichert einen Vector in einem Stream
 378 //@vec: Vector die gespeichert werden soll;
 379 //@aStream: Stream in dem gespeichert werden soll;
 380 procedure gluVector4fWrite(const vec: TgluVector4f; const aStream: TStream);
 381 begin
 382   aStream.Write(vec[0], SizeOf(vec));
 383 end;
 384
 385 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 386 //ließt einen Vector aus einem Stream
 387 //@aStream: Stream aus dem gelesen werden soll;
 388 //@result: gelesene Werte des Vectors;
 389 //@throw: Exception;
 390 function  gluVector2fRead(const aStream: TStream): TgluVector2f;
 391 begin
 392   if aStream.Read(result{%H-}, SizeOf(result)) < SizeOf(result) then
 393     raise Exception.Create('gluVector2fRead - unexpected stream size');
 394 end;
 395
 396 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 397 //ließt einen Vector aus einem Stream
 398 //@aStream: Stream aus dem gelesen werden soll;
 399 //@result: gelesene Werte des Vectors;
 400 //@throw: Exception;
 401 function gluVector3fRead(const aStream: TStream): TgluVector3f;
 402 begin
 403   if aStream.Read(result{%H-}, SizeOf(result)) < SizeOf(result) then
 404     raise Exception.Create('gluVector3fRead - unexpected stream size');
 405 end;
 406
 407 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 408 //ließt einen Vector aus einem Stream
 409 //@aStream: Stream aus dem gelesen werden soll;
 410 //@result: gelesene Werte des Vectors;
 411 //@throw: Exception;
 412 function gluVector4fRead(const aStream: TStream): TgluVector4f;
 413 begin
 414   if aStream.Read(result{%H-}, SizeOf(result)) < SizeOf(result) then
 415     raise Exception.Create('gluVector4fRead - unexpected stream size');
 416 end;
 417
 418 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 419 //erstellt einen Vector
 420 //@W: 1. Wert im Vector;
 421 //@X: 2. Wert im Vector;
 422 //@Y: 3. Wert im Vector;
 423 //@Z: 4. Wert im Vector;
 424 function gluVector4f(const X,Y,Z,W: Single): TgluVector4f;
 425 begin
 426   result[0] := X;
 427   result[1] := Y;
 428   result[2] := Z;
 429   result[3] := W;
 430 end;
 431
 432 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 433 function gluVector4f(const aVec: TgluVector3f; const W: Single): TgluVector4f;
 434 begin
 435   PgluVector3f(@result[0])^ := aVec;
 436   result[3] := W;
 437 end;
 438
 439 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 440 //erstellt einen Vector
 441 //@W: 1. Wert im Vector;
 442 //@X: 2. Wert im Vector;
 443 //@Y: 3. Wert im Vector;
 444 //@Z: 4. Wert im Vector;
 445 function gluVector4d(const X,Y,Z,W: Single): TgluVector4d;
 446 begin
 447   result[0] := X;
 448   result[1] := Y;
 449   result[2] := Z;
 450   result[3] := W;
 451 end;
 452
 453 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 454 //erstellt einen Vector
 455 //@X: 1. Wert im Vector;
 456 //@Y: 2. Wert im Vector;
 457 //@Z: 3. Wert im Vector;
 458 function gluVector3f(const X,Y,Z: Single): TgluVector3f;
 459 begin
 460   result[0] := X;
 461   result[1] := Y;
 462   result[2] := Z;
 463 end;
 464
 465 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 466 //erstellt einen Vector
 467 //@v: 4-Komponenten Vektor aus dem der Vektor erstellt werden soll;
 468 function gluVector3f(const v: TgluVector4f): TgluVector3f;
 469 begin
 470   result := PgluVector3f(@v[0])^;
 471 end;
 472
 473 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 474 function gluVector3f(const v: TgluVector2f; const z: Single): TgluVector3f;
 475 begin
 476   result[0] := v[0];
 477   result[1] := v[1];
 478   result[2] := z;
 479 end;
 480
 481 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 482 //erzeugt einen Vektor aus 2 Punkten
 483 //@p1: Punkt 1;
 484 //@p2: Punkt 2;
 485 //@result: Vektor zwischen den Punkten
 486 function gluVector3f(const p1, p2: TgluVector3f): TgluVector3f;
 487 var
 488   i: Integer;
 489 begin
 490   for i := 0 to 2 do
 491     result[i] := p2[i] - p1[i];
 492 end;
 493
 494 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 495 //erstellt einen Vector
 496 //@X: 1. Wert im Vector;
 497 //@Y: 2. Wert im Vector;
 498 function gluVector2f(const X,Y: Single): TgluVector2f;
 499 begin
 500   result[0] := X;
 501   result[1] := Y;
 502 end;
 503
 504 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 505 function gluVector2f(const v3: TgluVector3f): TgluVector2f;
 506 begin
 507   result[0] := v3[0];
 508   result[1] := v3[1];
 509 end;
 510
 511 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 512 function gluVector2f(const v4: TgluVector4f): TgluVector2f;
 513 begin
 514   result[0] := v4[0];
 515   result[1] := v4[1];
 516 end;
 517
 518 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 519 //erstellt einen Vector
 520 //@W: 1. Wert im Vector;
 521 //@X: 2. Wert im Vector;
 522 //@Y: 3. Wert im Vector;
 523 //@Z: 4. Wert im Vector;
 524 function  gluVector4i(const W, X, Y, Z: Integer): TgluVector4i;
 525 begin
 526   result[0] := W;
 527   result[1] := X;
 528   result[2] := Y;
 529   result[3] := Z;
 530 end;
 531
 532 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 533 //erstellt einen Vector
 534 //@W: 1. Wert im Vector;
 535 //@X: 2. Wert im Vector;
 536 //@Y: 3. Wert im Vector;
 537 //@Z: 4. Wert im Vector;
 538 function  gluVector2i(const X, Y: Integer): TgluVector2i;
 539 begin
 540   result[0] := X;
 541   result[1] := Y;
 542 end;
 543
 544 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 545 function gluVector2e(const X, Y: GLenum): TgluVector2e;
 546 begin
 547   result[0] := X;
 548   result[1] := Y;
 549 end;
 550
 551 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 552 function gluVector3e(const X, Y, Z: GLenum): TgluVector3e;
 553 begin
 554   result[0] := X;
 555   result[1] := Y;
 556   result[2] := Z;
 557 end;
 558
 559 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 560 function gluVector4e(const X, Y, Z, W: GLenum): TgluVector4e;
 561 begin
 562   result[0] := X;
 563   result[1] := Y;
 564   result[2] := Z;
 565   result[3] := W;
 566 end;
 567
 568 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 569 function gluVectorNormalize(const v: TgluVector4f): TgluVector4f;
 570 begin
 571   result := v;
 572   if (result[3] <> 0) then
 573     result := gluVectorMult(result, result[3]);
 574   PgluVector3f(@result[0])^ := gluVectorNormalize(PgluVector3f(@result[0])^);
 575 end;
 576
 577 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 578 //Normalisiert einen Vector
 579 //@v: Vector der normalisiert werden soll;
 580 //@result: normalisierter Vector;
 581 function gluVectorNormalize(const v: TgluVector3f): TgluVector3f;
 582 var len: Single;
 583 begin
 584   len := gluVectorLength(v);
 585   if (len > 0) then begin
 586     result[0] := v[0]/len;
 587     result[1] := v[1]/len;
 588     result[2] := v[2]/len;
 589   end;
 590 end;
 591
 592 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 593 //Normalisiert einen Vector
 594 //@v: Vector der normalisiert werden soll;
 595 //@result: normalisierter Vector;
 596 function gluVectorNormalize(const v: TgluVector2f): TgluVector2f;
 597 var len: Single;
 598 begin
 599   len := gluVectorLength(v);
 600   result[0] := v[0]/len;
 601   result[1] := v[1]/len;
 602 end;
 603
 604 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 605 //berechnet die Länge eines Vectors
 606 //@v: Vector dessen Länge berechnet werden soll;
 607 //@result: Lange des Vectors;
 608 function gluVectorLength(const v: TgluVector3f): Single;
 609 begin
 610   result := SQRT(SQR(v[0])+SQR(v[1])+SQR(v[2]));
 611 end;
 612
 613 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 614 //berechnet die Länge eines Vectors
 615 //@v: Vector dessen Länge berechnet werden soll;
 616 //@result: Lange des Vectors;
 617 function gluVectorLength(const v: TgluVector2f): Single;
 618 begin
 619   result := SQRT(SQR(v[0])+SQR(v[1]));
 620 end;
 621
 622 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 623 //Berechnet das VektorProdukt aus den Übergebenen Vektoren
 624 //@v1: 1. Vektor;
 625 //@v2: 2. Vektor;
 626 //@result: Vektor des Vektorprodukts aus v1 und v2;
 627 function gluVectorProduct(const v1, v2: TgluVector3f): TgluVector3f;
 628 begin
 629   result[0] := v1[1]*v2[2] - v1[2]*v2[1];
 630   result[1] := v1[2]*v2[0] - v1[0]*v2[2];
 631   result[2] := v1[0]*v2[1] - v1[1]*v2[0];
 632 end;
 633
 634 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 635 //Berechnet das Skalarprodukt der übergebenen Vektoren
 636 //@v1: 1. vektor;
 637 //@v2: 2. Vektor;
 638 //@result: Skalprodukt aus v1 und v2;
 639 function gluVectorScalar(const v1, v2: TgluVector4f): Single; overload;
 640 begin
 641   result := v1[0]*v2[0] + v1[1]*v2[1] + v1[2]*v2[2] + v1[3]*v2[3];
 642 end;
 643
 644 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 645 //Berechnet das Skalarprodukt der übergebenen Vektoren
 646 //@v1: 1. vektor;
 647 //@v2: 2. Vektor;
 648 //@result: Skalprodukt aus v1 und v2;
 649 function gluVectorScalar(const v1, v2: TgluVector3f): Single;
 650 begin
 651   result := v1[0]*v2[0] + v1[1]*v2[1] + v1[2]*v2[2];
 652 end;
 653
 654 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 655 //Berechnet das Skalarprodukt der übergebenen Vektoren
 656 //@v1: 1. vektor;
 657 //@v2: 2. Vektor;
 658 //@result: Skalprodukt aus v1 und v2;
 659 function gluVectorScalar(const v1, v2: TgluVector2f): Single;
 660 begin
 661   result := v1[0]*v2[0] + v1[1]*v2[1];
 662 end;
 663
 664 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 665 //Berechnet den Winkel zwischen den übergebenen Vectoren
 666 //@v1: 1. vektor;
 667 //@v2: 2. Vektor;
 668 //@result: Winkel zwischen v1 und v2;
 669 function gluVectorAngle(const v1, v2: TgluVector3f): Single;
 670 begin
 671   result := ArcCos(gluVectorScalar(v1, v2)/(gluVectorLength(v1)*gluVectorLength(v2)));
 672 end;
 673
 674 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 675 //Berechnet den Winkel zwischen den übergebenen Vectoren
 676 //@v1: 1. vektor;
 677 //@v2: 2. Vektor;
 678 //@result: Winkel zwischen v1 und v2;
 679 function gluVectorAngle(const v1, v2: TgluVector2f): Single;
 680 begin
 681   result := ArcCos(gluVectorScalar(v1, v2)/(gluVectorLength(v1)*gluVectorLength(v2)));
 682 end;
 683
 684 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 685 function gluVectorEquals(const v1, v2: TgluVector2f): Boolean;
 686 begin
 687   result := (v1[0] = v2[0]) and (v1[1] = v2[1]);
 688 end;
 689
 690 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 691 function gluVectorEquals(const v1, v2: TgluVector3f): Boolean;
 692 begin
 693   result := (v1[2] = v2[2]) and gluVectorEquals(PgluVector2f(@v1[0])^, PgluVector2f(@v2[0])^);
 694 end;
 695
 696 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 697 function gluVectorEquals(const v1, v2: TgluVector4f): Boolean;
 698 begin
 699   result := (v1[3] = v2[3]) and gluVectorEquals(PgluVector3f(@v1[0])^, PgluVector3f(@v2[0])^);
 700 end;
 701
 702 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 703 function gluVectorMult(const v: TgluVector2f; const s: Single): TgluVector2f;
 704 begin
 705   result[0] := v[0] * s;
 706   result[1] := v[1] * s;
 707 end;
 708
 709 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 710 //multipliziert den Vektor mit einem Skalar
 711 //@v: Vektor der multipliziert werden soll;
 712 //@s: Skalar;
 713 //@result: Elementweise multiplizierter Vektor;
 714 function gluVectorMult(const v: TgluVector3f; const s: Single): TgluVector3f;
 715 var
 716   i: Integer;
 717 begin
 718   for i := 0 to 2 do
 719     result[i] := v[i] * s;
 720 end;
 721
 722 function gluVectorMult(const v: TgluVector4f; const s: Single): TgluVector4f;
 723 var
 724   i: Integer;
 725 begin
 726   for i := 0 to 3 do
 727     result[i] := v[i] * s;
 728 end;
 729
 730 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 731 function gluVectorDivide(const v: TgluVector3f; const s: Single): TgluVector3f;
 732 var
 733   i: Integer;
 734 begin
 735   for i := 0 to 3 do
 736     result[i] := v[i] / s;
 737 end;
 738
 739 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 740 function gluVectorClamp(const v: TgluVector3f; const aMin, aMax: Single): TgluVector3f;
 741 var i: Integer;
 742 begin
 743   for i := 0 to High(v) do
 744     result[i] := Min(Max(v[i], aMin), aMax);
 745 end;
 746
 747 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 748 function gluVectorClamp(const v: TgluVector4f; const aMin, aMax: Single): TgluVector4f;
 749 var i: Integer;
 750 begin
 751   for i := 0 to High(v) do
 752     result[i] := Min(Max(v[i], aMin), aMax);
 753 end;
 754
 755 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 756 //addiert zwei Vektoren
 757 //@v1: Vektor 1;
 758 //@v2: Vektor 2;
 759 //@result: elementweise Summe der beiden Vektoren;
 760 function gluVectorAdd(const v1, v2: TgluVector3f): TgluVector3f;
 761 var
 762   i: Integer;
 763 begin
 764   for i := 0 to 2 do
 765     result[i] := v1[i] + v2[i];
 766 end;
 767
 768 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 769 //subtrahiert zwei Vektoren
 770 //@v1: Vektor 1;
 771 //@v2: Vektor 2;
 772 //@result: elementweise Differenz der beiden Vektoren;
 773 function gluVectorSubtract(const v1, v2: TgluVector3f): TgluVector3f;
 774 var
 775   i: Integer;
 776 begin
 777   for i := 0 to 2 do
 778     result[i] := v1[i] - v2[i];
 779 end;
 780
 781 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 782 //Verändert die Vektoren so, dass sie orthogonal und normalisiert sind, bleibt dabei in der gleichen Ebene
 783 //@v1: Vektor 1;
 784 //@v2: Vektor 2;
 785 procedure gluVectorOrthoNormalize(var reference, tangent: TgluVector3f);
 786 var
 787   proj: TgluVector3f;
 788 begin
 789   reference:= gluVectorNormalize(reference);
 790
 791   proj:= gluVectorMult(reference, gluVectorScalar(tangent, reference));
 792   tangent:= gluVectorSubtract(tangent, proj);
 793   tangent:= gluVectorNormalize(tangent);
 794 end;
 795
 796 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 797 //rechnet den übergebenen Vector in absolute (matrixunabhängige) Raumkoordinaten um
 798 //@v: Vector dessen absolute Koordinaten bestimmt werden sollen;
 799 //@result: absolute Raumkoordianten des Vectors v;
 800 function gluGetAbsCoord(const v: TgluVector3f): TgluVector3f;
 801 var
 802   v4: TgluVector4f;
 803   sum: Single;
 804   i, j: Integer;
 805   m: array[0..3, 0..3] of GLfloat;
 806 begin
 807   for i := 0 to 2 do
 808     v4[i] := v[i];
 809   v4[3] := 1;
 810   glGetFloatv(GL_MODELVIEW_MATRIX, @m[0, 0]);
 811   for i := 0 to 2 do begin
 812     sum := 0;
 813     for j := 0 to 3 do begin
 814       sum := sum + m[j, i]*v4[j];
 815     end;
 816     result[i] := sum;
 817   end;
 818 end;
 819
 820 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 821 //berechnet eine Ebene die durch 3 Punkte bestimmt wird
 822 //@p1: Punkt 1;
 823 //@p2: Punkt 2, Punkt auf dem der Normalenvekrtor steht;
 824 //@p3: Punkt 3;
 825 //@result: Parameter der Ebene (0, 1, 2: Normalvektor; 3: Abstand);
 826 function gluPlanef(const p1, p2, p3: TgluVector3f): TgluPlanef;
 827 var
 828   n, v1, v2: TgluVector3f;
 829 begin
 830   v1 := gluVector3f(p2, p1);
 831   v2 := gluVector3f(p2, p3);
 832   n := gluVectorProduct(v1, v2);
 833   result := gluPlanef(n, p2);
 834 end;
 835
 836 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 837 function gluPlanef(const n, p: TgluVector3f): TgluPlanef;
 838 var
 839   d: Single;
 840 begin
 841   d := gluVectorScalar(n, p);
 842   PgluVector3f(@result)^ := n;
 843   result[3] := -d;
 844 end;
 845
 846 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 847 //normalisiert die Parameter einer Ebene
 848 //@p: Parameter der Ebene;
 849 //@result: normalisierte Prameter der Ebene;
 850 function gluPlaneNormalize(const p: TgluPlanef): TgluPlanef;
 851 var
 852   m: Single;
 853   i: Integer;
 854 begin
 855   m := Sqrt(Sqr(p[0]) + Sqr(p[1]) + Sqr(p[2]));
 856   for i := 0 to 3 do
 857     result[i] := p[i] / m;
 858 end;
 859
 860 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 861 function gluPlaneCrossRay(const aPlane: TgluPlanef; const aRay: TgluRayf; out aPoint: TgluVector3f): Boolean;
 862 var
 863   lambda, real: Double;
 864   i: Integer;
 865 begin
 866   result := false;
 867   lambda := 0;
 868   real   := 0;
 869   for i := 0 to 2 do begin
 870     lambda := lambda + aRay.v[i] * aPlane[i];
 871     real   := real   + aRay.p[i] * aPlane[i];
 872   end;
 873   if (lambda = 0) then begin
 874     aPoint := gluVector3f(0, 0, 0);
 875     exit;
 876   end;
 877   lambda := (aPlane[3] - real) / lambda;
 878   aPoint := gluRayPoint(aRay, -lambda);
 879   result := true;
 880 end;
 881
 882 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 883 function gluRayf(const p, v: TgluVector3f): TgluRayf;
 884 begin
 885   result.p := p;
 886   result.v := v;
 887 end;
 888
 889 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 890 function gluRayNormalize(const r: TgluRayf): TgluRayf;
 891 begin
 892   result.p := r.p;
 893   result.v := gluVectorNormalize(r.v);
 894 end;
 895
 896 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 897 function gluRayPoint(const r: TgluRayf; const lambda: Single): TgluVector3f;
 898 begin
 899   result := gluVectorAdd(r.p, gluVectorMult(r.v, lambda));
 900 end;
 901
 902 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 903 //schriebt die Werte des Vektors in einen String
 904 //@v: Vektor der in einen String umgewandelt werden soll;
 905 //@round: Anzahl der Stellen auf die gerundet werden soll;
 906 //@result: String mit den erten des Vektors;
 907 function gluVector4fToStr(const v: TgluVector4f; const round: Integer): String;
 908 var
 909   f: TFormatSettings;
 910 begin
 911   f.DecimalSeparator := '.';
 912   if (round >= 0) then
 913     result := Format('%.*f; %.*f; %.*f; %.*f;', [round, v[0], round, v[1], round, v[2], round, v[3]], f)
 914   else
 915     result := Format('%f; %f; %f; %f;', [v[0], v[1], v[2], v[3]], f);
 916 end;
 917
 918 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 919 //schriebt die Werte des Vektors in einen String
 920 //@v: Vektor der in einen String umgewandelt werden soll;
 921 //@round: Anzahl der Stellen auf die gerundet werden soll;
 922 //@result: String mit den erten des Vektors;
 923 function gluVector3fToStr(const v: TgluVector3f; const round: Integer): String;
 924 var
 925   f: TFormatSettings;
 926 begin
 927   f.DecimalSeparator := '.';
 928   if (round >= 0) then
 929     result := Format('%.*f; %.*f; %.*f;', [round, v[0], round, v[1], round, v[2]], f)
 930   else
 931     result := Format('%f; %f; %f;', [v[0], v[1], v[2]], f);
 932 end;
 933
 934 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 935 //schriebt die Werte des Vektors in einen String
 936 //@v: Vektor der in einen String umgewandelt werden soll;
 937 //@round: Anzahl der Stellen auf die gerundet werden soll;
 938 //@result: String mit den erten des Vektors;
 939 function gluVector2fToStr(const v: TgluVector2f; const round: Integer): String;
 940 var
 941   f: TFormatSettings;
 942 begin
 943   f.DecimalSeparator := '.';
 944   if (round >= 0) then
 945     result := Format('%.*f; %.*f;', [round, v[0], round, v[1]], f)
 946   else
 947     result := Format('%f; %f;', [v[0], v[1]], f);
 948 end;
 949
 950 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 951 function gluStrToVectorIntern(str: String; const aAbortOnFailure: Boolean; out aVec: TgluVector4f): Boolean;
 952 var
 953   i, j, p, l: Integer;
 954   s: String;
 955   format: TFormatSettings;
 956   v: Single;
 957 begin
 958   result := false;
 959   FillChar(aVec{%H-}, SizeOf(aVec), 0);
 960   FillChar(format{%H-}, SizeOf(format), 0);
 961   format.DecimalSeparator := '.';
 962   if (Length(str) > 0) and (str[Length(str)] <> ';') then
 963     str := str + ';';
 964   j := 0;
 965   i := 1;
 966   p := 1;
 967   l := Length(str);
 968   while (i <= l) do begin
 969     if str[i] = ';' then begin
 970       s := Trim(copy(str, p, i-p));
 971       if not TryStrToFloat(s, v, format) then begin
 972         if aAbortOnFailure then
 973           exit;
 974         v := 0;
 975       end;
 976       aVec[j] := v;
 977       inc(j);
 978       p := i+1;
 979     end;
 980     inc(i);
 981   end;
 982   result := true;
 983 end;
 984
 985 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 986 function gluTryStrToVector4f(str: String; out aVec: TgluVector4f): Boolean;
 987 begin
 988   result := gluStrToVectorIntern(str, true, aVec);
 989 end;
 990
 991 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 992 function gluTryStrToVector3f(str: String; out aVec: TgluVector3f): Boolean;
 993 var
 994   v: TgluVector4f;
 995 begin
 996   if (Length(str) > 0) and (str[Length(str)] <> ';') then
 997     str := str + ';';
 998   result := gluTryStrToVector4f(str+'0;', v);
 999   aVec := PgluVector3f(@v[0])^;
1000 end;
1001
1002 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1003 function gluTryStrToVector2f(str: String; out aVec: TgluVector2f): Boolean;
1004 var
1005   v: TgluVector4f;
1006 begin
1007   if (Length(str) > 0) and (str[Length(str)] <> ';') then
1008     str := str + ';';
1009   result := gluTryStrToVector4f(str+'0;0;', v);
1010   aVec := PgluVector2f(@v[0])^;
1011 end;
1012
1013 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1014 //wandelt einen String in einen Vektor um
1015 //@str: String der in den Vektor umgewandelt werden soll;
1016 //@result: Vektor mit den Datein aus dem String;
1017 function gluStrToVector4f(str: String): TgluVector4f;
1018 begin
1019   gluStrToVectorIntern(str, false, result);
1020 end;
1021
1022 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1023 //wandelt einen String in einen Vektor um
1024 //@str: String der in den Vektor umgewandelt werden soll;
1025 //@result: Vektor mit den Datein aus dem String;
1026 function gluStrToVector3f(str: String): TgluVector3f;
1027 var
1028   v: TgluVector4f;
1029 begin
1030   if (Length(str) > 0) and (str[Length(str)] <> ';') then
1031     str := str + ';';
1032   v := gluStrToVector4f(str+'0;');
1033   result := PgluVector3f(@v[0])^;
1034 end;
1035
1036 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1037 //wandelt einen String in einen Vektor um
1038 //@str: String der in den Vektor umgewandelt werden soll;
1039 //@result: Vektor mit den Datein aus dem String;
1040 function gluStrToVector2f(str: String): TgluVector2f;
1041 var
1042   v: TgluVector3f;
1043 begin
1044   if (Length(str) > 0) and (str[Length(str)] <> ';') then
1045     str := str + ';';
1046   v := gluStrToVector3f(str+'0;');
1047   result := PgluVector2f(@v[0])^;
1048 end;
1049
1050 function gluVector4iToStr(const v: TgluVector4i): String;
1051 begin
1052   Result:= Format('%d;%d;%d;%d;',[v[0],v[1],v[2],v[3]]);
1053 end;
1054
1055 function gluVector3iToStr(const v: TgluVector3i): String;
1056 begin
1057   Result:= Format('%d;%d;%d;',[v[0],v[1],v[2]]);
1058 end;
1059
1060 function gluVector2iToStr(const v: TgluVector2i): String;
1061 begin
1062   Result:= Format('%d;%d;',[v[0],v[1]]);
1063 end;
1064
1065 function gluStrToVector4i(const str: String): TgluVector4i;
1066 var
1067   i, j, p, l: Integer;
1068   v: integer;
1069 begin
1070   FillChar(result{%H-}, SizeOf(result), 0);
1071   j := 0;
1072   i := 1;
1073   p := 1;
1074   l := Length(str);
1075   while (i <= l) do begin
1076     if str[i] = ';' then begin
1077       if not TryStrToInt(copy(str, p, i-p), v) then
1078         v := 0;
1079       result[j] := v;
1080       inc(j);
1081       p := i+1;
1082     end;
1083     inc(i);
1084   end;
1085 end;
1086
1087 function gluStrToVector3i(const str: String): TgluVector3i;
1088 var
1089   v: TgluVector4i;
1090 begin
1091   v := gluStrToVector4i(str+'0;');
1092   result := PgluVector3i(@v[0])^;
1093 end;
1094
1095 function gluStrToVector2i(const str: String): TgluVector2i;
1096 var
1097   v: TgluVector3i;
1098 begin
1099   v := gluStrToVector3i(str+'0;');
1100   result := PgluVector2i(@v[0])^;
1101 end;
1102
1103 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1104 //wandelt einen Vektor in eine Farbe um
1105 //@v: Vektor der umgewandelt werden soll;
1106 //@result: Farbe;
1107 function gluVectorToColor(const v: TgluVector4f): TVectorColor; overload;
1108 begin
1109   result := gluVectorToColor(PgluVector3f(@v[0])^);
1110 end;
1111
1112 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1113 //wandelt einen Vektor in eine Farbe um
1114 //@v: Vektor der umgewandelt werden soll;
1115 //@result: Farbe;
1116 function gluVectorToColor(const v: TgluVector3f): TVectorColor;
1117 var
1118   r, g, b: Byte;
1119 begin
1120   r := round(255*v[0]);
1121   g := round(255*v[1]);
1122   b := round(255*v[2]);
1123   result := r + (g shl 8) + (b shl 16);
1124 end;
1125
1126 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1127 function gluColorToVector3f(const c: TVectorColor): TgluVector3f;
1128 begin
1129   result[0] := ( c         and $FF) / 255;
1130   result[1] := ((c shr  8) and $FF) / 255;
1131   result[2] := ((c shr 16) and $FF) / 255;
1132 end;
1133
1134 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1135 function gluColorToVector4f(const c: TVectorColor; const a: Single): TgluVector4f;
1136 begin
1137   PgluVector3f(@result[0])^ := gluColorToVector3f(c);
1138   result[3] := a;
1139 end;
1140
1141 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1142 //rechnet eine Farbe im HSV-Farbraum in den RGB-Farbraum um
1143 //@v: Farbe im HSV-Farbraum;
1144 //@result: Farbe im RGB-Farbraum;
1145 function gluVectorHSVColor(v: TgluVector3f): TgluVector3f;
1146 const
1147   _H = 0;
1148   _S = 1;
1149   _V = 2;
1150 var
1151   h: Integer;
1152   f, p, q, t: Single;
1153 begin
1154   v[_H] := 360*v[_H];
1155 //H normieren
1156   while (v[_H] < 0) do
1157     v[_H] := v[_H] + 360;
1158   while (v[_H] > 360) do
1159     v[_H] := v[_H] - 360;
1160 //V normieren
1161   if (v[_V] < 0) then
1162     v[_V] := 0;
1163   if (v[_V] > 1) then
1164     v[_V] := 1;
1165
1166   h := Floor(v[_H] / 60);
1167   f := v[_H]/60 - h;
1168   p := v[_V] * (1 - v[_S]);
1169   q := v[_V] * (1 - v[_S] * f);
1170   t := v[_V] * (1 - v[_S] * (1 - f));
1171   case h of
1172     1: result := gluVector3f(q, v[_V], p);
1173     2: result := gluVector3f(p, v[_V], t);
1174     3: result := gluVector3f(p, q, v[_V]);
1175     4: result := gluVector3f(t, p, v[_V]);
1176     5: result := gluVector3f(v[_V], p, q);
1177   else
1178     result := gluVector3f(v[_V], t, p);
1179   end;
1180 end;
1181
1182 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1183 //rechnet eine Farbe im HSV-Farbraum in den RGB-Farbraum um
1184 //@v: Farbe im HSV-Farbraum;
1185 //@result: Farbe im RGB-Farbraum;
1186 function gluVectorHSVColor(v: TgluVector4f): TgluVector4f;
1187 begin
1188   PgluVector3f(@result)^ := gluVectorHSVColor(PgluVector3f(@v)^);
1189   result[3] := v[3];
1190 end;
1191
1192 end.
1193