@shaderfrog/core 1.3.0 → 1.3.2

package/cjs/plugins/three/threngine.js

@@ -1,619 +0,0 @@
-"use strict";
-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 __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-var _a, _b;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createMaterial = exports.threngine = exports.toonNode = exports.defaultPropertySetting = exports.physicalNode = exports.phongNode = void 0;
-var three_1 = require("three");
-var graph_types_1 = require("../../graph/graph-types");
-var graph_1 = require("../../graph/graph");
-var importers_1 = __importDefault(require("./importers"));
-var engine_1 = require("../../engine");
-var graph_2 = require("../../graph/graph");
-var ast_1 = require("../../util/ast");
-var code_nodes_1 = require("../../graph/code-nodes");
-var strategy_1 = require("../../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));
-};
-var phongNode = function (id, name, position, uniforms, stage) {
-    return (0, graph_1.prepopulatePropertyInputs)({
-        id: id,
-        name: 'MeshPhongMaterial',
-        position: position,
-        engine: true,
-        type: engine_1.EngineNodeType.phong,
-        config: {
-            version: 3,
-            uniforms: uniforms,
-            preprocess: true,
-            mangle: false,
-            properties: [
-                (0, code_nodes_1.property)('Color', 'color', 'rgb', 'uniform_diffuse'),
-                (0, code_nodes_1.property)('Emissive', 'emissive', 'rgb', 'uniform_emissive'),
-                (0, code_nodes_1.property)('Emissive Map', 'emissiveMap', 'texture', 'filler_emissiveMap'),
-                (0, code_nodes_1.property)('Emissive Intensity', 'emissiveIntensity', 'number', 'uniform_emissive'),
-                (0, code_nodes_1.property)('Texture', 'map', 'texture', 'filler_map'),
-                (0, code_nodes_1.property)('Normal Map', 'normalMap', 'texture', 'filler_normalMap'),
-                (0, code_nodes_1.property)('Normal Scale', 'normalScale', 'vector2'),
-                (0, code_nodes_1.property)('AO Map', 'aoMap', 'texture', 'filler_aoMap'),
-                (0, code_nodes_1.property)('AO Intensity', 'aoMapIntensity', 'number', 'filler_aoMapIntensity'),
-                (0, code_nodes_1.property)('Shininess', 'shininess', 'number'),
-                (0, code_nodes_1.property)('Reflectivity', 'reflectivity', 'number'),
-                (0, code_nodes_1.property)('Refraction Ratio', 'refractionRatio', 'number'),
-                (0, code_nodes_1.property)('Specular', 'specular', 'rgb', 'uniform_specular'),
-                (0, code_nodes_1.property)('Specular Map', 'specularMap', 'texture', 'filler_specularMap'),
-                (0, code_nodes_1.property)('Displacement Map', 'displacementMap', 'texture', 'filler_displacementMap'),
-                (0, code_nodes_1.property)('Displacement Scale', 'displacementScale', 'number'),
-                (0, code_nodes_1.property)('Env Map', 'envMap', 'samplerCube'),
-            ],
-            strategies: [
-                (0, strategy_1.uniformStrategy)(),
-                stage === 'fragment'
-                    ? (0, strategy_1.texture2DStrategy)()
-                    : (0, strategy_1.namedAttributeStrategy)('position'),
-            ],
-        },
-        inputs: [],
-        outputs: [
-            {
-                name: 'vector4',
-                dataType: 'vector4',
-                category: 'data',
-                id: '1',
-            },
-        ],
-        source: '',
-        stage: stage,
-    });
-};
-exports.phongNode = phongNode;
-var physicalNode = function (id, name, position, uniforms, stage) {
-    return (0, graph_1.prepopulatePropertyInputs)({
-        id: id,
-        name: 'MeshPhysicalMaterial',
-        position: position,
-        engine: true,
-        type: engine_1.EngineNodeType.physical,
-        config: {
-            uniforms: uniforms,
-            version: 3,
-            mangle: false,
-            preprocess: true,
-            properties: [
-                (0, code_nodes_1.property)('Color', 'color', 'rgb', 'uniform_diffuse'),
-                (0, code_nodes_1.property)('Texture', 'map', 'texture', 'filler_map'),
-                (0, code_nodes_1.property)('Opacity', 'opacity', 'number'),
-                (0, code_nodes_1.property)('Normal Map', 'normalMap', 'texture', 'filler_normalMap'),
-                (0, code_nodes_1.property)('Normal Scale', 'normalScale', 'vector2'),
-                (0, code_nodes_1.property)('AO Map', 'aoMap', 'texture', 'filler_aoMap'),
-                (0, code_nodes_1.property)('AO Intensity', 'aoMapIntensity', 'number', 'filler_aoMapIntensity'),
-                (0, code_nodes_1.property)('Metalness', 'metalness', 'number', 'uniform_metalness'),
-                (0, code_nodes_1.property)('Roughness', 'roughness', 'number', 'uniform_roughness'),
-                (0, code_nodes_1.property)('Roughness Map', 'roughnessMap', 'texture', 'filler_roughnessMap'),
-                (0, code_nodes_1.property)('Displacement Map', 'displacementMap', 'texture', 'filler_displacementMap'),
-                (0, code_nodes_1.property)('Displacement Scale', 'displacementScale', 'number'),
-                // MeshPhysicalMaterial gets envMap from the scene. MeshStandardMaterial
-                // gets it from the material
-                // property('Env Map', 'envMap', 'samplerCube'),
-                (0, code_nodes_1.property)('Transmission', 'transmission', 'number'),
-                (0, code_nodes_1.property)('Transmission Map', 'transmissionMap', 'texture', 'filler_transmissionMap'),
-                (0, code_nodes_1.property)('Thickness', 'thickness', 'number'),
-                (0, code_nodes_1.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'),
-                (0, code_nodes_1.property)('Reflectivity', 'reflectivity', 'number'),
-                (0, code_nodes_1.property)('Clearcoat', 'clearcoat', 'number'),
-                (0, code_nodes_1.property)('Iridescence', 'iridescence', 'number'),
-                (0, code_nodes_1.property)('Iridescence IOR', 'iridescenceIOR', 'number'),
-                (0, code_nodes_1.property)('Iridescence Thickness Range', 'iridescenceThicknessRange', 'array', undefined, ['100', '400']),
-            ],
-            hardCodedProperties: {
-                isMeshPhysicalMaterial: true,
-                isMeshStandardMaterial: true,
-            },
-            strategies: [
-                (0, strategy_1.uniformStrategy)(),
-                stage === 'fragment'
-                    ? (0, strategy_1.texture2DStrategy)()
-                    : (0, strategy_1.namedAttributeStrategy)('position'),
-            ],
-        },
-        inputs: [],
-        outputs: [
-            {
-                name: 'vector4',
-                dataType: 'vector4',
-                category: 'data',
-                id: '1',
-            },
-        ],
-        source: '',
-        stage: stage,
-    });
-};
-exports.physicalNode = physicalNode;
-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' || (0, graph_2.nodeName)(node);
-    if (node.stage === 'vertex') {
-        if ((0, graph_2.doesLinkThruShader)(graph, node)) {
-            (0, ast_1.returnGlPositionHardCoded)(mainName, programAst, 'vec3', 'transformed');
-        }
-        else {
-            (0, ast_1.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
-    (0, graph_1.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 three_1.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);
-};
-var defaultPropertySetting = function (property) {
-    if (property.type === 'texture') {
-        return new three_1.Texture();
-    }
-    else if (property.type === 'number') {
-        return 0.5;
-    }
-    else if (property.type === 'rgb') {
-        return new three_1.Color(1, 1, 1);
-    }
-    else if (property.type === 'rgba') {
-        return new three_1.Vector4(1, 1, 1, 1);
-    }
-};
-exports.defaultPropertySetting = defaultPropertySetting;
-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] = (0, exports.defaultPropertySetting)(property_1);
-        }
-        return acc;
-    }, {});
-};
-var evaluateNode = function (node) {
-    if (node.type === 'number') {
-        return parseFloat(node.value);
-    }
-    if (node.type === 'vector2') {
-        return new three_1.Vector2(parseFloat(node.value[0]), parseFloat(node.value[1]));
-    }
-    else if (node.type === 'vector3') {
-        return new three_1.Vector3(parseFloat(node.value[0]), parseFloat(node.value[1]), parseFloat(node.value[2]));
-    }
-    else if (node.type === 'vector4') {
-        return new three_1.Vector4(parseFloat(node.value[0]), parseFloat(node.value[1]), parseFloat(node.value[2]), parseFloat(node.value[3]));
-    }
-    else if (node.type === 'rgb') {
-        return new three_1.Color(parseFloat(node.value[0]), parseFloat(node.value[1]), parseFloat(node.value[2]));
-    }
-    else if (node.type === 'rgba') {
-        return new three_1.Vector4(parseFloat(node.value[0]), parseFloat(node.value[1]), parseFloat(node.value[2]), parseFloat(node.value[3]));
-    }
-    else {
-        return node.value;
-    }
-};
-var toonNode = function (id, name, position, uniforms, stage) {
-    return (0, graph_1.prepopulatePropertyInputs)({
-        id: id,
-        name: 'MeshToonMaterial',
-        position: position,
-        engine: true,
-        type: engine_1.EngineNodeType.toon,
-        config: {
-            uniforms: uniforms,
-            version: 3,
-            preprocess: true,
-            mangle: false,
-            properties: [
-                (0, code_nodes_1.property)('Color', 'color', 'rgb', 'uniform_diffuse'),
-                (0, code_nodes_1.property)('Texture', 'map', 'texture', 'filler_map'),
-                (0, code_nodes_1.property)('Gradient Map', 'gradientMap', 'texture', 'filler_gradientMap'),
-                (0, code_nodes_1.property)('Normal Map', 'normalMap', 'texture', 'filler_normalMap'),
-                (0, code_nodes_1.property)('Normal Scale', 'normalScale', 'vector2'),
-                (0, code_nodes_1.property)('AO Map', 'aoMap', 'texture', 'filler_aoMap'),
-                (0, code_nodes_1.property)('AO Intensity', 'aoMapIntensity', 'number', 'filler_aoMapIntensity'),
-                (0, code_nodes_1.property)('Displacement Map', 'displacementMap', 'texture', 'filler_displacementMap'),
-                (0, code_nodes_1.property)('Displacement Scale', 'displacementScale', 'number'),
-                (0, code_nodes_1.property)('Env Map', 'envMap', 'samplerCube'),
-            ],
-            strategies: [
-                (0, strategy_1.uniformStrategy)(),
-                stage === 'fragment'
-                    ? (0, strategy_1.texture2DStrategy)()
-                    : (0, strategy_1.namedAttributeStrategy)('position'),
-            ],
-        },
-        inputs: [],
-        outputs: [
-            {
-                name: 'vector4',
-                dataType: 'vector4',
-                category: 'data',
-                id: '1',
-            },
-        ],
-        source: '',
-        stage: stage,
-    });
-};
-exports.toonNode = toonNode;
-exports.threngine = {
-    name: 'three',
-    displayName: 'Three.js',
-    importers: importers_1.default,
-    mergeOptions: {
-        includePrecisions: true,
-        includeVersion: true,
-    },
-    evaluateNode: evaluateNode,
-    constructors: (_a = {},
-        _a[engine_1.EngineNodeType.phong] = exports.phongNode,
-        _a[engine_1.EngineNodeType.physical] = exports.physicalNode,
-        _a[engine_1.EngineNodeType.toon] = exports.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[graph_types_1.NodeType.SOURCE] = {
-            manipulateAst: function (engineContext, engine, graph, ast, inputEdges, node, sibling) {
-                var programAst = ast;
-                var mainName = 'main' || (0, graph_2.nodeName)(node);
-                // This hinges on the vertex shader calling vec3(p)
-                if (node.stage === 'vertex') {
-                    if ((0, graph_2.doesLinkThruShader)(graph, node)) {
-                        (0, ast_1.returnGlPositionVec3Right)(mainName, programAst);
-                    }
-                    else {
-                        (0, ast_1.returnGlPosition)(mainName, programAst);
-                    }
-                }
-                return ast;
-            },
-        },
-        _b[engine_1.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 three_1.MeshPhongMaterial(__assign({ 
-                            // @ts-ignore
-                            isMeshPhongMaterial: true }, threeMaterialProperties(graph, node, sibling))));
-                    });
-                    return [2 /*return*/];
-                });
-            }); },
-            manipulateAst: megaShaderMainpulateAst,
-        },
-        _b[engine_1.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 three_1.MeshPhysicalMaterial(__assign(__assign({}, node.config.hardCodedProperties), threeMaterialProperties(graph, node, sibling))));
-                    });
-                    return [2 /*return*/];
-                });
-            }); },
-            manipulateAst: megaShaderMainpulateAst,
-        },
-        _b[engine_1.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 three_1.MeshToonMaterial(__assign({ gradientMap: new three_1.Texture(), 
-                            // @ts-ignore
-                            isMeshToonMaterial: true }, threeMaterialProperties(graph, node, sibling))));
-                    });
-                    return [2 /*return*/];
-                });
-            }); },
-            manipulateAst: megaShaderMainpulateAst,
-        },
-        _b),
-};
-var createMaterial = function (compileResult, ctx) {
-    var engineMaterial = ctx.runtime.engineMaterial;
-    var finalUniforms = __assign(__assign(__assign(__assign({}, three_1.ShaderLib.phong.uniforms), three_1.ShaderLib.toon.uniforms), three_1.ShaderLib.physical.uniforms), { time: { value: 0 }, cameraPosition: { value: new three_1.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: three_1.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 three_1.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;
-};
-exports.createMaterial = createMaterial;

package/cjs/strategy/assignemntTo.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyAssignmentToStrategy = exports.assignemntToStrategy = void 0;
-var ast_1 = require("../util/ast");
-var base_node_1 = require("../graph/base-node");
-var _1 = require(".");
-// Constructor
-var assignemntToStrategy = function (assignTo) { return ({
-    type: _1.StrategyType.ASSIGNMENT_TO,
-    config: { assignTo: assignTo },
-}); };
-exports.assignemntToStrategy = assignemntToStrategy;
-// Apply the strategy
-var applyAssignmentToStrategy = function (strategy, ast, graphNode, siblingNode) {
-    var assignNode = (0, ast_1.findAssignmentTo)(ast, strategy.config.assignTo);
-    var name = strategy.config.assignTo;
-    return assignNode
-        ? [
-            [
-                (0, base_node_1.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;
-                },
-            ],
-        ]
-        : [];
-};
-exports.applyAssignmentToStrategy = applyAssignmentToStrategy;

package/cjs/strategy/declarationOf.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.constApplyDeclarationOf = exports.declarationOfStrategy = void 0;
-var ast_1 = require("../util/ast");
-var base_node_1 = require("../graph/base-node");
-var _1 = require(".");
-var declarationOfStrategy = function (declarationOf) { return ({
-    type: _1.StrategyType.DECLARATION_OF,
-    config: { declarationOf: declarationOf },
-}); };
-exports.declarationOfStrategy = declarationOfStrategy;
-var constApplyDeclarationOf = function (strategy, ast, graphNode, siblingNode) {
-    var declaration = (0, ast_1.findDeclarationOf)(ast, strategy.config.declarationOf);
-    var name = strategy.config.declarationOf;
-    return declaration
-        ? [
-            [
-                (0, base_node_1.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;
-                },
-            ],
-        ]
-        : [];
-};
-exports.constApplyDeclarationOf = constApplyDeclarationOf;