Rigidbodies

auto rb = std::make_shared<Rigidbody>();
rb->setMotionType(MotionType::Dynamic);
rb->setMass(5.0f);
rb->addBoxCollider({0.5f, 0.5f, 0.5f});
rb->setFriction(0.8f);

enum class MotionType { 
    Static,    // Immovable, zero velocity
    Dynamic,   // Fully simulated with forces and collisions
    Kinematic  // Movable but not affected by forces
};

auto ground = std::make_shared<Rigidbody>();
ground->setMotionType(MotionType::Static);
ground->addBoxCollider({10.0f, 0.1f, 10.0f});

auto ball = std::make_shared<Rigidbody>();
ball->setMotionType(MotionType::Dynamic);
ball->setMass(1.0f);
ball->addSphereCollider(0.5f);
ball->applyImpulse({0.0f, 10.0f, 0.0f});

auto platform = std::make_shared<Rigidbody>();
platform->setMotionType(MotionType::Kinematic);
platform->addBoxCollider({2.0f, 0.1f, 2.0f});
// Move directly via transform

// Set mass in kilograms
rigidbody->setMass(10.0f);

// Lower mass = easier to move
rigidbody->setMass(0.5f);  // Light object
rigidbody->setMass(100.0f); // Heavy object

// Set friction coefficient (0.0 = frictionless, 1.0 = high friction)
rigidbody->setFriction(0.5f);

// Examples:
rigidbody->setFriction(0.0f);  // Ice
rigidbody->setFriction(0.5f);  // Default
rigidbody->setFriction(0.9f);  // Rubber

// Set restitution (0.0 = no bounce, 1.0 = perfect bounce)
rigidbody->setRestitution(0.7f);

// Examples:
rigidbody->setRestitution(0.0f);  // No bounce
rigidbody->setRestitution(0.5f);  // Some bounce
rigidbody->setRestitution(0.9f);  // Very bouncy

// Set linear and angular damping
rigidbody->setDamping(0.05f, 0.1f);

// Lower values = less damping (objects move longer)
// Higher values = more damping (objects slow down faster)

// Apply force at center of mass
rigidbody->applyForce({0.0f, 100.0f, 0.0f});

// Apply force at a specific world-space point
rigidbody->applyForceAtPoint(
    {10.0f, 0.0f, 0.0f},  // Force vector
    {0.0f, 1.0f, 0.0f}    // Application point
);

// Apply impulse (from test/main.cpp:120)
if (object && object->rigidbody) {
    object->rigidbody->applyImpulse({0.0f, 0.0f, 20.0f});
}

// Set linear velocity directly
rigidbody->setLinearVelocity({5.0f, 0.0f, 0.0f});

// Set angular velocity
rigidbody->setAngularVelocity({0.0f, 1.0f, 0.0f});

// Add to existing linear velocity
rigidbody->addLinearVelocity({0.0f, 5.0f, 0.0f});

// Add to existing angular velocity
rigidbody->addAngularVelocity({0.0f, 0.5f, 0.0f});

// Get current velocities
Velocity3d linearVel = rigidbody->getLinearVelocity();
Velocity3d angularVel = rigidbody->getAngularVelocity();
Velocity3d totalVel = rigidbody->getVelocity();

// Set maximum velocities
rigidbody->setMaxLinearVelocity(50.0f);
rigidbody->setMaxAngularVelocity(10.0f);

// Add tags
rigidbody->addTag("Player");
rigidbody->addTag("Enemy");

// Check for tags
if (rigidbody->hasTag("Player")) {
    // Player-specific logic
}

// Remove tags
rigidbody->removeTag("Enemy");

// Use tags with raycasts
rigidbody->raycastTagged({"Enemy", "Obstacle"}, direction, 100.0f);

std::vector<std::string> tags;

auto sensor = std::make_shared<Sensor>();
sensor->addSphereCollider(1.0f);
sensor->setSignal("PlayerEnteredZone");

class Sensor final : public Rigidbody {
  public:
    Sensor() { Rigidbody::isSensor = true; }
    
    void setSignal(const std::string &signal) { 
        sendSignal = signal; 
    }
};

// Cast ray from rigidbody position
rigidbody->raycast({0.0f, -1.0f, 0.0f}, 100.0f);

// Cast ray with all hits
rigidbody->raycastAll({0.0f, -1.0f, 0.0f}, 100.0f);

// Cast ray from arbitrary world position
rigidbody->raycastWorld(
    {0.0f, 10.0f, 0.0f},   // Origin
    {0.0f, -1.0f, 0.0f},   // Direction
    100.0f                  // Max distance
);

// Cast with tag filtering
rigidbody->raycastTagged(
    {"Enemy", "Destructible"},  // Tags to hit
    {0.0f, -1.0f, 0.0f},
    100.0f
);

// Check overlap at current position
rigidbody->overlap();

// Check overlap with specific shapes
rigidbody->overlapSphere(2.0f);
rigidbody->overlapBox({1.0f, 1.0f, 1.0f});
rigidbody->overlapCapsule(0.5f, 2.0f);

// Check overlap at world position
rigidbody->overlapSphereWorld({0.0f, 5.0f, 0.0f}, 1.0f);

Position3d endPosition = {5.0f, 0.0f, 0.0f};

// Predict movement with current collider
rigidbody->predictMovement(endPosition);

// Predict with specific shapes
rigidbody->predictMovementSphere(endPosition, 0.5f);
rigidbody->predictMovementBox(endPosition, {0.5f, 0.5f, 0.5f});

// Get all hits along path
rigidbody->predictMovementAll(endPosition);

class MyComponent : public Component {
    void onQueryReceive(QueryResult& result) override {
        if (result.operation == QueryOperation::Raycast) {
            if (result.raycastResult.hit.didHit) {
                std::cout << "Hit at distance: " 
                          << result.raycastResult.hit.distance << std::endl;
            }
        }
    }
};

// Set position (updates physics body)
rigidbody->body->setPosition(
    {10.0f, 5.0f, 0.0f},
    physicsWorld
);

// Set rotation (updates physics body)
rigidbody->body->setRotation(
    {0.0f, 45.0f, 0.0f},
    physicsWorld
);

// Create physics world
auto world = std::make_shared<bezel::PhysicsWorld>();
world->init();
world->setGravity({0.0f, -9.81f, 0.0f});

// Create ground
auto ground = std::make_shared<Rigidbody>();
ground->setMotionType(MotionType::Static);
ground->addBoxCollider({10.0f, 0.1f, 10.0f});
ground->setFriction(0.5f);

// Create ball
auto ball = std::make_shared<Rigidbody>();
ball->setMotionType(MotionType::Dynamic);
ball->setMass(1.0f);
ball->addSphereCollider(0.5f);
ball->setRestitution(0.8f);  // Bouncy!
ball->setFriction(0.3f);
ball->applyImpulse({0.0f, 10.0f, 0.0f});

// Update loop
while (running) {
    world->update(deltaTime);
}