hyperstellar 0.1.63__tar.gz → 0.1.64__tar.gz

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

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

{hyperstellar-0.1.63 → hyperstellar-0.1.64}/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
@@ -1120,52 +1120,54 @@ CollisionInfo detectCircleCircle(vec2 posA, float radiusA, vec2 posB, float radi
     info.hasCollision = false;
     info.otherObjectID = objB;
     
-    // Calculate distance between centers
     vec2 delta = posB - posA;
     float distSq = dot(delta, delta);
     float radiusSum = radiusA + radiusB;
     
-    // Check if circles overlap
     if (distSq < radiusSum * radiusSum && distSq > EPSILON)
     {
         float dist = sqrt(distSq);
         info.hasCollision = true;
-        info.normal = delta / dist;           // Collision normal (A→B)
-        info.penetration = radiusSum - dist;  // Overlap depth
+        info.normal = delta / dist;
+        info.penetration = radiusSum - dist;
     }
     
     return info;
 }
 
-// Axis-Aligned Bounding Box collision detection
-CollisionInfo detectAABBAABB(vec2 posA, vec2 halfExtA, vec2 posB, vec2 halfExtB, int objB)
+// Axis-Aligned Bounding Box collision detection with fix for "sticky" behavior.
+// The fix: Use old positions only for determining the sign of the normal,
+// while penetration depth still uses the current (predicted) positions.
+// This prevents the normal from flipping when A leaps past B in one timestep.
+CollisionInfo detectAABBAABB(vec2 posA, vec2 halfExtA, vec2 posB, vec2 halfExtB,
+                             vec2 oldPosA, vec2 oldPosB, int objB)
 {
     CollisionInfo info;
     info.hasCollision = false;
     info.otherObjectID = objB;
-    
-    // Calculate separation vector
-    vec2 delta = posB - posA;
+
+    vec2 delta = posB - posA;                     // current (possibly overshot)
     vec2 overlap = halfExtA + halfExtB - abs(delta);
-    
-    // Check for overlap on both axes
+
     if (overlap.x > 0.0 && overlap.y > 0.0)
     {
         info.hasCollision = true;
-        
-        // Resolve along minimum penetration axis
+
+        // Use the OLD relative position to decide the normal direction.
+        // This preserves physical sign even after a large velocity causes overshoot.
+        vec2 oldDelta = oldPosB - oldPosA;
+
         if (overlap.x < overlap.y)
         {
-            info.normal = vec2(sign(delta.x), 0.0);
+            info.normal = vec2(sign(oldDelta.x), 0.0);
             info.penetration = overlap.x;
         }
         else
         {
-            info.normal = vec2(0.0, sign(delta.y));
+            info.normal = vec2(0.0, sign(oldDelta.y));
             info.penetration = overlap.y;
         }
     }
-    
     return info;
 }
 
