action-engine-js 1.0.0

package/actionengine/math/physics/shapes/actionphysicsconvexshape3D.js

@@ -0,0 +1,72 @@
+class ActionPhysicsConvexShape3D extends ActionPhysicsObject3D {
+    constructor(physicsWorld, vertices, mass = 1, initialPosition = new Vector3(0, 500, 0), colors = []) {
+        // Convert input vertices to Goblin.Vector3 for physics
+        const goblinVertices = vertices.map(v => new Goblin.Vector3(v.x, v.y, v.z));
+        
+        // Create the Goblin physics shape first, so we can access its faces
+        const goblinShape = new Goblin.ConvexShape(goblinVertices);
+        
+        // Default colors if none provided
+        const defaultColors = [
+            "#FF5733", // Coral
+            "#F9A826", // Orange
+            "#6A0572", // Purple
+            "#4D89E5", // Blue
+            "#2E8B57"  // SeaGreen
+        ];
+        
+        // Create triangles based on the actual faces of the convex hull
+        const triangles = [];
+        
+        // Each face in the Goblin shape is a triangular face of the convex hull
+        goblinShape.faces.forEach((face, index) => {
+            // Get the vertices of this face
+            const v1 = new Vector3(face.a.point.x, face.a.point.y, face.a.point.z);
+            const v2 = new Vector3(face.b.point.x, face.b.point.y, face.b.point.z);
+            const v3 = new Vector3(face.c.point.x, face.c.point.y, face.c.point.z);
+            
+            // Choose a color for this face
+            const color = colors[index % colors.length] || defaultColors[index % defaultColors.length];
+            
+            // Create a triangle with the vertices of this face
+            triangles.push(new Triangle(v1, v2, v3, color));
+        });
+        
+        // Pass triangles to parent constructor
+        super(physicsWorld, triangles);
+
+        // Create the rigid body
+        this.body = new Goblin.RigidBody(goblinShape, mass);
+        this.body.position.set(
+            initialPosition.x,
+            initialPosition.y,
+            initialPosition.z
+        );
+
+        this.body.linear_damping = 0.01;
+        this.body.angular_damping = 0.01;
+
+        this.storeOriginalData();
+    }
+
+    storeOriginalData() {
+        this.originalNormals = [];
+        this.originalVerts = [];
+        
+        this.triangles.forEach((triangle) => {
+            this.originalNormals.push(new Vector3(
+                triangle.normal.x,
+                triangle.normal.y,
+                triangle.normal.z
+            ));
+            
+            triangle.vertices.forEach((vertex) => {
+                this.originalVerts.push(new Vector3(
+                    vertex.x,
+                    vertex.y,
+                    vertex.z
+                ));
+            });
+        });
+    }
+}

package/actionengine/math/physics/shapes/actionphysicscylinder3D.js

