@directivegames/genesys.js 3.1.24

package/dist/src/render/lightmapping/LightmapSerialization.js

@@ -0,0 +1,244 @@
+/**
+ * LightmapSerialization handles the export and import of lightmap data.
+ *
+ * This system enables:
+ * - Exporting baked lightmaps to .lightmap files with separate texture images
+ * - Importing and applying saved lightmaps to scenes
+ * - Mesh-to-atlas mapping for tracking which actors use which parts of the lightmap
+ * - Manual file management for lightmap assets
+ *
+ * File structure:
+ * - scene.lightmap.json (JSON metadata)
+ * - scene.lightmap (high-precision binary lightmap texture)
+ */
+import * as THREE from 'three';
+import { z } from 'zod';
+/**
+ * Schema for validating lightmap file format
+ */
+const lightmapSchema = z.object({
+    version: z.string(),
+    metadata: z.object({
+        exportDate: z.string(),
+        sceneHash: z.string().optional(),
+        bakingOptions: z.object({
+            resolution: z.number(),
+            casts: z.number(),
+            progressiveSamples: z.number(),
+            lightSources: z.array(z.object({
+                position: z.tuple([z.number(), z.number(), z.number()]),
+                size: z.number(),
+                intensity: z.number(),
+                color: z.tuple([z.number(), z.number(), z.number()]),
+            })).optional(),
+            // Legacy fields for backwards compatibility
+            lightSize: z.number().optional(),
+            lightPosition: z.tuple([z.number(), z.number(), z.number()]).optional(),
+            directLightEnabled: z.boolean(),
+            indirectLightEnabled: z.boolean(),
+            ambientLightEnabled: z.boolean(),
+            ambientDistance: z.number(),
+        }),
+    }),
+    lightmap: z.object({
+        textureFile: z.string(),
+        width: z.number(),
+        height: z.number(),
+        format: z.string(),
+        filterMode: z.number(),
+    }),
+    meshMappings: z.record(z.string(), z.object({
+        actorUuid: z.string(),
+        meshIndex: z.number(),
+        uvBounds: z.object({
+            min: z.tuple([z.number(), z.number()]),
+            max: z.tuple([z.number(), z.number()]),
+        }),
+    })),
+    uv2Data: z.record(z.string(), z.array(z.object({
+        meshIndex: z.number(),
+        vertexCount: z.number(),
+        uv2Coordinates: z.array(z.number()), // Flattened UV2 coordinates
+        geometryAttributes: z.object({
+            positionCount: z.number(),
+            normalCount: z.number(),
+            hasUv: z.boolean(),
+        }).optional(), // For validation
+    }))),
+}).strict();
+/**
+ * Validates lightmap data against the schema
+ */
+export function validateLightmapData(data) {
+    const result = lightmapSchema.safeParse(data);
+    if (!result.success) {
+        throw new Error(`Invalid lightmap data: ${result.error.message}`);
+    }
+    return result.data;
+}
+/**
+ * Generates a hash for scene content to detect changes
+ */
+export function generateSceneHash(actors) {
+    const content = actors.map(actor => ({
+        uuid: actor.uuid,
+        position: actor.rootComponent.position.toArray(),
+        rotation: actor.rootComponent.rotation.toArray(),
+        scale: actor.rootComponent.scale.toArray(),
+    }));
+    // Simple hash based on JSON string - could be improved with a proper hash function
+    const jsonString = JSON.stringify(content);
+    let hash = 0;
+    for (let i = 0; i < jsonString.length; i++) {
+        const char = jsonString.charCodeAt(i);
+        hash = ((hash << 5) - hash) + char;
+        hash = hash & hash; // Convert to 32-bit integer
+    }
+    return Math.abs(hash).toString(16);
+}
+/**
+ * Creates mesh mappings by analyzing UV2 coordinates
+ */
+export function createMeshMappings(actors, meshes) {
+    const mappings = new Map();
+    for (const actor of actors) {
+        // Get meshes from this actor
+        const actorMeshes = getMeshesFromActor(actor);
+        actorMeshes.forEach((mesh, actorMeshIndex) => {
+            if (meshes.includes(mesh)) {
+                // Calculate UV bounds from UV2 coordinates
+                const uvBounds = calculateUVBounds(mesh);
+                mappings.set(`${actor.uuid}_${actorMeshIndex}`, {
+                    actorUuid: actor.uuid,
+                    meshIndex: actorMeshIndex, // Use per-actor mesh index, not global
+                    uvBounds: uvBounds,
+                });
+            }
+        });
+    }
+    return mappings;
+}
+/**
+ * Extracts UV2 coordinates from all meshes in the given actors
+ */
+export function extractUV2Data(actors, meshes) {
+    const uv2DataMap = {};
+    for (const actor of actors) {
+        const actorMeshes = getMeshesFromActor(actor);
+        const actorUV2Data = [];
+        actorMeshes.forEach((mesh, meshIndex) => {
+            if (meshes.includes(mesh)) {
+                const uv2Attribute = mesh.geometry.getAttribute('uv2');
+                if (uv2Attribute) {
+                    const geometry = mesh.geometry;
+                    actorUV2Data.push({
+                        meshIndex: meshIndex,
+                        vertexCount: uv2Attribute.count,
+                        uv2Coordinates: Array.from(uv2Attribute.array),
+                        geometryAttributes: {
+                            positionCount: geometry.getAttribute('position')?.count ?? 0,
+                            normalCount: geometry.getAttribute('normal')?.count ?? 0,
+                            hasUv: !!geometry.getAttribute('uv'),
+                        },
+                    });
+                }
+            }
+        });
+        if (actorUV2Data.length > 0) {
+            uv2DataMap[actor.uuid] = actorUV2Data;
+        }
+    }
+    return uv2DataMap;
+}
+/**
+ * Restores UV2 coordinates to meshes in the given actors
+ */
+export function restoreUV2Data(actors, uv2DataMap) {
+    for (const actor of actors) {
+        const actorUV2Data = uv2DataMap[actor.uuid];
+        if (actorUV2Data) {
+            const actorMeshes = getMeshesFromActor(actor);
+            for (const uv2Data of actorUV2Data) {
+                const mesh = actorMeshes[uv2Data.meshIndex];
+                if (mesh) {
+                    // Validate geometry compatibility (optional but recommended)
+                    if (uv2Data.geometryAttributes) {
+                        const currentGeometry = mesh.geometry;
+                        const positionCount = currentGeometry.getAttribute('position')?.count ?? 0;
+                        const normalCount = currentGeometry.getAttribute('normal')?.count ?? 0;
+                        if (positionCount !== uv2Data.geometryAttributes.positionCount ||
+                            normalCount !== uv2Data.geometryAttributes.normalCount) {
+                            console.warn(`UV2 data mismatch for actor ${actor.uuid}, mesh ${uv2Data.meshIndex}:`);
+                            console.warn(`  Expected: position=${uv2Data.geometryAttributes.positionCount}, normal=${uv2Data.geometryAttributes.normalCount}`);
+                            console.warn(`  Current:  position=${positionCount}, normal=${normalCount}`);
+                            console.warn(`  UV2 vertex count: ${uv2Data.vertexCount}`);
+                            console.warn('  This may indicate the geometry was modified during baking.');
+                        }
+                    }
+                    // Restore UV2 coordinates
+                    const uv2Array = new Float32Array(uv2Data.uv2Coordinates);
+                    const uv2Attribute = new THREE.BufferAttribute(uv2Array, 2);
+                    mesh.geometry.setAttribute('uv2', uv2Attribute);
+                }
+                else {
+                    console.warn(`🔍 Mesh not found for actor ${actor.uuid}, mesh index ${uv2Data.meshIndex}`);
+                }
+            }
+        }
+    }
+}
+/**
+ * Helper function to get meshes from an actor
+ * This duplicates logic from LightmapManager for now to avoid circular imports
+ */
+function getMeshesFromActor(actor) {
+    const meshes = [];
+    // Check for GLTFMeshActor
+    if (actor.getMeshComponent) {
+        const meshComponent = actor.getMeshComponent();
+        if (meshComponent) {
+            const model = meshComponent.getModel();
+            if (model) {
+                model.traverse((child) => {
+                    if (child instanceof THREE.Mesh) {
+                        meshes.push(child);
+                    }
+                });
+            }
+        }
+    }
+    // Check if root component is a MeshComponent
+    const rootComponent = actor.rootComponent;
+    if (rootComponent && 'getMesh' in rootComponent) {
+        const mesh = rootComponent.getMesh();
+        if (mesh instanceof THREE.Mesh) {
+            meshes.push(mesh);
+        }
+    }
+    // Apply the same filtering as during baking: only include meshes with materials and visibility
+    return meshes.filter(mesh => mesh.material && mesh.visible);
+}
+/**
+ * Calculates UV bounds for a mesh based on UV2 coordinates
+ */
+function calculateUVBounds(mesh) {
+    const uv2Attribute = mesh.geometry.getAttribute('uv2');
+    if (!uv2Attribute) {
+        return { min: [0, 0], max: [1, 1] }; // Default bounds
+    }
+    let minU = Infinity, minV = Infinity;
+    let maxU = -Infinity, maxV = -Infinity;
+    for (let i = 0; i < uv2Attribute.count; i++) {
+        const u = uv2Attribute.getX(i);
+        const v = uv2Attribute.getY(i);
+        minU = Math.min(minU, u);
+        minV = Math.min(minV, v);
+        maxU = Math.max(maxU, u);
+        maxV = Math.max(maxV, v);
+    }
+    return {
+        min: [minU, minV],
+        max: [maxU, maxV],
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"LightmapSerialization.js","sourceRoot":"","sources":["../../../../src/render/lightmapping/LightmapSerialization.ts"],"names":[],"mappings":"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"}

package/dist/src/render/lightmapping/LightmapSerializer.d.ts

@@ -0,0 +1,94 @@
+/**
+ * LightmapSerializer handles the conversion of lightmap data to and from files.
+ *
+ * This class provides the core export/import functionality:
+ * - Converts runtime lightmap data to serializable format
+ * - Saves lightmap textures as separate image files
+ * - Loads lightmap data and reconstructs textures
+ * - Manages file paths and naming conventions
+ */
+import * as THREE from 'three';
+import { type LightmapExportData, type LightmapImportResult } from './LightmapSerialization.js';
+/**
+ * Options for lightmap export
+ */
+export interface LightmapExportOptions {
+    /** Custom base filename for export (without extension) */
+    baseFileName?: string;
+    /** Whether to include scene hash for change detection */
+    includeSceneHash?: boolean;
+}
+/**
+ * Result of lightmap data export
+ */
+export interface LightmapDataExportResult {
+    /** The lightmap metadata as a JSON string */
+    metadataJson: string;
+    /** The lightmap texture data as binary blob */
+    textureBlob: Blob;
+    /** Suggested filename for the metadata file */
+    metadataFileName: string;
+    /** Suggested filename for the texture file */
+    textureFileName: string;
+}
+/**
+ * Options for lightmap import
+ */
+export interface LightmapImportOptions {
+    /** Whether to validate scene hash against current scene */
+    validateSceneHash?: boolean;
+    /** Callback for progress reporting */
+    onProgress?: (stage: string, progress: number) => void;
+}
+/**
+ * Handles serialization and deserialization of lightmap data
+ */
+export declare class LightmapSerializer {
+    private static readonly LIGHTMAP_VERSION;
+    private static readonly BINARY_FORMAT;
+    /**
+     * Exports lightmap data
+     * @param exportData The lightmap data to export
+     * @param options Export options
+     * @param renderer WebGL renderer for reading render target data
+     * @returns Promise resolving to the lightmap data that can be handled by the caller
+     */
+    static exportLightmapData(exportData: LightmapExportData, options: LightmapExportOptions | undefined, renderer: THREE.WebGLRenderer): Promise<LightmapDataExportResult>;
+    /**
+     * Imports lightmap data from provided file data
+     * @param lightmapJsonData The parsed lightmap metadata JSON
+     * @param textureData The binary texture data as ArrayBuffer
+     * @param options Import options
+     * @returns Promise resolving to lightmap import result
+     */
+    static importLightmap(lightmapJsonData: any, textureData: ArrayBuffer, options?: LightmapImportOptions): Promise<LightmapImportResult>;
+    /**
+     * Checks if a lightmap file exists for the given scene path
+     * Note: This method is deprecated. File existence should be checked at the application level.
+     * @param scenePath Path to the scene file
+     * @returns Promise resolving to false (deprecated functionality)
+     */
+    static lightmapExists(scenePath: string): Promise<boolean>;
+    /**
+     * Gets the lightmap file path for a given scene path
+     * @param scenePath Path to the scene file
+     * @returns Path to the corresponding lightmap file
+     */
+    static getLightmapPath(scenePath: string): string;
+    /**
+     * Imports a texture from a provided ArrayBuffer
+     */
+    private static importTextureFromBuffer;
+    /**
+     * Exports a THREE.js texture as high-precision binary data
+     */
+    private static exportTextureAsBinary;
+    /**
+     * Converts a map of mesh mappings to a serializable format
+     */
+    private static serializeMeshMappings;
+    /**
+     * Converts a serialized mesh mappings object back to a Map
+     */
+    private static deserializeMeshMappings;
+}

package/dist/src/render/lightmapping/LightmapSerializer.js

@@ -0,0 +1,223 @@
+/**
+ * LightmapSerializer handles the conversion of lightmap data to and from files.
+ *
+ * This class provides the core export/import functionality:
+ * - Converts runtime lightmap data to serializable format
+ * - Saves lightmap textures as separate image files
+ * - Loads lightmap data and reconstructs textures
+ * - Manages file paths and naming conventions
+ */
+import * as THREE from 'three';
+import { generateSceneHash, validateLightmapData, } from './LightmapSerialization.js';
+/**
+ * Handles serialization and deserialization of lightmap data
+ */
+export class LightmapSerializer {
+    /**
+     * Exports lightmap data
+     * @param exportData The lightmap data to export
+     * @param options Export options
+     * @param renderer WebGL renderer for reading render target data
+     * @returns Promise resolving to the lightmap data that can be handled by the caller
+     */
+    static async exportLightmapData(exportData, options = {}, renderer) {
+        // Generate file names
+        const baseFileName = options.baseFileName ?? 'lightmap';
+        const lightmapFileName = `${baseFileName}.lightmap.json`;
+        const textureFileName = `${baseFileName}.lightmap`;
+        // Generate scene hash if requested
+        const sceneHash = options.includeSceneHash
+            ? generateSceneHash(exportData.actors)
+            : undefined;
+        // Export texture as high-precision binary data
+        const { textureBlob, width, height } = await this.exportTextureAsBinary(exportData.texture, renderer, exportData.renderTarget);
+        // Create lightmap metadata
+        const lightmapData = {
+            version: this.LIGHTMAP_VERSION,
+            metadata: {
+                exportDate: new Date().toISOString(),
+                sceneHash: sceneHash,
+                bakingOptions: {
+                    resolution: exportData.bakingOptions.resolution,
+                    casts: exportData.bakingOptions.casts,
+                    progressiveSamples: exportData.bakingOptions.progressiveSamples ?? 100,
+                    lightSources: exportData.bakingOptions.lightSources.map(light => ({
+                        position: [light.position.x, light.position.y, light.position.z],
+                        size: light.size,
+                        intensity: light.intensity ?? 1.0,
+                        color: light.color ? [light.color.x, light.color.y, light.color.z] : [1, 1, 1]
+                    })),
+                    directLightEnabled: exportData.bakingOptions.directLightEnabled,
+                    indirectLightEnabled: exportData.bakingOptions.indirectLightEnabled,
+                    ambientLightEnabled: exportData.bakingOptions.ambientLightEnabled,
+                    ambientDistance: exportData.bakingOptions.ambientDistance,
+                },
+            },
+            lightmap: {
+                textureFile: textureFileName,
+                width: width,
+                height: height,
+                format: this.BINARY_FORMAT,
+                filterMode: exportData.bakingOptions.filterMode,
+            },
+            meshMappings: this.serializeMeshMappings(exportData.meshMappings),
+            uv2Data: exportData.uv2Data ?? {},
+        };
+        return {
+            metadataJson: JSON.stringify(lightmapData, null, 2),
+            textureBlob,
+            metadataFileName: lightmapFileName,
+            textureFileName: textureFileName,
+        };
+    }
+    /**
+     * Imports lightmap data from provided file data
+     * @param lightmapJsonData The parsed lightmap metadata JSON
+     * @param textureData The binary texture data as ArrayBuffer
+     * @param options Import options
+     * @returns Promise resolving to lightmap import result
+     */
+    static async importLightmap(lightmapJsonData, textureData, options = {}) {
+        options.onProgress?.('loading', 10);
+        // Validate lightmap metadata
+        const validatedData = validateLightmapData(lightmapJsonData);
+        options.onProgress?.('loading', 30);
+        // Load texture from provided data
+        const texture = await this.importTextureFromBuffer(textureData, validatedData.lightmap);
+        options.onProgress?.('loading', 70);
+        // Deserialize mesh mappings
+        const meshMappings = this.deserializeMeshMappings(validatedData.meshMappings);
+        options.onProgress?.('loading', 90);
+        // Reconstruct baking options
+        const bakingOptions = {
+            resolution: validatedData.metadata.bakingOptions.resolution,
+            casts: validatedData.metadata.bakingOptions.casts,
+            progressiveSamples: validatedData.metadata.bakingOptions.progressiveSamples,
+            lightSources: validatedData.metadata.bakingOptions.lightSources?.map((light) => ({
+                position: new THREE.Vector3(...light.position),
+                size: light.size,
+                intensity: light.intensity,
+                color: new THREE.Vector3(...light.color)
+            })) ?? [{
+                    position: new THREE.Vector3(...validatedData.metadata.bakingOptions.lightPosition ?? [10, 10, 10]),
+                    size: validatedData.metadata.bakingOptions.lightSize ?? 0.5,
+                    intensity: 1.0,
+                    color: new THREE.Vector3(1, 1, 1)
+                }],
+            directLightEnabled: validatedData.metadata.bakingOptions.directLightEnabled,
+            indirectLightEnabled: validatedData.metadata.bakingOptions.indirectLightEnabled,
+            ambientLightEnabled: validatedData.metadata.bakingOptions.ambientLightEnabled,
+            ambientDistance: validatedData.metadata.bakingOptions.ambientDistance,
+            filterMode: validatedData.lightmap.filterMode,
+        };
+        options.onProgress?.('loading', 100);
+        return {
+            texture,
+            bakingOptions,
+            meshMappings,
+            textureFile: validatedData.lightmap.textureFile,
+            uv2Data: validatedData.uv2Data,
+        };
+    }
+    /**
+     * Checks if a lightmap file exists for the given scene path
+     * Note: This method is deprecated. File existence should be checked at the application level.
+     * @param scenePath Path to the scene file
+     * @returns Promise resolving to false (deprecated functionality)
+     */
+    static async lightmapExists(scenePath) {
+        console.warn('LightmapSerializer.lightmapExists() is deprecated. Check file existence at the application level.');
+        return false;
+    }
+    /**
+     * Gets the lightmap file path for a given scene path
+     * @param scenePath Path to the scene file
+     * @returns Path to the corresponding lightmap file
+     */
+    static getLightmapPath(scenePath) {
+        const pathWithoutExt = scenePath.replace(/\.[^.]+$/, '');
+        return `${pathWithoutExt}.lightmap.json`;
+    }
+    /**
+     * Imports a texture from a provided ArrayBuffer
+     */
+    static async importTextureFromBuffer(textureData, lightmapInfo) {
+        // Only binary format is supported
+        if (lightmapInfo.format !== this.BINARY_FORMAT) {
+            throw new Error(`Unsupported lightmap format: ${lightmapInfo.format}. Only '${this.BINARY_FORMAT}' is supported.`);
+        }
+        const float32Array = new Float32Array(textureData);
+        // Validate array size
+        const expectedSize = lightmapInfo.width * lightmapInfo.height * 4; // RGBA
+        if (float32Array.length !== expectedSize) {
+            throw new Error(`Binary texture size mismatch. Expected ${expectedSize} floats, got ${float32Array.length}`);
+        }
+        // Create DataTexture with the loaded data
+        const dataTexture = new THREE.DataTexture(float32Array, lightmapInfo.width, lightmapInfo.height, THREE.RGBAFormat, THREE.FloatType);
+        // Apply stored settings
+        const filterMode = lightmapInfo.filterMode;
+        if (filterMode === THREE.NearestFilter || filterMode === THREE.LinearFilter) {
+            dataTexture.magFilter = filterMode;
+        }
+        dataTexture.minFilter = filterMode;
+        dataTexture.generateMipmaps = lightmapInfo.filterMode >= THREE.NearestMipmapNearestFilter;
+        dataTexture.flipY = false;
+        dataTexture.needsUpdate = true;
+        return dataTexture;
+    }
+    /**
+     * Exports a THREE.js texture as high-precision binary data
+     */
+    static async exportTextureAsBinary(texture, renderer, renderTarget) {
+        // Get texture dimensions
+        const width = texture.image?.width ?? 512;
+        const height = texture.image?.height ?? 512;
+        // Read pixels as Float32Array from render target
+        const pixelBuffer = new Float32Array(width * height * 4); // RGBA
+        // Direct reading from the original render target
+        const originalTarget = renderer.getRenderTarget();
+        renderer.setRenderTarget(renderTarget);
+        renderer.readRenderTargetPixels(renderTarget, 0, 0, width, height, pixelBuffer);
+        renderer.setRenderTarget(originalTarget);
+        // Create blob from Float32Array
+        const blob = new Blob([pixelBuffer.buffer], { type: 'application/octet-stream' });
+        return {
+            textureBlob: blob,
+            width,
+            height,
+        };
+    }
+    /**
+     * Converts a map of mesh mappings to a serializable format
+     */
+    static serializeMeshMappings(meshMappings) {
+        const result = {};
+        for (const [key, value] of meshMappings) {
+            result[key] = value;
+        }
+        return result;
+    }
+    /**
+     * Converts a serialized mesh mappings object back to a Map
+     */
+    static deserializeMeshMappings(serializedMappings) {
+        const result = new Map();
+        for (const [key, value] of Object.entries(serializedMappings)) {
+            result.set(key, value);
+        }
+        return result;
+    }
+}
+Object.defineProperty(LightmapSerializer, "LIGHTMAP_VERSION", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: '1.0.0'
+});
+Object.defineProperty(LightmapSerializer, "BINARY_FORMAT", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: 'float32'
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"LightmapSerializer.js","sourceRoot":"","sources":["../../../../src/render/lightmapping/LightmapSerializer.ts"],"names":[],"mappings":"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"}

