PascalType.Tables.OpenType.COLR.pas

unit PascalType.Tables.OpenType.COLR;

////////////////////////////////////////////////////////////////////////////////
//                                                                            //
//                      'COLR' table type                                     //
//                                                                            //
////////////////////////////////////////////////////////////////////////////////
//                                                                            //
//  Version: MPL 1.1 or LGPL 2.1 with linking exception                       //
//                                                                            //
//  The contents of this file are subject to the Mozilla Public License       //
//  Version 1.1 (the "License"); you may not use this file except in          //
//  compliance with the License. You may obtain a copy of the License at      //
//  http://www.mozilla.org/MPL/                                               //
//                                                                            //
//  Software distributed under the License is distributed on an "AS IS"       //
//  basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the   //
//  License for the specific language governing rights and limitations under  //
//  the License.                                                              //
//                                                                            //
//  Alternatively, the contents of this file may be used under the terms of   //
//  the Free Pascal modified version of the GNU Lesser General Public         //
//  License Version 2.1 (the "FPC modified LGPL License"), in which case the  //
//  provisions of this license are applicable instead of those above.         //
//  Please see the file LICENSE.txt for additional information concerning     //
//  this license.                                                             //
//                                                                            //
//  The code is part of the PascalType Project                                //
//                                                                            //
//  The initial developer of this code is Anders Melander.                    //
//                                                                            //
//  Portions created by Anders Melander are Copyright (C) 2024                //
//  by Anders Melander. All Rights Reserved.                                  //
//                                                                            //
////////////////////////////////////////////////////////////////////////////////

interface

{$I PT_Compiler.inc}

uses
  Generics.Collections,
  Generics.Defaults,
  Classes,
  PascalType.Types,
  PascalType.Types.Color,
  PascalType.Classes,
  PascalType.Tables,
  PascalType.Tables.OpenType,
  PascalType.Tables.OpenType.Common,
  PascalType.Tables.OpenType.Common.Variation;

//------------------------------------------------------------------------------
//
//              TOpenTypeColorCOLRTable
//
//------------------------------------------------------------------------------
// Microsoft Color table
//------------------------------------------------------------------------------
// https://learn.microsoft.com/en-us/typography/opentype/spec/COLR
//------------------------------------------------------------------------------
type
  TColorBaseGlyph = record
    GlyphID: TGlyphID;
    FirstLayerIndex: integer;
    LayerCount: integer;
  end;

  TColorGlyphLayer = record
    GlyphID: TGlyphID;
    PaletteIndex: Word; // FFFF = Use default
  end;


//----------------------------------------------------------------------------
// COLR v1 Paint Formats
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
// ColorLine table
//----------------------------------------------------------------------------
// https://learn.microsoft.com/en-us/typography/opentype/spec/colr#color-references-colorstop-and-colorline
//----------------------------------------------------------------------------
type
  TColorStop = record
    StopOffset: TF2Dot14;
    PaletteIndex: Word;
    Alpha: TF2Dot14;
  end;

  TColorLine = class(TCustomPascalTypeTable)
  private
    FExtend: Byte;
    FColorStops: TArray<TColorStop>;

  public
    procedure Assign(Source: TPersistent); override;
    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;

    property Extend: Byte read FExtend;
    property ColorStops: TArray<TColorStop> read FColorStops;
  end;


//----------------------------------------------------------------------------
// VarColorLine table
//----------------------------------------------------------------------------
// https://learn.microsoft.com/en-us/typography/opentype/spec/colr#color-references-colorstop-and-colorline
//----------------------------------------------------------------------------
type
  TVarColorStop = record
    StopOffset: TF2Dot14;
    PaletteIndex: Word;
    Alpha: TF2Dot14;
    VarIndexBase: Cardinal;
  end;

  TVarColorLine = class(TCustomPascalTypeTable)
  private
    FExtend: Byte;
    FColorStops: TArray<TVarColorStop>;

  public
    procedure Assign(Source: TPersistent); override;
    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;

    property Extend: Byte read FExtend;
    property ColorStops: TArray<TVarColorStop> read FColorStops;
  end;


//----------------------------------------------------------------------------
// Affine2x3 table
//----------------------------------------------------------------------------
// https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-12-and-13-painttransform-paintvartransform
//----------------------------------------------------------------------------
type
  TAffine2x3 = class(TCustomPascalTypeTable)
  private
    FXX, FYX, FXY, FYY, FDX, FDY: TFixedPoint;

  public
    procedure Assign(Source: TPersistent); override;
    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;

    property XX: TFixedPoint read FXX;
    property YX: TFixedPoint read FYX;
    property XY: TFixedPoint read FXY;
    property YY: TFixedPoint read FYY;
    property DX: TFixedPoint read FDX;
    property DY: TFixedPoint read FDY;
  end;


//----------------------------------------------------------------------------
// VarAffine2x3 table
//----------------------------------------------------------------------------
// https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-12-and-13-painttransform-paintvartransform
//----------------------------------------------------------------------------
type
  TVarAffine2x3 = class(TCustomPascalTypeTable)
  private
    FXX, FYX, FXY, FYY, FDX, FDY: TFixedPoint;
    FVarIndexBase: Cardinal;

  public
    procedure Assign(Source: TPersistent); override;
    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;

    property XX: TFixedPoint read FXX;
    property YX: TFixedPoint read FYX;
    property XY: TFixedPoint read FXY;
    property YY: TFixedPoint read FYY;
    property DX: TFixedPoint read FDX;
    property DY: TFixedPoint read FDY;
    property VarIndexBase: Cardinal read FVarIndexBase;
  end;


//----------------------------------------------------------------------------
// Paint table
//----------------------------------------------------------------------------
// https://learn.microsoft.com/en-us/typography/opentype/spec/colr#paint-tables
//----------------------------------------------------------------------------
type
  TPascalTypePaint = class(TCustomPascalTypeTable)
  private
    FFormat: Byte;

  protected
    function GetCOLRTable: TCustomPascalTypeTable;

  public
    procedure Assign(Source: TPersistent); override;
    constructor Create(AParent: TCustomPascalTypeTable; AFormat: Byte); reintroduce; virtual;

    class function CreateFromStream(AParent: TCustomPascalTypeTable; Stream: TStream; BasePos: Int64): TPascalTypePaint;

    property Format: Byte read FFormat;
  end;


//----------------------------------------------------------------------------
// Paint tables, Format 1: PaintColrLayers
//----------------------------------------------------------------------------
// https://learn.microsoft.com/en-us/typography/opentype/spec/colr#format-1-paintcolrlayers
//----------------------------------------------------------------------------
type
  TPaintColrLayers = class(TPascalTypePaint)
  private
    FNumLayers: Byte;
    FFirstLayerIndex: Cardinal;

  public
    procedure Assign(Source: TPersistent); override;
    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;

    property NumLayers: Byte read FNumLayers;
    property FirstLayerIndex: Cardinal read FFirstLayerIndex;
  end;


//----------------------------------------------------------------------------
// Paint tables, Format 2: PaintSolid
//----------------------------------------------------------------------------
// https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-2-and-3-paintsolid-paintvarsolid
//----------------------------------------------------------------------------
type
  TPaintSolid = class(TPascalTypePaint)
  private
    FPaletteIndex: Word;
    FAlpha: TF2Dot14;

  public
    procedure Assign(Source: TPersistent); override;
    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;

    property PaletteIndex: Word read FPaletteIndex;
    property Alpha: TF2Dot14 read FAlpha;
  end;


//----------------------------------------------------------------------------
// Paint tables, Format 3: PaintVarSolid
//----------------------------------------------------------------------------
// https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-2-and-3-paintsolid-paintvarsolid
//----------------------------------------------------------------------------
type
  TPaintVarSolid = class(TPascalTypePaint)
  private
    FPaletteIndex: Word;
    FAlpha: TF2Dot14;
    FVarIndexBase: Cardinal;

  public
    procedure Assign(Source: TPersistent); override;
    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;

    property PaletteIndex: Word read FPaletteIndex;
    property Alpha: TF2Dot14 read FAlpha;
    property VarIndexBase: Cardinal read FVarIndexBase;
  end;


//----------------------------------------------------------------------------
// Paint tables, Format 4: PaintLinearGradient
//----------------------------------------------------------------------------
// https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-4-and-5-paintlineargradient-paintvarlineargradient
//----------------------------------------------------------------------------
type
  TPaintLinearGradient = class(TPascalTypePaint)
  private
    FColorLine: TColorLine;
    FX0, FY0: SmallInt;
    FX1, FY1: SmallInt;
    FX2, FY2: SmallInt;

  public
    destructor Destroy; override;

    procedure Assign(Source: TPersistent); override;
    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;

    property ColorLine: TColorLine read FColorLine;
    property X0: SmallInt read FX0;
    property Y0: SmallInt read FY0;
    property X1: SmallInt read FX1;
    property Y1: SmallInt read FY1;
    property X2: SmallInt read FX2;
    property Y2: SmallInt read FY2;
  end;


//----------------------------------------------------------------------------
// Paint tables, Format 5: PaintVarLinearGradient
//----------------------------------------------------------------------------
// https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-4-and-5-paintlineargradient-paintvarlineargradient
//----------------------------------------------------------------------------
type
  TPaintVarLinearGradient = class(TPascalTypePaint)
  private
    FColorLine: TVarColorLine;
    FX0, FY0: SmallInt;
    FX1, FY1: SmallInt;
    FX2, FY2: SmallInt;
    FVarIndexBase: Cardinal;
  public
    destructor Destroy; override;
    procedure Assign(Source: TPersistent); override;
    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;
    property ColorLine: TVarColorLine read FColorLine;
    property X0: SmallInt read FX0;
    property Y0: SmallInt read FY0;
    property X1: SmallInt read FX1;
    property Y1: SmallInt read FY1;
    property X2: SmallInt read FX2;
    property Y2: SmallInt read FY2;
    property VarIndexBase: Cardinal read FVarIndexBase;
  end;


//----------------------------------------------------------------------------
// Paint tables, Format 6: PaintRadialGradient
//----------------------------------------------------------------------------
// https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-6-and-7-paintradialgradient-paintvarradialgradient
//----------------------------------------------------------------------------
type
  TPaintRadialGradient = class(TPascalTypePaint)
  private
    FColorLine: TColorLine;
    FX0, FY0, FRadius0: SmallInt;
    FX1, FY1, FRadius1: SmallInt;

  public
    destructor Destroy; override;

    procedure Assign(Source: TPersistent); override;
    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;

    property ColorLine: TColorLine read FColorLine;
    property X0: SmallInt read FX0;
    property Y0: SmallInt read FY0;
    property Radius0: SmallInt read FRadius0;
    property X1: SmallInt read FX1;
    property Y1: SmallInt read FY1;
    property Radius1: SmallInt read FRadius1;
  end;


