@shaderfrog/core 1.2.0 → 1.3.0

package/esm/plugins/three/threngine.js

@@ -0,0 +1,608 @@
+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);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+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;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var _a, _b;
+import { ShaderLib, RawShaderMaterial, Vector2, Vector3, Vector4, Color, GLSL3, Light, Texture, MeshPhongMaterial, MeshPhysicalMaterial, MeshToonMaterial, } from 'three';
+import { NodeType } from '../../graph/graph-types';
+import { prepopulatePropertyInputs, mangleMainFn } from '../../graph/graph';
+import importers from './importers';
+import { EngineNodeType } from '../../engine';
+import { doesLinkThruShader, nodeName } from '../../graph/graph';
+import { returnGlPosition, returnGlPositionHardCoded, returnGlPositionVec3Right, } from '../../util/ast';
+import { property, } from '../../graph/code-nodes';
+import { namedAttributeStrategy, texture2DStrategy, uniformStrategy, } from '../../strategy';
+var log = function () {
+    var _a;
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    return (_a = console.log).call.apply(_a, __spreadArray([console, '\x1b[35m(three)\x1b[0m'], __read(args), false));
+};
+export var phongNode = function (id, name, position, uniforms, stage) {
+    return prepopulatePropertyInputs({
+        id: id,
+        name: 'MeshPhongMaterial',
+        position: position,
+        engine: true,
+        type: EngineNodeType.phong,
+        config: {
+            version: 3,
+            uniforms: 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('AO Map', 'aoMap', 'texture', 'filler_aoMap'),
+                property('AO Intensity', 'aoMapIntensity', 'number', 'filler_aoMapIntensity'),
+                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', 'filler_displacementMap'),
+                property('Displacement Scale', 'displacementScale', 'number'),
+                property('Env Map', 'envMap', 'samplerCube'),
+            ],
+            strategies: [
+                uniformStrategy(),
+                stage === 'fragment'
+                    ? texture2DStrategy()
+                    : namedAttributeStrategy('position'),
+            ],
+        },
+        inputs: [],
+        outputs: [
+            {
+                name: 'vector4',
+                dataType: 'vector4',
+                category: 'data',
+                id: '1',
+            },
+        ],
+        source: '',
+        stage: stage,
+    });
+};
+export var physicalNode = function (id, name, position, uniforms, stage) {
+    return prepopulatePropertyInputs({
+        id: id,
+        name: 'MeshPhysicalMaterial',
+        position: position,
+        engine: true,
+        type: EngineNodeType.physical,
+        config: {
+            uniforms: uniforms,
+            version: 3,
+            mangle: false,
+            preprocess: true,
+            properties: [
+                property('Color', 'color', 'rgb', 'uniform_diffuse'),
+                property('Texture', 'map', 'texture', 'filler_map'),
+                property('Opacity', 'opacity', 'number'),
+                property('Normal Map', 'normalMap', 'texture', 'filler_normalMap'),
+                property('Normal Scale', 'normalScale', 'vector2'),
+                property('AO Map', 'aoMap', 'texture', 'filler_aoMap'),
+                property('AO Intensity', 'aoMapIntensity', 'number', 'filler_aoMapIntensity'),
+                property('Metalness', 'metalness', 'number', 'uniform_metalness'),
+                property('Roughness', 'roughness', 'number', 'uniform_roughness'),
+                property('Roughness Map', 'roughnessMap', 'texture', 'filler_roughnessMap'),
+                property('Displacement Map', 'displacementMap', 'texture', 'filler_displacementMap'),
+                property('Displacement Scale', 'displacementScale', 'number'),
+                // MeshPhysicalMaterial gets envMap from the scene. MeshStandardMaterial
+                // gets it from the material
+                // property('Env Map', 'envMap', 'samplerCube'),
+                property('Transmission', 'transmission', 'number'),
+                property('Transmission Map', 'transmissionMap', 'texture', 'filler_transmissionMap'),
+                property('Thickness', 'thickness', 'number'),
+                property('Index of Refraction', 'ior', 'number'),
+                // Sheen only works with directional lights?
+                // https://discourse.threejs.org/t/meshphysicalmaterial-s-sheen/31901/6
+                // property('Sheen', 'sheen', 'number'),
+                property('Reflectivity', 'reflectivity', 'number'),
+                property('Clearcoat', 'clearcoat', 'number'),
+                property('Iridescence', 'iridescence', 'number'),
+                property('Iridescence IOR', 'iridescenceIOR', 'number'),
+                property('Iridescence Thickness Range', 'iridescenceThicknessRange', 'array', undefined, ['100', '400']),
+            ],
+            hardCodedProperties: {
+                isMeshPhysicalMaterial: true,
+                isMeshStandardMaterial: true,
+            },
+            strategies: [
+                uniformStrategy(),
+                stage === 'fragment'
+                    ? texture2DStrategy()
+                    : namedAttributeStrategy('position'),
+            ],
+        },
+        inputs: [],
+        outputs: [
+            {
+                name: 'vector4',
+                dataType: 'vector4',
+                category: 'data',
+                id: '1',
+            },
+        ],
+        source: '',
+        stage: stage,
+    });
+};
+var cacher = function (engineContext, graph, node, sibling, newValue) {
+    var cacheKey = programCacheKey(engineContext, graph, node, sibling);
+    if (engineContext.runtime.cache.data[cacheKey]) {
+        log('Cache hit', cacheKey);
+    }
+    else {
+        log('Cache miss', cacheKey);
+    }
+    var materialData = engineContext.runtime.cache.data[cacheKey] || newValue();
+    engineContext.runtime.cache.data[cacheKey] = materialData;
+    engineContext.runtime.engineMaterial = materialData.material;
+    // TODO: We mutate the nodes here, can we avoid that later?
+    node.source =
+        node.stage === 'fragment' ? materialData.fragment : materialData.vertex;
+    if (sibling) {
+        sibling.source =
+            sibling.stage === 'fragment'
+                ? materialData.fragment
+                : materialData.vertex;
+    }
+};
+var onBeforeCompileMegaShader = function (engineContext, newMat) {
+    log('compiling three megashader!');
+    var _a = engineContext.runtime, renderer = _a.renderer, sceneData = _a.sceneData, scene = _a.scene, camera = _a.camera;
+    var mesh = sceneData.mesh;
+    // Temporarily swap the mesh material to the new one, since materials can
+    // be mesh specific, render, then get its source code
+    var originalMaterial = mesh.material;
+    mesh.material = newMat;
+    renderer.compile(scene, camera);
+    // The references to the compiled shaders in WebGL
+    var fragmentRef = renderer.properties
+        .get(mesh.material)
+        .programs.values()
+        .next().value.fragmentShader;
+    var vertexRef = renderer.properties
+        .get(mesh.material)
+        .programs.values()
+        .next().value.vertexShader;
+    var gl = renderer.getContext();
+    var fragment = gl.getShaderSource(fragmentRef);
+    var vertex = gl.getShaderSource(vertexRef);
+    // Reset the material on the mesh, since the shader we're computing context
+    // for might not be the one actually want on the mesh - like if a toon node
+    // was added to the graph but not connected
+    mesh.material = originalMaterial;
+    // Do we even need to do this? This is just for debugging right? Using the
+    // source on the node is the important thing.
+    return {
+        material: newMat,
+        fragmentRef: fragmentRef,
+        vertexRef: vertexRef,
+        fragment: fragment,
+        vertex: vertex,
+    };
+};
+var megaShaderMainpulateAst = function (engineContext, engine, graph, ast, inputEdges, node, sibling) {
+    var programAst = ast;
+    var mainName = 'main' || nodeName(node);
+    if (node.stage === 'vertex') {
+        if (doesLinkThruShader(graph, node)) {
+            returnGlPositionHardCoded(mainName, programAst, 'vec3', 'transformed');
+        }
+        else {
+            returnGlPosition(mainName, programAst);
+        }
+    }
+    // We specify engine nodes are mangle: false, which is the graph step that
+    // handles renaming the main fn, so we have to do it ourselves
+    mangleMainFn(programAst, node, sibling);
+    return programAst;
+};
+var nodeCacheKey = function (graph, node) {
+    return ('[ID:' +
+        node.id +
+        'Edges:' +
+        graph.edges
+            .filter(function (edge) { return edge.to === node.id; })
+            .map(function (edge) { return "(".concat(edge.to, "->").concat(edge.input, ")"); })
+            .sort()
+            .join(',') +
+        ']'
+    // Currently excluding node inputs because these are calculated *after*
+    // the onbeforecompile, so the next compile, they'll all change!
+    // node.inputs.map((i) => `${i.id}${i.bakeable}`)
+    );
+};
+var programCacheKey = function (engineContext, graph, node, sibling) {
+    // The megashader source is dependent on scene information, like the number
+    // and type of lights in the scene. This kinda sucks - it's duplicating
+    // three's material cache key, and is coupled to how three builds shaders
+    var scene = engineContext.runtime.scene;
+    var lights = [];
+    scene.traverse(function (obj) {
+        if (obj instanceof Light) {
+            lights.push(obj.type);
+        }
+    });
+    return ([node, sibling]
+        .filter(function (n) { return !!n; })
+        .sort(function (a, b) { return a.id.localeCompare(b.id); })
+        .map(function (n) { return nodeCacheKey(graph, n); })
+        .join('-') +
+        '|Lights:' +
+        lights.join(',') +
+        '|Envtex:' +
+        scene.environmentTexture);
+};
+export var defaultPropertySetting = function (property) {
+    if (property.type === 'texture') {
+        return new Texture();
+    }
+    else if (property.type === 'number') {
+        return 0.5;
+    }
+    else if (property.type === 'rgb') {
+        return new Color(1, 1, 1);
+    }
+    else if (property.type === 'rgba') {
+        return new Vector4(1, 1, 1, 1);
+    }
+};
+var threeMaterialProperties = function (graph, node, sibling) {
+    // Find inputs to this node that are dependent on a property of the material
+    var propertyInputs = node.inputs
+        .filter(function (i) { return i.property; })
+        .reduce(function (acc, input) {
+        var _a;
+        return (__assign(__assign({}, acc), (_a = {}, _a[input.id] = input, _a)));
+    }, {});
+    // Then look for any edges into those inputs and set the material property
+    return graph.edges
+        .filter(function (edge) { return edge.to === node.id || edge.to === (sibling === null || sibling === void 0 ? void 0 : sibling.id); })
+        .reduce(function (acc, edge) {
+        // Check if we've plugged into an input for a property
+        var propertyInput = propertyInputs[edge.input];
+        if (propertyInput) {
+            // Find the property itself
+            var property_1 = (node.config.properties || []).find(function (p) { return p.property === propertyInput.property; });
+            // Initialize the property on the material
+            acc[property_1.property] = defaultPropertySetting(property_1);
+        }
+        return acc;
+    }, {});
+};
+var evaluateNode = function (node) {
+    if (node.type === 'number') {
+        return parseFloat(node.value);
+    }
+    if (node.type === 'vector2') {
+        return new Vector2(parseFloat(node.value[0]), parseFloat(node.value[1]));
+    }
+    else if (node.type === 'vector3') {
+        return new Vector3(parseFloat(node.value[0]), parseFloat(node.value[1]), parseFloat(node.value[2]));
+    }
+    else if (node.type === 'vector4') {
+        return new Vector4(parseFloat(node.value[0]), parseFloat(node.value[1]), parseFloat(node.value[2]), parseFloat(node.value[3]));
+    }
+    else if (node.type === 'rgb') {
+        return new Color(parseFloat(node.value[0]), parseFloat(node.value[1]), parseFloat(node.value[2]));
+    }
+    else if (node.type === 'rgba') {
+        return new Vector4(parseFloat(node.value[0]), parseFloat(node.value[1]), parseFloat(node.value[2]), parseFloat(node.value[3]));
+    }
+    else {
+        return node.value;
+    }
+};
+export var toonNode = function (id, name, position, uniforms, stage) {
+    return prepopulatePropertyInputs({
+        id: id,
+        name: 'MeshToonMaterial',
+        position: position,
+        engine: true,
+        type: EngineNodeType.toon,
+        config: {
+            uniforms: uniforms,
+            version: 3,
+            preprocess: true,
+            mangle: false,
+            properties: [
+                property('Color', 'color', 'rgb', 'uniform_diffuse'),
+                property('Texture', 'map', 'texture', 'filler_map'),
+                property('Gradient Map', 'gradientMap', 'texture', 'filler_gradientMap'),
+                property('Normal Map', 'normalMap', 'texture', 'filler_normalMap'),
+                property('Normal Scale', 'normalScale', 'vector2'),
+                property('AO Map', 'aoMap', 'texture', 'filler_aoMap'),
+                property('AO Intensity', 'aoMapIntensity', 'number', 'filler_aoMapIntensity'),
+                property('Displacement Map', 'displacementMap', 'texture', 'filler_displacementMap'),
+                property('Displacement Scale', 'displacementScale', 'number'),
+                property('Env Map', 'envMap', 'samplerCube'),
+            ],
+            strategies: [
+                uniformStrategy(),
+                stage === 'fragment'
+                    ? texture2DStrategy()
+                    : namedAttributeStrategy('position'),
+            ],
+        },
+        inputs: [],
+        outputs: [
+            {
+                name: 'vector4',
+                dataType: 'vector4',
+                category: 'data',
+                id: '1',
+            },
+        ],
+        source: '',
+        stage: stage,
+    });
+};
+export var threngine = {
+    name: 'three',
+    displayName: 'Three.js',
+    importers: importers,
+    mergeOptions: {
+        includePrecisions: true,
+        includeVersion: true,
+    },
+    evaluateNode: evaluateNode,
+    constructors: (_a = {},
+        _a[EngineNodeType.phong] = phongNode,
+        _a[EngineNodeType.physical] = physicalNode,
+        _a[EngineNodeType.toon] = toonNode,
+        _a),
+    // TODO: Get from uniform lib?
+    preserve: new Set([
+        'viewMatrix',
+        'modelMatrix',
+        'modelViewMatrix',
+        'projectionMatrix',
+        'normalMatrix',
+        'uvTransform',
+        // Attributes
+        'position',
+        'normal',
+        'uv',
+        'uv2',
+        'tangent',
+        // Varyings
+        'vUv',
+        'vUv2',
+        'vViewPosition',
+        'vNormal',
+        'vPosition',
+        // Uniforms
+        'cameraPosition',
+        'isOrthographic',
+        'diffuse',
+        'emissive',
+        'specular',
+        'shininess',
+        'opacity',
+        'map',
+        'specularTint',
+        'time',
+        'normalScale',
+        'normalMap',
+        'envMap',
+        'envMapIntensity',
+        'flipEnvMap',
+        'maxMipLevel',
+        'roughnessMap',
+        // Uniforms for lighting
+        'receiveShadow',
+        'ambientLightColor',
+        'lightProbe',
+        // Light uniform arrays
+        'spotLights',
+        'pointLights',
+        // This isn't three wtf
+        'resolution',
+        'color',
+        'image',
+        'gradientMap',
+        // TODO: This isn't specific to threejs as an engine, it's specific to the
+        // phong shader. If a *shader* node has brightness, it should be unique, not
+        // use the threejs one!
+        'brightness',
+        // TODO: These depend on the shaderlib, this might need to be a runtime
+        // concern
+        // Metalness
+        'roughness',
+        'metalness',
+        'ior',
+        'specularIntensity',
+        'clearcoat',
+        'clearcoatRoughness',
+        'transmission',
+        'thickness',
+        'attenuationDistance',
+        'attenuationTint',
+        'transmissionSamplerMap',
+        'transmissionSamplerSize',
+        'displacementMap',
+        'displacementScale',
+        'displacementBias',
+    ]),
+    parsers: (_b = {},
+        _b[NodeType.SOURCE] = {
+            manipulateAst: function (engineContext, engine, graph, ast, inputEdges, node, sibling) {
+                var programAst = ast;
+                var mainName = 'main' || nodeName(node);
+                // This hinges on the vertex shader calling vec3(p)
+                if (node.stage === 'vertex') {
+                    if (doesLinkThruShader(graph, node)) {
+                        returnGlPositionVec3Right(mainName, programAst);
+                    }
+                    else {
+                        returnGlPosition(mainName, programAst);
+                    }
+                }
+                return ast;
+            },
+        },
+        _b[EngineNodeType.phong] = {
+            onBeforeCompile: function (graph, engineContext, node, sibling) { return __awaiter(void 0, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    cacher(engineContext, graph, node, sibling, function () {
+                        return onBeforeCompileMegaShader(engineContext, new MeshPhongMaterial(__assign({ 
+                            // @ts-ignore
+                            isMeshPhongMaterial: true }, threeMaterialProperties(graph, node, sibling))));
+                    });
+                    return [2 /*return*/];
+                });
+            }); },
+            manipulateAst: megaShaderMainpulateAst,
+        },
+        _b[EngineNodeType.physical] = {
+            onBeforeCompile: function (graph, engineContext, node, sibling) { return __awaiter(void 0, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    cacher(engineContext, graph, node, sibling, function () {
+                        return onBeforeCompileMegaShader(engineContext, new MeshPhysicalMaterial(__assign(__assign({}, node.config.hardCodedProperties), threeMaterialProperties(graph, node, sibling))));
+                    });
+                    return [2 /*return*/];
+                });
+            }); },
+            manipulateAst: megaShaderMainpulateAst,
+        },
+        _b[EngineNodeType.toon] = {
+            onBeforeCompile: function (graph, engineContext, node, sibling) { return __awaiter(void 0, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    cacher(engineContext, graph, node, sibling, function () {
+                        return onBeforeCompileMegaShader(engineContext, new MeshToonMaterial(__assign({ gradientMap: new Texture(), 
+                            // @ts-ignore
+                            isMeshToonMaterial: true }, threeMaterialProperties(graph, node, sibling))));
+                    });
+                    return [2 /*return*/];
+                });
+            }); },
+            manipulateAst: megaShaderMainpulateAst,
+        },
+        _b),
+};
+export var createMaterial = function (compileResult, ctx) {
+    var engineMaterial = ctx.runtime.engineMaterial;
+    var finalUniforms = __assign(__assign(__assign(__assign({}, ShaderLib.phong.uniforms), ShaderLib.toon.uniforms), ShaderLib.physical.uniforms), { time: { value: 0 }, cameraPosition: { value: new Vector3(1.0) } });
+    // Also the ThreeComponent's sceneConfig properties modify the material
+    var initialProperties = {
+        name: 'ShaderFrog Material',
+        lights: true,
+        uniforms: __assign({}, finalUniforms),
+        // See https://github.com/mrdoob/three.js/pull/26809
+        glslVersion: GLSL3,
+        vertexShader: compileResult === null || compileResult === void 0 ? void 0 : compileResult.vertexResult.replace('#version 300 es', ''),
+        fragmentShader: compileResult === null || compileResult === void 0 ? void 0 : compileResult.fragmentResult.replace('#version 300 es', ''),
+    };
+    var additionalProperties = Object.entries(__assign({}, engineMaterial))
+        .filter(function (_a) {
+        var _b = __read(_a, 1), property = _b[0];
+        // Ignore three material "hidden" properties
+        return property.charAt(0) !== '_' &&
+            // Ignore uuid since it should probably be unique?
+            property !== 'uuid' &&
+            // I'm not sure what three does with type under the hood, ignore it
+            property !== 'type' &&
+            // "precision" adds a precision preprocessor line
+            property !== 'precision' &&
+            // Ignore existing properties
+            !(property in initialProperties) &&
+            // Ignore STANDARD and PHYSICAL defines to the top of the shader in
+            // WebGLProgram
+            // https://github.com/mrdoob/three.js/blob/e7042de7c1a2c70e38654a04b6fd97d9c978e781/src/renderers/webgl/WebGLProgram.js#L392
+            // which occurs if we set isMeshPhysicalMaterial/isMeshStandardMaterial
+            property !== 'defines';
+    })
+        .reduce(function (acc, _a) {
+        var _b;
+        var _c = __read(_a, 2), key = _c[0], value = _c[1];
+        return (__assign(__assign({}, acc), (_b = {}, _b[key] = value, _b)));
+    }, {});
+    var material = new RawShaderMaterial(initialProperties);
+    // This prevents a deluge of warnings from three on the constructor saying
+    // that each of these properties is not a property of the material
+    Object.entries(additionalProperties).forEach(function (_a) {
+        var _b = __read(_a, 2), key = _b[0], value = _b[1];
+        // @ts-ignore
+        material[key] = value;
+    });
+    return material;
+};

