hyperstellar 0.1.73__tar.gz → 0.1.74__tar.gz

{hyperstellar-0.1.73 → hyperstellar-0.1.74}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperstellar
-Version: 0.1.73
+Version: 0.1.74
 Summary: GPU-accelerated physics simulation engine
 Author-email: Aiden Jabari <Jabariaiden15@email.com>
 License: MIT License

{hyperstellar-0.1.73 → hyperstellar-0.1.74}/hyperstellar/src/hyperstellar/_native/windows-x64/shaders/math.comp

@@ -1742,6 +1742,33 @@ void ageContacts(int objectIndex) {
     }
 }
 
+// Estimate world contact point between two objects after collision detection.
+// Uses shape types to give a reasonable point for torque calculation.
+vec2 getContactPoint(Object objA, Object objB, vec2 normal, float penetration) {
+    CollisionProperties propsA = collisionProps[gl_GlobalInvocationID.x];
+    int shapeA = propsA.shapeType;
+    float radiusA = objA.visualData.x;
+    vec2 halfExtA = objA.visualData.xy * 0.5;
+
+    // For circle: contact point is along normal at radius distance from centre
+    if (shapeA == COLLISION_CIRCLE) {
+        return objA.position - normal * radiusA;
+    }
+    // For AABB or polygon: estimate deepest point along normal
+    else if (shapeA == COLLISION_AABB || shapeA == COLLISION_POLYGON) {
+        // Approximate using the other object's AABB clamp method (from user snippet)
+        vec2 otherHalfExt = objB.visualData.xy * 0.5;
+        vec2 otherMin = objB.position - otherHalfExt;
+        vec2 otherMax = objB.position + otherHalfExt;
+        // Clamp object A's centre to object B's AABB - gives a point inside B
+        vec2 closest = clamp(objA.position, otherMin, otherMax);
+        return closest;
+    }
+    // Fallback: centre of object A
+    return objA.position;
+}
+
+
 // ============================================================================
 // MAIN COMPUTE SHADER ENTRY POINT - UPDATED WITH FIXED COLLISION RESOLUTION
 // ============================================================================
