@shaderfrog/core 0.1.1 → 1.0.0

package/dist/engine.d.ts

@@ -0,0 +1,66 @@
+import { Program } from '@shaderfrog/glsl-parser/ast';
+import { MergeOptions } from './graph/shader-sections';
+import { Graph, ShaderStage } from './graph/graph-types';
+import { NodePosition } from './graph/base-node';
+import { DataNode, UniformDataType } from './graph/data-nodes';
+import { CodeNode, NodeProperty, SourceNode } from './graph/code-nodes';
+import { NodeContext } from './graph/context';
+import { NodeParser } from './graph/parsers';
+export declare enum EngineNodeType {
+    toon = "toon",
+    phong = "phong",
+    physical = "physical",
+    shader = "shader",
+    binary = "binary"
+}
+export type PhysicalNodeConstructor = (id: string, name: string, groupId: string | null | undefined, position: NodePosition, uniforms: UniformDataType[], stage: ShaderStage | undefined, nextStageNodeId?: string) => CodeNode;
+export type ToonNodeConstructor = (id: string, name: string, groupId: string | null | undefined, position: NodePosition, uniforms: UniformDataType[], stage: ShaderStage | undefined, nextStageNodeId?: string) => CodeNode;
+export interface Engine {
+    name: string;
+    preserve: Set<string>;
+    mergeOptions: MergeOptions;
+    parsers: Record<string, NodeParser>;
+    importers: EngineImporters;
+    evaluateNode: (node: DataNode) => any;
+    constructors: {
+        [EngineNodeType.physical]: PhysicalNodeConstructor;
+        [EngineNodeType.toon]: ToonNodeConstructor;
+    };
+}
+export type EngineContext = {
+    engine: string;
+    nodes: Record<string, NodeContext>;
+    runtime: any;
+    debuggingNonsense: {
+        vertexSource?: string;
+        vertexPreprocessed?: string;
+        fragmentPreprocessed?: string;
+        fragmentSource?: string;
+    };
+};
+export type EngineImporter = {
+    convertAst(ast: Program, type?: ShaderStage): void;
+    nodeInputMap: Partial<Record<EngineNodeType, Record<string, string | null>>>;
+    edgeMap: {
+        [oldInput: string]: string;
+    };
+};
+export type EngineImporters = {
+    [engine: string]: EngineImporter;
+};
+export declare const convertNode: (node: SourceNode, converter: EngineImporter) => SourceNode;
+export declare const convertToEngine: (oldEngine: Engine, newEngine: Engine, graph: Graph) => Graph;
+export type DefaultPropertySetter = (p: NodeProperty) => any;
+/**
+ * Create the initial engine node properties for a plugin to create its initial
+ * material with. This finds all engine nodes in the graph, finds all their
+ * properties, evalutes them, and returns an object with initial properties to
+ * set on the new plugin material, like a three.RawShaderMaterial().
+ *
+ * Currently only PlayCanvas uses this. It's at odds with the compileResult.dataInputs
+ * code path. That path uses isDataNode() to check for inputs, which excludes
+ * baked inputs. PlayCanvas requires (at least diffusesMap?) baked input properties
+ * to be set to a pc.Texture() at runtime, otherwise there's an error about
+ * vertex_texCoord0.
+ */
+export declare const collectInitialEvaluatedGraphProperties: (engine: Engine, graph: Graph, defaultPropertySetting: DefaultPropertySetter) => Record<string, any>;

package/dist/engine.js

@@ -36,10 +36,10 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
 };
 import preprocess from '@shaderfrog/glsl-parser/preprocessor';
 import { generate, parser } from '@shaderfrog/glsl-parser';
-import { NodeType } from './graph-types';
+import { NodeType } from './graph/graph-types';
 import groupBy from 'lodash.groupby';
