Model.hpp

#ifndef RAYLIB_CPP_INCLUDE_MODEL_HPP_
#define RAYLIB_CPP_INCLUDE_MODEL_HPP_
 
#include <string>
#include <string_view>
 
#include "./raylib.hpp"
#include "./raylib-cpp-utils.hpp"
#include "./Vector3.hpp"
#include "./BoundingBox.hpp"
#include "./RaylibException.hpp"
#include "./RadiansDegrees.hpp"
 
namespace raylib {
class Mesh;
class Model : public ::Model {
 public:
    Model() {
        // Nothing.
        meshes = nullptr;
        materials = nullptr;
    }
 
    /*
     * Copy a model from another model.
     */
    Model(const ::Model& model) {
        set(model);
    }
 
    /*
     * Load a model from a file.
     *
     * @throws raylib::RaylibException Throws if failed to load the Modal.
     */
    Model(const std::string_view fileName) {
        Load(fileName);
    }
 
    /*
     * Load a model from a mesh.
     *
     * @throws raylib::RaylibException Throws if failed to load the Modal.
     */
    Model(const ::Mesh& mesh) {
        Load(mesh);
    }
 
    Model(const raylib::Mesh& mesh) = delete;
 
    ~Model() {
        Unload();
    }
 
    Model(const Model&) = delete;
 
    Model(Model&& other) {
        set(other);
 
        other.meshCount = 0;
        other.materialCount = 0;
        other.meshes = nullptr;
        other.materials = nullptr;
        other.meshMaterial = nullptr;
        other.boneCount = 0;
        other.bones = nullptr;
        other.bindPose = nullptr;
    }
 
    GETTERSETTER(::Matrix, Transform, transform)
    GETTERSETTER(int, MeshCount, meshCount)
    GETTERSETTER(int, MaterialCount, materialCount)
    GETTERSETTER(::Mesh*, Meshes, meshes)
    GETTERSETTER(::Material*, Materials, materials)
    GETTERSETTER(int*, MeshMaterial, meshMaterial)
    GETTERSETTER(int, BoneCount, boneCount)
    GETTERSETTER(::BoneInfo*, Bones, bones)
    GETTERSETTER(::Transform*, BindPose, bindPose)
 
    Model& operator=(const ::Model& model) {
        set(model);
        return *this;
    }
 
    Model& operator=(const Model&) = delete;
 
    Model& operator=(Model&& other) noexcept {
        if (this == &other) {
            return *this;
        }
 
        Unload();
        set(other);
 
        other.meshCount = 0;
        other.materialCount = 0;
        other.meshes = nullptr;
        other.materials = nullptr;
        other.meshMaterial = nullptr;
        other.boneCount = 0;
        other.bones = nullptr;
        other.bindPose = nullptr;
 
        return *this;
    }
 
    void Unload() {
        if (meshes != nullptr || materials != nullptr) {
            ::UnloadModel(*this);
            meshes = nullptr;
            materials = nullptr;
        }
    }
 
    Model& SetMeshMaterial(int meshId, int materialId) {
        ::SetModelMeshMaterial(this, meshId, materialId);
        return *this;
    }
 
    Model& UpdateAnimation(const ::ModelAnimation& anim, int frame) {
        ::UpdateModelAnimation(*this, anim, frame);
        return *this;
    }
 
    bool IsModelAnimationValid(const ::ModelAnimation& anim) const {
        return ::IsModelAnimationValid(*this, anim);
    }
 
    void Draw(::Vector3 position,
            float scale = 1.0f,
            ::Color tint = {255, 255, 255, 255}) const {
        ::DrawModel(*this, position, scale, tint);
    }
 
    void Draw(
            ::Vector3 position,
            ::Vector3 rotationAxis,
            Degree rotationAngle = 0.0f,
            ::Vector3 scale = {1.0f, 1.0f, 1.0f},
            ::Color tint = {255, 255, 255, 255}) const {
        ::DrawModelEx(*this, position, rotationAxis, rotationAngle, scale, tint);
    }
 
    void DrawWires(::Vector3 position,
            float scale = 1.0f,
            ::Color tint = {255, 255, 255, 255}) const {
        ::DrawModelWires(*this, position, scale, tint);
    }
 
    void DrawWires(
            ::Vector3 position,
            ::Vector3 rotationAxis,
            Degree rotationAngle = 0.0f,
            ::Vector3 scale = {1.0f, 1.0f, 1.0f},
            ::Color tint = {255, 255, 255, 255}) const {
        ::DrawModelWiresEx(*this, position, rotationAxis, rotationAngle, scale, tint);
    }
 
    BoundingBox GetBoundingBox() const {
        return ::GetModelBoundingBox(*this);
    }
 
    BoundingBox GetTransformedBoundingBox() const;
 
    operator BoundingBox() const {
        return GetBoundingBox();
    }
 
    bool IsReady() const {
        return ::IsModelReady(*this);
    }
 
    void Load(const std::string_view fileName) {
        set(::LoadModel(fileName.data()));
        if (!IsReady()) {
            throw RaylibException("Failed to load Model from " + std::string(fileName));
        }
    }
 
    void Load(const ::Mesh& mesh) {
        set(::LoadModelFromMesh(mesh));
        if (!IsReady()) {
            throw RaylibException("Failed to load Model from Mesh");
        }
    }
 
 protected:
    void set(const ::Model& model) {
        transform = model.transform;
 
        meshCount = model.meshCount;
        materialCount = model.materialCount;
        meshes = model.meshes;
        materials = model.materials;
        meshMaterial = model.meshMaterial;
 
        boneCount = model.boneCount;
        bones = model.bones;
        bindPose = model.bindPose;
    }
};
 
}  // namespace raylib
 
using RModel = raylib::Model;
 
#endif  // RAYLIB_CPP_INCLUDE_MODEL_HPP_