Bounce is a 3D physics engine for games.

Sorry, I know I've asked this question before but I'm still having trouble. I have a working car physics system using bounce, and I'm trying to lower the COM so that the cars are self-righting and don't keep rolling over. I'm currently doing that like this:

    b3MassData data;
    body_->GetMassData(&data);
    data.center = new_com;
    body_->SetMassData(&data);

But this makes everything behave erratically; cars spin everywhere, they get stuck into the ground etc.

What am I doing wrong?

Error at at: collision/sat/sat.cpp,129

Just hello world sample but I separate start and update so data goes outside the scope:

const scalar timeStep = 1.0f / 60.0f;
    const uint32 velocityIterations = 8;
    const uint32 positionIterations = 2;

    sptr<b3World> m_bounceWorld = nullptr;

    b3Vec3 gravity = {};

    b3BodyDef groundDef = {};
    b3Body* ground = nullptr;
    b3BoxHull groundBox = {};
    b3HullShape groundShape = {};
    b3FixtureDef groundBoxDef = {};
    b3Fixture* groundFixture = nullptr;

    b3BodyDef bodyDef = {};
    b3Body* m_body;
    b3BoxHull bodyBox = {};
    b3HullShape bodyShape = {};
    b3FixtureDef bodyBoxDef = {};
    b3Fixture* bodyFixture = nullptr;

    void emulateStart()
    {
        m_bounceWorld = make::sptr<b3World>();
        gravity = b3Vec3(0.0f, -9.8f, 0.0f);
        m_bounceWorld->SetGravity(gravity);

        // Create a static ground body at the world origin.
        ground = m_bounceWorld->CreateBody(groundDef);
        groundBox = b3BoxHull{10.0f, 1.0f, 10.0f};
        groundShape.m_hull = &groundBox;
        groundBoxDef.shape = &groundShape;
        groundFixture = ground->CreateFixture(groundBoxDef);

        // Create a dynamic body.
        bodyDef.type = e_dynamicBody;
        bodyDef.position.Set(0.0f, 10.0f, 0.0f);
        bodyDef.angularVelocity.Set(0.0f, B3_PI, 0.0f);
        m_body = m_bounceWorld->CreateBody(bodyDef);
        bodyBox.SetIdentity();
        bodyShape.m_hull = &bodyBox;
        bodyBoxDef.shape = &bodyShape;
        bodyBoxDef.density = 1.0f;
        bodyFixture = m_body->CreateFixture(bodyBoxDef);
    }

    void emulateUpdate(float dt)
    {
        W4_LOG_DEBUG("upd");
        m_bounceWorld->Step(timeStep, velocityIterations, positionIterations);
    }

    void main()
    {
        emulateStart();
        for (int i = 0; i < 100; ++i)
        {
            emulateUpdate(1.0f / 60.0f);
        }
    }

Everything works when I have start method with inlined update at the end:

void emulateStart()
    {
        m_bounceWorld = make::sptr<b3World>();
        gravity = b3Vec3(0.0f, -9.8f, 0.0f);
        m_bounceWorld->SetGravity(gravity);

        // Create a static ground body at the world origin.
        ground = m_bounceWorld->CreateBody(groundDef);
        groundBox = b3BoxHull{10.0f, 1.0f, 10.0f};
        groundShape.m_hull = &groundBox;
        groundBoxDef.shape = &groundShape;
        groundFixture = ground->CreateFixture(groundBoxDef);

        // Create a dynamic body.
        bodyDef.type = e_dynamicBody;
        bodyDef.position.Set(0.0f, 10.0f, 0.0f);
        bodyDef.angularVelocity.Set(0.0f, B3_PI, 0.0f);
        m_body = m_bounceWorld->CreateBody(bodyDef);
        bodyBox.SetIdentity();
        bodyShape.m_hull = &bodyBox;
        bodyBoxDef.shape = &bodyShape;
        bodyBoxDef.density = 1.0f;
        bodyFixture = m_body->CreateFixture(bodyBoxDef);

        for (int i = 0; i < 100; ++i)
        {
            m_bounceWorld->Step(timeStep, velocityIterations, positionIterations);
        }
    }

But I can't use this solution cuz I have separate update method in my engine

Also it looks like its broken but it works with immediate update just because memory garbage is untouched while callling it. How to locate the root of the problem?

Physx overlap https://gameworksdocs.nvidia.com/PhysX/4.1/documentation/physxguide/Manual/GeometryQueries.html#overlaps

React collide/overlap https://www.reactphysics3d.com/usermanual.html#:~:text=in%20this%20case%3A-,testOverlap(),-This%20group%20of

What's the analogue here?

Shapecasting to zero-length ray sounds ineffective. It also doesn't give me extrusion vector

Shape listener updates only inside world step so I can't manually call body.SetPosition then check if it was overlapped by something (in the same frame)

Why do I need overlap? I have kinematic character controller thats why it doesn't extrude by itself. Character can stuck inside geometry while playing (doesn't stuck manually by movement logic but it can occur sometimes, e.g. standing under moving elevator). So I need to un-stuck player in every frame before movement logic happens. Extrusion vector can be taken from contact listener but it won't update immediately after I call body.setTransform. Also seemsd like kinematic bodies doesn't make contact points. Is the solution to use dynamic bodies with zero gravity and return ShouldRespond = false for their collisions?

Is there any example of implementing optimized collision masks/matrices based on b3*Filter?

I think I need public api like

