PascalType.Tables.OpenType.Common.FeatureVariation.pas

unit PascalType.Tables.OpenType.Common.FeatureVariation;

////////////////////////////////////////////////////////////////////////////////
//                                                                            //
//  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) 2025-2026           //
//  by Anders Melander. All Rights Reserved.                                  //
//                                                                            //
////////////////////////////////////////////////////////////////////////////////

interface

{$I PT_Compiler.inc}

uses
  Classes,
  SysUtils,
  Generics.Collections,
  PascalType.Types,
  PascalType.Classes,
  PascalType.Tables,
  PascalType.Tables.OpenType,
  PascalType.Tables.OpenType.Feature;

//------------------------------------------------------------------------------
//
//      Feature variations
//
//------------------------------------------------------------------------------
// https://learn.microsoft.com/en-us/typography/opentype/spec/chapter2#feature-variations
//------------------------------------------------------------------------------


//------------------------------------------------------------------------------
//
//      Condition table
//
//------------------------------------------------------------------------------
// https://learn.microsoft.com/en-us/typography/opentype/spec/chapter2#condition-table
//------------------------------------------------------------------------------
type
  TOpenTypeConditionTableClass = class of TCustomOpenTypeConditionTable;

  TCustomOpenTypeConditionTable = class abstract(TCustomPascalTypeTable)
  private class var
    FConditionTableClasses: TDictionary<Word, TOpenTypeConditionTableClass>;

  private
    class destructor Destroy;

  public
    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;
    function IsMatch(const NormalizedCoords: TArray<TFixedPoint>): Boolean; virtual; abstract;

    class function Format: Word; virtual; abstract;
    class procedure RegisterConditionTableClass;
    class function FindClassByFormat(Format: Word): TOpenTypeConditionTableClass;
  end;

//------------------------------------------------------------------------------
//
//      Condition table format 1: font variation axis range
//
//------------------------------------------------------------------------------
// https://learn.microsoft.com/en-us/typography/opentype/spec/chapter2#condition-table-format-1-font-variation-axis-range
//------------------------------------------------------------------------------
type
  TOpenTypeConditionTableVariationRegion = class(TCustomOpenTypeConditionTable)
  private
    FAxisIndex: Word;
    FFilterRangeMin: TShortFrac;
    FFilterRangeMax: TShortFrac;
    FFilterRangeMinValue: Single;
    FFilterRangeMaxValue: Single;

  public
    procedure Assign(Source: TPersistent); override;
    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;
    function IsMatch(const NormalizedCoords: TArray<TFixedPoint>): Boolean; override;

    class function Format: Word; override;

    property AxisIndex: Word read FAxisIndex;
    property FilterRangeMin: TShortFrac read FFilterRangeMin;
    property FilterRangeMax: TShortFrac read FFilterRangeMax;
  end;

//------------------------------------------------------------------------------
//
//      ConditionSet table
//
//------------------------------------------------------------------------------
// https://learn.microsoft.com/en-us/typography/opentype/spec/chapter2#conditionset-table
//------------------------------------------------------------------------------
type
  TOpenTypeConditionSetTable = class(TCustomPascalTypeTable)
  private
    FConditions: TObjectList<TCustomOpenTypeConditionTable>;
    function GetConditionCount: Integer;
    function GetCondition(Index: Integer): TCustomOpenTypeConditionTable;

  public
    constructor Create(AParent: TCustomPascalTypeTable); override;
    destructor Destroy; override;

    procedure Assign(Source: TPersistent); override;
    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;
    function IsMatch(const NormalizedCoords: TArray<TFixedPoint>): Boolean;

    property ConditionCount: Integer read GetConditionCount;
    property Conditions[Index: Integer]: TCustomOpenTypeConditionTable read GetCondition; default;
  end;

//------------------------------------------------------------------------------
//
//      FeatureTableSubstitution table
//
//------------------------------------------------------------------------------
// https://learn.microsoft.com/en-us/typography/opentype/spec/chapter2#featuretablesubstitution-table
//------------------------------------------------------------------------------
type
  TOpenTypeFeatureTableSubstitutionTable = class(TCustomPascalTypeTable)
  private type
    TOpenTypeFeatureTableSubstitutionRecord = record
      FeatureIndex: Word;
      AlternateFeatureTable: TCustomOpenTypeFeatureTable;
    end;

  private
    FSubstitutions: TArray<TOpenTypeFeatureTableSubstitutionRecord>;
    function GetSubstitutionCount: Integer;

  public
    destructor Destroy; override;
    procedure Assign(Source: TPersistent); override;
    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;
    function FindSubstitution(FeatureIndex: Word): TCustomOpenTypeFeatureTable;

    property SubstitutionCount: Integer read GetSubstitutionCount;
  end;

