PhysicsShape.h

//
//  PhysicsShape.h
//  avara3d
//
//  Created by Morgan Davis on 1/25/18.
//  Copyright © 2026 Morgan K Davis. All rights reserved.
//
 
#ifndef AVARA3D_PHYSICS_SHAPE_PHYSICSSHAPE_H
#define AVARA3D_PHYSICS_SHAPE_PHYSICSSHAPE_H
 
#include <cstdint>
#include <memory>
#include <optional>
#include <unordered_set>
#include <variant>
 
#include "a3d/physics/PhysicsBody.h"
 
namespace a3d {
 
class Mesh;
class Node;
class PhysicsWorld;
class PhysicsShapeProxy;
class Scene;
 
class PhysicsShape {
 
public:
    // [Public Types]
 
    enum class Type : uint8_t {
        // TODO: change this
        Primitive, 
        BoundingBox, 
        ConvexHull, 
        ConcavePolyhedron 
    };
 
    using Source = std::variant<std::monostate, std::weak_ptr<Mesh>, std::weak_ptr<Node>>;
 
    // [Public Static Member Functions]
 
    static std::shared_ptr<PhysicsShape> BoundingBoxShape(const std::shared_ptr<Mesh>& mesh);
 
    static std::shared_ptr<PhysicsShape> BoundingBoxShape(const std::shared_ptr<Node>& node);
 
    static std::shared_ptr<PhysicsShape> ConvexHullShape(const std::shared_ptr<Mesh>& mesh);
 
    static std::shared_ptr<PhysicsShape> ConvexHullShape(const std::shared_ptr<Node>& node);
 
    static std::shared_ptr<PhysicsShape> ConcavePolyhedronShape(const std::shared_ptr<Mesh>& mesh);
 
    static std::shared_ptr<PhysicsShape> ConcavePolyhedronShape(const std::shared_ptr<Node>& node);
 
    // [Public Lifecycle Functions]
 
    PhysicsShape(Type type, const std::shared_ptr<Mesh>& mesh);
 
    PhysicsShape(Type type, const std::shared_ptr<Node>& node);
 
    PhysicsShape(const PhysicsShape&)            = delete;
    PhysicsShape& operator=(const PhysicsShape&) = delete;
 
    PhysicsShape(PhysicsShape&&)            = delete;
    PhysicsShape& operator=(PhysicsShape&&) = delete;
 
    virtual ~PhysicsShape();
 
    // [Public Member Functions]
 
    virtual Type                            type() const;
 
    virtual void                            type(Type type);
 
    float                                   margin() const;
 
    void                                    margin(float margin);
 
    Source                                  source() const;
 
    // [Internal Member Functions]
 
    virtual bool                            supportsBodyType(PhysicsBody::Type type) const;
    virtual bool                            supportsMargin() const;
 
    void                                    attachedToBody(PhysicsBody& body);
    void                                    detachedFromBody(PhysicsBody& body);
 
    void                                    physicsWorldReachable(PhysicsWorld& world);
    void                                    physicsWorldUnreachable(PhysicsWorld& world);
 
    void                                    source(const Source& sourceObject);
 
    void                                    checkCreateProxy();
 
    const std::unordered_set<PhysicsBody*>& bodies() const;
 
    const std::optional<float>&             marginOverride() const;
 
    PhysicsShapeProxy*                      proxy() const;
 
protected:
    // [Protected Lifecycle Functions]
 
    PhysicsShape();
 
    // [Protected Member Variables]
 
    Type                               _type;
    std::unique_ptr<PhysicsShapeProxy> _proxy;
 
private:
    // [Private Member Variables]
 
    std::optional<float>             _margin;
    Source                           _source;
    std::unordered_set<PhysicsBody*> _bodies;
};
 
} // namespace a3d
 
#endif // AVARA3D_PHYSICS_SHAPE_PHYSICSSHAPE_H