hyperstellar 0.1.64__tar.gz → 0.1.65__tar.gz

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

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

{hyperstellar-0.1.64 → hyperstellar-0.1.65}/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
@@ -1120,54 +1120,52 @@ 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;
-        info.penetration = radiusSum - dist;
+        info.normal = delta / dist;           // Collision normal (A→B)
+        info.penetration = radiusSum - dist;  // Overlap depth
     }
     
     return info;
 }
 
-// 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)
+// 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;
-
-    vec2 delta = posB - posA;                     // current (possibly overshot)
+    
+    // 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;
-
-        // 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;
-
+        
+        // Resolve along minimum penetration axis
         if (overlap.x < overlap.y)
         {
-            info.normal = vec2(sign(oldDelta.x), 0.0);
+            info.normal = vec2(sign(delta.x), 0.0);
             info.penetration = overlap.x;
         }
         else
         {
-            info.normal = vec2(0.0, sign(oldDelta.y));
+            info.normal = vec2(0.0, sign(delta.y));
             info.penetration = overlap.y;
         }
     }
+    
     return info;
 }
 
@@ -1179,6 +1177,7 @@ 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;
@@ -1197,9 +1196,11 @@ 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));
 }
 
@@ -1214,6 +1215,7 @@ 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++)
@@ -1225,18 +1227,24 @@ 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;
+            return info; // Separating axis found, no collision
         
+        // 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;
         }
@@ -1254,6 +1262,7 @@ 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);
@@ -1265,11 +1274,13 @@ 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;
@@ -1300,24 +1311,30 @@ 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;
@@ -1327,9 +1344,11 @@ 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;
@@ -1343,11 +1362,13 @@ 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;
     
@@ -1366,38 +1387,43 @@ CollisionInfo detectCirclePolygon(vec2 circlePos, float circleRadius,
     return info;
 }
 
-// Master collision detection dispatcher (now with old positions for AABB fix)
-CollisionInfo detectCollision(Object objA, Object objB, int objIndexB,
-                              vec2 oldPosA, vec2 oldPosB)
+// 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,
-                              oldPosA, oldPosB, objIndexB);
+        info = detectAABBAABB(objA.position, halfExtA, 
+                             objB.position, halfExtB, objIndexB);
     }
+    // Polygon vs Polygon
     else if (shapeA == COLLISION_POLYGON && shapeB == COLLISION_POLYGON)
     {
         info = detectPolygonPolygon(
@@ -1405,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;
@@ -1413,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;
+        info.normal = -info.normal; // Flip normal
     }
+    // Circle vs Polygon
     else if (shapeA == COLLISION_CIRCLE && shapeB == COLLISION_POLYGON)
     {
         info = detectCirclePolygon(objA.position, objA.visualData.x,
@@ -1431,14 +1460,15 @@ 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
     }
+    // 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;
+        info.normal = -info.normal; // Flip normal
     }
     else if (shapeA == COLLISION_POLYGON && shapeB == COLLISION_AABB)
     {
@@ -1451,7 +1481,11 @@ CollisionInfo detectCollision(Object objA, Object objB, int objIndexB,
 }
 
 // ============================================================================
-// NEW: RESEARCH-GRADE COLLISION RESOLUTION SYSTEM
+// RESEARCH-GRADE COLLISION RESOLUTION SYSTEM
+// ============================================================================
+
+// ============================================================================
+// BASIC COLLISION RESPONSE (Momentum-Conserving)
 // ============================================================================
 
 // Apply collision response to two objects (conserves momentum and energy)
@@ -1461,51 +1495,73 @@ void applyCollisionResponse(
     vec2 normal, float penetration,
     float restitution, float friction
 ) {
+    // Ensure valid masses
     if (massA < EPSILON || massB < EPSILON) return;
     
-    const float positionCorrectionFactor = 0.8;
-    const float penetrationSlop = 0.001;
+    // ========================================================================
+    // 1. POSITION CORRECTION (Separating objects)
+    // ========================================================================
+    const float positionCorrectionFactor = 0.8;  // Baumgarte stabilization
+    const float penetrationSlop = 0.001;         // Allow small penetration
     
     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;
     
-    float e = min(max(restitution, 0.0), 1.0);
+    // Calculate impulse scalar (conserves momentum and energy)
+    float e = min(max(restitution, 0.0), 1.0);  // Clamp restitution
     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;
@@ -1513,7 +1569,12 @@ void applyCollisionResponse(
     }
 }
 
-// Simplified collision resolution for parallel execution
+// ============================================================================
+// 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
 void resolveCollisionSimple(
     inout vec2 posA, inout vec2 velA, float massA,
     Object objB, int objBIndex,
@@ -1521,21 +1582,26 @@ 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,
@@ -1543,16 +1609,25 @@ 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
 }
 
-// Elastic collision formula (for perfect conservation)
+// ============================================================================
+// ANALYTICAL ELASTIC COLLISION FORMULA (For perfect conservation)
+// ============================================================================
+
+// Perfectly elastic collision for circles (conserves both momentum and energy)
 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;
@@ -1560,17 +1635,21 @@ 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;
     
@@ -1578,7 +1657,11 @@ void resolveElasticCollision(
     velB = velB - massRatioC * impulseB;
 }
 
-// Contact persistence system
+// ============================================================================
+// CONTACT PERSISTENCE SYSTEM (Optional, for stability)
+// ============================================================================
+
+// Find a persistent contact in the contact buffer
 int findPersistentContact(int objectA, int objectB, vec2 normal) {
     int baseIndex = objectA * MAX_CONTACTS_PER_OBJECT;
     
@@ -1588,26 +1671,32 @@ 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;
+    return -1; // No persistent contact found
 }
 
+// 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;
@@ -1615,12 +1704,14 @@ 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;
@@ -1631,6 +1722,7 @@ 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;
     
@@ -1638,9 +1730,11 @@ 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;
             }
@@ -1649,14 +1743,16 @@ void ageContacts(int objectIndex) {
 }
 
 // ============================================================================
-// MAIN COMPUTE SHADER ENTRY POINT - WITH AABB COLLISION FIX
+// MAIN COMPUTE SHADER ENTRY POINT - UPDATED WITH FIXED COLLISION RESOLUTION
 // ============================================================================
 
 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;
@@ -1668,12 +1764,16 @@ 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 || 
@@ -1685,18 +1785,22 @@ 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,
@@ -1705,6 +1809,7 @@ 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,
@@ -1712,6 +1817,7 @@ 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,
@@ -1736,31 +1842,42 @@ void main() {
             new_color = sanitizeVec4(new_color);
         }
     } else {
+        // Default physics mode (simple spring-mass-damper)
         acceleration = calculateDefaultPhysics(pos, vel, mass);
     }
     
     acceleration = sanitizeVec2(acceleration);
     