//------------------------------------------------------------------------------
//
//      FeatureVariations table
//
//------------------------------------------------------------------------------
// https://learn.microsoft.com/en-us/typography/opentype/spec/chapter2#featurevariations-table
//------------------------------------------------------------------------------
type
  TOpenTypeFeatureVariationsTable = class(TCustomPascalTypeTable)
  private type
    TOpenTypeFeatureVariationRecord = record
      ConditionSetTable: TOpenTypeConditionSetTable;
      FeatureTableSubstitutionTable: TOpenTypeFeatureTableSubstitutionTable;
    end;

  private
    FVersion: Cardinal;
    FVariationRecords: TArray<TOpenTypeFeatureVariationRecord>;
    function GetVariationRecordCount: Integer;

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

    function GetSubstitution(const NormalizedCoords: TArray<TFixedPoint>): TOpenTypeFeatureTableSubstitutionTable;

    property VariationRecordCount: Integer read GetVariationRecordCount;
  end;


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

implementation

uses
  Generics.Defaults,
  PascalType.ResourceStrings,
  PascalType.Tables.OpenType.Common;

{ TCustomOpenTypeConditionTable }

class destructor TCustomOpenTypeConditionTable.Destroy;
begin
  FConditionTableClasses.Free;
end;

class function TCustomOpenTypeConditionTable.FindClassByFormat(Format: Word): TOpenTypeConditionTableClass;
begin
  if (FConditionTableClasses = nil) or (not FConditionTableClasses.TryGetValue(Format, Result)) then
    Result := nil;
end;

procedure TCustomOpenTypeConditionTable.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  inherited;
  // Format is already read by TOpenTypeConditionSetTable.LoadFromStream
end;

class procedure TCustomOpenTypeConditionTable.RegisterConditionTableClass;
begin
  if (FConditionTableClasses = nil) then
    FConditionTableClasses:= TDictionary<Word, TOpenTypeConditionTableClass>.Create;
  FConditionTableClasses.Add(Format, Self);
end;

{ TOpenTypeConditionTableVariationRegion }

procedure TOpenTypeConditionTableVariationRegion.Assign(Source: TPersistent);
begin
  inherited;
  if (Source is TOpenTypeConditionTableVariationRegion) then
  begin
    FAxisIndex := TOpenTypeConditionTableVariationRegion(Source).FAxisIndex;
    FFilterRangeMin := TOpenTypeConditionTableVariationRegion(Source).FFilterRangeMin;
    FFilterRangeMax := TOpenTypeConditionTableVariationRegion(Source).FFilterRangeMax;
  end;
end;

procedure TOpenTypeConditionTableVariationRegion.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  inherited;
  FAxisIndex := BigEndianValue.ReadWord(Stream);
  FFilterRangeMin := BigEndianValue.ReadSmallInt(Stream);
  FFilterRangeMax := BigEndianValue.ReadSmallInt(Stream);

  FFilterRangeMinValue := FFilterRangeMin / 16384.0;
  FFilterRangeMaxValue := FFilterRangeMax / 16384.0;
end;

class function TOpenTypeConditionTableVariationRegion.Format: Word;
begin
  Result := 1;
end;

function TOpenTypeConditionTableVariationRegion.IsMatch(const NormalizedCoords: TArray<TFixedPoint>): Boolean;
begin
  if (FAxisIndex >= Length(NormalizedCoords)) then
    Exit(False);

  var Coord := NormalizedCoords[FAxisIndex].AsSingle;
  Result := (Coord >= FFilterRangeMinValue) and (Coord <= FFilterRangeMaxValue);
end;

{ TOpenTypeConditionSetTable }

constructor TOpenTypeConditionSetTable.Create(AParent: TCustomPascalTypeTable);
begin
  inherited;
  FConditions := TObjectList<TCustomOpenTypeConditionTable>.Create(True);
end;

destructor TOpenTypeConditionSetTable.Destroy;
begin
  FConditions.Free;
  inherited;
end;

procedure TOpenTypeConditionSetTable.Assign(Source: TPersistent);
begin
  inherited;
  if (Source is TOpenTypeConditionSetTable) then
  begin
    FConditions.Clear;
    for var i := 0 to TOpenTypeConditionSetTable(Source).ConditionCount - 1 do
    begin
      var SrcCondition := TOpenTypeConditionSetTable(Source).Conditions[i];
      var DstCondition := TOpenTypeConditionTableClass(SrcCondition.ClassType).Create(Self);

      FConditions.Add(DstCondition);

      DstCondition.Assign(SrcCondition);
    end;
  end;
end;

function TOpenTypeConditionSetTable.GetCondition(Index: Integer): TCustomOpenTypeConditionTable;
begin
  Result := FConditions[Index];
end;

