Hi there. I want to develop a physics engine for an artificial life system, similar to the seminal work by Karl Sims. I have a master's degree in artificial life, so that aspect is no problem, it's the physics engine I am concerned most about.

Of course I want it to be as fast as possible, but since it is for an offline process, it doesn't need to be realtime. That is, speed and efficiency are much less important than precision and portability/determinism, specifically with regards to energy conservation.

Sims' system used Featherstone's reduced coordinate algorithm, with Runge-Kutta-Fehlberg (fourth order) integration. But that was 30 years ago. Is it still a good way to go? Are there better approaches? Position based systems are newer, but as far as I understand, they eschew precision for speed, for realtime systems like games, right?

My question is, which approach would you take? Which papers, open source projects, videos, or articles do you think I should look at? What are the issues that will become important?

Also, please don't say "just use an existing engine." This is a hobby project for me to learn more about implementing physics engines. I am not new to physics engine development, but I am no expert either. I have created a variety of engines in the past (rigid and soft), but that was a while ago, and my programming ability is much better than my maths skills.

Thanks!

Hi all, I was recently looking into how to add basic physics to a small 3D graphics engine I have so I can start making a small game in it. I was wondering if anybody has any tips on where to start with this. More specifically, I am kind of looking at making it on my own to learn about how a basic physics engine might work. I'm not opposed to using a library, I just want to learn how it works under the hood first.

Over the past few days I've been looking into space partitioning (BSPs, Octrees). Is this a good place to start or should I be looking at something else? I don't plan on making anything too complex, but I would like to have a player that walks around and can collide with other game objects.

If space partitioning is the way to go, where do I go from there? I get the ideas of how to code them, but the actual practical use of how this helps with collisions is still a bit lost on me. I understand that you want to only check things that are close to each other but I still don't know how to do the actual collision check. Is AABB good enough for stuff like this or is there a better way to check for collisions when objects aren't necessarily aligned with an axis? Not to mention, what happens when an object covers the entire map (like a plane)?

I don't necessarily need answers for each of these questions, just a general idea of where to go to learn about and figure them out myself (Although if you do want to give an answer to one of the specific questions please feel free).

Any advice would be very helpful, thanks.

So, I'm in the process of understanding how a 2d physics engine works. I understand how axis-aligned bounding boxes work and the separating axis theorem, as well as impulse resolution. As of now, the math seems not too complicated (although i'm sure it will be in the future). However, what I don't get is how do I actually make a simulation. Like a visible window on my computer with the AABBs and all that? Can somebody link some tutorials on how to actually program one?

Hi I was wondering how a physics engine works and found Box2D but no good explanation how this works. So I decided to delve deeper into the topic and create a tutorial for this:

https://github.com/XMAMan/SmallSI

Can you please give me feedback on whether the explanation is understandable?

Can engineers get into space research? Or is a physics degree a more beneficial option?

Is there a timing involved between spin and when TORQUE initiates or not? Is torque instantaneous to spin?

Hey! I'm trying to make a physics engine in C++ and I have a rigidbody script and a function for resolving collisions. But when the distance between one rigidbody and another becomes slightly larger, the rigidbody with less mass just slides off. I do not want this ofcourse. Please help me. This is my function for resolving collisions:
void ResolveCollisionsIgnoreFirst(Rigidbody& boxRigidbody, Rigidbody& rigidbody)

