@directivegames/genesys.sdk 3.2.2

package/src/templates/scripts/genesys/build-project.ts

@@ -0,0 +1,51 @@
+import { getProjectRoot, isDev } from './common.js';
+
+const fileServerPort = !isDev ? 4000 : 4001;
+
+async function main() {
+  try {
+    const rootResponse = await fetch(`http://localhost:${fileServerPort}/`);
+
+    if (!rootResponse.ok) {
+      console.log('❌ Failed to talk to the Genesys SDK App, please make sure it is running and open the project in it!');
+      return;
+    }
+
+    const projectPath = getProjectRoot();
+
+    console.log(`🔨 Building project: ${projectPath} ...`);
+
+    const buildResponse = await fetch(`http://localhost:${fileServerPort}/api/build-project`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        projectPath,
+      }),
+    });
+    const responseJson = await buildResponse.json();
+    if (!buildResponse.ok) {
+      console.log('❌ Failed to build project, please check the console for errors!');
+      console.log(responseJson);
+      return;
+    }
+
+    /*
+    success: result.success,
+    message: result.message,
+    error: result.error
+    */
+    if (!responseJson.success) {
+      console.log(`❌ Failed to build project:\n - ${responseJson.error ?? responseJson.message}`);
+      return;
+    }
+
+    console.log(`✅ ${responseJson.message}`);
+
+  } catch (error) {
+    console.log('❌ Failed to talk to the Genesys SDK App, please make sure it is running and open the project in it!');
+  }
+}
+
+main();

package/src/templates/scripts/genesys/calc-bounding-box.ts

@@ -0,0 +1,272 @@
+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';
+
+import type { Transform } from './common.js';
+
+mockBrowserEnvironment();
+
+// Custom error types for better error handling
+class GLBLoadError extends Error {
+  constructor(message: string, public readonly filePath: string) {
+    super(message);
+    this.name = 'GLBLoadError';
+  }
+}
+
+class BoundingBoxCalculationError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'BoundingBoxCalculationError';
+  }
+}
+
+// Interface for manifest entry
+interface ManifestEntry {
+  readonly bounding_box: ENGINE.TBoundingBox;
+  readonly timestamp: string;
+}
+
+// Interface for the entire manifest
+interface BoundingBoxManifest {
+  [filePath: string]: ManifestEntry;
+}
+
+function verifyPath(path: string) {
+  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: string): Promise<any> {
+  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: THREE.Box3): ENGINE.TBoundingBox {
+  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: string,
+  transform: Transform
+): Promise<ENGINE.TBoundingBox> {
+  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 as [number, number, number]);
+  transform.rotation && transformedObject.rotation.set(...transform.rotation as [number, number, number]);
+  transform.scale && transformedObject.scale.set(...transform.scale as [number, number, number]);
+
+  // 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: string): Promise<ENGINE.TBoundingBox> {
+  const gltf = await loadGLBFile(glbFilePath);
+
+  const boundingBox = ENGINE.GLTFMeshComponent.calcBoundingBoxFromGLTF(gltf);
+  return extractBoundingBoxData(boundingBox);
+}
+
+/**
+ * Helper function to create a default transform
+ */
+function createTransform(
+  position: [number, number, number] = [0, 0, 0],
+  rotation: [number, number, number] = [0, 0, 0],
+  scale: [number, number, number] = [1, 1, 1]
+): Transform {
+  return { position, rotation, scale };
+}
+
+/**
+ * Utility function to convert degrees to radians
+ */
+function degreesToRadians(degrees: number): number {
+  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: string, gltfPaths: {[key: string]: string}): Promise<{[filePath: string]: ENGINE.TBoundingBox}> {
+  verifyPath(manifestFile);
+  manifestFile = resolve(manifestFile);
+  try {
+    // Read existing manifest or create empty one
+    let manifest: BoundingBoxManifest = {};
+
+    try {
+      if (fs.existsSync(manifestFile)) {
+        const manifestContent = fs.readFileSync(manifestFile, 'utf-8');
+        manifest = JSON.parse(manifestContent) as BoundingBoxManifest;
+        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: BoundingBoxManifest = { ...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 type { Transform, ManifestEntry, BoundingBoxManifest };
+export { BoundingBoxSchema } from 'genesys.js';
+
+

package/src/templates/scripts/genesys/common.ts

@@ -0,0 +1,46 @@
+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 as any).__filename = __filename;
+  (global as any).__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 type Transform = z.infer<typeof TransformSchema>;
+
+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/src/templates/scripts/genesys/const.ts

@@ -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: string = '.genesys-scene';
+export const PUBLIC_FOLDER: string = 'public';
+export const PROJECT_PREFIX: string = '@project';
+export const ENGINE_PREFIX: string = '@engine';
+export const DEFAULT_GAME_NAME: string = 'game.ts';
+export const DEFAULT_GAME_BUNDLE_NAME: string = 'game.js';
+export const BUILT_PROJECT_FOLDER: string = '.dist';
+export const JS_CLASSES_DIR_NAME: string = '@js-classes';

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

@@ -0,0 +1,11 @@
+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/src/templates/scripts/genesys/dev/generate-manifest.ts

@@ -0,0 +1,146 @@
+// 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';
+
+import type { FileManifest, FileManifestItem} from './storage-provider.js';
+
+/**
+ * Recursively scans a directory and returns file information
+ */
+function scanDirectory(
+  dirPath: string,
+  basePath: string = '',
+): FileManifestItem[] {
+
+  const items: FileManifestItem[] = [];
+
+  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: FileManifestItem = {
+        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: string): string | undefined {
+  const ext = path.extname(fileName).toLowerCase();
+  const contentTypes: Record<string, string> = {
+    '.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: FileManifestItem[]): Record<string, FileManifestItem[]> {
+  const grouped: Record<string, FileManifestItem[]> = {};
+
+  // 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(): Promise<void> {
+  console.log('Generating file manifest...');
+
+  const manifest: FileManifest = {
+    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/src/templates/scripts/genesys/dev/launcher.ts

@@ -0,0 +1,46 @@
+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 as any).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);
+  }
+}