action-engine-js 1.0.0

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

@@ -0,0 +1,158 @@
+/**
+ * ActionPhysicsBox3D - 3D Box Physics Object with Single Color System
+ * 
+ * BREAKING CHANGE: Previously used rainbow faces by default.
+ * Now uses single green color system for consistency with other shapes.
+ * 
+ * @param {ActionPhysicsWorld3D} physicsWorld - The physics world
+ * @param {number} width - Box width (default: 10)
+ * @param {number} height - Box height (default: 10)
+ * @param {number} depth - Box depth (default: 10)
+ * @param {number} mass - Physics mass (default: 1)
+ * @param {Vector3} initialPosition - Starting position (default: 0,500,0)
+ * @param {string|Array} color - Single hex color "#228B22" or array of 6 colors for faces (default: "#228B22" green)
+ */
+class ActionPhysicsBox3D extends ActionPhysicsObject3D {
+    constructor(physicsWorld, width = 10, height = 10, depth = 10, mass = 1, 
+                initialPosition = new Vector3(0, 500, 0), color = "#228B22", options = {}) {
+        // Create visual mesh with triangles
+        const triangles = [];
+        
+        // Determine what colors to use
+        let faceColors;
+        
+        if (typeof color === 'string') {
+            // Single color for all faces (including default green)
+            faceColors = Array(6).fill(color);
+        } else if (Array.isArray(color)) {
+            // Array of colors provided - use them for corresponding faces
+            faceColors = color.slice(0, 6);
+            // Fill missing colors with first provided color or default green
+            const fillColor = color[0] || "#228B22";
+            while (faceColors.length < 6) {
+                faceColors.push(fillColor);
+            }
+        } else {
+            // Fallback to green for any other case
+            faceColors = Array(6).fill("#228B22");
+        }
+        
+        // Helper to create face vertices
+        const createFace = (v1, v2, v3, v4, faceIndex) => {
+            triangles.push(new Triangle(v1, v2, v3, faceColors[faceIndex]));
+            triangles.push(new Triangle(v1, v3, v4, faceColors[faceIndex]));
+        };
+
+        // Half dimensions for vertex creation
+        const hw = width / 2;
+        const hh = height / 2;
+        const hd = depth / 2;
+
+        // Create vertices for each face
+        const vertices = {
+            frontTopLeft:     new Vector3(-hw,  hh,  hd),
+            frontTopRight:    new Vector3( hw,  hh,  hd),
+            frontBottomRight: new Vector3( hw, -hh,  hd),
+            frontBottomLeft:  new Vector3(-hw, -hh,  hd),
+            backTopLeft:      new Vector3(-hw,  hh, -hd),
+            backTopRight:     new Vector3( hw,  hh, -hd),
+            backBottomRight:  new Vector3( hw, -hh, -hd),
+            backBottomLeft:   new Vector3(-hw, -hh, -hd)
+        };
+
+        // Create all six faces with their respective colors
+        // Front face
+        createFace(
+            vertices.frontBottomLeft,
+            vertices.frontBottomRight,
+            vertices.frontTopRight,
+            vertices.frontTopLeft,
+            0 // Index for front face color
+        );
+
+        // Back face
+        createFace(
+            vertices.backBottomRight,
+            vertices.backBottomLeft,
+            vertices.backTopLeft,
+            vertices.backTopRight,
+            1 // Index for back face color
+        );
+
+        // Top face
+        createFace(
+            vertices.frontTopLeft,
+            vertices.frontTopRight,
+            vertices.backTopRight,
+            vertices.backTopLeft,
+            2 // Index for top face color
+        );
+
+        // Bottom face
+        createFace(
+            vertices.frontBottomRight,
+            vertices.frontBottomLeft,
+            vertices.backBottomLeft,
+            vertices.backBottomRight,
+            3 // Index for bottom face color
+        );
+
+        // Right face
+        createFace(
+            vertices.frontBottomRight,
+            vertices.backBottomRight,
+            vertices.backTopRight,
+            vertices.frontTopRight,
+            4 // Index for right face color
+        );
+
+        // Left face
+        createFace(
+            vertices.backBottomLeft,
+            vertices.frontBottomLeft,
+            vertices.frontTopLeft,
+            vertices.backTopLeft,
+            5 // Index for left face color
+        );
+
+        super(physicsWorld, triangles, options);
+
+        // Create physics shape and body
+        const shape = new Goblin.BoxShape(width/2, height/2, depth/2);
+        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();
+        
+        // Set visibility flag
+        this.isVisible = options.isVisible !== undefined ? options.isVisible : true;
+    }
+
+    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/actionphysicscapsule3D.js

@@ -0,0 +1,200 @@
+// actionengine/math/physics/actionphysicscapsule3D.js
+/**
+ * ActionPhysicsCapsule3D - 3D Capsule Physics Object with Single Color System
+ * 
+ * BREAKING CHANGE: Previously used two-color checkerboard pattern (color1, color2).
+ * Now uses single color system for consistent developer experience.
+ * 
+ * IMPORTANT GEOMETRY CONSTRAINT:
+ * Total height MUST be greater than 2 × radius!
+ * 
+ * Why? A capsule = cylinder + 2 hemisphere caps
+ * - Cylinder height = total height - (2 × radius)
+ * - If total height < 2 × radius, cylinder height becomes negative = impossible!
+ * - This constraint is enforced by the Goblin physics library
+ * 
+ * @param {ActionPhysicsWorld3D} physicsWorld - The physics world
+ * @param {number} radius - Capsule radius (default: 2)
+ * @param {number} height - Total height including caps - MUST be > 2×radius (default: 10)
+ * @param {number} mass - Physics mass (default: 1)
+ * @param {Vector3} initialPosition - Starting position (default: 0,10,0)
+ * @param {string} color - Hex color string like "#FF0000" (default: "#E94B3C" red)
+ */
+class ActionPhysicsCapsule3D extends ActionPhysicsObject3D {
+    constructor(
+        physicsWorld,
+        radius = 2,
+        height = 10,
+        mass = 1,
+        initialPosition = new Vector3(0, 10, 0),
+        color = "#E94B3C"
+    ) {
+        // Create visual mesh with triangles using single color system
+        const triangles = [];
+        
+        // Calculate the cylinder height (total height minus the two hemisphere caps)
+        // This will be negative if height < 2*radius, causing physics library to throw error
+        const cylinderHeight = height - 2 * radius;
+        const halfCylinderHeight = cylinderHeight * 0.5;
+        
+        // Segments for mesh detail
+        const radialSegments = 12;
+        const heightSegments = 4;
+        const capSegments = 6;
+        
+        // Use single color for all triangles (no more checkerboard)
+        const capsuleColor = color;
+        
+        // Helper function to create cylinder and cap vertices
+        const createVertex = (theta, y, radius) => {
+            return new Vector3(
+                radius * Math.cos(theta),
+                y,
+                radius * Math.sin(theta)
+            );
+        };
+        
+        // 1. Create Cylinder Body - FIXED WINDING ORDER
+        for (let y = 0; y < heightSegments; y++) {
+            const yBottom = -halfCylinderHeight + (y / heightSegments) * cylinderHeight;
+            const yTop = -halfCylinderHeight + ((y + 1) / heightSegments) * cylinderHeight;
+            
+            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);
+                
+                // FIXED: Reversed winding order for outward-facing normals
+                triangles.push(new Triangle(v1, v3, v2, capsuleColor));
+                triangles.push(new Triangle(v1, v4, v3, capsuleColor));
+            }
+        }
+        
+        // 2. Create Top Hemisphere Cap - FIXED WINDING ORDER
+        const topCenter = new Vector3(0, halfCylinderHeight + radius, 0);
+        for (let y = 0; y < capSegments; y++) {
+            const phi = (y / capSegments) * (Math.PI / 2);
+            const phiNext = ((y + 1) / capSegments) * (Math.PI / 2);
+            
+            const radiusAtPhi = radius * Math.cos(phi);
+            const radiusAtPhiNext = radius * Math.cos(phiNext);
+            
+            const yAtPhi = halfCylinderHeight + radius * Math.sin(phi);
+            const yAtPhiNext = halfCylinderHeight + radius * Math.sin(phiNext);
+            
+            if (y === capSegments - 1) {
+                // Special case for the top pole
+                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, yAtPhi, radiusAtPhi);
+                    const v2 = createVertex(thetaNext, yAtPhi, radiusAtPhi);
+                    
+                    // FIXED: Reversed winding order for top pole triangles
+                    triangles.push(new Triangle(v1, topCenter, v2, capsuleColor));
+                }
+            } else {
+                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, yAtPhi, radiusAtPhi);
+                    const v2 = createVertex(thetaNext, yAtPhi, radiusAtPhi);
+                    const v3 = createVertex(thetaNext, yAtPhiNext, radiusAtPhiNext);
+                    const v4 = createVertex(theta, yAtPhiNext, radiusAtPhiNext);
+                    
+                    // FIXED: Reversed winding order for top hemisphere
+                    triangles.push(new Triangle(v1, v3, v2, capsuleColor));
+                    triangles.push(new Triangle(v1, v4, v3, capsuleColor));
+                }
+            }
+        }
+        
+        // 3. Create Bottom Hemisphere Cap - FIXED WINDING ORDER
+        const bottomCenter = new Vector3(0, -halfCylinderHeight - radius, 0);
+        for (let y = 0; y < capSegments; y++) {
+            const phi = (y / capSegments) * (Math.PI / 2);
+            const phiNext = ((y + 1) / capSegments) * (Math.PI / 2);
+            
+            const radiusAtPhi = radius * Math.cos(phi);
+            const radiusAtPhiNext = radius * Math.cos(phiNext);
+            
+            const yAtPhi = -halfCylinderHeight - radius * Math.sin(phi);
+            const yAtPhiNext = -halfCylinderHeight - radius * Math.sin(phiNext);
+            
+            if (y === capSegments - 1) {
+                // Special case for the bottom pole
+                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, yAtPhi, radiusAtPhi);
+                    const v2 = createVertex(thetaNext, yAtPhi, radiusAtPhi);
+                    
+                    // FIXED: Correct winding order for bottom pole
+                    triangles.push(new Triangle(v1, v2, bottomCenter, capsuleColor));
+                }
+            } else {
+                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, yAtPhi, radiusAtPhi);
+                    const v2 = createVertex(thetaNext, yAtPhi, radiusAtPhi);
+                    const v3 = createVertex(thetaNext, yAtPhiNext, radiusAtPhiNext);
+                    const v4 = createVertex(theta, yAtPhiNext, radiusAtPhiNext);
+                    
+                    // FIXED: Correct winding order for bottom hemisphere
+                    triangles.push(new Triangle(v1, v2, v3, capsuleColor));
+                    triangles.push(new Triangle(v1, v3, v4, capsuleColor));
+                }
+            }
+        }
+        
+        // Rest of constructor remains the same
+        super(physicsWorld, triangles);
+        
+        const shape = new Goblin.CapsuleShape(radius, height);
+        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/actionphysicscompoundshape3D.js