//----------------------------------------------------------------------------
// Paint tables, Format 7: PaintVarRadialGradient
//----------------------------------------------------------------------------
// https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-6-and-7-paintradialgradient-paintvarradialgradient
//----------------------------------------------------------------------------
type
  TPaintVarRadialGradient = class(TPascalTypePaint)
  private
    FColorLine: TVarColorLine;
    FX0, FY0, FRadius0: SmallInt;
    FX1, FY1, FRadius1: SmallInt;
    FVarIndexBase: Cardinal;

  public
    destructor Destroy; override;

    procedure Assign(Source: TPersistent); override;
    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;

    property ColorLine: TVarColorLine read FColorLine;
    property X0: SmallInt read FX0;
    property Y0: SmallInt read FY0;
    property Radius0: SmallInt read FRadius0;
    property X1: SmallInt read FX1;
    property Y1: SmallInt read FY1;
    property Radius1: SmallInt read FRadius1;
    property VarIndexBase: Cardinal read FVarIndexBase;
  end;

  //----------------------------------------------------------------------------
  // Paint tables, Format 8: PaintSweepGradient
  //----------------------------------------------------------------------------
  // https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-8-and-9-paintsweepgradient-paintvarsweepgradient
  //----------------------------------------------------------------------------
  TPaintSweepGradient = class(TPascalTypePaint)
  private
    FColorLine: TColorLine;
    FCenterX, FCenterY: SmallInt;
    FStartAngle, FEndAngle: TF2Dot14;
  public
    destructor Destroy; override;
    procedure Assign(Source: TPersistent); override;
    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;
    property ColorLine: TColorLine read FColorLine;
    property CenterX: SmallInt read FCenterX;
    property CenterY: SmallInt read FCenterY;
    property StartAngle: TF2Dot14 read FStartAngle;
    property EndAngle: TF2Dot14 read FEndAngle;
  end;

  //----------------------------------------------------------------------------
  // Paint tables, Format 9: PaintVarSweepGradient
  //----------------------------------------------------------------------------
  // https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-8-and-9-paintsweepgradient-paintvarsweepgradient
  //----------------------------------------------------------------------------
  TPaintVarSweepGradient = class(TPascalTypePaint)
  private
    FColorLine: TVarColorLine;
    FCenterX, FCenterY: SmallInt;
    FStartAngle, FEndAngle: TF2Dot14;
    FVarIndexBase: Cardinal;
  public
    destructor Destroy; override;
    procedure Assign(Source: TPersistent); override;
    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;
    property ColorLine: TVarColorLine read FColorLine;
    property CenterX: SmallInt read FCenterX;
    property CenterY: SmallInt read FCenterY;
    property StartAngle: TF2Dot14 read FStartAngle;
    property EndAngle: TF2Dot14 read FEndAngle;
    property VarIndexBase: Cardinal read FVarIndexBase;
  end;

  //----------------------------------------------------------------------------
  // Paint tables, Format 10: PaintGlyph
  //----------------------------------------------------------------------------
  // https://learn.microsoft.com/en-us/typography/opentype/spec/colr#format-10-paintglyph
  //----------------------------------------------------------------------------
  TPaintGlyph = class(TPascalTypePaint)
  private
    FPaint: TPascalTypePaint;
    FGlyphID: TGlyphID;
  public
    destructor Destroy; override;
    procedure Assign(Source: TPersistent); override;
    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;
    property Paint: TPascalTypePaint read FPaint;
    property GlyphID: TGlyphID read FGlyphID;
  end;

  //----------------------------------------------------------------------------
  // Paint tables, Format 11: PaintColrGlyph
  //----------------------------------------------------------------------------
  // https://learn.microsoft.com/en-us/typography/opentype/spec/colr#format-11-paintcolrglyph
  //----------------------------------------------------------------------------
  TPaintColrGlyph = class(TPascalTypePaint)
  private
    FGlyphID: TGlyphID;
  public
    procedure Assign(Source: TPersistent); override;
    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;
    property GlyphID: TGlyphID read FGlyphID;
  end;

  //----------------------------------------------------------------------------
  // Paint tables, Format 12: PaintTransform
  //----------------------------------------------------------------------------
  // https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-12-and-13-painttransform-paintvartransform
  //----------------------------------------------------------------------------
  TPaintTransform = class(TPascalTypePaint)
  private
    FPaint: TPascalTypePaint;
    FTransform: TAffine2x3;
  public
    destructor Destroy; override;
    procedure Assign(Source: TPersistent); override;
    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;
    property Paint: TPascalTypePaint read FPaint;
    property Transform: TAffine2x3 read FTransform;
  end;

  //----------------------------------------------------------------------------
  // Paint tables, Format 13: PaintVarTransform
  //----------------------------------------------------------------------------
  // https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-12-and-13-painttransform-paintvartransform
  //----------------------------------------------------------------------------
  TPaintVarTransform = class(TPascalTypePaint)
  private
    FPaint: TPascalTypePaint;
    FTransform: TVarAffine2x3;
  public
    destructor Destroy; override;
    procedure Assign(Source: TPersistent); override;
    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;
    property Paint: TPascalTypePaint read FPaint;
    property Transform: TVarAffine2x3 read FTransform;
  end;

  //----------------------------------------------------------------------------
  // Paint tables, Format 14: PaintTranslate
  //----------------------------------------------------------------------------
  // https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-14-and-15-painttranslate-paintvartranslate
  //----------------------------------------------------------------------------
  TPaintTranslate = class(TPascalTypePaint)
  private
    FPaint: TPascalTypePaint;
    FDX, FDY: SmallInt;
  public
    destructor Destroy; override;
    procedure Assign(Source: TPersistent); override;
    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;
    property Paint: TPascalTypePaint read FPaint;
    property DX: SmallInt read FDX;
    property DY: SmallInt read FDY;
  end;

  //----------------------------------------------------------------------------
  // Paint tables, Format 15: PaintVarTranslate
  //----------------------------------------------------------------------------
  // https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-14-and-15-painttranslate-paintvartranslate
  //----------------------------------------------------------------------------
  TPaintVarTranslate = class(TPascalTypePaint)
  private
    FPaint: TPascalTypePaint;
    FDX, FDY: SmallInt;
    FVarIndexBase: Cardinal;
  public
    destructor Destroy; override;
    procedure Assign(Source: TPersistent); override;
    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;
    property Paint: TPascalTypePaint read FPaint;
    property DX: SmallInt read FDX;
    property DY: SmallInt read FDY;
    property VarIndexBase: Cardinal read FVarIndexBase;
  end;

  //----------------------------------------------------------------------------
  // Paint tables, Format 16: PaintScale
  //----------------------------------------------------------------------------
  // https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-16-to-23-paintscale-and-variant-scaling-formats
  //----------------------------------------------------------------------------
  TPaintScale = class(TPascalTypePaint)
  private
    FPaint: TPascalTypePaint;
    FScaleX, FScaleY: TF2Dot14;
  public
    destructor Destroy; override;
    procedure Assign(Source: TPersistent); override;
    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;
    property Paint: TPascalTypePaint read FPaint;
    property ScaleX: TF2Dot14 read FScaleX;
    property ScaleY: TF2Dot14 read FScaleY;
  end;

  //----------------------------------------------------------------------------
  // Paint tables, Format 17: PaintVarScale
  //----------------------------------------------------------------------------
  // https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-16-to-23-paintscale-and-variant-scaling-formats
  //----------------------------------------------------------------------------
  TPaintVarScale = class(TPascalTypePaint)
  private
    FPaint: TPascalTypePaint;
    FScaleX, FScaleY: TF2Dot14;
    FVarIndexBase: Cardinal;
  public
    destructor Destroy; override;
    procedure Assign(Source: TPersistent); override;
    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;
    property Paint: TPascalTypePaint read FPaint;
    property ScaleX: TF2Dot14 read FScaleX;
    property ScaleY: TF2Dot14 read FScaleY;
    property VarIndexBase: Cardinal read FVarIndexBase;
  end;

  //----------------------------------------------------------------------------
  // Paint tables, Format 18: PaintScaleAroundCenter
  //----------------------------------------------------------------------------
  // https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-16-to-23-paintscale-and-variant-scaling-formats
  //----------------------------------------------------------------------------
  TPaintScaleAroundCenter = class(TPascalTypePaint)
  private
    FPaint: TPascalTypePaint;
    FScaleX, FScaleY: TF2Dot14;
    FCenterX, FCenterY: SmallInt;
  public
    destructor Destroy; override;
    procedure Assign(Source: TPersistent); override;
    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;
    property Paint: TPascalTypePaint read FPaint;
    property ScaleX: TF2Dot14 read FScaleX;
    property ScaleY: TF2Dot14 read FScaleY;
    property CenterX: SmallInt read FCenterX;
    property CenterY: SmallInt read FCenterY;
  end;

  //----------------------------------------------------------------------------
  // Paint tables, Format 19: PaintVarScaleAroundCenter
  //----------------------------------------------------------------------------
  // https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-16-to-23-paintscale-and-variant-scaling-formats
  //----------------------------------------------------------------------------
  TPaintVarScaleAroundCenter = class(TPascalTypePaint)
  private
    FPaint: TPascalTypePaint;
    FScaleX, FScaleY: TF2Dot14;
    FCenterX, FCenterY: SmallInt;
    FVarIndexBase: Cardinal;
  public
    destructor Destroy; override;
    procedure Assign(Source: TPersistent); override;
    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;
    property Paint: TPascalTypePaint read FPaint;
    property ScaleX: TF2Dot14 read FScaleX;
    property ScaleY: TF2Dot14 read FScaleY;
    property CenterX: SmallInt read FCenterX;
    property CenterY: SmallInt read FCenterY;
    property VarIndexBase: Cardinal read FVarIndexBase;
  end;

  //----------------------------------------------------------------------------
  // Paint tables, Format 20: PaintScaleUniform
  //----------------------------------------------------------------------------
  // https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-16-to-23-paintscale-and-variant-scaling-formats
  //----------------------------------------------------------------------------
  TPaintScaleUniform = class(TPascalTypePaint)
  private
    FPaint: TPascalTypePaint;
    FScale: TF2Dot14;
  public
    destructor Destroy; override;
    procedure Assign(Source: TPersistent); override;
    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;
    property Paint: TPascalTypePaint read FPaint;
    property Scale: TF2Dot14 read FScale;
  end;

  //----------------------------------------------------------------------------
  // Paint tables, Format 21: PaintVarScaleUniform
  //----------------------------------------------------------------------------
  // https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-16-to-23-paintscale-and-variant-scaling-formats
  //----------------------------------------------------------------------------
  TPaintVarScaleUniform = class(TPascalTypePaint)
  private
    FPaint: TPascalTypePaint;
    FScale: TF2Dot14;
    FVarIndexBase: Cardinal;
  public
    destructor Destroy; override;
    procedure Assign(Source: TPersistent); override;
    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;
    property Paint: TPascalTypePaint read FPaint;
    property Scale: TF2Dot14 read FScale;
    property VarIndexBase: Cardinal read FVarIndexBase;
  end;

  //----------------------------------------------------------------------------
  // Paint tables, Format 22: PaintScaleUniformAroundCenter
  //----------------------------------------------------------------------------
  // https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-16-to-23-paintscale-and-variant-scaling-formats
  //----------------------------------------------------------------------------
  TPaintScaleUniformAroundCenter = class(TPascalTypePaint)
  private
    FPaint: TPascalTypePaint;
    FScale: TF2Dot14;
    FCenterX, FCenterY: SmallInt;
  public
    destructor Destroy; override;
    procedure Assign(Source: TPersistent); override;
    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;
    property Paint: TPascalTypePaint read FPaint;
    property Scale: TF2Dot14 read FScale;
    property CenterX: SmallInt read FCenterX;
    property CenterY: SmallInt read FCenterY;
  end;

  //----------------------------------------------------------------------------
  // Paint tables, Format 23: PaintVarScaleUniformAroundCenter
  //----------------------------------------------------------------------------
  // https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-16-to-23-paintscale-and-variant-scaling-formats
  //----------------------------------------------------------------------------
  TPaintVarScaleUniformAroundCenter = class(TPascalTypePaint)
  private
    FPaint: TPascalTypePaint;
    FScale: TF2Dot14;
    FCenterX, FCenterY: SmallInt;
    FVarIndexBase: Cardinal;
  public
    destructor Destroy; override;
    procedure Assign(Source: TPersistent); override;
    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;
    property Paint: TPascalTypePaint read FPaint;
    property Scale: TF2Dot14 read FScale;
    property CenterX: SmallInt read FCenterX;
    property CenterY: SmallInt read FCenterY;
    property VarIndexBase: Cardinal read FVarIndexBase;
  end;

  //----------------------------------------------------------------------------
  // Paint tables, Format 24: PaintRotate
  //----------------------------------------------------------------------------
  // https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-24-to-27-paintrotate-paintvarrotate-paintrotatearoundcenter-paintvarrotatearoundcenter
  //----------------------------------------------------------------------------
  TPaintRotate = class(TPascalTypePaint)
  private
    FPaint: TPascalTypePaint;
    FAngle: TF2Dot14;
  public
    destructor Destroy; override;
    procedure Assign(Source: TPersistent); override;
    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;
    property Paint: TPascalTypePaint read FPaint;
    property Angle: TF2Dot14 read FAngle;
  end;

  //----------------------------------------------------------------------------
  // Paint tables, Format 25: PaintVarRotate
  //----------------------------------------------------------------------------
  // https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-24-to-27-paintrotate-paintvarrotate-paintrotatearoundcenter-paintvarrotatearoundcenter
  //----------------------------------------------------------------------------
  TPaintVarRotate = class(TPascalTypePaint)
  private
    FPaint: TPascalTypePaint;
    FAngle: TF2Dot14;
    FVarIndexBase: Cardinal;
  public
    destructor Destroy; override;
    procedure Assign(Source: TPersistent); override;
    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;
    property Paint: TPascalTypePaint read FPaint;
    property Angle: TF2Dot14 read FAngle;
    property VarIndexBase: Cardinal read FVarIndexBase;
  end;

  //----------------------------------------------------------------------------
  // Paint tables, Format 26: PaintRotateAroundCenter
  //----------------------------------------------------------------------------
  // https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-24-to-27-paintrotate-paintvarrotate-paintrotatearoundcenter-paintvarrotatearoundcenter
  //----------------------------------------------------------------------------
  TPaintRotateAroundCenter = class(TPascalTypePaint)
  private
    FPaint: TPascalTypePaint;
    FAngle: TF2Dot14;
    FCenterX, FCenterY: SmallInt;
  public
    destructor Destroy; override;
    procedure Assign(Source: TPersistent); override;
    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;
    property Paint: TPascalTypePaint read FPaint;
    property Angle: TF2Dot14 read FAngle;
    property CenterX: SmallInt read FCenterX;
    property CenterY: SmallInt read FCenterY;
  end;

  //----------------------------------------------------------------------------
  // Paint tables, Format 27: PaintVarRotateAroundCenter
  //----------------------------------------------------------------------------
  // https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-24-to-27-paintrotate-paintvarrotate-paintrotatearoundcenter-paintvarrotatearoundcenter
  //----------------------------------------------------------------------------
  TPaintVarRotateAroundCenter = class(TPascalTypePaint)
  private
    FPaint: TPascalTypePaint;
    FAngle: TF2Dot14;
    FCenterX, FCenterY: SmallInt;
    FVarIndexBase: Cardinal;
  public
    destructor Destroy; override;
    procedure Assign(Source: TPersistent); override;
    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;
    property Paint: TPascalTypePaint read FPaint;
    property Angle: TF2Dot14 read FAngle;
    property CenterX: SmallInt read FCenterX;
    property CenterY: SmallInt read FCenterY;
    property VarIndexBase: Cardinal read FVarIndexBase;
  end;

  //----------------------------------------------------------------------------
  // Paint tables, Format 28: PaintSkew
  //----------------------------------------------------------------------------
  // https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-28-to-31-paintskew-paintvarskew-paintskewaroundcenter-paintvarskewaroundcenter
  //----------------------------------------------------------------------------
  TPaintSkew = class(TPascalTypePaint)
  private
    FPaint: TPascalTypePaint;
    FXSkewAngle, FYSkewAngle: TF2Dot14;
  public
    destructor Destroy; override;
    procedure Assign(Source: TPersistent); override;
    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;
    property Paint: TPascalTypePaint read FPaint;
    property XSkewAngle: TF2Dot14 read FXSkewAngle;
    property YSkewAngle: TF2Dot14 read FYSkewAngle;
  end;

  //----------------------------------------------------------------------------
  // Paint tables, Format 29: PaintVarSkew
  //----------------------------------------------------------------------------
  // https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-28-to-31-paintskew-paintvarskew-paintskewaroundcenter-paintvarskewaroundcenter
  //----------------------------------------------------------------------------
  TPaintVarSkew = class(TPascalTypePaint)
  private
    FPaint: TPascalTypePaint;
    FXSkewAngle, FYSkewAngle: TF2Dot14;
    FVarIndexBase: Cardinal;
  public
    destructor Destroy; override;
    procedure Assign(Source: TPersistent); override;
    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;
    property Paint: TPascalTypePaint read FPaint;
    property XSkewAngle: TF2Dot14 read FXSkewAngle;
    property YSkewAngle: TF2Dot14 read FYSkewAngle;
    property VarIndexBase: Cardinal read FVarIndexBase;
  end;

  //----------------------------------------------------------------------------
  // Paint tables, Format 30: PaintSkewAroundCenter
  //----------------------------------------------------------------------------
  // https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-28-to-31-paintskew-paintvarskew-paintskewaroundcenter-paintvarskewaroundcenter
  //----------------------------------------------------------------------------
  TPaintSkewAroundCenter = class(TPascalTypePaint)
  private
    FPaint: TPascalTypePaint;
    FXSkewAngle, FYSkewAngle: TF2Dot14;
    FCenterX, FCenterY: SmallInt;
  public
    destructor Destroy; override;
    procedure Assign(Source: TPersistent); override;
    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;
    property Paint: TPascalTypePaint read FPaint;
    property XSkewAngle: TF2Dot14 read FXSkewAngle;
    property YSkewAngle: TF2Dot14 read FYSkewAngle;
    property CenterX: SmallInt read FCenterX;
    property CenterY: SmallInt read FCenterY;
  end;

  //----------------------------------------------------------------------------
  // Paint tables, Format 31: PaintVarSkewAroundCenter
  //----------------------------------------------------------------------------
  // https://learn.microsoft.com/en-us/typography/opentype/spec/colr#formats-28-to-31-paintskew-paintvarskew-paintskewaroundcenter-paintvarskewaroundcenter
  //----------------------------------------------------------------------------
  TPaintVarSkewAroundCenter = class(TPascalTypePaint)
  private
    FPaint: TPascalTypePaint;
    FXSkewAngle, FYSkewAngle: TF2Dot14;
    FCenterX, FCenterY: SmallInt;
    FVarIndexBase: Cardinal;
  public
    destructor Destroy; override;
    procedure Assign(Source: TPersistent); override;
    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;
    property Paint: TPascalTypePaint read FPaint;
    property XSkewAngle: TF2Dot14 read FXSkewAngle;
    property YSkewAngle: TF2Dot14 read FYSkewAngle;
    property CenterX: SmallInt read FCenterX;
    property CenterY: SmallInt read FCenterY;
    property VarIndexBase: Cardinal read FVarIndexBase;
  end;

  //----------------------------------------------------------------------------
  // Paint tables, Format 32: PaintComposite
  //----------------------------------------------------------------------------
  // https://learn.microsoft.com/en-us/typography/opentype/spec/colr#format-32-paintcomposite
  //----------------------------------------------------------------------------
  TPaintComposite = class(TPascalTypePaint)
  private
    FSourcePaint: TPascalTypePaint;
    FCompositeMode: Byte;
    FBackdropPaint: TPascalTypePaint;
  public
    destructor Destroy; override;
    procedure Assign(Source: TPersistent); override;
    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;
    property SourcePaint: TPascalTypePaint read FSourcePaint;
    property CompositeMode: Byte read FCompositeMode;
    property BackdropPaint: TPascalTypePaint read FBackdropPaint;
  end;

  //----------------------------------------------------------------------------
  // BaseGlyphPaintRecord record
  //----------------------------------------------------------------------------
  // https://learn.microsoft.com/en-us/typography/opentype/spec/colr#baseglyphlist-layerlist-and-cliplist
  //----------------------------------------------------------------------------
  TBaseGlyphPaintRecord = record
    GlyphID: TGlyphID;
    PaintOffset: Cardinal;
  end;

  //----------------------------------------------------------------------------
  // BaseGlyphList table
  //----------------------------------------------------------------------------
  // https://learn.microsoft.com/en-us/typography/opentype/spec/colr#baseglyphlist-layerlist-and-cliplist
  //----------------------------------------------------------------------------
  TBaseGlyphList = class(TCustomPascalTypeTable)
  private
    FBaseGlyphPaintRecords: TArray<TBaseGlyphPaintRecord>;
    function GetCount: Integer;
    function GetRecord(Index: Integer): TBaseGlyphPaintRecord;
  public
    procedure Assign(Source: TPersistent); override;
    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;
    property Count: Integer read GetCount;
    property Records[Index: Integer]: TBaseGlyphPaintRecord read GetRecord;
  end;

  //----------------------------------------------------------------------------
  // LayerList table
  //----------------------------------------------------------------------------
  // https://learn.microsoft.com/en-us/typography/opentype/spec/colr#baseglyphlist-layerlist-and-cliplist
  //----------------------------------------------------------------------------
  TLayerList = class(TCustomPascalTypeTable)
  private
    FPaintOffsets: TArray<Cardinal>;
    function GetCount: Integer;
    function GetOffset(Index: Integer): Cardinal;
  public
    procedure Assign(Source: TPersistent); override;
    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;
    property Count: Integer read GetCount;
    property PaintOffsets[Index: Integer]: Cardinal read GetOffset;
  end;

  //----------------------------------------------------------------------------
  // ClipBox table
  //----------------------------------------------------------------------------
  // https://learn.microsoft.com/en-us/typography/opentype/spec/colr#baseglyphlist-layerlist-and-cliplist
  //----------------------------------------------------------------------------
  TClipBox = class(TCustomPascalTypeTable)
  private
    FFormat: Byte;
    FXMin, FYMin, FXMax, FYMax: SmallInt;
  public
    procedure Assign(Source: TPersistent); override;
    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;
    property Format: Byte read FFormat;
    property XMin: SmallInt read FXMin;
    property YMin: SmallInt read FYMin;
    property XMax: SmallInt read FXMax;
    property YMax: SmallInt read FYMax;
  end;

  //----------------------------------------------------------------------------
  // ClipBox table, Format 2: Variable ClipBox
  //----------------------------------------------------------------------------
  // https://learn.microsoft.com/en-us/typography/opentype/spec/colr#baseglyphlist-layerlist-and-cliplist
  //----------------------------------------------------------------------------
  TClipBoxVar = class(TClipBox)
  private
    FVarIndexBase: Cardinal;
  public
    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;
    property VarIndexBase: Cardinal read FVarIndexBase;
  end;

  //----------------------------------------------------------------------------
  // Clip record
  //----------------------------------------------------------------------------
  // https://learn.microsoft.com/en-us/typography/opentype/spec/colr#baseglyphlist-layerlist-and-cliplist
  //----------------------------------------------------------------------------
  TClipRecord = record
    StartGlyphID: TGlyphID;
    EndGlyphID: TGlyphID;
    ClipBoxOffset: Cardinal; // Offset24
  end;

  //----------------------------------------------------------------------------
  // ClipList table
  //----------------------------------------------------------------------------
  // https://learn.microsoft.com/en-us/typography/opentype/spec/colr#baseglyphlist-layerlist-and-cliplist
  //----------------------------------------------------------------------------
  TClipList = class(TCustomPascalTypeTable)
  private
    FFormat: Byte;
    FClips: TArray<TClipRecord>;
    function GetCount: Integer;
    function GetClip(Index: Integer): TClipRecord;
  public
    procedure Assign(Source: TPersistent); override;
    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;
    property Format: Byte read FFormat;
    property Count: Integer read GetCount;
    property Clips[Index: Integer]: TClipRecord read GetClip;
  end;