@@ -0,0 +1,117 @@
+// actionengine/math/physics/actionphysicscylinder3D.js
+class ActionPhysicsCylinder3D extends ActionPhysicsObject3D {
+    constructor(
+        physicsWorld,
+        radius = 2,
+        height = 10,
+        mass = 1,
+        initialPosition = new Vector3(0, 10, 0),
+        color1 = "#FF0000",
+        color2 = "#0000FF"
+    ) {
+        // Create visual mesh with triangles
+        const triangles = [];
+        
+        // Segments for mesh detail
+        const radialSegments = 12;
+        const heightSegments = 4;
+        
+        // Helper function to create cylinder vertices
+        const createVertex = (theta, y, radius) => {
+            return new Vector3(
+                radius * Math.cos(theta),
+                y,
+                radius * Math.sin(theta)
+            );
+        };
+        
+        // Helper to alternate colors for triangle checkerboard pattern
+        const getColor = (x, y) => ((x + y) % 2 === 0) ? color1 : color2;
+        
+        const halfHeight = height / 2;
+        
+        // 1. Create Cylinder Body
+        for (let y = 0; y < heightSegments; y++) {
+            const yBottom = -halfHeight + (y / heightSegments) * height;
+            const yTop = -halfHeight + ((y + 1) / heightSegments) * height;
+            
+            for (let x = 0; x < radialSegments; x++) {
+                const theta = (x / radialSegments) * Math.PI * 2;
+                const thetaNext = ((x + 1) % radialSegments) / radialSegments * Math.PI * 2;
+                
+                // Create four vertices for this quad segment
+                const v1 = createVertex(theta, yBottom, radius);
+                const v2 = createVertex(thetaNext, yBottom, radius);
+                const v3 = createVertex(thetaNext, yTop, radius);
+                const v4 = createVertex(theta, yTop, radius);
+                
+                // Create two triangles with outward-facing normals
+                triangles.push(new Triangle(v1, v3, v2, getColor(x, y)));
+                triangles.push(new Triangle(v1, v4, v3, getColor(x, y)));
+            }
+        }
+        
+        // 2. Create Top Cap
+        const topCenter = new Vector3(0, halfHeight, 0);
+        for (let x = 0; x < radialSegments; x++) {
+            const theta = (x / radialSegments) * Math.PI * 2;
+            const thetaNext = ((x + 1) % radialSegments) / radialSegments * Math.PI * 2;
+            
+            const v1 = createVertex(theta, halfHeight, radius);
+            const v2 = createVertex(thetaNext, halfHeight, radius);
+            
+            // Create triangle with upward-facing normal
+            triangles.push(new Triangle(v1, topCenter, v2, getColor(x, heightSegments)));
+        }
+        
+        // 3. Create Bottom Cap
+        const bottomCenter = new Vector3(0, -halfHeight, 0);
+        for (let x = 0; x < radialSegments; x++) {
+            const theta = (x / radialSegments) * Math.PI * 2;
+            const thetaNext = ((x + 1) % radialSegments) / radialSegments * Math.PI * 2;
+            
+            const v1 = createVertex(theta, -halfHeight, radius);
+            const v2 = createVertex(thetaNext, -halfHeight, radius);
+            
+            // Create triangle with downward-facing normal
+            triangles.push(new Triangle(v1, v2, bottomCenter, getColor(x, heightSegments + 1)));
+        }
+        
+        super(physicsWorld, triangles);
+        
+        // Create physics shape and body
+        const shape = new Goblin.CylinderShape(radius, halfHeight);
+        this.body = new Goblin.RigidBody(shape, mass);
+        this.body.position.set(
+            initialPosition.x,
+            initialPosition.y,
+            initialPosition.z
+        );
+        
+        this.body.linear_damping = 0.01;
+        this.body.angular_damping = 0.01;
+        
+        this.storeOriginalData();
+    }
+
+    storeOriginalData() {
+        this.originalNormals = [];
+        this.originalVerts = [];
+        
+        this.triangles.forEach((triangle) => {
+            this.originalNormals.push(new Vector3(
+                triangle.normal.x,
+                triangle.normal.y,
+                triangle.normal.z
+            ));
+            
+            triangle.vertices.forEach((vertex) => {
+                this.originalVerts.push(new Vector3(
+                    vertex.x,
+                    vertex.y,
+                    vertex.z
+                ));
+            });
+        });
+    }
+}

package/actionengine/math/physics/shapes/actionphysicsmesh3D.js

