@littlecarlito/blorktools 0.50.4 → 0.51.0

package/src/asset_debugger/util/workers/lighting-worker.js

@@ -0,0 +1,61 @@
+/**
+ * Lighting Worker
+ * 
+ * A web worker for processing lighting files (HDR/EXR) asynchronously.
+ */
+
+// Listen for messages from the main thread
+self.onmessage = async function(e) {
+  try {
+    const { file, id } = e.data;
+    console.log(`[Lighting Worker] Processing lighting file: ${file.name}`);
+    
+    // For HDR/EXR files, we can't directly parse them in a worker
+    // without additional libraries, so we'll pass the array buffer back
+    // to the main thread for processing with Three.js
+    
+    // Read file as array buffer
+    const arrayBuffer = await readFileAsArrayBuffer(file);
+    
+    // Extract file extension to determine type
+    const fileExtension = file.name.split('.').pop().toLowerCase();
+    
+    self.postMessage({
+      status: 'success',
+      id,
+      fileName: file.name,
+      fileSize: file.size,
+      fileType: fileExtension,
+      // We need to transfer the arrayBuffer to avoid copying
+      // This makes it unusable in the worker after transfer
+      arrayBuffer: arrayBuffer
+    }, [arrayBuffer]);
+  } catch (error) {
+    console.error('[Lighting Worker] Error:', error);
+    self.postMessage({
+      status: 'error',
+      error: error.message || 'Unknown error processing lighting file'
+    });
+  }
+};
+
+/**
+ * Read a file as an ArrayBuffer
+ * @param {File} file - The file to read
+ * @returns {Promise<ArrayBuffer>} A promise that resolves to the ArrayBuffer
+ */
+function readFileAsArrayBuffer(file) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    
+    reader.onload = function(e) {
+      resolve(e.target.result);
+    };
+    
+    reader.onerror = function() {
+      reject(new Error('Failed to read lighting file'));
+    };
+    
+    reader.readAsArrayBuffer(file);
+  });
+} 

package/src/asset_debugger/util/workers/model-worker.js

@@ -0,0 +1,109 @@
+/**
+ * Model Worker
+ * 
+ * This worker processes GLB model files.
+ * It performs initial validation and processing of GLB files in a separate thread.
+ */
+
+/**
+ * Process a GLB model file
+ * @param {File} file - The GLB file to process
+ * @returns {Object} An object containing processing results
+ */
+async function consumeGLBFile(file) {
+  try {
+    // Basic file validation
+    if (!file || !file.name.toLowerCase().endsWith('.glb')) {
+      return {
+        status: 'error',
+        error: 'Invalid GLB file'
+      };
+    }
+    
+    // Convert file to ArrayBuffer for processing
+    const arrayBuffer = await file.arrayBuffer();
+    
+    // Validate GLB format
+    if (arrayBuffer.byteLength < 12) {
+      return {
+        status: 'error',
+        error: 'Invalid GLB format: File too small'
+      };
+    }
+    
+    // Check GLB magic bytes
+    const headerView = new Uint8Array(arrayBuffer, 0, 4);
+    const magicString = String.fromCharCode.apply(null, headerView);
+    
+    if (magicString !== 'glTF') {
+      return {
+        status: 'error',
+        error: 'Invalid GLB format: Missing glTF magic bytes'
+      };
+    }
+    
+    // Get GLB version
+    const dataView = new DataView(arrayBuffer);
+    const version = dataView.getUint32(4, true);
+    if (version !== 2) {
+      return {
+        status: 'error',
+        error: `Unsupported GLB version: ${version}`
+      };
+    }
+    
+    // Check for JSON chunk
+    const jsonChunkType = dataView.getUint32(16, true);
+    if (jsonChunkType !== 0x4E4F534A) { // 'JSON' in ASCII
+      return {
+        status: 'error',
+        error: 'Invalid GLB: First chunk is not JSON'
+      };
+    }
+    
+    // Successfully validated the GLB file
+    return {
+      status: 'success',
+      fileName: file.name,
+      fileSize: file.size,
+      fileType: 'glb',
+      version: version,
+      // We don't need to send the full arrayBuffer back to the main thread
+      // Just send validation results
+      message: 'GLB file validated successfully'
+    };
+    
+  } catch (error) {
+    console.error('Error in model worker:', error);
+    return {
+      status: 'error',
+      error: `Error processing GLB file: ${error.message || 'Unknown error'}`
+    };
+  }
+}
+
+// Set up message handler to process GLB files
+self.onmessage = async (e) => {
+  try {
+    const { file, id } = e.data;
+    
+    // Process the file
+    const result = await consumeGLBFile(file);
+    
+    // Add the worker ID to the result
+    result.id = id;
+    
+    // Send the result back to the main thread
+    self.postMessage(result);
+  } catch (error) {
+    // Send error result back to main thread
+    self.postMessage({
+      status: 'error',
+      id: e.data.id,
+      error: error.message || 'Unknown error in model worker'
+    });
+  }
+};
+
+// Log that the worker has started
+console.log('Model worker started'); 

