SoftBody.hpp

Go to the documentation of this file.

/**************************************************************************
 * EngineSquared v0.1.1
 *
 * EngineSquared is a software package, part of the Engine² organization.
 *
 * This file is part of the EngineSquared project that is under MIT License.
 * Copyright © 2025-present by @EngineSquared, All rights reserved.
 *
 * EngineSquared is a free software: you can redistribute it and/or modify
 * it under the terms of the MIT License. See the project's LICENSE file for
 * the full license text and details.
 *
 * @file SoftBody.hpp
 * @brief Soft body component for deformable physics objects
 *
 * Integrates with Jolt Physics SoftBody system for cloth, ropes, and
 * deformable objects with realistic physics simulation.
 *
 * @author @EngineSquared
 * @version 0.1.1
 * @date 2025-12-05
 **************************************************************************/
 
#pragma once
 
#include <algorithm>
#include <glm/glm.hpp>
#include <glm/gtc/quaternion.hpp>
#include <utility>
#include <vector>
 
#include "component/Mesh.hpp"
 
namespace Physics::Component {

enum class SoftBodyType {
    Custom,   
    Cloth,    
    Rope,     
    Cube,     
    Pressure, 
};

struct SoftBodySettings {
    //=========================================================================
    // Simulation parameters
    //=========================================================================

    uint32_t solverIterations = 5;

    float linearDamping = 0.1f;

    float maxLinearVelocity = 500.0f;

    float gravityFactor = 1.0f;
 
    //=========================================================================
    // Material properties
    //=========================================================================

    float restitution = 0.0f;

    float friction = 0.2f;

    float pressure = 0.0f;
 
    //=========================================================================
    // Constraint parameters
    //=========================================================================

    float edgeCompliance = 0.0f;

    float shearCompliance = 0.0f;

    float bendCompliance = 1.0f;
 
    //=========================================================================
    // Collision
    //=========================================================================

    float vertexRadius = 0.0f;

    bool allowSleeping = true;

    bool doubleSidedFaces = false;
 
    //=========================================================================
    // Factory methods
    //=========================================================================

    static SoftBodySettings Default() { return {}; }

    static SoftBodySettings Cloth(float stiffness = 0.5f)
    {
        SoftBodySettings s;
        s.solverIterations = 8;
        s.linearDamping = 0.2f;
        s.gravityFactor = 1.0f;
        s.friction = 0.3f;
        s.edgeCompliance = (1.0f - stiffness) * 0.001f;
        s.shearCompliance = (1.0f - stiffness) * 0.002f;
        s.bendCompliance = (1.0f - stiffness) * 0.5f;
        s.vertexRadius = 0.01f;
        s.doubleSidedFaces = true;
        return s;
    }

    static SoftBodySettings Rope(float stiffness = 0.9f)
    {
        SoftBodySettings s;
        s.solverIterations = 10;
        s.linearDamping = 0.3f;
        s.gravityFactor = 1.0f;
        s.friction = 0.5f;
        s.edgeCompliance = (1.0f - stiffness) * 0.0001f;
        s.shearCompliance = 1e10f; // Disable shear for 1D
        s.bendCompliance = (1.0f - stiffness) * 0.01f;
        s.vertexRadius = 0.02f;
        return s;
    }

    static SoftBodySettings Balloon(float pressure = 1000.0f)
    {
        SoftBodySettings s;
        s.solverIterations = 10;
        s.linearDamping = 0.1f;
        s.pressure = pressure;
        s.restitution = 0.5f;
        s.friction = 0.3f;
        // Jolt defaults: { 1.0e-4f, 1.0e-4f, 1.0e-3f } for edge/shear/bend
        s.edgeCompliance = 1.0e-4f;
        s.shearCompliance = 1.0e-4f;
        s.bendCompliance = 1.0e-3f;
        s.vertexRadius = 0.02f; // Small, only for z-fighting prevention
        return s;
    }

    static SoftBodySettings Jelly()
    {
        SoftBodySettings s;
        s.solverIterations = 5;
        s.linearDamping = 0.2f;
        s.restitution = 0.8f;
        s.friction = 0.1f;
        s.edgeCompliance = 0.01f;
        s.shearCompliance = 0.02f;
        s.bendCompliance = 0.5f;
        s.pressure = 500.0f;
        return s;
    }
};

struct SoftBody {
    //=========================================================================
    // Configuration
    //=========================================================================

    SoftBodyType type = SoftBodyType::Custom;

    SoftBodySettings settings;
 
    //=========================================================================
    // Per-vertex physics data (parallel arrays with Mesh.vertices)
    //=========================================================================

    std::vector<float> invMasses;

    std::vector<uint32_t> pinnedVertices;

    std::vector<std::pair<uint32_t, uint32_t>> edges;
 
    //=========================================================================
    // Methods
    //=========================================================================

    [[nodiscard]] size_t GetVertexCount() const { return invMasses.size(); }

    [[nodiscard]] size_t GetEdgeCount() const { return edges.size(); }

    void PinVertex(uint32_t vertexIndex)
    {
        if (vertexIndex < invMasses.size())
        {
            invMasses[vertexIndex] = 0.0f;
            if (std::ranges::find(pinnedVertices, vertexIndex) == pinnedVertices.end())
            {
                pinnedVertices.push_back(vertexIndex);
            }
        }
    }

    void UnpinVertex(uint32_t vertexIndex, float mass = 1.0f)
    {
        static constexpr float kMinMass = 1.0e-6f;
 
        if (vertexIndex >= invMasses.size())
            return;
 
        if (mass <= 0.0f)
        {
            // mass <= 0 means pin the vertex, delegate to PinVertex
            PinVertex(vertexIndex);
            return;
        }
 
        float safeMass = mass < kMinMass ? kMinMass : mass;
        invMasses[vertexIndex] = 1.0f / safeMass;
        pinnedVertices.erase(std::ranges::remove(pinnedVertices, vertexIndex).begin(), pinnedVertices.end());
    }

    [[nodiscard]] bool IsVertexPinned(uint32_t vertexIndex) const
    {
        return vertexIndex < invMasses.size() && invMasses[vertexIndex] == 0.0f;
    }

    [[nodiscard]] bool IsValid() const { return !invMasses.empty(); }
 
    //=========================================================================
    // Constructors
    //=========================================================================

    SoftBody() = default;

    explicit SoftBody(const SoftBodySettings &settings) : settings(settings) {}

    SoftBody(SoftBodyType bodyType, const SoftBodySettings &settings) : type(bodyType), settings(settings) {}
};
 
} // namespace Physics::Component