@shaderfrog/core 0.1.1 → 1.0.0

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

@@ -0,0 +1,28 @@
+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, groupId: string | null | undefined, position: NodePosition, uniforms: UniformDataType[], stage: ShaderStage | undefined, nextStageNodeId?: string) => 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, groupId: string | null | undefined, position: NodePosition, uniforms: UniformDataType[], stage: ShaderStage | undefined, nextStageNodeId?: string) => CodeNode;
+export declare let mIdx: number;
+export declare const babylengine: Engine;

package/dist/plugins/babylon/bablyengine.js

@@ -71,13 +71,13 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 };
 var _a, _b;
-import * as BABYLON from 'babylonjs';
+import { PBRMaterial, Texture, Light, Vector2, Vector3, Vector4, Color3, Color4, } from 'babylonjs';
 import { EngineNodeType } from '../../engine';
-import { nodeName, doesLinkThruShader, prepopulatePropertyInputs, mangleMainFn, } from '../../graph';
-import { NodeType } from '../../graph-types';
+import { nodeName, doesLinkThruShader, prepopulatePropertyInputs, mangleMainFn, } from '../../graph/graph';
+import { NodeType } from '../../graph/graph-types';
 import importers from './importers';
-import { returnGlPositionHardCoded, returnGlPosition, returnGlPositionVec3Right, } from '../../ast/manipulate';
-import { property, } from '../../nodes/code-nodes';
+import { returnGlPositionHardCoded, returnGlPosition, returnGlPositionVec3Right, } from '../../util/ast';
+import { property, } from '../../graph/code-nodes';
 import { namedAttributeStrategy, texture2DStrategy, uniformStrategy, } from '../../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
@@ -86,7 +86,7 @@ import { namedAttributeStrategy, texture2DStrategy, uniformStrategy, } from '../
 // uniforms
 export var physicalDefaultProperties = {
     forceIrradianceInFragment: true,
-    albedoColor: new BABYLON.Color3(1.0, 1.0, 1.0),
+    albedoColor: new Color3(1.0, 1.0, 1.0),
     metallic: 0.0,
     roughness: 1.0,
 };
@@ -211,16 +211,16 @@ var babylonMaterialProperties = function (scene, graph, node, sibling) {
             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 BABYLON.Texture('', scene);
+                acc[property_1.property] = new 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 BABYLON.Color3(1, 1, 1);
+                acc[property_1.property] = new Color3(1, 1, 1);
             }
             else if (property_1.type === 'rgba') {
-                acc[property_1.property] = new BABYLON.Color4(1, 1, 1, 1);
+                acc[property_1.property] = new Color4(1, 1, 1, 1);
             }
         }
         return acc;
