@shaderfrog/core 0.0.2 → 0.1.1

package/dist/graph.test.js

@@ -0,0 +1,168 @@
+import util from 'util';
+import { parser } from '@shaderfrog/glsl-parser';
+import { generate } from '@shaderfrog/glsl-parser';
+import { shaderSectionsToProgram } from './ast/shader-sections';
+import { addNode } from './nodes/engine-node';
+import { mergeShaderSections, findShaderSections } from './ast/shader-sections';
+import { numberNode } from './nodes/data-nodes';
+import { makeEdge } from './nodes/edge';
+import { evaluateNode } from './evaluate';
+var inspect = function (thing) {
+    return console.log(util.inspect(thing, false, null, true));
+};
+var mergeBlocks = function (ast1, ast2) {
+    var s1 = findShaderSections(ast1);
+    var s2 = findShaderSections(ast2);
+    var merged = mergeShaderSections(s1, s2);
+    return generate(shaderSectionsToProgram(merged, {
+        includePrecisions: true,
+        includeVersion: true,
+    }));
+};
+var dedupe = function (code) {
+    return generate(shaderSectionsToProgram(findShaderSections(parser.parse(code)), {
+        includePrecisions: true,
+        includeVersion: true,
+    }));
+};
+var counter = 0;
+var p = { x: 0, y: 0 };
+var id = function () { return '' + counter++; };
+var constructor = function () { return ({
+    config: {
+        version: 3,
+        preprocess: false,
+        strategies: [],
+        uniforms: [],
+    },
+    id: '1',
+    name: '1',
+    type: '',
+    inputs: [],
+    outputs: [],
+    position: { x: 0, y: 0 },
+    source: '',
+    stage: undefined,
+    groupId: null,
+}); };
+var engine = {
+    name: 'three',
+    evaluateNode: function (node) {
+        if (node.type === 'number') {
+            return parseFloat(node.value);
+        }
+        return node.value;
+    },
+    constructors: {
+        physical: constructor,
+        toon: constructor,
+    },
+    mergeOptions: {
+        includePrecisions: true,
+        includeVersion: true,
+    },
+    importers: {},
+    preserve: new Set(),
+    parsers: {},
+};
+// it('graph compiler arbitrary helper test', () => {
+//   const graph: Graph = {
+//     nodes: [
+//       outputNode('0', 'Output v', p, 'vertex'),
+//       outputNode('1', 'Output f', p, 'fragment'),
+//       makeSourceNode(
+//         '2',
+//         `uniform sampler2D image1;
+// uniform sampler2D image2;
+// void main() {
+//   vec3 col = texture2D(image1, posTurn - 0.4 * time).rgb + 1.0;
+//   vec3 col = texture2D(image2, negTurn - 0.4 * time).rgb + 2.0;
+// }
+// `,
+//         'fragment'
+//       ),
+//       makeSourceNode(
+//         '3',
+//         `void main() {
+//     return vec4(0.0);
+// }
+// `,
+//         'fragment'
+//       ),
+//       makeSourceNode(
+//         '4',
+//         `void main() {
+//     return vec4(1.0);
+// }
+// `,
+//         'fragment'
+//       ),
+//     ],
+//     edges: [
+//       makeEdge(id(), '2', '1', 'out', 'filler_frogFragOut', 'fragment'),
+//       makeEdge(id(), '3', '2', 'out', 'filler_image1', 'fragment'),
+//       makeEdge(id(), '4', '2', 'out', 'filler_image2', 'fragment'),
+//     ],
+//   };
+//   const engineContext: EngineContext = {
+//     engine: 'three',
+//     nodes: {},
+//     runtime: {},
+//     debuggingNonsense: {},
+//   };
+//   const result = compileGraph(engineContext, engine, graph);
+//   const built = generate(
+//     shaderSectionsToProgram(result.fragment, {
+//       includePrecisions: true,
+//       includeVersion: true,
+//     }).program
+//   );
+//   expect(built).toBe('hi');
+// });
+describe('evaluateNode()', function () {
+    it('evaluates binary nodes', function () {
+        var finalAdd = addNode(id(), p);
+        var add2 = addNode(id(), p);
+        var num1 = numberNode(id(), 'number', p, '3');
+        var num2 = numberNode(id(), 'number', p, '5');
+        var num3 = numberNode(id(), 'number', p, '7');
+        var graph = {
+            nodes: [num1, num2, num3, finalAdd, add2],
+            edges: [
+                makeEdge(id(), num1.id, finalAdd.id, 'out', 'a'),
+                makeEdge(id(), add2.id, finalAdd.id, 'out', 'b'),
+                makeEdge(id(), num2.id, add2.id, 'out', 'a'),
+                makeEdge(id(), num3.id, add2.id, 'out', 'b'),
+            ],
+        };
+        expect(evaluateNode(engine, graph, finalAdd)).toBe(15);
+    });
+});
+it('should merge uniforms with interface blocks', function () {
+    var astX = parser.parse("uniform vec2 x;");
+    var astY = parser.parse("uniform vec2 y, z;\nuniform vec3 a;");
+    expect(mergeBlocks(astX, astY)).toEqual("uniform vec2 x, y, z;\nuniform vec3 a;\n");
+    var astL01 = parser.parse("uniform Light0 { vec4 y; } x;", { quiet: true });
+    var astL02 = parser.parse("uniform Light0 { vec4 y; } x;", { quiet: true });
+    expect(mergeBlocks(astL01, astL02)).toEqual("uniform Light0 { vec4 y; } x;\n");
+    var astL001 = parser.parse("uniform Light0 { vec4 y; } x;", {
+        quiet: true,
+    });
+    var astL002 = parser.parse("uniform Light0 x;", { quiet: true });
+    expect(mergeBlocks(astL001, astL002)).toEqual("uniform Light0 { vec4 y; } x;\n");
+    var astLo01 = parser.parse("uniform Light0 x;", { quiet: true });
+    var astLo02 = parser.parse("uniform Light0 { vec4 y; } x;", {
+        quiet: true,
+    });
+    expect(mergeBlocks(astLo01, astLo02)).toEqual("uniform Light0 { vec4 y; } x;\n");
+    // This may be a bug, look at how the uniforms are merged. I at least want to
+    // note its current behavior in this test
+    var vec2Arr1 = parser.parse("uniform vec2 y[5];");
+    var vec2Arr2 = parser.parse("uniform vec2 y[10];");
+    expect(mergeBlocks(vec2Arr1, vec2Arr2)).toEqual("uniform vec2 y[10];\n");
+    var block1 = parser.parse("uniform Scene { mat4 view; };");
+    var block2 = parser.parse("uniform Scene { mat4 view; };");
+    expect(mergeBlocks(block1, block2)).toEqual("uniform Scene { mat4 view; };\n");
+    // Verify these lines are preserved (they go through dedupeUniforms)
+    expect(dedupe("layout(std140,column_major) uniform;")).toEqual("layout(std140,column_major) uniform;");
+});