void ResolveCollisions(Rigidbody& rigidbody, Rigidbody& boxRigidbody)
{
    float distance = glm::distance(rigidbody.getPosition(), boxRigidbody.getPosition());
    std::cout << distance;

    // Calculate minimum penetration depth based on combined radius/bounding box half size
    float minimumPenetrationDepth = rigidbody.getMass() + boxRigidbody.getMass();

    if (distance - minimumPenetrationDepth <= 0.01f)
    {
        glm::vec3 collisionNormal = glm::normalize(rigidbody.getPosition() - boxRigidbody.getPosition());

        // Calculate relative velocity
        glm::vec3 relativeVelocity = rigidbody.getVelocity() - boxRigidbody.getVelocity();
        float relativeVelocityNormal = glm::dot(relativeVelocity, collisionNormal);

        float restitution = 0.1f; // Adjust the coefficient as needed

        // Calculate impulse magnitude for normal direction
        float j = -(1 + restitution) * relativeVelocityNormal;
        j /= 1 / rigidbody.getMass() + 1 / boxRigidbody.getMass();

        // Apply impulse for normal direction
        glm::vec3 impulse = j * collisionNormal;

        // Update velocities for normal direction
        rigidbody.setVelocity(rigidbody.getVelocity() + impulse / rigidbody.getMass());

        // Resolve penetration
        (rigidbody.getMass() + boxRigidbody.getMass()); // Use combined mass for center of mass calculation
        const float percent = 0.2f; // Penetration percentage to correct
        const float slop = 0.1f; // Allowance to prevent jittering
        float penetrationDepth = calculatePenetrationDepth(rigidbody, boxRigidbody);
        glm::vec3 desiredDistance =
            0.5f * (rigidbody.getBoundingBoxMax() - rigidbody.getBoundingBoxMin()) +
            0.5f * (boxRigidbody.getBoundingBoxMax() - boxRigidbody.getBoundingBoxMin());; // Calculate desired non-penetration distance (e.g., sum of bounding box half sizes)
        float desiredDistanceMagnitude = glm::length(desiredDistance);
        float penetrationDepthBruh = desiredDistanceMagnitude - distance;

        if (penetrationDepthBruh > slop) {
            glm::vec3 correction = penetrationDepth * collisionNormal;
            rigidbody.setPosition(rigidbody.getPosition() + correction);
        }

        // Calculate relative velocity in the direction of the tangent (friction)
        glm::vec3 relativeVelocityTangent = relativeVelocity - (glm::dot(relativeVelocity, collisionNormal) * collisionNormal);
        float relativeVelocityTangentMagnitude = glm::length(relativeVelocityTangent);

        // Calculate friction coefficient
        float staticFrictionThreshold = 0.001f;
        float frictionCoefficient = 0.1f;

        // Apply friction impulse if there's relative tangential velocity
        if (relativeVelocityTangentMagnitude < staticFrictionThreshold) {
            // If relative tangential velocity is low, apply static friction to prevent sliding
            // Calculate static friction impulse
            glm::vec3 staticFrictionImpulseA = -relativeVelocityTangent * rigidbody.getMass(); // Opposes motion
            glm::vec3 staticFrictionImpulseB = -relativeVelocityTangent * boxRigidbody.getMass(); // Opposes motion

            // Apply static friction impulse
            rigidbody.setVelocity(rigidbody.getVelocity() + staticFrictionImpulseA / rigidbody.getMass());
        }
        else {
            // If relative tangential velocity is high, apply dynamic friction
            // Calculate friction coefficient
            float frictionCoefficient = 0.1f; // Adjust as needed

            // Apply friction impulse if there's relative tangential velocity
            // Calculate impulse magnitude for friction
            float frictionImpulseMagnitude = frictionCoefficient * j;

            // Clamp friction impulse magnitude to prevent reversal of relative motion
            frictionImpulseMagnitude = std::min(frictionImpulseMagnitude, relativeVelocityTangentMagnitude);

            // Calculate friction impulse vector
            glm::vec3 frictionImpulse = glm::normalize(relativeVelocityTangent) * frictionImpulseMagnitude;

            // Apply friction impulse
            rigidbody.setVelocity(rigidbody.getVelocity() - frictionImpulse / rigidbody.getMass());
        }

        // Calculate angular velocity change due to collision
        glm::vec3 rA = rigidbody.getPosition() - boxRigidbody.getPosition();
        glm::vec3 rB = boxRigidbody.getPosition() - rigidbody.getPosition();
        glm::vec3 angularVelocityChangeA = glm::cross(rA, impulse) / rigidbody.getMass();
        glm::vec3 angularVelocityChangeB = glm::cross(rB, -impulse) / boxRigidbody.getMass();

        // Apply angular velocity change
        rigidbody.setRotation(rigidbody.getRotation() + angularVelocityChangeA);
    }
}

And if you were wondering, this is my rigidbody script: https://pastebin.com/uayq9zE5

What would happen if Jupiter, Saturn, Uranus, and/or Neptune were to be condensed to the volume of earth or our moon, while maintaining its mass, gravitational field, and internal and external rotation, in exchange for amplifying its density & magnetic field?

(Bonus question Ie: What would happen if nothing but the volume of earth plus those and that within where to be be shrunken?)

I am trying to figure out how to determine the fill level of an arbitrarily oriented container (a fairly arbitrary shape) . I could use Unity's physics engine if I need to (though I wouldn't know how for this particular problem), but I was really hoping to do so directly in code. I don't need a full example, pointers would be great though.

Hi, i am wondering what are the differences/ pros and cons of different simulators that are often used to simulate articulated bodies . The main ones that come to mind are Pybullet, Raisim, mujoco and Isaac.

I know that Unreal uses PhyX physics engine and Gazebo used by Default ODF or Bullet. I would like to know the pros and cons of both of them.

I have been trying to learn how to write a simple physics engine, and have a few rigid bodies moving around under the control of forces. I understand the basics of integrating accelerations and velocities, and applying forces and impulses to rigid bodies.

But I just don't get constraints. I can't find resources for implementing simple constraints. I've glanced at some open source engines but they are well beyond me. When I try to search of information about constraints, it's either simplistic tutorials for bouncing rotationless particles off walls or each other, or people talking about how to use constraints in an existing physics engine, or extremely abstract mathematical concepts that I can't relate to the application.

Currently I am trying to make a simple position constraint between two 2D rigid bodies. That's all. Like a hinge on a ragdoll. I understand what 'satisfy the constraint' means in terms of the desired behaviour, but I can't picture it with regards to what the actual code needs to do. Do I have to work out impulses that nullify the separating velocity AND pull the joint together in the next time step? I just can't seem to grasp or visualise what's needed.

I used equations from Chris Hecker's brilliant 4-part tutorial to get rigid body collision response working, but I don't understand how to go from there to a hinge. I suspect it's simple, but it's beyond my understanding.

Sorry, I know this is a fairly basic question, but I'd really appreciate it if someone could explain the concept of solving constraints in English, without immediately diving into energy functions and Jacobians and Lagrange multipliers. My mathematics is much weaker than my programming skills. I'd love to learn more mathematics related to this topic, but I need to know what it is I'm trying to achieve.

Is there someone out there who'd be willing to field a few basic(ish) questions about solving physics systems?

Panther Robotics is a middle school club here in Maryland. The students had an idea similar to reaction wheels. I have no ability to simulate it in a physics engine. If anyone would be interested in modeling it for them, we would be grateful.

Hello everyone, I am interested in coding a physics engine in either C or C++ I haven't decided yet. I want to code everything from the ground up not just use Unreal or Unity. What I don't understand is how do I go from typing code in VS Code to watching my code bounce a ball off the wall? What program would I use to turn that code into a visual simulation? Sorry if this is a dumb question.