@shaderfrog/core 0.0.2 → 0.1.1

package/dist/stratgies.test.js

@@ -0,0 +1,164 @@
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+import { parser } from '@shaderfrog/glsl-parser';
+import { generate } from '@shaderfrog/glsl-parser';
+import { applyStrategy, StrategyType } from './strategy';
+import * as graphModule from './graph';
+import { makeExpression } from './ast/manipulate';
+import preprocess from '@shaderfrog/glsl-parser/preprocessor';
+var orig;
+beforeEach(function () {
+    orig = graphModule.mangleName;
+    // Terrible hack. in the real world, strategies are applied after mangling
+    // @ts-ignore
+    graphModule.mangleName = function (name) { return name; };
+});
+afterEach(function () {
+    // @ts-ignore
+    graphModule.mangleName = orig;
+});
+it('named attribute strategy`', function () {
+    var source = "\nin vec3 replaceThisAtrribute;\nvoid main() {\n  vec2 y = replaceThisAtrribute;\n}\n";
+    var ast = parser.parse(source, { quiet: true });
+    var fillers = applyStrategy({
+        type: StrategyType.NAMED_ATTRIBUTE,
+        config: {
+            attributeName: 'replaceThisAtrribute',
+        },
+    }, { source: source }, ast);
+    expect(fillers.length).toBe(1);
+    fillers[0][1]({
+        type: 'literal',
+        literal: "myFiller()",
+        whitespace: '',
+    });
+    var result = generate(ast);
+    // Should replace the use of the filler, but not the declaration
+    expect(result).toBe("\nin vec3 replaceThisAtrribute;\nvoid main() {\n  vec2 y = myFiller();\n}\n");
+});
+it('inject strategy after', function () {
+    var source = "\nuniform float x;\n// Some comment\nvoid main() {\n/* some comment */\nre(x, y, z);\n// Middle comment\nre(x, y, z);\n// Final comment\n}";
+    var ast = parser.parse(source, { quiet: true });
+    var fillers = applyStrategy({
+        type: StrategyType.INJECT,
+        config: {
+            find: 're(x, y, z);',
+            insert: 'after',
+            count: Infinity,
+        },
+    }, { source: source }, ast);
+    expect(fillers.length).toBe(1);
+    fillers[0][1]({
+        type: 'literal',
+        literal: "someOtherCall(x, y, z);\nsomeOtherCall(x, y, z);",
+        whitespace: '',
+    });
+    var result = generate(ast);
+    // Should fill references
+    expect(result).toBe("\nuniform float x;\n// Some comment\nvoid main() {\n/* some comment */\nre(x, y, z);\nsomeOtherCall(x, y, z);\nsomeOtherCall(x, y, z);\n// Middle comment\nre(x, y, z);\nsomeOtherCall(x, y, z);\nsomeOtherCall(x, y, z);\n// Final comment\n}");
+});
+it('inject strategy before', function () {
+    var source = "\nuniform float x;\n// Some comment\nvoid main() {\n/* some comment */\nre(x, y, z);\n// Middle comment\nre(x, y, z);\n// Final comment\n}";
+    var ast = parser.parse(source, { quiet: true });
+    var fillers = applyStrategy({
+        type: StrategyType.INJECT,
+        config: {
+            find: 're(x, y, z);',
+            insert: 'before',
+            count: Infinity,
+        },
+    }, { source: source }, ast);
+    expect(fillers.length).toBe(1);
+    fillers[0][1]({
+        type: 'literal',
+        literal: "someOtherCall(x, y, z);\nsomeOtherCall(x, y, z);",
+        whitespace: '\n',
+    });
+    var result = generate(ast);
+    // Should fill references
+    expect(result).toBe("\nuniform float x;\n// Some comment\nvoid main() {\n/* some comment */\nsomeOtherCall(x, y, z);\nsomeOtherCall(x, y, z);\nre(x, y, z);\n// Middle comment\nsomeOtherCall(x, y, z);\nsomeOtherCall(x, y, z);\nre(x, y, z);\n// Final comment\n}");
+});
+it('correctly fills with uniform strategy', function () {
+    var _a, _b, _c;
+    var ast = parser.parse("\nlayout(std140,column_major) uniform;\nuniform sampler2D image;\nuniform vec4 input, output, other;\nuniform vec4 zenput;\nuniform Light0 { vec4 y; } x;\nvec3 topLevel = vec3(0.0);\nvoid other(in vec3 param) {}\nvoid main() {\n  vec4 computed = texture2D(image, uvPow * 1.0);\n  vec4 x = input;\n  vec4 y = output;\n  vec4 z = zenput;\n}", { quiet: true });
+    var fillers = applyStrategy({ type: StrategyType.UNIFORM, config: {} }, {}, ast);
+    // It should find uniforms with simple types, excluding sampler2D
+    expect(fillers.map(function (_a) {
+        var _b = __read(_a, 1), name = _b[0].displayName;
+        return name;
+    })).toEqual([
+        'image',
+        'input',
+        'output',
+        'other',
+        'zenput',
+    ]);
+    (_a = fillers.find(function (_a) {
+        var _b = __read(_a, 1), name = _b[0].displayName;
+        return name === 'input';
+    })) === null || _a === void 0 ? void 0 : _a[1](makeExpression('a'));
+    (_b = fillers.find(function (_a) {
+        var _b = __read(_a, 1), name = _b[0].displayName;
+        return name === 'output';
+    })) === null || _b === void 0 ? void 0 : _b[1](makeExpression('b'));
+    (_c = fillers.find(function (_a) {
+        var _b = __read(_a, 1), name = _b[0].displayName;
+        return name === 'zenput';
+    })) === null || _c === void 0 ? void 0 : _c[1](makeExpression('c'));
+    var result = generate(ast);
+    // Should fill references
+    expect(result).toContain('vec4 x = a;');
+    expect(result).toContain('vec4 y = b;');
+    expect(result).toContain('vec4 z = c;');
+    // Should preserve things it shouldn't touch
+    expect(result).toContain('layout(std140,column_major) uniform;');
+    expect(result).toContain('uniform sampler2D image;');
+    expect(result).toContain('uniform Light0 { vec4 y; } x;');
+    // Should remove uniforms from declarator list
+    expect(result).toContain('uniform vec4 other;');
+    // Should remove uniform lines
+    expect(result).not.toContain('uniform vec4 zenput');
+});
+it('uses name without suffix for single call', function () {
+    var ast = parser.parse("\nvoid main() {\n  vec4 computed = texture2D(noiseImage, uvPow * 1.0);\n}", { quiet: true });
+    expect(applyStrategy({ type: StrategyType.TEXTURE_2D, config: {} }, {}, ast).map(function (_a) {
+        var _b = __read(_a, 1), name = _b[0].displayName;
+        return name;
+    })).toEqual(['noiseImage']);
+});
+it('finds multiple texture2D inputs for one uniform', function () {
+    var ast = parser.parse("\nvoid main() {\n  vec4 computed = texture2D(noiseImage, uvPow * 1.0);\n  computed += texture2D(noiseImage, uvPow * 2.0);\n}", { quiet: true });
+    expect(applyStrategy({ type: StrategyType.TEXTURE_2D, config: {} }, {}, ast).map(function (_a) {
+        var _b = __read(_a, 1), name = _b[0].displayName;
+        return name;
+    })).toEqual(['noiseImage_0', 'noiseImage_1']);
+});
+it('Make sure texture2D finds preprocessed texture() call', function () {
+    // I thought this was a regression, but it wasn't a real bug, but tests seems
+    // benign to keep anyway
+    var program = "\n#define texture2DBias texture\n\nuniform sampler2D normalMap;\n\nvoid getNormal() {\n    vec3 normalMap = unpackNormal(texture2DBias(normalMap, vUv0, textureBias));\n}";
+    var pp = preprocess(program, {
+        preserve: {
+            version: function () { return true; },
+        },
+    });
+    var ast = parser.parse(pp, { quiet: true });
+    expect(applyStrategy({ type: StrategyType.TEXTURE_2D, config: {} }, {}, ast).map(function (_a) {
+        var _b = __read(_a, 1), name = _b[0].displayName;
+        return name;
+    })).toEqual(['normalMapx']);
+});