@@ -1866,7 +1893,7 @@ void main() {
     new_rotation = mod(new_rotation, 2.0 * PI);  // Wrap rotation
     
     // ========================================================================
-    // WORLD BOUNDARIES
+    // WORLD BOUNDARIES (UNCHANGED)
     // ========================================================================
     const vec2 world_min = vec2(-1000000.0, -1000000.0);
     const vec2 world_max = vec2(1000000.0, 1000000.0);
@@ -1900,131 +1927,124 @@ void main() {
     // CONSTRAINT RESOLUTION (UNCHANGED)
     // ========================================================================
     applyConstraints(new_pos, new_vel, objectIndex, originalPos);
-
-// ========================================================================
-// NEW: COLLISION SYSTEM - FIXED FOR PARALLEL EXECUTION
-// ========================================================================
-
-// Strategy:
-// 1. Each thread only modifies its OWN object's velocity
-// 2. Use impulses that conserve momentum without modifying other objects
-// 3. Position correction happens AFTER all velocity updates
-
-vec2 collision_vel = new_vel;
-bool had_collision = false;
-
-// Check collisions with ALL other objects (not just higher indices)
-for (int i = 0; i < uNumObjects; i++) {
-    if (i == objectIndex) continue;  // Skip self
-    
-    Object other = objectsIn[i];
     
-    // Detect collision
-    CollisionInfo collision = detectCollision(p, other, i);
-    
-    if (collision.hasCollision) {
-        had_collision = true;
-        
-        // Get collision properties
-        CollisionProperties propsA = collisionProps[objectIndex];
-        CollisionProperties propsB = collisionProps[i];
-        
-        // Calculate effective properties
-        float restitution = min(propsA.restitution, propsB.restitution);
-        float friction = sqrt(propsA.friction * propsB.friction);
+    // ========================================================================
+    // NEW COLLISION SYSTEM - ANTI-STICKING IMPULSE + TORQUE
+    // ========================================================================
+    vec2 collision_vel = new_vel;
+    bool had_collision = false;
+    
+    // Precompute inertia for torque (square plate approximation)
+    float halfW = p.visualData.x * 0.5;
+    float halfH = p.visualData.y * 0.5;
+    float inertia = mass * (halfW * halfW + halfH * halfH) / 6.0;
+    if (inertia < EPSILON) inertia = EPSILON;
+    float accumulated_torque = 0.0;
+    
+    // Check collisions with ALL other objects
+    for (int i = 0; i < uNumObjects; i++) {
+        if (i == objectIndex) continue;  // Skip self
         
-        // Get masses
-        float massA = mass;
-        float massB = max(EPSILON, other.mass);
+        Object other = objectsIn[i];
         
-        // Relative velocity
-        vec2 relativeVel = other.velocity - collision_vel;
-        float velocityAlongNormal = dot(relativeVel, collision.normal);
+        // Detect collision
+        CollisionInfo collision = detectCollision(p, other, i);
         
-        // Only resolve if moving toward each other
-        if (velocityAlongNormal < 0.0) {
-            // Calculate impulse (standard rigid body physics)
-            float e = clamp(restitution, 0.0, 1.0);
-            float j = -(1.0 + e) * velocityAlongNormal;
-            j /= (1.0 / massA + 1.0 / massB);
+        if (collision.hasCollision) {
+            had_collision = true;
+            
+            // Get collision properties
+            CollisionProperties propsA = collisionProps[objectIndex];
+            CollisionProperties propsB = collisionProps[i];
+            
+            // Calculate effective properties
+            float restitution = min(propsA.restitution, propsB.restitution);
+            float friction = sqrt(propsA.friction * propsB.friction);
             
-            // Apply impulse to THIS object only
-            vec2 impulse = j * collision.normal;
-            collision_vel -= impulse / massA;
+            // Get masses
+            float massA = mass;
+            float massB = max(EPSILON, other.mass);
             
-            // Friction
-            if (friction > 0.0) {
-                vec2 tangent = relativeVel - collision.normal * dot(relativeVel, collision.normal);
-                float tangentLength = length(tangent);
+            // Relative velocity
+            vec2 relativeVel = other.velocity - collision_vel;
+            float velocityAlongNormal = dot(relativeVel, collision.normal);
+            
+            // Only resolve if moving toward each other
+            if (velocityAlongNormal < 0.0) {
+                // Analytical impulse (symmetric, conserves momentum)
+                float e = clamp(restitution, 0.0, 1.0);
+                float j = -(1.0 + e) * velocityAlongNormal;
+                j /= (1.0 / massA + 1.0 / massB);
+                
+                // Apply impulse to THIS object only
+                vec2 impulse = j * collision.normal;
+                collision_vel += impulse / massA;   // Note: += because we subtract from relative velocity formula
                 
-                if (tangentLength > EPSILON) {
-                    tangent = normalize(tangent);
-                    float vt = dot(relativeVel, tangent);
-                    
-                    float jt = -vt * friction;
-                    jt /= (1.0 / massA + 1.0 / massB);
-                    
-                    // Coulomb friction limit
-                    float maxFriction = abs(j) * friction;
-                    jt = clamp(jt, -maxFriction, maxFriction);
-                    
-                    vec2 frictionImpulse = jt * tangent;
-                    collision_vel -= frictionImpulse / massA;
+                // Friction (Coulomb model)
+                vec2 friction_impulse = vec2(0.0);
+                if (friction > 0.0) {
+                    vec2 tangent = relativeVel - collision.normal * velocityAlongNormal;
+                    float tangentLength = length(tangent);
+                    if (tangentLength > EPSILON) {
+                        tangent = normalize(tangent);
+                        float vt = dot(relativeVel, tangent);
+                        float jt = -vt * friction;
+                        jt /= (1.0 / massA + 1.0 / massB);
+                        // Coulomb limit
+                        jt = clamp(jt, -abs(j) * friction, abs(j) * friction);
+                        friction_impulse = jt * tangent;
+                        collision_vel += friction_impulse / massA;
+                    }
                 }
+                
+                // ================================================================
+                // TORQUE CALCULATION (from contact point)
+                // ================================================================
+                vec2 contactPoint = getContactPoint(p, other, collision.normal, collision.penetration);
+                vec2 r = contactPoint - new_pos;   // lever arm from centre to contact
+                float torque_n = r.x * impulse.y - r.y * impulse.x;      // cross(r, impulse)
+                float torque_f = r.x * friction_impulse.y - r.y * friction_impulse.x;
+                accumulated_torque += (torque_n + torque_f) / inertia;
             }
-        }
-        
-        // POSITION CORRECTION - only for deep penetrations
-        // Move THIS object away from penetration
-        const float slop = 0.01;
-        const float percent = 0.4;  // Less aggressive than before
-        
-        if (collision.penetration > slop) {
-            float totalMass = massA + massB;
-            vec2 correction = collision.normal * (collision.penetration - slop) * percent;
             
-            // Only correct THIS object's position
-            // The correction is weighted by the inverse mass ratio
-            new_pos -= correction * (massB / totalMass);
+            // POSITION CORRECTION - mild, to reduce sticking
+            const float slop = 0.05;      // larger slop = less aggressive
+            const float percent = 0.2;    // smaller percent = softer correction
+            if (collision.penetration > slop) {
+                float totalMass = massA + massB;
+                vec2 correction = collision.normal * (collision.penetration - slop) * percent;
+                // Only correct THIS object's position, weighted by mass ratio
+                new_pos -= correction * (massB / totalMass);
+            }
         }
     }
-}
-
-// Apply collision-modified velocity
-if (had_collision) {
-    new_vel = sanitizeVec2(collision_vel);
-}
-
-// ========================================================================
-// REST OF CODE(boundaries, final write, etc.)
-// ========================================================================
     
-    // Age out old contacts for this object
-    if (uEnableWarmStart == 1) {
-        ageContacts(objectIndex);
+    // Apply collision-modified velocity and torque
+    if (had_collision) {
+        new_vel = sanitizeVec2(collision_vel);
+        new_angular_vel += accumulated_torque * uDt;
     }
     
-    // REMOVED: The second collision loop that was causing double-resolution
-    // We no longer need to check i < objectIndex because all pairs are
-    // processed exactly once in the loop above
-    
-    // Apply the collision-corrected state
-    new_pos = sanitizeVec2(new_pos);
-    new_vel = sanitizeVec2(new_vel);
+    // Clamp angular velocity for stability
+    const float maxOmega = 100.0;
+    new_angular_vel = clamp(new_angular_vel, -maxOmega, maxOmega);
+    new_rotation = mod(new_rotation, 2.0 * PI);
     
     // ========================================================================
     // FINAL SANITY CHECKS
     // ========================================================================
+    new_pos = sanitizeVec2(new_pos);
+    new_vel = sanitizeVec2(new_vel);
     
     // Ensure velocities aren't excessive
-    float maxSpeed = 1000.0;
+    float maxSpeed = 1000000.0;
     float currentSpeed = length(new_vel);
     if (currentSpeed > maxSpeed) {
         new_vel = normalize(new_vel) * maxSpeed;
     }
     
     // ========================================================================
-    // WRITE UPDATED OBJECT STATE 
+    // WRITE UPDATED OBJECT STATE
     // ========================================================================
     objectsOut[gid].position = new_pos;
     objectsOut[gid].velocity = new_vel;
@@ -2045,8 +2065,4 @@ if (had_collision) {
     objectsOut[gid]._pad1 = 0;
     objectsOut[gid]._padEnd[0] = 0;
     objectsOut[gid]._padEnd[1] = 0;
-}
-
-// ============================================================================
-// END OF RESEARCH-GRADE COLLISION SYSTEM
-// ============================================================================
+}

{hyperstellar-0.1.73 → hyperstellar-0.1.74}/hyperstellar/src/hyperstellar.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperstellar
-Version: 0.1.73
+Version: 0.1.74
 Summary: GPU-accelerated physics simulation engine
 Author-email: Aiden Jabari <Jabariaiden15@email.com>
 License: MIT License

{hyperstellar-0.1.73 → hyperstellar-0.1.74}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hyperstellar"
-version = "0.1.73"
+version = "0.1.74"
 description = "GPU-accelerated physics simulation engine"
 readme = "README.md"
 authors = [{name = "Aiden Jabari", email = "Jabariaiden15@email.com"}]
@@ -72,5 +72,6 @@ where = ["hyperstellar/src"]
 
 
 
+