@stevejtrettel/shader-sandbox 0.1.0

package/dist-lib/project/loadProject.js

@@ -0,0 +1,350 @@
+/**
+ * Project Layer - Config Loader
+ *
+ * Loads Shadertoy projects from disk into normalized ShadertoyProject representation.
+ * Handles both single-pass (no config) and multi-pass (with config) projects.
+ *
+ * Based on docs/project-spec.md
+ */
+import { promises as fs } from 'fs';
+import * as path from 'path';
+// =============================================================================
+// Helper Functions
+// =============================================================================
+/**
+ * Check if a file exists.
+ */
+async function fileExists(p) {
+    try {
+        await fs.access(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Type guard for PassName.
+ */
+function isPassName(s) {
+    return s === 'Image' || s === 'BufferA' || s === 'BufferB' || s === 'BufferC' || s === 'BufferD';
+}
+/**
+ * List all .glsl files in a directory.
+ */
+async function listGlslFiles(root) {
+    const entries = await fs.readdir(root, { withFileTypes: true });
+    return entries
+        .filter((e) => e.isFile() && e.name.toLowerCase().endsWith('.glsl'))
+        .map((e) => e.name);
+}
+/**
+ * Check if project has a textures/ directory with files.
+ */
+async function hasTexturesDirWithFiles(root) {
+    const dir = path.join(root, 'textures');
+    if (!(await fileExists(dir)))
+        return false;
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    return entries.some((e) => e.isFile());
+}
+/**
+ * Get default source file name for a pass.
+ */
+function defaultSourceForPass(name) {
+    switch (name) {
+        case 'Image':
+            return 'image.glsl';
+        case 'BufferA':
+            return 'bufferA.glsl';
+        case 'BufferB':
+            return 'bufferB.glsl';
+        case 'BufferC':
+            return 'bufferC.glsl';
+        case 'BufferD':
+            return 'bufferD.glsl';
+    }
+}
+// =============================================================================
+// Main Entry Point
+// =============================================================================
+/**
+ * Load a Shadertoy project from disk.
+ *
+ * Automatically detects:
+ * - Single-pass mode (no config, just image.glsl)
+ * - Multi-pass mode (config.json present)
+ *
+ * @param root - Absolute path to project directory
+ * @returns Fully normalized ShadertoyProject
+ * @throws Error with descriptive message if project is invalid
+ */
+export async function loadProject(root) {
+    const configPath = path.join(root, 'config.json');
+    const hasConfig = await fileExists(configPath);
+    if (hasConfig) {
+        // Multi-pass mode: parse config
+        const raw = await fs.readFile(configPath, 'utf8');
+        let config;
+        try {
+            config = JSON.parse(raw);
+        }
+        catch (err) {
+            throw new Error(`Invalid JSON in config.json at '${root}': ${err?.message ?? String(err)}`);
+        }
+        return await loadProjectWithConfig(root, config);
+    }
+    else {
+        // Single-pass mode: just image.glsl
+        return await loadSinglePassProject(root);
+    }
+}
+// =============================================================================
+// Single-Pass Mode (No Config)
+// =============================================================================
+/**
+ * Load a simple single-pass project.
+ *
+ * Requirements:
+ * - Must have image.glsl
+ * - Cannot have other .glsl files
+ * - Cannot have textures/ directory
+ * - No common.glsl allowed
+ *
+ * @param root - Project directory
+ * @returns ShadertoyProject with only Image pass
+ */
+async function loadSinglePassProject(root) {
+    const imagePath = path.join(root, 'image.glsl');
+    if (!(await fileExists(imagePath))) {
+        throw new Error(`Single-pass project at '${root}' requires 'image.glsl'.`);
+    }
+    // Check for extra GLSL files
+    const glslFiles = await listGlslFiles(root);
+    const extraGlsl = glslFiles.filter((name) => name !== 'image.glsl');
+    if (extraGlsl.length > 0) {
+        throw new Error(`Project at '${root}' contains multiple GLSL files (${glslFiles.join(', ')}) but no 'config.json'. Add a config file to use multiple passes.`);
+    }
+    // Check for textures
+    if (await hasTexturesDirWithFiles(root)) {
+        throw new Error(`Project at '${root}' uses textures (in 'textures/' folder) but has no 'config.json'. Add a config file to define texture bindings.`);
+    }
+    // Load shader source
+    const imageSource = await fs.readFile(imagePath, 'utf8');
+    const title = path.basename(root);
+    const project = {
+        root,
+        meta: {
+            title,
+            author: null,
+            description: null,
+        },
+        layout: 'default',
+        controls: false,
+        commonSource: null,
+        passes: {
+            Image: {
+                name: 'Image',
+                glslSource: imageSource,
+                channels: [
+                    { kind: 'none' },
+                    { kind: 'none' },
+                    { kind: 'none' },
+                    { kind: 'none' },
+                ],
+            },
+        },
+        textures: [],
+    };
+    return project;
+}
+// =============================================================================
+// Multi-Pass Mode (With Config)
+// =============================================================================
+/**
+ * Parse a channel value (string shorthand or object) into normalized ChannelJSONObject.
+ *
+ * String shortcuts:
+ * - "BufferA", "BufferB", etc. → buffer reference
+ * - "keyboard" → keyboard input
+ * - "photo.jpg" (with extension) → texture file
+ */
+function parseChannelValue(value) {
+    if (typeof value === 'string') {
+        // Check for buffer names
+        if (isPassName(value)) {
+            return { buffer: value };
+        }
+        // Check for keyboard
+        if (value === 'keyboard') {
+            return { keyboard: true };
+        }
+        // Assume texture (file path)
+        return { texture: value };
+    }
+    // Already an object
+    return value;
+}
+/**
+ * Load a project with config.json.
+ *
+ * @param root - Project directory
+ * @param config - Parsed JSON config
+ * @returns Normalized ShadertoyProject
+ */
+async function loadProjectWithConfig(root, config) {
+    // Extract pass configs from top level
+    const passConfigs = {
+        Image: config.Image,
+        BufferA: config.BufferA,
+        BufferB: config.BufferB,
+        BufferC: config.BufferC,
+        BufferD: config.BufferD,
+    };
+    // Validate: must have Image pass (or be empty config for simple shader)
+    const hasAnyPass = passConfigs.Image || passConfigs.BufferA || passConfigs.BufferB ||
+        passConfigs.BufferC || passConfigs.BufferD;
+    if (!hasAnyPass) {
+        // Empty config = simple Image pass with no channels
+        passConfigs.Image = {};
+    }
+    // Resolve commonSource
+    let commonSource = null;
+    if (config.common) {
+        const commonPath = path.join(root, config.common);
+        if (!(await fileExists(commonPath))) {
+            throw new Error(`Common GLSL file '${config.common}' not found in '${root}'.`);
+        }
+        commonSource = await fs.readFile(commonPath, 'utf8');
+    }
+    else {
+        // Check for default common.glsl
+        const defaultCommonPath = path.join(root, 'common.glsl');
+        if (await fileExists(defaultCommonPath)) {
+            commonSource = await fs.readFile(defaultCommonPath, 'utf8');
+        }
+    }
+    // Texture deduplication map
+    const textureMap = new Map();
+    /**
+     * Register a texture and return its internal name.
+     */
+    function registerTexture(j) {
+        const filter = j.filter ?? 'linear';
+        const wrap = j.wrap ?? 'repeat';
+        const key = `${j.texture}|${filter}|${wrap}`;
+        let existing = textureMap.get(key);
+        if (existing) {
+            return existing.name;
+        }
+        const name = `tex${textureMap.size}`;
+        const tex = {
+            name,
+            source: j.texture,
+            filter,
+            wrap,
+        };
+        textureMap.set(key, tex);
+        return name;
+    }
+    /**
+     * Parse a channel object into ChannelSource.
+     */
+    function parseChannelObject(value, passName, channelKey) {
+        // Buffer channel
+        if ('buffer' in value) {
+            const buf = value.buffer;
+            if (!isPassName(buf)) {
+                throw new Error(`Invalid buffer name '${buf}' for ${channelKey} in pass '${passName}' at '${root}'.`);
+            }
+            return {
+                kind: 'buffer',
+                buffer: buf,
+                current: !!value.current,
+            };
+        }
+        // Texture channel
+        if ('texture' in value) {
+            const internalName = registerTexture(value);
+            return {
+                kind: 'texture',
+                name: internalName,
+                cubemap: value.type === 'cubemap',
+            };
+        }
+        // Keyboard channel
+        if ('keyboard' in value) {
+            return { kind: 'keyboard' };
+        }
+        throw new Error(`Invalid channel object for ${channelKey} in pass '${passName}' at '${root}'.`);
+    }
+    /**
+     * Load a single pass from simplified config.
+     */
+    async function loadPass(name, passConfig) {
+        if (!passConfig)
+            return undefined;
+        const sourceRel = passConfig.source ?? defaultSourceForPass(name);
+        const sourcePath = path.join(root, sourceRel);
+        if (!(await fileExists(sourcePath))) {
+            throw new Error(`Source GLSL file for pass '${name}' not found at '${sourceRel}' in '${root}'.`);
+        }
+        const glslSource = await fs.readFile(sourcePath, 'utf8');
+        // Normalize channels (always 4 channels)
+        const channelSources = [];
+        const channelKeys = ['iChannel0', 'iChannel1', 'iChannel2', 'iChannel3'];
+        for (const key of channelKeys) {
+            const rawValue = passConfig[key];
+            if (!rawValue) {
+                channelSources.push({ kind: 'none' });
+                continue;
+            }
+            // Parse string shorthand or use object directly
+            const parsed = parseChannelValue(rawValue);
+            if (!parsed) {
+                channelSources.push({ kind: 'none' });
+                continue;
+            }
+            channelSources.push(parseChannelObject(parsed, name, key));
+        }
+        return {
+            name,
+            glslSource,
+            channels: channelSources,
+        };
+    }
+    // Load all passes
+    const imagePass = await loadPass('Image', passConfigs.Image);
+    const bufferAPass = await loadPass('BufferA', passConfigs.BufferA);
+    const bufferBPass = await loadPass('BufferB', passConfigs.BufferB);
+    const bufferCPass = await loadPass('BufferC', passConfigs.BufferC);
+    const bufferDPass = await loadPass('BufferD', passConfigs.BufferD);
+    // If no Image pass was loaded but we have buffers, that's an error
+    if (!imagePass && (bufferAPass || bufferBPass || bufferCPass || bufferDPass)) {
+        throw new Error(`config.json at '${root}' has buffers but no Image pass.`);
+    }
+    // If still no Image pass, create empty one
+    if (!imagePass) {
+        throw new Error(`config.json at '${root}' must define an Image pass.`);
+    }
+    // Build metadata
+    const title = config.title ?? path.basename(root);
+    const author = config.author ?? null;
+    const description = config.description ?? null;
+    const project = {
+        root,
+        meta: { title, author, description },
+        layout: config.layout ?? 'default',
+        controls: config.controls ?? false,
+        commonSource,
+        passes: {
+            Image: imagePass,
+            BufferA: bufferAPass,
+            BufferB: bufferBPass,
+            BufferC: bufferCPass,
+            BufferD: bufferDPass,
+        },
+        textures: Array.from(textureMap.values()),
+    };
+    return project;
+}

package/dist-lib/project/loaderHelper.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Helper functions for loading demo files
+ * Called by the generated loader
+ */
+import { ShadertoyProject, ShadertoyConfig } from './types';
+export declare function loadDemo(demoName: string, glslFiles: Record<string, () => Promise<string>>, jsonFiles: Record<string, () => Promise<ShadertoyConfig>>, imageFiles: Record<string, () => Promise<string>>): Promise<ShadertoyProject>;
+//# sourceMappingURL=loaderHelper.d.ts.map

package/dist-lib/project/loaderHelper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loaderHelper.d.ts","sourceRoot":"","sources":["../../src/project/loaderHelper.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,gBAAgB,EAChB,eAAe,EAIhB,MAAM,SAAS,CAAC;AA8CjB,wBAAsB,QAAQ,CAC5B,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC,EAChD,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,OAAO,CAAC,eAAe,CAAC,CAAC,EACzD,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC,GAChD,OAAO,CAAC,gBAAgB,CAAC,CAkB3B"}

package/dist-lib/project/loaderHelper.js

@@ -0,0 +1,240 @@
+/**
+ * Helper functions for loading demo files
+ * Called by the generated loader
+ */
+/**
+ * Case-insensitive file lookup helper.
+ * Returns the actual key from the record that matches the path (case-insensitive).
+ */
+function findFileCaseInsensitive(files, path) {
+    // First try exact match
+    if (path in files)
+        return path;
+    // Try case-insensitive match
+    const lowerPath = path.toLowerCase();
+    for (const key of Object.keys(files)) {
+        if (key.toLowerCase() === lowerPath) {
+            return key;
+        }
+    }
+    return null;
+}
+/**
+ * Type guard for PassName.
+ */
+function isPassName(s) {
+    return s === 'Image' || s === 'BufferA' || s === 'BufferB' || s === 'BufferC' || s === 'BufferD';
+}
+/**
+ * Parse a channel value (string shorthand or object) into normalized ChannelJSONObject.
+ */
+function parseChannelValue(value) {
+    if (typeof value === 'string') {
+        if (isPassName(value)) {
+            return { buffer: value };
+        }
+        if (value === 'keyboard') {
+            return { keyboard: true };
+        }
+        return { texture: value };
+    }
+    return value;
+}
+export async function loadDemo(demoName, glslFiles, jsonFiles, imageFiles) {
+    const configPath = `/demos/${demoName}/config.json`;
+    const hasConfig = configPath in jsonFiles;
+    if (hasConfig) {
+        const config = await jsonFiles[configPath]();
+        const hasPassConfigs = config.Image || config.BufferA || config.BufferB ||
+            config.BufferC || config.BufferD;
+        if (hasPassConfigs) {
+            return loadWithConfig(demoName, config, glslFiles, imageFiles);
+        }
+        else {
+            // Config with only settings (layout, controls, etc.) but no passes
+            return loadSinglePass(demoName, glslFiles, config);
+        }
+    }
+    else {
+        return loadSinglePass(demoName, glslFiles);
+    }
+}
+async function loadSinglePass(demoName, glslFiles, configOverrides) {
+    const imagePath = `/demos/${demoName}/image.glsl`;
+    const actualImagePath = findFileCaseInsensitive(glslFiles, imagePath);
+    if (!actualImagePath) {
+        throw new Error(`Demo '${demoName}' not found. Expected ${imagePath}`);
+    }
+    const imageSource = await glslFiles[actualImagePath]();
+    const layout = configOverrides?.layout || 'tabbed';
+    const controls = configOverrides?.controls ?? true;
+    const title = configOverrides?.title ||
+        demoName.split('-').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ');
+    return {
+        root: `/demos/${demoName}`,
+        meta: {
+            title,
+            author: configOverrides?.author || null,
+            description: configOverrides?.description || null,
+        },
+        layout,
+        controls,
+        commonSource: null,
+        passes: {
+            Image: {
+                name: 'Image',
+                glslSource: imageSource,
+                channels: [
+                    { kind: 'none' },
+                    { kind: 'none' },
+                    { kind: 'none' },
+                    { kind: 'none' },
+                ],
+            },
+        },
+        textures: [],
+    };
+}
+async function loadWithConfig(demoName, config, glslFiles, imageFiles) {
+    // Extract pass configs from top level
+    const passConfigs = {
+        Image: config.Image,
+        BufferA: config.BufferA,
+        BufferB: config.BufferB,
+        BufferC: config.BufferC,
+        BufferD: config.BufferD,
+    };
+    // Load common source
+    let commonSource = null;
+    if (config.common) {
+        const commonPath = `/demos/${demoName}/${config.common}`;
+        const actualCommonPath = findFileCaseInsensitive(glslFiles, commonPath);
+        if (actualCommonPath) {
+            commonSource = await glslFiles[actualCommonPath]();
+        }
+    }
+    else {
+        const defaultCommonPath = `/demos/${demoName}/common.glsl`;
+        const actualCommonPath = findFileCaseInsensitive(glslFiles, defaultCommonPath);
+        if (actualCommonPath) {
+            commonSource = await glslFiles[actualCommonPath]();
+        }
+    }
+    // Collect all texture paths
+    const texturePathsSet = new Set();
+    const passOrder = ['Image', 'BufferA', 'BufferB', 'BufferC', 'BufferD'];
+    for (const passName of passOrder) {
+        const passConfig = passConfigs[passName];
+        if (!passConfig)
+            continue;
+        for (const channelKey of ['iChannel0', 'iChannel1', 'iChannel2', 'iChannel3']) {
+            const channelValue = passConfig[channelKey];
+            if (!channelValue)
+                continue;
+            const parsed = parseChannelValue(channelValue);
+            if (parsed && 'texture' in parsed) {
+                texturePathsSet.add(parsed.texture);
+            }
+        }
+    }
+    // Load textures
+    const textures = [];
+    const texturePathToName = new Map();
+    for (const texturePath of texturePathsSet) {
+        const fullPath = `/demos/${demoName}/${texturePath.replace(/^\.\//, '')}`;
+        const actualPath = findFileCaseInsensitive(imageFiles, fullPath);
+        if (!actualPath) {
+            throw new Error(`Texture not found: ${texturePath} (expected at ${fullPath})`);
+        }
+        const imageUrl = await imageFiles[actualPath]();
+        const textureFilename = texturePath.split('/').pop();
+        const textureName = textureFilename.replace(/\.[^.]+$/, '');
+        textures.push({
+            name: textureName,
+            filename: textureFilename, // Preserve original filename for display
+            source: imageUrl,
+            filter: 'linear',
+            wrap: 'repeat',
+        });
+        texturePathToName.set(texturePath, textureName);
+    }
+    // Build passes
+    const passes = {};
+    for (const passName of passOrder) {
+        const passConfig = passConfigs[passName];
+        if (!passConfig)
+            continue;
+        const defaultNames = {
+            Image: 'image.glsl',
+            BufferA: 'bufferA.glsl',
+            BufferB: 'bufferB.glsl',
+            BufferC: 'bufferC.glsl',
+            BufferD: 'bufferD.glsl',
+        };
+        const sourceFile = passConfig.source || defaultNames[passName];
+        const sourcePath = `/demos/${demoName}/${sourceFile}`;
+        const actualSourcePath = findFileCaseInsensitive(glslFiles, sourcePath);
+        if (!actualSourcePath) {
+            throw new Error(`Missing shader file: ${sourcePath}`);
+        }
+        const glslSource = await glslFiles[actualSourcePath]();
+        const channels = [
+            normalizeChannel(passConfig.iChannel0, texturePathToName),
+            normalizeChannel(passConfig.iChannel1, texturePathToName),
+            normalizeChannel(passConfig.iChannel2, texturePathToName),
+            normalizeChannel(passConfig.iChannel3, texturePathToName),
+        ];
+        passes[passName] = {
+            name: passName,
+            glslSource,
+            channels,
+        };
+    }
+    if (!passes.Image) {
+        throw new Error(`Demo '${demoName}' must have an Image pass`);
+    }
+    const title = config.title ||
+        demoName.split('-').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ');
+    const author = config.author || null;
+    const description = config.description || null;
+    const layout = config.layout || 'tabbed';
+    const controls = config.controls ?? true;
+    return {
+        root: `/demos/${demoName}`,
+        meta: { title, author, description },
+        layout,
+        controls,
+        commonSource,
+        passes,
+        textures,
+    };
+}
+function normalizeChannel(channelValue, texturePathToName) {
+    if (!channelValue) {
+        return { kind: 'none' };
+    }
+    // Parse string shorthand
+    const parsed = parseChannelValue(channelValue);
+    if (!parsed) {
+        return { kind: 'none' };
+    }
+    if ('buffer' in parsed) {
+        return {
+            kind: 'buffer',
+            buffer: parsed.buffer,
+            current: !!parsed.current,
+        };
+    }
+    if ('texture' in parsed) {
+        const textureName = texturePathToName?.get(parsed.texture) || parsed.texture;
+        return {
+            kind: 'texture',
+            name: textureName,
+            cubemap: parsed.type === 'cubemap',
+        };
+    }
+    if ('keyboard' in parsed) {
+        return { kind: 'keyboard' };
+    }
+    return { kind: 'none' };
+}