hyperstellar 0.1.67__tar.gz → 0.1.69__tar.gz

{hyperstellar-0.1.67 → hyperstellar-0.1.69}/PKG-INFO

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

{hyperstellar-0.1.67 → hyperstellar-0.1.69}/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
@@ -1137,41 +1137,35 @@ CollisionInfo detectCircleCircle(vec2 posA, float radiusA, vec2 posB, float radi
     return info;
 }
 
-// Hybrid AABB detection: current positions for penetration, old positions for normal direction
-CollisionInfo detectAABBAABB(vec2 posA_curr, vec2 halfExtA, vec2 posB_curr, vec2 halfExtB,
-                             vec2 posA_old, vec2 posB_old, int objB)
+// Axis-Aligned Bounding Box collision detection
+CollisionInfo detectAABBAABB(vec2 posA, vec2 halfExtA, vec2 posB, vec2 halfExtB, int objB)
 {
     CollisionInfo info;
     info.hasCollision = false;
     info.otherObjectID = objB;
-
-    // Penetration uses CURRENT (predicted/selfNew) positions
-    vec2 delta_curr = posB_curr - posA_curr;
-    vec2 overlap = halfExtA + halfExtB - abs(delta_curr);
-
+    
+    // Calculate separation vector
+    vec2 delta = posB - posA;
+    vec2 overlap = halfExtA + halfExtB - abs(delta);
+    
+    // Check for overlap on both axes
     if (overlap.x > 0.0 && overlap.y > 0.0)
     {
         info.hasCollision = true;
-
-        // Normal direction uses OLD positions (physically correct side)
-        vec2 delta_old = posB_old - posA_old;
-
-        // Choose the MINIMUM overlap axis — that's the separation axis
-        if (overlap.x < overlap.y ||
-            (abs(overlap.x - overlap.y) < 0.001 && abs(delta_old.x) >= abs(delta_old.y)))
+        
+        // Resolve along minimum penetration axis
+        if (overlap.x < overlap.y)
         {
-            // Minimum penetration is along X — push along X
-            info.normal = vec2(sign(delta_old.x), 0.0);
+            info.normal = vec2(sign(delta.x), 0.0);
             info.penetration = overlap.x;
         }
         else
         {
-            // Minimum penetration is along Y — push along Y
-            info.normal = vec2(0.0, sign(delta_old.y));
+            info.normal = vec2(0.0, sign(delta.y));
             info.penetration = overlap.y;
         }
     }
-
+    
     return info;
 }
 
@@ -1393,38 +1387,43 @@ CollisionInfo detectCirclePolygon(vec2 circlePos, float circleRadius,
     return info;
 }
 
-// Master collision detection dispatcher - hybrid for AABB
-CollisionInfo detectCollision(Object objA, Object objB, int objIndexB,
-                              vec2 posA_old, vec2 posB_old)
+// Master collision detection dispatcher
+CollisionInfo detectCollision(Object objA, Object objB, int objIndexB)
 {
     CollisionInfo info;
     info.hasCollision = false;
     
+    // Get collision properties for both objects
     CollisionProperties propsA = collisionProps[gl_GlobalInvocationID.x];
     CollisionProperties propsB = collisionProps[objIndexB];
     
+    // Check if collisions are enabled for both objects
     if (propsA.enabled == 0 || propsB.enabled == 0)
         return info;
     
     int shapeA = propsA.shapeType;
     int shapeB = propsB.shapeType;
     
+    // Skip if either object has no collision shape
     if (shapeA == COLLISION_NONE || shapeB == COLLISION_NONE)
         return info;
     
+    // Dispatch to appropriate collision detection function based on shape types
     if (shapeA == COLLISION_CIRCLE && shapeB == COLLISION_CIRCLE)
     {
+        // Circle vs Circle
         info = detectCircleCircle(objA.position, objA.visualData.x,
                                   objB.position, objB.visualData.x, objIndexB);
     }
+    // AABB vs AABB
     else if (shapeA == COLLISION_AABB && shapeB == COLLISION_AABB)
     {
         vec2 halfExtA = objA.visualData.xy * 0.5;
         vec2 halfExtB = objB.visualData.xy * 0.5;
         info = detectAABBAABB(objA.position, halfExtA, 
-                              objB.position, halfExtB,
-                              posA_old, posB_old, objIndexB);
+                             objB.position, halfExtB, objIndexB);
     }