package/dist/util/ast.js

@@ -0,0 +1,9 @@
+import { generate } from '@shaderfrog/glsl-parser';
+export var generateFiller = function (filler) {
+    if (!filler) {
+        throw new Error('Cannot generate void filler!');
+    }
+    return Array.isArray(filler)
+        ? filler.map(generate).join('')
+        : generate(filler);
+};

package/dist/util/ensure.js

@@ -0,0 +1,7 @@
+export var ensure = function (argument, message) {
+    if (message === void 0) { message = 'This value was promised to be there.'; }
+    if (argument === undefined || argument === null) {
+        throw new TypeError(message);
+    }
+    return argument;
+};

package/dist/util/id.js

@@ -0,0 +1,2 @@
+var counter = 0;
+export var makeId = function () { return '' + counter++; };

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "@shaderfrog/core",
-  "version": "0.0.2",
+  "version": "0.1.1",
   "description": "Shaderfrog core",
   "main": "index.js",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "prepare": "npm run build",
+    "build": "./build.sh",
+    "watch-test": "jest --watch",
+    "test": "jest --colors"
   },
   "repository": {
     "type": "git",
@@ -13,7 +16,7 @@
   "author": "Andrew Ray",
   "license": "ISC",
   "files": [
-    "src"
+    "dist"
   ],
   "bugs": {
     "url": "https://github.com/ShaderFrog/core/issues"
@@ -37,8 +40,10 @@
     "lodash.groupby": "^4.6.0"
   },
   "peerDependencies": {
+    "@shaderfrog/glsl-parser": "^2.0.0-beta.5",
     "babylonjs": ">=4",
-    "three": ">=0.50"
+    "three": ">=0.50",
+    "playcanvas": "^1.65.3"
   },
   "peerDependenciesMeta": {
     "babylonjs": {
@@ -46,6 +51,9 @@
     },
     "three": {
       "optional": true
+    },
+    "playcanvas": {
+      "optional": true
     }
   }
 }

