MD5Model_types.hpp

Go to the documentation of this file.

 
#ifndef CSCI441_MD5_MODEL_TYPES_HPP
#define CSCI441_MD5_MODEL_TYPES_HPP
 
/*
 * md5mesh model loader + animation
 * last modification: Dr. Jeffrey Paone
 * encapsulated into a class
 * supports texturing
 *
 * Doom3's md5mesh viewer with animation.  Mesh and Animation declaration
 * See http://tfc.duke.free.fr/coding/md5-specs-en.html for more details
 *
 * Copyright (c) 2005-2007 David HENRY
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, sublicense, and/or
 * sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 *
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
 * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 */
 
#ifdef CSCI441_USE_GLEW
    #include <GL/glew.h>
#else
    #include <glad/gl.h>
#endif
 
#include <glm/ext/quaternion_float.hpp>
 
#include <cstring>
#include <stdexcept>
 
namespace CSCI441_INTERNAL {
 
    // md5mtr types
 
    struct MD5Texture {
        static constexpr GLshort MAX_NAME_LENGTH = 512;
        GLuint texHandle = 0;
        char filename[MAX_NAME_LENGTH] = "";
 
        MD5Texture() = default;
        MD5Texture(const MD5Texture &OTHER) {
            _copyFromSrc(OTHER);
        }
        MD5Texture& operator=(const MD5Texture &OTHER) {
            if (this != &OTHER) {
                _copyFromSrc(OTHER);
            }
            return *this;
        }
        MD5Texture(MD5Texture&& src) noexcept {
            _moveFromSrc(src);
        }
        MD5Texture& operator=(MD5Texture&& src) noexcept {
            if (this != &src) {
                _moveFromSrc(src);
            }
            return *this;
        }
    private:
        void _copyFromSrc(const MD5Texture &src) {
            this->texHandle = src.texHandle;
            strncpy(this->filename, src.filename, MAX_NAME_LENGTH);
            this->filename[ strlen(src.filename) ] = '\0';
        }
        void _moveFromSrc(MD5Texture& src) {
            _copyFromSrc(src);
 
            src.texHandle = 0;
            strncpy(src.filename, "", MAX_NAME_LENGTH);
            src.filename[0] = '\0';
        }
    };
 
    // md5material types
    struct MD5MaterialShader {
        static constexpr GLshort MAX_NAME_LENGTH = 512;
        static constexpr GLshort NUM_TEXTURES = 4;
        char name[MAX_NAME_LENGTH] = "";
        MD5Texture textures[NUM_TEXTURES];
        GLuint displacementScale = 1;
        enum TextureMap {
            DIFFUSE,
            SPECULAR,
            NORMAL,
            HEIGHT
        };
        MD5MaterialShader() = default;
        MD5MaterialShader(const MD5MaterialShader &OTHER) {
            _copyFromSrc(OTHER);
        }
        MD5MaterialShader& operator=(const MD5MaterialShader &OTHER) {
            if (this != &OTHER) {
                _copyFromSrc(OTHER);
            }
            return *this;
        }
        MD5MaterialShader(MD5MaterialShader&& src) noexcept {
            _moveFromSrc(src);
        }
        MD5MaterialShader& operator=(MD5MaterialShader&& src) noexcept {
            if (this != &src) {
                _moveFromSrc(src);
            }
            return *this;
        }
    private:
        void _copyFromSrc(const MD5MaterialShader &src) {
            for (GLshort i = 0; i < NUM_TEXTURES; i++) {
                this->textures[i] = src.textures[i];
            }
            strncpy(this->name, src.name, MAX_NAME_LENGTH);
            this->name[ strlen(src.name) ] = '\0';
        }
        void _moveFromSrc(MD5MaterialShader &src) {
            for (GLshort i = 0; i < NUM_TEXTURES; i++) {
                this->textures[i] = std::move( src.textures[i] );
            }
            strncpy(this->name, src.name, MAX_NAME_LENGTH);
            this->name[ strlen(src.name) ] = '\0';
            strncpy(src.name, "", MAX_NAME_LENGTH);
            src.name[0] = '\0';
        }
    };
 
    // md5mesh types
 