@@ -0,0 +1,74 @@
+// actionengine/math/physics/actionphysicsmesh3D.js
+class ActionPhysicsMesh3D extends ActionPhysicsObject3D {
+    constructor(
+        physicsWorld,
+        vertices,  // Array of Vector3 positions
+        indices,   // Array of indices forming triangles (groups of 3)
+        mass = 0,  // Default to static (0 = immovable)
+        initialPosition = new Vector3(0, 0, 0),
+        colors = null  // Optional array of colors for each triangle
+    ) {
+        // Create triangles from vertices and indices
+        const triangles = [];
+        
+        // Process indices in groups of 3 to form triangles
+        for (let i = 0; i < indices.length; i += 3) {
+            const v1 = vertices[indices[i]].clone();
+            const v2 = vertices[indices[i+1]].clone();
+            const v3 = vertices[indices[i+2]].clone();
+            
+            // Determine color for this triangle
+            let color = "#AAAAAA";  // Default gray
+            if (colors && colors[Math.floor(i/3)]) {
+                color = colors[Math.floor(i/3)];
+            } else if (colors && colors.length === 1) {
+                color = colors[0];
+            }
+            
+            triangles.push(new Triangle(v1, v2, v3, color));
+        }
+        
+        super(physicsWorld, triangles);
+        
+        // Convert vertices to Goblin.Vector3 for the physics engine
+        const goblinVertices = vertices.map(v => new Goblin.Vector3(v.x, v.y, v.z));
+        
+        // Create physics shape and body
+        const shape = new Goblin.MeshShape(goblinVertices, indices);
+        this.body = new Goblin.RigidBody(shape, mass);
+        this.body.position.set(
+            initialPosition.x,
+            initialPosition.y,
+            initialPosition.z
+        );
+        
+        // Set damping properties if it's not static
+        if (mass > 0) {
+            this.body.linear_damping = 0.01;
+            this.body.angular_damping = 0.01;
+        }
+        
+        this.storeOriginalData();
+    }
+
+    storeOriginalData() {
+        this.originalNormals = [];
+        this.originalVerts = [];
+        
+        this.triangles.forEach((triangle) => {
+            this.originalNormals.push(new Vector3(
+                triangle.normal.x,
+                triangle.normal.y,
+                triangle.normal.z
+            ));
+            
+            triangle.vertices.forEach((vertex) => {
+                this.originalVerts.push(new Vector3(
+                    vertex.x,
+                    vertex.y,
+                    vertex.z
+                ));
+            });
+        });
+    }
+}

package/actionengine/math/physics/shapes/actionphysicsplane3D.js

