@shaderfrog/core 1.3.0 → 1.3.2

package/cjs/plugins/babylon/bablyengine.js

@@ -1,597 +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.babylengine = exports.mIdx = exports.toonNode = exports.physicalNode = exports.physicalDefaultProperties = void 0;
-var babylonjs_1 = require("babylonjs");
-var engine_1 = require("../../engine");
-var graph_1 = require("../../graph/graph");
-var graph_types_1 = require("../../graph/graph-types");
-var importers_1 = __importDefault(require("./importers"));
-var ast_1 = require("../../util/ast");
-var code_nodes_1 = require("../../graph/code-nodes");
-var strategy_1 = require("../../strategy");
-// Setting these properties on the material have side effects, not just for the
-// GLSL, but for the material itself in JS memory apparently, maybe the bound
-// uniforms?. The material we create in babylengine must have the same initial
-// properties as those in BabylonComponent or else there will be errors with
-// uniforms
-exports.physicalDefaultProperties = {
-    forceIrradianceInFragment: true,
-    albedoColor: new babylonjs_1.Color3(1.0, 1.0, 1.0),
-    metallic: 0.0,
-    roughness: 1.0,
-};
-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[33m(babylengine)\x1b[0m'], __read(args), false));
-};
-var babylonHackCache = {};
-var physicalNode = function (id, name, position, uniforms, stage) {
-    return (0, graph_1.prepopulatePropertyInputs)({
-        id: id,
-        name: 'PBRMaterial',
-        position: position,
-        engine: true,
-        type: engine_1.EngineNodeType.physical,
-        config: {
-            uniforms: uniforms,
-            version: 3,
-            mangle: false,
-            preprocess: true,
-            properties: [
-                (0, code_nodes_1.property)('Base Color', 'baseColor', 'rgb', '?????'),
-                (0, code_nodes_1.property)('Color', 'albedoColor', 'rgb', 'uniform_vAlbedoColor'),
-                (0, code_nodes_1.property)('Texture', 'albedoTexture', 'texture', 'filler_albedoSampler'),
-                (0, code_nodes_1.property)('Bump Map', 'bumpTexture', 'texture', 'filler_bumpSampler'),
-                (0, code_nodes_1.property)('Metalness', 'metallic', 'number'),
-                (0, code_nodes_1.property)('Roughness', 'roughness', 'number'),
-                (0, code_nodes_1.property)('Env Map', 'environmentTexture', 'samplerCube'),
-                (0, code_nodes_1.property)('Reflection Texture', 'reflectionTexture', 'samplerCube'),
-                (0, code_nodes_1.property)('Refraction Texture', 'refractionTexture', 'samplerCube'),
-                (0, code_nodes_1.property)('Index Of Refraction', 'indexOfRefraction', 'number'),
-                (0, code_nodes_1.property)('Alpha', 'alpha', 'number'),
-                (0, code_nodes_1.property)('Direct Intensity', 'directIntensity', 'number'),
-                (0, code_nodes_1.property)('Environment Intensity', 'environmentIntensity', 'number'),
-                (0, code_nodes_1.property)('Camera Exposure', 'cameraExposure', 'number'),
-                (0, code_nodes_1.property)('Camera Contrast', 'cameraContrast', 'number'),
-                (0, code_nodes_1.property)('Micro Surface', 'microSurface', 'number'),
-                (0, code_nodes_1.property)('Reflectivity Color', 'reflectivityColor', 'rgb'),
-            ],
-            hardCodedProperties: exports.physicalDefaultProperties,
-            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 toonNode = function (id, name, position, uniforms, stage) {
-    return (0, graph_1.prepopulatePropertyInputs)({
-        id: id,
-        name: name,
-        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)('Displacement Map', 'displacementMap', 'texture'),
-                (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;
-var babylonMaterialProperties = function (scene, 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
-    var props = 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
-            if (property_1.type === 'texture') {
-                acc[property_1.property] = new babylonjs_1.Texture('', scene);
-            }
-            else if (property_1.type === 'number') {
-                acc[property_1.property] = 0.5;
-            }
-            else if (property_1.type === 'rgb') {
-                acc[property_1.property] = new babylonjs_1.Color3(1, 1, 1);
-            }
-            else if (property_1.type === 'rgba') {
-                acc[property_1.property] = new babylonjs_1.Color4(1, 1, 1, 1);
-            }
-        }
-        return acc;
-    }, {});
-    return props;
-};
-exports.mIdx = 0;
-var id = function () { return exports.mIdx++; };
-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.getNodes().filter(function (n) { return n instanceof babylonjs_1.Light; });
-    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 cacher = function (engineContext, graph, node, sibling, newValue) { return __awaiter(void 0, void 0, void 0, function () {
-    var cacheKey, materialData;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                cacheKey = programCacheKey(engineContext, graph, node, sibling);
-                if (engineContext.runtime.cache.data[cacheKey]) {
-                    log("Cache hit \"".concat(cacheKey, "\""));
-                }
-                else {
-                    log("Cache miss \"".concat(cacheKey, "\""));
-                }
-                return [4 /*yield*/, (engineContext.runtime.cache.data[cacheKey] ||
-                        newValue())];
-            case 1:
-                materialData = _a.sent();
-                log("Material cache \"".concat(cacheKey, "\" is now"), materialData);
-                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;
-                }
-                return [2 /*return*/];
-        }
-    });
-}); };
-var onBeforeCompileMegaShader = function (engineContext, graph, node, sibling) { return __awaiter(void 0, void 0, void 0, function () {
-    var _a, scene, sceneData, pbrName, shaderMaterial, newProperties, vertexSource, fragmentSource, genHackCacheKey, hackKey;
-    var _b;
-    return __generator(this, function (_c) {
-        _a = engineContext.runtime, scene = _a.scene, sceneData = _a.sceneData;
-        pbrName = "engine_pbr".concat(id());
-        shaderMaterial = new babylonjs_1.PBRMaterial(pbrName, scene);
-        shaderMaterial.linkRefractionWithTransparency = true;
-        shaderMaterial.subSurface.isRefractionEnabled = true;
-        newProperties = __assign(__assign({}, (node.config.hardCodedProperties ||
-            ((_b = sibling === null || sibling === void 0 ? void 0 : sibling.config) === null || _b === void 0 ? void 0 : _b.hardCodedProperties) ||
-            {})), babylonMaterialProperties(scene, graph, node, sibling));
-        Object.assign(shaderMaterial, newProperties);
-        log('Engine megashader initial properties', { newProperties: newProperties });
-        genHackCacheKey = function (unknown) {
-            return unknown.toString();
-        };
-        return [2 /*return*/, new Promise(function (resolve) {
-                shaderMaterial.customShaderNameResolve = function (shaderName, uniforms, uniformBuffers, samplers, defines, attributes, options) {
-                    hackKey = genHackCacheKey(defines);
-                    log('Babylengine creating new shader', {
-                        uniforms: uniforms,
-                        uniformBuffers: uniformBuffers,
-                        samplers: samplers,
-                        defines: defines,
-                        attributes: attributes,
-                        options: options,
-                    });
-                    if (options) {
-                        options.processFinalCode = function (type, code) {
-                            // If babylon thinks it has cached code for a new shader,
-                            // processFinalCode doesn't get called. This hack attempt is to try to
-                            // recreate Babylon's internal cache, based on my understanding that
-                            // babylon looks to the defines to determine shader uniqueness
-                            babylonHackCache[hackKey] = babylonHackCache[hackKey] || {
-                                fragment: '',
-                                vertex: '',
-                            };
-                            if (type === 'vertex') {
-                                log('captured vertex code', { code: code });
-                                vertexSource = code;
-                                babylonHackCache[hackKey].vertex = code;
-                                return code;
-                            }
-                            else if (type === 'fragment') {
-                                log('captured fragment code', { code: code });
-                                fragmentSource = code;
-                                babylonHackCache[hackKey].fragment = code;
-                                return code;
-                            }
-                            throw new Error("Unknown type ".concat(type));
-                        };
-                    }
-                    else {
-                        console.warn('No options for', pbrName);
-                    }
-                    return shaderName;
-                };
-                if (!sceneData.mesh) {
-                    log('🍃 EFF, no MESHREF RENDER()....');
-                }
-                shaderMaterial.forceCompilation(sceneData.mesh, function (compiledMaterial) {
-                    var _a, _b;
-                    log('Babylon shader compilation done!');
-                    if (!fragmentSource || !vertexSource) {
-                        log('Reusing previous mesh render...');
-                        vertexSource = (_a = babylonHackCache[hackKey]) === null || _a === void 0 ? void 0 : _a.vertex;
-                        fragmentSource = (_b = babylonHackCache[hackKey]) === null || _b === void 0 ? void 0 : _b.fragment;
-                    }
-                    if (!fragmentSource || !vertexSource) {
-                        debugger;
-                    }
-                    log('captured', { fragmentSource: fragmentSource, vertexSource: vertexSource });
-                    if (node.stage === 'fragment') {
-                        node.source = fragmentSource;
-                    }
-                    if ((sibling === null || sibling === void 0 ? void 0 : sibling.stage) === 'fragment') {
-                        sibling.source = fragmentSource;
-                    }
-                    if (node.stage === 'vertex') {
-                        node.source = vertexSource;
-                    }
-                    if ((sibling === null || sibling === void 0 ? void 0 : sibling.stage) === 'vertex') {
-                        sibling.source = vertexSource;
-                    }
-                    engineContext.runtime.cache.nodes[node.id] = {
-                        // fragmentRef,
-                        // vertexRef,
-                        fragment: fragmentSource,
-                        vertex: vertexSource,
-                    };
-                    // This doesn't appear to do anything (see comment above submeshes)
-                    compiledMaterial.dispose(true);
-                    resolve({
-                        material: compiledMaterial,
-                        fragment: fragmentSource,
-                        vertex: vertexSource,
-                    });
-                });
-            })];
-    });
-}); };
-// TODO: NEED TO DO SAME THREE MANGLIGN STEP HERE
-var megaShaderMainpulateAst = function (engineContext, engine, graph, ast, inputEdges, node, sibling) {
-    var programAst = ast;
-    var mainName = 'main' || (0, graph_1.nodeName)(node);
-    if (node.stage === 'vertex') {
-        if ((0, graph_1.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 evaluateNode = function (node) {
-    if (node.type === 'number') {
-        return parseFloat(node.value);
-    }
-    if (node.type === 'vector2') {
-        return new babylonjs_1.Vector2(parseFloat(node.value[0]), parseFloat(node.value[1]));
-    }
-    else if (node.type === 'vector3') {
-        return new babylonjs_1.Vector3(parseFloat(node.value[0]), parseFloat(node.value[1]), parseFloat(node.value[2]));
-    }
-    else if (node.type === 'vector4') {
-        return new babylonjs_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 babylonjs_1.Color3(parseFloat(node.value[0]), parseFloat(node.value[1]), parseFloat(node.value[2]));
-    }
-    else if (node.type === 'rgba') {
-        return new babylonjs_1.Color4(parseFloat(node.value[0]), parseFloat(node.value[1]), parseFloat(node.value[2]), parseFloat(node.value[3]));
-    }
-    else {
-        return node.value;
-    }
-};
-exports.babylengine = {
-    name: 'babylon',
-    displayName: 'Babylon.js',
-    importers: importers_1.default,
-    mergeOptions: {
-        includePrecisions: true,
-        includeVersion: false,
-    },
-    evaluateNode: evaluateNode,
-    constructors: (_a = {},
-        _a[engine_1.EngineNodeType.physical] = exports.physicalNode,
-        _a[engine_1.EngineNodeType.toon] = exports.toonNode,
-        _a),
-    // TODO: Get from uniform lib?
-    preserve: new Set([
-        'viewProjection',
-        'normalMatrix',
-        'vAmbientInfos',
-        'vOpacityInfos',
-        'vEmissiveInfos',
-        'vLightmapInfos',
-        'vReflectivityInfos',
-        'vMicroSurfaceSamplerInfos',
-        'vReflectionInfos',
-        'vReflectionFilteringInfo',
-        'vReflectionPosition',
-        'vReflectionSize',
-        'vBumpInfos',
-        'albedoMatrix',
-        'ambientMatrix',
-        'opacityMatrix',
-        'emissiveMatrix',
-        'lightmapMatrix',
-        'reflectivityMatrix',
-        'microSurfaceSamplerMatrix',
-        'bumpMatrix',
-        'bumpSampler',
-        'vTangentSpaceParams',
-        'reflectionMatrix',
-        'vReflectionColor',
-        'vAlbedoColor',
-        'vLightingIntensity',
-        'vReflectionMicrosurfaceInfos',
-        'pointSize',
-        'vReflectivityColor',
-        'vEmissiveColor',
-        'visibility',
-        'vMetallicReflectanceFactors',
-        'vMetallicReflectanceInfos',
-        'metallicReflectanceMatrix',
-        'vClearCoatParams',
-        'vClearCoatRefractionParams',
-        'vClearCoatInfos',
-        'clearCoatMatrix',
-        'clearCoatRoughnessMatrix',
-        'vClearCoatBumpInfos',
-        'vClearCoatTangentSpaceParams',
-        'clearCoatBumpMatrix',
-        'vClearCoatTintParams',
-        'clearCoatColorAtDistance',
-        'vClearCoatTintInfos',
-        'clearCoatTintMatrix',
-        'vAnisotropy',
-        'vAnisotropyInfos',
-        'anisotropyMatrix',
-        'vSheenColor',
-        'vSheenRoughness',
-        'vSheenInfos',
-        'sheenMatrix',
-        'sheenRoughnessMatrix',
-        'vRefractionMicrosurfaceInfos',
-        'vRefractionFilteringInfo',
-        'vRefractionInfos',
-        'refractionMatrix',
-        'vThicknessInfos',
-        'thicknessMatrix',
-        'vThicknessParam',
-        'vDiffusionDistance',
-        'vTintColor',
-        'vSubSurfaceIntensity',
-        'scatteringDiffusionProfile',
-        'vDetailInfos',
-        'detailMatrix',
-        'Scene',
-        'vEyePosition',
-        'vAmbientColor',
-        'vCameraInfos',
-        'vPositionW',
-        'vMainUV1',
-        'vNormalW',
-        'Light0',
-        'albedoSampler',
-        'environmentBrdfSampler',
-        'position',
-        'normal',
-        'uv',
-        'world',
-        'time',
-        'Light0',
-        'Light1',
-        'Light2',
-        'Light3',
-        'light0',
-        'light1',
-        'light2',
-        'light3',
-        'vLightData0',
-        'vLightDiffuse0',
-        'vLightSpecular0',
-        'vLightFalloff0',
-        'vSphericalL00',
-        'vSphericalL1_1',
-        'vSphericalL10',
-        'vSphericalL11',
-        'vSphericalL2_2',
-        'vSphericalL2_1',
-        'vSphericalL20',
-        'vSphericalL21',
-        'vSphericalL22',
-        'vAlbedoInfos',
-        'reflectionSampler',
-    ]),
-    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_1.nodeName)(node);
-                // This hinges on the vertex shader calling vec3(p)
-                if (node.stage === 'vertex') {
-                    if ((0, graph_1.doesLinkThruShader)(graph, node)) {
-                        (0, ast_1.returnGlPositionVec3Right)(mainName, programAst);
-                    }
-                    else {
-                        (0, ast_1.returnGlPosition)(mainName, programAst);
-                    }
-                }
-                return ast;
-            },
-        },
-        _b[engine_1.EngineNodeType.physical] = {
-            onBeforeCompile: function (graph, engineContext, node, sibling) {
-                return cacher(engineContext, graph, node, sibling, function () {
-                    return onBeforeCompileMegaShader(engineContext, graph, node, sibling);
-                });
-            },
-            manipulateAst: megaShaderMainpulateAst,
-        },
-        _b),
-};
-exports.babylengine.parsers[engine_1.EngineNodeType.toon] =
-    exports.babylengine.parsers[engine_1.EngineNodeType.physical];
-exports.babylengine.parsers[engine_1.EngineNodeType.phong] =
-    exports.babylengine.parsers[engine_1.EngineNodeType.physical];

package/cjs/plugins/babylon/importers.js

@@ -1,66 +0,0 @@
-"use strict";
-var _a;
-Object.defineProperty(exports, "__esModule", { value: true });
-var utils_1 = require("@shaderfrog/glsl-parser/parser/utils");
-var engine_1 = require("../../engine");
-var nodeInputMap = {
-    normalMap: 'bumpSampler',
-    property_map: 'property_albedoTexture',
-    property_normalMap: 'property_bumpTexture',
-    property_color: 'property_albedoColor',
-    property_metalness: 'property_metallic',
-    filler_position: 'filler_position',
-};
-var importers = {
-    three: {
-        // TODO: For hell:
-        // the renames below don't really work, the "seen" thing is confusing - I
-        // don't remember why I did that - is that to avoid renaming the original
-        // declaration? the original declaraitons need to be renamed or stripped
-        // from the original shader and the right imports added
-        //
-        // Also need to show babylon compile errors in the UI
-        convertAst: function (ast, type) {
-            // Babylon has no normalmatrix. They do have a normal attribute. So undo any
-            // multiplication by normalMatrix?
-            var seen = {};
-            (0, utils_1.renameBindings)(ast.scopes[0], function (name) {
-                // console.log({ name }, 'seen:', seen[name]);
-                var renamed = name === 'vUv'
-                    ? 'vMainUV1'
-                    : name === 'vNormal'
-                        ? 'vNormalW'
-                        : name === 'projectionMatrix'
-                            ? seen[name]
-                                ? 'viewProjection'
-                                : 'hobgoblin'
-                            : name === 'modelMatrix'
-                                ? seen[name]
-                                    ? 'world'
-                                    : name
-                                : name === 'modelViewMatrix'
-                                    ? seen[name]
-                                        ? '(world * viewProjection)'
-                                        : name
-                                    : name === 'vPosition'
-                                        ? seen[name]
-                                            ? 'vPositionW'
-                                            : name
-                                        : name;
-                seen[name] = true;
-                return renamed;
-            });
-        },
-        nodeInputMap: (_a = {},
-            _a[engine_1.EngineNodeType.physical] = nodeInputMap,
-            _a),
-        edgeMap: {
-            normalMap: 'bumpSampler',
-            property_map: 'property_albedoTexture',
-            property_normalMap: 'property_bumpTexture',
-            property_color: 'property_albedoColor',
-            property_metalness: 'property_metallic',
-        },
-    },
-};
-exports.default = importers;

package/cjs/plugins/babylon/index.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.engine = void 0;
-var bablyengine_1 = require("./bablyengine");
-Object.defineProperty(exports, "engine", { enumerable: true, get: function () { return bablyengine_1.babylengine; } });