@@ -249,7 +249,7 @@ var programCacheKey = function (engineContext, graph, node, sibling) {
     // 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 BABYLON.Light; });
+    var lights = scene.getNodes().filter(function (n) { return n instanceof Light; });
     return ([node, sibling]
         .sort(function (a, b) { return a.id.localeCompare(b.id); })
         .map(function (n) { return nodeCacheKey(graph, n); })
@@ -292,7 +292,7 @@ var onBeforeCompileMegaShader = function (engineContext, graph, node, sibling) {
     return __generator(this, function (_b) {
         _a = engineContext.runtime, scene = _a.scene, sceneData = _a.sceneData;
         pbrName = "engine_pbr".concat(id());
-        shaderMaterial = new BABYLON.PBRMaterial(pbrName, scene);
+        shaderMaterial = new PBRMaterial(pbrName, scene);
         shaderMaterial.linkRefractionWithTransparency = true;
         shaderMaterial.subSurface.isRefractionEnabled = true;
         newProperties = __assign(__assign({}, (node.config.hardCodedProperties ||
@@ -410,19 +410,19 @@ var evaluateNode = function (node) {
         return parseFloat(node.value);
     }
     if (node.type === 'vector2') {
-        return new BABYLON.Vector2(parseFloat(node.value[0]), parseFloat(node.value[1]));
+        return new Vector2(parseFloat(node.value[0]), parseFloat(node.value[1]));
     }
     else if (node.type === 'vector3') {
-        return new BABYLON.Vector3(parseFloat(node.value[0]), parseFloat(node.value[1]), parseFloat(node.value[2]));
+        return new Vector3(parseFloat(node.value[0]), parseFloat(node.value[1]), parseFloat(node.value[2]));
     }
     else if (node.type === 'vector4') {
-        return new BABYLON.Vector4(parseFloat(node.value[0]), parseFloat(node.value[1]), parseFloat(node.value[2]), parseFloat(node.value[3]));
+        return new Vector4(parseFloat(node.value[0]), parseFloat(node.value[1]), parseFloat(node.value[2]), parseFloat(node.value[3]));
     }
     else if (node.type === 'rgb') {
-        return new BABYLON.Color3(parseFloat(node.value[0]), parseFloat(node.value[1]), parseFloat(node.value[2]));
+        return new Color3(parseFloat(node.value[0]), parseFloat(node.value[1]), parseFloat(node.value[2]));
     }
     else if (node.type === 'rgba') {
-        return new BABYLON.Color4(parseFloat(node.value[0]), parseFloat(node.value[1]), parseFloat(node.value[2]), parseFloat(node.value[3]));
+        return new Color4(parseFloat(node.value[0]), parseFloat(node.value[1]), parseFloat(node.value[2]), parseFloat(node.value[3]));
     }
     else {
         return node.value;

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,39 @@
+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, groupId: string | null | undefined, position: NodePosition, uniforms: UniformDataType[], stage: ShaderStage | undefined, nextStageNodeId?: string) => 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, groupId: string | null | undefined, position: NodePosition, uniforms: UniformDataType[], stage: ShaderStage | undefined, nextStageNodeId?: string) => CodeNode;
+export declare let mIdx: number;
+export declare const playengine: Engine;

package/dist/plugins/playcanvas/playengine.js

@@ -73,11 +73,11 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
 var _a, _b;
 import * as pc from 'playcanvas';
 import { EngineNodeType } from '../../engine';
-import { nodeName, doesLinkThruShader, prepopulatePropertyInputs, mangleMainFn, } from '../../graph';
-import { NodeType } from '../../graph-types';
+import { nodeName, doesLinkThruShader, prepopulatePropertyInputs, mangleMainFn, } from '../../graph/graph';
+import { NodeType } from '../../graph/graph-types';
 import importers from './importers';
-import { returnGlPositionHardCoded, returnGlPosition, returnGlPositionVec3Right, } from '../../ast/manipulate';
-import { property, } from '../../nodes/code-nodes';
+import { returnGlPositionHardCoded, returnGlPosition, returnGlPositionVec3Right, } from '../../util/ast';
+import { property, } from '../../graph/code-nodes';
 import { namedAttributeStrategy, texture2DStrategy, uniformStrategy, } from '../../strategy';
 var log = function () {
     var _a;

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

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

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

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

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

@@ -0,0 +1,31 @@
+import { ShaderStage } from '../../graph/graph-types';
+import { Engine } from '../../engine';
+import { CodeNode, NodeProperty } from '../../graph/code-nodes';
+import { NodePosition } from '../../graph/base-node';
+import { UniformDataType } from '../../graph/data-nodes';
+export declare const physicalNode: (id: string, name: string, groupId: string | null | undefined, position: NodePosition, uniforms: UniformDataType[], stage: ShaderStage | undefined, nextStageNodeId?: string) => CodeNode;
+export declare const defaultPropertySetting: (three: any, property: NodeProperty) => any;
+export type ThreeRuntime = {
+    scene: any;
+    camera: any;
+    renderer: any;
+    three: any;
+    sceneData: any;
+    engineMaterial: any;
+    index: number;
+    cache: {
+        data: {
+            [key: string]: any;
+        };
+        nodes: {
+            [id: string]: {
+                fragmentRef: any;
+                vertexRef: any;
+                fragment: string;
+                vertex: string;
+            };
+        };
+    };
+};
+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;

package/dist/plugins/three/threngine.js

@@ -72,13 +72,13 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
 };
 var _a, _b;
 import { Vector2, Vector3, Vector4, Color } from 'three';
-import { NodeType } from '../../graph-types';
-import { prepopulatePropertyInputs, mangleMainFn } from '../../graph';
+import { NodeType } from '../../graph/graph-types';
+import { prepopulatePropertyInputs, mangleMainFn } from '../../graph/graph';
 import importers from './importers';
 import { EngineNodeType } from '../../engine';
-import { doesLinkThruShader, nodeName } from '../../graph';
-import { returnGlPosition, returnGlPositionHardCoded, returnGlPositionVec3Right, } from '../../ast/manipulate';
-import { property, } from '../../nodes/code-nodes';
+import { doesLinkThruShader, nodeName } from '../../graph/graph';
+import { returnGlPosition, returnGlPositionHardCoded, returnGlPositionVec3Right, } from '../../util/ast';
+import { property, } from '../../graph/code-nodes';
 import { namedAttributeStrategy, texture2DStrategy, uniformStrategy, } from '../../strategy';
 var log = function () {
     var _a;

package/dist/strategy/assignemntTo.d.ts

@@ -0,0 +1,9 @@
+import { BaseStrategy, ApplyStrategy, StrategyType } from '.';
+export interface AssignemntToStrategy extends BaseStrategy {
+    type: StrategyType.ASSIGNMENT_TO;
+    config: {
+        assignTo: string;
+    };
+}
+export declare const assignemntToStrategy: (assignTo: string) => AssignemntToStrategy;
+export declare const applyAssignmentToStrategy: ApplyStrategy<AssignemntToStrategy>;

package/dist/strategy/assignemntTo.js

@@ -1,5 +1,5 @@
-import { findAssignmentTo } from '../ast/manipulate';
-import { nodeInput } from '../nodes/core-node';
+import { findAssignmentTo } from '../util/ast';
+import { nodeInput } from '../graph/base-node';
 import { StrategyType } from '.';
 // Constructor
 export var assignemntToStrategy = function (assignTo) { return ({

package/dist/strategy/declarationOf.d.ts

@@ -0,0 +1,9 @@
+import { BaseStrategy, ApplyStrategy, StrategyType } from '.';
+export declare const declarationOfStrategy: (declarationOf: string) => DeclarationOfStrategy;
+export interface DeclarationOfStrategy extends BaseStrategy {
+    type: StrategyType.DECLARATION_OF;
+    config: {
+        declarationOf: string;
+    };
+}
+export declare const constApplyDeclarationOf: ApplyStrategy<DeclarationOfStrategy>;

package/dist/strategy/declarationOf.js

@@ -1,5 +1,5 @@
-import { findDeclarationOf } from '../ast/manipulate';
-import { nodeInput } from '../nodes/core-node';
+import { findDeclarationOf } from '../util/ast';
+import { nodeInput } from '../graph/base-node';
 import { StrategyType } from '.';
 export var declarationOfStrategy = function (declarationOf) { return ({
     type: StrategyType.DECLARATION_OF,

package/dist/strategy/hardCode.d.ts

@@ -0,0 +1,15 @@
+import { NodeInput } from '../graph/base-node';
+import { BaseStrategy, ApplyStrategy, StrategyType } from '.';
+/**
+ * I don't actually know if anything uses this, nor do I remember how it would
+ * be used, since the filler strategy has no effect on the AST. TODO: Remove
+ * this strategy if no one uses it!
+ */
+export interface HardCodeStrategy extends BaseStrategy {
+    type: StrategyType.HARD_CODE_INPUTS;
+    config: {
+        inputs: NodeInput[];
+    };
+}
+export declare const hardCodeStrategy: (inputs: NodeInput[]) => HardCodeStrategy;
+export declare const applyHardCodeStrategy: ApplyStrategy<HardCodeStrategy>;

package/dist/strategy/index.d.ts

@@ -0,0 +1,8 @@
+export * from './hardCode';
+export * from './uniform';
+export * from './assignemntTo';
+export * from './declarationOf';
+export * from './texture2D';
+export * from './namedAttribute';
+export * from './variable';
+export * from './strategy';

package/dist/strategy/index.js

@@ -1,12 +1,3 @@
-var _a;
-import { applyHardCodeStrategy } from './hardCode';
-import { applyUniformStrategy } from './uniform';
-import { applyAssignmentToStrategy, } from './assignemntTo';
-import { constApplyDeclarationOf as constApplyDeclarationOfStrategy, } from './declarationOf';
-import { applyTexture2DStrategy } from './texture2D';
-import { applyNamedAttributeStrategy, } from './namedAttribute';
-import { applyVariableStrategy } from './variable';
-import { applyInjectStrategy } from './inject';
 export * from './hardCode';
 export * from './uniform';
 export * from './assignemntTo';
@@ -14,25 +5,4 @@ export * from './declarationOf';
 export * from './texture2D';
 export * from './namedAttribute';
 export * from './variable';
-export var StrategyType;
-(function (StrategyType) {
-    StrategyType["VARIABLE"] = "Variable Names";
-    StrategyType["ASSIGNMENT_TO"] = "Assignment To";
-    StrategyType["DECLARATION_OF"] = "Variable Declaration";
-    StrategyType["TEXTURE_2D"] = "Texture2D";
-    StrategyType["NAMED_ATTRIBUTE"] = "Named Attribute";
-    StrategyType["UNIFORM"] = "Uniform";
-    StrategyType["INJECT"] = "Inject";
-    StrategyType["HARD_CODE_INPUTS"] = "Hard Code Inputs";
-})(StrategyType || (StrategyType = {}));
-var strategyRunners = (_a = {},
-    _a[StrategyType.INJECT] = applyInjectStrategy,
-    _a[StrategyType.HARD_CODE_INPUTS] = applyHardCodeStrategy,
-    _a[StrategyType.UNIFORM] = applyUniformStrategy,
-    _a[StrategyType.ASSIGNMENT_TO] = applyAssignmentToStrategy,
-    _a[StrategyType.DECLARATION_OF] = constApplyDeclarationOfStrategy,
-    _a[StrategyType.TEXTURE_2D] = applyTexture2DStrategy,
-    _a[StrategyType.NAMED_ATTRIBUTE] = applyNamedAttributeStrategy,
-    _a[StrategyType.VARIABLE] = applyVariableStrategy,
-    _a);
-export var applyStrategy = function (strategy, node, ast) { return strategyRunners[strategy.type](node, ast, strategy); };
+export * from './strategy';

package/dist/strategy/inject.d.ts

@@ -0,0 +1,15 @@
+import { BaseStrategy, ApplyStrategy, StrategyType } from '.';
+export interface InjectStrategy extends BaseStrategy {
+    type: StrategyType.INJECT;
+    config: {
+        find: string;
+        insert: 'before' | 'after' | 'replace';
+        count: number;
+    };
+}
+/**
+ * Inject source code into an AST, in a find-and-replace style. This only
+ * operates on statements right now
+ */
+export declare const injectStrategy: (config: InjectStrategy['config']) => InjectStrategy;
+export declare const applyInjectStrategy: ApplyStrategy<InjectStrategy>;

package/dist/strategy/inject.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 { nodeInput } from '../nodes/core-node';
+import { nodeInput } from '../graph/base-node';
 import { StrategyType } from '.';
 /**
  * Inject source code into an AST, in a find-and-replace style. This only

package/dist/strategy/namedAttribute.d.ts

@@ -0,0 +1,9 @@
+import { BaseStrategy, ApplyStrategy, StrategyType } from '.';
+export declare const namedAttributeStrategy: (attributeName: string) => NamedAttributeStrategy;
+export interface NamedAttributeStrategy extends BaseStrategy {
+    type: StrategyType.NAMED_ATTRIBUTE;
+    config: {
+        attributeName: string;
+    };
+}
+export declare const applyNamedAttributeStrategy: ApplyStrategy<NamedAttributeStrategy>;

package/dist/strategy/namedAttribute.js

@@ -14,7 +14,7 @@ var __read = (this && this.__read) || function (o, n) {
     }
     return ar;
 };
-import { nodeInput } from '../nodes/core-node';
+import { nodeInput } from '../graph/base-node';
 import { StrategyType } from '.';
 import { generateFiller } from '../util/ast';
 export var namedAttributeStrategy = function (attributeName) { return ({

package/dist/strategy/strategy.d.ts

@@ -0,0 +1,28 @@
+import { AstNode, Program } from '@shaderfrog/glsl-parser/ast';
+import { SourceNode } from '../graph/code-nodes';
+import { HardCodeStrategy } from './hardCode';
+import { UniformStrategy } from './uniform';
+import { AssignemntToStrategy } from './assignemntTo';
+import { DeclarationOfStrategy } from './declarationOf';
+import { Texture2DStrategy } from './texture2D';
+import { NamedAttributeStrategy } from './namedAttribute';
+import { VariableStrategy } from './variable';
+import { InjectStrategy } from './inject';
+import { ComputedInput } from '../graph/parsers';
+export declare enum StrategyType {
+    VARIABLE = "Variable Names",
+    ASSIGNMENT_TO = "Assignment To",
+    DECLARATION_OF = "Variable Declaration",
+    TEXTURE_2D = "Texture2D",
+    NAMED_ATTRIBUTE = "Named Attribute",
+    UNIFORM = "Uniform",
+    INJECT = "Inject",
+    HARD_CODE_INPUTS = "Hard Code Inputs"
+}
+export interface BaseStrategy {
+    type: StrategyType;
+    config: Object;
+}
+export type Strategy = UniformStrategy | AssignemntToStrategy | Texture2DStrategy | NamedAttributeStrategy | VariableStrategy | HardCodeStrategy | InjectStrategy | DeclarationOfStrategy;
+export type ApplyStrategy<T> = (node: SourceNode, ast: AstNode | Program, strategy: T) => ComputedInput[];
+export declare const applyStrategy: (strategy: Strategy, node: SourceNode, ast: AstNode | Program) => ComputedInput[];

package/dist/strategy/strategy.js

@@ -0,0 +1,31 @@
+var _a;
+import { applyHardCodeStrategy } from './hardCode';
+import { applyUniformStrategy } from './uniform';
+import { applyAssignmentToStrategy, } from './assignemntTo';
+import { constApplyDeclarationOf as constApplyDeclarationOfStrategy, } from './declarationOf';
+import { applyTexture2DStrategy } from './texture2D';
+import { applyNamedAttributeStrategy, } from './namedAttribute';
+import { applyVariableStrategy } from './variable';
+import { applyInjectStrategy } from './inject';
+export var StrategyType;
+(function (StrategyType) {
+    StrategyType["VARIABLE"] = "Variable Names";
+    StrategyType["ASSIGNMENT_TO"] = "Assignment To";
+    StrategyType["DECLARATION_OF"] = "Variable Declaration";
+    StrategyType["TEXTURE_2D"] = "Texture2D";
+    StrategyType["NAMED_ATTRIBUTE"] = "Named Attribute";
+    StrategyType["UNIFORM"] = "Uniform";
+    StrategyType["INJECT"] = "Inject";
+    StrategyType["HARD_CODE_INPUTS"] = "Hard Code Inputs";
+})(StrategyType || (StrategyType = {}));
+var strategyRunners = (_a = {},
+    _a[StrategyType.INJECT] = applyInjectStrategy,
+    _a[StrategyType.HARD_CODE_INPUTS] = applyHardCodeStrategy,
+    _a[StrategyType.UNIFORM] = applyUniformStrategy,
+    _a[StrategyType.ASSIGNMENT_TO] = applyAssignmentToStrategy,
+    _a[StrategyType.DECLARATION_OF] = constApplyDeclarationOfStrategy,
+    _a[StrategyType.TEXTURE_2D] = applyTexture2DStrategy,
+    _a[StrategyType.NAMED_ATTRIBUTE] = applyNamedAttributeStrategy,
+    _a[StrategyType.VARIABLE] = applyVariableStrategy,
+    _a);
+export var applyStrategy = function (strategy, node, ast) { return strategyRunners[strategy.type](node, ast, strategy); };

package/dist/strategy/stratgies.test.d.ts

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

package/dist/{stratgies.test.js → strategy/stratgies.test.js}

@@ -16,9 +16,9 @@ var __read = (this && this.__read) || function (o, n) {
 };
 import { parser } from '@shaderfrog/glsl-parser';
 import { generate } from '@shaderfrog/glsl-parser';
-import { applyStrategy, StrategyType } from './strategy';
-import * as graphModule from './graph';
-import { makeExpression } from './ast/manipulate';
+import { applyStrategy, StrategyType } from '.';
+import * as graphModule from '../graph/graph';
+import { makeExpression } from '../util/ast';
 import preprocess from '@shaderfrog/glsl-parser/preprocessor';
 var orig;
 beforeEach(function () {

package/dist/strategy/texture2D.d.ts

@@ -0,0 +1,6 @@
+import { BaseStrategy, ApplyStrategy, StrategyType } from '.';
+export interface Texture2DStrategy extends BaseStrategy {
+    type: StrategyType.TEXTURE_2D;
+}
+export declare const texture2DStrategy: () => Texture2DStrategy;
+export declare const applyTexture2DStrategy: ApplyStrategy<Texture2DStrategy>;

package/dist/strategy/texture2D.js

@@ -25,7 +25,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
 };
 import { generate } from '@shaderfrog/glsl-parser';
 import { visit, } from '@shaderfrog/glsl-parser/ast';
-import { nodeInput } from '../nodes/core-node';
+import { nodeInput } from '../graph/base-node';
 import { StrategyType } from '.';
 export var texture2DStrategy = function () { return ({
     type: StrategyType.TEXTURE_2D,

package/dist/strategy/uniform.d.ts

@@ -0,0 +1,6 @@
+import { BaseStrategy, ApplyStrategy, StrategyType } from '.';
+export interface UniformStrategy extends BaseStrategy {
+    type: StrategyType.UNIFORM;
+}
+export declare const uniformStrategy: () => UniformStrategy;
+export declare const applyUniformStrategy: ApplyStrategy<UniformStrategy>;

package/dist/strategy/uniform.js

@@ -14,8 +14,8 @@ var __read = (this && this.__read) || function (o, n) {
     }
     return ar;
 };
-import { mangleName } from '../graph';
-import { nodeInput } from '../nodes/core-node';
+import { mangleName } from '../graph/graph';
+import { nodeInput } from '../graph/base-node';
 import { StrategyType } from '.';
 import { generateFiller } from '../util/ast';
 export var uniformStrategy = function () { return ({

package/dist/strategy/variable.d.ts

@@ -0,0 +1,6 @@
+import { BaseStrategy, ApplyStrategy, StrategyType } from '.';
+export interface VariableStrategy extends BaseStrategy {
+    type: StrategyType.VARIABLE;
+}
+export declare const variableStrategy: () => VariableStrategy;
+export declare const applyVariableStrategy: ApplyStrategy<VariableStrategy>;

package/dist/strategy/variable.js

@@ -34,7 +34,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     }
     return to.concat(ar || Array.prototype.slice.call(from));
 };
-import { nodeInput } from '../nodes/core-node';
+import { nodeInput } from '../graph/base-node';
 import { StrategyType } from '.';
 import { generateFiller } from '../util/ast';
 export var variableStrategy = function () { return ({

package/dist/util/ast.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Utility functions to work with ASTs
+ */
+import { Filler } from '../graph/parsers';
+import { AstNode, ExpressionStatementNode, FunctionNode, DeclarationNode } from '@shaderfrog/glsl-parser/ast';
+import { Program } from '@shaderfrog/glsl-parser/ast';
+import { ShaderStage } from '../graph/graph-types';
+import { Scope } from '@shaderfrog/glsl-parser/parser/scope';
+export declare const findVec4Constructor: (ast: AstNode) => AstNode | undefined;
+export declare const findAssignmentTo: (ast: AstNode | Program, assignTo: string) => ExpressionStatementNode | undefined;
+export declare const findDeclarationOf: (ast: AstNode | Program, declarationOf: string) => DeclarationNode | undefined;
+export declare const from2To3: (ast: Program, stage: ShaderStage) => void;
+export declare const outDeclaration: (name: string) => Object;
+export declare const makeStatement: (stmt: string) => AstNode;
+export declare const makeFnStatement: (fnStmt: string) => AstNode;
+export declare const makeExpression: (expr: string) => AstNode;
+export declare const makeExpressionWithScopes: (expr: string) => {
+    scope: Scope;
+    expression: AstNode;
+};
+export declare const makeFnBodyStatementWithScopes: (body: string) => {
+    scope: Scope;
+    statements: AstNode[];
+};
+export declare const findFn: (ast: Program, name: string) => FunctionNode | undefined;
+export declare const returnGlPosition: (fnName: string, ast: Program) => void;
+export declare const returnGlPositionHardCoded: (fnName: string, ast: Program, returnType: string, hardCodedReturn: string) => void;
+export declare const returnGlPositionVec3Right: (fnName: string, ast: Program) => void;
+export declare const convert300MainToReturn: (suffix: string, ast: Program) => void;
+export declare const generateFiller: (filler: Filler) => string;