-import { collectNodeProperties } from './graph';
-import { evaluateNode } from './evaluate';
+import { collectNodeProperties } from './graph/graph';
+import { evaluateNode } from './graph/evaluate';
 var log = function () {
     var _a;
     var args = [];

package/dist/graph/base-node.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Base node stuff, used across all nodes
+ */
+import { GraphDataType } from './data-nodes';
+export type InputCategory = 'data' | 'code';
+export type InputType = 'uniform' | 'property' | 'filler';
+export interface NodeInput {
+    displayName: string;
+    id: string;
+    type: InputType;
+    dataType?: GraphDataType;
+    accepts: Set<InputCategory>;
+    baked?: boolean;
+    bakeable: boolean;
+    property?: string;
+}
+export declare const nodeInput: (displayName: string, id: string, type: InputType, dataType: GraphDataType | undefined, accepts: Set<InputCategory>, bakeable: boolean, property?: string) => NodeInput;
+export interface NodeOutput {
+    name: string;
+    id: string;
+    category: InputCategory;
+}
+export type NodePosition = {
+    x: number;
+    y: number;
+};
+export interface CoreNode {
+    id: string;
+    name: string;
+    type: string;
+    inputs: NodeInput[];
+    outputs: NodeOutput[];
+    position: NodePosition;
+}

package/dist/graph/code-nodes.d.ts

@@ -0,0 +1,46 @@
+import { ShaderStage } from './graph-types';
+import { Strategy } from '../strategy';
+import { GraphDataType, UniformDataType } from './data-nodes';
+import { CoreNode, NodeInput } from './base-node';
+export declare const mapInputName: (node: CodeNode, { id, displayName }: NodeInput) => string;
+export type InputMapping = {
+    [original: string]: string;
+};
+export type NodeConfig = {
+    version: 2 | 3;
+    mangle?: boolean;
+    preprocess: boolean;
+    inputMapping?: InputMapping;
+    strategies: Strategy[];
+    uniforms: UniformDataType[];
+    properties?: NodeProperty[];
+    hardCodedProperties?: Record<string, any>;
+};
+export interface NodeProperty {
+    displayName: string;
+    type: GraphDataType;
+    property: string;
+    fillerName?: string;
+    defaultValue?: any;
+}
+export declare const property: (displayName: string, property: string, type: GraphDataType, fillerName?: string, defaultValue?: any) => NodeProperty;
+export declare enum SourceType {
+    EXPRESSION = "Expression",
+    FN_BODY_FRAGMENT = "Function Body Fragment",
+    SHADER_FRAGMENT = "Shader Fragment"
+}
+export interface CodeNode extends CoreNode {
+    config: NodeConfig;
+    source: string;
+    sourceType?: SourceType;
+    stage: ShaderStage | undefined;
+    biStage?: boolean;
+    groupId: string | null | undefined;
+    nextStageNodeId?: string;
+    prevStageNodeId?: string;
+    originalEngine?: string;
+}
+export interface BinaryNode extends CodeNode {
+    operator: string;
+}
+export type SourceNode = BinaryNode | CodeNode;

package/dist/graph/context.d.ts

@@ -0,0 +1,35 @@
+import { AstNode, Program } from '@shaderfrog/glsl-parser/ast';
+import { Engine, EngineContext } from '../engine';
+import { NodeInput } from './base-node';
+import { Graph, GraphNode } from './graph-types';
+import { InputFillers } from './parsers';
+/**
+ * A node's context is the runtime / in-memory computed data associated with a
+ * graph node. It includes the parsed AST representation of the node, as well as
+ * the inputs found in that AST. It's not currently saved to the database.
+ */
+export type NodeContext = {
+    id?: string;
+    name?: string;
+    source?: string;
+    ast: AstNode | Program;
+    inputs?: NodeInput[];
+    inputFillers: InputFillers;
+    errors?: NodeErrors;
+};
+type NodeErrors = {
+    type: 'errors';
+    errors: any[];
+};
+export declare const computeContextForNodes: (engineContext: EngineContext, engine: Engine, graph: Graph, nodes: GraphNode[]) => Promise<NodeErrors | Record<string, NodeContext>>;
+/**
+ * Compute the context for every node in the graph, done on initial graph load
+ * to compute the inputs/outputs for every node
+ */
+export declare const computeAllContexts: (engineContext: EngineContext, engine: Engine, graph: Graph) => Promise<NodeErrors | Record<string, NodeContext>>;
+/**
+ * Compute the contexts for nodes starting from the outputs, working backwards.
+ * Used to only (re)-compute context for any actively used nodes
+ */
+export declare const computeGraphContext: (engineContext: EngineContext, engine: Engine, graph: Graph) => Promise<void>;
+export {};

package/dist/{context.js → graph/context.js}

@@ -71,7 +71,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 };
 import groupBy from 'lodash.groupby';