    struct MD5Joint {
        static constexpr GLint NULL_JOINT = -1;
        static constexpr GLshort MAX_NAME_LENGTH = 256;
        char name[MAX_NAME_LENGTH] = "";
        GLint parent = NULL_JOINT;
        glm::vec3 position = {0.0f, 0.0f, 0.0f};
        glm::quat orientation = {0.0f, 0.0f, 0.0f, 0.0f};
 
        MD5Joint() = default;
        MD5Joint(const MD5Joint &OTHER) {
            _copyFromSrc(OTHER);
        }
        MD5Joint& operator=(const MD5Joint &OTHER) {
            if (this != &OTHER) {
                _copyFromSrc(OTHER);
            }
            return *this;
        }
        MD5Joint(MD5Joint&& src) noexcept {
            _moveFromSrc(src);
        }
        MD5Joint& operator=(MD5Joint&& src) noexcept {
            if (this != &src) {
                _moveFromSrc(src);
            }
            return *this;
        }
    private:
        void _copyFromSrc(const MD5Joint& src) {
            strncpy(this->name, src.name, MAX_NAME_LENGTH);
            this->name[ strlen(src.name) ] = '\0';
            this->parent = src.parent;
            this->position = src.position;
            this->orientation = src.orientation;
        }
        void _moveFromSrc(MD5Joint& src) {
            // copy values from source
            _copyFromSrc(src);
            // reset source
            strncpy(src.name, "", MAX_NAME_LENGTH);
            src.name[0] = '\0';
            src.parent = NULL_JOINT;
            src.position = glm::vec3(0.0f, 0.0f, 0.0f);
            src.orientation = glm::quat(0.0f, 0.0f, 0.0f, 0.0f);
        }
    };
 
    struct MD5Vertex {
        glm::vec2 texCoord = {0.0f, 0.0f};
        GLint start = 0;
        GLint count = 0;
 
        MD5Vertex() = default;
        MD5Vertex(const MD5Vertex &OTHER) {
            _copyFromSrc(OTHER);
        }
        MD5Vertex& operator=(const MD5Vertex &OTHER) {
            if (this != &OTHER) {
                _copyFromSrc(OTHER);
            }
            return *this;
        }
        MD5Vertex(MD5Vertex&& src) noexcept {
            _moveFromSrc(src);
        }
        MD5Vertex& operator=(MD5Vertex&& src) noexcept {
            if (this != &src) {
                _moveFromSrc(src);
            }
            return *this;
        }
    private:
        void _copyFromSrc(const MD5Vertex &src) {
            this->texCoord = src.texCoord;
            this->start = src.start;
            this->count = src.count;
        }
        void _moveFromSrc(MD5Vertex& src) {
            _copyFromSrc(src);
 
            src.texCoord = glm::vec2(0.0f, 0.0f);
            src.start = 0;
            src.count = 0;
        }
    };
 
    struct MD5Triangle {
        static constexpr GLshort NUM_VERTICES = 3;
        GLint index[NUM_VERTICES] = {0};
 
        MD5Triangle() = default;
        MD5Triangle(const MD5Triangle &OTHER) {
            _copyFromSrc(OTHER);
        }
        MD5Triangle& operator=(const MD5Triangle &OTHER) {
            if (this != &OTHER) {
                _copyFromSrc(OTHER);
            }
            return *this;
        }
        MD5Triangle(MD5Triangle&& src) noexcept {
            _moveFromSrc(src);
        }
        MD5Triangle& operator=(MD5Triangle&& src) noexcept {
            if (this != &src) {
                _moveFromSrc(src);
            }
            return *this;
        }
    private:
        void _copyFromSrc(const MD5Triangle &src) {
            for (GLshort i = 0; i < NUM_VERTICES; i++) {
                this->index[i] = src.index[i];
            }
        }
        void _moveFromSrc(MD5Triangle &src) {
            _copyFromSrc(src);
 
            for (GLint & i : src.index) {
                i = 0;
            }
        }
    };
 
    struct MD5Weight {
        GLint joint = MD5Joint::NULL_JOINT;
        GLfloat bias = 0.f;
        glm::vec3 position = {0.0f, 0.0f, 0.0f};
 
