PascalType.Tables.OpenType.VVAR.pas

unit PascalType.Tables.OpenType.VVAR;

////////////////////////////////////////////////////////////////////////////////
//                                                                            //
//  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.Common.Variation;

type
  TPascalTypeVerticalMetricsVariationTable = class(TCustomPascalTypeNamedTable)
  private
    FMajorVersion: Word;
    FMinorVersion: Word;
    FItemVariationStore: TItemVariationStore;
    FAdvanceHeightMap: TDeltaSetIndexMap;
    FTSBMap: TDeltaSetIndexMap;
    FBSBMap: TDeltaSetIndexMap;
    FYOrigMap: TDeltaSetIndexMap;
  public
    constructor Create(AParent: TCustomPascalTypeTable); override;
    destructor Destroy; override;

    class function GetTableType: TTableType; override;

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

    function GetAdvanceHeightDelta(GlyphIndex: Word; const NormalizedCoords: TArray<TFixedPoint>): Single;
    function GetTSBDelta(GlyphIndex: Word; const NormalizedCoords: TArray<TFixedPoint>): Single;
    function GetBSBDelta(GlyphIndex: Word; const NormalizedCoords: TArray<TFixedPoint>): Single;
    function GetVORGDelta(GlyphIndex: Word; const NormalizedCoords: TArray<TFixedPoint>): Single;

    property ItemVariationStore: TItemVariationStore read FItemVariationStore;
  end;

implementation

uses
  PascalType.ResourceStrings;

{ TPascalTypeVerticalMetricsVariationTable }

constructor TPascalTypeVerticalMetricsVariationTable.Create(AParent: TCustomPascalTypeTable);
begin
  inherited;
  FItemVariationStore := TItemVariationStore.Create(Self);
end;

destructor TPascalTypeVerticalMetricsVariationTable.Destroy;
begin
  FItemVariationStore.Free;
  FAdvanceHeightMap.Free;
  FTSBMap.Free;
  FBSBMap.Free;
  FYOrigMap.Free;
  inherited;
end;

class function TPascalTypeVerticalMetricsVariationTable.GetTableType: TTableType;
begin
  Result.AsAnsiChar := 'VVAR';
end;

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

  FMajorVersion := BigEndianValue.ReadWord(Stream);
  FMinorVersion := BigEndianValue.ReadWord(Stream);
  var ItemVariationStoreOffset := BigEndianValue.ReadCardinal(Stream);
  var AdvanceHeightMapOffset := BigEndianValue.ReadCardinal(Stream);
  var TSBMapOffset := BigEndianValue.ReadCardinal(Stream);
  var BSBMapOffset := BigEndianValue.ReadCardinal(Stream);
  var YOrigMapOffset := BigEndianValue.ReadCardinal(Stream);

  if ItemVariationStoreOffset <> 0 then
  begin
    Stream.Position := StartPos + ItemVariationStoreOffset;
    FItemVariationStore.LoadFromStream(Stream);
  end;

  if AdvanceHeightMapOffset <> 0 then
  begin
    Stream.Position := StartPos + AdvanceHeightMapOffset;
    FAdvanceHeightMap := TDeltaSetIndexMap.Create(Self);
    FAdvanceHeightMap.LoadFromStream(Stream, Size - AdvanceHeightMapOffset); // Not the actual size, but better than no size
  end;

  if TSBMapOffset <> 0 then
  begin
    Stream.Position := StartPos + TSBMapOffset;
    FTSBMap := TDeltaSetIndexMap.Create(Self);
    FTSBMap.LoadFromStream(Stream, Size - TSBMapOffset);
  end;

  if BSBMapOffset <> 0 then
  begin
    Stream.Position := StartPos + BSBMapOffset;
    FBSBMap := TDeltaSetIndexMap.Create(Self);
    FBSBMap.LoadFromStream(Stream, Size - BSBMapOffset);
  end;

  if YOrigMapOffset <> 0 then
  begin
    Stream.Position := StartPos + YOrigMapOffset;
    FYOrigMap := TDeltaSetIndexMap.Create(Self);
    FYOrigMap.LoadFromStream(Stream, Size - YOrigMapOffset);
  end;
end;

procedure TPascalTypeVerticalMetricsVariationTable.SaveToStream(Stream: TStream);
begin
  raise EPascalTypeNotImplemented.Create(RCStrNotImplemented);
end;

function TPascalTypeVerticalMetricsVariationTable.GetAdvanceHeightDelta(GlyphIndex: Word; const NormalizedCoords: TArray<TFixedPoint>): Single;
begin
  Result := 0;
  if (FAdvanceHeightMap <> nil) then
  begin
    var Outer, Inner: Word;
    if FAdvanceHeightMap.GetIndex(GlyphIndex, Outer, Inner) then
      Result := FItemVariationStore.GetDelta(Outer, Inner, NormalizedCoords);
  end else
    Result := FItemVariationStore.GetDelta(0, GlyphIndex, NormalizedCoords);
end;

function TPascalTypeVerticalMetricsVariationTable.GetTSBDelta(GlyphIndex: Word; const NormalizedCoords: TArray<TFixedPoint>): Single;
begin
  Result := 0;
  if (FTSBMap <> nil) then
  begin
    var Outer, Inner: Word;
    if FTSBMap.GetIndex(GlyphIndex, Outer, Inner) then
      Result := FItemVariationStore.GetDelta(Outer, Inner, NormalizedCoords);
  end;
end;

function TPascalTypeVerticalMetricsVariationTable.GetBSBDelta(GlyphIndex: Word; const NormalizedCoords: TArray<TFixedPoint>): Single;
begin
  Result := 0;
  if (FBSBMap <> nil) then
  begin
    var Outer, Inner: Word;
    if FBSBMap.GetIndex(GlyphIndex, Outer, Inner) then
      Result := FItemVariationStore.GetDelta(Outer, Inner, NormalizedCoords);
  end;
end;

function TPascalTypeVerticalMetricsVariationTable.GetVORGDelta(GlyphIndex: Word; const NormalizedCoords: TArray<TFixedPoint>): Single;
begin
  Result := 0;
  if (FYOrigMap <> nil) then
  begin
    var Outer, Inner: Word;
    if FYOrigMap.GetIndex(GlyphIndex, Outer, Inner) then
      Result := FItemVariationStore.GetDelta(Outer, Inner, NormalizedCoords);
  end;
end;

initialization

  PascalTypeTableClasses.RegisterTables([TPascalTypeVerticalMetricsVariationTable]);

end.