-import { mapInputName, SourceType, } from './nodes/code-nodes';
+import { mapInputName, SourceType } from './code-nodes';
 import { NodeType } from './graph-types';
 import { collectConnectedNodes, filterGraphFromNode, isSourceNode, mangleEntireProgram, } from './graph';
 import { coreParsers } from './parsers';

package/dist/graph/data-nodes.d.ts

@@ -0,0 +1,83 @@
+import { CoreNode, NodeInput, NodeOutput, NodePosition } from './base-node';
+type ArrayType = 'array';
+type Vector = 'vector2' | 'vector3' | 'vector4';
+type Color = 'rgb' | 'rgba';
+type Mat = 'mat2' | 'mat3' | 'mat4' | 'mat2x2' | 'mat2x3' | 'mat2x4' | 'mat3x2' | 'mat3x3' | 'mat3x4' | 'mat4x2' | 'mat4x3' | 'mat4x4';
+export type GraphDataType = Vector | Color | Mat | 'texture' | 'samplerCube' | 'number' | ArrayType;
+export interface NumberNode extends CoreNode {
+    type: 'number';
+    value: string;
+    range?: [number, number];
+    stepper?: number;
+}
+export declare const numberNode: (id: string, name: string, position: NodePosition, value: string, optionals?: {
+    range?: [number, number];
+    stepper?: number;
+    inputs?: NodeInput[];
+    outputs?: NodeOutput[];
+}) => NumberNode;
+export type NumberDataUniform = Omit<NumberNode, 'id' | 'inputs' | 'outputs' | 'position'>;
+export declare const numberUniformData: (name: string, value: string, range?: [number, number], stepper?: number) => NumberDataUniform;
+export interface TextureNode extends CoreNode {
+    type: 'texture';
+    value: string;
+}
+export declare const textureNode: (id: string, name: string, position: NodePosition, value: string) => TextureNode;
+export type TextureDataUniform = Omit<TextureNode, 'id' | 'inputs' | 'outputs' | 'position'>;
+export declare const textureUniformData: (name: string, value: string) => TextureDataUniform;
+export interface SamplerCubeNode extends CoreNode {
+    type: 'samplerCube';
+    value: string;
+}
+export declare const samplerCubeNode: (id: string, name: string, position: NodePosition, value: string) => SamplerCubeNode;
+export type SamplerCubeDataUniform = Omit<SamplerCubeNode, 'id' | 'inputs' | 'outputs' | 'position'>;
+export declare const samplerCubeUniformData: (name: string, value: string) => SamplerCubeDataUniform;
+export type ArrayValue = string[];
+export interface ArrayNode extends CoreNode {
+    type: 'array';
+    dimensions: number;
+    value: ArrayValue;
+}
+export declare function arrayNode(id: string, name: string, position: NodePosition, value: ArrayValue): ArrayNode;
+export type Vector2 = [string, string];
+export type Vector3 = [string, string, string];
+export type Vector4 = [string, string, string, string];
+export interface Vector2Node extends CoreNode {
+    type: 'vector2';
+    dimensions: 2;
+    value: Vector2;
+}
+export interface Vector3Node extends CoreNode {
+    type: 'vector3';
+    dimensions: 3;
+    value: Vector3;
+}
+export interface Vector4Node extends CoreNode {
+    type: 'vector4';
+    dimensions: 4;
+    value: Vector4;
+}
+export declare function vectorNode(id: string, name: string, position: NodePosition, value: Vector2 | Vector3 | Vector4): Vector2Node | Vector3Node | Vector4Node;
+export type ArrayDataUniform = Omit<ArrayNode, 'id' | 'inputs' | 'outputs' | 'position'>;
+export declare const arrayUniformData: (name: string, value: ArrayValue) => ArrayDataUniform;
+export type Vector2DataUniform = Omit<Vector2Node, 'id' | 'inputs' | 'outputs' | 'position'>;
+export type Vector3DataUniform = Omit<Vector3Node, 'id' | 'inputs' | 'outputs' | 'position'>;
+export type Vector4DataUniform = Omit<Vector4Node, 'id' | 'inputs' | 'outputs' | 'position'>;
+export declare const vectorUniformData: (name: string, value: Vector2 | Vector3 | Vector4) => Vector2DataUniform | Vector3DataUniform | Vector4DataUniform;
+export interface RgbNode extends CoreNode {
+    type: 'rgb';
+    dimensions: 3;
+    value: Vector3;
+}
+export interface RgbaNode extends CoreNode {
+    type: 'rgba';
+    dimensions: 4;
+    value: Vector4;
+}
+export declare function colorNode(id: string, name: string, position: NodePosition, value: Vector3 | Vector4): RgbNode | RgbaNode;
+export type RgbDataUniform = Omit<RgbNode, 'id' | 'inputs' | 'outputs' | 'position'>;
+export type RgbaDataUniform = Omit<RgbaNode, 'id' | 'inputs' | 'outputs' | 'position'>;
+export declare const colorUniformData: (name: string, value: Vector3 | Vector4) => RgbDataUniform | RgbaDataUniform;
+export type UniformDataType = TextureDataUniform | SamplerCubeDataUniform | NumberDataUniform | Vector2DataUniform | Vector3DataUniform | Vector4DataUniform | RgbDataUniform | RgbaDataUniform;
+export type DataNode = TextureNode | SamplerCubeNode | NumberNode | Vector2Node | Vector3Node | Vector4Node | ArrayNode | RgbNode | RgbaNode;
+export {};