type
  TOpenTypeColorCOLRTable = class(TCustomOpenTypeNamedTable, IPascalTypeColorGlyphLookup, IPascalTypeColorGlyphProvider)
  private
    FVersion: Word;
    FGlyphs: TArray<TColorBaseGlyph>;
    FLayers: TArray<TColorGlyphLayer>;

    // Version 1
    FBaseGlyphList: TBaseGlyphList;
    FLayerList: TLayerList;
    FClipList: TClipList;
    FVarIndexMap: TDeltaSetIndexMap;
    FItemVariationStore: TItemVariationStore;

    // Cache for shared objects
    FPaintCache: TObjectDictionary<Int64, TPascalTypePaint>;
    FColorLineCache: TObjectDictionary<Int64, TCustomPascalTypeTable>;
    FTransformCache: TObjectDictionary<Int64, TCustomPascalTypeTable>;
    FClipBoxCache: TObjectDictionary<Int64, TClipBox>;

  private class var
    FComparer: IComparer<TColorBaseGlyph>;

  private
    class destructor Destroy;

  protected
    function GetGlyph(Index: integer): TColorBaseGlyph;
    function GetGlyphCount: integer;
    function GetLayer(Index: integer): TColorGlyphLayer;
    function GetLayerCount: integer;
  private
    // IPascalTypeColorGlyphLookup
    function GetColorGlyphLookup: IPascalTypeColorGlyphLookup;
    // IPascalTypeColorGlyphProvider
    function GetColoredGlyph(GlyphID: TGlyphID; var ColoredGlyphs: TColoredGlyphs): boolean;
  public
    constructor Create(AParent: TCustomPascalTypeTable); override;
    destructor Destroy; override;

    class function GetTableType: TPascalTypeTag; override;

    procedure Assign(Source: TPersistent); override;

    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;
//    procedure SaveToStream(Stream: TStream); override;

    function GetPaint(Stream: TStream; AbsoluteOffset: Int64): TPascalTypePaint;
    function GetColorLine(Stream: TStream; AbsoluteOffset: Int64; IsVariable: Boolean): TCustomPascalTypeTable;
    function GetTransform(Stream: TStream; AbsoluteOffset: Int64; IsVariable: Boolean): TCustomPascalTypeTable;
    function GetClipBox(Stream: TStream; AbsoluteOffset: Int64): TClipBox;

    property Version: Word read FVersion write FVersion;

    property GlyphCount: integer read GetGlyphCount;
    property Glyphs[Index: integer]: TColorBaseGlyph read GetGlyph;

    property LayerCount: integer read GetLayerCount;
    property Layers[Index: integer]: TColorGlyphLayer read GetLayer;

    // Version 1 properties
    property BaseGlyphList: TBaseGlyphList read FBaseGlyphList;
    property LayerList: TLayerList read FLayerList;
    property ClipList: TClipList read FClipList;
    property VarIndexMap: TDeltaSetIndexMap read FVarIndexMap;
    property ItemVariationStore: TItemVariationStore read FItemVariationStore;
  end;


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

implementation

uses
  SysUtils,
  PascalType.ResourceStrings;

//------------------------------------------------------------------------------
//
//              TColorLine
//
//------------------------------------------------------------------------------

procedure TColorLine.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TColorLine then
  begin
    FExtend := TColorLine(Source).FExtend;
    FColorStops := Copy(TColorLine(Source).FColorStops);
  end;
end;

procedure TColorLine.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  inherited;
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | Type     | Name            | Description                                                             |
  // +==========+=================+=========================================================================+
  // | uint8    | extend          | A value from the Extend enum.                                           |
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | uint16   | numColorStops   | Number of color stops.                                                  |
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | ColorStop| colorStops[]    | Array of color stops.                                                   |
  // +----------+-----------------+-------------------------------------------------------------------------+
  FExtend := BigEndianValue.ReadByte(Stream);
  var Count := BigEndianValue.ReadWord(Stream);
  SetLength(FColorStops, Count);
  for var i := 0 to Count - 1 do
  begin
    // ColorStop record
    // +----------+-----------------+-------------------------------------------------------------------------+
    // | Type     | Name            | Description                                                             |
    // +==========+=================+=========================================================================+
    // | F2DOT14  | stopOffset      | Location on the gradient line.                                          |
    // +----------+-----------------+-------------------------------------------------------------------------+
    // | uint16   | paletteIndex    | Index to a CPAL palette.                                                |
    // +----------+-----------------+-------------------------------------------------------------------------+
    // | F2DOT14  | alpha           | Alpha value.                                                            |
    // +----------+-----------------+-------------------------------------------------------------------------+
    FColorStops[i].StopOffset := BigEndianValue.ReadWord(Stream);
    FColorStops[i].PaletteIndex := BigEndianValue.ReadWord(Stream);
    FColorStops[i].Alpha := BigEndianValue.ReadWord(Stream);
  end;
end;


//------------------------------------------------------------------------------
//
//              TVarColorLine
//
//------------------------------------------------------------------------------

procedure TVarColorLine.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TVarColorLine then
  begin
    FExtend := TVarColorLine(Source).FExtend;
    FColorStops := Copy(TVarColorLine(Source).FColorStops);
  end;
end;

procedure TVarColorLine.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  inherited;
  // +-------------+-----------------+----------------------------------------------------------------------+
  // | Type        | Name            | Description                                                          |
  // +=============+=================+======================================================================+
  // | uint8       | extend          | A value from the Extend enum.                                        |
  // +-------------+-----------------+----------------------------------------------------------------------+
  // | uint16      | numColorStops   | Number of color stops.                                               |
  // +-------------+-----------------+----------------------------------------------------------------------+
  // | VarColorStop| colorStops[]    | Array of variable color stops.                                       |
  // +-------------+-----------------+----------------------------------------------------------------------+
  FExtend := BigEndianValue.ReadByte(Stream);
  var Count := BigEndianValue.ReadWord(Stream);
  SetLength(FColorStops, Count);
  for var i := 0 to Count - 1 do
  begin
    // VarColorStop record
    // +----------+-----------------+-------------------------------------------------------------------------+
    // | Type     | Name            | Description                                                             |
    // +==========+=================+=========================================================================+
    // | F2DOT14  | stopOffset      | Location on the gradient line.                                          |
    // +----------+-----------------+-------------------------------------------------------------------------+
    // | uint16   | paletteIndex    | Index to a CPAL palette.                                                |
    // +----------+-----------------+-------------------------------------------------------------------------+
    // | F2DOT14  | alpha           | Alpha value.                                                            |
    // +----------+-----------------+-------------------------------------------------------------------------+
    // | uint32   | varIndexBase    | Base index into ItemVariationStore.                                     |
    // +----------+-----------------+-------------------------------------------------------------------------+
    FColorStops[i].StopOffset := BigEndianValue.ReadWord(Stream);
    FColorStops[i].PaletteIndex := BigEndianValue.ReadWord(Stream);
    FColorStops[i].Alpha := BigEndianValue.ReadWord(Stream);
    FColorStops[i].VarIndexBase := BigEndianValue.ReadInteger(Stream);
  end;
end;


//------------------------------------------------------------------------------
//
//              TAffine2x3
//
//------------------------------------------------------------------------------

procedure TAffine2x3.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TAffine2x3 then
  begin
    FXX := TAffine2x3(Source).FXX;
    FYX := TAffine2x3(Source).FYX;
    FXY := TAffine2x3(Source).FXY;
    FYY := TAffine2x3(Source).FYY;
    FDX := TAffine2x3(Source).FDX;
    FDY := TAffine2x3(Source).FDY;
  end;
end;

procedure TAffine2x3.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  inherited;
  // +----------+-------+-----------------------------------------------------------------------------------+
  // | Type     | Name  | Description                                                                       |
  // +==========+=======+===================================================================================+
  // | Fixed    | xx    | x-component of the scaling or rotation vector.                                    |
  // +----------+-------+-----------------------------------------------------------------------------------+
  // | Fixed    | yx    | y-component of the scaling or rotation vector.                                    |
  // +----------+-------+-----------------------------------------------------------------------------------+
  // | Fixed    | xy    | x-component of the translation or skew vector.                                    |
  // +----------+-------+-----------------------------------------------------------------------------------+
  // | Fixed    | yy    | y-component of the translation or skew vector.                                    |
  // +----------+-------+-----------------------------------------------------------------------------------+
  // | Fixed    | dx    | x-translation component.                                                          |
  // +----------+-------+-----------------------------------------------------------------------------------+
  // | Fixed    | dy    | y-translation component.                                                          |
  // +----------+-------+-----------------------------------------------------------------------------------+
  FXX := BigEndianValue.ReadInteger(Stream);
  FYX := BigEndianValue.ReadInteger(Stream);
  FXY := BigEndianValue.ReadInteger(Stream);
  FYY := BigEndianValue.ReadInteger(Stream);
  FDX := BigEndianValue.ReadInteger(Stream);
  FDY := BigEndianValue.ReadInteger(Stream);
end;


//------------------------------------------------------------------------------
//
//              TVarAffine2x3
//
//------------------------------------------------------------------------------

procedure TVarAffine2x3.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TVarAffine2x3 then
  begin
    FXX := TVarAffine2x3(Source).FXX;
    FYX := TVarAffine2x3(Source).FYX;
    FXY := TVarAffine2x3(Source).FXY;
    FYY := TVarAffine2x3(Source).FYY;
    FDX := TVarAffine2x3(Source).FDX;
    FDY := TVarAffine2x3(Source).FDY;
    FVarIndexBase := TVarAffine2x3(Source).FVarIndexBase;
  end;
end;

procedure TVarAffine2x3.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  inherited;
  // +----------+--------------+---------------------------------------------------------------------------+
  // | Type     | Name         | Description                                                               |
  // +==========+==============+===========================================================================+
  // | Fixed    | xx           | x-component of the scaling or rotation vector.                            |
  // +----------+--------------+---------------------------------------------------------------------------+
  // | Fixed    | yx           | y-component of the scaling or rotation vector.                            |
  // +----------+--------------+---------------------------------------------------------------------------+
  // | Fixed    | xy           | x-component of the translation or skew vector.                            |
  // +----------+--------------+---------------------------------------------------------------------------+
  // | Fixed    | yy           | y-component of the translation or skew vector.                            |
  // +----------+--------------+---------------------------------------------------------------------------+
  // | Fixed    | dx           | x-translation component.                                                  |
  // +----------+--------------+---------------------------------------------------------------------------+
  // | Fixed    | dy           | y-translation component.                                                  |
  // +----------+--------------+---------------------------------------------------------------------------+
  // | uint32   | varIndexBase | Base index into ItemVariationStore.                                       |
  // +----------+--------------+---------------------------------------------------------------------------+
  FXX := BigEndianValue.ReadInteger(Stream);
  FYX := BigEndianValue.ReadInteger(Stream);
  FXY := BigEndianValue.ReadInteger(Stream);
  FYY := BigEndianValue.ReadInteger(Stream);
  FDX := BigEndianValue.ReadInteger(Stream);
  FDY := BigEndianValue.ReadInteger(Stream);
  FVarIndexBase := BigEndianValue.ReadInteger(Stream);
end;


//------------------------------------------------------------------------------
//
//              TPascalTypePaint
//
//------------------------------------------------------------------------------

constructor TPascalTypePaint.Create(AParent: TCustomPascalTypeTable; AFormat: Byte);
begin
  inherited Create(AParent);
  FFormat := AFormat;
end;

procedure TPascalTypePaint.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TPascalTypePaint then
    FFormat := TPascalTypePaint(Source).FFormat;
end;

function TPascalTypePaint.GetCOLRTable: TCustomPascalTypeTable;
begin
  var Table := Parent;
  while (Table <> nil) and (not (Table is TOpenTypeColorCOLRTable)) do
    Table := Table.Parent;
  Result := Table;
end;

