@shaderfrog/core 0.1.0 → 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,6 +1,6 @@
 {
   "name": "@shaderfrog/core",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Shaderfrog core",
   "main": "index.js",
   "scripts": {