opengl
/
ShaderFile
1
0
Förgrening 0
Kod Ärenden 0 Pull-förfrågningar 0 Släpp 0 Wiki Aktiviteter
Du kan inte välja fler än 25 ämnen Ämnen måste starta med en bokstav eller siffra, kan innehålla bindestreck ('-') och vara max 35 tecken långa.
14 Incheckningar
1 Gren
222 KiB
 
Träd: fc7e3feaa8
Grenar Taggar
${ item.name }
Skapa branchen ${ searchTerm }
från 'fc7e3feaa8'
${ noResults }
ShaderFile/uengShaderFile.old.pas

5642 rader
234 KiB
Rå Blame Historik 

  1. unit uengShaderFile;

  2. 

  3. { Package:      SpaceEngine

  4.   Prefix:       eng - ENGine

  5.   Beschreibung: stellt Klassen zum laden von Shader-Datein zur Verfügung

  6.                 beim laden des Codes wird gleichzeitig die Präprozessor-Sprache ausgewertet

  7.   Hint:         'USE_VFS' in Projekt-Einstellungen definieren um VFS Support zu aktivieren

  8.                 'SHADER_FILE_NO_VFS' in Projekt-Einstellungen um VFS Support für diese Unit zu deaktivieren}

  9. 

  10. {$mode objfpc}{$H+}

  11. {.$DEFINE EXPRESSION_ADD_BRACKET}

  12. {.$DEFINE DEBUG}

  13. 

  14. interface

  15. 

  16. {$IFDEF SHADER_FILE_NO_VFS}

  17.   {$UNDEF USE_VFS}

  18. {$ENDIF}

  19. 

  20. uses

  21.   //System

  22.   Classes, SysUtils, variants,

  23. 

  24.   //bitSpaceEngine

  25.   uutlGenerics, uutlCommon;

  26. 

  27. type

  28. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  29. //EXPRESSIONS///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  30. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  31.   TengShaderPartScope = class;

  32.   TengGenCodeArgs = class;

  33. 

  34.   TengExpressionItem = class

  35.   protected

  36.     fLine: Integer;

  37.     fCol: Integer;

  38.     fFilename: String;

  39.   public

  40.     function GetText: String; virtual;

  41.     function GetValue(const aScope: TengShaderPartScope; const aGenCodeArgs: TengGenCodeArgs): Variant; virtual;

  42.     constructor Create(const aLine, aCol: Integer; const aFilename: String);

  43.   end;

  44. 

  45. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  46.   TengExpressionValue = class(TengExpressionItem)

  47.   private

  48.     fValue: Variant;

  49.   public

  50.     function GetText: String; override;

  51.     function GetValue(const aScope: TengShaderPartScope; const aGenCodeArgs: TengGenCodeArgs): Variant; override;

  52.     constructor Create(const aValue: Variant; const aLine, aCol: Integer; const aFilename: String);

  53.   end;

  54. 

  55. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  56.   TengExpressionVariable = class(TengExpressionItem)

  57.   private

  58.     fVariableName: String;

  59.   public

  60.     function GetText: String; override;

  61.     function GetValue(const aScope: TengShaderPartScope; const aGenCodeArgs: TengGenCodeArgs): Variant; override;

  62.     constructor Create(const aVariableName: String; const aLine, aCol: Integer; const aFilename: String);

  63.   end;

  64. 

  65. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  66.   TengExpressionGroup = class(TengExpressionItem)

  67.   private

  68.     fChild: TengExpressionItem;

  69.   public

  70.     property Child: TengExpressionItem read fChild write fChild;

  71.     function GetText: String; override;

  72.     function GetValue(const aScope: TengShaderPartScope; const aGenCodeArgs: TengGenCodeArgs): Variant; override;

  73.     constructor Create(const aChild: TengExpressionItem; const aLine, aCol: Integer; const aFilename: String);

  74.     destructor Destroy; override;

  75.   end;

  76. 

  77. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  78.   TengExpressionUnaryOperator = (

  79.     opBinaryNot, opLogicalNot, opDefined, opSet

  80.   );

  81.   TengExpressionUnaryOperation = class(TengExpressionItem)

  82.   private

  83.     fChild: TengExpressionItem;

  84.     fUnaryOp: TengExpressionUnaryOperator;

  85.   public

  86.     property Child: TengExpressionItem read fChild write fChild;

  87.     property UnaryOp: TengExpressionUnaryOperator read fUnaryOp;

  88. 

  89.     function GetText: String; override;

  90.     function GetValue(const aScope: TengShaderPartScope; const aGenCodeArgs: TengGenCodeArgs): Variant; override;

  91. 

  92.     constructor Create(const aUnaryOp: TengExpressionUnaryOperator; const aLine, aCol: Integer; const aFilename: String);

  93.     destructor Destroy; override;

  94.   end;

  95. 

  96. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  97.   TengExpressionBinaryOperator = ( //order of elements in this enum is also the weight of the operators

  98.     opBinaryOr, opBinaryAnd, opBinaryXor,                               // binary

  99.     opMultiply, opDivide, opAdd, opSubtract,                            // arithmetic

  100.     opLogicalOr, opLogicalAnd, opLogicalXor,                            // logical

  101.     opEquals, opLesser, opGreater, opLEquals, opGEquals, opUnequals     // comparison

  102.   );

  103.   TengExpressionBinaryOperation = class(TengExpressionItem)

  104.   private

  105.     fFirst: TengExpressionItem;

  106.     fSecond: TengExpressionItem;

  107.     fBinaryOp: TengExpressionBinaryOperator;

  108.   public

  109.     property First:  TengExpressionItem read fFirst  write fFirst;

  110.     property Second: TengExpressionItem read fSecond write fSecond;

  111.     property BinaryOp: TengExpressionBinaryOperator read fBinaryOp;

  112. 

  113.     function GetText: String; override;

  114.     function GetValue(const aScope: TengShaderPartScope; const aGenCodeArgs: TengGenCodeArgs): Variant; override;

  115. 

  116.     constructor Create(const aOperator: TengExpressionBinaryOperator; const aLine, aCol: Integer; const aFilename: String);

  117.     destructor Destroy; override;

  118.   end;

  119. 

  120. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  121. //EXCEPTIONS////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  122. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  123.   TengShaderPart = class;

  124.   CengShaderPart = class of TengShaderPart;

  125. 

  126.   EengShaderPart = class(Exception)

  127.   public

  128.     Line, Col: Integer;

  129.     Filename: String;

  130.     constructor Create(const aMsg: String; const aLine, aCol: Integer; const aFilename: String); overload;

  131.   end;

  132. 

  133.   EengInvalidParamter = class(EengShaderPart)

  134.     constructor Create(const aMsg: String; const aLine, aCol: Integer; const aFilename: String); overload;

  135.   end;

  136. 

  137.   EengInvalidIdentifier = class(EengShaderPart)

  138.     constructor Create(const aIdentifier: String; const aLine, aCol: Integer; const aFilename: String); overload;

  139.   end;

  140. 

  141.   EengEmptyToken = class(EengShaderPart)

  142.     constructor Create(const aLine, aCol: Integer; const aFilename: String); overload;

  143.   end;

  144. 

  145.   EengInvalidToken = class(EengShaderPart)

  146.     constructor Create(const aClassName: String; const aToken: String; const aLine, aCol: Integer; const aFilename: String); overload;

  147.   end;

  148. 

  149.   EengInvalidParamterCount = class(EengShaderPart)

  150.     constructor Create(const aToken: String; const aLine, aCol: Integer; const aFilename: String); overload;

  151.   end;

  152. 

  153.   EengDuplicateIdentifier = class(EengShaderPart)

  154.     constructor Create(const aName: String; const aNew, aOld: TengShaderPart); overload;

  155.   end;

  156. 

  157.   EengInternal = class(EengShaderPart)

  158.     constructor Create(const aMsg: String); overload;

  159.     constructor Create(const aMsg: String; const aLine, aCol: Integer; const aFilename: String); overload;

  160.   end;

  161. 

  162.   EengUnknownIdentifier = class(EengShaderPart)

  163.     constructor Create(const aIdent: String; const aLine, aCol: Integer; const aFilename: String); overload;

  164.   end;

  165. 

  166.   EengExpression = class(EengShaderPart);

  167. 

  168. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  169. //SHADER PARTS//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  170. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  171.   TengShaderFile = class;

  172.   TengParseArgs = class;

  173. 

  174.   TengTokenParameter = packed record

  175.     Name: String;

  176.     Quoted: Boolean;

  177.     Line: Integer;

  178.     Col: Integer;

  179.   end;

  180.   TengTokenParameterList = specialize TutlSimpleList<TengTokenParameter>;

  181. 

  182.   TengMapDataFlag = (

  183.     mdfIfEvaluate,    //evaluate if parts and add suitable subtree

  184.     mdfIfAll,         //do not evaluate if parts and add all subtrees

  185.     mdfAddInherited,  //add inherited scopes to parent

  186.     mdfMapInherited,  //map parts of inherited scopes

  187.     mdfCurrentScope,  //do not map child scopes

  188.     mdfChild          //is set if current node is not that node the recursion started

  189.   );

  190.   TengMapDataFlags = set of TengMapDataFlag;

  191. 

  192.   TengShaderPartFlag = (

  193.     spfCodeGenVisited //this item was visited by code gen routine

  194.   );

  195.   TengShaderPartFlags = set of TengShaderPartFlag;

  196.   TengShaderPart = class(TutlInterfaceNoRefCount)

  197.   { Load & Store Code }

  198.   protected type

  199.     TengShaderPartEnumerator = class(TObject)

  200.     private

  201.       fOwner: TengShaderPart;

  202.       fPosition: Integer;

  203.       function GetCurrent: TengShaderPart;

  204.     public

  205.       property Current: TengShaderPart read GetCurrent;

  206.       function MoveNext: Boolean;

  207.       constructor Create(const aOwner: TengShaderPart);

  208.     end;

  209. 

  210.   private

  211.     fRoot: TengShaderFile;

  212.     fParent: TengShaderPart;

  213.     fLine: Integer;

  214.     fCol: Integer;

  215.   protected

  216.     function GetCount: Integer; virtual;

  217.     function GetChild(const aIndex: Integer): TengShaderPart; virtual;

  218.     function GetFilename: String; virtual;

  219.     function GetShaderClass: String; virtual;

  220.     function GetText: String; virtual;

  221. 

  222.     function ParseTextIntern(const aParseArgs: TengParseArgs; const aParameters: TengTokenParameterList): String; virtual;

  223.     function ParseText(const aParseArgs: TengParseArgs): String;

  224. 

  225.   { Generate Shader Code }

  226.   private

  227.     fFlags: TengShaderPartFlags;

  228.   protected

  229.     procedure MapData(const aFlags: TengMapDataFlags; const aTypes: array of CengShaderPart); virtual;

  230.     procedure GenCodeIntern(const aGenCodeArgs: TengGenCodeArgs); virtual;

  231.     procedure ClearGenCode; virtual;

  232.   public

  233.     property Flags: TengShaderPartFlags read fFlags;

  234. 

  235.   { General  }

  236.   public

  237.     property Root: TengShaderFile read fRoot;

  238.     property Line: Integer read fLine;

  239.     property Col: Integer read fCol;

  240.     property Filename: String read GetFilename;

  241.     property ShaderClass: String read GetShaderClass;

  242.     property Parent: TengShaderPart read fParent;

  243.     property Count: Integer read GetCount;

  244.     property Children[const aIndex: Integer]: TengShaderPart read GetChild; default;

  245.     property Text: String read GetText;

  246. 

  247.     function HasParentType(const aParentType: CengShaderPart; const aIncludeSelf: Boolean = false): Boolean;

  248.     procedure GetParentByType(const aParentType: CengShaderPart; out aPart);

  249.     function GetEnumerator: TengShaderPartEnumerator;

  250. 

  251.     constructor Create(const aParent: TengShaderPart); virtual;

  252.   public

  253.     class function GetTokenName: String; virtual;

  254.     class function CheckToken(const aToken: String): Boolean; virtual;

  255.     class procedure CheckToken(const aParseArgs: TengParseArgs; const aParent: TengShaderPart); virtual;

  256.   end;

  257.   TengShaderPartList = specialize TutlList<TengShaderPart>;

  258. 

  259. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  260.   TengShaderPartContainer = class(TengShaderPart)

  261.   { Load & Store Code }

  262.   private

  263.     fChildren: TengShaderPartList;

  264.     function HandleToken(var aToken: String; const aParseArgs: TengParseArgs): String;

  265.   protected

  266.     function GetCount: Integer; override;

  267.     function GetChild(const aIndex: Integer): TengShaderPart; override;

  268.     function GetText: String; override;

  269.     function ParseTextIntern(const aParseArgs: TengParseArgs; const aParameters: TengTokenParameterList): String; override;

  270. 

  271.   { Generate Shader Code }

  272.   protected

  273.     procedure MapData(const aFlags: TengMapDataFlags; const aTypes: array of CengShaderPart); override;

  274.     procedure GenCodeIntern(const aGenCodeArgs: TengGenCodeArgs); override;

  275.     procedure ClearGenCode; override;

  276. 

  277.   { General }

  278.   public

  279.     procedure AddChild(const aChild: TengShaderPart; const aPrepend: Boolean = false);

  280.     constructor Create(const aParent: TengShaderPart); override;

  281.     destructor Destroy; override;

  282.   end;

  283. 

  284. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  285.   TengFindMappedPartFlag = (

  286.     // general

  287.     ffGlobal,         // set current node to root before searching

  288.     ffDescending,     // depth search starting at current node

  289.     ffAscending,      // search in parents and grand parents starting at current node

  290.     ffLocal,          // search in mapped parts of current item (will be reseted when entering next or previous recursion level)

  291.     ffFindFirst,      // return after finding at least one result

  292.     ffVisited,        // only search in scopes that are already visited by GenCode

  293. 

  294.     // class data

  295.     ffInherited,      // search in inherited classes (this is not a new recursion level!)

  296.     ffFile,           // search in file that belongs to this class (this is not a new recursion level!)

  297. 

  298.     // file                                    GenCodeIntern

  299.     ffIgnoreClasses   // ignore class parts

  300.   );

  301.   TengFindMappedPartFlags = set of TengFindMappedPartFlag;

  302. 

  303.   TengShaderPartScope = class(TengShaderPartContainer)

  304.   { Generate Shader Code }

  305.   private type

  306.     TengShaderPartScopeHashSet = specialize TutlHashSet<TengShaderPartScope>;

  307.     TengShaderPartMap = specialize TutlMap<string, TengShaderPart>;

  308.   private

  309.     fInherited: TengShaderPartScopeHashSet;

  310.     fChildScopes: TengShaderPartScopeHashSet;

  311.     fMappedParts: TengShaderPartMap;

  312. 

  313.     function CheckName(const aName: String; const aShaderPart: TengShaderPart): Boolean;

  314.   protected

  315.     procedure MapChildScope(const aScope: TengShaderPartScope);

  316.     procedure MapInheritedScope(const aScope: TengShaderPartScope);

  317.     function MapShaderPart(const aName: String; const aShaderPart: TengShaderPart): Boolean;

  318. 

  319.     procedure FindMappedPart(out aShaderPart; const aName: String; const aFlags: TengFindMappedPartFlags; const aType: CengShaderPart = nil);

  320.     procedure FindMappedParts(const aParts: TengShaderPartList; const aName: String; const aFlags: TengFindMappedPartFlags; const aType: CengShaderPart = nil); virtual;

  321. 

  322.     function GetFindPropertyFlags: TengFindMappedPartFlags; virtual;

  323.     procedure CheckDuplicate(const aName: String; const aOld, aNew: TengShaderPart); virtual;

  324.     procedure MapData(const aFlags: TengMapDataFlags; const aTypes: array of CengShaderPart); override;

  325.     procedure GenCodeIntern(const aGenCodeArgs: TengGenCodeArgs); override;

  326.     procedure ClearGenCode; override;

  327.     procedure ClearMappedData(const aExcludedTypes: array of CengShaderPart); overload;

  328.     procedure ClearMappedData; overload;

  329.   public

  330.     constructor Create(const aParent: TengShaderPart); override;

  331.     destructor Destroy; override;

  332.   end;

  333. 

  334. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  335.   TengShaderCode = class;

  336.   TengShaderPartProperty = class;

  337.   TengShaderPartDefine = class;

  338.   TengCodeGenerator = class(TengShaderPartScope)

  339.   private

  340.     function GetProperty(const aName: String): TengShaderPartProperty;

  341.   protected

  342.     procedure GenerateCode(const aGenCodeArgs: TengGenCodeArgs); virtual;

  343.   public

  344.     property Properties[const aName: String]: TengShaderPartProperty read GetProperty; default;

  345. 

  346.     function GenerateCode: TengShaderCode;

  347.     procedure ListProperties(const aList: TStrings); virtual;

  348.   end;

  349. 

  350. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  351.   TengShaderPartClass = class(TengCodeGenerator)

  352.   { Load & Store Code }

  353.   private

  354.     fName: String;

  355.     fExtends: TStringList;

  356.     function GetExtendCount: Integer;

  357.     function GetExtends(const aIndex: Integer): String;

  358.   protected

  359.     function GetText: String; override;

  360.     function GetShaderClass: String; override;

  361. 

  362.     function ParseTextIntern(const aParseArgs: TengParseArgs; const aParameters: TengTokenParameterList): String; override;

  363.   public

  364.     property Name: String read fName;

  365.     property ExtendCount: Integer read GetExtendCount;

  366.     property Extends[const aIndex: Integer]: String read GetExtends;

  367. 

  368.   { Generate Shader Code }

  369.   protected

  370.     procedure CheckDuplicate(const aName: String; const aOld, aNew: TengShaderPart); override;

  371.     function GetFindPropertyFlags: TengFindMappedPartFlags; override;

  372.     procedure GenCodeIntern(const aGenCodeArgs: TengGenCodeArgs); override;

  373.     procedure GenerateCode(const aGenCodeArgs: TengGenCodeArgs); override;

  374.   public

  375.     procedure FindMappedParts(const aParts: TengShaderPartList; const aName: String; const aFlags: TengFindMappedPartFlags; const aType: CengShaderPart = nil); override;

  376.     procedure MapData(const aFlags: TengMapDataFlags; const aTypes: array of CengShaderPart); override;

  377. 

  378.   { General }

  379.   public

  380.     constructor Create(const aParent: TengShaderPart); override;

  381.     destructor Destroy; override;

  382.   public

  383.     class function GetTokenName: String; override;

  384.     class procedure CheckToken(const aParseArgs: TengParseArgs; const aParent: TengShaderPart); override;

  385.   end;

  386. 

  387. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  388.   TengShaderFile = class(TengCodeGenerator)

  389.   { Load & Store Code }

  390.   private

  391.     fFilename: String;

  392.   protected

  393.     function GetFilename: String; override;

  394.   public

  395.     property Filename: String read fFilename;

  396.     procedure LoadFromFile(const aFilename: String);

  397.     procedure SaveToFile(const aFilename: String);

  398.     procedure LoadFromStream(const aStream: TStream; const aFilename: String);

  399.     procedure SaveToStream(const aStream: TStream);

  400. 

  401.   { Generate Shader Code }

  402.   private type

  403.     TengShaderPartClassMap = specialize TutlMap<string, TengShaderPartClass>;

  404.   private

  405.     fClasses: TengShaderPartClassMap;

  406.     function GetGenerator(const aName: String): TengCodeGenerator;

  407.   protected

  408.     function GetFindPropertyFlags: TengFindMappedPartFlags; override;

  409.     procedure MapData(const aFlags: TengMapDataFlags; const aTypes: array of CengShaderPart); override;

  410.     function GetClass(const aName: String): TengShaderPartClass;

  411.     procedure AddClass(const aClass: TengShaderPartClass);

  412.     procedure GenerateCode(const aGenCodeArgs: TengGenCodeArgs); override;

  413.   public

  414.     { be carefull with the returned object, it will be destroyed

  415.       when the shaderfile is cleared, reloaded or destroyed }

  416.     property Generator[const aName: String]: TengCodeGenerator read GetGenerator;

  417.     procedure ListGenerators(const aList: TStrings);

  418. 

  419.   { General }

  420.   public

  421.     procedure Clear;

  422.     constructor Create(const aParent: TengShaderPart); override; overload;

  423.     constructor Create; overload;

  424.     destructor Destroy; override;

  425.   end;

  426. 

  427. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  428.   TengShaderPartInclude = class(TengShaderPart)

  429.   { Load & Store Code }

  430.   private

  431.     fShaderFile: TengShaderFile;

  432.     fIncludeFile: String;

  433.     fAbsoluteFile: String;

  434.   protected

  435.     function GetCount: Integer; override;

  436.     function GetChild(const aIndex: Integer): TengShaderPart; override;

  437.     function GetText: String; override;

  438.     function ParseTextIntern(const aParseArgs: TengParseArgs; const aParameters: TengTokenParameterList): String; override;

  439. 

  440.   { Generate Code }

  441.   private

  442.     procedure CheckShaderFile;

  443.   protected

  444.     procedure MapData(const aFlags: TengMapDataFlags; const aTypes: array of CengShaderPart); override;

  445.     procedure GenCodeIntern(const aGenCodeArgs: TengGenCodeArgs); override;

  446. 

  447.   { General }

  448.   public

  449.     property IncludeFile: String read fIncludeFile;

  450.     constructor Create(const aParent: TengShaderPart); override;

  451.     destructor Destroy; override;

  452.   public

  453.     class function GetTokenName: String; override;

  454.   end;

  455. 

  456. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  457.   TengShaderPartComment = class(TengShaderPart)

  458.   private

  459.     fText: String;

  460.   protected

  461.     function GetText: String; override;

  462.     function ParseTextIntern(const aParseArgs: TengParseArgs; const aParameters: TengTokenParameterList): String; override;

  463.   public

  464.     class function GetTokenName: String; override;

  465.   end;

  466. 

  467. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  468.   TengShaderPartInherited = class(TengShaderPart)

  469.   { Load & Store Code }

  470.   private

  471.     fInheritedName: String;

  472.     fParameters: TStringList;

  473.   protected

  474.     function GetText: String; override;

  475.     function ParseTextIntern(const aParseArgs: TengParseArgs; const aParameters: TengTokenParameterList): String; override;

  476. 

  477.   { Generate Shader Code }

  478.   protected

  479.     procedure GenCodeIntern(const aGenCodeArgs: TengGenCodeArgs); override;

  480. 

  481.   { General }

  482.   public

  483.     constructor Create(const aParent: TengShaderPart); override;

  484.     destructor Destroy; override;

  485.   public

  486.     class function GetTokenName: String; override;

  487.     class procedure CheckToken(const aParseArgs: TengParseArgs; const aParent: TengShaderPart); override;

  488.   end;

  489. 

  490. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  491.   TengMetaType = (metaNormal, metaVersion, metaExtension, metaLayout);

  492.   IengMetaData = interface(IUnknown)

  493.     ['{8064AB43-4A82-4E77-BE46-E222827522FF}']

  494.     function GetValues(const aIndex: Integer): String;

  495.     function GetCount: Integer;

  496.     function GetMetaType: TengMetaType;

  497.     function GetName: String;

  498. 

  499.     property MetaType: TengMetaType read GetMetaType;

  500.     property Name:     String       read GetName;

  501.     property Count:    Integer      read GetCount;

  502.     property Values[const aIndex: Integer]: String read GetValues; default;

  503.   end;

  504.   TengMetaData = class(TInterfacedObject, IengMetaData)

  505.   private

  506.     fMetaType: TengMetaType;

  507.     fName: String;

  508.     fValues: TStringList;

  509.     function GetValues(const aIndex: Integer): String;

  510.     function GetCount: Integer;

  511.     function GetMetaType: TengMetaType;

  512.     function GetName: String;

  513.   public

  514.     property MetaType: TengMetaType read GetMetaType;

  515.     property Name:     String       read GetName;

  516.     property Count:    Integer      read GetCount;

  517.     property Values[const aIndex: Integer]: String read GetValues; default;

  518. 

  519.     procedure AddValue(const aValue: String);

  520. 

  521.     constructor Create(const aName: String; const aType: TengMetaType);

  522.     destructor Destroy; override;

  523.   end;

  524.   TengShaderPartMeta = class(TengShaderPart)

  525.   private

  526.     fMetaData: IengMetaData;

  527.   protected

  528.     function GetText: String; override;

  529.     function ParseTextIntern(const aParseArgs: TengParseArgs; const aParameters: TengTokenParameterList): String; override;

  530.     procedure GenCodeIntern(const aGenCodeArgs: TengGenCodeArgs); override;

  531.   public

  532.     property Data: IengMetaData read fMetaData;

  533.   public

  534.     destructor Destroy; override;

  535.   public

  536.     class function GetTokenName: String; override;

  537.   end;

  538. 

  539. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  540.   TengShaderPartKeyValuePair = class(TengShaderPart)

  541.   { Load & Store Code }

  542.   protected

  543.     fName: String;

  544.     fValue: Variant;

  545.     fValueName: String;

  546. 

  547.     function GetText: String; override;

  548.     function ParseTextIntern(const aParseArgs: TengParseArgs; const aParameters: TengTokenParameterList): String; override;

  549.   public

  550.     property Name:  String  read fName;

  551.     property Value: Variant read fValue;

  552. 

  553.     constructor CreateValue(const aParent: TengShaderPart; const aName: String; const aValue: Variant);

  554.     constructor CreateName(const aParent: TengShaderPart; const aName, aValueName: String);

  555.   { Generate Code }

  556.   protected

  557.     procedure GenCodeIntern(const aGenCodeArgs: TengGenCodeArgs); override;

  558.   end;

  559. 

  560. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  561.   TengShaderPartProperty = class(TengShaderPartKeyValuePair)

  562.   public

  563.     property Value: Variant read fValue write fValue;

  564.     procedure MapData(const aFlags: TengMapDataFlags; const aTypes: array of CengShaderPart); override;

  565.   public

  566.     class function GetTokenName: String; override;

  567.   end;

  568. 

  569. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  570.   TengShaderPartDefine = class(TengShaderPartKeyValuePair)

  571.   protected

  572.     function ParseTextIntern(const aParseArgs: TengParseArgs; const aParameters: TengTokenParameterList): String; override;

  573.     procedure MapData(const aFlags: TengMapDataFlags; const aTypes: array of CengShaderPart); override;

  574.   public

  575.     class function GetTokenName: String; override;

  576.   end;

  577. 

  578. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  579.   TengShaderPartCodeProperty = class(TengShaderPart)

  580.   { Load & Store Code }

  581.   protected

  582.     fName: String;

  583.     fType: String;

  584.     function GetText: String; override;

  585.     function ParseTextIntern(const aParseArgs: TengParseArgs; const aParameters: TengTokenParameterList): String; override;

  586. 

  587.   { Generate Code }

  588.   protected

  589.     property Name: String read fName;

  590.     property PropType: String read fType;

  591.     function IsEquals(const aCodeProp: TengShaderPartCodeProperty): Boolean; virtual;

  592.     procedure MapData(const aFlags: TengMapDataFlags; const aTypes: array of CengShaderPart); override;

  593.     procedure GenCodeIntern(const aGenCodeArgs: TengGenCodeArgs); override;

  594.   end;

  595. 

  596. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  597.   TengShaderPartVar = class(TengShaderPartCodeProperty)

  598.   { Load & Store Cde }

  599.   private

  600.     fDefault: String;

  601.   protected

  602.     function GetText: String; override;

  603.     function ParseTextIntern(const aParseArgs: TengParseArgs; const aParameters: TengTokenParameterList): String; override;

  604. 

  605.   { Generate Shader Code }

  606.   protected

  607.     function IsEquals(const aCodeProp: TengShaderPartCodeProperty): Boolean; override;

  608.     procedure GenCodeIntern(const aGenCodeArgs: TengGenCodeArgs); override;

  609. 

  610.   { General }

  611.   public

  612.     class function GetTokenName: String; override;

  613.   end;

  614. 

  615. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  616.   TengShaderPartVarying = class(TengShaderPartCodeProperty)

  617.  { Generate Shader Code }

  618.   protected

  619.     procedure GenCodeIntern(const aGenCodeArgs: TengGenCodeArgs); override;

  620. 

  621.   { General }

  622.   public

  623.     class function GetTokenName: String; override;

  624.   end;

  625. 

  626. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  627.   TengShaderPartUniform = class(TengShaderPartCodeProperty)

  628.   { Generate Shader Code }

  629.    protected

  630.      procedure GenCodeIntern(const aGenCodeArgs: TengGenCodeArgs); override;

  631. 

  632.    { General }

  633.    public

  634.      class function GetTokenName: String; override;

  635.   end;

  636. 

  637. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  638.   TengShaderPartCall = class(TengShaderPart)

  639.   { Load & Store Code }

  640.   private

  641.     fName: String;

  642.     fParameters: TStringList;

  643.   protected

  644.     function GetText: String; override;

  645.     function ParseTextIntern(const aParseArgs: TengParseArgs; const aParameters: TengTokenParameterList): String; override;

  646. 

  647.   { Generate Shader Code }

  648.   protected

  649.     procedure GenCodeIntern(const aGenCodeArgs: TengGenCodeArgs); override;

  650. 

  651.   { General }

  652.   public

  653.     constructor Create(const aParent: TengShaderPart); override;

  654.     destructor Destroy; override;

  655.   public

  656.     class function GetTokenName: String; override;

  657.   end;

  658. 

  659. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  660.   TengShaderPartProcParam = packed record

  661.     Typ: String;

  662.     Name: String;

  663.   end;

  664.   TengShaderPartProcParamList = specialize TutlSimpleList<TengShaderPartProcParam>;

  665.   TengShaderPartProc = class(TengShaderPartScope)

  666.   { Load & Store Code }

  667.   private

  668.     fName: String;

  669.     fIsInline: Boolean;

  670.     fParameters: TengShaderPartProcParamList;

  671.   protected

  672.     function GetHeaderText: String; virtual;

  673.     function GetText: String; override;

  674.     function ParseTextIntern(const aParseArgs: TengParseArgs; const aParameters: TengTokenParameterList): String; override;

  675. 

  676.   { Generate Shader Code }

  677.   protected

  678.     function GenHeaderCode: String; virtual;

  679.     procedure GenInlineCode(const aGenCodeArgs: TengGenCodeArgs; const aAddToken: Boolean = true); virtual;

  680.     procedure GenCodeIntern(const aGenCodeArgs: TengGenCodeArgs); override;

  681.     procedure MapData(const aFlags: TengMapDataFlags; const aTypes: array of CengShaderPart); override;

  682. 

  683.   { General }

  684.   public

  685.     property Name: String read fName;

  686.     property IsInline: Boolean read fIsInline;

  687.     constructor Create(const aParent: TengShaderPart); override;

  688.     destructor Destroy; override;

  689.   public

  690.     class function GetTokenName: String; override;

  691.     class procedure CheckToken(const aParseArgs: TengParseArgs; const aParent: TengShaderPart); override;

  692.   end;

  693. 

  694. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  695.   TengShaderPartMain = class(TengShaderPartProc)

  696.   { Save & Store Code }

  697.   protected

  698.     function GetHeaderText: String; override;

  699.     function ParseTextIntern(const aParseArgs: TengParseArgs; const aParameters: TengTokenParameterList): String; override;

  700. 

  701.   { Generate Code }

  702.   protected

  703.     function GenHeaderCode: String; override;

  704. 

  705.   { General }

  706.   public

  707.     class function GetTokenName: String; override;

  708.   end;

  709. 

  710. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  711.   TengShaderPartFunc = class(TengShaderPartProc)

  712.   { Save & Store Code }

  713.   private

  714.     fReturnType: String;

  715.   protected

  716.     function GetHeaderText: String; override;

  717.     function ParseTextIntern(const aParseArgs: TengParseArgs; const aParameters: TengTokenParameterList): String; override;

  718.   public

  719.     property ReturnType: String read fReturnType;

  720. 

  721.   { Generate Code }

  722.   protected

  723.     procedure GenInlineCode(const aGenCodeArgs: TengGenCodeArgs; const aAddToken: Boolean = true); override;

  724.     function GenHeaderCode: String; override;

  725. 

  726.   { General }

  727.   public

  728.     class function GetTokenName: String; override;

  729.     class procedure CheckToken(const aParseArgs: TengParseArgs; const aParent: TengShaderPart); override;

  730.   end;

  731. 

  732. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  733.   TengShaderPartIf = class(TengShaderPart)

  734.   { Load & Store Code }

  735.   private

  736.     fExpression: TengExpressionItem;

  737.     fIfPart: TengShaderPart;

  738.     fElsePart: TengShaderPart;

  739. 

  740.     function ParseExpression(const aParameters: TengTokenParameterList; aIndex: Integer): TengExpressionItem;

  741.   protected

  742.     function GetCount: Integer; override;

  743.     function GetChild(const aIndex: Integer): TengShaderPart; override;

  744.     function GetText: String; override;

  745.     function ParseTextIntern(const aParseArgs: TengParseArgs; const aParameters: TengTokenParameterList): String; override;

  746. 

  747.     function HandleToken(const aToken: String; const aParseArgs: TengParseArgs): String;

  748.     function HandleEndToken(const aToken: String; const aParseArgs: TengParseArgs): String; virtual;

  749. 

  750.   { Generate Shader Code }

  751.   protected

  752.     procedure MapData(const aFlags: TengMapDataFlags; const aTypes: array of CengShaderPart); override;

  753.     procedure GenCodeIntern(const aGenCodeArgs: TengGenCodeArgs); override;

  754. 

  755.   { General }

  756.   public

  757.     destructor Destroy; override;

  758.   public

  759.     class function GetTokenName: String; override;

  760.   end;

  761. 

  762. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  763.   TengShaderPartElIf = class(TengShaderPartIf)

  764.   protected

  765.     function GetText: String; override;

  766.     function HandleEndToken(const aToken: String; const aParseArgs: TengParseArgs): String; override;

  767.   public

  768.     class function GetTokenName: String; override;

  769.   end;

  770. 

  771. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  772.   TengShaderPartElse = class(TengShaderPartContainer)

  773.   protected

  774.     function GetText: String; override;

  775.   public

  776.     class function GetTokenName: String; override;

  777.   end;

  778. 

  779. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  780.   TengShaderPartEcho = class(TengShaderPart)

  781.   { Load & Store Code }

  782.   private

  783.     fName: String;

  784.   protected

  785.     function GetText: String; override;

  786.     function ParseTextIntern(const aParseArgs: TengParseArgs; const aParameters: TengTokenParameterList): String; override;

  787. 

  788.   { Generate Shader Code }

  789.   protected

  790.     procedure GenCodeIntern(const aGenCodeArgs: TengGenCodeArgs); override;

  791. 

  792.   { General }

  793.   public

  794.     class function GetTokenName: String; override;

  795.   end;

  796. 

  797. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  798.   TengShaderPartMessage = class(TengShaderPart)

  799.   private

  800.     fMessage: String;

  801.   protected

  802.     function GetText: String; override;

  803.     function ParseTextIntern(const aParseArgs: TengParseArgs; const aParameters: TengTokenParameterList): String; override;

  804.   public

  805.     class function GetTokenName: String; override;

  806.   end;

  807. 

  808. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  809.   TengShaderPartWarning = class(TengShaderPartMessage)

  810.   public

  811.     class function GetTokenName: String; override;

  812.   end;

  813. 

  814. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  815.   TengShaderPartError = class(TengShaderPartMessage)

  816.   protected

  817.     procedure GenCodeIntern(const aGenCodeArgs: TengGenCodeArgs); override;

  818.   public

  819.     class function GetTokenName: String; override;

  820.   end;

  821. 

  822. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  823.   TengShaderPartCode = class(TengShaderPart)

  824.   { Load & Store Code }

  825.   private

  826.     fCode: String;

  827.   protected

  828.     function GetText: String; override;

  829.     function ParseTextIntern(const aParseArgs: TengParseArgs; const aParameters: TengTokenParameterList): String; override;

  830.   public

  831.     property Code: String read fCode;

  832. 

  833.   { Generate Shader Code }

  834.   protected

  835.     procedure GenCodeIntern(const aGenCodeArgs: TengGenCodeArgs); override;

  836.   end;

  837. 

  838. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  839.   TengShaderPartLineBreak = class(TengShaderPart)

  840.   { Load & Store Code }

  841.   protected

  842.     function GetText: String; override;

  843.     function ParseTextIntern(const aParseArgs: TengParseArgs; const aParameters: TengTokenParameterList): String; override;

  844. 

  845.   { Generate Shader Code }

  846.   protected

  847.     procedure GenCodeIntern(const aGenCodeArgs: TengGenCodeArgs); override;

  848. 

  849.   { General }

  850.   public

  851.     class function GetTokenName: String; override;

  852.   end;

  853. 

  854. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  855.   TengShaderPartCommandEnd = class(TengShaderPart)

  856.   { Load & Store Code }

  857.   private

  858.     fToken: String;

  859.   protected

  860.     function GetText: String; override;

  861.     function ParseTextIntern(const aParseArgs: TengParseArgs; const aParameters: TengTokenParameterList): String; override;

  862. 

  863.   { Generate Shader Code }

  864.   protected

  865.     procedure GenCodeIntern(const aGenCodeArgs: TengGenCodeArgs); override;

  866. 

  867.   { General }

  868.   public

  869.     class function CheckToken(const aToken: String): Boolean; override;

  870.   end;

  871. 

  872. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  873. //HELPER////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  874. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  875.   TengShaderCode = class(TStringList)

  876.   private type

  877.     TMetaList = specialize TutlList<IengMetaData>;

  878.   private

  879.     function GetMeta(const aIndex: Integer): IengMetaData;

  880.     function GetMetaCount: Integer;

  881.   protected

  882.     fMetaList: TMetaList;

  883.   public

  884.     property Meta[const aIndex: Integer]: IengMetaData read GetMeta;

  885.     property MetaCount: Integer read GetMetaCount;

  886. 

  887.     constructor Create;

  888.     destructor Destroy; override;

  889.   end;

  890. 

  891. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  892.   TengShaderCodeIntern = class(TengShaderCode)

  893.   public

  894.     property MetaList: TMetaList read fMetaList;

  895.     procedure AddMeta(const aMeta: IengMetaData);

  896.   end;

  897. 

  898. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  899.   TengParseArgs = class

  900.   private

  901.     fCode: TStringList;

  902.     fLineLength: Integer;

  903.     fLineCount: Integer;

  904.     fCurrentLine: String;

  905.     fCurrentChar: Char;

  906.     fCol: Integer;

  907.     fLine: Integer;

  908.     fOwner: TengShaderFile;

  909. 

  910.     procedure SetCol(const aValue: Integer);

  911.     procedure SetLine(const aValue: Integer);

  912.     function GetEndOfLine: Boolean;

  913.     function GetEndOfFile: Boolean;

  914.     function GetCode: TStrings;

  915.   public

  916.     property Code:        TStrings read GetCode;

  917.     property LineLength:  Integer  read fLineLength;

  918.     property LineCount:   Integer  read fLineCount;

  919.     property CurrentLine: String   read fCurrentLine;

  920.     property CurrentChar: Char     read fCurrentChar;

  921.     property EndOfLine:   Boolean  read GetEndOfLine;

  922.     property EndOfFile:   Boolean  read GetEndOfFile;

  923.     property Col:         Integer  read fCol  write SetCol;

  924.     property Line:        Integer  read fLine write SetLine;

  925. 

  926.     procedure IncCol;

  927.     procedure IncLine;

  928.     function ParseParameters(const aParameters: TengTokenParameterList): Boolean;

  929.     procedure LoadCode(const aStream: TStream);

  930. 

  931.     constructor Create(const aOwner: TengShaderFile);

  932.     destructor Destroy; override;

  933.   end;

  934. 

  935. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  936.   TengGenCodeFlag = (

  937.     gcfGenProcedure,        // generate shader code for procedure or function

  938.     gcfGenProcInline,       // generate inline shader code for procedure or function

  939.     gcfGenProcCall,         // generate procedure call

  940.     gcfGenCodeProp          // generate shader code for code properties (e.g. Var, Varying, Uniform)

  941.   );

  942.   TengGenCodeFlags = set of TengGenCodeFlag;

  943.   TengGenCodeArgs = class(TObject)

  944.   private type

  945.     TCodeItem = class

  946.     public

  947.       function GetText: String; virtual;

  948.       function IsEmpty: Boolean;

  949.     end;

  950. 

  951.     TCodeItemStart = class(TCodeItem)

  952.       function GetText: String; override;

  953.     end;

  954. 

  955.     TCodeItemText = class(TCodeItem)

  956.     public

  957.       Text: String;

  958.       function GetText: String; override;

  959.       constructor Create(const aText: String);

  960.     end;

  961. 

  962.     TCodeItemLineBreak = class(TCodeItem)

  963.     public

  964.       function GetText: String; override;

  965.     end;

  966. 

  967.     TCodeItemCommandEnd = class(TCodeItem)

  968.     public

  969.       Token: String;

  970.       function GetText: String; override;

  971.       constructor Create(const aToken: String);

  972.     end;

  973. 

  974.     TTokenType = (ttBegin, ttEnd, ttSingle);

  975.     TCodeItemToken = class(TCodeItem)

  976.     public

  977.       TokenType: TTokenType;

  978.       Level: Integer;

  979.       constructor Create(const aTokenType: TTokenType; const aLevel: Integer = -1);

  980.     end;

  981. 

  982.     TCodeItemList = specialize TutlList<TCodeItem>;

  983.     TCodeStackItem = class

  984.     private type

  985.       TFlag = (cfIgnoreNextSemicolon);

  986.       TFlags = set of TFlag;

  987.     private

  988.       fFlags: TFlags;

  989.       fItems: TCodeItemList;

  990.       function GetEmpty: Boolean;

  991.     public

  992.       property Items: TCodeItemList read fItems;

  993.       property Empty: Boolean read GetEmpty;

  994. 

  995.       {$IFDEF DEBUG}

  996.       function GetDebugText: String;

  997.       {$ENDIF}

  998.       function GetText: String;

  999.       procedure SplitCurrentCommand(const aItem: TCodeStackItem);

  1000.       function Merge(const aItem: TCodeStackItem; aIndex: Integer): Integer;

  1001. 

  1002.       procedure AddText(const aText: String);

  1003.       procedure AddCommandEnd(const aToken: String = '');

  1004.       procedure AddToken(const aTokenType: TTokenType; const aLevel: Integer = -1);

  1005.       procedure AddLineEnd;

  1006. 

  1007.       function GetMinLineOffset: Integer;

  1008.       procedure IgnoreNextSemicolon;

  1009. 

  1010.       procedure ReplaceIdents(const aOld, aNew: TStrings);

  1011.       procedure ReplaceReturns(const aItem: TCodeStackItem; const aRetType, aFuncName: String; const aCntr: Integer);

  1012. 

  1013.       constructor Create;

  1014.       destructor Destroy; override;

  1015.     end;

  1016. 

  1017.     TProcWrapper = class

  1018.     public

  1019.       Proc: TengShaderPartProc;

  1020.       Code: TCodeStackItem;

  1021.       constructor Create;

  1022.       destructor Destroy; override;

  1023.     end;

  1024. 

  1025.     TCodeStack = specialize TutlList<TCodeStackItem>;

  1026.     TProcParamStack = specialize TutlList<TStrings>;

  1027.     TGenCodeFlagsStack = specialize TutlList<TengGenCodeFlags>;

  1028.     TProcedureList = specialize TutlList<TProcWrapper>;

  1029.     TCodePropertyMap = specialize TutlMap<string, TengShaderPartCodeProperty>;

  1030.   public type

  1031.     TPopCodeFlag = (

  1032.       pcfAppend,

  1033.       pcfPrepend,

  1034.       pcfAddEmptyLine

  1035.     );

  1036.     TPopCodeFlags = set of TPopCodeFlag;

  1037.   private

  1038.     fMaxPropNameLen: Integer;

  1039.     fRoot: TengShaderPartScope;

  1040.     fFlags: TGenCodeFlagsStack;

  1041.     fProcParams: TProcParamStack;

  1042.     fProcedures: TProcedureList;

  1043.     fProperties: TCodePropertyMap;

  1044.     fCode: TCodeStack;

  1045.     fCommands: TCodeStack;

  1046.     fShaderCode: TengShaderCodeIntern;

  1047.     fInlineRetCounter: Integer;

  1048. 

  1049.     function GetFlags: TengGenCodeFlags;

  1050.     function GetText: String;

  1051.     function GetCode: TCodeStackItem;

  1052.     function GetProcParams: TStrings;

  1053.   public

  1054.     property Root: TengShaderPartScope read fRoot;

  1055.     property Flags: TengGenCodeFlags read GetFlags;

  1056.     property Code: TCodeStackItem read GetCode;

  1057.     property ProcParams: TStrings read GetProcParams;

  1058.     property MaxPropNameLen: Integer read fMaxPropNameLen;

  1059. 

  1060.     procedure PushCode;

  1061.     procedure InsertCode(const aCodeStackItem: TCodeStackItem);

  1062.     function PushCurrentCommand: TCodeStackItem;

  1063.     procedure PushFlags(const aFlags: TengGenCodeFlags);

  1064.     procedure PushProcParams(const aParams: TStrings);

  1065. 

  1066.     procedure PopCode(const aFlags: TPopCodeFlags = [pcfAppend]);

  1067.     function ExtractCode: TCodeStackItem;

  1068.     procedure PopCurrentCommand(const aRetType, aFuncName: String);

  1069.     procedure PopFlags;

  1070.     procedure PopProcParams;

  1071. 

  1072.     procedure AddProcedure(const aProc: TengShaderPartProc);

  1073.     procedure AddCodeProperty(const aProp: TengShaderPartCodeProperty);

  1074.     procedure AddMeta(const aMeta: IengMetaData);

  1075. 

  1076.     function HasCodeProperty(const aName: String): Boolean;

  1077. 

  1078.     procedure GenProcedureCode(const aAppend: Boolean = false);

  1079.     procedure GenCodePropertyCode(const aTypes: array of CengShaderPart);

  1080.     procedure GenMetaCode;

  1081. 

  1082.     constructor Create(const aShaderCode: TengShaderCodeIntern; const aRoot: TengShaderPartScope);

  1083.     destructor Destroy; override;

  1084.   end;

  1085. 

  1086. function TrySetProperty(const aGenerator: TengCodeGenerator; const aName: String; const aValue: Variant): Boolean;

  1087. 

  1088. {$IFDEF DEBUG}

  1089. procedure SaveAsXMindXml(const aShaderPart: TengShaderPart; const aDirectory: String);

  1090. {$ENDIF}

  1091. 

  1092. implementation

  1093. 

  1094. uses

  1095.   uutlExceptions, FileUtil, RegExpr, Math{$IFDEF USE_VFS}, uvfsManager{$ENDIF};

  1096. 

  1097. const

  1098.   PRECOMPILER_STATEMENT_BEGIN = '{';

  1099.   PRECOMPILER_STATEMENT_END   = '}';

  1100.   PRECOMPILER_QUOTE_CHAR      = '''';

  1101.   TOKEN_IDENTIFIER            = '$';

  1102.   TOKEN_COMMAND_END           = ';';

  1103.   TOKEN_SCOPE_BEGIN           = '{';

  1104.   TOKEN_SCOPE_END             = '}';

  1105.   TOKEN_LINE_BREAK            = sLineBreak;

  1106.   COMMENT_IDENTIFIER          = '.';

  1107. 

  1108.   TOKEN_CLASS           = TOKEN_IDENTIFIER + 'CLASS';       //{$CLASS PhongLight $EXTENDS Normal Glow}

  1109.   TOKEN_EXTENDS         = TOKEN_IDENTIFIER + 'EXTENDS';

  1110.   TOKEN_INHERITED       = TOKEN_IDENTIFIER + 'INHERITED';   //{$INHERITED}   {$INHERITED BaseClass}

  1111. 

  1112.   TOKEN_INCLUDE         = TOKEN_IDENTIFIER + 'INCLUDE';     //{$INCLUDE 'Normal.frag'}

  1113. 

  1114.   TOKEN_META            = TOKEN_IDENTIFIER + 'META';        //{$META 'Fuu' 'Bar'}

  1115.   TOKEN_VERSION         = TOKEN_IDENTIFIER + 'VERSION';     //{$META $VERSION 'version'}

  1116.   TOKEN_EXTENSION       = TOKEN_IDENTIFIER + 'EXTENSION';   //{$META $EXTENSION 'GL_ARB_geometry_shader4' 'enable'}

  1117.   TOKEN_LAYOUT          = TOKEN_IDENTIFIER + 'LAYOUT';      //{$META $LAYOUT '(line_strip, max_vertices = 6) out'}

  1118. 

  1119.   TOKEN_PROPERTY        = TOKEN_IDENTIFIER + 'PROPERTY';    //{$PROPERTY InvertRoughmap 'false'}

  1120.   TOKEN_DEFINE          = TOKEN_IDENTIFIER + 'DEFINE';      //{$DEFINE RENDER_FACE_FRONT '0'}

  1121.   TOKEN_ECHO            = TOKEN_IDENTIFIER + 'ECHO';        //{$ECHO InvertRoughmap}

  1122. 

  1123.   TOKEN_VAR             = TOKEN_IDENTIFIER + 'VAR';         //{$VAR 'float' 'refractivity' '0.0'}

  1124.   TOKEN_VARYING         = TOKEN_IDENTIFIER + 'VARYING';     //{$VARYING 'vec3' 'vVertex'}

  1125.   TOKEN_UNIFORM         = TOKEN_IDENTIFIER + 'UNIFORM';     //{$UNIFORM 'sampler2D' 'uShadowMap'}

  1126. 

  1127.   TOKEN_CALL            = TOKEN_IDENTIFIER + 'CALL';        //{$CALL CalcLight}

  1128.   TOKEN_PROC            = TOKEN_IDENTIFIER + 'PROC';        //{$PROC CalcLight} Code... {$END}

  1129.   TOKEN_FUNC            = TOKEN_IDENTIFIER + 'FUNC';        //{$FUND 'float' 'ShadowPoisson' 'vec2' 'shadowMapST' 'float' 'receiver'} Code... {$END}

  1130.   TOKEN_MAIN            = TOKEN_IDENTIFIER + 'MAIN';

  1131.   TOKEN_INLINE          = TOKEN_IDENTIFIER + 'INLINE';      //{$PROC CalcLight $INLINE} Code... {$END}

  1132. 

  1133.   TOKEN_IF              = TOKEN_IDENTIFIER + 'IF';          //{$IF PhongLight = '0'} Code ... {$END}

  1134.   TOKEN_ELIF            = TOKEN_IDENTIFIER + 'ELIF';

  1135.   TOKEN_ELSE            = TOKEN_IDENTIFIER + 'ELSE';

  1136.   TOKEN_END             = TOKEN_IDENTIFIER + 'END';

  1137. 

  1138.   TOKEN_MESSAGE         = TOKEN_IDENTIFIER + 'MESSAGE';     //{$MESSAGE 'message'}

  1139.   TOKEN_WARNING         = TOKEN_IDENTIFIER + 'WARNING';     //{$WARNING 'message'}

  1140.   TOKEN_ERROR           = TOKEN_IDENTIFIER + 'ERROR';       //{$ERROR 'message'}

  1141. 

  1142.   TOKEN_OP_LOGICAL_NOT  = TOKEN_IDENTIFIER + 'NOT';         //{$IF $NOT test}

  1143.   TOKEN_OP_LOGICAL_OR   = TOKEN_IDENTIFIER + 'OR';          //{$IF test1 $OR  test2}

  1144.   TOKEN_OP_LOGICAL_AND  = TOKEN_IDENTIFIER + 'AND';         //{$IF test1 $AND test2}

  1145.   TOKEN_OP_LOGICAL_XOR  = TOKEN_IDENTIFIER + 'XOR';         //{$IF test1 $XOR test2}

  1146.   TOKEN_OP_DEFINED      = TOKEN_IDENTIFIER + 'DEFINED';     //{$IF $DEFINED test2}

  1147.   TOKEN_OP_SET          = TOKEN_IDENTIFIER + 'SET';         //{$IF $SET vVertex}

  1148.   TOKEN_OP_ADD          = '+';            //{$IF test1 + test2}

  1149.   TOKEN_OP_SUBTRACT     = '-';            //{$IF test1 - test2}

  1150.   TOKEN_OP_MULTIPLY     = '*';            //{$IF test1 * test2}

  1151.   TOKEN_OP_DIVIDE       = '/';            //{$IF test1 / test2}

  1152.   TOKEN_OP_EQUALS       = '=';            //{$IF test1 = test2}

  1153.   TOKEN_OP_LESSER       = '<';            //{$IF test1 < test2}

  1154.   TOKEN_OP_GREATER      = '>';            //{$IF test1 > test2}

  1155.   TOKEN_OP_LEQUALS      = '<=';           //{$IF test1 <= test2}

  1156.   TOKEN_OP_GEQUALS      = '>=';           //{$IF test1 >= test2}

  1157.   TOKEN_OP_UNEQUALS     = '<>';           //{$IF test1 <> test2}

  1158.   TOKEN_OP_BINARY_OR    = '|';            //{$IF test1 | test2}

  1159.   TOKEN_OP_BINARY_AND   = '&';            //{$IF test1 & test2}

  1160.   TOKEN_OP_BINARY_XOR   = '^';            //{$IF test1 ^ test2}

  1161.   TOKEN_OP_BINARY_NOT   = '!';            //{$IF !test1}

  1162.   TOKEN_OP_GROUP_BEGIN  = '(';            //{$IF (test1 $OR test2) >= '0'}

  1163.   TOKEN_OP_GROUP_END    = ')';

  1164. 

  1165.   WHITESPACES       = [' ', #9];

  1166.   VALID_IDENT_CHARS = ['A'..'Z', 'a'..'z', '0'..'9', '_'];

  1167.   VALID_TOKEN_CHARS = ['$'] + VALID_IDENT_CHARS;

  1168.   TOKEN_SPLIT_CHARS = [' ', #9, TOKEN_OP_GROUP_BEGIN, TOKEN_OP_GROUP_END];

  1169. 

  1170.   LAYOUT_MIN_VERSION   = 150;

  1171.   VERSION_EXTRA_COMPAT = 'compatibility';   //{$META $VERSION 'compatibility'}

  1172. 

  1173.   EXPRESSION_UNARY_OPERATIONS: array[TengExpressionUnaryOperator] of String = (

  1174.     TOKEN_OP_BINARY_NOT,  //opBinaryNot

  1175.     TOKEN_OP_LOGICAL_NOT, //opLogicalNot

  1176.     TOKEN_OP_DEFINED,     //opDefined

  1177.     TOKEN_OP_SET          //opSet

  1178.   );

  1179. 

  1180.   EXPRESSION_BINARY_OPERATIONS: array[TengExpressionBinaryOperator] of String = (

  1181.     TOKEN_OP_BINARY_OR,   //opBinaryOr

  1182.     TOKEN_OP_BINARY_AND,  //opBinaryAnd

  1183.     TOKEN_OP_BINARY_XOR,  //opBinaryXor

  1184. 

  1185.     TOKEN_OP_MULTIPLY,    //opMultiply

  1186.     TOKEN_OP_DIVIDE,      //opDivide

  1187.     TOKEN_OP_ADD,         //opAdd

  1188.     TOKEN_OP_SUBTRACT,    //opSubtract

  1189. 

  1190.     TOKEN_OP_LOGICAL_OR,  //opLogicalOr

  1191.     TOKEN_OP_LOGICAL_AND, //opLogicalAnd

  1192.     TOKEN_OP_LOGICAL_XOR, //opLogicalXor

  1193. 

  1194.     TOKEN_OP_EQUALS,      //opEquals

  1195.     TOKEN_OP_LESSER,      //opLesser

  1196.     TOKEN_OP_GREATER,     //opGreater

  1197.     TOKEN_OP_LEQUALS,     //opLEquals

  1198.     TOKEN_OP_GEQUALS,     //opGEquals

  1199.     TOKEN_OP_UNEQUALS     //opUnequals,

  1200.   );

  1201. 

  1202.   TOKEN_CLASSES: array[0..20] of CengShaderPart = (

  1203.     TengShaderPartProperty,

  1204.     TengShaderPartClass,

  1205.     TengShaderPartDefine,

  1206.     TengShaderPartError,

  1207.     TengShaderPartIf,

  1208.     TengShaderPartInclude,

  1209.     TengShaderPartMessage,

  1210.     TengShaderPartMeta,

  1211.     TengShaderPartCall,

  1212.     TengShaderPartProc,

  1213.     TengShaderPartFunc,

  1214.     TengShaderPartMain,

  1215.     TengShaderPartInherited,

  1216.     TengShaderPartUniform,

  1217.     TengShaderPartVar,

  1218.     TengShaderPartVarying,

  1219.     TengShaderPartWarning,

  1220.     TengShaderPartLineBreak,

  1221.     TengShaderPartCommandEnd,

  1222.     TengShaderPartComment,

  1223.     TengShaderPartEcho);

  1224. 

  1225.   COMMAND_END_TOKENS = [TOKEN_COMMAND_END, TOKEN_SCOPE_BEGIN, TOKEN_SCOPE_END];

  1226. 

  1227.   FIND_OVERWRITTEN_FLAGS: TengFindMappedPartFlags = [ffLocal, ffInherited];                                   // search all ShaderParts in current and inherited scopes

  1228.   FIND_INHERITED_FLAGS:   TengFindMappedPartFlags = [ffInherited];                                            // search in inherited scropes only

  1229.   FIND_IN_SCOPE_FLAGS:    TengFindMappedPartFlags = [ffLocal, ffAscending, ffInherited, ffFile];              // search in current, all parent, all interhited scopes and in file the scope

  1230.   FIND_GLOBAL:            TengFindMappedPartFlags = [ffGlobal, ffLocal];                                      // search in root file only (for defines that are set from the program)

  1231.   GEN_CODE_FIND_FLAGS:    TengFindMappedPartFlags = [ffLocal, ffAscending, ffInherited, ffFile, ffVisited];   // search in current, all parent, all inherited scopes and in file scope, but search only in already visited scopes

  1232.   FIND_PROPERTY_FLAGS:    TengFindMappedPartFlags = [ffLocal, ffDescending, ffInherited];                     // search in current, all inherited and all child scopes

  1233. 

  1234. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1235. {$IFDEF DEBUG}

  1236. function MakeDebugStr(const aItems: TengGenCodeArgs.TCodeItemList; const aFilename: String): String;

  1237. var

  1238.   i: TengGenCodeArgs.TCodeItem;

  1239.   fs: TFileStream;

  1240. begin

  1241.   fs := TFileStream.Create(aFilename, fmCreate);

  1242.   try

  1243.     result := '';

  1244.     for i in aItems do begin

  1245.       result := result + i.ClassName;

  1246.       result := result + '(';

  1247.       if (i is TengGenCodeArgs.TCodeItemLineBreak) then

  1248.         result := result + 'LB)' + sLineBreak + sLineBreak

  1249.       else

  1250.        result := result + i.GetText + ')' + sLineBreak;

  1251.     end;

  1252.     fs.Write(result[1], Length(result));

  1253.   finally

  1254.     FreeAndNil(fs);

  1255.   end;

  1256. end;

  1257. {$ENDIF}

  1258. 

  1259. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1260. function TrySetProperty(const aGenerator: TengCodeGenerator; const aName: String; const aValue: Variant): Boolean;

  1261. var

  1262.   prop: TengShaderPartProperty;

  1263. begin

  1264.   prop   := aGenerator.Properties[aName];

  1265.   result := Assigned(prop);

  1266.   if result then

  1267.     prop.Value := aValue;

  1268. end;

  1269. 

  1270. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1271. function IsValidIdentifier(const aIdent: String): Boolean;

  1272. var

  1273.   i, len: Integer;

  1274. begin

  1275.   len := Length(aIdent);

  1276.   result := false;

  1277.   for i := 1 to len do

  1278.     if not (aIdent[i] in VALID_IDENT_CHARS) then

  1279.       exit;

  1280.   result := true;

  1281. end;

  1282. 

  1283. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1284. function CheckEndToken(const aParseArgs: TengParseArgs; const aShaderPart: TengShaderPart): String;

  1285. var

  1286.   oldLine, oldCol: Integer;

  1287.   param: TengTokenParameterList;

  1288. begin

  1289.   param := TengTokenParameterList.Create;

  1290.   try

  1291.     oldLine := aParseArgs.Line;

  1292.     oldCol  := aParseArgs.Col;

  1293.     if not aParseArgs.ParseParameters(param) then

  1294.       raise EengInvalidToken.Create('expected ' + TOKEN_END, oldLine, oldCol, aShaderPart.Filename);

  1295.     if (param[0].Name <> TOKEN_END) then

  1296.       raise EengInvalidToken.Create(aShaderPart.ClassName, param[0].Name, oldLine, oldCol, aShaderPart.Filename);

  1297.     if (param.Count <> 1) then

  1298.       raise EengInvalidParamterCount.Create(TOKEN_END, oldLine, oldCol, aShaderPart.Filename);

  1299.     result := '';

  1300.   finally

  1301.     FreeAndNil(param);

  1302.   end;

  1303. end;

  1304. 

  1305. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1306. function CheckType(const aShaderPart: TengShaderPart; const aTypes: array of CengShaderPart): Boolean;

  1307. var

  1308.   t: CengShaderPart;

  1309. begin

  1310.   result := true;

  1311.   for t in aTypes do

  1312.     if (aShaderPart is t) then

  1313.       exit;

  1314.   result := (Length(aTypes) = 0);

  1315. end;

  1316. 

  1317. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1318. function CheckParentScope(const aShaderPart: TengShaderPart): TengShaderPartScope;

  1319. begin

  1320.   aShaderPart.GetParentType(TengShaderPartScope, result);

  1321.   if not Assigned(result) then

  1322.     raise EengInternal.Create('this part has no container parent');

  1323. end;

  1324. 

  1325. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1326. //TengExpressionItem////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1327. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1328. function TengExpressionItem.GetText: String;

  1329. begin

  1330.   result := '';

  1331. end;

  1332. 

  1333. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1334. function TengExpressionItem.GetValue(const aScope: TengShaderPartScope; const aGenCodeArgs: TengGenCodeArgs): Variant;

  1335. begin

  1336.   result := Unassigned;

  1337. end;

  1338. 

  1339. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1340. constructor TengExpressionItem.Create(const aLine, aCol: Integer; const aFilename: String);

  1341. begin

  1342.   inherited Create;

  1343.   fLine     := aLine;

  1344.   fCol      := aCol;

  1345.   fFilename := aFilename;

  1346. end;

  1347. 

  1348. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1349. //TengExpressionItemSingle//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1350. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1351. function TengExpressionValue.GetText: String;

  1352. begin

  1353.   result := '''' + fValue + '''';

  1354. end;

  1355. 

  1356. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1357. function TengExpressionValue.GetValue(const aScope: TengShaderPartScope; const aGenCodeArgs: TengGenCodeArgs): Variant;

  1358. begin

  1359.   result := fValue;

  1360. end;

  1361. 

  1362. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1363. constructor TengExpressionValue.Create(const aValue: Variant; const aLine, aCol: Integer; const aFilename: String);

  1364. begin

  1365.   inherited Create(aLine, aCol, aFilename);

  1366.   fValue := aValue;

  1367. end;

  1368. 

  1369. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1370. //TengExpressionVariable////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1371. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1372. function TengExpressionVariable.GetText: String;

  1373. begin

  1374.   result := fVariableName;

  1375. end;

  1376. 

  1377. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1378. function TengExpressionVariable.GetValue(const aScope: TengShaderPartScope; const aGenCodeArgs: TengGenCodeArgs): Variant;

  1379. var

  1380.   p: TengShaderPart;

  1381. begin

  1382.   aScope.FindMappedPart(p, fVariableName, FIND_IN_SCOPE_FLAGS);

  1383.   if not Assigned(p) then begin

  1384.     aScope.FindMappedPart(p, fVariableName, FIND_GLOBAL);

  1385.     if not Assigned(p) then

  1386.       raise EengUnknownIdentifier.Create(fVariableName, fLine, fCol, fFilename)

  1387.   end

  1388.   else if not (p is TengShaderPartProperty) and not (p is TengShaderPartDefine) then

  1389.     raise EengInvalidParamter.Create('unexpected type, expected ' +

  1390.       TengShaderPartProperty.GetTokenName + ' or ' +

  1391.       TengShaderPartDefine.GetTokenName,

  1392.       fLine, fCol, fFilename)

  1393.   else

  1394.     result := (p as TengShaderPartKeyValuePair).Value;

  1395. end;

  1396. 

  1397. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1398. constructor TengExpressionVariable.Create(const aVariableName: String; const aLine, aCol: Integer; const aFilename: String);

  1399. begin

  1400.   inherited Create(aLine, aCol, aFilename);

  1401.   fVariableName := aVariableName;

  1402. end;

  1403. 

  1404. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1405. //TengExpressionGroup///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1406. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1407. function TengExpressionGroup.GetText: String;

  1408. begin

  1409.   if Assigned(fChild) then

  1410.     result := TOKEN_OP_GROUP_BEGIN + fChild.GetText + TOKEN_OP_GROUP_END

  1411.   else

  1412.     result := '';

  1413. end;

  1414. 

  1415. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1416. function TengExpressionGroup.GetValue(const aScope: TengShaderPartScope; const aGenCodeArgs: TengGenCodeArgs): Variant;

  1417. begin

  1418.   result := fChild.GetValue(aScope, aGenCodeArgs);

  1419. end;

  1420. 

  1421. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1422. constructor TengExpressionGroup.Create(const aChild: TengExpressionItem; const aLine, aCol: Integer; const aFilename: String);

  1423. begin

  1424.   inherited Create(aLine, aCol, aFilename);

  1425.   fChild := aChild;

  1426. end;

  1427. 

  1428. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1429. destructor TengExpressionGroup.Destroy;

  1430. begin

  1431.   FreeAndNil(fChild);

  1432.   inherited Destroy;

  1433. end;

  1434. 

  1435. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1436. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1437. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1438. function TengExpressionUnaryOperation.GetText: String;

  1439. begin

  1440.   if not Assigned(fChild) then

  1441.     EengExpression.Create('no child assigned');

  1442.   result :=

  1443.     {$IFDEF EXPRESSION_ADD_BRACKET}TOKEN_OP_GROUP_BEGIN +{$ENDIF}

  1444.     EXPRESSION_UNARY_OPERATIONS[fUnaryOp] + ' ' + fChild.GetText

  1445.     {$IFDEF EXPRESSION_ADD_BRACKET} + TOKEN_OP_GROUP_END{$ENDIF};

  1446. end;

  1447. 

  1448. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1449. function TengExpressionUnaryOperation.GetValue(const aScope: TengShaderPartScope; const aGenCodeArgs: TengGenCodeArgs): Variant;

  1450. var

  1451.   p: TengShaderPart;

  1452.   v: Variant;

  1453. begin

  1454.   try

  1455.     case fUnaryOp of

  1456. 

  1457.       opBinaryNot: begin

  1458.         v := fChild.GetValue(aScope, aGenCodeArgs);

  1459.         result := not Integer(v);

  1460.       end;

  1461. 

  1462.       opLogicalNot: begin

  1463.         v := fChild.GetValue(aScope, aGenCodeArgs);

  1464.         result := not Boolean(v);

  1465.       end;

  1466. 

  1467.       opDefined: begin

  1468.         v := (fChild as TengExpressionVariable).fVariableName;

  1469.         if not (fChild is TengExpressionVariable) then

  1470.           raise EengInternal.Create('child is not a variable', fLine, fCol, fFilename);

  1471.         aScope.FindMappedPart(p, (fChild as TengExpressionVariable).fVariableName, FIND_IN_SCOPE_FLAGS);

  1472.         result := Assigned(p);

  1473.         if result and (not (p is TengShaderPartProperty) or not (p is TengShaderPartDefine)) then with fChild do

  1474.           raise EengInvalidParamter.Create('unexpected type, expected ' +

  1475.             TengShaderPartProperty.GetTokenName + ' or ' +

  1476.             TengShaderPartDefine.GetTokenName,

  1477.             fLine, fCol, fFilename);

  1478.       end;

  1479. 

  1480.       opSet: begin

  1481.         if Assigned(aGenCodeArgs) then begin

  1482.           if not (fChild is TengExpressionVariable) then

  1483.             raise EengInternal.Create('child is not a variable', fLine, fCol, fFilename);

  1484.           result := aGenCodeArgs.HasCodeProperty((fChild as TengExpressionVariable).fVariableName);

  1485.         end else

  1486.           result := false;

  1487.       end

  1488. 

  1489.     else

  1490.       result := inherited GetValue(aScope, aGenCodeArgs);

  1491.     end;

  1492.   except

  1493.     on ex: Exception do

  1494.       raise EengInvalidParamter.Create(ex.Message + ' ("' + GetText + '" ==> "' + EXPRESSION_UNARY_OPERATIONS[fUnaryOp] + ' ' + v + '")', fLine, fCol, fFilename);

  1495.   end;

  1496. end;

  1497. 

  1498. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1499. constructor TengExpressionUnaryOperation.Create(const aUnaryOp: TengExpressionUnaryOperator; const aLine, aCol: Integer; const aFilename: String);

  1500. begin

  1501.   inherited Create(aLine, aCol, aFilename);

  1502.   fUnaryOp := aUnaryOp;

  1503.   fChild := nil;

  1504. end;

  1505. 

  1506. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1507. destructor TengExpressionUnaryOperation.Destroy;

  1508. begin

  1509.   FreeAndNil(fChild);

  1510.   inherited Destroy;

  1511. end;

  1512. 

  1513. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1514. //TengExpressionBinaryOperation///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1515. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1516. function TengExpressionBinaryOperation.GetText: String;

  1517. begin

  1518.   if not Assigned(fFirst) or not Assigned(fSecond) then

  1519.     raise EengExpression.Create('first or second item not assigned');

  1520.   result :=

  1521.     {$IFDEF EXPRESSION_ADD_BRACKET}TOKEN_OP_GROUP_BEGIN +{$ENDIF}

  1522.     fFirst.GetText + ' ' + EXPRESSION_BINARY_OPERATIONS[fBinaryOp] + ' ' + fSecond.GetText

  1523.     {$IFDEF EXPRESSION_ADD_BRACKET} + TOKEN_OP_GROUP_END{$ENDIF};

  1524. end;

  1525. 

  1526. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1527. function TengExpressionBinaryOperation.GetValue(const aScope: TengShaderPartScope; const aGenCodeArgs: TengGenCodeArgs): Variant;

  1528. var

  1529.   v1, v2: Variant;

  1530. begin

  1531.   v1 := fFirst.GetValue(aScope, aGenCodeArgs);

  1532.   v2 := fSecond.GetValue(aScope, aGenCodeArgs);

  1533.   try

  1534.     case fBinaryOp of

  1535.       opBinaryOr:   result := (Integer(v1)  or Integer(v2));

  1536.       opBinaryAnd:  result := (Integer(v1) and Integer(v2));

  1537.       opBinaryXor:  result := (Integer(v1) xor Integer(v2));

  1538. 

  1539.       opMultiply:   result := (v1   * v2);

  1540.       opDivide:     result := (v1   / v2);

  1541.       opAdd:        result := (v1   + v2);

  1542.       opSubtract:   result := (v1   - v2);

  1543. 

  1544.       opLogicalOr:  result := (Boolean(v1)  or Boolean(v2));

  1545.       opLogicalAnd: result := (Boolean(v1) and Boolean(v2));

  1546.       opLogicalXor: result := (Boolean(v1) xor Boolean(v2));

  1547. 

  1548.       opEquals:     result := (v1   = v2);

  1549.       opLesser:     result := (v1   < v2);

  1550.       opGreater:    result := (v1   > v2);

  1551.       opLEquals:    result := (v1  <= v2);

  1552.       opGEquals:    result := (v1  >= v2);

  1553.       opUnequals:   result := (v1  <> v2);

  1554.     end;

  1555.   except

  1556.     on ex: Exception do

  1557.       raise EengInvalidParamter.Create(ex.Message + ' ("' + GetText + '" ==> "' + v1 + ' ' + EXPRESSION_BINARY_OPERATIONS[fBinaryOp] + ' ' + v2 + '")', fLine, fCol, fFilename);

  1558.   end;

  1559. end;

  1560. 

  1561. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1562. constructor TengExpressionBinaryOperation.Create(const aOperator: TengExpressionBinaryOperator; const aLine, aCol: Integer; const aFilename: String);

  1563. begin

  1564.   inherited Create(aLine, aCol, aFilename);

  1565.   fBinaryOp := aOperator;

  1566.   fFirst := nil;

  1567.   fSecond := nil;

  1568. end;

  1569. 

  1570. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1571. destructor TengExpressionBinaryOperation.Destroy;

  1572. begin

  1573.   FreeAndNil(fFirst);

  1574.   FreeAndNil(fSecond);

  1575.   inherited Destroy;

  1576. end;

  1577. 

  1578. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1579. //EengShaderPart////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1580. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1581. constructor EengShaderPart.Create(const aMsg: String; const aLine, aCol: Integer; const aFilename: String);

  1582. begin

  1583.   inherited Create(aMsg + format(' (file: %s; line: %d; col: %d)', [ExtractFileName(aFilename), aLine+1, aCol]));

  1584.   Line     := aLine;

  1585.   Col      := aCol;

  1586.   Filename := aFilename;

  1587. end;

  1588. 

  1589. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1590. //EengInvalidParamter///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1591. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1592. constructor EengInvalidParamter.Create(const aMsg: String; const aLine, aCol: Integer; const aFilename: String);

  1593. begin

  1594.   inherited Create('invalid parameter: ' + aMsg, aLine, aCol, aFilename);

  1595. end;

  1596. 

  1597. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1598. //EengInvalidIdentifier/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1599. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1600. constructor EengInvalidIdentifier.Create(const aIdentifier: String; const aLine, aCol: Integer; const aFilename: String);

  1601. begin

  1602.   inherited Create('invalid identifier: ' + aIdentifier, aLine, aCol, aFilename);

  1603. end;

  1604. 

  1605. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1606. //EengEmptyToken////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1607. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1608. constructor EengEmptyToken.Create(const aLine, aCol: Integer; const aFilename: String);

  1609. begin

  1610.   inherited Create('empty token', aLine, aCol, aFilename);

  1611. end;

  1612. 

  1613. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1614. //EengInvalidToken//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1615. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1616. constructor EengInvalidToken.Create(const aClassName: String; const aToken: String; const aLine, aCol: Integer; const aFilename: String);

  1617. begin

  1618.   inherited Create('invalid token: ' + aClassName + ' <> '+ aToken, aLine, aCol, aFilename);

  1619. end;

  1620. 

  1621. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1622. //EengInvalidParamterCount//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1623. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1624. constructor EengInvalidParamterCount.Create(const aToken: String; const aLine, aCol: Integer; const aFilename: String);

  1625. begin

  1626.   inherited Create('invalid parameter count in ' + aToken, aLine, aCol, aFilename);

  1627. end;

  1628. 

  1629. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1630. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1631. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1632. constructor EengDuplicateIdentifier.Create(const aName: String; const aNew, aOld: TengShaderPart);

  1633. begin

  1634.   inherited Create(format('duplicate identifier: %s (previously declared here: %s %d:%d)',

  1635.     [aName, aOld.Filename, aOld.Line, aOld.Col]), aNew.Line, aNew.Col, aNew.Filename);

  1636. end;

  1637. 

  1638. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1639. //EengInternal//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1640. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1641. constructor EengInternal.Create(const aMsg: String);

  1642. begin

  1643.   inherited Create(aMsg);

  1644. end;

  1645. 

  1646. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1647. constructor EengInternal.Create(const aMsg: String; const aLine, aCol: Integer; const aFilename: String);

  1648. begin

  1649.   inherited Create(aMsg, aLine, aCol, aFilename);

  1650. end;

  1651. 

  1652. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1653. //EengUnknownIdentifier/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1654. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1655. constructor EengUnknownIdentifier.Create(const aIdent: String; const aLine, aCol: Integer; const aFilename: String);

  1656. begin

  1657.   inherited Create('unknown identifier: ' + aIdent, aLine, aCol, aFilename);

  1658. end;

  1659. 

  1660. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1661. //TengShaderPart.TengShaderPartEnumerator///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1662. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1663. function TengShaderPart.TengShaderPartEnumerator.GetCurrent: TengShaderPart;

  1664. begin

  1665.   result := fOwner[fPosition];

  1666. end;

  1667. 

  1668. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1669. function TengShaderPart.TengShaderPartEnumerator.MoveNext: Boolean;

  1670. begin

  1671.   inc(fPosition);

  1672.   result := (fPosition < fOwner.Count);

  1673. end;

  1674. 

  1675. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1676. constructor TengShaderPart.TengShaderPartEnumerator.Create(const aOwner: TengShaderPart);

  1677. begin

  1678.   inherited Create;

  1679.   fOwner := aOwner;

  1680.   fPosition := -1;

  1681. end;

  1682. 

  1683. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1684. //TengShaderPart////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1685. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1686. function TengShaderPart.GetCount: Integer;

  1687. begin

  1688.   result := 0;

  1689. end;

  1690. 

  1691. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1692. function TengShaderPart.{%H-}GetChild(const aIndex: Integer): TengShaderPart;

  1693. begin

  1694.   raise EengShaderPart.Create('this part does not have any children');

  1695. end;

  1696. 

  1697. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1698. function TengShaderPart.GetFilename: String;

  1699. begin

  1700.   if Assigned(fParent) then

  1701.     result := fParent.Filename

  1702.   else

  1703.     result := '';

  1704. end;

  1705. 

  1706. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1707. function TengShaderPart.GetShaderClass: String;

  1708. begin

  1709.   if Assigned(fParent) then

  1710.     result := fParent.ShaderClass

  1711.   else

  1712.     result := '';

  1713. end;

  1714. 

  1715. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1716. function TengShaderPart.GetText: String;

  1717. begin

  1718.   result := ''; //DUMMY

  1719. end;

  1720. 

  1721. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1722. function TengShaderPart.ParseTextIntern(const aParseArgs: TengParseArgs; const aParameters: TengTokenParameterList): String;

  1723. begin

  1724.   result := ''; //DUMMY

  1725. end;

  1726. 

  1727. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1728. function TengShaderPart.ParseText(const aParseArgs: TengParseArgs): String;

  1729. var

  1730.   param: TengTokenParameterList;

  1731. begin

  1732.   param := TengTokenParameterList.Create;

  1733.   try

  1734.     fCol  := aParseArgs.Col;

  1735.     fLine := aParseArgs.Line;

  1736.     if (GetTokenName <> '') then

  1737.       aParseArgs.ParseParameters(param);

  1738.     result := ParseTextIntern(aParseArgs, param);

  1739.   finally

  1740.     FreeAndNil(param);

  1741.   end;

  1742. end;

  1743. 

  1744. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1745. procedure TengShaderPart.MapData(const aFlags: TengMapDataFlags; const aTypes: array of CengShaderPart);

  1746. begin

  1747.   //DUMMY

  1748. end;

  1749. 

  1750. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1751. procedure TengShaderPart.GenCodeIntern(const aGenCodeArgs: TengGenCodeArgs);

  1752. begin

  1753.   fFlags := fFlags + [spfCodeGenVisited];

  1754. end;

  1755. 

  1756. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1757. procedure TengShaderPart.ClearGenCode;

  1758. begin

  1759.   fFlags := fFlags - [spfCodeGenVisited];

  1760. end;

  1761. 

  1762. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1763. function TengShaderPart.HasParentType(const aParentType: CengShaderPart; const aIncludeSelf: Boolean): Boolean;

  1764. var

  1765.   p: TengShaderPart;

  1766. begin

  1767.   result := aIncludeSelf and (self is aParentType);

  1768.   if not result then begin

  1769.     GetParentType(aParentType, p);

  1770.     result := Assigned(p);

  1771.   end;

  1772. end;

  1773. 

  1774. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1775. function TengShaderPart.ParentOrSelfHasType(const aParentType: CengShaderPart): Boolean;

  1776. begin

  1777.   result := (self is aParentType) or ParentHasType(aParentType);

  1778. end;

  1779. 

  1780. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1781. procedure TengShaderPart.GetParentByType(const aParentType: CengShaderPart; out aPart);

  1782. begin

  1783.   if (fParent is aParentType) then

  1784.     TengShaderPart(aPart) := fParent

  1785.   else if Assigned(fParent) then

  1786.     fParent.GetParentType(aParentType, aPart)

  1787.   else

  1788.     TengShaderPart(aPart) := nil;

  1789. end;

  1790. 

  1791. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1792. function TengShaderPart.GetEnumerator: TengShaderPartEnumerator;

  1793. begin

  1794.   result := TengShaderPartEnumerator.Create(self);

  1795. end;

  1796. 

  1797. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1798. constructor TengShaderPart.Create(const aParent: TengShaderPart);

  1799. begin

  1800.   inherited Create;

  1801.   fParent := aParent;

  1802.   if Assigned(fParent) then

  1803.     fRoot := aParent.Root

  1804.   else

  1805.     fRoot := nil;

  1806. end;

  1807. 

  1808. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1809. class function TengShaderPart.GetTokenName: String;

  1810. begin

  1811.   result := '';

  1812. end;

  1813. 

  1814. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1815. class function TengShaderPart.CheckToken(const aToken: String): Boolean;

  1816. begin

  1817.   result := (aToken = GetTokenName);

  1818. end;

  1819. 

  1820. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1821. class procedure TengShaderPart.CheckToken(const aParseArgs: TengParseArgs; const aParent: TengShaderPart);

  1822. begin

  1823.   //DUMMY

  1824. end;

  1825. 

  1826. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1827. //TengShaderPartContainer///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1828. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1829. function TengShaderPartContainer.HandleToken(var aToken: String; const aParseArgs: TengParseArgs): String;

  1830. var

  1831.   obj: TengShaderPart;

  1832.   c: CengShaderPart;

  1833. begin

  1834.   obj := nil;

  1835.   for c in TOKEN_CLASSES do

  1836.     if c.CheckToken(aToken) then begin

  1837.       c.CheckToken(aParseArgs, self);

  1838.       obj := c.Create(self);

  1839.       fChildren.Add(obj);

  1840.       break;

  1841.     end;

  1842. 

  1843.   if Assigned(obj) then

  1844.     result := obj.ParseText(aParseArgs)

  1845.   else

  1846.     result := aToken;

  1847. end;

  1848. 

  1849. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1850. function TengShaderPartContainer.GetCount: Integer;

  1851. begin

  1852.   result := fChildren.Count;

  1853. end;

  1854. 

  1855. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1856. function TengShaderPartContainer.GetChild(const aIndex: Integer): TengShaderPart;

  1857. begin

  1858.   result := fChildren[aIndex];

  1859. end;

  1860. 

  1861. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1862. function TengShaderPartContainer.GetText: String;

  1863. var

  1864.   p: TengShaderPart;

  1865. begin

  1866.   result := '';

  1867.   for p in self do

  1868.     result := result + p.Text;

  1869. end;

  1870. 

  1871. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1872. function TengShaderPartContainer.ParseTextIntern(const aParseArgs: TengParseArgs; const aParameters: TengTokenParameterList): String;

  1873. var

  1874.   codeObj: TengShaderPartCode;

  1875. begin

  1876.   fChildren.Clear;

  1877.   while not aParseArgs.EndOfFile do begin

  1878.     codeObj := TengShaderPartCode.Create(self);

  1879.     try

  1880.       result := codeObj.ParseText(aParseArgs);

  1881.       if (codeObj.Code <> '') then

  1882.         AddChild(codeObj)

  1883.       else

  1884.         FreeAndNil(codeObj);

  1885.     except

  1886.       FreeAndNil(codeObj);

  1887.       raise;

  1888.     end;

  1889.     if (result <> '') then begin

  1890.       result := HandleToken(result, aParseArgs);

  1891.       if (result <> '') then

  1892.         break;

  1893.     end;

  1894.   end;

  1895. end;

  1896. 

  1897. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1898. procedure TengShaderPartContainer.MapData(const aFlags: TengMapDataFlags; const aTypes: array of CengShaderPart);

  1899. var

  1900.   p: TengShaderPart;

  1901. begin

  1902.   inherited MapData(aFlags, aTypes);

  1903.   for p in fChildren do

  1904.     p.MapData(aFlags, aTypes);

  1905. end;

  1906. 

  1907. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1908. procedure TengShaderPartContainer.GenCodeIntern(const aGenCodeArgs: TengGenCodeArgs);

  1909. var

  1910.   p: TengShaderPart;

  1911. begin

  1912.   inherited GenCodeIntern(aGenCodeArgs);

  1913.   for p in fChildren do

  1914.     if not (p is TengShaderPartClass) then

  1915.       p.GenCodeIntern(aGenCodeArgs);

  1916. end;

  1917. 

  1918. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1919. procedure TengShaderPartContainer.ClearGenCode;

  1920. var

  1921.   p: TengShaderPart;

  1922. begin

  1923.   inherited ClearGenCode;

  1924.   for p in fChildren do

  1925.     p.ClearGenCode;

  1926. end;

  1927. 

  1928. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1929. procedure TengShaderPartContainer.AddChild(const aChild: TengShaderPart; const aPrepend: Boolean);

  1930. begin

  1931.   if aPrepend then

  1932.     fChildren.PushFirst(aChild)

  1933.   else

  1934.     fChildren.PushLast(aChild);

  1935. end;

  1936. 

  1937. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1938. constructor TengShaderPartContainer.Create(const aParent: TengShaderPart);

  1939. begin

  1940.   inherited Create(aParent);

  1941.   fChildren := TengShaderPartList.Create(true);

  1942. end;

  1943. 

  1944. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1945. destructor TengShaderPartContainer.Destroy;

  1946. begin

  1947.   FreeAndNil(fChildren);

  1948.   inherited Destroy;

  1949. end;

  1950. 

  1951. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1952. //TengShaderPartScope///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1953. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1954. function TengShaderPartScope.CheckName(const aName: String; const aShaderPart: TengShaderPart): Boolean;

  1955. var

  1956.   old: TengShaderPart;

  1957. begin

  1958.   result := false;

  1959. 

  1960.   // check properties (global)

  1961.   FindMappedPart(old, aName, [ffGlobal, ffLocal, ffDescending], TengShaderPartProperty);

  1962.   if Assigned(old) then begin

  1963.     if (old <> aShaderPart) then

  1964.       raise EengDuplicateIdentifier.Create(aName, aShaderPart, old)

  1965.     else

  1966.       exit;

  1967.   end;

  1968. 

  1969.   // check all others

  1970.   FindMappedPart(old, aName, FIND_IN_SCOPE_FLAGS);

  1971.   if Assigned(old) then begin

  1972.     if (old <> aShaderPart) then

  1973.       CheckDuplicate(aName, old, aShaderPart)

  1974.     else

  1975.       exit;

  1976.   end;

  1977. 

  1978.   result := true;

  1979. end;

  1980. 

  1981. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1982. procedure TengShaderPartScope.MapChildScope(const aScope: TengShaderPartScope);

  1983. begin

  1984.   if (CheckParentScope(aScope) <> self) then

  1985.     raise EengInternal.Create('container is not a direct child of this container');

  1986.   if not fChildScopes.Contains(aScope) then

  1987.     fChildScopes.Add(aScope);

  1988. end;

  1989. 

  1990. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1991. procedure TengShaderPartScope.MapInheritedScope(const aScope: TengShaderPartScope);

  1992. begin

  1993.   if not fInherited.Contains(aScope) then

  1994.     fInherited.Add(aScope);

  1995. end;

  1996. 

  1997. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1998. function TengShaderPartScope.MapShaderPart(const aName: String; const aShaderPart: TengShaderPart): Boolean;

  1999. begin

  2000.   if (CheckParentScope(aShaderPart) <> self) then

  2001.     raise EengInternal.Create('shader part does not belong to this container');

  2002. 

  2003.   result := CheckName(aName, aShaderPart);

  2004.   if result then

  2005.     fMappedParts.Add(aName, aShaderPart);

  2006. end;

  2007. 

  2008. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2009. procedure TengShaderPartScope.FindMappedPart(out aShaderPart; const aName: String; const aFlags: TengFindMappedPartFlags; const aType: CengShaderPart);

  2010. var

  2011.   list: TengShaderPartList;

  2012. begin

  2013.   TengShaderPart(aShaderPart) := nil;

  2014.   list := TengShaderPartList.Create(false);

  2015.   try

  2016.     FindMappedParts(list, aName, aFlags + [ffFindFirst], aType);

  2017.     if (list.Count > 0) then

  2018.       TengShaderPart(aShaderPart) := list[0];

  2019.   finally

  2020.     FreeAndNil(list);

  2021.   end;

  2022. end;

  2023. 

  2024. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2025. procedure TengShaderPartScope.FindMappedParts(const aParts: TengShaderPartList; const aName: String; const aFlags: TengFindMappedPartFlags; const aType: CengShaderPart);

  2026. 

  2027.   procedure AddPart(const aShaderPart: TengShaderPart);

  2028.   begin

  2029.     if Assigned(aShaderPart) and

  2030.        (not Assigned(aType) or (aShaderPart is aType)) and

  2031.        (aParts.IndexOf(aShaderPart) < 0) then

  2032.       aParts.Add(aShaderPart);

  2033.   end;

  2034. 

  2035. var

  2036.   s: TengShaderPartScope;

  2037.   p: TengShaderPart;

  2038. begin

  2039.   if (ffFindFirst in aFlags) and (aParts.Count > 0) then

  2040.     exit;

  2041. 

  2042.   if not (ffGlobal in aFlags) then begin

  2043. 

  2044.     // local

  2045.     if (ffLocal in aFlags) then begin

  2046.       if (aName <> '') then

  2047.         AddPart(fMappedParts[aName])

  2048.       else

  2049.         for p in fMappedParts do

  2050.           AddPart(p);

  2051.     end;

  2052. 

  2053.     // descending

  2054.     if (ffDescending in aFlags) then

  2055.       for s in fChildScopes do

  2056.         s.FindMappedParts(aParts, aName, aFlags + [ffLocal], aType);

  2057. 

  2058.     // ascending

  2059.     if (ffAscending in aFlags) then begin

  2060.       GetParentType(TengShaderPartScope, s);

  2061.       if Assigned(s) and s.fChildScopes.Contains(self) then

  2062.         s.FindMappedParts(aParts, aName, aFlags + [ffLocal], aType);

  2063.     end;

  2064. 

  2065.     // search in inherited scopes

  2066.     if (ffInherited in aFlags) then

  2067.       for s in fInherited do

  2068.         s.FindMappedParts(aParts, aName, aFlags + [ffLocal], aType);

  2069. 

  2070.   end else

  2071.     fRoot.FindMappedParts(aParts, aName, aFlags - [ffGlobal], aType);

  2072. end;

  2073. 

  2074. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2075. function TengShaderPartScope.GetFindPropertyFlags: TengFindMappedPartFlags;

  2076. begin

  2077.   result := FIND_PROPERTY_FLAGS;

  2078. end;

  2079. 

  2080. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2081. procedure TengShaderPartScope.CheckDuplicate(const aName: String; const aOld, aNew: TengShaderPart);

  2082. begin

  2083.   raise EengDuplicateIdentifier.Create(aName, aNew, aOld);

  2084. end;

  2085. 

  2086. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2087. procedure TengShaderPartScope.MapData(const aFlags: TengMapDataFlags; const aTypes: array of CengShaderPart);

  2088. var

  2089.   s: TengShaderPartScope;

  2090.   p: TengShaderPart;

  2091. begin

  2092.   if (mdfCurrentScope in aFlags) and (mdfChild in aFlags) then

  2093.     exit;

  2094. 

  2095.   GetParentType(TengShaderPartScope, s);

  2096.   if Assigned(s) then

  2097.     s.MapChildScope(self);

  2098. 

  2099.   for p in fChildren do

  2100.     p.MapData(aFlags + [mdfChild], aTypes);

  2101. 

  2102.   if (mdfMapInherited in aFlags) then

  2103.     for s in fInherited do

  2104.       s.MapData(aFlags, aTypes);

  2105. end;

  2106. 

  2107. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2108. procedure TengShaderPartScope.GenCodeIntern(const aGenCodeArgs: TengGenCodeArgs);

  2109. begin

  2110.   MapData([mdfMapInherited, mdfCurrentScope, mdfIfEvaluate], []);

  2111.   inherited GenCodeIntern(aGenCodeArgs);

  2112. end;

  2113. 

  2114. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2115. procedure TengShaderPartScope.ClearGenCode;

  2116. var

  2117.   p: TengShaderPartScope;

  2118. begin

  2119.   inherited ClearGenCode;

  2120.   for p in fInherited do

  2121.     p.ClearGenCode;

  2122. end;

  2123. 

  2124. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2125. procedure TengShaderPartScope.ClearMappedData(const aExcludedTypes: array of CengShaderPart);

  2126. var

  2127.   s: TengShaderPartScope;

  2128.   i: Integer;

  2129. begin

  2130.   for s in fChildScopes do

  2131.     s.ClearMappedData(aExcludedTypes);

  2132.   for s in fInherited do

  2133.     s.ClearMappedData(aExcludedTypes);

  2134.   for i := fMappedParts.Count-1 downto 0 do

  2135.     if not CheckType(fMappedParts.ValueAt[i], aExcludedTypes) then

  2136.       fMappedParts.DeleteAt(i);

  2137. end;

  2138. 

  2139. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2140. procedure TengShaderPartScope.ClearMappedData;

  2141. var

  2142.   s: TengShaderPartScope;

  2143. begin

  2144.   for s in fChildScopes do

  2145.     s.ClearMappedData;

  2146.   fChildScopes.Clear;

  2147. 

  2148.   for s in fInherited do

  2149.     s.ClearMappedData;

  2150.   fInherited.Clear;

  2151. 

  2152.   fMappedParts.Clear;

  2153. end;

  2154. 

  2155. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2156. constructor TengShaderPartScope.Create(const aParent: TengShaderPart);

  2157. begin

  2158.   inherited Create(aParent);

  2159.   fInherited   := TengShaderPartScopeHashSet.Create(false);

  2160.   fChildScopes := TengShaderPartScopeHashSet.Create(false);

  2161.   fMappedParts := TengShaderPartMap.Create(false);

  2162. end;

  2163. 

  2164. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2165. destructor TengShaderPartScope.Destroy;

  2166. begin

  2167.   FreeAndNil(fMappedParts);

  2168.   FreeAndNil(fChildScopes);

  2169.   FreeAndNil(fInherited);

  2170.   inherited Destroy;

  2171. end;

  2172. 

  2173. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2174. //TengCodeGenerator/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2175. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2176. function TengCodeGenerator.GetProperty(const aName: String): TengShaderPartProperty;

  2177. begin

  2178.   FindMappedPart(result, aName, GetFindPropertyFlags, TengShaderPartProperty);

  2179. end;

  2180. 

  2181. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2182. procedure TengCodeGenerator.GenerateCode(const aGenCodeArgs: TengGenCodeArgs);

  2183. begin

  2184.   //DUMMY

  2185. end;

  2186. 

  2187. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2188. function TengCodeGenerator.GenerateCode: TengShaderCode;

  2189. var

  2190.   args: TengGenCodeArgs;

  2191. begin

  2192.   result := TengShaderCodeIntern.Create;

  2193.   args := TengGenCodeArgs.Create((result as TengShaderCodeIntern), self);

  2194.   try

  2195.     ClearGenCode;

  2196.     ClearMappedData([TengShaderPartProperty]);

  2197. 

  2198.     GenCodeIntern(args);

  2199. 

  2200.     args.PushCode;

  2201.     try

  2202.       GenerateCode(args);

  2203.       args.GenProcedureCode;

  2204.     finally

  2205.       args.PopCode;

  2206.     end;

  2207. 

  2208.     args.GenCodePropertyCode([TengShaderPartVar]);

  2209.     args.GenCodePropertyCode([TengShaderPartVarying]);

  2210.     args.GenCodePropertyCode([TengShaderPartUniform]);

  2211.     args.GenMetaCode;

  2212.   finally

  2213.     FreeAndNil(args);

  2214.   end;

  2215. end;

  2216. 

  2217. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2218. procedure TengCodeGenerator.ListProperties(const aList: TStrings);

  2219. var

  2220.   list: TengShaderPartList;

  2221.   p: TengShaderPart;

  2222. begin

  2223.   list := TengShaderPartList.Create(false);

  2224.   try

  2225.     FindMappedParts(list, '', GetFindPropertyFlags, TengShaderPartProperty);

  2226.     for p in list do

  2227.       aList.Add((p as TengShaderPartProperty).Name);

  2228.   finally

  2229.     FreeAndNil(list);

  2230.   end;

  2231. end;

  2232. 

  2233. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2234. //TengShaderPartClass///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2235. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2236. function TengShaderPartClass.GetExtendCount: Integer;

  2237. begin

  2238.   result := fExtends.Count;

  2239. end;

  2240. 

  2241. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2242. function TengShaderPartClass.GetExtends(const aIndex: Integer): String;

  2243. begin

  2244.   if (aIndex >= 0) and (aIndex < fExtends.Count) then

  2245.     result := fExtends[aIndex]

  2246.   else

  2247.     raise EOutOfRange.Create(aIndex, 0, fExtends.Count-1);

  2248. end;

  2249. 

  2250. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2251. function TengShaderPartClass.GetText: String;

  2252. var

  2253.   s: String;

  2254. begin

  2255.   result := PRECOMPILER_STATEMENT_BEGIN + GetTokenName + ' ' + fName;

  2256.   if (fExtends.Count > 0) then begin

  2257.     result := result + ' ' + TOKEN_EXTENDS;

  2258.     for s in fExtends do

  2259.       result := result + ' ' + s;

  2260.   end;

  2261.   result := result + PRECOMPILER_STATEMENT_END +

  2262.   inherited GetText +

  2263.   PRECOMPILER_STATEMENT_BEGIN + TOKEN_END + PRECOMPILER_STATEMENT_END;

  2264. end;

  2265. 

  2266. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2267. function TengShaderPartClass.GetShaderClass: String;

  2268. begin

  2269.   result := fName;

  2270. end;

  2271. 

  2272. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2273. function TengShaderPartClass.ParseTextIntern(const aParseArgs: TengParseArgs; const aParameters: TengTokenParameterList): String;

  2274. var

  2275.   i: Integer;

  2276. begin

  2277.   if (aParameters[0].Name <> GetTokenName) then

  2278.     raise EengInvalidToken.Create(ClassName, aParameters[0].Name, Line, Col, Filename);

  2279.   if (aParameters.Count < 2) then

  2280.     raise EengInvalidParamterCount.Create(GetTokenName, Line, Col, Filename);

  2281.   fName := aParameters[1].Name;

  2282.   if not IsValidIdentifier(fName) then

  2283.     raise EengShaderPart.Create('invalid name: ' + fName, Line, Col, GetFilename);

  2284.   if (aParameters.Count > 2) then begin

  2285.     if (aParameters.Count < 4) then

  2286.       raise EengInvalidParamterCount.Create(GetTokenName, Line, Col, Filename);

  2287.     if (aParameters[2].Name <> TOKEN_EXTENDS) then

  2288.       raise EengInvalidParamter.Create(aParameters[2].Name + ' (expected ' + TOKEN_EXTENDS + ')', Line, Col, Filename);

  2289.     fExtends.Clear;

  2290.     for i := 3 to aParameters.Count-1 do

  2291.       fExtends.Add(aParameters[i].Name);

  2292.   end;

  2293. 

  2294.   fRoot.AddClass(self);

  2295. 

  2296.   inherited ParseTextIntern(aParseArgs, aParameters);

  2297.   result := CheckEndToken(aParseArgs, self);

  2298. end;

  2299. 

  2300. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2301. procedure TengShaderPartClass.CheckDuplicate(const aName: String; const aOld, aNew: TengShaderPart);

  2302. 

  2303.   function IsInherited(const aRoot: TengShaderPartScope; const aClass: TengShaderPartClass): Boolean;

  2304.   var

  2305.     p: TengShaderPartScope;

  2306.   begin

  2307.     result := true;

  2308.     for p in fInherited do

  2309.       if (p is TengShaderPartClass) and ((p = aClass) or IsInherited(p, aClass)) then

  2310.         exit;

  2311.     result := false;

  2312.   end;

  2313. 

  2314.   function CompareParam(const p1, p2: TengShaderPartProcParam): Boolean;

  2315.   begin

  2316.     result := (p1.Name = p2.Name) and (p1.Typ = p2.Typ);

  2317.   end;

  2318. 

  2319. var

  2320.   i: Integer;

  2321.   o, n: TengShaderPartProc;

  2322.   c: TengShaderPartClass;

  2323. begin

  2324.   if (aOld is TengShaderPartProc) and (aNew is TengShaderPartProc) then begin

  2325.     o := (aOld as TengShaderPartProc);

  2326.     n := (aNew as TengShaderPartProc);

  2327.     o.GetParentType(TengShaderPartClass, c);

  2328.     if (o.fParameters.Count <> n.fParameters.Count) then

  2329.       raise EengInvalidParamterCount.Create('method must have the same parameters as the overwritten one', n.Line, n.Col, n.Filename);

  2330.     for i := 0 to o.fParameters.Count-1 do

  2331.       if not CompareParam(n.fParameters[i], o.fParameters[i]) then

  2332.         raise EengInvalidParamter.Create('parameters must have the same name and type as the overwritten one', n.Line, n.Col, n.Filename);

  2333.     if (o.ClassName <> n.ClassName) then

  2334.       raise EengInvalidToken.Create('method must be the same type as the overwritten one', n.Line, n.Col, n.Filename);

  2335.     if (o is TengShaderPartFunc) and ((o as TengShaderPartFunc).ReturnType <> (n as TengShaderPartFunc).ReturnType) then

  2336.       raise EengInvalidParamter.Create('return type must be the same as the overwritten one', n.Line, n.Col, n.Filename);

  2337.   end else

  2338.     inherited CheckDuplicate(aName, aOld, aNew);

  2339. end;

  2340. 

  2341. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2342. function TengShaderPartClass.GetFindPropertyFlags: TengFindMappedPartFlags;

  2343. begin

  2344.   result := inherited GetFindPropertyFlags + [ffFile];

  2345. end;

  2346. 

  2347. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2348. procedure TengShaderPartClass.GenCodeIntern(const aGenCodeArgs: TengGenCodeArgs);

  2349. var

  2350.   p: TengShaderPartScope;

  2351. begin

  2352.   for p in fInherited do

  2353.     p.GenCodeIntern(aGenCodeArgs);

  2354.   aGenCodeArgs.Code.AddToken(ttBegin);

  2355.   try

  2356.     inherited GenCodeIntern(aGenCodeArgs);

  2357.   finally

  2358.     aGenCodeArgs.Code.AddToken(ttEnd);

  2359.   end;

  2360. end;

  2361. 

  2362. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2363. procedure TengShaderPartClass.GenerateCode(const aGenCodeArgs: TengGenCodeArgs);

  2364. var

  2365.   main: TengShaderPartMain;

  2366. begin

  2367.   FindMappedPart(main, '', FIND_IN_SCOPE_FLAGS, TengShaderPartMain);

  2368.   if not Assigned(main) then

  2369.     raise EengInternal.Create('no main routine found');

  2370. 

  2371.   aGenCodeArgs.PushFlags([gcfGenProcedure]);

  2372.   try

  2373.     main.GenCodeIntern(aGenCodeArgs);

  2374.   finally

  2375.     aGenCodeArgs.PopFlags;

  2376.   end;

  2377. end;

  2378. 

  2379. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2380. procedure TengShaderPartClass.FindMappedParts(const aParts: TengShaderPartList; const aName: String; const aFlags: TengFindMappedPartFlags; const aType: CengShaderPart);

  2381. var

  2382.   f: TengShaderFile;

  2383. begin

  2384.   if (ffIgnoreClasses in aFlags) or

  2385.      ((ffFindFirst in aFlags) and (aParts.Count > 0)) then

  2386.     exit;

  2387. 

  2388.   // search in file

  2389.   if not (ffGlobal in aFlags) and (ffFile in aFlags) then begin

  2390.     GetParentType(TengShaderFile, f);

  2391.     if not Assigned(f) then

  2392.       EengInternal.Create('unable to find file object');

  2393.     f.FindMappedParts(aParts, aName, aFlags + [ffIgnoreClasses], aType);

  2394.   end;

  2395. 

  2396.   inherited FindMappedParts(aParts, aName, aFlags, aType);

  2397. end;

  2398. 

  2399. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2400. procedure TengShaderPartClass.MapData(const aFlags: TengMapDataFlags; const aTypes: array of CengShaderPart);

  2401. var

  2402.   s: String;

  2403.   sc: TengShaderPartScope;

  2404. begin

  2405.   if (mdfAddInherited in aFlags) then begin

  2406.     for s in fExtends do begin

  2407.       sc := fRoot.GetClass(s);

  2408.       if not Assigned(sc) then

  2409.         raise EengUnknownIdentifier.Create(s, Line, Col, Filename);

  2410.       MapInheritedScope(sc);

  2411.     end;

  2412.   end;

  2413.   inherited MapData(aFlags, aTypes);

  2414. end;

  2415. 

  2416. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2417. constructor TengShaderPartClass.Create(const aParent: TengShaderPart);

  2418. begin

  2419.   inherited Create(aParent);

  2420.   fExtends := TStringList.Create;

  2421. end;

  2422. 

  2423. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2424. destructor TengShaderPartClass.Destroy;

  2425. begin

  2426.   FreeAndNil(fExtends);

  2427.   inherited Destroy;

  2428. end;

  2429. 

  2430. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2431. class function TengShaderPartClass.GetTokenName: String;

  2432. begin

  2433.   result := TOKEN_CLASS;

  2434. end;

  2435. 

  2436. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2437. class procedure TengShaderPartClass.CheckToken(const aParseArgs: TengParseArgs; const aParent: TengShaderPart);

  2438. 

  2439.   procedure RaiseEx(const aToken: String);

  2440.   begin

  2441.     with aParseArgs do

  2442.       raise EengShaderPart.Create('token ' + GetTokenName + ' is not allowed in ' + aToken, Line, Col, aParent.Filename);

  2443.   end;

  2444. 

  2445. begin

  2446.   if (aParent is TengShaderPartClass) or aParent.ParentHasType(TengShaderPartClass) then

  2447.     RaiseEx(TengShaderPartClass.GetTokenName);

  2448.   if (aParent is TengShaderPartIf) or aParent.ParentHasType(TengShaderPartIf) then

  2449.     RaiseEx(TengShaderPartIf.GetTokenName);

  2450.   if (aParent is TengShaderPartElse) or aParent.ParentHasType(TengShaderPartElse) then

  2451.     RaiseEx(TengShaderPartElse.GetTokenName);

  2452.   if (aParent is TengShaderPartElIf) or aParent.ParentHasType(TengShaderPartElIf) then

  2453.     RaiseEx(TengShaderPartElIf.GetTokenName);

  2454. end;

  2455. 

  2456. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2457. //TengShaderFile////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2458. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2459. function TengShaderFile.GetFilename: String;

  2460. begin

  2461.   result := fFilename;

  2462. end;

  2463. 

  2464. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2465. procedure TengShaderFile.LoadFromFile(const aFilename: String);

  2466. var

  2467.   s: TStream;

  2468.   {$IFDEF USE_VFS}sHandle: IStreamHandle;{$ENDIF}

  2469. 

  2470.   function GetStream(out aStream: TStream): Boolean;

  2471.   begin

  2472.     {$IFDEF USE_VFS}

  2473.     result := vfsManager.ReadFile(aFilename, sHandle);

  2474.     if result then

  2475.       aStream := sHandle.GetStream

  2476.     else

  2477.       aStream := nil;;

  2478.     {$ELSE}

  2479.     result := true;

  2480.     aStream := TFileStream.Create(aFilename, fmOpenRead);

  2481.     {$ENDIF}

  2482.   end;

  2483. 

  2484.   procedure FreeStream(var aStream: TStream);

  2485.   begin

  2486.     {$IFDEF USE_VFS}

  2487.     aStream := nil;

  2488.     sHandle := nil;

  2489.     {$ELSE}

  2490.     FreeAndNil(aStream);

  2491.     {$ENDIF}

  2492.   end;

  2493. 

  2494. begin

  2495.   if not {$IFDEF USE_VFS}vfsManager.{$ENDIF}FileExists(aFilename) then

  2496.     if Assigned(fParent) then with fParent do

  2497.       raise EengShaderPart.Create('file does not exist: ' + aFilename, Line, Col, Filename)

  2498.     else

  2499.       raise EengShaderPart.Create('file does not exist: ' + aFilename);

  2500. 

  2501.   if GetStream(s) then begin

  2502.     try

  2503.       LoadFromStream(s, aFilename);

  2504.     finally

  2505.       FreeStream(s);

  2506.     end;

  2507.   end;

  2508. end;

  2509. 

  2510. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2511. procedure TengShaderFile.SaveToFile(const aFilename: String);

  2512. var

  2513.   s: TStream;

  2514.   {$IFDEF USE_VFS}sHandle: IStreamHandle;{$ENDIF}

  2515. 

  2516.   function GetStream(out aStream: TStream): Boolean;

  2517.   begin

  2518.     {$IFDEF USE_VFS}

  2519.     result := vfsManager.CreateFile(aFilename, sHandle);

  2520.     if result then

  2521.       aStream := sHandle.GetStream

  2522.     else

  2523.       aStream := nil;;

  2524.     {$ELSE}

  2525.     result := true;

  2526.     aStream := TFileStream.Create(aFilename, fmCreate);

  2527.     {$ENDIF}

  2528.   end;

  2529. 

  2530.   procedure FreeStream(var aStream: TStream);

  2531.   begin

  2532.     {$IFDEF USE_VFS}

  2533.     aStream := nil;

  2534.     sHandle := nil;

  2535.     {$ELSE}

  2536.     FreeAndNil(aStream);

  2537.     {$ENDIF}

  2538.   end;

  2539. 

  2540. begin

  2541.   fFilename := aFilename;

  2542.   if GetStream(s) then begin

  2543.     try

  2544.       SaveToStream(s);

  2545.     finally

  2546.       FreeStream(s);

  2547.     end;

  2548.   end;

  2549. end;

  2550. 

  2551. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2552. procedure TengShaderFile.LoadFromStream(const aStream: TStream; const aFilename: String);

  2553. var

  2554.   token: String;

  2555.   args: TengParseArgs;

  2556. begin

  2557.   fFilename := aFilename;

  2558.   Clear;

  2559.   args := TengParseArgs.Create(self);

  2560.   try

  2561.     args.LoadCode(aStream);

  2562.     token := ParseText(args);

  2563.     if (token <> '') then

  2564.       raise EengShaderPart.Create('unknown token ''' + token + '''', args.Line, args.Col, Filename);

  2565.   finally

  2566.     FreeAndNil(args);

  2567.   end;

  2568. end;

  2569. 

  2570. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2571. procedure TengShaderFile.SaveToStream(const aStream: TStream);

  2572. var

  2573.   sl: TStringList;

  2574. begin

  2575.   sl := TStringList.Create;

  2576.   try

  2577.     sl.Text := Text;

  2578.     sl.SaveToStream(aStream);

  2579.   finally

  2580.     FreeAndNil(sl);

  2581.   end;

  2582. end;

  2583. 

  2584. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2585. function TengShaderFile.GetGenerator(const aName: String): TengCodeGenerator;

  2586. begin

  2587.   ClearMappedData;

  2588.   MapData([],                          [TengShaderPartDefine]);

  2589.   MapData([mdfIfAll, mdfAddInherited], [TengShaderPartProperty]);

  2590.   if (aName <> '') then

  2591.     result := fClasses[aName]

  2592.   else

  2593.     result := self;

  2594. end;

  2595. 

  2596. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2597. function TengShaderFile.GetFindPropertyFlags: TengFindMappedPartFlags;

  2598. begin

  2599.   result := inherited GetFindPropertyFlags + [ffIgnoreClasses];

  2600. end;

  2601. 

  2602. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2603. procedure TengShaderFile.MapData(const aFlags: TengMapDataFlags; const aTypes: array of CengShaderPart);

  2604. var

  2605.   s: TengShaderPartScope;

  2606.   p: TengShaderPart;

  2607. begin

  2608.   // do not call inherited or included files will map themself as child to this file-scope,

  2609.   // but files are all inherited to each other

  2610.   if (mdfCurrentScope in aFlags) and (mdfChild in aFlags) then

  2611.     exit;

  2612. 

  2613.   if (mdfAddInherited in aFlags) then begin

  2614.     GetParentType(TengShaderPartScope, s);

  2615.     if Assigned(s) then begin

  2616.       if(s is TengShaderFile) then

  2617.         s.MapInheritedScope(self)

  2618.       else

  2619.         s.MapChildScope(self);

  2620.     end;

  2621.   end;

  2622. 

  2623.   for p in fChildren do

  2624.     p.MapData(aFlags + [mdfChild], aTypes);

  2625. 

  2626.   if (mdfMapInherited in aFlags) then

  2627.     for s in fInherited do

  2628.       s.MapData(aFlags, aTypes);

  2629. end;

  2630. 

  2631. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2632. function TengShaderFile.GetClass(const aName: String): TengShaderPartClass;

  2633. begin

  2634.   result := fClasses[aName];

  2635. end;

  2636. 

  2637. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2638. procedure TengShaderFile.AddClass(const aClass: TengShaderPartClass);

  2639. var

  2640.   c: TengShaderPartClass;

  2641. begin

  2642.   c := fClasses[aClass.Name];

  2643.   if not Assigned(c) then

  2644.     fClasses.Add(aClass.Name, aClass)

  2645.   else if (c <> aClass) then

  2646.     raise EengInternal.Create('name is already registred for other class data object: ' + aClass.Name);

  2647. end;

  2648. 

  2649. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2650. procedure TengShaderFile.GenerateCode(const aGenCodeArgs: TengGenCodeArgs);

  2651. var

  2652.   main: TengShaderPartMain;

  2653. begin

  2654.   FindMappedPart(main, '', FIND_IN_SCOPE_FLAGS, TengShaderPartMain);

  2655.   if Assigned(main) then begin

  2656.     aGenCodeArgs.PushFlags([gcfGenProcedure]);

  2657.     try

  2658.       main.GenCodeIntern(aGenCodeArgs);

  2659.     finally

  2660.       aGenCodeArgs.PopFlags;

  2661.     end;

  2662.   end;

  2663. end;

  2664. 

  2665. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2666. procedure TengShaderFile.ListGenerators(const aList: TStrings);

  2667. var

  2668.   s: String;

  2669. begin

  2670.   ClearMappedData;

  2671.   MapData([],                          [TengShaderPartDefine]);

  2672.   MapData([mdfIfAll, mdfAddInherited], [TengShaderPartProperty]);

  2673.   for s in fClasses.Keys do

  2674.     aList.Add(s);

  2675. end;

  2676. 

  2677. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2678. procedure TengShaderFile.Clear;

  2679. begin

  2680.   ClearMappedData;

  2681.   ClearGenCode;

  2682.   fClasses.Clear;

  2683.   fChildren.Clear;

  2684. end;

  2685. 

  2686. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2687. constructor TengShaderFile.Create(const aParent: TengShaderPart);

  2688. begin

  2689.   inherited Create(aParent);

  2690.   fClasses := TengShaderPartClassMap.Create(false);

  2691.   if not Assigned(fRoot) then

  2692.     fRoot := self;

  2693. end;

  2694. 

  2695. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2696. constructor TengShaderFile.Create;

  2697. begin

  2698.   Create(nil);

  2699. end;

  2700. 

  2701. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2702. destructor TengShaderFile.Destroy;

  2703. begin

  2704.   FreeAndNil(fClasses);

  2705.   inherited Destroy;

  2706. end;

  2707. 

  2708. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2709. //TengShaderPartInclude/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2710. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2711. function TengShaderPartInclude.GetCount: Integer;

  2712. begin

  2713.   if Assigned(fShaderFile) then

  2714.     result := 1

  2715.   else

  2716.     result := 0;

  2717. end;

  2718. 

  2719. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2720. function TengShaderPartInclude.GetChild(const aIndex: Integer): TengShaderPart;

  2721. begin

  2722.   if Assigned(fShaderFile) then

  2723.     result := fShaderFile

  2724.   else

  2725.     raise EOutOfRange.Create(aIndex, 0, -1);

  2726. end;

  2727. 

  2728. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2729. function TengShaderPartInclude.GetText: String;

  2730. begin

  2731.   result := PRECOMPILER_STATEMENT_BEGIN + GetTokenName + ' ''' + fIncludeFile + '''' + PRECOMPILER_STATEMENT_END;

  2732. end;

  2733. 

  2734. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2735. function TengShaderPartInclude.ParseTextIntern(const aParseArgs: TengParseArgs; const aParameters: TengTokenParameterList): String;

  2736. begin

  2737.   if (aParameters[0].Name <> GetTokenName) then

  2738.     raise EengInvalidToken.Create(ClassName, aParameters[0].Name, Line, Col, Filename);

  2739.   if (aParameters.Count <> 2) then

  2740.     raise EengInvalidParamterCount.Create(GetTokenName, Line, Col, Filename);

  2741.   fIncludeFile  := aParameters[1].Name;

  2742.   fAbsoluteFile := CreateAbsolutePath(fIncludeFile, ExtractFilePath(Filename));

  2743.   result := '';

  2744. end;

  2745. 

  2746. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2747. procedure TengShaderPartInclude.CheckShaderFile;

  2748. begin

  2749.   if not Assigned(fShaderFile) then

  2750.     fShaderFile := TengShaderFile.Create(self);

  2751.   if (fShaderFile.Filename <> fAbsoluteFile) then

  2752.     fShaderFile.LoadFromFile(fAbsoluteFile);

  2753. end;

  2754. 

  2755. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2756. procedure TengShaderPartInclude.MapData(const aFlags: TengMapDataFlags; const aTypes: array of CengShaderPart);

  2757. begin

  2758.   inherited MapData(aFlags, aTypes);

  2759.   CheckShaderFile;

  2760.   fShaderFile.MapData(aFlags, aTypes);

  2761. end;

  2762. 

  2763. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2764. procedure TengShaderPartInclude.GenCodeIntern(const aGenCodeArgs: TengGenCodeArgs);

  2765. begin

  2766.   inherited GenCodeIntern(aGenCodeArgs);

  2767.   CheckShaderFile;

  2768.   aGenCodeArgs.Code.AddToken(ttBegin);

  2769.   try

  2770.     aGenCodeArgs.Code.AddToken(ttSingle);

  2771.     aGenCodeArgs.Code.AddLineEnd;

  2772.     fShaderFile.GenCodeIntern(aGenCodeArgs);

  2773.   finally

  2774.     aGenCodeArgs.Code.AddToken(ttEnd);

  2775.   end;

  2776. end;

  2777. 

  2778. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2779. constructor TengShaderPartInclude.Create(const aParent: TengShaderPart);

  2780. begin

  2781.   inherited Create(aParent);

  2782.   fShaderFile := nil;

  2783. end;

  2784. 

  2785. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2786. destructor TengShaderPartInclude.Destroy;

  2787. begin

  2788.   FreeAndNil(fShaderFile);

  2789.   inherited Destroy;

  2790. end;

  2791. 

  2792. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2793. class function TengShaderPartInclude.GetTokenName: String;

  2794. begin

  2795.   result := TOKEN_INCLUDE;

  2796. end;

  2797. 

  2798. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2799. //TengShaderPartComment/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2800. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2801. function TengShaderPartComment.GetText: String;

  2802. begin

  2803.   result := PRECOMPILER_STATEMENT_BEGIN + GetTokenName + fText + PRECOMPILER_STATEMENT_END;

  2804. end;

  2805. 

  2806. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2807. function TengShaderPartComment.ParseTextIntern(const aParseArgs: TengParseArgs; const aParameters: TengTokenParameterList): String;

  2808. begin

  2809.   if (aParameters[0].Name <> GetTokenName) then

  2810.     raise EengInvalidToken.Create(ClassName, aParameters[0].Name, Line, Col, Filename);

  2811.   if (aParameters.Count <> 2) then

  2812.     raise EengInvalidParamterCount.Create(GetTokenName, Line, Col, Filename);

  2813.   fText := aParameters[1].Name;

  2814.   result := '';

  2815. end;

  2816. 

  2817. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2818. class function TengShaderPartComment.GetTokenName: String;

  2819. begin

  2820.   result := COMMENT_IDENTIFIER;

  2821. end;

  2822. 

  2823. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2824. //TengShaderPartInherited///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2825. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2826. function TengShaderPartInherited.GetText: String;

  2827. begin

  2828.   result := PRECOMPILER_STATEMENT_BEGIN + GetTokenName;

  2829.   if (fInheritedName <> '') then

  2830.     result := ' ' + fInheritedName;

  2831.   result := result + PRECOMPILER_STATEMENT_END;

  2832. end;

  2833. 

  2834. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2835. function TengShaderPartInherited.ParseTextIntern(const aParseArgs: TengParseArgs; const aParameters: TengTokenParameterList): String;

  2836. var

  2837.   i: Integer;

  2838. begin

  2839.   if (aParameters[0].Name <> GetTokenName) then

  2840.     raise EengInvalidToken.Create(ClassName, aParameters[0].Name, Line, Col, Filename);

  2841.   if (aParameters.Count < 1) then

  2842.     raise EengInvalidParamterCount.Create(GetTokenName, Line, Col, Filename);

  2843. 

  2844.   fParameters.Clear;

  2845.   if (aParameters.Count >= 2) then begin

  2846.     if not IsValidIdentifier(aParameters[1].Name) and (aParameters[1].Name <> TOKEN_MAIN) then

  2847.       raise EengInvalidIdentifier.Create(aParameters[1].Name, Line, Col, Filename);

  2848.     fInheritedName := aParameters[1].Name;

  2849.     for i := 2 to aParameters.Count-1 do

  2850.       fParameters.Add(aParameters[i].Name);

  2851.   end else

  2852.     fInheritedName := '';

  2853.   result := '';

  2854. end;

  2855. 

  2856. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2857. procedure TengShaderPartInherited.GenCodeIntern(const aGenCodeArgs: TengGenCodeArgs);

  2858. 

  2859.   function FindProc(const aParentProc: TengShaderPartProc): TengShaderPartProc;

  2860.   var

  2861.     c: TengShaderPartClass;

  2862.     p: TengShaderPart;

  2863.     s: TengShaderPartScope;

  2864.     procs: TengShaderPartList;

  2865.   begin

  2866.     procs := TengShaderPartList.Create(false);

  2867.     try

  2868.       s := CheckParentScope(aParentProc);

  2869.       if not (s is TengShaderPartClass) then

  2870.         raise EengInternal.Create('parent scope of method with inherited token must be a class', Line, Col, Filename);

  2871.       s.FindMappedParts(procs, aParentProc.Name, FIND_INHERITED_FLAGS, TengShaderPartProc);

  2872.       if (fInheritedName <> '') then begin

  2873.         for p in procs do begin

  2874.           result := (p as TengShaderPartProc);

  2875.           result.GetParentType(TengShaderPartClass, c);

  2876.           if not Assigned(c) then

  2877.             raise EengInternal.Create('inherited method without class', Line, Col, Filename);

  2878.           if (c.Name = fInheritedName) then

  2879.             exit;

  2880.         end;

  2881.         raise EengInvalidIdentifier.Create('could not find inherited method: ' + aParentProc.Name, Line, Col, Filename)

  2882.       end else if (procs.Count > 1) then

  2883.         raise EengInvalidParamterCount.Create(GetTokenName + ' is ambiguous: specify inherited class')

  2884.       else if (procs.Count <= 0) then

  2885.         raise EengInvalidIdentifier.Create('could not find inherited method: ' + aParentProc.Name, Line, Col, Filename)

  2886.       else

  2887.         result := (procs[0] as TengShaderPartProc);

  2888.     finally

  2889.       FreeAndNil(procs);

  2890.     end;

  2891.   end;

  2892. 

  2893.   procedure GenCode(const aProc: TengShaderPartProc; const aParams: TStrings);

  2894.   begin

  2895.     aGenCodeArgs.PushFlags(aGenCodeArgs.Flags + [gcfGenProcInline]);

  2896.     aGenCodeArgs.PushProcParams(aParams);

  2897.     try

  2898.       aProc.GenCodeIntern(aGenCodeArgs);

  2899.     finally

  2900.       aGenCodeArgs.PopProcParams;

  2901.       aGenCodeArgs.PopFlags;

  2902.     end;

  2903.   end;

  2904. 

  2905. var

  2906.   proc: TengShaderPartProc;

  2907.   params: TStringList;

  2908.   p: TengShaderPartProcParam;

  2909. begin

  2910.   inherited GenCodeIntern(aGenCodeArgs);

  2911. 

  2912.   GetParentType(TengShaderPartProc, proc);

  2913.   if not Assigned(proc) then

  2914.     raise EengInternal.Create('inherited without parent procedure', Line, Col, Filename);

  2915. 

  2916.   proc := FindProc(proc);

  2917.   if (fParameters.Count > 0) then begin

  2918.     if (fParameters.Count <> proc.fParameters.Count) then

  2919.       raise EengInvalidParamterCount.Create(proc.Name + ' expects ' + IntToStr(proc.fParameters.Count) + ' parameter', Line, Col, Filename);

  2920.     GenCode(proc, fParameters);

  2921.   end else begin

  2922.     params := TStringList.Create;

  2923.     try

  2924.       for p in proc.fParameters do

  2925.         params.Add(p.Name);

  2926.       GenCode(proc, params);

  2927.     finally

  2928.       FreeAndNil(params);

  2929.     end;

  2930.   end;

  2931. end;

  2932. 

  2933. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2934. constructor TengShaderPartInherited.Create(const aParent: TengShaderPart);

  2935. begin

  2936.   inherited Create(aParent);

  2937.   fParameters := TStringList.Create;

  2938. end;

  2939. 

  2940. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2941. destructor TengShaderPartInherited.Destroy;

  2942. begin

  2943.   FreeAndNil(fParameters);

  2944.   inherited Destroy;

  2945. end;

  2946. 

  2947. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2948. class function TengShaderPartInherited.GetTokenName: String;

  2949. begin

  2950.   result := TOKEN_INHERITED;

  2951. end;

  2952. 

  2953. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2954. class procedure TengShaderPartInherited.CheckToken(const aParseArgs: TengParseArgs; const aParent: TengShaderPart);

  2955. begin

  2956.   inherited CheckToken(aParseArgs, aParent);

  2957.   if not ((aParent is TengShaderPartProc) or aParent.ParentHasType(TengShaderPartProc)) or

  2958.      not (aParent.ParentHasType(TengShaderPartClass)) then

  2959.     with aParseArgs do

  2960.       raise EengShaderPart.Create(GetTokenName + ' is not allowed outside of a function or procedure', Line, Col, aParent.GetFilename);

  2961. end;

  2962. 

  2963. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2964. //TengMetaData//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2965. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2966. function TengMetaData.GetCount: Integer;

  2967. begin

  2968.   result := fValues.Count;

  2969. end;

  2970. 

  2971. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2972. function TengMetaData.GetMetaType: TengMetaType;

  2973. begin

  2974.   result := fMetaType;

  2975. end;

  2976. 

  2977. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2978. function TengMetaData.GetName: String;

  2979. begin

  2980.   result := fName;

  2981. end;

  2982. 

  2983. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2984. function TengMetaData.GetValues(const aIndex: Integer): String;

  2985. begin

  2986.   result := fValues[aIndex];

  2987. end;

  2988. 

  2989. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2990. procedure TengMetaData.AddValue(const aValue: String);

  2991. begin

  2992.   fValues.Add(aValue);

  2993. end;

  2994. 

  2995. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  2996. constructor TengMetaData.Create(const aName: String; const aType: TengMetaType);

  2997. begin

  2998.   inherited Create;

  2999.   fName     := aName;

  3000.   fMetaType := aType;

  3001.   fValues   := TStringList.Create;

  3002. end;

  3003. 

  3004. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3005. destructor TengMetaData.Destroy;

  3006. begin

  3007.   FreeAndNil(fValues);

  3008.   inherited Destroy;

  3009. end;

  3010. 

  3011. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3012. //TengShaderPartMeta////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3013. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3014. function TengShaderPartMeta.GetText: String;

  3015. var

  3016.   i: Integer;

  3017. begin

  3018.   result := PRECOMPILER_STATEMENT_BEGIN + GetTokenName + ' ' + fMetaData.Name;

  3019.   for i := 0 to fMetaData.Count-1 do

  3020.     result := result + ' ' + fMetaData[i];

  3021.   result := result + PRECOMPILER_STATEMENT_END;

  3022. end;

  3023. 

  3024. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3025. function TengShaderPartMeta.ParseTextIntern(const aParseArgs: TengParseArgs; const aParameters: TengTokenParameterList): String;

  3026. var

  3027.   i: Integer;

  3028.   t: TengMetaType;

  3029.   d: TengMetaData;

  3030.   n: String;

  3031. begin

  3032.   if (aParameters[0].Name <> GetTokenName) then

  3033.     raise EengInvalidToken.Create(ClassName, aParameters[0].Name, Line, Col, Filename);

  3034.   if (aParameters.Count < 2) then

  3035.     raise EengInvalidParamterCount.Create(GetTokenName, Line, Col, Filename);

  3036. 

  3037.   result := '';

  3038.   n := aParameters[1].Name;

  3039. 

  3040.   {.$VERSION}

  3041.   if (n = TOKEN_VERSION) then begin

  3042.     t := metaVersion;

  3043.     if (aParameters.Count >= 3) and (aParameters.Count <= 4) then

  3044. 

  3045.     if (aParameters.Count = 3) then begin

  3046.       if (aParameters[2].Name <> VERSION_EXTRA_COMPAT) and not TryStrToInt(aParameters[2].Name, i) then

  3047.         raise EengInvalidParamter.Create('version must be an number or "' + VERSION_EXTRA_COMPAT + '"', Line, Col, Filename);

  3048.     end else if (aParameters.Count = 4) then begin

  3049.       if (aParameters[2].Name <> VERSION_EXTRA_COMPAT) and not TryStrToInt(aParameters[2].Name, i) then

  3050.         raise EengInvalidParamter.Create('version must be an number or "' + VERSION_EXTRA_COMPAT + '"', Line, Col, Filename);

  3051.       if (aParameters[3].Name <> VERSION_EXTRA_COMPAT) then

  3052.         raise EengInvalidParamter.Create('only "' + VERSION_EXTRA_COMPAT + '" is alowed as second parameter', Line, Col, Filename);

  3053.     end else

  3054.       raise EengInvalidParamterCount.Create(GetTokenName, Line, Col, Filename);

  3055. 

  3056.   {.$EXTENSION}

  3057.   end else if (n = TOKEN_EXTENSION) then begin

  3058.     t := metaExtension;

  3059.     if (aParameters.Count <> 4) then

  3060.       raise EengInvalidParamterCount.Create(GetTokenName, Line, Col, Filename);

  3061. 

  3062.   {.$LAYOUT}

  3063.   end else if (n = TOKEN_LAYOUT) then begin

  3064.     t := metaLayout;

  3065.     if (aParameters.Count <> 3) then

  3066.       raise EengInvalidParamterCount.Create(GetTokenName, Line, Col, Filename);

  3067. 

  3068.   {.VALUES}

  3069.   end else

  3070.     t := metaNormal;

  3071. 

  3072.   d := TengMetaData.Create(n, t);

  3073.   for i := 2 to aParameters.Count-1 do

  3074.     d.AddValue(aParameters[i].Name);

  3075.   fMetaData := d;

  3076. end;

  3077. 

  3078. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3079. procedure TengShaderPartMeta.GenCodeIntern(const aGenCodeArgs: TengGenCodeArgs);

  3080. begin

  3081.   inherited GenCodeIntern(aGenCodeArgs);

  3082.   aGenCodeArgs.AddMeta(fMetaData);

  3083. end;

  3084. 

  3085. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3086. destructor TengShaderPartMeta.Destroy;

  3087. begin

  3088.   fMetaData := nil;

  3089.   inherited Destroy;

  3090. end;

  3091. 

  3092. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3093. class function TengShaderPartMeta.GetTokenName: String;

  3094. begin

  3095.   result := TOKEN_META;

  3096. end;

  3097. 

  3098. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3099. //TengShaderPartKeyValuePair////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3100. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3101. function TengShaderPartKeyValuePair.GetText: String;

  3102. begin

  3103.   result := PRECOMPILER_STATEMENT_BEGIN + GetTokenName + ' ' + fName;

  3104.   if (fValueName <> '') then

  3105.     result := result + ' ' + fValueName

  3106.   else if (fValue <> Unassigned) then

  3107.     result := result + ' ''' + String(fValue) + '''';

  3108.   result := result + PRECOMPILER_STATEMENT_END;

  3109. end;

  3110. 

  3111. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3112. function TengShaderPartKeyValuePair.ParseTextIntern(const aParseArgs: TengParseArgs; const aParameters: TengTokenParameterList): String;

  3113. begin

  3114.   if (aParameters[0].Name <> GetTokenName) then

  3115.     raise EengInvalidToken.Create(ClassName, GetTokenName, Line, Col, Filename);

  3116.   if (aParameters.Count < 2) or (aParameters.Count > 3) then

  3117.     raise EengInvalidParamterCount.Create(GetTokenName, Line, Col, Filename);

  3118. 

  3119.   result := '';

  3120.   fName := aParameters[1].Name;

  3121.   if not IsValidIdentifier(fName) then

  3122.     raise EengInvalidIdentifier.Create(fName, Line, Col, Filename);

  3123.   if (aParameters.Count >= 3) then

  3124.     if aParameters[2].Quoted then begin

  3125.       fValue     := aParameters[2].Name;

  3126.       fValueName := '';

  3127.     end else begin

  3128.       fValue     := Unassigned;

  3129.       fValueName := aParameters[2].Name;

  3130.     end

  3131.   else begin

  3132.     fValue     := Unassigned;

  3133.     fValueName := '';

  3134.   end;

  3135. end;

  3136. 

  3137. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3138. constructor TengShaderPartKeyValuePair.CreateValue(const aParent: TengShaderPart; const aName: String; const aValue: Variant);

  3139. begin

  3140.   inherited Create(aParent);

  3141.   fName      := aName;

  3142.   fValue     := aValue;

  3143.   fValueName := '';

  3144. end;

  3145. 

  3146. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3147. constructor TengShaderPartKeyValuePair.CreateName(const aParent: TengShaderPart; const aName, aValueName: String);

  3148. begin

  3149.   inherited Create(aParent);

  3150.   fName      := aName;

  3151.   fValue     := Unassigned;

  3152.   fValueName := aValueName;

  3153. end;

  3154. 

  3155. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3156. procedure TengShaderPartKeyValuePair.GenCodeIntern(const aGenCodeArgs: TengGenCodeArgs);

  3157. begin

  3158.   inherited GenCodeIntern(aGenCodeArgs);

  3159.   aGenCodeArgs.Code.AddToken(ttSingle);

  3160. end;

  3161. 

  3162. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3163. //TengShaderPartProperty//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3164. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3165. procedure TengShaderPartProperty.MapData(const aFlags: TengMapDataFlags; const aTypes: array of CengShaderPart);

  3166. var

  3167.   p: TengShaderPart;

  3168.   s: TengShaderPartScope;

  3169. begin

  3170.   inherited MapData(aFlags, aTypes);

  3171.   if CheckType(self, aTypes) then begin

  3172.     s := CheckParentScope(self);

  3173.     if s.MapShaderPart(Name, self) and (fValueName <> '') then begin

  3174.       s.FindMappedPart(p, fValueName, FIND_IN_SCOPE_FLAGS);

  3175.       if not Assigned(p) then

  3176.         raise EengUnknownIdentifier.Create(fValueName, Line, Col, Filename)

  3177.       else if not (p is TengShaderPartDefine) then

  3178.         raise EengInvalidParamter.Create('invalid type, expected ' + TengShaderPartDefine.GetTokenName, Line, Col, Filename)

  3179.       else

  3180.         fValue := (p as TengShaderPartDefine).Value;

  3181.     end;

  3182.   end;

  3183. end;

  3184. 

  3185. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3186. class function TengShaderPartProperty.GetTokenName: String;

  3187. begin

  3188.   result := TOKEN_PROPERTY;

  3189. end;

  3190. 

  3191. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3192. //TengShaderPartDefine//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3193. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3194. function TengShaderPartDefine.ParseTextIntern(const aParseArgs: TengParseArgs; const aParameters: TengTokenParameterList): String;

  3195. begin

  3196.   if (aParameters.Count <> 3) then

  3197.     raise EengInvalidParamterCount.Create(GetTokenName, Line, Col, GetFilename);

  3198.   result := inherited ParseTextIntern(aParseArgs, aParameters);

  3199.   if (fValueName <> '') then

  3200.     fValue := fValueName;

  3201. end;

  3202. 

  3203. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3204. procedure TengShaderPartDefine.MapData(const aFlags: TengMapDataFlags; const aTypes: array of CengShaderPart);

  3205. begin

  3206.   if CheckType(self, aTypes) then

  3207.     CheckParentScope(self).MapShaderPart(Name, self);

  3208. end;

  3209. 

  3210. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3211. class function TengShaderPartDefine.GetTokenName: String;

  3212. begin

  3213.   result := TOKEN_DEFINE;

  3214. end;

  3215. 

  3216. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3217. //TengShaderPartCodeProperty////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3218. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3219. function TengShaderPartCodeProperty.GetText: String;

  3220. begin

  3221.   result := PRECOMPILER_STATEMENT_BEGIN + GetTokenName + ' ''' + fType + ''' ''' + fName + '''' + PRECOMPILER_STATEMENT_END;

  3222. end;

  3223. 

  3224. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3225. function TengShaderPartCodeProperty.ParseTextIntern(const aParseArgs: TengParseArgs; const aParameters: TengTokenParameterList): String;

  3226. begin

  3227.   if (aParameters[0].Name <> GetTokenName) then

  3228.     raise EengInvalidToken.Create(ClassName, aParameters[0].Name, Line, Col, Filename);

  3229.   if (aParameters.Count <> 3) then

  3230.     raise EengInvalidParamterCount.Create(GetTokenName, Line, Col, Filename);

  3231. 

  3232.   result := '';

  3233.   fType := aParameters[1].Name;

  3234.   fName := aParameters[2].Name;

  3235. end;

  3236. 

  3237. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3238. function TengShaderPartCodeProperty.IsEquals(const aCodeProp: TengShaderPartCodeProperty): Boolean;

  3239. begin

  3240.   result :=

  3241.     (ClassName = aCodeProp.ClassName) and

  3242.     (fName     = aCodeProp.fName) and

  3243.     (fType     = aCodeProp.fType);

  3244. end;

  3245. 

  3246. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3247. procedure TengShaderPartCodeProperty.MapData(const aFlags: TengMapDataFlags; const aTypes: array of CengShaderPart);

  3248. begin

  3249.   if CheckType(self, aTypes) then

  3250.     CheckParentScope(self).MapShaderPart(fName, self);

  3251. end;

  3252. 

  3253. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3254. procedure TengShaderPartCodeProperty.GenCodeIntern(const aGenCodeArgs: TengGenCodeArgs);

  3255. begin

  3256.   inherited GenCodeIntern(aGenCodeArgs);

  3257.   if not (gcfGenCodeProp in aGenCodeArgs.Flags) then begin

  3258.     aGenCodeArgs.AddCodeProperty(self);

  3259.     aGenCodeArgs.Code.AddToken(ttSingle);

  3260.   end;

  3261. end;

  3262. 

  3263. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3264. //TengShaderPartVar/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3265. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3266. function TengShaderPartVar.GetText: String;

  3267. begin

  3268.   result := PRECOMPILER_STATEMENT_BEGIN + GetTokenName + ' ''' + fType + ''' ''' + fName + '''';

  3269.   if (fDefault <> Unassigned) then

  3270.     result := result + ' ''' + fDefault + '''';

  3271.   result := result + PRECOMPILER_STATEMENT_END;

  3272. end;

  3273. 

  3274. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3275. function TengShaderPartVar.ParseTextIntern(const aParseArgs: TengParseArgs; const aParameters: TengTokenParameterList): String;

  3276. begin

  3277.   if (aParameters[0].Name <> GetTokenName) then

  3278.     raise EengInvalidToken.Create(ClassName, aParameters[0].Name, Line, Col, Filename);

  3279.   if (aParameters.Count < 3) or (aParameters.Count > 4) then

  3280.     raise EengInvalidParamterCount.Create(GetTokenName, Line, Col, Filename);

  3281. 

  3282.   result := '';

  3283.   fType := aParameters[1].Name;

  3284.   fName := aParameters[2].Name;

  3285.   if (aParameters.Count >= 4) then

  3286.     fDefault := aParameters[3].Name

  3287.   else

  3288.     fDefault := Unassigned;

  3289. end;

  3290. 

  3291. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3292. function TengShaderPartVar.IsEquals(const aCodeProp: TengShaderPartCodeProperty): Boolean;

  3293. begin

  3294.   result := inherited IsEquals(aCodeProp);

  3295.   if result and ((aCodeProp as TengShaderPartVar).fDefault <> '') and (fDefault <> '') then

  3296.     result := ((aCodeProp as TengShaderPartVar).fDefault = fDefault);

  3297. end;

  3298. 

  3299. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3300. procedure TengShaderPartVar.GenCodeIntern(const aGenCodeArgs: TengGenCodeArgs);

  3301. begin

  3302.   inherited GenCodeIntern(aGenCodeArgs);

  3303.   if (gcfGenCodeProp in aGenCodeArgs.Flags) then begin

  3304.     aGenCodeArgs.Code.AddText(Format('%'+IntToStr(aGenCodeArgs.MaxPropNameLen)+'s %s', [fType, fName]));

  3305.     if (fDefault <> '') then

  3306.       aGenCodeArgs.Code.AddText(' = ' + fDefault);

  3307.     aGenCodeArgs.Code.AddText(';');

  3308.   end;

  3309. end;

  3310. 

  3311. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3312. class function TengShaderPartVar.GetTokenName: String;

  3313. begin

  3314.   result := TOKEN_VAR;

  3315. end;

  3316. 

  3317. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3318. //TengShaderPartVarying/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3319. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3320. procedure TengShaderPartVarying.GenCodeIntern(const aGenCodeArgs: TengGenCodeArgs);

  3321. begin

  3322.   inherited GenCodeIntern(aGenCodeArgs);

  3323.   if (gcfGenCodeProp in aGenCodeArgs.Flags) then

  3324.     aGenCodeArgs.Code.AddText(Format('varying %'+IntToStr(aGenCodeArgs.MaxPropNameLen)+'s %s;', [fType, fName]));

  3325. end;

  3326. 

  3327. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3328. class function TengShaderPartVarying.GetTokenName: String;

  3329. begin

  3330.   result := TOKEN_VARYING;

  3331. end;

  3332. 

  3333. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3334. //TengShaderPartUniform/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3335. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3336. procedure TengShaderPartUniform.GenCodeIntern(const aGenCodeArgs: TengGenCodeArgs);

  3337. begin

  3338.   inherited GenCodeIntern(aGenCodeArgs);

  3339.   if (gcfGenCodeProp in aGenCodeArgs.Flags) then

  3340.     aGenCodeArgs.Code.AddText(Format('uniform %'+IntToStr(aGenCodeArgs.MaxPropNameLen)+'s %s;', [fType, fName]));

  3341. end;

  3342. 

  3343. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3344. class function TengShaderPartUniform.GetTokenName: String;

  3345. begin

  3346.   result := TOKEN_UNIFORM;

  3347. end;

  3348. 

  3349. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3350. //TengShaderPartCall////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3351. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3352. function TengShaderPartCall.GetText: String;

  3353. var

  3354.   i: Integer;

  3355. begin

  3356.   result := PRECOMPILER_STATEMENT_BEGIN + GetTokenName + ' ' + fName;

  3357.   for i := 0 to fParameters.Count-1 do

  3358.     if (PtrInt(fParameters.Objects[i]) <> 0) then

  3359.       result := result + ' ''' + fParameters[i] + ''''

  3360.     else

  3361.       result := result + ' ' + fParameters[i];

  3362.   result := result + PRECOMPILER_STATEMENT_END;

  3363. end;

  3364. 

  3365. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3366. function TengShaderPartCall.ParseTextIntern(const aParseArgs: TengParseArgs; const aParameters: TengTokenParameterList): String;

  3367. var

  3368.   i: Integer;

  3369. begin

  3370.   if (aParameters[0].Name <> GetTokenName) then

  3371.     raise EengInvalidToken.Create(ClassName, aParameters[0].Name, Line, Col, Filename);

  3372.   if (aParameters.Count < 2) then

  3373.     raise EengInvalidParamterCount.Create(GetTokenName, Line, Col, Filename);

  3374. 

  3375.   fParameters.Clear;

  3376.   result := '';

  3377.   fName := aParameters[1].Name;

  3378.   if not IsValidIdentifier(fName) then

  3379.     raise EengShaderPart.Create('invalid name: ' + fName, Line, Col, GetFilename);

  3380.   for i := 2 to aParameters.Count-1 do

  3381.     fParameters.AddObject(aParameters[i].Name, TObject(PtrInt(aParameters[i].Quoted)));

  3382. end;

  3383. 

  3384. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3385. procedure TengShaderPartCall.GenCodeIntern(const aGenCodeArgs: TengGenCodeArgs);

  3386. var

  3387.   p: TengShaderPartProc;

  3388. begin

  3389.   aGenCodeArgs.Root.FindMappedPart(p, fName, FIND_OVERWRITTEN_FLAGS, TengShaderPartProc);

  3390.   if not Assigned(p) then

  3391.     CheckParentScope(self).FindMappedPart(p, fName, GEN_CODE_FIND_FLAGS, TengShaderPartProc);

  3392. 

  3393.   if not Assigned(p) then

  3394.     raise EengUnknownIdentifier.Create(fName, Line, Col, Filename);

  3395.   if not (p is TengShaderPartProc) then

  3396.     raise EengInvalidParamter.Create('Expected ' + TengShaderPartFunc.GetTokenName + ' or ' + TengShaderPartProc.GetTokenName, Line, Col, Filename);

  3397.   if ((p as TengShaderPartProc).fParameters.Count <> fParameters.Count) then

  3398.     raise EengInvalidParamterCount.Create(fName + ' expects ' + IntToStr((p as TengShaderPartProc).fParameters.Count) + ' parameter', Line, Col, Filename);

  3399. 

  3400.   aGenCodeArgs.PushProcParams(fParameters);

  3401.   aGenCodeArgs.PushFlags(aGenCodeArgs.Flags - [gcfGenProcedure, gcfGenProcInline] + [gcfGenProcCall]);

  3402.   try

  3403.     p.GenCodeIntern(aGenCodeArgs);

  3404.   finally

  3405.     aGenCodeArgs.PopProcParams;

  3406.     aGenCodeArgs.PopFlags;

  3407.   end;

  3408.   inherited GenCodeIntern(aGenCodeArgs);

  3409. end;

  3410. 

  3411. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3412. constructor TengShaderPartCall.Create(const aParent: TengShaderPart);

  3413. begin

  3414.   inherited Create(aParent);

  3415.   fParameters := TStringList.Create;

  3416. end;

  3417. 

  3418. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3419. destructor TengShaderPartCall.Destroy;

  3420. begin

  3421.   FreeAndNil(fParameters);

  3422.   inherited Destroy;

  3423. end;

  3424. 

  3425. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3426. class function TengShaderPartCall.GetTokenName: String;

  3427. begin

  3428.   result := TOKEN_CALL;

  3429. end;

  3430. 

  3431. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3432. //TengShaderPartProc////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3433. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3434. function TengShaderPartProc.GetHeaderText: String;

  3435. var

  3436.   p: TengShaderPartProcParam;

  3437. begin

  3438.   result := PRECOMPILER_STATEMENT_BEGIN + GetTokenName + ' ''' + fName + '''';

  3439.   for p in fParameters do

  3440.     result := result + ' ''' + p.Typ + ''' ''' + p.Name + '''';

  3441.   result := result + PRECOMPILER_STATEMENT_END;

  3442. end;

  3443. 

  3444. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3445. function TengShaderPartProc.GetText: String;

  3446. begin

  3447.   result := GetHeaderText +

  3448.     inherited GetText +

  3449.     PRECOMPILER_STATEMENT_BEGIN + TOKEN_END + PRECOMPILER_STATEMENT_END;

  3450. end;

  3451. 

  3452. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3453. function TengShaderPartProc.ParseTextIntern(const aParseArgs: TengParseArgs; const aParameters: TengTokenParameterList): String;

  3454. type

  3455.   TParseArgsState = (pasType, pasName);

  3456. var

  3457.   i: Integer;

  3458.   state: TParseArgsState;

  3459.   param: TengShaderPartProcParam;

  3460. begin

  3461.   if (aParameters[0].Name <> GetTokenName) then

  3462.     raise EengInvalidToken.Create(ClassName, aParameters[0].Name, Line, Col, Filename);

  3463.   if (aParameters.Count < 2) then

  3464.     raise EengInvalidParamterCount.Create(GetTokenName, Line, Col, Filename);

  3465. 

  3466.   result := '';

  3467.   fName := aParameters[1].Name;

  3468.   state := pasType;

  3469.   fParameters.Clear;

  3470.   i := 2;

  3471.   while (i < aParameters.Count) do begin

  3472.     case state of

  3473.       pasType: begin

  3474.         if (aParameters[i].Name = TOKEN_INLINE) then begin

  3475.           fIsInline := true;

  3476.         end else begin

  3477.           param.Typ := aParameters[i].Name;

  3478.           state := pasName;

  3479.         end;

  3480.       end;

  3481. 

  3482.       pasName: begin

  3483.         if (aParameters[i].Name = TOKEN_INLINE) then begin

  3484.           raise EengInvalidParamter.Create('expected parameter name, found ' + TOKEN_INLINE, aParameters[i].Line, aParameters[i].Col, Filename);

  3485.         end else begin

  3486.           param.Name := aParameters[i].Name;

  3487.           fParameters.Add(param);

  3488.           state := pasType;

  3489.         end;

  3490.       end;

  3491.     end;

  3492.     inc(i);

  3493.   end;

  3494.   if (state <> pasType) then

  3495.     raise EengInvalidParamterCount.Create(GetTokenName, Line, Col, Filename);

  3496. 

  3497.   inherited ParseTextIntern(aParseArgs, aParameters);

  3498.   result := CheckEndToken(aParseArgs, self);

  3499. end;

  3500. 

  3501. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3502. function TengShaderPartProc.GenHeaderCode: String;

  3503. var

  3504.   p: TengShaderPartProcParam;

  3505. begin

  3506.   result := '';

  3507.   for p in fParameters do begin

  3508.     if (result <> '') then

  3509.       result := result + ', ';

  3510.     result := result + p.Typ + ' ' + p.Name;

  3511.   end;

  3512.   if (result = '') then

  3513.     result := 'void';

  3514.   result := 'void ' + fName + '(' + result + ')';

  3515. end;

  3516. 

  3517. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3518. procedure TengShaderPartProc.GenInlineCode(const aGenCodeArgs: TengGenCodeArgs; const aAddToken: Boolean);

  3519. var

  3520.   old, new: TStringList;

  3521.   p: TengShaderPartProcParam;

  3522.   rx: TRegExpr;

  3523.   s: String;

  3524. begin

  3525.   aGenCodeArgs.PushCode;

  3526.   if aAddToken then

  3527.     aGenCodeArgs.Code.AddToken(ttBegin);

  3528.   try

  3529.     inherited GenCodeIntern(aGenCodeArgs);

  3530. 

  3531.     old := TStringList.Create;

  3532.     new := TStringList.Create;

  3533.     rx := TRegExpr.Create;

  3534.     try

  3535.       //prepare old parameter

  3536.       for p in fParameters do

  3537.         old.Add(p.Name);

  3538. 

  3539.       //prepare new parameter

  3540.       rx.Expression := '[^A-z0-9_]+';

  3541.       for s in aGenCodeArgs.ProcParams do

  3542.         if (rx.Exec(s)) then

  3543.           new.Add('(' + s + ')')

  3544.         else

  3545.           new.Add(s);

  3546. 

  3547.       //replace parameter

  3548.       aGenCodeArgs.Code.ReplaceIdents(old, new);

  3549.     finally

  3550.       FreeAndNil(rx);

  3551.       FreeAndNil(old);

  3552.       FreeAndNil(new);

  3553.     end;

  3554.   finally

  3555.     if aAddToken then

  3556.       aGenCodeArgs.Code.AddToken(ttEnd);

  3557.     aGenCodeArgs.PopCode;

  3558.   end;

  3559. end;

  3560. 

  3561. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3562. procedure TengShaderPartProc.GenCodeIntern(const aGenCodeArgs: TengGenCodeArgs);

  3563. var

  3564.   s, params: String;

  3565. begin

  3566.   // generate inline code

  3567.   if (aGenCodeArgs.Flags * [gcfGenProcCall, gcfGenProcedure] <> []) and

  3568.      ((gcfGenProcInline in aGenCodeArgs.Flags) or fIsInline) then

  3569.   begin

  3570.     GenInlineCode(aGenCodeArgs);

  3571.     if (ClassType = TengShaderPartProc) then

  3572.       aGenCodeArgs.Code.IgnoreNextSemicolon;

  3573. 

  3574.   // generate code

  3575.   end else if (gcfGenProcedure in aGenCodeArgs.Flags) then begin

  3576.     aGenCodeArgs.Code.AddLineEnd;

  3577.     aGenCodeArgs.Code.AddText(GenHeaderCode);

  3578.     aGenCodeArgs.Code.AddLineEnd;

  3579.     aGenCodeArgs.Code.AddText('{');

  3580.     aGenCodeArgs.Code.AddLineEnd;

  3581.     aGenCodeArgs.Code.AddToken(ttBegin);

  3582.     aGenCodeArgs.Code.AddCommandEnd();

  3583.     try

  3584.       inherited GenCodeIntern(aGenCodeArgs);

  3585.     finally

  3586.       aGenCodeArgs.Code.AddText('}');

  3587.       aGenCodeArgs.Code.AddToken(ttEnd);

  3588.       aGenCodeArgs.Code.AddCommandEnd();

  3589.       aGenCodeArgs.Code.AddLineEnd;

  3590.     end;

  3591. 

  3592.   // generate call

  3593.   end else if (gcfGenProcCall in aGenCodeArgs.Flags) then begin

  3594.     params := '';

  3595.     for s in aGenCodeArgs.ProcParams do begin

  3596.       if (params <> '') then

  3597.         params := params + ', ';

  3598.       params := params + s;

  3599.     end;

  3600.     aGenCodeArgs.Code.AddText(fName + '(' + params + ')');

  3601.     aGenCodeArgs.AddProcedure(self);

  3602.   end;

  3603. end;

  3604. 

  3605. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3606. procedure TengShaderPartProc.MapData(const aFlags: TengMapDataFlags; const aTypes: array of CengShaderPart);

  3607. begin

  3608.   if CheckType(self, aTypes) then begin

  3609.     with CheckParentScope(self) do begin

  3610.       MapShaderPart(fName, self); // Procs are named shader parts

  3611.       MapChildScope(self);        // and also Child Scopes

  3612.     end;

  3613.   end;

  3614. end;

  3615. 

  3616. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3617. constructor TengShaderPartProc.Create(const aParent: TengShaderPart);

  3618. begin

  3619.   inherited Create(aParent);

  3620.   fParameters := TengShaderPartProcParamList.Create(true);

  3621. end;

  3622. 

  3623. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3624. destructor TengShaderPartProc.Destroy;

  3625. begin

  3626.   FreeAndNil(fParameters);

  3627.   inherited Destroy;

  3628. end;

  3629. 

  3630. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3631. class function TengShaderPartProc.GetTokenName: String;

  3632. begin

  3633.   result := TOKEN_PROC;

  3634. end;

  3635. 

  3636. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3637. class procedure TengShaderPartProc.CheckToken(const aParseArgs: TengParseArgs; const aParent: TengShaderPart);

  3638. begin

  3639.   if (aParent is TengShaderPartProc) or (aParent.ParentHasType(TengShaderPartProc)) then

  3640.     with aParseArgs do

  3641.       raise EengShaderPart.Create('token ' + GetTokenName + ' is not allowed in procedure or function', Line, Col, aParent.Filename);

  3642. end;

  3643. 

  3644. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3645. //TengShaderPartMain////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3646. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3647. function TengShaderPartMain.GetHeaderText: String;

  3648. begin

  3649.   result := PRECOMPILER_STATEMENT_BEGIN + GetTokenName + PRECOMPILER_STATEMENT_END;

  3650. end;

  3651. 

  3652. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3653. function TengShaderPartMain.ParseTextIntern(const aParseArgs: TengParseArgs; const aParameters: TengTokenParameterList): String;

  3654. var

  3655.   p: TengTokenParameter;

  3656. begin

  3657.   if (aParameters[0].Name <> GetTokenName) then

  3658.     raise EengInvalidToken.Create(ClassName, aParameters[0].Name, Line, Col, Filename);

  3659.   if (aParameters.Count <> 1) then

  3660.     raise EengInvalidParamterCount.Create(GetTokenName, Line, Col, Filename);

  3661. 

  3662.   result   := '';

  3663.   p.Name   := 'main';

  3664.   p.Quoted := false;

  3665.   aParameters.Add(p);

  3666.   inherited ParseTextIntern(aParseArgs, aParameters);

  3667. end;

  3668. 

  3669. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3670. function TengShaderPartMain.GenHeaderCode: String;

  3671. begin

  3672.   result := 'void main(void)';

  3673. end;

  3674. 

  3675. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3676. class function TengShaderPartMain.GetTokenName: String;

  3677. begin

  3678.   result := TOKEN_MAIN;

  3679. end;

  3680. 

  3681. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3682. //TengShaderPartFunc////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3683. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3684. function TengShaderPartFunc.GetHeaderText: String;

  3685. var

  3686.   p: TengShaderPartProcParam;

  3687. begin

  3688.   result := PRECOMPILER_STATEMENT_BEGIN + GetTokenName + ' ''' + fReturnType + ''' ''' + fName + '''';

  3689.   for p in fParameters do

  3690.     result := result + ' ''' + p.Typ + ''' ''' + p.Name + '''';

  3691.   result := result + PRECOMPILER_STATEMENT_END;

  3692. end;

  3693. 

  3694. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3695. function TengShaderPartFunc.ParseTextIntern(const aParseArgs: TengParseArgs; const aParameters: TengTokenParameterList): String;

  3696. begin

  3697.   if (aParameters[0].Name <> GetTokenName) then

  3698.     raise EengInvalidToken.Create(ClassName, aParameters[0].Name, Line, Col, Filename);

  3699.   if (aParameters.Count < 3) then

  3700.     raise EengInvalidParamterCount.Create(GetTokenName, Line, Col, Filename);

  3701. 

  3702.   fReturnType := aParameters[1].Name;

  3703.   aParameters.Delete(1);

  3704.   result := inherited ParseTextIntern(aParseArgs, aParameters);

  3705. end;

  3706. 

  3707. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3708. procedure TengShaderPartFunc.GenInlineCode(const aGenCodeArgs: TengGenCodeArgs; const aAddToken: Boolean);

  3709. var

  3710.   o: Integer;

  3711. begin

  3712.   o := aGenCodeArgs.PushCurrentCommand.GetMinLineOffset;

  3713.   aGenCodeArgs.PushCode;

  3714.   aGenCodeArgs.Code.AddLineEnd;

  3715.   aGenCodeArgs.Code.AddToken(ttBegin, o);

  3716.   try

  3717.     inherited GenInlineCode(aGenCodeArgs, false);

  3718.   finally

  3719.     aGenCodeArgs.PopCurrentCommand(fReturnType, fName);

  3720.     aGenCodeArgs.Code.AddToken(ttEnd);

  3721.     aGenCodeArgs.PopCode;

  3722.   end;

  3723. end;

  3724. 

  3725. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3726. function TengShaderPartFunc.GenHeaderCode: String;

  3727. var

  3728.   p: TengShaderPartProcParam;

  3729. begin

  3730.   result := '';

  3731.   for p in fParameters do begin

  3732.     if (result <> '') then

  3733.       result := result + ', ';

  3734.     result := result + p.Typ + ' ' + p.Name;

  3735.   end;

  3736.   if (result = '') then

  3737.     result := 'void';

  3738.   result := fReturnType + ' ' + fName + '(' + result + ')';

  3739. end;

  3740. 

  3741. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3742. class function TengShaderPartFunc.GetTokenName: String;

  3743. begin

  3744.   result := TOKEN_FUNC;

  3745. end;

  3746. 

  3747. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3748. class procedure TengShaderPartFunc.CheckToken(const aParseArgs: TengParseArgs; const aParent: TengShaderPart);

  3749. begin

  3750.   if (aParent is TengShaderPartFunc) or (aParent.ParentHasType(TengShaderPartFunc)) then

  3751.     with aParseArgs do

  3752.       raise EengShaderPart.Create('token ' + GetTokenName + ' is not allowed in function', Line, Col, aParent.Filename);

  3753. end;

  3754. 

  3755. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3756. //TengShaderPartIf//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3757. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3758. function TengShaderPartIf.ParseExpression(const aParameters: TengTokenParameterList; aIndex: Integer): TengExpressionItem;

  3759. type

  3760.   TExpectedParam = (exVariable, exValue, exGroupBegin, exGroupEnd, exUnaryOperation, exBinaryOperation);

  3761.   TExpectedParams = set of TExpectedParam;

  3762.   TExpressionItemStack = specialize TutlList<TengExpressionItem>;

  3763. 

  3764. var

  3765.   param: TengTokenParameter;

  3766. 

  3767.   function NextParam: Boolean;

  3768.   begin

  3769.     inc(aIndex);

  3770.     result := (aIndex < aParameters.Count);

  3771.     if result then

  3772.       param := aParameters[aIndex];

  3773.   end;

  3774. 

  3775.   function IsUnaryOperation(const aParam: String; out aOperator: TengExpressionUnaryOperator): Boolean;

  3776.   begin

  3777.     result := true;

  3778.     for aOperator in TengExpressionUnaryOperator do

  3779.       if (aParam = EXPRESSION_UNARY_OPERATIONS[aOperator]) then

  3780.         exit;

  3781.     result := false;

  3782.   end;

  3783. 

  3784.   function IsBinaryOperation(const aParam: String; out aOperator: TengExpressionBinaryOperator): Boolean;

  3785.   begin

  3786.     result := true;

  3787.     for aOperator in TengExpressionBinaryOperator do

  3788.       if (aParam = EXPRESSION_BINARY_OPERATIONS[aOperator]) then

  3789.         exit;

  3790.     result := false;

  3791.   end;

  3792. 

  3793.   procedure MergeItems(const aStack: TExpressionItemStack; const aNew: TengExpressionItem);

  3794.   var

  3795.     itm: TengExpressionItem;

  3796.   begin

  3797.     if (aStack.Count > 0) then begin

  3798.       itm := aStack.Last;

  3799.       if (itm is TengExpressionBinaryOperation) then begin

  3800.         if (aNew is TengExpressionBinaryOperation) then begin

  3801. 

  3802.           //both are binary operators, new is weaker then existing

  3803.           if ((aNew as TengExpressionBinaryOperation).BinaryOp < (itm as TengExpressionBinaryOperation).BinaryOp) then begin

  3804.             aStack.PopLast;

  3805.             (aNew as TengExpressionBinaryOperation).First := itm;

  3806.             aStack.PushLast(aNew);

  3807. 

  3808.           //both are binary operators, new is stronger than existing

  3809.           end else begin

  3810.             if not Assigned((itm as TengExpressionBinaryOperation).Second) then

  3811.               raise EengExpression.Create('inconsistent state', param.Line, param.Col, Filename);

  3812.             (aNew as TengExpressionBinaryOperation).First := (itm as TengExpressionBinaryOperation).Second;

  3813.             (itm as TengExpressionBinaryOperation).Second := aNew;

  3814.             aStack.PushLast(aNew);

  3815.           end;

  3816. 

  3817.         //existing is binary operator, new is normal

  3818.         end else begin

  3819.           if Assigned((itm as TengExpressionBinaryOperation).Second) then

  3820.             raise EengExpression.Create('inconsistent state', param.Line, param.Col, Filename);

  3821.           (itm as TengExpressionBinaryOperation).Second := aNew;

  3822.           while (aStack.Count > 1) do

  3823.             aStack.PopLast; //remove all but first

  3824.         end;

  3825.       end else begin

  3826. 

  3827.         //existing is normal item, new is binary operation

  3828.         if (aNew is TengExpressionBinaryOperation) then begin

  3829.           aStack.PopLast;

  3830.           (aNew as TengExpressionBinaryOperation).First := itm;

  3831.           aStack.PushLast(aNew);

  3832. 

  3833.         //existing is unary operation, new is normal item or unary operation

  3834.         end else if (itm is TengExpressionUnaryOperation) then begin

  3835.           if Assigned((itm as TengExpressionUnaryOperation).Child) then

  3836.             raise EengExpression.Create('inconsistent state', param.Line, param.Col, Filename);

  3837.           (itm as TengExpressionUnaryOperation).Child := aNew;

  3838.           if not (aNew is TengExpressionUnaryOperation) then begin

  3839.             while (aStack.Count > 1) do

  3840.               aStack.PopLast; //remove all but first

  3841.           end else

  3842.             aStack.PushLast(aNew);

  3843. 

  3844.         //existing and new are both normal items

  3845.         end else begin

  3846.           raise EengExpression.Create('inconsistent state', param.Line, param.Col, Filename);

  3847.         end;

  3848.       end;

  3849.     end else

  3850.       aStack.PushLast(aNew);

  3851.   end;

  3852. 

  3853.   function BuildTree(const aDepth: Integer = 0): TengExpressionItem;

  3854.   var

  3855.     uOp: TengExpressionUnaryOperator;

  3856.     bOp: TengExpressionBinaryOperator;

  3857.     expected: TExpectedParams;

  3858. 

  3859.     stack: TExpressionItemStack;

  3860.   begin

  3861.     expected := [exVariable, exValue, exGroupBegin, exUnaryOperation];

  3862.     result := nil;

  3863.     stack := TExpressionItemStack.Create(false);

  3864.     try try

  3865.       repeat

  3866.         //GroupBegin

  3867.         if (param.Name = TOKEN_OP_GROUP_BEGIN) then begin

  3868.           if not (exGroupBegin in expected) then

  3869.             raise EengExpression.Create('unexpected ''' + TOKEN_OP_GROUP_BEGIN + '''', param.Line, param.Col, Filename);

  3870.           if not NextParam then

  3871.             raise EengExpression.Create('unexpected end', Line, Col, Filename);

  3872.           MergeItems(stack, TengExpressionGroup.Create(BuildTree(aDepth + 1), param.Line, param.Col, Filename));

  3873.           if (param.Name <> TOKEN_OP_GROUP_END) then

  3874.             raise EengExpression.Create('missing ''' + TOKEN_OP_GROUP_END + '''', param.Line, param.Col, Filename);

  3875.           expected := [exBinaryOperation, exGroupEnd];

  3876. 

  3877.         //GroupEnd

  3878.         end else if (param.Name = TOKEN_OP_GROUP_END) then begin

  3879.           if not (exGroupEnd in expected) or (aDepth = 0) then

  3880.             raise EengExpression.Create('unexpected ''' + TOKEN_OP_GROUP_END + '''', param.Line, param.Col, Filename);

  3881.           exit;

  3882. 

  3883.         //UnaryOperation

  3884.         end else if IsUnaryOperation(param.Name, uOp) then begin

  3885.           if not (exUnaryOperation in expected) then

  3886.             raise EengExpression.Create('unexpected operator: ' + param.Name, param.Line, param.Col, Filename);

  3887.           MergeItems(stack, TengExpressionUnaryOperation.Create(uOp, param.Line, param.Col, Filename));

  3888.           expected := [exVariable];

  3889.           if (uOp <> opDefined) then

  3890.             expected := expected + [exValue, exGroupBegin, exUnaryOperation]

  3891. 

  3892.         //BinaryOperation

  3893.         end else if IsBinaryOperation(param.Name, bOp) then begin

  3894.           if not (exBinaryOperation in expected) then

  3895.             raise EengExpression.Create('unexpected operator: ' + param.Name, param.Line, param.Col, Filename);

  3896.           MergeItems(stack, TengExpressionBinaryOperation.Create(bOp, param.Line, param.Col, Filename));

  3897.           expected := [exVariable, exValue, exGroupBegin, exUnaryOperation];

  3898. 

  3899.         //Value

  3900.         end else if param.Quoted and IsValidIdentifier(param.Name) then begin

  3901.           if not (exValue in expected) then

  3902.             raise EengExpression.Create('unexpected value: ' + param.Name, param.Line, param.Col, Filename);

  3903.           MergeItems(stack, TengExpressionValue.Create(param.Name, param.Line, param.Col, Filename));

  3904.           expected := [exGroupEnd, exBinaryOperation];

  3905. 

  3906.         //Variable

  3907.         end else if IsValidIdentifier(param.Name) then begin

  3908.           if not (exVariable in expected) then

  3909.             raise EengExpression.Create('unexpected variable: ' + param.Name, param.Line, param.Col, Filename);

  3910.           MergeItems(stack, TengExpressionVariable.Create(param.Name, param.Line, param.Col, Filename));

  3911.           expected := [exGroupEnd, exBinaryOperation];

  3912. 

  3913.         //Unknown

  3914.         end else

  3915.           raise EengExpression.Create('invalid parameter: ' + param.Name, param.Line, param.Col, Filename);

  3916.       until not NextParam;

  3917. 

  3918.     except

  3919.       if (stack.Count > 0) then begin

  3920.         stack[0].Free;

  3921.         stack[0] := nil;

  3922.       end;

  3923.       raise;

  3924.     end;

  3925.     finally

  3926.       if (stack.Count > 0) then

  3927.         result := stack[0];

  3928.       FreeAndNil(stack);

  3929.     end;

  3930.   end;

  3931. 

  3932. begin

  3933.   if (aIndex >= aParameters.Count) then

  3934.     raise EengExpression.Create('invalid parameter count in expression', Line, Col, Filename);

  3935.   dec(aIndex);

  3936.   NextParam;

  3937.   result := BuildTree;

  3938. end;

  3939. 

  3940. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3941. function TengShaderPartIf.GetCount: Integer;

  3942. begin

  3943.   result := 1;

  3944.   if Assigned(fElsePart) then

  3945.     inc(result);

  3946. end;

  3947. 

  3948. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3949. function TengShaderPartIf.GetChild(const aIndex: Integer): TengShaderPart;

  3950. begin

  3951.   if (aIndex >= 0) and (aIndex < Count) then begin

  3952.     case aIndex of

  3953.       0: result := fIfPart;

  3954.       1: result := fElsePart;

  3955.     end;

  3956.   end else

  3957.     raise EOutOfRange.Create(aIndex, 0, Count-1);

  3958. end;

  3959. 

  3960. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3961. function TengShaderPartIf.GetText: String;

  3962. begin

  3963.   result := PRECOMPILER_STATEMENT_BEGIN + GetTokenName + ' ' + fExpression.GetText + PRECOMPILER_STATEMENT_END + fIfPart.Text;

  3964.   if Assigned(fElsePart) then

  3965.     result := result + fElsePart.Text;

  3966.   result := result + PRECOMPILER_STATEMENT_BEGIN + TOKEN_END + PRECOMPILER_STATEMENT_END;

  3967. end;

  3968. 

  3969. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3970. function TengShaderPartIf.ParseTextIntern(const aParseArgs: TengParseArgs; const aParameters: TengTokenParameterList): String;

  3971. begin

  3972.   if (aParameters[0].Name <> GetTokenName) then

  3973.     raise EengInvalidToken.Create(ClassName, aParameters[0].Name, Line, Col, Filename);

  3974.   if (aParameters.Count < 2) then

  3975.     raise EengInvalidParamterCount.Create(GetTokenName, Line, Col, Filename);

  3976. 

  3977.   fExpression := ParseExpression(aParameters, 1);

  3978. 

  3979.   fIfPart := TengShaderPartContainer.Create(self);

  3980.   result := fIfPart.ParseText(aParseArgs);

  3981.   result := HandleToken(result, aParseArgs);

  3982. end;

  3983. 

  3984. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3985. function TengShaderPartIf.HandleToken(const aToken: String; const aParseArgs: TengParseArgs): String;

  3986. begin

  3987.   result := aToken;

  3988.   if (result = TengShaderPartElse.GetTokenName) then begin

  3989.     fElsePart := TengShaderPartElse.Create(self);

  3990.     result := fElsePart.ParseText(aParseArgs);

  3991.   end else if (result = TengShaderPartElIf.GetTokenName) then begin

  3992.     fElsePart := TengShaderPartElIf.Create(self);

  3993.     result := fElsePart.ParseText(aParseArgs);

  3994.   end;

  3995.   result := HandleEndToken(result, aParseArgs);

  3996. end;

  3997. 

  3998. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  3999. function TengShaderPartIf.HandleEndToken(const aToken: String; const aParseArgs: TengParseArgs): String;

  4000. begin

  4001.   result := CheckEndToken(aParseArgs, self);

  4002. end;

  4003. 

  4004. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4005. procedure TengShaderPartIf.MapData(const aFlags: TengMapDataFlags; const aTypes: array of CengShaderPart);

  4006. begin

  4007.   inherited MapData(aFlags, aTypes);

  4008. 

  4009.   //map all

  4010.   if (mdfIfAll in aFlags) then begin

  4011.     if Assigned(fIfPart) then

  4012.       fIfPart.MapData(aFlags, aTypes);

  4013.     if Assigned(fElsePart) then

  4014.       fElsePart.MapData(aFlags, aTypes);

  4015. 

  4016.   // evaluete and map suitable

  4017.   end else if (mdfIfEvaluate in aFlags) then begin

  4018.     if fExpression.GetValue(CheckParentScope(self), nil) then begin

  4019.       if Assigned(fIfPart) then

  4020.         fIfPart.MapData(aFlags, aTypes);

  4021.     end else begin

  4022.       if Assigned(fElsePart) then

  4023.         fElsePart.MapData(aFlags, aTypes);

  4024.     end;

  4025.   end;

  4026. end;

  4027. 

  4028. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4029. procedure TengShaderPartIf.GenCodeIntern(const aGenCodeArgs: TengGenCodeArgs);

  4030. var

  4031.   p: TengShaderPart;

  4032.   b: Boolean;

  4033. begin

  4034.   inherited GenCodeIntern(aGenCodeArgs);

  4035. 

  4036.   b := fExpression.GetValue(CheckParentScope(self), aGenCodeArgs);

  4037.   if b then

  4038.     p := fIfPart

  4039.   else

  4040.     p := fElsePart;

  4041. 

  4042.   aGenCodeArgs.Code.AddToken(ttBegin); // IF ...

  4043.   try

  4044.     if Assigned(p) then

  4045.       p.GenCodeIntern(aGenCodeArgs);

  4046.   finally

  4047.     aGenCodeArgs.Code.AddToken(ttEnd); // ... END

  4048.   end;

  4049. end;

  4050. 

  4051. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4052. destructor TengShaderPartIf.Destroy;

  4053. begin

  4054.   FreeAndNil(fExpression);

  4055.   FreeAndNil(fIfPart);

  4056.   FreeAndNil(fElsePart);

  4057.   inherited Destroy;

  4058. end;

  4059. 

  4060. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4061. class function TengShaderPartIf.GetTokenName: String;

  4062. begin

  4063.   result := TOKEN_IF;

  4064. end;

  4065. 

  4066. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4067. //TengShaderPartElIf////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4068. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4069. function TengShaderPartElIf.GetText: String;

  4070. begin

  4071.   result := PRECOMPILER_STATEMENT_BEGIN + GetTokenName + PRECOMPILER_STATEMENT_END + fIfPart.Text;

  4072.   if Assigned(fElsePart) then

  4073.     result := result + fElsePart.Text;

  4074. end;

  4075. 

  4076. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4077. function TengShaderPartElIf.HandleEndToken(const aToken: String; const aParseArgs: TengParseArgs): String;

  4078. begin

  4079.   result := aToken;

  4080.   if (result <> TOKEN_END) then

  4081.     raise EengInvalidToken.Create(ClassName, result, aParseArgs.Line, aParseArgs.Col, Filename);

  4082. end;

  4083. 

  4084. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4085. class function TengShaderPartElIf.GetTokenName: String;

  4086. begin

  4087.   result := TOKEN_ELIF;

  4088. end;

  4089. 

  4090. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4091. //TengShaderPartElse////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4092. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4093. function TengShaderPartElse.GetText: String;

  4094. begin

  4095.   result := PRECOMPILER_STATEMENT_BEGIN + GetTokenName + PRECOMPILER_STATEMENT_END + inherited GetText;

  4096. end;

  4097. 

  4098. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4099. class function TengShaderPartElse.GetTokenName: String;

  4100. begin

  4101.   result := TOKEN_ELSE;

  4102. end;

  4103. 

  4104. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4105. //TengShaderPartEcho////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4106. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4107. function TengShaderPartEcho.GetText: String;

  4108. begin

  4109.   result := PRECOMPILER_STATEMENT_BEGIN + GetTokenName + ' ' + fName + PRECOMPILER_STATEMENT_END;

  4110. end;

  4111. 

  4112. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4113. function TengShaderPartEcho.ParseTextIntern(const aParseArgs: TengParseArgs; const aParameters: TengTokenParameterList): String;

  4114. begin

  4115.   if (aParameters[0].Name <> GetTokenName) then

  4116.     raise EengInvalidToken.Create(ClassName, aParameters[0].Name, Line, Col, Filename);

  4117.   if (aParameters.Count <> 2) then

  4118.     raise EengInvalidParamterCount.Create(GetTokenName, Line, Col, Filename);

  4119.   result := '';

  4120.   fName  := aParameters[1].Name;

  4121.   if not IsValidIdentifier(fName) then

  4122.     raise EengShaderPart.Create('invalid name: ' + fName, Line, Col, GetFilename);

  4123. end;

  4124. 

  4125. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4126. procedure TengShaderPartEcho.GenCodeIntern(const aGenCodeArgs: TengGenCodeArgs);

  4127. var

  4128.   p: TengShaderPart;

  4129. begin

  4130.   CheckParentScope(self).FindMappedPart(p, fName, GEN_CODE_FIND_FLAGS);

  4131. 

  4132.   if not Assigned(p) then

  4133.     raise EengUnknownIdentifier.Create(fName, Line, Col, Filename);

  4134.   if not (p is TengShaderPartKeyValuePair) then

  4135.     raise EengInvalidParamter.Create('Expected ' + TengShaderPartDefine.GetTokenName + ' or ' + TengShaderPartProperty.GetTokenName, Line, Col, Filename);

  4136. 

  4137.   aGenCodeArgs.Code.AddText((p as TengShaderPartKeyValuePair).Value);

  4138.   inherited GenCodeIntern(aGenCodeArgs);

  4139. end;

  4140. 

  4141. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4142. class function TengShaderPartEcho.GetTokenName: String;

  4143. begin

  4144.   result := TOKEN_ECHO;

  4145. end;

  4146. 

  4147. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4148. //TengShaderPartMessage/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4149. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4150. function TengShaderPartMessage.GetText: String;

  4151. begin

  4152.   result := PRECOMPILER_STATEMENT_BEGIN + GetTokenName + ' ''' + fMessage + '''' + PRECOMPILER_STATEMENT_END;

  4153. end;

  4154. 

  4155. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4156. function TengShaderPartMessage.ParseTextIntern(const aParseArgs: TengParseArgs; const aParameters: TengTokenParameterList): String;

  4157. begin

  4158.   if (aParameters[0].Name <> GetTokenName) then

  4159.     raise EengInvalidToken.Create(ClassName, aParameters[0].Name, Line, Col, Filename);

  4160.   if (aParameters.Count <> 2) then

  4161.     raise EengInvalidParamterCount.Create(GetTokenName, Line, Col, Filename);

  4162.   result := '';

  4163.   fMessage := aParameters[1].Name;

  4164. end;

  4165. 

  4166. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4167. class function TengShaderPartMessage.GetTokenName: String;

  4168. begin

  4169.   result := TOKEN_MESSAGE;

  4170. end;

  4171. 

  4172. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4173. //TengShaderPartWarning/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4174. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4175. class function TengShaderPartWarning.GetTokenName: String;

  4176. begin

  4177.   result := TOKEN_WARNING;

  4178. end;

  4179. 

  4180. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4181. //TengShaderPartError///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4182. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4183. procedure TengShaderPartError.GenCodeIntern(const aGenCodeArgs: TengGenCodeArgs);

  4184. begin

  4185.   inherited GenCodeIntern(aGenCodeArgs);

  4186.   raise EengShaderPart.Create(fMessage, Line, Col, Filename);

  4187. end;

  4188. 

  4189. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4190. class function TengShaderPartError.GetTokenName: String;

  4191. begin

  4192.   result := TOKEN_ERROR;

  4193. end;

  4194. 

  4195. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4196. //TengShaderPartCode////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4197. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4198. function TengShaderPartCode.GetText: String;

  4199. begin

  4200.   result := fCode;

  4201. end;

  4202. 

  4203. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4204. function TengShaderPartCode.ParseTextIntern(const aParseArgs: TengParseArgs; const aParameters: TengTokenParameterList): String;

  4205. 

  4206.   function CheckToken: Boolean;

  4207.   begin

  4208.     with aParseArgs do

  4209.       result :=

  4210.         (CurrentChar = PRECOMPILER_STATEMENT_BEGIN) and

  4211.         (Col < LineLength) and

  4212.         (CurrentLine[Col + 1] in [TOKEN_IDENTIFIER, COMMENT_IDENTIFIER]);

  4213.   end;

  4214. 

  4215.   function FindToken: String;

  4216.   var

  4217.     c: Integer;

  4218.   begin

  4219.     with aParseArgs do

  4220.       if (CurrentChar = TOKEN_COMMAND_END) then

  4221.         result := TOKEN_COMMAND_END

  4222.       else if (Col < LineLength) then begin

  4223.         c := Col + 1;

  4224.         case CurrentLine[c] of

  4225.           TOKEN_IDENTIFIER: begin

  4226.             result := TOKEN_IDENTIFIER;

  4227.             inc(c);

  4228.             while (c <= LineLength) and (CurrentLine[c] in VALID_TOKEN_CHARS) do begin

  4229.               result := result + CurrentLine[c];

  4230.               inc(c);

  4231.             end;

  4232.             result := Trim(result);

  4233.             if (result = TOKEN_IDENTIFIER) then

  4234.               raise EengShaderPart.Create('empty token', Line, Col, Filename);

  4235.           end;

  4236. 

  4237.           //skip comment

  4238.           COMMENT_IDENTIFIER:

  4239.             result := COMMENT_IDENTIFIER;

  4240.         end;

  4241.       end else begin

  4242.         result := '';

  4243.         aParseArgs.IncCol;

  4244.       end;

  4245.   end;

  4246. 

  4247. begin

  4248.   fCode := '';

  4249.   while not aParseArgs.EndOfLine do begin

  4250.     if CheckToken then begin

  4251.       result := FindToken;

  4252.       if (result <> '') then

  4253.         exit;

  4254.     end else if (aParseArgs.CurrentChar in COMMAND_END_TOKENS) then begin

  4255.       result := aParseArgs.CurrentChar;

  4256.       exit;

  4257.     end else begin

  4258.       fCode := fCode + aParseArgs.CurrentChar;

  4259.       aParseArgs.IncCol;

  4260.     end;

  4261.   end;

  4262.   result := TOKEN_LINE_BREAK;

  4263. end;

  4264. 

  4265. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4266. procedure TengShaderPartCode.GenCodeIntern(const aGenCodeArgs: TengGenCodeArgs);

  4267. begin

  4268.   inherited GenCodeIntern(aGenCodeArgs);

  4269.   aGenCodeArgs.Code.AddText(fCode);

  4270. end;

  4271. 

  4272. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4273. //TengShaderPartLineBreak///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4274. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4275. function TengShaderPartLineBreak.GetText: String;

  4276. begin

  4277.   result := GetTokenName;

  4278. end;

  4279. 

  4280. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4281. function TengShaderPartLineBreak.ParseTextIntern(const aParseArgs: TengParseArgs; const aParameters: TengTokenParameterList): String;

  4282. begin

  4283.   if not aParseArgs.EndOfLine then

  4284.     raise EengShaderPart.Create('TengShaderPartLineBreak but not end of line', aParseArgs.Line, aParseArgs.Col, Filename);

  4285.   aParseArgs.IncLine;

  4286.   result := '';

  4287. end;

  4288. 

  4289. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4290. procedure TengShaderPartLineBreak.GenCodeIntern(const aGenCodeArgs: TengGenCodeArgs);

  4291. begin

  4292.   inherited GenCodeIntern(aGenCodeArgs);

  4293.   aGenCodeArgs.Code.AddLineEnd;

  4294. end;

  4295. 

  4296. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4297. class function TengShaderPartLineBreak.GetTokenName: String;

  4298. begin

  4299.   result := TOKEN_LINE_BREAK;

  4300. end;

  4301. 

  4302. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4303. //TengShaderPartCommandEnd//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4304. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4305. function TengShaderPartCommandEnd.GetText: String;

  4306. begin

  4307.   result := fToken;

  4308. end;

  4309. 

  4310. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4311. function TengShaderPartCommandEnd.ParseTextIntern(const aParseArgs: TengParseArgs; const aParameters: TengTokenParameterList): String;

  4312. begin

  4313.   result := '';

  4314.   fToken := aParseArgs.CurrentChar;

  4315.   aParseArgs.IncCol;

  4316. end;

  4317. 

  4318. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4319. procedure TengShaderPartCommandEnd.GenCodeIntern(const aGenCodeArgs: TengGenCodeArgs);

  4320. begin

  4321.   inherited GenCodeIntern(aGenCodeArgs);

  4322.   aGenCodeArgs.Code.AddCommandEnd(fToken);

  4323. end;

  4324. 

  4325. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4326. class function TengShaderPartCommandEnd.CheckToken(const aToken: String): Boolean;

  4327. var

  4328.   s: String;

  4329. begin

  4330.   result := true;

  4331.   for s in COMMAND_END_TOKENS do

  4332.     if (s = aToken) then

  4333.       exit;

  4334.   result := false;

  4335. end;

  4336. 

  4337. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4338. //TengShaderCode////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4339. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4340. function TengShaderCode.GetMeta(const aIndex: Integer): IengMetaData;

  4341. begin

  4342.   result := fMetaList[aIndex];

  4343. end;

  4344. 

  4345. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4346. function TengShaderCode.GetMetaCount: Integer;

  4347. begin

  4348.   result := fMetaList.Count;

  4349. end;

  4350. 

  4351. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4352. constructor TengShaderCode.Create;

  4353. begin

  4354.   inherited Create;

  4355.   fMetaList := TMetaList.Create;

  4356. end;

  4357. 

  4358. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4359. destructor TengShaderCode.Destroy;

  4360. begin

  4361.   FreeAndNil(fMetaList);

  4362.   inherited Destroy;

  4363. end;

  4364. 

  4365. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4366. //TengShaderCodeIntern//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4367. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4368. procedure TengShaderCodeIntern.AddMeta(const aMeta: IengMetaData);

  4369. begin

  4370.   fMetaList.Add(aMeta);

  4371. end;

  4372. 

  4373. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4374. //TengParseArgs/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4375. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4376. procedure TengParseArgs.SetCol(const aValue: Integer);

  4377. begin

  4378.   fCol := aValue;

  4379.   if not EndOfLine then

  4380.     fCurrentChar := fCurrentLine[fCol]

  4381.   else

  4382.     fCurrentChar := #0;

  4383. end;

  4384. 

  4385. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4386. procedure TengParseArgs.SetLine(const aValue: Integer);

  4387. begin

  4388.   fLine := aValue;

  4389.   if not EndOfFile then begin

  4390.     fCurrentLine := fCode[fLine];

  4391.     fLineLength  := Length(fCurrentLine);

  4392.   end else begin

  4393.     fCurrentLine := '';

  4394.     fLineLength  := -1;

  4395.   end;

  4396.   Col := 1;

  4397. end;

  4398. 

  4399. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4400. function TengParseArgs.GetEndOfFile: Boolean;

  4401. begin

  4402.   result := (fLine >= fLineCount);

  4403. end;

  4404. 

  4405. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4406. function TengParseArgs.GetEndOfLine: Boolean;

  4407. begin

  4408.   result := (fCol > fLineLength);

  4409. end;

  4410. 

  4411. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4412. function TengParseArgs.GetCode: TStrings;

  4413. begin

  4414.   result := fCode;

  4415. end;

  4416. 

  4417. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4418. procedure TengParseArgs.IncCol;

  4419. begin

  4420.   Col := Col + 1;

  4421. end;

  4422. 

  4423. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4424. procedure TengParseArgs.IncLine;

  4425. begin

  4426.   Line := Line + 1;

  4427. end;

  4428. 

  4429. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4430. function TengParseArgs.ParseParameters(const aParameters: TengTokenParameterList): Boolean;

  4431. type

  4432.   TCharType = (ctUnknown, ctValidTokenChar, ctInvalidTokenChar, ctWhiteSpace);

  4433. var

  4434.   s: String;

  4435.   charType: TCharType;

  4436.   pLine, pCol: Integer;

  4437.   isComment: Boolean;

  4438. 

  4439.   procedure AddPart(const aTrimAndCheck: Boolean = true);

  4440.   var

  4441.     len: Integer;

  4442.     p: TengTokenParameter;

  4443.   begin

  4444.     if aTrimAndCheck then

  4445.       s := Trim(s);

  4446.     if not aTrimAndCheck or (s <> '')then begin

  4447.       len := Length(s);

  4448.       if aTrimAndCheck and ((s[1] = PRECOMPILER_QUOTE_CHAR) or (s[len] = PRECOMPILER_QUOTE_CHAR)) then begin

  4449.         if not (s[1] = PRECOMPILER_QUOTE_CHAR) then

  4450.           raise EengShaderPart.Create('missing leading quote char', Line, Col, fOwner.Filename);

  4451.         if not (s[len] = PRECOMPILER_QUOTE_CHAR) then

  4452.           raise EengShaderPart.Create('missing trailing quote char', Line, Col, fOwner.Filename);

  4453.         delete(s, len, 1);

  4454.         delete(s, 1, 1);

  4455.         p.Quoted := true;

  4456.       end else

  4457.         p.Quoted := false;

  4458.       p.Name := s;

  4459.       p.Line := pLine;

  4460.       p.Col  := pCol;

  4461.       aParameters.Add(p);

  4462.     end;

  4463.     s := '';

  4464.     pLine := Line;

  4465.     pCol  := Col;

  4466.     charType := ctUnknown;

  4467.   end;

  4468. 

  4469. var

  4470.   quote, inToken, commentTokenAdded: Boolean;

  4471.   lOld, cOld: Integer;

  4472. begin

  4473.   result := false;

  4474.   aParameters.Clear;

  4475.   if (CurrentChar <> PRECOMPILER_STATEMENT_BEGIN) or

  4476.    (Col + 1 > LineLength) or

  4477.    ( (CurrentLine[Col + 1] <> TOKEN_IDENTIFIER) and

  4478.      (CurrentLine[Col + 1] <> COMMENT_IDENTIFIER)) then

  4479.      exit;

  4480. 

  4481.   result            := true;

  4482.   quote             := false;

  4483.   inToken           := false;

  4484.   isComment         := CurrentLine[Col + 1] = COMMENT_IDENTIFIER;

  4485.   commentTokenAdded := false;

  4486.   s                 := '';

  4487.   charType          := ctUnknown;

  4488.   lOld              := Line;

  4489.   cOld              := Col;

  4490.   AddPart; //initialize

  4491. 

  4492.   while not EndOfFile do begin

  4493.     while not EndOfLine do begin

  4494.       case CurrentChar of

  4495.         PRECOMPILER_STATEMENT_BEGIN: begin

  4496.           if quote then

  4497.             s := s + PRECOMPILER_STATEMENT_BEGIN

  4498.           else if not inToken then

  4499.             inToken := true

  4500.           else

  4501.             EengShaderPart.Create('invalid char in token');

  4502.         end;

  4503. 

  4504.         PRECOMPILER_STATEMENT_END: begin

  4505.           if not quote then begin

  4506.             AddPart(not isComment);

  4507.             IncCol;

  4508.             if (aParameters.Count <= 0) or (aParameters[0].Name = TOKEN_IDENTIFIER) then

  4509.               raise EengEmptyToken.Create(lOld, cOld, fOwner.Filename);

  4510.             exit;

  4511.           end else

  4512.             s := s + CurrentChar;

  4513.         end;

  4514. 

  4515.         PRECOMPILER_QUOTE_CHAR: begin

  4516.           if not quote and not isComment then

  4517.             AddPart;

  4518.           s := s + PRECOMPILER_QUOTE_CHAR;

  4519.           quote := not quote;

  4520.           if not quote and not isComment then

  4521.             AddPart;

  4522.         end;

  4523. 

  4524.         COMMENT_IDENTIFIER: begin

  4525.           s := s + COMMENT_IDENTIFIER;

  4526.           if isComment and not commentTokenAdded then begin

  4527.             commentTokenAdded := true;

  4528.             AddPart(false);

  4529.           end;

  4530.         end;

  4531.       else

  4532.         if not quote and not isComment then begin

  4533.           if (CurrentChar in TOKEN_SPLIT_CHARS) then begin

  4534.             AddPart;

  4535.           end else if (CurrentChar in VALID_TOKEN_CHARS) then begin

  4536.             if (charType <> ctValidTokenChar) then

  4537.               AddPart;

  4538.             charType := ctValidTokenChar;

  4539.           end else begin

  4540.             if (charType <> ctInvalidTokenChar) then

  4541.               AddPart;

  4542.             charType := ctInvalidTokenChar;

  4543.           end;

  4544.         end;

  4545.         s := s + CurrentChar;

  4546.       end;

  4547.       IncCol;

  4548.     end;

  4549.     s := s + sLineBreak;

  4550.     IncLine;

  4551.   end;

  4552.   raise EengShaderPart.Create('incomplete token', lOld, cOld, fOwner.Filename);

  4553. end;

  4554. 

  4555. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4556. procedure TengParseArgs.LoadCode(const aStream: TStream);

  4557. begin

  4558.   fCode.LoadFromStream(aStream);

  4559.   fLineCount := fCode.Count;

  4560.   Line := 0;

  4561. end;

  4562. 

  4563. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4564. constructor TengParseArgs.Create(const aOwner: TengShaderFile);

  4565. begin

  4566.   inherited Create;

  4567.   fOwner     := aOwner;

  4568.   fCode      := TStringList.Create;

  4569.   fLineCount := fCode.Count;

  4570.   Line       := 0;

  4571. end;

  4572. 

  4573. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4574. destructor TengParseArgs.Destroy;

  4575. begin

  4576.   FreeAndNil(fCode);

  4577.   inherited Destroy;

  4578. end;

  4579. 

  4580. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4581. //TengGenCodeArgs.TCodeItem/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4582. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4583. function TengGenCodeArgs.TCodeItem.GetText: String;

  4584. begin

  4585.   result := '';

  4586. end;

  4587. 

  4588. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4589. function TengGenCodeArgs.TCodeItem.IsEmpty: Boolean;

  4590. begin

  4591.   result := (Trim(GetText) = '');

  4592. end;

  4593. 

  4594. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4595. //TengGenCodeArgs.TCodeItemStart////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4596. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4597. function TengGenCodeArgs.TCodeItemStart.GetText: String;

  4598. begin

  4599.   result := '';

  4600. end;

  4601. 

  4602. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4603. //TengGenCodeArgs.TCodeItemText/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4604. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4605. function TengGenCodeArgs.TCodeItemText.GetText: String;

  4606. begin

  4607.   result := Text;

  4608. end;

  4609. 

  4610. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4611. constructor TengGenCodeArgs.TCodeItemText.Create(const aText: String);

  4612. begin

  4613.   inherited Create;

  4614.   Text := aText;

  4615. end;

  4616. 

  4617. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4618. //TCodeItemLineBreak.TCodeItemLineBreak/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4619. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4620. function TengGenCodeArgs.TCodeItemLineBreak.GetText: String;

  4621. begin

  4622.   result := sLineBreak;

  4623. end;

  4624. 

  4625. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4626. //TengGenCodeArgs.TCodeItemCommandEnd///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4627. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4628. function TengGenCodeArgs.TCodeItemCommandEnd.GetText: String;

  4629. begin

  4630.   result := Token;

  4631. end;

  4632. 

  4633. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4634. constructor TengGenCodeArgs.TCodeItemCommandEnd.Create(const aToken: String);

  4635. begin

  4636.   inherited Create;

  4637.   Token := aToken;

  4638. end;

  4639. 

  4640. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4641. //TengGenCodeArgs.TCodeItemToken////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4642. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4643. constructor TengGenCodeArgs.TCodeItemToken.Create(const aTokenType: TTokenType; const aLevel: Integer);

  4644. begin

  4645.   inherited Create;

  4646.   TokenType := aTokenType;

  4647.   Level := aLevel;

  4648. end;

  4649. 

  4650. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4651. //TengGenCodeArgs.TCodeStackItem////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4652. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4653. function TengGenCodeArgs.TCodeStackItem.GetEmpty: Boolean;

  4654. begin

  4655.   result := (fItems.Count = 0) or

  4656.             ((fItems.Count = 1) and (fItems[0] is TCodeItemStart));

  4657. end;

  4658. 

  4659. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4660. {$IFDEF DEBUG}

  4661. function TengGenCodeArgs.TCodeStackItem.GetDebugText: String;

  4662. var

  4663.   ci: TCodeItem;

  4664. begin

  4665.   result := '';

  4666.   for ci in fItems do

  4667.     if (ci is TCodeItemToken) then with (ci as TCodeItemToken) do begin

  4668.       case TokenType of

  4669.         ttBegin:    result := result + '$B';

  4670.         ttEnd:      result := result + '$E';

  4671.         ttSingle:   result := result + '$S';

  4672.       end;

  4673.       if (Level >= 0) then

  4674.         result := result + IntToStr(Level);

  4675.     end else if (ci is TCodeItemCommandEnd) then with (ci as TCodeItemCommandEnd) do begin

  4676.       result := result + '$C("' + ci.GetText + '")';

  4677.     end else

  4678.       result := result + ci.GetText;

  4679. end;

  4680. {$ENDIF}

  4681. 

  4682. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4683. function TengGenCodeArgs.TCodeStackItem.GetText: String;

  4684. type

  4685.   TGenFlag = (

  4686.     gfToken,          // current line has a token in it

  4687.     gfTokenSingle,    // current line has a single token in it

  4688.     gfPrevEmpty,      // previouse line was empty

  4689.     gfAddToPrevLine,  // trim left current line and add to prev line if not empty

  4690.     gfAddNextLine     // trim left next line and add to current line if not empty

  4691.   );

  4692.   TGenFlags = set of TGenFlag;

  4693. var

  4694.   i: Integer;

  4695.   line: String;

  4696.   sl: TStringList;

  4697.   f: TGenFlags;

  4698. 

  4699.   function GetStrOffset(const aStr: String): Integer;

  4700.   var

  4701.     len: Integer;

  4702.   begin

  4703.     result := 0;

  4704.     len := Length(aStr);

  4705.     while (result < len) and (aStr[result+1] in WHITESPACES) do

  4706.       inc(result);

  4707.   end;

  4708. 

  4709.   function GetOffset(const aItem: TCodeItemToken): Integer;

  4710.   begin

  4711.     result := aItem.Level;

  4712.     if (result < 0) then

  4713.       result := GetStrOffset(line);

  4714.   end;

  4715. 

  4716.   function GetMinOffset(aStartIndex: Integer): Integer;

  4717.   begin

  4718.     if (Trim(line) <> '') then

  4719.       result := GetStrOffset(line)

  4720.     else

  4721.       result := High(Integer);

  4722.     while (aStartIndex < sl.Count) do begin

  4723.       if (Trim(sl[aStartIndex]) <> '') then

  4724.         result := Min(result, GetStrOffset(sl[aStartIndex]));

  4725.       inc(aStartIndex);

  4726.     end;

  4727.     if (result >= High(Integer)) then

  4728.       result := -1;

  4729.   end;

  4730. 

  4731.   function TrimLeftLen(const aStr: String; aLen: Integer): String;

  4732.   var

  4733.     i, len: Integer;

  4734.   begin

  4735.     i   := 1;

  4736.     len := Length(aStr);

  4737.     while (i <= len) and (aStr[i] in WHITESPACES) and (aLen > 0) do begin

  4738.       inc(i);

  4739.       dec(aLen);

  4740.     end;

  4741.     result := Copy(aStr, i, len - i + 1);

  4742.   end;

  4743. 

  4744.   function PrepareStr(const aStr: String; const aOffset: Integer): String;

  4745.   begin

  4746.     if (aOffset < 0) then

  4747.       result := StringOfChar(' ', -aOffset) + aStr

  4748.     else

  4749.       result := TrimLeftLen(aStr, aOffset);

  4750.   end;

  4751. 

  4752.   procedure IndentBlock(aStartIndex: Integer; const aOffset: Integer);

  4753.   var

  4754.     o: Integer;

  4755.   begin

  4756.     o := GetMinOffset(aStartIndex);

  4757.     if (o < 0) then

  4758.       exit;

  4759.     o := o - aOffset;

  4760.     if (o = 0) then

  4761.       exit;

  4762.     while (aStartIndex < sl.Count) do begin

  4763.       sl[aStartIndex] := PrepareStr(sl[aStartIndex], o);

  4764.       inc(aStartIndex);

  4765.     end;

  4766.     line := PrepareStr(line, o);

  4767.   end;

  4768. 

  4769.   procedure ProgressBlock(const aOffset: Integer);

  4770.   var

  4771.     item: TCodeItem;

  4772.     s: String;

  4773.     lineIndex: Integer;

  4774.   begin

  4775.     lineIndex := sl.Count; //start at next line

  4776.     while (i < fItems.Count) do begin

  4777.       item := fItems[i];

  4778.       inc(i);

  4779. 

  4780.       // LineBreak

  4781.       if (item is TCodeItemLineBreak) then begin

  4782.         if (Trim(line) = '') then begin

  4783.           if (f * [gfToken, gfPrevEmpty] = []) then begin

  4784.             sl.Add(line);

  4785.             Include(f, gfPrevEmpty);

  4786.           end;

  4787.           if not (gfTokenSingle in f) then

  4788.             Exclude(f, gfAddToPrevLine);

  4789.         end else begin

  4790.           if not (gfAddToPrevLine in f) then begin

  4791.             sl.Add(line);

  4792.             Exclude(f, gfPrevEmpty);

  4793.           end else if (sl.Count > 0) then

  4794.             sl[sl.Count-1] := sl[sl.Count-1] + TrimLeft(line)

  4795.           else

  4796.             sl.Add(line);

  4797.           Exclude(f, gfAddToPrevLine);

  4798.         end;

  4799.         Exclude(f, gfToken);

  4800.         Exclude(f, gfTokenSingle);

  4801.         if (gfAddNextLine in f) then

  4802.           f := f + [gfAddToPrevLine] - [gfAddNextLine];

  4803.         line := '';

  4804. 

  4805.       // Token

  4806.       end else if (item is TCodeItemToken) then with (item as TCodeItemToken) do begin

  4807.         Include(f, gfToken);

  4808.         case TokenType of

  4809.           ttBegin: begin

  4810.             if (Trim(line) <> '') then

  4811.               Include(f, gfAddNextLine);

  4812.             Include(f, gfPrevEmpty);

  4813.             ProgressBlock(GetOffset(item as TCodeItemToken));

  4814.           end;

  4815. 

  4816.           ttEnd: begin

  4817.             if (Trim(line) = '') then

  4818.               Include(f, gfAddToPrevLine);

  4819.             IndentBlock(lineIndex, aOffset);

  4820.             exit;

  4821.           end;

  4822. 

  4823.           ttSingle: begin

  4824.             Include(f, gfTokenSingle);

  4825.           end;

  4826.         end;

  4827. 

  4828.       // other

  4829.       end else begin

  4830.         s := item.GetText;;

  4831.         if (gfAddNextLine in f) and (Trim(s) <> '') then

  4832.           Exclude(f, gfAddNextLine);

  4833.         line := line + s;

  4834.       end;

  4835.     end;

  4836.   end;

  4837. 

  4838.   procedure TrimList;

  4839.   begin

  4840.     while (sl.Count > 0) and (Trim(sl[0]) = '') do

  4841.       sl.Delete(0);

  4842.     while (sl.Count > 0) and (Trim(sl[sl.Count-1]) = '') do

  4843.       sl.Delete(sl.Count-1);

  4844.   end;

  4845. 

  4846. begin

  4847.   sl := TStringList.Create;

  4848.   try

  4849.     {$IFDEF DEBUG}

  4850.     sl.Text := GetDebugText;

  4851.     sl.SaveToFile('dbg');

  4852.     sl.Clear;

  4853.     {$ENDIF}

  4854. 

  4855.     i := 0;

  4856.     line := '';

  4857.     f := [gfPrevEmpty];

  4858.     ProgressBlock(0);

  4859.     TrimList;

  4860.     result := sl.Text;

  4861.   finally

  4862.     FreeAndNil(sl);

  4863.   end;

  4864. end;

  4865. 

  4866. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4867. procedure TengGenCodeArgs.TCodeStackItem.SplitCurrentCommand(const aItem: TCodeStackItem);

  4868. var

  4869.   HasCode: Boolean;

  4870.   ci: TCodeItem;

  4871. 

  4872.   function IsEndToken(const ci: TCodeItem): Boolean;

  4873.   begin

  4874.     result := (ci is TCodeItemToken) and ((ci as TCodeItemToken).TokenType = ttEnd)

  4875.   end;

  4876. 

  4877. begin

  4878.   fItems.OwnsObjects := false;

  4879.   aItem.fItems.OwnsObjects := false;

  4880.   try

  4881.     //move all items before TCodeItemCommandEnd to aItem

  4882.     while (fItems.Count > 1) and not (fItems[fItems.Count-1] is TCodeItemCommandEnd) do begin

  4883.       ci := fItems.PopLast;

  4884.       if (trim(ci.GetText) <> '') then

  4885.         HasCode := true;

  4886.       if IsEndToken(ci) then

  4887.         HasCode := false;

  4888.       aItem.fItems.Insert(1, ci);

  4889.     end;

  4890. 

  4891.     // if ther is no code between last CommandEnd and Last End-Token, move back to last end Token

  4892.     if not HasCode then begin

  4893.       while not IsEndToken(aItem.fItems[1]) do begin

  4894.         fItems.PushLast(aItem.fItems[1]);

  4895.         aItem.fItems.Delete(1);

  4896.       end;

  4897.       fItems.PushLast(aItem.fItems[1]);

  4898.       aItem.fItems.Delete(1);

  4899.     end;

  4900.   finally

  4901.     aItem.fItems.OwnsObjects := true;

  4902.     fItems.OwnsObjects := true;

  4903.   end;

  4904. end;

  4905. 

  4906. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4907. function TengGenCodeArgs.TCodeStackItem.Merge(const aItem: TCodeStackItem; aIndex: Integer): Integer;

  4908. begin

  4909.   if (aIndex <= 0) then

  4910.     aIndex := 1; // do not go below start item

  4911.   result := aIndex + aItem.fItems.Count - 1;

  4912.   aItem.fItems.OwnsObjects := false;

  4913.   try

  4914.     while (aItem.fItems.Count > 1) do begin

  4915.       fItems.Insert(aIndex, aItem.fItems[aItem.fItems.Count-1]);

  4916.       aItem.fItems.Delete(aItem.fItems.Count-1);

  4917.     end;

  4918.   finally

  4919.     aItem.fItems.OwnsObjects := true;

  4920.   end;

  4921. end;

  4922. 

  4923. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4924. procedure TengGenCodeArgs.TCodeStackItem.AddText(const aText: String);

  4925. begin

  4926.   fItems.Add(TCodeItemText.Create(aText));

  4927.   if (Trim(aText) <> '') then

  4928.     Exclude(fFlags, cfIgnoreNextSemicolon);

  4929. end;

  4930. 

  4931. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4932. procedure TengGenCodeArgs.TCodeStackItem.AddCommandEnd(const aToken: String);

  4933. begin

  4934.   if (cfIgnoreNextSemicolon in fFlags) then begin

  4935.     if (aToken <> '') then

  4936.       Exclude(fFlags, cfIgnoreNextSemicolon);

  4937.     if (aToken = ';') then

  4938.       exit;

  4939.   end;

  4940.   fItems.Add(TCodeItemCommandEnd.Create(aToken));

  4941. end;

  4942. 

  4943. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4944. procedure TengGenCodeArgs.TCodeStackItem.AddToken(const aTokenType: TTokenType; const aLevel: Integer);

  4945. begin

  4946.   fItems.Add(TCodeItemToken.Create(aTokenType, aLevel));

  4947. end;

  4948. 

  4949. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4950. procedure TengGenCodeArgs.TCodeStackItem.AddLineEnd;

  4951. begin

  4952.   fItems.Add(TCodeItemLineBreak.Create);

  4953. end;

  4954. 

  4955. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4956. function TengGenCodeArgs.TCodeStackItem.GetMinLineOffset: Integer;

  4957. 

  4958.   procedure CalcOffset(const aLine: String);

  4959.   var i, len: Integer;

  4960.   begin

  4961.     if (Trim(aLine) = '') then

  4962.       exit;

  4963.     len := Length(aLine);

  4964.     i := 1;

  4965.     while (i <= len) and (aLine[i] in WHITESPACES) do

  4966.       inc(i);

  4967.     if (i < result) then

  4968.       result := i-1;

  4969.   end;

  4970. 

  4971. var

  4972.   item: TCodeItem;

  4973.   line: String;

  4974. begin

  4975.   result := High(Integer);

  4976.   line := '';

  4977.   for item in fItems do begin

  4978.     if (item is TCodeItemLineBreak) then begin

  4979.       CalcOffset(line);

  4980.       line := '';

  4981.     end else

  4982.       line := line + item.GetText;

  4983.   end;

  4984.   CalcOffset(line);

  4985.   if (result = High(Integer)) then

  4986.     result := -1;

  4987. end;

  4988. 

  4989. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4990. procedure TengGenCodeArgs.TCodeStackItem.IgnoreNextSemicolon;

  4991. begin

  4992.   Include(fFlags, cfIgnoreNextSemicolon);

  4993. end;

  4994. 

  4995. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  4996. procedure TengGenCodeArgs.TCodeStackItem.ReplaceIdents(const aOld, aNew: TStrings);

  4997. var

  4998.   rx: TRegExpr;

  4999.   i: Integer;

  5000.   itm: TCodeItem;

  5001. begin

  5002.   if (aOld.Count <> aNew.Count) then

  5003.     raise EengInternal.Create('old and new idents must have the same size');

  5004.   rx := TRegExpr.Create;

  5005.   try

  5006.     for i := 0 to aOld.Count-1 do begin

  5007.       rx.Expression := '([^A-z0-9_]+|^)' + aOld[i] + '([^A-z0-9_]+|$)';

  5008.       for itm in fItems do

  5009.         if (itm is TCodeItemText) then

  5010.           with (itm as TCodeItemText) do

  5011.             Text := rx.Replace(Text, '$1' + aNew[i] + '$2', true);

  5012.     end;

  5013.   finally

  5014.     FreeAndNil(rx);

  5015.   end;

  5016. end;

  5017. 

  5018. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  5019. procedure TengGenCodeArgs.TCodeStackItem.ReplaceReturns(const aItem: TCodeStackItem; const aRetType, aFuncName: String; const aCntr: Integer);

  5020. var

  5021.   s: String;

  5022.   i, j, retCount, first, firstOffset: Integer;

  5023.   item: TCodeItem;

  5024.   rx: TRegExpr;

  5025. begin

  5026.   rx := TRegExpr.Create;

  5027.   try

  5028.     rx.Expression := '([^A-z0-9_]+|^)return([^A-z0-9_]+|$)';

  5029. 

  5030.     //find number of "return" in code and first item with not only whitespaces

  5031.     retCount := 0;

  5032.     first := 0;

  5033.     for i := 0 to fItems.Count-1 do begin

  5034.       item := fItems[i];

  5035.       s := item.GetText;

  5036.       if (item is TCodeItemText) and (Trim(s) <> '') and (first = 0) then begin

  5037.         first := i;

  5038.         firstOffset := Length(s) - Length(TrimLeft(s));

  5039.       end;

  5040.       if (rx.Exec(s)) then

  5041.         inc(retCount);

  5042.     end;

  5043. 

  5044.     //more than one return

  5045.     if (retCount > 1) then begin

  5046.       //TrimEnd;

  5047.       s := aFuncName + Format('_ret%.3d', [aCntr]);

  5048.       fItems.Insert(first,     TCodeItemText.Create(StringOfChar(' ', firstOffset) + aRetType + ' ' + s));

  5049.       fItems.Insert(first + 1, TCodeItemCommandEnd.Create(';'));

  5050.       fItems.Insert(first + 2, TCodeItemLineBreak.Create);

  5051. 

  5052.       for item in fItems do

  5053.         if (item is TCodeItemText) then

  5054.           with (item as TCodeItemText) do

  5055.             Text := rx.Replace(Text, '$1' + s + ' =$2', true);

  5056. 

  5057.       Merge(aItem, fItems.Count);

  5058.       AddText(s);

  5059. 

  5060.     // only one return

  5061.     end else begin

  5062.       i := fItems.Count-1;

  5063.       while (i > 0) do begin

  5064.         item := fItems[i];

  5065.         if (item is TCodeItemText) then

  5066.           with (item as TCodeItemText) do begin

  5067.             if (rx.Exec(Text)) then begin

  5068.               // replace

  5069.               fItems.Insert(i, TCodeItemText.Create(rx.Match[1]));

  5070.               Text := rx.Replace(Text, '(', true);

  5071. 

  5072.               // replace last CommandEnd with ')'

  5073.               j := fItems.Count-1;

  5074.               while (j > i) and not (fItems[j] is TCodeItemCommandEnd) do

  5075.                 dec(j);

  5076.               if (j > i) then begin

  5077.                 fItems.Delete(j);

  5078.                 fItems.Insert(j, TCodeItemText.Create(')'));

  5079.                 fItems.Insert(j+1, TCodeItemToken.Create(ttEnd));

  5080.               end;

  5081. 

  5082.               // merge

  5083.               i := fItems.IndexOf(item);

  5084.               fItems.Insert(i, TCodeItemToken.Create(ttBegin));

  5085.               inc(i);

  5086.               i := Merge(aItem, i);

  5087.               exit;

  5088.             end;

  5089.           end;

  5090.         dec(i);

  5091.       end;

  5092. 

  5093.       raise EengInternal.Create('no return found in current code');

  5094.     end;

  5095.   finally

  5096.     FreeAndNil(rx);

  5097.   end;

  5098. end;

  5099. 

  5100. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  5101. constructor TengGenCodeArgs.TCodeStackItem.Create;

  5102. begin

  5103.   inherited Create;

  5104.   fItems := TCodeItemList.Create(true);

  5105.   fItems.Add(TCodeItemStart.Create);

  5106. end;

  5107. 

  5108. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  5109. destructor TengGenCodeArgs.TCodeStackItem.Destroy;

  5110. begin

  5111.   FreeAndNil(fItems);

  5112.   inherited Destroy;

  5113. end;

  5114. 

  5115. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  5116. //TengGenCodeArgs.TProcWrapper//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  5117. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  5118. constructor TengGenCodeArgs.TProcWrapper.Create;

  5119. begin

  5120.   Proc := nil;

  5121.   Code := nil;

  5122. end;

  5123. 

  5124. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  5125. destructor TengGenCodeArgs.TProcWrapper.Destroy;

  5126. begin

  5127.   FreeAndNil(Code);

  5128.   Proc := nil;

  5129.   inherited Destroy;

  5130. end;

  5131. 

  5132. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  5133. //TengGenCodeArgs///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  5134. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  5135. function TengGenCodeArgs.GetFlags: TengGenCodeFlags;

  5136. begin

  5137.   if (fFlags.Count > 0) then

  5138.     result := fFlags.Last

  5139.   else

  5140.     result := [];

  5141. end;

  5142. 

  5143. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  5144. function TengGenCodeArgs.GetText: String;

  5145. begin

  5146.   result := fCode.Last.GetText;

  5147. end;

  5148. 

  5149. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  5150. function TengGenCodeArgs.GetCode: TCodeStackItem;

  5151. begin

  5152.   result := fCode.Last;

  5153. end;

  5154. 

  5155. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  5156. function TengGenCodeArgs.GetProcParams: TStrings;

  5157. begin

  5158.   result := fProcParams.Last;

  5159. end;

  5160. 

  5161. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  5162. procedure TengGenCodeArgs.PushCode;

  5163. begin

  5164.   fCode.PushLast(TCodeStackItem.Create);

  5165. end;

  5166. 

  5167. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  5168. procedure TengGenCodeArgs.InsertCode(const aCodeStackItem: TCodeStackItem);

  5169. begin

  5170.   fCode.PushLast(aCodeStackItem);

  5171. end;

  5172. 

  5173. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  5174. function TengGenCodeArgs.PushCurrentCommand: TCodeStackItem;

  5175. begin

  5176.   result := TCodeStackItem.Create;

  5177.   fCommands.PushLast(result);

  5178.   Code.SplitCurrentCommand(result);

  5179. end;

  5180. 

  5181. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  5182. procedure TengGenCodeArgs.PushFlags(const aFlags: TengGenCodeFlags);

  5183. begin

  5184.   fFlags.PushLast(aFlags);

  5185. end;

  5186. 

  5187. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  5188. procedure TengGenCodeArgs.PushProcParams(const aParams: TStrings);

  5189. begin

  5190.   fProcParams.PushLast(aParams);

  5191. end;

  5192. 

  5193. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  5194. procedure TengGenCodeArgs.PopCode(const aFlags: TPopCodeFlags);

  5195. var

  5196.   csi: TCodeStackItem;

  5197. begin

  5198.   csi := fCode.PopLast(false);

  5199.   try

  5200.     if not csi.Empty and (aFlags * [pcfAppend, pcfPrepend] <> []) then begin

  5201.       if (pcfPrepend in aFlags) then begin

  5202.         if (pcfAddEmptyLine in aFlags) then

  5203.           csi.AddLineEnd;

  5204.         Code.Merge(csi, 1);

  5205.       end else begin

  5206.         if (pcfAddEmptyLine in aFlags) then

  5207.           Code.AddLineEnd;

  5208.         Code.Merge(csi, Code.Items.Count);

  5209.       end;

  5210.     end;

  5211.   finally

  5212.     FreeAndNil(csi);

  5213.   end;

  5214. end;

  5215. 

  5216. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  5217. function TengGenCodeArgs.ExtractCode: TCodeStackItem;

  5218. begin

  5219.   result := fCode.PopLast(false);

  5220. end;

  5221. 

  5222. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  5223. procedure TengGenCodeArgs.PopCurrentCommand(const aRetType, aFuncName: String);

  5224. var

  5225.   csi: TCodeStackItem;

  5226. begin

  5227.   csi := fCommands.PopLast(false);

  5228.   try

  5229.     Code.ReplaceReturns(csi, aRetType, aFuncName, fInlineRetCounter);

  5230.     inc(fInlineRetCounter);

  5231.   finally

  5232.     FreeAndNil(csi);

  5233.   end;

  5234. end;

  5235. 

  5236. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  5237. procedure TengGenCodeArgs.PopFlags;

  5238. begin

  5239.   fFlags.PopLast(true);

  5240. end;

  5241. 

  5242. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  5243. procedure TengGenCodeArgs.PopProcParams;

  5244. begin

  5245.   fProcParams.PopLast;

  5246. end;

  5247. 

  5248. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  5249. procedure TengGenCodeArgs.AddProcedure(const aProc: TengShaderPartProc);

  5250. 

  5251.   function FindProc(const aName: String): TProcWrapper;

  5252.   begin

  5253.     for result in fProcedures do

  5254.       if (result.Proc.Name = aName) then

  5255.         exit;

  5256.     result := nil;

  5257.   end;

  5258. 

  5259. var

  5260.   w: TProcWrapper;

  5261. begin

  5262.   w := FindProc(aProc.Name);

  5263.   if Assigned(w) then begin

  5264.     if (aProc <> w.Proc) then

  5265.       raise EengDuplicateIdentifier.Create(w.Proc.Name, aProc, w.Proc);

  5266.     exit;

  5267.   end;

  5268. 

  5269.   w := TProcWrapper.Create;

  5270.   w.Proc := aProc;

  5271.   fProcedures.Add(w);

  5272. 

  5273.   PushCode; // push current code

  5274.   PushFlags(Flags + [gcfGenProcedure]);

  5275.   try

  5276.     w.Proc.GenCodeIntern(self);

  5277.   finally

  5278.     w.Code := ExtractCode; // pop procedure code and store it in wrapper

  5279.     PopFlags;

  5280.   end;

  5281. end;

  5282. 

  5283. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  5284. procedure TengGenCodeArgs.AddCodeProperty(const aProp: TengShaderPartCodeProperty);

  5285. var

  5286.   p: TengShaderPartCodeProperty;

  5287. begin

  5288.   p := fProperties[aProp.Name];

  5289.   if Assigned(p) then begin

  5290.     if not p.IsEquals(aProp) then

  5291.       raise EengDuplicateIdentifier.Create(p.Name, aProp, p);

  5292.     exit;

  5293.   end;

  5294.   fProperties.Add(aProp.Name, aProp);

  5295. end;

  5296. 

  5297. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  5298. procedure TengGenCodeArgs.AddMeta(const aMeta: IengMetaData);

  5299. begin

  5300.   fShaderCode.AddMeta(aMeta);

  5301. end;

  5302. 

  5303. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  5304. function TengGenCodeArgs.HasCodeProperty(const aName: String): Boolean;

  5305. begin

  5306.   result := fProperties.Contains(aName);

  5307. end;

  5308. 

  5309. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  5310. procedure TengGenCodeArgs.GenProcedureCode(const aAppend: Boolean);

  5311. var

  5312.   w: TProcWrapper;

  5313. begin

  5314.   for w in fProcedures do begin

  5315.     if not Assigned(w.Code) then

  5316.       continue;

  5317. 

  5318.     InsertCode(w.Code); // push stored code ...

  5319.     w.Code := nil;

  5320.     PopCode([pcfPrepend, pcfAddEmptyLine]); // and pop it back to the code tree (this will merge the code)

  5321.   end;

  5322. end;

  5323. 

  5324. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  5325. procedure TengGenCodeArgs.GenCodePropertyCode(const aTypes: array of CengShaderPart);

  5326. var

  5327.   p: TengShaderPartCodeProperty;

  5328.   m: TCodePropertyMap;

  5329. begin

  5330.   PushCode;

  5331.   PushFlags(Flags + [gcfGenCodeProp]);

  5332.   m := TCodePropertyMap.Create(false);

  5333.   try

  5334.     fMaxPropNameLen := 0;

  5335.     for p in fProperties do

  5336.       if CheckType(p, aTypes) then begin

  5337.         fMaxPropNameLen := Max(fMaxPropNameLen, Length(p.PropType));

  5338.         m.Add(p.PropType+p.Name, p);

  5339.       end;

  5340.     for p in m do begin

  5341.       p.GenCodeIntern(self);

  5342.       Code.AddLineEnd;

  5343.     end;

  5344.   finally

  5345.     FreeAndNil(m);

  5346.     PopCode([pcfPrepend, pcfAddEmptyLine]);

  5347.     PopFlags;

  5348.   end;

  5349. end;

  5350. 

  5351. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  5352. procedure TengGenCodeArgs.GenMetaCode;

  5353. var

  5354.   m: IengMetaData;

  5355.   s: String;

  5356.   vCompat: Boolean;

  5357.   vMax: Integer;

  5358.   layouts: TStringList;

  5359. begin

  5360.   vCompat := false;

  5361.   vMax := 0;

  5362.   PushCode;

  5363.   layouts := TStringList.Create;

  5364.   try

  5365.     for m in fShaderCode.MetaList do begin

  5366.       case m.MetaType of

  5367.         metaVersion: begin

  5368.           if (m.Values[0] = VERSION_EXTRA_COMPAT) then

  5369.             vCompat := true

  5370.           else

  5371.             vMax := Max(vMax, StrToInt(m.Values[0]));

  5372.           if (m.Count > 1) and (m.Values[1] = VERSION_EXTRA_COMPAT) then

  5373.             vCompat := true;

  5374.         end;

  5375. 

  5376.         metaExtension: begin

  5377.           Code.AddText(format('#extension %s : %s', [m.Values[0], m.Values[1]]));

  5378.           Code.AddLineEnd;

  5379.         end;

  5380. 

  5381.         metaLayout: begin

  5382.           layouts.Add(format('layout%s;', [m.Values[0]]));

  5383.         end;

  5384.       end;

  5385.     end;

  5386. 

  5387.     if (vMax >= LAYOUT_MIN_VERSION) then

  5388.       for s in layouts do begin

  5389.         Code.AddText(s);

  5390.         Code.AddLineEnd;

  5391.       end;

  5392. 

  5393.     if (vMax > 0) then begin

  5394.       PushCode;

  5395.       try

  5396.         Code.AddText('#version ' + IntToStr(vMax));

  5397.         if vCompat then

  5398.           Code.AddText(' ' + VERSION_EXTRA_COMPAT);

  5399.         Code.AddLineEnd;

  5400.       finally

  5401.         PopCode([pcfPrepend]);

  5402.       end;

  5403.     end;

  5404.   finally

  5405.     PopCode([pcfPrepend, pcfAddEmptyLine]);

  5406.     FreeAndNil(layouts);

  5407.   end;

  5408. end;

  5409. 

  5410. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  5411. constructor TengGenCodeArgs.Create(const aShaderCode: TengShaderCodeIntern; const aRoot: TengShaderPartScope);

  5412. begin

  5413.   inherited Create;

  5414.   fRoot        := aRoot;

  5415.   fProcedures  := TProcedureList.Create(true);

  5416.   fProperties  := TCodePropertyMap.Create(false);

  5417.   fFlags       := TGenCodeFlagsStack.Create(true);

  5418.   fCode        := TCodeStack.Create(true);

  5419.   fCommands    := TCodeStack.Create(true);

  5420.   fProcParams  := TProcParamStack.Create(false);

  5421.   fShaderCode  := aShaderCode;

  5422.   PushCode;

  5423. end;

  5424. 

  5425. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  5426. destructor TengGenCodeArgs.Destroy;

  5427. begin

  5428.   fShaderCode.Text := GetText;

  5429.   FreeAndNil(fProcParams);

  5430.   FreeAndNil(fCommands);

  5431.   FreeAndNil(fCode);

  5432.   FreeAndNil(fFlags);

  5433.   FreeAndNil(fProperties);

  5434.   FreeAndNil(fProcedures);

  5435.   inherited Destroy;

  5436. end;

  5437. 

  5438. 

  5439. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  5440. //DEBUG/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  5441. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  5442. {$IFDEF DEBUG}

  5443. procedure SaveAsXMindXml(const aShaderPart: TengShaderPart; const aDirectory: String);

  5444. var

  5445.   linkStr: String;

  5446. 

  5447.   function Escape(const aText: String): String;

  5448.   begin

  5449.     result := StringReplace(aText,  '''', '' { &apos; }, [rfReplaceAll]);

  5450.     result := StringReplace(result, '"',  '&quot;', [rfReplaceAll]);

  5451.     result := StringReplace(result, '&',  '&amp;',  [rfReplaceAll]);

  5452.     result := StringReplace(result, '<',  '&lt;',   [rfReplaceAll]);

  5453.     result := StringReplace(result, '>',  '&gt;',   [rfReplaceAll]);

  5454.   end;

  5455. 

  5456.   function MakeID(const aItem: TengShaderPart): String;

  5457.   begin

  5458.     result := Format('%p', [Pointer(aItem)]);

  5459.   end;

  5460. 

  5461.   function GetTitle(const aItem: TengShaderPart): String;

  5462.   var

  5463.     i: Integer;

  5464.     s: String;

  5465.   begin

  5466.     // TengShaderPartIf

  5467.     if (aItem.Parent is TengShaderPartIf) then begin

  5468.       if (aItem.Parent.Children[0] = aItem) then

  5469.         result := '- TRUE -'

  5470.       else if (aItem.Parent.Count > 1) and (aItem.Parent.Children[1] = aItem) then

  5471.         result := '- FALSE -'

  5472.       else

  5473.         result := '- UNKNOWN -';

  5474. 

  5475.     // TengShaderPartClass

  5476.     end else if (aItem is TengShaderPartClass) then

  5477.       result := aItem.GetTokenName + ' ' + (aItem as TengShaderPartClass).Name

  5478. 

  5479.     // TengShaderPartInclude

  5480.     else if (aItem is TengShaderPartInclude) then

  5481.       result := aItem.GetTokenName

  5482. 

  5483.     // TengShaderFile

  5484.     else if (aItem is TengShaderFile) then

  5485.       result := ExtractFileName((aItem as TengShaderFile).Filename)

  5486. 

  5487.     // TengShaderPartProperty

  5488.     else if (aItem is TengShaderPartProperty) then with (aItem as TengShaderPartProperty) do

  5489.       result := aItem.GetTokenName + ' ' + Name

  5490. 

  5491.     // TengShaderPartCodeProperty

  5492.     else if (aItem is TengShaderPartCodeProperty) then with (aItem as TengShaderPartCodeProperty) do

  5493.       result := aItem.GetTokenName + ' ' + fType + ' ' + fName

  5494. 

  5495.     // TengShaderPartCall

  5496.     else if (aItem is TengShaderPartCall) then with (aItem as TengShaderPartCall) do

  5497.       result := aItem.GetTokenName + ' ' + fName

  5498. 

  5499.     // TengShaderPartProc

  5500.     else if (aItem is TengShaderPartProc) then with (aItem as TengShaderPartProc) do

  5501.       result := aItem.GetTokenName + ' ' + fName

  5502. 

  5503.     // TengShaderPartMeta

  5504.     else if (aItem is TengShaderPartMeta) then with (aItem as TengShaderPartMeta) do begin

  5505.       result := aItem.GetTokenName + ' ' + fMetaData.Name;

  5506.       for i := 0 to fMetaData.Count-1 do

  5507.         result := result + ' ' + fMetaData[i];

  5508. 

  5509.     // TengShaderPartMeta

  5510.     end else if (aItem is TengShaderPartIf) then with (aItem as TengShaderPartIf) do

  5511.       result := aItem.GetTokenName + ' ' + fExpression.GetText

  5512. 

  5513.     // TengShaderPartEcho

  5514.     else if (aItem is TengShaderPartEcho) then with (aItem as TengShaderPartEcho) do

  5515.       result := aItem.GetTokenName + ' ' + fName

  5516. 

  5517.     // TengShaderPartMessage

  5518.     else if (aItem is TengShaderPartMessage) then with (aItem as TengShaderPartMessage) do

  5519.       result := aItem.GetTokenName + ' ' + fMessage

  5520. 

  5521.     else if (aItem is TengShaderPartInherited) then with (aItem as TengShaderPartInherited) do begin

  5522.       result := aItem.GetTokenName + ' ' + fInheritedName;

  5523.       for s in fParameters do

  5524.         result := ' ' + s;

  5525. 

  5526.     end else

  5527.       result := 'TODO: ' + aItem.GetTokenName;

  5528.     result := Escape(result);

  5529.   end;

  5530. 

  5531.   function GetDesc(const aItem: TengShaderPart): String;

  5532.   begin

  5533.     result := ''; //'<notes><plain>Your Description Here</plain></notes>';

  5534.   end;

  5535. 

  5536.   function MakeLinks(const aItem: TengShaderPartScope): String;

  5537.   var

  5538.     p: TengShaderPart;

  5539.   begin

  5540.     result := '';

  5541.     for p in aItem.fInherited do // red

  5542.       result := result + '<relationship end1="' + MakeID(aItem) + '" end2="' + MakeID(p) + '" style-id="1c2250lh1o9dug5bqnmfjqjj2h" timestamp="1407953246105"><control-points><control-point index="0"></control-point><control-point index="1"><position svg:x="-150" svg:y="0"/></control-point></control-points></relationship>';

  5543.     for p in aItem.fChildScopes do // green

  5544.       result := result + '<relationship end1="' + MakeID(aItem) + '" end2="' + MakeID(p) + '" style-id="kjafgighq039598z56afioh565" timestamp="1407953246105"><control-points><control-point index="0"></control-point><control-point index="1"><position svg:x="-150" svg:y="0"/></control-point></control-points></relationship>';

  5545.     for p in aItem.fMappedParts do // blue

  5546.       result := result + '<relationship end1="' + MakeID(aItem) + '" end2="' + MakeID(p) + '" style-id="akjbq3589715ljkbg09uath6pa" timestamp="1407953246105"><control-points><control-point index="0"></control-point><control-point index="1"><position svg:x="-150" svg:y="0"/></control-point></control-points></relationship>';

  5547.   end;

  5548. 

  5549.   function CreateCodeItem(var aCode: String): String;

  5550.   var

  5551.     sl: TStringList;

  5552.   begin

  5553.     sl := TStringList.Create;

  5554.     try

  5555.       sl.Text := aCode;

  5556.       while (sl.Count > 0) and (Trim(sl[0]) = '') do

  5557.         sl.Delete(0);

  5558.       while (sl.Count > 0) and (Trim(sl[sl.Count-1]) = '') do

  5559.         sl.Delete(sl.Count-1);

  5560.       if (sl.Count > 0) then

  5561.         result := '<topic timestamp="1407871141500" style-id="7dh2otp9bqp93n80sk589g5916"><title>- CODE -</title>' +

  5562.           '<notes><plain>' + Escape(sl.Text) + '</plain></notes></topic>'

  5563.       else

  5564.         result := '';

  5565.       aCode := '';

  5566.     finally

  5567.       FreeAndNil(sl);

  5568.     end;

  5569.   end;

  5570. 

  5571.   function DoItem(const aItem: TengShaderPart; const aIsRoot: Boolean = false): String;

  5572.   var

  5573.     p: TengShaderPart;

  5574.     code: String;

  5575.   begin

  5576.     code := '';

  5577.     result := '<topic id="' + MakeID(aItem) + '" style-id="7dh2otp9bqp93n80sk589g5916" timestamp="1407871141500"';

  5578.     if (aIsRoot) then

  5579.       result := result + ' structure-class="org.xmind.ui.logic.right"';

  5580.     result := result + '><title>' + GetTitle(aItem) + '</title>' + GetDesc(aItem);

  5581. 

  5582.     if (aItem is TengShaderPartScope) then

  5583.       linkStr := linkStr + MakeLinks(aItem as TengShaderPartScope);

  5584. 

  5585.     if (aItem.Count > 0) then begin

  5586.       result := result + '<children><topics type="attached">';

  5587.       for p in aItem do begin

  5588.         if (p is TengShaderPartCode) then

  5589.           code := code + (p as TengShaderPartCode).Text

  5590.         else if (p is TengShaderPartCommandEnd) then

  5591.           code := code + (p as TengShaderPartCommandEnd).fToken

  5592.         else if (p is TengShaderPartLineBreak) then

  5593.           code := code + (p as TengShaderPartLineBreak).Text

  5594.         else

  5595.           result := result + CreateCodeItem(code) + DoItem(p);

  5596.       end;

  5597.       result := result + CreateCodeItem(code) + '</topics></children>';

  5598.     end;

  5599.     result := result + '</topic>';

  5600.   end;

  5601. 

  5602. var

  5603.   fs: TFileStream;

  5604.   s: String;

  5605.   len: Integer;

  5606. begin

  5607.   linkStr := '';

  5608.   s := '<?xml version="1.0" encoding="UTF-8" standalone="no"?><xmap-content xmlns="urn:xmind:xmap:xmlns:content:2.0" xmlns:fo="http://www.w3.org/1999/XSL/Format" xmlns:svg="http://www.w3.org/2000/svg" xmlns:xhtml="http://www.w3.org/1999/xhtml" xmlns:xlink="http://www.w3.org/1999/xlink" timestamp="1407871228304" version="2.0"><sheet id="2e1sqd3f443tanv8s665jo6r9u" timestamp="1407871228304">' +

  5609.     DoItem(aShaderPart, true) + '<title>glslPreCompiler Code Tree</title>';

  5610.   if (linkStr <> '') then

  5611.     s := s + '<relationships>' + linkStr + '</relationships>';

  5612.   s := s + '</sheet></xmap-content>';

  5613.   len := Length(s);

  5614.   if (len > 0) then begin

  5615.     fs := TFileStream.Create(IncludeTrailingPathDelimiter(aDirectory) + 'content.xml', fmCreate);

  5616.     try

  5617.       fs.Write(s[1], len);

  5618.     finally

  5619.       FreeAndNil(fs);

  5620.     end;

  5621. 

  5622.     s := '<?xml version="1.0" encoding="UTF-8" standalone="no"?><xmap-styles xmlns="urn:xmind:xmap:xmlns:style:2.0" xmlns:fo="http://www.w3.org/1999/XSL/Format" xmlns:svg="http://www.w3.org/2000/svg" version="2.0"><styles>' +

  5623.         '<style id="7dh2otp9bqp93n80sk589g5916" type="topic"><topic-properties fo:font-family="Calibri" fo:font-size="10pt" line-class="org.xmind.branchConnection.elbow" shape-class="org.xmind.topicShape.roundedRect"/></style>' +

  5624.         '<style id="1c2250lh1o9dug5bqnmfjqjj2h" type="relationship"><relationship-properties line-color="#FF0000" /></style>' +

  5625.         '<style id="kjafgighq039598z56afioh565" type="relationship"><relationship-properties line-color="#00FF00" /></style>' +

  5626.         '<style id="akjbq3589715ljkbg09uath6pa" type="relationship"><relationship-properties line-color="#0000FF" /></style>' +

  5627.       '</styles></xmap-styles>';

  5628.     len := Length(s);

  5629.     fs := TFileStream.Create(IncludeTrailingPathDelimiter(aDirectory) + 'styles.xml', fmCreate);

  5630.     try

  5631.       fs.Write(s[1], len);

  5632.     finally

  5633.       FreeAndNil(fs);

  5634.     end;

  5635.   end;

  5636. end;

  5637. {$ENDIF}

  5638. 

  5639. 

  5640. end.