action-engine-js 1.0.0

package/actionengine/math/geometry/modelcodegenerator.js

@@ -0,0 +1,97 @@
+// actionengine/math/geometry/modelcodegenerator.js
+
+/**
+ * ModelCodeGenerator converts GLB models into ActionEngine Triangle-based code.
+ * This outputs ActionEngine Model Format - clean Triangle[] code instead of base64.
+ */
+class ModelCodeGenerator {
+    
+    /**
+     * Generate ActionEngine Triangle code from GLB file
+     * @param {string} base64Data - GLB file as base64 string
+     * @param {string} modelName - Name for the generated function
+     * @param {Object} options - Generation options
+     * @returns {string} Complete JavaScript code for the model
+     */
+    static generateFromGLB(base64Data, modelName = null, options = {}) {
+        // Generate generic name if none provided
+        if (!modelName) {
+            const timestamp = Date.now().toString(36);
+            modelName = `Model_${timestamp}`;
+        }
+        
+        try {
+            // Load GLB model using ActionEngine GLBLoader
+            const glbModel = GLBLoader.loadModel(base64Data);
+            
+            // Generate Triangle-based code directly from GLB triangles
+            return ModelCodeGenerator.generateTriangleCode(glbModel.triangles, modelName, options);
+        } catch (error) {
+            console.error('ActionEngine model code generation failed:', error);
+            throw error;
+        }
+    }
+    
+    /**
+     * Generate ActionEngine Triangle code from Triangle array
+     * @param {Triangle[]} triangles - Array of Triangle objects
+     * @param {string} modelName - Function name for the model
+     * @param {Object} options - Code generation options
+     * @returns {string} Complete JavaScript function code
+     */
+    static generateTriangleCode(triangles, modelName, options = {}) {
+        const timestamp = new Date().toISOString();
+        
+        let code = `// Generated ActionEngine Model: ${modelName}\n`;
+        code += `// Created: ${timestamp}\n`;
+        code += `createTriangles() {\n`;
+        code += `    return [\n`;
+        
+        triangles.forEach((triangle, i) => {
+            const v1 = triangle.vertices[0];
+            const v2 = triangle.vertices[1];
+            const v3 = triangle.vertices[2];
+            const color = triangle.color || "#808080";
+            
+            code += `        new Triangle(\n`;
+            code += `            new Vector3(${v1.x.toFixed(6)}, ${v1.y.toFixed(6)}, ${v1.z.toFixed(6)}),\n`;
+            code += `            new Vector3(${v2.x.toFixed(6)}, ${v2.y.toFixed(6)}, ${v2.z.toFixed(6)}),\n`;
+            code += `            new Vector3(${v3.x.toFixed(6)}, ${v3.y.toFixed(6)}, ${v3.z.toFixed(6)}),\n`;
+            code += `            "${color}"\n`;
+            code += `        )${i < triangles.length - 1 ? ',' : ''}\n`;
+        });
+        
+        code += `    ];\n`;
+        code += `}\n`;
+        
+        return code;
+    }
+    
+    /**
+     * Export Triangle code as downloadable file
+     * @param {Triangle[]} triangles - Array of Triangle objects
+     * @param {string} modelName - Name for the model
+     */
+    static exportTriangleCode(triangles, modelName) {
+        const code = ModelCodeGenerator.generateTriangleCode(triangles, modelName);
+        
+        // Download the file
+        const blob = new Blob([code], { type: 'text/javascript' });
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement('a');
+        a.href = url;
+        a.download = `${modelName}.js`;
+        a.click();
+        URL.revokeObjectURL(url);
+    }
+    
+    /**
+     * Export GLB model as ActionEngine Triangle code
+     * @param {string} base64Data - GLB file as base64 string
+     * @param {string} modelName - Name for the model
+     */
+    static exportGLBAsCode(base64Data, modelName) {
+        const glbModel = GLBLoader.loadModel(base64Data);
+        ModelCodeGenerator.exportTriangleCode(glbModel.triangles, modelName);
+    }
+}

package/actionengine/math/geometry/triangle.js