package/src/ast/manipulate.ts

@@ -1,392 +0,0 @@
-/**
- * Utility functions to work with ASTs
- */
-import { parser, generate } from '@shaderfrog/glsl-parser';
-import {
-  visit,
-  AstNode,
-  NodeVisitors,
-  ExpressionStatementNode,
-  FunctionNode,
-  AssignmentNode,
-  DeclarationStatementNode,
-  KeywordNode,
-  DeclarationNode,
-} from '@shaderfrog/glsl-parser/ast';
-import { Program } from '@shaderfrog/glsl-parser/ast';
-import { ShaderStage } from '../core/graph';
-
-export const findVec4Constructor = (ast: AstNode): AstNode | undefined => {
-  let parent: AstNode | undefined;
-  const visitors: NodeVisitors = {
-    function_call: {
-      enter: (path) => {
-        if (
-          'specifier' in path.node.identifier &&
-          path.node.identifier?.specifier?.token === 'vec4'
-        ) {
-          parent = path.findParent((p) => 'right' in p.node)?.node;
-          path.skip();
-        }
-      },
-    },
-  };
-  visit(ast, visitors);
-  return parent;
-};
-
-export const findAssignmentTo = (
-  ast: AstNode | Program,
-  assignTo: string
-): ExpressionStatementNode | undefined => {
-  let assign: ExpressionStatementNode | undefined;
-  const visitors: NodeVisitors = {
-    expression_statement: {
-      enter: (path) => {
-        if (path.node.expression?.left?.identifier === assignTo) {
-          assign = path.node;
-        }
-        path.skip();
-      },
-    },
-  };
-  visit(ast, visitors);
-  return assign;
-};
-
-export const findDeclarationOf = (
-  ast: AstNode | Program,
-  declarationOf: string
-): DeclarationNode | undefined => {
-  let declaration: DeclarationNode | undefined;
-  const visitors: NodeVisitors = {
-    declaration_statement: {
-      enter: (path) => {
-        const foundDecl = path.node.declaration?.declarations?.find(
-          (decl: any) => decl?.identifier?.identifier === declarationOf
-        );
-        if (foundDecl) {
-          declaration = foundDecl;
-        }
-        path.skip();
-      },
-    },
-  };
-  visit(ast, visitors);
-  return declaration;
-};
-
-export const from2To3 = (ast: Program, stage: ShaderStage) => {
-  const glOut = 'fragmentColor';
-  // TODO: add this back in when there's only one after the merge
-  // ast.program.unshift({
-  //   type: 'preprocessor',
-  //   line: '#version 300 es',
-  //   _: '\n',
-  // });
-  if (stage === 'fragment') {
-    ast.program.unshift({
-      type: 'declaration_statement',
-      declaration: {
-        type: 'declarator_list',
-        specified_type: {
-          type: 'fully_specified_type',
-          qualifiers: [{ type: 'keyword', token: 'out', whitespace: ' ' }],
-          specifier: {
-            type: 'type_specifier',
-            specifier: { type: 'keyword', token: 'vec4', whitespace: ' ' },
-            quantifier: null,
-          },
-        },
-        declarations: [
-          {
-            type: 'declaration',
-            identifier: {
-              type: 'identifier',
-              identifier: glOut,
-              whitespace: undefined,
-            },
-            quantifier: null,
-            operator: undefined,
-            initializer: undefined,
-          },
-        ],
-        commas: [],
-      },
-      semi: { type: 'literal', literal: ';', whitespace: '\n    ' },
-    });
-  }
-  visit(ast, {
-    function_call: {
-      enter: (path) => {
-        const identifier = path.node.identifier;
-        if (
-          'specifier' in identifier &&
-          identifier.specifier?.identifier === 'texture2D'
-        ) {
-          identifier.specifier.identifier = 'texture';
-        }
-      },
-    },
-    identifier: {
-      enter: (path) => {
-        if (path.node.identifier === 'gl_FragColor') {
-          path.node.identifier = glOut;
-        }
-      },
-    },
-    keyword: {
-      enter: (path) => {
-        if (
-          (path.node.token === 'attribute' || path.node.token === 'varying') &&
-          path.findParent((path) => path.node.type === 'declaration_statement')
-        ) {
-          path.node.token =
-            stage === 'vertex' && path.node.token === 'varying' ? 'out' : 'in';
-        }
-      },
-    },
-  });
-};
-
-export const outDeclaration = (name: string): Object => ({
-  type: 'declaration_statement',
-  declaration: {
-    type: 'declarator_list',
-    specified_type: {
-      type: 'fully_specified_type',
-      qualifiers: [{ type: 'keyword', token: 'out', whitespace: ' ' }],
-      specifier: {
-        type: 'type_specifier',
-        specifier: { type: 'keyword', token: 'vec4', whitespace: ' ' },
-        quantifier: null,
-      },
-    },
-    declarations: [
-      {
-        type: 'declaration',
-        identifier: {
-          type: 'identifier',
-          identifier: name,
-          whitespace: undefined,
-        },
-        quantifier: null,
-        operator: undefined,
-        initializer: undefined,
-      },
-    ],
-    commas: [],
-  },
-  semi: { type: 'literal', literal: ';', whitespace: '\n    ' },
-});
-
-export const makeStatement = (stmt: string): AstNode => {
-  // console.log(stmt);
-  let ast;
-  try {
-    ast = parser.parse(
-      `${stmt};
-`,
-      { quiet: true }
-    );
-  } catch (error: any) {
-    console.error({ stmt, error });
-    throw new Error(`Error parsing stmt "${stmt}": ${error?.message}`);
-  }
-  // console.log(util.inspect(ast, false, null, true));
-  return ast.program[0];
-};
-
-export const makeFnStatement = (fnStmt: string): AstNode => {
-  let ast;
-  try {
-    ast = parser.parse(
-      `
-  void main() {
-      ${fnStmt};
-    }`,
-      { quiet: true }
-    );
-  } catch (error: any) {
-    console.error({ fnStmt, error });
-    throw new Error(`Error parsing fnStmt "${fnStmt}": ${error?.message}`);
-  }
-
-  // console.log(util.inspect(ast, false, null, true));
-  return (ast.program[0] as FunctionNode).body.statements[0];
-};
-
-export const makeExpression = (expr: string): AstNode => {
-  let ast;
-  try {
-    ast = parser.parse(
-      `void main() {
-          a = ${expr};
-        }`,
-      { quiet: true }
-    );
-  } catch (error: any) {
-    console.error({ expr, error });
-    throw new Error(`Error parsing expr "${expr}": ${error?.message}`);
-  }
-
-  // console.log(util.inspect(ast, false, null, true));
-  return (ast.program[0] as FunctionNode).body.statements[0].expression.right;
-};
-
-export const makeExpressionWithScopes = (expr: string): Program => {
-  let ast: Program;
-  try {
-    ast = parser.parse(
-      `void main() {
-          ${expr};
-        }`,
-      { quiet: true }
-    );
-  } catch (error: any) {
-    console.error({ expr, error });
-    throw new Error(`Error parsing expr "${expr}": ${error?.message}`);
-  }
-
-  // console.log(util.inspect(ast, false, null, true));
-  return {
-    type: 'program',
-    // Set the main() fn body scope as the global one
-    scopes: [ast.scopes[1]],
-    program: [(ast.program[0] as FunctionNode).body.statements[0].expression],
-  };
-};
-
-export const findFn = (ast: Program, name: string): FunctionNode | undefined =>
-  ast.program.find(
-    (stmt): stmt is FunctionNode =>
-      stmt.type === 'function' && stmt.prototype.header.name.identifier === name
-  );
-
-export const returnGlPosition = (fnName: string, ast: Program): void =>
-  convertVertexMain(fnName, ast, 'vec4', (assign) => assign.expression.right);
-
-export const returnGlPositionHardCoded = (
-  fnName: string,
-  ast: Program,
-  returnType: string,
-  hardCodedReturn: string
-): void =>
-  convertVertexMain(fnName, ast, returnType, () =>
-    makeExpression(hardCodedReturn)
-  );
-
-export const returnGlPositionVec3Right = (fnName: string, ast: Program): void =>
-  convertVertexMain(fnName, ast, 'vec3', (assign) => {
-    let found: AstNode | undefined;
-    visit(assign, {
-      function_call: {
-        enter: (path) => {
-          const { node } = path;
-          if (
-            // @ts-ignore
-            node?.identifier?.specifier?.token === 'vec4' &&
-            node?.args?.[2]?.token?.includes('1.')
-          ) {
-            found = node.args[0];
-          }
-        },
-      },
-    });
-    if (!found) {
-      console.error(generate(ast));
-      throw new Error(
-        'Could not find position assignment to convert to return!'
-      );
-    }
-    return found;
-  });
-
-const convertVertexMain = (
-  fnName: string,
-  ast: Program,
-  returnType: string,
-  generateRight: (positionAssign: ExpressionStatementNode) => AstNode
-) => {
-  const mainReturnVar = `frogOut`;
-
-  const main = findFn(ast, fnName);
-  if (!main) {
-    throw new Error(`No ${fnName} fn found!`);
-  }
-
-  // Convert the main function to one that returns
-  (main.prototype.header.returnType.specifier.specifier as KeywordNode).token =
-    returnType;
-
-  // Find the gl_position assignment line
-  const assign = main.body.statements.find(
-    (stmt: AstNode) =>
-      stmt.type === 'expression_statement' &&
-      stmt.expression.left?.identifier === 'gl_Position'
-  );
-  if (!assign) {
-    throw new Error(`No gl position assign found in main fn!`);
-  }
-
-  const rtnStmt = makeFnStatement(
-    `${returnType} ${mainReturnVar} = 1.0`
-  ) as DeclarationStatementNode;
-  rtnStmt.declaration.declarations[0].initializer = generateRight(assign);
-
-  main.body.statements.splice(main.body.statements.indexOf(assign), 1, rtnStmt);
-  main.body.statements.push(makeFnStatement(`return ${mainReturnVar}`));
-};
-
-export const convert300MainToReturn = (fnName: string, ast: Program): void => {
-  const mainReturnVar = `frogOut`;
-
-  // Find the output variable, as in "pc_fragColor" from  "out highp vec4 pc_fragColor;"
-  let outName: string | undefined;
-  ast.program.find((line, index) => {
-    if (
-      line.type === 'declaration_statement' &&
-      line.declaration?.specified_type?.qualifiers?.find(
-        (n: KeywordNode) => n.token === 'out'
-      ) &&
-      line.declaration.specified_type.specifier.specifier.token === 'vec4'
-    ) {
-      // Remove the out declaration
-      ast.program.splice(index, 1);
-      outName = line.declaration.declarations[0].identifier.identifier;
-      return true;
-    }
-  });
-  if (!outName) {
-    console.error(generate(ast));
-    throw new Error('No "out vec4" line found in the fragment shader');
-  }
-
-  visit(ast, {
-    identifier: {
-      enter: (path) => {
-        if (path.node.identifier === outName) {
-          path.node.identifier = mainReturnVar;
-          // @ts-ignore
-          path.node.doNotDescope = true; // hack because this var is in the scope which gets renamed later
-        }
-      },
-    },
-    function: {
-      enter: (path) => {
-        if (path.node.prototype.header.name.identifier === fnName) {
-          (
-            path.node.prototype.header.returnType.specifier
-              .specifier as KeywordNode
-          ).token = 'vec4';
-          path.node.body.statements.unshift(
-            makeFnStatement(`vec4 ${mainReturnVar}`)
-          );
-          path.node.body.statements.push(
-            makeFnStatement(`return ${mainReturnVar}`)
-          );
-        }
-      },
-    },
-  });
-};