@@ -0,0 +1,147 @@
+class ActionPhysicsCompoundShape3D extends ActionPhysicsObject3D {
+    constructor(physicsWorld, initialPosition = new Vector3(0, 500, 0), mass = 1) {
+        // Start with an empty triangle list - we'll add them as child shapes are added
+        super(physicsWorld, []);
+        
+        // Create the Goblin compound shape
+        this.compoundShape = new Goblin.CompoundShape();
+        this.body = new Goblin.RigidBody(this.compoundShape, mass);
+        this.body.position.set(
+            initialPosition.x, 
+            initialPosition.y, 
+            initialPosition.z
+        );
+        
+        this.body.linear_damping = 0.01;
+        this.body.angular_damping = 0.01;
+        
+        // Keep track of the child objects
+        this.childObjects = [];
+        
+        // Store triangles from all children
+        this.allTriangles = [];
+    }
+    
+    // Add a child shape to the compound shape
+    addChildShape(physicsObject, position, rotation = new Goblin.Quaternion()) {
+        if (!physicsObject || !physicsObject.body || !physicsObject.body.shape) {
+            console.error("[ActionPhysicsCompoundShape3D] Cannot add invalid physics object");
+            return this;
+        }
+        
+        // Store the shape with its position and rotation
+        const childShape = physicsObject.body.shape;
+        const childPosition = new Goblin.Vector3(position.x, position.y, position.z);
+        
+        // Add the shape to the compound shape
+        this.compoundShape.addChildShape(childShape, childPosition, rotation);
+        
+        // Store the object and its transform information for visual updates
+        this.childObjects.push({
+            object: physicsObject,
+            position: new Vector3(position.x, position.y, position.z),
+            rotation: rotation
+        });
+        
+        // Get the triangles from the child object and transform them
+        const transformedTriangles = this.transformTriangles(
+            physicsObject.triangles,
+            position,
+            rotation
+        );
+        
+        // Add the transformed triangles to our collection
+        this.allTriangles.push(...transformedTriangles);
+        
+        // Update our triangle list
+        this.triangles = this.allTriangles.slice();
+        
+        // Update original data
+        this.storeOriginalData();
+        
+        return this;
+    }
+    
+    // Transform triangles from a child shape to the compound shape's space
+    transformTriangles(triangles, position, rotation) {
+        return triangles.map(triangle => {
+            // Create new transformed vertices
+            const transformedVertices = triangle.vertices.map(vertex => {
+                // First create a Goblin vector for the vertex
+                const goblinVec = new Goblin.Vector3(vertex.x, vertex.y, vertex.z);
+                
+                // Apply rotation
+                rotation.transformVector3(goblinVec);
+                
+                // Apply translation
+                goblinVec.x += position.x;
+                goblinVec.y += position.y;
+                goblinVec.z += position.z;
+                
+                // Convert back to Vector3
+                return new Vector3(goblinVec.x, goblinVec.y, goblinVec.z);
+            });
+            
+            // Create a new triangle with the transformed vertices
+            return new Triangle(
+                transformedVertices[0],
+                transformedVertices[1],
+                transformedVertices[2],
+                triangle.color
+            );
+        });
+    }
+    
+    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
+                ));
+            });
+        });
+    }
+}
+
+/* Usage example:
+const physicsWorld = new ActionPhysicsWorld3D();
+
+// Create a compound shape at position (0, 20, 0) with mass 5
+const compoundShape = new ActionPhysicsCompoundShape3D(
+    physicsWorld,
+    new Vector3(0, 20, 0),
+    5
+);
+
+// Create a sphere (without adding it to the world)
+const sphere = new ActionPhysicsSphere3D(
+    physicsWorld,
+    2,  // radius
+    1   // mass (this won't matter for the compound)
+);
+
+// Create a box (without adding it to the world)
+const box = new ActionPhysicsBox3D(
+    physicsWorld,
+    3, 3, 3,  // dimensions
+    1         // mass (this won't matter for the compound)
+);
+
+// Add the sphere and box to the compound shape
+compoundShape.addChildShape(sphere, new Vector3(0, 0, 0));
+compoundShape.addChildShape(box, new Vector3(0, 5, 0));
+
+// Add the compound shape to the physics world
+physicsWorld.addObject(compoundShape);
+*/

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

