@galacean/engine-shader-compiler 0.0.0-experimental-2.0-spine.0

package/bundler/rollup.cjs.js

@@ -0,0 +1,368 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var fs = require('node:fs');
+var path = require('node:path');
+var node_module = require('node:module');
+var node_url = require('node:url');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
+var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
+
+/** Normalize to forward slashes (Windows uses `\`; downstream regex/keys assume `/`). */ function normalizePath(p) {
+    return p.split(path__default["default"].sep).join("/");
+}
+/** Recursively find all files with a given extension. */ function findFiles(dir, ext) {
+    const results = [];
+    if (!fs__default["default"].existsSync(dir)) return results;
+    for (const entry of fs__default["default"].readdirSync(dir, {
+        withFileTypes: true
+    })){
+        const fullPath = path__default["default"].join(dir, entry.name);
+        if (entry.isDirectory()) {
+            results.push(...findFiles(fullPath, ext));
+        } else if (entry.name.endsWith(ext)) {
+            results.push(normalizePath(fullPath));
+        }
+    }
+    return results;
+}
+/** `PBR.shaderc` → `PBRSource`,  `2D/Sprite.shaderc` → `SpriteSource`. */ function shadercPathToVarName(relPath) {
+    const normalized = normalizePath(relPath).replace(/\.shaderc$/, "");
+    const base = normalized.split("/").pop() ?? normalized;
+    const cleaned = base.replace(/[^A-Za-z0-9]/g, "");
+    if (cleaned.length === 0) return "Source";
+    return `${cleaned[0].toUpperCase()}${cleaned.slice(1)}Source`;
+}
+/** `Common/Common.glsl` → `Common_Common` — TS identifier for source-index imports. */ function pathToIdentifier(rel, ext) {
+    let id = rel.replace(new RegExp(`\\${ext}$`), "").replace(/[^A-Za-z0-9_]/g, "_");
+    if (/^[0-9]/.test(id)) id = "_" + id;
+    return id;
+}
+/** Remove empty parent directories upward from `startDir` until `stopDir` is hit. */ function pruneEmptyDirs(startDir, stopDir) {
+    let dir = startDir;
+    while(dir !== stopDir && fs__default["default"].existsSync(dir) && fs__default["default"].readdirSync(dir).length === 0){
+        fs__default["default"].rmdirSync(dir);
+        dir = path__default["default"].dirname(dir);
+    }
+}
+async function runFull(options) {
+    const inputDir = path__default["default"].resolve(options.input);
+    const outputDir = path__default["default"].resolve(options.output);
+    const platformTarget = options.platformTarget ?? 0;
+    if (!fs__default["default"].existsSync(inputDir)) {
+        throw new Error(`Input directory does not exist: ${inputDir}`);
+    }
+    fs__default["default"].mkdirSync(outputDir, {
+        recursive: true
+    });
+    // Emit source indexes before compile so collectIncludeMap can resolve the freshly-built sources.
+    if (options.emitSources) {
+        emitSources(inputDir);
+    }
+    const shaderCompiler = await loadShaderCompiler();
+    shaderCompiler._setIncludeMap(await collectIncludeMap(inputDir));
+    let failed = 0;
+    if (options.only) {
+        const target = path__default["default"].resolve(options.only);
+        if (!compileSingle(shaderCompiler, target, inputDir, outputDir, platformTarget)) failed++;
+    } else {
+        const shaderFiles = findFiles(inputDir, ".shader");
+        console.log(`[shader-compiler-bundler] Precompiling ${shaderFiles.length} shader(s)...`);
+        for (const file of shaderFiles){
+            if (!compileSingle(shaderCompiler, file, inputDir, outputDir, platformTarget)) failed++;
+        }
+        if (options.clean) {
+            const removed = cleanOrphanedBundles(shaderFiles, inputDir, outputDir);
+            if (removed > 0) console.log(`[shader-compiler-bundler] Cleaned ${removed} orphaned .shaderc file(s).`);
+        }
+        if (failed > 0) console.warn(`[shader-compiler-bundler] ${failed} shader(s) failed to precompile.`);
+    }
+    if (options.emitIndex) {
+        emitIndex(outputDir);
+    }
+    return {
+        failed
+    };
+}
+async function startWatcher(options) {
+    const inputDir = path__default["default"].resolve(options.input);
+    const outputDir = path__default["default"].resolve(options.output);
+    const platformTarget = options.platformTarget ?? 0;
+    const shaderCompiler = await loadShaderCompiler();
+    shaderCompiler._setIncludeMap(await collectIncludeMap(inputDir));
+    // .glsl change → full recompile (can't cheaply track include graphs).
+    // .shader change → single-file recompile.
+    const handleInputChange = async (filename)=>{
+        if (!filename) return;
+        const norm = normalizePath(filename);
+        const fullPath = path__default["default"].join(inputDir, filename);
+        if (norm.endsWith(".glsl")) {
+            console.log(`[shader-compiler-bundler] Include changed (${norm}), full recompile...`);
+            shaderCompiler._setIncludeMap(await collectIncludeMap(inputDir));
+            runFull(options).catch((e)=>console.error(e));
+            return;
+        }
+        if (!norm.endsWith(".shader")) return;
+        if (!fs__default["default"].existsSync(fullPath)) {
+            removeBundleFor(fullPath, inputDir, outputDir);
+        } else {
+            compileSingle(shaderCompiler, fullPath, inputDir, outputDir, platformTarget);
+        }
+        if (options.emitSources) emitSources(inputDir);
+        if (options.emitIndex) emitIndex(outputDir);
+    };
+    console.log(`[shader-compiler-bundler] Watching ${inputDir} ...`);
+    fs__default["default"].watch(inputDir, {
+        recursive: true
+    }, (_event, filename)=>{
+        handleInputChange(filename).catch((e)=>console.error(e));
+    });
+}
+async function loadShaderCompiler() {
+    // @ts-ignore — `../dist/main.js` is the compiled runtime entry; no .ts source.
+    // Bundler ships at `<pkg>/bundler/` and the runtime at `<pkg>/dist/`, so this
+    // resolves to the sibling `dist/` from `bundler/cli.js` at runtime.
+    const mod = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('../dist/main.js')); });
+    const instance = new mod.ShaderCompiler();
+    if (typeof instance._precompile !== "function") {
+        throw new Error("ShaderCompiler._precompile is not available; rebuild @galacean/engine-shader-compiler first.");
+    }
+    return instance;
+}
+// Local .glsl come from inputDir; standard library comes from
+// `@galacean/engine-shader/sources` with a sibling-dir fallback for engine self-build cold-start.
+async function collectIncludeMap(inputDir) {
+    const map = {};
+    for (const file of findFiles(inputDir, ".glsl")){
+        const relPath = normalizePath(path__default["default"].relative(inputDir, file));
+        map[relPath] = fs__default["default"].readFileSync(file, "utf-8");
+    }
+    let usedRelease = false;
+    // Resolve from inputDir's node_modules so consumers without transitive linkage to shader-compiler can still find it.
+    try {
+        const requireFromInput = node_module.createRequire(path__default["default"].join(inputDir, "package.json"));
+        const sourcesPath = requireFromInput.resolve("@galacean/engine-shader/sources");
+        const { shaderLibrary } = await (function (t) { return Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require(t)); }); })(node_url.pathToFileURL(sourcesPath).href);
+        for (const { source, path: chunkPath } of shaderLibrary){
+            map[chunkPath] = source;
+        }
+        usedRelease = true;
+    } catch  {
+    // engine self-build cold-start: dist/sources.* not yet built; use sibling source.
+    }
+    if (!usedRelease) {
+        const siblingLibrary = path__default["default"].join(path__default["default"].dirname(inputDir), "ShaderLibrary");
+        if (fs__default["default"].existsSync(siblingLibrary)) {
+            for (const file of findFiles(siblingLibrary, ".glsl")){
+                const rel = normalizePath(path__default["default"].relative(siblingLibrary, file));
+                map[`ShaderLibrary/${rel}`] = fs__default["default"].readFileSync(file, "utf-8");
+            }
+        }
+    }
+    return map;
+}
+// Mirrors `ShaderPass._shaderRootPath` in engine; inlined to keep bundler engine-free.
+const SHADER_ROOT_PATH = "shaders://root/";
+function compileSingle(shaderCompiler, shaderPath, inputDir, outputDir, platformTarget) {
+    const source = fs__default["default"].readFileSync(shaderPath, "utf-8");
+    const relativePath = normalizePath(path__default["default"].relative(inputDir, shaderPath));
+    const bundleRelative = relativePath.replace(/\.shader$/, ".shaderc");
+    const bundlePath = path__default["default"].join(outputDir, bundleRelative);
+    const basePathForIncludeKey = new URL(relativePath, SHADER_ROOT_PATH).href;
+    fs__default["default"].mkdirSync(path__default["default"].dirname(bundlePath), {
+        recursive: true
+    });
+    try {
+        const precompiled = shaderCompiler._precompile(source, platformTarget, basePathForIncludeKey);
+        fs__default["default"].writeFileSync(bundlePath, JSON.stringify(precompiled));
+        console.log(`  ${relativePath} -> ${bundleRelative}`);
+        return true;
+    } catch (e) {
+        console.error(`  FAILED: ${relativePath}`);
+        console.error(e);
+        return false;
+    }
+}
+function cleanOrphanedBundles(shaderFiles, inputDir, outputDir) {
+    const aliveSet = new Set(shaderFiles.map((f)=>normalizePath(path__default["default"].relative(inputDir, f)).replace(/\.shader$/, "")));
+    const bundleFiles = findFiles(outputDir, ".shaderc");
+    let removed = 0;
+    for (const bundleFile of bundleFiles){
+        const rel = normalizePath(path__default["default"].relative(outputDir, bundleFile)).replace(/\.shaderc$/, "");
+        if (!aliveSet.has(rel)) {
+            fs__default["default"].unlinkSync(bundleFile);
+            console.log(`  Removed orphaned: ${rel}.shaderc`);
+            removed++;
+            pruneEmptyDirs(path__default["default"].dirname(bundleFile), outputDir);
+        }
+    }
+    return removed;
+}
+function emitIndex(outputDir) {
+    const bundleFiles = findFiles(outputDir, ".shaderc");
+    const entries = bundleFiles.map((file)=>{
+        const rel = normalizePath(path__default["default"].relative(outputDir, file));
+        return {
+            varName: shadercPathToVarName(rel),
+            importPath: `./${rel}`
+        };
+    }).sort((a, b)=>a.varName.localeCompare(b.varName));
+    const imports = entries.map((e)=>`import ${e.varName} from "${e.importPath}";`).join("\n");
+    const exportBlock = `export {\n${entries.map((e)=>`  ${e.varName}`).join(",\n")}\n};`;
+    // prettier-ignore the export block: consumer's prettier config is unknown.
+    const content = `// Auto-generated by shader-compiler-precompile --emit-index — do not edit.\n${imports}\n\n// prettier-ignore\n${exportBlock}\n`;
+    const indexPath = path__default["default"].join(outputDir, "index.ts");
+    const existing = fs__default["default"].existsSync(indexPath) ? fs__default["default"].readFileSync(indexPath, "utf-8") : "";
+    if (content !== existing) {
+        fs__default["default"].writeFileSync(indexPath, content);
+        console.log("  Updated index.ts");
+    }
+}
+// Generate raw-source indexes:
+//   <inputDir>/index.ts           — `.shader` array (defines IShaderSource interface)
+//   <sibling>/ShaderLibrary/index.ts — `.glsl` array (only if the directory exists)
+function emitSources(inputDir) {
+    emitShaderSourceIndex(inputDir);
+    const libraryDir = path__default["default"].join(path__default["default"].dirname(inputDir), "ShaderLibrary");
+    if (fs__default["default"].existsSync(libraryDir)) {
+        emitLibrarySourceIndex(libraryDir);
+    }
+}
+function emitShaderSourceIndex(rootDir) {
+    const srcDir = path__default["default"].dirname(rootDir);
+    const files = findFiles(rootDir, ".shader").sort();
+    const importPaths = files.map((f)=>normalizePath(path__default["default"].relative(rootDir, f)));
+    const paths = files.map((f)=>normalizePath(path__default["default"].relative(srcDir, f)));
+    const ids = importPaths.map((p)=>pathToIdentifier(p, ".shader"));
+    const lines = [];
+    lines.push("// Auto-generated by shader-compiler-precompile --emit-sources — do not edit.");
+    lines.push("");
+    importPaths.forEach((rel, i)=>lines.push(`import ${ids[i]} from "./${rel}";`));
+    lines.push("");
+    lines.push("export interface IShaderSource {");
+    lines.push("  path: string;");
+    lines.push("  source: string;");
+    lines.push("}");
+    lines.push("");
+    lines.push("// prettier-ignore");
+    lines.push("export const shaders: IShaderSource[] = [");
+    paths.forEach((p, i)=>lines.push(`  { source: ${ids[i]}, path: ${JSON.stringify(p)} },`));
+    lines.push("];");
+    lines.push("");
+    const out = path__default["default"].join(rootDir, "index.ts");
+    fs__default["default"].writeFileSync(out, lines.join("\n"), "utf-8");
+    console.log(`  Emitted shaders index ${path__default["default"].relative(process.cwd(), out)} (${files.length})`);
+}
+function emitLibrarySourceIndex(rootDir) {
+    const srcDir = path__default["default"].dirname(rootDir);
+    const files = findFiles(rootDir, ".glsl").sort();
+    const importPaths = files.map((f)=>normalizePath(path__default["default"].relative(rootDir, f)));
+    const paths = files.map((f)=>normalizePath(path__default["default"].relative(srcDir, f)));
+    const ids = importPaths.map((p)=>pathToIdentifier(p, ".glsl"));
+    const lines = [];
+    lines.push("// Auto-generated by shader-compiler-precompile --emit-sources — do not edit.");
+    lines.push("");
+    lines.push(`import type { IShaderSource } from "../Shaders";`);
+    importPaths.forEach((rel, i)=>lines.push(`import ${ids[i]} from "./${rel}";`));
+    lines.push("");
+    lines.push("// prettier-ignore");
+    lines.push("export const shaderLibrary: IShaderSource[] = [");
+    paths.forEach((p, i)=>lines.push(`  { source: ${ids[i]}, path: ${JSON.stringify(p)} },`));
+    lines.push("];");
+    lines.push("");
+    const out = path__default["default"].join(rootDir, "index.ts");
+    fs__default["default"].writeFileSync(out, lines.join("\n"), "utf-8");
+    console.log(`  Emitted library index ${path__default["default"].relative(process.cwd(), out)} (${files.length})`);
+}
+function removeBundleFor(shaderPath, inputDir, outputDir) {
+    const rel = normalizePath(path__default["default"].relative(inputDir, shaderPath)).replace(/\.shader$/, ".shaderc");
+    const bundlePath = path__default["default"].join(outputDir, rel);
+    if (fs__default["default"].existsSync(bundlePath)) {
+        fs__default["default"].unlinkSync(bundlePath);
+        console.log(`  Removed: ${rel}`);
+        pruneEmptyDirs(path__default["default"].dirname(bundlePath), outputDir);
+    }
+}
+
+/**
+ * Pure transformer: take a file's id + source and emit JS module source.
+ *
+ * - `.shaderc`        → exports the embedded JSON literal as the default export.
+ * - `.shader`/`.glsl` → exports the raw source as a string literal.
+ */ function transformAsModule(code, id) {
+    if (id.endsWith(".shaderc")) {
+        return {
+            code: `export default ${code};`,
+            map: {
+                mappings: ""
+            }
+        };
+    }
+    return {
+        code: `export default ${JSON.stringify(code)};`,
+        map: {
+            mappings: ""
+        }
+    };
+}
+/**
+ * Rollup plugin that transforms shader assets into JS modules.
+ *
+ * - Always: transforms `.glsl` / `.shader` / `.shaderc` files.
+ * - When `precompile` option is set: runs a full precompile in buildStart and,
+ *   in watch mode, starts a background watcher that mirrors `.shader` source
+ *   changes into `.shaderc` outputs and refreshes the aggregated index.
+ */ function shaderCompiler(options = {}) {
+    const { filter, precompile } = options;
+    const precompileOptions = precompile && {
+        clean: true,
+        emitIndex: true,
+        ...precompile
+    };
+    let initialDone = false;
+    let watcherStarted = false;
+    return {
+        name: "shader-compiler",
+        async buildStart () {
+            if (!precompileOptions || initialDone) return;
+            initialDone = true;
+            await runFull(precompileOptions);
+            if (this.meta.watchMode && !watcherStarted) {
+                watcherStarted = true;
+                startWatcher(precompileOptions).catch((e)=>this.warn(`[shader-compiler] watcher failed: ${e.message}`));
+            }
+        },
+        transform (code, id) {
+            const normalized = normalizePath(id);
+            if (!normalized.match(/\.(glsl|shader|shaderc)$/)) return null;
+            if (filter && !filter(normalized)) return null;
+            return {
+                code: transformAsModule(code, normalized).code
+            };
+        }
+    };
+}
+
+exports.shaderCompiler = shaderCompiler;