hyperstellar 0.1.65__tar.gz → 0.1.67__tar.gz

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

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

{hyperstellar-0.1.65 → hyperstellar-0.1.67}/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 (UNCHANGED - KEEP YOUR EXISTING CODE)
+// COLLISION DETECTION FUNCTIONS
 // ============================================================================
 
 // Circle-Circle collision detection
@@ -1137,35 +1137,41 @@ CollisionInfo detectCircleCircle(vec2 posA, float radiusA, vec2 posB, float radi
     return info;
 }
 
-// Axis-Aligned Bounding Box collision detection
-CollisionInfo detectAABBAABB(vec2 posA, vec2 halfExtA, vec2 posB, vec2 halfExtB, int objB)
+// 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)
 {
     CollisionInfo info;
     info.hasCollision = false;
     info.otherObjectID = objB;
-    
-    // Calculate separation vector
-    vec2 delta = posB - posA;
-    vec2 overlap = halfExtA + halfExtB - abs(delta);
-    
-    // Check for overlap on both axes
+
+    // Penetration uses CURRENT (predicted/selfNew) positions
+    vec2 delta_curr = posB_curr - posA_curr;
+    vec2 overlap = halfExtA + halfExtB - abs(delta_curr);
+
     if (overlap.x > 0.0 && overlap.y > 0.0)
     {
         info.hasCollision = true;
-        
-        // Resolve along minimum penetration axis
-        if (overlap.x < overlap.y)
+
+        // 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)))
         {
-            info.normal = vec2(sign(delta.x), 0.0);
+            // Minimum penetration is along X — push along X
+            info.normal = vec2(sign(delta_old.x), 0.0);
             info.penetration = overlap.x;
         }
         else
         {
-            info.normal = vec2(0.0, sign(delta.y));
+            // Minimum penetration is along Y — push along Y
+            info.normal = vec2(0.0, sign(delta_old.y));
             info.penetration = overlap.y;
         }
     }
-    
+
     return info;
 }
 
@@ -1387,43 +1393,38 @@ CollisionInfo detectCirclePolygon(vec2 circlePos, float circleRadius,
     return info;
 }
 
-// Master collision detection dispatcher
-CollisionInfo detectCollision(Object objA, Object objB, int objIndexB)
+// Master collision detection dispatcher - hybrid for AABB
+CollisionInfo detectCollision(Object objA, Object objB, int objIndexB,
+                              vec2 posA_old, vec2 posB_old)
 {
     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, objIndexB);
+                              objB.position, halfExtB,
+                              posA_old, posB_old, objIndexB);
     }
-    // Polygon vs Polygon
     else if (shapeA == COLLISION_POLYGON && shapeB == COLLISION_POLYGON)
     {
         info = detectPolygonPolygon(
@@ -1431,7 +1432,6 @@ 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;
@@ -1440,13 +1440,11 @@ 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
+        info.normal = -info.normal;
     }
-    // Circle vs Polygon
     else if (shapeA == COLLISION_CIRCLE && shapeB == COLLISION_POLYGON)
     {
         info = detectCirclePolygon(objA.position, objA.visualData.x,
@@ -1460,15 +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; // Flip normal
+        info.normal = -info.normal;
     }
-    // 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 = detectCircleAABB(objB.position, objB.visualData.x,
                                objA.position, halfExtA, objIndexB);
-        info.normal = -info.normal; // Flip normal
+        info.normal = -info.normal;
     }
     else if (shapeA == COLLISION_POLYGON && shapeB == COLLISION_AABB)
     {
@@ -1480,10 +1477,6 @@ CollisionInfo detectCollision(Object objA, Object objB, int objIndexB)
     return info;
 }
 
-// ============================================================================
-// RESEARCH-GRADE COLLISION RESOLUTION SYSTEM
-// ============================================================================
-
 // ============================================================================
 // BASIC COLLISION RESPONSE (Momentum-Conserving)
 // ============================================================================
@@ -1874,10 +1867,10 @@ void main() {
     applyConstraints(new_pos, new_vel, objectIndex, originalPos);
 
     // ========================================================================
-    // COLLISION HANDLING - Keep selfNew for circles, but fix stickiness for rectangles
+    // COLLISION HANDLING - Hybrid AABB + safe normal direction
     // ========================================================================
     vec2 collision_vel = new_vel;
-    vec2 final_pos = new_pos;      // Accumulate corrections (prevents feedback loop)
+    vec2 final_pos = new_pos;
     bool had_collision = false;
     
     for (int i = 0; i < uNumObjects; i++) {
@@ -1885,8 +1878,7 @@ void main() {
         
         Object other = objectsIn[i];
         
-        // Keep your selfNew detection - this is what made circles bouncy
-        CollisionInfo collision = detectCollision(selfNew, other, i);   // <--- selfNew here
+        CollisionInfo collision = detectCollision(selfNew, other, i, p.position, other.position);
         
         if (collision.hasCollision) {
             had_collision = true;
@@ -1900,24 +1892,28 @@ void main() {
             float massA = mass;
             float massB = max(EPSILON, other.mass);
             
-            // Velocity impulse (asymmetric - only affect this object)
+            // === ENSURE NORMAL POINTS AWAY FROM THIS OBJECT ===
+            vec2 fromOther = selfNew.position - other.position;
+            if (dot(collision.normal, fromOther) < 0.0) {
+                collision.normal = -collision.normal;
+            }
+            
+            // Velocity impulse
             vec2 relativeVel = other.velocity - collision_vel;
             float velAlongNormal = dot(relativeVel, collision.normal);
             
-            if (velAlongNormal < 0.0) {   // approaching
+            if (velAlongNormal < 0.0) {
                 float e = clamp(restitution, 0.0, 1.0);
-                float j = -(1.0 + e) * velAlongNormal / (1.0 / massA + 1.0 / massB);
-                
+                float j = -(1.0 + e) * velAlongNormal / (1.0/massA + 1.0/massB);
                 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) {
+                    if (tLen > 0.01) {
                         tangent = normalize(tangent);
                         float vt = dot(relativeVel, tangent);
-                        float jt = -vt * friction / (1.0 / massA + 1.0 / massB);
+                        float jt = -vt * friction * 0.5;
                         float maxJt = abs(j) * friction;
                         jt = clamp(jt, -maxJt, maxJt);
                         collision_vel -= (jt * tangent) / massA;
@@ -1925,19 +1921,13 @@ void main() {
                 }
             }
             
-            // 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
+            // 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);
-                
-                // Force correction direction away from the other object
-                if (dot(collision.normal, other.position - selfNew.position) < 0.0) {
-                    correction = -correction;
-                }
-                
                 final_pos -= correction;
             }
         }
@@ -1946,10 +1936,10 @@ void main() {
     if (had_collision) {
         new_vel = sanitizeVec2(collision_vel);
     }
-    new_pos = sanitizeVec2(final_pos);   // Apply all corrections at once
+    new_pos = sanitizeVec2(final_pos);
 
     // ========================================================================
-    // REST OF CODE(boundaries, final write, etc.)
+    // REST OF CODE (age contacts, final sanity, write output)
     // ========================================================================
     
     // Age out old contacts for this object
@@ -1961,20 +1951,14 @@ void main() {
     new_pos = sanitizeVec2(new_pos);
     new_vel = sanitizeVec2(new_vel);
     
-    // ========================================================================
-    // FINAL SANITY CHECKS
-    // ========================================================================
-    
-    // Ensure velocities aren't excessive
+    // Final sanity checks
     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.65 → hyperstellar-0.1.67}/hyperstellar/src/hyperstellar.egg-info/PKG-INFO

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

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

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