function TOpenTypeConditionSetTable.GetConditionCount: Integer;
begin
  Result := FConditions.Count;
end;

function TOpenTypeConditionSetTable.IsMatch(const NormalizedCoords: TArray<TFixedPoint>): Boolean;
begin
  if (FConditions.Count = 0) then
    Exit(True);

  for var Condition in FConditions do
    if not Condition.IsMatch(NormalizedCoords) then
      Exit(False);

  Result := True;
end;

procedure TOpenTypeConditionSetTable.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  var StartPos := Stream.Position;
  inherited;

  var ConditionCount := BigEndianValue.ReadWord(Stream);
  var Offsets: TArray<Cardinal>;
  SetLength(Offsets, ConditionCount);

  for var i := 0 to ConditionCount - 1 do
    Offsets[i] := BigEndianValue.ReadCardinal(Stream);

  for var i := 0 to ConditionCount - 1 do
  begin
    Stream.Position := StartPos + Offsets[i];
    var Format := BigEndianValue.ReadWord(Stream);

    var ConditionClass := TCustomOpenTypeConditionTable.FindClassByFormat(Format);
    if (ConditionClass = nil) then
      continue; // Unsupported condition format

    var Condition := ConditionClass.Create(Self);

    FConditions.Add(Condition);
    Condition.LoadFromStream(Stream);
  end;
end;

{ TOpenTypeFeatureTableSubstitutionTable }

destructor TOpenTypeFeatureTableSubstitutionTable.Destroy;
begin
  for var i := 0 to High(FSubstitutions) do
    FSubstitutions[i].AlternateFeatureTable.Free;
  inherited;
end;

procedure TOpenTypeFeatureTableSubstitutionTable.Assign(Source: TPersistent);
begin
  inherited;
  if (Source is TOpenTypeFeatureTableSubstitutionTable) then
  begin
    for var i := 0 to High(FSubstitutions) do
      FSubstitutions[i].AlternateFeatureTable.Free;

    SetLength(FSubstitutions, TOpenTypeFeatureTableSubstitutionTable(Source).SubstitutionCount);

    for var i := 0 to High(FSubstitutions) do
    begin
      var SrcSubst := TOpenTypeFeatureTableSubstitutionTable(Source).FSubstitutions[i];
      FSubstitutions[i].FeatureIndex := SrcSubst.FeatureIndex;
      FSubstitutions[i].AlternateFeatureTable := TCustomOpenTypeFeatureTable(SrcSubst.AlternateFeatureTable.ClassType).Create(Self);
      FSubstitutions[i].AlternateFeatureTable.Assign(SrcSubst.AlternateFeatureTable);
    end;
  end;
end;

function TOpenTypeFeatureTableSubstitutionTable.FindSubstitution(FeatureIndex: Word): TCustomOpenTypeFeatureTable;
begin
  for var i := 0 to High(FSubstitutions) do
    if (FSubstitutions[i].FeatureIndex = FeatureIndex) then
      Exit(FSubstitutions[i].AlternateFeatureTable);
  Result := nil;
end;

function TOpenTypeFeatureTableSubstitutionTable.GetSubstitutionCount: Integer;
begin
  Result := Length(FSubstitutions);
end;

procedure TOpenTypeFeatureTableSubstitutionTable.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  var StartPos := Stream.Position;
  inherited;

  var Version := BigEndianValue.ReadCardinal(Stream);
  if (Version <> $00010000) then
    raise EPascalTypeError.Create(RCStrUnsupportedVersion);

  var SubstitutionCount := BigEndianValue.ReadWord(Stream);
  SetLength(FSubstitutions, SubstitutionCount);

  // FeatureRecord only contains the offset to the Feature Table. To determine
  // the correct class for specialized feature parameter parsing, we must
  // retrieve the feature's Tag from the GSUB/GPOS table's FeatureListTable.
  var CommonTable: TCustomOpenTypeCommonTable := nil;
  if (Parent <> nil) and (Parent.Parent <> nil) then
    CommonTable := Parent.Parent as TCustomOpenTypeCommonTable;

  for var i := 0 to SubstitutionCount - 1 do
  begin
    FSubstitutions[i].FeatureIndex := BigEndianValue.ReadWord(Stream);
    var AlternateFeatureOffset := BigEndianValue.ReadCardinal(Stream);

    var SavePos := Stream.Position;
    Stream.Position := StartPos + AlternateFeatureOffset;

    var FeatureClass: TOpenTypeFeatureTableClass := nil;
    var Tag: TTableType := 0;

    if (FSubstitutions[i].FeatureIndex < CommonTable.FeatureListTable.FeatureCount) then
    begin
      Tag := CommonTable.FeatureListTable.Feature[FSubstitutions[i].FeatureIndex].TableType;
      FeatureClass := FindFeatureByType(Tag);
    end;

    if (FeatureClass = nil) then
      FeatureClass := TOpenTypeFeatureTableGeneric;

    var FeatureTable := FeatureClass.Create(Self);
    FSubstitutions[i].AlternateFeatureTable := FeatureTable;

    if (FeatureTable is TOpenTypeFeatureTableGeneric) then
      TOpenTypeFeatureTableGeneric(FeatureTable).TableType := Tag;

    FeatureTable.LoadFromStream(Stream);

    Stream.Position := SavePos;
  end;
