hyperstellar 0.1.72__tar.gz → 0.1.74__tar.gz

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

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

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

@@ -1110,7 +1110,7 @@ void applyConstraints(inout vec2 pos, inout vec2 vel, int objectIndex, vec2 orig
 }
 
 // ============================================================================
-// COLLISION DETECTION FUNCTIONS
+// COLLISION DETECTION FUNCTIONS (UNCHANGED - KEEP YOUR EXISTING CODE)
 // ============================================================================
 
 // Circle-Circle collision detection
@@ -1387,72 +1387,6 @@ CollisionInfo detectCirclePolygon(vec2 circlePos, float circleRadius,
     return info;
 }
 
-// -------------------------------------------------------------------------
-// NEW: Exact AABB projection onto a SAT axis
-// Meant to replace approximate polygon projection for AABB shapes
-// -------------------------------------------------------------------------
-vec2 projectAABB(vec2 center, vec2 halfExt, vec2 axis)
-{
-    // Project the 4 AABB vertices efficiently using the half-extents
-    float centerProj = dot(center, axis);
-    float extent = abs(axis.x) * halfExt.x + abs(axis.y) * halfExt.y;
-    return vec2(centerProj - extent, centerProj + extent);
-}
-
-// -------------------------------------------------------------------------
-// NEW: AABB vs Polygon collision using a dedicated SAT that respects AABB axes
-// -------------------------------------------------------------------------
-CollisionInfo detectAABBPolygon(
-    vec2 posA, vec2 halfExtA,
-    vec2 posB, float radiusB, int sidesB, float rotB,
-    int objB)
-{
-    CollisionInfo info;
-    info.hasCollision = false;
-    info.otherObjectID = objB;
-    info.penetration = 1e10;
-
-    // AABB contributes 2 axes: X and Y
-    vec2 aabbAxes[2];
-    aabbAxes[0] = vec2(1.0, 0.0);
-    aabbAxes[1] = vec2(0.0, 1.0);
-
-    // Test AABB axes
-    for (int i = 0; i < 2; i++)
-    {
-        vec2 axis = aabbAxes[i];
-        vec2 projA = projectAABB(posA, halfExtA, axis);
-        vec2 projB = projectPolygon(posB, radiusB, sidesB, rotB, axis);
-        if (projA.y < projB.x || projB.y < projA.x)
-            return info;
-        float overlap = min(projA.y, projB.y) - max(projA.x, projB.x);
-        if (overlap < info.penetration) {
-            info.penetration = overlap;
-            info.normal = axis;
-            if (dot(posB - posA, axis) < 0.0) info.normal = -axis;
-        }
-    }
-
-    // Test polygon edge axes
-    for (int i = 0; i < sidesB; i++)
-    {
-        vec2 axis = getPolygonNormal(i, sidesB, rotB);
-        vec2 projA = projectAABB(posA, halfExtA, axis);
-        vec2 projB = projectPolygon(posB, radiusB, sidesB, rotB, axis);
-        if (projA.y < projB.x || projB.y < projA.x)
-            return info;
-        float overlap = min(projA.y, projB.y) - max(projA.x, projB.x);
-        if (overlap < info.penetration) {
-            info.penetration = overlap;
-            info.normal = axis;
-            if (dot(posB - posA, axis) < 0.0) info.normal = -axis;
-        }
-    }
-
-    info.hasCollision = true;
-    return info;
-}
-
 // Master collision detection dispatcher
 CollisionInfo detectCollision(Object objA, Object objB, int objIndexB)
 {
@@ -1506,11 +1440,13 @@ CollisionInfo detectCollision(Object objA, Object objB, int objIndexB)
     }
     else if (shapeA == COLLISION_AABB && shapeB == COLLISION_CIRCLE)
     {
+        // Swap roles and flip normal
         vec2 halfExtA = objA.visualData.xy * 0.5;
         info = detectCircleAABB(objB.position, objB.visualData.x,
                                objA.position, halfExtA, objIndexB);
         info.normal = -info.normal; // Flip normal
     }
+    // Circle vs Polygon
     else if (shapeA == COLLISION_CIRCLE && shapeB == COLLISION_POLYGON)
     {
         info = detectCirclePolygon(objA.position, objA.visualData.x,
@@ -1526,29 +1462,28 @@ CollisionInfo detectCollision(Object objA, Object objB, int objIndexB)
                                    objIndexB);
         info.normal = -info.normal; // Flip normal
     }
-    // AABB vs Polygon (corrected)
+    // AABB vs Polygon (simplified - treat polygon as circle for collision)
     else if (shapeA == COLLISION_AABB && shapeB == COLLISION_POLYGON)
     {
         vec2 halfExtA = objA.visualData.xy * 0.5;
-        info = detectAABBPolygon(objA.position, halfExtA,
-                                 objB.position, objB.visualData.x,
-                                 int(objB.visualData.y), objB.visualData.z,
-                                 objIndexB);
+        info = detectCircleAABB(objB.position, objB.visualData.x,
+                               objA.position, halfExtA, objIndexB);
+        info.normal = -info.normal; // Flip normal
     }
-    // Polygon vs AABB (corrected)
     else if (shapeA == COLLISION_POLYGON && shapeB == COLLISION_AABB)
     {
         vec2 halfExtB = objB.visualData.xy * 0.5;
-        info = detectAABBPolygon(objB.position, halfExtB,
-                                 objA.position, objA.visualData.x,
-                                 int(objA.visualData.y), objA.visualData.z,
-                                 objIndexB);
-        info.normal = -info.normal;
+        info = detectCircleAABB(objA.position, objA.visualData.x,
+                               objB.position, halfExtB, objIndexB);
     }
     
     return info;
 }
 
+// ============================================================================
+// NEW: RESEARCH-GRADE COLLISION RESOLUTION SYSTEM
+// ============================================================================
+
 // ============================================================================
 // BASIC COLLISION RESPONSE (Momentum-Conserving)
 // ============================================================================
@@ -1807,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
 // ============================================================================
@@ -1931,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);
@@ -1965,127 +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);
+            
+            // Get masses
+            float massA = mass;
+            float massB = max(EPSILON, other.mass);
             
-            // Apply impulse to THIS object only
-            vec2 impulse = j * collision.normal;
-            collision_vel -= impulse / massA;
+            // Relative velocity
+            vec2 relativeVel = other.velocity - collision_vel;
+            float velocityAlongNormal = dot(relativeVel, collision.normal);
             
-            // Friction
-            if (friction > 0.0) {
-                vec2 tangent = relativeVel - collision.normal * dot(relativeVel, collision.normal);
-                float tangentLength = length(tangent);
+            // 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);
                 
-                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;
+                // Apply impulse to THIS object only
+                vec2 impulse = j * collision.normal;
+                collision_vel += impulse / massA;   // Note: += because we subtract from relative velocity formula
+                
+                // 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;
     }
     
-    // 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;

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

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

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

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