@shaderfrog/core 1.0.5 → 1.0.6

package/dist/graph/graph.d.ts

@@ -67,4 +67,13 @@ export declare const compileGraph: (engineContext: EngineContext, engine: Engine
  * which currently means it will find all active engine nodes.
  */
 export declare const collectNodeProperties: (graph: Graph) => SearchResult;
+export type IndexedDataInputs = Record<string, NodeInput[]>;
+export type CompileResult = {
+    fragmentResult: string;
+    vertexResult: string;
+    compileResult: CompileGraphResult;
+    dataNodes: Record<string, GraphNode>;
+    dataInputs: IndexedDataInputs;
+};
+export declare const compileSource: (graph: Graph, engine: Engine, ctx: EngineContext) => Promise<CompileResult>;
 export {};

package/dist/graph/graph.js

@@ -9,6 +9,42 @@ var __assign = (this && this.__assign) || function () {
     };
     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;
@@ -35,7 +71,8 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 };
 import { renameBindings, renameFunctions, } from '@shaderfrog/glsl-parser/parser/utils';
-import { emptyShaderSections, findShaderSections, mergeShaderSections, } from './shader-sections';
+import { computeGraphContext } from './context';
+import { emptyShaderSections, findShaderSections, mergeShaderSections, shaderSectionsToProgram, } from './shader-sections';
 import { makeExpression } from '../util/ast';
 import { ensure } from '../util/ensure';
 import { SourceType } from './code-nodes';
@@ -44,6 +81,7 @@ import { makeId } from '../util/id';
 import { coreParsers } from './parsers';
 import { toGlsl } from './evaluate';
 import { MAGIC_OUTPUT_STMTS, NodeType } from './graph-types';
+import { generate } from '@shaderfrog/glsl-parser';
 var log = function () {
     var _a;
     var args = [];
@@ -379,3 +417,33 @@ export var collectNodeProperties = function (graph) {
         inputs: __assign(__assign({}, fragProperties.inputs), vertProperties.inputs),
     };
 };
+export var compileSource = function (graph, engine, ctx) { return __awaiter(void 0, void 0, void 0, function () {
+    var compileResult, fragmentResult, vertexResult, dataInputs, dataNodes;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, computeGraphContext(ctx, engine, graph)];
+            case 1:
+                _a.sent();
+                compileResult = compileGraph(ctx, engine, graph);
+                fragmentResult = generate(shaderSectionsToProgram(compileResult.fragment, engine.mergeOptions).program);
+                vertexResult = generate(shaderSectionsToProgram(compileResult.vertex, engine.mergeOptions).program);
+                dataInputs = filterGraphNodes(graph, [compileResult.outputFrag, compileResult.outputVert], { input: isDataInput }).inputs;
+                dataNodes = Object.entries(dataInputs).reduce(function (acc, _a) {
+                    var _b = __read(_a, 2), nodeId = _b[0], inputs = _b[1];
+                    return inputs.reduce(function (iAcc, input) {
+                        var fromEdge = graph.edges.find(function (edge) { return edge.to === nodeId && edge.input === input.id; });
+                        var fromNode = fromEdge && graph.nodes.find(function (node) { return node.id === fromEdge.from; });
+                        return fromNode
+                            ? __assign(__assign({}, iAcc), collectConnectedNodes(graph, fromNode)) : iAcc;
+                    }, acc);
+                }, {});
+                return [2 /*return*/, {
+                        compileResult: compileResult,
+                        fragmentResult: fragmentResult,
+                        vertexResult: vertexResult,
+                        dataNodes: dataNodes,
+                        dataInputs: dataInputs,
+                    }];
+        }
+    });
+}); };

package/dist/graph/index.d.ts

@@ -3,6 +3,7 @@ export * from './data-nodes';
 export * from './engine-node';
 export * from './code-nodes';
 export * from './edge';
+export * from './parsers';
 export * from './context';
 export * from './evaluate';
 export * from './graph-types';

package/dist/graph/index.js

@@ -3,6 +3,7 @@ export * from './data-nodes';
 export * from './engine-node';
 export * from './code-nodes';
 export * from './edge';
+export * from './parsers';
 export * from './context';
 export * from './evaluate';
 export * from './graph-types';

package/dist/plugins/three/threngine.d.ts

@@ -1,5 +1,7 @@
+import { RawShaderMaterial } from 'three';
 import { ShaderStage } from '../../graph/graph-types';
-import { Engine } from '../../engine';
+import { Engine, EngineContext } from '../../engine';
+import { CompileResult } from '../../graph/graph';
 import { CodeNode, NodeProperty } from '../../graph/code-nodes';
 import { NodePosition } from '../../graph/base-node';
 import { UniformDataType } from '../../graph/data-nodes';
@@ -29,3 +31,4 @@ export type ThreeRuntime = {
 };
 export declare const toonNode: (id: string, name: string, groupId: string | null | undefined, position: NodePosition, uniforms: UniformDataType[], stage: ShaderStage | undefined, nextStageNodeId?: string) => CodeNode;
 export declare const threngine: Engine;
+export declare const createMaterial: (compileResult: CompileResult, ctx: EngineContext) => RawShaderMaterial;

package/dist/plugins/three/threngine.js

@@ -71,7 +71,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 };
 var _a, _b;
-import { Vector2, Vector3, Vector4, Color } from 'three';
+import { ShaderLib, RawShaderMaterial, Vector2, Vector3, Vector4, Color, } from 'three';
 import { NodeType } from '../../graph/graph-types';
 import { prepopulatePropertyInputs, mangleMainFn } from '../../graph/graph';
 import importers from './importers';
@@ -493,3 +493,49 @@ export var threngine = {
         },
         _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 } });
+    var initialProperties = {
+        name: 'ShaderFrog Material',
+        lights: true,
+        uniforms: __assign({}, finalUniforms),
+        transparent: true,
+        opacity: 1.0,
+        vertexShader: compileResult === null || compileResult === void 0 ? void 0 : compileResult.vertexResult,
+        fragmentShader: compileResult === null || compileResult === void 0 ? void 0 : compileResult.fragmentResult,
+    };
+    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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shaderfrog/core",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "description": "Shaderfrog core",
   "module": "./dist/index.js",
   "scripts": {