hyperstellar 0.1.63__tar.gz → 0.1.65__tar.gz

{hyperstellar-0.1.63 → hyperstellar-0.1.65}/PKG-INFO

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

{hyperstellar-0.1.63 → hyperstellar-0.1.65}/hyperstellar/src/hyperstellar/_native/windows-x64/shaders/math.comp

@@ -1481,7 +1481,7 @@ CollisionInfo detectCollision(Object objA, Object objB, int objIndexB)
 }
 
 // ============================================================================
-// NEW: RESEARCH-GRADE COLLISION RESOLUTION SYSTEM
+// RESEARCH-GRADE COLLISION RESOLUTION SYSTEM
 // ============================================================================
 
 // ============================================================================
@@ -1868,148 +1868,95 @@ void main() {
     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);
 
-// ========================================================================
-// 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(selfNew, other, i); 
+    // ========================================================================
+    // COLLISION HANDLING - Keep selfNew for circles, but fix stickiness for rectangles
+    // ========================================================================
+    vec2 collision_vel = new_vel;
+    vec2 final_pos = new_pos;      // Accumulate corrections (prevents feedback loop)
+    bool had_collision = false;
     
-    if (collision.hasCollision) {
-        had_collision = true;
+    for (int i = 0; i < uNumObjects; i++) {
+        if (i == objectIndex) continue;
         
-        // Get collision properties
-        CollisionProperties propsA = collisionProps[objectIndex];
-        CollisionProperties propsB = collisionProps[i];
+        Object other = objectsIn[i];
         
-        // Calculate effective properties
-        float restitution = min(propsA.restitution, propsB.restitution);
-        float friction = sqrt(propsA.friction * propsB.friction);
+        // Keep your selfNew detection - this is what made circles bouncy
+        CollisionInfo collision = detectCollision(selfNew, other, i);   // <--- selfNew here
         
-        // 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);
+        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);
             
-            // Apply impulse to THIS object only
-            vec2 impulse = j * collision.normal;
-            collision_vel -= impulse / massA;
+            // Velocity impulse (asymmetric - only affect this object)
+            vec2 relativeVel = other.velocity - collision_vel;
+            float velAlongNormal = dot(relativeVel, collision.normal);
             
-            // Friction
-            if (friction > 0.0) {
-                vec2 tangent = relativeVel - collision.normal * dot(relativeVel, collision.normal);
-                float tangentLength = length(tangent);
+            if (velAlongNormal < 0.0) {   // approaching
+                float e = clamp(restitution, 0.0, 1.0);
+                float j = -(1.0 + e) * velAlongNormal / (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;
+                collision_vel -= (j * collision.normal) / massA;
+                
+                // Friction - conservative
+                if (friction > 0.0) {
+                    vec2 tangent = relativeVel - collision.normal * dot(relativeVel, collision.normal);
+                    float tLen = length(tangent);
+                    if (tLen > EPSILON) {
+                        tangent = normalize(tangent);
+                        float vt = dot(relativeVel, tangent);
+                        float jt = -vt * friction / (1.0 / massA + 1.0 / massB);
+                        float maxJt = abs(j) * friction;
+                        jt = clamp(jt, -maxJt, maxJt);
+                        collision_vel -= (jt * tangent) / massA;
+                    }
                 }
             }
-        }
-        
-        // POSITION CORRECTION - only for deep penetrations
-        // Move THIS object away from penetration
-        const float slop = 0.01;
-        const float percent = 0.4;  
-        
-        if (collision.penetration > slop) {
-            float totalMass = massA + massB;
-            vec2 correction = collision.normal * (collision.penetration - slop) * percent;
             
-            // The correction is weighted by the inverse mass ratio
-            new_pos -= correction * (massB / totalMass);
+            // Position correction - ACCUMULATED + rectangle-tuned values
+            const float slop = 0.025;      // Increased to reduce micro-corrections on flat edges
+            const float percent = 0.75;    // Stronger push to separate cleanly
+            
+            if (collision.penetration > slop) {
+                float totalMass = massA + massB;
+                vec2 correction = collision.normal * (collision.penetration - slop) * percent * (massB / totalMass);
+                
+                // Force correction direction away from the other object
+                if (dot(collision.normal, other.position - selfNew.position) < 0.0) {
+                    correction = -correction;
+                }
+                
+                final_pos -= correction;
+            }
         }
     }
-}
-
-// Apply collision-modified velocity
-if (had_collision) {
-    new_vel = sanitizeVec2(collision_vel);
-}
+    
+    if (had_collision) {
+        new_vel = sanitizeVec2(collision_vel);
+    }
+    new_pos = sanitizeVec2(final_pos);   // Apply all corrections at once
 
-// ========================================================================
-// REST OF CODE(boundaries, final write, etc.)
-// ========================================================================
+    // ========================================================================
+    // REST OF CODE(boundaries, final write, etc.)
+    // ========================================================================
     
     // Age out old contacts for this object
     if (uEnableWarmStart == 1) {
         ageContacts(objectIndex);
     }
     
-    // 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);
@@ -2047,8 +1994,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.63 → hyperstellar-0.1.65}/hyperstellar/src/hyperstellar.egg-info/PKG-INFO

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

{hyperstellar-0.1.63 → hyperstellar-0.1.65}/pyproject.toml

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