@shaderfrog/core 1.3.0 → 1.3.2

package/cjs/graph/shader-sections.js

@@ -1,268 +0,0 @@
-"use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.findShaderSections = exports.shaderSectionsToProgram = exports.mergeShaderSections = exports.dedupeUniforms = exports.dedupeQualifiedStatements = exports.highestPrecisions = exports.dedupeVersions = exports.higherPrecision = exports.emptyShaderSections = void 0;
-var glsl_parser_1 = require("@shaderfrog/glsl-parser");
-var ast_1 = require("../util/ast");
-var emptyShaderSections = function () { return ({
-    precision: [],
-    preprocessor: [],
-    version: [],
-    structs: [],
-    program: [],
-    inStatements: [],
-    outStatements: [],
-    uniforms: [],
-}); };
-exports.emptyShaderSections = emptyShaderSections;
-var Precision;
-(function (Precision) {
-    Precision[Precision["highp"] = 2] = "highp";
-    Precision[Precision["mediump"] = 1] = "mediump";
-    Precision[Precision["lowp"] = 0] = "lowp";
-})(Precision || (Precision = {}));
-var higherPrecision = function (p1, p2) {
-    return Precision[p1] > Precision[p2] ? p1 : p2;
-};
-exports.higherPrecision = higherPrecision;
-var dedupeVersions = function (nodes) { return nodes[0]; };
-exports.dedupeVersions = dedupeVersions;
-var highestPrecisions = function (nodes) {
-    return Object.entries(nodes.reduce(function (precisions, stmt) {
-        var _a;
-        return (__assign(__assign({}, precisions), (_a = {}, _a[stmt.declaration.specifier.specifier.token] = (0, exports.higherPrecision)(precisions[stmt.declaration.specifier.specifier.token], stmt.declaration.qualifier.token), _a)));
-    }, {})).map(function (_a) {
-        var _b = __read(_a, 2), typeName = _b[0], precision = _b[1];
-        return (0, ast_1.makeStatement)("precision ".concat(precision, " ").concat(typeName));
-    });
-};
-exports.highestPrecisions = highestPrecisions;
-var dedupeQualifiedStatements = function (statements, qualifier) {
-    return Object.entries(statements.reduce(function (stmts, stmt) {
-        var _a;
-        return (__assign(__assign({}, stmts), (_a = {}, _a[stmt.declaration.specified_type.specifier.specifier.token] = __assign(__assign({}, (stmts[stmt.declaration.specified_type.specifier.specifier.token] || {})), stmt.declaration.declarations.reduce(function (types, decl) {
-            var _a;
-            return (__assign(__assign({}, types), (_a = {}, _a[decl.identifier.identifier] = true, _a)));
-        }, {})), _a)));
-    }, {})).map(function (_a) {
-        var _b = __read(_a, 2), type = _b[0], varNames = _b[1];
-        return (0, ast_1.makeStatement)("".concat(qualifier, " ").concat(type, " ").concat(Object.keys(varNames).join(', ')));
-    });
-};
-exports.dedupeQualifiedStatements = dedupeQualifiedStatements;
-/**
- * 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
- */
-var dedupeUniforms = function (statements) {
-    var groupedByTypeName = Object.entries(statements.reduce(function (stmts, stmt) {
-        var _a, _b, _c;
-        var _d;
-        var decl = stmt.declaration;
-        // This is the standard case, a uniform like "uniform vec2 x"
-        if ('specified_type' in decl) {
-            var specified_type = decl.specified_type;
-            var specifier = specified_type.specifier.specifier;
-            // Token is for "vec2", "identifier" is for custom names like struct
-            var type_1 = 'token' in specifier
-                ? specifier.token
-                : 'identifier' in specifier
-                    ? specifier.identifier
-                    : undefined;
-            if (!type_1) {
-                console.error('Unknown statement: ', stmt);
-                throw new Error("Unknown specifier: ".concat(specifier.type));
-            }
-            // Groups uniforms into their return type, and for each type, collapses
-            // uniform names into an object where the keys determine uniqueness
-            // "vec2": { x: x[1] }
-            var grouped = decl.declarations.reduce(function (types, decl) {
-                var _a;
-                var _b, _c, _d;
-                var identifier = decl.identifier;
-                var quantifier = '';
-                if (decl.quantifier) {
-                    if (!('token' in decl.quantifier[0].expression)) {
-                        console.error('Unknown expression in quantifier: ', decl);
-                        throw new Error("Unknown expression in quantifier: ".concat((0, glsl_parser_1.generate)(decl)));
-                    }
-                    quantifier = "[".concat(decl.quantifier[0].expression.token, "]");
-                }
-                return __assign(__assign({}, types), (_a = {}, _a[identifier.identifier] = ((_c = (_b = stmts[type_1]) === null || _b === void 0 ? void 0 : _b[identifier.identifier]) === null || _c === void 0 ? void 0 : _c.hasInterface)
-                    ? (_d = stmts[type_1]) === null || _d === void 0 ? void 0 : _d[identifier.identifier]
-                    : {
-                        hasInterface: false,
-                        generated: identifier.identifier + quantifier,
-                    }, _a));
-            }, {});
-            return __assign(__assign({}, stmts), (_a = {}, _a[type_1] = __assign(__assign({}, (stmts[type_1] || {})), grouped), _a));
-            // This is the less common case, a uniform like "uniform Light { vec3 position; } name"
-        }
-        else if ('interface_type' in decl) {
-            var interface_type = decl.interface_type, identifier = decl.identifier;
-            // If this is an interface block only, like uniform Scene { mat4 view; };
-            // then group the interface block declaration under ''
-            var interfaceDeclaredUniform = ((_d = identifier === null || identifier === void 0 ? void 0 : identifier.identifier) === null || _d === void 0 ? void 0 : _d.identifier) || '';
-            var node = {
-                type: 'interface_declarator',
-                lp: decl.lp,
-                declarations: decl.declarations,
-                qualifiers: [],
-                // This is non-nullable, to produce "X" in "uniform X { ... } varName"
-                // But it appears "X" is in declarations above
-                interface_type: {
-                    type: 'identifier',
-                    identifier: '',
-                    whitespace: '',
-                },
-                rp: decl.rp,
-            };
-            return __assign(__assign({}, stmts), (_b = {}, _b[interface_type.identifier] = (_c = {},
-                _c[interfaceDeclaredUniform] = {
-                    generated: "".concat((0, glsl_parser_1.generate)(node)).concat(interfaceDeclaredUniform),
-                    hasInterface: true,
-                },
-                _c), _b));
-        }
-        else {
-            console.error('Unknown uniform AST', { stmt: stmt, code: (0, glsl_parser_1.generate)(stmt) });
-            throw new Error('Unknown uniform AST encountered when merging uniforms');
-        }
-    }, {}));
-    return groupedByTypeName.map(function (_a) {
-        var _b = __read(_a, 2), type = _b[0], variables = _b[1];
-        return (0, ast_1.makeStatement)("uniform ".concat(type, " ").concat(Object.values(variables)
-            .map(function (v) { return v.generated; })
-            .join(', ')));
-    });
-};
-exports.dedupeUniforms = dedupeUniforms;
-var mergeShaderSections = function (s1, s2) {
-    return {
-        version: __spreadArray(__spreadArray([], __read(s1.version), false), __read(s2.version), false),
-        precision: __spreadArray(__spreadArray([], __read(s1.precision), false), __read(s2.precision), false),
-        preprocessor: __spreadArray(__spreadArray([], __read(s1.preprocessor), false), __read(s2.preprocessor), false),
-        inStatements: __spreadArray(__spreadArray([], __read(s1.inStatements), false), __read(s2.inStatements), false),
-        outStatements: __spreadArray(__spreadArray([], __read(s1.outStatements), false), __read(s2.outStatements), false),
-        structs: __spreadArray(__spreadArray([], __read(s1.structs), false), __read(s2.structs), false),
-        uniforms: __spreadArray(__spreadArray([], __read(s1.uniforms), false), __read(s2.uniforms), false),
-        program: __spreadArray(__spreadArray([], __read(s1.program), false), __read(s2.program), false),
-    };
-};
-exports.mergeShaderSections = mergeShaderSections;
-var shaderSectionsToProgram = function (sections, mergeOptions) { return ({
-    type: 'program',
-    scopes: [],
-    program: __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], __read((mergeOptions.includeVersion ? [(0, exports.dedupeVersions)(sections.version)] : [])), false), __read((mergeOptions.includePrecisions
-        ? (0, exports.highestPrecisions)(sections.precision)
-        : [])), false), __read(sections.preprocessor), false), __read(sections.structs), false), __read((0, exports.dedupeQualifiedStatements)(sections.inStatements, 'in')), false), __read((0, exports.dedupeQualifiedStatements)(sections.outStatements, 'out')), false), __read((0, exports.dedupeUniforms)(sections.uniforms)), false), __read(sections.program), false),
-}); };
-exports.shaderSectionsToProgram = shaderSectionsToProgram;
-/**
- * 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
- */
-var findShaderSections = function (ast) {
-    var initialValue = {
-        precision: [],
-        preprocessor: [],
-        version: [],
-        structs: [],
-        inStatements: [],
-        outStatements: [],
-        uniforms: [],
-        program: [],
-    };
-    return ast.program.reduce(function (sections, node) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
-        if (node.type === 'preprocessor' && node.line.startsWith('#version')) {
-            return __assign(__assign({}, sections), { version: sections.version.concat(node) });
-        }
-        else if (node.type === 'declaration_statement' &&
-            node.declaration.type === 'precision') {
-            return __assign(__assign({}, sections), { precision: sections.precision.concat(node) });
-        }
-        else if (node.type === 'preprocessor') {
-            return __assign(__assign({}, sections), { preprocessor: sections.preprocessor.concat(node) });
-        }
-        else if (node.type === 'declaration_statement' &&
-            node.declaration.type === 'declarator_list' &&
-            ((_d = (_c = (_b = (_a = node.declaration) === null || _a === void 0 ? void 0 : _a.specified_type) === null || _b === void 0 ? void 0 : _b.specifier) === null || _c === void 0 ? void 0 : _c.specifier) === null || _d === void 0 ? void 0 : _d.type) === 'struct') {
-            return __assign(__assign({}, sections), { structs: sections.structs.concat(node) });
-            // This definition of a uniform lines up with the processing we do in
-            // dedupeUniforms
-        }
-        else if (node.type === 'declaration_statement' &&
-            // Ignore lines like "layout(std140,column_major) uniform;"
-            !('qualifiers' in node.declaration &&
-                ((_f = (_e = node.declaration) === null || _e === void 0 ? void 0 : _e.qualifiers) === null || _f === void 0 ? void 0 : _f.find(function (q) { return 'layout' in q; }))) &&
-            // One of these checks is for a uniform with an interface block, and the
-            // other is for vanilla uniforms. I don't remember which is which
-            (('specified_type' in node.declaration &&
-                'qualifiers' in node.declaration.specified_type &&
-                ((_g = node.declaration.specified_type.qualifiers) === null || _g === void 0 ? void 0 : _g.find(function (n) { return 'token' in n && n.token === 'uniform'; }))) ||
-                ('qualifiers' in node.declaration &&
-                    ((_j = (_h = node.declaration) === null || _h === void 0 ? void 0 : _h.qualifiers) === null || _j === void 0 ? void 0 : _j.find(function (n) { return 'token' in n && n.token === 'uniform'; }))))) {
-            return __assign(__assign({}, sections), { uniforms: sections.uniforms.concat(node) });
-        }
-        else if (node.type === 'declaration_statement' &&
-            'specified_type' in node.declaration &&
-            ((_m = (_l = (_k = node.declaration) === null || _k === void 0 ? void 0 : _k.specified_type) === null || _l === void 0 ? void 0 : _l.qualifiers) === null || _m === void 0 ? void 0 : _m.find(function (n) { return 'token' in n && n.token === 'in'; }))) {
-            if ((0, glsl_parser_1.generate)(node).includes('main_Fireball')) {
-                console.log('findShaderSections\n', (0, glsl_parser_1.generate)(ast));
-                console.log("Tracking inStatement \"".concat((0, glsl_parser_1.generate)(node), "\""), node);
-                debugger;
-            }
-            return __assign(__assign({}, sections), { inStatements: sections.inStatements.concat(node) });
-        }
-        else if (node.type === 'declaration_statement' &&
-            'specified_type' in node.declaration &&
-            ((_q = (_p = (_o = node.declaration) === null || _o === void 0 ? void 0 : _o.specified_type) === null || _p === void 0 ? void 0 : _p.qualifiers) === null || _q === void 0 ? void 0 : _q.find(function (n) { return 'token' in n && n.token === 'out'; }))) {
-            return __assign(__assign({}, sections), { outStatements: sections.outStatements.concat(node) });
-        }
-        else {
-            return __assign(__assign({}, sections), { program: sections.program.concat(node) });
-        }
-    }, initialValue);
-};
-exports.findShaderSections = findShaderSections;

package/cjs/index.js

@@ -1,19 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./graph"), exports);
-__exportStar(require("./strategy"), exports);
-__exportStar(require("./engine"), exports);

package/cjs/package.json

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