@@ -0,0 +1,100 @@
+class ActionPhysicsPlane3D extends ActionPhysicsObject3D {
+    constructor(
+    physicsWorld, 
+    orientation = 1, 
+    width = 100, 
+    length = 100, 
+    mass = 0, 
+    initialPosition = new Vector3(0, 0, 0),
+    normalDirection = 1,  // 1 = up/positive, -1 = down/negative
+    doubleSided = true    // Whether to create back-facing triangles
+) {
+    // Create visual mesh with triangles
+    const segments = 10; // Can be adjusted based on needed detail
+    const triangles = [];
+    const getColor = (x, z) => ((Math.floor(x) + Math.floor(z)) % 2 === 0) ? "#FFFFFF" : "#CCCCCC";
+    const getBackColor = (x, z) => ((Math.floor(x) + Math.floor(z)) % 2 === 0) ? "#DDDDDD" : "#999999";
+    
+    // Generate grid of vertices
+    for (let x = 0; x < segments; x++) {
+        for (let z = 0; z < segments; z++) {
+            const x1 = (x / segments - 0.5) * width;
+            const x2 = ((x + 1) / segments - 0.5) * width;
+            const z1 = (z / segments - 0.5) * length;
+            const z2 = ((z + 1) / segments - 0.5) * length;
+            
+            // Create vertices based on orientation
+            let v1, v2, v3, v4;
+            if (orientation === 0) { // YZ plane
+                v1 = new Vector3(0, x1, z1);
+                v2 = new Vector3(0, x2, z1);
+                v3 = new Vector3(0, x2, z2);
+                v4 = new Vector3(0, x1, z2);
+            } else if (orientation === 1) { // XZ plane (ground plane)
+                v1 = new Vector3(x1, 0, z1);
+                v2 = new Vector3(x2, 0, z1);
+                v3 = new Vector3(x2, 0, z2);
+                v4 = new Vector3(x1, 0, z2);
+            } else { // XY plane
+                v1 = new Vector3(x1, z1, 0);
+                v2 = new Vector3(x2, z1, 0);
+                v3 = new Vector3(x2, z2, 0);
+                v4 = new Vector3(x1, z2, 0);
+            }
+            
+            // Front-facing triangles (based on normalDirection)
+            if (normalDirection > 0) {
+                triangles.push(new Triangle(v1, v3, v2, getColor(x, z))); 
+                triangles.push(new Triangle(v1, v4, v3, getColor(x, z)));
+            } else {
+                triangles.push(new Triangle(v1, v2, v3, getColor(x, z)));
+                triangles.push(new Triangle(v1, v3, v4, getColor(x, z)));
+            }
+            
+            // Back-facing triangles (if doubleSided is true)
+            if (doubleSided) {
+                if (normalDirection > 0) {
+                    triangles.push(new Triangle(v1, v2, v3, getBackColor(x, z)));
+                    triangles.push(new Triangle(v1, v3, v4, getBackColor(x, z)));
+                } else {
+                    triangles.push(new Triangle(v1, v3, v2, getBackColor(x, z)));
+                    triangles.push(new Triangle(v1, v4, v3, getBackColor(x, z)));
+                }
+            }
+        }
+    }
+    
+    super(physicsWorld, triangles);
+    
+    const shape = new Goblin.PlaneShape(orientation, width/2, length/2);
+    this.body = new Goblin.RigidBody(shape, mass);
+    this.body.position.set(
+        initialPosition.x,
+        initialPosition.y,
+        initialPosition.z
+    );
+    
+    this.storeOriginalData();
+}
+
+    storeOriginalData() {
+        this.originalNormals = [];
+        this.originalVerts = [];
+        
+        this.triangles.forEach((triangle) => {
+            this.originalNormals.push(new Vector3(
+                triangle.normal.x,
+                triangle.normal.y,
+                triangle.normal.z
+            ));
+            
+            triangle.vertices.forEach((vertex) => {
+                this.originalVerts.push(new Vector3(
+                    vertex.x,
+                    vertex.y,
+                    vertex.z
+                ));
+            });
+        });
+    }
+}

package/actionengine/math/physics/shapes/actionphysicssphere3D.js

