@littlecarlito/blorktools 0.50.3 → 0.51.0

package/src/asset_debugger/util/data/glb-buffer-manager.js

@@ -0,0 +1,407 @@
+import { BINARY_DATA_PROPERTY, MESH_BINARY_EXTENSION, MESH_INDEX_PROPERTY } from "../state/glb-preview-state";
+import { validateGLBHeader, validateJSONChunk, validateBinaryChunk, isRemovalOperation, hasExtension, hasBufferURI, isDataURI, getChunkInfo } from './glb-classifier.js';
+
+export function associateBinaryBufferWithMesh(glbArrayBuffer, meshIndex, binaryData) {
+    return new Promise((resolve, reject) => {
+        try {
+            const isRemoval = isRemovalOperation(binaryData);
+            console.log(`${isRemoval ? 'Removing' : 'Associating'} binary data for mesh ${meshIndex} (${isRemoval ? 0 : binaryData.byteLength} bytes)`);
+            
+            const dataView = new DataView(glbArrayBuffer);
+            validateGLBHeader(dataView);
+            
+            console.log(`GLB buffer size: ${dataView.byteLength} bytes`);
+            
+            const chunkInfo = getChunkInfo(dataView);
+            console.log(`JSON chunk length: ${chunkInfo.jsonChunkLength} bytes`);
+            
+            validateJSONChunk(dataView, chunkInfo.jsonChunkLength);
+            
+            const gltf = parseJSONChunk(glbArrayBuffer, chunkInfo);
+            ensureExtensions(gltf);
+            
+            const associations = gltf.extensions[MESH_BINARY_EXTENSION].meshBinaryAssociations;
+            const existingAssociationIndex = associations.findIndex(assoc => assoc[MESH_INDEX_PROPERTY] === meshIndex);
+            const existingAssociation = existingAssociationIndex >= 0 ? associations[existingAssociationIndex] : null;
+            
+            if (isRemoval && existingAssociation) {
+                resolve(removeBinaryAssociation(glbArrayBuffer, gltf, associations, existingAssociationIndex, meshIndex));
+                return;
+            }
+            
+            resolve(addOrUpdateBinaryAssociation(glbArrayBuffer, gltf, meshIndex, binaryData, existingAssociation, associations, chunkInfo));
+        } catch (error) {
+            console.error('Error in associateBinaryBufferWithMesh:', error);
+            reject(new Error(`Error associating binary buffer: ${error.message}`));
+        }
+    });
+}
+
+export function getBinaryBufferForMesh(glbArrayBuffer, meshIndex) {
+    return new Promise((resolve, reject) => {
+        try {
+            const dataView = new DataView(glbArrayBuffer);
+            validateGLBHeader(dataView);
+            
+            const chunkInfo = getChunkInfo(dataView);
+            validateJSONChunk(dataView, chunkInfo.jsonChunkLength);
+            
+            const gltf = parseJSONChunk(glbArrayBuffer, chunkInfo);
+            
+            if (!hasExtension(gltf, MESH_BINARY_EXTENSION)) {
+                resolve(null);
+                return;
+            }
+            
+            const associations = gltf.extensions[MESH_BINARY_EXTENSION].meshBinaryAssociations;
+            if (!associations || !Array.isArray(associations)) {
+                resolve(null);
+                return;
+            }
+            
+            const association = associations.find(assoc => assoc[MESH_INDEX_PROPERTY] === meshIndex);
+            
+            if (!association) {
+                resolve(null);
+                return;
+            }
+            
+            const bufferIndex = association[BINARY_DATA_PROPERTY];
+            
+            if (!gltf.buffers || !gltf.buffers[bufferIndex]) {
+                console.log(`Buffer ${bufferIndex} not found for mesh ${meshIndex}`);
+                resolve(null);
+                return;
+            }
+            
+            const buffer = gltf.buffers[bufferIndex];
+            console.log(`Found buffer ${bufferIndex} for mesh ${meshIndex} with length ${buffer.byteLength}`);
+            
+            resolve(extractBufferData(glbArrayBuffer, gltf, buffer, bufferIndex, chunkInfo));
+        } catch (error) {
+            console.error('Error retrieving binary buffer:', error);
+            reject(new Error(`Error retrieving binary buffer: ${error.message}`));
+        }
+    });
+}
+
+function parseJSONChunk(glbArrayBuffer, chunkInfo) {
+    const jsonData = glbArrayBuffer.slice(chunkInfo.jsonStart, chunkInfo.jsonEnd);
+    const decoder = new TextDecoder('utf-8');
+    const jsonString = decoder.decode(jsonData);
+    return JSON.parse(jsonString);
+}
+
+function ensureExtensions(gltf) {
+    if (!gltf.extensions) {
+        gltf.extensions = {};
+    }
+    
+    if (!gltf.extensions[MESH_BINARY_EXTENSION]) {
+        gltf.extensions[MESH_BINARY_EXTENSION] = {
+            meshBinaryAssociations: []
+        };
+    }
+}
+
+function removeBinaryAssociation(glbArrayBuffer, gltf, associations, existingAssociationIndex, meshIndex) {
+    console.log(`Removing binary association for mesh ${meshIndex}`);
+    associations.splice(existingAssociationIndex, 1);
+    
+    if (associations.length === 0) {
+        delete gltf.extensions[MESH_BINARY_EXTENSION];
+        
+        if (Object.keys(gltf.extensions).length === 0) {
+            delete gltf.extensions;
+        }
+    }
+    
+    const newJsonString = JSON.stringify(gltf);
+    const newJsonBytes = new TextEncoder().encode(newJsonString);
+    
+    return updateGlbJsonOnly(glbArrayBuffer, newJsonBytes);
+}
+
+function addOrUpdateBinaryAssociation(glbArrayBuffer, gltf, meshIndex, binaryData, existingAssociation, associations, chunkInfo) {
+    let bufferToUpdateIndex = -1;
+    
+    if (existingAssociation) {
+        bufferToUpdateIndex = existingAssociation[BINARY_DATA_PROPERTY];
+    } else {
+        bufferToUpdateIndex = gltf.buffers ? gltf.buffers.length : 0;
+        
+        associations.push({
+            [MESH_INDEX_PROPERTY]: meshIndex,
+            [BINARY_DATA_PROPERTY]: bufferToUpdateIndex
+        });
+    }
+    
+    if (!gltf.buffers) {
+        gltf.buffers = [];
+    }
+    
+    const exactByteLength = binaryData.byteLength;
+    const bufferLength = Math.ceil(exactByteLength / 4) * 4;
+    
+    if (bufferToUpdateIndex < gltf.buffers.length) {
+        gltf.buffers[bufferToUpdateIndex] = {
+            byteLength: exactByteLength
+        };
+        
+        delete gltf.buffers[bufferToUpdateIndex].uri;
+    } else {
+        gltf.buffers.push({
+            byteLength: exactByteLength
+        });
+    }
+    
+    return rebuildGLBWithBinaryData(glbArrayBuffer, gltf, bufferToUpdateIndex, binaryData, bufferLength, chunkInfo);
+}
+
+function rebuildGLBWithBinaryData(glbArrayBuffer, gltf, bufferToUpdateIndex, binaryData, bufferLength, chunkInfo) {
+    const newJsonString = JSON.stringify(gltf);
+    const newJsonBytes = new TextEncoder().encode(newJsonString);
+    
+    const paddedJsonLength = Math.ceil(newJsonBytes.length / 4) * 4;
+    const jsonPadding = paddedJsonLength - newJsonBytes.length;
+    
+    const existingBuffers = extractExistingBuffers(glbArrayBuffer, gltf, bufferToUpdateIndex, chunkInfo);
+    
+    let totalBinarySize = 0;
+    
+    for (const buf of existingBuffers) {
+        totalBinarySize += Math.ceil(buf.data.byteLength / 4) * 4;
+    }
+    
+    totalBinarySize += bufferLength;
+    
+    const newTotalSize = 
+        12 +
+        8 + paddedJsonLength +
+        8 + totalBinarySize;
+    
+    console.log(`New GLB total size: ${newTotalSize} bytes`);
+    console.log(`New binary chunk size: ${totalBinarySize} bytes`);
+    
+    return buildNewGLB(newTotalSize, newJsonBytes, paddedJsonLength, jsonPadding, totalBinarySize, existingBuffers, binaryData, bufferLength);
+}
+
+function extractExistingBuffers(glbArrayBuffer, gltf, excludeBufferIndex, chunkInfo) {
+    const dataView = new DataView(glbArrayBuffer);
+    const existingBuffers = [];
+    
+    if (chunkInfo.binaryChunkOffset + 8 <= dataView.byteLength) {
+        try {
+            const binaryChunkHeaderLength = dataView.getUint32(chunkInfo.binaryChunkOffset, true);
+            const binaryChunkType = dataView.getUint32(chunkInfo.binaryChunkOffset + 4, true);
+            
+            if (binaryChunkType === 0x004E4942) {
+                console.log(`Original binary chunk found: ${binaryChunkHeaderLength} bytes`);
+                
+                let currentOffset = 0;
+                
+                for (let i = 0; i < gltf.buffers.length; i++) {
+                    if (i === excludeBufferIndex) {
+                        continue;
+                    }
+                    
+                    if (gltf.buffers[i] && !hasBufferURI(gltf.buffers[i])) {
+                        const bufLen = gltf.buffers[i].byteLength;
+                        const paddedLen = Math.ceil(bufLen / 4) * 4;
+                        
+                        if (chunkInfo.binaryChunkOffset + 8 + currentOffset + bufLen <= dataView.byteLength) {
+                            const bufData = glbArrayBuffer.slice(
+                                chunkInfo.binaryChunkOffset + 8 + currentOffset,
+                                chunkInfo.binaryChunkOffset + 8 + currentOffset + bufLen
+                            );
+                            
+                            existingBuffers.push({
+                                index: i,
+                                data: bufData
+                            });
+                        }
+                        
+                        currentOffset += paddedLen;
+                    }
+                }
+            }
+        } catch (e) {
+            console.warn('Error extracting existing binary data:', e);
+        }
+    }
+    
+    return existingBuffers;
+}
+
+function extractBufferData(glbArrayBuffer, gltf, buffer, bufferIndex, chunkInfo) {
+    if (hasBufferURI(buffer)) {
+        if (isDataURI(buffer.uri)) {
+            const base64Data = buffer.uri.split(',')[1];
+            const binaryString = atob(base64Data);
+            const bytes = new Uint8Array(binaryString.length);
+            for (let i = 0; i < binaryString.length; i++) {
+                bytes[i] = binaryString.charCodeAt(i);
+            }
+            return bytes.buffer;
+        } else {
+            throw new Error('External URI buffers not supported');
+        }
+    } else {
+        return extractGLBBuffer(glbArrayBuffer, gltf, buffer, bufferIndex, chunkInfo);
+    }
+}
+
+function extractGLBBuffer(glbArrayBuffer, gltf, buffer, bufferIndex, chunkInfo) {
+    const dataView = new DataView(glbArrayBuffer);
+    
+    if (!validateBinaryChunk(dataView, chunkInfo.binaryChunkOffset)) {
+        console.log(`No binary chunk found at offset ${chunkInfo.binaryChunkOffset}`);
+        return null;
+    }
+    
+    let currentOffset = 0;
+    let foundBuffer = false;
+    
+    for (let i = 0; i < gltf.buffers.length; i++) {
+        if (i === bufferIndex) {
+            foundBuffer = true;
+            break;
+        }
+        
+        if (!hasBufferURI(gltf.buffers[i])) {
+            const bufferLength = gltf.buffers[i].byteLength;
+            const paddedLength = Math.ceil(bufferLength / 4) * 4;
+            currentOffset += paddedLength;
+        }
+    }
+    
+    if (!foundBuffer) {
+        console.warn(`Buffer index ${bufferIndex} exceeds buffer count`);
+        return null;
+    }
+    
+    const bufferStartOffset = chunkInfo.binaryChunkOffset + 8 + currentOffset;
+    const bufferEndOffset = bufferStartOffset + buffer.byteLength;
+    
+    if (bufferEndOffset > dataView.byteLength) {
+        console.warn(`Buffer extends beyond GLB file (${bufferEndOffset} > ${dataView.byteLength})`);
+        return null;
+    }
+    
+    console.log(`Extracting buffer at offset ${currentOffset} (${bufferStartOffset}-${bufferEndOffset})`);
+    return glbArrayBuffer.slice(bufferStartOffset, bufferEndOffset);
+}
+
+function buildNewGLB(newTotalSize, newJsonBytes, paddedJsonLength, jsonPadding, totalBinarySize, existingBuffers, binaryData, bufferLength) {
+    const newGlb = new ArrayBuffer(newTotalSize);
+    const newDataView = new DataView(newGlb);
+    const newUint8Array = new Uint8Array(newGlb);
+    
+    newDataView.setUint32(0, 0x46546C67, true);
+    newDataView.setUint32(4, 2, true);
+    newDataView.setUint32(8, newTotalSize, true);
+    
+    newDataView.setUint32(12, paddedJsonLength, true);
+    newDataView.setUint32(16, 0x4E4F534A, true);
+    
+    newUint8Array.set(newJsonBytes, 20);
+    
+    for (let i = 0; i < jsonPadding; i++) {
+        newUint8Array[20 + newJsonBytes.length + i] = 0x20;
+    }
+    
+    const newBinaryChunkOffset = 20 + paddedJsonLength;
+    
+    newDataView.setUint32(newBinaryChunkOffset, totalBinarySize, true);
+    newDataView.setUint32(newBinaryChunkOffset + 4, 0x004E4942, true);
+    
+    let currentBinaryOffset = newBinaryChunkOffset + 8;
+    
+    for (let i = 0; i < existingBuffers.length; i++) {
+        const buf = existingBuffers[i];
+        const bufArray = new Uint8Array(buf.data);
+        const paddedLength = Math.ceil(buf.data.byteLength / 4) * 4;
+        
+        newUint8Array.set(bufArray, currentBinaryOffset);
+        
+        const padding = paddedLength - buf.data.byteLength;
+        for (let j = 0; j < padding; j++) {
+            newUint8Array[currentBinaryOffset + buf.data.byteLength + j] = 0;
+        }
+        
+        currentBinaryOffset += paddedLength;
+    }
+    
+    if (binaryData && binaryData.byteLength > 0) {
+        const binaryArray = new Uint8Array(binaryData);
+        
+        newUint8Array.set(binaryArray, currentBinaryOffset);
+        
+        const padding = bufferLength - binaryData.byteLength;
+        for (let i = 0; i < padding; i++) {
+            newUint8Array[currentBinaryOffset + binaryData.byteLength + i] = 0;
+        }
+    }
+    
+    console.log('Successfully created new GLB with updated binary data');
+    return newGlb;
+}
+
+function updateGlbJsonOnly(glbArrayBuffer, newJsonBytes) {
+    const dataView = new DataView(glbArrayBuffer);
+    
+    const oldJsonChunkLength = dataView.getUint32(12, true);
+    
+    const jsonStart = 20;
+    const jsonEnd = jsonStart + oldJsonChunkLength;
+    
+    const binaryChunkOffset = jsonEnd;
+    let binaryChunkData = null;
+    
+    if (binaryChunkOffset + 8 <= dataView.byteLength) {
+        const binaryChunkHeaderLength = dataView.getUint32(binaryChunkOffset, true);
+        const binaryChunkType = dataView.getUint32(binaryChunkOffset + 4, true);
+        
+        if (binaryChunkType === 0x004E4942) {
+            binaryChunkData = glbArrayBuffer.slice(
+                binaryChunkOffset, 
+                binaryChunkOffset + 8 + binaryChunkHeaderLength
+            );
+        }
+    }
+    
+    const paddedJsonLength = Math.ceil(newJsonBytes.length / 4) * 4;
+    const jsonPadding = paddedJsonLength - newJsonBytes.length;
+    
+    const newTotalSize = 
+        12 +
+        8 + paddedJsonLength;
+    
+    const hasBinaryChunk = binaryChunkData !== null;
+    const finalSize = hasBinaryChunk ? newTotalSize + (binaryChunkData.byteLength) : newTotalSize;
+    
+    const newGlb = new ArrayBuffer(finalSize);
+    const newDataView = new DataView(newGlb);
+    const newUint8Array = new Uint8Array(newGlb);
+    
+    newDataView.setUint32(0, 0x46546C67, true);
+    newDataView.setUint32(4, 2, true);
+    newDataView.setUint32(8, finalSize, true);
+    
+    newDataView.setUint32(12, paddedJsonLength, true);
+    newDataView.setUint32(16, 0x4E4F534A, true);
+    
+    newUint8Array.set(newJsonBytes, 20);
+    
+    for (let i = 0; i < jsonPadding; i++) {
+        newUint8Array[20 + newJsonBytes.length + i] = 0x20;
+    }
+    
+    if (hasBinaryChunk) {
+        const newBinaryOffset = 20 + paddedJsonLength;
+        const binaryArray = new Uint8Array(binaryChunkData);
+        newUint8Array.set(binaryArray, newBinaryOffset);
+    }
+    
+    return newGlb;
+}