end;

{ TOpenTypeFeatureVariationsTable }

destructor TOpenTypeFeatureVariationsTable.Destroy;
begin
  for var i := 0 to High(FVariationRecords) do
  begin
    FVariationRecords[i].ConditionSetTable.Free;
    FVariationRecords[i].FeatureTableSubstitutionTable.Free;
  end;
  inherited;
end;

procedure TOpenTypeFeatureVariationsTable.Assign(Source: TPersistent);
begin
  inherited;
  if (Source is TOpenTypeFeatureVariationsTable) then
  begin
    for var i := 0 to High(FVariationRecords) do
    begin
      FVariationRecords[i].ConditionSetTable.Free;
      FVariationRecords[i].FeatureTableSubstitutionTable.Free;
    end;

    FVersion := TOpenTypeFeatureVariationsTable(Source).FVersion;
    SetLength(FVariationRecords, TOpenTypeFeatureVariationsTable(Source).VariationRecordCount);

    for var i := 0 to High(FVariationRecords) do
    begin
      var SrcRecord := TOpenTypeFeatureVariationsTable(Source).FVariationRecords[i];
      if (SrcRecord.ConditionSetTable <> nil) then
      begin
        FVariationRecords[i].ConditionSetTable := TOpenTypeConditionSetTable.Create(Self);
        FVariationRecords[i].ConditionSetTable.Assign(SrcRecord.ConditionSetTable);
      end else
        FVariationRecords[i].ConditionSetTable := nil;

      if (SrcRecord.FeatureTableSubstitutionTable <> nil) then
      begin
        FVariationRecords[i].FeatureTableSubstitutionTable := TOpenTypeFeatureTableSubstitutionTable.Create(Self);
        FVariationRecords[i].FeatureTableSubstitutionTable.Assign(SrcRecord.FeatureTableSubstitutionTable);
      end else
        FVariationRecords[i].FeatureTableSubstitutionTable := nil;
    end;
  end;
end;

function TOpenTypeFeatureVariationsTable.GetSubstitution(const NormalizedCoords: TArray<TFixedPoint>): TOpenTypeFeatureTableSubstitutionTable;
begin
  for var i := 0 to High(FVariationRecords) do
    if FVariationRecords[i].ConditionSetTable.IsMatch(NormalizedCoords) then
      Exit(FVariationRecords[i].FeatureTableSubstitutionTable);
  Result := nil;
end;

function TOpenTypeFeatureVariationsTable.GetVariationRecordCount: Integer;
begin
  Result := Length(FVariationRecords);
end;

procedure TOpenTypeFeatureVariationsTable.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  var StartPos := Stream.Position;
  inherited;

  FVersion := BigEndianValue.ReadCardinal(Stream);
  if (FVersion <> $00010000) then
    raise EPascalTypeError.Create(RCStrUnsupportedVersion);

  var RecordCount := BigEndianValue.ReadCardinal(Stream);
  SetLength(FVariationRecords, RecordCount);

  for var i := 0 to RecordCount - 1 do
  begin
    var ConditionSetOffset := BigEndianValue.ReadCardinal(Stream);
    var FeatureTableSubstitutionOffset := BigEndianValue.ReadCardinal(Stream);

    var SavePos := Stream.Position;

    if (ConditionSetOffset <> 0) then
    begin
      Stream.Position := StartPos + ConditionSetOffset;
      FVariationRecords[i].ConditionSetTable := TOpenTypeConditionSetTable.Create(Self);
      FVariationRecords[i].ConditionSetTable.LoadFromStream(Stream);
    end else
      FVariationRecords[i].ConditionSetTable := nil;

    if (FeatureTableSubstitutionOffset <> 0) then
    begin
      Stream.Position := StartPos + FeatureTableSubstitutionOffset;
      FVariationRecords[i].FeatureTableSubstitutionTable := TOpenTypeFeatureTableSubstitutionTable.Create(Self);
      FVariationRecords[i].FeatureTableSubstitutionTable.LoadFromStream(Stream);
    end else
      FVariationRecords[i].FeatureTableSubstitutionTable := nil;

    Stream.Position := SavePos;
  end;
end;

initialization
  TOpenTypeConditionTableVariationRegion.RegisterConditionTableClass;
end.