@shaderfrog/core 1.3.0 → 1.3.2

package/esm/engine.d.ts

@@ -1,69 +0,0 @@
-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 PhongNodeConstructor = (id: string, name: string, position: NodePosition, uniforms: UniformDataType[], stage: ShaderStage | undefined) => CodeNode;
-export type PhysicalNodeConstructor = (id: string, name: string, position: NodePosition, uniforms: UniformDataType[], stage: ShaderStage | undefined) => CodeNode;
-export type ToonNodeConstructor = (id: string, name: string, position: NodePosition, uniforms: UniformDataType[], stage: ShaderStage | undefined) => CodeNode;
-export interface Engine {
-    name: 'three' | 'babylon' | 'playcanvas';
-    displayName: string;
-    preserve: Set<string>;
-    mergeOptions: MergeOptions;
-    parsers: Record<string, NodeParser>;
-    importers: EngineImporters;
-    evaluateNode: (node: DataNode) => any;
-    constructors: {
-        [EngineNodeType.phong]?: PhongNodeConstructor;
-        [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/esm/graph/base-node.d.ts

@@ -1,36 +0,0 @@
-/**
- * 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: InputCategory[];
-    baked?: boolean;
-    bakeable: boolean;
-    property?: string;
-}
-export declare const nodeInput: (displayName: string, id: string, type: InputType, dataType: GraphDataType | undefined, accepts: InputCategory[], bakeable: boolean, property?: string) => NodeInput;
-export interface NodeOutput {
-    name: string;
-    id: string;
-    dataType?: GraphDataType;
-    category: InputCategory;
-}
-export type NodePosition = {
-    x: number;
-    y: number;
-};
-export interface BaseNode {
-    id: string;
-    parentId?: string;
-    name: string;
-    type: string;
-    inputs: NodeInput[];
-    outputs: NodeOutput[];
-    position: NodePosition;
-}

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

@@ -1,44 +0,0 @@
-import { ShaderStage } from './graph-types';
-import { Strategy } from '../strategy';
-import { GraphDataType, UniformDataType } from './data-nodes';
-import { BaseNode, 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 {
-    SHADER_PROGRAM = "Shader Program",
-    EXPRESSION = "Expression",
-    FN_BODY_FRAGMENT = "Function Body Fragment"
-}
-export interface CodeNode extends BaseNode {
-    config: NodeConfig;
-    engine: boolean;
-    source: string;
-    sourceType?: SourceType;
-    stage?: ShaderStage;
-    biStage?: boolean;
-    originalEngine?: string;
-}
-export interface BinaryNode extends CodeNode {
-    operator: string;
-}
-export type SourceNode = BinaryNode | CodeNode;

package/esm/graph/context.d.ts

@@ -1,37 +0,0 @@
-import type { GlslSyntaxError } from '@shaderfrog/glsl-parser';
-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;
-};
-export type NodeErrors = {
-    type: 'errors';
-    nodeId: string;
-    errors: (GlslSyntaxError | string)[];
-};
-export declare const isError: (test: any) => test is NodeErrors;
-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>;
-/**
- * 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<NodeErrors>;

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

@@ -1,83 +0,0 @@
-import { BaseNode, 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 BaseNode {
-    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 = Pick<NumberNode, 'type' | 'value' | 'name' | 'range' | 'stepper'>;
-export declare const numberUniformData: (name: string, value: string, range?: [number, number], stepper?: number) => NumberDataUniform;
-export interface TextureNode extends BaseNode {
-    type: 'texture';
-    value: string | number;
-}
-export declare const textureNode: (id: string, name: string, position: NodePosition, value: string | number) => TextureNode;
-export type TextureDataUniform = Pick<TextureNode, 'type' | 'value' | 'name'>;
-export declare const textureUniformData: (name: string, value: string | number) => TextureDataUniform;
-export interface SamplerCubeNode extends BaseNode {
-    type: 'samplerCube';
-    value: string;
-}
-export declare const samplerCubeNode: (id: string, name: string, position: NodePosition, value: string) => SamplerCubeNode;
-export type SamplerCubeDataUniform = Pick<SamplerCubeNode, 'type' | 'value' | 'name'>;
-export declare const samplerCubeUniformData: (name: string, value: string) => SamplerCubeDataUniform;
-export type ArrayValue = string[];
-export interface ArrayNode extends BaseNode {
-    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 BaseNode {
-    type: 'vector2';
-    dimensions: 2;
-    value: Vector2;
-}
-export interface Vector3Node extends BaseNode {
-    type: 'vector3';
-    dimensions: 3;
-    value: Vector3;
-}
-export interface Vector4Node extends BaseNode {
-    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 = Pick<ArrayNode, 'type' | 'value' | 'name' | 'dimensions'>;
-export declare const arrayUniformData: (name: string, value: ArrayValue) => ArrayDataUniform;
-export type Vector2DataUniform = Pick<Vector2Node, 'type' | 'value' | 'name' | 'dimensions'>;
-export type Vector3DataUniform = Pick<Vector3Node, 'type' | 'value' | 'name' | 'dimensions'>;
-export type Vector4DataUniform = Pick<Vector4Node, 'type' | 'value' | 'name' | 'dimensions'>;
-export declare const vectorUniformData: (name: string, value: Vector2 | Vector3 | Vector4) => Vector2DataUniform | Vector3DataUniform | Vector4DataUniform;
-export interface RgbNode extends BaseNode {
-    type: 'rgb';
-    dimensions: 3;
-    value: Vector3;
-}
-export interface RgbaNode extends BaseNode {
-    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' | 'parentId'>;
-export type RgbaDataUniform = Omit<RgbaNode, 'id' | 'inputs' | 'outputs' | 'position' | 'parentId'>;
-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/esm/graph/edge.d.ts

@@ -1,13 +0,0 @@
-import { EdgeLink, ShaderStage } from './graph-types';
-import { GraphDataType } from './data-nodes';
-export type EdgeType = ShaderStage | GraphDataType | EdgeLink;
-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;
-export declare const linkFromVertToFrag: (id: string, vertId: string, fragId: string) => Edge;

package/esm/graph/evaluate.d.ts

@@ -1,9 +0,0 @@
-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/esm/graph/graph-node.d.ts

@@ -1,8 +0,0 @@
-import { ShaderStage } from './graph-types';
-import { BinaryNode, CodeNode, NodeConfig } from './code-nodes';
-import { NodePosition } from './base-node';
-export declare const sourceNode: (id: string, name: string, position: NodePosition, config: NodeConfig, source: string, stage: ShaderStage, originalEngine?: 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 addNode: (id: string, position: NodePosition) => BinaryNode;
-export declare const multiplyNode: (id: string, position: NodePosition) => BinaryNode;

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

@@ -1,38 +0,0 @@
-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';
-/**
- * The type applied to the edge representing a link between node stages
- */
-export declare enum EdgeLink {
-    NEXT_STAGE = "next_stage"
-}
-/**
- * The handle types for links. These become <Handle /> ids
- */
-export declare enum LinkHandle {
-    NEXT_STAGE = "next_stage",
-    PREVIOUS_STAGE = "previous_stage"
-}
-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/esm/graph/graph.d.ts

@@ -1,89 +0,0 @@
-import { Program } from '@shaderfrog/glsl-parser/ast';
-import { Engine, EngineContext } from '../engine';
-import { NodeErrors } from './context';
-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, nextSibling?: GraphNode) => string;
-export declare const mangleVar: (name: string, engine: Engine, node: GraphNode, sibling?: GraphNode) => string;
-export declare const mangleEntireProgram: (engine: Engine, ast: Program, node: GraphNode, sibling?: GraphNode) => void;
-export declare const mangleMainFn: (ast: Program, node: GraphNode, sibling?: GraphNode) => void;
-export declare const ensureFromNode: (graph: Graph, inputEdge: Edge) => GraphNode;
-export declare const resetGraphIds: (graph: Graph) => Graph;
-export declare const findLinkedNode: (graph: Graph, id: string) => GraphNode;
-/**
- * Find any unconnected vertex nodes linked to collected fragment nodes
- */
-export declare const findLinkedVertexNodes: (graph: Graph, existingIds?: NodeIds) => GraphNode[];
-export type Predicates = {
-    node?: (node: GraphNode, inputEdges: Edge[], lastResult: SearchResult) => boolean;
-    edge?: (input: NodeInput | undefined, node: GraphNode, inputEdge: Edge | undefined, fromNode: GraphNode | undefined, lastResult: SearchResult) => boolean;
-    input?: (input: NodeInput, node: GraphNode, inputEdge: Edge | undefined, fromNode: GraphNode | undefined, lastResult: SearchResult) => boolean;
-};
-export type SearchResult = {
-    nodes: Record<string, GraphNode>;
-    inputs: Record<string, NodeInput[]>;
-    edges: Edge[];
-};
-export declare const consSearchResult: () => SearchResult;
-export declare const mergeSearchResults: (a: SearchResult, b: SearchResult) => SearchResult;
-/**
- * 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.
- *
- * 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, lastResult?: SearchResult) => 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 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 | NodeErrors>;
-export {};

package/esm/graph/graph.test.d.ts

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

package/esm/graph/index.d.ts

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

package/esm/graph/parsers.d.ts

@@ -1,39 +0,0 @@
-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, ast: AstNode | Program, inputEdges: Edge[], node: SourceNode, sibling: SourceNode) => AstNode | Program;
-export type NodeParser = {
-    onBeforeCompile?: OnBeforeCompile;
-    manipulateAst?: ManipulateAst;
-    findInputs?: FindInputs;
-    produceFiller?: ProduceNodeFiller;
-};
-export type FindInputs = (engineContext: EngineContext, ast: Program | AstNode, inputEdges: Edge[], node: SourceNode, sibling: SourceNode) => 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/esm/graph/shader-sections.d.ts

@@ -1,47 +0,0 @@
-/**
- * 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/esm/index.d.ts

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

package/esm/package.json

@@ -1 +0,0 @@
-{"type": "module"}

package/esm/plugins/babylon/bablyengine.d.ts

@@ -1,28 +0,0 @@
-import { PBRMaterial, Camera, Scene } from 'babylonjs';
-import { Engine } from '../../engine';
-import { ShaderStage } from '../../graph/graph-types';
-import { CodeNode } from '../../graph/code-nodes';
-import { NodePosition } from '../../graph/base-node';
-import { UniformDataType } from '../../graph/data-nodes';
-export declare const physicalDefaultProperties: Partial<Record<keyof PBRMaterial, any>>;
-export declare const physicalNode: (id: string, name: string, position: NodePosition, uniforms: UniformDataType[], stage: ShaderStage | undefined) => CodeNode;
-export type RuntimeContext = {
-    scene: Scene;
-    camera: Camera;
-    BABYLON: any;
-    sceneData: any;
-    cache: {
-        data: {
-            [key: string]: any;
-        };
-        nodes: {
-            [id: string]: {
-                fragment: string;
-                vertex: string;
-            };
-        };
-    };
-};
-export declare const toonNode: (id: string, name: string, position: NodePosition, uniforms: UniformDataType[], stage: ShaderStage | undefined) => CodeNode;
-export declare let mIdx: number;
-export declare const babylengine: Engine;

package/esm/plugins/babylon/importers.d.ts

@@ -1,3 +0,0 @@
-import { EngineImporters } from '../../engine';
-declare const importers: EngineImporters;
-export default importers;

package/esm/plugins/babylon/index.d.ts

@@ -1,2 +0,0 @@
-import { babylengine } from './bablyengine';
-export { babylengine as engine };

package/esm/plugins/playcanvas/importers.d.ts

@@ -1,3 +0,0 @@
-import { EngineImporters } from '../../engine';
-declare const importers: EngineImporters;
-export default importers;

package/esm/plugins/playcanvas/index.d.ts

@@ -1,2 +0,0 @@
-import { playengine } from './playengine';
-export { playengine as engine };

package/esm/plugins/playcanvas/playengine.d.ts

@@ -1,39 +0,0 @@
-import * as pc from 'playcanvas';
-import { Engine } from '../../engine';
-import { ShaderStage } from '../../graph/graph-types';
-import { CodeNode, NodeProperty } from '../../graph/code-nodes';
-import { NodePosition } from '../../graph/base-node';
-import { UniformDataType } from '../../graph/data-nodes';
-export declare const physicalDefaultProperties: {
-    blendType: number;
-    opacity: number;
-    useMetalness: boolean;
-    cull: number;
-};
-/**
- * For the use of "0.5", apparently PlayCanvas optimizes uniform
- * generation where if you set diffuse to white (1,1,1) then it doesn't
- * add the diffuse uniform, because that's the default state.
- */
-export declare const defaultPropertySetting: (app: pc.Application, property: NodeProperty) => 0.5 | pc.Texture | pc.Color;
-export declare const physicalNode: (id: string, name: string, position: NodePosition, uniforms: UniformDataType[], stage: ShaderStage | undefined) => CodeNode;
-export type RuntimeContext = {
-    scene: pc.Scene;
-    camera: pc.Camera;
-    pc: any;
-    sceneData: any;
-    cache: {
-        data: {
-            [key: string]: any;
-        };
-        nodes: {
-            [id: string]: {
-                fragment: string;
-                vertex: string;
-            };
-        };
-    };
-};
-export declare const toonNode: (id: string, name: string, position: NodePosition, uniforms: UniformDataType[], stage: ShaderStage | undefined) => CodeNode;
-export declare let mIdx: number;
-export declare const playengine: Engine;

package/esm/plugins/three/importers.d.ts

@@ -1,3 +0,0 @@
-import { EngineImporters } from '../../engine';
-declare const importers: EngineImporters;
-export default importers;

package/esm/plugins/three/index.d.ts

@@ -1,2 +0,0 @@
-import { createMaterial, threngine } from './threngine';
-export { createMaterial, threngine as engine };