class function TPascalTypePaint.CreateFromStream(AParent: TCustomPascalTypeTable; Stream: TStream; BasePos: Int64): TPascalTypePaint;
begin
  var COLR: TOpenTypeColorCOLRTable := nil;
  if (AParent is TOpenTypeColorCOLRTable) then
    COLR := TOpenTypeColorCOLRTable(AParent)
  else
  begin
    var P := AParent;
    while (P <> nil) and (not (P is TOpenTypeColorCOLRTable)) do
      P := P.Parent;

    if P is TOpenTypeColorCOLRTable then
      COLR := TOpenTypeColorCOLRTable(P);
  end;

  var AbsolutePos := Stream.Position;
  if (COLR <> nil) and (COLR.FPaintCache.TryGetValue(AbsolutePos, Result)) then
    Exit;

  var PaintFormat := BigEndianValue.ReadByte(Stream);

  case PaintFormat of
    1: Result := TPaintColrLayers.Create(AParent, PaintFormat);
    2: Result := TPaintSolid.Create(AParent, PaintFormat);
    3: Result := TPaintVarSolid.Create(AParent, PaintFormat);
    4: Result := TPaintLinearGradient.Create(AParent, PaintFormat);
    5: Result := TPaintVarLinearGradient.Create(AParent, PaintFormat);
    6: Result := TPaintRadialGradient.Create(AParent, PaintFormat);
    7: Result := TPaintVarRadialGradient.Create(AParent, PaintFormat);
    8: Result := TPaintSweepGradient.Create(AParent, PaintFormat);
    9: Result := TPaintVarSweepGradient.Create(AParent, PaintFormat);
    10: Result := TPaintGlyph.Create(AParent, PaintFormat);
    11: Result := TPaintColrGlyph.Create(AParent, PaintFormat);
    12: Result := TPaintTransform.Create(AParent, PaintFormat);
    13: Result := TPaintVarTransform.Create(AParent, PaintFormat);
    14: Result := TPaintTranslate.Create(AParent, PaintFormat);
    15: Result := TPaintVarTranslate.Create(AParent, PaintFormat);
    16: Result := TPaintScale.Create(AParent, PaintFormat);
    17: Result := TPaintVarScale.Create(AParent, PaintFormat);
    18: Result := TPaintScaleAroundCenter.Create(AParent, PaintFormat);
    19: Result := TPaintVarScaleAroundCenter.Create(AParent, PaintFormat);
    20: Result := TPaintScaleUniform.Create(AParent, PaintFormat);
    21: Result := TPaintVarScaleUniform.Create(AParent, PaintFormat);
    22: Result := TPaintScaleUniformAroundCenter.Create(AParent, PaintFormat);
    23: Result := TPaintVarScaleUniformAroundCenter.Create(AParent, PaintFormat);
    24: Result := TPaintRotate.Create(AParent, PaintFormat);
    25: Result := TPaintVarRotate.Create(AParent, PaintFormat);
    26: Result := TPaintRotateAroundCenter.Create(AParent, PaintFormat);
    27: Result := TPaintVarRotateAroundCenter.Create(AParent, PaintFormat);
    28: Result := TPaintSkew.Create(AParent, PaintFormat);
    29: Result := TPaintVarSkew.Create(AParent, PaintFormat);
    30: Result := TPaintSkewAroundCenter.Create(AParent, PaintFormat);
    31: Result := TPaintVarSkewAroundCenter.Create(AParent, PaintFormat);
    32: Result := TPaintComposite.Create(AParent, PaintFormat);
  else
    raise EPascalTypeError.CreateFmt('Invalid COLRv1 paint table type: %d', [PaintFormat]);
  end;

  if COLR <> nil then
    COLR.FPaintCache.Add(AbsolutePos, Result);

  Result.LoadFromStream(Stream);
end;


//------------------------------------------------------------------------------
//
//      TPaintColrLayers
//
//------------------------------------------------------------------------------

procedure TPaintColrLayers.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TPaintColrLayers then
  begin
    FNumLayers := TPaintColrLayers(Source).FNumLayers;
    FFirstLayerIndex := TPaintColrLayers(Source).FFirstLayerIndex;
  end;
end;

procedure TPaintColrLayers.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  inherited;
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | Type     | Name            | Description                                                             |
  // +==========+=================+=========================================================================+
  // | uint8    | numLayers       | Number of layers.                                                       |
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | uint32   | firstLayerIndex | Index into the layerList.                                               |
  // +----------+-----------------+-------------------------------------------------------------------------+
  FNumLayers := BigEndianValue.ReadByte(Stream);
  FFirstLayerIndex := BigEndianValue.ReadInteger(Stream);
end;


//------------------------------------------------------------------------------
//
//      TPaintSolid
//
//------------------------------------------------------------------------------
procedure TPaintSolid.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TPaintSolid then
  begin
    FPaletteIndex := TPaintSolid(Source).FPaletteIndex;
    FAlpha := TPaintSolid(Source).FAlpha;
  end;
end;

procedure TPaintSolid.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  inherited;
  // +----------+--------------+---------------------------------------------------------------------------+
  // | Type     | Name         | Description                                                               |
  // +==========+==============+===========================================================================+
  // | uint16   | paletteIndex | Index into the CPAL palette.                                              |
  // +----------+--------------+---------------------------------------------------------------------------+
  // | F2DOT14  | alpha        | Alpha value.                                                              |
  // +----------+--------------+---------------------------------------------------------------------------+
  FPaletteIndex := BigEndianValue.ReadWord(Stream);
  FAlpha := BigEndianValue.ReadWord(Stream);
end;


//------------------------------------------------------------------------------
//
//      TPaintVarSolid
//
//------------------------------------------------------------------------------
procedure TPaintVarSolid.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TPaintVarSolid then
  begin
    FPaletteIndex := TPaintVarSolid(Source).FPaletteIndex;
    FAlpha := TPaintVarSolid(Source).FAlpha;
    FVarIndexBase := TPaintVarSolid(Source).FVarIndexBase;
  end;
end;

procedure TPaintVarSolid.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  inherited;
  // +----------+--------------+---------------------------------------------------------------------------+
  // | Type     | Name         | Description                                                               |
  // +==========+==============+===========================================================================+
  // | uint16   | paletteIndex | Index into the CPAL palette.                                              |
  // +----------+--------------+---------------------------------------------------------------------------+
  // | F2DOT14  | alpha        | Alpha value.                                                              |
  // +----------+--------------+---------------------------------------------------------------------------+
  // | uint32   | varIndexBase | Base index into ItemVariationStore.                                       |
  // +----------+--------------+---------------------------------------------------------------------------+
  FPaletteIndex := BigEndianValue.ReadWord(Stream);
  FAlpha := BigEndianValue.ReadWord(Stream);
  FVarIndexBase := BigEndianValue.ReadInteger(Stream);
end;


//------------------------------------------------------------------------------
//
//      TPaintLinearGradient
//
//------------------------------------------------------------------------------
destructor TPaintLinearGradient.Destroy;
begin
  FColorLine := nil;
  inherited;
end;

procedure TPaintLinearGradient.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TPaintLinearGradient then
  begin
    FColorLine := TPaintLinearGradient(Source).FColorLine;
    FX0 := TPaintLinearGradient(Source).FX0;
    FY0 := TPaintLinearGradient(Source).FY0;
    FX1 := TPaintLinearGradient(Source).FX1;
    FY1 := TPaintLinearGradient(Source).FY1;
    FX2 := TPaintLinearGradient(Source).FX2;
    FY2 := TPaintLinearGradient(Source).FY2;
  end;
end;

procedure TPaintLinearGradient.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  inherited;
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | Type     | Name            | Description                                                             |
  // +==========+=================+=========================================================================+
  // | Offset24 | colorLineOffset | Offset to ColorLine table.                                              |
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | int16    | x0              | x-coordinate of the first point.                                        |
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | int16    | y0              | y-coordinate of the first point.                                        |
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | int16    | x1              | x-coordinate of the second point.                                       |
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | int16    | y1              | y-coordinate of the second point.                                       |
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | int16    | x2              | x-coordinate of the third point.                                        |
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | int16    | y2              | y-coordinate of the third point.                                        |
  // +----------+-----------------+-------------------------------------------------------------------------+
  var Offset := BigEndianValue.ReadUInt24(Stream);
  FX0 := BigEndianValue.ReadWord(Stream);
  FY0 := BigEndianValue.ReadWord(Stream);
  FX1 := BigEndianValue.ReadWord(Stream);
  FY1 := BigEndianValue.ReadWord(Stream);
  FX2 := BigEndianValue.ReadWord(Stream);
  FY2 := BigEndianValue.ReadWord(Stream);

  FColorLine := TColorLine(TOpenTypeColorCOLRTable(GetCOLRTable).GetColorLine(Stream, (Stream.Position - 16) + Offset, False));
end;


//------------------------------------------------------------------------------
//
//      TPaintVarLinearGradient
//
//------------------------------------------------------------------------------
destructor TPaintVarLinearGradient.Destroy;
begin
  FColorLine := nil;
  inherited;
end;

procedure TPaintVarLinearGradient.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TPaintVarLinearGradient then
  begin
    FColorLine := TPaintVarLinearGradient(Source).FColorLine;
    FX0 := TPaintVarLinearGradient(Source).FX0;
    FY0 := TPaintVarLinearGradient(Source).FY0;
    FX1 := TPaintVarLinearGradient(Source).FX1;
    FY1 := TPaintVarLinearGradient(Source).FY1;
    FX2 := TPaintVarLinearGradient(Source).FX2;
    FY2 := TPaintVarLinearGradient(Source).FY2;
    FVarIndexBase := TPaintVarLinearGradient(Source).FVarIndexBase;
  end;
end;

procedure TPaintVarLinearGradient.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  inherited;
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | Type     | Name            | Description                                                             |
  // +==========+=================+=========================================================================+
  // | Offset24 | colorLineOffset | Offset to ColorLine table.                                              |
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | int16    | x0              | x-coordinate of the first point.                                        |
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | int16    | y0              | y-coordinate of the first point.                                        |
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | int16    | x1              | x-coordinate of the second point.                                       |
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | int16    | y1              | y-coordinate of the second point.                                       |
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | int16    | x2              | x-coordinate of the third point.                                        |
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | int16    | y2              | y-coordinate of the third point.                                        |
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | uint32   | varIndexBase    | Base index into ItemVariationStore.                                     |
  // +----------+-----------------+-------------------------------------------------------------------------+
  var Offset := BigEndianValue.ReadUInt24(Stream);
  FX0 := BigEndianValue.ReadWord(Stream);
  FY0 := BigEndianValue.ReadWord(Stream);
  FX1 := BigEndianValue.ReadWord(Stream);
  FY1 := BigEndianValue.ReadWord(Stream);
  FX2 := BigEndianValue.ReadWord(Stream);
  FY2 := BigEndianValue.ReadWord(Stream);
  FVarIndexBase := BigEndianValue.ReadInteger(Stream);

  FColorLine := TVarColorLine(TOpenTypeColorCOLRTable(GetCOLRTable).GetColorLine(Stream, (Stream.Position - 20) + Offset, True));
end;


//------------------------------------------------------------------------------
//
//      TPaintRadialGradient
//
//------------------------------------------------------------------------------
destructor TPaintRadialGradient.Destroy;
begin
  FColorLine := nil;
  inherited;
end;

procedure TPaintRadialGradient.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TPaintRadialGradient then
  begin
    FColorLine := TPaintRadialGradient(Source).FColorLine;
    FX0 := TPaintRadialGradient(Source).FX0;
    FY0 := TPaintRadialGradient(Source).FY0;
    FRadius0 := TPaintRadialGradient(Source).FRadius0;
    FX1 := TPaintRadialGradient(Source).FX1;
    FY1 := TPaintRadialGradient(Source).FY1;
    FRadius1 := TPaintRadialGradient(Source).FRadius1;
  end;
end;

procedure TPaintRadialGradient.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  inherited;
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | Type     | Name            | Description                                                             |
  // +==========+=================+=========================================================================+
  // | Offset24 | colorLineOffset | Offset to ColorLine table.                                              |
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | int16    | x0              | x-coordinate of the first center.                                       |
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | int16    | y0              | y-coordinate of the first center.                                       |
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | int16    | radius0         | Radius of the first circle.                                             |
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | int16    | x1              | x-coordinate of the second center.                                      |
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | int16    | y1              | y-coordinate of the second center.                                      |
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | int16    | radius1         | Radius of the second circle.                                            |
  // +----------+-----------------+-------------------------------------------------------------------------+
  var Offset := BigEndianValue.ReadUInt24(Stream);
  FX0 := BigEndianValue.ReadWord(Stream);
  FY0 := BigEndianValue.ReadWord(Stream);
  FRadius0 := BigEndianValue.ReadWord(Stream);
  FX1 := BigEndianValue.ReadWord(Stream);
  FY1 := BigEndianValue.ReadWord(Stream);
  FRadius1 := BigEndianValue.ReadWord(Stream);

  FColorLine := TColorLine(TOpenTypeColorCOLRTable(GetCOLRTable).GetColorLine(Stream, (Stream.Position - 16) + Offset, False));
end;


//------------------------------------------------------------------------------
//
//      TPaintVarRadialGradient
//
//------------------------------------------------------------------------------
destructor TPaintVarRadialGradient.Destroy;
begin
  FColorLine := nil;
  inherited;
end;

procedure TPaintVarRadialGradient.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TPaintVarRadialGradient then
  begin
    FColorLine := TPaintVarRadialGradient(Source).FColorLine;
    FX0 := TPaintVarRadialGradient(Source).FX0;
    FY0 := TPaintVarRadialGradient(Source).FY0;
    FRadius0 := TPaintVarRadialGradient(Source).FRadius0;
    FX1 := TPaintVarRadialGradient(Source).FX1;
    FY1 := TPaintVarRadialGradient(Source).FY1;
    FRadius1 := TPaintVarRadialGradient(Source).FRadius1;
    FVarIndexBase := TPaintVarRadialGradient(Source).FVarIndexBase;
  end;
end;

procedure TPaintVarRadialGradient.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  inherited;
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | Type     | Name            | Description                                                             |
  // +==========+=================+=========================================================================+
  // | Offset24 | colorLineOffset | Offset to ColorLine table.                                              |
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | int16    | x0              | x-coordinate of the first center.                                       |
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | int16    | y0              | y-coordinate of the first center.                                       |
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | int16    | radius0         | Radius of the first circle.                                             |
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | int16    | x1              | x-coordinate of the second center.                                      |
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | int16    | y1              | y-coordinate of the second center.                                      |
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | int16    | radius1         | Radius of the second circle.                                            |
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | uint32   | varIndexBase    | Base index into ItemVariationStore.                                     |
  // +----------+-----------------+-------------------------------------------------------------------------+
  var Offset := BigEndianValue.ReadUInt24(Stream);
  FX0 := BigEndianValue.ReadWord(Stream);
  FY0 := BigEndianValue.ReadWord(Stream);
  FRadius0 := BigEndianValue.ReadWord(Stream);
  FX1 := BigEndianValue.ReadWord(Stream);
  FY1 := BigEndianValue.ReadWord(Stream);
  FRadius1 := BigEndianValue.ReadWord(Stream);
  FVarIndexBase := BigEndianValue.ReadInteger(Stream);

  FColorLine := TVarColorLine(TOpenTypeColorCOLRTable(GetCOLRTable).GetColorLine(Stream, (Stream.Position - 20) + Offset, True));
end;


//------------------------------------------------------------------------------
//
//      TPaintSweepGradient
//
//------------------------------------------------------------------------------
destructor TPaintSweepGradient.Destroy;
begin
  FColorLine := nil;
  inherited;
end;

procedure TPaintSweepGradient.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TPaintSweepGradient then
  begin
    FColorLine := TPaintSweepGradient(Source).FColorLine;
    FCenterX := TPaintSweepGradient(Source).FCenterX;
    FCenterY := TPaintSweepGradient(Source).FCenterY;
    FStartAngle := TPaintSweepGradient(Source).FStartAngle;
    FEndAngle := TPaintSweepGradient(Source).FEndAngle;
  end;
end;

procedure TPaintSweepGradient.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  inherited;
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | Type     | Name            | Description                                                             |
  // +==========+=================+=========================================================================+
  // | Offset24 | colorLineOffset | Offset to ColorLine table.                                              |
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | int16    | centerX         | x-coordinate of the center.                                             |
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | int16    | centerY         | y-coordinate of the center.                                             |
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | F2DOT14  | startAngle      | Start angle.                                                            |
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | F2DOT14  | endAngle        | End angle.                                                              |
  // +----------+-----------------+-------------------------------------------------------------------------+
  var Offset := BigEndianValue.ReadUInt24(Stream);
  FCenterX := BigEndianValue.ReadWord(Stream);
  FCenterY := BigEndianValue.ReadWord(Stream);
  FStartAngle := BigEndianValue.ReadWord(Stream);
  FEndAngle := BigEndianValue.ReadWord(Stream);

  FColorLine := TColorLine(TOpenTypeColorCOLRTable(GetCOLRTable).GetColorLine(Stream, (Stream.Position - 12) + Offset, False));