@@ -0,0 +1,33 @@
+// actionengine/math/geometry/triangle.js
+class Triangle {
+    constructor(v1, v2, v3, color = "#FF00FF", texture = null, uvs = null) {
+        this.vertices = [v1, v2, v3];
+        this.normal = this.calculateNormal();
+        this.color = color;  // Default to magenta
+        this.texture = texture;
+        this.uvs = uvs;
+    }
+
+    calculateNormal() {
+        const edge1 = this.vertices[1].sub(this.vertices[0]);
+        const edge2 = this.vertices[2].sub(this.vertices[0]);
+        return edge1.cross(edge2).normalize();
+    }
+
+    getVertexArray() {
+        return this.vertices.flatMap((v) => [v.x, v.y, v.z]);
+    }
+
+    getNormalArray() {
+        return [...this.normal.toArray(), ...this.normal.toArray(), ...this.normal.toArray()];
+    }
+    
+    getColorArray() {
+        // Convert hex color to RGB array
+        const r = parseInt(this.color.substr(1, 2), 16) / 255;
+        const g = parseInt(this.color.substr(3, 2), 16) / 255;
+        const b = parseInt(this.color.substr(5, 2), 16) / 255;
+        // Return color for all three vertices
+        return [r, g, b, r, g, b, r, g, b];
+    }
+}

package/actionengine/math/geometry/triangleutils.js

@@ -0,0 +1,34 @@
+// actionengine/math/geometry/triangleutils.js
+class TriangleUtils {
+	static interpolateZ(x, y, p1, p2, p3) {
+		const denominator = (p2.y - p3.y) * (p1.x - p3.x) + (p3.x - p2.x) * (p1.y - p3.y);
+		if (Math.abs(denominator) < 0.0001) {
+			return (p1.z + p2.z + p3.z) / 3;
+		}
+		const w1 = ((p2.y - p3.y) * (x - p3.x) + (p3.x - p2.x) * (y - p3.y)) / denominator;
+		const w2 = ((p3.y - p1.y) * (x - p3.x) + (p1.x - p3.x) * (y - p3.y)) / denominator;
+		const w3 = 1 - w1 - w2;
+		return w1 * p1.z + w2 * p2.z + w3 * p3.z;
+	}
+
+	static pointInTriangle(p, v1, v2, v3) {
+		const d1 = (p.x - v2.x) * (v1.y - v2.y) - (v1.x - v2.x) * (p.y - v2.y);
+		const d2 = (p.x - v3.x) * (v2.y - v3.y) - (v2.x - v3.x) * (p.y - v3.y);
+		const d3 = (p.x - v1.x) * (v3.y - v1.y) - (v3.x - v1.x) * (p.y - v1.y);
+		const hasNeg = d1 < 0 || d2 < 0 || d3 < 0;
+		const hasPos = d1 > 0 || d2 > 0 || d3 > 0;
+		return !(hasNeg && hasPos);
+	}
+
+	static isFrontFacing(p1, p2, p3) {
+		return (p2.x - p1.x) * (p3.y - p1.y) - (p3.x - p1.x) * (p2.y - p1.y) < 0;
+	}
+
+	static getBarycentricCoords(x, y, p1, p2, p3) {
+		const denominator = (p2.y - p3.y) * (p1.x - p3.x) + (p3.x - p2.x) * (p1.y - p3.y);
+		const w1 = ((p2.y - p3.y) * (x - p3.x) + (p3.x - p2.x) * (y - p3.y)) / denominator;
+		const w2 = ((p3.y - p1.y) * (x - p3.x) + (p1.x - p3.x) * (y - p3.y)) / denominator;
+		const w3 = 1 - w1 - w2;
+		return { w1, w2, w3 };
+	}
+}

package/actionengine/math/mathutils.js

@@ -0,0 +1,25 @@
+// actionengine/math/mathutils.js
+class MathUtils {
+    static clamp(value, min, max) {
+        return Math.min(Math.max(value, min), max);
+    }
+
+    static lerp(start, end, t) {
+        return start + (end - start) * t;
+    }
+
+    static sign(p, v1, v2) {
+        return (p.x - v2.x) * (v1.z - v2.z) - (v1.x - v2.x) * (p.z - v2.z);
+    }
+}
+
+class SeededRandom {
+    constructor(seed) {
+        this.seed = seed;
+    }
+    
+    next() {
+        this.seed = (this.seed * 16807) % 2147483647;
+        return (this.seed - 1) / 2147483646;
+    }
+}