package/src/asset_debugger/util/workers/texture-worker.js

@@ -0,0 +1,54 @@
+/**
+ * Texture Worker
+ * 
+ * A web worker for processing texture files asynchronously.
+ */
+
+// Listen for messages from the main thread
+self.onmessage = async function(e) {
+  try {
+    const { file, textureType, id } = e.data;
+    console.log(`[Texture Worker] Processing ${textureType} texture: ${file.name}`);
+    
+    // Generate a preview data URL
+    const previewDataUrl = await createPreviewDataUrl(file);
+    
+    // Process the texture (in a real implementation, this would do the heavy processing)
+    // Here we just post the preview data URL back
+    self.postMessage({
+      status: 'success',
+      id,
+      textureType,
+      previewDataUrl,
+      fileName: file.name,
+      fileSize: file.size
+    });
+  } catch (error) {
+    console.error('[Texture Worker] Error:', error);
+    self.postMessage({
+      status: 'error',
+      error: error.message || 'Unknown error processing texture'
+    });
+  }
+};
+
+/**
+ * Create a preview data URL from a file
+ * @param {File} file - The file to create a preview for
+ * @returns {Promise<string>} A promise that resolves to the data URL
+ */
+function createPreviewDataUrl(file) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    
+    reader.onload = function(e) {
+      resolve(e.target.result);
+    };
+    
+    reader.onerror = function(e) {
+      reject(new Error('Failed to read texture file'));
+    };
+    
+    reader.readAsDataURL(file);
+  });
+} 

package/src/asset_debugger/util/workers/worker-manager.js