end;


//------------------------------------------------------------------------------
//
//      TPaintVarSweepGradient
//
//------------------------------------------------------------------------------
destructor TPaintVarSweepGradient.Destroy;
begin
  FColorLine := nil;
  inherited;
end;

procedure TPaintVarSweepGradient.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TPaintVarSweepGradient then
  begin
    FColorLine := TPaintVarSweepGradient(Source).FColorLine;
    FCenterX := TPaintVarSweepGradient(Source).FCenterX;
    FCenterY := TPaintVarSweepGradient(Source).FCenterY;
    FStartAngle := TPaintVarSweepGradient(Source).FStartAngle;
    FEndAngle := TPaintVarSweepGradient(Source).FEndAngle;
    FVarIndexBase := TPaintVarSweepGradient(Source).FVarIndexBase;
  end;
end;

procedure TPaintVarSweepGradient.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  inherited;
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | Type     | Name            | Description                                                             |
  // +==========+=================+=========================================================================+
  // | Offset24 | colorLineOffset | Offset to ColorLine table.                                              |
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | int16    | centerX         | x-coordinate of the center.                                             |
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | int16    | centerY         | y-coordinate of the center.                                             |
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | F2DOT14  | startAngle      | Start angle.                                                            |
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | F2DOT14  | endAngle        | End angle.                                                              |
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | uint32   | varIndexBase    | Base index into ItemVariationStore.                                     |
  // +----------+-----------------+-------------------------------------------------------------------------+
  var Offset := BigEndianValue.ReadUInt24(Stream);
  FCenterX := BigEndianValue.ReadWord(Stream);
  FCenterY := BigEndianValue.ReadWord(Stream);
  FStartAngle := BigEndianValue.ReadWord(Stream);
  FEndAngle := BigEndianValue.ReadWord(Stream);
  FVarIndexBase := BigEndianValue.ReadInteger(Stream);

  FColorLine := TVarColorLine(TOpenTypeColorCOLRTable(GetCOLRTable).GetColorLine(Stream, (Stream.Position - 16) + Offset, True));
end;


//------------------------------------------------------------------------------
//
//      TPaintGlyph
//
//------------------------------------------------------------------------------
destructor TPaintGlyph.Destroy;
begin
  FPaint := nil;
  inherited;
end;

procedure TPaintGlyph.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TPaintGlyph then
  begin
    FPaint := TPaintGlyph(Source).FPaint;
    FGlyphID := TPaintGlyph(Source).FGlyphID;
  end;
end;

procedure TPaintGlyph.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  inherited;
  // +----------+-------------+----------------------------------------------------------------------------+
  // | Type     | Name        | Description                                                                |
  // +==========+=============+============================================================================+
  // | Offset24 | paintOffset | Offset to Paint table.                                                     |
  // +----------+-------------+----------------------------------------------------------------------------+
  // | uint16   | glyphID     | Glyph ID.                                                                  |
  // +----------+-------------+----------------------------------------------------------------------------+
  var Offset := BigEndianValue.ReadUInt24(Stream);
  FGlyphID := BigEndianValue.ReadWord(Stream);

  var Pos := Stream.Position;
  Stream.Position := (Pos - 6) + Offset;
  FPaint := TPascalTypePaint.CreateFromStream(Parent, Stream, 0);
  Stream.Position := Pos;
end;


//------------------------------------------------------------------------------
//
//      TPaintColrGlyph
//
//------------------------------------------------------------------------------
procedure TPaintColrGlyph.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TPaintColrGlyph then
    FGlyphID := TPaintColrGlyph(Source).FGlyphID;
end;

procedure TPaintColrGlyph.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  inherited;
  // +----------+-------------+----------------------------------------------------------------------------+
  // | Type     | Name        | Description                                                                |
  // +==========+=============+============================================================================+
  // | uint16   | glyphID     | Glyph ID.                                                                  |
  // +----------+-------------+----------------------------------------------------------------------------+
  FGlyphID := BigEndianValue.ReadWord(Stream);
end;


//------------------------------------------------------------------------------
//
//      TPaintTransform
//
//------------------------------------------------------------------------------
destructor TPaintTransform.Destroy;
begin
  FPaint := nil;
  FTransform := nil;
  inherited;
end;

procedure TPaintTransform.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TPaintTransform then
  begin
    FPaint := TPaintTransform(Source).FPaint;
    FTransform := TPaintTransform(Source).FTransform;
  end;
end;

procedure TPaintTransform.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  inherited;
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | Type     | Name            | Description                                                             |
  // +==========+=================+=========================================================================+
  // | Offset24 | paintOffset     | Offset to Paint table.                                                  |
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | Offset24 | transformOffset | Offset to Affine2x3 table.                                              |
  // +----------+-----------------+-------------------------------------------------------------------------+
  var POffset := BigEndianValue.ReadUInt24(Stream);
  var TOffset := BigEndianValue.ReadUInt24(Stream);

  var Pos := Stream.Position;
  Stream.Position := (Pos - 7) + POffset;
  FPaint := TPascalTypePaint.CreateFromStream(Parent, Stream, 0);

  FTransform := TAffine2x3(TOpenTypeColorCOLRTable(GetCOLRTable).GetTransform(Stream, (Pos - 7) + TOffset, False));
  Stream.Position := Pos;
end;


//------------------------------------------------------------------------------
//
//      TPaintVarTransform
//
//------------------------------------------------------------------------------
destructor TPaintVarTransform.Destroy;
begin
  FPaint := nil;
  FTransform := nil;
  inherited;
end;

procedure TPaintVarTransform.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TPaintVarTransform then
  begin
    FPaint := TPaintVarTransform(Source).FPaint;
    FTransform := TPaintVarTransform(Source).FTransform;
  end;
end;

procedure TPaintVarTransform.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  inherited;
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | Type     | Name            | Description                                                             |
  // +==========+=================+=========================================================================+
  // | Offset24 | paintOffset     | Offset to Paint table.                                                  |
  // +----------+-----------------+-------------------------------------------------------------------------+
  // | Offset24 | transformOffset | Offset to Affine2x3 table.                                              |
  // +----------+-----------------+-------------------------------------------------------------------------+
  var POffset := BigEndianValue.ReadUInt24(Stream);
  var TOffset := BigEndianValue.ReadUInt24(Stream);

  var Pos := Stream.Position;
  Stream.Position := (Pos - 7) + POffset;
  FPaint := TPascalTypePaint.CreateFromStream(Parent, Stream, 0);

  FTransform := TVarAffine2x3(TOpenTypeColorCOLRTable(GetCOLRTable).GetTransform(Stream, (Pos - 7) + TOffset, True));
  Stream.Position := Pos;
end;


//------------------------------------------------------------------------------
//
//      TPaintTranslate
//
//------------------------------------------------------------------------------
destructor TPaintTranslate.Destroy;
begin
  FPaint := nil;
  inherited;
end;

procedure TPaintTranslate.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TPaintTranslate then
  begin
    FPaint := TPaintTranslate(Source).FPaint;
    FDX := TPaintTranslate(Source).FDX;
    FDY := TPaintTranslate(Source).FDY;
  end;
end;

procedure TPaintTranslate.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  inherited;
  // +----------+-------------+----------------------------------------------------------------------------+
  // | Type     | Name        | Description                                                                |
  // +==========+=============+============================================================================+
  // | Offset24 | paintOffset | Offset to Paint table.                                                     |
  // +----------+-------------+----------------------------------------------------------------------------+
  // | int16    | dx          | x-translation.                                                             |
  // +----------+-------------+----------------------------------------------------------------------------+
  // | int16    | dy          | y-translation.                                                             |
  // +----------+-------------+----------------------------------------------------------------------------+
  var Offset := BigEndianValue.ReadUInt24(Stream);
  FDX := BigEndianValue.ReadWord(Stream);
  FDY := BigEndianValue.ReadWord(Stream);

  var Pos := Stream.Position;
  Stream.Position := (Pos - 8) + Offset;
  FPaint := TPascalTypePaint.CreateFromStream(Parent, Stream, 0);
  Stream.Position := Pos;
end;


//------------------------------------------------------------------------------
//
//      TPaintVarTranslate
//
//------------------------------------------------------------------------------
destructor TPaintVarTranslate.Destroy;
begin
  FPaint := nil;
  inherited;
end;

procedure TPaintVarTranslate.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TPaintVarTranslate then
  begin
    FPaint := TPaintVarTranslate(Source).FPaint;
    FDX := TPaintVarTranslate(Source).FDX;
    FDY := TPaintVarTranslate(Source).FDY;
    FVarIndexBase := TPaintVarTranslate(Source).FVarIndexBase;
  end;
end;

procedure TPaintVarTranslate.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  inherited;
  // +----------+--------------+---------------------------------------------------------------------------+
  // | Type     | Name         | Description                                                               |
  // +==========+==============+===========================================================================+
  // | Offset24 | paintOffset  | Offset to Paint table.                                                    |
  // +----------+--------------+---------------------------------------------------------------------------+
  // | int16    | dx           | x-translation.                                                            |
  // +----------+--------------+---------------------------------------------------------------------------+
  // | int16    | dy           | y-translation.                                                            |
  // +----------+--------------+---------------------------------------------------------------------------+
  // | uint32   | varIndexBase | Base index into ItemVariationStore.                                       |
  // +----------+--------------+---------------------------------------------------------------------------+
  var Offset := BigEndianValue.ReadUInt24(Stream);
  FDX := BigEndianValue.ReadWord(Stream);
  FDY := BigEndianValue.ReadWord(Stream);
  FVarIndexBase := BigEndianValue.ReadInteger(Stream);

  var Pos := Stream.Position;
  Stream.Position := (Pos - 12) + Offset;
  FPaint := TPascalTypePaint.CreateFromStream(Parent, Stream, 0);
  Stream.Position := Pos;
end;


//------------------------------------------------------------------------------
//
//      TPaintScale
//
//------------------------------------------------------------------------------
destructor TPaintScale.Destroy;
begin
  FPaint := nil;
  inherited;
end;

procedure TPaintScale.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TPaintScale then
  begin
    FPaint := TPaintScale(Source).FPaint;
    FScaleX := TPaintScale(Source).FScaleX;
    FScaleY := TPaintScale(Source).FScaleY;
  end;
end;

procedure TPaintScale.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  inherited;
  // +----------+-------------+----------------------------------------------------------------------------+
  // | Type     | Name        | Description                                                                |
  // +==========+=============+============================================================================+
  // | Offset24 | paintOffset | Offset to Paint table.                                                     |
  // +----------+-------------+----------------------------------------------------------------------------+
  // | F2DOT14  | scaleX      | x-scale.                                                                   |
  // +----------+-------------+----------------------------------------------------------------------------+
  // | F2DOT14  | scaleY      | y-scale.                                                                   |
  // +----------+-------------+----------------------------------------------------------------------------+
  var Offset := BigEndianValue.ReadUInt24(Stream);
  FScaleX := BigEndianValue.ReadWord(Stream);
  FScaleY := BigEndianValue.ReadWord(Stream);

  var Pos := Stream.Position;
  Stream.Position := (Pos - 8) + Offset;
  FPaint := TPascalTypePaint.CreateFromStream(Parent, Stream, 0);
  Stream.Position := Pos;
end;


//------------------------------------------------------------------------------
//
//      TPaintVarScale
//
//------------------------------------------------------------------------------
destructor TPaintVarScale.Destroy;
begin
  FPaint := nil;
  inherited;
end;

procedure TPaintVarScale.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TPaintVarScale then
  begin
    FPaint := TPaintVarScale(Source).FPaint;
    FScaleX := TPaintVarScale(Source).FScaleX;
    FScaleY := TPaintVarScale(Source).FScaleY;
    FVarIndexBase := TPaintVarScale(Source).FVarIndexBase;
  end;
end;

procedure TPaintVarScale.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  inherited;
  // +----------+--------------+---------------------------------------------------------------------------+
  // | Type     | Name         | Description                                                               |
  // +==========+==============+===========================================================================+
  // | Offset24 | paintOffset  | Offset to Paint table.                                                    |
  // +----------+--------------+---------------------------------------------------------------------------+
  // | F2DOT14  | scaleX       | x-scale.                                                                  |
  // +----------+--------------+---------------------------------------------------------------------------+
  // | F2DOT14  | scaleY       | y-scale.                                                                  |
  // +----------+--------------+---------------------------------------------------------------------------+
  // | uint32   | varIndexBase | Base index into ItemVariationStore.                                       |
  // +----------+--------------+---------------------------------------------------------------------------+
  var Offset := BigEndianValue.ReadUInt24(Stream);
  FScaleX := BigEndianValue.ReadWord(Stream);
  FScaleY := BigEndianValue.ReadWord(Stream);
  FVarIndexBase := BigEndianValue.ReadInteger(Stream);

  var Pos := Stream.Position;
  Stream.Position := (Pos - 12) + Offset;
  FPaint := TPascalTypePaint.CreateFromStream(Parent, Stream, 0);
  Stream.Position := Pos;
end;


//------------------------------------------------------------------------------
//
//      TPaintScaleAroundCenter
//
//------------------------------------------------------------------------------
destructor TPaintScaleAroundCenter.Destroy;
begin
  FPaint := nil;
  inherited;
end;

procedure TPaintScaleAroundCenter.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TPaintScaleAroundCenter then
  begin
    FPaint := TPaintScaleAroundCenter(Source).FPaint;
    FScaleX := TPaintScaleAroundCenter(Source).FScaleX;
    FScaleY := TPaintScaleAroundCenter(Source).FScaleY;
    FCenterX := TPaintScaleAroundCenter(Source).FCenterX;
    FCenterY := TPaintScaleAroundCenter(Source).FCenterY;
  end;
end;

procedure TPaintScaleAroundCenter.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  inherited;
  // +----------+-------------+----------------------------------------------------------------------------+
  // | Type     | Name        | Description                                                                |
  // +==========+=============+============================================================================+
  // | Offset24 | paintOffset | Offset to Paint table.                                                     |
  // +----------+-------------+----------------------------------------------------------------------------+
  // | F2DOT14  | scaleX      | x-scale.                                                                   |
  // +----------+-------------+----------------------------------------------------------------------------+
  // | F2DOT14  | scaleY      | y-scale.                                                                   |
  // +----------+-------------+----------------------------------------------------------------------------+
  // | int16    | centerX     | x-coordinate of the center.                                                |
  // +----------+-------------+----------------------------------------------------------------------------+
  // | int16    | centerY     | y-coordinate of the center.                                                |
  // +----------+-------------+----------------------------------------------------------------------------+
  var Offset := BigEndianValue.ReadUInt24(Stream);
  FScaleX := BigEndianValue.ReadWord(Stream);
  FScaleY := BigEndianValue.ReadWord(Stream);
  FCenterX := BigEndianValue.ReadWord(Stream);
  FCenterY := BigEndianValue.ReadWord(Stream);

  var Pos := Stream.Position;
  Stream.Position := (Pos - 12) + Offset;
  FPaint := TPascalTypePaint.CreateFromStream(Parent, Stream, 0);
  Stream.Position := Pos;
end;


//------------------------------------------------------------------------------
//
//      TPaintVarScaleAroundCenter
//
//------------------------------------------------------------------------------
destructor TPaintVarScaleAroundCenter.Destroy;
begin
  FPaint := nil;
  inherited;
end;