@@ -1177,7 +1179,6 @@ vec2 projectPolygon(vec2 center, float radius, int sides, float rotation, vec2 a
     
     float angleStep = 2.0 * PI / float(sides);
     
-    // Project each vertex onto axis
     for (int i = 0; i < sides; i++)
     {
         float angle = rotation + float(i) * angleStep;
@@ -1196,11 +1197,9 @@ vec2 getPolygonNormal(int side, int totalSides, float rotation)
     float angleStep = 2.0 * PI / float(totalSides);
     float angle = rotation + float(side) * angleStep;
     
-    // Calculate edge vector
     vec2 edge = vec2(cos(angle + angleStep), sin(angle + angleStep)) - 
                 vec2(cos(angle), sin(angle));
     
-    // Return perpendicular (normal) to edge
     return normalize(vec2(-edge.y, edge.x));
 }
 
@@ -1215,7 +1214,6 @@ CollisionInfo detectPolygonPolygon(
     info.otherObjectID = objB;
     info.penetration = 1e10;
     
-    // Test all edge normals from both polygons
     int totalTests = sidesA + sidesB;
     
     for (int i = 0; i < totalTests; i++)
@@ -1227,24 +1225,18 @@ CollisionInfo detectPolygonPolygon(
         else
             axis = getPolygonNormal(i - sidesA, sidesB, rotB);
         
-        // Project both polygons onto axis
         vec2 projA = projectPolygon(posA, radiusA, sidesA, rotA, axis);
         vec2 projB = projectPolygon(posB, radiusB, sidesB, rotB, axis);
         
-        // Check for separating axis
         if (projA.y < projB.x || projB.y < projA.x)
-            return info; // Separating axis found, no collision
+            return info;
         
-        // Calculate overlap
         float overlap = min(projA.y, projB.y) - max(projA.x, projB.x);
         
-        // Track minimum overlap (minimum translation vector)
         if (overlap < info.penetration)
         {
             info.penetration = overlap;
             info.normal = axis;
-            
-            // Ensure normal points from A to B
             if (dot(posB - posA, axis) < 0.0)
                 info.normal = -axis;
         }
@@ -1262,7 +1254,6 @@ CollisionInfo detectCircleAABB(vec2 circlePos, float radius,
     info.hasCollision = false;
     info.otherObjectID = objB;
     
-    // Find closest point on AABB to circle center
     vec2 closest = clamp(circlePos, boxPos - halfExt, boxPos + halfExt);
     vec2 delta = circlePos - closest;
     float distSq = dot(delta, delta);
@@ -1274,13 +1265,11 @@ CollisionInfo detectCircleAABB(vec2 circlePos, float radius,
         
         if (dist > EPSILON)
         {
-            // Circle center outside AABB
             info.normal = -(delta / dist);
             info.penetration = radius - dist;
         }
         else
         {
-            // Circle center inside AABB - push out nearest edge
             vec2 toEdge = boxPos - circlePos;
             vec2 absToEdge = abs(toEdge);
             vec2 edgeDist = halfExt - absToEdge;
@@ -1311,30 +1300,24 @@ CollisionInfo detectCirclePolygon(vec2 circlePos, float circleRadius,
     info.otherObjectID = objB;
     info.penetration = 1e10;
     
-    // Test polygon edge normals
     float angleStep = 2.0 * PI / float(polySides);
     
     for (int i = 0; i < polySides; i++)
     {
         vec2 axis = getPolygonNormal(i, polySides, polyRot);
         
-        // Project circle onto axis (capsule projection)
         float circleProj = dot(circlePos, axis);
         vec2 circleProjRange = vec2(circleProj - circleRadius, 
                                      circleProj + circleRadius);
         
-        // Project polygon onto axis
         vec2 polyProj = projectPolygon(polyPos, polyRadius, polySides, polyRot, axis);
         
-        // Check for separation
         if (circleProjRange.y < polyProj.x || polyProj.y < circleProjRange.x)
             return info;
         
-        // Calculate overlap
         float overlap = min(circleProjRange.y, polyProj.y) - 
                        max(circleProjRange.x, polyProj.x);
         
-        // Track minimum overlap
         if (overlap < info.penetration)
         {
             info.penetration = overlap;
@@ -1344,11 +1327,9 @@ CollisionInfo detectCirclePolygon(vec2 circlePos, float circleRadius,
         }
     }
     
-    // Test axis from circle center to closest polygon vertex
     vec2 closestVertex = polyPos;
     float closestDistSq = 1e10;
     
-    // Find closest polygon vertex to circle center
     for (int i = 0; i < polySides; i++)
     {
         float angle = polyRot + float(i) * angleStep;
@@ -1362,13 +1343,11 @@ CollisionInfo detectCirclePolygon(vec2 circlePos, float circleRadius,
         }
     }
     
-    // Test axis from circle center to closest vertex
     vec2 axis = normalize(circlePos - closestVertex);
     float circleProj = dot(circlePos, axis);
     vec2 circleProjRange = vec2(circleProj - circleRadius, circleProj + circleRadius);
     vec2 polyProj = projectPolygon(polyPos, polyRadius, polySides, polyRot, axis);
     
-    // Final separation check
     if (circleProjRange.y < polyProj.x || polyProj.y < circleProjRange.x)
         return info;
     
@@ -1387,43 +1366,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 (now with old positions for AABB fix)
+CollisionInfo detectCollision(Object objA, Object objB, int objIndexB,
+                              vec2 oldPosA, vec2 oldPosB)
 {
     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);
+        info = detectAABBAABB(objA.position, halfExtA,
+                              objB.position, halfExtB,
+                              oldPosA, oldPosB, objIndexB);
     }
-    // Polygon vs Polygon
     else if (shapeA == COLLISION_POLYGON && shapeB == COLLISION_POLYGON)
     {
         info = detectPolygonPolygon(
@@ -1431,7 +1405,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 +1413,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 +1431,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)
     {
@@ -1484,10 +1454,6 @@ CollisionInfo detectCollision(Object objA, Object objB, int objIndexB)
 // NEW: RESEARCH-GRADE COLLISION RESOLUTION SYSTEM
 // ============================================================================
 
-// ============================================================================
-// BASIC COLLISION RESPONSE (Momentum-Conserving)
-// ============================================================================
-
 // Apply collision response to two objects (conserves momentum and energy)
 void applyCollisionResponse(
     inout vec2 posA, inout vec2 velA, float massA,
@@ -1495,73 +1461,51 @@ void applyCollisionResponse(
     vec2 normal, float penetration,
     float restitution, float friction
 ) {
-    // Ensure valid masses
     if (massA < EPSILON || massB < EPSILON) return;
     
-    // ========================================================================
-    // 1. POSITION CORRECTION (Separating objects)
-    // ========================================================================
-    const float positionCorrectionFactor = 0.8;  // Baumgarte stabilization
-    const float penetrationSlop = 0.001;         // Allow small penetration
+    const float positionCorrectionFactor = 0.8;
+    const float penetrationSlop = 0.001;
     
     if (penetration > penetrationSlop) {
         float totalMass = massA + massB;
         float invTotalMass = 1.0 / totalMass;
         
-        // Calculate correction vector
         vec2 correction = (penetration - penetrationSlop) * positionCorrectionFactor * normal;
         
-        // Apply position correction based on mass ratio
         posA -= correction * (massB * invTotalMass);
         posB += correction * (massA * invTotalMass);
     }
     
-    // ========================================================================
-    // 2. VELOCITY CORRECTION (Impulse-based, conserves momentum)
-    // ========================================================================
-    // Relative velocity
     vec2 relativeVel = velB - velA;
     float velocityAlongNormal = dot(relativeVel, normal);
     
-    // Only resolve if objects are moving toward each other
     if (velocityAlongNormal > 0.0) return;
     
-    // Calculate impulse scalar (conserves momentum and energy)
-    float e = min(max(restitution, 0.0), 1.0);  // Clamp restitution
+    float e = min(max(restitution, 0.0), 1.0);
     float impulseScalar = -(1.0 + e) * velocityAlongNormal;
     impulseScalar /= (1.0 / massA + 1.0 / massB);
     
-    // Apply impulse to both velocities (equal and opposite)
     vec2 impulse = impulseScalar * normal;
     velA -= impulse / massA;
     velB += impulse / massB;
     
-    // ========================================================================
-    // 3. FRICTION (Coulomb model)
-    // ========================================================================
     if (friction > 0.0) {
-        // Recompute relative velocity after normal impulse
         relativeVel = velB - velA;
         
-        // Tangent vector (perpendicular to normal)
         vec2 tangent = relativeVel - normal * dot(relativeVel, normal);
         float tangentLength = length(tangent);
         
         if (tangentLength > EPSILON) {
             tangent = normalize(tangent);
             
-            // Relative velocity in tangent direction
             float relVelTangent = dot(relativeVel, tangent);
             
-            // Friction impulse scalar
             float frictionImpulse = -relVelTangent * friction;
             frictionImpulse /= (1.0 / massA + 1.0 / massB);
             
-            // Coulomb's law: friction impulse cannot exceed normal impulse
             float maxFriction = abs(impulseScalar) * friction;
             frictionImpulse = clamp(frictionImpulse, -maxFriction, maxFriction);
             
-            // Apply friction impulse
             vec2 frictionVec = frictionImpulse * tangent;
             velA -= frictionVec / massA;
             velB += frictionVec / massB;
@@ -1569,12 +1513,7 @@ void applyCollisionResponse(
     }
 }
 
-// ============================================================================
-// SIMPLIFIED COLLISION RESOLUTION FOR PARALLEL EXECUTION
-// ============================================================================
-
-// This version handles collisions in a thread-safe way by only modifying
-// the current object and letting the other object handle its own updates
+// Simplified collision resolution for parallel execution
 void resolveCollisionSimple(
     inout vec2 posA, inout vec2 velA, float massA,
     Object objB, int objBIndex,
@@ -1582,26 +1521,21 @@ void resolveCollisionSimple(
 ) {
     if (!collision.hasCollision) return;
     
-    // Get collision properties
     CollisionProperties propsA = collisionProps[gl_GlobalInvocationID.x];
     CollisionProperties propsB = collisionProps[objBIndex];
     
-    // Effective restitution and friction
     float restitution = min(propsA.restitution, propsB.restitution);
     float friction = sqrt(propsA.friction * propsB.friction);
     
-    // Other object's state
     vec2 posB = objB.position;
     vec2 velB = objB.velocity;
     float massB = max(EPSILON, objB.mass);
     
-    // Copy state for local processing
     vec2 tempPosA = posA;
     vec2 tempVelA = velA;
     vec2 tempPosB = posB;
     vec2 tempVelB = velB;
     
-    // Apply collision response
     applyCollisionResponse(
         tempPosA, tempVelA, massA,
         tempPosB, tempVelB, massB,
@@ -1609,25 +1543,16 @@ void resolveCollisionSimple(
         restitution, friction
     );
     
-    // Update this object's state
     posA = tempPosA;
     velA = tempVelA;
-    
-    // Note: The other object (objB) will handle its own update in its thread
-    // This ensures momentum is conserved across the entire system
 }
 
-// ============================================================================
-// ANALYTICAL ELASTIC COLLISION FORMULA (For perfect conservation)
-// ============================================================================
-
-// Perfectly elastic collision for circles (conserves both momentum and energy)
+// Elastic collision formula (for perfect conservation)
 void resolveElasticCollision(
     inout vec2 posA, inout vec2 velA, float massA,
     inout vec2 posB, inout vec2 velB, float massB,
     vec2 normal, float penetration
 ) {
-    // Position correction
     const float positionPush = 0.5;
     if (penetration > 0.0) {
         float totalMass = massA + massB;
@@ -1635,21 +1560,17 @@ void resolveElasticCollision(
         posB += normal * penetration * positionPush * (massA / totalMass);
     }
     
-    // Relative velocity along collision normal
     vec2 relativeVel = velB - velA;
     float velocityAlongNormal = dot(relativeVel, normal);
     
-    // If objects are separating, no impulse needed
     if (velocityAlongNormal > 0.0) return;
     
-    // Perfectly elastic collision formulas (conserves both momentum and energy)
     float totalMass = massA + massB;
     float massRatioA = (massA - massB) / totalMass;
     float massRatioB = (2.0 * massB) / totalMass;
     float massRatioC = (2.0 * massA) / totalMass;
     float massRatioD = (massB - massA) / totalMass;
     
-    // Apply velocity changes
     vec2 impulseA = normal * velocityAlongNormal;
     vec2 impulseB = normal * velocityAlongNormal;
     
@@ -1657,11 +1578,7 @@ void resolveElasticCollision(
     velB = velB - massRatioC * impulseB;
 }
 
-// ============================================================================
-// CONTACT PERSISTENCE SYSTEM (Optional, for stability)
-// ============================================================================
-
-// Find a persistent contact in the contact buffer
+// Contact persistence system
 int findPersistentContact(int objectA, int objectB, vec2 normal) {
     int baseIndex = objectA * MAX_CONTACTS_PER_OBJECT;
     
@@ -1671,32 +1588,26 @@ int findPersistentContact(int objectA, int objectB, vec2 normal) {
         
         ContactPoint contact = contacts[contactIndex];
         
-        // Check if this contact is between the same objects
-        // and has a similar normal direction
         if (contact.frameCount > 0 && dot(contact.normal, normal) > 0.9) {
             return contactIndex;
         }
     }
     
-    return -1; // No persistent contact found
+    return -1;
 }
 
-// Update or create a contact point
 void updateContactPoint(int objectA, int objectB, vec2 normal, vec2 position, float penetration) {
     int baseIndex = objectA * MAX_CONTACTS_PER_OBJECT;
     int oldestIndex = baseIndex;
     int oldestFrameCount = 9999;
     
-    // Find slot for this contact
     for (int i = 0; i < MAX_CONTACTS_PER_OBJECT; i++) {
         int contactIndex = baseIndex + i;
         if (contactIndex >= contacts.length()) break;
         
         ContactPoint contact = contacts[contactIndex];
         
-        // If this slot is empty or matches our contact, use it
         if (contact.frameCount == 0 || dot(contact.normal, normal) > 0.9) {
-            // Update existing contact
             contacts[contactIndex].normal = normal;
             contacts[contactIndex].position = position;
             contacts[contactIndex].penetration = penetration;
@@ -1704,14 +1615,12 @@ void updateContactPoint(int objectA, int objectB, vec2 normal, vec2 position, fl
             return;
         }
         
-        // Track the oldest contact for replacement
         if (contact.frameCount < oldestFrameCount) {
             oldestFrameCount = contact.frameCount;
             oldestIndex = contactIndex;
         }
     }
     
-    // Replace the oldest contact
     if (oldestIndex >= 0 && oldestIndex < contacts.length()) {
         contacts[oldestIndex].normal = normal;
         contacts[oldestIndex].position = position;
@@ -1722,7 +1631,6 @@ void updateContactPoint(int objectA, int objectB, vec2 normal, vec2 position, fl
     }
 }
 
-// Age out old contacts
 void ageContacts(int objectIndex) {
     int baseIndex = objectIndex * MAX_CONTACTS_PER_OBJECT;
     
@@ -1730,11 +1638,9 @@ void ageContacts(int objectIndex) {
         int contactIndex = baseIndex + i;
         if (contactIndex >= contacts.length()) break;
         
-        // Decrement frame count, remove if too old
         if (contacts[contactIndex].frameCount > 0) {
             contacts[contactIndex].frameCount--;
             if (contacts[contactIndex].frameCount == 0) {
-                // Reset contact
                 contacts[contactIndex].accumulatedNormalImpulse = 0.0;
                 contacts[contactIndex].accumulatedTangentImpulse = 0.0;
             }
@@ -1743,16 +1649,14 @@ void ageContacts(int objectIndex) {
 }
 
 // ============================================================================
-// MAIN COMPUTE SHADER ENTRY POINT - UPDATED WITH FIXED COLLISION RESOLUTION
+// MAIN COMPUTE SHADER ENTRY POINT - WITH AABB COLLISION FIX
 // ============================================================================
 
 void main() {
     uint gid = gl_GlobalInvocationID.x;
     
-    // Early exit if beyond active object count
     if (int(gid) >= uNumObjects) return;
     
-    // Read current object state
     Object p = objectsIn[gid];
     vec2 pos = p.position;
     vec2 vel = p.velocity;
@@ -1764,16 +1668,12 @@ void main() {
     int objectIndex = int(gid);
     vec2 originalPos = pos;
     
-    // Initialize physics variables
     vec2 acceleration = vec2(0.0);
     float angular_accel = 0.0;
     vec4 new_color = color;
     
-    // ========================================================================
-    // PHYSICS EQUATION EVALUATION (UNCHANGED)
-    // ========================================================================
+    // Physics equation evaluation (unchanged)
     if (uEquationMode == 0) {
-        // Custom equation mode
         int eqID = p.equationID;
         bool isValidEquation = (eqID >= 0 && eqID < MAX_EQUATION_COUNT) && 
                               (mappings[eqID].tokenCount_ax > 0 || 
@@ -1785,22 +1685,18 @@ void main() {
                                mappings[eqID].tokenCount_a > 0);
         
         if (!isValidEquation) {
-            // Use default physics if equation is invalid
             acceleration = calculateDefaultPhysics(pos, vel, mass);
         } else {
-            // Evaluate custom physics equation components
             EquationMapping mapping = mappings[eqID];
             float ax = 0.0;
             float ay = 0.0;
             
-            // Evaluate X acceleration component
             if (mapping.tokenCount_ax > 0) {
                 ax = evaluateRPNComponent(pos.x, pos.y, vel.x, vel.y, p.collisionData.x, p.collisionData.y,
                                         rotation, angular_vel, color, mass, charge, objectIndex,
                                         0, mapping.tokenOffset_ax, mapping.tokenCount_ax, mapping.constantOffset_ax);
             }
             
-            // Evaluate Y acceleration component
             if (mapping.tokenCount_ay > 0) {
                 ay = evaluateRPNComponent(pos.x, pos.y, vel.x, vel.y, p.collisionData.x, p.collisionData.y,
                                         rotation, angular_vel, color, mass, charge, objectIndex,
@@ -1809,7 +1705,6 @@ void main() {
             
             acceleration = sanitizeVec2(vec2(ax, ay));
             
-            // Evaluate angular acceleration
             if (mapping.tokenCount_angular > 0) {
                 angular_accel = evaluateRPNComponent(pos.x, pos.y, vel.x, vel.y, p.collisionData.x, p.collisionData.y,
                                                    rotation, angular_vel, color, mass, charge, objectIndex,
@@ -1817,7 +1712,6 @@ void main() {
                 angular_accel = isInvalidFloat(angular_accel) ? 0.0 : angular_accel;
             }
             
-            // Evaluate color components (dynamic coloring)
             if (mapping.tokenCount_r > 0) {
                 new_color.r = evaluateRPNComponent(pos.x, pos.y, vel.x, vel.y, p.collisionData.x, p.collisionData.y,
                                                  rotation, angular_vel, color, mass, charge, objectIndex,
@@ -1842,192 +1736,113 @@ void main() {
             new_color = sanitizeVec4(new_color);
         }
     } else {
-        // Default physics mode (simple spring-mass-damper)
         acceleration = calculateDefaultPhysics(pos, vel, mass);
     }
     
     acceleration = sanitizeVec2(acceleration);
     
-    // ========================================================================
-    // STABLE INTEGRATION (Symplectic Euler - Energy Conserving)
-    // ========================================================================
-    
-    // 1. Update VELOCITY first using current acceleration
+    // Symplectic Euler integration
     vec2 new_vel = vel + acceleration * uDt;
     new_vel = sanitizeVec2(new_vel);
     
-    // 2. Use NEW VELOCITY to update POSITION (energy-conserving)
     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
+    Object selfNew = p;
+    selfNew.position = new_pos;
+    
     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
+    new_rotation = mod(new_rotation, 2.0 * PI);
     
-    // ========================================================================
-    // 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; 
-    }
+    applyConstraints(new_pos, new_vel, objectIndex, originalPos);
     
     // ========================================================================
-    // CONSTRAINT RESOLUTION (UNCHANGED)
+    // COLLISION HANDLING - using old positions for normal sign in AABB case
     // ========================================================================
-    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
+    vec2 collision_vel = new_vel;
+    bool had_collision = false;
     
-    Object other = objectsIn[i];
-    
-    // Detect collision
-    CollisionInfo collision = detectCollision(selfNew, other, i); 
-    
-    if (collision.hasCollision) {
-        had_collision = true;
-        
-        // Get collision properties
-        CollisionProperties propsA = collisionProps[objectIndex];
-        CollisionProperties propsB = collisionProps[i];
+    for (int i = 0; i < uNumObjects; i++) {
+        if (i == objectIndex) continue;
         
-        // Calculate effective properties
-        float restitution = min(propsA.restitution, propsB.restitution);
-        float friction = sqrt(propsA.friction * propsB.friction);
+        Object other = objectsIn[i];
         
-        // Get masses
-        float massA = mass;
-        float massB = max(EPSILON, other.mass);
+        // Pass current positions for overlap detection, but also
+        // original (pre-update) positions for correct normal sign.
+        CollisionInfo collision = detectCollision(selfNew, other, i, p.position, other.position);
         
-        // 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];
             
-            // Apply impulse to THIS object only
-            vec2 impulse = j * collision.normal;
-            collision_vel -= impulse / massA;
+            float restitution = min(propsA.restitution, propsB.restitution);
+            float friction = sqrt(propsA.friction * propsB.friction);
             
-            // Friction
-            if (friction > 0.0) {
-                vec2 tangent = relativeVel - collision.normal * dot(relativeVel, collision.normal);
-                float tangentLength = length(tangent);
+            float massA = mass;
+            float massB = max(EPSILON, other.mass);
+            
+            vec2 relativeVel = other.velocity - collision_vel;
+            float velocityAlongNormal = dot(relativeVel, collision.normal);
+            
+            if (velocityAlongNormal < 0.0) {
+                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 impulse = j * collision.normal;
+                collision_vel -= impulse / massA;
+                
+                if (friction > 0.0) {
+                    vec2 tangent = relativeVel - collision.normal * dot(relativeVel, collision.normal);
+                    float tangentLength = length(tangent);
                     
-                    vec2 frictionImpulse = jt * tangent;
-                    collision_vel -= frictionImpulse / massA;
+                    if (tangentLength > EPSILON) {
+                        tangent = normalize(tangent);
+                        float vt = dot(relativeVel, tangent);
+                        
+                        float jt = -vt * friction;
+                        jt /= (1.0 / massA + 1.0 / massB);
+                        
+                        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;  
-        
-        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);
+            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;
+                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 (had_collision) {
+        new_vel = sanitizeVec2(collision_vel);
+    }
+    
     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);
     
-    // ========================================================================
-    // 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 to output buffer
     objectsOut[gid].position = new_pos;
     objectsOut[gid].velocity = new_vel;
     objectsOut[gid].mass = mass;
@@ -2047,8 +1862,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.64}/hyperstellar/src/hyperstellar.egg-info/PKG-INFO

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

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

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