package/dist/graph/edge.d.ts

@@ -0,0 +1,12 @@
+import { ShaderStage } from './graph-types';
+import { GraphDataType } from './data-nodes';
+export type EdgeType = ShaderStage | GraphDataType;
+export type Edge = {
+    id: string;
+    from: string;
+    to: string;
+    output: string;
+    input: string;
+    type?: EdgeType;
+};
+export declare const makeEdge: (id: string, from: string, to: string, output: string, input: string, type?: EdgeType) => Edge;

package/dist/graph/engine-node.d.ts

@@ -0,0 +1,15 @@
+import { ShaderStage } from './graph-types';
+import { BinaryNode, CodeNode, NodeConfig } from './code-nodes';
+import { NodePosition } from './base-node';
+/**
+ * TODO: These definitions should live outside of core since I'm trying to
+ * refactor out this core folder to only know about nodes with config config,
+ * where nodes like output/phong/physical are all configured at the
+ * implementation level. "phong" shouldn't be in the core
+ */
+export declare const sourceNode: (id: string, name: string, position: NodePosition, config: NodeConfig, source: string, stage: ShaderStage, originalEngine?: string, nextStageNodeId?: string) => CodeNode;
+export declare const outputNode: (id: string, name: string, position: NodePosition, stage: ShaderStage) => CodeNode;
+export declare const expressionNode: (id: string, name: string, position: NodePosition, source: string) => CodeNode;
+export declare const phongNode: (id: string, name: string, groupId: string, position: NodePosition, stage: ShaderStage, nextStageNodeId?: string) => CodeNode;
+export declare const addNode: (id: string, position: NodePosition) => BinaryNode;
+export declare const multiplyNode: (id: string, position: NodePosition) => BinaryNode;

package/dist/{nodes → graph}/engine-node.js

@@ -1,6 +1,6 @@
 import { EngineNodeType } from '../engine';
-import { prepopulatePropertyInputs } from '../graph';
-import { NodeType } from '../graph-types';
+import { prepopulatePropertyInputs } from './graph';
+import { NodeType } from './graph-types';
 import { assignemntToStrategy, namedAttributeStrategy, texture2DStrategy, uniformStrategy, variableStrategy, } from '../strategy';
 import { SourceType, property, } from './code-nodes';
 /**

package/dist/graph/evaluate.d.ts

@@ -0,0 +1,9 @@
+import { Engine } from '../engine';
+import { Edge } from './edge';
+import { SourceNode } from './code-nodes';
+import { Graph, GraphNode } from './graph-types';
+import { DataNode } from './data-nodes';
+export type Evaluator = (node: GraphNode) => any;
+export type Evaluate = (node: SourceNode, inputEdges: Edge[], inputNodes: GraphNode[], evaluate: Evaluator) => any;
+export declare const toGlsl: (node: DataNode) => string;
+export declare const evaluateNode: (engine: Engine, graph: Graph, node: GraphNode) => any;

package/dist/graph/graph-types.d.ts

@@ -0,0 +1,25 @@
+import { DataNode } from './data-nodes';
+import { Edge } from './edge';
+import { SourceNode } from './code-nodes';
+/**
+ * Core graph types.
+ *
+ * Originally abstracted out of graph.ts to avoid a circular
+ * dependency between graph.ts and parsers.ts. Both files need these types at
+ * module initialization time, and without this third file, the types will be
+ * undefined in either graph/parsers.ts at init time. If the types were only
+ * used at runtime it would be fine, because the circular depenency is resolved
+ * by then.
+ */
+export type ShaderStage = 'fragment' | 'vertex';
+export declare enum NodeType {
+    OUTPUT = "output",
+    BINARY = "binary",
+    SOURCE = "source"
+}
+export type GraphNode = SourceNode | DataNode;
+export interface Graph {
+    nodes: GraphNode[];
+    edges: Edge[];
+}
+export declare const MAGIC_OUTPUT_STMTS = "mainStmts";