package/esm/strategy/assignemntTo.d.ts

@@ -0,0 +1,9 @@
+import { BaseStrategy, ApplyStrategy, StrategyType } from '.';
+export interface AssignemntToStrategy extends BaseStrategy {
+    type: StrategyType.ASSIGNMENT_TO;
+    config: {
+        assignTo: string;
+    };
+}
+export declare const assignemntToStrategy: (assignTo: string) => AssignemntToStrategy;
+export declare const applyAssignmentToStrategy: ApplyStrategy<AssignemntToStrategy>;

package/esm/strategy/assignemntTo.js

@@ -0,0 +1,26 @@
+import { findAssignmentTo } from '../util/ast';
+import { nodeInput } from '../graph/base-node';
+import { StrategyType } from '.';
+// Constructor
+export var assignemntToStrategy = function (assignTo) { return ({
+    type: StrategyType.ASSIGNMENT_TO,
+    config: { assignTo: assignTo },
+}); };
+// Apply the strategy
+export var applyAssignmentToStrategy = function (strategy, ast, graphNode, siblingNode) {
+    var assignNode = findAssignmentTo(ast, strategy.config.assignTo);
+    var name = strategy.config.assignTo;
+    return assignNode
+        ? [
+            [
+                nodeInput(name, "filler_".concat(name), 'filler', undefined, // Data type for what plugs into this filler
+                ['code', 'data'], false),
+                function (fillerAst) {
+                    assignNode.expression.right =
+                        fillerAst;
+                    return ast;
+                },
+            ],
+        ]
+        : [];
+};