        MD5Weight() = default;
        MD5Weight(const MD5Weight &OTHER) {
            _copyFromSrc(OTHER);
        }
        MD5Weight& operator=(const MD5Weight &OTHER) {
            if (this != &OTHER) {
                _copyFromSrc(OTHER);
            }
            return *this;
        }
        MD5Weight(MD5Weight&& src) noexcept {
            _moveFromSrc(src);
        }
        MD5Weight& operator=(MD5Weight&& src) noexcept {
            if (this != &src) {
                _moveFromSrc(src);
            }
            return *this;
        }
    private:
        void _copyFromSrc(const MD5Weight &src) {
            this->joint = src.joint;
            this->bias = src.bias;
            this->position = src.position;
        }
        void _moveFromSrc(MD5Weight &src) {
            _copyFromSrc(src);
 
            src.joint = MD5Joint::NULL_JOINT;
            src.bias = 0.0f;
            src.position = glm::vec3(0.0f, 0.0f, 0.0f);
        }
    };
 
    struct MD5Mesh {
 
        MD5Vertex* vertices = nullptr;
        MD5Triangle* triangles = nullptr;
        MD5Weight* weights = nullptr;
 
        MD5MaterialShader* shader = nullptr;
 
        GLint numVertices = 0;
        GLint numTriangles = 0;
        GLint numWeights = 0;
         MD5Mesh() = default;
        ~MD5Mesh() {
            delete[] vertices;
            vertices = nullptr;
 
            delete[] triangles;
            triangles = nullptr;
 
            delete[] weights;
            weights = nullptr;
        }
        MD5Mesh(const MD5Mesh &OTHER) = delete;
        MD5Mesh& operator=(const MD5Mesh &OTHER) = delete;
 
        MD5Mesh(MD5Mesh&& src) noexcept {
            _moveFromSrc(src);
        }
        MD5Mesh& operator=(MD5Mesh&& src) noexcept {
            if (this != &src) {
                _moveFromSrc(src);
            }
            return *this;
        }
    private:
        void _moveFromSrc(MD5Mesh& src) {
            this->vertices = src.vertices;
            src.vertices = nullptr;
 
            this->triangles = src.triangles;
            src.triangles = nullptr;
 
            this->weights = src.weights;
            src.weights = nullptr;
 
            this->shader = src.shader;
            src.shader = nullptr;
 
            this->numVertices = src.numVertices;
            src.numVertices = 0;
 
            this->numTriangles = src.numTriangles;
            src.numTriangles = 0;
 
            this->numWeights = src.numWeights;
            src.numWeights = 0;
        }
    };
 
    // md5anim types
 
    struct MD5JointInfo {
        static constexpr GLshort MAX_NAME_LENGTH = 256;
        char name[MAX_NAME_LENGTH] = "";
        GLint parent = MD5Joint::NULL_JOINT;
        GLuint flags = 0;
        GLint startIndex = 0;
 
        MD5JointInfo() = default;
        MD5JointInfo(const MD5JointInfo& OTHER) {
            _copyFromSrc(OTHER);
        }
        MD5JointInfo& operator=(const MD5JointInfo& OTHER) {
            if (this != &OTHER) {
                _copyFromSrc(OTHER);
            }
            return *this;
        }
        MD5JointInfo(MD5JointInfo&& src) noexcept {
            _moveFromSrc(src);
        }
        MD5JointInfo& operator=(MD5JointInfo&& src) noexcept {
            if (this != &src) {
                _moveFromSrc(src);
            }
            return *this;
        }
    private:
        void _copyFromSrc(const MD5JointInfo &src) {
            strncpy(this->name, src.name, MAX_NAME_LENGTH);
            this->name[ strlen(src.name) ] = '\0';
            this->parent = src.parent;
            this->flags = src.flags;
            this->startIndex = src.startIndex;
        }
        void _moveFromSrc(MD5JointInfo &src) {
            _copyFromSrc(src);
 
            strncpy(src.name, "", MAX_NAME_LENGTH);
            src.name[0] = '\0';
            src.parent = MD5Joint::NULL_JOINT;
            src.flags = 0;
            src.startIndex = 0;
        }
    };
 
    struct MD5BaseFrameJoint {
        glm::vec3 position = {0.0f, 0.0f, 0.0f};
        glm::quat orientation = {0.0f, 0.0f, 0.0f, 0.0f};
 