package/dist/nodes/code-nodes.js

@@ -0,0 +1,18 @@
+export var mapInputName = function (node, _a) {
+    var _b, _c;
+    var id = _a.id, displayName = _a.displayName;
+    return ((_c = (_b = node.config) === null || _b === void 0 ? void 0 : _b.inputMapping) === null || _c === void 0 ? void 0 : _c[id]) || displayName;
+};
+export var property = function (displayName, property, type, fillerName, defaultValue) { return ({
+    displayName: displayName,
+    type: type,
+    property: property,
+    fillerName: fillerName,
+    defaultValue: defaultValue,
+}); };
+export var SourceType;
+(function (SourceType) {
+    SourceType["EXPRESSION"] = "Expression";
+    SourceType["FN_BODY_FRAGMENT"] = "Function Body Fragment";
+    SourceType["SHADER_FRAGMENT"] = "Shader Fragment";
+})(SourceType || (SourceType = {}));

package/dist/nodes/core-node.js

@@ -0,0 +1,9 @@
+export var nodeInput = function (displayName, id, type, dataType, accepts, bakeable, property) { return ({
+    displayName: displayName,
+    id: id,
+    type: type,
+    dataType: dataType,
+    accepts: accepts,
+    bakeable: bakeable,
+    property: property,
+}); };

package/dist/nodes/data-nodes.js