package/esm/strategy/declarationOf.d.ts

@@ -0,0 +1,9 @@
+import { BaseStrategy, ApplyStrategy, StrategyType } from '.';
+export declare const declarationOfStrategy: (declarationOf: string) => DeclarationOfStrategy;
+export interface DeclarationOfStrategy extends BaseStrategy {
+    type: StrategyType.DECLARATION_OF;
+    config: {
+        declarationOf: string;
+    };
+}
+export declare const constApplyDeclarationOf: ApplyStrategy<DeclarationOfStrategy>;

package/esm/strategy/declarationOf.js

@@ -0,0 +1,23 @@
+import { findDeclarationOf } from '../util/ast';
+import { nodeInput } from '../graph/base-node';
+import { StrategyType } from '.';
+export var declarationOfStrategy = function (declarationOf) { return ({
+    type: StrategyType.DECLARATION_OF,
+    config: { declarationOf: declarationOf },
+}); };
+export var constApplyDeclarationOf = function (strategy, ast, graphNode, siblingNode) {
+    var declaration = findDeclarationOf(ast, strategy.config.declarationOf);
+    var name = strategy.config.declarationOf;
+    return declaration
+        ? [
+            [
+                nodeInput(name, "filler_".concat(name), 'filler', undefined, // Data type for what plugs into this filler
+                ['code', 'data'], false),
+                function (fillerAst) {
+                    declaration.initializer = fillerAst;
+                    return ast;
+                },
+            ],
+        ]
+        : [];
+};