@shaderfrog/core 2.0.0-beta.3 → 3.0.0

package/plugins/three/threngine.js

@@ -76,10 +76,11 @@ 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/graph';
+import { doesLinkThruShader } from '../../graph/graph';
 import { returnGlPosition, returnGlPositionHardCoded, returnGlPositionVec3Right, } from '../../util/ast';
 import { property, } from '../../graph/code-nodes';
 import { namedAttributeStrategy, texture2DStrategy, uniformStrategy, } from '../../strategy';
+import indexById from '../../util/indexByid';
 var log = function () {
     var _a;
     var args = [];
@@ -117,6 +118,8 @@ export var phongNode = function (id, name, position, uniforms, stage) {
                 property('Specular Map', 'specularMap', 'texture', 'filler_specularMap'),
                 property('Displacement Map', 'displacementMap', 'texture', 'filler_displacementMap'),
                 property('Displacement Scale', 'displacementScale', 'number'),
+                property('Bump Map', 'bumpMap', 'texture', 'filler_bumpMap'),
+                property('Bump Scale', 'bumpScale', 'number'),
                 property('Env Map', 'envMap', 'samplerCube'),
             ],
             strategies: [
@@ -167,6 +170,7 @@ export var physicalNode = function (id, name, position, uniforms, stage) {
                 // MeshPhysicalMaterial gets envMap from the scene. MeshStandardMaterial
                 // gets it from the material
                 // property('Env Map', 'envMap', 'samplerCube'),
+                property('Env Map Intensity', 'envMapIntensity', 'number', 'uniform_envMapIntensity'),
                 property('Transmission', 'transmission', 'number'),
                 property('Transmission Map', 'transmissionMap', 'texture', 'filler_transmissionMap'),
                 property('Thickness', 'thickness', 'number'),
@@ -176,6 +180,7 @@ export var physicalNode = function (id, name, position, uniforms, stage) {
                 // property('Sheen', 'sheen', 'number'),
                 property('Reflectivity', 'reflectivity', 'number'),
                 property('Clearcoat', 'clearcoat', 'number'),
+                property('Clearcoat Roughness', 'clearcoatRoughness', 'number'),
                 property('Iridescence', 'iridescence', 'number'),
                 property('Iridescence IOR', 'iridescenceIOR', 'number'),
                 property('Iridescence Thickness Range', 'iridescenceThicknessRange', 'array', undefined, ['100', '400']),
@@ -213,17 +218,13 @@ var cacher = function (engineContext, graph, node, sibling, newValue) {
         log('Cache miss', cacheKey);
     }
     var materialData = engineContext.runtime.cache.data[cacheKey] || newValue();
+    // This is nasty: We mutate the runtime context here, and return the partial
+    // nodeContext later. See also the TODO: Refactor in context.ts.
     engineContext.runtime.cache.data[cacheKey] = materialData;
     engineContext.runtime.engineMaterial = materialData.material;
-    // TODO: We mutate the nodes here, can we avoid that later?
-    node.source =
-        node.stage === 'fragment' ? materialData.fragment : materialData.vertex;
-    if (sibling) {
-        sibling.source =
-            sibling.stage === 'fragment'
-                ? materialData.fragment
-                : materialData.vertex;
-    }
+    return {
+        computedSource: node.stage === 'fragment' ? materialData.fragment : materialData.vertex,
+    };
 };
 var onBeforeCompileMegaShader = function (engineContext, newMat) {
     log('compiling three megashader!');
@@ -262,7 +263,7 @@ var onBeforeCompileMegaShader = function (engineContext, newMat) {
 };
 var megaShaderMainpulateAst = function (engineContext, engine, graph, ast, inputEdges, node, sibling) {
     var programAst = ast;
-    var mainName = 'main' || nodeName(node);
+    var mainName = 'main'; // || nodeName(node);
     if (node.stage === 'vertex') {
         if (doesLinkThruShader(graph, node)) {
             returnGlPositionHardCoded(mainName, programAst, 'vec3', 'transformed');
@@ -292,6 +293,7 @@ var nodeCacheKey = function (graph, node) {
     );
 };
 var programCacheKey = function (engineContext, graph, node, sibling) {
+    var _a, _b;
     // The megashader source is dependent on scene information, like the number
     // and type of lights in the scene. This kinda sucks - it's duplicating
     // three's material cache key, and is coupled to how three builds shaders
@@ -299,7 +301,7 @@ var programCacheKey = function (engineContext, graph, node, sibling) {
     var lights = [];
     scene.traverse(function (obj) {
         if (obj instanceof Light) {
-            lights.push(obj.type);
+            lights.push(obj.uuid);
         }
     });
     return ([node, sibling]
@@ -309,8 +311,10 @@ var programCacheKey = function (engineContext, graph, node, sibling) {
         .join('-') +
         '|Lights:' +
         lights.join(',') +
-        '|Envtex:' +
-        scene.environmentTexture);
+        '|Bg:' +
+        ((_a = scene.background) === null || _a === void 0 ? void 0 : _a.uuid) +
+        '|Env:' +
+        ((_b = scene.environment) === null || _b === void 0 ? void 0 : _b.uuid));
 };
 export var defaultPropertySetting = function (property) {
     if (property.type === 'texture') {
@@ -328,12 +332,7 @@ export var defaultPropertySetting = function (property) {
 };
 var threeMaterialProperties = function (graph, node, sibling) {
     // Find inputs to this node that are dependent on a property of the material
-    var propertyInputs = node.inputs
-        .filter(function (i) { return i.property; })
-        .reduce(function (acc, input) {
-        var _a;
-        return (__assign(__assign({}, acc), (_a = {}, _a[input.id] = input, _a)));
-    }, {});
+    var propertyInputs = indexById(node.inputs.filter(function (i) { return i.property; }));
     // Then look for any edges into those inputs and set the material property
     return graph.edges
         .filter(function (edge) { return edge.to === node.id || edge.to === (sibling === null || sibling === void 0 ? void 0 : sibling.id); })
@@ -349,6 +348,24 @@ var threeMaterialProperties = function (graph, node, sibling) {
         return acc;
     }, {});
 };
+export var stringifyThreeValue = function (input) {
+    if (input instanceof Vector2) {
+        return "new Vector2(".concat(input.x, ", ").concat(input.y, ")");
+    }
+    else if (input instanceof Vector3) {
+        return "new Vector3(".concat(input.x, ", ").concat(input.y, ", ").concat(input.z, ")");
+    }
+    else if (input instanceof Vector4) {
+        return "new Vector4(".concat(input.x, ", ").concat(input.y, ", ").concat(input.z, ", ").concat(input.w, ")");
+    }
+    else if (input instanceof Color) {
+        return "new Color(".concat(input.r, ", ").concat(input.g, ", ").concat(input.b, ")");
+    }
+    else if (input instanceof Texture) {
+        return "new Texture()";
+    }
+    return "".concat(input);
+};
 var evaluateNode = function (node) {
     if (node.type === 'number') {
         return parseFloat(node.value);
@@ -395,6 +412,7 @@ export var toonNode = function (id, name, position, uniforms, stage) {
                 property('Displacement Map', 'displacementMap', 'texture', 'filler_displacementMap'),
                 property('Displacement Scale', 'displacementScale', 'number'),
                 property('Env Map', 'envMap', 'samplerCube'),
+                property('Env Map Intensity', 'envMapIntensity', 'number'),
             ],
             strategies: [
                 uniformStrategy(),
@@ -459,8 +477,9 @@ export var threngine = {
         'shininess',
         'opacity',
         'map',
+        'IncidentLight',
+        'ReflectedLight',
         'specularTint',
-        'time',
         'normalScale',
         'normalMap',
         'envMap',
@@ -502,12 +521,16 @@ export var threngine = {
         'displacementMap',
         'displacementScale',
         'displacementBias',
+        // passed by shaderfrog. maybe should have separate names? duplicated across
+        // all the engines.
+        'time',
+        'renderResolution',
     ]),
     parsers: (_b = {},
         _b[NodeType.SOURCE] = {
             manipulateAst: function (engineContext, engine, graph, ast, inputEdges, node, sibling) {
                 var programAst = ast;
-                var mainName = 'main' || nodeName(node);
+                var mainName = 'main'; // || nodeName(node);
                 // This hinges on the vertex shader calling vec3(p)
                 if (node.stage === 'vertex') {
                     if (doesLinkThruShader(graph, node)) {
@@ -523,12 +546,11 @@ export var threngine = {
         _b[EngineNodeType.phong] = {
             onBeforeCompile: function (graph, engineContext, node, sibling) { return __awaiter(void 0, void 0, void 0, function () {
                 return __generator(this, function (_a) {
-                    cacher(engineContext, graph, node, sibling, function () {
-                        return onBeforeCompileMegaShader(engineContext, new MeshPhongMaterial(__assign({ 
-                            // @ts-ignore
-                            isMeshPhongMaterial: true }, threeMaterialProperties(graph, node, sibling))));
-                    });
-                    return [2 /*return*/];
+                    return [2 /*return*/, cacher(engineContext, graph, node, sibling, function () {
+                            return onBeforeCompileMegaShader(engineContext, new MeshPhongMaterial(__assign({ 
+                                // @ts-ignore
+                                isMeshPhongMaterial: true }, threeMaterialProperties(graph, node, sibling))));
+                        })];
                 });
             }); },
             manipulateAst: megaShaderMainpulateAst,
@@ -536,10 +558,9 @@ export var threngine = {
         _b[EngineNodeType.physical] = {
             onBeforeCompile: function (graph, engineContext, node, sibling) { return __awaiter(void 0, void 0, void 0, function () {
                 return __generator(this, function (_a) {
-                    cacher(engineContext, graph, node, sibling, function () {
-                        return onBeforeCompileMegaShader(engineContext, new MeshPhysicalMaterial(__assign(__assign({}, node.config.hardCodedProperties), threeMaterialProperties(graph, node, sibling))));
-                    });
-                    return [2 /*return*/];
+                    return [2 /*return*/, cacher(engineContext, graph, node, sibling, function () {
+                            return onBeforeCompileMegaShader(engineContext, new MeshPhysicalMaterial(__assign(__assign({}, node.config.hardCodedProperties), threeMaterialProperties(graph, node, sibling))));
+                        })];
                 });
             }); },
             manipulateAst: megaShaderMainpulateAst,
@@ -547,12 +568,11 @@ export var threngine = {
         _b[EngineNodeType.toon] = {
             onBeforeCompile: function (graph, engineContext, node, sibling) { return __awaiter(void 0, void 0, void 0, function () {
                 return __generator(this, function (_a) {
-                    cacher(engineContext, graph, node, sibling, function () {
-                        return onBeforeCompileMegaShader(engineContext, new MeshToonMaterial(__assign({ gradientMap: new Texture(), 
-                            // @ts-ignore
-                            isMeshToonMaterial: true }, threeMaterialProperties(graph, node, sibling))));
-                    });
-                    return [2 /*return*/];
+                    return [2 /*return*/, cacher(engineContext, graph, node, sibling, function () {
+                            return onBeforeCompileMegaShader(engineContext, new MeshToonMaterial(__assign({ gradientMap: new Texture(), 
+                                // @ts-ignore
+                                isMeshToonMaterial: true }, threeMaterialProperties(graph, node, sibling))));
+                        })];
                 });
             }); },
             manipulateAst: megaShaderMainpulateAst,
@@ -561,7 +581,7 @@ export var threngine = {
 };
 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 }, cameraPosition: { value: new Vector3(1.0) } });
+    var finalUniforms = __assign(__assign(__assign(__assign({}, ShaderLib.phong.uniforms), ShaderLib.toon.uniforms), ShaderLib.physical.uniforms), { time: { value: 0 }, cameraPosition: { value: new Vector3(1.0) }, renderResolution: { value: new Vector2(1.0) } });
     // Also the ThreeComponent's sceneConfig properties modify the material
     var initialProperties = {
         name: 'ShaderFrog Material',

package/plugins/three/threngine.test.js

@@ -37,15 +37,17 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 import { expect, it } from 'vitest';
 import { outputNode, sourceNode } from '../../graph/graph-node';
 import { makeEdge } from '../../graph/edge';
-import { compileSource } from '../../graph/graph';
-import { texture2DStrategy } from '../../strategy';
+import { compileSource, nodeName } from '../../graph/graph';
+import { namedAttributeStrategy, texture2DStrategy } from '../../strategy';
 import { isError } from '../../graph/context';
 import { threngine } from './threngine';
 import { makeId } from '../../util/id';
 import { fail } from '../../test-util';
+import importers from './importers';
+import { generate, parser } from '@shaderfrog/glsl-parser';
 var p = { x: 0, y: 0 };
 var makeSourceNode = function (id, source, stage, strategies) {
-    if (strategies === void 0) { strategies = [texture2DStrategy()]; }
+    if (strategies === void 0) { strategies = [texture2DStrategy(), namedAttributeStrategy('position')]; }
     return sourceNode(id, "Shader ".concat(id), p, {
         version: 2,
         preprocess: false,
@@ -82,8 +84,53 @@ it('threngine compileSource() and manipulateAst()', function () { return __await
                 // Threngine has parsers for vertex shaders, make sure that is set properly
                 expect(result.vertexResult).toContain("vec4 main_Shader_".concat(vertInput.id, "() {\n  vec4 frogOut = modelViewMatrix * vec4(position, 1.0);\n  return frogOut;\n}"));
                 // Check that it inlned. For fun.
-                expect(result.vertexResult).toContain("gl_Position = main_Shader_".concat(vertInput.id, "();"));
+                expect(result.vertexResult).toContain("gl_Position = ".concat(nodeName(vertInput), "();"));
                 return [2 /*return*/];
         }
     });
 }); });
+it('threngine compileSource() linking through vertex', function () { return __awaiter(void 0, void 0, void 0, function () {
+    var outV, outF, vert1, vert2, graph, engineContext, result;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                outV = outputNode(makeId(), 'Output v', p, 'vertex');
+                outF = outputNode(makeId(), 'Output f', p, 'fragment');
+                vert1 = makeSourceNode(makeId(), "void main() {\n  gl_Position = modelViewMatrix * vec4(position, 1.0);\n}\n", 'vertex');
+                vert2 = makeSourceNode(makeId(), "void main() {\n  gl_Position = modelViewMatrix * vec4(position, 1.0);\n}\n", 'vertex');
+                graph = {
+                    nodes: [outV, outF, vert1, vert2],
+                    edges: [
+                        makeEdge(makeId(), vert1.id, outV.id, 'out', 'filler_gl_Position', 'vertex'),
+                        makeEdge(makeId(), vert2.id, vert1.id, 'out', 'filler_position', 'vertex'),
+                    ],
+                };
+                engineContext = {
+                    engine: 'three',
+                    nodes: {},
+                    runtime: {},
+                    debuggingNonsense: {},
+                };
+                return [4 /*yield*/, compileSource(graph, threngine, engineContext)];
+            case 1:
+                result = _a.sent();
+                if (isError(result)) {
+                    fail(result);
+                }
+                // Because vert2 links through vert1, it should be a vec3, not a vec4
+                expect(result.vertexResult).toContain("vec3 ".concat(nodeName(vert2), "() {"));
+                expect(result.vertexResult).toContain("vec4 ".concat(nodeName(vert1), "() {"));
+                return [2 /*return*/];
+        }
+    });
+}); });
+it('threngine shadertoy import', function () { return __awaiter(void 0, void 0, void 0, function () {
+    var testImport, p;
+    return __generator(this, function (_a) {
+        testImport = "\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord ){\n  vec3 rd = normalize(vec3(2.*fragCoord - iResolution.xy, iResolution.y));\n  fragColor = vec4(sqrt(clamp(col, 0., 1.)), 1.0 * iTime);\n}\n";
+        p = parser.parse(testImport);
+        importers.shadertoy.convertAst(p, 'fragment');
+        expect(generate(p)).toContain("\nprecision highp float;\nprecision highp int;\n\nuniform vec2 mouse;\nuniform float time;\nuniform vec2 renderResolution;\n\nvoid main() {\n  vec3 rd = normalize(vec3(2.*gl_FragCoord.xy - renderResolution.xy, renderResolution.y));\n  gl_FragColor = vec4(sqrt(clamp(col, 0., 1.)), 1.0 * time);\n}\n");
+        return [2 /*return*/];
+    });
+}); });

package/strategy/assignmentTo.d.ts

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

package/strategy/assignmentTo.js

@@ -0,0 +1,35 @@
+import { findAssignmentTo } from '../util/ast';
+import { nodeInput } from '../graph/base-node';
+import { StrategyType } from '.';
+// Constructor
+export var assignemntToStrategy = function (assignTo, nth) {
+    if (nth === void 0) { nth = 1; }
+    return ({
+        type: StrategyType.ASSIGNMENT_TO,
+        config: { assignTo: assignTo, nth: nth },
+    });
+};
+// Apply the strategy
+export var applyAssignmentToStrategy = function (strategy, ast, graphNode, siblingNode) {
+    var assignNode = findAssignmentTo(ast, strategy.config.assignTo, strategy.config.nth || 1);
+    var name = strategy.config.assignTo;
+    return assignNode
+        ? [
+            [
+                nodeInput(name, "filler_".concat(name), 'filler', undefined, // Data type for what plugs into this filler
+                ['code', 'data'], false),
+                function (filler) {
+                    var filled = filler();
+                    if ('expression' in assignNode) {
+                        assignNode.expression.right =
+                            filled;
+                    }
+                    else {
+                        assignNode.initializer = filled;
+                    }
+                    return ast;
+                },
+            ],
+        ]
+        : [];
+};

package/strategy/declarationOf.js

@@ -13,8 +13,8 @@ export var constApplyDeclarationOf = function (strategy, ast, graphNode, sibling
             [
                 nodeInput(name, "filler_".concat(name), 'filler', undefined, // Data type for what plugs into this filler
                 ['code', 'data'], false),
-                function (fillerAst) {
-                    declaration.initializer = fillerAst;
+                function (filler) {
+                    declaration.initializer = filler();
                     return ast;
                 },
             ],

package/strategy/hardCode.js

@@ -12,10 +12,7 @@ export var applyHardCodeStrategy = function (strategy, ast, graphNode, siblingNo
             // so this awkward branch is to make types line up. But I don't think
             // this code path would ever get called
             function (filler) {
-                if (!filler || Array.isArray(filler)) {
-                    throw new Error('Cannot use void filler');
-                }
-                return filler;
+                return filler();
             },
         ];
         return ci;

package/strategy/index.d.ts

@@ -1,6 +1,6 @@
 export * from './hardCode';
 export * from './uniform';
-export * from './assignemntTo';
+export * from './assignmentTo';
 export * from './inject';
 export * from './declarationOf';
 export * from './texture2D';

package/strategy/index.js

@@ -1,6 +1,6 @@
 export * from './hardCode';
 export * from './uniform';
-export * from './assignemntTo';
+export * from './assignmentTo';
 export * from './inject';
 export * from './declarationOf';
 export * from './texture2D';

package/strategy/inject.js

@@ -62,10 +62,9 @@ export var applyInjectStrategy = function (strategy, ast, graphNode, siblingNode
         [
             nodeInput(name, "filler_".concat(name), 'filler', undefined, // Data type for what plugs into this filler
             ['code', 'data'], false),
-            function (fillerAst) {
-                var toInsert = Array.isArray(fillerAst)
-                    ? fillerAst
-                    : [fillerAst];
+            function (filler) {
+                var result = filler();
+                var toInsert = Array.isArray(result) ? result : [result];
                 // Loop backwards through the matches because when we inject code into
                 // parent nodes, it modifies the statement list arrays
                 for (

package/strategy/namedAttribute.js

@@ -28,7 +28,7 @@ export var applyNamedAttributeStrategy = function (strategy, ast, graphNode, sib
         [
             nodeInput(attributeName, "filler_".concat(attributeName), 'filler', undefined, // Data type for what plugs into this filler
             ['code', 'data'], true),
-            function (fillerAst) {
+            function (filler) {
                 Object.entries(program.scopes[0].bindings).forEach(function (_a) {
                     var _b = __read(_a, 2), name = _b[0], binding = _b[1];
                     binding.references.forEach(function (ref) {
@@ -37,7 +37,7 @@ export var applyNamedAttributeStrategy = function (strategy, ast, graphNode, sib
                         if (ref.type === 'identifier' &&
                             ref !== binding.declaration &&
                             ref.identifier === attributeName) {
-                            ref.identifier = generateFiller(fillerAst);
+                            ref.identifier = generateFiller(filler());
                         }
                     });
                 });

package/strategy/strategy.d.ts

@@ -2,13 +2,38 @@ 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 { AssignmentToStrategy } from './assignmentTo';
 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';
+import { NodeInput } from '../graph';
+/**
+ * Fillers are generated by *strategies*. Strategies are applied to the AST
+ * by applyStrategy() in strategy.ts, which runs strategy functions like
+ * applyTexture2DStrategy(), which returns a list of fillers found by each
+ * strategy.
+ */
+export type Filler = (...args: string[]) => AstNode | AstNode[] | void;
+export type InputFiller = (filler: Filler) => AstNode | Program;
+export type FillerArguments = AstNode[];
+export type FillerStmt = AstNode;
+export type InputFillerGroup = {
+    filler: InputFiller;
+    fillerArgs?: FillerArguments;
+    fillerStmt?: AstNode;
+};
+export type InputFillers = Record<string, InputFillerGroup>;
+/**
+ * A computed input is ultimately what the strategy application process returns
+ */
+export type ComputedInput = [
+    NodeInput,
+    InputFiller,
+    FillerArguments?,
+    FillerStmt?
+];
 export declare enum StrategyType {
     VARIABLE = "Variable Names",
     ASSIGNMENT_TO = "Assignment To",
@@ -23,6 +48,6 @@ export interface BaseStrategy {
     type: StrategyType;
     config: Object;
 }
-export type Strategy = UniformStrategy | AssignemntToStrategy | Texture2DStrategy | NamedAttributeStrategy | VariableStrategy | HardCodeStrategy | InjectStrategy | DeclarationOfStrategy;
-export type ApplyStrategy<T> = (strategy: T, ast: AstNode | Program, node: SourceNode, sibling: SourceNode) => ComputedInput[];
-export declare const applyStrategy: (strategy: Strategy, ast: AstNode | Program, node: SourceNode, sibling: SourceNode) => ComputedInput[];
+export type Strategy = UniformStrategy | AssignmentToStrategy | Texture2DStrategy | NamedAttributeStrategy | VariableStrategy | HardCodeStrategy | InjectStrategy | DeclarationOfStrategy;
+export type ApplyStrategy<T> = (strategy: T, ast: AstNode | Program, node: SourceNode, sibling?: SourceNode) => ComputedInput[];
+export declare const applyStrategy: (strategy: Strategy, ast: AstNode | Program, node: SourceNode, sibling?: SourceNode) => ComputedInput[];

package/strategy/strategy.js

@@ -1,7 +1,7 @@
 var _a;
 import { applyHardCodeStrategy } from './hardCode';
 import { applyUniformStrategy } from './uniform';
-import { applyAssignmentToStrategy, } from './assignemntTo';
+import { applyAssignmentToStrategy, } from './assignmentTo';
 import { constApplyDeclarationOf as constApplyDeclarationOfStrategy, } from './declarationOf';
 import { applyTexture2DStrategy } from './texture2D';
 import { applyNamedAttributeStrategy, } from './namedAttribute';