@directivegames/genesys.sdk 3.2.2

package/dist/src/templates/scripts/genesys/calc-bounding-box.js

@@ -0,0 +1,205 @@
+import fs, { readFileSync } from 'fs';
+import path, { resolve } from 'path';
+import * as ENGINE from 'genesys.js';
+import * as THREE from 'three';
+import { MeshoptDecoder } from 'three/examples/jsm/libs/meshopt_decoder.module.js';
+import { DRACOLoader } from 'three/examples/jsm/loaders/DRACOLoader.js';
+import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
+import { mockBrowserEnvironment } from './mock.js';
+mockBrowserEnvironment();
+// Custom error types for better error handling
+class GLBLoadError extends Error {
+    filePath;
+    constructor(message, filePath) {
+        super(message);
+        this.filePath = filePath;
+        this.name = 'GLBLoadError';
+    }
+}
+class BoundingBoxCalculationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'BoundingBoxCalculationError';
+    }
+}
+function verifyPath(path) {
+    if (path.startsWith(ENGINE.PROJECT_PATH_PREFIX) || path.startsWith(ENGINE.ENGINE_PATH_PREFIX)) {
+        throw new Error(`Expecting a valid path, not a project or engine path: ${path}`);
+    }
+}
+/**
+ * Helper function to load and parse a GLB file
+ * @param glbFilePath - Path to the GLB file
+ * @returns Promise resolving to the loaded GLTF scene
+ */
+async function loadGLBFile(glbFilePath) {
+    verifyPath(glbFilePath);
+    // Resolve the absolute path
+    const absolutePath = resolve(glbFilePath);
+    try {
+        // Read the GLB file
+        const glbData = readFileSync(absolutePath);
+        const arrayBuffer = glbData.buffer.slice(glbData.byteOffset, glbData.byteOffset + glbData.byteLength);
+        // Load the GLB using GLTFLoader
+        const loader = new GLTFLoader();
+        loader.setMeshoptDecoder(MeshoptDecoder);
+        const dracoLoader = new DRACOLoader();
+        dracoLoader.setDecoderPath('https://www.gstatic.com/draco/versioned/decoders/1.5.6/');
+        loader.setDRACOLoader(dracoLoader);
+        const gltf = await loader.parseAsync(arrayBuffer, '');
+        if (!gltf.scene) {
+            throw new BoundingBoxCalculationError('No scene found in GLB file');
+        }
+        return gltf;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            if (error.name === 'GLBLoadError' || error.name === 'BoundingBoxCalculationError') {
+                throw error;
+            }
+            throw new GLBLoadError(`Failed to load GLB file: ${error.message}`, glbFilePath);
+        }
+        throw new GLBLoadError('Unknown error loading GLB file', glbFilePath);
+    }
+}
+/**
+ * Helper function to extract bounding box data from a Three.js Box3
+ * @param boundingBox - Three.js Box3 object
+ * @returns BoundingBox interface object
+ */
+function extractBoundingBoxData(boundingBox) {
+    return ENGINE.DescriptionHelper.dumpBoundingBox(boundingBox);
+}
+/**
+ * Calculates the bounding box of a GLB mesh with applied transformations
+ * @param glbFilePath - Path to the GLB file
+ * @param transform - Transformation to apply (position, rotation, scale)
+ * @returns Promise resolving to the calculated bounding box
+ */
+async function calculateGLBBoundingBox(glbFilePath, transform) {
+    const gltf = await loadGLBFile(glbFilePath);
+    // Create a new object to apply transformations
+    const transformedObject = new THREE.Object3D();
+    transformedObject.add(gltf.scene);
+    // Apply transformations
+    transform.position && transformedObject.position.set(...transform.position);
+    transform.rotation && transformedObject.rotation.set(...transform.rotation);
+    transform.scale && transformedObject.scale.set(...transform.scale);
+    // Update world matrix to ensure transformations are applied
+    transformedObject.updateMatrixWorld(true);
+    const boundingBox = ENGINE.GLTFMeshComponent.calcBoundingBoxFromGLTF(gltf);
+    return extractBoundingBoxData(boundingBox);
+}
+/**
+ * Calculates the original bounding box of a GLB mesh without any transformations
+ * @param glbFilePath - Path to the GLB file
+ * @returns Promise resolving to the original mesh bounding box
+ */
+async function calculateGLBOriginalBoundingBox(glbFilePath) {
+    const gltf = await loadGLBFile(glbFilePath);
+    const boundingBox = ENGINE.GLTFMeshComponent.calcBoundingBoxFromGLTF(gltf);
+    return extractBoundingBoxData(boundingBox);
+}
+/**
+ * Helper function to create a default transform
+ */
+function createTransform(position = [0, 0, 0], rotation = [0, 0, 0], scale = [1, 1, 1]) {
+    return { position, rotation, scale };
+}
+/**
+ * Utility function to convert degrees to radians
+ */
+function degreesToRadians(degrees) {
+    return degrees * (Math.PI / 180);
+}
+/**
+ * Fetches the bounding box data from the manifest file, and returns the bounding box data
+ * It internally keeps a bounding box manifest as a cache, and only recalculates the bounding box data if the file has been modified since last calculation
+ * @param manifestFile - Path to the manifest JSON file, must be a valid path, not `@project` or `@engine` path
+ * @param gltfPaths - Dictionary of gltf key to GLTF file paths, key in theory can be any ID of a gltf mesh.
+ */
+async function fetchBoundingBoxData(manifestFile, gltfPaths) {
+    verifyPath(manifestFile);
+    manifestFile = resolve(manifestFile);
+    try {
+        // Read existing manifest or create empty one
+        let manifest = {};
+        try {
+            if (fs.existsSync(manifestFile)) {
+                const manifestContent = fs.readFileSync(manifestFile, 'utf-8');
+                manifest = JSON.parse(manifestContent);
+                console.log(`Loaded existing manifest with ${Object.keys(manifest).length} entries`);
+            }
+            else {
+                console.log('Creating new manifest file');
+            }
+        }
+        catch (error) {
+            console.warn(`Failed to read existing manifest, starting fresh: ${error instanceof Error ? error.message : String(error)}`);
+            manifest = {};
+        }
+        // Process each GLTF file
+        const updatedManifest = { ...manifest };
+        let processedCount = 0;
+        let skippedCount = 0;
+        for (const [key, gltfPath] of Object.entries(gltfPaths)) {
+            try {
+                // Resolve absolute path for consistent comparison
+                const absolutePath = resolve(gltfPath);
+                // Check if file exists
+                if (!fs.existsSync(absolutePath)) {
+                    console.warn(`Warning: File not found: ${gltfPath}`);
+                    continue;
+                }
+                // Get file stats to check modification time
+                const stats = fs.statSync(absolutePath);
+                const currentTimestamp = stats.mtime.toISOString();
+                // Check if we need to update this file
+                const existingEntry = manifest[key];
+                if (existingEntry && existingEntry.timestamp === currentTimestamp) {
+                    console.log(`Skipping ${gltfPath} (unchanged)`);
+                    skippedCount++;
+                    continue;
+                }
+                // Calculate bounding box for new/modified file
+                console.log(`Processing ${gltfPath}...`);
+                const boundingBox = await calculateGLBOriginalBoundingBox(absolutePath);
+                // Update manifest entry
+                updatedManifest[key] = {
+                    bounding_box: boundingBox,
+                    timestamp: currentTimestamp
+                };
+                processedCount++;
+                console.log(`✓ Updated bounding box for ${gltfPath}`);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                console.error(`Failed to process ${gltfPath}: ${errorMessage}`);
+                // Continue processing other files even if one fails
+            }
+        }
+        // Save updated manifest if any changes were made
+        if (processedCount > 0) {
+            // Ensure directory exists
+            const manifestDir = path.dirname(manifestFile);
+            if (!fs.existsSync(manifestDir)) {
+                fs.mkdirSync(manifestDir, { recursive: true });
+            }
+            // Write manifest with pretty formatting
+            fs.writeFileSync(manifestFile, JSON.stringify(updatedManifest, null, 2), 'utf-8');
+            console.log(`\n✓ Manifest updated: ${processedCount} files processed, ${skippedCount} files skipped`);
+            console.log(`Manifest saved to: ${manifestFile}`);
+        }
+        else {
+            console.log(`\n✓ No updates needed: ${skippedCount} files already up to date`);
+        }
+        return Object.fromEntries(Object.entries(gltfPaths).map(([key, absPath]) => [key, updatedManifest[key].bounding_box]));
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to update bounding box manifest: ${errorMessage}`);
+    }
+}
+// Export the main functions for use as a module
+export { calculateGLBBoundingBox, calculateGLBOriginalBoundingBox, createTransform, degreesToRadians, fetchBoundingBoxData, extractBoundingBoxData, GLBLoadError, BoundingBoxCalculationError };
+export { BoundingBoxSchema } from 'genesys.js';

package/dist/src/templates/scripts/genesys/common.js

@@ -0,0 +1,36 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { z } from 'zod';
+export const isDev = process.env.NODE_ENV === 'development' ||
+    process.env.NODE_ENV === 'dev' ||
+    process.argv.includes('--dev');
+export function mockEsModule() {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    global.__filename = __filename;
+    global.__dirname = __dirname;
+}
+mockEsModule();
+export function getProjectRoot() {
+    let currentDir = __dirname;
+    while (true) {
+        if (fs.existsSync(path.join(currentDir, 'package.json'))) {
+            return currentDir;
+        }
+        const parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir) {
+            throw new Error('Project root not found');
+        }
+        currentDir = parentDir;
+    }
+}
+export const TransformSchema = z.object({
+    position: z.array(z.number()).length(3).optional().describe('Position as [x, y, z]'),
+    rotation: z.array(z.number()).length(3).optional().describe('Rotation in radians as [x, y, z]'),
+    scale: z.array(z.number()).length(3).optional().describe('Scale as [x, y, z], use this to scale the actor up or down'),
+});
+export const ActorInfoSchema = z.object({
+    displayName: z.string().describe('Display name of the actor'),
+    description: z.string().optional().describe('Description of the actor, including its purpose, how to use it, etc.'),
+});

package/dist/src/templates/scripts/genesys/const.js

@@ -0,0 +1,9 @@
+// MUST be kept in sync with https://github.com/directivegames/genesys.ai/blob/develop/src/const.ts
+export const SCENE_EXTENSION = '.genesys-scene';
+export const PUBLIC_FOLDER = 'public';
+export const PROJECT_PREFIX = '@project';
+export const ENGINE_PREFIX = '@engine';
+export const DEFAULT_GAME_NAME = 'game.ts';
+export const DEFAULT_GAME_BUNDLE_NAME = 'game.js';
+export const BUILT_PROJECT_FOLDER = '.dist';
+export const JS_CLASSES_DIR_NAME = '@js-classes';

package/dist/src/templates/scripts/genesys/dev/dump-default-scene.js

@@ -0,0 +1,8 @@
+import * as ENGINE from 'genesys.js';
+import { defaultWorldOptions } from '../mcp/utils.js';
+function main() {
+    const world = new ENGINE.World(defaultWorldOptions);
+    ENGINE.GameBuilder.createDefaultEditorScene(world);
+    console.log(JSON.stringify(world.asExportedObject(), null, 2));
+}
+main();

package/dist/src/templates/scripts/genesys/dev/generate-manifest.js

@@ -0,0 +1,116 @@
+// pnpm exec tsx ./scripts/genesys/dev/generate-manifest.ts
+import * as fs from 'fs';
+import * as path from 'path';
+import * as ENGINE from 'genesys.js';
+import { ManifestPath } from './storage-provider.js';
+/**
+ * Recursively scans a directory and returns file information
+ */
+function scanDirectory(dirPath, basePath = '') {
+    const items = [];
+    if (!fs.existsSync(dirPath)) {
+        return items;
+    }
+    try {
+        const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dirPath, entry.name);
+            const relativePath = basePath ? path.join(basePath, entry.name) : entry.name;
+            const stats = fs.statSync(fullPath);
+            const item = {
+                name: entry.name,
+                path: relativePath.replace(/\\/g, '/'), // Normalize to forward slashes
+                size: stats.size,
+                modifiedTime: stats.mtime,
+                isDirectory: entry.isDirectory(),
+                contentType: getContentType(entry.name)
+            };
+            items.push(item);
+            // Recursively scan subdirectories
+            if (entry.isDirectory()) {
+                const subItems = scanDirectory(fullPath, relativePath);
+                items.push(...subItems);
+            }
+        }
+    }
+    catch (error) {
+        console.warn(`Failed to scan directory ${dirPath}:`, error);
+    }
+    return items;
+}
+/**
+ * Gets content type based on file extension
+ */
+function getContentType(fileName) {
+    const ext = path.extname(fileName).toLowerCase();
+    const contentTypes = {
+        '.json': 'application/json',
+        '.js': 'application/javascript',
+        '.ts': 'application/typescript',
+        '.html': 'text/html',
+        '.css': 'text/css',
+        '.png': 'image/png',
+        '.jpg': 'image/jpeg',
+        '.jpeg': 'image/jpeg',
+        '.gif': 'image/gif',
+        '.webp': 'image/webp',
+        '.svg': 'image/svg+xml',
+        '.glb': 'model/gltf-binary',
+        '.gltf': 'model/gltf+json',
+        '.wav': 'audio/wav',
+        '.mp3': 'audio/mpeg',
+        '.ogg': 'audio/ogg',
+        '.genesys-scene': 'application/json',
+        '.genesys-project': 'application/json'
+    };
+    return contentTypes[ext];
+}
+/**
+ * Groups files by directory path for efficient lookup
+ */
+function groupFilesByDirectory(files) {
+    const grouped = {};
+    // Add root directory
+    grouped[''] = [];
+    for (const file of files) {
+        const dir = path.dirname(file.path).replace(/\\/g, '/');
+        const normalizedDir = dir === '.' ? '' : dir;
+        if (!grouped[normalizedDir]) {
+            grouped[normalizedDir] = [];
+        }
+        grouped[normalizedDir].push(file);
+    }
+    return grouped;
+}
+/**
+ * Generates the file manifest
+ */
+export async function generateManifest() {
+    console.log('Generating file manifest...');
+    const manifest = {
+        generated: new Date().toISOString(),
+        projectFiles: {},
+        engineFiles: {}
+    };
+    // Scan project files
+    console.log('Scanning project files...');
+    const projectRoot = process.cwd();
+    const builtProjectRoot = path.join(projectRoot, ENGINE.BUILT_PROJECT_FOLDER);
+    const projectFiles = scanDirectory(builtProjectRoot);
+    manifest.projectFiles = groupFilesByDirectory(projectFiles);
+    // Scan engine files
+    console.log('Scanning engine files...');
+    const engineAssetsRoot = path.join(projectRoot, 'node_modules', 'genesys.js', 'assets');
+    if (fs.existsSync(engineAssetsRoot)) {
+        const engineFiles = scanDirectory(engineAssetsRoot, 'assets');
+        manifest.engineFiles = groupFilesByDirectory(engineFiles);
+        console.log(`Engine files: ${Object.values(manifest.engineFiles).flat().length}`);
+    }
+    // Write manifest to public directory so it's accessible to the dev server
+    const manifestPath = path.join(projectRoot, ManifestPath);
+    fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+    console.log(`File manifest generated: ${manifestPath}`);
+    console.log(`Project files: ${Object.values(manifest.projectFiles).flat().length}`);
+    console.log(`Engine files: ${Object.values(manifest.engineFiles).flat().length}`);
+}
+generateManifest().catch(console.error);

package/dist/src/templates/scripts/genesys/dev/launcher.js

@@ -0,0 +1,39 @@
+import * as ENGINE from 'genesys.js';
+import { DevStorageProvider } from './storage-provider.js';
+// Ensure process is available globally with minimal implementation
+if (typeof globalThis.process === 'undefined') {
+    globalThis.process = {
+        cwd: () => '/',
+        env: {},
+    };
+}
+// Initialize the game - can be called manually
+export async function launchGame() {
+    const container = document.getElementById('game-container');
+    if (!container) {
+        console.error('Game container not found!');
+        return;
+    }
+    try {
+        // Create the storage provider for Vite dev environment
+        const storageProvider = new DevStorageProvider();
+        ENGINE.projectContext({
+            project: 'dev-game',
+            storageProvider,
+        });
+        // Create the game runtime
+        const gameRuntime = new ENGINE.GameRuntime({
+            provider: storageProvider,
+            container: container,
+            gameId: 'dev-game',
+            buildProject: false,
+            skipClearGameClasses: false
+        });
+        console.log('Starting game runtime...');
+        // Start the game with the default scene
+        await gameRuntime.startGame();
+    }
+    catch (error) {
+        console.error('Failed to initialize game:', error);
+    }
+}

package/dist/src/templates/scripts/genesys/dev/storage-provider.js

@@ -0,0 +1,188 @@
+import * as ENGINE from 'genesys.js';
+export const ManifestPath = 'dist/file-manifest.json';
+export class DevStorageProvider {
+    manifestCache = null;
+    manifestPromise = null;
+    async loadManifest() {
+        if (this.manifestCache) {
+            return this.manifestCache;
+        }
+        if (this.manifestPromise) {
+            return this.manifestPromise;
+        }
+        this.manifestPromise = this.fetchManifest();
+        this.manifestCache = await this.manifestPromise;
+        this.manifestPromise = null;
+        return this.manifestCache;
+    }
+    async fetchManifest() {
+        try {
+            const response = await fetch(`/${ManifestPath}`);
+            if (!response.ok) {
+                throw new Error(`Failed to load manifest: ${response.status} ${response.statusText}`);
+            }
+            return await response.json();
+        }
+        catch (error) {
+            console.warn('Failed to load file manifest, falling back to empty manifest:', error);
+            return {
+                generated: new Date().toISOString(),
+                projectFiles: {},
+                engineFiles: {}
+            };
+        }
+    }
+    async resolvePath(path, expiry) {
+        if (path.isResolved()) {
+            return path;
+        }
+        let resolvedUrl;
+        if (path.initialPath.startsWith(ENGINE.PROJECT_PATH_PREFIX)) {
+            resolvedUrl = path.initialPath.replace(ENGINE.PROJECT_PATH_PREFIX, ENGINE.BUILT_PROJECT_FOLDER);
+        }
+        else if (path.initialPath.startsWith(ENGINE.ENGINE_PATH_PREFIX)) {
+            resolvedUrl = path.initialPath.replace(ENGINE.ENGINE_PATH_PREFIX, '/node_modules/genesys.js');
+        }
+        else if (path.initialPath.startsWith('/')) {
+            resolvedUrl = `/node_modules/genesys.js${path.initialPath}`;
+        }
+        else if (path.initialPath.startsWith('http') || path.initialPath.startsWith('https')) {
+            resolvedUrl = path.initialPath;
+        }
+        else {
+            // Paths without prefix are treated as engine paths
+            resolvedUrl = `/node_modules/genesys.js/${path.initialPath}`;
+        }
+        path.resolvePath(resolvedUrl, ENGINE.AssetPathEncodeState.Unknown);
+        return path;
+    }
+    async downloadFileAsBuffer(path) {
+        const resolvedPath = await this.resolvePath(path);
+        const response = await fetch(resolvedPath.getResolvedPath());
+        this.checkResponse(path, response);
+        return response.arrayBuffer();
+    }
+    async downloadFileAsJson(path) {
+        const resolvedPath = await this.resolvePath(path);
+        const response = await fetch(resolvedPath.getResolvedPath());
+        this.checkResponse(path, response);
+        return response.json();
+    }
+    async downloadFileAsText(path) {
+        const resolvedPath = await this.resolvePath(path);
+        const response = await fetch(resolvedPath.getResolvedPath());
+        this.checkResponse(path, response);
+        return response.text();
+    }
+    async uploadFile(path, content, options) {
+        throw new Error('ViteDevStorageProvider does not support uploading files.');
+    }
+    async listFiles(path, recursive, includeHiddenFiles) {
+        try {
+            const manifest = await this.loadManifest();
+            const initialPath = path.initialPath;
+            const targetPath = this.normalizePathForManifest(initialPath);
+            // Determine which file collection to use
+            // Paths without prefix are treated as engine assets
+            const isEngineAsset = initialPath.startsWith(ENGINE.ENGINE_PATH_PREFIX);
+            const isProjectAsset = initialPath.startsWith(ENGINE.PROJECT_PATH_PREFIX);
+            if (!isEngineAsset && !isProjectAsset) {
+                throw new Error(`Invalid path: ${path}`);
+            }
+            const fileCollection = isEngineAsset ? manifest.engineFiles : manifest.projectFiles;
+            const files = [];
+            const directories = [];
+            if (recursive) {
+                // For recursive listing, include all files that start with the target path
+                for (const [dirPath, items] of Object.entries(fileCollection)) {
+                    if (dirPath === targetPath || dirPath.startsWith(targetPath + '/') || (targetPath === '' && !dirPath.includes('/'))) {
+                        for (const item of items) {
+                            const engineFileItem = this.convertToEngineFileItem(item, isEngineAsset);
+                            if (!includeHiddenFiles && item.name.startsWith('.')) {
+                                continue;
+                            }
+                            if (item.isDirectory) {
+                                directories.push(engineFileItem);
+                            }
+                            else {
+                                files.push(engineFileItem);
+                            }
+                        }
+                    }
+                }
+            }
+            else {
+                // For non-recursive listing, only include direct children
+                const directItems = fileCollection[targetPath] || [];
+                for (const item of directItems) {
+                    const engineFileItem = this.convertToEngineFileItem(item, isEngineAsset);
+                    if (!includeHiddenFiles && item.name.startsWith('.')) {
+                        continue;
+                    }
+                    // Only include direct children (not nested)
+                    const itemDirPath = item.path.substring(0, item.path.lastIndexOf('/'));
+                    const normalizedItemDirPath = itemDirPath === '.' || itemDirPath === '' ? '' : itemDirPath;
+                    if (normalizedItemDirPath === targetPath) {
+                        if (item.isDirectory) {
+                            directories.push(engineFileItem);
+                        }
+                        else {
+                            files.push(engineFileItem);
+                        }
+                    }
+                }
+            }
+            return { files, directories };
+        }
+        catch (error) {
+            console.warn(`Failed to list files for path ${path.initialPath}:`, error);
+            return { files: [], directories: [] };
+        }
+    }
+    async exists(path) {
+        try {
+            const resolvedPath = await this.resolvePath(path);
+            const response = await fetch(resolvedPath.getResolvedPath(), { method: 'HEAD' });
+            return response.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+    async buildCurrentProject(runTsc) {
+        // For development, we don't need to build the project
+        // Vite handles the compilation
+        return true;
+    }
+    normalizePathForManifest(pathStr) {
+        // Remove @project/ or @engine/ prefix
+        let normalized = pathStr.replace(ENGINE.PROJECT_PATH_PREFIX, '').replace(ENGINE.ENGINE_PATH_PREFIX, '');
+        // Remove leading slash if present
+        if (normalized.startsWith('/')) {
+            normalized = normalized.substring(1);
+        }
+        // Remove trailing slash if present
+        if (normalized.endsWith('/')) {
+            normalized = normalized.substring(0, normalized.length - 1);
+        }
+        return normalized;
+    }
+    convertToEngineFileItem(manifestItem, isEngineAsset) {
+        const prefix = isEngineAsset ? ENGINE.ENGINE_PATH_PREFIX : ENGINE.PROJECT_PATH_PREFIX;
+        const path = `${prefix}/${manifestItem.path}`;
+        return {
+            name: manifestItem.name,
+            path: path,
+            absolutePath: path,
+            size: manifestItem.size,
+            modifiedTime: new Date(manifestItem.modifiedTime),
+            isDirectory: manifestItem.isDirectory,
+            contentType: manifestItem.contentType
+        };
+    }
+    checkResponse(path, response) {
+        if (!response.ok) {
+            throw new Error(`Failed to fetch ${path.initialPath}: ${response.status} ${response.statusText}`);
+        }
+    }
+}

package/dist/src/templates/scripts/genesys/dev/update-template-scenes.js

@@ -0,0 +1,67 @@
+import fs from 'fs';
+import path from 'path';
+import { SCENE_EXTENSION } from '../const.js';
+import { loadWorld } from '../mcp/utils.js';
+import { mockBrowserEnvironment } from '../mock.js';
+// Mock browser environment as required by the engine
+mockBrowserEnvironment();
+async function findGenesysSceneFiles(dir) {
+    const sceneFiles = [];
+    try {
+        const items = fs.readdirSync(dir, { withFileTypes: true });
+        for (const item of items) {
+            const fullPath = path.join(dir, item.name);
+            if (item.isDirectory()) {
+                // Recursively search subdirectories
+                const subFiles = await findGenesysSceneFiles(fullPath);
+                sceneFiles.push(...subFiles);
+            }
+            else if (item.isFile() && item.name.endsWith(SCENE_EXTENSION)) {
+                sceneFiles.push(fullPath);
+            }
+        }
+    }
+    catch (error) {
+        console.error(`Error reading directory ${dir}:`, error);
+    }
+    return sceneFiles;
+}
+async function updateSceneFile(sceneFilePath) {
+    console.log(`Processing: ${sceneFilePath}`);
+    try {
+        // Use the loadWorld utility with proper disposal using 'using' keyword
+        using worldResource = await loadWorld(sceneFilePath, {
+            readonly: false, // Allow saving changes
+            skipLoadingGLTF: true // Skip GLTF loading for faster processing
+        });
+        console.log(`✓ Successfully updated: ${sceneFilePath}`);
+    }
+    catch (error) {
+        console.error(`✗ Failed to update ${sceneFilePath}:`, error);
+    }
+}
+async function main() {
+    console.log('Searching for .genesys-scene files in src folder...');
+    const srcDir = path.join(process.cwd(), 'src');
+    if (!fs.existsSync(srcDir)) {
+        console.error('src directory not found');
+        return;
+    }
+    const sceneFiles = await findGenesysSceneFiles(srcDir);
+    if (sceneFiles.length === 0) {
+        console.log('No .genesys-scene files found in src folder');
+        return;
+    }
+    console.log(`Found ${sceneFiles.length} .genesys-scene files:`);
+    sceneFiles.forEach(file => console.log(`  - ${path.relative(process.cwd(), file)}`));
+    console.log('\nUpdating scene files...');
+    // Process each scene file
+    for (const sceneFile of sceneFiles) {
+        await updateSceneFile(sceneFile);
+    }
+    console.log('\nScene update process completed!');
+}
+main().catch(error => {
+    console.error('Script failed:', error);
+    process.exit(1);
+});