package/dist/graph/graph.d.ts

@@ -0,0 +1,70 @@
+import { Program } from '@shaderfrog/glsl-parser/ast';
+import { Engine, EngineContext } from '../engine';
+import { ShaderSections } from './shader-sections';
+import { DataNode } from './data-nodes';
+import { Edge } from './edge';
+import { CodeNode, SourceNode } from './code-nodes';
+import { NodeInput } from './base-node';
+import { ProduceNodeFiller } from './parsers';
+import { Graph, GraphNode } from './graph-types';
+export declare const isDataNode: (node: GraphNode) => node is DataNode;
+export declare const isSourceNode: (node: GraphNode) => node is SourceNode;
+export declare const findNode: (graph: Graph, id: string) => GraphNode;
+export declare const doesLinkThruShader: (graph: Graph, node: GraphNode) => boolean;
+export declare const nodeName: (node: GraphNode) => string;
+export declare const mangleName: (name: string, node: GraphNode) => string;
+export declare const mangleVar: (name: string, engine: Engine, node: GraphNode) => string;
+export declare const mangleEntireProgram: (ast: Program, node: SourceNode, engine: Engine) => void;
+export declare const mangleMainFn: (ast: Program, node: SourceNode) => void;
+type Predicates = {
+    node?: (node: GraphNode, inputEdges: Edge[]) => boolean;
+    input?: (input: NodeInput, node: GraphNode, inputEdge: Edge | undefined, fromNode: GraphNode | undefined) => boolean;
+};
+export type SearchResult = {
+    nodes: Record<string, GraphNode>;
+    inputs: Record<string, NodeInput[]>;
+};
+/**
+ * Create the inputs on a node from the properties. This used to be done at
+ * context time. Doing it at node creation time lets us auto-bake edges into
+ * the node at initial graph creation time.
+ */
+export declare const prepopulatePropertyInputs: (node: CodeNode) => CodeNode;
+/**
+ * Recursively filter the graph, starting from a specific node, looking for
+ * nodes and edges that match predicates. This function returns the inputs for
+ * matched edges, not the edges themselves, as a convenience for the only
+ * consumer of this function, which is finding input names to use as uniforms.
+ *
+ * Inputs can only be filtered if the graph context has been computed, since
+ * inputs aren't created until then.
+ */
+export declare const filterGraphFromNode: (graph: Graph, node: GraphNode, predicates: Predicates, depth?: number) => SearchResult;
+export declare const collectConnectedNodes: (graph: Graph, node: GraphNode) => NodeIds;
+export declare const filterGraphNodes: (graph: Graph, nodes: GraphNode[], filter: Predicates, depth?: number) => SearchResult;
+type NodeIds = Record<string, GraphNode>;
+export type CompileNodeResult = [
+    compiledSections: ShaderSections,
+    filler: ReturnType<ProduceNodeFiller>,
+    compiledIds: NodeIds
+];
+export declare const isDataInput: (input: NodeInput) => boolean;
+export declare const compileNode: (engine: Engine, graph: Graph, edges: Edge[], engineContext: EngineContext, node: GraphNode, activeIds?: NodeIds) => CompileNodeResult;
+export type CompileGraphResult = {
+    fragment: ShaderSections;
+    vertex: ShaderSections;
+    outputFrag: GraphNode;
+    outputVert: GraphNode;
+    orphanNodes: GraphNode[];
+    activeNodeIds: Set<string>;
+};
+export declare const compileGraph: (engineContext: EngineContext, engine: Engine, graph: Graph) => CompileGraphResult;
+/**
+ * Find engine nodes to set properties on, like find a Physical node so
+ * consumers can set physicalNode.myProperty = 123.
+ *
+ * Finds all active nodes in the graph that have inputs that are properties,
+ * which currently means it will find all active engine nodes.
+ */
+export declare const collectNodeProperties: (graph: Graph) => SearchResult;
+export {};

