physics_component.h

#pragma once
#include "../component.h"
#include <DirectXMath.h>
 
using namespace DirectX;
 
namespace ecs {
 
class PhysicsComponent : public Component {
public:
    PhysicsComponent() {
        m_Velocity = XMVectorZero();
        m_Acceleration = XMVectorZero();
        m_PreviousPosition = XMVectorZero();
        m_Mass = 1.0f;
        m_BoundingRadius = 1.0f;
        m_IsGrounded = false;
        m_IsPhysicsEnabled = false;
        m_GravityEnabled = true;
    }
 
    ~PhysicsComponent() = default;
 
    void Initialize() override {
        // Initialisation du composant physique
    }
 
    void Update(float deltaTime) override {
        if (!m_IsPhysicsEnabled) return;
 
        // Mise à jour de la vélocité basée sur l'accélération
        m_Velocity = m_Velocity + m_Acceleration * deltaTime;
        
        // Si la physique est activée et qu'une fonction de mise à jour de position est définie
        if (m_UpdatePositionCallback) {
            m_UpdatePositionCallback(m_Velocity * deltaTime);
        }
    }
 
    void LaunchObject(float alpha, float initialStretch, float springConstant) {
        // Constants
        const float gravity = -9.81f;
    
        // Convert alpha from degrees to radians if needed
        float alphaRadians = alpha * (XM_PI / 180.0f);
    
        // Scale factors to make the physics simulation more visible
        float scaleFactor = 200.0f;  // Adjust this based on your world scale
    
        // Calculate initial velocity magnitude
        float velocityMagnitude = initialStretch * sqrtf(springConstant / m_Mass) * 
                                  sqrtf(1.0f - powf((m_Mass * gravity * sinf(alphaRadians) / 
                                  (springConstant * initialStretch)), 2.0f));
    
        // Apply scale factor
        velocityMagnitude *= scaleFactor;
    
        // Calculate velocity components
        XMVECTOR velocity = XMVectorSet(
            velocityMagnitude * cosf(alphaRadians),  // vx = v0 * cos(alpha)
            velocityMagnitude * sinf(alphaRadians),  // vy = v0 * sin(alpha)
            0.0f,                                   // z-component (0 for 2D trajectory)
            0.0f
        );
    
        // Apply velocity
        SetVelocity(velocity);
        
        // Enable physics and reset grounded state
        SetPhysicsEnabled(true);
        SetGrounded(false);
    }
 
    void SetVelocity(XMVECTOR velocity) { m_Velocity = velocity; }
    void SetAcceleration(XMVECTOR acceleration) { m_Acceleration = acceleration; }
    void SetMass(float mass) { m_Mass = mass; }
    void SetGrounded(bool isGrounded) { m_IsGrounded = isGrounded; }
    void SetPhysicsEnabled(bool enabled) { m_IsPhysicsEnabled = enabled; }
    void SetBoundingRadius(float radius) { m_BoundingRadius = radius; }
    void SetPreviousPosition(XMVECTOR position) { m_PreviousPosition = position; }
    void SetGravityEnabled(bool enabled) { m_GravityEnabled = enabled; }
    void SetUpdatePositionCallback(std::function<void(XMVECTOR)> callback) { m_UpdatePositionCallback = callback; }
 
    XMVECTOR GetVelocity() const { return m_Velocity; }
    XMVECTOR GetAcceleration() const { return m_Acceleration; }
    float GetMass() const { return m_Mass; }
    bool IsGrounded() const { return m_IsGrounded; }
    bool IsPhysicsEnabled() const { return m_IsPhysicsEnabled; }
    float GetBoundingRadius() const { return m_BoundingRadius; }
    XMVECTOR GetPreviousPosition() const { return m_PreviousPosition; }
    bool IsGravityEnabled() const { return m_GravityEnabled; }
private:
    XMVECTOR m_Velocity;
    XMVECTOR m_Acceleration;
    XMVECTOR m_PreviousPosition;
    float m_Mass;
    float m_BoundingRadius;
    bool m_IsGrounded;
    bool m_IsPhysicsEnabled;
    bool m_GravityEnabled;
    
    // Callback pour mettre à jour la position (sera connecté au TransformComponent)
    std::function<void(XMVECTOR)> m_UpdatePositionCallback;
};
 
}  // namespace ecs