package/dist/src/render/lightmapping/MultiLightmapperMaterial.d.ts

@@ -0,0 +1,41 @@
+import { ShaderMaterial } from 'three';
+import type { Color, Matrix4, Texture, Vector3 } from 'three';
+import type { MeshBVH } from 'three-mesh-bvh';
+/**
+ * Light data for multi-light lightmapping
+ */
+export interface LightData {
+    position: Vector3;
+    color: Color;
+    intensity: number;
+    size: number;
+    type: number;
+    distance: number;
+    decay: number;
+    angle: number;
+    penumbra: number;
+    direction: Vector3;
+    areaDimensions: [number, number];
+}
+export type MultiLightmapperMaterialOptions = {
+    bvh: MeshBVH;
+    invModelMatrix: Matrix4;
+    positions: Texture;
+    normals: Texture;
+    casts: number;
+    lights: LightData[];
+    maxLights: number;
+    opacity: number;
+    sampleIndex: number;
+    directLightEnabled: boolean;
+    indirectLightEnabled: boolean;
+    ambientLightEnabled: boolean;
+    ambientDistance: number;
+};
+/**
+ * Multi-light lightmapper material supporting DirectionalLight, PointLight, SpotLight, and RectAreaLight.
+ * This is vibe-coded so don't expect it to work or be efficient.
+ */
+export declare class MultiLightmapperMaterial extends ShaderMaterial {
+    constructor(options: MultiLightmapperMaterialOptions);
+}