persistent classes names reverted

Examples/AdvDemos/Archipelago/fArchipelagoC.cpp

@@ -472,7 +472,7 @@ void __fastcall TForm1::DOWakeProgress(TObject *Sender, const double deltaTime,
 	if (WakeVertices == NULL) {
 		WakeVertices = new TGLAffineVectorList();
 		WakeStretch = new TGLAffineVectorList();
-		WakeTime = new TGSingleList();
+		WakeTime = new TGLSingleList();
 	}
 
 	// enlarge current vertices

Examples/AdvDemos/Archipelago/fArchipelagoC.h

@@ -97,7 +97,7 @@ public:		// User declarations
 
 	TGLAffineVectorList *WakeVertices;
 	TGLAffineVectorList *WakeStretch;
-	TGSingleList *WakeTime;
+	TGLSingleList *WakeTime;
 	void ResetMousePos(void);
 	float WaterPhase(const float px, const float py);
 	float WaterHeight(const float px, const float py);

Examples/AdvDemos/Archipelago/fArchipelagoD.pas

@@ -97,7 +97,7 @@ type
     HelpOpacity: Single;
     WakeVertices: TGLAffineVectorList;
     WakeStretch: TGLAffineVectorList;
-    WakeTime: TGSingleList;
+    WakeTime: TGLSingleList;
     procedure ResetMousePos;
     function WaterPhase(const px, py: Single): Single;
     function WaterHeight(const px, py: Single): Single;
@@ -549,7 +549,7 @@ begin
   begin
     WakeVertices := TGLAffineVectorList.Create;
     WakeStretch := TGLAffineVectorList.Create;
-    WakeTime := TGSingleList.Create;
+    WakeTime := TGLSingleList.Create;
   end;
 
   // enlarge current vertices

Examples/AdvDemos/Earth/fEarthD.pas

@@ -136,8 +136,8 @@ type
   private
     FileName, Path: TFileName;
     procedure LoadConstellationLines;
-    function AtmosphereColor(const rayStart, rayEnd: TGLVector): TGColorVector;
-    function ComputeColor(var rayDest: TGLVector; mayHitGround: Boolean): TGColorVector;
+    function AtmosphereColor(const rayStart, rayEnd: TGLVector): TGLColorVector;
+    function ComputeColor(var rayDest: TGLVector; mayHitGround: Boolean): TGLColorVector;
   end;
 
 var
@@ -149,8 +149,8 @@ const
   cAtmosphereRadius: Single = 0.55;
   // use value slightly lower than actual radius, for antialiasing effect
   cEarthRadius: Single = 0.495;
-  cLowAtmColor: TGColorVector = (X: 1; Y: 1; Z: 1; W: 1);
-  cHighAtmColor: TGColorVector = (X: 0; Y: 0; Z: 1; W: 1);
+  cLowAtmColor: TGLColorVector = (X: 1; Y: 1; Z: 1; W: 1);
+  cHighAtmColor: TGLColorVector = (X: 0; Y: 0; Z: 1; W: 1);
   cIntDivTable: array [2 .. 20] of Single = (1 / 2, 1 / 3, 1 / 4, 1 / 5, 1 / 6, 1 / 7, 1 / 8, 1 / 9,
     1 / 10, 1 / 11, 1 / 12, 1 / 13, 1 / 14, 1 / 15, 1 / 16, 1 / 17, 1 / 18, 1 / 19, 1 / 20);
 
@@ -191,11 +191,11 @@ end;
 
 //--------------------------------------------------------------------------------
 
-function TFormEarth.AtmosphereColor(const rayStart, rayEnd: TGLVector): TGColorVector;
+function TFormEarth.AtmosphereColor(const rayStart, rayEnd: TGLVector): TGLColorVector;
 var
   i, n: Integer;
   atmPoint, normal: TGLVector;
-  altColor: TGColorVector;
+  altColor: TGLColorVector;
   alt, rayLength, contrib, decay, intensity, invN: Single;
 
 begin
@@ -238,7 +238,7 @@ end;
 
 //-----------------------------------------------------------------------
 
-function TFormEarth.ComputeColor(var rayDest: TGLVector; mayHitGround: Boolean): TGColorVector;
+function TFormEarth.ComputeColor(var rayDest: TGLVector; mayHitGround: Boolean): TGLColorVector;
 var
   ai1, ai2, pi1, pi2: TGLVector;
   rayVector: TGLVector;

Examples/AdvDemos/Forest/fForestD.pas

@@ -112,7 +112,7 @@ type
     Path: TFileName;
     TestTree: TGLTree;
     TreesShown: Integer;
-    nearTrees: TGPersistentObjectList;
+    nearTrees: TGLPersistentObjectList;
     Imposter: TImposter;
     densityBitmap: TBitmap;
     mirrorTexture: TGLTextureHandle;
@@ -216,7 +216,7 @@ begin
   SetCursorPos(lmp.X, lmp.Y);
   ShowCursor(False);
 
-  nearTrees := TGPersistentObjectList.Create;
+  nearTrees := TGLPersistentObjectList.Create;
 
   camTurn := -60;
   enableRectReflection := False;

Examples/AdvDemos/GLSViewer/Source/fGLSViewer.pas

@@ -313,8 +313,8 @@ type
   // Hidden line shader (specific implem for the viewer, *not* generic)
   THiddenLineShader = class(TGLShader)
   private
-    LinesColor: TGColorVector;
-    BackgroundColor: TGColorVector;
+    LinesColor: TGLColorVector;
+    BackgroundColor: TGLColorVector;
     PassCount: Integer;
   public
     procedure DoApply(var rci: TGLRenderContextInfo; Sender: TObject); override;
@@ -875,7 +875,7 @@ end;
 procedure TFormGLSViewer.acConvertToIndexedTrianglesExecute(Sender: TObject);
 var
   v: TGLAffineVectorList;
-  I: TGIntegerList;
+  I: TGLIntegerList;
   m: TGLMeshObject;
   fg: TFGVertexIndexList;
 begin
@@ -910,7 +910,7 @@ var
   I: Integer;
   mo: TGLMeshObject;
   fg: TFGVertexIndexList;
-  strips: TGPersistentObjectList;
+  strips: TGLPersistentObjectList;
 begin
   acConvertToTriangles.Execute;
   mo := ffObject.MeshObjects[0];
@@ -921,7 +921,7 @@ begin
     for I := 0 to strips.Count - 1 do
     begin
       fg := TFGVertexIndexList.CreateOwned(mo.FaceGroups);
-      fg.VertexIndices := (strips[I] as TGIntegerList);
+      fg.VertexIndices := (strips[I] as TGLIntegerList);
       if I = 0 then
         fg.Mode := fgmmTriangles
       else

Examples/Demos/behaviours/Torque/fTorqueD.pas

@@ -107,7 +107,7 @@ procedure TFormTorque.GLSceneViewer1MouseDown(Sender: TObject; Button: TMouseBut
   Shift: TShiftState; X, Y: Integer);
 var
   pickedObject: TGLCustomSceneObject;
-  oldColor: TGColorVector;
+  oldColor: TGLColorVector;
   rci: TGLRenderContextInfo;
 begin
   // if an object is picked...

Examples/Demos/graph/heightfield/fHeightFieldD.pas

@@ -71,11 +71,11 @@ type
   private
 
     procedure Formula1(const X, Y: Single; var z: Single;
-      var Color: TGColorVector; var texPoint: TTexPoint);
+      var Color: TGLColorVector; var texPoint: TTexPoint);
     procedure Formula2(const X, Y: Single; var z: Single;
-      var Color: TGColorVector; var texPoint: TTexPoint);
+      var Color: TGLColorVector; var texPoint: TTexPoint);
     procedure Formula3(const X, Y: Single; var z: Single;
-      var Color: TGColorVector; var texPoint: TTexPoint);
+      var Color: TGLColorVector; var texPoint: TTexPoint);
   public
     mx, my: Integer;
   end;
@@ -97,7 +97,7 @@ begin
 end;
 
 procedure TFormHeightField.Formula1(const X, Y: Single; var z: Single;
-  var Color: TGColorVector; var texPoint: TTexPoint);
+  var Color: TGLColorVector; var texPoint: TTexPoint);
 begin
   // first formula
   z := VectorNorm(X, Y);
@@ -106,7 +106,7 @@ begin
 end;
 
 procedure TFormHeightField.Formula2(const X, Y: Single; var z: Single;
-  var Color: TGColorVector; var texPoint: TTexPoint);
+  var Color: TGLColorVector; var texPoint: TTexPoint);
 begin
   // 2nd formula
   z := 0.5 * cos(X * 6.28) * sin(Sqrt(abs(Y)) * 6.28);
@@ -114,7 +114,7 @@ begin
 end;
 
 procedure TFormHeightField.Formula3(const X, Y: Single; var z: Single;
-  var Color: TGColorVector; var texPoint: TTexPoint);
+  var Color: TGLColorVector; var texPoint: TTexPoint);
 begin
   // 3rd formula, dynamic
   z := 1 / (1 + VectorNorm(Sphere1.position.X - X, Sphere1.position.Y - Y));

Examples/Demos/materials/TransparAdv/fTransparAdvD.pas

@@ -132,11 +132,11 @@ end;
 //---------------------------------------------------------------------------
 procedure TFormTransparAdv.CreateShapes;
 const
-  vLtBlue: TGColorVector = (X: 0.00; Y: 0.00; Z: 1.00; W:0.90);
-  vLtPink: TGColorVector = (X: 0.40; Y:0.00; Z:0.20; W:0.50);
-  vLtYellow: TGColorVector = (X: 0.98; Y:0.96; Z:0.14; W:0.30);
-  vLtMagenta: TGColorVector = (X: 0.83; Y:0.04; Z:0.83; W:0.70);
-  vLtGreen: TGColorVector = (X: 0.05; Y:0.98; Z:0.14; W:0.30);
+  vLtBlue: TGLColorVector = (X: 0.00; Y: 0.00; Z: 1.00; W:0.90);
+  vLtPink: TGLColorVector = (X: 0.40; Y:0.00; Z:0.20; W:0.50);
+  vLtYellow: TGLColorVector = (X: 0.98; Y:0.96; Z:0.14; W:0.30);
+  vLtMagenta: TGLColorVector = (X: 0.83; Y:0.04; Z:0.83; W:0.70);
+  vLtGreen: TGLColorVector = (X: 0.05; Y:0.98; Z:0.14; W:0.30);
 var
   vd: array [0 .. 3] of TGLVertexData;
 

Examples/Demos/materials/multipass/fMultiPassD.pas

@@ -63,7 +63,7 @@ type
 
   THiddenLineShader = class(TGLShader)
   private
-    BackgroundColor, LineColor: TGColorVector;
+    BackgroundColor, LineColor: TGLColorVector;
     PassCount: Integer;
   public
     procedure DoApply(var rci: TGLRenderContextInfo; Sender: TObject); override;
@@ -72,7 +72,7 @@ type
 
   TOutLineShader = class(TGLShader)
   private
-    BackgroundColor, LineColor: TGColorVector;
+    BackgroundColor, LineColor: TGLColorVector;
     OutlineSmooth, Lighting: Boolean;
     OutlineWidth, Oldlinewidth: Single;
     PassCount: Integer;

Examples/Demos/materials/multipass/fMultipassC.h

@@ -50,7 +50,7 @@ class THiddenLineShader : public TGLShader
     __fastcall virtual THiddenLineShader(TComponent* AOwner);
     __fastcall virtual ~THiddenLineShader(void);
 
-    TGColorVector BackgroundColor, LineColor;
+    TGLColorVector BackgroundColor, LineColor;
     int PassCount;
 
     void __fastcall DoApply(TGLRenderContextInfo &rci, System::TObject* Sender);
@@ -64,7 +64,7 @@ class TOutLineShader : public TGLShader
     __fastcall virtual TOutLineShader(TComponent* AOwner);
     __fastcall virtual ~TOutLineShader(void);
 
-    TGColorVector BackgroundColor, LineColor;
+    TGLColorVector BackgroundColor, LineColor;
     bool OutlineSmooth, Lighting;
     float OutlineWidth, OldlineWidth;
     int PassCount;

Examples/Demos/meshes/formula/fFormulaC.cpp

@@ -35,7 +35,7 @@ TAffineVector __fastcall TForm1::MakeVect(const float aX, const float aY)
 //---------------------------------------------------------------------------
 
 void __fastcall TForm1::AddTriangle(const TAffineVector p1,
-	const TAffineVector p2, const TAffineVector p3, const TGColorVector color)
+	const TAffineVector p2, const TAffineVector p3, const TGLColorVector color)
 {
 	Mesh1->Vertices->AddVertex(p1, NullVector, color);
 	Mesh1->Vertices->AddVertex(p2, NullVector, color);

Examples/Demos/meshes/formula/fFormulaC.h

@@ -63,7 +63,7 @@ private:	// User declarations
 	void __fastcall AddTriangle(const TAffineVector p1,
 						  const TAffineVector p2,
 						  const TAffineVector p3,
-						  const TGColorVector color);
+						  const TGLColorVector color);
 public:		// User declarations
 	__fastcall TForm1(TComponent* Owner);
 };

Examples/Demos/meshes/formula/fFormulaD.pas

@@ -58,7 +58,7 @@ type
     invRes1, invRes2 : Single;
     function MakeVect(const aX, aY : Single) : TAffineVector;
     procedure AddTriangle(const p1, p2, p3 : TAffineVector;
-                          const color : TGColorVector);
+                          const color : TGLColorVector);
   public
      
   end;
@@ -80,7 +80,7 @@ begin
 end;
 
 procedure TFormFormula.AddTriangle(const p1, p2, p3 : TAffineVector;
-                         const color : TGColorVector);
+                         const color : TGLColorVector);
 begin
   with Mesh1.Vertices do begin
      AddVertex(p1, NullVector, color);

Examples/Demos/meshes/subdivide/fSubdivideC.cpp

@@ -58,8 +58,8 @@ void __fastcall TForm1::BUSubdivideClick(TObject *Sender)
 {
    int i, j;
    TGLAffineVectorList *tris, *norms, *tex, *buf, *morphTris, *morphNorms;
-   TGIntegerList *indices, *texIndices;
-   TGIntegerList *firstRemap, *subdivideRemap, *bufRemap;
+   TGLIntegerList *indices, *texIndices;
+   TGLIntegerList *firstRemap, *subdivideRemap, *bufRemap;
    __int64 t;
 
    BUSubdivide->Enabled = false;
@@ -72,7 +72,7 @@ void __fastcall TForm1::BUSubdivideClick(TObject *Sender)
 	  tex = new TGLAffineVectorList;
 	  tris = GLActor1->MeshObjects->Items[i]->ExtractTriangles(tex);
 	  indices = BuildVectorCountOptimizedIndices(tris);
-	  firstRemap = (TGIntegerList *)(indices->CreateClone());
+	  firstRemap = (TGLIntegerList *)(indices->CreateClone());
 	  RemapAndCleanupReferences(tris, indices);
 
 	  norms = BuildNormals(tris, indices);
@@ -106,14 +106,14 @@ void __fastcall TForm1::BUSubdivideClick(TObject *Sender)
 	  // Pack & Optimize the expanded stuff
 	  indices->Free();
 	  indices = BuildVectorCountOptimizedIndices(tris, norms, tex);
-	  subdivideRemap = (TGIntegerList *)(indices->CreateClone());
+	  subdivideRemap = (TGLIntegerList *)(indices->CreateClone());
 	  RemapReferences(norms, indices);
 	  RemapReferences(tex, indices);
 	  RemapAndCleanupReferences(tris, indices);
 
 	  IncreaseCoherency(indices, 13);
 
-	  bufRemap = new TGIntegerList;
+	  bufRemap = new TGLIntegerList;
 	 for (j = 0; j < GLActor1->MeshObjects->MorphTargetCount()-1; j++)
 	 {
 		GLActor1->MeshObjects->MorphTo(j);

Examples/Demos/meshes/subdivide/fSubdivideD.pas

@@ -104,8 +104,8 @@ procedure TFormSubdivide.BUSubdivideClick(Sender: TObject);
 var
   i, j: Integer;
   tris, norms, tex, buf, morphTris, morphNorms: TGLAffineVectorList;
-  indices, texIndices: TGIntegerList;
-  firstRemap, subdivideRemap, bufRemap: TGIntegerList;
+  indices, texIndices: TGLIntegerList;
+  firstRemap, subdivideRemap, bufRemap: TGLIntegerList;
   t: Int64;
 begin
   BUSubdivide.Enabled := False;
@@ -119,7 +119,7 @@ begin
     with GLActor1.MeshObjects[i] do
       tris := ExtractTriangles(tex);
     indices := BuildVectorCountOptimizedIndices(tris);
-    firstRemap := TGIntegerList(indices.CreateClone);
+    firstRemap := TGLIntegerList(indices.CreateClone);
     RemapAndCleanupReferences(tris, indices);
 
     norms := BuildNormals(tris, indices);
@@ -151,7 +151,7 @@ begin
     // Pack & Optimize the expanded stuff
     indices.Free;
     indices := BuildVectorCountOptimizedIndices(tris, norms, tex);
-    subdivideRemap := TGIntegerList(indices.CreateClone);
+    subdivideRemap := TGLIntegerList(indices.CreateClone);
     RemapReferences(norms, indices);
     RemapReferences(tex, indices);
     RemapAndCleanupReferences(tris, indices);
@@ -161,7 +161,7 @@ begin
     with GLActor1.MeshObjects[i] as TGLMorphableMeshObject do
     begin
 
-      bufRemap := TGIntegerList.Create;
+      bufRemap := TGLIntegerList.Create;
       for j := 0 to MorphTargets.Count - 1 do
       begin
         MorphTo(j);

Examples/Demos/movements/objmove/fObjmoveC.cpp

@@ -22,7 +22,7 @@
 #pragma resource "*.dfm"
 TFormObjmove *FormObjmove;
 
-const TGColorVector
+const TGLColorVector
   SelectionColor[]  = {0.243, 0.243, 0.243, 1.000};
 
 

Examples/Demos/movements/objmove/fObjmoveD.pas

@@ -80,7 +80,7 @@ type
   end;
 
 const
-  SelectionColor: TGColorVector = (X : 0.243; Y : 0.243; Z: 0.243; W : 1.000);
+  SelectionColor: TGLColorVector = (X : 0.243; Y : 0.243; Z: 0.243; W : 1.000);
 
 var
   FormObjmove: TFormObjmove;

Examples/Demos/physics/NewtonWalkCarry/fNewtonWalkCarryD.pas

@@ -138,7 +138,7 @@ var
   cp: TPoint;
   visible_cursor: boolean;
   ScObj, FScObj: TGLBaseSceneObject;
-  targetColor: TGColorVector;
+  targetColor: TGLColorVector;
   picked: TGLCustomSceneObject;
   mm: TMatrix4f;
 

Packages/GXScene_RT.dpk

@@ -242,7 +242,7 @@ contains
   GLScene.GeometryBB in '..\Source\GLScene.GeometryBB.pas',
   GXS.CurvesAndSurfaces in '..\Sourcex\GXS.CurvesAndSurfaces.pas',
   GLScene.AnimationUtils in '..\Source\GLScene.AnimationUtils.pas',
-  Formats.X in '..\Source\Formats.X.pas',
+  Formatx.X in '..\Sourcex\Formatx.X.pas',
   GLScene.TextureFormat in '..\Source\GLScene.TextureFormat.pas',
   Formats.DXTC in '..\Source\Formats.DXTC.pas',
   Formats.GL2 in '..\Source\Formats.GL2.pas',

Packages/GXScene_RT.dproj

@@ -391,7 +391,7 @@
         <DCCReference Include="..\Source\GLScene.GeometryBB.pas"/>
         <DCCReference Include="..\Sourcex\GXS.CurvesAndSurfaces.pas"/>
         <DCCReference Include="..\Source\GLScene.AnimationUtils.pas"/>
-        <DCCReference Include="..\Source\Formats.X.pas"/>
+        <DCCReference Include="..\Sourcex\Formatx.X.pas"/>
         <DCCReference Include="..\Source\GLScene.TextureFormat.pas"/>
         <DCCReference Include="..\Source\Formats.DXTC.pas"/>
         <DCCReference Include="..\Source\Formats.GL2.pas"/>

Source/Formats.VRML.pas

@@ -43,20 +43,20 @@ type
 
   TVRMLSingleArray = class(TVRMLNode)
   private
-    FValues: TGSingleList;
+    FValues: TGLSingleList;
   public
     constructor Create; override;
     destructor Destroy; override;
-    property Values: TGSingleList read FValues;
+    property Values: TGLSingleList read FValues;
   end;
 
   TVRMLIntegerArray = class(TVRMLNode)
   private
-    FValues: TgIntegerList;
+    FValues: TGLIntegerList;
   public
     constructor Create; override;
     destructor Destroy; override;
-    property Values: TgIntegerList read FValues;
+    property Values: TGLIntegerList read FValues;
   end;
 
   TVRMLMaterial = class(TVRMLNode)
@@ -271,7 +271,7 @@ end;
 constructor TVRMLSingleArray.Create;
 begin
   inherited;
-  FValues := TGSingleList.Create;
+  FValues := TGLSingleList.Create;
 end;
 
 destructor TVRMLSingleArray.Destroy;
@@ -288,7 +288,7 @@ end;
 constructor TVRMLIntegerArray.Create;
 begin
   inherited;
-  FValues := TgIntegerList.Create;
+  FValues := TGLIntegerList.Create;
 end;
 
 destructor TVRMLIntegerArray.Destroy;

Source/Formats.X.pas

@@ -84,7 +84,7 @@ type
   private
     FVertices, FNormals, FTexCoords: TGLAffineVectorList;
     FVertexIndices, FNormalIndices, FMaterialIndices, FVertCountIndices
-      : TgIntegerList;
+      : TGLIntegerList;
     FMaterialList: TDXMaterialList;
   public
     constructor Create; override;
@@ -92,10 +92,10 @@ type
     property Vertices: TGLAffineVectorList read FVertices;
     property Normals: TGLAffineVectorList read FNormals;
     property TexCoords: TGLAffineVectorList read FTexCoords;
-    property VertexIndices: TgIntegerList read FVertexIndices;
-    property NormalIndices: TgIntegerList read FNormalIndices;
-    property MaterialIndices: TgIntegerList read FMaterialIndices;
-    property VertCountIndices: TgIntegerList read FVertCountIndices;
+    property VertexIndices: TGLIntegerList read FVertexIndices;
+    property NormalIndices: TGLIntegerList read FNormalIndices;
+    property MaterialIndices: TGLIntegerList read FMaterialIndices;
+    property VertCountIndices: TGLIntegerList read FVertCountIndices;
     property MaterialList: TDXMaterialList read FMaterialList;
   end;
 
@@ -347,8 +347,8 @@ var
       VectorList.Add(ReadVector3f);
   end;
 
-  procedure ReadMeshIndices(IndexList: TgIntegerList;
-    VertCountIndices: TgIntegerList = nil);
+  procedure ReadMeshIndices(IndexList: TGLIntegerList;
+    VertCountIndices: TGLIntegerList = nil);
   var
     str: String;
     i, j, NumFaces, NumIndices, jStart: Integer;
@@ -604,10 +604,10 @@ begin
   FVertices := TGLAffineVectorList.Create;
   FNormals := TGLAffineVectorList.Create;
   FTexCoords := TGLAffineVectorList.Create;
-  FVertexIndices := TgIntegerList.Create;
-  FNormalIndices := TgIntegerList.Create;
-  FMaterialIndices := TgIntegerList.Create;
-  FVertCountIndices := TgIntegerList.Create;
+  FVertexIndices := TGLIntegerList.Create;
+  FNormalIndices := TGLIntegerList.Create;
+  FMaterialIndices := TGLIntegerList.Create;
+  FVertCountIndices := TGLIntegerList.Create;
   FMaterialList := TDXMaterialList.Create;
 end;
 

Source/GLS.ArchiveManager.pas

@@ -72,7 +72,7 @@ type
   end;
 
   // The list of registered classes
-  TGLArchiveFileFormatsList = class(TgPersistentObjectList)
+  TGLArchiveFileFormatsList = class(TGLPersistentObjectList)
   public
     destructor Destroy; override;
     procedure Add(const Ext, Desc: string; DescID: integer;

Source/GLS.Atmosphere.pas

@@ -53,8 +53,8 @@ type
     FPlanetRadius: Single;
     FAtmosphereRadius: Single;
     FOpacity: Single;
-    FLowAtmColor: TGColor;
-    FHighAtmColor: TGColor;
+    FLowAtmColor: TGLColor;
+    FHighAtmColor: TGLColor;
     FSun: TGLBaseSceneObject;
     procedure SetSun(const Value: TGLBaseSceneObject);
     procedure SetAtmosphereRadius(const Value: Single);
@@ -64,8 +64,8 @@ type
     function StoreOpacity: Boolean;
     function StorePlanetRadius: Boolean;
     procedure SetSlices(const Value: Integer);
-    procedure SetLowAtmColor(const AValue: TGColor);
-    procedure SetHighAtmColor(const AValue: TGColor);
+    procedure SetLowAtmColor(const AValue: TGLColor);
+    procedure SetHighAtmColor(const AValue: TGLColor);
     function StoreLowAtmColor: Boolean;
     function StoreHighAtmColor: Boolean;
   protected
@@ -81,9 +81,9 @@ type
     property PlanetRadius: Single read FPlanetRadius write SetPlanetRadius
       stored StorePlanetRadius;
     // Use value slightly lower than actual radius, for antialiasing effect
-    property LowAtmColor: TGColor read FLowAtmColor write SetLowAtmColor
+    property LowAtmColor: TGLColor read FLowAtmColor write SetLowAtmColor
       stored StoreLowAtmColor;
-    property HighAtmColor: TGColor read FHighAtmColor write SetHighAtmColor
+    property HighAtmColor: TGLColor read FHighAtmColor write SetHighAtmColor
       stored StoreHighAtmColor;
     property BlendingMode: TGLAtmosphereBlendingMode read FBlendingMode
       write FBlendingMode default abmOneMinusSrcAlpha;
@@ -145,8 +145,8 @@ end;
 constructor TGLCustomAtmosphere.Create(AOwner: TComponent);
 begin
   inherited;
-  FLowAtmColor := TGColor.Create(Self);
-  FHighAtmColor := TGColor.Create(Self);
+  FLowAtmColor := TGLColor.Create(Self);
+  FHighAtmColor := TGLColor.Create(Self);
   FOpacity := 2.1;
   SetSlices(60);
   FAtmosphereRadius := 3.55;
@@ -172,11 +172,11 @@ var
   sunPos, eyePos, lightingVector: TGLVector;
   diskNormal, diskRight, diskUp: TGLVector;
 
-  function AtmosphereColor(const rayStart, rayEnd: TGLVector): TGColorVector;
+  function AtmosphereColor(const rayStart, rayEnd: TGLVector): TGLColorVector;
   var
     I, n: Integer;
     atmPoint, normal: TGLVector;
-    altColor: TGColorVector;
+    altColor: TGLColorVector;
     alt, rayLength, contrib, decay, intensity, invN: Single;
   begin
     Result := clrTransparent;
@@ -217,7 +217,7 @@ var
   end;
 
   function ComputeColor(var rayDest: TGLVector; mayHitGround: Boolean)
-    : TGColorVector;
+    : TGLColorVector;
   var
     ai1, ai2, pi1, pi2: TGLVector;
     rayVector: TGLVector;
@@ -442,12 +442,12 @@ begin
     raise EGLAtmosphereException.Create('Slices must be more than0!');
 end;
 
-procedure TGLCustomAtmosphere.SetHighAtmColor(const AValue: TGColor);
+procedure TGLCustomAtmosphere.SetHighAtmColor(const AValue: TGLColor);
 begin
   FHighAtmColor.Assign(AValue);
 end;
 
-procedure TGLCustomAtmosphere.SetLowAtmColor(const AValue: TGColor);
+procedure TGLCustomAtmosphere.SetLowAtmColor(const AValue: TGLColor);
 begin
   FLowAtmColor.Assign(AValue);
 end;

Source/GLS.BaseClasses.pas

@@ -36,7 +36,7 @@ type
   end;
 
   // An abstract class describing the "update" interface.
-  TGLUpdateAbleObject = class(TGInterfacedPersistent, IGLNotifyAble)
+  TGLUpdateAbleObject = class(TGLInterfacedPersistent, IGLNotifyAble)
   private
     FOwner: TPersistent;
     FUpdating: Integer;

Source/GLS.BitmapFont.pas

@@ -189,13 +189,13 @@ type
        Enable states are also possibly altered. *)
     procedure RenderString(var ARci: TGLRenderContextInfo;
       const aText: UnicodeString; aAlignment: TAlignment;
-      aLayout: TTextLayout; const aColor: TGColorVector;
+      aLayout: TTextLayout; const aColor: TGLColorVector;
       aPosition: PGLVector = nil; aReverseY: boolean = False); overload; virtual;
     (* A simpler canvas-style TextOut helper for RenderString.
        The rendering is reversed along Y by default, to allow direct use
        with TGLCanvas *)
     procedure TextOut(var rci: TGLRenderContextInfo; X, Y: Single;
-      const Text: UnicodeString; const Color: TGColorVector); overload;
+      const Text: UnicodeString; const Color: TGLColorVector); overload;
     procedure TextOut(var rci: TGLRenderContextInfo; X, Y: Single;
       const Text: UnicodeString; const Color: TColor); overload;
     function TextWidth(const Text: UnicodeString): Integer;
@@ -245,14 +245,14 @@ type
     FText: UnicodeString;
     FAlignment: TAlignment;
     FLayout: TTextLayout;
-    FModulateColor: TGColor;
+    FModulateColor: TGLColor;
     FOptions: TGLFlatTextOptions;
   protected
     procedure SetBitmapFont(const val: TGLCustomBitmapFont);
     procedure SetText(const val: UnicodeString);
     procedure SetAlignment(const val: TAlignment);
     procedure SetLayout(const val: TTextLayout);
-    procedure SetModulateColor(const val: TGColor);
+    procedure SetModulateColor(const val: TGLColor);
     procedure SetOptions(const val: TGLFlatTextOptions);
     procedure Notification(AComponent: TComponent;
       Operation: TOperation); override;
@@ -279,7 +279,7 @@ type
       Possible values : tlTop, tlCenter, tlBottom *)
     property Layout: TTextLayout read FLayout write SetLayout;
     // Color modulation, can be used for fade in/out too.
-    property ModulateColor: TGColor read FModulateColor write SetModulateColor;
+    property ModulateColor: TGLColor read FModulateColor write SetModulateColor;
     (* Flat text options.
        ftoTwoSided : when set the text will be visible from its two
        sides even if faceculling is on (at the scene-level). *)
@@ -832,7 +832,7 @@ end;
 
 procedure TGLCustomBitmapFont.RenderString(var ARci: TGLRenderContextInfo;
   const aText: UnicodeString; aAlignment: TAlignment; aLayout: TTextLayout;
-  const aColor: TGColorVector; aPosition: PGLVector = nil;
+  const aColor: TGLColorVector; aPosition: PGLVector = nil;
   aReverseY: boolean = False);
 
   function AlignmentAdjustement(p: Integer): Single;
@@ -964,7 +964,7 @@ begin
 end;
 
 procedure TGLCustomBitmapFont.TextOut(var rci: TGLRenderContextInfo; X, Y: Single;
-  const Text: UnicodeString; const Color: TGColorVector);
+  const Text: UnicodeString; const Color: TGLColorVector);
 var
   V: TGLVector;
 begin
@@ -1148,7 +1148,7 @@ constructor TGLFlatText.Create(AOwner: TComponent);
 begin
   inherited;
   ObjectStyle := ObjectStyle + [osDirectDraw, osNoVisibilityCulling];
-  FModulateColor := TGColor.CreateInitialized(Self, clrWhite);
+  FModulateColor := TGLColor.CreateInitialized(Self, clrWhite);
 end;
 
 destructor TGLFlatText.Destroy;
@@ -1200,7 +1200,7 @@ begin
   StructureChanged;
 end;
 
-procedure TGLFlatText.SetModulateColor(const val: TGColor);
+procedure TGLFlatText.SetModulateColor(const val: TGLColor);
 begin
   FModulateColor.Assign(val);
 end;

Source/GLS.CUDA.APIComps.pas

@@ -53,7 +53,7 @@ type
   TCUDAComponent = class(TCUDAHandlesMaster)
   private
     FMaster: TCUDAComponent;
-    FItems: TgPersistentObjectList;
+    FItems: TGLPersistentObjectList;
     procedure SetMaster(AMaster: TCUDAComponent);
     function GetItem(const i: Integer): TCUDAComponent;
     function GetItemsCount: Integer;
@@ -1059,7 +1059,7 @@ end;
 procedure TCUDAComponent.AddItem(AItem: TCUDAComponent);
 begin
   if not Assigned(FItems) then
-    FItems := TgPersistentObjectList.Create;
+    FItems := TGLPersistentObjectList.Create;
   FItems.Add(AItem);
 end;
 

Source/GLS.Canvas.pas

@@ -121,9 +121,9 @@ type
     procedure FillRect(const x1, y1, x2, y2: Single); overload;
     // Draw the (x1,y1)-(x2, y2) rectangle (filled with given gradient's color). 
     procedure FillRectGradient(const x1, y1, x2, y2: Single;
-      const x1y1Color, x2y1Color, x2y2Color, x1y2Color: TGColorVector); overload;
+      const x1y1Color, x2y1Color, x2y2Color, x1y2Color: TGLColorVector); overload;
     procedure FillRectGradient(const x1, y1, x2, y2: Integer;
-      const x1y1Color, x2y1Color, x2y2Color, x1y2Color: TGColorVector); overload;
+      const x1y1Color, x2y1Color, x2y2Color, x1y2Color: TGLColorVector); overload;
     // Draws an ellipse with (x1,y1)-(x2, y2) bounding rectangle. 
     procedure EllipseBB(const x1, y1, x2, y2: Integer); overload;
     procedure EllipseBB(const x1, y1, x2, y2: Single); overload;
@@ -139,11 +139,11 @@ type
     OpenGL will use the last PenColor and PenAlpha as the center color and do gradient 
   	to edge of ellipse using the edgeColor parameter. *)
     procedure FillEllipseGradient(const x, y, xRadius, yRadius: Single;
-      const edgeColor: TGColorVector); overload;
+      const edgeColor: TGLColorVector); overload;
     procedure FillEllipseGradient(const x, y: Integer;
-      const xRadius, yRadius: Integer; const edgeColor: TGColorVector); overload;
+      const xRadius, yRadius: Integer; const edgeColor: TGLColorVector); overload;
     procedure FillEllipseGradient(const x, y, Radius: Single;
-      const edgeColor: TGColorVector); overload;
+      const edgeColor: TGLColorVector); overload;
     (* Draw an elliptical arc.
        The points (x1, y1) and (x2, y2) specify the bounding rectangle.
        An ellipse formed by the specified bounding rectangle defines the curve of the arc.
@@ -523,7 +523,7 @@ begin
 end;
 
 procedure TGLCanvas.FillRectGradient(const x1, y1, x2, y2: Single;
-  const x1y1Color, x2y1Color, x2y2Color, x1y2Color: TGColorVector);
+  const x1y1Color, x2y1Color, x2y2Color, x1y2Color: TGLColorVector);
 begin
   StartPrimitive(GL_QUADS);
   gl.Color4f(x1y1Color.X, x1y1Color.Y, x1y1Color.Z, x1y1Color.W);
@@ -541,7 +541,7 @@ begin
 end;
 
 procedure TGLCanvas.FillRectGradient(const x1, y1, x2, y2: Integer;
-  const x1y1Color, x2y1Color, x2y2Color, x1y2Color: TGColorVector);
+  const x1y1Color, x2y1Color, x2y2Color, x1y2Color: TGLColorVector);
 begin
   StartPrimitive(GL_QUADS);
   gl.Color4f(x1y1Color.X, x1y1Color.Y, x1y1Color.Z, x1y1Color.W);
@@ -558,7 +558,7 @@ begin
   gl.Color4fv(@FCurrentPenColorVector);
 end;
 
-procedure TGLCanvas.FillEllipseGradient(const x, y: Integer; const xRadius, yRadius: Integer; const edgeColor: TGColorVector);
+procedure TGLCanvas.FillEllipseGradient(const x, y: Integer; const xRadius, yRadius: Integer; const edgeColor: TGLColorVector);
 begin
   StartPrimitive(GL_TRIANGLE_FAN);
 
@@ -574,7 +574,7 @@ begin
   gl.Color4fv(@FCurrentPenColorVector);
 end;
 
-procedure TGLCanvas.FillEllipseGradient(const x, y, xRadius, yRadius: Single; const edgeColor: TGColorVector);
+procedure TGLCanvas.FillEllipseGradient(const x, y, xRadius, yRadius: Single; const edgeColor: TGLColorVector);
 begin
   StartPrimitive(GL_TRIANGLE_FAN);
   gl.Vertex2f(x, y); // really necessary now :)
@@ -586,7 +586,7 @@ begin
   gl.Color4fv(@FCurrentPenColorVector);
 end;
 
-procedure TGLCanvas.FillEllipseGradient(const x, y, Radius: Single; const edgeColor: TGColorVector);
+procedure TGLCanvas.FillEllipseGradient(const x, y, Radius: Single; const edgeColor: TGLColorVector);
 begin
   FillEllipseGradient(x, y, Radius, Radius, edgeColor);
 end;

Source/GLS.Color.pas

@@ -24,23 +24,23 @@ uses
 
 
 type
-  PGColorVector = ^TGColorVector;
-  TGColorVector = TVector4f;
+  PGLColorVector = ^TGLColorVector;
+  TGLColorVector = TVector4f;
 
   PRGBColor = ^TRGBColor;
   TRGBColor = TVector3b;
 
   // Wraps an OpenGL color.
-  TGColor = class(TGLUpdateAbleObject)
+  TGLColor = class(TGLUpdateAbleObject)
   private
-    FColor: TGColorVector;
-    FPDefaultColor: PGColorVector;
-    procedure SetColorVector(const aColor: TGColorVector); overload;
+    FColor: TGLColorVector;
+    FPDefaultColor: PGLColorVector;
+    procedure SetColorVector(const aColor: TGLColorVector); overload;
     procedure SetColorComponent(index: Integer; value: Single);
     function GetColorComponent(const index: Integer): Single;
     procedure SetAsWinColor(const val: TColor);
     function GetAsWinColor: TColor;
-    procedure SetDirectColorVector(const aColor: TGColorVector);
+    procedure SetDirectColorVector(const aColor: TGLColorVector);
   protected
     procedure DefineProperties(Filer: TFiler); override;
     procedure ReadData(Stream: TStream);
@@ -50,19 +50,19 @@ type
   public
     constructor Create(AOwner: TPersistent); override;
     constructor CreateInitialized(AOwner: TPersistent;
-      const Color: TGColorVector; changeEvent: TNotifyEvent = nil);
+      const Color: TGLColorVector; changeEvent: TNotifyEvent = nil);
     destructor Destroy; override;
     procedure NotifyChange(Sender: TObject); override;
     procedure Assign(Source: TPersistent); override;
-    procedure Initialize(const color: TGColorVector);
+    procedure Initialize(const color: TGLColorVector);
     function AsAddress: PSingle;
     procedure RandomColor;
     procedure SetColor(Red, Green, Blue: Single; Alpha: Single = 1); overload;
-    property Color: TGColorVector read FColor write SetColorVector;
-    property DirectColor: TGColorVector read FColor write SetDirectColorVector;
+    property Color: TGLColorVector read FColor write SetColorVector;
+    property DirectColor: TGLColorVector read FColor write SetDirectColorVector;
     property AsWinColor: TColor read GetAsWinColor write SetAsWinColor;
     property hsva: TGLVector read GetHSVA write SetHSVA;
-    property DefaultColor: TGColorVector read FColor;
+    property DefaultColor: TGLColorVector read FColor;
   published
     property Red: Single index 0 read GetColorComponent write SetColorComponent
       stored False;
@@ -74,44 +74,44 @@ type
       write SetColorComponent stored False;
   end;
 
-  PGColorEntry = ^TGColorEntry;
-  TGColorEntry = record
+  PGLColorEntry = ^TGLColorEntry;
+  TGLColorEntry = record
     Name: String;
-    Color: TGColorVector;
+    Color: TGLColorVector;
   end;
 
-  TGColorManager = class(TList)
+  TGLColorManager = class(TList)
   public
     destructor Destroy; override;
-    procedure AddColor(const aName: String; const aColor: TGColorVector);
+    procedure AddColor(const aName: String; const aColor: TGLColorVector);
     procedure EnumColors(Proc: TGetStrProc); overload;
     procedure EnumColors(AValues: TStrings); overload;
-    function FindColor(const aName: String): TGColorVector;
+    function FindColor(const aName: String): TGLColorVector;
     // Convert a clrXxxx or a '<Red Green Blue Alpha> to a color vector
-    function GetColor(const aName: String): TGColorVector;
-    function GetColorName(const aColor: TGColorVector): String;
+    function GetColor(const aName: String): TGLColorVector;
+    function GetColorName(const aColor: TGLColorVector): String;
     procedure RegisterDefaultColors;
     procedure RemoveColor(const aName: String);
   end;
 
 // Builds a TColor from Red Green Blue components.
 function RGB2Color(const r, g, b: Byte): TColor; inline;
-function ColorManager: TGColorManager;
-procedure RegisterColor(const aName: String; const aColor: TGColorVector);
+function ColorManager: TGLColorManager;
+procedure RegisterColor(const aName: String; const aColor: TGLColorVector);
 procedure UnRegisterColor(const aName: String);
 function GetRValue(rgb: DWORD): Byte; {$NODEFINE GetRValue}
 function GetGValue(rgb: DWORD): Byte; {$NODEFINE GetGValue}
 function GetBValue(rgb: DWORD): Byte; {$NODEFINE GetBValue}
 procedure InitGLSceneColors;
 // Converts a delphi color into its RGB fragments and correct range.
-function ConvertWinColor(aColor: TColor; Alpha: Single = 1): TGColorVector;
+function ConvertWinColor(aColor: TColor; Alpha: Single = 1): TGLColorVector;
 // Converts a color vector (containing float values)
-function ConvertColorVector(const aColor: TGColorVector): TColor; overload;
+function ConvertColorVector(const aColor: TGLColorVector): TColor; overload;
 (* Converts a color vector (containing float values) and alter intensity.
   intensity is in [0..1] *)
-function ConvertColorVector(const aColor: TGColorVector; intensity: Single): TColor; overload;
+function ConvertColorVector(const aColor: TGLColorVector; intensity: Single): TColor; overload;
 // Converts RGB components into a color vector with correct range
-function ConvertRGBColor(const aColor: array of Byte): TGColorVector;
+function ConvertRGBColor(const aColor: array of Byte): TGLColorVector;
 
 // color definitions
 const
@@ -193,180 +193,180 @@ const
   // since they depend on the desktop scheme)
 const
 {$J+ - allow change of the following typed constants}
-  clrScrollBar: TGColorVector = (X: 0; Y: 0; Z: 0; W: 1);
-  clrBackground: TGColorVector = (X: 0; Y: 0; Z: 0; W: 1);
-  clrActiveCaption: TGColorVector = (X: 0; Y: 0; Z: 0; W: 1);
-  clrInactiveCaption: TGColorVector = (X: 0; Y: 0; Z: 0; W: 1);
-  clrMenu: TGColorVector = (X: 0; Y: 0; Z: 0; W: 1);
-  clrWindow: TGColorVector = (X: 0; Y: 0; Z: 0; W: 1);
-  clrWindowFrame: TGColorVector = (X: 0; Y: 0; Z: 0; W: 1);
-  clrMenuText: TGColorVector = (X: 0; Y: 0; Z: 0; W: 1);
-  clrWindowText: TGColorVector = (X: 0; Y: 0; Z: 0; W: 1);
-  clrCaptionText: TGColorVector = (X: 0; Y: 0; Z: 0; W: 1);
-  clrActiveBorder: TGColorVector = (X: 0; Y: 0; Z: 0; W: 1);
-  clrInactiveBorder: TGColorVector = (X: 0; Y: 0; Z: 0; W: 1);
-  clrAppWorkSpace: TGColorVector = (X: 0; Y: 0; Z: 0; W: 1);
-  clrHighlight: TGColorVector = (X: 0; Y: 0; Z: 0; W: 1);
-  clrHighlightText: TGColorVector = (X: 0; Y: 0; Z: 0; W: 1);
-  clrBtnFace: TGColorVector = (X: 0; Y: 0; Z: 0; W: 1);
-  clrBtnShadow: TGColorVector = (X: 0; Y: 0; Z: 0; W: 1);
-  clrGrayText: TGColorVector = (X: 0; Y: 0; Z: 0; W: 1);
-  clrBtnText: TGColorVector = (X: 0; Y: 0; Z: 0; W: 1);
-  clrInactiveCaptionText: TGColorVector = (X: 0; Y: 0; Z: 0; W: 1);
-  clrBtnHighlight: TGColorVector = (X: 0; Y: 0; Z: 0; W: 1);
-  clr3DDkShadow: TGColorVector = (X: 0; Y: 0; Z: 0; W: 1);
-  clr3DLight: TGColorVector = (X: 0; Y: 0; Z: 0; W: 1);
-  clrInfoText: TGColorVector = (X: 0; Y: 0; Z: 0; W: 1);
-  clrInfoBk: TGColorVector = (X: 0; Y: 0; Z: 0; W: 1);
+  clrScrollBar: TGLColorVector = (X: 0; Y: 0; Z: 0; W: 1);
+  clrBackground: TGLColorVector = (X: 0; Y: 0; Z: 0; W: 1);
+  clrActiveCaption: TGLColorVector = (X: 0; Y: 0; Z: 0; W: 1);
+  clrInactiveCaption: TGLColorVector = (X: 0; Y: 0; Z: 0; W: 1);
+  clrMenu: TGLColorVector = (X: 0; Y: 0; Z: 0; W: 1);
+  clrWindow: TGLColorVector = (X: 0; Y: 0; Z: 0; W: 1);
+  clrWindowFrame: TGLColorVector = (X: 0; Y: 0; Z: 0; W: 1);
+  clrMenuText: TGLColorVector = (X: 0; Y: 0; Z: 0; W: 1);
+  clrWindowText: TGLColorVector = (X: 0; Y: 0; Z: 0; W: 1);
+  clrCaptionText: TGLColorVector = (X: 0; Y: 0; Z: 0; W: 1);
+  clrActiveBorder: TGLColorVector = (X: 0; Y: 0; Z: 0; W: 1);
+  clrInactiveBorder: TGLColorVector = (X: 0; Y: 0; Z: 0; W: 1);
+  clrAppWorkSpace: TGLColorVector = (X: 0; Y: 0; Z: 0; W: 1);
+  clrHighlight: TGLColorVector = (X: 0; Y: 0; Z: 0; W: 1);
+  clrHighlightText: TGLColorVector = (X: 0; Y: 0; Z: 0; W: 1);
+  clrBtnFace: TGLColorVector = (X: 0; Y: 0; Z: 0; W: 1);
+  clrBtnShadow: TGLColorVector = (X: 0; Y: 0; Z: 0; W: 1);
+  clrGrayText: TGLColorVector = (X: 0; Y: 0; Z: 0; W: 1);
+  clrBtnText: TGLColorVector = (X: 0; Y: 0; Z: 0; W: 1);
+  clrInactiveCaptionText: TGLColorVector = (X: 0; Y: 0; Z: 0; W: 1);
+  clrBtnHighlight: TGLColorVector = (X: 0; Y: 0; Z: 0; W: 1);
+  clr3DDkShadow: TGLColorVector = (X: 0; Y: 0; Z: 0; W: 1);
+  clr3DLight: TGLColorVector = (X: 0; Y: 0; Z: 0; W: 1);
+  clrInfoText: TGLColorVector = (X: 0; Y: 0; Z: 0; W: 1);
+  clrInfoBk: TGLColorVector = (X: 0; Y: 0; Z: 0; W: 1);
 
 {$J- - disable change of other typed constants}
   // 'static' color definitions sort of grays
-  clrTransparent: TGColorVector = (X: 0; Y: 0; Z: 0; W: 0);
-  clrBlack: TGColorVector = (X: 0; Y: 0; Z: 0; W: 1);
-  clrGray05: TGColorVector = (X: 0.05; Y: 0.05; Z: 0.05; W: 1);
-  clrGray10: TGColorVector = (X: 0.10; Y: 0.10; Z: 0.10; W: 1);
-  clrGray15: TGColorVector = (X: 0.15; Y: 0.15; Z: 0.15; W: 1);
-  clrGray20: TGColorVector = (X: 0.20; Y: 0.20; Z: 0.20; W: 1);
-  clrGray25: TGColorVector = (X: 0.25; Y: 0.25; Z: 0.25; W: 1);
-  clrGray30: TGColorVector = (X: 0.30; Y: 0.30; Z: 0.30; W: 1);
-  clrGray35: TGColorVector = (X: 0.35; Y: 0.35; Z: 0.35; W: 1);
-  clrGray40: TGColorVector = (X: 0.40; Y: 0.40; Z: 0.40; W: 1);
-  clrGray45: TGColorVector = (X: 0.45; Y: 0.45; Z: 0.45; W: 1);
-  clrGray50: TGColorVector = (X: 0.50; Y: 0.50; Z: 0.50; W: 1);
-  clrGray55: TGColorVector = (X: 0.55; Y: 0.55; Z: 0.55; W: 1);
-  clrGray60: TGColorVector = (X: 0.60; Y: 0.60; Z: 0.60; W: 1);
-  clrGray65: TGColorVector = (X: 0.65; Y: 0.65; Z: 0.65; W: 1);
-  clrGray70: TGColorVector = (X: 0.70; Y: 0.70; Z: 0.70; W: 1);
-  clrGray75: TGColorVector = (X: 0.75; Y: 0.75; Z: 0.75; W: 1);
-  clrGray80: TGColorVector = (X: 0.80; Y: 0.80; Z: 0.80; W: 1);
-  clrGray85: TGColorVector = (X: 0.85; Y: 0.85; Z: 0.85; W: 1);
-  clrGray90: TGColorVector = (X: 0.90; Y: 0.90; Z: 0.90; W: 1);
-  clrGray95: TGColorVector = (X: 0.95; Y: 0.95; Z: 0.95; W: 1);
-  clrWhite: TGColorVector = (X: 1; Y: 1; Z: 1; W: 1);
+  clrTransparent: TGLColorVector = (X: 0; Y: 0; Z: 0; W: 0);
+  clrBlack: TGLColorVector = (X: 0; Y: 0; Z: 0; W: 1);
+  clrGray05: TGLColorVector = (X: 0.05; Y: 0.05; Z: 0.05; W: 1);
+  clrGray10: TGLColorVector = (X: 0.10; Y: 0.10; Z: 0.10; W: 1);
+  clrGray15: TGLColorVector = (X: 0.15; Y: 0.15; Z: 0.15; W: 1);
+  clrGray20: TGLColorVector = (X: 0.20; Y: 0.20; Z: 0.20; W: 1);
+  clrGray25: TGLColorVector = (X: 0.25; Y: 0.25; Z: 0.25; W: 1);
+  clrGray30: TGLColorVector = (X: 0.30; Y: 0.30; Z: 0.30; W: 1);
+  clrGray35: TGLColorVector = (X: 0.35; Y: 0.35; Z: 0.35; W: 1);
+  clrGray40: TGLColorVector = (X: 0.40; Y: 0.40; Z: 0.40; W: 1);
+  clrGray45: TGLColorVector = (X: 0.45; Y: 0.45; Z: 0.45; W: 1);
+  clrGray50: TGLColorVector = (X: 0.50; Y: 0.50; Z: 0.50; W: 1);
+  clrGray55: TGLColorVector = (X: 0.55; Y: 0.55; Z: 0.55; W: 1);
+  clrGray60: TGLColorVector = (X: 0.60; Y: 0.60; Z: 0.60; W: 1);
+  clrGray65: TGLColorVector = (X: 0.65; Y: 0.65; Z: 0.65; W: 1);
+  clrGray70: TGLColorVector = (X: 0.70; Y: 0.70; Z: 0.70; W: 1);
+  clrGray75: TGLColorVector = (X: 0.75; Y: 0.75; Z: 0.75; W: 1);
+  clrGray80: TGLColorVector = (X: 0.80; Y: 0.80; Z: 0.80; W: 1);
+  clrGray85: TGLColorVector = (X: 0.85; Y: 0.85; Z: 0.85; W: 1);
+  clrGray90: TGLColorVector = (X: 0.90; Y: 0.90; Z: 0.90; W: 1);
+  clrGray95: TGLColorVector = (X: 0.95; Y: 0.95; Z: 0.95; W: 1);
+  clrWhite: TGLColorVector = (X: 1; Y: 1; Z: 1; W: 1);
 
   // other grays
-  clrDimGray: TGColorVector = (X: 0.329412; Y: 0.329412; Z: 0.329412; W: 1);
-  clrGray: TGColorVector = (X: 0.752941; Y: 0.752941; Z: 0.752941; W: 1);
-  clrLightGray: TGColorVector = (X: 0.658824; Y: 0.658824; Z: 0.658824; W: 1);
+  clrDimGray: TGLColorVector = (X: 0.329412; Y: 0.329412; Z: 0.329412; W: 1);
+  clrGray: TGLColorVector = (X: 0.752941; Y: 0.752941; Z: 0.752941; W: 1);
+  clrLightGray: TGLColorVector = (X: 0.658824; Y: 0.658824; Z: 0.658824; W: 1);
 
   // colors en masse
-  clrAqua: TGColorVector = (X: 0; Y: 1; Z: 1; W: 1);
-  clrAquamarine: TGColorVector = (X: 0.439216; Y: 0.858824; Z: 0.576471; W: 1);
-  clrBakersChoc: TGColorVector = (X: 0.36; Y: 0.20; Z: 0.09; W: 1);
-  clrBlue: TGColorVector = (X: 0; Y: 0; Z: 1; W: 1);
-  clrBlueViolet: TGColorVector = (X: 0.62352; Y: 0.372549; Z: 0.623529; W: 1);
-  clrBrown: TGColorVector = (X: 0.647059; Y: 0.164706; Z: 0.164706; W: 1);
-  clrCadetBlue: TGColorVector = (X: 0.372549; Y: 0.623529; Z: 0.623529; W: 1);
-  clrCoral: TGColorVector = (X: 1; Y: 0.498039; Z: 0.0; W: 1);
-  clrCornflowerBlue: TGColorVector = (X: 0.258824; Y: 0.258824; Z: 0.435294; W: 1);
-  clrDarkGreen: TGColorVector = (X: 0.184314; Y: 0.309804; Z: 0.184314; W: 1);
-  clrDarkOliveGreen: TGColorVector = (X: 0.309804; Y: 0.309804; Z: 0.184314; W: 1);
-  clrDarkOrchid: TGColorVector = (X: 0.6; Y: 0.196078; Z: 0.8; W: 1);
-  clrDarkSlateBlue: TGColorVector = (X: 0.419608; Y: 0.137255; Z: 0.556863; W: 1);
-  clrDarkSlateGray: TGColorVector = (X: 0.184314; Y: 0.309804; Z: 0.309804; W: 1);
-  clrDarkSlateGrey: TGColorVector = (X: 0.184314; Y: 0.309804; Z: 0.309804; W: 1);
-  clrDarkTurquoise: TGColorVector = (X: 0.439216; Y: 0.576471; Z: 0.858824; W: 1);
-  clrFirebrick: TGColorVector = (X: 0.556863; Y: 0.137255; Z: 0.137255; W: 1);
-  clrForestGreen: TGColorVector = (X: 0.137255; Y: 0.556863; Z: 0.137255; W: 1);
-  clrFuchsia: TGColorVector = (X: 1; Y: 0; Z: 1; W: 1);
-  clrGold: TGColorVector = (X: 0.8; Y: 0.498039; Z: 0.196078; W: 1);
-  clrGoldenrod: TGColorVector = (X: 0.858824; Y: 0.858824; Z: 0.439216; W: 1);
-  clrGreenYellow: TGColorVector = (X: 0.576471; Y: 0.858824; Z: 0.439216; W: 1);
-  clrIndian: TGColorVector = (X: 0.309804; Y: 0.184314; Z: 0.184314; W: 1);
-  clrKhaki: TGColorVector = (X: 0.623529; Y: 0.623529; Z: 0.372549; W: 1);
-  clrLightBlue: TGColorVector = (X: 0.74902; Y: 0.847059; Z: 0.847059; W: 1);
-  clrLightSteelBlue: TGColorVector = (X: 0.560784; Y: 0.560784; Z: 0.737255; W: 1);
-  clrLime: TGColorVector = (X: 0; Y: 1; Z: 0; W: 1);
-  clrLimeGreen: TGColorVector = (X: 0.196078; Y: 0.8; Z: 0.196078; W: 1);
-  clrMaroon: TGColorVector = (X: 0.556863; Y: 0.137255; Z: 0.419608; W: 1);
-  clrMediumAquamarine: TGColorVector = (X: 0.196078; Y: 0.8; Z: 0.6; W: 1);
-  clrMediumBlue: TGColorVector = (X: 0.196078; Y: 0.196078; Z: 0.8; W: 1);
-  clrMediumForestGreen: TGColorVector = (X: 0.419608; Y: 0.556863; Z: 0.137255; W: 1);
-  clrMediumGoldenrod: TGColorVector = (X: 0.917647; Y: 0.917647; Z: 0.678431; W: 1);
-  clrMediumOrchid: TGColorVector = (X: 0.576471; Y: 0.439216; Z: 0.858824; W: 1);
-  clrMediumSeaGreen: TGColorVector = (X: 0.258824; Y: 0.435294; Z: 0.258824; W: 1);
-  clrMediumSlateBlue: TGColorVector = (X: 0.498039; Y: 0; Z: 1; W: 1);
-  clrMediumSpringGreen: TGColorVector = (X: 0.498039; Y: 1; Z: 0; W: 1);
-  clrMediumTurquoise: TGColorVector = (X: 0.439216; Y: 0.858824; Z: 0.858824; W: 1);
-  clrMediumViolet: TGColorVector = (X: 0.858824; Y: 0.439216; Z: 0.576471; W: 1);
-  clrMediumPurple: TGColorVector = (X: 0.73; Y: 0.16; Z: 0.96; W: 1);
-  clrMidnightBlue: TGColorVector = (X: 0.184314; Y: 0.184314; Z: 0.309804; W: 1);
-  clrNavy: TGColorVector = (X: 0.137255; Y: 0.137255; Z: 0.556863; W: 1);
-  clrNavyBlue: TGColorVector = (X: 0.137255; Y: 0.137255; Z: 0.556863; W: 1);
-  clrOrange: TGColorVector = (X: 1; Y: 0.5; Z: 0.0; W: 1);
-  clrOrangeRed: TGColorVector = (X: 1; Y: 0.25; Z: 0; W: 1);
-  clrOrchid: TGColorVector = (X: 0.858824; Y: 0.439216; Z: 0.858824; W: 1);
-  clrPaleGreen: TGColorVector = (X: 0.560784; Y: 0.737255; Z: 0.560784; W: 1);
-  clrPink: TGColorVector = (X: 0.737255; Y: 0.560784; Z: 0.560784; W: 1);
-  clrPlum: TGColorVector = (X: 0.917647; Y: 0.678431; Z: 0.917647; W: 1);
-  clrSalmon: TGColorVector = (X: 0.435294; Y: 0.258824; Z: 0.258824; W: 1);
-  clrSeaGreen: TGColorVector = (X: 0.137255; Y: 0.556863; Z: 0.419608; W: 1);
-  clrSienna: TGColorVector = (X: 0.556863; Y: 0.419608; Z: 0.137255; W: 1);
-  clrSkyBlue: TGColorVector = (X: 0.196078; Y: 0.6; Z: 0.8; W: 1);
-  clrSlateBlue: TGColorVector = (X: 0; Y: 0.498039; Z: 1; W: 1);
-  clrSpringGreen: TGColorVector = (X: 0; Y: 1; Z: 0.498039; W: 1);
-  clrSteelBlue: TGColorVector = (X: 0.137255; Y: 0.419608; Z: 0.556863; W: 1);
-  clrTan: TGColorVector = (X: 0.858824; Y: 0.576471; Z: 0.439216; W: 1);
-  clrThistle: TGColorVector = (X: 0.847059; Y: 0.74902; Z: 0.847059; W: 1);
-  clrTurquoise: TGColorVector = (X: 0.678431; Y: 0.917647; Z: 0.917647; W: 1);
-  clrViolet: TGColorVector = (X: 0.309804; Y: 0.184314; Z: 0.309804; W: 1);
-  clrVioletRed: TGColorVector = (X: 0.8; Y: 0.196078; Z: 0.6; W: 1);
-  clrYellowGreen: TGColorVector = (X: 0.6; Y: 0.8; Z: 0.196078; W: 1);
-  clrSummerSky: TGColorVector = (X: 0.22; Y: 0.69; Z: 0.87; W: 1);
-  clrRichBlue: TGColorVector = (X: 0.35; Y: 0.35; Z: 0.67; W: 1);
-  clrBrass: TGColorVector = (X: 0.71; Y: 0.65; Z: 0.26; W: 1);
-  clrCopper: TGColorVector = (X: 0.72; Y: 0.45; Z: 0.20; W: 1);
-  clrBronze: TGColorVector = (X: 0.55; Y: 0.47; Z: 0.14; W: 1);
-  clrBronze2: TGColorVector = (X: 0.65; Y: 0.49; Z: 0.24; W: 1);
-  clrSilver: TGColorVector = (X: 0.90; Y: 0.91; Z: 0.98; W: 1);
-  clrBrightGold: TGColorVector = (X: 0.85; Y: 0.85; Z: 0.10; W: 1);
-  clrOldGold: TGColorVector = (X: 0.81; Y: 0.71; Z: 0.23; W: 1);
-  clrFeldspar: TGColorVector = (X: 0.82; Y: 0.57; Z: 0.46; W: 1);
-  clrQuartz: TGColorVector = (X: 0.85; Y: 0.85; Z: 0.95; W: 1);
-  clrNeonPink: TGColorVector = (X: 1.00; Y: 0.43; Z: 0.78; W: 1);
-  clrDarkPurple: TGColorVector = (X: 0.53; Y: 0.12; Z: 0.47; W: 1);
-  clrNeonBlue: TGColorVector = (X: 0.30; Y: 0.30; Z: 1.00; W: 1);
-  clrCoolCopper: TGColorVector = (X: 0.85; Y: 0.53; Z: 0.10; W: 1);
-  clrMandarinOrange: TGColorVector = (X: 0.89; Y: 0.47; Z: 0.20; W: 1);
-  clrLightWood: TGColorVector = (X: 0.91; Y: 0.76; Z: 0.65; W: 1);
-  clrMediumWood: TGColorVector = (X: 0.65; Y: 0.50; Z: 0.39; W: 1);
-  clrDarkWood: TGColorVector = (X: 0.52; Y: 0.37; Z: 0.26; W: 1);
-  clrSpicyPink: TGColorVector = (X: 1.00; Y: 0.11; Z: 0.68; W: 1);
-  clrSemiSweetChoc: TGColorVector = (X: 0.42; Y: 0.26; Z: 0.15; W: 1);
-  clrFlesh: TGColorVector = (X: 0.96; Y: 0.80; Z: 0.69; W: 1);
-  clrNewTan: TGColorVector = (X: 0.92; Y: 0.78; Z: 0.62; W: 1);
-  clrNewMidnightBlue: TGColorVector = (X: 0.00; Y: 0.00; Z: 0.61; W: 1);
-  clrVeryDarkBrown: TGColorVector = (X: 0.35; Y: 0.16; Z: 0.14; W: 1);
-  clrDarkBrown: TGColorVector = (X: 0.36; Y: 0.25; Z: 0.20; W: 1);
-  clrDarkTan: TGColorVector = (X: 0.59; Y: 0.41; Z: 0.31; W: 1);
-  clrGreenCopper: TGColorVector = (X: 0.32; Y: 0.49; Z: 0.46; W: 1);
-  clrDkGreenCopper: TGColorVector = (X: 0.29; Y: 0.46; Z: 0.43; W: 1);
-  clrDustyRose: TGColorVector = (X: 0.52; Y: 0.39; Z: 0.39; W: 1);
-  clrHuntersGreen: TGColorVector = (X: 0.13; Y: 0.37; Z: 0.31; W: 1);
-  clrScarlet: TGColorVector = (X: 0.55; Y: 0.09; Z: 0.09; W: 1);
-  clrLightPurple: TGColorVector = (X: 0.87; Y: 0.58; Z: 0.98; W: 1);
-  clrVeryLightPurple: TGColorVector = (X: 0.94; Y: 0.81; Z: 0.99; W: 1);
-  clrGreen: TGColorVector = (X: 0; Y: 0.5; Z: 0; W: 1);
-  clrOlive: TGColorVector = (X: 0.5; Y: 0.5; Z: 1; W: 1);
-  clrPurple: TGColorVector = (X: 1; Y: 0; Z: 1; W: 1);
-  clrTeal: TGColorVector = (X: 0; Y: 0.5; Z: 0.5; W: 1);
-  clrRed: TGColorVector = (X: 1; Y: 0; Z: 0; W: 1);
-  clrYellow: TGColorVector = (X: 1; Y: 1; Z: 0; W: 1);
-  clrWheat: TGColorVector = (X: 0.847059; Y: 0.847059; Z: 0.74902; W: 1);
+  clrAqua: TGLColorVector = (X: 0; Y: 1; Z: 1; W: 1);
+  clrAquamarine: TGLColorVector = (X: 0.439216; Y: 0.858824; Z: 0.576471; W: 1);
+  clrBakersChoc: TGLColorVector = (X: 0.36; Y: 0.20; Z: 0.09; W: 1);
+  clrBlue: TGLColorVector = (X: 0; Y: 0; Z: 1; W: 1);
+  clrBlueViolet: TGLColorVector = (X: 0.62352; Y: 0.372549; Z: 0.623529; W: 1);
+  clrBrown: TGLColorVector = (X: 0.647059; Y: 0.164706; Z: 0.164706; W: 1);
+  clrCadetBlue: TGLColorVector = (X: 0.372549; Y: 0.623529; Z: 0.623529; W: 1);
+  clrCoral: TGLColorVector = (X: 1; Y: 0.498039; Z: 0.0; W: 1);
+  clrCornflowerBlue: TGLColorVector = (X: 0.258824; Y: 0.258824; Z: 0.435294; W: 1);
+  clrDarkGreen: TGLColorVector = (X: 0.184314; Y: 0.309804; Z: 0.184314; W: 1);
+  clrDarkOliveGreen: TGLColorVector = (X: 0.309804; Y: 0.309804; Z: 0.184314; W: 1);
+  clrDarkOrchid: TGLColorVector = (X: 0.6; Y: 0.196078; Z: 0.8; W: 1);
+  clrDarkSlateBlue: TGLColorVector = (X: 0.419608; Y: 0.137255; Z: 0.556863; W: 1);
+  clrDarkSlateGray: TGLColorVector = (X: 0.184314; Y: 0.309804; Z: 0.309804; W: 1);
+  clrDarkSlateGrey: TGLColorVector = (X: 0.184314; Y: 0.309804; Z: 0.309804; W: 1);
+  clrDarkTurquoise: TGLColorVector = (X: 0.439216; Y: 0.576471; Z: 0.858824; W: 1);
+  clrFirebrick: TGLColorVector = (X: 0.556863; Y: 0.137255; Z: 0.137255; W: 1);
+  clrForestGreen: TGLColorVector = (X: 0.137255; Y: 0.556863; Z: 0.137255; W: 1);
+  clrFuchsia: TGLColorVector = (X: 1; Y: 0; Z: 1; W: 1);
+  clrGold: TGLColorVector = (X: 0.8; Y: 0.498039; Z: 0.196078; W: 1);
+  clrGoldenrod: TGLColorVector = (X: 0.858824; Y: 0.858824; Z: 0.439216; W: 1);
+  clrGreenYellow: TGLColorVector = (X: 0.576471; Y: 0.858824; Z: 0.439216; W: 1);
+  clrIndian: TGLColorVector = (X: 0.309804; Y: 0.184314; Z: 0.184314; W: 1);
+  clrKhaki: TGLColorVector = (X: 0.623529; Y: 0.623529; Z: 0.372549; W: 1);
+  clrLightBlue: TGLColorVector = (X: 0.74902; Y: 0.847059; Z: 0.847059; W: 1);
+  clrLightSteelBlue: TGLColorVector = (X: 0.560784; Y: 0.560784; Z: 0.737255; W: 1);
+  clrLime: TGLColorVector = (X: 0; Y: 1; Z: 0; W: 1);
+  clrLimeGreen: TGLColorVector = (X: 0.196078; Y: 0.8; Z: 0.196078; W: 1);
+  clrMaroon: TGLColorVector = (X: 0.556863; Y: 0.137255; Z: 0.419608; W: 1);
+  clrMediumAquamarine: TGLColorVector = (X: 0.196078; Y: 0.8; Z: 0.6; W: 1);
+  clrMediumBlue: TGLColorVector = (X: 0.196078; Y: 0.196078; Z: 0.8; W: 1);
+  clrMediumForestGreen: TGLColorVector = (X: 0.419608; Y: 0.556863; Z: 0.137255; W: 1);
+  clrMediumGoldenrod: TGLColorVector = (X: 0.917647; Y: 0.917647; Z: 0.678431; W: 1);
+  clrMediumOrchid: TGLColorVector = (X: 0.576471; Y: 0.439216; Z: 0.858824; W: 1);
+  clrMediumSeaGreen: TGLColorVector = (X: 0.258824; Y: 0.435294; Z: 0.258824; W: 1);
+  clrMediumSlateBlue: TGLColorVector = (X: 0.498039; Y: 0; Z: 1; W: 1);
+  clrMediumSpringGreen: TGLColorVector = (X: 0.498039; Y: 1; Z: 0; W: 1);
+  clrMediumTurquoise: TGLColorVector = (X: 0.439216; Y: 0.858824; Z: 0.858824; W: 1);
+  clrMediumViolet: TGLColorVector = (X: 0.858824; Y: 0.439216; Z: 0.576471; W: 1);
+  clrMediumPurple: TGLColorVector = (X: 0.73; Y: 0.16; Z: 0.96; W: 1);
+  clrMidnightBlue: TGLColorVector = (X: 0.184314; Y: 0.184314; Z: 0.309804; W: 1);
+  clrNavy: TGLColorVector = (X: 0.137255; Y: 0.137255; Z: 0.556863; W: 1);
+  clrNavyBlue: TGLColorVector = (X: 0.137255; Y: 0.137255; Z: 0.556863; W: 1);
+  clrOrange: TGLColorVector = (X: 1; Y: 0.5; Z: 0.0; W: 1);
+  clrOrangeRed: TGLColorVector = (X: 1; Y: 0.25; Z: 0; W: 1);
+  clrOrchid: TGLColorVector = (X: 0.858824; Y: 0.439216; Z: 0.858824; W: 1);
+  clrPaleGreen: TGLColorVector = (X: 0.560784; Y: 0.737255; Z: 0.560784; W: 1);
+  clrPink: TGLColorVector = (X: 0.737255; Y: 0.560784; Z: 0.560784; W: 1);
+  clrPlum: TGLColorVector = (X: 0.917647; Y: 0.678431; Z: 0.917647; W: 1);
+  clrSalmon: TGLColorVector = (X: 0.435294; Y: 0.258824; Z: 0.258824; W: 1);
+  clrSeaGreen: TGLColorVector = (X: 0.137255; Y: 0.556863; Z: 0.419608; W: 1);
+  clrSienna: TGLColorVector = (X: 0.556863; Y: 0.419608; Z: 0.137255; W: 1);
+  clrSkyBlue: TGLColorVector = (X: 0.196078; Y: 0.6; Z: 0.8; W: 1);
+  clrSlateBlue: TGLColorVector = (X: 0; Y: 0.498039; Z: 1; W: 1);
+  clrSpringGreen: TGLColorVector = (X: 0; Y: 1; Z: 0.498039; W: 1);
+  clrSteelBlue: TGLColorVector = (X: 0.137255; Y: 0.419608; Z: 0.556863; W: 1);
+  clrTan: TGLColorVector = (X: 0.858824; Y: 0.576471; Z: 0.439216; W: 1);
+  clrThistle: TGLColorVector = (X: 0.847059; Y: 0.74902; Z: 0.847059; W: 1);
+  clrTurquoise: TGLColorVector = (X: 0.678431; Y: 0.917647; Z: 0.917647; W: 1);
+  clrViolet: TGLColorVector = (X: 0.309804; Y: 0.184314; Z: 0.309804; W: 1);
+  clrVioletRed: TGLColorVector = (X: 0.8; Y: 0.196078; Z: 0.6; W: 1);
+  clrYellowGreen: TGLColorVector = (X: 0.6; Y: 0.8; Z: 0.196078; W: 1);
+  clrSummerSky: TGLColorVector = (X: 0.22; Y: 0.69; Z: 0.87; W: 1);
+  clrRichBlue: TGLColorVector = (X: 0.35; Y: 0.35; Z: 0.67; W: 1);
+  clrBrass: TGLColorVector = (X: 0.71; Y: 0.65; Z: 0.26; W: 1);
+  clrCopper: TGLColorVector = (X: 0.72; Y: 0.45; Z: 0.20; W: 1);
+  clrBronze: TGLColorVector = (X: 0.55; Y: 0.47; Z: 0.14; W: 1);
+  clrBronze2: TGLColorVector = (X: 0.65; Y: 0.49; Z: 0.24; W: 1);
+  clrSilver: TGLColorVector = (X: 0.90; Y: 0.91; Z: 0.98; W: 1);
+  clrBrightGold: TGLColorVector = (X: 0.85; Y: 0.85; Z: 0.10; W: 1);
+  clrOldGold: TGLColorVector = (X: 0.81; Y: 0.71; Z: 0.23; W: 1);
+  clrFeldspar: TGLColorVector = (X: 0.82; Y: 0.57; Z: 0.46; W: 1);
+  clrQuartz: TGLColorVector = (X: 0.85; Y: 0.85; Z: 0.95; W: 1);
+  clrNeonPink: TGLColorVector = (X: 1.00; Y: 0.43; Z: 0.78; W: 1);
+  clrDarkPurple: TGLColorVector = (X: 0.53; Y: 0.12; Z: 0.47; W: 1);
+  clrNeonBlue: TGLColorVector = (X: 0.30; Y: 0.30; Z: 1.00; W: 1);
+  clrCoolCopper: TGLColorVector = (X: 0.85; Y: 0.53; Z: 0.10; W: 1);
+  clrMandarinOrange: TGLColorVector = (X: 0.89; Y: 0.47; Z: 0.20; W: 1);
+  clrLightWood: TGLColorVector = (X: 0.91; Y: 0.76; Z: 0.65; W: 1);
+  clrMediumWood: TGLColorVector = (X: 0.65; Y: 0.50; Z: 0.39; W: 1);
+  clrDarkWood: TGLColorVector = (X: 0.52; Y: 0.37; Z: 0.26; W: 1);
+  clrSpicyPink: TGLColorVector = (X: 1.00; Y: 0.11; Z: 0.68; W: 1);
+  clrSemiSweetChoc: TGLColorVector = (X: 0.42; Y: 0.26; Z: 0.15; W: 1);
+  clrFlesh: TGLColorVector = (X: 0.96; Y: 0.80; Z: 0.69; W: 1);
+  clrNewTan: TGLColorVector = (X: 0.92; Y: 0.78; Z: 0.62; W: 1);
+  clrNewMidnightBlue: TGLColorVector = (X: 0.00; Y: 0.00; Z: 0.61; W: 1);
+  clrVeryDarkBrown: TGLColorVector = (X: 0.35; Y: 0.16; Z: 0.14; W: 1);
+  clrDarkBrown: TGLColorVector = (X: 0.36; Y: 0.25; Z: 0.20; W: 1);
+  clrDarkTan: TGLColorVector = (X: 0.59; Y: 0.41; Z: 0.31; W: 1);
+  clrGreenCopper: TGLColorVector = (X: 0.32; Y: 0.49; Z: 0.46; W: 1);
+  clrDkGreenCopper: TGLColorVector = (X: 0.29; Y: 0.46; Z: 0.43; W: 1);
+  clrDustyRose: TGLColorVector = (X: 0.52; Y: 0.39; Z: 0.39; W: 1);
+  clrHuntersGreen: TGLColorVector = (X: 0.13; Y: 0.37; Z: 0.31; W: 1);
+  clrScarlet: TGLColorVector = (X: 0.55; Y: 0.09; Z: 0.09; W: 1);
+  clrLightPurple: TGLColorVector = (X: 0.87; Y: 0.58; Z: 0.98; W: 1);
+  clrVeryLightPurple: TGLColorVector = (X: 0.94; Y: 0.81; Z: 0.99; W: 1);
+  clrGreen: TGLColorVector = (X: 0; Y: 0.5; Z: 0; W: 1);
+  clrOlive: TGLColorVector = (X: 0.5; Y: 0.5; Z: 1; W: 1);
+  clrPurple: TGLColorVector = (X: 1; Y: 0; Z: 1; W: 1);
+  clrTeal: TGLColorVector = (X: 0; Y: 0.5; Z: 0.5; W: 1);
+  clrRed: TGLColorVector = (X: 1; Y: 0; Z: 0; W: 1);
+  clrYellow: TGLColorVector = (X: 1; Y: 1; Z: 0; W: 1);
+  clrWheat: TGLColorVector = (X: 0.847059; Y: 0.847059; Z: 0.74902; W: 1);
 
   cDefaultNormalMapScale = 0.125;
 
 {$J- - disallow change of the following typed constants}
 
 var
-  // Specifies if TGColor should allocate memory for
+  // Specifies if TGLColor should allocate memory for
   // their default values (ie. design-time) or not (run-time)
   vUseDefaultColorSets: Boolean = False;
 
 implementation //-------------------------------------------------------------
 
 var
-  vColorManager: TGColorManager;
+  vColorManager: TGLColorManager;
 
 
 function RGB2Color(const r, g, b: Byte): TColor;
@@ -375,17 +375,17 @@ begin
 end;
 
 
-function ColorManager: TGColorManager;
+function ColorManager: TGLColorManager;
 begin
   if not Assigned(vColorManager) then
   begin
-    vColorManager := TGColorManager.Create;
+    vColorManager := TGLColorManager.Create;
     vColorManager.RegisterDefaultColors;
   end;
   Result := vColorManager;
 end;
 
-function ConvertWinColor(aColor: TColor; alpha: Single = 1): TGColorVector;
+function ConvertWinColor(aColor: TColor; alpha: Single = 1): TGLColorVector;
 var
   winColor: Integer;
 begin
@@ -442,13 +442,13 @@ begin
   clrBackground := ConvertWinColor(clBackground);
 end;
 
-function ConvertColorVector(const aColor: TGColorVector): TColor;
+function ConvertColorVector(const aColor: TGLColorVector): TColor;
 begin
   Result := RGB2Color(Round(255 * aColor.X), Round(255 * aColor.Y),
     Round(255 * aColor.Z));
 end;
 
-function ConvertColorVector(const aColor: TGColorVector;
+function ConvertColorVector(const aColor: TGLColorVector;
   intensity: Single): TColor;
 begin
   intensity := 255 * intensity;
@@ -456,7 +456,7 @@ begin
     Round(intensity * aColor.Z));
 end;
 
-function ConvertRGBColor(const aColor: array of Byte): TGColorVector;
+function ConvertRGBColor(const aColor: array of Byte): TGLColorVector;
 var
   n: Integer;
 begin
@@ -478,30 +478,30 @@ begin
 end;
 
 // ------------------
-// ------------------ TGColor ------------------
+// ------------------ TGLColor ------------------
 // ------------------
-constructor TGColor.Create(AOwner: TPersistent);
+constructor TGLColor.Create(AOwner: TPersistent);
 begin
   inherited;
   Initialize(clrBlack);
 end;
 
-constructor TGColor.CreateInitialized(AOwner: TPersistent;
-  const color: TGColorVector; changeEvent: TNotifyEvent = nil);
+constructor TGLColor.CreateInitialized(AOwner: TPersistent;
+  const color: TGLColorVector; changeEvent: TNotifyEvent = nil);
 begin
   Create(AOwner);
   Initialize(color);
   OnNotifyChange := changeEvent;
 end;
 
-destructor TGColor.Destroy;
+destructor TGLColor.Destroy;
 begin
   if Assigned(FPDefaultColor) then
     Dispose(FPDefaultColor);
   inherited;
 end;
 
-procedure TGColor.Initialize(const color: TGColorVector);
+procedure TGLColor.Initialize(const color: TGLColorVector);
 begin
   SetVector(FColor, color);
   if vUseDefaultColorSets then
@@ -512,18 +512,18 @@ begin
   end;
 end;
 
-procedure TGColor.SetColorVector(const aColor: TGColorVector);
+procedure TGLColor.SetColorVector(const aColor: TGLColorVector);
 begin
   SetVector(FColor, aColor);
   NotifyChange(Self);
 end;
 
-procedure TGColor.SetDirectColorVector(const aColor: TGColorVector);
+procedure TGLColor.SetDirectColorVector(const aColor: TGLColorVector);
 begin
   SetVector(FColor, aColor);
 end;
 
-procedure TGColor.SetColorComponent(index: Integer; value: Single);
+procedure TGLColor.SetColorComponent(index: Integer; value: Single);
 begin
   if FColor.V[index] <> value then
   begin
@@ -532,51 +532,51 @@ begin
   end;
 end;
 
-procedure TGColor.SetAsWinColor(const val: TColor);
+procedure TGLColor.SetAsWinColor(const val: TColor);
 begin
   FColor := ConvertWinColor(val);
   NotifyChange(Self);
 end;
 
-function TGColor.GetAsWinColor: TColor;
+function TGLColor.GetAsWinColor: TColor;
 begin
   Result := ConvertColorVector(FColor);
 end;
 
-function TGColor.GetColorComponent(const index: Integer): Single;
+function TGLColor.GetColorComponent(const index: Integer): Single;
 begin
   Result := FColor.V[Index];
 end;
 
-procedure TGColor.Assign(Source: TPersistent);
+procedure TGLColor.Assign(Source: TPersistent);
 begin
-  if Assigned(Source) and (Source is TGColor) then
+  if Assigned(Source) and (Source is TGLColor) then
   begin
-    FColor := TGColor(Source).FColor;
+    FColor := TGLColor(Source).FColor;
     NotifyChange(Self);
   end
   else
     inherited;
 end;
 
-procedure TGColor.DefineProperties(Filer: TFiler);
+procedure TGLColor.DefineProperties(Filer: TFiler);
 begin
   inherited;
   Filer.DefineBinaryProperty('Color', ReadData, WriteData,
     not(Assigned(FPDefaultColor) and VectorEquals(FColor, FPDefaultColor^)));
 end;
 
-procedure TGColor.ReadData(Stream: TStream);
+procedure TGLColor.ReadData(Stream: TStream);
 begin
   Stream.Read(FColor, SizeOf(FColor));
 end;
 
-procedure TGColor.WriteData(Stream: TStream);
+procedure TGLColor.WriteData(Stream: TStream);
 begin
   Stream.Write(FColor, SizeOf(FColor));
 end;
 
-procedure TGColor.NotifyChange(Sender: TObject);
+procedure TGLColor.NotifyChange(Sender: TObject);
 var
   intf: IGLNotifyAble;
 begin
@@ -590,19 +590,19 @@ begin
   end;
 end;
 
-function TGColor.AsAddress: PSingle;
+function TGLColor.AsAddress: PSingle;
 begin
   Result := @FColor;
 end;
 
-procedure TGColor.RandomColor;
+procedure TGLColor.RandomColor;
 begin
   Red := Random;
   Green := Random;
   Blue := Random;
 end;
 
-procedure TGColor.SetColor(Red, Green, Blue: Single; Alpha: Single = 1);
+procedure TGLColor.SetColor(Red, Green, Blue: Single; Alpha: Single = 1);
 begin
   FColor.X := Red;
   FColor.Y := Green;
@@ -611,7 +611,7 @@ begin
   NotifyChange(Self);
 end;
 
-function TGColor.GetHSVA: TGLVector;
+function TGLColor.GetHSVA: TGLVector;
 var
   delta, min: Single;
 const
@@ -647,7 +647,7 @@ begin
   Result.W := Alpha;
 end;
 
-procedure TGColor.SetHSVA(const hsva: TGLVector);
+procedure TGLColor.SetHSVA(const hsva: TGLVector);
 var
   f, hTemp, p, q, t: Single;
 const
@@ -715,23 +715,23 @@ begin
 end;
 
 // ------------------
-// ------------------ TGColorManager ------------------
+// ------------------ TGLColorManager ------------------
 // ------------------
 
-function TGColorManager.FindColor(const aName: String): TGColorVector;
+function TGLColorManager.FindColor(const aName: String): TGLColorVector;
 var
   i: Integer;
 begin
   Result := clrBlack;
   for i := 0 to Count - 1 do
-    if CompareText(string(TGColorEntry(Items[i]^).Name), aName) = 0 then
+    if CompareText(string(TGLColorEntry(Items[i]^).Name), aName) = 0 then
     begin
-      SetVector(Result, TGColorEntry(Items[i]^).color);
+      SetVector(Result, TGLColorEntry(Items[i]^).color);
       Break;
     end;
 end;
 
-function TGColorManager.GetColor(const aName: String): TGColorVector;
+function TGLColorManager.GetColor(const aName: String): TGLColorVector;
 var
   workCopy: String;
   delimiter: Integer;
@@ -787,7 +787,7 @@ end;
 
 // ------------------------------------------------------------------------------
 
-function TGColorManager.GetColorName(const aColor: TGColorVector): String;
+function TGLColorManager.GetColorName(const aColor: TGLColorVector): String;
 
 const
   MinDiff = 1E-6;
@@ -797,14 +797,14 @@ var
 
 begin
   for i := 0 to Count - 1 do
-    with TGColorEntry(Items[i]^) do
+    with TGLColorEntry(Items[i]^) do
       if (Abs(Color.X - aColor.X) < MinDiff) and
         (Abs(Color.Y - aColor.Y) < MinDiff) and
         (Abs(Color.Z - aColor.Z) < MinDiff) and
         (Abs(Color.W - aColor.W) < MinDiff) then
         Break;
   if i < Count then
-    Result := string(TGColorEntry(Items[i]^).Name)
+    Result := string(TGLColorEntry(Items[i]^).Name)
   else
     Result := Format('<%.3f %.3f %.3f %.3f>', [aColor.X, aColor.Y, aColor.Z,
       aColor.W]);
@@ -812,21 +812,21 @@ end;
 
 // ------------------------------------------------------------------------------
 
-destructor TGColorManager.Destroy;
+destructor TGLColorManager.Destroy;
 var
   i: Integer;
 begin
   for i := 0 to Count - 1 do
-    FreeMem(Items[i], SizeOf(TGColorEntry));
+    FreeMem(Items[i], SizeOf(TGLColorEntry));
   inherited Destroy;
 end;
 
 // ------------------------------------------------------------------------------
 
-procedure TGColorManager.AddColor(const aName: String;
-  const aColor: TGColorVector);
+procedure TGLColorManager.AddColor(const aName: String;
+  const aColor: TGLColorVector);
 var
-  newEntry: PGColorEntry;
+  newEntry: PGLColorEntry;
 begin
   New(newEntry);
   if newEntry = nil then
@@ -839,23 +839,23 @@ begin
   Add(newEntry);
 end;
 
-procedure TGColorManager.EnumColors(Proc: TGetStrProc);
+procedure TGLColorManager.EnumColors(Proc: TGetStrProc);
 var
   i: Integer;
 begin
   for i := 0 to Count - 1 do
-    Proc(string(TGColorEntry(Items[i]^).Name));
+    Proc(string(TGLColorEntry(Items[i]^).Name));
 end;
 
-procedure TGColorManager.EnumColors(AValues: TStrings);
+procedure TGLColorManager.EnumColors(AValues: TStrings);
 var
   i: Integer;
 begin
   for i := 0 to Count - 1 do
-    AValues.Add(string(TGColorEntry(Items[i]^).Name));
+    AValues.Add(string(TGLColorEntry(Items[i]^).Name));
 end;
 
-procedure TGColorManager.RegisterDefaultColors;
+procedure TGLColorManager.RegisterDefaultColors;
 begin
   Capacity := 150;
   AddColor('clrTransparent', clrTransparent);
@@ -1013,13 +1013,13 @@ begin
   AddColor('clrInfoBk', clrInfoBk);
 end;
 
-procedure TGColorManager.RemoveColor(const aName: String);
+procedure TGLColorManager.RemoveColor(const aName: String);
 var
   i: Integer;
 begin
   for i := 0 to Count - 1 do
   begin
-    if CompareText(string(TGColorEntry(Items[i]^).Name), aName) = 0 then
+    if CompareText(string(TGLColorEntry(Items[i]^).Name), aName) = 0 then
     begin
       Delete(i);
       Break;
@@ -1027,7 +1027,7 @@ begin
   end;
 end;
 
-procedure RegisterColor(const aName: String; const aColor: TGColorVector);
+procedure RegisterColor(const aName: String; const aColor: TGLColorVector);
 begin
   ColorManager.AddColor(aName, aColor);
 end;

Source/GLS.CurvesAndSurfaces.pas

@@ -25,12 +25,12 @@ function BSplinePoint(t: single; n, k: integer; knots: PSingleArray;
   cp: PAffineVectorArray): TAffineVector;
 function BSplineSurfacePoint(s, t: single; m, n, k1, k2: integer;
   uknots, vknots: PSingleArray; cp: PAffineVectorArray): TAffineVector;
-procedure GenerateBSpline(Steps, Order: integer; KnotVector: TGSingleList;
+procedure GenerateBSpline(Steps, Order: integer; KnotVector: TGLSingleList;
   ControlPoints, Vertices: TGLAffineVectorList);
 procedure GenerateBSplineSurface(Steps, UOrder, VOrder, Width, Height: integer;
-  UKnotVector, VKnotVector: TGSingleList;
+  UKnotVector, VKnotVector: TGLSingleList;
   ControlPoints, Vertices: TGLAffineVectorList);
-procedure GenerateKnotVector(KnotVector: TGSingleList;
+procedure GenerateKnotVector(KnotVector: TGLSingleList;
   NumberOfPoints, Order: integer; Continuity: TBSplineContinuity);
 
 implementation // -----------------------------------------------------------
@@ -223,7 +223,7 @@ begin
   end;
 end;
 
-procedure GenerateBSpline(Steps, Order: integer; KnotVector: TGSingleList;
+procedure GenerateBSpline(Steps, Order: integer; KnotVector: TGLSingleList;
   ControlPoints, Vertices: TGLAffineVectorList);
 var
   i: integer;
@@ -236,7 +236,7 @@ begin
 end;
 
 procedure GenerateBSplineSurface(Steps, UOrder, VOrder, Width, Height: integer;
-  UKnotVector, VKnotVector: TGSingleList; ControlPoints, Vertices: TGLAffineVectorList);
+  UKnotVector, VKnotVector: TGLSingleList; ControlPoints, Vertices: TGLAffineVectorList);
 var
   i, j: integer;
 begin
@@ -249,7 +249,7 @@ begin
         @UKnotVector.List[0], @VKnotVector.List[0], ControlPoints.List);
 end;
 
-procedure GenerateKnotVector(KnotVector: TGSingleList;
+procedure GenerateKnotVector(KnotVector: TGLSingleList;
   NumberOfPoints, Order: integer; Continuity: TBSplineContinuity);
 var
   i, n, k: integer;

Source/GLS.DCE.pas

@@ -547,7 +547,7 @@ function TGLDCEManager.MoveByDistance(var Body: TGLDCEDynamic;
 var
   // Friction and bounce
   TotalFriction, Bounce, f, m, restitution: single;
-  ContactList: TgIntegerList;
+  ContactList: TGLIntegerList;
   // Temporary properties (Static or Dynamic)
   tFriction, tBounceFactor: single;
   TObject: TGLBaseSceneObject;
@@ -667,7 +667,7 @@ begin
   // Generate events and calculate average friction
   lastobj := -1;
   TotalFriction := Body.Friction;
-  ContactList := TgIntegerList.Create;
+  ContactList := TGLIntegerList.Create;
   try
     for i := 0 to High(MP.Contacts) do
       with MP do

Source/GLS.Extrusion.pas

@@ -149,13 +149,13 @@ type
   TGLPipeNode = class(TGLNode)
   private
     FRadiusFactor: Single;
-    FColor: TGColor;
+    FColor: TGLColor;
     FTexCoordT: Single;
   protected
     function GetDisplayName: string; override;
     procedure SetRadiusFactor(const val: Single);
     function StoreRadiusFactor: Boolean;
-    procedure SetColor(const val: TGColor);
+    procedure SetColor(const val: TGLColor);
     procedure ColorChanged(sender: TObject);
     function StoreTexCoordT: Boolean;
   public
@@ -165,7 +165,7 @@ type
   published
     property RadiusFactor: Single read FRadiusFactor write SetRadiusFactor stored
       StoreRadiusFactor;
-    property Color: TGColor read FColor write SetColor;
+    property Color: TGLColor read FColor write SetColor;
     property TexCoordT: Single read FTexCoordT write FTexCoordT stored
       StoreTexCoordT;
   end;
@@ -687,7 +687,7 @@ constructor TGLPipeNode.Create(Collection: TCollection);
 begin
   inherited Create(Collection);
   FRadiusFactor := 1.0;
-  FColor := TGColor.CreateInitialized(Self, clrBlack, ColorChanged);
+  FColor := TGLColor.CreateInitialized(Self, clrBlack, ColorChanged);
   FTexCoordT := 1.0;
 end;
 
@@ -735,7 +735,7 @@ begin
   Result := (FTexCoordT <> 1.0);
 end;
 
-procedure TGLPipeNode.SetColor(const val: TGColor);
+procedure TGLPipeNode.SetColor(const val: TGLColor);
 begin
   FColor.Assign(val);
 end;
@@ -928,7 +928,7 @@ type
   end;
   TRowData = record
     node: array of TNodeData;
-    color: TGColorVector;
+    color: TGLColorVector;
     center: TVector3f;
     textcoordT: Single;
   end;

Source/GLS.FBORenderer.pas

@@ -188,7 +188,7 @@ type
     FPostInitialize: TNotifyEvent;
     FAfterRender: TGLDirectRenderEvent;
     FPreInitialize: TNotifyEvent;
-    FBackgroundColor: TGColor;
+    FBackgroundColor: TGLColor;
     FClearOptions: TGLFBOClearOptions;
     FAspect: Single;
     FSceneScaleFactor: Single;
@@ -216,7 +216,7 @@ type
     procedure SetCamera(const Value: TGLCamera);
     procedure SetEnabledRenderBuffers(const Value: TGLEnabledRenderBuffers);
     procedure SetTargetVisibility(const Value: TGLFBOTargetVisibility);
-    procedure SetBackgroundColor(const Value: TGColor);
+    procedure SetBackgroundColor(const Value: TGLColor);
     function StoreSceneScaleFactor: Boolean;
     function StoreAspect: Boolean;
     procedure SetUseLibraryAsMultiTarget(Value: Boolean);
@@ -264,7 +264,7 @@ type
       write SetDepthTextureName;
     property MaterialLibrary: TGLAbstractMaterialLibrary read GetMaterialLibrary
       write SetMaterialLibrary;
-    property BackgroundColor: TGColor read FBackgroundColor write SetBackgroundColor;
+    property BackgroundColor: TGLColor read FBackgroundColor write SetBackgroundColor;
     property ClearOptions: TGLFBOClearOptions read FClearOptions
       write FClearOptions;
     (* Camera used for rendering to the FBO
@@ -808,7 +808,7 @@ end;
 procedure TGLFrameBuffer.Render(var rci: TGLRenderContextInfo; baseObject:
   TGLBaseSceneObject);
 var
-  backColor: TGColorVector;
+  backColor: TGLColorVector;
   buffer: TGLSceneBuffer;
 begin
   Bind;
@@ -979,7 +979,7 @@ begin
   inherited;
   ObjectStyle := [osDirectDraw, osNoVisibilityCulling];
   FFbo := TGLFrameBuffer.Create;
-  FBackgroundColor := TGColor.Create(Self);
+  FBackgroundColor := TGLColor.Create(Self);
   FUseLibraryAsMultiTarget := False;
   FForceTextureDimensions := True;
   FWidth := 256;
@@ -1278,7 +1278,7 @@ procedure TGLFBORenderer.RenderToFBO(var ARci: TGLRenderContextInfo);
 
 type
   TGLStoredStates = record
-    ColorClearValue: TGColorVector;
+    ColorClearValue: TGLColorVector;
     ColorWriteMask: TGLColorMask;
     Tests: TGLStates;
   end;
@@ -1306,7 +1306,7 @@ type
   end;
 
 var
-  backColor: TGColorVector;
+  backColor: TGLColorVector;
   buffer: TGLSceneBuffer;
   savedStates: TGLStoredStates;
   w, h: Integer;
@@ -1420,7 +1420,7 @@ begin
   end;
 end;
 
-procedure TGLFBORenderer.SetBackgroundColor(const Value: TGColor);
+procedure TGLFBORenderer.SetBackgroundColor(const Value: TGLColor);
 begin
   FBackgroundColor.Assign(Value);
 end;

Source/GLS.Feedback.pas

@@ -46,7 +46,7 @@ type
   TGLFeedback = class(TGLBaseSceneObject)
   private
     FActive: Boolean;
-    FBuffer: TGSingleList;
+    FBuffer: TGLSingleList;
     FMaxBufferSize: Cardinal;
     FBuffered: Boolean;
     FCorrectionScaling: Single;
@@ -66,11 +66,11 @@ type
       Normals: TGLAffineVectorList = nil;
       Colors: TGLVectorList = nil;
       TexCoords: TGLAffineVectorList = nil;
-      VertexIndices: TgIntegerList = nil);
+      VertexIndices: TGLIntegerList = nil);
     // True when there is data in the buffer ready for parsing
     property Buffered: Boolean read FBuffered;
     // The feedback buffer
-    property Buffer: TGSingleList read FBuffer;
+    property Buffer: TGLSingleList read FBuffer;
     (* Vertex positions in the buffer needs to be scaled by
        CorrectionScaling to get correct coordinates. *)
     property CorrectionScaling: Single read FCorrectionScaling;
@@ -96,7 +96,7 @@ constructor TGLFeedback.Create(AOwner: TComponent);
 begin
   inherited;
   FMaxBufferSize := $100000;
-  FBuffer := TGSingleList.Create;
+  FBuffer := TGLSingleList.Create;
   FBuffer.Capacity := FMaxBufferSize div SizeOf(Single);
   FBuffered := False;
   FActive := False;
@@ -189,14 +189,14 @@ procedure TGLFeedback.BuildMeshFromBuffer(
   Normals: TGLAffineVectorList = nil;
   Colors: TGLVectorList = nil;
   TexCoords: TGLAffineVectorList = nil;
-  VertexIndices: TgIntegerList = nil);
+  VertexIndices: TGLIntegerList = nil);
 var
   value: Single;
   i, j, LCount, skip: Integer;
   vertex, color, texcoord: TGLVector;
   tempVertices, tempNormals, tempTexCoords: TGLAffineVectorList;
   tempColors: TGLVectorList;
-  tempIndices: TgIntegerList;
+  tempIndices: TGLIntegerList;
   ColorBuffered, TexCoordBuffered: Boolean;
 begin
   Assert(FMode <> fm2D, 'Cannot build mesh from fm2D feedback mode.');
@@ -292,7 +292,7 @@ begin
   end
   else
   begin
-    tempIndices := TgIntegerList.Create;
+    tempIndices := TGLIntegerList.Create;
     tempIndices.AddSerie(0, 1, tempVertices.Count);
   end;
 

Source/GLS.File3DPDF.pas

@@ -260,7 +260,7 @@ var
   FaceCount, ModelPositionCount, NormalCount, I, J: Integer;
   FacePositionList, NormalList, ModelPositionList, ModelNormalList, FaceShadingList: String;
   Lines: TStringList;
-  Indicies: TgIntegerList;
+  Indicies: TGLIntegerList;
 
   function FormatVector(const AVector: TAffineVector): string;
   begin

Source/GLS.File3DS.pas

@@ -62,8 +62,8 @@ type
     procedure LoadData(const ANumKeys: Integer; const Keys: PKeyHeaderList; const AData: Pointer); virtual;
     procedure Apply(var DataTransf: TGLFile3DSAnimationData; const AFrame: real); virtual; abstract;
     procedure Assign(Source: TPersistent); override;
-    procedure WriteToFiler(Writer: TGVirtualWriter); override;
-    procedure ReadFromFiler(Reader: TGVirtualReader); override;
+    procedure WriteToFiler(Writer: TGLVirtualWriter); override;
+    procedure ReadFromFiler(Reader: TGLVirtualReader); override;
   end;
 
   TGLFile3DSScaleAnimationKeys = class(TGLFile3DSAnimationKeys)
@@ -73,8 +73,8 @@ type
     procedure LoadData(const ANumKeys: Integer; const Keys: PKeyHeaderList; const AData: Pointer); override;
     procedure Apply(var DataTransf: TGLFile3DSAnimationData; const AFrame: real); override;
     procedure Assign(Source: TPersistent); override;
-    procedure WriteToFiler(Writer: TGVirtualWriter); override;
-    procedure ReadFromFiler(Reader: TGVirtualReader); override;
+    procedure WriteToFiler(Writer: TGLVirtualWriter); override;
+    procedure ReadFromFiler(Reader: TGLVirtualReader); override;
   end;
 
   TGLFile3DSRotationAnimationKeys = class(TGLFile3DSAnimationKeys)
@@ -84,8 +84,8 @@ type
     procedure LoadData(const ANumKeys: Integer; const Keys: PKeyHeaderList; const AData: Pointer); override;
     procedure Apply(var DataTransf: TGLFile3DSAnimationData; const AFrame: real); override;
     procedure Assign(Source: TPersistent); override;
-    procedure WriteToFiler(Writer: TGVirtualWriter); override;
-    procedure ReadFromFiler(Reader: TGVirtualReader); override;
+    procedure WriteToFiler(Writer: TGLVirtualWriter); override;
+    procedure ReadFromFiler(Reader: TGLVirtualReader); override;
   end;
 
   TGLFile3DSPositionAnimationKeys = class(TGLFile3DSAnimationKeys)
@@ -95,8 +95,8 @@ type
     procedure LoadData(const ANumKeys: Integer; const Keys: PKeyHeaderList; const AData: Pointer); override;
     procedure Apply(var DataTransf: TGLFile3DSAnimationData; const AFrame: real); override;
     procedure Assign(Source: TPersistent); override;
-    procedure WriteToFiler(Writer: TGVirtualWriter); override;
-    procedure ReadFromFiler(Reader: TGVirtualReader); override;
+    procedure WriteToFiler(Writer: TGLVirtualWriter); override;
+    procedure ReadFromFiler(Reader: TGLVirtualReader); override;
   end;
 
   TGLFile3DSColorAnimationKeys = class(TGLFile3DSAnimationKeys)
@@ -106,8 +106,8 @@ type
     procedure LoadData(const ANumKeys: Integer; const Keys: PKeyHeaderList; const AData: Pointer); override;
     procedure Apply(var DataTransf: TGLFile3DSAnimationData; const AFrame: real); override;
     procedure Assign(Source: TPersistent); override;
-    procedure WriteToFiler(Writer: TGVirtualWriter); override;
-    procedure ReadFromFiler(Reader: TGVirtualReader); override;
+    procedure WriteToFiler(Writer: TGLVirtualWriter); override;
+    procedure ReadFromFiler(Reader: TGLVirtualReader); override;
   end;
 
   TTGLFile3DSPositionAnimationKeys = class(TGLFile3DSAnimationKeys)
@@ -117,8 +117,8 @@ type
     procedure LoadData(const ANumKeys: Integer; const Keys: PKeyHeaderList; const AData: Pointer); override;
     procedure Apply(var DataTransf: TGLFile3DSAnimationData; const AFrame: real); override;
     procedure Assign(Source: TPersistent); override;
-    procedure WriteToFiler(Writer: TGVirtualWriter); override;
-    procedure ReadFromFiler(Reader: TGVirtualReader); override;
+    procedure WriteToFiler(Writer: TGLVirtualWriter); override;
+    procedure ReadFromFiler(Reader: TGLVirtualReader); override;
   end;
 
   TGLFile3DSSpotLightCutOffAnimationKeys = class(TGLFile3DSAnimationKeys)
@@ -128,8 +128,8 @@ type
     procedure LoadData(const ANumKeys: Integer; const Keys: PKeyHeaderList; const AData: Pointer); override;
     procedure Apply(var DataTransf: TGLFile3DSAnimationData; const AFrame: real); override;
     procedure Assign(Source: TPersistent); override;
-    procedure WriteToFiler(Writer: TGVirtualWriter); override;
-    procedure ReadFromFiler(Reader: TGVirtualReader); override;
+    procedure WriteToFiler(Writer: TGLVirtualWriter); override;
+    procedure ReadFromFiler(Reader: TGLVirtualReader); override;
   end;
 
   TGLFile3DSLightHotSpotAnimationKeys = class(TGLFile3DSAnimationKeys)
@@ -139,8 +139,8 @@ type
     procedure LoadData(const ANumKeys: Integer; const Keys: PKeyHeaderList; const AData: Pointer); override;
     procedure Apply(var DataTransf: TGLFile3DSAnimationData; const AFrame: real); override;
     procedure Assign(Source: TPersistent); override;
-    procedure WriteToFiler(Writer: TGVirtualWriter); override;
-    procedure ReadFromFiler(Reader: TGVirtualReader); override;
+    procedure WriteToFiler(Writer: TGLVirtualWriter); override;
+    procedure ReadFromFiler(Reader: TGLVirtualReader); override;
   end;
 
   TGLFile3DSRollAnimationKeys = class(TGLFile3DSAnimationKeys)
@@ -150,8 +150,8 @@ type
     procedure LoadData(const ANumKeys: Integer; const Keys: PKeyHeaderList; const AData: Pointer); override;
     procedure Apply(var DataTransf: TGLFile3DSAnimationData; const AFrame: real); override;
     procedure Assign(Source: TPersistent); override;
-    procedure WriteToFiler(Writer: TGVirtualWriter); override;
-    procedure ReadFromFiler(Reader: TGVirtualReader); override;
+    procedure WriteToFiler(Writer: TGLVirtualWriter); override;
+    procedure ReadFromFiler(Reader: TGLVirtualReader); override;
   end;
 
   TGLFile3DSAnimationKeyList = class(TGLPersistentObject)
@@ -163,8 +163,8 @@ type
     procedure AddKeys(const AItem: TGLFile3DSAnimationKeys);
     procedure ClearKeys;
     procedure Assign(Source: TPersistent); override;
-    procedure WriteToFiler(Writer: TGVirtualWriter); override;
-    procedure ReadFromFiler(Reader: TGVirtualReader); override;
+    procedure WriteToFiler(Writer: TGLVirtualWriter); override;
+    procedure ReadFromFiler(Reader: TGLVirtualReader); override;
     destructor Destroy; override;
   end;
 
@@ -188,8 +188,8 @@ type
     procedure GetExtents(out min, max: TAffineVector); override;
     function ExtractTriangles(texCoords: TGLAffineVectorList = nil; normals: TGLAffineVectorList = nil): TGLAffineVectorList;
       override;
-    procedure WriteToFiler(Writer: TGVirtualWriter); override;
-    procedure ReadFromFiler(Reader: TGVirtualReader); override;
+    procedure WriteToFiler(Writer: TGLVirtualWriter); override;
+    procedure ReadFromFiler(Reader: TGLVirtualReader); override;
     procedure Assign(Source: TPersistent); override;
     constructor Create; override;
     destructor Destroy; override;
@@ -216,8 +216,8 @@ type
     procedure LoadAnimation(const AData: Pointer); override;
     procedure SetFrame(const AFrame: real); override;
     procedure Assign(Source: TPersistent); override;
-    procedure WriteToFiler(Writer: TGVirtualWriter); override;
-    procedure ReadFromFiler(Reader: TGVirtualReader); override;
+    procedure WriteToFiler(Writer: TGLVirtualWriter); override;
+    procedure ReadFromFiler(Reader: TGLVirtualReader); override;
     destructor Destroy; override;
   end;
 
@@ -240,8 +240,8 @@ type
     procedure LoadData(Owner: TGLBaseMesh; AData: PCamera3DS);
     procedure LoadAnimation(const AData: Pointer); override;
     procedure SetFrame(const AFrame: real); override;
-    procedure WriteToFiler(Writer: TGVirtualWriter); override;
-    procedure ReadFromFiler(Reader: TGVirtualReader); override;
+    procedure WriteToFiler(Writer: TGLVirtualWriter); override;
+    procedure ReadFromFiler(Reader: TGLVirtualReader); override;
     destructor Destroy; override;
   end;
 
@@ -504,14 +504,14 @@ begin
     inherited Assign(Source);
 end;
 
-procedure TGLFile3DSAnimationKeys.WriteToFiler(Writer: TGVirtualWriter);
+procedure TGLFile3DSAnimationKeys.WriteToFiler(Writer: TGLVirtualWriter);
 begin
   Writer.WriteInteger(FNumKeys);
   if FNumKeys > 0 then
     Writer.Write(FKeys[0], FNumKeys * SizeOf(TKeyHeader3DS));
 end;
 
-procedure TGLFile3DSAnimationKeys.ReadFromFiler(Reader: TGVirtualReader);
+procedure TGLFile3DSAnimationKeys.ReadFromFiler(Reader: TGLVirtualReader);
 begin
   FNumKeys := Reader.ReadInteger;
   SetLength(FKeys, FNumKeys);
@@ -567,7 +567,7 @@ begin
     FScale[I] := (Source as TGLFile3DSScaleAnimationKeys).FScale[I];
 end;
 
-procedure TGLFile3DSScaleAnimationKeys.WriteToFiler(Writer: TGVirtualWriter);
+procedure TGLFile3DSScaleAnimationKeys.WriteToFiler(Writer: TGLVirtualWriter);
 begin
   inherited;
 
@@ -575,7 +575,7 @@ begin
     Writer.Write(FScale[0], FNumKeys * SizeOf(TPoint3DS));
 end;
 
-procedure TGLFile3DSScaleAnimationKeys.ReadFromFiler(Reader: TGVirtualReader);
+procedure TGLFile3DSScaleAnimationKeys.ReadFromFiler(Reader: TGLVirtualReader);
 begin
   inherited;
 
@@ -642,7 +642,7 @@ begin
     FRot[I] := (Source as TGLFile3DSRotationAnimationKeys).FRot[I];
 end;
 
-procedure TGLFile3DSRotationAnimationKeys.WriteToFiler(Writer: TGVirtualWriter);
+procedure TGLFile3DSRotationAnimationKeys.WriteToFiler(Writer: TGLVirtualWriter);
 begin
   inherited;
 
@@ -650,7 +650,7 @@ begin
     Writer.Write(FRot[0], FNumKeys * SizeOf(TKFRotKey3DS));
 end;
 
-procedure TGLFile3DSRotationAnimationKeys.ReadFromFiler(Reader: TGVirtualReader);
+procedure TGLFile3DSRotationAnimationKeys.ReadFromFiler(Reader: TGLVirtualReader);
 begin
   inherited;
 
@@ -694,7 +694,7 @@ begin
     FPos[I] := (Source as TGLFile3DSPositionAnimationKeys).FPos[I];
 end;
 
-procedure TGLFile3DSPositionAnimationKeys.WriteToFiler(Writer: TGVirtualWriter);
+procedure TGLFile3DSPositionAnimationKeys.WriteToFiler(Writer: TGLVirtualWriter);
 begin
   inherited;
 
@@ -702,7 +702,7 @@ begin
     Writer.Write(FPos[0], FNumKeys * SizeOf(TPoint3DS));
 end;
 
-procedure TGLFile3DSPositionAnimationKeys.ReadFromFiler(Reader: TGVirtualReader);
+procedure TGLFile3DSPositionAnimationKeys.ReadFromFiler(Reader: TGLVirtualReader);
 begin
   inherited;
 
@@ -739,7 +739,7 @@ begin
     FCol[I] := (Source as TGLFile3DSColorAnimationKeys).FCol[I];
 end;
 
-procedure TGLFile3DSColorAnimationKeys.WriteToFiler(Writer: TGVirtualWriter);
+procedure TGLFile3DSColorAnimationKeys.WriteToFiler(Writer: TGLVirtualWriter);
 begin
   inherited;
 
@@ -747,7 +747,7 @@ begin
     Writer.Write(FCol[0], FNumKeys * SizeOf(TFColor3DS));
 end;
 
-procedure TGLFile3DSColorAnimationKeys.ReadFromFiler(Reader: TGVirtualReader);
+procedure TGLFile3DSColorAnimationKeys.ReadFromFiler(Reader: TGLVirtualReader);
 begin
   inherited;
 
@@ -791,7 +791,7 @@ begin
     FTPos[I] := (Source as TTGLFile3DSPositionAnimationKeys).FTPos[I];
 end;
 
-procedure TTGLFile3DSPositionAnimationKeys.WriteToFiler(Writer: TGVirtualWriter);
+procedure TTGLFile3DSPositionAnimationKeys.WriteToFiler(Writer: TGLVirtualWriter);
 begin
   inherited;
 
@@ -799,7 +799,7 @@ begin
     Writer.Write(FTPos[0], FNumKeys * SizeOf(TPoint3DS));
 end;
 
-procedure TTGLFile3DSPositionAnimationKeys.ReadFromFiler(Reader: TGVirtualReader);
+procedure TTGLFile3DSPositionAnimationKeys.ReadFromFiler(Reader: TGLVirtualReader);
 begin
   inherited;
 
@@ -837,7 +837,7 @@ begin
     FFall[I] := (Source as TGLFile3DSSpotLightCutOffAnimationKeys).FFall[I];
 end;
 
-procedure TGLFile3DSSpotLightCutOffAnimationKeys.WriteToFiler(Writer: TGVirtualWriter);
+procedure TGLFile3DSSpotLightCutOffAnimationKeys.WriteToFiler(Writer: TGLVirtualWriter);
 begin
   inherited;
 
@@ -845,7 +845,7 @@ begin
     Writer.Write(FFall[0], FNumKeys * SizeOf(Single));
 end;
 
-procedure TGLFile3DSSpotLightCutOffAnimationKeys.ReadFromFiler(Reader: TGVirtualReader);
+procedure TGLFile3DSSpotLightCutOffAnimationKeys.ReadFromFiler(Reader: TGLVirtualReader);
 begin
   inherited;
 
@@ -883,7 +883,7 @@ begin
     FHot[I] := (Source as TGLFile3DSLightHotSpotAnimationKeys).FHot[I];
 end;
 
-procedure TGLFile3DSLightHotSpotAnimationKeys.WriteToFiler(Writer: TGVirtualWriter);
+procedure TGLFile3DSLightHotSpotAnimationKeys.WriteToFiler(Writer: TGLVirtualWriter);
 begin
   inherited;
 
@@ -891,7 +891,7 @@ begin
     Writer.Write(FHot[0], FNumKeys * SizeOf(Single));
 end;
 
-procedure TGLFile3DSLightHotSpotAnimationKeys.ReadFromFiler(Reader: TGVirtualReader);
+procedure TGLFile3DSLightHotSpotAnimationKeys.ReadFromFiler(Reader: TGLVirtualReader);
 begin
   inherited;
 
@@ -928,7 +928,7 @@ begin
     FRoll[I] := (Source as TGLFile3DSRollAnimationKeys).FRoll[I];
 end;
 
-procedure TGLFile3DSRollAnimationKeys.WriteToFiler(Writer: TGVirtualWriter);
+procedure TGLFile3DSRollAnimationKeys.WriteToFiler(Writer: TGLVirtualWriter);
 begin
   inherited;
 
@@ -936,7 +936,7 @@ begin
     Writer.Write(FRoll[0], FNumKeys * SizeOf(Single));
 end;
 
-procedure TGLFile3DSRollAnimationKeys.ReadFromFiler(Reader: TGVirtualReader);
+procedure TGLFile3DSRollAnimationKeys.ReadFromFiler(Reader: TGLVirtualReader);
 begin
   inherited;
 
@@ -992,7 +992,7 @@ begin
     inherited Assign(Source);
 end;
 
-procedure TGLFile3DSAnimationKeyList.WriteToFiler(Writer: TGVirtualWriter);
+procedure TGLFile3DSAnimationKeyList.WriteToFiler(Writer: TGLVirtualWriter);
 var
   I: Integer;
   Val: TGLFile3DSAnimKeysClassType;
@@ -1006,7 +1006,7 @@ begin
   end;
 end;
 
-procedure TGLFile3DSAnimationKeyList.ReadFromFiler(Reader: TGVirtualReader);
+procedure TGLFile3DSAnimationKeyList.ReadFromFiler(Reader: TGLVirtualReader);
 var
   I, cnt: Integer;
   Val: TGLFile3DSAnimKeysClassType;
@@ -1117,7 +1117,7 @@ begin
   end;
 end;
 
-procedure TGLFile3DSDummyObject.WriteToFiler(Writer: TGVirtualWriter);
+procedure TGLFile3DSDummyObject.WriteToFiler(Writer: TGLVirtualWriter);
 var
   str: string;
 begin
@@ -1132,7 +1132,7 @@ begin
   FAnimList.WriteToFiler(Writer);
 end;
 
-procedure TGLFile3DSDummyObject.ReadFromFiler(Reader: TGVirtualReader);
+procedure TGLFile3DSDummyObject.ReadFromFiler(Reader: TGLVirtualReader);
 begin
   inherited;
 
@@ -1297,7 +1297,7 @@ begin
     FLightSrc.Assign((Source as TGLFile3DSOmniLightObject).FLightSrc);
 end;
 
-procedure TGLFile3DSOmniLightObject.WriteToFiler(Writer: TGVirtualWriter);
+procedure TGLFile3DSOmniLightObject.WriteToFiler(Writer: TGLVirtualWriter);
 var
   str: string;
 begin
@@ -1310,7 +1310,7 @@ begin
   Writer.WriteString(str);
 end;
 
-procedure TGLFile3DSOmniLightObject.ReadFromFiler(Reader: TGVirtualReader);
+procedure TGLFile3DSOmniLightObject.ReadFromFiler(Reader: TGLVirtualReader);
 begin
   inherited;
 
@@ -1449,7 +1449,7 @@ begin
   FTargetObj.Position.SetPoint(FAnimTransf.TargetPos);
 end;
 
-procedure TGLFile3DSCameraObject.WriteToFiler(Writer: TGVirtualWriter);
+procedure TGLFile3DSCameraObject.WriteToFiler(Writer: TGLVirtualWriter);
 var
   str: string;
 begin
@@ -1462,7 +1462,7 @@ begin
   Writer.WriteString(str);
 end;
 
-procedure TGLFile3DSCameraObject.ReadFromFiler(Reader: TGVirtualReader);
+procedure TGLFile3DSCameraObject.ReadFromFiler(Reader: TGLVirtualReader);
 begin
   inherited;
 

Source/GLS.File3DSSceneObjects.pas

@@ -328,18 +328,18 @@ end;
 
 procedure TGLFile3DSActor.ReadMesh(Stream: TStream);
 var
-  virt: TGBinaryReader;
+  virt: TGLBinaryReader;
 begin
-  virt := TGBinaryReader.Create(Stream);
+  virt := TGLBinaryReader.Create(Stream);
   MeshOBjects.ReadFromFiler(virt);
   virt.Free;
 end;
 
 procedure TGLFile3DSActor.WriteMesh(Stream: TStream);
 var
-  virt: TGBinaryWriter;
+  virt: TGLBinaryWriter;
 begin
-  virt := TGBinaryWriter.Create(Stream);
+  virt := TGLBinaryWriter.Create(Stream);
   MeshOBjects.WriteToFiler(virt);
   virt.Free;
 end;
@@ -375,9 +375,9 @@ end;
 procedure TGLFile3DSFreeForm.ReadMesh(Stream: TStream);
 var
   v: TGLVector;
-  virt: TGBinaryReader;
+  virt: TGLBinaryReader;
 begin
-  virt := TGBinaryReader.Create(Stream);
+  virt := TGLBinaryReader.Create(Stream);
 
   virt.read(FRefMat, sizeof(FRefMat));
   virt.read(v, sizeof(v));
@@ -393,10 +393,10 @@ end;
 
 procedure TGLFile3DSFreeForm.WriteMesh(Stream: TStream);
 var
-  virt: TGBinaryWriter;
+  virt: TGLBinaryWriter;
   v: TGLVector;
 begin
-  virt := TGBinaryWriter.Create(Stream);
+  virt := TGLBinaryWriter.Create(Stream);
 
   virt.write(FRefMat, sizeof(FRefMat));
   v := S_Rot3DS.AsVector;

Source/GLS.FileASE.pas

@@ -802,14 +802,14 @@ var
   norm, tex, light: Boolean;
   lmt: array [0..2] of TAffineVector;
   subID: Integer;
-  vi: TgIntegerList;
+  vi: TGLIntegerList;
 begin
   norm := aASEMesh.HasNormals;
   tex := aASEMesh.TextChannelsCount > 0;
   light := tex and (aASEMesh.TextChannelsCount > 1);
   subID := -1;
 
-  vi := TgIntegerList.Create;
+  vi := TGLIntegerList.Create;
   if tex or norm then begin
     // here used NOT optimized storage
 

Source/GLS.FileGL2.pas

@@ -179,7 +179,7 @@ var
   quat: TQuaternion;
   pos: TAffineVector;
   basepose: TGLSkeletonFrame;
-  bonelist: TgIntegerList;
+  bonelist: TGLIntegerList;
   bone: TGLSkeletonBone;
 
 begin
@@ -191,7 +191,7 @@ begin
 
     TGLActor(Owner).Reference := aarSkeleton;
 
-    bonelist := TgIntegerList.Create;
+    bonelist := TGLIntegerList.Create;
     for i := 0 to GLAFile.AnimHeader.numBones - 1 do
       bonelist.Add(i);
     while bonelist.Count > 0 do

Source/GLS.FileLMTS.pas

@@ -131,7 +131,7 @@ var
   _4cc: Cardinal;
   C: Integer;
   fName: string;
-  vi: TgIntegerList;
+  vi: TGLIntegerList;
   libmat: TGLLibmaterial;
   lmnames, matnames: TStringlist;
   MatInfoHeader: array [0 .. 3] of AnsiChar;
@@ -144,7 +144,7 @@ begin
   MO := TGLMeshObject.CreateOwned(owner.MeshObjects);
   MO.Mode := momFaceGroups;
 
-  vi := TgIntegerList.create;
+  vi := TGLIntegerList.create;
 
   LL := owner.LightmapLibrary;
   ML := owner.MaterialLibrary;

Source/GLS.FileMD5.pas

@@ -29,8 +29,8 @@ type
     FCurrentPos: Integer;
     FBasePose: TGLSkeletonFrame;
     FFramePositions: TGLAffineVectorList;
-    FFrameQuaternions: TGQuaternionList;
-    FJointFlags: TgIntegerList;
+    FFrameQuaternions: TGLQuaternionList;
+    FJointFlags: TGLIntegerList;
     FNumFrames, FFirstFrame, FFrameRate, FNumJoints: Integer;
     function ReadLine: String;
   public
@@ -202,17 +202,17 @@ procedure TGLMD5VectorFile.LoadFromStream(aStream: TStream);
     mesh: TGLSkeletonMeshObject;
     fg: TFGVertexIndexList;
     vnum, wnum, numverts, numweights: Integer;
-    VertexWeightID, VertexWeightCount, VertexBoneRef: TgIntegerList;
-    VertexWeight: TGSingleList;
+    VertexWeightID, VertexWeightCount, VertexBoneRef: TGLIntegerList;
+    VertexWeight: TGLSingleList;
     VertexWeighted: TGLAffineVectorList;
     blendedVert, transformedVert: TAffineVector;
     i, j, k: Integer;
     mat: TGLMatrix;
   begin
-    VertexWeightID := TgIntegerList.Create;
-    VertexWeightCount := TgIntegerList.Create;
-    VertexBoneRef := TgIntegerList.Create;
-    VertexWeight := TGSingleList.Create;
+    VertexWeightID := TGLIntegerList.Create;
+    VertexWeightCount := TGLIntegerList.Create;
+    VertexBoneRef := TGLIntegerList.Create;
+    VertexWeight := TGLSingleList.Create;
     VertexWeighted := TGLAffineVectorList.Create;
 
     numverts := 0;
@@ -332,7 +332,7 @@ procedure TGLMD5VectorFile.LoadFromStream(aStream: TStream);
   begin
     if not Assigned(FJointFlags) then
     begin
-      FJointFlags := TgIntegerList.Create;
+      FJointFlags := TGLIntegerList.Create;
       Assert(Owner.Skeleton.Frames.Count > 0,
         'The md5mesh file must be loaded before md5anim files!');
       FJointFlags.Count := Owner.Skeleton.Frames[0].Position.Count;
@@ -479,7 +479,7 @@ begin
         begin
           FNumJoints := StrToInt(FTempString[1]);
           FFramePositions := TGLAffineVectorList.Create;
-          FFrameQuaternions := TGQuaternionList.Create;
+          FFrameQuaternions := TGLQuaternionList.Create;
           if Owner.Skeleton.Frames.Count = 0 then
           begin
             FBasePose := TGLSkeletonFrame.CreateOwned(Owner.Skeleton.Frames);

Source/GLS.FileMS3D.pas

@@ -122,10 +122,10 @@ type
   // *) ms3d_material_t;
   TMS3DMaterial = record
     Name: array[0..31] of AnsiChar;
-    Ambient: TGColorVector;
-    Diffuse: TGColorVector;
-    Specular: TGColorVector;
-    Emissive: TGColorVector;
+    Ambient: TGLColorVector;
+    Diffuse: TGLColorVector;
+    Specular: TGLColorVector;
+    Emissive: TGLColorVector;
     Shininess: single;
     Transparency: single;
     Mode: AnsiChar;

Source/GLS.FileNurbs.pas

@@ -53,7 +53,7 @@ procedure TGLNurbsVectorFile.LoadFromStream(stream: TStream);
   end;
 
   function ReadSingleArray(sl: TStrings; idx: Integer;
-    list: TGSingleList): Integer;
+    list: TGLSingleList): Integer;
   var
     k: Integer;
     buf: String;

Source/GLS.FileOBJ.pas

@@ -154,7 +154,7 @@ type
   private
     FMode: TOBJFGMode;
     FName: string;
-    FPolygonVertices: TgIntegerList;
+    FPolygonVertices: TGLIntegerList;
     FCurrentVertexCount: integer;
     FShowNormals: boolean;
     procedure PolygonComplete; (* Current polygon completed. Adds FCurrentVertexCount
@@ -164,8 +164,8 @@ type
     procedure Assign(Source: TPersistent); override;
     constructor CreateOwned(aOwner: TglFaceGroups); override;
     destructor Destroy; override;
-    procedure WriteToFiler(writer: TGVirtualWriter); override;
-    procedure ReadFromFiler(reader: TGVirtualReader); override;
+    procedure WriteToFiler(writer: TGLVirtualWriter); override;
+    procedure ReadFromFiler(reader: TGLVirtualReader); override;
     procedure Add(VertexIdx, NormalIdx, TexCoordIdx: Integer);
     procedure BuildList(var mrci: TGLRenderContextInfo); override;
     procedure AddToTriangles(aList: TGLAffineVectorList;
@@ -174,7 +174,7 @@ type
     function TriangleCount: Integer; override;
     property Mode: TOBJFGMode read FMode write SetMode;
     property Name: string read FName write FName;
-    property PolygonVertices: TgIntegerList read FPolygonVertices;
+    property PolygonVertices: TGLIntegerList read FPolygonVertices;
     property ShowNormals: boolean read FShowNormals write FShowNormals;
   end;
 
@@ -211,7 +211,7 @@ begin
   Assert(VertexIndices.Count = 0, 'Decide on the mode before adding vertices.');
   FMode := aMode;
   if FMode = objfgmmPolygons then
-    FPolygonVertices := TgIntegerList.Create
+    FPolygonVertices := TGLIntegerList.Create
   else
   begin
     FPolygonVertices.Free;
@@ -1388,7 +1388,7 @@ begin
     else
     begin
       if FPolygonVertices = nil then
-        FPolygonVertices := TgIntegerList.Create;
+        FPolygonVertices := TGLIntegerList.Create;
       FPolygonVertices.Assign(TOBJFGVertexNormalTexIndexList(Source).FPolygonVertices);
     end;
   end
@@ -1397,7 +1397,7 @@ begin
 end;
 
 procedure TOBJFGVertexNormalTexIndexList.ReadFromFiler(
-  reader: TGVirtualReader);
+  reader: TGLVirtualReader);
 var
   archiveVersion: Integer;
 begin
@@ -1412,7 +1412,7 @@ begin
 
     if FMode = objfgmmPolygons then
     begin
-      FPolygonVertices := TgIntegerList.Create;
+      FPolygonVertices := TGLIntegerList.Create;
       FPolygonVertices.ReadFromFiler(reader);
     end;  
   end
@@ -1421,7 +1421,7 @@ begin
 end;
 
 procedure TOBJFGVertexNormalTexIndexList.WriteToFiler(
-  writer: TGVirtualWriter);
+  writer: TGLVirtualWriter);
 begin
   inherited WriteToFiler(writer);
   with writer do

Source/GLS.FileVRML.pas

@@ -36,7 +36,7 @@ implementation
 // ------------------------------------------------------------------
 
 procedure TessellatePolygon(PolyVerts: TGLAffineVectorList;
-  PolyIndices, TriIndices: TgIntegerList);
+  PolyIndices, TriIndices: TGLIntegerList);
 
   function IsPolyClockWise: Boolean;
   var
@@ -79,10 +79,10 @@ var
   i, j, prev, next, min_vert, min_prev, min_next: Integer;
   PolyCW, NoPointsInTriangle: Boolean;
   V: TAffineMatrix;
-  temp: TgIntegerList;
+  temp: TGLIntegerList;
   min_dist, d, area: Single;
 begin
-  temp := TgIntegerList.Create;
+  temp := TGLIntegerList.Create;
   try
     PolyCW := IsPolyClockWise;
     temp.Assign(PolyIndices);
@@ -242,11 +242,11 @@ var
     fg: TFGVertexNormalTexIndexList;
     vertices, normals, texcoords, triNormals, newVertices, newNormals,
       newTexCoords: TGLAffineVectorList;
-    optimized: TgIntegerList;
+    optimized: TGLIntegerList;
     cosAngle: Single;
     normal: TAffineVector;
     s, t: array [0 .. 2] of Integer;
-    n: array [0 .. 2] of TgIntegerList;
+    n: array [0 .. 2] of TGLIntegerList;
     smooth, hasVertices, hasNormals, hasNormalIndices, hasTexCoords,
       hasTexCoordIndices: Boolean;
   begin
@@ -267,9 +267,9 @@ var
     newNormals := TGLAffineVectorList.Create;
     newTexCoords := TGLAffineVectorList.Create;
     triNormals := TGLAffineVectorList.Create;
-    n[0] := TgIntegerList.Create;
-    n[1] := TgIntegerList.Create;
-    n[2] := TgIntegerList.Create;
+    n[0] := TGLIntegerList.Create;
+    n[1] := TGLIntegerList.Create;
+    n[2] := TGLIntegerList.Create;
     for i := 0 to mesh.FaceGroups.Count - 1 do
     begin
       fg := TFGVertexNormalTexIndexList(mesh.FaceGroups[i]);
@@ -438,10 +438,10 @@ var
   procedure RecursNodes(node: TVRMLNode);
   var
     i, j, n: Integer;
-    points: TGSingleList;
-    indices, fgindices: TgIntegerList;
+    points: TGLSingleList;
+    indices, fgindices: TGLIntegerList;
     fg: TFGVertexNormalTexIndexList;
-    face: TgIntegerList;
+    face: TGLIntegerList;
     tempLibMat: TGLLibMaterial;
     saveTransform, mat: TGLMatrix;
     saveMaterial: TGLLibMaterial;
@@ -522,7 +522,7 @@ var
     begin
       fg := TFGVertexNormalTexIndexList.CreateOwned(mesh.FaceGroups);
       mesh.Mode := momFaceGroups;
-      face := TgIntegerList.Create;
+      face := TGLIntegerList.Create;
       if Assigned(currentMaterial) then
         fg.MaterialName := currentMaterial.Name;
       for n := 0 to node.Count - 1 do

Source/GLS.FireFX.pas

@@ -58,7 +58,7 @@ type
     FParticleSize, FFireDensity, FFireEvaporation: Single;
     FFireCrown, FParticleInterval, IntervalDelta: Single;
     NP: Integer;
-    FInnerColor, FOuterColor: TGColor;
+    FInnerColor, FOuterColor: TGLColor;
     FFireBurst, FFireRadius: Single;
     FDisabled, FPaused, FUseInterval: Boolean;
     FReference: TGLBaseSceneObject;
@@ -71,14 +71,14 @@ type
     procedure SetInitialDir(const val: TGLCoordinates);
     procedure SetCadencer(const val: TGLCadencer);
     function StoreParticleSize: Boolean;
-    procedure SetInnerColor(const val: TGColor);
-    procedure SetOuterColor(const val: TGColor);
+    procedure SetInnerColor(const val: TGLColor);
+    procedure SetOuterColor(const val: TGLColor);
     procedure SetReference(const val: TGLBaseSceneObject);
     procedure SetMaxParticles(const val: Integer);
     procedure Notification(AComponent: TComponent; Operation: TOperation); override;
     procedure CalcFire(deltaTime: Double; ParticleInterval, ParticleLife: Single;
       FireAlpha: Single);
-    procedure AffParticle3d(Color2: TGColorVector; const mat: TGLMatrix);
+    procedure AffParticle3d(Color2: TGLColorVector; const mat: TGLMatrix);
   public
     constructor Create(AOwner: TComponent); override;
     destructor Destroy; override;
@@ -110,9 +110,9 @@ type
     // Size of the particle, in absolute units.
     property ParticleSize: Single read FParticleSize write FParticleSize stored StoreParticleSize;
     // Inner color of a particle.
-    property InnerColor: TGColor read FInnerColor write SetInnerColor;
+    property InnerColor: TGLColor read FInnerColor write SetInnerColor;
     // Outer color of a particle.
-    property OuterColor: TGColor read FOuterColor write SetOuterColor; // default clrWhite;
+    property OuterColor: TGLColor read FOuterColor write SetOuterColor; // default clrWhite;
     property FireDensity: Single read FFireDensity write FFireDensity;
     property FireEvaporation: Single read FFireEvaporation write FFireEvaporation;
     (* Adjust a crown (circular) radius on which particles are spawned.
@@ -214,9 +214,9 @@ begin
   FInitialDir := TGLCoordinates.CreateInitialized(Self, YHmgVector, csPoint);
   FMaxParticles := 256;
   FParticleSize := 1.0;
-  FInnerColor := TGColor.Create(Self);
+  FInnerColor := TGLColor.Create(Self);
   FInnerColor.Initialize(clrYellow);
-  FOuterColor := TGColor.Create(Self);
+  FOuterColor := TGLColor.Create(Self);
   FOuterColor.Initialize(clrOrange);
   FFireDensity := 1;
   FFireEvaporation := 0.86;
@@ -311,7 +311,7 @@ begin
 end;
 
 
-procedure TGLFireFXManager.SetInnerColor(const val: TGColor);
+procedure TGLFireFXManager.SetInnerColor(const val: TGLColor);
 begin
   if FInnerColor <> val then
   begin
@@ -321,7 +321,7 @@ begin
 end;
 
 
-procedure TGLFireFXManager.SetOuterColor(const val: TGColor);
+procedure TGLFireFXManager.SetOuterColor(const val: TGLColor);
 begin
   if FOuterColor <> val then
   begin
@@ -524,7 +524,7 @@ begin
   end;
 end;
 
-procedure TGLFireFXManager.AffParticle3d(Color2: TGColorVector; const mat: TGLMatrix);
+procedure TGLFireFXManager.AffParticle3d(Color2: TGLColorVector; const mat: TGLMatrix);
 var
   vx, vy: TGLVector;
   i: Integer;
@@ -653,7 +653,7 @@ var
   i: Integer;
   innerColor: TGLVector;
   lastTr: TAffineVector;
-  distList: TGSingleList;
+  distList: TGLSingleList;
   objList: TList;
   fp: PGLFireParticle;
 begin
@@ -680,7 +680,7 @@ begin
 
   if n > 1 then
   begin
-    distList := TGSingleList.Create;
+    distList := TGLSingleList.Create;
     objList := TList.Create;
     for i := 0 to n - 1 do
     begin

Source/GLS.GameMenu.pas

@@ -37,8 +37,8 @@ type
     FFont: TGLCustomBitmapFont;
     FMarginVert, FMarginHorz, FSpacing: Integer;
     FMenuScale: TGLGameMenuScale;
-    FBackColor: TGColor;
-    FInactiveColor, FActiveColor, FDisabledColor: TGColor;
+    FBackColor: TGLColor;
+    FInactiveColor, FActiveColor, FDisabledColor: TGLColor;
     FMaterialLibrary: TGLMaterialLibrary;
     FTitleMaterialName: TGLLibMaterialName;
     FTitleWidth, FTitleHeight: Integer;
@@ -53,10 +53,10 @@ type
     procedure SetMarginVert(AValue: Integer);
     procedure SetSpacing(AValue: Integer);
     procedure SetFont(AValue: TGLCustomBitmapFont);
-    procedure SetBackColor(AValue: TGColor);
-    procedure SetInactiveColor(AValue: TGColor);
-    procedure SetActiveColor(AValue: TGColor);
-    procedure SetDisabledColor(AValue: TGColor);
+    procedure SetBackColor(AValue: TGLColor);
+    procedure SetInactiveColor(AValue: TGLColor);
+    procedure SetActiveColor(AValue: TGLColor);
+    procedure SetDisabledColor(AValue: TGLColor);
     function GetEnabled(AIndex: Integer): Boolean;
     procedure SetEnabled(AIndex: Integer; AValue: Boolean);
     procedure SetItems(AValue: TStrings);
@@ -87,10 +87,10 @@ type
     property TitleMaterialName: string read FTitleMaterialName write SetTitleMaterialName;
     property TitleWidth: Integer read FTitleWidth write SetTitleWidth default 0;
     property TitleHeight: Integer read FTitleHeight write SetTitleHeight default 0;
-    property BackColor: TGColor read FBackColor write SetBackColor;
-    property InactiveColor: TGColor read FInactiveColor write SetInactiveColor;
-    property ActiveColor: TGColor read FActiveColor write SetActiveColor;
-    property DisabledColor: TGColor read FDisabledColor write SetDisabledColor;
+    property BackColor: TGLColor read FBackColor write SetBackColor;
+    property InactiveColor: TGLColor read FInactiveColor write SetInactiveColor;
+    property ActiveColor: TGLColor read FActiveColor write SetActiveColor;
+    property DisabledColor: TGLColor read FDisabledColor write SetDisabledColor;
     property Items: TStrings read FItems write SetItems;
     property Selected: Integer read FSelected write SetSelected default -1;
     property OnSelectedChanged: TNotifyEvent read FOnSelectedChanged write FOnSelectedChanged;
@@ -130,10 +130,10 @@ begin
   FMarginVert := 16;
   FSpacing := 16;
   FMenuScale := gmsNormal;
-  FBackColor := TGColor.CreateInitialized(Self, clrTransparent, NotifyChange);
-  FInactiveColor := TGColor.CreateInitialized(Self, clrGray75, NotifyChange);
-  FActiveColor := TGColor.CreateInitialized(Self, clrWhite, NotifyChange);
-  FDisabledColor := TGColor.CreateInitialized(Self, clrGray60, NotifyChange);
+  FBackColor := TGLColor.CreateInitialized(Self, clrTransparent, NotifyChange);
+  FInactiveColor := TGLColor.CreateInitialized(Self, clrGray75, NotifyChange);
+  FActiveColor := TGLColor.CreateInitialized(Self, clrWhite, NotifyChange);
+  FDisabledColor := TGLColor.CreateInitialized(Self, clrGray60, NotifyChange);
 end;
 
 destructor TGLGameMenu.Destroy;
@@ -164,7 +164,7 @@ var
   canvas: TGLCanvas;
   buffer: TGLSceneBuffer;
   i, w, h, tw, Y: Integer;
-  color: TGColorVector;
+  color: TGLColorVector;
   libMat: TGLLibMaterial;
 begin
   if Font = nil then
@@ -327,22 +327,22 @@ begin
     FFont.FreeNotification(Self);
 end;
 
-procedure TGLGameMenu.SetBackColor(AValue: TGColor);
+procedure TGLGameMenu.SetBackColor(AValue: TGLColor);
 begin
   FBackColor.Assign(AValue);
 end;
 
-procedure TGLGameMenu.SetInactiveColor(AValue: TGColor);
+procedure TGLGameMenu.SetInactiveColor(AValue: TGLColor);
 begin
   FInactiveColor.Assign(AValue);
 end;
 
-procedure TGLGameMenu.SetActiveColor(AValue: TGColor);
+procedure TGLGameMenu.SetActiveColor(AValue: TGLColor);
 begin
   FActiveColor.Assign(AValue);
 end;
 
-procedure TGLGameMenu.SetDisabledColor(AValue: TGColor);
+procedure TGLGameMenu.SetDisabledColor(AValue: TGLColor);
 begin
   FDisabledColor.Assign(AValue);
 end;

Source/GLS.Gizmo.pas

@@ -158,9 +158,9 @@ type
     // FLastOperation,
     FOperation: TGLGizmoOperation;
     FSelAxis: TGLGizmoAxis;
-    FBoundingBoxColor: TGColor;
-    FSelectedColor: TGColor;
-    FVisibleInfoLabelsColor: TGColor;
+    FBoundingBoxColor: TGLColor;
+    FSelectedColor: TGLColor;
+    FVisibleInfoLabelsColor: TGLColor;
     FBoundingBoxColorChanged: Boolean;
     FVisibleInfoLabelsColorChanged: Boolean;
     FForceOperation: Boolean;
@@ -197,9 +197,9 @@ type
     procedure SetRootGizmo(const AValue: TGLBaseSceneObject);
     procedure SetGizmoElements(const AValue: TGLGizmoElements);
     procedure SeTGLGizmoVisibleInfoLabels(const AValue: TGLGizmoVisibleInfoLabels);
-    procedure SetBoundingBoxColor(const AValue: TGColor);
-    procedure SetSelectedColor(const AValue: TGColor);
-    procedure SetVisibleInfoLabelsColor(const AValue: TGColor);
+    procedure SetBoundingBoxColor(const AValue: TGLColor);
+    procedure SetSelectedColor(const AValue: TGLColor);
+    procedure SetVisibleInfoLabelsColor(const AValue: TGLColor);
     procedure SetExcludeObjectsList(const AValue: TStrings);
     procedure DirectGlDisable(Sender: TObject; var Rci: TGLRenderContextInfo);
     procedure DirectGlEnable(Sender: TObject; var Rci: TGLRenderContextInfo);
@@ -235,9 +235,9 @@ type
     property Viewer: TGLSceneViewer read FViewer write SetViewer;
     property GizmoElements: TGLGizmoElements read FGizmoElements
       write SetGizmoElements;
-    property BoundingBoxColor: TGColor read FBoundingBoxColor
+    property BoundingBoxColor: TGLColor read FBoundingBoxColor
       write SetBoundingBoxColor;
-    property SelectedColor: TGColor read FSelectedColor write SetSelectedColor;
+    property SelectedColor: TGLColor read FSelectedColor write SetSelectedColor;
     property SelAxis: TGLGizmoAxis read FSelAxis write FSelAxis;
     property ForceAxis: Boolean read FForceAxis write FForceAxis;
     property SelectedObj: TGLBaseSceneObject read FSelectedObj
@@ -251,7 +251,7 @@ type
       write SetExcludeObjectsList;
     property VisibleInfoLabels: TGLGizmoVisibleInfoLabels
       read FVisibleVisibleInfoLabels write SeTGLGizmoVisibleInfoLabels;
-    property VisibleInfoLabelsColor: TGColor read FVisibleInfoLabelsColor
+    property VisibleInfoLabelsColor: TGLColor read FVisibleInfoLabelsColor
       write SetVisibleInfoLabelsColor;
     property AutoZoom: Boolean read FAutoZoom write FAutoZoom;
     property AutoZoomFactor: Single read FAutoZoomFactor write FAutoZoomFactor;
@@ -335,12 +335,12 @@ begin
   FGizmoThickness := 1;
 
   FInternalRaycastHitData := TList.Create;
-  FBoundingBoxColor := TGColor.Create(Self);
+  FBoundingBoxColor := TGLColor.Create(Self);
   FBoundingBoxColor.Color := ClrWhite;
   FBoundingBoxColorChanged := False;
-  FSelectedColor := TGColor.Create(Self);
+  FSelectedColor := TGLColor.Create(Self);
   FSelectedColor.Color := ClrYellow;
-  FVisibleInfoLabelsColor := TGColor.Create(Self);
+  FVisibleInfoLabelsColor := TGLColor.Create(Self);
   FVisibleInfoLabelsColor.Color := ClrYellow;
   FVisibleInfoLabelsColorChanged := False;
 
@@ -743,7 +743,7 @@ begin
   end;
 end;
 
-procedure TGLGizmo.SetBoundingBoxColor(const AValue: TGColor);
+procedure TGLGizmo.SetBoundingBoxColor(const AValue: TGLColor);
 begin
   // Bug Here New Color is not Updated
   if AValue <> FBoundingBoxColor then
@@ -768,7 +768,7 @@ begin
   end;
 end;
 
-procedure TGLGizmo.SetSelectedColor(const AValue: TGColor);
+procedure TGLGizmo.SetSelectedColor(const AValue: TGLColor);
 begin
   if AValue <> FSelectedColor then
   begin
@@ -776,7 +776,7 @@ begin
   end;
 end;
 
-procedure TGLGizmo.SetVisibleInfoLabelsColor(const AValue: TGColor);
+procedure TGLGizmo.SetVisibleInfoLabelsColor(const AValue: TGLColor);
 begin
   // Bug Here New Color is not Updated
   if AValue <> FSelectedColor then

Source/GLS.GizmoEx.pas

@@ -263,10 +263,10 @@ type
     fInfoLabelCoordType: TInfoLabelCoordType;
     FReferenceCoordSystem: TGLGizmoExReferenceCoordinateSystem;
 
-    FBoundingBoxColor: TGColor;
-    FSelectedColor: TGColor;
-    FVisibleInfoLabelsColor: TGColor;
-    FSelectionRegionColor: TGColor;
+    FBoundingBoxColor: TGLColor;
+    FSelectedColor: TGLColor;
+    FVisibleInfoLabelsColor: TGLColor;
+    FSelectionRegionColor: TGLColor;
 
     FVisibleInfoLabelsColorChanged: Boolean;
 
@@ -326,10 +326,10 @@ type
     procedure SetRootObjects(const AValue: TGLBaseSceneObject);
     procedure SetGizmoTmpRoot(const AValue: TGLBaseSceneObject);
     procedure SeTGLGizmoExVisibleInfoLabels(const AValue: TGLGizmoExVisibleInfoLabels);
-    procedure SetBoundingBoxColor(const AValue: TGColor);
-    procedure SetSelectedColor(const AValue: TGColor);
-    procedure SetVisibleInfoLabelsColor(const AValue: TGColor);
-    procedure SetSelectionRegionColor(const AValue: TGColor);
+    procedure SetBoundingBoxColor(const AValue: TGLColor);
+    procedure SetSelectedColor(const AValue: TGLColor);
+    procedure SetVisibleInfoLabelsColor(const AValue: TGLColor);
+    procedure SetSelectionRegionColor(const AValue: TGLColor);
     procedure SetCanChangeWithChildren(AValue: Boolean);
     procedure SetAALines(aValue: Boolean);
     procedure SetInfoLabelCoordType(aValue: TInfoLabelCoordType);
@@ -401,9 +401,9 @@ type
     //--------------------------------------------------------------------
   published
     property Viewer: TGLSceneViewer read FViewer write SetViewer;
-    property BoundingBoxColor: TGColor read FBoundingBoxColor write SetBoundingBoxColor;
-    property SelectedColor: TGColor read FSelectedColor write SetSelectedColor;
-    property SelectionRegionColor: TGColor read FSelectionRegionColor write SetSelectionRegionColor;
+    property BoundingBoxColor: TGLColor read FBoundingBoxColor write SetBoundingBoxColor;
+    property SelectedColor: TGLColor read FSelectedColor write SetSelectedColor;
+    property SelectionRegionColor: TGLColor read FSelectionRegionColor write SetSelectionRegionColor;
     property SelectedObj: TGLBaseSceneObject read GetSelectedObj write SetSelectedObj;
     property SelectedObjects: TGLPickList read GetPickList write SetPickList;
     property OperationMode: TGLGizmoExOperationMode read FOperationMode write SetOperationMode default gomSelect;
@@ -412,7 +412,7 @@ type
     property ExcludeClassname: Boolean read FExcludeClassname write FExcludeClassname;
     property ExcludeClassnameList: TStrings read FExcludeClassnameList write SetExcludeClassnameList;
     property VisibleInfoLabels: TGLGizmoExVisibleInfoLabels read FVisibleVisibleInfoLabels write SeTGLGizmoExVisibleInfoLabels;
-    property VisibleInfoLabelsColor: TGColor read FVisibleInfoLabelsColor write SetVisibleInfoLabelsColor;
+    property VisibleInfoLabelsColor: TGLColor read FVisibleInfoLabelsColor write SetVisibleInfoLabelsColor;
     property AutoZoom: Boolean read FAutoZoom write FAutoZoom default True;
     property AutoZoomFactor: Single read FAutoZoomFactor write SetAutoZoomFactor;
     property ZoomFactor: Single read FZoomFactor write SetZoomFactor;
@@ -720,13 +720,13 @@ begin
   FMoveCoef := 0.1;
   FScaleCoef := 0.1;
 
-  FBoundingBoxColor := TGColor.Create(Self);
+  FBoundingBoxColor := TGLColor.Create(Self);
   FBoundingBoxColor.Color := clrWhite;
-  FSelectionRegionColor := TGColor.Create(Self);
+  FSelectionRegionColor := TGLColor.Create(Self);
   SelectionRegionColor.Color := clrBlack;
-  FSelectedColor := TGColor.Create(Self);
+  FSelectedColor := TGLColor.Create(Self);
   FSelectedColor.Color := clrYellow;
-  FVisibleInfoLabelsColor := TGColor.Create(Self);
+  FVisibleInfoLabelsColor := TGLColor.Create(Self);
   FVisibleInfoLabelsColor.Color := clrYellow;
   FVisibleInfoLabelsColorChanged := False;
 
@@ -2365,7 +2365,7 @@ begin
 
 end;
 
-procedure TGLGizmoEx.SetBoundingBoxColor(const AValue: TGColor);
+procedure TGLGizmoEx.SetBoundingBoxColor(const AValue: TGLColor);
 begin
   if AValue <> FBoundingBoxColor then
   begin
@@ -2374,7 +2374,7 @@ begin
   end;
 end;
 
-procedure TGLGizmoEx.SetSelectedColor(const AValue: TGColor);
+procedure TGLGizmoEx.SetSelectedColor(const AValue: TGLColor);
 begin
   if AValue <> FSelectedColor then
   begin
@@ -2734,7 +2734,7 @@ begin
 end;
 
 
-procedure TGLGizmoEx.SetVisibleInfoLabelsColor(const AValue: TGColor);
+procedure TGLGizmoEx.SetVisibleInfoLabelsColor(const AValue: TGLColor);
 begin
   if AValue <> FSelectedColor then
   begin
@@ -2745,7 +2745,7 @@ begin
   end;
 end;
 
-procedure TGLGizmoEx.SetSelectionRegionColor(const AValue: TGColor);
+procedure TGLGizmoEx.SetSelectionRegionColor(const AValue: TGLColor);
 begin
   if AValue <> FSelectionRegionColor then
   begin

Source/GLS.Graph.pas

@@ -66,9 +66,9 @@ type
   end;
 
   TGLHeightFieldGetHeightEvent = procedure(const x, y: Single; var z: Single;
-    var Color: TGColorVector; var TexPoint: TTexPoint) of object;
+    var Color: TGLColorVector; var TexPoint: TTexPoint) of object;
   TGLHeightFieldGetHeight2Event = procedure(Sender: TObject; const x, y: Single;
-    var z: Single; var Color: TGColorVector; var TexPoint: TTexPoint) of object;
+    var z: Single; var Color: TGLColorVector; var TexPoint: TTexPoint) of object;
 
   TGLHeightFieldOption = (hfoTextureCoordinates, hfoTwoSided);
   TGLHeightFieldOptions = set of TGLHeightFieldOption;
@@ -99,9 +99,9 @@ type
     procedure SetOnGetHeight2(const val: TGLHeightFieldGetHeight2Event);
     procedure SetColorMode(const val: TGLHeightFieldColorMode);
     procedure DefaultHeightField(const x, y: Single; var z: Single;
-      var Color: TGColorVector; var TexPoint: TTexPoint);
+      var Color: TGLColorVector; var TexPoint: TTexPoint);
     procedure Height2Field(const x, y: Single; var z: Single;
-      var Color: TGColorVector; var texPoint: TTexPoint);
+      var Color: TGLColorVector; var texPoint: TTexPoint);
   public
     constructor Create(AOwner: TComponent); override;
     destructor Destroy; override;
@@ -322,7 +322,7 @@ end;
 procedure TGLHeightField.BuildList(var rci: TGLRenderContextInfo);
 type
   TRowData = packed record
-    Color: TGColorVector;
+    Color: TGLColorVector;
     Z: Single;
     TexPoint: TTexPoint;
     Normal: TAffineVector;
@@ -537,7 +537,7 @@ begin
 end;
 
 procedure TGLHeightField.DefaultHeightField(const x, y: Single; var z: Single;
-  var color: TGColorVector; var texPoint: TTexPoint);
+  var color: TGLColorVector; var texPoint: TTexPoint);
 begin
   z := VectorNorm(x, y);
   z := cos(z * 12) / (2 * (z * 6.28 + 1));
@@ -545,7 +545,7 @@ begin
 end;
 
 procedure TGLHeightField.Height2Field(const x, y: Single; var z: Single;
-  var color: TGColorVector; var texPoint: TTexPoint);
+  var color: TGLColorVector; var texPoint: TTexPoint);
 begin
   FOnGetHeight2(Self, x, y, z, color, texPoint);
 end;

Source/GLS.Graphics.pas

@@ -321,7 +321,7 @@ type
   end;
 
   // Stores registered raster file formats.
-  TGLRasterFileFormatsList = class(TgPersistentObjectList)
+  TGLRasterFileFormatsList = class(TGLPersistentObjectList)
   public
     destructor Destroy; override;
     procedure Add(const Ext, Desc: string; DescID: Integer; AClass:

Source/GLS.Gui.pas

@@ -514,10 +514,10 @@ var
   TmpElement: TGLGuiElement;
   TmpAlignment: TGUIAlignments;
   Version: Integer;
-  Data: TGBinaryReader;
+  Data: TGLBinaryReader;
 
 begin
-  Data := TGBinaryReader.Create(Stream);
+  Data := TGLBinaryReader.Create(Stream);
   try
 
     Version := Data.ReadInteger;
@@ -560,10 +560,10 @@ var
   Alignments, xc, YC: Integer;
   TmpElement: TGLGuiElement;
   TmpAlignment: TGUIAlignments;
-  Data: TGBinaryWriter;
+  Data: TGLBinaryWriter;
 
 begin
-  Data := TGBinaryWriter.Create(Stream);
+  Data := TGLBinaryWriter.Create(Stream);
   try
     Data.WriteInteger(1);
     Data.WriteInteger(FGuiComponents.Count);

Source/GLS.HUDObjects.pas

@@ -81,14 +81,14 @@ type
     FRotation: Single;
     FAlignment: TAlignment;
     FLayout: TTextLayout;
-    FModulateColor: TGColor;
+    FModulateColor: TGLColor;
   protected
     procedure SetBitmapFont(const val: TGLCustomBitmapFont);
     procedure SetText(const val: UnicodeString);
     procedure SetRotation(const val: Single);
     procedure SetAlignment(const val: TAlignment);
     procedure SetLayout(const val: TTextLayout);
-    procedure SetModulateColor(const val: TGColor);
+    procedure SetModulateColor(const val: TGLColor);
     procedure Notification(AComponent: TComponent;
       Operation: TOperation); override;
     procedure RenderTextAtPosition(const X, Y, Z: Single;
@@ -122,7 +122,7 @@ type
       Possible values : tlTop, tlCenter, tlBottom *)
     property Layout: TTextLayout read FLayout write SetLayout default tlTop;
     // Color modulation, can be used for fade in/out too.
-    property ModulateColor: TGColor read FModulateColor write SetModulateColor;
+    property ModulateColor: TGLColor read FModulateColor write SetModulateColor;
   end;
 
   (* Position (X, Y and X) is in absolute coordinates. This component converts
@@ -295,7 +295,7 @@ constructor TGLHUDText.Create(AOwner: TComponent);
 begin
   inherited;
   ObjectStyle := ObjectStyle + [osDirectDraw, osNoVisibilityCulling];
-  FModulateColor := TGColor.CreateInitialized(Self, clrWhite);
+  FModulateColor := TGLColor.CreateInitialized(Self, clrWhite);
 end;
 
 
@@ -354,7 +354,7 @@ begin
   StructureChanged;
 end;
 
-procedure TGLHUDText.SetModulateColor(const val: TGColor);
+procedure TGLHUDText.SetModulateColor(const val: TGLColor);
 begin
   FModulateColor.Assign(val);
 end;

Source/GLS.Imposter.pas

@@ -113,9 +113,9 @@ type
   // Abstract ImposterBuilder class.
   TGLImposterBuilder = class(TGLUpdateAbleComponent)
   private
-    FBackColor: TGColor;
+    FBackColor: TGLColor;
     FBuildOffset: TGLCoordinates;
-    FImposterRegister: TgPersistentObjectList;
+    FImposterRegister: TGLPersistentObjectList;
     FRenderPoint: TGLRenderPoint;
     FImposterOptions: TImposterOptions;
     FAlphaTreshold: Single;
@@ -125,11 +125,11 @@ type
   protected
     procedure SetRenderPoint(AValue: TGLRenderPoint);
     procedure RenderPointFreed(Sender: TObject);
-    procedure SetBackColor(AValue: TGColor);
+    procedure SetBackColor(AValue: TGLColor);
     procedure SetBuildOffset(AValue: TGLCoordinates);
     procedure SetImposterReference(AValue: TImposterReference);
     procedure InitializeImpostorTexture(const TextureSize: TPoint);
-    property ImposterRegister: TgPersistentObjectList read FImposterRegister;
+    property ImposterRegister: TGLPersistentObjectList read FImposterRegister;
     procedure UnregisterImposter(imposter: TImposter);
     function CreateNewImposter: TImposter; virtual;
     procedure PrepareImposters(Sender: TObject; var rci: TGLRenderContextInfo);
@@ -163,7 +163,7 @@ type
     (* Background color for impostor rendering.
        Typically, you'll want to leave the alpha channel to zero, and pick
        as RGB as color that matches the impostor'ed objects edge colors most.*)
-    property BackColor: TGColor read FBackColor write SetBackColor;
+    property BackColor: TGLColor read FBackColor write SetBackColor;
     (* Offset applied to the impostor'ed object during imposter construction.
        Can be used to manually tune the centering of objects. *)
     property BuildOffset: TGLCoordinates read FBuildOffset write SetBuildOffset;
@@ -547,8 +547,8 @@ end;
 constructor TGLImposterBuilder.Create(AOwner: TComponent);
 begin
   inherited;
-  FImposterRegister := TgPersistentObjectList.Create;
-  FBackColor := TGColor.CreateInitialized(Self, clrTransparent);
+  FImposterRegister := TGLPersistentObjectList.Create;
+  FBackColor := TGLColor.CreateInitialized(Self, clrTransparent);
   FBuildOffset := TGLCoordinates.CreateInitialized(Self, NullHmgPoint, CsPoint);
   FImposterOptions := cDefaultImposterOptions;
   FAlphaTreshold := 0.5;
@@ -713,7 +713,7 @@ begin
   FRenderPoint := nil;
 end;
 
-procedure TGLImposterBuilder.SetBackColor(AValue: TGColor);
+procedure TGLImposterBuilder.SetBackColor(AValue: TGLColor);
 begin
   FBackColor.Assign(AValue);
 end;

Source/GLS.LensFlare.pas

@@ -45,20 +45,20 @@ type
      lens flare elements. *)
   TGLFlareGradient = class(TGLUpdateAbleObject)
   private
-    FFromColor: TGColor;
-    FToColor: TGColor;
+    FFromColor: TGLColor;
+    FToColor: TGLColor;
   protected
-    procedure SetFromColor(const val: TGColor);
-    procedure SetToColor(const val: TGColor);
+    procedure SetFromColor(const val: TGLColor);
+    procedure SetToColor(const val: TGLColor);
   public
     constructor Create(AOwner: TPersistent); override;
     constructor CreateInitialized(AOwner: TPersistent;
-      const fromColor, toColor: TGColorVector);
+      const fromColor, toColor: TGLColorVector);
     destructor Destroy; override;
     procedure Assign(Source: TPersistent); override;
   published
-    property FromColor: TGColor read FFromColor write SetFromColor;
-    property ToColor: TGColor read FToColor write SetToColor;
+    property FromColor: TGLColor read FFromColor write SetFromColor;
+    property ToColor: TGLColor read FToColor write SetToColor;
   end;
 
 const
@@ -203,12 +203,12 @@ implementation
 constructor TGLFlareGradient.Create(AOwner: TPersistent);
 begin
   inherited;
-  FFromColor := TGColor.Create(Self);
-  FToColor := TGColor.Create(Self);
+  FFromColor := TGLColor.Create(Self);
+  FToColor := TGLColor.Create(Self);
 end;
 
 constructor TGLFlareGradient.CreateInitialized(AOwner: TPersistent;
-  const fromColor, toColor: TGColorVector);
+  const fromColor, toColor: TGLColorVector);
 begin
   Create(AOwner);
   FFromColor.Initialize(fromColor);
@@ -232,12 +232,12 @@ begin
   inherited;
 end;
 
-procedure TGLFlareGradient.SetFromColor(const val: TGColor);
+procedure TGLFlareGradient.SetFromColor(const val: TGLColor);
 begin
   FFromColor.Assign(val);
 end;
 
-procedure TGLFlareGradient.SetToColor(const val: TGColor);
+procedure TGLFlareGradient.SetToColor(const val: TGLColor);
 begin
   FToColor.Assign(val);
 end;

Source/GLS.LinePFX.pas

@@ -33,8 +33,8 @@ type
     FLength: Single;
   protected
   public
-    procedure WriteToFiler(writer: TGVirtualWriter); override;
-    procedure ReadFromFiler(reader: TGVirtualReader); override;
+    procedure WriteToFiler(writer: TGLVirtualWriter); override;
+    procedure ReadFromFiler(reader: TGLVirtualReader); override;
     // Direction of the line.
     property Direction: TAffineVector read FDirection write FDirection;
     // Length of the line
@@ -134,7 +134,7 @@ procedure TGLLinePFXManager.RenderParticle(var rci: TGLRenderContextInfo;
   aParticle: TGLParticle);
 var
   lifeTime, sizeScale, fx, fy, f: Single;
-  inner, outer: TGColorVector;
+  inner, outer: TGLColorVector;
   pos, dir, start, stop, dv: TAffineVector;
 begin
   lifeTime := CurrentTime - aParticle.CreationTime;
@@ -193,7 +193,7 @@ end;
 // ------------------ TGLLineParticle ------------------
 // ------------------
 
-procedure TGLLineParticle.WriteToFiler(writer: TGVirtualWriter);
+procedure TGLLineParticle.WriteToFiler(writer: TGLVirtualWriter);
 begin
   inherited WriteToFiler(writer);
   with writer do
@@ -204,7 +204,7 @@ begin
   end;
 end;
 
-procedure TGLLineParticle.ReadFromFiler(reader: TGVirtualReader);
+procedure TGLLineParticle.ReadFromFiler(reader: TGLVirtualReader);
 var
   archiveVersion: Integer;
 begin

Source/GLS.Material.pas

@@ -173,13 +173,13 @@ type
      polygon mode (lines / fill). *)
   TGLFaceProperties = class(TGLUpdateAbleObject)
   private
-    FAmbient, FDiffuse, FSpecular, FEmission: TGColor;
+    FAmbient, FDiffuse, FSpecular, FEmission: TGLColor;
     FShininess: TGLShininess;
   protected
-    procedure SetAmbient(AValue: TGColor);
-    procedure SetDiffuse(AValue: TGColor);
-    procedure SetEmission(AValue: TGColor);
-    procedure SetSpecular(AValue: TGColor);
+    procedure SetAmbient(AValue: TGLColor);
+    procedure SetDiffuse(AValue: TGLColor);
+    procedure SetEmission(AValue: TGLColor);
+    procedure SetSpecular(AValue: TGLColor);
     procedure SetShininess(AValue: TGLShininess);
   public
     constructor Create(AOwner: TPersistent); override;
@@ -188,11 +188,11 @@ type
     procedure ApplyNoLighting(var rci: TGLRenderContextInfo; aFace: TGLCullFaceMode); inline;
     procedure Assign(Source: TPersistent); override;
   published
-    property Ambient: TGColor read FAmbient write SetAmbient;
-    property Diffuse: TGColor read FDiffuse write SetDiffuse;
-    property Emission: TGColor read FEmission write SetEmission;
+    property Ambient: TGLColor read FAmbient write SetAmbient;
+    property Diffuse: TGLColor read FDiffuse write SetDiffuse;
+    property Emission: TGLColor read FEmission write SetEmission;
     property Shininess: TGLShininess read FShininess write SetShininess default 0;
-    property Specular: TGColor read FSpecular write SetSpecular;
+    property Specular: TGLColor read FSpecular write SetSpecular;
   end;
 
   TGLDepthProperties = class(TGLUpdateAbleObject)
@@ -597,8 +597,8 @@ type
     constructor Create(AOwner: TComponent); override;
     destructor Destroy; override;
     procedure DestroyHandles;
-    procedure WriteToFiler(writer: TGVirtualWriter);
-    procedure ReadFromFiler(reader: TGVirtualReader);
+    procedure WriteToFiler(writer: TGLVirtualWriter);
+    procedure ReadFromFiler(reader: TGLVirtualReader);
     procedure SaveToStream(aStream: TStream); virtual;
     procedure LoadFromStream(aStream: TStream); virtual;
     procedure AddMaterialsFromStream(aStream: TStream);
@@ -681,10 +681,10 @@ constructor TGLFaceProperties.Create(aOwner: TPersistent);
 begin
   inherited;
   // OpenGL default colors
-  FAmbient := TGColor.CreateInitialized(Self, clrGray20);
-  FDiffuse := TGColor.CreateInitialized(Self, clrGray80);
-  FEmission := TGColor.Create(Self);
-  FSpecular := TGColor.Create(Self);
+  FAmbient := TGLColor.CreateInitialized(Self, clrGray20);
+  FDiffuse := TGLColor.CreateInitialized(Self, clrGray80);
+  FEmission := TGLColor.Create(Self);
+  FSpecular := TGLColor.Create(Self);
   FShininess := 0;
 end;
 
@@ -726,25 +726,25 @@ begin
   end;
 end;
 
-procedure TGLFaceProperties.SetAmbient(AValue: TGColor);
+procedure TGLFaceProperties.SetAmbient(AValue: TGLColor);
 begin
   FAmbient.DirectColor := AValue.Color;
   NotifyChange(Self);
 end;
 
-procedure TGLFaceProperties.SetDiffuse(AValue: TGColor);
+procedure TGLFaceProperties.SetDiffuse(AValue: TGLColor);
 begin
   FDiffuse.DirectColor := AValue.Color;
   NotifyChange(Self);
 end;
 
-procedure TGLFaceProperties.SetEmission(AValue: TGColor);
+procedure TGLFaceProperties.SetEmission(AValue: TGLColor);
 begin
   FEmission.DirectColor := AValue.Color;
   NotifyChange(Self);
 end;
 
-procedure TGLFaceProperties.SetSpecular(AValue: TGColor);
+procedure TGLFaceProperties.SetSpecular(AValue: TGLColor);
 begin
   FSpecular.DirectColor := AValue.Color;
   NotifyChange(Self);
@@ -2405,7 +2405,7 @@ begin
   Result := (FMaterials.Count > 0);
 end;
 
-procedure TGLMaterialLibrary.WriteToFiler(writer: TGVirtualWriter);
+procedure TGLMaterialLibrary.WriteToFiler(writer: TGLVirtualWriter);
 var
   i, j: Integer;
   libMat: TGLLibMaterial;
@@ -2575,7 +2575,7 @@ begin
   end;
 end;
 
-procedure TGLMaterialLibrary.ReadFromFiler(reader: TGVirtualReader);
+procedure TGLMaterialLibrary.ReadFromFiler(reader: TGLVirtualReader);
 var
   archiveVersion: Integer;
   libMat: TGLLibMaterial;
@@ -2747,9 +2747,9 @@ end;
 
 procedure TGLMaterialLibrary.SaveToStream(aStream: TStream);
 var
-  wr: TGBinaryWriter;
+  wr: TGLBinaryWriter;
 begin
-  wr := TGBinaryWriter.Create(aStream);
+  wr := TGLBinaryWriter.Create(aStream);
   try
     Self.WriteToFiler(wr);
   finally
@@ -2759,9 +2759,9 @@ end;
 
 procedure TGLMaterialLibrary.LoadFromStream(aStream: TStream);
 var
-  rd: TGBinaryReader;
+  rd: TGLBinaryReader;
 begin
-  rd := TGBinaryReader.Create(aStream);
+  rd := TGLBinaryReader.Create(aStream);
   try
     Self.ReadFromFiler(rd);
   finally

Source/GLS.MaterialEx.pas

@@ -73,16 +73,16 @@ type
       IGLMaterialLibrarySupported)
   private
     FNameHashKey: Integer;
-    FUserList: TgPersistentObjectList;
+    FUserList: TGLPersistentObjectList;
     FDefferedInit: Boolean;
     FNotifying: Boolean;
     FIsValid: Boolean;
-    function GetUserList: TgPersistentObjectList;
+    function GetUserList: TGLPersistentObjectList;
     function GetMaterialLibraryEx: TGLMaterialLibraryEx;
   protected
     procedure SetName(const AValue: TGLMaterialComponentName); override;
     procedure NotifyChange(Sender: TObject); virtual;
-    property UserList: TgPersistentObjectList read GetUserList;
+    property UserList: TGLPersistentObjectList read GetUserList;
     procedure DoOnPrepare(Sender: TGLContext); virtual; abstract;
   public
     destructor Destroy; override;
@@ -132,7 +132,7 @@ type
     FLODBias: Integer;
     FLODBiasFract: Single;
     FWrap: array[0..2] of TGLSeparateTextureWrap;
-    FBorderColor: TGColor;
+    FBorderColor: TGLColor;
     FCompareMode: TGLTextureCompareMode;
     FCompareFunc: TGLDepthFunction;
     FDecodeSRGB: Boolean;
@@ -142,7 +142,7 @@ type
     procedure SetFilteringQuality(AValue: TGLTextureFilteringQuality);
     function GetWrap(Index: Integer): TGLSeparateTextureWrap;
     procedure SetWrap(Index: Integer; AValue: TGLSeparateTextureWrap);
-    procedure SetBorderColor(const AValue: TGColor);
+    procedure SetBorderColor(const AValue: TGLColor);
     procedure SetCompareMode(AValue: TGLTextureCompareMode);
     procedure SetCompareFunc(AValue: TGLDepthFunction);
     procedure SetDecodeSRGB(AValue: Boolean);
@@ -175,7 +175,7 @@ type
     property WrapZ: TGLSeparateTextureWrap index 2 read GetWrap write SetWrap
       default twRepeat;
     // Texture border color.
-    property BorderColor: TGColor read FBorderColor
+    property BorderColor: TGLColor read FBorderColor
       write SetBorderColor;
     // Compare mode and function for depth texture
     property CompareMode: TGLTextureCompareMode read FCompareMode
@@ -409,7 +409,7 @@ type
     FTextureOverride: Boolean;
     FTextureMatrix: TGLMatrix;
     FMappingMode: TGLTextureMappingMode;
-    FEnvColor: TGColor;
+    FEnvColor: TGLColor;
     FMapSCoordinates: TGLCoordinates4;
     FMapTCoordinates: TGLCoordinates4;
     FMapRCoordinates: TGLCoordinates4;
@@ -443,7 +443,7 @@ type
     function StoreMappingQCoordinates: Boolean;
     procedure SetSwizzling(const AValue: TGLTextureSwizzling);
     function StoreSwizzling: Boolean;
-    procedure SetEnvColor(const AValue: TGColor);
+    procedure SetEnvColor(const AValue: TGLColor);
     procedure CalculateTextureMatrix;
     procedure ApplyMappingMode;
     procedure UnApplyMappingMode;
@@ -478,7 +478,7 @@ type
     property TextureRotate: Single read FTextureRotate write
       SetTextureRotate stored StoreTextureRotate;
     // Texture Environment color.
-    property EnvColor: TGColor read FEnvColor write SetEnvColor;
+    property EnvColor: TGLColor read FEnvColor write SetEnvColor;
     (* Texture coordinates mapping mode.
     This property controls automatic texture coordinates generation. *)
     property MappingMode: TGLTextureMappingMode read FMappingMode write
@@ -892,12 +892,12 @@ type
     FShaders: array[TGLShaderType] of TGLShaderEx;
     FIsValid: Boolean;
     FInfoLog: string;
-    FUniforms: TgPersistentObjectList;
+    FUniforms: TGLPersistentObjectList;
     FAutoFill: Boolean;
     function GetLibShaderName(AType: TGLShaderType): string;
     procedure SetLibShaderName(AType: TGLShaderType; const AValue: string);
     function GetUniform(const AName: string): IShaderParameter;
-    class procedure ReleaseUniforms(AList: TgPersistentObjectList);
+    class procedure ReleaseUniforms(AList: TGLPersistentObjectList);
     property LibVertexShaderName: TGLMaterialComponentName index shtVertex
       read GetLibShaderName write SetLibShaderName;
     property LibFragmentShaderName: TGLMaterialComponentName index shtFragment
@@ -1324,11 +1324,11 @@ begin
     Result := 0;
 end;
 
-function TGLBaseMaterialCollectionItem.GetUserList: TgPersistentObjectList;
+function TGLBaseMaterialCollectionItem.GetUserList: TGLPersistentObjectList;
 begin
   if FUserList = nil then
   begin
-    FUserList := TgPersistentObjectList.Create;
+    FUserList := TGLPersistentObjectList.Create;
     FNotifying := False;
   end;
   Result := FUserList;
@@ -2479,7 +2479,7 @@ begin
   FWrap[0] := twRepeat;
   FWrap[1] := twRepeat;
   FWrap[2] := twRepeat;
-  FBorderColor := TGColor.CreateInitialized(Self, clrTransparent);
+  FBorderColor := TGLColor.CreateInitialized(Self, clrTransparent);
   FCompareMode := tcmNone;
   FCompareFunc := cfLequal;
   FDecodeSRGB := True;
@@ -2589,7 +2589,7 @@ begin
       FWrap[0] := TGLSeparateTextureWrap(ReadInteger);
       FWrap[1] := TGLSeparateTextureWrap(ReadInteger);
       FWrap[2] := TGLSeparateTextureWrap(ReadInteger);
-      Read(FBorderColor.AsAddress^, SizeOf(TGColorVector));
+      Read(FBorderColor.AsAddress^, SizeOf(TGLColorVector));
       FCompareMode := TGLTextureCompareMode(ReadInteger);
       FCompareFunc := TGLDepthFunction(ReadInteger);
       FDecodeSRGB := ReadBoolean;
@@ -2599,7 +2599,7 @@ begin
   end;
 end;
 
-procedure TGLTextureSampler.SetBorderColor(const AValue: TGColor);
+procedure TGLTextureSampler.SetBorderColor(const AValue: TGLColor);
 begin
   FBorderColor.Assign(AValue);
   NotifyChange(Self);
@@ -2700,7 +2700,7 @@ begin
     WriteInteger(Integer(FWrap[0]));
     WriteInteger(Integer(FWrap[1]));
     WriteInteger(Integer(FWrap[2]));
-    Write(FBorderColor.AsAddress^, SizeOf(TGColorVector));
+    Write(FBorderColor.AsAddress^, SizeOf(TGLColorVector));
     WriteInteger(Integer(FCompareMode));
     WriteInteger(Integer(FCompareFunc));
     WriteBoolean(FDecodeSRGB);
@@ -3674,7 +3674,7 @@ begin
   FTextureMatrix := IdentityHmgMatrix;
   FEnabled := False;
   FSwizzling := TGLTextureSwizzling.Create(Self);
-  FEnvColor := TGColor.CreateInitialized(Self, clrTransparent);
+  FEnvColor := TGLColor.CreateInitialized(Self, clrTransparent);
 end;
 
 destructor TGLTextureProperties.Destroy;
@@ -3986,7 +3986,7 @@ begin
 end;
 
 procedure TGLTextureProperties.SetEnvColor(const AValue:
-  TGColor);
+  TGLColor);
 begin
   FEnvColor.Assign(AValue);
   NotifyChange(Self);
@@ -4418,7 +4418,7 @@ begin
   FHandle := TGLProgramHandle.Create;
   FHandle.OnPrapare := DoOnPrepare;
   FEnabled := False;
-  FUniforms := TgPersistentObjectList.Create;
+  FUniforms := TGLPersistentObjectList.Create;
   FAutoFill := True;
 end;
 
@@ -4447,7 +4447,7 @@ end;
 procedure TGLBaseShaderModel.DoOnPrepare(Sender: TGLContext);
 var
   T: TGLShaderType;
-  LUniforms: TgPersistentObjectList;
+  LUniforms: TGLPersistentObjectList;
   LUniform, LUniform2: TGLShaderUniform;
   ID: Cardinal;
   I, J, C: Integer;
@@ -4537,7 +4537,7 @@ begin
               end;
 
               // Get uniforms
-              LUniforms := TgPersistentObjectList.Create;
+              LUniforms := TGLPersistentObjectList.Create;
 
               gl.GetProgramiv(ID, GL_ACTIVE_UNIFORMS, @C);
               for I := 0 to C - 1 do
@@ -4826,7 +4826,7 @@ begin
 end;
 
 class procedure TGLBaseShaderModel.ReleaseUniforms(
-  AList: TgPersistentObjectList);
+  AList: TGLPersistentObjectList);
 var
   I: Integer;
 begin

Source/GLS.MaterialMultiProxy.pas

@@ -48,7 +48,7 @@ type
   TGLMaterialMultiProxy = class;
 
   {MasterObject description for a MultiProxy object. }
-  TGLMaterialMultiProxyMaster = class(TGInterfacedCollectionItem, IGLMaterialLibrarySupported)
+  TGLMaterialMultiProxyMaster = class(TGLInterfacedCollectionItem, IGLMaterialLibrarySupported)
   private
     FMasterObject: TGLBaseSceneObject;
     FMasterLibMaterial: TGLLibMaterial;

Source/GLS.MaterialScript.pas

@@ -96,7 +96,7 @@ type
     Done: Boolean;
     NewMat: TGLLibMaterial;
     TmpCoords: TGLCoordinates;
-    TmpColor: TGColor;
+    TmpColor: TGLColor;
     TmpCoords4: TGLCoordinates4;
     TmpStr: string;
     procedure SeTGLShaderItems(const Value: TGLShaderItems);

Source/GLS.Mesh.pas

@@ -100,10 +100,10 @@ type
       Use the NullVector, NullHmgVector or NullTexPoint constants for
       params you don't want to set. *)
     procedure AddVertex(const aVertex: TVertex; const aNormal: TAffineVector;
-      const aColor: TGColorVector; const aTexPoint: TTexPoint); overload;
+      const aColor: TGLColorVector; const aTexPoint: TTexPoint); overload;
     //  Adds a vertex to the list, no texturing version.  
     procedure AddVertex(const vertex: TVertex; const normal: TAffineVector;
-      const color: TGColorVector); overload;
+      const color: TGLColorVector); overload;
     //  Adds a vertex to the list, no texturing, not color version.  
     procedure AddVertex(const vertex: TVertex; const normal: TAffineVector); overload;
     //  Duplicates the vertex of given index and adds it at the end of the list. 
@@ -417,7 +417,7 @@ begin
 end;
 
 procedure TGLVertexList.AddVertex(const aVertex: TVertex;
-  const aNormal: TAffineVector; const aColor: TGColorVector;
+  const aNormal: TAffineVector; const aColor: TGLColorVector;
   const aTexPoint: TTexPoint);
 begin
   if FCount = FCapacity then
@@ -435,7 +435,7 @@ begin
 end;
 
 procedure TGLVertexList.AddVertex(const vertex: TVertex;
-  const normal: TAffineVector; const color: TGColorVector);
+  const normal: TAffineVector; const color: TGLColorVector);
 begin
   AddVertex(vertex, normal, color, NullTexPoint);
 end;

Source/GLS.MeshBSP.pas

@@ -141,7 +141,7 @@ type
       const maxTrianglesPerLeaf: Integer = MaxInt);
     (*  Goes through all triangle edges, looking for tjunctions.
       The candidates are indices of points to lookup a tjunction vertices. *)
-    procedure FixTJunctions(const tJunctionsCandidates: TgIntegerList);
+    procedure FixTJunctions(const tJunctionsCandidates: TGLIntegerList);
     (*  BSP node split plane.
       Divides space between positive and negative half-space, positive
       half-space being the one were the evaluation of an homogeneous
@@ -385,14 +385,14 @@ var
   i, j, n: Integer;
   nodeParents: array of Integer;
   remapIndex: array of Integer;
-  indicesToCheck: TgIntegerList;
+  indicesToCheck: TGLIntegerList;
   node: TFGBSPNode;
 begin
   n := faceGroups.Count;
   if n = 0 then
     Exit;
   SetLength(nodeParents, n);
-  indicesToCheck := TgIntegerList.Create;
+  indicesToCheck := TGLIntegerList.Create;
   try
     // build nodes parent information
     FillChar(nodeParents[0], SizeOf(Integer) * n, 255);
@@ -761,7 +761,7 @@ end;
 function TFGBSPNode.AddLerpIfDistinct(iA, iB, iMid: Integer): Integer;
 var
   midNormal: TAffineVector;
-  midColor: TGColorVector;
+  midColor: TGLColorVector;
   midTexCoord: TAffineVector;
   midLightmapTexCoord: TAffineVector;
   f: Single;
@@ -826,8 +826,8 @@ procedure TFGBSPNode.PerformSplit(const splitPlane: THmgPlane;
   const maxTrianglesPerLeaf: Integer = MaxInt);
 var
   fgPos, fgNeg: TFGBSPNode;
-  fgPosIndices, fgNegIndices: TgIntegerList;
-  indices: TgIntegerList;
+  fgPosIndices, fgNegIndices: TGLIntegerList;
+  indices: TGLIntegerList;
 
   procedure SplitTriangleMid(strayID, strayNext, strayPrev: Integer;
     eNext, ePrev: Single);
@@ -893,7 +893,7 @@ begin
   fgNegIndices := fgNeg.VertexIndices;
   // initiate split
   Self.FSplitPlane := splitPlane;
-  indices := TgIntegerList.Create;
+  indices := TGLIntegerList.Create;
   vertices := Owner.Owner.vertices;
   i := 0;
   while i < VertexIndices.Count do
@@ -1034,10 +1034,10 @@ begin
   end;
 end;
 
-procedure TFGBSPNode.FixTJunctions(const tJunctionsCandidates: TgIntegerList);
+procedure TFGBSPNode.FixTJunctions(const tJunctionsCandidates: TGLIntegerList);
 
   function FindTJunction(iA, iB, iC: Integer;
-    candidatesList: TgIntegerList): Integer;
+    candidatesList: TGLIntegerList): Integer;
   var
     i, k: Integer;
     vertices: PAffineVectorArray;
@@ -1092,10 +1092,10 @@ procedure TFGBSPNode.FixTJunctions(const tJunctionsCandidates: TgIntegerList);
 var
   i, tj: Integer;
   indices: PIntegerArray;
-  mark: TgIntegerList;
+  mark: TGLIntegerList;
 begin
   Assert(Mode in [fgmmTriangles, fgmmFlatTriangles]);
-  mark := TgIntegerList.Create;
+  mark := TGLIntegerList.Create;
   mark.AddSerie(1, 0, VertexIndices.Count);
   indices := VertexIndices.List;
   i := 0;

Source/GLS.MeshBuilder.pas

@@ -560,7 +560,7 @@ var
   i: Integer;
   fg: TGLFaceGroup;
   coords, TexCoords, Normals: TGLAffineVectorList;
-  il: TgIntegerList;
+  il: TGLIntegerList;
   materialName: String;
 begin
   if (mooMergeObjects in options) then
@@ -641,19 +641,19 @@ procedure FacesSmooth(aMeshObj: TGLMeshObject;
 Var
   i, J, k, L: Integer;
   WeldedVertex: TGLAffineVectorList;
-  TmpIntegerList: TgIntegerList;
+  TmpIntegerList: TGLIntegerList;
   IndexMap: TStringList;
   n: TAffineVector;
-  indicesMap: TgIntegerList;
+  indicesMap: TGLIntegerList;
   Index: Integer;
-  FaceList: TgIntegerList;
+  FaceList: TGLIntegerList;
   NormalList: TGLAffineVectorList;
   FaceNormalList: TGLAffineVectorList;
   FaceGroup: TGLFaceGroup;
   fg, FG1: TFGVertexIndexList;
   Threshold: Single;
   Angle: Single;
-  ReferenceMap: TgIntegerList;
+  ReferenceMap: TGLIntegerList;
   ID1, ID2: Integer;
   Index1, Index2, Index3: Integer;
 
@@ -679,10 +679,10 @@ Var
 begin
   Threshold := aThreshold * Pi / 180.0;
   // build the vectices reference map
-  ReferenceMap := TgIntegerList.Create;
+  ReferenceMap := TGLIntegerList.Create;
   WeldedVertex := TGLAffineVectorList.Create;
   WeldedVertex.Assign(aMeshObj.Vertices);
-  indicesMap := TgIntegerList.Create;
+  indicesMap := TGLIntegerList.Create;
   // first of all, weld the very closed vertices
   WeldVertices(WeldedVertex, indicesMap, aWeldDistance);
   // then, rebuild the map list
@@ -690,7 +690,7 @@ begin
   for i := 0 to WeldedVertex.Count - 1 do
   begin
     ReferenceMap.Assign(indicesMap);
-    TmpIntegerList := TgIntegerList.Create;
+    TmpIntegerList := TGLIntegerList.Create;
     Index := ReferenceMap.IndexOf(i);
     while Index >= 0 do
     begin
@@ -705,10 +705,10 @@ begin
   WeldedVertex.Free;
   indicesMap.Free;
   // creates a TexPoint list for save face infomation, where s=facegroup index, t=face index
-  FaceList := TgIntegerList.Create;
+  FaceList := TGLIntegerList.Create;
   NormalList := TGLAffineVectorList.Create;
   FaceNormalList := TGLAffineVectorList.Create;
-  // NormalIndex := TgIntegerList.Create;
+  // NormalIndex := TGLIntegerList.Create;
   for i := 0 to aMeshObj.FaceGroups.Count - 1 do
   begin
     FaceGroup := aMeshObj.FaceGroups[i];

Source/GLS.MeshLines.pas

@@ -149,8 +149,8 @@ type
       Tolerance: Single = 1): Boolean;
     function PointNearSegment(const StartNode, EndNode: TGLLineNode;
       const X, Z: Single; LineWidth: Single; Tolerance: Single = 1): Boolean;
-    procedure StitchStrips(idx: TgIntegerList);
-    procedure AddStitchMarker(idx: TgIntegerList);
+    procedure StitchStrips(idx: TGLIntegerList);
+    procedure AddStitchMarker(idx: TGLIntegerList);
     procedure SetShowNodes(const Value: Boolean);
     procedure SetNoZWrite(const Value: Boolean);
     procedure SetLightmapIndex(const Value: Integer);
@@ -806,7 +806,7 @@ begin
   result := sqrt(sqr(xt - X) + sqr(yt - Z)) <= lDist;
 end;
 
-procedure TGLMeshLines.StitchStrips(idx: TgIntegerList);
+procedure TGLMeshLines.StitchStrips(idx: TGLIntegerList);
 var
   i: Integer;
   i0, i1, i2: Integer;
@@ -826,7 +826,7 @@ begin
   end;
 end;
 
-procedure TGLMeshLines.AddStitchMarker(idx: TgIntegerList);
+procedure TGLMeshLines.AddStitchMarker(idx: TGLIntegerList);
 begin
   idx.Add(-1);
   idx.Add(-2);

Source/GLS.MeshUtils.pas

@@ -26,17 +26,17 @@ uses
 *)
 procedure ConvertStripToList(const strip: TGLAffineVectorList;
   list: TGLAffineVectorList); overload;
-procedure ConvertStripToList(const strip: TgIntegerList;
-  list: TgIntegerList); overload;
+procedure ConvertStripToList(const strip: TGLIntegerList;
+  list: TGLIntegerList); overload;
 procedure ConvertStripToList(const strip: TGLAffineVectorList;
-  const indices: TgIntegerList; list: TGLAffineVectorList); overload;
+  const indices: TGLIntegerList; list: TGLAffineVectorList); overload;
 function ConvertStripToList(const AindicesList: PLongWordArray; Count: LongWord;
-  RestartIndex: LongWord): TGLongWordList; overload;
+  RestartIndex: LongWord): TGLLongWordList; overload;
 function ConvertFansToList(const AindicesList: PLongWordArray; Count: LongWord;
-  RestartIndex: LongWord): TGLongWordList;
+  RestartIndex: LongWord): TGLLongWordList;
 // Expands an indexed structure into a non-indexed structure.
 procedure ConvertIndexedListToList(const data: TGLAffineVectorList;
-  const indices: TgIntegerList; list: TGLAffineVectorList);
+  const indices: TGLIntegerList; list: TGLAffineVectorList);
 (* 
   Builds a vector-count optimized indices list.
   The returned list (to be freed by caller) contains an "optimized" indices
@@ -47,16 +47,16 @@ procedure ConvertIndexedListToList(const data: TGLAffineVectorList;
 *)
 function BuildVectorCountOptimizedIndices(const vertices: TGLAffineVectorList;
   const normals: TGLAffineVectorList = nil;
-  const texCoords: TGLAffineVectorList = nil): TgIntegerList;
+  const texCoords: TGLAffineVectorList = nil): TGLIntegerList;
 (* 
   Alters a reference array and removes unused reference values.
   This functions scans the reference list and removes all values that aren't
   referred in the indices list, the indices list is *not* remapped. 
 *)
 procedure RemapReferences(reference: TGLAffineVectorList;
-  const indices: TgIntegerList); overload;
-procedure RemapReferences(reference: TgIntegerList;
-  const indices: TgIntegerList); overload;
+  const indices: TGLIntegerList); overload;
+procedure RemapReferences(reference: TGLIntegerList;
+  const indices: TGLIntegerList); overload;
 (* 
   Alters a reference/indice pair and removes unused reference values.
   This functions scans the reference list and removes all values that aren't
@@ -64,7 +64,7 @@ procedure RemapReferences(reference: TgIntegerList;
   coherent. 
 *)
 procedure RemapAndCleanupReferences(reference: TGLAffineVectorList;
-  indices: TgIntegerList);
+  indices: TGLIntegerList);
 (* 
   Creates an indices map from a remap list.
   The remap list is what BuildVectorCountOptimizedIndices, a list of indices
@@ -74,17 +74,17 @@ procedure RemapAndCleanupReferences(reference: TGLAffineVectorList;
   it to something suitable for RemapTrianglesIndices.
   Any simpler documentation of this function welcome ;) 
 *)
-function RemapIndicesToIndicesMap(remapIndices: TgIntegerList): TgIntegerList;
+function RemapIndicesToIndicesMap(remapIndices: TGLIntegerList): TGLIntegerList;
 (* 
   Remaps a list of triangles vertex indices and remove degenerate triangles.
   The indicesMap provides newVertexIndex:=indicesMap[oldVertexIndex] 
 *)
-procedure RemapTrianglesIndices(indices, indicesMap: TgIntegerList);
+procedure RemapTrianglesIndices(indices, indicesMap: TGLIntegerList);
 (* 
   Remaps a list of indices.
   The indicesMap provides newVertexIndex:=indicesMap[oldVertexIndex] 
 *)
-procedure remapIndices(indices, indicesMap: TgIntegerList);
+procedure remapIndices(indices, indicesMap: TGLIntegerList);
 (* 
   Attempts to unify triangle winding.
   Depending on topology, this may or may not be successful (some topologies
@@ -92,16 +92,16 @@ procedure remapIndices(indices, indicesMap: TgIntegerList);
   have edges shared by more than two triangles, those that have unconnected
   submeshes etc.) 
 *)
-procedure UnifyTrianglesWinding(indices: TgIntegerList);
+procedure UnifyTrianglesWinding(indices: TGLIntegerList);
 // Inverts the triangles winding (vertex order).
-procedure InvertTrianglesWinding(indices: TgIntegerList);
+procedure InvertTrianglesWinding(indices: TGLIntegerList);
 (* 
   Builds normals for a triangles list.
   Builds one normal per reference vertex (may be NullVector is reference isn't
   used), which is the averaged for normals of all adjacent triangles.
   Returned list must be freed by caller. 
 *)
-function BuildNormals(reference: TGLAffineVectorList; indices: TgIntegerList)
+function BuildNormals(reference: TGLAffineVectorList; indices: TGLIntegerList)
   : TGLAffineVectorList;
 (* 
   Builds a list of non-oriented (non duplicated) edges list.
@@ -115,9 +115,9 @@ function BuildNormals(reference: TGLAffineVectorList; indices: TgIntegerList)
   A maximum of two triangles can be referred by this list,
   and its final size will be that of the Result (ie. non oriented edges list) 
 *)
-function BuildNonOrientedEdgesList(triangleIndices: TgIntegerList;
-  triangleEdges: TgIntegerList = nil; edgesTriangles: TgIntegerList = nil)
-  : TgIntegerList;
+function BuildNonOrientedEdgesList(triangleIndices: TGLIntegerList;
+  triangleEdges: TGLIntegerList = nil; edgesTriangles: TGLIntegerList = nil)
+  : TGLIntegerList;
 (* 
   Welds all vertices separated by a distance inferior to weldRadius.
   Any two vertices whose distance is inferior to weldRadius will be merged
@@ -131,20 +131,20 @@ function BuildNonOrientedEdgesList(triangleIndices: TgIntegerList;
   exported from high-polycount CAD tools (to remove duplicate vertices,
   quantification errors, etc.) 
 *)
-procedure WeldVertices(vertices: TGLAffineVectorList; indicesMap: TgIntegerList;
+procedure WeldVertices(vertices: TGLAffineVectorList; indicesMap: TGLIntegerList;
   weldRadius: Single);
 (* 
   Attempts to create as few as possible triangle strips to cover the mesh.
   The indices parameters define a set of triangles as a set of indices to
   vertices in a vertex pool, free of duplicate vertices (or resulting
   stripification will be of lower quality).
-  The function returns a list of TgIntegerList, each of these lists hosting
+  The function returns a list of TGLIntegerList, each of these lists hosting
   a triangle strip, returned objects must be freed by caller.
   If agglomerateLoneTriangles is True, the first of the lists actually contains
   the agglomerated list of the triangles that couldn't be stripified. 
 *)
-function StripifyMesh(indices: TgIntegerList; maxVertexIndex: Integer;
-  agglomerateLoneTriangles: Boolean = False): TgPersistentObjectList;
+function StripifyMesh(indices: TGLIntegerList; maxVertexIndex: Integer;
+  agglomerateLoneTriangles: Boolean = False): TGLPersistentObjectList;
 (* 
   Increases indices coherency wrt vertex caches.
   The indices parameters is understood as vertex indices of a triangles set,
@@ -156,7 +156,7 @@ function StripifyMesh(indices: TgIntegerList; maxVertexIndex: Integer;
   This procedure performs a coherency optimization via a greedy hill-climber
   algorithm (ie. not optimal but fast). 
 *)
-procedure IncreaseCoherency(indices: TgIntegerList; cacheSize: Integer);
+procedure IncreaseCoherency(indices: TGLIntegerList; cacheSize: Integer);
 
 type
   TSubdivideEdgeEvent = procedure(const idxA, idxB, newIdx: Integer); register;
@@ -170,11 +170,11 @@ type
   The procedure is not intended for real-time use. 
 *)
 procedure SubdivideTriangles(smoothFactor: Single; vertices: TGLAffineVectorList;
-  triangleIndices: TgIntegerList; normals: TGLAffineVectorList = nil;
+  triangleIndices: TGLIntegerList; normals: TGLAffineVectorList = nil;
   onSubdivideEdge: TSubdivideEdgeEvent = nil);
 // Create list of indices of triangles with adjacency from triangle list 
 function MakeTriangleAdjacencyList(const AindicesList: PLongWordArray;
-  Count: LongWord; const AVerticesList: PAffineVectorArray): TGLongWordList;
+  Count: LongWord; const AVerticesList: PAffineVectorArray): TGLLongWordList;
 
 var
   vImprovedFixingOpenTriangleEdge: Boolean = False;
@@ -217,7 +217,7 @@ begin
   end;
 end;
 
-procedure ConvertStripToList(const strip: TgIntegerList; list: TgIntegerList);
+procedure ConvertStripToList(const strip: TGLIntegerList; list: TGLIntegerList);
 var
   i: Integer;
   stripList: PIntegerArray;
@@ -234,7 +234,7 @@ begin
 end;
 
 procedure ConvertStripToList(const strip: TGLAffineVectorList;
-  const indices: TgIntegerList; list: TGLAffineVectorList);
+  const indices: TGLIntegerList; list: TGLAffineVectorList);
 var
   i: Integer;
   stripList: PAffineVectorArray;
@@ -253,7 +253,7 @@ begin
 end;
 
 procedure ConvertIndexedListToList(const data: TGLAffineVectorList;
-  const indices: TgIntegerList; list: TGLAffineVectorList);
+  const indices: TGLIntegerList; list: TGLAffineVectorList);
 var
   i: Integer;
   indicesList: PIntegerArray;
@@ -279,13 +279,13 @@ end;
 
 function BuildVectorCountOptimizedIndices(const vertices: TGLAffineVectorList;
   const normals: TGLAffineVectorList = nil;
-  const texCoords: TGLAffineVectorList = nil): TgIntegerList;
+  const texCoords: TGLAffineVectorList = nil): TGLIntegerList;
 var
   i, j, k: Integer;
   found: Boolean;
   hashSize: Integer;
-  hashTable: array of TgIntegerList;
-  list: TgIntegerList;
+  hashTable: array of TGLIntegerList;
+  list: TGLIntegerList;
   verticesList, normalsList, texCoordsList: PAffineVectorArray;
 const
   cVerticesPerHashKey = 48;
@@ -298,7 +298,7 @@ const
   end;
 
 begin
-  Result := TgIntegerList.Create;
+  Result := TGLIntegerList.Create;
   Result.Capacity := vertices.Count;
 
   if Assigned(normals) then
@@ -333,7 +333,7 @@ begin
   // allocate and fill our hashtable (will store "reference" vertex indices)
   for i := 0 to hashSize do
   begin
-    hashTable[i] := TgIntegerList.Create;
+    hashTable[i] := TGLIntegerList.Create;
     hashTable[i].GrowthDelta := cVerticesPerHashKey div 2;
   end;
   // here we go for all vertices
@@ -439,7 +439,7 @@ end;
 // RemapReferences (vectors)
 //
 procedure RemapReferences(reference: TGLAffineVectorList;
-  const indices: TgIntegerList);
+  const indices: TGLIntegerList);
 var
   i: Integer;
   tag: array of Byte;
@@ -469,7 +469,7 @@ begin
     div SizeOf(TAffineVector);
 end;
 
-procedure RemapReferences(reference: TgIntegerList; const indices: TgIntegerList);
+procedure RemapReferences(reference: TGLIntegerList; const indices: TGLIntegerList);
 var
   i, n: Integer;
   tag: array of Byte;
@@ -498,7 +498,7 @@ begin
 end;
 
 procedure RemapAndCleanupReferences(reference: TGLAffineVectorList;
-  indices: TgIntegerList);
+  indices: TGLIntegerList);
 var
   i, n: Integer;
   tag: array of Integer;
@@ -530,7 +530,7 @@ begin
     indicesList[i] := tag[indicesList[i]];
 end;
 
-function RemapIndicesToIndicesMap(remapIndices: TgIntegerList): TgIntegerList;
+function RemapIndicesToIndicesMap(remapIndices: TGLIntegerList): TGLIntegerList;
 var
   i, n: Integer;
   tag: array of Integer;
@@ -552,14 +552,14 @@ begin
     end;
   end;
   // 3rd step, fillup indices map
-  Result := TgIntegerList.Create;
+  Result := TGLIntegerList.Create;
   Result.Count := remapIndices.Count;
   indicesMap := Result.list;
   for i := 0 to Result.Count - 1 do
     indicesMap[i] := tag[remapList[i]];
 end;
 
-procedure RemapTrianglesIndices(indices, indicesMap: TgIntegerList);
+procedure RemapTrianglesIndices(indices, indicesMap: TGLIntegerList);
 var
   i, k, a, b, c, n: Integer;
 begin
@@ -584,7 +584,7 @@ begin
   indices.Count := k;
 end;
 
-procedure remapIndices(indices, indicesMap: TgIntegerList);
+procedure remapIndices(indices, indicesMap: TGLIntegerList);
 var
   i: Integer;
   map, ind: PIntegerArray;
@@ -595,11 +595,11 @@ begin
     ind[i] := map[ind[i]];
 end;
 
-procedure UnifyTrianglesWinding(indices: TgIntegerList);
+procedure UnifyTrianglesWinding(indices: TGLIntegerList);
 var
   nbTris: Integer;
   mark: array of ByteBool; // marks triangles that have been processed
-  triangleStack: TgIntegerList; // marks triangles winded, that must be processed
+  triangleStack: TGLIntegerList; // marks triangles winded, that must be processed
 
   procedure TestRewind(a, b: Integer);
   var
@@ -657,7 +657,7 @@ begin
   nbTris := indices.Count div 3;
   SetLength(mark, nbTris);
   // Build connectivity data
-  triangleStack := TgIntegerList.Create;
+  triangleStack := TGLIntegerList.Create;
   try
     triangleStack.Capacity := nbTris div 4;
     // Pick a triangle, adjust normals of neighboring triangles, recurse
@@ -673,7 +673,7 @@ begin
   end;
 end;
 
-procedure InvertTrianglesWinding(indices: TgIntegerList);
+procedure InvertTrianglesWinding(indices: TGLIntegerList);
 var
   i: Integer;
 begin
@@ -686,7 +686,7 @@ begin
   end;
 end;
 
-function BuildNormals(reference: TGLAffineVectorList; indices: TgIntegerList)
+function BuildNormals(reference: TGLAffineVectorList; indices: TGLIntegerList)
   : TGLAffineVectorList;
 var
   i, n, k: Integer;
@@ -723,22 +723,22 @@ begin
 end;
 
 //----------------------------------------------------------
-function BuildNonOrientedEdgesList(triangleIndices: TgIntegerList;
-  triangleEdges: TgIntegerList = nil; edgesTriangles: TgIntegerList = nil)
-  : TgIntegerList;
+function BuildNonOrientedEdgesList(triangleIndices: TGLIntegerList;
+  triangleEdges: TGLIntegerList = nil; edgesTriangles: TGLIntegerList = nil)
+  : TGLIntegerList;
 const
   cEdgesHashMax = 127; // must be a power of two minus 1
 var
-  edgesHash: array [0 .. cEdgesHashMax] of TgIntegerList;
+  edgesHash: array [0 .. cEdgesHashMax] of TGLIntegerList;
   curTri: Integer;
-  edges: TgIntegerList;
+  edges: TGLIntegerList;
 
   function ProcessEdge(a, b: Integer): Integer;
   var
     i, n: Integer;
     HashKey: Integer;
     edgesList, iList: PIntegerArray;
-    hashList: TgIntegerList;
+    hashList: TGLIntegerList;
   begin
     if a >= b then
     begin
@@ -770,7 +770,7 @@ var
     HashKey: Integer;
     edgesList: PIntegerArray;
     iList, iListEnd: PInteger;
-    hashList: TgIntegerList;
+    hashList: TGLIntegerList;
   begin
     if a >= b then
     begin
@@ -804,7 +804,7 @@ var
   j, k: Integer;
   triIndicesList: PIntegerArray;
 begin
-  Result := TgIntegerList.Create;
+  Result := TGLIntegerList.Create;
   Result.Capacity := 1024;
   Result.GrowthDelta := 1024;
   if Assigned(triangleEdges) then
@@ -815,7 +815,7 @@ begin
   k := (triangleIndices.Count div (cEdgesHashMax + 1)) + 128;
   for j := 0 to High(edgesHash) do
   begin
-    edgesHash[j] := TgIntegerList.Create;
+    edgesHash[j] := TGLIntegerList.Create;
     edgesHash[j].Capacity := k;
   end;
   // collect all edges
@@ -879,20 +879,20 @@ begin
     edgesHash[j].Free;
 end;
 
-procedure IncreaseCoherency(indices: TgIntegerList; cacheSize: Integer);
+procedure IncreaseCoherency(indices: TGLIntegerList; cacheSize: Integer);
 var
   i, n, maxVertex, bestCandidate, bestScore, candidateIdx,
     lastCandidate: Integer;
-  trisOfVertex: array of TgIntegerList;
-  candidates: TgIntegerList;
+  trisOfVertex: array of TGLIntegerList;
+  candidates: TGLIntegerList;
   indicesList: PIntegerArray;
 begin
   // Alloc lookup structure
   maxVertex := indices.MaxInteger;
   SetLength(trisOfVertex, maxVertex + 1);
   for i := 0 to High(trisOfVertex) do
-    trisOfVertex[i] := TgIntegerList.Create;
-  candidates := TgIntegerList.Create;
+    trisOfVertex[i] := TGLIntegerList.Create;
+  candidates := TGLIntegerList.Create;
   indicesList := PIntegerArray(indices.list);
   // Fillup lookup structure
   i := 0;
@@ -968,7 +968,7 @@ begin
     trisOfVertex[i].Free;
 end;
 
-procedure WeldVertices(vertices: TGLAffineVectorList; indicesMap: TgIntegerList;
+procedure WeldVertices(vertices: TGLAffineVectorList; indicesMap: TGLIntegerList;
   weldRadius: Single);
 var
   i, j, n, k: Integer;
@@ -1032,21 +1032,21 @@ begin
   vertices.Count := k;
 end;
 
-function StripifyMesh(indices: TgIntegerList; maxVertexIndex: Integer;
-  agglomerateLoneTriangles: Boolean = False): TgPersistentObjectList;
+function StripifyMesh(indices: TGLIntegerList; maxVertexIndex: Integer;
+  agglomerateLoneTriangles: Boolean = False): TGLPersistentObjectList;
 var
   accountedTriangles: array of ByteBool;
-  vertexTris: array of TgIntegerList;
+  vertexTris: array of TGLIntegerList;
   indicesList: PIntegerArray;
   indicesCount: Integer;
-  currentStrip: TgIntegerList;
+  currentStrip: TGLIntegerList;
   nextTriangle, nextVertex: Integer;
 
   function FindTriangleWithEdge(vertA, vertB: Integer): Boolean;
   var
     i, n: Integer;
     p: PIntegerArray;
-    list: TgIntegerList;
+    list: TGLIntegerList;
   begin
     Result := False;
     list := vertexTris[vertA];
@@ -1102,17 +1102,17 @@ var
 
 var
   i, n, triangle: Integer;
-  loneTriangles: TgIntegerList;
+  loneTriangles: TGLIntegerList;
 begin
   Assert((indices.Count mod 3) = 0, 'indices count is not a multiple of 3!');
-  Result := TgPersistentObjectList.Create;
+  Result := TGLPersistentObjectList.Create;
   // direct access and cache vars
   indicesList := indices.list;
   indicesCount := indices.Count;
   // Build adjacency lookup table (vertex based, not triangle based)
   SetLength(vertexTris, maxVertexIndex + 1);
   for i := 0 to High(vertexTris) do
-    vertexTris[i] := TgIntegerList.Create;
+    vertexTris[i] := TGLIntegerList.Create;
   n := 0;
   triangle := 0;
   for i := 0 to indicesCount - 1 do
@@ -1130,7 +1130,7 @@ begin
   SetLength(accountedTriangles, indicesCount); // yeah, waste of memory
   if agglomerateLoneTriangles then
   begin
-    loneTriangles := TgIntegerList.Create;
+    loneTriangles := TGLIntegerList.Create;
     Result.Add(loneTriangles);
   end
   else
@@ -1143,19 +1143,19 @@ begin
       accountedTriangles[i] := True;
       if FindTriangleWithEdge(indicesList[i + 1], indicesList[i]) then
       begin
-        currentStrip := TgIntegerList.Create;
+        currentStrip := TGLIntegerList.Create;
         currentStrip.Add(indicesList[i + 2]);
         BuildStrip(indicesList[i], indicesList[i + 1]);
       end
       else if FindTriangleWithEdge(indicesList[i + 2], indicesList[i + 1]) then
       begin
-        currentStrip := TgIntegerList.Create;
+        currentStrip := TGLIntegerList.Create;
         currentStrip.Add(indicesList[i]);
         BuildStrip(indicesList[i + 1], indicesList[i + 2]);
       end
       else if FindTriangleWithEdge(indicesList[i], indicesList[i + 2]) then
       begin
-        currentStrip := TgIntegerList.Create;
+        currentStrip := TGLIntegerList.Create;
         currentStrip.Add(indicesList[i + 1]);
         BuildStrip(indicesList[i + 2], indicesList[i]);
       end
@@ -1164,7 +1164,7 @@ begin
         if agglomerateLoneTriangles then
           currentStrip := loneTriangles
         else
-          currentStrip := TgIntegerList.Create;
+          currentStrip := TGLIntegerList.Create;
         currentStrip.Add(indicesList[i], indicesList[i + 1],
           indicesList[i + 2]);
       end;
@@ -1179,17 +1179,17 @@ begin
 end;
 
 procedure SubdivideTriangles(smoothFactor: Single; vertices: TGLAffineVectorList;
-  triangleIndices: TgIntegerList; normals: TGLAffineVectorList = nil;
+  triangleIndices: TGLIntegerList; normals: TGLAffineVectorList = nil;
   onSubdivideEdge: TSubdivideEdgeEvent = nil);
 var
   i, a, b, c, nv: Integer;
-  edges: TgIntegerList;
-  triangleEdges: TgIntegerList;
+  edges: TGLIntegerList;
+  triangleEdges: TGLIntegerList;
   p, n: TAffineVector;
   f: Single;
 begin
   // build edges list
-  triangleEdges := TgIntegerList.Create;
+  triangleEdges := TGLIntegerList.Create;
   try
     edges := BuildNonOrientedEdgesList(triangleIndices, triangleEdges);
     try
@@ -2067,7 +2067,7 @@ begin
 end;
 
 function MakeTriangleAdjacencyList(const AindicesList: PLongWordArray;
-  Count: LongWord; const AVerticesList: PAffineVectorArray): TGLongWordList;
+  Count: LongWord; const AVerticesList: PAffineVectorArray): TGLLongWordList;
 
   function AdjacentEdge(x, n: Integer): Integer;
   begin
@@ -2079,7 +2079,7 @@ var
   j: Byte;
   n, ii, jj: LongWord;
   tri, adjtri: TVector3dw;
-  NewIndices: TGLongWordList;
+  NewIndices: TGLLongWordList;
 begin
   Result := nil;
   Assert(Assigned(AindicesList));
@@ -2100,7 +2100,7 @@ begin
     EliminateAdjacentDegenerateTriangles;
   end;
 
-  NewIndices := TGLongWordList.Create;
+  NewIndices := TGLLongWordList.Create;
   NewIndices.SetCountResetsMemory := False;
   NewIndices.Capacity := 6 * PrimitiveNum;
 
@@ -2134,16 +2134,16 @@ begin
 end;
 
 function ConvertStripToList(const AindicesList: PLongWordArray; Count: LongWord;
-  RestartIndex: LongWord): TGLongWordList;
+  RestartIndex: LongWord): TGLLongWordList;
 var
   i: Integer;
   Index, prevIndex1, prevIndex2, stripCount: LongWord;
-  NewIndices: TGLongWordList;
+  NewIndices: TGLLongWordList;
 begin
   Result := nil;
   if not Assigned(AindicesList) or (Count < 3) then
     Exit;
-  NewIndices := TGLongWordList.Create;
+  NewIndices := TGLLongWordList.Create;
   stripCount := 0;
   prevIndex1 := 0;
   prevIndex2 := 0;
@@ -2198,17 +2198,17 @@ begin
 end;
 
 function ConvertFansToList(const AindicesList: PLongWordArray; Count: LongWord;
-  RestartIndex: LongWord): TGLongWordList;
+  RestartIndex: LongWord): TGLLongWordList;
 var
   i: Integer;
   Index, centerIndex, prevIndex, fansCount: LongWord;
-  NewIndices: TGLongWordList;
+  NewIndices: TGLLongWordList;
   degenerate: Boolean;
 begin
   Result := nil;
   if not Assigned(AindicesList) or (Count < 3) then
     Exit;
-  NewIndices := TGLongWordList.Create;
+  NewIndices := TGLLongWordList.Create;
   fansCount := 0;
   prevIndex := 0;
   degenerate := False;

Source/GLS.Mirror.pas

@@ -141,7 +141,7 @@ var
   oldProxySubObject: Boolean;
   refMat, curMat, ModelMat: TGLMatrix;
   clipPlane: TDoubleHmgPlane;
-  bgColor: TGColorVector;
+  bgColor: TGLColorVector;
   cameraPosBackup, cameraDirectionBackup: TGLVector;
   CurrentBuffer: TGLSceneBuffer;
 begin

Source/GLS.MultiPolygon.pas

@@ -95,7 +95,7 @@ type
     procedure GetExtents(var min, max: TAffineVector);
   end;
 
-  TGLPolygonList = class(TgPersistentObjectList)
+  TGLPolygonList = class(TGLPersistentObjectList)
   private
     FAktList: TGLAffineVectorList;
     function GetList(I: Integer): TGLAffineVectorList;

Source/GLS.NGDManager.pas

@@ -101,18 +101,18 @@ type
   TGLNGDDebugOption = class(TPersistent)
   strict private
     FManager: TGLNGDManager;
-    FGeomColorDyn: TGColor; // Green
-    FGeomColorStat: TGColor; // Red
-    FAABBColor: TGColor; // Yellow
-    FAABBColorSleep: TGColor; // Orange
-    FCenterOfMassColor: TGColor; // Purple dot
-    FContactColor: TGColor; // White
-    FJointAxisColor: TGColor; // Blue
-    FJointPivotColor: TGColor; // Aquamarine
-    FForceColor: TGColor; // Black
-    FAppliedForceColor: TGColor; // Silver
-    FAppliedVelocityColor: TGColor; // Lime
-    FCustomColor: TGColor; // Aqua
+    FGeomColorDyn: TGLColor; // Green
+    FGeomColorStat: TGLColor; // Red
+    FAABBColor: TGLColor; // Yellow
+    FAABBColorSleep: TGLColor; // Orange
+    FCenterOfMassColor: TGLColor; // Purple dot
+    FContactColor: TGLColor; // White
+    FJointAxisColor: TGLColor; // Blue
+    FJointPivotColor: TGLColor; // Aquamarine
+    FForceColor: TGLColor; // Black
+    FAppliedForceColor: TGLColor; // Silver
+    FAppliedVelocityColor: TGLColor; // Lime
+    FCustomColor: TGLColor; // Aqua
     FDotAxisSize: Single; // 1
     FManagerDebugs: TGLNGDManagerDebugs; // Default All false
     procedure SetManagerDebugs(const Value: TGLNGDManagerDebugs);
@@ -122,18 +122,18 @@ type
     constructor Create(AOwner: TComponent);
     destructor Destroy; override;
   published
-    property GeomColorDyn: TGColor read FGeomColorDyn write FGeomColorDyn;
-    property GeomColorStat: TGColor read FGeomColorStat write FGeomColorStat;
-    property AABBColor: TGColor read FAABBColor write FAABBColor;
-    property AABBColorSleep: TGColor read FAABBColorSleep write FAABBColorSleep;
-    property CenterOfMassColor: TGColor read FCenterOfMassColor write FCenterOfMassColor;
-    property ContactColor: TGColor read FContactColor write FContactColor;
-    property JointAxisColor: TGColor read FJointAxisColor write FJointAxisColor;
-    property JointPivotColor: TGColor read FJointPivotColor write FJointPivotColor;
-    property ForceColor: TGColor read FForceColor write FForceColor;
-    property AppliedForceColor: TGColor read FAppliedForceColor write FAppliedForceColor;
-    property AppliedVelocityColor: TGColor read FAppliedVelocityColor write FAppliedVelocityColor;
-    property CustomColor: TGColor read FCustomColor write FCustomColor;
+    property GeomColorDyn: TGLColor read FGeomColorDyn write FGeomColorDyn;
+    property GeomColorStat: TGLColor read FGeomColorStat write FGeomColorStat;
+    property AABBColor: TGLColor read FAABBColor write FAABBColor;
+    property AABBColorSleep: TGLColor read FAABBColorSleep write FAABBColorSleep;
+    property CenterOfMassColor: TGLColor read FCenterOfMassColor write FCenterOfMassColor;
+    property ContactColor: TGLColor read FContactColor write FContactColor;
+    property JointAxisColor: TGLColor read FJointAxisColor write FJointAxisColor;
+    property JointPivotColor: TGLColor read FJointPivotColor write FJointPivotColor;
+    property ForceColor: TGLColor read FForceColor write FForceColor;
+    property AppliedForceColor: TGLColor read FAppliedForceColor write FAppliedForceColor;
+    property AppliedVelocityColor: TGLColor read FAppliedVelocityColor write FAppliedVelocityColor;
+    property CustomColor: TGLColor read FCustomColor write FCustomColor;
     property NGDManagerDebugs: TGLNGDManagerDebugs read FManagerDebugs write SetManagerDebugs
       default [];
     property DotAxisSize: Single read FDotAxisSize write SetDotAxisSize stored StoredDotAxis;
@@ -159,7 +159,7 @@ type
   private
     FNewtonWorld: PNewtonWorld;
     FNGDBehaviours: TGLNGDBehaviourList;
-    FCurrentColor: TGColor;
+    FCurrentColor: TGLColor;
   protected
     procedure Loaded; override;
     procedure SetVisible(const Value: Boolean);
@@ -662,20 +662,20 @@ begin
   FManager := AOwner as TGLNGDManager;
   with FManager do
   begin
-    FGeomColorDyn := TGColor.CreateInitialized(self, clrGreen, NotifyChange);
-    FGeomColorStat := TGColor.CreateInitialized(self, clrRed, NotifyChange);
-    FAABBColor := TGColor.CreateInitialized(self, clrYellow, NotifyChange);
-    FAABBColorSleep := TGColor.CreateInitialized(self, clrOrange, NotifyChange);
-    FCenterOfMassColor := TGColor.CreateInitialized(self, clrPurple, NotifyChange);
-    FContactColor := TGColor.CreateInitialized(self, clrWhite, NotifyChange);
-    FJointAxisColor := TGColor.CreateInitialized(self, clrBlue, NotifyChange);
-    FJointPivotColor := TGColor.CreateInitialized(self, clrAquamarine, NotifyChange);
-
-    FForceColor := TGColor.CreateInitialized(self, clrBlack, NotifyChange);
-    FAppliedForceColor := TGColor.CreateInitialized(self, clrSilver, NotifyChange);
-    FAppliedVelocityColor := TGColor.CreateInitialized(self, clrLime, NotifyChange);
-
-    FCustomColor := TGColor.CreateInitialized(self, clrAqua, NotifyChange);
+    FGeomColorDyn := TGLColor.CreateInitialized(self, clrGreen, NotifyChange);
+    FGeomColorStat := TGLColor.CreateInitialized(self, clrRed, NotifyChange);
+    FAABBColor := TGLColor.CreateInitialized(self, clrYellow, NotifyChange);
+    FAABBColorSleep := TGLColor.CreateInitialized(self, clrOrange, NotifyChange);
+    FCenterOfMassColor := TGLColor.CreateInitialized(self, clrPurple, NotifyChange);
+    FContactColor := TGLColor.CreateInitialized(self, clrWhite, NotifyChange);
+    FJointAxisColor := TGLColor.CreateInitialized(self, clrBlue, NotifyChange);
+    FJointPivotColor := TGLColor.CreateInitialized(self, clrAquamarine, NotifyChange);
+
+    FForceColor := TGLColor.CreateInitialized(self, clrBlack, NotifyChange);
+    FAppliedForceColor := TGLColor.CreateInitialized(self, clrSilver, NotifyChange);
+    FAppliedVelocityColor := TGLColor.CreateInitialized(self, clrLime, NotifyChange);
+
+    FCustomColor := TGLColor.CreateInitialized(self, clrAqua, NotifyChange);
   end;
   FDotAxisSize := 1;
   FManagerDebugs := [];

Source/GLS.ODEManager.pas

@@ -64,7 +64,7 @@ type
     FOnCustomCollision: TGLODECustomCollisionEvent;
     FNumContactJoints,
 	FMaxContacts: Integer;
-    FODEBehaviours: TgPersistentObjectList;
+    FODEBehaviours: TGLPersistentObjectList;
     FRFContactList: TList;
     FIterations: Integer;
     FSolver: TGLODESolverMethod;
@@ -75,7 +75,7 @@ type
 	FVisibleAtRunTime: Boolean;
     FGeomColorDynD,
   	FGeomColorDynE,
-	FGeomColorStat: TGColor;
+	FGeomColorStat: TGLColor;
   protected
     procedure Loaded; override;
     procedure CalcContact(Object1, Object2: TObject; var Contact: TdContact);
@@ -92,11 +92,11 @@ type
     procedure RenderPointFreed(Sender: TObject);
     procedure SetVisible(const Value: Boolean);
     procedure SetVisibleAtRunTime(const Value: Boolean);
-    procedure SetGeomColorDynE(const Value: TGColor);
+    procedure SetGeomColorDynE(const Value: TGLColor);
     procedure GeomColorChangeDynE(Sender: TObject);
-    procedure SetGeomColorDynD(const Value: TGColor);
+    procedure SetGeomColorDynD(const Value: TGLColor);
     procedure GeomColorChangeDynD(Sender: TObject);
-    procedure SetGeomColorStat(const Value: TGColor);
+    procedure SetGeomColorStat(const Value: TGLColor);
     procedure GeomColorChangeStat(Sender: TObject);
     property ODEBehaviours[index: Integer]: TGLODEBehaviour read GetODEBehaviour;
   public
@@ -118,9 +118,9 @@ type
     property RenderPoint: TGLRenderPoint read FRenderPoint write SetRenderPoint;
     property Visible: Boolean read FVisible write SetVisible;
     property VisibleAtRunTime: Boolean read FVisibleAtRunTime write SetVisibleAtRunTime;
-    property GeomColorDynD: TGColor read FGeomColorDynD write SetGeomColorDynD;
-    property GeomColorDynE: TGColor read FGeomColorDynE write SetGeomColorDynE;
-    property GeomColorStat: TGColor read FGeomColorStat write SetGeomColorStat;
+    property GeomColorDynD: TGLColor read FGeomColorDynD write SetGeomColorDynD;
+    property GeomColorDynE: TGLColor read FGeomColorDynE write SetGeomColorDynE;
+    property GeomColorStat: TGLColor read FGeomColorStat write SetGeomColorStat;
   end;
 
   TGLODECollisionSurface = class(TPersistent)
@@ -445,7 +445,7 @@ type
   private
     FTriMeshData: PdxTriMeshData;
     FVertices: TGLAffineVectorList;
-    FIndices: TgIntegerList;
+    FIndices: TGLIntegerList;
   protected
     procedure Initialize; override;
     procedure Finalize; override;
@@ -453,7 +453,7 @@ type
     procedure WriteToFiler(writer: TWriter); override;
     procedure ReadFromFiler(reader: TReader); override;
     procedure SetVertices(const Value: TGLAffineVectorList);
-    procedure SetIndices(const Value: TgIntegerList);
+    procedure SetIndices(const Value: TGLIntegerList);
   public
     constructor Create(AOwner: TXCollection); override;
     destructor Destroy; override;
@@ -462,7 +462,7 @@ type
     class function ItemCategory: String; override;
     procedure RefreshTriMeshData;
     property Vertices: TGLAffineVectorList read FVertices write SetVertices;
-    property Indices: TgIntegerList read FIndices write SetIndices;
+    property Indices: TGLIntegerList read FIndices write SetIndices;
   end;
 
   // ODE plane implementation
@@ -813,7 +813,7 @@ type
     FRenderContacts: Boolean;
     FContactRenderPoints: TGLAffineVectorList;
     FPointSize: Single;
-    FContactColor: TGColor;
+    FContactColor: TGLColor;
   protected
     procedure Initialize; override;
     procedure Finalize; override;
@@ -835,7 +835,7 @@ type
     procedure SetContactResolution(const Value: Single);
     procedure SetRenderContacts(const Value: Boolean);
     procedure SetPointSize(const Value: Single);
-    procedure SetContactColor(const Value: TGColor);
+    procedure SetContactColor(const Value: TGLColor);
   public
     constructor Create(AOwner: TXCollection); override;
     destructor Destroy; override;
@@ -853,7 +853,7 @@ type
     //  Contact point rendering size (in pixels).
     property PointSize: Single read FPointSize write SetPointSize;
     //  Contact point rendering color.
-    property ContactColor: TGColor read FContactColor write SetContactColor;
+    property ContactColor: TGLColor read FContactColor write SetContactColor;
   end;
 
   (* Add this behaviour to a TGLHeightField or TGLTerrainRenderer to enable
@@ -1294,7 +1294,7 @@ begin
 
   inherited;
 
-  FODEBehaviours:= TgPersistentObjectList.Create;
+  FODEBehaviours:= TGLPersistentObjectList.Create;
   FRFContactList:= TList.Create;
 
   FGravity:= TGLCoordinates.CreateInitialized(Self, NullHmgPoint, csVector);
@@ -1313,9 +1313,9 @@ begin
     FContactGroup := dJointGroupCreate(100);
   end;
 
-  FGeomColorDynD := TGColor.CreateInitialized(Self, clrRed, GeomColorChangeDynD);
-  FGeomColorDynE := TGColor.CreateInitialized(Self, clrLime, GeomColorChangeDynE);
-  FGeomColorStat := TGColor.CreateInitialized(Self, clrBlue, GeomColorChangeStat);
+  FGeomColorDynD := TGLColor.CreateInitialized(Self, clrRed, GeomColorChangeDynD);
+  FGeomColorDynE := TGLColor.CreateInitialized(Self, clrLime, GeomColorChangeDynE);
+  FGeomColorStat := TGLColor.CreateInitialized(Self, clrBlue, GeomColorChangeStat);
 
   RegisterManager(Self);
 end;
@@ -1629,7 +1629,7 @@ begin
   end;
 end;
 
-procedure TGLODEManager.SetGeomColorDynD(const Value: TGColor);
+procedure TGLODEManager.SetGeomColorDynD(const Value: TGLColor);
 begin
   FGeomColorDynD.Assign(Value);
   NotifyChange(Self);
@@ -1640,7 +1640,7 @@ begin
   NotifyChange(Self);
 end;
 
-procedure TGLODEManager.SetGeomColorDynE(const Value: TGColor);
+procedure TGLODEManager.SetGeomColorDynE(const Value: TGLColor);
 begin
   FGeomColorDynE.Assign(Value);
   NotifyChange(Self);
@@ -1651,7 +1651,7 @@ begin
   NotifyChange(Self);
 end;
 
-procedure TGLODEManager.SetGeomColorStat(const Value: TGColor);
+procedure TGLODEManager.SetGeomColorStat(const Value: TGLColor);
 begin
   FGeomColorStat.Assign(Value);
   NotifyChange(Self);
@@ -3440,7 +3440,7 @@ constructor TGLODEElementTriMesh.Create(AOwner: TXCollection);
 begin
   inherited;
   FVertices := TGLAffineVectorList.Create;
-  FIndices := TgIntegerList.Create;
+  FIndices := TGLIntegerList.Create;
 end;
 
 destructor TGLODEElementTriMesh.Destroy;
@@ -3530,7 +3530,7 @@ begin
   RefreshTriMeshData;
 end;
 
-procedure TGLODEElementTriMesh.SetIndices(const Value: TgIntegerList);
+procedure TGLODEElementTriMesh.SetIndices(const Value: TGLIntegerList);
 begin
   FIndices.Assign(Value);
   RefreshTriMeshData;
@@ -5034,7 +5034,7 @@ begin
 
   FRenderContacts := False;
   FContactRenderPoints := TGLAffineVectorList.Create;
-  FContactColor := TGColor.CreateInitialized(Self, clrRed, NotifyChange);
+  FContactColor := TGLColor.CreateInitialized(Self, clrRed, NotifyChange);
   FPointSize := 3;
 end;
 
@@ -5225,7 +5225,7 @@ begin
   end;
 end;
 
-procedure TGLODECustomCollider.SetContactColor(const Value: TGColor);
+procedure TGLODECustomCollider.SetContactColor(const Value: TGLColor);
 begin
   FContactColor.Assign(Value);
 end;

Source/GLS.ODESkeletonColliders.pas

@@ -23,8 +23,8 @@ type
   private
     FGeom: PdxGeom;
   public
-    procedure WriteToFiler(writer: TGVirtualWriter); override;
-    procedure ReadFromFiler(reader: TGVirtualReader); override;
+    procedure WriteToFiler(writer: TGLVirtualWriter); override;
+    procedure ReadFromFiler(reader: TGLVirtualReader); override;
     procedure AddToSpace(Space: PdxSpace); virtual;
     procedure AlignCollider; override;
     // The geoms are created through the AddToSpace procedure
@@ -39,8 +39,8 @@ type
     procedure SetRadius(const val: TdReal);
   public
     constructor Create; override;
-    procedure WriteToFiler(writer: TGVirtualWriter); override;
-    procedure ReadFromFiler(reader: TGVirtualReader); override;
+    procedure WriteToFiler(writer: TGLVirtualWriter); override;
+    procedure ReadFromFiler(reader: TGLVirtualReader); override;
     procedure AddToSpace(Space: PdxSpace); override;
 
     property Radius: TdReal read FRadius write SetRadius;
@@ -55,8 +55,8 @@ type
     procedure SetLength(const val: Single);
   public
     constructor Create; override;
-    procedure WriteToFiler(writer: TGVirtualWriter); override;
-    procedure ReadFromFiler(reader: TGVirtualReader); override;
+    procedure WriteToFiler(writer: TGLVirtualWriter); override;
+    procedure ReadFromFiler(reader: TGLVirtualReader); override;
     procedure AddToSpace(Space: PdxSpace); override;
     property Radius: Single read FRadius write SetRadius;
     property Length: Single read FLength write SetLength;
@@ -72,8 +72,8 @@ type
     procedure SetBoxDepth(const val: TdReal);
   public
     constructor Create; override;
-    procedure WriteToFiler(writer: TGVirtualWriter); override;
-    procedure ReadFromFiler(reader: TGVirtualReader); override;
+    procedure WriteToFiler(writer: TGLVirtualWriter); override;
+    procedure ReadFromFiler(reader: TGLVirtualReader); override;
     procedure AddToSpace(Space: PdxSpace); override;
     property BoxWidth: TdReal read FBoxWidth write SetBoxWidth;
     property BoxHeight: TdReal read FBoxHeight write SetBoxHeight;
@@ -104,7 +104,7 @@ end;
 // ------------------ TSCODEBase ------------------
 // ------------------
 
-procedure TSCODEBase.WriteToFiler(writer: TGVirtualWriter);
+procedure TSCODEBase.WriteToFiler(writer: TGLVirtualWriter);
 begin
   inherited WriteToFiler(writer);
   with writer do
@@ -113,7 +113,7 @@ begin
   end;
 end;
 
-procedure TSCODEBase.ReadFromFiler(reader: TGVirtualReader);
+procedure TSCODEBase.ReadFromFiler(reader: TGLVirtualReader);
 var
   archiveVersion: Integer;
 begin
@@ -169,7 +169,7 @@ begin
   AlignCollider;
 end;
 
-procedure TSCODESphere.WriteToFiler(writer: TGVirtualWriter);
+procedure TSCODESphere.WriteToFiler(writer: TGLVirtualWriter);
 begin
   inherited WriteToFiler(writer);
   with writer do
@@ -179,7 +179,7 @@ begin
   end;
 end;
 
-procedure TSCODESphere.ReadFromFiler(reader: TGVirtualReader);
+procedure TSCODESphere.ReadFromFiler(reader: TGLVirtualReader);
 var
   archiveVersion: Integer;
 begin
@@ -220,7 +220,7 @@ begin
   AlignCollider;
 end;
 
-procedure TSCODECCylinder.WriteToFiler(writer: TGVirtualWriter);
+procedure TSCODECCylinder.WriteToFiler(writer: TGLVirtualWriter);
 begin
   inherited WriteToFiler(writer);
   with writer do
@@ -231,7 +231,7 @@ begin
   end;
 end;
 
-procedure TSCODECCylinder.ReadFromFiler(reader: TGVirtualReader);
+procedure TSCODECCylinder.ReadFromFiler(reader: TGLVirtualReader);
 var
   archiveVersion: Integer;
 begin
@@ -286,7 +286,7 @@ begin
   AlignCollider;
 end;
 
-procedure TSCODEBox.WriteToFiler(writer: TGVirtualWriter);
+procedure TSCODEBox.WriteToFiler(writer: TGLVirtualWriter);
 begin
   inherited WriteToFiler(writer);
   with writer do
@@ -298,7 +298,7 @@ begin
   end;
 end;
 
-procedure TSCODEBox.ReadFromFiler(reader: TGVirtualReader);
+procedure TSCODEBox.ReadFromFiler(reader: TGLVirtualReader);
 var
   archiveVersion: Integer;
 begin

Source/GLS.ODEUtils.pas

@@ -490,7 +490,7 @@ var
   FaceExtractor: TGLFaceExtractor;
   VertexCount: integer;
   Vertex: TAffineVector;
-  OffsetList: TgIntegerList;
+  OffsetList: TGLIntegerList;
   Face: TGLFace;
   iMO: integer;
   TriMeshData: PdxTriMeshData;
@@ -499,7 +499,7 @@ begin
   FaceExtractor := TGLFaceExtractor.Create(GLBaseMesh);
 
   try
-    OffsetList := TgIntegerList.Create;
+    OffsetList := TGLIntegerList.Create;
 
     FaceExtractor.ProcessMesh;
 

Source/GLS.Objects.pas

@@ -75,13 +75,13 @@ type
   TGLDummyCube = class(TGLCameraInvariantObject)
   private
     FCubeSize: TGLFloat;
-    FEdgeColor: TGColor;
+    FEdgeColor: TGLColor;
     FVisibleAtRunTime, FAmalgamate: Boolean;
     FGroupList: TGLListHandle;
     FOnVisibilityDetermination: TGLVisibilityDeterminationEvent;
   protected
     procedure SetCubeSize(const val: TGLFloat); inline;
-    procedure SetEdgeColor(const val: TGColor); inline;
+    procedure SetEdgeColor(const val: TGLColor); inline;
     procedure SetVisibleAtRunTime(const val: Boolean); inline;
     procedure SetAmalgamate(const val: Boolean); inline;
   public
@@ -99,7 +99,7 @@ type
     function BarycenterAbsolutePosition: TGLVector; override;
   published
     property CubeSize: TGLFloat read FCubeSize write SetCubeSize;
-    property EdgeColor: TGColor read FEdgeColor write SetEdgeColor;
+    property EdgeColor: TGLColor read FEdgeColor write SetEdgeColor;
     (* If true the dummycube's edges will be visible at runtime.
       The default behaviour of the dummycube is to be visible at design-time
       only, and invisible at runtime. *)
@@ -322,13 +322,13 @@ type
   // Available spline modes for a TLine.
   TGLLineSplineMode = (lsmLines, lsmCubicSpline, lsmBezierSpline, lsmNURBSCurve,
     lsmSegments, lsmLoop);
-  // Specialized Node for use in a TGLLines objects. Adds a Color property (TGColor) }
+  // Specialized Node for use in a TGLLines objects. Adds a Color property (TGLColor) }
 
   TGLLinesNode = class(TGLNode)
   private
-    FColor: TGColor;
+    FColor: TGLColor;
   protected
-    procedure SetColor(const val: TGColor);
+    procedure SetColor(const val: TGLColor);
     procedure OnColorChange(Sender: TObject);
     function StoreColor: Boolean;
   public
@@ -339,7 +339,7 @@ type
     (* The node color.
       Can also defined the line color (interpolated between nodes) if
       loUseNodeColorForLines is set (in TGLLines). *)
-    property Color: TGColor read FColor write SetColor stored StoreColor;
+    property Color: TGLColor read FColor write SetColor stored StoreColor;
   end;
 
   (* Specialized collection for Nodes in a TGLLines objects. Stores TGLLinesNode items *)
@@ -352,12 +352,12 @@ type
   (* Base class for line objects. Introduces line style properties (width, color...) *)
   TGLLineBase = class(TGLImmaterialSceneObject)
   private
-    FLineColor: TGColor;
+    FLineColor: TGLColor;
     FLinePattern: TGLushort;
     FLineWidth: Single;
     FAntiAliased: Boolean;
   protected
-    procedure SetLineColor(const Value: TGColor);
+    procedure SetLineColor(const Value: TGLColor);
     procedure SetLinePattern(const Value: TGLushort);
     procedure SetLineWidth(const val: Single);
     function StoreLineWidth: Boolean; inline;
@@ -378,7 +378,7 @@ type
     property AntiAliased: Boolean read FAntiAliased write SetAntiAliased
       default False;
     // Default color of the lines.
-    property LineColor: TGColor read FLineColor write SetLineColor;
+    property LineColor: TGLColor read FLineColor write SetLineColor;
     (* Bitwise line pattern.
       For instance $FFFF (65535) is a white line (stipple disabled), $0000
       is a black line, $CCCC is the stipple used in axes and dummycube, etc. *)
@@ -395,18 +395,18 @@ type
   private
     FNodes: TGLLinesNodes;
     FNodesAspect: TGLLineNodesAspect;
-    FNodeColor: TGColor;
+    FNodeColor: TGLColor;
     FNodeSize: Single;
-    FOldNodeColor: TGColorVector;
+    FOldNodeColor: TGLColorVector;
   protected
     procedure SetNodesAspect(const Value: TGLLineNodesAspect);
-    procedure SetNodeColor(const Value: TGColor);
+    procedure SetNodeColor(const Value: TGLColor);
     procedure OnNodeColorChanged(Sender: TObject);
     procedure SetNodes(const aNodes: TGLLinesNodes);
     procedure SetNodeSize(const val: Single);
     function StoreNodeSize: Boolean;
     procedure DrawNode(var rci: TGLRenderContextInfo; X, Y, Z: Single;
-      Color: TGColor);
+      Color: TGLColor);
   public
     constructor Create(AOwner: TComponent); override;
     destructor Destroy; override;
@@ -418,7 +418,7 @@ type
     procedure AddNode(const Value: TAffineVector); overload;
   published
     // Default color for nodes. lnaInvisible and lnaAxes ignore this setting
-    property NodeColor: TGColor read FNodeColor write SetNodeColor;
+    property NodeColor: TGLColor read FNodeColor write SetNodeColor;
     // The nodes list.
     property Nodes: TGLLinesNodes read FNodes write SetNodes;
     (* Default aspect of line nodes.
@@ -447,7 +447,7 @@ type
     FOptions: TGLLinesOptions;
     FNURBSOrder: Integer;
     FNURBSTolerance: Single;
-    FNURBSKnots: TGSingleList;
+    FNURBSKnots: TGLSingleList;
   protected
     procedure SetSplineMode(const val: TGLLineSplineMode);
     procedure SetDivision(const Value: Integer);
@@ -459,7 +459,7 @@ type
     destructor Destroy; override;
     procedure Assign(Source: TPersistent); override;
     procedure BuildList(var rci: TGLRenderContextInfo); override;
-    property NURBSKnots: TGSingleList read FNURBSKnots;
+    property NURBSKnots: TGLSingleList read FNURBSKnots;
     property NURBSOrder: Integer read FNURBSOrder write SetNURBSOrder;
     property NURBSTolerance: Single read FNURBSTolerance
       write SetNURBSTolerance;
@@ -682,7 +682,7 @@ type
 
 // Issues for a unit-size cube stippled wireframe
 procedure CubeWireframeBuildList(var rci: TGLRenderContextInfo; Size: TGLFloat;
-  Stipple: Boolean; const Color: TGColorVector);
+  Stipple: Boolean; const Color: TGLColorVector);
 
 const
   TangentAttributeName: PAnsiChar = 'Tangent';
@@ -693,7 +693,7 @@ implementation
 // -------------------------------------------------------------
 
 procedure CubeWireframeBuildList(var rci: TGLRenderContextInfo; Size: TGLFloat;
-  Stipple: Boolean; const Color: TGColorVector);
+  Stipple: Boolean; const Color: TGLColorVector);
 var
   mi, ma: Single;
 begin
@@ -753,7 +753,7 @@ begin
   inherited;
   ObjectStyle := ObjectStyle + [osDirectDraw];
   FCubeSize := 1;
-  FEdgeColor := TGColor.Create(Self);
+  FEdgeColor := TGLColor.Create(Self);
   FEdgeColor.Initialize(clrWhite);
   FGroupList := TGLListHandle.Create;
   CamInvarianceMode := cimNone;
@@ -859,7 +859,7 @@ begin
   end;
 end;
 
-procedure TGLDummyCube.SetEdgeColor(const val: TGColor);
+procedure TGLDummyCube.SetEdgeColor(const val: TGLColor);
 begin
   if val <> FEdgeColor then
   begin
@@ -1763,7 +1763,7 @@ end;
 constructor TGLLineBase.Create(AOwner: TComponent);
 begin
   inherited Create(AOwner);
-  FLineColor := TGColor.Create(Self);
+  FLineColor := TGLColor.Create(Self);
   FLineColor.Initialize(clrWhite);
   FLinePattern := $FFFF;
   FAntiAliased := False;
@@ -1783,7 +1783,7 @@ begin
   inherited;
 end;
 
-procedure TGLLineBase.SetLineColor(const Value: TGColor);
+procedure TGLLineBase.SetLineColor(const Value: TGLColor);
 begin
   FLineColor.Color := Value.Color;
   StructureChanged;
@@ -1880,7 +1880,7 @@ end;
 constructor TGLLinesNode.Create(Collection: TCollection);
 begin
   inherited Create(Collection);
-  FColor := TGColor.Create(Self);
+  FColor := TGLColor.Create(Self);
   FColor.Initialize((TGLLinesNodes(Collection).GetOwner as TGLLines)
     .NodeColor.Color);
   FColor.OnNotifyChange := OnColorChange;
@@ -1899,7 +1899,7 @@ begin
   inherited;
 end;
 
-procedure TGLLinesNode.SetColor(const val: TGColor);
+procedure TGLLinesNode.SetColor(const val: TGLColor);
 begin
   FColor.Assign(val);
 end;
@@ -1938,7 +1938,7 @@ constructor TGLNodedLines.Create(AOwner: TComponent);
 begin
   inherited Create(AOwner);
   FNodes := TGLLinesNodes.Create(Self);
-  FNodeColor := TGColor.Create(Self);
+  FNodeColor := TGLColor.Create(Self);
   FNodeColor.Initialize(clrBlue);
   FNodeColor.OnNotifyChange := OnNodeColorChanged;
   FOldNodeColor := clrBlue;
@@ -1962,7 +1962,7 @@ begin
   end;
 end;
 
-procedure TGLNodedLines.SetNodeColor(const Value: TGColor);
+procedure TGLNodedLines.SetNodeColor(const Value: TGLColor);
 begin
   FNodeColor.Color := Value.Color;
   StructureChanged;
@@ -2013,7 +2013,7 @@ begin
 end;
 
 procedure TGLNodedLines.DrawNode(var rci: TGLRenderContextInfo; X, Y, Z: Single;
-  Color: TGColor);
+  Color: TGLColor);
 begin
   gl.PushMatrix;
   gl.Translatef(X, Y, Z);
@@ -2086,7 +2086,7 @@ begin
   inherited Create(AOwner);
   FDivision := 10;
   FSplineMode := lsmLines;
-  FNURBSKnots := TGSingleList.Create;
+  FNURBSKnots := TGLSingleList.Create;
   FNURBSOrder := 0;
   FNURBSTolerance := 50;
 end;

Source/GLS.Octree.pas

@@ -1477,7 +1477,7 @@ var
 var
   I, K: Integer;
   P: PGLOctreeNode;
-  TriangleIndices: TgIntegerList;
+  TriangleIndices: TGLIntegerList;
 
 begin
   // Calc AABBs
@@ -1488,7 +1488,7 @@ begin
     HandleNode(RootNode);
 
   Result := TGLAffineVectorList.Create;
-  TriangleIndices := TgIntegerList.Create;
+  TriangleIndices := TGLIntegerList.Create;
   try
     // fill the triangles from all nodes in the resultarray to AL
     for I := 0 to High(ResultArray) do
@@ -1542,7 +1542,7 @@ var
 var
   I, K: Integer;
   P: PGLOctreeNode;
-  TriangleIndices: TgIntegerList;
+  TriangleIndices: TGLIntegerList;
 begin
   // Calc AABBs
   AABB1 := ObjAABB;
@@ -1555,7 +1555,7 @@ begin
     HandleNode(RootNode);
 
   Result := TGLAffineVectorList.Create;
-  TriangleIndices := TgIntegerList.Create;
+  TriangleIndices := TGLIntegerList.Create;
   try
     // fill the triangles from all nodes in the resultarray to AL
     for I := 0 to High(ResultArray) do

Source/GLS.ParametricSurfaces.pas

@@ -67,7 +67,7 @@ type
     FWeightedControlPoints: TGLAffineVectorList;
     FKnotsU,
     FKnotsV,
-    FWeights: TGSingleList;
+    FWeights: TGLSingleList;
     FOrderU,
     FOrderV,
     FCountU,
@@ -78,16 +78,16 @@ type
     FRenderer: TParametricSurfaceRenderer;
     FBasis: TParametricSurfaceBasis;
     procedure SetControlPoints(Value: TGLAffineVectorList);
-    procedure SetKnotsU(Value: TGSingleList);
-    procedure SetKnotsV(Value: TGSingleList);
-    procedure SetWeights(Value: TGSingleList);
+    procedure SetKnotsU(Value: TGLSingleList);
+    procedure SetKnotsV(Value: TGLSingleList);
+    procedure SetWeights(Value: TGLSingleList);
     procedure SetRenderer(Value: TParametricSurfaceRenderer);
     procedure SetBasis(Value: TParametricSurfaceBasis);
   public
     constructor Create; override;
     destructor Destroy; override;
-    procedure WriteToFiler(writer: TGVirtualWriter); override;
-    procedure ReadFromFiler(reader: TGVirtualReader); override;
+    procedure WriteToFiler(writer: TGLVirtualWriter); override;
+    procedure ReadFromFiler(reader: TGLVirtualReader); override;
     procedure BuildList(var mrci: TGLRenderContextInfo); override;
     procedure Prepare; override;
     procedure Clear; override;
@@ -102,10 +102,10 @@ type
     (* KnotsU and KnotsV are the knot vectors in the U and V direction. Knots
        define the continuity of curves and how control points influence the
        parametric values to build the surface. *)
-    property KnotsU: TGSingleList read FKnotsU write SetKnotsU;
-    property KnotsV: TGSingleList read FKnotsV write SetKnotsV;
+    property KnotsU: TGLSingleList read FKnotsU write SetKnotsU;
+    property KnotsV: TGLSingleList read FKnotsV write SetKnotsV;
     // Weights define how much a control point effects the surface.
-    property Weights: TGSingleList read FWeights write SetWeights;
+    property Weights: TGLSingleList read FWeights write SetWeights;
     // OrderU and OrderV defines the curve order in the U and V direction
     property OrderU: Integer read FOrderU write FOrderU;
     property OrderV: Integer read FOrderV write FOrderV;
@@ -143,20 +143,20 @@ type
   private
     FCountU, FCountV: Integer;
     FControlPointIndices,
-    FTexCoordIndices: TgIntegerList;
+    FTexCoordIndices: TGLIntegerList;
     FResolution: Integer;
     FMinU, FMaxU,
     FMinV, FMaxV: Single;
     FTempControlPoints,
     FTempTexCoords: TGLAffineVectorList;
   protected
-    procedure SetControlPointIndices(const Value: TgIntegerList);
-    procedure SetTexCoordIndices(const Value: TgIntegerList);
+    procedure SetControlPointIndices(const Value: TGLIntegerList);
+    procedure SetTexCoordIndices(const Value: TGLIntegerList);
   public
     constructor Create; override;
     destructor Destroy; override;
-    procedure WriteToFiler(writer: TGVirtualWriter); override;
-    procedure ReadFromFiler(reader: TGVirtualReader); override;
+    procedure WriteToFiler(writer: TGLVirtualWriter); override;
+    procedure ReadFromFiler(reader: TGLVirtualReader); override;
     procedure BuildList(var mrci: TGLRenderContextInfo); override;
     procedure Prepare; override;
     property CountU: Integer read FCountU write FCountU;
@@ -166,8 +166,8 @@ type
     property MaxU: Single read FMaxU write FMaxU;
     property MinV: Single read FMinV write FMinV;
     property MaxV: Single read FMaxV write FMaxV;
-    property ControlPointIndices: TgIntegerList read FControlPointIndices write SetControlPointIndices;
-    property TexCoordIndices: TgIntegerList read FTexCoordIndices write SetTexCoordIndices;
+    property ControlPointIndices: TGLIntegerList read FControlPointIndices write SetControlPointIndices;
+    property TexCoordIndices: TGLIntegerList read FTexCoordIndices write SetTexCoordIndices;
   end;
 
 // ----------------------------------------------------------------------
@@ -183,9 +183,9 @@ begin
   inherited;
   FControlPoints := TGLAffineVectorList.Create;
   FWeightedControlPoints := TGLAffineVectorList.Create;
-  FKnotsU := TGSingleList.Create;
-  FKnotsV := TGSingleList.Create;
-  FWeights := TGSingleList.Create;
+  FKnotsU := TGLSingleList.Create;
+  FKnotsV := TGLSingleList.Create;
+  FWeights := TGLSingleList.Create;
   Resolution := 20;
 end;
 
@@ -199,7 +199,7 @@ begin
   inherited;
 end;
 
-procedure TMOParametricSurface.WriteToFiler(writer: TGVirtualWriter);
+procedure TMOParametricSurface.WriteToFiler(writer: TGLVirtualWriter);
 begin
   inherited WriteToFiler(writer);
   with writer do
@@ -221,7 +221,7 @@ begin
   end;
 end;
 
-procedure TMOParametricSurface.ReadFromFiler(reader: TGVirtualReader);
+procedure TMOParametricSurface.ReadFromFiler(reader: TGLVirtualReader);
 var
   archiveVersion: Integer;
 begin
@@ -396,17 +396,17 @@ begin
   FControlPoints.Assign(Value);
 end;
 
-procedure TMOParametricSurface.SetKnotsU(Value: TGSingleList);
+procedure TMOParametricSurface.SetKnotsU(Value: TGLSingleList);
 begin
   FKnotsU.Assign(Value);
 end;
 
-procedure TMOParametricSurface.SetKnotsV(Value: TGSingleList);
+procedure TMOParametricSurface.SetKnotsV(Value: TGLSingleList);
 begin
   FKnotsV.Assign(Value);
 end;
 
-procedure TMOParametricSurface.SetWeights(Value: TGSingleList);
+procedure TMOParametricSurface.SetWeights(Value: TGLSingleList);
 begin
   FWeights.Assign(Value);
 end;
@@ -437,8 +437,8 @@ end;
 constructor TFGBezierSurface.Create;
 begin
   inherited;
-  FControlPointIndices := TgIntegerList.Create;
-  FTexCoordIndices := TgIntegerList.Create;
+  FControlPointIndices := TGLIntegerList.Create;
+  FTexCoordIndices := TGLIntegerList.Create;
   FTempControlPoints := TGLAffineVectorList.Create;
   FTempTexCoords := TGLAffineVectorList.Create;
 
@@ -461,7 +461,7 @@ begin
   inherited;
 end;
 
-procedure TFGBezierSurface.WriteToFiler(writer: TGVirtualWriter);
+procedure TFGBezierSurface.WriteToFiler(writer: TGLVirtualWriter);
 begin
   inherited WriteToFiler(writer);
   with writer do
@@ -479,7 +479,7 @@ begin
   end;
 end;
 
-procedure TFGBezierSurface.ReadFromFiler(reader: TGVirtualReader);
+procedure TFGBezierSurface.ReadFromFiler(reader: TGLVirtualReader);
 var
   archiveVersion: Integer;
 begin
@@ -536,12 +536,12 @@ begin
   mrci.GLStates.PopAttrib;
 end;
 
-procedure TFGBezierSurface.SetControlPointIndices(const Value: TgIntegerList);
+procedure TFGBezierSurface.SetControlPointIndices(const Value: TGLIntegerList);
 begin
   FControlPointIndices.Assign(Value);
 end;
 
-procedure TFGBezierSurface.SetTexCoordIndices(const Value: TgIntegerList);
+procedure TFGBezierSurface.SetTexCoordIndices(const Value: TGLIntegerList);
 begin
   FTexCoordIndices.Assign(Value);
 end;

Source/GLS.ParticleFX.pas

@@ -71,8 +71,8 @@ type
   public
     constructor Create; override;
     destructor Destroy; override;
-    procedure WriteToFiler(writer: TGVirtualWriter); override;
-    procedure ReadFromFiler(reader: TGVirtualReader); override;
+    procedure WriteToFiler(writer: TGLVirtualWriter); override;
+    procedure ReadFromFiler(reader: TGLVirtualReader); override;
     property Manager: TGLParticleFXManager read FManager write FManager;
     // Particle's ID, given at birth. ID is a value unique per manager.
     property ID: Integer read FID;
@@ -106,7 +106,7 @@ type
   TGLParticleList = class(TGLPersistentObject)
   private
     FOwner: TGLParticleFXManager; // NOT persistent
-    FItemList: TgPersistentObjectList;
+    FItemList: TGLPersistentObjectList;
     FDirectList: PGLParticleArray; // NOT persistent
   protected
     function GetItems(index: Integer): TGLParticle;
@@ -115,8 +115,8 @@ type
   public
     constructor Create; override;
     destructor Destroy; override;
-    procedure WriteToFiler(writer: TGVirtualWriter); override;
-    procedure ReadFromFiler(reader: TGVirtualReader); override;
+    procedure WriteToFiler(writer: TGLVirtualWriter); override;
+    procedure ReadFromFiler(reader: TGLVirtualReader); override;
     // Refers owner manager
     property Owner: TGLParticleFXManager read FOwner write FOwner;
     property Items[index: Integer]: TGLParticle read GetItems write SetItems; default;
@@ -430,8 +430,8 @@ type
 
   TPFXLifeColor = class(TCollectionItem)
   private
-    FColorInner: TGColor;
-    FColorOuter: TGColor;
+    FColorInner: TGLColor;
+    FColorOuter: TGLColor;
     FLifeTime, FInvLifeTime: Single;
     FIntervalRatio: Single;
     FSizeScale: Single;
@@ -440,8 +440,8 @@ type
     FRotateAngle: Single;
   protected
     function GetDisplayName: string; override;
-    procedure SetColorInner(const val: TGColor);
-    procedure SetColorOuter(const val: TGColor);
+    procedure SetColorInner(const val: TGLColor);
+    procedure SetColorOuter(const val: TGLColor);
     procedure SetLifeTime(const val: Single);
     procedure SetSizeScale(const val: Single);
     procedure SetRotateAngle(const Value: Single); // indirectly persistent
@@ -454,8 +454,8 @@ type
     // Stores 1/(LifeTime[Next]-LifeTime[Self])
     property InvIntervalRatio: Single read FIntervalRatio;
   published
-    property ColorInner: TGColor read FColorInner write SetColorInner;
-    property ColorOuter: TGColor read FColorOuter write SetColorOuter;
+    property ColorInner: TGLColor read FColorInner write SetColorInner;
+    property ColorOuter: TGLColor read FColorOuter write SetColorOuter;
     property LifeTime: Single read FLifeTime write SetLifeTime;
     property SizeScale: Single read FSizeScale write SetSizeScale;
     property RotateAngle: Single read FRotateAngle write SetRotateAngle;
@@ -484,19 +484,19 @@ type
     FLifeColorsLookup: TList;
     FLifeRotations: Boolean;
     FLifeScaling: Boolean;
-    FColorInner: TGColor;
-    FColorOuter: TGColor;
+    FColorInner: TGLColor;
+    FColorOuter: TGLColor;
     FParticleSize: Single;
   protected
     procedure SetLifeColors(const val: TPFXLifeColors);
-    procedure SetColorInner(const val: TGColor);
-    procedure SetColorOuter(const val: TGColor);
+    procedure SetColorInner(const val: TGLColor);
+    procedure SetColorOuter(const val: TGLColor);
     procedure InitializeRendering(var rci: TGLRenderContextInfo); override;
     procedure FinalizeRendering(var rci: TGLRenderContextInfo); override;
     function MaxParticleAge: Single; override;
-    procedure ComputeColors(var lifeTime: Single; var inner, outer: TGColorVector);
-    procedure ComputeInnerColor(var lifeTime: Single; var inner: TGColorVector);
-    procedure ComputeOuterColor(var lifeTime: Single; var outer: TGColorVector);
+    procedure ComputeColors(var lifeTime: Single; var inner, outer: TGLColorVector);
+    procedure ComputeInnerColor(var lifeTime: Single; var inner: TGLColorVector);
+    procedure ComputeOuterColor(var lifeTime: Single; var outer: TGLColorVector);
     function ComputeSizeScale(var lifeTime: Single; var sizeScale: Single): Boolean;
     function ComputeRotateAngle(var lifeTime, rotateAngle: Single): Boolean;
     procedure RotateVertexBuf(buf: TGLAffineVectorList; lifeTime: Single;
@@ -505,8 +505,8 @@ type
     constructor Create(aOwner: TComponent); override;
     destructor Destroy; override;
     property ParticleSize: Single read FParticleSize write FParticleSize;
-    property ColorInner: TGColor read FColorInner write SetColorInner;
-    property ColorOuter: TGColor read FColorOuter write SetColorOuter;
+    property ColorInner: TGLColor read FColorInner write SetColorInner;
+    property ColorOuter: TGLColor read FColorOuter write SetColorOuter;
     property LifeColors: TPFXLifeColors read FLifeColors write SetLifeColors;
   published
     property BlendingMode default bmAdditive;
@@ -814,7 +814,7 @@ begin
     FVelocity.V[Index] := aValue;
 end;
 
-procedure TGLParticle.WriteToFiler(writer: TGVirtualWriter);
+procedure TGLParticle.WriteToFiler(writer: TGLVirtualWriter);
 begin
   inherited WriteToFiler(writer);
   with writer do
@@ -827,7 +827,7 @@ begin
   end;
 end;
 
-procedure TGLParticle.ReadFromFiler(reader: TGVirtualReader);
+procedure TGLParticle.ReadFromFiler(reader: TGLVirtualReader);
 var
   archiveVersion: integer;
 begin
@@ -852,7 +852,7 @@ end;
 constructor TGLParticleList.Create;
 begin
   inherited Create;
-  FItemList := TgPersistentObjectList.Create;
+  FItemList := TGLPersistentObjectList.Create;
   FitemList.GrowthDelta := 64;
   FDirectList := nil;
 end;
@@ -863,7 +863,7 @@ begin
   inherited Destroy;
 end;
 
-procedure TGLParticleList.WriteToFiler(writer: TGVirtualWriter);
+procedure TGLParticleList.WriteToFiler(writer: TGLVirtualWriter);
 begin
   inherited WriteToFiler(writer);
   with writer do
@@ -873,7 +873,7 @@ begin
   end;
 end;
 
-procedure TGLParticleList.ReadFromFiler(reader: TGVirtualReader);
+procedure TGLParticleList.ReadFromFiler(reader: TGLVirtualReader);
 var
   archiveVersion: integer;
 begin
@@ -1737,8 +1737,8 @@ end;
 constructor TPFXLifeColor.Create(Collection: TCollection);
 begin
   inherited Create(Collection);
-  FColorInner := TGColor.CreateInitialized(Self, NullHmgVector);
-  FColorOuter := TGColor.CreateInitialized(Self, NullHmgVector);
+  FColorInner := TGLColor.CreateInitialized(Self, NullHmgVector);
+  FColorOuter := TGLColor.CreateInitialized(Self, NullHmgVector);
   FLifeTime := 1;
   FInvLifeTime := 1;
   FSizeScale := 1;
@@ -1773,12 +1773,12 @@ begin
       ColorOuter.Red, ColorOuter.Green, ColorOuter.Blue, ColorOuter.Alpha]);
 end;
 
-procedure TPFXLifeColor.SetColorInner(const val: TGColor);
+procedure TPFXLifeColor.SetColorInner(const val: TGLColor);
 begin
   FColorInner.Assign(val);
 end;
 
-procedure TPFXLifeColor.SetColorOuter(const val: TGColor);
+procedure TPFXLifeColor.SetColorOuter(const val: TGLColor);
 begin
   FColorOuter.Assign(val);
 end;
@@ -1995,8 +1995,8 @@ constructor TGLLifeColoredPFXManager.Create(aOwner: TComponent);
 begin
   inherited;
   FLifeColors := TPFXLifeColors.Create(Self);
-  FColorInner := TGColor.CreateInitialized(Self, clrYellow);
-  FColorOuter := TGColor.CreateInitialized(Self, NullHmgVector);
+  FColorInner := TGLColor.CreateInitialized(Self, clrYellow);
+  FColorOuter := TGLColor.CreateInitialized(Self, NullHmgVector);
   with FLifeColors.Add do
   begin
     LifeTime := 3;
@@ -2012,12 +2012,12 @@ begin
   inherited Destroy;
 end;
 
-procedure TGLLifeColoredPFXManager.SetColorInner(const val: TGColor);
+procedure TGLLifeColoredPFXManager.SetColorInner(const val: TGLColor);
 begin
   FColorInner.Assign(val);
 end;
 
-procedure TGLLifeColoredPFXManager.SetColorOuter(const val: TGColor);
+procedure TGLLifeColoredPFXManager.SetColorOuter(const val: TGLColor);
 begin
   FColorOuter.Assign(val);
 end;
@@ -2051,7 +2051,7 @@ begin
   Result := LifeColors.MaxLifeTime;
 end;
 
-procedure TGLLifeColoredPFXManager.ComputeColors(var lifeTime: Single; var inner, outer: TGColorVector);
+procedure TGLLifeColoredPFXManager.ComputeColors(var lifeTime: Single; var inner, outer: TGLColorVector);
 var
   i, k, n: Integer;
   f: Single;
@@ -2097,7 +2097,7 @@ begin
   end;
 end;
 
-procedure TGLLifeColoredPFXManager.ComputeInnerColor(var lifeTime: Single; var inner: TGColorVector);
+procedure TGLLifeColoredPFXManager.ComputeInnerColor(var lifeTime: Single; var inner: TGLColorVector);
 var
   i, k, n: Integer;
   f: Single;
@@ -2140,7 +2140,7 @@ begin
   end;
 end;
 
-procedure TGLLifeColoredPFXManager.ComputeOuterColor(var lifeTime: Single; var outer: TGColorVector);
+procedure TGLLifeColoredPFXManager.ComputeOuterColor(var lifeTime: Single; var outer: TGLColorVector);
 var
   i, k, n: Integer;
   f: Single;
@@ -2448,7 +2448,7 @@ procedure TGLPolygonPFXManager.RenderParticle(var rci: TGLRenderContextInfo; aPa
 var
   i: Integer;
   lifeTime, sizeScale: Single;
-  inner, outer: TGColorVector;
+  inner, outer: TGLColorVector;
   pos: TAffineVector;
   vertexList: PAffineVectorArray;
 begin
@@ -2683,7 +2683,7 @@ const
     ((S: 0.5; T: 0.5), (S: 0.0; T: 0.5), (S: 0.0; T: 0.0), (S: 0.5; T: 0.0)));
 var
   lifeTime, sizeScale: Single;
-  inner, outer: TGColorVector;
+  inner, outer: TGLColorVector;
   pos: TAffineVector;
   vertexList: PAffineVectorArray;
   i: Integer;

Source/GLS.Particles.pas

@@ -53,7 +53,7 @@ type
   TGLParticles = class(TGLImmaterialSceneObject)
   private
     FCubeSize: TGLFloat;
-    FEdgeColor: TGColor;
+    FEdgeColor: TGLColor;
     FVisibleAtRunTime: Boolean;
     particlePool: TList;
     FParticlePoolSize: Integer;
@@ -64,7 +64,7 @@ type
     FOnBeforeRenderParticles, FOnAfterRenderParticles: TGLDirectRenderEvent;
   protected
     procedure SetCubeSize(const val: TGLFloat);
-    procedure SetEdgeColor(const val: TGColor);
+    procedure SetEdgeColor(const val: TGLColor);
     procedure SetVisibleAtRunTime(const val: Boolean);
     procedure SetParticlePoolSize(val: Integer);
     procedure ClearParticlePool;
@@ -87,7 +87,7 @@ type
     procedure KillParticles;
   published
     property CubeSize: TGLFloat read FCubeSize write SetCubeSize;
-    property EdgeColor: TGColor read FEdgeColor write SetEdgeColor;
+    property EdgeColor: TGLColor read FEdgeColor write SetEdgeColor;
     property VisibleAtRunTime: Boolean read FVisibleAtRunTime write SetVisibleAtRunTime default False;
     (* Size of the particle pool (for storing killed particles).
        Default size is zero, meaning the particlePool is disabled. *)
@@ -123,7 +123,7 @@ begin
   inherited;
   ObjectStyle := ObjectStyle + [osDirectDraw, osNoVisibilityCulling];
   FCubeSize := 1;
-  FEdgeColor := TGColor.Create(Self);
+  FEdgeColor := TGLColor.Create(Self);
   FEdgeColor.Initialize(clrWhite);
   particlePool := TList.Create;
 end;
@@ -267,7 +267,7 @@ begin
 end;
 
 
-procedure TGLParticles.SetEdgeColor(const val: TGColor);
+procedure TGLParticles.SetEdgeColor(const val: TGLColor);
 begin
   if val <> FEdgeColor then
   begin

Source/GLS.ROAMPatch.pas

@@ -66,9 +66,9 @@ type
     procedure SetHeightData(Val: TGLHeightData);
     procedure SetOcclusionSkip(Val: Integer);
     procedure RenderROAM(Vertices: TGLAffineVectorList;
-      VertexIndices: TgIntegerList; TexCoords: TGTexPointList);
+      VertexIndices: TGLIntegerList; TexCoords: TGLTexPointList);
     procedure RenderAsStrips(Vertices: TGLAffineVectorList;
-      VertexIndices: TgIntegerList; TexCoords: TGTexPointList);
+      VertexIndices: TGLIntegerList; TexCoords: TGLTexPointList);
   public
     constructor Create;
     destructor Destroy; override;
@@ -89,18 +89,18 @@ type
       (additions without capacity check). High-resolution renders use
       display lists, and are assumed to be made together. *)
     procedure RenderHighRes(Vertices: TGLAffineVectorList;
-      VertexIndices: TgIntegerList; TexCoords: TGTexPointList; ForceROAM: Boolean);
+      VertexIndices: TGLIntegerList; TexCoords: TGLTexPointList; ForceROAM: Boolean);
     (*  Render the patch by accumulating triangles.
       The lists are assumed to have enough capacity to allow AddNC calls
       (additions without capacity check).
       Once at least autoFlushVertexCount vertices have been accumulated,
       perform a FlushAccum *)
     procedure RenderAccum(Vertices: TGLAffineVectorList;
-      VertexIndices: TgIntegerList; TexCoords: TGTexPointList;
+      VertexIndices: TGLIntegerList; TexCoords: TGLTexPointList;
       AutoFlushVertexCount: Integer);
     // Render all vertices accumulated in the arrays and set their count back to zero.
     class procedure FlushAccum(Vertices: TGLAffineVectorList;
-      VertexIndices: TgIntegerList; TexCoords: TGTexPointList);
+      VertexIndices: TGLIntegerList; TexCoords: TGLTexPointList);
     property HeightData: TGLHeightData read FHeightData write SetHeightData;
     property VertexScale: TAffineVector read FVertexScale write FVertexScale;
     property VertexOffset: TAffineVector read FVertexOffset write FVertexOffset;
@@ -129,7 +129,7 @@ type
 procedure SetROAMTrianglesCapacity(nb: Integer);
 function GetROAMTrianglesCapacity: Integer;
 //  Draw contours on rendering terrain patches
-procedure DrawContours(Vertices: TGLAffineVectorList; VertexIndices: TgIntegerList;
+procedure DrawContours(Vertices: TGLAffineVectorList; VertexIndices: TGLIntegerList;
   ContourInterval: Integer; ContourWidth: Integer; DecVal: Integer);
 
 // ------------------------------------------------------------------
@@ -147,7 +147,7 @@ var
   RenderRaster: PSmallIntRaster;
   RenderIndices: PIntegerArray;
   RenderVertices: TGLAffineVectorList;
-  RenderTexCoords: TGTexPointList;
+  RenderTexCoords: TGLTexPointList;
 
   TessMaxVariance: Cardinal;
   TessMaxDepth: Cardinal;
@@ -174,7 +174,7 @@ begin
   Result := vTriangleNodesCapacity;
 end;
 
-procedure DrawContours(Vertices: TGLAffineVectorList; VertexIndices: TgIntegerList;
+procedure DrawContours(Vertices: TGLAffineVectorList; VertexIndices: TGLIntegerList;
   ContourInterval: Integer; ContourWidth: Integer; DecVal: Integer);
 var
   i: Integer;
@@ -679,7 +679,7 @@ begin
 end;
 
 procedure TGLROAMPatch.RenderHighRes(Vertices: TGLAffineVectorList;
-  VertexIndices: TgIntegerList; TexCoords: TGTexPointList; ForceROAM: Boolean);
+  VertexIndices: TGLIntegerList; TexCoords: TGLTexPointList; ForceROAM: Boolean);
 
 var
   Primitive: Cardinal;
@@ -726,7 +726,7 @@ begin
 end;
 
 procedure TGLROAMPatch.RenderAccum(Vertices: TGLAffineVectorList;
-  VertexIndices: TgIntegerList; TexCoords: TGTexPointList;
+  VertexIndices: TGLIntegerList; TexCoords: TGLTexPointList;
   AutoFlushVertexCount: Integer);
 var
   OcclusionPassed: Boolean;
@@ -777,7 +777,7 @@ begin
 end;
 
 class procedure TGLROAMPatch.FlushAccum(Vertices: TGLAffineVectorList;
-  VertexIndices: TgIntegerList; TexCoords: TGTexPointList);
+  VertexIndices: TGLIntegerList; TexCoords: TGLTexPointList);
 begin
   if VertexIndices.Count = 0 then
     Exit;
@@ -841,7 +841,7 @@ begin
 end;
 
 procedure TGLROAMPatch.RenderROAM(Vertices: TGLAffineVectorList;
-  VertexIndices: TgIntegerList; TexCoords: TGTexPointList);
+  VertexIndices: TGLIntegerList; TexCoords: TGLTexPointList);
 
   procedure ROAMRenderPoint(var p: TROAMRenderPoint; anX, anY: Integer);
   begin
@@ -875,7 +875,7 @@ begin
 end;
 
 procedure TGLROAMPatch.RenderAsStrips(Vertices: TGLAffineVectorList;
-  VertexIndices: TgIntegerList; TexCoords: TGTexPointList);
+  VertexIndices: TGLIntegerList; TexCoords: TGLTexPointList);
 
 var
   X, Y, baseTop, rowLength: Integer;

Source/GLS.Ragdoll.pas

@@ -24,7 +24,7 @@ type
   TGLRagdolJoint = class
   end;
 
-  TGLRagdolBoneList = class(TgPersistentObjectList)
+  TGLRagdolBoneList = class(TGLPersistentObjectList)
   private
     FRagdoll: TGLRagdoll;
   protected
@@ -32,8 +32,8 @@ type
   public
     constructor Create(Ragdoll: TGLRagdoll); reintroduce;
     destructor Destroy; override;
-    procedure WriteToFiler(writer: TGVirtualWriter); override;
-    procedure ReadFromFiler(reader: TGVirtualReader); override;
+    procedure WriteToFiler(writer: TGLVirtualWriter); override;
+    procedure ReadFromFiler(reader: TGLVirtualReader); override;
     property Ragdoll: TGLRagdoll read FRagdoll;
     property Items[Index: Integer]: TGLRagdolBone read GetRagdollBone; default;
   end;
@@ -74,8 +74,8 @@ type
     constructor CreateOwned(aOwner: TGLRagdolBoneList);
     constructor Create(Ragdoll: TGLRagdoll);
     destructor Destroy; override;
-    procedure WriteToFiler(writer: TGVirtualWriter); override;
-    procedure ReadFromFiler(reader: TGVirtualReader); override;
+    procedure WriteToFiler(writer: TGLVirtualWriter); override;
+    procedure ReadFromFiler(reader: TGLVirtualReader); override;
     property Owner: TGLRagdolBoneList read FOwner;
     property Name: String read FName write FName;
     property BoneID: Integer read FBoneID write FBoneID;
@@ -97,8 +97,8 @@ type
   public
     constructor Create(aOwner: TGLBaseMesh); reintroduce;
     destructor Destroy; override;
-    procedure WriteToFiler(writer: TGVirtualWriter); override;
-    procedure ReadFromFiler(reader: TGVirtualReader); override;
+    procedure WriteToFiler(writer: TGLVirtualWriter); override;
+    procedure ReadFromFiler(reader: TGLVirtualReader); override;
     // Must be set before build the ragdoll
     procedure SetRootBone(RootBone: TGLRagdolBone);
     // Create the bounding box and setup the ragdoll do be started later
@@ -140,13 +140,13 @@ begin
   Result := TGLRagdolBone(List^[Index]);
 end;
 
-procedure TGLRagdolBoneList.ReadFromFiler(reader: TGVirtualReader);
+procedure TGLRagdolBoneList.ReadFromFiler(reader: TGLVirtualReader);
 begin
   inherited;
   // Not implemented
 end;
 
-procedure TGLRagdolBoneList.WriteToFiler(writer: TGVirtualWriter);
+procedure TGLRagdolBoneList.WriteToFiler(writer: TGLVirtualWriter);
 begin
   inherited;
   // Not implemented
@@ -280,7 +280,7 @@ begin
   Result := TGLRagdolBone(List^[Index]);
 end;
 
-procedure TGLRagdolBone.ReadFromFiler(reader: TGVirtualReader);
+procedure TGLRagdolBone.ReadFromFiler(reader: TGLVirtualReader);
 begin
   inherited;
 
@@ -306,7 +306,7 @@ begin
     Items[i].UpdateChild;
 end;
 
-procedure TGLRagdolBone.WriteToFiler(writer: TGVirtualWriter);
+procedure TGLRagdolBone.WriteToFiler(writer: TGLVirtualWriter);
 begin
   inherited;
 end;
@@ -361,7 +361,7 @@ begin
   inherited Destroy;
 end;
 
-procedure TGLRagdoll.ReadFromFiler(reader: TGVirtualReader);
+procedure TGLRagdoll.ReadFromFiler(reader: TGLVirtualReader);
 begin
   inherited;
 end;
@@ -405,7 +405,7 @@ begin
   FOwner.Skeleton.MorphMesh(True);
 end;
 
-procedure TGLRagdoll.WriteToFiler(writer: TGVirtualWriter);
+procedure TGLRagdoll.WriteToFiler(writer: TGLVirtualWriter);
 begin
   inherited;
 

Source/GLS.RandomHDS.pas

@@ -107,7 +107,7 @@ type
   TGLBaseRandomHDS = class;
 
   // Function type to use for topography-based texture
-  TOnDrawTexture = function(const Sender: TGLBaseRandomHDS; x, y: integer; z: double; Normal: TGLVector): TGColorVector of object;
+  TOnDrawTexture = function(const Sender: TGLBaseRandomHDS; x, y: integer; z: double; Normal: TGLVector): TGLColorVector of object;
 
   TSingleClamp = procedure(var x, y: single) of object;
   TIntegerClamp = procedure(var x, y: integer) of object;
@@ -130,7 +130,7 @@ type
     FLighting: boolean;
     FLightDirection: TGLVector;
     FTerrainRenderer: TGLTerrainRenderer;
-    FLightColor: TGColorVector;
+    FLightColor: TGLColorVector;
     FShadows: boolean;
     FSea: boolean;
     FSeaLevel: single;
@@ -144,13 +144,13 @@ type
     FPrimerLandscape: boolean;
     FLandTileInfo: TLandTileInfo;
     FOnDrawTexture: TOnDrawTexture;
-    function OnDrawTextureDefault(const Sender: TGLBaseRandomHDS; x, y: integer; z: double; Normal: TGLVector): TGColorVector;
+    function OnDrawTextureDefault(const Sender: TGLBaseRandomHDS; x, y: integer; z: double; Normal: TGLVector): TGLColorVector;
     procedure SetSeed(const Value: integer);
     procedure SetMaterialName(const Value: string);
     procedure SetLighting(const Value: boolean);
     procedure SetLightDirection(const Value: TGLVector);
     procedure SetTerrainRenderer(const Value: TGLTerrainRenderer); virtual; abstract;
-    procedure SetLightColor(const Value: TGColorVector);
+    procedure SetLightColor(const Value: TGLColorVector);
     procedure SetShadows(const Value: boolean);
     procedure SetSea(const Value: boolean);
     procedure SetSeaLevel(const Value: single);
@@ -176,7 +176,7 @@ type
     constructor Create(AOwner: TComponent); override;
     destructor Destroy; override;
     // Usually white, but you can generate e.g.sunset ambiance by setting it to red
-    property LightColor: TGColorVector read FLightColor write SetLightColor;
+    property LightColor: TGLColorVector read FLightColor write SetLightColor;
     // Light is parallel (sun light)
     property LightDirection: TGLVector read FLightDirection write SetLightDirection;
     (* This function must be supplied by the user. Here he/she can define which
@@ -273,7 +273,7 @@ type
     procedure BuildNormals;
     (* For every pixel of the texture, computes slope and interpolated height and
       sends these information to a user-supplied function (OnDrawTexture), whose
-      result is a TGColorVector. If no OnDrawTexture is supplied, a basic default
+      result is a TGLColorVector. If no OnDrawTexture is supplied, a basic default
       texture will be used. *)
     procedure BuildTexture;
     // Fill the heightfield with "Empty" values (-999)
@@ -576,14 +576,14 @@ type
 
 (* Texture functions *)
 function LoadJPGtexture(const JpgName: string): tBitmap;
-function NoisyColor(const Color: tColor; const Noise: single = 0.05): TGColorVector;
-function TextureGreen(const x, y: integer): TGColorVector;
-function TextureBlue(const x, y: integer): TGColorVector;
-function TextureSand(const x, y: integer): TGColorVector;
-function TextureBrownSoil(const x, y: integer): TGColorVector;
-function TextureDarkGreen(const x, y: integer): TGColorVector;
-function TextureDarkGray(const x, y: integer): TGColorVector;
-function TextureWhite(const x, y: integer): TGColorVector;
+function NoisyColor(const Color: tColor; const Noise: single = 0.05): TGLColorVector;
+function TextureGreen(const x, y: integer): TGLColorVector;
+function TextureBlue(const x, y: integer): TGLColorVector;
+function TextureSand(const x, y: integer): TGLColorVector;
+function TextureBrownSoil(const x, y: integer): TGLColorVector;
+function TextureDarkGreen(const x, y: integer): TGLColorVector;
+function TextureDarkGray(const x, y: integer): TGLColorVector;
+function TextureWhite(const x, y: integer): TGLColorVector;
 
 (* Random HDS functions *)
 (* Fractal algorithm based on the middle-point displacement method. It is built in
@@ -627,7 +627,7 @@ begin
   Jpg.Free;
 end;
 
-function NoisyColor(const Color: tColor; const Noise: single = 0.05): TGColorVector;
+function NoisyColor(const Color: tColor; const Noise: single = 0.05): TGLColorVector;
 var
   r: single;
 begin
@@ -636,37 +636,37 @@ begin
   AddVector(Result, r);
 end;
 
-function TextureSand(const x, y: integer): TGColorVector;
+function TextureSand(const x, y: integer): TGLColorVector;
 begin
   Result := NoisyColor($0071D8FF);
 end;
 
-function TextureBrownSoil(const x, y: integer): TGColorVector;
+function TextureBrownSoil(const x, y: integer): TGLColorVector;
 begin
   Result := NoisyColor($00008BBF);
 end;
 
-function TextureDarkGreen(const x, y: integer): TGColorVector;
+function TextureDarkGreen(const x, y: integer): TGLColorVector;
 begin
   Result := NoisyColor($00004000);
 end;
 
-function TextureDarkGray(const x, y: integer): TGColorVector;
+function TextureDarkGray(const x, y: integer): TGLColorVector;
 begin
   Result := NoisyColor(clDkGray);
 end;
 
-function TextureWhite(const x, y: integer): TGColorVector;
+function TextureWhite(const x, y: integer): TGLColorVector;
 begin
   Result := NoisyColor(clWhite);
 end;
 
-function TextureBlue(const x, y: integer): TGColorVector;
+function TextureBlue(const x, y: integer): TGLColorVector;
 begin
   Result := NoisyColor(clBlue);
 end;
 
-function TextureGreen(const x, y: integer): TGColorVector;
+function TextureGreen(const x, y: integer): TGLColorVector;
 begin
   Result := NoisyColor(clGreen);
 end;
@@ -734,7 +734,7 @@ begin
 end;
 
 function TGLBaseRandomHDS.OnDrawTextureDefault(const Sender: TGLBaseRandomHDS; x, y: integer; z: double; Normal: TGLVector)
-  : TGColorVector;
+  : TGLColorVector;
 begin
   if z > Sender.SeaLevel * VSF then
     Result := TextureGreen(x, y)
@@ -777,7 +777,7 @@ begin
   FLandTileInfo := Value;
 end;
 
-procedure TGLBaseRandomHDS.SetLightColor(const Value: TGColorVector);
+procedure TGLBaseRandomHDS.SetLightColor(const Value: TGLColorVector);
 begin
   FLightColor := Value;
 end;
@@ -1123,7 +1123,7 @@ var
     Result := RGB((r1 + r2) div 2, (g1 + g2) div 2, (b1 + b2) div 2);
   end;
 
-  procedure MakeRGBTriple(const Color: TGColorVector; var RGBTriple: TRGBTriple);
+  procedure MakeRGBTriple(const Color: TGLColorVector; var RGBTriple: TRGBTriple);
   begin
     with RGBTriple do
     begin
@@ -1136,8 +1136,8 @@ var
   function ComputePixel(const x, y: integer): TRGBTriple;
   var
     i, j: integer;
-    Shade: TGColorVector;
-    Cover: TGColorVector;
+    Shade: TGLColorVector;
+    Cover: TGLColorVector;
     z: double;
   begin
     i := (x0 + x) div TextureScale;
@@ -1251,8 +1251,8 @@ end; // *)
   Mat	:TGLLibMaterial;
   x,y	:integer;
   i,j	:integer;
-  Shade	:TGColorVector;
-  Cover	:TGColorVector;
+  Shade	:TGLColorVector;
+  Cover	:TGLColorVector;
   z		:double;
   begin
   if not fTextureCreated then CreateTexture;

Source/GLS.RenderContextInfo.pas

@@ -76,7 +76,7 @@ type
     GLStates: TGLStateCache;
     PipelineTransformation: TGTransformation;
     Rcci: TGLRenderContextClippingInfo;
-    SceneAmbientColor: TGColorVector;
+    SceneAmbientColor: TGLColorVector;
     BufferFaceCull: Boolean;
     BufferLighting: Boolean;
     BufferFog: Boolean;
@@ -86,8 +86,8 @@ type
     IgnoreBlendingRequests: Boolean;
     IgnoreDepthRequests: Boolean;
     Amalgamating: Boolean;
-    Lights: TgPersistentObjectList;
-    AfterRenderEffects: TgPersistentObjectList;
+    Lights: TGLPersistentObjectList;
+    AfterRenderEffects: TGLPersistentObjectList;
     CurrentMaterialLevel: TGLMaterialLevel;
     PrimitiveMask: TGLMeshPrimitives;
     OrderCounter: Integer;

Source/GLS.Scene.pas

@@ -172,7 +172,7 @@ type
     FBoundingBoxPersonalUnscaled: THmgBoundingBox;
     FBoundingBoxOfChildren: THmgBoundingBox;
     FBoundingBoxIncludingChildren: THmgBoundingBox;
-    FChildren: TgPersistentObjectList; // created on 1st use
+    FChildren: TGLPersistentObjectList; // created on 1st use
     FVisible: Boolean;
     FUpdateCount: Integer;
     FShowAxes: Boolean;
@@ -189,8 +189,8 @@ type
     FTagObject: TObject;
     FTagFloat: Single;
 
-    objList: TgPersistentObjectList;
-    distList: TGSingleList;
+    objList: TGLPersistentObjectList;
+    distList: TGLSingleList;
     ///  FOriginalFiler: TFiler;   //used to allow persistent events in behaviours & effects
     (* If somebody could look at DefineProperties, ReadBehaviours, ReadEffects
      and verify code is safe to use then it could be uncommented *)
@@ -904,12 +904,12 @@ type
     FSpotExponent, FSpotCutOff: Single;
     FConstAttenuation, FLinearAttenuation, FQuadraticAttenuation: Single;
     FShining: Boolean;
-    FAmbient, FDiffuse, FSpecular: TGColor;
+    FAmbient, FDiffuse, FSpecular: TGLColor;
     FLightStyle: TGLLightStyle;
   protected
-    procedure SetAmbient(AValue: TGColor);
-    procedure SetDiffuse(AValue: TGColor);
-    procedure SetSpecular(AValue: TGColor);
+    procedure SetAmbient(AValue: TGLColor);
+    procedure SetDiffuse(AValue: TGLColor);
+    procedure SetSpecular(AValue: TGLColor);
     procedure SetConstAttenuation(AValue: Single);
     procedure SetLinearAttenuation(AValue: Single);
     procedure SetQuadraticAttenuation(AValue: Single);
@@ -933,10 +933,10 @@ type
     property LightID: Cardinal read FLightID;
     function Attenuated: Boolean;
   published
-    property Ambient: TGColor read FAmbient write SetAmbient;
+    property Ambient: TGLColor read FAmbient write SetAmbient;
     property ConstAttenuation: Single read FConstAttenuation write
       SetConstAttenuation;
-    property Diffuse: TGColor read FDiffuse write SetDiffuse;
+    property Diffuse: TGLColor read FDiffuse write SetDiffuse;
     property LinearAttenuation: Single read FLinearAttenuation write
       SetLinearAttenuation;
     property QuadraticAttenuation: Single read FQuadraticAttenuation write
@@ -944,7 +944,7 @@ type
     property Position;
     property LightStyle: TGLLightStyle read FLightStyle write SetLightStyle default lsSpot;
     property Shining: Boolean read FShining write SetShining default True;
-    property Specular: TGColor read FSpecular write SetSpecular;
+    property Specular: TGLColor read FSpecular write SetSpecular;
     property SpotCutOff: Single read FSpotCutOff write SetSpotCutOff;
     property SpotDirection: TGLCoordinates read FSpotDirection write
       SetSpotDirection;
@@ -1139,7 +1139,7 @@ type
     FUpdateCount: Integer;
     FObjects: TGLSceneRootObject;
     FBaseContext: TGLContext; //reference, not owned!
-    FLights, FBuffers: TgPersistentObjectList;
+    FLights, FBuffers: TGLPersistentObjectList;
     FCurrentGLCamera: TGLCamera;
     FCurrentBuffer: TGLSceneBuffer;
     FObjectsSorting: TGLObjectsSorting;
@@ -1195,7 +1195,7 @@ type
     // Load the scene from a text files. See LoadFromFile for details.
     procedure LoadFromTextFile(const fileName: string);
     property CurrentGLCamera: TGLCamera read FCurrentGLCamera;
-    property Lights: TgPersistentObjectList read FLights;
+    property Lights: TGLPersistentObjectList read FLights;
     property Objects: TGLSceneRootObject read FObjects;
     property CurrentBuffer: TGLSceneBuffer read FCurrentBuffer;
     (* List of objects that request to be initialized when rendering context is active.
@@ -1229,12 +1229,12 @@ type
   TGLFogEnvironment = class(TGLUpdateAbleObject)
   private
     FSceneBuffer: TGLSceneBuffer;
-    FFogColor: TGColor; // alpha value means the fog density
+    FFogColor: TGLColor; // alpha value means the fog density
     FFogStart, FFogEnd: Single;
     FFogMode: TFogMode;
     FFogDistance: TFogDistance;
   protected
-    procedure SetFogColor(Value: TGColor);
+    procedure SetFogColor(Value: TGLColor);
     procedure SetFogStart(Value: Single);
     procedure SetFogEnd(Value: Single);
     procedure SetFogMode(Value: TFogMode);
@@ -1247,7 +1247,7 @@ type
     function IsAtDefaultValues: Boolean;
   published
     // Color of the fog when it is at 100% intensity.
-    property FogColor: TGColor read FFogColor write SetFogColor;
+    property FogColor: TGLColor read FFogColor write SetFogColor;
     // Minimum distance for fog, what is closer is not affected.
     property FogStart: Single read FFogStart write SetFogStart;
     // Maximum distance for fog, what is farther is at 100% fog intensity.
@@ -1274,7 +1274,7 @@ type
     // Internal state
     FRendering: Boolean;
     FRenderingContext: TGLContext;
-    FAfterRenderEffects: TgPersistentObjectList;
+    FAfterRenderEffects: TGLPersistentObjectList;
     FViewMatrixStack: array of TGLMatrix;
     FProjectionMatrixStack: array of TGLMatrix;
     FBaseProjectionMatrix: TGLMatrix;
@@ -1286,7 +1286,7 @@ type
     FDepthTest: Boolean;
     FBackgroundColor: TColor;
     FBackgroundAlpha: Single;
-    FAmbientColor: TGColor;
+    FAmbientColor: TGLColor;
     FAntiAliasing: TGLAntiAliasing;
     FDepthPrecision: TGLDepthPrecision;
     FColorDepth: TGLColorDepth;
@@ -1321,7 +1321,7 @@ type
   protected
     procedure SetBackgroundColor(AColor: TColor);
     procedure SetBackgroundAlpha(alpha: Single);
-    procedure SetAmbientColor(AColor: TGColor);
+    procedure SetAmbientColor(AColor: TGLColor);
     function GetLimit(Which: TGLLimitType): Integer;
     procedure SetCamera(ACamera: TGLCamera);
     procedure SetContextOptions(Options: TGLContextOptions);
@@ -1564,7 +1564,7 @@ type
     (* Scene ambient color vector.
        This ambient color is defined independantly from all lightsources,
        which can have their own ambient components. *)
-    property AmbientColor: TGColor read FAmbientColor write SetAmbientColor;
+    property AmbientColor: TGLColor read FAmbientColor write SetAmbientColor;
     (* Context options allows to setup specifics of the rendering context.
        Not all contexts support all options. *)
     property ContextOptions: TGLContextOptions read FContextOptions write
@@ -1887,14 +1887,14 @@ begin
   FPickable := True;
   FObjectsSorting := osInherited;
   FVisibilityCulling := vcInherited;
-  FChildren := TgPersistentObjectList.Create;
+  FChildren := TGLPersistentObjectList.Create;
 
   fBBChanges := [oBBcChild, oBBcStructure];
   FBoundingBoxPersonalUnscaled := NullBoundingBox;
   FBoundingBoxOfChildren := NullBoundingBox;
   FBoundingBoxIncludingChildren := NullBoundingBox;
-  distList := TGSingleList.Create;
-  objList := TgPersistentObjectList.Create;
+  distList := TGLSingleList.Create;
+  objList := TGLPersistentObjectList.Create;
 end;
 
 constructor TGLBaseSceneObject.CreateAsChild(aParentOwner: TGLBaseSceneObject);
@@ -3249,7 +3249,7 @@ end;
 procedure TGLBaseSceneObject.RecTransformationChanged;
 var
   i: Integer;
-  list: PGPointerObjectList;
+  list: PGLPointerObjectList;
   matSet: TGLObjectChanges;
 begin
   matSet := [ocAbsoluteMatrix, ocInvAbsoluteMatrix];
@@ -3742,7 +3742,7 @@ procedure TGLBaseSceneObject.RenderChildren(firstChildIndex, lastChildIndex:
 var
   i: Integer;
 
-  plist: PGPointerObjectList;
+  plist: PGLPointerObjectList;
   obj: TGLBaseSceneObject;
   oldSorting: TGLObjectsSorting;
   oldCulling: TGLVisibilityCulling;
@@ -5436,10 +5436,10 @@ begin
   FSpotCutOff := 180;
   FSpotExponent := 0;
   FLightStyle := lsSpot;
-  FAmbient := TGColor.Create(Self);
-  FDiffuse := TGColor.Create(Self);
+  FAmbient := TGLColor.Create(Self);
+  FDiffuse := TGLColor.Create(Self);
   FDiffuse.Initialize(clrWhite);
-  FSpecular := TGColor.Create(Self);
+  FSpecular := TGLColor.Create(Self);
 end;
 
 destructor TGLLightSource.Destroy;
@@ -5524,19 +5524,19 @@ begin
   end;
 end;
 
-procedure TGLLightSource.SetAmbient(AValue: TGColor);
+procedure TGLLightSource.SetAmbient(AValue: TGLColor);
 begin
   FAmbient.Color := AValue.Color;
   NotifyChange(Self);
 end;
 
-procedure TGLLightSource.SetDiffuse(AValue: TGColor);
+procedure TGLLightSource.SetDiffuse(AValue: TGLColor);
 begin
   FDiffuse.Color := AValue.Color;
   NotifyChange(Self);
 end;
 
-procedure TGLLightSource.SetSpecular(AValue: TGColor);
+procedure TGLLightSource.SetSpecular(AValue: TGLColor);
 begin
   FSpecular.Color := AValue.Color;
   NotifyChange(Self);
@@ -5586,7 +5586,7 @@ begin
   FCurrentBuffer := nil;
   FObjects := TGLSceneRootObject.Create(Self);
   FObjects.Name := 'ObjectRoot';
-  FLights := TgPersistentObjectList.Create;
+  FLights := TGLPersistentObjectList.Create;
   FObjectsSorting := osRenderBlendedLast;
   FVisibilityCulling := vcNone;
   // actual maximum number of lights is stored in TGLSceneViewer
@@ -5666,7 +5666,7 @@ end;
 procedure TGLScene.AddBuffer(aBuffer: TGLSceneBuffer);
 begin
   if not Assigned(FBuffers) then
-    FBuffers := TgPersistentObjectList.Create;
+    FBuffers := TGLPersistentObjectList.Create;
   if FBuffers.IndexOf(aBuffer) < 0 then
   begin
     FBuffers.Add(aBuffer);
@@ -6042,7 +6042,7 @@ constructor TGLFogEnvironment.Create(AOwner: TPersistent);
 begin
   inherited;
   FSceneBuffer := (AOwner as TGLSceneBuffer);
-  FFogColor := TGColor.CreateInitialized(Self, clrBlack);
+  FFogColor := TGLColor.CreateInitialized(Self, clrBlack);
   FFogMode := fmLinear;
   FFogStart := 10;
   FFogEnd := 1000;
@@ -6055,7 +6055,7 @@ begin
   inherited Destroy;
 end;
 
-procedure TGLFogEnvironment.SetFogColor(Value: TGColor);
+procedure TGLFogEnvironment.SetFogColor(Value: TGLColor);
 begin
   if Assigned(Value) then
   begin
@@ -6190,7 +6190,7 @@ begin
   FFogEnvironment := TGLFogEnvironment.Create(Self);
   FBackgroundColor := clBtnFace;
   FBackgroundAlpha := 1;
-  FAmbientColor := TGColor.CreateInitialized(Self, clrGray20);
+  FAmbientColor := TGLColor.CreateInitialized(Self, clrGray20);
   FDepthTest := True;
   FFaceCulling := True;
   FLighting := True;
@@ -6200,7 +6200,7 @@ begin
   FShadeModel := smDefault;
   FFogEnable := False;
   FLayer := clMainPlane;
-  FAfterRenderEffects := TgPersistentObjectList.Create;
+  FAfterRenderEffects := TGLPersistentObjectList.Create;
   FContextOptions := [roDoubleBuffer, roRenderToWindow, roDebugContext];
   ResetPerformanceMonitor;
 end;
@@ -7480,7 +7480,7 @@ begin
   end;
 end;
 
-procedure TGLSceneBuffer.SetAmbientColor(AColor: TGColor);
+procedure TGLSceneBuffer.SetAmbientColor(AColor: TGLColor);
 begin
   FAmbientColor.Assign(AColor);
 end;

Source/GLS.SceneRegister.pas

@@ -84,7 +84,7 @@ type
   TGLColorProperty = class(TClassProperty, ICustomPropertyDrawing,
     ICustomPropertyListDrawing)
   protected
-    function ColorToBorderColor(aColor: TGColorVector; selected: Boolean): TColor;
+    function ColorToBorderColor(aColor: TGLColorVector; selected: Boolean): TColor;
   public
     function GetAttributes: TPropertyAttributes; override;
     procedure GetValues(Proc: TGetStrProc); override;
@@ -647,11 +647,11 @@ end;
 procedure TGLColorProperty.Edit;
 var
   colorDialog: TColorDialog;
-  GLColor: TGColor;
+  GLColor: TGLColor;
 begin
   colorDialog := TColorDialog.Create(nil);
   try
-    GLColor := TGColor(GetOrdValue);
+    GLColor := TGLColor(GetOrdValue);
     colorDialog.Options := [cdFullOpen];
     colorDialog.Color := ConvertColorVector(GLColor.Color);
     if colorDialog.Execute then
@@ -676,16 +676,16 @@ end;
 
 function TGLColorProperty.GetValue: string;
 begin
-  Result := ColorManager.GetColorName(TGColor(GetOrdValue).Color);
+  Result := ColorManager.GetColorName(TGLColor(GetOrdValue).Color);
 end;
 
 procedure TGLColorProperty.SetValue(const Value: string);
 begin
-  TGColor(GetOrdValue).Color := ColorManager.GetColor(Value);
+  TGLColor(GetOrdValue).Color := ColorManager.GetColor(Value);
   Modified;
 end;
 
-function TGLColorProperty.ColorToBorderColor(aColor: TGColorVector; selected: Boolean): TColor;
+function TGLColorProperty.ColorToBorderColor(aColor: TGLColorVector; selected: Boolean): TColor;
 begin
   if (aColor.X > 0.75) or (aColor.Y > 0.75) or (aColor.Z > 0.75) then
     Result := clBlack
@@ -709,7 +709,7 @@ procedure TGLColorProperty.ListDrawValue(const Value: string; ACanvas: TCanvas;
 var
   vRight: Integer;
   vOldPenColor, vOldBrushColor: TColor;
-  Color: TGColorVector;
+  Color: TGLColorVector;
 begin
   vRight := (ARect.Bottom - ARect.Top) + ARect.Left;
   with ACanvas do
@@ -1365,7 +1365,7 @@ begin
   RegisterPropertiesInCategory(strLayoutCategoryName,
     [TypeInfo(TGLObjectsSorting), TypeInfo(TGLNormalDirection)]);
   RegisterPropertiesInCategory(strVisualCategoryName,
-    [TypeInfo(TGLVisibilityCulling), TypeInfo(TGLLightStyle), TypeInfo(TGColor),
+    [TypeInfo(TGLVisibilityCulling), TypeInfo(TGLLightStyle), TypeInfo(TGLColor),
     TypeInfo(TGLNormalDirection), TypeInfo(TGLCameraStyle)]);
   RegisterPropertiesInCategory(strVisualCategoryName, TGLBaseSceneObject,
     ['Rotation', 'Direction', 'Position', 'Up', 'Scale', '*Angle', 'ShowAxes', 'FocalLength']);
@@ -1589,7 +1589,7 @@ begin
   RegisterPropertyEditor(TypeInfo(TGLSoundFile), TGLSoundSample, '', TGLSoundFileProperty);
   RegisterPropertyEditor(TypeInfo(string), TGLBaseSoundSource, 'SoundName', TGLSoundNameProperty);
   RegisterPropertyEditor(TypeInfo(TGLCoordinates), nil, '', TGLCoordinatesProperty);
-  RegisterPropertyEditor(TypeInfo(TGColor), nil, '', TGLColorProperty);
+  RegisterPropertyEditor(TypeInfo(TGLColor), nil, '', TGLColorProperty);
   RegisterPropertyEditor(TypeInfo(TGLMaterial), nil, '', TGLMaterialProperty);
   RegisterComponentEditor(TGLGuiLayout, TGLGUILayoutEditor);
 

Source/GLS.Selection.pas

@@ -38,7 +38,7 @@ type
 
   (* List class for object picking.
      This list is used to store the results of a PickObjects call. *)
-  TGLPickList = class(TgPersistentObjectList)
+  TGLPickList = class(TGLPersistentObjectList)
   private
     function GetFar(aValue: Integer): Single;
     function GetHit(aValue: Integer): TObject;

Source/GLS.ShadowPlane.pas

@@ -62,14 +62,14 @@ type
     FRendering: Boolean;
     FShadowingObject: TGLBaseSceneObject;
     FShadowedLight: TGLLightSource;
-    FShadowColor: TGColor;
+    FShadowColor: TGLColor;
     FShadowOptions: TShadowPlaneOptions;
     FOnBeginRenderingShadows, FOnEndRenderingShadows: TNotifyEvent;
   protected
     procedure Notification(AComponent: TComponent; Operation: TOperation); override;
     procedure SetShadowingObject(const val: TGLBaseSceneObject);
     procedure SetShadowedLight(const val: TGLLightSource);
-    procedure SetShadowColor(const val: TGColor);
+    procedure SetShadowColor(const val: TGLColor);
     procedure SetShadowOptions(const val: TShadowPlaneOptions);
   public
     constructor Create(AOwner: TComponent); override;
@@ -83,7 +83,7 @@ type
     // The light which casts shadows. It must be enabled otherwise shadows won't be cast
     property ShadowedLight: TGLLightSource read FShadowedLight write SetShadowedLight;
     //The shadow's color. This color is transparently blended to make shadowed area darker
-    property ShadowColor: TGColor read FShadowColor write SetShadowColor;
+    property ShadowColor: TGLColor read FShadowColor write SetShadowColor;
     (* Controls rendering options:
       spoUseStencil: plane area is stenciled, prevents shadowing
         objects to be visible on the sides of the mirror (stencil buffer
@@ -112,12 +112,12 @@ implementation
 
 constructor TGLShadowPlane.Create(AOwner: Tcomponent);
 const
-  cDefaultShadowColor: TGColorVector = (X:0; Y:0; Z:0; W:0.5);
+  cDefaultShadowColor: TGLColorVector = (X:0; Y:0; Z:0; W:0.5);
 begin
   inherited Create(AOwner);
   FShadowOptions := cDefaultShadowPlaneOptions;
   ObjectStyle := ObjectStyle + [osDirectDraw];
-  FShadowColor := TGColor.CreateInitialized(Self, cDefaultShadowColor);
+  FShadowColor := TGLColor.CreateInitialized(Self, cDefaultShadowColor);
 end;
 
 destructor TGLShadowPlane.Destroy;
@@ -314,7 +314,7 @@ begin
 end;
 
 
-procedure TGLShadowPlane.SetShadowColor(const val: TGColor);
+procedure TGLShadowPlane.SetShadowColor(const val: TGLColor);
 begin
   FShadowColor.Assign(val);
 end;

Source/GLS.ShadowVolume.pas

@@ -119,7 +119,7 @@ type
   // Specifies an individual shadow casting light.
   TGLShadowVolumeLight = class(TGLShadowVolumeCaster)
   private
-    FSilhouettes: TgPersistentObjectList;
+    FSilhouettes: TGLPersistentObjectList;
   protected
     function GetLightSource: TGLLightSource;
     procedure SetLightSource(const ls: TGLLightSource);
@@ -198,7 +198,7 @@ type
     FCapping: TGLShadowVolumeCapping;
     FOptions: TGLShadowVolumeOptions;
     FMode: TGLShadowVolumeMode;
-    FDarkeningColor: TGColor;
+    FDarkeningColor: TGLColor;
   protected
     procedure Notification(AComponent: TComponent; Operation: TOperation); override;
     procedure SetActive(const val: Boolean);
@@ -206,7 +206,7 @@ type
     procedure SetOccluders(const val: TGLShadowVolumeCasters);
     procedure SetOptions(const val: TGLShadowVolumeOptions);
     procedure SetMode(const val: TGLShadowVolumeMode);
-    procedure SetDarkeningColor(const val: TGColor);
+    procedure SetDarkeningColor(const val: TGLColor);
   public
     constructor Create(AOwner: TComponent); override;
     destructor Destroy; override;
@@ -233,7 +233,7 @@ type
     // Shadow rendering mode.
     property Mode: TGLShadowVolumeMode read FMode write SetMode default svmAccurate;
     // Darkening color used in svmDarkening mode.
-    property DarkeningColor: TGColor read FDarkeningColor write SetDarkeningColor;
+    property DarkeningColor: TGLColor read FDarkeningColor write SetDarkeningColor;
   end;
 
 //-------------------------------------------------------------
@@ -326,7 +326,7 @@ end;
 constructor TGLShadowVolumeLight.Create(ACollection: TCollection);
 begin
   inherited Create(ACollection);
-  FSilhouettes := TgPersistentObjectList.Create;
+  FSilhouettes := TGLPersistentObjectList.Create;
 end;
 
 destructor TGLShadowVolumeLight.Destroy;
@@ -496,7 +496,7 @@ begin
   FCapping := svcAlways;
   FMode := svmAccurate;
   FOptions := [svoCacheSilhouettes, svoScissorClips];
-  FDarkeningColor := TGColor.CreateInitialized(Self, VectorMake(0, 0, 0, 0.5));
+  FDarkeningColor := TGLColor.CreateInitialized(Self, VectorMake(0, 0, 0, 0.5));
 end;
 
 destructor TGLShadowVolume.Destroy;
@@ -581,7 +581,7 @@ begin
   end;
 end;
 
-procedure TGLShadowVolume.SetDarkeningColor(const val: TGColor);
+procedure TGLShadowVolume.SetDarkeningColor(const val: TGLColor);
 begin
   FDarkeningColor.Assign(val);
 end;

Source/GLS.Silhouette.pas

@@ -40,20 +40,20 @@ type
   TGLSilhouette = class
   private
     FVertices: TGLVectorList;
-    FIndices: TgIntegerList;
-    FCapIndices: TgIntegerList;
+    FIndices: TGLIntegerList;
+    FCapIndices: TGLIntegerList;
     FParameters: TGLSilhouetteParameters;
   protected
-    procedure SetIndices(const value: TgIntegerList);
-    procedure SetCapIndices(const value: TgIntegerList);
+    procedure SetIndices(const value: TGLIntegerList);
+    procedure SetCapIndices(const value: TGLIntegerList);
     procedure SetVertices(const value: TGLVectorList);
   public
     constructor Create; virtual;
     destructor Destroy; override;
     property Parameters: TGLSilhouetteParameters read FParameters write FParameters;
     property Vertices: TGLVectorList read FVertices write SetVertices;
-    property Indices: TgIntegerList read FIndices write SetIndices;
-    property CapIndices: TgIntegerList read FCapIndices write SetCapIndices;
+    property Indices: TGLIntegerList read FIndices write SetIndices;
+    property CapIndices: TGLIntegerList read FCapIndices write SetCapIndices;
     procedure Flush; virtual;
     procedure Clear; inline;
     procedure ExtrudeVerticesToInfinity(const origin: TAffineVector);
@@ -92,12 +92,12 @@ type
       it'd be nicer with Structs or classes, but it's actually faster this way.
       The reason it's faster is because of less cache overwrites when we only
       access a tiny bit of a triangle (for instance), not all data. *)
-    FEdgeVertices: TgIntegerList;
-    FEdgeFaces: TgIntegerList;
-    FFaceVisible: TGByteList;
-    FFaceVertexIndex: TgIntegerList;
+    FEdgeVertices: TGLIntegerList;
+    FEdgeFaces: TGLIntegerList;
+    FFaceVisible: TGLByteList;
+    FFaceVertexIndex: TGLIntegerList;
     FFaceNormal: TGLAffineVectorList;
-    FVertexMemory: TgIntegerList;
+    FVertexMemory: TGLIntegerList;
     FVertices: TGLAffineVectorList;
     function GetEdgeCount: integer;
     function GetFaceCount: integer;
@@ -127,8 +127,8 @@ constructor TGLSilhouette.Create;
 begin
   inherited;
   FVertices := TGLVectorList.Create;
-  FIndices := TgIntegerList.Create;
-  FCapIndices := TgIntegerList.Create;
+  FIndices := TGLIntegerList.Create;
+  FCapIndices := TGLIntegerList.Create;
 end;
 
 destructor TGLSilhouette.Destroy;
@@ -139,12 +139,12 @@ begin
   inherited;
 end;
 
-procedure TGLSilhouette.SetIndices(const value: TgIntegerList);
+procedure TGLSilhouette.SetIndices(const value: TGLIntegerList);
 begin
   FIndices.Assign(value);
 end;
 
-procedure TGLSilhouette.SetCapIndices(const value: TgIntegerList);
+procedure TGLSilhouette.SetCapIndices(const value: TGLIntegerList);
 begin
   FCapIndices.Assign(value);
 end;
@@ -272,13 +272,13 @@ end;
 
 constructor TGLConnectivity.Create(APrecomputeFaceNormal: Boolean);
 begin
-  FFaceVisible := TGByteList.Create;
-  FFaceVertexIndex := TgIntegerList.Create;
+  FFaceVisible := TGLByteList.Create;
+  FFaceVertexIndex := TGLIntegerList.Create;
   FFaceNormal := TGLAffineVectorList.Create;
-  FEdgeVertices := TgIntegerList.Create;
-  FEdgeFaces := TgIntegerList.Create;
+  FEdgeVertices := TGLIntegerList.Create;
+  FEdgeFaces := TGLIntegerList.Create;
   FPrecomputeFaceNormal := APrecomputeFaceNormal;
-  FVertexMemory := TgIntegerList.Create;
+  FVertexMemory := TGLIntegerList.Create;
   FVertices := TGLAffineVectorList.Create;
 end;
 

Source/GLS.SkyDome.pas

@@ -92,16 +92,16 @@ type
   private
     FStartAngle: Single;
     FStopAngle: Single;
-    FStartColor: TGColor;
-    FStopColor: TGColor;
+    FStartColor: TGLColor;
+    FStopColor: TGLColor;
     FSlices: Integer;
     FStacks: Integer;
   protected
     function GetDisplayName: string; override;
     procedure SetStartAngle(const val: Single);
-    procedure SetStartColor(const val: TGColor);
+    procedure SetStartColor(const val: TGLColor);
     procedure SetStopAngle(const val: Single);
-    procedure SetStopColor(const val: TGColor);
+    procedure SetStopColor(const val: TGLColor);
     procedure SetSlices(const val: Integer);
     procedure SetStacks(const val: Integer);
     procedure OnColorChange(sender: TObject);
@@ -112,9 +112,9 @@ type
     procedure BuildList(var rci: TGLRenderContextInfo);
   published
     property StartAngle: Single read FStartAngle write SetStartAngle;
-    property StartColor: TGColor read FStartColor write SetStartColor;
+    property StartColor: TGLColor read FStartColor write SetStartColor;
     property StopAngle: Single read FStopAngle write SetStopAngle;
-    property StopColor: TGColor read FStopColor write SetStopColor;
+    property StopColor: TGLColor read FStopColor write SetStopColor;
     property Slices: Integer read FSlices write SetSlices default 12;
     property Stacks: Integer read FStacks write SetStacks default 1;
   end;
@@ -224,14 +224,14 @@ type
   private
     FSunElevation: Single;
     FTurbidity: Single;
-    FCurSunColor, FCurSkyColor, FCurHazeColor: TGColorVector;
+    FCurSunColor, FCurSkyColor, FCurHazeColor: TGLColorVector;
     FCurHazeTurbid, FCurSunSkyTurbid: Single;
-    FSunZenithColor: TGColor;
-    FSunDawnColor: TGColor;
-    FHazeColor: TGColor;
-    FSkyColor: TGColor;
-    FNightColor: TGColor;
-    FDeepColor: TGColor;
+    FSunZenithColor: TGLColor;
+    FSunDawnColor: TGLColor;
+    FHazeColor: TGLColor;
+    FSkyColor: TGLColor;
+    FNightColor: TGLColor;
+    FDeepColor: TGLColor;
     FSlices, FStacks: Integer;
     FExtendedOptions: TGLEarthSkydomeOptions;
     FMorning: Boolean;
@@ -239,12 +239,12 @@ type
     procedure Loaded; override;
     procedure SetSunElevation(const val: Single);
     procedure SetTurbidity(const val: Single);
-    procedure SetSunZenithColor(const val: TGColor);
-    procedure SetSunDawnColor(const val: TGColor);
-    procedure SetHazeColor(const val: TGColor);
-    procedure SetSkyColor(const val: TGColor);
-    procedure SetNightColor(const val: TGColor);
-    procedure SetDeepColor(const val: TGColor);
+    procedure SetSunZenithColor(const val: TGLColor);
+    procedure SetSunDawnColor(const val: TGLColor);
+    procedure SetHazeColor(const val: TGLColor);
+    procedure SetSkyColor(const val: TGLColor);
+    procedure SetNightColor(const val: TGLColor);
+    procedure SetDeepColor(const val: TGLColor);
     procedure SetSlices(const val: Integer);
     procedure SetStacks(const val: Integer);
     procedure OnColorChanged(Sender: TObject);
@@ -252,7 +252,7 @@ type
     (* Coordinates system note: X is forward, Y is left and Z is up
        always rendered as sphere of radius 1 *)
     procedure RenderDome;
-    function CalculateColor(const theta, cosGamma: Single): TGColorVector;
+    function CalculateColor(const theta, cosGamma: Single): TGLColorVector;
   public
     constructor Create(AOwner: TComponent); override;
     destructor Destroy; override;
@@ -264,12 +264,12 @@ type
     property SunElevation: Single read FSunElevation write SetSunElevation;
     // Expresses the purity of air. Value range is from 1 (pure atmosphere) to 120 (very nebulous)
     property Turbidity: Single read FTurbidity write SetTurbidity;
-    property SunZenithColor: TGColor read FSunZenithColor write SetSunZenithColor;
-    property SunDawnColor: TGColor read FSunDawnColor write SetSunDawnColor;
-    property HazeColor: TGColor read FHazeColor write SetHazeColor;
-    property SkyColor: TGColor read FSkyColor write SetSkyColor;
-    property NightColor: TGColor read FNightColor write SetNightColor;
-    property DeepColor: TGColor read FDeepColor write SetDeepColor;
+    property SunZenithColor: TGLColor read FSunZenithColor write SetSunZenithColor;
+    property SunDawnColor: TGLColor read FSunDawnColor write SetSunDawnColor;
+    property HazeColor: TGLColor read FHazeColor write SetHazeColor;
+    property SkyColor: TGLColor read FSkyColor write SetSkyColor;
+    property NightColor: TGLColor read FNightColor write SetNightColor;
+    property DeepColor: TGLColor read FDeepColor write SetDeepColor;
     property ExtendedOptions: TGLEarthSkydomeOptions read FExtendedOptions write FExtendedOptions;
     property Slices: Integer read FSlices write SetSlices default 24;
     property Stacks: Integer read FStacks write SetStacks default 48;
@@ -972,10 +972,10 @@ end;
 constructor TGLSkyDomeBand.Create(Collection: TCollection);
 begin
   inherited Create(Collection);
-  FStartColor := TGColor.Create(Self);
+  FStartColor := TGLColor.Create(Self);
   FStartColor.Initialize(clrBlue);
   FStartColor.OnNotifyChange := OnColorChange;
-  FStopColor := TGColor.Create(Self);
+  FStopColor := TGLColor.Create(Self);
   FStopColor.Initialize(clrBlue);
   FStopColor.OnNotifyChange := OnColorChange;
   FSlices := 12;
@@ -1018,7 +1018,7 @@ begin
   TGLSkyDomeBands(Collection).NotifyChange;
 end;
 
-procedure TGLSkyDomeBand.SetStartColor(const val: TGColor);
+procedure TGLSkyDomeBand.SetStartColor(const val: TGLColor);
 begin
   FStartColor.Assign(val);
 end;
@@ -1033,7 +1033,7 @@ begin
   TGLSkyDomeBands(Collection).NotifyChange;
 end;
 
-procedure TGLSkyDomeBand.SetStopColor(const val: TGColor);
+procedure TGLSkyDomeBand.SetStopColor(const val: TGLColor);
 begin
   FStopColor.Assign(val);
 end;
@@ -1068,7 +1068,7 @@ procedure TGLSkyDomeBand.BuildList(var rci: TGLRenderContextInfo);
 // always rendered as sphere of radius 1
 
   procedure RenderBand(start, stop: Single;
-    const colStart, colStop: TGColorVector);
+    const colStart, colStop: TGLColorVector);
   var
     i: Integer;
     f, r, r2: Single;
@@ -1290,7 +1290,7 @@ var
   star: TGLSkyDomeStar;
   lastColor: TColor;
   lastPointSize10, pointSize10: Integer;
-  Color, twinkleColor: TGColorVector;
+  Color, twinkleColor: TGLColorVector;
 
   (*sub*)procedure DoTwinkle;
   begin
@@ -1432,7 +1432,7 @@ procedure TGLSkyDomeStars.LoadStarsFile(const starsFileName: string);
 var
   fs: TFileStream;
   sr: TGLStarRecord;
-  colorVector: TGColorVector;
+  colorVector: TGLColorVector;
 begin
   fs := TFileStream.Create(starsFileName, fmOpenRead + fmShareDenyWrite);
   try
@@ -1568,16 +1568,16 @@ begin
   Bands.Clear;
   FSunElevation := 75;
   FTurbidity := 15;
-  FSunZenithColor := TGColor.CreateInitialized(Self, clrWhite, OnColorChanged);
-  FSunDawnColor := TGColor.CreateInitialized(Self, Vectormake(1, 0.5, 0, 0),
+  FSunZenithColor := TGLColor.CreateInitialized(Self, clrWhite, OnColorChanged);
+  FSunDawnColor := TGLColor.CreateInitialized(Self, Vectormake(1, 0.5, 0, 0),
     OnColorChanged);
-  FHazeColor := TGColor.CreateInitialized(Self, Vectormake(0.9, 0.95, 1, 0),
+  FHazeColor := TGLColor.CreateInitialized(Self, Vectormake(0.9, 0.95, 1, 0),
     OnColorChanged);
-  FSkyColor := TGColor.CreateInitialized(Self, Vectormake(0.45, 0.6, 0.9, 0),
+  FSkyColor := TGLColor.CreateInitialized(Self, Vectormake(0.45, 0.6, 0.9, 0),
     OnColorChanged);
-  FNightColor := TGColor.CreateInitialized(Self, clrTransparent,
+  FNightColor := TGLColor.CreateInitialized(Self, clrTransparent,
     OnColorChanged);
-  FDeepColor := TGColor.CreateInitialized(Self, Vectormake(0, 0.2, 0.4, 0));
+  FDeepColor := TGLColor.CreateInitialized(Self, Vectormake(0, 0.2, 0.4, 0));
   FStacks := 24;
   FSlices := 48;
   PreCalculate;
@@ -1642,37 +1642,37 @@ begin
   PreCalculate;
 end;
 
-procedure TGLEarthSkyDome.SetSunZenithColor(const val: TGColor);
+procedure TGLEarthSkyDome.SetSunZenithColor(const val: TGLColor);
 begin
   FSunZenithColor.Assign(val);
   PreCalculate;
 end;
 
-procedure TGLEarthSkyDome.SetSunDawnColor(const val: TGColor);
+procedure TGLEarthSkyDome.SetSunDawnColor(const val: TGLColor);
 begin
   FSunDawnColor.Assign(val);
   PreCalculate;
 end;
 
-procedure TGLEarthSkyDome.SetHazeColor(const val: TGColor);
+procedure TGLEarthSkyDome.SetHazeColor(const val: TGLColor);
 begin
   FHazeColor.Assign(val);
   PreCalculate;
 end;
 
-procedure TGLEarthSkyDome.SetSkyColor(const val: TGColor);
+procedure TGLEarthSkyDome.SetSkyColor(const val: TGLColor);
 begin
   FSkyColor.Assign(val);
   PreCalculate;
 end;
 
-procedure TGLEarthSkyDome.SetNightColor(const val: TGColor);
+procedure TGLEarthSkyDome.SetNightColor(const val: TGLColor);
 begin
   FNightColor.Assign(val);
   PreCalculate;
 end;
 
-procedure TGLEarthSkyDome.SetDeepColor(const val: TGColor);
+procedure TGLEarthSkyDome.SetDeepColor(const val: TGLColor);
 begin
   FDeepColor.Assign(val);
   PreCalculate;
@@ -1865,7 +1865,7 @@ end;
 //----------------------------------------------------------------------
 
 function TGLEarthSkyDome.CalculateColor(const theta, cosGamma: Single)
-  : TGColorVector;
+  : TGLColorVector;
 var
   t: Single;
 begin
@@ -1897,7 +1897,7 @@ var
     i: Integer;
     r, thetaStart: Single;
     vertex1: TGLVector;
-    Color: TGColorVector;
+    Color: TGLColorVector;
   begin
     r := 0;
     vertex1.W := 1;
@@ -1924,7 +1924,7 @@ var
     i: Integer;
     r, r2, thetaStart, thetaStop: Single;
     vertex1, vertex2: TGLVector;
-    Color: TGColorVector;
+    Color: TGLColorVector;
   begin
     vertex1.W := 1;
     if stop = 90 then

Source/GLS.SmartObjects.pas

@@ -70,7 +70,7 @@ type
   TGLCyborgThinks = class(TCollection);
 
   // A list of thinking periods for TGLCyborgThinkMode
-  TGLCyborgThinksList = class(TgPersistentObjectList);
+  TGLCyborgThinksList = class(TGLPersistentObjectList);
 
 const
   cDefaultCyborgOptions = [coCollide];

Source/GLS.SpacePartition.pas

@@ -109,7 +109,7 @@ type
   end;
 
   // List for storing space partition leaves
-  TGLSpacePartitionLeafList = class(TgPersistentObjectList)
+  TGLSpacePartitionLeafList = class(TGLPersistentObjectList)
   private
     function GetItems(I: Integer): TGLSpacePartitionLeaf;
     procedure SetItems(I: Integer; const Value: TGLSpacePartitionLeaf);

Source/GLS.TerrainRenderer.pas

@@ -68,8 +68,8 @@ type
     FTilesPerTexture: Single;
     FMaxCLODTriangles, FCLODPrecision: Integer;
     FBufferVertices: TGLAffineVectorList;
-    FBufferTexPoints: TGTexPointList;
-    FBufferVertexIndices: TgIntegerList;
+    FBufferTexPoints: TGLTexPointList;
+    FBufferVertexIndices: TGLIntegerList;
     FMaterialLibrary: TGLMaterialLibrary;
     FOnGetTerrainBounds: TGetTerrainBoundsEvent;
     FOnPatchPostRender: TPatchPostRenderEvent;
@@ -242,8 +242,8 @@ begin
   FCLODPrecision := 100;
   FOcclusionTesselate := totTesselateIfVisible;
   FBufferVertices := TGLAffineVectorList.Create;
-  FBufferTexPoints := TGTexPointList.Create;
-  FBufferVertexIndices := TgIntegerList.Create;
+  FBufferTexPoints := TGLTexPointList.Create;
+  FBufferVertexIndices := TGLIntegerList.Create;
   TileManagement := [tmClearUsedFlags, tmMarkUsedTiles, tmReleaseUnusedTiles,
     tmAllocateNewTiles];
 end;

Source/GLS.Texture.pas

@@ -397,8 +397,8 @@ type
     FTexWidth: Integer;
     FTexHeight: Integer;
     FTexDepth: Integer;
-    FEnvColor: TGColor;
-    FBorderColor: TGColor;
+    FEnvColor: TGLColor;
+    FBorderColor: TGLColor;
     FNormalMapScale: Single;
     FTextureWrapS: TGLSeparateTextureWrap;
     FTextureWrapT: TGLSeparateTextureWrap;
@@ -443,8 +443,8 @@ type
     procedure SetDisabled(AValue: Boolean);
     procedure SetEnabled(const val: Boolean);
     function GetEnabled: Boolean; inline;
-    procedure SetEnvColor(const val: TGColor);
-    procedure SetBorderColor(const val: TGColor);
+    procedure SetEnvColor(const val: TGLColor);
+    procedure SetBorderColor(const val: TGLColor);
     procedure SetNormalMapScale(const val: Single);
     procedure SetTextureCompareMode(const val: TGLTextureCompareMode);
     procedure SetTextureCompareFunc(const val: TGLDepthCompareFunc);
@@ -589,9 +589,9 @@ type
     property MappingQCoordinates: TGLCoordinates4 read GetMappingQCoordinates
       write SetMappingQCoordinates stored StoreMappingQCoordinates;
     // Texture Environment color
-    property EnvColor: TGColor read FEnvColor write SetEnvColor;
+    property EnvColor: TGLColor read FEnvColor write SetEnvColor;
     // Texture Border color
-    property BorderColor: TGColor read FBorderColor write SetBorderColor;
+    property BorderColor: TGLColor read FBorderColor write SetBorderColor;
     // If true, the texture is disabled (not used)
     property Disabled: Boolean read FDisabled write SetDisabled default True;
     (* Normal Map scaling.
@@ -1756,8 +1756,8 @@ begin
   FSamplerHandle.OnAllocate := OnSamplerAllocate;
   FSamplerHandle.OnDestroy := OnSamplerDestroy;
   FMappingMode := tmmUser;
-  FEnvColor := TGColor.CreateInitialized(Self, clrTransparent);
-  FBorderColor := TGColor.CreateInitialized(Self, clrTransparent);
+  FEnvColor := TGLColor.CreateInitialized(Self, clrTransparent);
+  FBorderColor := TGLColor.CreateInitialized(Self, clrTransparent);
   FNormalMapScale := cDefaultNormalMapScale;
   FTextureCompareMode := tcmNone;
   FTextureCompareFunc := cfLequal;
@@ -2030,13 +2030,13 @@ begin
   Result := not Disabled;
 end;
 
-procedure TGLTexture.SetEnvColor(const val: TGColor);
+procedure TGLTexture.SetEnvColor(const val: TGLColor);
 begin
   FEnvColor.Assign(val);
   NotifyParamsChange;
 end;
 
-procedure TGLTexture.SetBorderColor(const val: TGColor);
+procedure TGLTexture.SetBorderColor(const val: TGLColor);
 begin
   FBorderColor.Assign(val);
   NotifyParamsChange;

Source/GLS.ThorFX.pas

@@ -61,7 +61,7 @@ type
     FVibrate: single;
     FWildness: single;
     NP: integer;
-    FInnerColor, FOuterColor, FCoreColor: TGColor;
+    FInnerColor, FOuterColor, FCoreColor: TGLColor;
     FDisabled, FCore, FGlow: boolean;
     FOnCalcPoint: TCalcPointEvent;
   protected
@@ -73,9 +73,9 @@ type
     procedure SetMaxpoints(const val: integer);
     function StoreGlowSize: boolean;
     function StoreVibrate: boolean;
-    procedure SetInnerColor(const val: TGColor);
-    procedure SetOuterColor(const val: TGColor);
-    procedure SetCoreColor(const val: TGColor);
+    procedure SetInnerColor(const val: TGLColor);
+    procedure SetOuterColor(const val: TGLColor);
+    procedure SetCoreColor(const val: TGLColor);
     procedure Notification(AComponent: TComponent;
       Operation: TOperation); override;
     procedure ThorInit;
@@ -91,9 +91,9 @@ type
     property Maxpoints: integer read FMaxpoints write SetMaxpoints default 256;
     property GlowSize: single read FGlowSize write FGlowSize stored StoreGlowSize;
     property Vibrate: single read FVibrate write FVibrate stored StoreVibrate;
-    property InnerColor: TGColor read FInnerColor write SetInnerColor;
-    property OuterColor: TGColor read FOuterColor write SetOuterColor; // default clrWhite;
-    property CoreColor: TGColor read FCoreColor write SetCoreColor; // default clrWhite;
+    property InnerColor: TGLColor read FInnerColor write SetInnerColor;
+    property OuterColor: TGLColor read FOuterColor write SetOuterColor; // default clrWhite;
+    property CoreColor: TGLColor read FCoreColor write SetCoreColor; // default clrWhite;
     property Disabled: boolean read FDisabled write FDisabled;
     property Core: boolean read FCore write FCore;
     property Glow: boolean read FGlow write FGlow;
@@ -147,12 +147,12 @@ begin
   FGlowSize := 0.2;
   FVibrate := 0;
   FWildness := 1;
-  FInnerColor := TGColor.Create(Self);
+  FInnerColor := TGLColor.Create(Self);
   FInnerColor.Initialize(clrWhite);
-  FOuterColor := TGColor.Create(Self);
+  FOuterColor := TGLColor.Create(Self);
   FOuterColor.Initialize(clrBlue);
   FOuterColor.Alpha := 0;
-  FCoreColor := TGColor.Create(Self);
+  FCoreColor := TGLColor.Create(Self);
   FCoreColor.Initialize(clrWhite);
   FCore := True;
   FGlow := True;
@@ -238,7 +238,7 @@ begin
   Result := (FVibrate <> 1);
 end;
 
-procedure TGLThorFXManager.SetInnerColor(const val: TGColor);
+procedure TGLThorFXManager.SetInnerColor(const val: TGLColor);
 begin
   if FInnerColor <> val then
   begin
@@ -247,7 +247,7 @@ begin
   end;
 end;
 
-procedure TGLThorFXManager.SetOuterColor(const val: TGColor);
+procedure TGLThorFXManager.SetOuterColor(const val: TGLColor);
 begin
   if FOuterColor <> val then
   begin
@@ -256,7 +256,7 @@ begin
   end;
 end;
 
-procedure TGLThorFXManager.SetCoreColor(const val: TGColor);
+procedure TGLThorFXManager.SetCoreColor(const val: TGLColor);
 begin
   if FCoreColor <> val then
   begin
@@ -464,14 +464,14 @@ var
   i: integer;
   // absPos :TGLVector;
   InnerColor: TGLVector;
-  distList: TGSingleList;
+  distList: TGLSingleList;
   objList: TList;
   fp: PThorpoint;
   mat: TGLMatrix;
 
   vx, vy: TGLVector;
   m: integer;
-  Icol, Ocol, Ccol: TGColorVector;
+  Icol, Ocol, Ccol: TGLColorVector;
   Ppos, Ppos2: TAffineVector;
 begin
   if Manager = nil then
@@ -493,7 +493,7 @@ begin
 
   if N > 1 then
   begin
-    distList := TGSingleList.Create;
+    distList := TGLSingleList.Create;
     objList := TList.Create;
     for i := 0 to N - 1 do
     begin

Source/GLS.TilePlane.pas

@@ -30,7 +30,7 @@ type
   TGLTiledAreaRow = class(TGLPersistentObject)
   private
     FColMin, FColMax: Integer;
-    FData: TgIntegerList;
+    FData: TGLIntegerList;
   protected
     procedure SetColMin(const val: Integer);
     procedure SetColMax(const val: Integer);
@@ -39,15 +39,15 @@ type
   public
     constructor Create; override;
     destructor Destroy; override;
-    procedure WriteToFiler(writer: TGVirtualWriter); override;
-    procedure ReadFromFiler(reader: TGVirtualReader); override;
+    procedure WriteToFiler(writer: TGLVirtualWriter); override;
+    procedure ReadFromFiler(reader: TGLVirtualReader); override;
     property Cell[col: Integer]: Integer read GetCell write SetCell; default;
     property ColMin: Integer read FColMin write SetColMin;
     property ColMax: Integer read FColMax write SetColMax;
-    property Data: TgIntegerList read FData;
+    property Data: TGLIntegerList read FData;
     procedure Pack;
     function Empty: Boolean;
-    procedure RemapTiles(remapList: TgIntegerList);
+    procedure RemapTiles(remapList: TGLIntegerList);
   end;
 
   (* Stores tile information in a tiled area.
@@ -56,7 +56,7 @@ type
   TGLTiledArea = class(TGLPersistentObject)
   private
     FRowMin, FRowMax: Integer;
-    FRows: TgPersistentObjectList;
+    FRows: TGLPersistentObjectList;
   protected
     procedure SetRowMin(const val: Integer);
     procedure SetRowMax(const val: Integer);
@@ -66,8 +66,8 @@ type
   public
     constructor Create; override;
     destructor Destroy; override;
-    procedure WriteToFiler(writer: TGVirtualWriter); override;
-    procedure ReadFromFiler(reader: TGVirtualReader); override;
+    procedure WriteToFiler(writer: TGLVirtualWriter); override;
+    procedure ReadFromFiler(reader: TGLVirtualReader); override;
     property Tile[col, row: Integer]: Integer read GetTile write SetTile; default;
     property row[index: Integer]: TGLTiledAreaRow read GetRow;
     property RowMin: Integer read FRowMin write SetRowMin;
@@ -75,7 +75,7 @@ type
     procedure Pack;
     procedure Clear;
     function Empty: Boolean;
-    procedure RemapTiles(remapList: TgIntegerList);
+    procedure RemapTiles(remapList: TGLIntegerList);
   end;
 
   (* A tiled textured plane.
@@ -128,7 +128,7 @@ implementation
 constructor TGLTiledAreaRow.Create;
 begin
   inherited;
-  FData := TgIntegerList.Create;
+  FData := TGLIntegerList.Create;
   FColMin := 0;
   FColMax := -1;
 end;
@@ -139,7 +139,7 @@ begin
   inherited;
 end;
 
-procedure TGLTiledAreaRow.WriteToFiler(writer: TGVirtualWriter);
+procedure TGLTiledAreaRow.WriteToFiler(writer: TGLVirtualWriter);
 begin
   inherited WriteToFiler(writer);
   with writer do
@@ -150,7 +150,7 @@ begin
   end;
 end;
 
-procedure TGLTiledAreaRow.ReadFromFiler(reader: TGVirtualReader);
+procedure TGLTiledAreaRow.ReadFromFiler(reader: TGLVirtualReader);
 var
   archiveVersion: Integer;
 begin
@@ -207,7 +207,7 @@ begin
   Result := (FData.Count = 0);
 end;
 
-procedure TGLTiledAreaRow.RemapTiles(remapList: TgIntegerList);
+procedure TGLTiledAreaRow.RemapTiles(remapList: TGLIntegerList);
 var
   i, k: Integer;
 begin
@@ -284,7 +284,7 @@ end;
 constructor TGLTiledArea.Create;
 begin
   inherited;
-  FRows := TgPersistentObjectList.Create;
+  FRows := TGLPersistentObjectList.Create;
   FRowMax := -1;
 end;
 
@@ -294,7 +294,7 @@ begin
   inherited;
 end;
 
-procedure TGLTiledArea.WriteToFiler(writer: TGVirtualWriter);
+procedure TGLTiledArea.WriteToFiler(writer: TGLVirtualWriter);
 begin
   inherited WriteToFiler(writer);
   with writer do
@@ -305,7 +305,7 @@ begin
   end;
 end;
 
-procedure TGLTiledArea.ReadFromFiler(reader: TGVirtualReader);
+procedure TGLTiledArea.ReadFromFiler(reader: TGLVirtualReader);
 var
   archiveVersion: Integer;
 begin
@@ -373,7 +373,7 @@ begin
   Result := (FRows.Count = 0);
 end;
 
-procedure TGLTiledArea.RemapTiles(remapList: TgIntegerList);
+procedure TGLTiledArea.RemapTiles(remapList: TGLIntegerList);
 var
   i: Integer;
   r: TGLTiledAreaRow;
@@ -542,7 +542,7 @@ end;
 procedure TGLTilePlane.BuildList(var rci: TGLRenderContextInfo);
 type
   TQuadListInfo = packed record
-    x, y: TgIntegerList;
+    x, y: TGLIntegerList;
   end;
 
   procedure IssueQuad(col, row: Integer);
@@ -574,8 +574,8 @@ begin
     SetLength(quadInfos, MaterialLibrary.Materials.Count);
     for i := 0 to High(quadInfos) do
     begin // correction in (i:=0) from (i:=1)
-      quadInfos[i].x := TgIntegerList.Create;
-      quadInfos[i].y := TgIntegerList.Create;
+      quadInfos[i].x := TGLIntegerList.Create;
+      quadInfos[i].y := TGLIntegerList.Create;
     end;
     // collect quads into quadInfos, sorted by material
     for row := Tiles.RowMin to Tiles.RowMax do

Source/GLS.Tree.pas

@@ -79,8 +79,8 @@ type
     FBranchID: Integer;
     FParentID: Integer;
     FMatrix: TGLMatrix;
-    FLower: TgIntegerList;
-    FUpper: TgIntegerList;
+    FLower: TGLIntegerList;
+    FUpper: TGLIntegerList;
     FCentralLeader: Boolean;
     procedure BuildBranch(branchNoise: TGLTreeBranchNoise;
       const matrix: TGLMatrix; TexCoordY, Twist: Single; Level: Integer);
@@ -93,23 +93,23 @@ type
     property Right: TGLTreeBranch read FRight;
     property Parent: TGLTreeBranch read FParent;
     property matrix: TGLMatrix read FMatrix;
-    property Lower: TgIntegerList read FLower;
-    property Upper: TgIntegerList read FUpper;
+    property Lower: TGLIntegerList read FLower;
+    property Upper: TGLIntegerList read FUpper;
   end;
 
   TGLTreeBranches = class
   private
     FOwner: TGLTree;
-    FSinList: TGSingleList;
-    FCosList: TGSingleList;
+    FSinList: TGLSingleList;
+    FCosList: TGLSingleList;
     FVertices: TGLAffineVectorList;
     FNormals: TGLAffineVectorList;
     FTexCoords: TGLAffineVectorList;
-    FIndices: TgIntegerList;
+    FIndices: TGLIntegerList;
     FRoot: TGLTreeBranch;
     FCount: Integer;
     FBranchCache: TList;
-    FBranchIndices: TgIntegerList;
+    FBranchIndices: TGLIntegerList;
     procedure BuildBranches;
   public
     constructor Create(AOwner: TGLTree);
@@ -117,8 +117,8 @@ type
     procedure BuildList(var rci: TGLRenderContextInfo);
     procedure Clear;
     property Owner: TGLTree read FOwner;
-    property SinList: TGSingleList read FSinList;
-    property CosList: TGSingleList read FCosList;
+    property SinList: TGLSingleList read FSinList;
+    property CosList: TGLSingleList read FCosList;
     property Vertices: TGLAffineVectorList read FVertices;
     property Normals: TGLAffineVectorList read FNormals;
     property TexCoords: TGLAffineVectorList read FTexCoords;
@@ -371,8 +371,8 @@ constructor TGLTreeBranch.Create(AOwner: TGLTreeBranches;
 begin
   FOwner := AOwner;
   FParent := AParent;
-  FUpper := TgIntegerList.Create;
-  FLower := TgIntegerList.Create;
+  FUpper := TGLIntegerList.Create;
+  FLower := TGLIntegerList.Create;
   FCentralLeader := False;
 
   // Skeletal construction helpers
@@ -613,14 +613,14 @@ end;
 constructor TGLTreeBranches.Create(AOwner: TGLTree);
 begin
   FOwner := AOwner;
-  FSinList := TGSingleList.Create;
-  FCosList := TGSingleList.Create;
+  FSinList := TGLSingleList.Create;
+  FCosList := TGLSingleList.Create;
   FVertices := TGLAffineVectorList.Create;
   FNormals := TGLAffineVectorList.Create;
   FTexCoords := TGLAffineVectorList.Create;
-  FIndices := TgIntegerList.Create;
+  FIndices := TGLIntegerList.Create;
   FBranchCache := TList.Create;
-  FBranchIndices := TgIntegerList.Create;
+  FBranchIndices := TGLIntegerList.Create;
   FCount := 0;
 end;
 

Source/GLS.VectorFileObjects.pas

@@ -82,8 +82,8 @@ type
     constructor Create; override;
     destructor Destroy; override;
     procedure Assign(Source: TPersistent); override;
-    procedure WriteToFiler(writer: TGVirtualWriter); override;
-    procedure ReadFromFiler(reader: TGVirtualReader); override;
+    procedure WriteToFiler(writer: TGLVirtualWriter); override;
+    procedure ReadFromFiler(reader: TGLVirtualReader); override;
     // Clears all mesh object data, submeshes, facegroups, etc.
     procedure Clear; virtual;
     // Translates all the vertices by the given delta.
@@ -100,8 +100,8 @@ type
       The only valid modes are currently momTriangles and momTriangleStrip
       (ie. momFaceGroups not supported).
     *)
-    procedure BuildNormals(vertexIndices: TgIntegerList; mode: TGLMeshObjectMode;
-	  NormalIndices: TgIntegerList = nil);
+    procedure BuildNormals(vertexIndices: TGLIntegerList; mode: TGLMeshObjectMode;
+	  NormalIndices: TGLIntegerList = nil);
     // Builds normals faster without index calculations for the stripe mode
     procedure GenericOrderedBuildNormals (mode: TGLMeshObjectMode);
     (*
@@ -136,19 +136,19 @@ type
     FName: string;
     FPosition: TGLAffineVectorList;
     FRotation: TGLAffineVectorList;
-    FQuaternion: TGQuaternionList;
+    FQuaternion: TGLQuaternionList;
     FLocalMatrixList: PMatrixArray;
     FTransformMode: TGLSkeletonFrameTransform;
   protected
     procedure SetPosition(const val: TGLAffineVectorList);
     procedure SetRotation(const val: TGLAffineVectorList);
-    procedure SetQuaternion(const val: TGQuaternionList);
+    procedure SetQuaternion(const val: TGLQuaternionList);
   public
     constructor CreateOwned(aOwner: TGLSkeletonFrameList);
     constructor Create; override;
     destructor Destroy; override;
-    procedure WriteToFiler(writer: TGVirtualWriter); override;
-    procedure ReadFromFiler(reader: TGVirtualReader); override;
+    procedure WriteToFiler(writer: TGLVirtualWriter); override;
+    procedure ReadFromFiler(reader: TGLVirtualReader); override;
     property Owner: TGLSkeletonFrameList read FOwner;
     property Name: string read FName write FName;
     // Position values for the joints.
@@ -157,7 +157,7 @@ type
     property Rotation: TGLAffineVectorList read FRotation write SetRotation;
     (* Quaternions are an alternative to Euler rotations to build the
       global matrices for the skeleton bones. *)
-    property Quaternion: TGQuaternionList read FQuaternion write SetQuaternion;
+    property Quaternion: TGLQuaternionList read FQuaternion write SetQuaternion;
     (* TransformMode indicates whether to use Rotation or Quaternion to build
       the local transform matrices. *)
     property TransformMode: TGLSkeletonFrameTransform read FTransformMode write FTransformMode;
@@ -175,7 +175,7 @@ type
   end;
 
   // A list of TGLSkeletonFrame objects
-  TGLSkeletonFrameList = class(TgPersistentObjectList)
+  TGLSkeletonFrameList = class(TGLPersistentObjectList)
   private
     FOwner: TPersistent;
   protected
@@ -183,7 +183,7 @@ type
   public
     constructor CreateOwned(aOwner: TPersistent);
     destructor Destroy; override;
-    procedure ReadFromFiler(reader: TGVirtualReader); override;
+    procedure ReadFromFiler(reader: TGLVirtualReader); override;
     // As the name states; Convert Quaternions to Rotations or vice-versa.
     procedure ConvertQuaternionsToRotations(KeepQuaternions: Boolean = True; SetTransformMode: Boolean = True);
     procedure ConvertRotationsToQuaternions(KeepRotations: Boolean = True; SetTransformMode: Boolean = True);
@@ -196,7 +196,7 @@ type
   TGLSkeletonBone = class;
 
   // A list of skeleton bones
-  TGLSkeletonBoneList = class(TgPersistentObjectList)
+  TGLSkeletonBoneList = class(TGLPersistentObjectList)
   private
     FSkeleton: TGLSkeleton; // not persistent
   protected
@@ -207,8 +207,8 @@ type
     constructor CreateOwned(aOwner: TGLSkeleton);
     constructor Create; override;
     destructor Destroy; override;
-    procedure WriteToFiler(writer: TGVirtualWriter); override;
-    procedure ReadFromFiler(reader: TGVirtualReader); override;
+    procedure WriteToFiler(writer: TGLVirtualWriter); override;
+    procedure ReadFromFiler(reader: TGLVirtualReader); override;
     property Skeleton: TGLSkeleton read FSkeleton;
     property Items[Index: Integer]: TGLSkeletonBone read GetSkeletonBone; default;
     // Returns a bone by its BoneID, nil if not found.
@@ -225,8 +225,8 @@ type
   // This list store skeleton root bones exclusively
   TGLSkeletonRootBoneList = class(TGLSkeletonBoneList)
   public
-    procedure WriteToFiler(writer: TGVirtualWriter); override;
-    procedure ReadFromFiler(reader: TGVirtualReader); override;
+    procedure WriteToFiler(writer: TGLVirtualWriter); override;
+    procedure ReadFromFiler(reader: TGLVirtualReader); override;
     // Render skeleton wireframe
     procedure BuildList(var mrci: TGLRenderContextInfo); override;
     property GlobalMatrix: TGLMatrix read FGlobalMatrix write FGlobalMatrix;
@@ -251,8 +251,8 @@ type
     constructor CreateOwned(aOwner: TGLSkeletonBoneList);
     constructor Create; override;
     destructor Destroy; override;
-    procedure WriteToFiler(writer: TGVirtualWriter); override;
-    procedure ReadFromFiler(reader: TGVirtualReader); override;
+    procedure WriteToFiler(writer: TGLVirtualWriter); override;
+    procedure ReadFromFiler(reader: TGLVirtualReader); override;
     // Render skeleton wireframe
     procedure BuildList(var mrci: TGLRenderContextInfo); override;
     property Owner: TGLSkeletonBoneList read FOwner;
@@ -303,8 +303,8 @@ type
   public
     constructor Create; override;
     constructor CreateOwned(AOwner: TGLSkeletonColliderList);
-    procedure WriteToFiler(writer: TGVirtualWriter); override;
-    procedure ReadFromFiler(reader: TGVirtualReader); override;
+    procedure WriteToFiler(writer: TGLVirtualWriter); override;
+    procedure ReadFromFiler(reader: TGLVirtualReader); override;
     (* This method is used to align the colliders and their
       derived objects to their associated skeleton bone.
       Override to set up descendant class alignment properties. *)
@@ -321,7 +321,7 @@ type
   end;
 
   // List class for storing TGLSkeletonCollider objects
-  TGLSkeletonColliderList = class(TgPersistentObjectList)
+  TGLSkeletonColliderList = class(TGLPersistentObjectList)
   private
     FOwner: TPersistent;
   protected
@@ -329,7 +329,7 @@ type
   public
     constructor CreateOwned(AOwner: TPersistent);
     destructor Destroy; override;
-    procedure ReadFromFiler(reader: TGVirtualReader); override;
+    procedure ReadFromFiler(reader: TGLVirtualReader); override;
     procedure Clear; override;
     // Calls AlignCollider for each collider in the list.
     procedure AlignColliders;
@@ -346,7 +346,7 @@ type
     Weight: Single;
     ExternalPositions: TGLAffineVectorList;
     ExternalRotations: TGLAffineVectorList;
-    ExternalQuaternions: TGQuaternionList;
+    ExternalQuaternions: TGLQuaternionList;
   end;
 
   (* Main skeleton object. This class stores the bones hierarchy and animation frames.
@@ -372,8 +372,8 @@ type
     constructor CreateOwned(aOwner: TGLBaseMesh);
     constructor Create; override;
     destructor Destroy; override;
-    procedure WriteToFiler(writer: TGVirtualWriter); override;
-    procedure ReadFromFiler(reader: TGVirtualReader); override;
+    procedure WriteToFiler(writer: TGLVirtualWriter); override;
+    procedure ReadFromFiler(reader: TGLVirtualReader); override;
     property Owner: TGLBaseMesh read FOwner;
     property RootBones: TGLSkeletonRootBoneList read FRootBones write SetRootBones;
     property Frames: TGLSkeletonFrameList read FFrames write SetFrames;
@@ -489,8 +489,8 @@ type
     constructor Create; override;
     destructor Destroy; override;
     procedure Assign(Source: TPersistent); override;
-    procedure WriteToFiler(writer: TGVirtualWriter); override;
-    procedure ReadFromFiler(reader: TGVirtualReader); override;
+    procedure WriteToFiler(writer: TGLVirtualWriter); override;
+    procedure ReadFromFiler(reader: TGLVirtualReader); override;
     procedure Clear; override;
     function ExtractTriangles(texCoords: TGLAffineVectorList = nil;
 	    Normals: TGLAffineVectorList = nil): TGLAffineVectorList; override;
@@ -549,7 +549,7 @@ type
   end;
 
   // A list of TGLMeshObject objects.
-  TGLMeshObjectList = class(TgPersistentObjectList)
+  TGLMeshObjectList = class(TGLPersistentObjectList)
   private
     FOwner: TGLBaseMesh;
     // Returns True if all its MeshObjects use VBOs.
@@ -560,7 +560,7 @@ type
   public
     constructor CreateOwned(aOwner: TGLBaseMesh);
     destructor Destroy; override;
-    procedure ReadFromFiler(reader: TGVirtualReader); override;
+    procedure ReadFromFiler(reader: TGLVirtualReader); override;
     procedure PrepareMaterialLibraryCache(matLib: TGLMaterialLibrary);
     procedure DropMaterialLibraryCache;
     (* Prepare the texture and materials before rendering.
@@ -604,13 +604,13 @@ type
   public
     constructor CreateOwned(aOwner: TGLMeshMorphTargetList);
     destructor Destroy; override;
-    procedure WriteToFiler(writer: TGVirtualWriter); override;
-    procedure ReadFromFiler(reader: TGVirtualReader); override;
+    procedure WriteToFiler(writer: TGLVirtualWriter); override;
+    procedure ReadFromFiler(reader: TGLVirtualReader); override;
     property Owner: TGLMeshMorphTargetList read FOwner;
   end;
 
   // A list of TGLMeshMorphTarget objects. 
-  TGLMeshMorphTargetList = class(TgPersistentObjectList)
+  TGLMeshMorphTargetList = class(TGLPersistentObjectList)
   private
     FOwner: TPersistent;
   protected
@@ -618,7 +618,7 @@ type
   public
     constructor CreateOwned(AOwner: TPersistent);
     destructor Destroy; override;
-    procedure ReadFromFiler(reader: TGVirtualReader); override;
+    procedure ReadFromFiler(reader: TGLVirtualReader); override;
     procedure Translate(const delta: TAffineVector);
     property Owner: TPersistent read FOwner;
     procedure Clear; override;
@@ -633,8 +633,8 @@ type
   public
     constructor Create; override;
     destructor Destroy; override;
-    procedure WriteToFiler(writer: TGVirtualWriter); override;
-    procedure ReadFromFiler(reader: TGVirtualReader); override;
+    procedure WriteToFiler(writer: TGLVirtualWriter); override;
+    procedure ReadFromFiler(reader: TGLVirtualReader); override;
     procedure Clear; override;
     procedure Translate(const delta: TAffineVector); override;
     procedure MorphTo(morphTargetIndex: Integer); virtual;
@@ -678,8 +678,8 @@ type
   public
     constructor Create; override;
     destructor Destroy; override;
-    procedure WriteToFiler(writer: TGVirtualWriter); override;
-    procedure ReadFromFiler(reader: TGVirtualReader); override;
+    procedure WriteToFiler(writer: TGLVirtualWriter); override;
+    procedure ReadFromFiler(reader: TGLVirtualReader); override;
     procedure Clear; override;
     property VerticesBonesWeights: PGLVerticesBoneWeights read FVerticesBonesWeights;
     property VerticeBoneWeightCount: Integer read FVerticeBoneWeightCount write SetVerticeBoneWeightCount;
@@ -713,8 +713,8 @@ type
   public
     constructor CreateOwned(aOwner: TGLFaceGroups); virtual;
     destructor Destroy; override;
-    procedure WriteToFiler(writer: TGVirtualWriter); override;
-    procedure ReadFromFiler(reader: TGVirtualReader); override;
+    procedure WriteToFiler(writer: TGLVirtualWriter); override;
+    procedure ReadFromFiler(reader: TGLVirtualReader); override;
     procedure PrepareMaterialLibraryCache(matLib: TGLMaterialLibrary);
     procedure DropMaterialLibraryCache;
     procedure BuildList(var mrci: TGLRenderContextInfo); virtual; abstract;
@@ -751,19 +751,19 @@ type
     in the order given by the vertices. *)
   TFGVertexIndexList = class(TGLFaceGroup)
   private
-    FVertexIndices: TgIntegerList;
+    FVertexIndices: TGLIntegerList;
     FIndexVBO: TGLVBOElementArrayHandle;
     FMode: TGLFaceGroupMeshMode;
     procedure SetupVBO;
     procedure InvalidateVBO;
   protected
-    procedure SetVertexIndices(const val: TgIntegerList);
-    procedure AddToList(Source, destination: TGLAffineVectorList; indices: TgIntegerList);
+    procedure SetVertexIndices(const val: TGLIntegerList);
+    procedure AddToList(Source, destination: TGLAffineVectorList; indices: TGLIntegerList);
   public
     constructor Create; override;
     destructor Destroy; override;
-    procedure WriteToFiler(writer: TGVirtualWriter); override;
-    procedure ReadFromFiler(reader: TGVirtualReader); override;
+    procedure WriteToFiler(writer: TGLVirtualWriter); override;
+    procedure ReadFromFiler(reader: TGLVirtualReader); override;
     procedure BuildList(var mrci: TGLRenderContextInfo); override;
     procedure AddToTriangles(aList: TGLAffineVectorList; aTexCoords: TGLAffineVectorList = nil;
       aNormals: TGLAffineVectorList = nil); override;
@@ -776,7 +776,7 @@ type
     // Return the normal from the 1st three points in the facegroup
     function GetNormal: TAffineVector;
     property Mode: TGLFaceGroupMeshMode read FMode write FMode;
-    property VertexIndices: TgIntegerList read FVertexIndices write SetVertexIndices;
+    property VertexIndices: TGLIntegerList read FVertexIndices write SetVertexIndices;
   end;
 
   (* Adds normals and texcoords indices.
@@ -784,22 +784,22 @@ type
     indices are optionnal, if missing (empty), VertexIndices will be used. *)
   TFGVertexNormalTexIndexList = class(TFGVertexIndexList)
   private
-    FNormalIndices: TgIntegerList;
-    FTexCoordIndices: TgIntegerList;
+    FNormalIndices: TGLIntegerList;
+    FTexCoordIndices: TGLIntegerList;
   protected
-    procedure SetNormalIndices(const val: TgIntegerList); inline;
-    procedure SetTexCoordIndices(const val: TgIntegerList); inline;
+    procedure SetNormalIndices(const val: TGLIntegerList); inline;
+    procedure SetTexCoordIndices(const val: TGLIntegerList); inline;
   public
     constructor Create; override;
     destructor Destroy; override;
-    procedure WriteToFiler(writer: TGVirtualWriter); override;
-    procedure ReadFromFiler(reader: TGVirtualReader); override;
+    procedure WriteToFiler(writer: TGLVirtualWriter); override;
+    procedure ReadFromFiler(reader: TGLVirtualReader); override;
     procedure BuildList(var mrci: TGLRenderContextInfo); override;
     procedure AddToTriangles(aList: TGLAffineVectorList; aTexCoords: TGLAffineVectorList = nil;
       aNormals: TGLAffineVectorList = nil); override;
     procedure Add(vertexIdx, normalIdx, texCoordIdx: Integer);
-    property NormalIndices: TgIntegerList read FNormalIndices write  SetNormalIndices;
-    property TexCoordIndices: TgIntegerList read FTexCoordIndices write  SetTexCoordIndices;
+    property NormalIndices: TGLIntegerList read FNormalIndices write  SetNormalIndices;
+    property TexCoordIndices: TGLIntegerList read FTexCoordIndices write  SetTexCoordIndices;
   end;
 
   (* Adds per index texture coordinates to its ancestor.
@@ -813,8 +813,8 @@ type
   public
     constructor Create; override;
     destructor Destroy; override;
-    procedure WriteToFiler(writer: TGVirtualWriter); override;
-    procedure ReadFromFiler(reader: TGVirtualReader); override;
+    procedure WriteToFiler(writer: TGLVirtualWriter); override;
+    procedure ReadFromFiler(reader: TGLVirtualReader); override;
     procedure BuildList(var mrci: TGLRenderContextInfo); override;
     procedure AddToTriangles(aList: TGLAffineVectorList; aTexCoords: TGLAffineVectorList = nil;
       aNormals: TGLAffineVectorList = nil); override;
@@ -824,7 +824,7 @@ type
   end;
 
   // A list of TGLFaceGroup objects. 
-  TGLFaceGroups = class(TgPersistentObjectList)
+  TGLFaceGroups = class(TGLPersistentObjectList)
   private
     FOwner: TGLMeshObject;
   protected
@@ -832,7 +832,7 @@ type
   public
     constructor CreateOwned(aOwner: TGLMeshObject);
     destructor Destroy; override;
-    procedure ReadFromFiler(reader: TGVirtualReader); override;
+    procedure ReadFromFiler(reader: TGLVirtualReader); override;
     procedure PrepareMaterialLibraryCache(matLib: TGLMaterialLibrary);
     procedure DropMaterialLibraryCache;
     property Owner: TGLMeshObject read FOwner;
@@ -1307,7 +1307,7 @@ type
   end;
 
   // Stores registered vector file formats 
-  TGLVectorFileFormatsList = class(TgPersistentObjectList)
+  TGLVectorFileFormatsList = class(TGLPersistentObjectList)
   public
     destructor Destroy; override;
     procedure Add(const Ext, Desc: string; DescID: Integer; AClass: TGLVectorFileClass);
@@ -1555,7 +1555,7 @@ begin
     inherited; // Die!
 end;
 
-procedure TGLBaseMeshObject.WriteToFiler(writer: TGVirtualWriter);
+procedure TGLBaseMeshObject.WriteToFiler(writer: TGLVirtualWriter);
 begin
   inherited WriteToFiler(writer);
   with writer do
@@ -1568,7 +1568,7 @@ begin
   end;
 end;
 
-procedure TGLBaseMeshObject.ReadFromFiler(reader: TGVirtualReader);
+procedure TGLBaseMeshObject.ReadFromFiler(reader: TGLVirtualReader);
 var
   archiveVersion: Integer;
 begin
@@ -1606,12 +1606,12 @@ begin
   FVertices.Translate(delta);
 end;
 
-procedure TGLBaseMeshObject.BuildNormals(vertexIndices: TgIntegerList; Mode: TGLMeshObjectMode;
-  normalIndices: TgIntegerList = nil);
+procedure TGLBaseMeshObject.BuildNormals(vertexIndices: TGLIntegerList; Mode: TGLMeshObjectMode;
+  normalIndices: TGLIntegerList = nil);
 var
   i, base: Integer;
   n: TAffineVector;
-  newNormals: TgIntegerList;
+  newNormals: TGLIntegerList;
 
   function TranslateNewNormal(vertexIndex: Integer; const delta: TAffineVector): Integer;
   var
@@ -1690,7 +1690,7 @@ begin
   begin
     // add new normals
     base := Normals.Count;
-    newNormals := TgIntegerList.Create;
+    newNormals := TGLIntegerList.Create;
     newNormals.AddSerie(-1, 0, Vertices.Count);
     case Mode of
       momTriangles:
@@ -1834,7 +1834,7 @@ begin
   inherited Create;
   FPosition := TGLAffineVectorList.Create;
   FRotation := TGLAffineVectorList.Create;
-  FQuaternion := TGQuaternionList.Create;
+  FQuaternion := TGLQuaternionList.Create;
   FTransformMode := sftRotation;
 end;
 
@@ -1847,7 +1847,7 @@ begin
   inherited Destroy;
 end;
 
-procedure TGLSkeletonFrame.WriteToFiler(writer: TGVirtualWriter);
+procedure TGLSkeletonFrame.WriteToFiler(writer: TGLVirtualWriter);
 begin
   inherited WriteToFiler(writer);
   with writer do
@@ -1861,7 +1861,7 @@ begin
   end;
 end;
 
-procedure TGLSkeletonFrame.ReadFromFiler(reader: TGVirtualReader);
+procedure TGLSkeletonFrame.ReadFromFiler(reader: TGLVirtualReader);
 var
   archiveVersion: Integer;
 begin
@@ -1894,7 +1894,7 @@ begin
   FRotation.Assign(val);
 end;
 
-procedure TGLSkeletonFrame.SetQuaternion(const val: TGQuaternionList);
+procedure TGLSkeletonFrame.SetQuaternion(const val: TGLQuaternionList);
 begin
   FQuaternion.Assign(val);
 end;
@@ -2027,7 +2027,7 @@ begin
   inherited;
 end;
 
-procedure TGLSkeletonFrameList.ReadFromFiler(reader: TGVirtualReader);
+procedure TGLSkeletonFrameList.ReadFromFiler(reader: TGLVirtualReader);
 var
   i: Integer;
 begin
@@ -2100,7 +2100,7 @@ begin
   inherited;
 end;
 
-procedure TGLSkeletonBoneList.WriteToFiler(writer: TGVirtualWriter);
+procedure TGLSkeletonBoneList.WriteToFiler(writer: TGLVirtualWriter);
 begin
   inherited WriteToFiler(writer);
   with writer do
@@ -2110,7 +2110,7 @@ begin
   end;
 end;
 
-procedure TGLSkeletonBoneList.ReadFromFiler(reader: TGVirtualReader);
+procedure TGLSkeletonBoneList.ReadFromFiler(reader: TGLVirtualReader);
 var
   archiveVersion, i: Integer;
 begin
@@ -2188,7 +2188,7 @@ end;
 // ------------------ TGLSkeletonRootBoneList ------------------
 // ------------------
 
-procedure TGLSkeletonRootBoneList.WriteToFiler(writer: TGVirtualWriter);
+procedure TGLSkeletonRootBoneList.WriteToFiler(writer: TGLVirtualWriter);
 begin
   inherited WriteToFiler(writer);
   with writer do
@@ -2198,7 +2198,7 @@ begin
   end;
 end;
 
-procedure TGLSkeletonRootBoneList.ReadFromFiler(reader: TGVirtualReader);
+procedure TGLSkeletonRootBoneList.ReadFromFiler(reader: TGLVirtualReader);
 var
   archiveVersion, i: Integer;
 begin
@@ -2253,7 +2253,7 @@ begin
   inherited Destroy;
 end;
 
-procedure TGLSkeletonBone.WriteToFiler(writer: TGVirtualWriter);
+procedure TGLSkeletonBone.WriteToFiler(writer: TGLVirtualWriter);
 begin
   inherited WriteToFiler(writer);
   with writer do
@@ -2265,7 +2265,7 @@ begin
   end;
 end;
 
-procedure TGLSkeletonBone.ReadFromFiler(reader: TGVirtualReader);
+procedure TGLSkeletonBone.ReadFromFiler(reader: TGLVirtualReader);
 var
   archiveVersion, i: Integer;
 begin
@@ -2389,7 +2389,7 @@ begin
     FOwner.Add(Self);
 end;
 
-procedure TGLSkeletonCollider.WriteToFiler(writer: TGVirtualWriter);
+procedure TGLSkeletonCollider.WriteToFiler(writer: TGLVirtualWriter);
 begin
   inherited WriteToFiler(writer);
   with writer do
@@ -2403,7 +2403,7 @@ begin
   end;
 end;
 
-procedure TGLSkeletonCollider.ReadFromFiler(reader: TGVirtualReader);
+procedure TGLSkeletonCollider.ReadFromFiler(reader: TGLVirtualReader);
 var
   archiveVersion: Integer;
 begin
@@ -2469,7 +2469,7 @@ begin
   Result := TGLSkeletonCollider(inherited Get(index));
 end;
 
-procedure TGLSkeletonColliderList.ReadFromFiler(reader: TGVirtualReader);
+procedure TGLSkeletonColliderList.ReadFromFiler(reader: TGLVirtualReader);
 var
   i: Integer;
 begin
@@ -2531,7 +2531,7 @@ begin
   inherited Destroy;
 end;
 
-procedure TGLSkeleton.WriteToFiler(writer: TGVirtualWriter);
+procedure TGLSkeleton.WriteToFiler(writer: TGLVirtualWriter);
 begin
   inherited WriteToFiler(writer);
   with writer do
@@ -2547,7 +2547,7 @@ begin
   end;
 end;
 
-procedure TGLSkeleton.ReadFromFiler(reader: TGVirtualReader);
+procedure TGLSkeleton.ReadFromFiler(reader: TGLVirtualReader);
 var
   archiveVersion: Integer;
 begin
@@ -2669,7 +2669,7 @@ var
   i, n: Integer;
   blendPositions: TGLAffineVectorList;
   blendRotations: TGLAffineVectorList;
-  blendQuaternions: TGQuaternionList;
+  blendQuaternions: TGLQuaternionList;
 begin
   n := High(lerpInfos) - Low(lerpInfos) + 1;
   Assert(n >= 1);
@@ -2743,7 +2743,7 @@ begin
 
         sftQuaternion:
           begin
-            blendQuaternions := TGQuaternionList.Create;
+            blendQuaternions := TGLQuaternionList.Create;
             // Initial frame lerp
             Quaternion.Lerp(Frames[lerpInfos[i].frameIndex1].Quaternion,
               Frames[lerpInfos[i].frameIndex2].Quaternion,
@@ -2975,7 +2975,7 @@ begin
   end;
 end;
 
-procedure TGLMeshObject.WriteToFiler(writer: TGVirtualWriter);
+procedure TGLMeshObject.WriteToFiler(writer: TGLVirtualWriter);
 var
   i: Integer;
 begin
@@ -2998,10 +2998,10 @@ begin
   end;
 end;
 
-procedure TGLMeshObject.ReadFromFiler(reader: TGVirtualReader);
+procedure TGLMeshObject.ReadFromFiler(reader: TGLVirtualReader);
 var
   i, Count, archiveVersion: Integer;
-  lOldLightMapTexCoords: TGTexPointList;
+  lOldLightMapTexCoords: TGLTexPointList;
   tc: TTexPoint;
   size, ro: Integer;
 begin
@@ -3018,7 +3018,7 @@ begin
       end
       else if (archiveVersion = 1) or (archiveVersion = 2) then
       begin
-        lOldLightMapTexCoords := TGTexPointList.CreateFromFiler(reader);
+        lOldLightMapTexCoords := TGLTexPointList.CreateFromFiler(reader);
         for i := 0 to lOldLightMapTexCoords.Count - 1 do
         begin
           tc:=lOldLightMapTexCoords[i];
@@ -4212,7 +4212,7 @@ begin
   inherited;
 end;
 
-procedure TGLMeshObjectList.ReadFromFiler(reader: TGVirtualReader);
+procedure TGLMeshObjectList.ReadFromFiler(reader: TGLVirtualReader);
 var
   i: Integer;
   mesh: TGLMeshObject;
@@ -4523,7 +4523,7 @@ begin
   inherited;
 end;
 
-procedure TGLMeshMorphTarget.WriteToFiler(writer: TGVirtualWriter);
+procedure TGLMeshMorphTarget.WriteToFiler(writer: TGLVirtualWriter);
 begin
   inherited WriteToFiler(writer);
   with writer do
@@ -4533,7 +4533,7 @@ begin
   end;
 end;
 
-procedure TGLMeshMorphTarget.ReadFromFiler(reader: TGVirtualReader);
+procedure TGLMeshMorphTarget.ReadFromFiler(reader: TGLVirtualReader);
 var
   archiveVersion: Integer;
 begin
@@ -4564,7 +4564,7 @@ begin
   inherited;
 end;
 
-procedure TGLMeshMorphTargetList.ReadFromFiler(reader: TGVirtualReader);
+procedure TGLMeshMorphTargetList.ReadFromFiler(reader: TGLVirtualReader);
 var
   i: Integer;
 begin
@@ -4615,7 +4615,7 @@ begin
   inherited;
 end;
 
-procedure TGLMorphableMeshObject.WriteToFiler(writer: TGVirtualWriter);
+procedure TGLMorphableMeshObject.WriteToFiler(writer: TGLVirtualWriter);
 begin
   inherited WriteToFiler(writer);
   with writer do
@@ -4625,7 +4625,7 @@ begin
   end;
 end;
 
-procedure TGLMorphableMeshObject.ReadFromFiler(reader: TGVirtualReader);
+procedure TGLMorphableMeshObject.ReadFromFiler(reader: TGLVirtualReader);
 var
   archiveVersion: Integer;
 begin
@@ -4720,7 +4720,7 @@ begin
   inherited Destroy;
 end;
 
-procedure TGLSkeletonMeshObject.WriteToFiler(writer: TGVirtualWriter);
+procedure TGLSkeletonMeshObject.WriteToFiler(writer: TGLVirtualWriter);
 var
   i: Integer;
 begin
@@ -4736,7 +4736,7 @@ begin
   end;
 end;
 
-procedure TGLSkeletonMeshObject.ReadFromFiler(reader: TGVirtualReader);
+procedure TGLSkeletonMeshObject.ReadFromFiler(reader: TGLVirtualReader);
 var
   archiveVersion, i: Integer;
 begin
@@ -5103,7 +5103,7 @@ begin
   inherited;
 end;
 
-procedure TGLFaceGroup.WriteToFiler(writer: TGVirtualWriter);
+procedure TGLFaceGroup.WriteToFiler(writer: TGLVirtualWriter);
 begin
   inherited WriteToFiler(writer);
   with writer do
@@ -5122,7 +5122,7 @@ begin
   end;
 end;
 
-procedure TGLFaceGroup.ReadFromFiler(reader: TGVirtualReader);
+procedure TGLFaceGroup.ReadFromFiler(reader: TGLVirtualReader);
 var
   archiveVersion: Integer;
 begin
@@ -5219,7 +5219,7 @@ end;
 constructor TFGVertexIndexList.Create;
 begin
   inherited;
-  FVertexIndices := TgIntegerList.Create;
+  FVertexIndices := TGLIntegerList.Create;
   FMode := fgmmTriangles;
 end;
 
@@ -5230,7 +5230,7 @@ begin
   inherited;
 end;
 
-procedure TFGVertexIndexList.WriteToFiler(writer: TGVirtualWriter);
+procedure TFGVertexIndexList.WriteToFiler(writer: TGLVirtualWriter);
 begin
   inherited WriteToFiler(writer);
   with writer do
@@ -5241,7 +5241,7 @@ begin
   end;
 end;
 
-procedure TFGVertexIndexList.ReadFromFiler(reader: TGVirtualReader);
+procedure TFGVertexIndexList.ReadFromFiler(reader: TGLVirtualReader);
 var
   archiveVersion: Integer;
 begin
@@ -5274,7 +5274,7 @@ begin
   end;
 end;
 
-procedure TFGVertexIndexList.SetVertexIndices(const val: TgIntegerList);
+procedure TFGVertexIndexList.SetVertexIndices(const val: TGLIntegerList);
 begin
   FVertexIndices.Assign(val);
   InvalidateVBO;
@@ -5304,7 +5304,7 @@ begin
   end;
 end;
 
-procedure TFGVertexIndexList.AddToList(Source, destination: TGLAffineVectorList; indices: TgIntegerList);
+procedure TFGVertexIndexList.AddToList(Source, destination: TGLAffineVectorList; indices: TGLIntegerList);
 var
   i, n: Integer;
 begin
@@ -5440,14 +5440,14 @@ end;
 procedure TFGVertexIndexList.ConvertToList;
 var
   i: Integer;
-  bufList: TgIntegerList;
+  bufList: TGLIntegerList;
 begin
   if VertexIndices.Count >= 3 then
   begin
     case Mode of
       fgmmTriangleStrip:
         begin
-          bufList := TgIntegerList.Create;
+          bufList := TGLIntegerList.Create;
           try
             ConvertStripToList(VertexIndices, bufList);
             VertexIndices := bufList;
@@ -5458,7 +5458,7 @@ begin
         end;
       fgmmTriangleFan:
         begin
-          bufList := TgIntegerList.Create;
+          bufList := TGLIntegerList.Create;
           try
             for i := 0 to VertexIndices.Count - 3 do
               bufList.Add(vertexIndices[0], vertexIndices[i], vertexIndices[i + 1]);
@@ -5496,8 +5496,8 @@ end;
 constructor TFGVertexNormalTexIndexList.Create;
 begin
   inherited;
-  FNormalIndices := TgIntegerList.Create;
-  FTexCoordIndices := TgIntegerList.Create;
+  FNormalIndices := TGLIntegerList.Create;
+  FTexCoordIndices := TGLIntegerList.Create;
 end;
 
 destructor TFGVertexNormalTexIndexList.Destroy;
@@ -5507,7 +5507,7 @@ begin
   inherited;
 end;
 
-procedure TFGVertexNormalTexIndexList.WriteToFiler(writer: TGVirtualWriter);
+procedure TFGVertexNormalTexIndexList.WriteToFiler(writer: TGLVirtualWriter);
 begin
   inherited WriteToFiler(writer);
   with writer do
@@ -5518,7 +5518,7 @@ begin
   end;
 end;
 
-procedure TFGVertexNormalTexIndexList.ReadFromFiler(reader: TGVirtualReader);
+procedure TFGVertexNormalTexIndexList.ReadFromFiler(reader: TGLVirtualReader);
 var
   archiveVersion: Integer;
 begin
@@ -5534,12 +5534,12 @@ begin
     RaiseFilerException(archiveVersion);
 end;
 
-procedure TFGVertexNormalTexIndexList.SetNormalIndices(const val: TgIntegerList);
+procedure TFGVertexNormalTexIndexList.SetNormalIndices(const val: TGLIntegerList);
 begin
   FNormalIndices.Assign(val);
 end;
 
-procedure TFGVertexNormalTexIndexList.SetTexCoordIndices(const val: TgIntegerList);
+procedure TFGVertexNormalTexIndexList.SetTexCoordIndices(const val: TGLIntegerList);
 begin
   FTexCoordIndices.Assign(val);
 end;
@@ -5620,7 +5620,7 @@ begin
   inherited;
 end;
 
-procedure TFGIndexTexCoordList.WriteToFiler(writer: TGVirtualWriter);
+procedure TFGIndexTexCoordList.WriteToFiler(writer: TGLVirtualWriter);
 begin
   inherited WriteToFiler(writer);
   with writer do
@@ -5630,7 +5630,7 @@ begin
   end;
 end;
 
-procedure TFGIndexTexCoordList.ReadFromFiler(reader: TGVirtualReader);
+procedure TFGIndexTexCoordList.ReadFromFiler(reader: TGLVirtualReader);
 var
   archiveVersion: Integer;
 begin
@@ -5773,7 +5773,7 @@ begin
   inherited;
 end;
 
-procedure TGLFaceGroups.ReadFromFiler(reader: TGVirtualReader);
+procedure TGLFaceGroups.ReadFromFiler(reader: TGLVirtualReader);
 var
   i: Integer;
 begin

Source/GLS.VerletClothify.pas

@@ -145,7 +145,7 @@ type
   TGLMeshObjectVerletNode = class(TGLVerletNode)
   private
     MeshObject: TGLMeshObject;
-    VertexIndices: TgIntegerList;
+    VertexIndices: TGLIntegerList;
   public
     procedure AfterProgress; override;
     constructor CreateOwned(const AOwner: TGLVerletWorld); override;
@@ -336,7 +336,7 @@ end;
 constructor TGLMeshObjectVerletNode.CreateOwned(const AOwner: TGLVerletWorld);
 begin
   inherited;
-  VertexIndices := TgIntegerList.Create;
+  VertexIndices := TGLIntegerList.Create;
 end;
 
 destructor TGLMeshObjectVerletNode.Destroy;

Source/GLS.VerletTypes.pas

@@ -673,8 +673,8 @@ type
   private
     FVerletConstraint: TGLVerletConstraint;
   public
-    procedure WriteToFiler(Writer: TGVirtualWriter); override;
-    procedure ReadFromFiler(Reader: TGVirtualReader); override;
+    procedure WriteToFiler(Writer: TGLVirtualWriter); override;
+    procedure ReadFromFiler(Reader: TGLVirtualReader); override;
     procedure AddToVerletWorld(VerletWorld: TGLVerletWorld); virtual;
     // The verlet constraint is created through the AddToVerletWorld procedure
     property VerletConstraint: TGLVerletConstraint read FVerletConstraint;
@@ -688,8 +688,8 @@ type
     procedure SetRadius(const Val: Single);
   public
     constructor Create; override;
-    procedure WriteToFiler(Writer: TGVirtualWriter); override;
-    procedure ReadFromFiler(Reader: TGVirtualReader); override;
+    procedure WriteToFiler(Writer: TGLVirtualWriter); override;
+    procedure ReadFromFiler(Reader: TGLVirtualReader); override;
     procedure AddToVerletWorld(VerletWorld: TGLVerletWorld); override;
     procedure AlignCollider; override;
     property Radius: Single read FRadius write SetRadius;
@@ -704,8 +704,8 @@ type
     procedure SetLength(const Val: Single);
   public
     constructor Create; override;
-    procedure WriteToFiler(Writer: TGVirtualWriter); override;
-    procedure ReadFromFiler(Reader: TGVirtualReader); override;
+    procedure WriteToFiler(Writer: TGLVirtualWriter); override;
+    procedure ReadFromFiler(Reader: TGLVirtualReader); override;
     procedure AddToVerletWorld(VerletWorld: TGLVerletWorld); override;
     procedure AlignCollider; override;
     property Radius: Single read FRadius write SetRadius;
@@ -2611,13 +2611,13 @@ end;
 // ------------------
 // ------------------ TGLVerletSkeletonCollider ------------------
 // ------------------
-procedure TGLVerletSkeletonCollider.WriteToFiler(Writer: TGVirtualWriter);
+procedure TGLVerletSkeletonCollider.WriteToFiler(Writer: TGLVirtualWriter);
 begin
   inherited WriteToFiler(Writer);
   Writer.WriteInteger(0); // Archive Version 0
 end;
 
-procedure TGLVerletSkeletonCollider.ReadFromFiler(Reader: TGVirtualReader);
+procedure TGLVerletSkeletonCollider.ReadFromFiler(Reader: TGLVirtualReader);
 var
   archiveVersion: Integer;
 begin
@@ -2646,14 +2646,14 @@ begin
   AlignCollider;
 end;
 
-procedure TGLVerletSphere.WriteToFiler(Writer: TGVirtualWriter);
+procedure TGLVerletSphere.WriteToFiler(Writer: TGLVirtualWriter);
 begin
   inherited WriteToFiler(Writer);
   Writer.WriteInteger(0); // Archive Version 0
   Writer.WriteFloat(FRadius);
 end;
 
-procedure TGLVerletSphere.ReadFromFiler(Reader: TGVirtualReader);
+procedure TGLVerletSphere.ReadFromFiler(Reader: TGLVirtualReader);
 var
   archiveVersion: Integer;
 begin
@@ -2702,7 +2702,7 @@ begin
   AlignCollider;
 end;
 
-procedure TGLVerletCapsule.WriteToFiler(Writer: TGVirtualWriter);
+procedure TGLVerletCapsule.WriteToFiler(Writer: TGLVirtualWriter);
 begin
   inherited WriteToFiler(Writer);
   Writer.WriteInteger(0); // Archive Version 0
@@ -2710,7 +2710,7 @@ begin
   Writer.WriteFloat(FLength);
 end;
 
-procedure TGLVerletCapsule.ReadFromFiler(Reader: TGVirtualReader);
+procedure TGLVerletCapsule.ReadFromFiler(Reader: TGLVirtualReader);
 var
   archiveVersion: Integer;
 begin