@@ -0,0 +1,212 @@
+/**
+ * Worker Manager
+ * 
+ * This module manages the creation and communication with web workers for file processing.
+ */
+
+// Track active workers by ID
+const activeWorkers = new Map();
+
+// Counter for generating unique worker IDs
+let workerIdCounter = 0;
+
+/**
+ * Get a unique ID for a worker
+ * @returns {string} A unique worker ID
+ */
+function getWorkerId() {
+  return `worker_${Date.now()}_${workerIdCounter++}`;
+}
+
+/**
+ * Process a texture file using a web worker
+ * @param {File} file - The texture file to process
+ * @param {string} textureType - The type of texture (baseColor, orm, normal)
+ * @returns {Promise<Object>} A promise that resolves with the worker result
+ */
+export function processTextureFile(file, textureType) {
+  return new Promise((resolve, reject) => {
+    try {
+      const workerId = getWorkerId();
+      
+      // Create a new worker
+      const worker = new Worker(new URL('./texture-worker.js', import.meta.url), { type: 'module' });
+      
+      // Set up message handler for receiving results
+      worker.onmessage = (e) => {
+        const result = e.data;
+        
+        if (result.status === 'success') {
+          resolve(result);
+        } else {
+          reject(new Error(result.error || 'Unknown error in texture worker'));
+        }
+        
+        // Clean up
+        cleanupWorker(workerId);
+      };
+      
+      // Set up error handler
+      worker.onerror = (error) => {
+        console.error('Texture worker error:', error);
+        reject(new Error('Worker error: ' + (error.message || 'Unknown error')));
+        cleanupWorker(workerId);
+      };
+      
+      // Store the worker in the map
+      activeWorkers.set(workerId, worker);
+      
+      // Send the file to the worker
+      worker.postMessage({
+        file,
+        textureType,
+        id: workerId
+      });
+      
+    } catch (error) {
+      console.error('Error starting texture worker:', error);
+      reject(error);
+    }
+  });
+}
+
+/**
+ * Process a model file using a web worker
+ * @param {File} file - The model file to process
+ * @returns {Promise<Object>} A promise that resolves with the worker result
+ */
+export function processModelFile(file) {
+  return new Promise((resolve, reject) => {
+    try {
+      const workerId = getWorkerId();
+      
+      // Create a new worker
+      const worker = new Worker(new URL('./model-worker.js', import.meta.url), { type: 'module' });
+      
+      // Set up message handler for receiving results
+      worker.onmessage = (e) => {
+        const result = e.data;
+        
+        if (result.status === 'success') {
+          resolve(result);
+        } else {
+          reject(new Error(result.error || 'Unknown error in model worker'));
+        }
+        
+        // Clean up
+        cleanupWorker(workerId);
+      };
+      
+      // Set up error handler
+      worker.onerror = (error) => {
+        console.error('Model worker error:', error);
+        reject(new Error('Worker error: ' + (error.message || 'Unknown error')));
+        cleanupWorker(workerId);
+      };
+      
+      // Store the worker in the map
+      activeWorkers.set(workerId, worker);
+      
+      // Send the file to the worker
+      worker.postMessage({
+        file,
+        id: workerId
+      });
+      
+    } catch (error) {
+      console.error('Error starting model worker:', error);
+      reject(error);
+    }
+  });
+}
+
+/**
+ * Process a lighting file using a web worker
+ * @param {File} file - The lighting file to process
+ * @returns {Promise<Object>} A promise that resolves with the worker result
+ */
+export function processLightingFile(file) {
+  return new Promise((resolve, reject) => {
+    try {
+      const workerId = getWorkerId();
+      
+      // Create a new worker
+      const worker = new Worker(new URL('./lighting-worker.js', import.meta.url), { type: 'module' });
+      
+      // Set up message handler for receiving results
+      worker.onmessage = (e) => {
+        const result = e.data;
+        
+        if (result.status === 'success') {
+          resolve(result);
+        } else {
+          reject(new Error(result.error || 'Unknown error in lighting worker'));
+        }
+        
+        // Clean up
+        cleanupWorker(workerId);
+      };
+      
+      // Set up error handler
+      worker.onerror = (error) => {
+        console.error('Lighting worker error:', error);
+        reject(new Error('Worker error: ' + (error.message || 'Unknown error')));
+        cleanupWorker(workerId);
+      };
+      
+      // Store the worker in the map
+      activeWorkers.set(workerId, worker);
+      
+      // Send the file to the worker
+      worker.postMessage({
+        file,
+        id: workerId
+      });
+      
+    } catch (error) {
+      console.error('Error starting lighting worker:', error);
+      reject(error);
+    }
+  });
+}
+
+/**
+ * Clean up a worker by ID
+ * @param {string} workerId - The ID of the worker to clean up
+ */
+function cleanupWorker(workerId) {
+  if (activeWorkers.has(workerId)) {
+    const worker = activeWorkers.get(workerId);
+    worker.terminate();
+    activeWorkers.delete(workerId);
+    console.log(`Worker ${workerId} terminated and cleaned up`);
+  }
+}
+
+/**
+ * Check if there are any active workers
+ * @returns {boolean} True if there are active workers, false otherwise
+ */
+export function hasActiveWorkers() {
+  return activeWorkers.size > 0;
+}
+
+/**
+ * Terminate all active workers
+ */
+export function terminateAllWorkers() {
+  for (const [id, worker] of activeWorkers.entries()) {
+    worker.terminate();
+    console.log(`Worker ${id} terminated`);
+  }
+  activeWorkers.clear();
+  console.log('All workers terminated');
+}
+
+export default {
+  processTextureFile,
+  processModelFile,
+  processLightingFile,
+  hasActiveWorkers,
+  terminateAllWorkers
+};