procedure TPaintVarScaleAroundCenter.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TPaintVarScaleAroundCenter then
  begin
    FPaint := TPaintVarScaleAroundCenter(Source).FPaint;
    FScaleX := TPaintVarScaleAroundCenter(Source).FScaleX;
    FScaleY := TPaintVarScaleAroundCenter(Source).FScaleY;
    FCenterX := TPaintVarScaleAroundCenter(Source).FCenterX;
    FCenterY := TPaintVarScaleAroundCenter(Source).FCenterY;
    FVarIndexBase := TPaintVarScaleAroundCenter(Source).FVarIndexBase;
  end;
end;

procedure TPaintVarScaleAroundCenter.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  inherited;
  // +----------+--------------+---------------------------------------------------------------------------+
  // | Type     | Name         | Description                                                               |
  // +==========+==============+===========================================================================+
  // | Offset24 | paintOffset  | Offset to Paint table.                                                    |
  // +----------+--------------+---------------------------------------------------------------------------+
  // | F2DOT14  | scaleX       | x-scale.                                                                  |
  // +----------+--------------+---------------------------------------------------------------------------+
  // | F2DOT14  | scaleY       | y-scale.                                                                  |
  // +----------+--------------+---------------------------------------------------------------------------+
  // | int16    | centerX      | x-coordinate of the center.                                               |
  // +----------+--------------+---------------------------------------------------------------------------+
  // | int16    | centerY      | y-coordinate of the center.                                               |
  // +----------+--------------+---------------------------------------------------------------------------+
  // | uint32   | varIndexBase | Base index into ItemVariationStore.                                       |
  // +----------+--------------+---------------------------------------------------------------------------+
  var Offset := BigEndianValue.ReadUInt24(Stream);
  FScaleX := BigEndianValue.ReadWord(Stream);
  FScaleY := BigEndianValue.ReadWord(Stream);
  FCenterX := BigEndianValue.ReadWord(Stream);
  FCenterY := BigEndianValue.ReadWord(Stream);
  FVarIndexBase := BigEndianValue.ReadInteger(Stream);

  var Pos := Stream.Position;
  Stream.Position := (Pos - 16) + Offset;
  FPaint := TPascalTypePaint.CreateFromStream(Parent, Stream, 0);
  Stream.Position := Pos;
end;


//------------------------------------------------------------------------------
//
//      TPaintScaleUniform
//
//------------------------------------------------------------------------------
destructor TPaintScaleUniform.Destroy;
begin
  FPaint := nil;
  inherited;
end;

procedure TPaintScaleUniform.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TPaintScaleUniform then
  begin
    FPaint := TPaintScaleUniform(Source).FPaint;
    FScale := TPaintScaleUniform(Source).FScale;
  end;
end;

procedure TPaintScaleUniform.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  inherited;
  // +----------+-------------+----------------------------------------------------------------------------+
  // | Type     | Name        | Description                                                                |
  // +==========+=============+============================================================================+
  // | Offset24 | paintOffset | Offset to Paint table.                                                     |
  // +----------+-------------+----------------------------------------------------------------------------+
  // | F2DOT14  | scale       | Scale value.                                                               |
  // +----------+-------------+----------------------------------------------------------------------------+
  var Offset := BigEndianValue.ReadUInt24(Stream);
  FScale := BigEndianValue.ReadWord(Stream);

  var Pos := Stream.Position;
  Stream.Position := (Pos - 6) + Offset;
  FPaint := TPascalTypePaint.CreateFromStream(Parent, Stream, 0);
  Stream.Position := Pos;
end;


//------------------------------------------------------------------------------
//
//      TPaintVarScaleUniform
//
//------------------------------------------------------------------------------
destructor TPaintVarScaleUniform.Destroy;
begin
  FPaint := nil;
  inherited;
end;

procedure TPaintVarScaleUniform.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TPaintVarScaleUniform then
  begin
    FPaint := TPaintVarScaleUniform(Source).FPaint;
    FScale := TPaintVarScaleUniform(Source).FScale;
    FVarIndexBase := TPaintVarScaleUniform(Source).FVarIndexBase;
  end;
end;

procedure TPaintVarScaleUniform.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  inherited;
  // +----------+--------------+---------------------------------------------------------------------------+
  // | Type     | Name         | Description                                                               |
  // +==========+==============+===========================================================================+
  // | Offset24 | paintOffset  | Offset to Paint table.                                                    |
  // +----------+--------------+---------------------------------------------------------------------------+
  // | F2DOT14  | scale        | Scale value.                                                              |
  // +----------+--------------+---------------------------------------------------------------------------+
  // | uint32   | varIndexBase | Base index into ItemVariationStore.                                       |
  // +----------+--------------+---------------------------------------------------------------------------+
  var Offset := BigEndianValue.ReadUInt24(Stream);
  FScale := BigEndianValue.ReadWord(Stream);
  FVarIndexBase := BigEndianValue.ReadInteger(Stream);

  var Pos := Stream.Position;
  Stream.Position := (Pos - 10) + Offset;
  FPaint := TPascalTypePaint.CreateFromStream(Parent, Stream, 0);
  Stream.Position := Pos;
end;


//------------------------------------------------------------------------------
//
//      TPaintScaleUniformAroundCenter
//
//------------------------------------------------------------------------------
destructor TPaintScaleUniformAroundCenter.Destroy;
begin
  FPaint := nil;
  inherited;
end;

procedure TPaintScaleUniformAroundCenter.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TPaintScaleUniformAroundCenter then
  begin
    FPaint := TPaintScaleUniformAroundCenter(Source).FPaint;
    FScale := TPaintScaleUniformAroundCenter(Source).FScale;
    FCenterX := TPaintScaleUniformAroundCenter(Source).FCenterX;
    FCenterY := TPaintScaleUniformAroundCenter(Source).FCenterY;
  end;
end;

procedure TPaintScaleUniformAroundCenter.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  inherited;
  // +----------+-------------+----------------------------------------------------------------------------+
  // | Type     | Name        | Description                                                                |
  // +==========+=============+============================================================================+
  // | Offset24 | paintOffset | Offset to Paint table.                                                     |
  // +----------+-------------+----------------------------------------------------------------------------+
  // | F2DOT14  | scale       | Scale value.                                                               |
  // +----------+-------------+----------------------------------------------------------------------------+
  // | int16    | centerX     | x-coordinate of the center.                                                |
  // +----------+-------------+----------------------------------------------------------------------------+
  // | int16    | centerY     | y-coordinate of the center.                                                |
  // +----------+-------------+----------------------------------------------------------------------------+
  var Offset := BigEndianValue.ReadUInt24(Stream);
  FScale := BigEndianValue.ReadWord(Stream);
  FCenterX := BigEndianValue.ReadWord(Stream);
  FCenterY := BigEndianValue.ReadWord(Stream);

  var Pos := Stream.Position;
  Stream.Position := (Pos - 10) + Offset;
  FPaint := TPascalTypePaint.CreateFromStream(Parent, Stream, 0);
  Stream.Position := Pos;
end;


//------------------------------------------------------------------------------
//
//      TPaintVarScaleUniformAroundCenter
//
//------------------------------------------------------------------------------
destructor TPaintVarScaleUniformAroundCenter.Destroy;
begin
  FPaint := nil;
  inherited;
end;

procedure TPaintVarScaleUniformAroundCenter.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TPaintVarScaleUniformAroundCenter then
  begin
    FPaint := TPaintVarScaleUniformAroundCenter(Source).FPaint;
    FScale := TPaintVarScaleUniformAroundCenter(Source).FScale;
    FCenterX := TPaintVarScaleUniformAroundCenter(Source).FCenterX;
    FCenterY := TPaintVarScaleUniformAroundCenter(Source).FCenterY;
    FVarIndexBase := TPaintVarScaleUniformAroundCenter(Source).FVarIndexBase;
  end;
end;

procedure TPaintVarScaleUniformAroundCenter.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  inherited;
  // +----------+--------------+---------------------------------------------------------------------------+
  // | Type     | Name         | Description                                                               |
  // +==========+==============+===========================================================================+
  // | Offset24 | paintOffset  | Offset to Paint table.                                                    |
  // +----------+--------------+---------------------------------------------------------------------------+
  // | F2DOT14  | scale        | Scale value.                                                              |
  // +----------+--------------+---------------------------------------------------------------------------+
  // | int16    | centerX      | x-coordinate of the center.                                               |
  // +----------+--------------+---------------------------------------------------------------------------+
  // | int16    | centerY      | y-coordinate of the center.                                               |
  // +----------+--------------+---------------------------------------------------------------------------+
  // | uint32   | varIndexBase | Base index into ItemVariationStore.                                       |
  // +----------+--------------+---------------------------------------------------------------------------+
  var Offset := BigEndianValue.ReadUInt24(Stream);
  FScale := BigEndianValue.ReadWord(Stream);
  FCenterX := BigEndianValue.ReadWord(Stream);
  FCenterY := BigEndianValue.ReadWord(Stream);
  FVarIndexBase := BigEndianValue.ReadInteger(Stream);

  var Pos := Stream.Position;
  Stream.Position := (Pos - 14) + Offset;
  FPaint := TPascalTypePaint.CreateFromStream(Parent, Stream, 0);
  Stream.Position := Pos;
end;


//------------------------------------------------------------------------------
//
//      TPaintRotate
//
//------------------------------------------------------------------------------
destructor TPaintRotate.Destroy;
begin
  FPaint := nil;
  inherited;
end;

procedure TPaintRotate.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TPaintRotate then
  begin
    FPaint := TPaintRotate(Source).FPaint;
    FAngle := TPaintRotate(Source).FAngle;
  end;
end;

procedure TPaintRotate.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  inherited;
  // +----------+-------------+----------------------------------------------------------------------------+
  // | Type     | Name        | Description                                                                |
  // +==========+=============+============================================================================+
  // | Offset24 | paintOffset | Offset to Paint table.                                                     |
  // +----------+-------------+----------------------------------------------------------------------------+
  // | F2DOT14  | angle       | Rotation angle.                                                            |
  // +----------+-------------+----------------------------------------------------------------------------+
  var Offset := BigEndianValue.ReadUInt24(Stream);
  FAngle := BigEndianValue.ReadWord(Stream);

  var Pos := Stream.Position;
  Stream.Position := (Pos - 6) + Offset;
  FPaint := TPascalTypePaint.CreateFromStream(Parent, Stream, 0);
  Stream.Position := Pos;
end;


//------------------------------------------------------------------------------
//
//      TPaintVarRotate
//
//------------------------------------------------------------------------------
destructor TPaintVarRotate.Destroy;
begin
  FPaint := nil;
  inherited;
end;

procedure TPaintVarRotate.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TPaintVarRotate then
  begin
    FPaint := TPaintVarRotate(Source).FPaint;
    FAngle := TPaintVarRotate(Source).FAngle;
    FVarIndexBase := TPaintVarRotate(Source).FVarIndexBase;
  end;
end;

procedure TPaintVarRotate.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  inherited;
  // +----------+--------------+---------------------------------------------------------------------------+
  // | Type     | Name         | Description                                                               |
  // +==========+==============+===========================================================================+
  // | Offset24 | paintOffset  | Offset to Paint table.                                                    |
  // +----------+--------------+---------------------------------------------------------------------------+
  // | F2DOT14  | angle        | Rotation angle.                                                           |
  // +----------+--------------+---------------------------------------------------------------------------+
  // | uint32   | varIndexBase | Base index into ItemVariationStore.                                       |
  // +----------+--------------+---------------------------------------------------------------------------+
  var Offset := BigEndianValue.ReadUInt24(Stream);
  FAngle := BigEndianValue.ReadWord(Stream);
  FVarIndexBase := BigEndianValue.ReadInteger(Stream);

  var Pos := Stream.Position;
  Stream.Position := (Pos - 10) + Offset;
  FPaint := TPascalTypePaint.CreateFromStream(Parent, Stream, 0);
  Stream.Position := Pos;
end;


//------------------------------------------------------------------------------
//
//      TPaintRotateAroundCenter
//
//------------------------------------------------------------------------------
destructor TPaintRotateAroundCenter.Destroy;
begin
  FPaint := nil;
  inherited;
end;

procedure TPaintRotateAroundCenter.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TPaintRotateAroundCenter then
  begin
    FPaint := TPaintRotateAroundCenter(Source).FPaint;
    FAngle := TPaintRotateAroundCenter(Source).FAngle;
    FCenterX := TPaintRotateAroundCenter(Source).FCenterX;
    FCenterY := TPaintRotateAroundCenter(Source).FCenterY;
  end;
end;

procedure TPaintRotateAroundCenter.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  inherited;
  // +----------+-------------+----------------------------------------------------------------------------+
  // | Type     | Name        | Description                                                                |
  // +==========+=============+============================================================================+
  // | Offset24 | paintOffset | Offset to Paint table.                                                     |
  // +----------+-------------+----------------------------------------------------------------------------+
  // | F2DOT14  | angle       | Rotation angle.                                                            |
  // +----------+-------------+----------------------------------------------------------------------------+
  // | int16    | centerX     | x-coordinate of the center.                                                |
  // +----------+-------------+----------------------------------------------------------------------------+
  // | int16    | centerY     | y-coordinate of the center.                                                |
  // +----------+-------------+----------------------------------------------------------------------------+
  var Offset := BigEndianValue.ReadUInt24(Stream);
  FAngle := BigEndianValue.ReadWord(Stream);
  FCenterX := BigEndianValue.ReadWord(Stream);
  FCenterY := BigEndianValue.ReadWord(Stream);

  var Pos := Stream.Position;
  Stream.Position := (Pos - 10) + Offset;
  FPaint := TPascalTypePaint.CreateFromStream(Parent, Stream, 0);
  Stream.Position := Pos;
end;


//------------------------------------------------------------------------------
//
//      TPaintVarRotateAroundCenter
//
//------------------------------------------------------------------------------
destructor TPaintVarRotateAroundCenter.Destroy;
begin
  FPaint := nil;
  inherited;
end;

procedure TPaintVarRotateAroundCenter.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TPaintVarRotateAroundCenter then
  begin
    FPaint := TPaintVarRotateAroundCenter(Source).FPaint;
    FAngle := TPaintVarRotateAroundCenter(Source).FAngle;
    FCenterX := TPaintVarRotateAroundCenter(Source).FCenterX;
    FCenterY := TPaintVarRotateAroundCenter(Source).FCenterY;
    FVarIndexBase := TPaintVarRotateAroundCenter(Source).FVarIndexBase;
  end;
end;

procedure TPaintVarRotateAroundCenter.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  inherited;
  // +----------+--------------+---------------------------------------------------------------------------+
  // | Type     | Name         | Description                                                               |
  // +==========+==============+===========================================================================+
  // | Offset24 | paintOffset  | Offset to Paint table.                                                    |
  // +----------+--------------+---------------------------------------------------------------------------+
  // | F2DOT14  | angle        | Rotation angle.                                                           |
  // +----------+--------------+---------------------------------------------------------------------------+
  // | int16    | centerX      | x-coordinate of the center.                                               |
  // +----------+--------------+---------------------------------------------------------------------------+
  // | int16    | centerY      | y-coordinate of the center.                                               |
  // +----------+--------------+---------------------------------------------------------------------------+
  // | uint32   | varIndexBase | Base index into ItemVariationStore.                                       |
  // +----------+--------------+---------------------------------------------------------------------------+
  var Offset := BigEndianValue.ReadUInt24(Stream);
  FAngle := BigEndianValue.ReadWord(Stream);
  FCenterX := BigEndianValue.ReadWord(Stream);
  FCenterY := BigEndianValue.ReadWord(Stream);
  FVarIndexBase := BigEndianValue.ReadInteger(Stream);

  var Pos := Stream.Position;
  Stream.Position := (Pos - 14) + Offset;
  FPaint := TPascalTypePaint.CreateFromStream(Parent, Stream, 0);
  Stream.Position := Pos;
end;


//------------------------------------------------------------------------------
//
//      TPaintSkew
//
//------------------------------------------------------------------------------
destructor TPaintSkew.Destroy;
begin
  FPaint := nil;
  inherited;