@@ -0,0 +1,126 @@
+// actionengine/math/physics/actionphysicscone3D.js
+/**
+ * ActionPhysicsCone3D - 3D Cone Physics Object with Single Color System
+ * 
+ * BREAKING CHANGE: Previously used two-color checkerboard pattern (color1, color2).
+ * Now uses single color system for consistency with other shapes.
+ * 
+ * @param {ActionPhysicsWorld3D} physicsWorld - The physics world
+ * @param {number} radius - Cone base radius (default: 2)
+ * @param {number} height - Cone height (default: 10)
+ * @param {number} mass - Physics mass (default: 1)
+ * @param {Vector3} initialPosition - Starting position (default: 0,10,0)
+ * @param {string} color - Hex color string like "#FF0000" (default: "#FFA500" orange)
+ */
+class ActionPhysicsCone3D extends ActionPhysicsObject3D {
+    constructor(
+        physicsWorld,
+        radius = 2,
+        height = 10,
+        mass = 1,
+        initialPosition = new Vector3(0, 10, 0),
+        color = "#FFA500"
+    ) {
+        // Create visual mesh with triangles using single color system
+        const triangles = [];
+        
+        // Segments for mesh detail
+        const radialSegments = 12;
+        const heightSegments = 6;
+        
+        // Use single color for all triangles (changed from checkerboard pattern)
+        const coneColor = color;
+        
+        // Helper function to create vertices
+        const createVertex = (theta, heightPercent, radiusPercent) => {
+            const currentRadius = radius * (1 - heightPercent) * radiusPercent;
+            return new Vector3(
+                currentRadius * Math.cos(theta),
+                height * (heightPercent - 0.5),  // Ranges from -half_height to half_height
+                currentRadius * Math.sin(theta)
+            );
+        };
+        
+        // 1. Create Cone Body
+        const tip = new Vector3(0, height/2, 0);
+        const base = new Vector3(0, -height/2, 0);
+        
+        // Create cone sides
+        for (let y = 0; y < heightSegments; y++) {
+            const yBottom = y / heightSegments;
+            const yTop = (y + 1) / heightSegments;
+            
+            for (let x = 0; x < radialSegments; x++) {
+                const theta = (x / radialSegments) * Math.PI * 2;
+                const thetaNext = ((x + 1) % radialSegments) / radialSegments * Math.PI * 2;
+                
+                if (y === heightSegments - 1) {
+                    // Top segment connects to tip
+                    const v1 = createVertex(theta, yBottom, 1);
+                    const v2 = createVertex(thetaNext, yBottom, 1);
+                    
+                    // Correct winding order for outward-facing normal
+                    triangles.push(new Triangle(v1, tip, v2, coneColor));
+                } else {
+                    // Regular segment
+                    const v1 = createVertex(theta, yBottom, 1);
+                    const v2 = createVertex(thetaNext, yBottom, 1);
+                    const v3 = createVertex(thetaNext, yTop, 1);
+                    const v4 = createVertex(theta, yTop, 1);
+                    
+                    // Correct winding order for outward-facing normals
+                    triangles.push(new Triangle(v1, v3, v2, coneColor));
+                    triangles.push(new Triangle(v1, v4, v3, coneColor));
+                }
+            }
+        }
+        
+        // 2. Create Base with correct winding order for downward-facing normal
+        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, 0, 1);
+            const v2 = createVertex(thetaNext, 0, 1);
+            
+            triangles.push(new Triangle(v1, v2, base, coneColor));
+        }
+        
+        super(physicsWorld, triangles);
+        
+        // Create physics shape and body - Goblin expects half-height
+        const shape = new Goblin.ConeShape(radius, height/2);
+        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
+                ));
+            });
+        });
+    }
+}