+    // Polygon vs Polygon
     else if (shapeA == COLLISION_POLYGON && shapeB == COLLISION_POLYGON)
     {
         info = detectPolygonPolygon(
@@ -1432,6 +1431,7 @@ CollisionInfo detectCollision(Object objA, Object objB, int objIndexB,
             objB.position, objB.visualData.x, int(objB.visualData.y), objB.visualData.z,
             objIndexB);
     }
+    // Circle vs AABB
     else if (shapeA == COLLISION_CIRCLE && shapeB == COLLISION_AABB)
     {
         vec2 halfExtB = objB.visualData.xy * 0.5;
@@ -1443,7 +1443,7 @@ CollisionInfo detectCollision(Object objA, Object objB, int objIndexB,
         vec2 halfExtA = objA.visualData.xy * 0.5;
         info = detectCircleAABB(objB.position, objB.visualData.x,
                                objA.position, halfExtA, objIndexB);
-        info.normal = -info.normal;
+        info.normal = -info.normal; // Flip normal
     }
     else if (shapeA == COLLISION_CIRCLE && shapeB == COLLISION_POLYGON)
     {
@@ -1458,14 +1458,14 @@ CollisionInfo detectCollision(Object objA, Object objB, int objIndexB,
                                    objA.position, objA.visualData.x,
                                    int(objA.visualData.y), objA.visualData.z,
                                    objIndexB);
-        info.normal = -info.normal;
+        info.normal = -info.normal; // Flip normal
     }
     else if (shapeA == COLLISION_AABB && shapeB == COLLISION_POLYGON)
     {
         vec2 halfExtA = objA.visualData.xy * 0.5;
         info = detectCircleAABB(objB.position, objB.visualData.x,
                                objA.position, halfExtA, objIndexB);
-        info.normal = -info.normal;
+        info.normal = -info.normal; // Flip normal
     }
     else if (shapeA == COLLISION_POLYGON && shapeB == COLLISION_AABB)
     {
@@ -1853,94 +1853,144 @@ void main() {
     vec2 new_pos = pos + new_vel * uDt;
     new_pos = sanitizeVec2(new_pos);
     
-    Object selfNew = p;                                // copy original
-    selfNew.position = new_pos;                        // update position
-
     // 3. Same for angular motion
     float new_angular_vel = angular_vel + angular_accel * uDt;
     float new_rotation = rotation + new_angular_vel * uDt;
     new_rotation = mod(new_rotation, 2.0 * PI);  // Wrap rotation
     
+    // ========================================================================
+    // WORLD BOUNDARIES
+    // ========================================================================
+    const vec2 world_min = vec2(-1000000.0, -1000000.0);
+    const vec2 world_max = vec2(1000000.0, 1000000.0);
+    const float boundary_friction = 0.95;
+    
+    // X boundaries
+    if (new_pos.x < world_min.x) { 
+        new_pos.x = world_min.x; 
+        new_vel.x = abs(new_vel.x) * uRestitution; 
+        new_vel.y *= boundary_friction; 
+    } 
+    else if (new_pos.x > world_max.x) { 
+        new_pos.x = world_max.x; 
+        new_vel.x = -abs(new_vel.x) * uRestitution; 
+        new_vel.y *= boundary_friction; 
+    }
+    
+    // Y boundaries
+    if (new_pos.y < world_min.y) { 
+        new_pos.y = world_min.y; 
+        new_vel.y = abs(new_vel.y) * uRestitution; 
+        new_vel.x *= boundary_friction; 
+    } 
+    else if (new_pos.y > world_max.y) { 
+        new_pos.y = world_max.y; 
+        new_vel.y = -abs(new_vel.y) * uRestitution; 
+        new_vel.x *= boundary_friction; 
+    }
+    
     // ========================================================================
     // CONSTRAINT RESOLUTION (UNCHANGED)
     // ========================================================================
     applyConstraints(new_pos, new_vel, objectIndex, originalPos);
 
-    // ========================================================================
-    // COLLISION HANDLING - Hybrid AABB + safe normal direction
-    // ========================================================================
-    vec2 collision_vel = new_vel;
-    vec2 final_pos = new_pos;
-    bool had_collision = false;
+// ========================================================================
+// 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];
     
-    for (int i = 0; i < uNumObjects; i++) {
-        if (i == objectIndex) continue;
+    // Detect collision
+    CollisionInfo collision = detectCollision(p, other, i);
+    
+    if (collision.hasCollision) {
+        had_collision = true;
         
-        Object other = objectsIn[i];
+        // Get collision properties
+        CollisionProperties propsA = collisionProps[objectIndex];
+        CollisionProperties propsB = collisionProps[i];
         
-        CollisionInfo collision = detectCollision(selfNew, other, i, p.position, other.position);
+        // Calculate effective properties
+        float restitution = min(propsA.restitution, propsB.restitution);
+        float friction = sqrt(propsA.friction * propsB.friction);
         
-        if (collision.hasCollision) {
-            had_collision = true;
-            
-            CollisionProperties propsA = collisionProps[objectIndex];
-            CollisionProperties propsB = collisionProps[i];
-            
-            float restitution = min(propsA.restitution, propsB.restitution);
-            float friction = sqrt(propsA.friction * propsB.friction);
-            
-            float massA = mass;
-            float massB = max(EPSILON, other.mass);
-            
-            // === ENSURE NORMAL POINTS AWAY FROM THIS OBJECT ===
-            vec2 fromOther = selfNew.position - other.position;
-            if (dot(collision.normal, fromOther) < 0.0) {
-                collision.normal = -collision.normal;
-            }
+        // Get masses
+        float massA = mass;
+        float massB = max(EPSILON, other.mass);
+        
+        // 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) {
+            // 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);
             
-            // Velocity impulse
-            vec2 relativeVel = other.velocity - collision_vel;
-            float velAlongNormal = dot(relativeVel, collision.normal);
+            // Apply impulse to THIS object only
+            vec2 impulse = j * collision.normal;
+            collision_vel -= impulse / massA;
             
-            if (velAlongNormal < 0.0) {
-                float e = clamp(restitution, 0.0, 1.0);
-                float j = -(1.0 + e) * velAlongNormal / (1.0/massA + 1.0/massB);
-                collision_vel -= (j * collision.normal) / massA;
+            // Friction
+            if (friction > 0.0) {
+                vec2 tangent = relativeVel - collision.normal * dot(relativeVel, collision.normal);
+                float tangentLength = length(tangent);
                 
-                if (friction > 0.0) {
-                    vec2 tangent = relativeVel - collision.normal * dot(relativeVel, collision.normal);
-                    float tLen = length(tangent);
-                    if (tLen > 0.01) {
-                        tangent = normalize(tangent);
-                        float vt = dot(relativeVel, tangent);
-                        float jt = -vt * friction * 0.5;
-                        float maxJt = abs(j) * friction;
-                        jt = clamp(jt, -maxJt, maxJt);
-                        collision_vel -= (jt * tangent) / massA;
-                    }
+                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;
                 }
             }
+        }
+        
+        // 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;
             
-            // Position correction - conservative for stability
-            const float slop = 0.045;
-            const float percent = 0.62;
-            
-            if (collision.penetration > slop) {
-                float totalMass = massA + massB;
-                vec2 correction = collision.normal * (collision.penetration - slop) * percent * (massB / totalMass);
-                final_pos -= correction;
-            }
+            // Only correct THIS object's position
+            // The correction is weighted by the inverse mass ratio
+            new_pos -= correction * (massB / totalMass);
         }
     }
-    
-    if (had_collision) {
-        new_vel = sanitizeVec2(collision_vel);
-    }
-    new_pos = sanitizeVec2(final_pos);
+}
 
-    // ========================================================================
-    // REST OF CODE (age contacts, final sanity, write output)
-    // ========================================================================
+// 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) {
@@ -1951,14 +2001,20 @@ void main() {
     new_pos = sanitizeVec2(new_pos);
     new_vel = sanitizeVec2(new_vel);
     
-    // Final sanity checks
+    // ========================================================================
+    // FINAL SANITY CHECKS
+    // ========================================================================
+    
+    // Ensure velocities aren't excessive
     float maxSpeed = 1000.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;
     objectsOut[gid].mass = mass;

{hyperstellar-0.1.67 → hyperstellar-0.1.69}/hyperstellar/src/hyperstellar.egg-info/PKG-INFO

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

{hyperstellar-0.1.67 → hyperstellar-0.1.69}/pyproject.toml

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