end;

procedure TPaintSkew.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TPaintSkew then
  begin
    FPaint := TPaintSkew(Source).FPaint;
    FXSkewAngle := TPaintSkew(Source).FXSkewAngle;
    FYSkewAngle := TPaintSkew(Source).FYSkewAngle;
  end;
end;

procedure TPaintSkew.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  inherited;
  // +----------+-------------+----------------------------------------------------------------------------+
  // | Type     | Name        | Description                                                                |
  // +==========+=============+============================================================================+
  // | Offset24 | paintOffset | Offset to Paint table.                                                     |
  // +----------+-------------+----------------------------------------------------------------------------+
  // | F2DOT14  | xSkewAngle  | x-skew angle.                                                              |
  // +----------+-------------+----------------------------------------------------------------------------+
  // | F2DOT14  | ySkewAngle  | y-skew angle.                                                              |
  // +----------+-------------+----------------------------------------------------------------------------+
  var Offset := BigEndianValue.ReadUInt24(Stream);
  FXSkewAngle := BigEndianValue.ReadWord(Stream);
  FYSkewAngle := BigEndianValue.ReadWord(Stream);

  var Pos := Stream.Position;
  Stream.Position := (Pos - 8) + Offset;
  FPaint := TPascalTypePaint.CreateFromStream(Parent, Stream, 0);
  Stream.Position := Pos;
end;


//------------------------------------------------------------------------------
//
//      TPaintVarSkew
//
//------------------------------------------------------------------------------
destructor TPaintVarSkew.Destroy;
begin
  FPaint := nil;
  inherited;
end;

procedure TPaintVarSkew.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TPaintVarSkew then
  begin
    FPaint := TPaintVarSkew(Source).FPaint;
    FXSkewAngle := TPaintVarSkew(Source).FXSkewAngle;
    FYSkewAngle := TPaintVarSkew(Source).FYSkewAngle;
    FVarIndexBase := TPaintVarSkew(Source).FVarIndexBase;
  end;
end;

procedure TPaintVarSkew.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  inherited;
  // +----------+--------------+---------------------------------------------------------------------------+
  // | Type     | Name         | Description                                                               |
  // +==========+==============+===========================================================================+
  // | Offset24 | paintOffset  | Offset to Paint table.                                                    |
  // +----------+--------------+---------------------------------------------------------------------------+
  // | F2DOT14  | xSkewAngle   | x-skew angle.                                                             |
  // +----------+--------------+---------------------------------------------------------------------------+
  // | F2DOT14  | ySkewAngle   | y-skew angle.                                                             |
  // +----------+--------------+---------------------------------------------------------------------------+
  // | uint32   | varIndexBase | Base index into ItemVariationStore.                                       |
  // +----------+--------------+---------------------------------------------------------------------------+
  var Offset := BigEndianValue.ReadUInt24(Stream);
  FXSkewAngle := BigEndianValue.ReadWord(Stream);
  FYSkewAngle := BigEndianValue.ReadWord(Stream);
  FVarIndexBase := BigEndianValue.ReadInteger(Stream);

  var Pos := Stream.Position;
  Stream.Position := (Pos - 12) + Offset;
  FPaint := TPascalTypePaint.CreateFromStream(Parent, Stream, 0);
  Stream.Position := Pos;
end;


//------------------------------------------------------------------------------
//
//      TPaintSkewAroundCenter
//
//------------------------------------------------------------------------------
destructor TPaintSkewAroundCenter.Destroy;
begin
  FPaint := nil;
  inherited;
end;

procedure TPaintSkewAroundCenter.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TPaintSkewAroundCenter then
  begin
    FPaint := TPaintSkewAroundCenter(Source).FPaint;
    FXSkewAngle := TPaintSkewAroundCenter(Source).FXSkewAngle;
    FYSkewAngle := TPaintSkewAroundCenter(Source).FYSkewAngle;
    FCenterX := TPaintSkewAroundCenter(Source).FCenterX;
    FCenterY := TPaintSkewAroundCenter(Source).FCenterY;
  end;
end;

procedure TPaintSkewAroundCenter.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  inherited;
  // +----------+-------------+----------------------------------------------------------------------------+
  // | Type     | Name        | Description                                                                |
  // +==========+=============+============================================================================+
  // | Offset24 | paintOffset | Offset to Paint table.                                                     |
  // +----------+-------------+----------------------------------------------------------------------------+
  // | F2DOT14  | xSkewAngle  | x-skew angle.                                                              |
  // +----------+-------------+----------------------------------------------------------------------------+
  // | F2DOT14  | ySkewAngle  | y-skew angle.                                                              |
  // +----------+-------------+----------------------------------------------------------------------------+
  // | int16    | centerX     | x-coordinate of the center.                                                |
  // +----------+-------------+----------------------------------------------------------------------------+
  // | int16    | centerY     | y-coordinate of the center.                                                |
  // +----------+-------------+----------------------------------------------------------------------------+
  var Offset := BigEndianValue.ReadUInt24(Stream);
  FXSkewAngle := BigEndianValue.ReadWord(Stream);
  FYSkewAngle := BigEndianValue.ReadWord(Stream);
  FCenterX := BigEndianValue.ReadWord(Stream);
  FCenterY := BigEndianValue.ReadWord(Stream);

  var Pos := Stream.Position;
  Stream.Position := (Pos - 12) + Offset;
  FPaint := TPascalTypePaint.CreateFromStream(Parent, Stream, 0);
  Stream.Position := Pos;
end;


//------------------------------------------------------------------------------
//
//      TPaintVarSkewAroundCenter
//
//------------------------------------------------------------------------------
destructor TPaintVarSkewAroundCenter.Destroy;
begin
  FPaint := nil;
  inherited;
end;

procedure TPaintVarSkewAroundCenter.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TPaintVarSkewAroundCenter then
  begin
    FPaint := TPaintVarSkewAroundCenter(Source).FPaint;
    FXSkewAngle := TPaintVarSkewAroundCenter(Source).FXSkewAngle;
    FYSkewAngle := TPaintVarSkewAroundCenter(Source).FYSkewAngle;
    FCenterX := TPaintVarSkewAroundCenter(Source).FCenterX;
    FCenterY := TPaintVarSkewAroundCenter(Source).FCenterY;
    FVarIndexBase := TPaintVarSkewAroundCenter(Source).FVarIndexBase;
  end;
end;

procedure TPaintVarSkewAroundCenter.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  inherited;
  // +----------+--------------+---------------------------------------------------------------------------+
  // | Type     | Name         | Description                                                               |
  // +==========+==============+===========================================================================+
  // | Offset24 | paintOffset  | Offset to Paint table.                                                    |
  // +----------+--------------+---------------------------------------------------------------------------+
  // | F2DOT14  | xSkewAngle   | x-skew angle.                                                             |
  // +----------+--------------+---------------------------------------------------------------------------+
  // | F2DOT14  | ySkewAngle   | y-skew angle.                                                             |
  // +----------+--------------+---------------------------------------------------------------------------+
  // | int16    | centerX      | x-coordinate of the center.                                               |
  // +----------+--------------+---------------------------------------------------------------------------+
  // | int16    | centerY      | y-coordinate of the center.                                               |
  // +----------+--------------+---------------------------------------------------------------------------+
  // | uint32   | varIndexBase | Base index into ItemVariationStore.                                       |
  // +----------+--------------+---------------------------------------------------------------------------+
  var Offset := BigEndianValue.ReadUInt24(Stream);
  FXSkewAngle := BigEndianValue.ReadWord(Stream);
  FYSkewAngle := BigEndianValue.ReadWord(Stream);
  FCenterX := BigEndianValue.ReadWord(Stream);
  FCenterY := BigEndianValue.ReadWord(Stream);
  FVarIndexBase := BigEndianValue.ReadInteger(Stream);

  var Pos := Stream.Position;
  Stream.Position := (Pos - 16) + Offset;
  FPaint := TPascalTypePaint.CreateFromStream(Parent, Stream, 0);
  Stream.Position := Pos;
end;


//------------------------------------------------------------------------------
//
//      TPaintComposite
//
//------------------------------------------------------------------------------
destructor TPaintComposite.Destroy;
begin
  FSourcePaint := nil;
  FBackdropPaint := nil;
  inherited;
end;

procedure TPaintComposite.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TPaintComposite then
  begin
    FSourcePaint := TPaintComposite(Source).FSourcePaint;
    FCompositeMode := TPaintComposite(Source).FCompositeMode;
    FBackdropPaint := TPaintComposite(Source).FBackdropPaint;
  end;
end;

procedure TPaintComposite.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  inherited;
  // +----------+--------------------+----------------------------------------------------------------------+
  // | Type     | Name               | Description                                                          |
  // +==========+====================+======================================================================+
  // | Offset24 | sourcePaintOffset  | Offset to source Paint table.                                        |
  // +----------+--------------------+----------------------------------------------------------------------+
  // | uint8    | compositeMode      | A value from the CompositeMode enum.                                 |
  // +----------+--------------------+----------------------------------------------------------------------+
  // | Offset24 | backdropPaintOffset| Offset to backdrop Paint table.                                      |
  // +----------+--------------------+----------------------------------------------------------------------+
  var SOffset := BigEndianValue.ReadUInt24(Stream);
  FCompositeMode := BigEndianValue.ReadByte(Stream);
  var BOffset := BigEndianValue.ReadUInt24(Stream);

  var Pos := Stream.Position;
  Stream.Position := (Pos - 8) + SOffset;
  FSourcePaint := TPascalTypePaint.CreateFromStream(Parent, Stream, 0);

  Stream.Position := (Pos - 8) + BOffset;
  FBackdropPaint := TPascalTypePaint.CreateFromStream(Parent, Stream, 0);

  Stream.Position := Pos;
end;


//------------------------------------------------------------------------------
//
//              TBaseGlyphList
//
//------------------------------------------------------------------------------

function TBaseGlyphList.GetCount: Integer;
begin
  Result := Length(FBaseGlyphPaintRecords);
end;

function TBaseGlyphList.GetRecord(Index: Integer): TBaseGlyphPaintRecord;
begin
  Result := FBaseGlyphPaintRecords[Index];
end;

procedure TBaseGlyphList.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TBaseGlyphList then
    FBaseGlyphPaintRecords := Copy(TBaseGlyphList(Source).FBaseGlyphPaintRecords);
end;

procedure TBaseGlyphList.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  inherited;
  // +---------------------+-----------------------+--------------------------------------------------------+
  // | Type                | Name                  | Description                                            |
  // +=====================+=======================+========================================================+
  // | uint32              | numBaseGlyphPaintRecs | Number of BaseGlyphPaintRecords.                       |
  // +---------------------+-----------------------+--------------------------------------------------------+
  // | BaseGlyphPaintRecord| baseGlyphPaintRecords[]| Array of BaseGlyphPaintRecords.                       |
  // +---------------------+-----------------------+--------------------------------------------------------+
  var Count := BigEndianValue.ReadInteger(Stream);
  SetLength(FBaseGlyphPaintRecords, Count);
  for var i := 0 to Count - 1 do
  begin
    // BaseGlyphPaintRecord
    // +----------+-------------+----------------------------------------------------------------------------+
    // | Type     | Name        | Description                                                                |
    // +==========+=============+============================================================================+
    // | uint16   | glyphID     | Glyph ID of the base glyph.                                                |
    // +----------+-------------+----------------------------------------------------------------------------+
    // | Offset32 | paintOffset | Offset to Paint table.                                                     |
    // +----------+-------------+----------------------------------------------------------------------------+
    FBaseGlyphPaintRecords[i].GlyphID := BigEndianValue.ReadWord(Stream);
    FBaseGlyphPaintRecords[i].PaintOffset := BigEndianValue.ReadInteger(Stream);
  end;
end;


//------------------------------------------------------------------------------
//
//              TLayerList
//
//------------------------------------------------------------------------------

function TLayerList.GetCount: Integer;
begin
  Result := Length(FPaintOffsets);
end;

function TLayerList.GetOffset(Index: Integer): Cardinal;
begin
  Result := FPaintOffsets[Index];
end;

procedure TLayerList.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TLayerList then
    FPaintOffsets := Copy(TLayerList(Source).FPaintOffsets);
end;

procedure TLayerList.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  inherited;
  // +----------+--------------+---------------------------------------------------------------------------+
  // | Type     | Name         | Description                                                               |
  // +==========+==============+===========================================================================+
  // | uint32   | numLayers    | Number of layers.                                                         |
  // +----------+--------------+---------------------------------------------------------------------------+
  // | Offset32 | paintOffsets | Array of offsets to Paint tables.                                         |
  // +----------+--------------+---------------------------------------------------------------------------+
  var Count := BigEndianValue.ReadInteger(Stream);
  SetLength(FPaintOffsets, Count);
  for var i := 0 to Count - 1 do
    FPaintOffsets[i] := BigEndianValue.ReadInteger(Stream);
end;


//------------------------------------------------------------------------------
//
//              TClipBox
//
//------------------------------------------------------------------------------

procedure TClipBox.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TClipBox then
  begin
    FFormat := TClipBox(Source).FFormat;
    FXMin := TClipBox(Source).FXMin;
    FYMin := TClipBox(Source).FYMin;
    FXMax := TClipBox(Source).FXMax;
    FYMax := TClipBox(Source).FYMax;
  end;
end;

procedure TClipBox.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  inherited;
  // Format is already read by the caller or by a factory
  // +-------+------+--------------------------------------------------------------------------------------+
  // | Type  | Name | Description                                                                          |
  // +=======+======+======================================================================================+
  // | int16 | xMin | Minimum x-coordinate.                                                                |
  // +-------+------+--------------------------------------------------------------------------------------+
  // | int16 | yMin | Minimum y-coordinate.                                                                |
  // +-------+------+--------------------------------------------------------------------------------------+
  // | int16 | xMax | Maximum x-coordinate.                                                                |
  // +-------+------+--------------------------------------------------------------------------------------+
  // | int16 | yMax | Maximum y-coordinate.                                                                |
  // +-------+------+--------------------------------------------------------------------------------------+
  FXMin := BigEndianValue.ReadWord(Stream);
  FYMin := BigEndianValue.ReadWord(Stream);
  FXMax := BigEndianValue.ReadWord(Stream);
  FYMax := BigEndianValue.ReadWord(Stream);
end;


//------------------------------------------------------------------------------
//
//              TClipBoxVar
//
//------------------------------------------------------------------------------

procedure TClipBoxVar.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  inherited;
  // +--------+--------------+-----------------------------------------------------------------------------+
  // | Type   | Name         | Description                                                                 |
  // +========+==============+=============================================================================+
  // | uint32 | varIndexBase | Base index into ItemVariationStore.                                         |
  // +--------+--------------+-----------------------------------------------------------------------------+
  FVarIndexBase := BigEndianValue.ReadInteger(Stream);
end;


//------------------------------------------------------------------------------
//
//              TClipList
//
//------------------------------------------------------------------------------

function TClipList.GetCount: Integer;
begin
  Result := Length(FClips);
end;

function TClipList.GetClip(Index: Integer): TClipRecord;
begin
  Result := FClips[Index];
end;

procedure TClipList.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TClipList then
  begin
    FFormat := TClipList(Source).FFormat;
    FClips := Copy(TClipList(Source).FClips);
  end;
end;