@@ -0,0 +1,123 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+export var numberNode = function (id, name, position, value, optionals) { return ({
+    type: 'number',
+    id: id,
+    name: name,
+    position: position,
+    value: value,
+    inputs: (optionals === null || optionals === void 0 ? void 0 : optionals.inputs) || [],
+    outputs: (optionals === null || optionals === void 0 ? void 0 : optionals.outputs) || [
+        {
+            name: 'float',
+            id: '1',
+            category: 'data',
+        },
+    ],
+    range: optionals === null || optionals === void 0 ? void 0 : optionals.range,
+    stepper: optionals === null || optionals === void 0 ? void 0 : optionals.stepper,
+}); };
+export var numberUniformData = function (name, value, range, stepper) { return ({
+    type: 'number',
+    name: name,
+    value: value,
+    range: range,
+    stepper: stepper,
+}); };
+export var textureNode = function (id, name, position, value) { return ({
+    type: 'texture',
+    id: id,
+    name: name,
+    position: position,
+    value: value,
+    inputs: [],
+    outputs: [
+        {
+            name: 'texture',
+            id: '1',
+            category: 'data',
+        },
+    ],
+}); };
+export var textureUniformData = function (name, value) { return ({ type: 'texture', name: name, value: value }); };
+export var samplerCubeNode = function (id, name, position, value) { return ({
+    type: 'samplerCube',
+    id: id,
+    name: name,
+    position: position,
+    value: value,
+    inputs: [],
+    outputs: [
+        {
+            name: 'samplerCube',
+            id: '1',
+            category: 'data',
+        },
+    ],
+}); };
+export var samplerCubeUniformData = function (name, value) { return ({ type: 'samplerCube', name: name, value: value }); };
+export function arrayNode(id, name, position, value) {
+    return {
+        id: id,
+        name: name,
+        position: position,
+        inputs: [],
+        outputs: [
+            {
+                name: 'array',
+                id: '1',
+                category: 'data',
+            },
+        ],
+        value: value,
+        dimensions: value.length,
+        type: 'array',
+    };
+}
+export function vectorNode(id, name, position, value) {
+    return __assign({ id: id, name: name, position: position, inputs: [], outputs: [
+            {
+                name: "vector".concat(value.length),
+                id: '1',
+                category: 'data',
+            },
+        ] }, (value.length === 2
+        ? { value: value, dimensions: 2, type: 'vector2' }
+        : value.length === 3
+            ? { value: value, dimensions: 3, type: 'vector3' }
+            : { value: value, dimensions: 4, type: 'vector4' }));
+}
+export var arrayUniformData = function (name, value) { return ({
+    name: name,
+    value: value,
+    dimensions: value.length,
+    type: 'array',
+}); };
+export var vectorUniformData = function (name, value) { return (__assign({ name: name }, (value.length === 2
+    ? { value: value, dimensions: 2, type: 'vector2' }
+    : value.length === 3
+        ? { value: value, dimensions: 3, type: 'vector3' }
+        : { value: value, dimensions: 4, type: 'vector4' }))); };
+export function colorNode(id, name, position, value) {
+    return __assign({ id: id, name: name, position: position, inputs: [], outputs: [
+            {
+                name: value.length === 3 ? 'rgb' : 'rgba',
+                id: '1',
+                category: 'data',
+            },
+        ] }, (value.length === 3
+        ? { value: value, dimensions: 3, type: 'rgb' }
+        : { value: value, dimensions: 4, type: 'rgba' }));
+}
+export var colorUniformData = function (name, value) { return (__assign({ name: name }, (value.length === 3
+    ? { value: value, dimensions: 3, type: 'rgb' }
+    : { value: value, dimensions: 4, type: 'rgba' }))); };

package/dist/nodes/edge.js

@@ -0,0 +1 @@
+export var makeEdge = function (id, from, to, output, input, type) { return ({ id: id, from: from, to: to, output: output, input: input, type: type }); };

package/dist/nodes/engine-node.js