        MD5BaseFrameJoint() = default;
        MD5BaseFrameJoint(const MD5BaseFrameJoint& OTHER) {
            _copyFromSrc(OTHER);
        }
        MD5BaseFrameJoint& operator=(const MD5BaseFrameJoint &OTHER) {
            if (this != &OTHER) {
                _copyFromSrc(OTHER);
            }
            return *this;
        }
        MD5BaseFrameJoint(MD5BaseFrameJoint&& src) noexcept {
            _moveFromSrc(src);
        }
        MD5BaseFrameJoint& operator=(MD5BaseFrameJoint&& src) noexcept {
            if (this != &src) {
                _moveFromSrc(src);
            }
            return *this;
        }
    private:
        void _copyFromSrc(const MD5BaseFrameJoint &src) {
            this->position = src.position;
            this->orientation = src.orientation;
        }
        void _moveFromSrc(MD5BaseFrameJoint &src) {
            _copyFromSrc(src);
 
            src.position = glm::vec3(0.0f, 0.0f, 0.0f);
            src.orientation = glm::quat(0.0f, 0.0f, 0.0f, 0.0f);
        }
    };
 
    struct MD5BoundingBox {
        glm::vec3 min = {0.0f, 0.0f, 0.0f};
        glm::vec3 max = {0.0f, 0.0f, 0.0f};
 
        MD5BoundingBox() = default;
        MD5BoundingBox(const MD5BoundingBox &OTHER) {
            _copyFromSrc(OTHER);
        }
        MD5BoundingBox& operator=(const MD5BoundingBox &OTHER) {
            if (this != &OTHER) {
                _copyFromSrc(OTHER);
            }
            return *this;
        }
        MD5BoundingBox(MD5BoundingBox&& src) noexcept {
            _moveFromSrc(src);
        }
        MD5BoundingBox& operator=(MD5BoundingBox&& src) noexcept {
            if (this != &src) {
                _moveFromSrc(src);
            }
            return *this;
        }
    private:
        void _copyFromSrc(const MD5BoundingBox& src) {
            this->min = src.min;
            this->max = src.max;
        }
        void _moveFromSrc(MD5BoundingBox& src) {
            _copyFromSrc(src);
 
            src.min = glm::vec3(0.0f, 0.0f, 0.0f);
            src.max = glm::vec3(0.0f, 0.0f, 0.0f);
        }
    };
 
    class MD5Animation {
    public:
        GLint frameRate = 0;
 
        [[nodiscard]] GLint getNumberOfFrames() const { return _numFrames; }
        void setNumberOfFrames(const GLint numFrames) {
            // if previously set, delete prior allocation to avoid memory leak
            if(_skeletonFrames != nullptr) {
                for (GLint i = 0; i < _numFrames; ++i) {
                    delete _skeletonFrames[i];
                }
            }
            delete[] _skeletonFrames;
            _skeletonFrames = nullptr;   // no longer exists, in event new set equals zero
            delete[] _boundingBoxes;
            _boundingBoxes = nullptr;    // no longer exists, in event new set equals zero
 
            _numFrames = numFrames;
            if ( _numFrames > 0 ) {
                _skeletonFrames = new MD5Joint*[_numFrames];
                for (GLint i = 0; i < _numFrames; ++i) {
                    _skeletonFrames[i] = nullptr;
                }
                _boundingBoxes = new MD5BoundingBox[_numFrames];
            }
        }
 
        [[nodiscard]] GLint getNumberOfJoints() const { return _numJoints; }
        void setNumberOfJoints(const GLint numJoints) {
            // if previously set, delete prior allocation to avoid memory leak
            if(_skeletonFrames != nullptr) {
                for (GLint i = 0; i < _numFrames; ++i) {
                    delete _skeletonFrames[i];
                    _skeletonFrames[i] = nullptr;    // no longer exists, in event new set equals zero
                }
            }
 
            _numJoints = numJoints;
            if (_numJoints > 0) {
                if(_skeletonFrames != nullptr) {
                    for(GLint i = 0; i < _numFrames; ++i) {
                        // Allocate memory for joints of each frame
                        _skeletonFrames[i] = new MD5Joint[_numJoints];
                    }
                }
            }
        }
 