procedure TClipList.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  inherited;
  // +------------+----------+-----------------------------------------------------------------------------+
  // | Type       | Name     | Description                                                                 |
  // +============+==========+=============================================================================+
  // | uint8      | format   | Set to 1.                                                                   |
  // +------------+----------+-----------------------------------------------------------------------------+
  // | uint8      | numClips | Number of ClipRecords.                                                      |
  // +------------+----------+-----------------------------------------------------------------------------+
  // | ClipRecord | clips[]  | Array of ClipRecords.                                                       |
  // +------------+----------+-----------------------------------------------------------------------------+
  FFormat := BigEndianValue.ReadByte(Stream);
  var Count := BigEndianValue.ReadByte(Stream);
  SetLength(FClips, Count);
  for var i := 0 to Count - 1 do
  begin
    // ClipRecord
    // +----------+---------------+--------------------------------------------------------------------------+
    // | Type     | Name          | Description                                                              |
    // +==========+===============+==========================================================================+
    // | uint16   | startGlyphID  | First glyph ID in the range.                                             |
    // +----------+---------------+--------------------------------------------------------------------------+
    // | uint16   | endGlyphID    | Last glyph ID in the range.                                              |
    // +----------+---------------+--------------------------------------------------------------------------+
    // | Offset24 | clipBoxOffset | Offset to ClipBox table.                                                 |
    // +----------+---------------+--------------------------------------------------------------------------+
    FClips[i].StartGlyphID := BigEndianValue.ReadWord(Stream);
    FClips[i].EndGlyphID := BigEndianValue.ReadWord(Stream);
    FClips[i].ClipBoxOffset := BigEndianValue.ReadUInt24(Stream);
  end;
end;


//------------------------------------------------------------------------------
//
//              TOpenTypeColorCOLRTable
//
//------------------------------------------------------------------------------

constructor TOpenTypeColorCOLRTable.Create(AParent: TCustomPascalTypeTable);
begin
  inherited;
  FPaintCache := TObjectDictionary<Int64, TPascalTypePaint>.Create([doOwnsValues]);
  FColorLineCache := TObjectDictionary<Int64, TCustomPascalTypeTable>.Create([doOwnsValues]);
  FTransformCache := TObjectDictionary<Int64, TCustomPascalTypeTable>.Create([doOwnsValues]);
  FClipBoxCache := TObjectDictionary<Int64, TClipBox>.Create([doOwnsValues]);
end;

destructor TOpenTypeColorCOLRTable.Destroy;
begin
  FItemVariationStore.Free;
  FVarIndexMap.Free;
  FClipList.Free;
  FLayerList.Free;
  FBaseGlyphList.Free;
  FClipBoxCache.Free;
  FTransformCache.Free;
  FColorLineCache.Free;
  FPaintCache.Free;
  inherited;
end;

class destructor TOpenTypeColorCOLRTable.Destroy;
begin
  FComparer := nil;
end;

//------------------------------------------------------------------------------

class function TOpenTypeColorCOLRTable.GetTableType: TPascalTypeTag;
begin
  Result := 'COLR';
end;

//------------------------------------------------------------------------------

procedure TOpenTypeColorCOLRTable.Assign(Source: TPersistent);
begin
  inherited;

  if Source is TOpenTypeColorCOLRTable then
  begin
    FVersion := TOpenTypeColorCOLRTable(Source).FVersion;
    FGlyphs := Copy(TOpenTypeColorCOLRTable(Source).FGlyphs);
    FLayers := Copy(TOpenTypeColorCOLRTable(Source).FLayers);

    if (TOpenTypeColorCOLRTable(Source).FBaseGlyphList <> nil) then
    begin
      if (FBaseGlyphList = nil) then
        FBaseGlyphList := TBaseGlyphList.Create(Self);
      FBaseGlyphList.Assign(TOpenTypeColorCOLRTable(Source).FBaseGlyphList);
    end;

    if (TOpenTypeColorCOLRTable(Source).FLayerList <> nil) then
    begin
      if (FLayerList = nil) then
        FLayerList := TLayerList.Create(Self);
      FLayerList.Assign(TOpenTypeColorCOLRTable(Source).FLayerList);
    end;

    if (TOpenTypeColorCOLRTable(Source).FClipList <> nil) then
    begin
      if (FClipList = nil) then
        FClipList := TClipList.Create(Self);
      FClipList.Assign(TOpenTypeColorCOLRTable(Source).FClipList);
    end;

    if (TOpenTypeColorCOLRTable(Source).FVarIndexMap <> nil) then
    begin
      if (FVarIndexMap = nil) then
        FVarIndexMap := TDeltaSetIndexMap.Create(Self);
      FVarIndexMap.Assign(TOpenTypeColorCOLRTable(Source).FVarIndexMap);
    end;

    if (TOpenTypeColorCOLRTable(Source).FItemVariationStore <> nil) then
    begin
      if (FItemVariationStore = nil) then
        FItemVariationStore := TItemVariationStore.Create(Self);
      FItemVariationStore.Assign(TOpenTypeColorCOLRTable(Source).FItemVariationStore);
    end;
  end;
end;

function TOpenTypeColorCOLRTable.GetPaint(Stream: TStream; AbsoluteOffset: Int64): TPascalTypePaint;
begin
  if FPaintCache.TryGetValue(AbsoluteOffset, Result) then
    exit;

  var SavedPos := Stream.Position;
  Stream.Position := AbsoluteOffset;
  Result := TPascalTypePaint.CreateFromStream(Self, Stream, 0);
  Stream.Position := SavedPos;
  // FPaintCache.Add is called by CreateFromStream
end;

function TOpenTypeColorCOLRTable.GetColorLine(Stream: TStream; AbsoluteOffset: Int64; IsVariable: Boolean): TCustomPascalTypeTable;
begin
  if FColorLineCache.TryGetValue(AbsoluteOffset, Result) then
    exit;

  var SavedPos := Stream.Position;
  Stream.Position := AbsoluteOffset;
  if IsVariable then
    Result := TVarColorLine.Create(Self)
  else
    Result := TColorLine.Create(Self);
  Result.LoadFromStream(Stream);
  FColorLineCache.Add(AbsoluteOffset, Result);
  Stream.Position := SavedPos;
end;

function TOpenTypeColorCOLRTable.GetTransform(Stream: TStream; AbsoluteOffset: Int64; IsVariable: Boolean): TCustomPascalTypeTable;
begin
  if FTransformCache.TryGetValue(AbsoluteOffset, Result) then
    exit;

  var SavedPos := Stream.Position;
  Stream.Position := AbsoluteOffset;
  if IsVariable then
    Result := TVarAffine2x3.Create(Self)
  else
    Result := TAffine2x3.Create(Self);
  Result.LoadFromStream(Stream);
  FTransformCache.Add(AbsoluteOffset, Result);
  Stream.Position := SavedPos;
end;

function TOpenTypeColorCOLRTable.GetClipBox(Stream: TStream; AbsoluteOffset: Int64): TClipBox;
begin
  if FClipBoxCache.TryGetValue(AbsoluteOffset, Result) then
    exit;

  var SavedPos := Stream.Position;
  Stream.Position := AbsoluteOffset;
  var LFormat := BigEndianValue.ReadByte(Stream);
  case LFormat of
    1: Result := TClipBox.Create(Self);
    2: Result := TClipBoxVar.Create(Self);
  else
    raise EPascalTypeError.CreateFmt('Invalid COLRv1 Clip Box type: %d', [LFormat]);
  end;
  Result.FFormat := LFormat;
  Result.LoadFromStream(Stream);
  FClipBoxCache.Add(AbsoluteOffset, Result);
  Stream.Position := SavedPos;
end;

function TOpenTypeColorCOLRTable.GetGlyphCount: integer;
begin
  Result := Length(FGlyphs);
end;

function TOpenTypeColorCOLRTable.GetGlyph(Index: integer): TColorBaseGlyph;
begin
  Result := FGlyphs[Index];
end;

//------------------------------------------------------------------------------

function TOpenTypeColorCOLRTable.GetLayerCount: integer;
begin
  Result := Length(FLayers);
end;

function TOpenTypeColorCOLRTable.GetLayer(Index: integer): TColorGlyphLayer;
begin
  Result := FLayers[Index];
end;

//------------------------------------------------------------------------------

procedure TOpenTypeColorCOLRTable.LoadFromStream(Stream: TStream; Size: Cardinal);
var
  StartPos: Int64;
  baseGlyphRecordsOffset: integer;
  layerRecordsOffset: integer;
  baseGlyphListOffset: integer;
  layerListOffset: integer;
  clipListOffset: integer;
  varIndexMapOffset: integer;
  itemVariationStoreOffset: integer;
begin
  StartPos := Stream.Position;
  inherited;

  // +----------+-------------------------+-----------------------------------------------------------------------+
  // | Type     | Name                    | Description                                                           |
  // +==========+=========================+=======================================================================+
  // | uint16   | version                 | Table version number (=0 or 1).                                       |
  // +----------+-------------------------+-----------------------------------------------------------------------+
  // | uint16   | numBaseGlyphRecords     | Number of BaseGlyph records.                                          |
  // +----------+-------------------------+-----------------------------------------------------------------------+
  // | Offset32 | baseGlyphRecordsOffset  | Offset to baseGlyphRecords array.                                     |
  // +----------+-------------------------+-----------------------------------------------------------------------+
  // | Offset32 | layerRecordsOffset      | Offset to layerRecords array.                                         |
  // +----------+-------------------------+-----------------------------------------------------------------------+
  // | uint16   | numLayerRecords         | Number of Layer records.                                              |
  // +----------+-------------------------+-----------------------------------------------------------------------+
  // Version 1:
  // +----------+-------------------------+-----------------------------------------------------------------------+
  // | Offset32 | baseGlyphListOffset     | Offset to BaseGlyphList table.                                        |
  // +----------+-------------------------+-----------------------------------------------------------------------+
  // | Offset32 | layerListOffset         | Offset to LayerList table.                                            |
  // +----------+-------------------------+-----------------------------------------------------------------------+
  // | Offset32 | clipListOffset          | Offset to ClipList table.                                             |
  // +----------+-------------------------+-----------------------------------------------------------------------+
  // | Offset32 | varIndexMapOffset       | Offset to DeltaSetIndexMap table.                                     |
  // +----------+-------------------------+-----------------------------------------------------------------------+
  // | Offset32 | itemVariationStoreOffset| Offset to ItemVariationStore.                                         |
  // +----------+-------------------------+-----------------------------------------------------------------------+

  // version
  FVersion := BigEndianValue.ReadWord(Stream);

  if (Version <> 0) and (Version <> 1) then
    raise EPascalTypeError.Create(RCStrUnsupportedVersion);

  // numBaseGlyphRecords
  SetLength(FGlyphs, BigEndianValue.ReadWord(Stream));

  // baseGlyphRecordsOffset
  baseGlyphRecordsOffset := BigEndianValue.ReadInteger(Stream);

  // layerRecordsOffset
  layerRecordsOffset := BigEndianValue.ReadInteger(Stream);

  // numLayerRecords
  SetLength(FLayers, BigEndianValue.ReadWord(Stream));

  if (Version > 0) then
  begin
    baseGlyphListOffset := BigEndianValue.ReadInteger(Stream);
    layerListOffset := BigEndianValue.ReadInteger(Stream);
    clipListOffset := BigEndianValue.ReadInteger(Stream);
    varIndexMapOffset := BigEndianValue.ReadInteger(Stream);
    itemVariationStoreOffset := BigEndianValue.ReadInteger(Stream);
  end else
  begin
    baseGlyphListOffset := 0;
    layerListOffset := 0;
    clipListOffset := 0;
    varIndexMapOffset := 0;
    itemVariationStoreOffset := 0;
  end;


  // Base Glyph Record
  // +----------+-----------------+-----------------------------------------------------------------------------+
  // | Type     | Name            | Description                                                                 |
  // +==========+=================+=============================================================================+
  // | uint16   | gID             | Glyph ID of reference glyph.                                                |
  // +----------+-----------------+-----------------------------------------------------------------------------+
  // | uint16   | firstLayerIndex | Index into the Layer Records.                                               |
  // +----------+-----------------+-----------------------------------------------------------------------------+
  // | uint16   | numLayers       | Number of color layers.                                                     |
  // +----------+-----------------+-----------------------------------------------------------------------------+
  if (baseGlyphRecordsOffset <> 0) then
  begin
    Stream.Position := StartPos + baseGlyphRecordsOffset;
    for var i := 0 to High(FGlyphs) do
    begin
      FGlyphs[i].GlyphID := BigEndianValue.ReadWord(Stream);
      FGlyphs[i].FirstLayerIndex := BigEndianValue.ReadWord(Stream);
      FGlyphs[i].LayerCount := BigEndianValue.ReadWord(Stream);
    end;
  end;

  // Layer Record
  // +----------+--------------+---------------------------------------------------------------------------+
  // | Type     | Name         | Description                                                               |
  // +==========+==============+===========================================================================+
  // | uint16   | gID          | Glyph ID of layer glyph.                                                  |
  // +----------+--------------+---------------------------------------------------------------------------+
  // | uint16   | paletteIndex | Index into CPAL palette.                                                  |
  // +----------+--------------+---------------------------------------------------------------------------+
  if (layerRecordsOffset <> 0) then
  begin
    Stream.Position := StartPos + layerRecordsOffset;
    for var i := 0 to High(FLayers) do
    begin
      FLayers[i].GlyphID := BigEndianValue.ReadWord(Stream);
      FLayers[i].PaletteIndex := BigEndianValue.ReadWord(Stream);
    end;
  end;

  if (Version > 0) then
  begin
    if (baseGlyphListOffset <> 0) then
    begin
      Stream.Position := StartPos + baseGlyphListOffset;
      FBaseGlyphList := TBaseGlyphList.Create(Self);
      FBaseGlyphList.LoadFromStream(Stream);
    end;

    if (layerListOffset <> 0) then
    begin
      Stream.Position := StartPos + layerListOffset;
      FLayerList := TLayerList.Create(Self);
      FLayerList.LoadFromStream(Stream);
    end;

    if (clipListOffset <> 0) then
    begin
      Stream.Position := StartPos + clipListOffset;
      FClipList := TClipList.Create(Self);
      FClipList.LoadFromStream(Stream);
    end;

    if (varIndexMapOffset <> 0) then
    begin
      Stream.Position := StartPos + varIndexMapOffset;
      FVarIndexMap := TDeltaSetIndexMap.Create(Self);
      FVarIndexMap.LoadFromStream(Stream);
    end;

    if (itemVariationStoreOffset <> 0) then
    begin
      Stream.Position := StartPos + itemVariationStoreOffset;
      FItemVariationStore := TItemVariationStore.Create(Self);
      FItemVariationStore.LoadFromStream(Stream);
    end;
  end;
end;

//------------------------------------------------------------------------------

function TOpenTypeColorCOLRTable.GetColorGlyphLookup: IPascalTypeColorGlyphLookup;
begin
  if (Length(FGlyphs) > 0) then
    Result := Self
  else
    Result := nil;
end;

function TOpenTypeColorCOLRTable.GetColoredGlyph(GlyphID: TGlyphID; var ColoredGlyphs: TColoredGlyphs): boolean;
type
  PColorGlyphLayer = ^TColorGlyphLayer;
var
  Glyph: TColorBaseGlyph;
  Index: Integer;
  i: integer;
  Layer: PColorGlyphLayer;
begin
  Glyph.GlyphID := GlyphID;

  if (FComparer = nil) then
    FComparer := TComparer<TColorBaseGlyph>.Construct(
      function(const A, B: TColorBaseGlyph): integer
      begin
        Result := integer(A.GlyphID)-integer(B.GlyphID);
      end);

  if (not TArray.BinarySearch<TColorBaseGlyph>(FGlyphs, Glyph, Index, FComparer)) then
    Exit(False);

  Setlength(ColoredGlyphs, FGlyphs[Index].LayerCount);
  Layer := @FLayers[FGlyphs[Index].FirstLayerIndex];

  for i := 0 to High(ColoredGlyphs) do
  begin
    ColoredGlyphs[i].GlyphID := Layer.GlyphID;
    ColoredGlyphs[i].PaletteIndex := Layer.PaletteIndex;
    Inc(Layer);
  end;

  Result := True;
end;

//------------------------------------------------------------------------------

initialization

  PascalTypeTableClasses.RegisterTables([TOpenTypeColorCOLRTable]);

end.