@@ -0,0 +1,189 @@
+import { EngineNodeType } from '../engine';
+import { prepopulatePropertyInputs } from '../graph';
+import { NodeType } from '../graph-types';
+import { assignemntToStrategy, namedAttributeStrategy, texture2DStrategy, uniformStrategy, variableStrategy, } from '../strategy';
+import { SourceType, property, } from './code-nodes';
+/**
+ * TODO: These definitions should live outside of core since I'm trying to
+ * refactor out this core folder to only know about nodes with config config,
+ * where nodes like output/phong/physical are all configured at the
+ * implementation level. "phong" shouldn't be in the core
+ */
+export var sourceNode = function (id, name, position, config, source, stage, originalEngine, nextStageNodeId) { return ({
+    id: id,
+    name: name,
+    groupId: undefined,
+    type: NodeType.SOURCE,
+    config: config,
+    position: position,
+    inputs: [],
+    outputs: [
+        {
+            name: 'vector4',
+            category: 'data',
+            id: '1',
+        },
+    ],
+    source: source,
+    stage: stage,
+    originalEngine: originalEngine,
+    nextStageNodeId: nextStageNodeId,
+}); };
+export var outputNode = function (id, name, position, stage) { return ({
+    id: id,
+    name: name,
+    position: position,
+    groupId: undefined,
+    type: NodeType.OUTPUT,
+    config: {
+        version: 3,
+        mangle: false,
+        preprocess: false,
+        uniforms: [],
+        inputMapping: stage === 'fragment'
+            ? {
+                filler_frogFragOut: 'Color',
+            }
+            : {
+                filler_gl_Position: 'Position',
+            },
+        strategies: [
+            assignemntToStrategy(stage === 'fragment' ? 'frogFragOut' : 'gl_Position'),
+        ],
+    },
+    inputs: [],
+    outputs: [],
+    // Consumed by findVec4Constructo4
+    source: stage === 'fragment'
+        ? "\n#version 300 es\nprecision highp float;\n\nout vec4 frogFragOut;\nvoid main() {\n  frogFragOut = vec4(1.0);\n}\n"
+        : // gl_Position isn't "out"-able apparently https://stackoverflow.com/a/24425436/743464
+            "\n#version 300 es\nprecision highp float;\n\nvoid main() {\n  gl_Position = vec4(1.0);\n}\n",
+    stage: stage,
+}); };
+export var expressionNode = function (id, name, position, source) { return ({
+    id: id,
+    name: name,
+    position: position,
+    type: NodeType.SOURCE,
+    sourceType: SourceType.EXPRESSION,
+    groupId: undefined,
+    stage: undefined,
+    config: {
+        uniforms: [],
+        version: 3,
+        preprocess: false,
+        inputMapping: {},
+        strategies: [variableStrategy()],
+    },
+    inputs: [],
+    outputs: [
+        {
+            name: 'expression',
+            category: 'data',
+            id: '1',
+        },
+    ],
+    source: source,
+}); };
+export var phongNode = function (id, name, groupId, position, stage, nextStageNodeId) {
+    return prepopulatePropertyInputs({
+        id: id,
+        name: name,
+        groupId: groupId,
+        position: position,
+        type: EngineNodeType.phong,
+        config: {
+            version: 3,
+            uniforms: [],
+            preprocess: true,
+            mangle: false,
+            properties: [
+                property('Color', 'color', 'rgb', 'uniform_diffuse'),
+                property('Emissive', 'emissive', 'rgb', 'uniform_emissive'),
+                property('Emissive Map', 'emissiveMap', 'texture', 'filler_emissiveMap'),
+                property('Emissive Intensity', 'emissiveIntensity', 'number', 'uniform_emissive'),
+                property('Texture', 'map', 'texture', 'filler_map'),
+                property('Normal Map', 'normalMap', 'texture', 'filler_normalMap'),
+                property('Normal Scale', 'normalScale', 'vector2'),
+                property('Shininess', 'shininess', 'number'),
+                property('Reflectivity', 'reflectivity', 'number'),
+                property('Refraction Ratio', 'refractionRatio', 'number'),
+                property('Specular', 'specular', 'rgb', 'uniform_specular'),
+                property('Specular Map', 'specularMap', 'texture', 'filler_specularMap'),
+                property('Displacement Map', 'displacementMap', 'texture'),
+                property('Env Map', 'envMap', 'samplerCube'),
+            ],
+            strategies: [
+                uniformStrategy(),
+                stage === 'fragment'
+                    ? texture2DStrategy()
+                    : namedAttributeStrategy('position'),
+            ],
+        },
+        inputs: [],
+        outputs: [
+            {
+                name: 'vector4',
+                category: 'data',
+                id: '1',
+            },
+        ],
+        source: '',
+        stage: stage,
+        nextStageNodeId: nextStageNodeId,
+    });
+};
+export var addNode = function (id, position) { return ({
+    id: id,
+    name: 'add',
+    position: position,
+    type: NodeType.BINARY,
+    groupId: undefined,
+    stage: undefined,
+    config: {
+        mangle: false,
+        version: 3,
+        preprocess: true,
+        strategies: [],
+        uniforms: [],
+    },
+    inputs: [],
+    outputs: [
+        {
+            name: 'sum',
+            category: 'data',
+            id: '1',
+        },
+    ],
+    source: "a + b",
+    operator: '+',
+    sourceType: SourceType.EXPRESSION,
+    biStage: true,
+}); };
+export var multiplyNode = function (id, position) { return ({
+    id: id,
+    name: 'multiply',
+    type: NodeType.BINARY,
+    groupId: undefined,
+    stage: undefined,
+    position: position,
+    config: {
+        version: 3,
+        uniforms: [],
+        mangle: false,
+        preprocess: true,
+        strategies: [],
+    },
+    inputs: [],
+    outputs: [
+        {
+            name: 'product',
+            category: 'data',
+            id: '1',
+        },
+    ],
+    source: "a * b",
+    operator: '*',
+    sourceType: SourceType.EXPRESSION,
+    biStage: true,
+}); };