package/dist/{graph.js → graph/graph.js}

@@ -35,12 +35,12 @@ 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 './ast/shader-sections';
-import { makeExpression } from './ast/manipulate';
-import { ensure } from './util/ensure';
-import { SourceType } from './nodes/code-nodes';
-import { nodeInput } from './nodes/core-node';
-import { makeId } from './util/id';
+import { emptyShaderSections, findShaderSections, mergeShaderSections, } from './shader-sections';
+import { makeExpression } from '../util/ast';
+import { ensure } from '../util/ensure';
+import { SourceType } from './code-nodes';
+import { nodeInput } from './base-node';
+import { makeId } from '../util/id';
 import { coreParsers } from './parsers';
 import { toGlsl } from './evaluate';
 import { MAGIC_OUTPUT_STMTS, NodeType } from './graph-types';

package/dist/graph/graph.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/{graph.test.js → graph/graph.test.js}

@@ -1,11 +1,10 @@
 import util from 'util';
 import { parser } from '@shaderfrog/glsl-parser';
 import { generate } from '@shaderfrog/glsl-parser';
-import { shaderSectionsToProgram } from './ast/shader-sections';
-import { addNode } from './nodes/engine-node';
-import { mergeShaderSections, findShaderSections } from './ast/shader-sections';
-import { numberNode } from './nodes/data-nodes';
-import { makeEdge } from './nodes/edge';
+import { addNode } from './engine-node';
+import { shaderSectionsToProgram, mergeShaderSections, findShaderSections, } from './shader-sections';
+import { numberNode } from './data-nodes';
+import { makeEdge } from './edge';
 import { evaluateNode } from './evaluate';
 var inspect = function (thing) {
     return console.log(util.inspect(thing, false, null, true));

package/dist/graph/index.d.ts

@@ -0,0 +1,9 @@
+export * from './base-node';
+export * from './data-nodes';
+export * from './engine-node';
+export * from './edge';
+export * from './context';
+export * from './evaluate';
+export * from './graph-types';
+export * from './graph';
+export * from './shader-sections';

package/dist/graph/index.js

@@ -0,0 +1,9 @@
+export * from './base-node';
+export * from './data-nodes';
+export * from './engine-node';
+export * from './edge';
+export * from './context';
+export * from './evaluate';
+export * from './graph-types';
+export * from './graph';
+export * from './shader-sections';

package/dist/graph/parsers.d.ts

@@ -0,0 +1,39 @@
+import { AstNode, Program } from '@shaderfrog/glsl-parser/ast';
+import { Engine, EngineContext } from '../engine';
+import { Edge } from './edge';
+import { SourceNode } from './code-nodes';
+import { NodeInput } from './base-node';
+import { Graph } from './graph-types';
+import { Evaluate } from './evaluate';
+export declare const alphabet = "abcdefghijklmnopqrstuvwxyz";
+export type Filler = AstNode | AstNode[] | void;
+export type InputFiller = (filler: Filler) => AstNode | Program;
+export type InputFillerGroup = {
+    filler: InputFiller;
+    backfillArgs?: AstNode[];
+};
+export type InputFillers = Record<string, InputFillerGroup>;
+type FillerArguments = AstNode[];
+export type ComputedInput = [NodeInput, InputFiller, FillerArguments?];
+export type ProduceAst = (engineContext: EngineContext, engine: Engine, graph: Graph, node: SourceNode, inputEdges: Edge[]) => AstNode | Program;
+export type OnBeforeCompile = (graph: Graph, engineContext: EngineContext, node: SourceNode, sibling?: SourceNode) => Promise<void>;
+export type ManipulateAst = (engineContext: EngineContext, engine: Engine, graph: Graph, node: SourceNode, ast: AstNode | Program, inputEdges: Edge[]) => AstNode | Program;
+export type NodeParser = {
+    onBeforeCompile?: OnBeforeCompile;
+    manipulateAst?: ManipulateAst;
+    findInputs?: FindInputs;
+    produceFiller?: ProduceNodeFiller;
+};
+export type FindInputs = (engineContext: EngineContext, node: SourceNode, ast: Program | AstNode, inputEdges: Edge[]) => ComputedInput[];
+export type ProduceNodeFiller = (node: SourceNode, ast: Program | AstNode) => Filler;
+type CoreNodeParser = {
+    produceAst: ProduceAst;
+    findInputs: FindInputs;
+    produceFiller: ProduceNodeFiller;
+    evaluate?: Evaluate;
+};
+type CoreParser = {
+    [key: string]: CoreNodeParser;
+};
+export declare const coreParsers: CoreParser;
+export {};

package/dist/{parsers.js → graph/parsers.js}

@@ -27,13 +27,13 @@ var _a;
 import { generate, parser } from '@shaderfrog/glsl-parser';
 import { visit, } from '@shaderfrog/glsl-parser/ast';
 import preprocess from '@shaderfrog/glsl-parser/preprocessor';
-import { convert300MainToReturn, from2To3, makeExpression, makeExpressionWithScopes, makeFnBodyStatementWithScopes, makeFnStatement, } from './ast/manipulate';
-import { applyStrategy } from './strategy';
-import { SourceType } from './nodes/code-nodes';
-import { nodeInput } from './nodes/core-node';
+import { convert300MainToReturn, from2To3, makeExpression, makeExpressionWithScopes, makeFnBodyStatementWithScopes, makeFnStatement, } from '../util/ast';
+import { applyStrategy } from '../strategy';
+import { SourceType } from './code-nodes';
+import { nodeInput } from './base-node';
 import { MAGIC_OUTPUT_STMTS, NodeType } from './graph-types';
 import { nodeName } from './graph';
-import { generateFiller } from './util/ast';
+import { generateFiller } from '../util/ast';
 /*
  * Core graph parsers, which is the plumbing/interface the graph and context
  * calls into, to parse, find inputs, etc, and define this per-node type.

package/dist/graph/shader-sections.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Categorizing / deduping parts of shaders to help merge them together
+ */
+import { AstNode, DeclarationStatementNode, PreprocessorNode } from '@shaderfrog/glsl-parser/ast';
+import { Program } from '@shaderfrog/glsl-parser/ast';
+export interface ShaderSections {
+    precision: DeclarationStatementNode[];
+    version: AstNode[];
+    preprocessor: PreprocessorNode[];
+    structs: AstNode[];
+    inStatements: DeclarationStatementNode[];
+    outStatements: DeclarationStatementNode[];
+    uniforms: DeclarationStatementNode[];
+    program: AstNode[];
+}
+export declare const emptyShaderSections: () => ShaderSections;
+declare enum Precision {
+    highp = 2,
+    mediump = 1,
+    lowp = 0
+}
+export declare const higherPrecision: (p1: Precision, p2: Precision) => Precision;
+export declare const dedupeVersions: (nodes: AstNode[]) => AstNode;
+export declare const highestPrecisions: (nodes: DeclarationStatementNode[]) => DeclarationStatementNode[];
+export declare const dedupeQualifiedStatements: (statements: DeclarationStatementNode[], qualifier: string) => any;
+/**
+ * Merge uniforms together into lists of identifiers under the same type.
+ * There's special case handling for mixing of uniforms with "interface blocks"
+ * and those without when merging to make sure the interface block definition is
+ * preserved. Check out the tests for more.
+ *
+ * This function consumes uniforms as found by findShaderSections, so the
+ * definitions must line up
+ */
+export declare const dedupeUniforms: (statements: DeclarationStatementNode[]) => any;
+export declare const mergeShaderSections: (s1: ShaderSections, s2: ShaderSections) => ShaderSections;
+export type MergeOptions = {
+    includePrecisions: boolean;
+    includeVersion: boolean;
+};
+export declare const shaderSectionsToProgram: (sections: ShaderSections, mergeOptions: MergeOptions) => Program;
+/**
+ * Group an AST into logical sections. The output of this funciton is consumed
+ * by the dedupe methods, namely dedupeUniforms, so the data shapes are coupled
+ */
+export declare const findShaderSections: (ast: Program) => ShaderSections;
+export {};

package/dist/{ast → graph}/shader-sections.js

@@ -35,7 +35,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 };
 import { generate } from '@shaderfrog/glsl-parser';
-import { makeStatement } from './manipulate';
+import { makeStatement } from '../util/ast';
 export var emptyShaderSections = function () { return ({
     precision: [],
     preprocessor: [],

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './graph';
+export * from './strategy';
+export * from './engine';

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from './graph';
+export * from './strategy';
+export * from './engine';