@@ -0,0 +1,95 @@
+// actionengine/math/physics/actionphysicssphere3D.js
+/**
+ * ActionPhysicsSphere3D - 3D Sphere Physics Object with Single Color System
+ * 
+ * BREAKING CHANGE: Previously used black/white checkerboard pattern.
+ * Now uses single color system for consistent developer experience.
+ * 
+ * @param {ActionPhysicsWorld3D} physicsWorld - The physics world
+ * @param {number} radius - Sphere radius (default: 5)
+ * @param {number} mass - Physics mass (default: 1)
+ * @param {Vector3} initialPosition - Starting position (default: 0,500,0)
+ * @param {string} color - Hex color string like "#FF0000" (default: "#FFFFFF" white)
+ */
+class ActionPhysicsSphere3D extends ActionPhysicsObject3D {
+    constructor(physicsWorld, radius = 5, mass = 1, initialPosition = new Vector3(0, 500, 0), color = "#FFFFFF") {
+        // Visual mesh creation with single color system
+        const segments = 8;
+        const triangles = [];
+        
+        // All triangles use the same color (changed from checkerboard pattern)
+        const sphereColor = color;
+        
+        const createVertex = (phi, theta) => new Vector3(
+            radius * Math.sin(phi) * Math.cos(theta),
+            radius * Math.cos(phi),
+            radius * Math.sin(phi) * Math.sin(theta)
+        );
+
+        // Sphere segments generation
+        for (let lat = 0; lat <= segments; lat++) {
+            const phi = (lat / segments) * Math.PI;
+            const nextPhi = ((lat + 1) / segments) * Math.PI;
+            for (let lon = 0; lon < segments; lon++) {
+                const theta = (lon / segments) * 2 * Math.PI;
+                const nextTheta = ((lon + 1) / segments) * 2 * Math.PI;
+                
+                if (lat === 0) {
+                    triangles.push(new Triangle(
+                        new Vector3(0, radius, 0),
+                        createVertex(Math.PI / segments, nextTheta),
+                        createVertex(Math.PI / segments, theta),
+                        sphereColor
+                    ));
+                } else if (lat === segments - 1) {
+                    triangles.push(new Triangle(
+                        new Vector3(0, -radius, 0),
+                        createVertex(Math.PI - Math.PI / segments, theta),
+                        createVertex(Math.PI - Math.PI / segments, nextTheta),
+                        sphereColor
+                    ));
+                } else {
+                    const v1 = createVertex(phi, theta);
+                    const v2 = createVertex(nextPhi, theta);
+                    const v3 = createVertex(nextPhi, nextTheta);
+                    const v4 = createVertex(phi, nextTheta);
+                    triangles.push(new Triangle(v1, v3, v2, sphereColor));
+                    triangles.push(new Triangle(v1, v4, v3, sphereColor));
+                }
+            }
+        }
+        
+        super(physicsWorld, triangles);
+
+        const shape = new Goblin.SphereShape(radius);
+        this.body = new Goblin.RigidBody(shape, mass);
+        this.body.position.set(
+            initialPosition.x,
+            initialPosition.y,
+            initialPosition.z
+        );
+        
+        this.body.linear_damping = 0.01;
+        this.body.angular_damping = 0.01;
+        
+        // Store original data for visual updates
+        this.originalNormals = [];
+        this.originalVerts = [];
+        
+        this.triangles.forEach((triangle) => {
+            this.originalNormals.push(new Vector3(
+                triangle.normal.x,
+                triangle.normal.y,
+                triangle.normal.z
+            ));
+            
+            triangle.vertices.forEach((vertex) => {
+                this.originalVerts.push(new Vector3(
+                    vertex.x,
+                    vertex.y,
+                    vertex.z
+                ));
+            });
+        });
+    }
+}

package/actionengine/math/quaternion.js

@@ -0,0 +1,61 @@
+// actionengine/math/quaternion.js
+class Quaternion {
+    constructor(x = 0, y = 0, z = 0, w = 1) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.w = w;
+    }
+
+    static fromAxisAngle(axis, angle) {
+        const halfAngle = angle * 0.5;
+        const s = Math.sin(halfAngle);
+        return new Quaternion(
+            axis.x * s,
+            axis.y * s,
+            axis.z * s,
+            Math.cos(halfAngle)
+        );
+    }
+
+    static fromEulerY(yAngle) {
+        const halfAngle = yAngle * 0.5;
+        return new Quaternion(
+            0,
+            Math.sin(halfAngle),
+            0,
+            Math.cos(halfAngle)
+        );
+    }
+
+    slerp(other, t) {
+        let cosHalfTheta = this.x * other.x + this.y * other.y + 
+                          this.z * other.z + this.w * other.w;
+
+        if (Math.abs(cosHalfTheta) >= 1.0) {
+            return this;
+        }
+
+        const halfTheta = Math.acos(cosHalfTheta);
+        const sinHalfTheta = Math.sqrt(1.0 - cosHalfTheta * cosHalfTheta);
+
+        if (Math.abs(sinHalfTheta) < 0.001) {
+            return new Quaternion(
+                this.x * 0.5 + other.x * 0.5,
+                this.y * 0.5 + other.y * 0.5,
+                this.z * 0.5 + other.z * 0.5,
+                this.w * 0.5 + other.w * 0.5
+            );
+        }
+
+        const ratioA = Math.sin((1 - t) * halfTheta) / sinHalfTheta;
+        const ratioB = Math.sin(t * halfTheta) / sinHalfTheta;
+
+        return new Quaternion(
+            this.x * ratioA + other.x * ratioB,
+            this.y * ratioA + other.y * ratioB,
+            this.z * ratioA + other.z * ratioB,
+            this.w * ratioA + other.w * ratioB
+        );
+    }
+}