-    // Symplectic Euler integration
+    // ========================================================================
+    // STABLE INTEGRATION (Symplectic Euler - Energy Conserving)
+    // ========================================================================
+    
+    // 1. Update VELOCITY first using current acceleration
     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;
-    selfNew.position = 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);
+    new_rotation = mod(new_rotation, 2.0 * PI);  // Wrap rotation
     
+    // ========================================================================
+    // CONSTRAINT RESOLUTION (UNCHANGED)
+    // ========================================================================
     applyConstraints(new_pos, new_vel, objectIndex, originalPos);
-    
+
     // ========================================================================
-    // COLLISION HANDLING - using old positions for normal sign in AABB case
+    // 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;
     
     for (int i = 0; i < uNumObjects; i++) {
@@ -1768,9 +1885,8 @@ void main() {
         
         Object other = objectsIn[i];
         
-        // 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);
+        // Keep your selfNew detection - this is what made circles bouncy
+        CollisionInfo collision = detectCollision(selfNew, other, i);   // <--- selfNew here
         
         if (collision.hasCollision) {
             had_collision = true;
@@ -1784,43 +1900,45 @@ void main() {
             float massA = mass;
             float massB = max(EPSILON, other.mass);
             
+            // Velocity impulse (asymmetric - only affect this object)
             vec2 relativeVel = other.velocity - collision_vel;
-            float velocityAlongNormal = dot(relativeVel, collision.normal);
+            float velAlongNormal = dot(relativeVel, collision.normal);
             
-            if (velocityAlongNormal < 0.0) {
+            if (velAlongNormal < 0.0) {   // approaching
                 float e = clamp(restitution, 0.0, 1.0);
-                float j = -(1.0 + e) * velocityAlongNormal;
-                j /= (1.0 / massA + 1.0 / massB);
+                float j = -(1.0 + e) * velAlongNormal / (1.0 / massA + 1.0 / massB);
                 
-                vec2 impulse = j * collision.normal;
-                collision_vel -= impulse / massA;
+                collision_vel -= (j * collision.normal) / massA;
                 
+                // Friction - conservative
                 if (friction > 0.0) {
                     vec2 tangent = relativeVel - collision.normal * dot(relativeVel, collision.normal);
-                    float tangentLength = length(tangent);
-                    
-                    if (tangentLength > EPSILON) {
+                    float tLen = length(tangent);
+                    if (tLen > 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;
+                        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;
                     }
                 }
             }
             
-            const float slop = 0.01;
-            const float percent = 0.4;
+            // 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;
-                new_pos -= correction * (massB / totalMass);
+                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;
             }
         }
     }
@@ -1828,21 +1946,35 @@ void main() {
     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.)
+    // ========================================================================
     
+    // Age out old contacts for this object
     if (uEnableWarmStart == 1) {
         ageContacts(objectIndex);
     }
     
+    // 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 to output buffer
+    // ========================================================================
+    // WRITE UPDATED OBJECT STATE 
+    // ========================================================================
     objectsOut[gid].position = new_pos;
     objectsOut[gid].velocity = new_vel;
     objectsOut[gid].mass = mass;

{hyperstellar-0.1.64 → hyperstellar-0.1.65}/hyperstellar/src/hyperstellar.egg-info/PKG-INFO

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

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

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