package/src/asset_debugger/util/data/glb-classifier.js

@@ -0,0 +1,290 @@
+import { deduplicateItemsByName } from "./duplicate-handler";
+
+export function validateGLBHeader(dataView) {
+    if (dataView.byteLength < 12) {
+        throw new Error('Invalid GLB: File too small');
+    }
+    
+    const magic = dataView.getUint32(0, true);
+    const expectedMagic = 0x46546C67;
+    if (magic !== expectedMagic) {
+        throw new Error('Invalid GLB: Incorrect magic bytes');
+    }
+    
+    const version = dataView.getUint32(4, true);
+    if (version !== 2) {
+        throw new Error(`Unsupported GLB version: ${version}`);
+    }
+}
+
+export function validateJSONChunk(dataView, jsonChunkLength) {
+    const jsonChunkType = dataView.getUint32(16, true);
+    
+    if (jsonChunkType !== 0x4E4F534A) {
+        throw new Error('Invalid GLB: First chunk is not JSON');
+    }
+    
+    const jsonStart = 20;
+    const jsonEnd = jsonStart + jsonChunkLength;
+    
+    if (jsonEnd > dataView.byteLength) {
+        throw new Error('Invalid GLB: JSON chunk extends beyond file size');
+    }
+}
+
+export function validateBinaryChunk(dataView, binaryChunkOffset) {
+    if (dataView.byteLength <= binaryChunkOffset + 8) {
+        return false;
+    }
+    
+    const binaryChunkType = dataView.getUint32(binaryChunkOffset + 4, true);
+    if (binaryChunkType !== 0x004E4942) {
+        throw new Error('Invalid GLB: Second chunk is not BIN');
+    }
+    
+    return true;
+}
+
+export function isRemovalOperation(binaryData) {
+    return !binaryData || binaryData.byteLength === 0;
+}
+
+export function hasExtension(gltf, extensionName) {
+    return gltf.extensions && gltf.extensions[extensionName];
+}
+
+export function hasBufferURI(buffer) {
+    return buffer.uri;
+}
+
+export function isDataURI(uri) {
+    return uri.startsWith('data:');
+}
+
+export function getChunkInfo(dataView) {
+    const jsonChunkLength = dataView.getUint32(12, true);
+    const jsonChunkType = dataView.getUint32(16, true);
+    
+    return {
+        jsonChunkLength,
+        jsonChunkType,
+        jsonStart: 20,
+        jsonEnd: 20 + jsonChunkLength,
+        binaryChunkOffset: 20 + jsonChunkLength
+    };
+}
+
+/**
+ * Analyze the rig data in a GLTF model
+ * @param {Object} gltf - The loaded GLTF model data
+ * @returns {Object} Analyzed rig details
+ */
+export function analyzeGltfModel(gltf) {
+    console.log('analyzeGltfModel called with:', gltf);
+    
+    if (!gltf || !gltf.scene) {
+        console.error('Invalid GLTF model:', gltf);
+        return null;
+    }
+    
+    console.log('Analyzing GLTF model for rig information...');
+    console.log('GLTF scene structure:', gltf.scene);
+    
+    const rawDetails = {
+        bones: [],
+        rigs: [],
+        roots: [],
+        controls: [],
+        joints: [],
+        constraints: [] // Add a new array to track constraints
+    };
+    
+    // Extract scene information
+    const scene = gltf.scene;
+    
+    // Helper function to traverse the scene
+    const traverseNode = (node, parentType = null) => {       
+        // Look for joint constraints in this node
+        const constraints = parseJointConstraints(node);
+        if (constraints) {
+            rawDetails.constraints.push({
+                nodeName: node.name,
+                nodeType: node.type,
+                constraintType: constraints.type,
+                constraintData: constraints
+            });
+        }
+        
+        // Check if the node is a bone
+        if (node.isBone || node.name.toLowerCase().includes('bone')) {
+            rawDetails.bones.push({
+                name: node.name,
+                position: node.position ? [node.position.x, node.position.y, node.position.z] : null,
+                rotation: node.rotation ? [node.rotation.x, node.rotation.y, node.rotation.z] : null,
+                parentName: parentType === 'bone' ? node.parent.name : null,
+                constraintType: constraints ? constraints.type : 'none' // Add constraint type
+            });
+            parentType = 'bone';
+        }
+        
+        // Check if the node is a rig
+        if (node.name.toLowerCase().includes('rig') || node.name.toLowerCase().includes('armature')) {
+            rawDetails.rigs.push({
+                name: node.name,
+                position: node.position ? [node.position.x, node.position.y, node.position.z] : null,
+                childCount: node.children ? node.children.length : 0
+            });
+            parentType = 'rig';
+        }
+        
+        // Check if the node is a root
+        if (node.name.toLowerCase().includes('root')) {
+            rawDetails.roots.push({
+                name: node.name,
+                position: node.position ? [node.position.x, node.position.y, node.position.z] : null
+            });
+            parentType = 'root';
+        }
+        
+        // Check if the node is a control/handle
+        if (node.name.toLowerCase().includes('control') || 
+            node.name.toLowerCase().includes('ctrl') || 
+            node.name.toLowerCase().includes('handle')) {
+            rawDetails.controls.push({
+                name: node.name,
+                position: node.position ? [node.position.x, node.position.y, node.position.z] : null,
+                type: node.name.toLowerCase().includes('control') ? 'control' : 
+                      node.name.toLowerCase().includes('ctrl') ? 'ctrl' : 'handle'
+            });
+            parentType = 'control';
+        }
+        
+        // Traverse children
+        if (node.children) {
+            node.children.forEach(child => traverseNode(child, parentType));
+        }
+    };
+    
+    // Start traversal from the scene
+    scene.traverse(node => traverseNode(node));
+    
+    // Process raw details to deduplicate items
+    const result = {
+        bones: deduplicateItemsByName(rawDetails.bones),
+        rigs: deduplicateItemsByName(rawDetails.rigs),
+        roots: deduplicateItemsByName(rawDetails.roots),
+        controls: deduplicateItemsByName(rawDetails.controls),
+        joints: deduplicateItemsByName(rawDetails.joints),
+        constraints: rawDetails.constraints // Don't deduplicate constraints
+    };
+    
+    console.log('Rig analysis results:', result);
+    return result;
+}
+
+/**
+ * Parse joint constraint data from node extras or userData
+ * @param {Object} node - Bone/joint node to examine
+ * @returns {Object|null} - Constraint data if found, null otherwise
+ */
+export function parseJointConstraints(node) {   
+    // Initialize constraint object
+    let constraints = null;
+    
+    // Check for constraints in userData
+    if (node.userData) {
+        // Look for Blender constraint data in userData
+        if (node.userData.constraints || node.userData.boneConstraints) {
+            constraints = node.userData.constraints || node.userData.boneConstraints;
+            return constraints;
+        }
+        
+        // Check for limit_rotation type constraints
+        if (node.userData.limitRotation || node.userData.rotationLimits) {
+            constraints = {
+                type: 'limitRotation',
+                limits: node.userData.limitRotation || node.userData.rotationLimits
+            };
+            return constraints;
+        }
+    }
+    
+    // Look for GLTF extras (where custom data is often stored)
+    if (node.extras) {
+        if (node.extras.constraints || node.extras.jointType) {
+            constraints = node.extras.constraints || { type: node.extras.jointType };
+            return constraints;
+        }
+    }
+    
+    // Infer constraints from bone properties
+    // Check if bone has locked rotation axes
+    if (node.rotation && node.userData.initialRotation) {
+        // Look for zero initial rotations that might indicate locked axes
+        const lockedAxes = [];
+        const epsilon = 0.0001; // Small threshold for floating point comparison
+        
+        if (Math.abs(node.userData.initialRotation.x) < epsilon) lockedAxes.push('x');
+        if (Math.abs(node.userData.initialRotation.y) < epsilon) lockedAxes.push('y');
+        if (Math.abs(node.userData.initialRotation.z) < epsilon) lockedAxes.push('z');
+        
+        // If we have 2+ locked axes, this might be a hinge joint
+        if (lockedAxes.length >= 2) {
+            const freeAxis = ['x', 'y', 'z'].find(axis => !lockedAxes.includes(axis));
+            if (freeAxis) {
+                constraints = {
+                    type: 'hinge',
+                    axis: freeAxis
+                };
+                return constraints;
+            }
+        }
+        
+        // If all axes are locked, this might be a fixed joint
+        if (lockedAxes.length === 3) {
+            constraints = {
+                type: 'fixed'
+            };
+            return constraints;
+        }
+    }
+    
+    // Check naming conventions that might indicate constraint types
+    const lowerName = node.name.toLowerCase();
+    if (lowerName.includes('fixed') || lowerName.includes('rigid')) {
+        constraints = {
+            type: 'fixed'
+        };
+        return constraints;
+    }
+    
+    if (lowerName.includes('hinge') || lowerName.includes('elbow') || lowerName.includes('knee')) {
+        // Default to Y axis for hinge if not specified
+        constraints = {
+            type: 'hinge',
+            axis: lowerName.includes('_x') ? 'x' : (lowerName.includes('_z') ? 'z' : 'y')
+        };
+        return constraints;
+    }
+    
+    if (lowerName.includes('spring') || lowerName.includes('bounce')) {
+        constraints = {
+            type: 'spring',
+            stiffness: 50,  // Default stiffness
+            damping: 5      // Default damping
+        };
+        return constraints;
+    }
+    
+    // No constraints found
+    return null;
+}
+
+// TODO Create a function for determining if a glb has a display mesh
+
+// TODO Create a function for getting the mesh index of the display mesh
+
+// TODO Create a function that calls the two above and then uses that info to get the binary buffer for the display mesh
+//          Then checks to see if Rig Control Node is true in the buffer
+//          If it is calls new method to make the display mesh a control node
+//              Stub it out for now that will be next task