        [[nodiscard]] const MD5Joint* getSkeletonFrame(const GLint frameIndex) const {
            if ( frameIndex < 0 || frameIndex >= _numFrames ) {
                throw std::out_of_range("frameIndex out of range");
            }
            if (_skeletonFrames == nullptr) {
                throw std::out_of_range("skeleton frames are null, setNumberOfFrames() may not have been called");
            }
            return _skeletonFrames[frameIndex];
        }
        [[nodiscard]] MD5Joint& getSkeletonFrameJoint(const GLint frameIndex, const GLint jointIndex) const {
            if ( frameIndex < 0 || frameIndex >= _numFrames ) {
                throw std::out_of_range("frameIndex out of range");
            }
            if ( jointIndex < 0 || jointIndex >= _numJoints ) {
                throw std::out_of_range("jointIndex out of range");
            }
            if (_skeletonFrames == nullptr) {
                throw std::out_of_range("skeleton frames are null, setNumberOfFrames() may not have been called");
            }
            if (_skeletonFrames[frameIndex] == nullptr) {
                throw std::out_of_range("skeleton joints are null, setNumberOfJoints() may not have been called");
            }
            return _skeletonFrames[frameIndex][jointIndex];
        }
 
        [[nodiscard]] MD5BoundingBox& getBoundingBox(const GLint frameIndex) const {
            if(frameIndex < 0 || frameIndex >= _numFrames) {
                throw std::out_of_range("frameIndex out of range");
            }
            if (_boundingBoxes == nullptr) {
                throw std::out_of_range("bounding boxes are null, setNumberOfFrames() may not have been called");
            }
            return _boundingBoxes[frameIndex];
        }
 
        MD5Animation() = default;
        ~MD5Animation() {
            if(_skeletonFrames != nullptr) {
                for (GLint i = 0; i < _numFrames; i++) {
                    delete[] _skeletonFrames[i];
                    _skeletonFrames[i] = nullptr;
                }
            }
            delete[] _skeletonFrames;
            _skeletonFrames = nullptr;
 
            delete[] _boundingBoxes;
            _boundingBoxes = nullptr;
        }
 
        MD5Animation(const MD5Animation& OTHER) = delete;
        MD5Animation& operator=(const MD5Animation& OTHER) = delete;
 
        MD5Animation(MD5Animation&& src) noexcept {
            _moveFromSrc(src);
        }
        MD5Animation& operator=(MD5Animation&& src) noexcept {
            if (this != &src) {
                _moveFromSrc(src);
            }
            return *this;
        }
    private:
        GLint _numFrames = 0;
        GLint _numJoints = 0;
        MD5Joint** _skeletonFrames = nullptr;
        MD5BoundingBox* _boundingBoxes = nullptr;
 
        void _moveFromSrc(MD5Animation &src) {
            this->_numFrames = src._numFrames;
            src._numFrames = 0;
 
            this->_numJoints = src._numJoints;
            src._numJoints = 0;
 
            this->frameRate = src.frameRate;
            src.frameRate = 0;
 
            this->_skeletonFrames = src._skeletonFrames;
            src._skeletonFrames = nullptr;
 
            this->_boundingBoxes = src._boundingBoxes;
            src._boundingBoxes = nullptr;
        }
    };
 
    struct MD5AnimationState {
        GLint currFrame = 0;
        GLint nextFrame = 0;
        GLfloat lastTime = 0.0f;
        GLfloat maxTime = 0.0f;
 
        MD5AnimationState() = default;
        MD5AnimationState(const MD5AnimationState &OTHER) {
            _copyFromSrc(OTHER);
        }
        MD5AnimationState& operator=(const MD5AnimationState &OTHER) {
            if (this != &OTHER) {
                _copyFromSrc(OTHER);
            }
            return *this;
        }
        MD5AnimationState(MD5AnimationState&& src) noexcept {
            _moveFromSrc(src);
        }
        MD5AnimationState& operator=(MD5AnimationState&& src) noexcept {
            if (this != &src) {
                _moveFromSrc(src);
            }
            return *this;
        }
    private:
        void _copyFromSrc(const MD5AnimationState &src) {
            this->currFrame = src.currFrame;
            this->nextFrame = src.nextFrame;
            this->lastTime = src.lastTime;
            this->maxTime = src.maxTime;
        }
        void _moveFromSrc(MD5AnimationState &src) {
            _copyFromSrc(src);
 
            src.currFrame = 0;
            src.nextFrame = 0;
            src.lastTime = 0.0f;
            src.maxTime = 0.0f;
        }
    };
}
 
#endif//CSCI441_MD5_MODEL_TYPES_HPP