enum class layer
{
    Player = 0,
    Obstacle = 1,
    Transparent = 2
    // 3,4.5.... this isn't a bitmask
}

worldWrapper.setCollision(layer::Player, layer::Obstacle, true); // By default all collisions are disabled
bodyWrapper.addFixture(definition, scale, layer::Player);

class CustomXxxxxxxFilter : public b3XxxxxxxFilter
        {
        public:
            virtual bool ShouldRayCast(b3Fixture* fixture)
            {
                // What to do here?
            }
        };

I've implemented something like this in the last library I've switched from (https://github.com/DanielChappuis/reactphysics3d) (switched cuz it doesn't have any shapeCast):

// collisionLayer = [0..15]
typedef unsigned char collisionLayer;

struct collisionMask
{
public:
    static const collisionMask all;

    unsigned short value = 0;

    collisionMask (std::initializer_list<collisionLayer> layers)
    {
        for (int i: layers)
        {
            ASSERT(i >= 0 && i < 16);
            value |= 1 << i;
        }
    }

private:
    collisionMask (unsigned short mask) : value(mask) { }
};

class worldWrapper {
// ...
    void setEnabledCollision (collisionLayer layer1, collisionLayer layer2, bool state)
    {
        ASSERT(layer1 >= 0 && layer1 < 16);
        ASSERT(layer2 >= 0 && layer2 < 16);
        unsigned short layer1Value = 1 << layer1;
        unsigned short layer2Value = 1 << layer2;
        unsigned short firstMask = m_collisionMatrix[layer1];
        firstMask ^= firstMask & layer2Value;
        firstMask |= state ? layer2Value : 0;
        m_collisionMatrix[layer1] = firstMask;
        unsigned short secondMask = m_collisionMatrix[layer2];
        secondMask ^= secondMask & layer1Value;
        secondMask |= state ? layer1Value : 0;
        m_collisionMatrix[layer2] = secondMask;
    }

    // Layer = [0..15]
    void setColliderLayer (rp::Collider* collider, collisionLayer layer)
    {
        ASSERT(layer >= 0 && layer < 16);
        unsigned short layerValue = 1 << layer;
        collider->setCollisionCategoryBits(layerValue);
        collider->setCollideWithMaskBits(m_collisionMatrix[layer]);
    }
// ...
}

But that library has setCollisionCategoryBits and setCollideWithMaskBits (and its pretty ugly tbh) so I have to use Fixture::userData here for storing these bits (or storing global std::map<Fixture, layer> inside the worldWrapper)

Also I think its a bit unflexible so looking for another solution

shape.cpp, line 42

b3Vec3 p1 = xf * capsule->m_vertex1;
b3Vec3 p2 = xf * capsule->m_vertex2;
draw->DrawPoint(p1, scalar(4), color);
draw->DrawPoint(p2, scalar(4), color);
draw->DrawSegment(p1, p2, color);

Should be changed to

b3Vec3 c1 = xf * capsule->m_vertex1;
b3Vec3 c2 = xf * capsule->m_vertex2;
draw->DrawCapsule(c1, c2, capsule->m_radius, color);

Also API of draw:

virtual void DrawSolidCapsule(const b3Quat& rotation, const b3Vec3& p1, const b3Vec3& p2, scalar radius, const b3Color& color, bool depthEnabled = true) = 0;

rotation is found implicitly from p1 and p2 but rotation is passed as argument (DrawCapsule doesn't have this mistake)

C++ 17, emscripten

/common/template/array.h:246:3: error: explicit qualification required to use member 'Copy' from dependent base class

Solved by changing Line 246 from:

Copy(other);

to

this->Copy(other);

http://www.cs.technion.ac.il/users/yechiel/CS/FAQs/c++-faq/nondependent-name-lookup-members.html

I'm using Bounce on a SEGA Dreamcast game, and as you can imagine that's a fairly resource constrained system!

Everything is working fine, but I'm trying to squeeze out some last bits of performance.

Interestingly, 3% of my frame-time is going into b3SphereShape::ComputeAABB - specifically it's the subsequent calls to b3Mul, and b3Cross.

I was wondering if that rotation is necessary there, or is it enough to just add m_center to xf.translation?

I mean B3_VEC3_CLASS_EXTRA in user_settings.h like in https://github.com/ocornut/imgui/blob/master/imconfig.h#L85 For vec2, vec3, vec4, transform and quaternion implicit convertion in client code

My compiler has flagged this:

warning: self-comparison always evaluates to false [-Wtautological-compare]
 1696 |   } while (edge != edge);

Looks like a bug?

Fixes build on ubuntu 18 with gcc-7.5. Fixes 2 types of errors: 1#

/home/dee/dev/test/bounce/include/bounce/common/time.h:182:48: error: ‘c0’ was not declared in this scope
         double dt = 1000.0 * double(c.tv_sec - c0.tv_sec) + 1.0e-6 * double(c.tv_nsec - c0.tv_nsec);

2#

bounce/dynamics/contacts/hull_sphere_contact.cpp:27:60: error: no matching function for call to ‘operator new(sizetype, void*&)’
  return new (mem) b3HullAndSphereContact(fixtureA, fixtureB);
  
/bounce/dynamics/contacts/triangle_capsule_contact.cpp:27:65: error: no matching function for call to ‘operator new(sizetype, void*&)’
  return new (mem) b3TriangleAndCapsuleContact(fixtureA, fixtureB);
etc.