MD5Model.hpp

Go to the documentation of this file.

 
#ifndef CSCI441_MD5_MODEL_HPP
#define CSCI441_MD5_MODEL_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.
 *
 */
 
#include "constants.h"
#include "TextureUtils.hpp"
 
#ifdef CSCI441_USE_GLEW
    #include <GL/glew.h>
#else
    #include <glad/gl.h>
#endif
 
#include <glm/exponential.hpp>
#include <glm/ext/quaternion_common.hpp>
#include <glm/ext/quaternion_float.hpp>
 
#define GLM_ENABLE_EXPERIMENTAL
#include <glm/gtx/quaternion.hpp>
 
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <stdexcept>
 
namespace CSCI441 {
 
    class [[maybe_unused]] MD5Model {
    protected:
        // 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->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.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 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);
            }
            void _moveFromSrc(MD5Texture& src) {
                _copyFromSrc(src);
 
                src.texHandle = 0;
                strncpy(src.filename, "", MAX_NAME_LENGTH);
            }
        };
 
        struct MD5Mesh {
            static constexpr GLshort MAX_NAME_LENGTH = 512;
            static constexpr GLshort NUM_TEXTURES = 4;
            MD5Vertex* vertices = nullptr;
            MD5Triangle* triangles = nullptr;
            MD5Weight* weights = nullptr;
            MD5Texture textures[NUM_TEXTURES];
            enum TextureMap {
                DIFFUSE,
                SPECULAR,
                NORMAL,
                HEIGHT
            };
            GLint numVertices = 0;
            GLint numTriangles = 0;
            GLint numWeights = 0;
 
            char shader[MAX_NAME_LENGTH] = "";
 
             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;
 
                for (GLshort i = 0; i < NUM_TEXTURES; i++) {
                    this->textures[i] = std::move( src.textures[i] );
                }
 
                this->numVertices = src.numVertices;
                src.numVertices = 0;
 
                this->numTriangles = src.numTriangles;
                src.numTriangles = 0;
 
                this->numWeights = src.numWeights;
                src.numWeights = 0;
 
                strncpy(this->shader, src.shader, MAX_NAME_LENGTH);
                strncpy(src.shader, "", MAX_NAME_LENGTH);
            }
        };
 
        // 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->parent = src.parent;
                this->flags = src.flags;
                this->startIndex = src.startIndex;
            }
            void _moveFromSrc(MD5JointInfo &src) {
                _copyFromSrc(src);
 
                strncpy(src.name, "", MAX_NAME_LENGTH);
                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;
            }
        };
 
    public:
        MD5Model() {
            // allocate space for one animation by default
            _numAnimations = 1;
            // create the initial animation
            _animations = new MD5Animation*[_numAnimations];
            _animations[0] = new MD5Animation();
            // and the associated animation state information
            _animationInfos = new MD5AnimationState[_numAnimations];
        }
        ~MD5Model();
 
        MD5Model(const MD5Model&) = delete;
        MD5Model& operator=(const MD5Model&) = delete;
 
        MD5Model(MD5Model&& src) noexcept {
            _moveFromSrc(src);
        }
        MD5Model& operator=(MD5Model&& src) noexcept {
            if (this != &src) {
                _moveFromSrc(src);
            }
            return *this;
        }
 
        [[maybe_unused]] bool loadMD5Model(const char* MD5_MESH_FILE, const char* MD5_ANIM_FILE = "");
 
        [[nodiscard]] bool isAnimated() const { return _isAnimated; }
 
        // md5mesh prototypes
        [[nodiscard]] bool readMD5Model(const char* FILENAME);
        [[maybe_unused]] void allocVertexArrays(GLuint vPosAttribLoc, GLuint vColorAttribLoc, GLuint vTexCoordAttribLoc);
 
        [[maybe_unused]] void setActiveTextures(GLint diffuseMapActiveTexture, GLint specularMapActiveTexture, GLint normalMapActiveTexture, GLint heightMapActiveTexture);
 
        [[maybe_unused]] void draw() const;
        [[maybe_unused]] void drawSkeleton() const;
 
        // md5anim prototypes
        [[nodiscard]] bool readMD5Anim(const char* filename, GLushort targetAnimationIndex = 0);
        [[nodiscard]] bool addMD5Anim(const char* filename);
        [[nodiscard]] GLushort getNumberOfAnimations() const {
            // one slot is always allocated, but if model is not allocated then return 0
            if (!_isAnimated) return 0;
            // model is animated, return number of animations that were successfully loaded
            return _numAnimations;
        }
        void useTargetAnimationIndex(GLushort targetAnimationIndex);
        void animate(GLfloat dt);
 
    private:
        MD5Joint* _baseSkeleton = nullptr;
        MD5Mesh* _meshes = nullptr;
        GLint _numJoints = 0;
        GLint _numMeshes = 0;
 
        // vertex array related stuff
        GLint _maxVertices = 0;
        GLint _maxTriangles = 0;
        glm::vec3* _vertexArray = nullptr;
        glm::vec2* _texelArray = nullptr;
        GLuint* _vertexIndicesArray = nullptr;
        GLuint _vao = 0;
        GLuint _vbo[2] = {0, 0};
 
        // skeleton related stuff
        GLuint _skeletonVAO = 0;
        GLuint _skeletonVBO = 0;
        MD5Joint* _skeleton = nullptr;
 
        // animation related stuff
        MD5Animation** _animations = nullptr;
        GLushort _numAnimations = 0;
        GLushort _currentAnimationIndex = 0;
        bool _isAnimated = false;
        MD5AnimationState* _animationInfos = nullptr;
 
        GLint _diffuseActiveTexture  = GL_TEXTURE0;
        GLint _specularActiveTexture = GL_TEXTURE1;
        GLint _normalActiveTexture   = GL_TEXTURE2;
        GLint _heightActiveTexture   = GL_TEXTURE3;
 
        // helper functions
        void _prepareMesh(const MD5Mesh* pMESH) const;
        void _drawMesh(const MD5Mesh* pMESH) const;
        [[nodiscard]] bool _checkAnimValidity(GLushort targetAnimationIndex) const;
        static void _buildFrameSkeleton(const MD5JointInfo* pJOINT_INFOS,
                                        const MD5BaseFrameJoint* pBASE_FRAME,
                                        const GLfloat* pANIM_FRAME_DATA,
                                        const MD5Joint* pSkeletonFrame,
                                        GLint NUM_JOINTS);
        void _interpolateSkeletons(GLfloat interp);
        void _freeModel();
        void _freeVertexArrays();
        void _freeAnim();
 
        void _moveFromSrc(MD5Model &src);
    };
}
 
//----------------------------------------------------------------------------------------------------
 
inline
CSCI441::MD5Model::~MD5Model()
{
    _freeModel();
    _freeVertexArrays();
    _freeAnim();
}
 
// load our MD5 model
[[maybe_unused]]
inline bool
CSCI441::MD5Model::loadMD5Model(
    const char* MD5_MESH_FILE,
    const char* MD5_ANIM_FILE
) {
    // Load MD5 _model file
    if( readMD5Model(MD5_MESH_FILE) ) {
        // if MD5 animation file name provided
        if(strcmp(MD5_ANIM_FILE, "") != 0 ) {
            // Load MD5 animation file
            if( !readMD5Anim(MD5_ANIM_FILE) ) {
                return false;
            }
        }
        if( !isAnimated() ) {
            printf ("[.MD5_ANIM_FILE]: no animation loaded.\n");
        }
    } else {
        return false;
    }
    return true;
}
 
// Load an MD5 model from file.
inline bool
CSCI441::MD5Model::readMD5Model(
    const char* FILENAME
) {
    char buff[512];
    GLint version = 0;
    GLint currentMesh = 0;
 
    GLint totalVertices = 0;
    GLint totalWeights = 0;
    GLint totalTriangles = 0;
 
    GLfloat minX =  999999, minY =  999999, minZ =  999999;
    GLfloat maxX = -999999, maxY = -999999, maxZ = -999999;
 
    printf("[.md5mesh]: about to read %s\n", FILENAME );
 
    FILE *fp = fopen(FILENAME, "rb" );
    if( !fp ) {
        fprintf (stderr, "[.md5mesh]: Error: couldn't open \"%s\"!\n", FILENAME);
        return false;
    }
 
    while( !feof(fp) ) {
        // Read whole line
        fgets( buff, sizeof(buff), fp );
 
        if( sscanf(buff, " MD5Version %d", &version) == 1 ) {
            if( version != 10 ) {
                // Bad version
                fprintf (stderr, "[.md5mesh]: Error: bad model version\n");
                fclose (fp);
                return false;
            }
        } else if( sscanf(buff, " numJoints %d", &_numJoints) == 1 ) {
            if( _numJoints > 0 ) {
                // Allocate memory for base skeleton joints
                _baseSkeleton = new MD5Joint[_numJoints];
            }
        } else if( sscanf(buff, " numMeshes %d", &_numMeshes) == 1 ) {
            if( _numMeshes > 0 ) {
                // Allocate memory for meshes
                _meshes = new MD5Mesh[_numMeshes];
            }
        } else if( strncmp(buff, "joints {", 8) == 0 ) {
            // Read each joint
            for(GLint i = 0; i < _numJoints; ++i) {
                MD5Joint *joint = &_baseSkeleton[i];
 
                // Read whole line
                fgets( buff, sizeof(buff), fp );
 
                if( sscanf(buff, "%s %d ( %f %f %f ) ( %f %f %f )",
                           joint->name, &joint->parent,
                           &joint->position[0], &joint->position[1], &joint->position[2],
                           &joint->orientation[0],&joint->orientation[1], &joint->orientation[2]) == 8
                        ) {
                    // Compute the w component
                    joint->orientation.w = glm::extractRealComponent(joint->orientation);
                }
            }
        } else if( strncmp(buff, "mesh {", 6) == 0 ) {
            MD5Mesh *mesh = &_meshes[currentMesh];
            GLint vert_index = 0;
            GLint tri_index = 0;
            GLint weight_index = 0;
            GLfloat floatData[4];
            GLint intData[3];
 
            while( buff[0] != '}' && !feof(fp) ) {
                // Read whole line
                fgets( buff, sizeof(buff), fp );
 
                if( strstr( buff, "shader ") ) {
                    GLint quote = 0, j = 0;
 
                    // Copy the shader name without the quote marks
                    for(unsigned long uli = 0; uli < sizeof(buff) && (quote < 2); ++uli) {
                        if( buff[uli] == '\"' )
                            quote++;
 
                        if( (quote == 1) && (buff[uli] != '\"') ) {
                            mesh->shader[j] = buff[uli];
                            j++;
                        }
                    }
                    // there was a shader name
                    if( j > 0 ) {
                        // diffuse map
                        strcpy(mesh->textures[MD5Mesh::TextureMap::DIFFUSE].filename, mesh->shader);
                        strcat(mesh->textures[MD5Mesh::TextureMap::DIFFUSE].filename, ".tga");
                        mesh->textures[MD5Mesh::TextureMap::DIFFUSE].texHandle = CSCI441::TextureUtils::loadAndRegisterTexture( mesh->textures[MD5Mesh::TextureMap::DIFFUSE].filename, GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, GL_REPEAT, GL_REPEAT, GL_FALSE, GL_FALSE);
                        if( mesh->textures[MD5Mesh::TextureMap::DIFFUSE].texHandle == 0 ) {
                            strcpy(mesh->textures[MD5Mesh::TextureMap::DIFFUSE].filename, mesh->shader);
                            strcat(mesh->textures[MD5Mesh::TextureMap::DIFFUSE].filename, "_d.tga");
                            mesh->textures[MD5Mesh::TextureMap::DIFFUSE].texHandle = CSCI441::TextureUtils::loadAndRegisterTexture( mesh->textures[MD5Mesh::TextureMap::DIFFUSE].filename, GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, GL_REPEAT, GL_REPEAT, GL_FALSE, GL_FALSE );
                            if( mesh->textures[MD5Mesh::TextureMap::DIFFUSE].texHandle == 0 ) {
                                strcpy(mesh->textures[MD5Mesh::TextureMap::DIFFUSE].filename, mesh->shader);
                                strcat(mesh->textures[MD5Mesh::TextureMap::DIFFUSE].filename, ".png");
                                mesh->textures[MD5Mesh::TextureMap::DIFFUSE].texHandle = CSCI441::TextureUtils::loadAndRegisterTexture(mesh->textures[MD5Mesh::TextureMap::DIFFUSE].filename, GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, GL_REPEAT, GL_REPEAT, GL_FALSE, GL_FALSE );
                                if( mesh->textures[MD5Mesh::TextureMap::DIFFUSE].texHandle == 0 ) {
                                    fprintf(stderr, "[.md5mesh | ERROR]: Could not load diffuse map for shader %s\n", mesh->shader);
                                }
                            }
                        }
 
                        // specular map
                        strcpy(mesh->textures[MD5Mesh::TextureMap::SPECULAR].filename, mesh->shader);
                        strcat(mesh->textures[MD5Mesh::TextureMap::SPECULAR].filename, "_s.tga");
                        mesh->textures[MD5Mesh::TextureMap::SPECULAR].texHandle = CSCI441::TextureUtils::loadAndRegisterTexture( mesh->textures[MD5Mesh::TextureMap::SPECULAR].filename, GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, GL_REPEAT, GL_REPEAT, GL_FALSE, GL_FALSE );
                        if( mesh->textures[MD5Mesh::TextureMap::SPECULAR].texHandle == 0 ) {
                            strcpy(mesh->textures[MD5Mesh::TextureMap::SPECULAR].filename, mesh->shader);
                            strcat(mesh->textures[MD5Mesh::TextureMap::SPECULAR].filename, "_s.png");
                            mesh->textures[MD5Mesh::TextureMap::SPECULAR].texHandle = CSCI441::TextureUtils::loadAndRegisterTexture( mesh->textures[MD5Mesh::TextureMap::SPECULAR].filename, GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, GL_REPEAT, GL_REPEAT, GL_FALSE, GL_FALSE );
                            if( mesh->textures[MD5Mesh::TextureMap::SPECULAR].texHandle == 0 ) {
                                fprintf(stderr, "[.md5mesh | ERROR]: Could not load specular map for shader %s\n", mesh->shader);
                            }
                        }
 
                        // normal map
                        strcpy(mesh->textures[MD5Mesh::TextureMap::NORMAL].filename, mesh->shader);
                        strcat(mesh->textures[MD5Mesh::TextureMap::NORMAL].filename, "_local.tga");
                        mesh->textures[MD5Mesh::TextureMap::NORMAL].texHandle = CSCI441::TextureUtils::loadAndRegisterTexture( mesh->textures[MD5Mesh::TextureMap::NORMAL].filename, GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, GL_REPEAT, GL_REPEAT, GL_FALSE, GL_FALSE );
                        if( mesh->textures[MD5Mesh::TextureMap::NORMAL].texHandle == 0 ) {
                            strcpy(mesh->textures[MD5Mesh::TextureMap::NORMAL].filename, mesh->shader);
                            strcat(mesh->textures[MD5Mesh::TextureMap::NORMAL].filename, "_local.png");
                            mesh->textures[MD5Mesh::TextureMap::NORMAL].texHandle = CSCI441::TextureUtils::loadAndRegisterTexture( mesh->textures[MD5Mesh::TextureMap::NORMAL].filename, GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, GL_REPEAT, GL_REPEAT, GL_FALSE, GL_FALSE );
                            if( mesh->textures[MD5Mesh::TextureMap::NORMAL].texHandle == 0 ) {
                                fprintf(stderr, "[.md5mesh | ERROR]: Could not load normal map for shader %s\n", mesh->shader);
                            }
                        }
 
                        // height map
                        strcpy(mesh->textures[MD5Mesh::TextureMap::HEIGHT].filename, mesh->shader);
                        strcat(mesh->textures[MD5Mesh::TextureMap::HEIGHT].filename, "_h.tga");
                        mesh->textures[MD5Mesh::TextureMap::HEIGHT].texHandle = CSCI441::TextureUtils::loadAndRegisterTexture( mesh->textures[MD5Mesh::TextureMap::HEIGHT].filename, GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, GL_REPEAT, GL_REPEAT, GL_FALSE, GL_FALSE );
                        if( mesh->textures[MD5Mesh::TextureMap::HEIGHT].texHandle == 0 ) {
                            strcpy(mesh->textures[MD5Mesh::TextureMap::HEIGHT].filename, mesh->shader);
                            strcat(mesh->textures[MD5Mesh::TextureMap::HEIGHT].filename, "_h.png");
                            mesh->textures[MD5Mesh::TextureMap::HEIGHT].texHandle = CSCI441::TextureUtils::loadAndRegisterTexture( mesh->textures[MD5Mesh::TextureMap::HEIGHT].filename, GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, GL_REPEAT, GL_REPEAT, GL_FALSE, GL_FALSE );
                            if( mesh->textures[MD5Mesh::TextureMap::HEIGHT].texHandle == 0 ) {
                                fprintf(stderr, "[.md5mesh | ERROR]: Could not load height map for shader %s\n", mesh->shader);
                            }
                        }
                    }
                } else if( sscanf(buff, " numverts %d", &mesh->numVertices) == 1 ) {
                    if( mesh->numVertices > 0 ) {
                        // Allocate memory for vertices
                        mesh->vertices = new MD5Vertex[mesh->numVertices];
                    }
 
                    if( mesh->numVertices > _maxVertices )
                        _maxVertices = mesh->numVertices;
 
                    totalVertices += mesh->numVertices;
                } else if( sscanf(buff, " numtris %d", &mesh->numTriangles) == 1 ) {
                    if( mesh->numTriangles > 0 ) {
                        // Allocate memory for triangles
                        mesh->triangles = new MD5Triangle[mesh->numTriangles];
                    }
 
                    if( mesh->numTriangles > _maxTriangles )
                        _maxTriangles = mesh->numTriangles;
 
                    totalTriangles += mesh->numTriangles;
                } else if( sscanf(buff, " numweights %d", &mesh->numWeights) == 1 ) {
                    if( mesh->numWeights > 0 ) {
                        // Allocate memory for vertex weights
                        mesh->weights = new MD5Weight[mesh->numWeights];
                    }
 
                    totalWeights += mesh->numWeights;
                } else if( sscanf(buff, " vert %d ( %f %f ) %d %d",
                                  &vert_index,
                                  &floatData[0], &floatData[1],
                                  &intData[0], &intData[1]) == 5
                        ) {
                    // Copy vertex data
                    mesh->vertices[vert_index].texCoord.s = floatData[0];
                    mesh->vertices[vert_index].texCoord.t = floatData[1];
                    mesh->vertices[vert_index].start = intData[0];
                    mesh->vertices[vert_index].count = intData[1];
                } else if( sscanf(buff, " tri %d %d %d %d",
                                  &tri_index,
                                  &intData[0], &intData[1], &intData[2]) == 4
                        ) {
                    // Copy triangle data
                    mesh->triangles[tri_index ].index[0] = intData[0];
                    mesh->triangles[tri_index ].index[1] = intData[1];
                    mesh->triangles[tri_index ].index[2] = intData[2];
                } else if( sscanf(buff, " weight %d %d %f ( %f %f %f )",
                                  &weight_index, &intData[0], &floatData[3],
                                  &floatData[0], &floatData[1], &floatData[2]) == 6
                        ) {
                    // Copy vertex data
                    mesh->weights[weight_index].joint  = intData[0];
                    mesh->weights[weight_index].bias   = floatData[3];
                    mesh->weights[weight_index].position[0] = floatData[0];
                    mesh->weights[weight_index].position[1] = floatData[1];
                    mesh->weights[weight_index].position[2] = floatData[2];
 
                    if( floatData[0] < minX ) { minX = floatData[0]; }
                    if( floatData[0] > maxX ) { maxX = floatData[0]; }
                    if( floatData[1] < minY ) { minY = floatData[1]; }
                    if( floatData[1] > maxY ) { maxY = floatData[1]; }
                    if( floatData[2] < minZ ) { minZ = floatData[2]; }
                    if( floatData[2] > maxZ ) { maxZ = floatData[2]; }
                }
            }
 
            currentMesh++;
        }
    }
 
    fclose(fp);
 
    _skeleton = _baseSkeleton;
 
    printf("[.md5mesh]: finished reading %s\n", FILENAME );
    printf("[.md5mesh]: read in %d meshes, %d joints, %d vertices, %d weights, and %d triangles\n", _numMeshes, _numJoints, totalVertices, totalWeights, totalTriangles );
    printf( "[.md5mesh]: base pose %f units across in X, %f units across in Y, %f units across in Z\n", (maxX - minX), (maxY-minY), (maxZ - minZ) );
    printf( "\n" );
 
    return true;
}
 
inline void
CSCI441::MD5Model::_freeModel()
{
    delete[] _baseSkeleton;
    if (_baseSkeleton == _skeleton) _skeleton = nullptr;    // if there is no animation, prevent double delete
    _baseSkeleton = nullptr;
 
    delete[] _meshes;
    _meshes = nullptr;
}
 
[[maybe_unused]]
inline void
CSCI441::MD5Model::draw() const
{
    // Draw each mesh of the model
    for(GLint i = 0; i < _numMeshes; ++i) {
        MD5Mesh& mesh = _meshes[i];                  // get the mesh
        _prepareMesh(&mesh);                // do some preprocessing on it
        _drawMesh(&mesh);
    }
}
 
inline void
CSCI441::MD5Model::_prepareMesh(
    const MD5Mesh *pMESH
) const {
    GLint i, j, k;
 
    // Setup vertex indices
    for(k = 0, i = 0; i < pMESH->numTriangles; ++i) {
        for(j = 0; j < 3; ++j, ++k)
            _vertexIndicesArray[k] = pMESH->triangles[i].index[j];
    }
 
    // Setup vertices
    for(i = 0; i < pMESH->numVertices; ++i) {
        glm::vec3 finalVertex = {0.0f, 0.0f, 0.0f };
 
        // Calculate final vertex to draw with weights
        for(j = 0; j < pMESH->vertices[i].count; ++j) {
            const MD5Weight *weight = &pMESH->weights[pMESH->vertices[i].start + j];
            const MD5Joint  *joint  = &_skeleton[weight->joint];
 
            // Calculate transformed vertex for this weight
            const glm::vec3 weightedVertex = glm::rotate(joint->orientation, glm::vec4(weight->position, 0.0f));
 
            // The sum of all weight->bias should be 1.0
            finalVertex.x += (joint->position.x + weightedVertex.x) * weight->bias;
            finalVertex.y += (joint->position.y + weightedVertex.y) * weight->bias;
            finalVertex.z += (joint->position.z + weightedVertex.z) * weight->bias;
        }
 
        _vertexArray[i].x = finalVertex.x;
        _vertexArray[i].y = finalVertex.y;
        _vertexArray[i].z = finalVertex.z;
 
        _texelArray[i].s = pMESH->vertices[i].texCoord.s;
        _texelArray[i].t = pMESH->vertices[i].texCoord.t;
    }
 
    glBindVertexArray(_vao );
 
    glBindBuffer(GL_ARRAY_BUFFER, _vbo[0] );
    glBufferSubData(GL_ARRAY_BUFFER, 0, static_cast<GLsizeiptr>(sizeof(glm::vec3)) * pMESH->numVertices, &_vertexArray[0] );
    glBufferSubData(GL_ARRAY_BUFFER, static_cast<GLsizeiptr>(sizeof(glm::vec3)) * _maxVertices, static_cast<GLsizeiptr>(sizeof(glm::vec2)) * pMESH->numVertices, &_texelArray[0] );
 
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _vbo[1] );
    glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0, static_cast<GLsizeiptr>(sizeof(GLuint)) * pMESH->numTriangles * 3, _vertexIndicesArray );
}
 
inline void
CSCI441::MD5Model::_drawMesh(
    const MD5Mesh *pMESH
) const {
    if (pMESH->textures[MD5Mesh::TextureMap::SPECULAR].texHandle != 0) {
        // Bind Specular Map if exists
        glActiveTexture(_specularActiveTexture);
        glBindTexture(GL_TEXTURE_2D, pMESH->textures[MD5Mesh::TextureMap::SPECULAR].texHandle );
    }
    if (pMESH->textures[MD5Mesh::TextureMap::NORMAL].texHandle != 0) {
        // Bind Normal Map if exists
        glActiveTexture(_normalActiveTexture);
        glBindTexture(GL_TEXTURE_2D, pMESH->textures[MD5Mesh::TextureMap::NORMAL].texHandle );
    }
    if (pMESH->textures[MD5Mesh::TextureMap::HEIGHT].texHandle != 0) {
        // Bind Height Map if exists
        glActiveTexture(_heightActiveTexture);
        glBindTexture(GL_TEXTURE_2D, pMESH->textures[MD5Mesh::TextureMap::HEIGHT].texHandle );
    }
    // bind diffuse last because ideally it is texture 0 and will remain for future renderings
    if (pMESH->textures[MD5Mesh::TextureMap::DIFFUSE].texHandle != 0) {
        // Bind Diffuse Map if exists
        glActiveTexture(_diffuseActiveTexture);
        glBindTexture(GL_TEXTURE_2D, pMESH->textures[MD5Mesh::TextureMap::DIFFUSE].texHandle );
    }
    if (_diffuseActiveTexture != GL_TEXTURE0) {
        // reset back to active texture being zero
        glActiveTexture(GL_TEXTURE0);
    }
 
    glBindVertexArray(_vao );
    glDrawElements(GL_TRIANGLES, pMESH->numTriangles * 3, GL_UNSIGNED_INT, (void*)nullptr );
}
 
[[maybe_unused]]
inline void
CSCI441::MD5Model::allocVertexArrays(
    const GLuint vPosAttribLoc,
    const GLuint vColorAttribLoc,
    const GLuint vTexCoordAttribLoc
) {
    _vertexArray = new glm::vec3[_maxVertices];
    _texelArray = new glm::vec2[_maxVertices];
    _vertexIndicesArray = new GLuint[_maxTriangles * 3];
 
    glGenVertexArrays( 1, &_vao );
    glBindVertexArray(_vao );
 
    glGenBuffers(2, _vbo );
    glBindBuffer(GL_ARRAY_BUFFER, _vbo[0] );
    glBufferData(GL_ARRAY_BUFFER, static_cast<GLsizeiptr>(sizeof(glm::vec3)) * _maxVertices + static_cast<GLsizeiptr>(sizeof(glm::vec2)) * _maxVertices, nullptr, GL_DYNAMIC_DRAW );
 
    glEnableVertexAttribArray( vPosAttribLoc );
    glVertexAttribPointer( vPosAttribLoc, 3, GL_FLOAT, GL_FALSE, 0, static_cast<void *>(nullptr) );
 
    glEnableVertexAttribArray( vTexCoordAttribLoc );
    glVertexAttribPointer( vTexCoordAttribLoc, 2, GL_FLOAT, GL_FALSE, 0, reinterpret_cast<void *>(sizeof(glm::vec3) * _maxVertices) );
 
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _vbo[1] );
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, static_cast<GLsizeiptr>(sizeof(GLuint)) * _maxTriangles * 3, nullptr, GL_DYNAMIC_DRAW );
 
    printf("[.md5mesh]: Model VAO/VBO/IBO registered at %u/%u/%u\n", _vao, _vbo[0], _vbo[1] );
 
    glGenVertexArrays( 1, &_skeletonVAO );
    glBindVertexArray(_skeletonVAO );
 
    glGenBuffers( 1, &_skeletonVBO );
    glBindBuffer(GL_ARRAY_BUFFER, _skeletonVBO );
    glBufferData(GL_ARRAY_BUFFER, static_cast<GLsizeiptr>(sizeof(glm::vec3)) * _numJoints * 3 * 2, nullptr, GL_DYNAMIC_DRAW );
 
    glEnableVertexAttribArray( vPosAttribLoc ); // vPos
    glVertexAttribPointer( vPosAttribLoc, 3, GL_FLOAT, GL_FALSE, 0, static_cast<void *>(nullptr) );
 
    glEnableVertexAttribArray( vColorAttribLoc ); // vColor
    glVertexAttribPointer( vColorAttribLoc, 3, GL_FLOAT, GL_FALSE, 0, reinterpret_cast<void *>(sizeof(glm::vec3) * _numJoints * 3) );
 
    printf("[.md5mesh]: Skeleton VAO/VBO registered at %u/%u\n", _skeletonVAO, _skeletonVBO );
}
 
inline void
CSCI441::MD5Model::setActiveTextures(
    const GLint diffuseMapActiveTexture = GL_TEXTURE0,
    const GLint specularMapActiveTexture = GL_TEXTURE1,
    const GLint normalMapActiveTexture = GL_TEXTURE2,
    const GLint heightMapActiveTexture = GL_TEXTURE3
) {
    _diffuseActiveTexture = diffuseMapActiveTexture;
    _specularActiveTexture = specularMapActiveTexture;
    _normalActiveTexture = normalMapActiveTexture;
    _heightActiveTexture = heightMapActiveTexture;
}
 
inline void
CSCI441::MD5Model::_freeVertexArrays()
{
    delete[] _vertexArray;
    _vertexArray = nullptr;
 
    delete[] _vertexIndicesArray;
    _vertexIndicesArray = nullptr;
 
    delete[] _texelArray;
    _texelArray = nullptr;
 
    glDeleteVertexArrays( 1, &_vao );
    _vao = 0;
 
    glDeleteBuffers(2, _vbo );
    _vbo[0] = 0;
    _vbo[1] = 0;
 
    glDeleteVertexArrays( 1, &_skeletonVAO );
    _skeletonVAO = 0;
 
    glDeleteBuffers( 1, &_skeletonVBO );
    _skeletonVBO = 0;
}
 
[[maybe_unused]]
inline void
CSCI441::MD5Model::drawSkeleton() const
{
    glBindVertexArray(_skeletonVAO );
    glBindBuffer(GL_ARRAY_BUFFER, _skeletonVBO );
 
    constexpr glm::vec3 jointColor = {1.0f, 1.0f, 0.0f };
    constexpr glm::vec3 boneColor = {1.0f, 0.0f, 1.0f };
 
    // put in points for joints
    for(GLint i = 0; i < _numJoints; ++i ) {
        glBufferSubData(GL_ARRAY_BUFFER, i * static_cast<GLsizeiptr>(sizeof(glm::vec3)), sizeof(glm::vec3), &(_skeleton[i].position) );
        glBufferSubData(GL_ARRAY_BUFFER, i * static_cast<GLsizeiptr>(sizeof(glm::vec3)) + static_cast<GLsizeiptr>(sizeof(glm::vec3)) * _numJoints * 3, sizeof(glm::vec3), &jointColor[0]);
    }
 
    // put in lines for bones
    GLint numBones = 0;
    for(GLint i = 0; i < _numJoints; ++i ) {
        if( _skeleton[i].parent != MD5Joint::NULL_JOINT ) {
            glBufferSubData(
                GL_ARRAY_BUFFER,
                static_cast<GLsizeiptr>(sizeof(glm::vec3)) * _numJoints + (i * 2) * static_cast<GLsizeiptr>(sizeof(glm::vec3)),
                static_cast<GLsizeiptr>(sizeof(glm::vec3)),
                &(_skeleton[_skeleton[i].parent].position)
            );
            glBufferSubData(
                GL_ARRAY_BUFFER,
                static_cast<GLsizeiptr>(sizeof(glm::vec3)) * _numJoints + (i * 2) * static_cast<GLsizeiptr>(sizeof(glm::vec3)) + static_cast<GLsizeiptr>(sizeof(glm::vec3)) * _numJoints * 3,
                sizeof(glm::vec3),
                &boneColor[0]
            );
 
            glBufferSubData(
                GL_ARRAY_BUFFER,
                static_cast<GLsizeiptr>(sizeof(glm::vec3)) * _numJoints + (i * 2) * static_cast<GLsizeiptr>(sizeof(glm::vec3)) + static_cast<GLsizeiptr>(sizeof(glm::vec3)),
                static_cast<GLsizeiptr>(sizeof(glm::vec3)),
                &(_skeleton[i].position)
            );
            glBufferSubData(
                GL_ARRAY_BUFFER,
                static_cast<GLsizeiptr>(sizeof(glm::vec3)) * _numJoints + (i * 2) * static_cast<GLsizeiptr>(sizeof(glm::vec3)) + static_cast<GLsizeiptr>(sizeof(glm::vec3)) + static_cast<GLsizeiptr>(sizeof(glm::vec3)) * _numJoints * 3,
                sizeof(glm::vec3),
                &boneColor[0]
            );
            numBones++;
        }
    }
 
    glPointSize(5.0f);
    glDrawArrays(GL_POINTS, 0, _numJoints );
    glPointSize(1.0f);
 
    glLineWidth( 3.0f );
    glDrawArrays(GL_LINES, _numJoints, numBones * 2 );
    glLineWidth(1.0f);
}
 
inline bool
CSCI441::MD5Model::_checkAnimValidity(const GLushort targetAnimationIndex) const
{
    // md5mesh and md5anim must have the same number of joints
    if( _numJoints != _animations[targetAnimationIndex]->getNumberOfJoints() ) {
        fprintf(stdout, "\n[.md5anim]: skeleton and animation do not have same number of joints.  cannot apply animation %u to skeleton\n\n", targetAnimationIndex);
        return false;
    }
    if (_animations[targetAnimationIndex]->getNumberOfJoints() == 0 ) {
        fprintf(stdout, "\n[.md5anim]: animation has zero joints.  cannot apply animation %u to skeleton\n\n", targetAnimationIndex);
        return false;
    }
 
    // We just check with frame[0]
    for(GLint i = 0; i < _numJoints; ++i) {
        // Joints must have the same parent index
        if (_baseSkeleton[i].parent != _animations[targetAnimationIndex]->getSkeletonFrameJoint(0, i).parent) {
            fprintf(stdout, "\n[.md5anim]: skeleton and animation joints do not have same parent index.  cannot apply animation %u to skeleton\n\n", targetAnimationIndex);
            return false;
        }
 
        // Joints must have the same name
        if (strcmp (_baseSkeleton[i].name, _animations[targetAnimationIndex]->getSkeletonFrameJoint(0, i).name) != 0) {
            fprintf(stdout, "\n[.md5anim]: skeleton and animation joints do not have same name.  cannot apply animation %u to skeleton\n\n", targetAnimationIndex);
            return false;
        }
    }
 
    fprintf(stdout, "\n[.md5anim]: skeleton and animation match.  animation %u can be applied to skeleton\n\n", targetAnimationIndex);
    return true;
}
 
inline void
CSCI441::MD5Model::_buildFrameSkeleton(
        const MD5JointInfo* pJOINT_INFOS,
        const MD5BaseFrameJoint* pBASE_FRAME,
        const GLfloat* pANIM_FRAME_DATA,
        const MD5Joint* pSkeletonFrame,
        const GLint NUM_JOINTS
) {
    if(pJOINT_INFOS == nullptr
       || pBASE_FRAME == nullptr
       || pANIM_FRAME_DATA == nullptr
       || pSkeletonFrame == nullptr) return;
 
    for(GLint i = 0; i < NUM_JOINTS; ++i) {
        const MD5BaseFrameJoint *baseJoint = &pBASE_FRAME[i];
        glm::vec3 animatedPosition = baseJoint->position;
        glm::quat animatedOrientation = baseJoint->orientation;
        GLint j = 0;
 
        // Tx
        if(pJOINT_INFOS[i].flags & 1 ) {
            animatedPosition.x = pANIM_FRAME_DATA[pJOINT_INFOS[i].startIndex + j];
            ++j;
        }
 
        // Ty
        if(pJOINT_INFOS[i].flags & 2 ) {
            animatedPosition.y = pANIM_FRAME_DATA[pJOINT_INFOS[i].startIndex + j];
            ++j;
        }
 
        // Tz
        if(pJOINT_INFOS[i].flags & 4 ) {
            animatedPosition.z = pANIM_FRAME_DATA[pJOINT_INFOS[i].startIndex + j];
            ++j;
        }
 
        // Qx
        if(pJOINT_INFOS[i].flags & 8 ) {
            animatedOrientation.x = pANIM_FRAME_DATA[pJOINT_INFOS[i].startIndex + j];
            ++j;
        }
 
        // Qy
        if(pJOINT_INFOS[i].flags & 16 ) {
            animatedOrientation.y = pANIM_FRAME_DATA[pJOINT_INFOS[i].startIndex + j];
            ++j;
        }
 
        // Qz
        if(pJOINT_INFOS[i].flags & 32 ) {
            animatedOrientation.z = pANIM_FRAME_DATA[pJOINT_INFOS[i].startIndex + j];
        }
 
        // Compute orientation quaternion's w value
        animatedOrientation.w = glm::extractRealComponent(animatedOrientation);
 
        // NOTE: we assume that this joint's parent has
        // already been calculated, i.e. joint's ID should
        // never be smaller than its parent ID.
        const auto thisJoint = const_cast<MD5Joint *>(&pSkeletonFrame[i]);
 
        const GLint parent = pJOINT_INFOS[i].parent;
        thisJoint->parent = parent;
        strcpy (thisJoint->name, pJOINT_INFOS[i].name);
 
        // Has parent?
        if( thisJoint->parent == MD5Joint::NULL_JOINT ) {
            thisJoint->position = animatedPosition;
            thisJoint->orientation = animatedOrientation;
        } else {
            const MD5Joint *parentJoint = &pSkeletonFrame[parent];
            glm::vec3 rotatedPosition = glm::rotate(parentJoint->orientation, glm::vec4(animatedPosition, 0.0f));
 
            // Add positions
            thisJoint->position = parentJoint->position + rotatedPosition;
 
            // Concatenate rotations
            thisJoint->orientation = glm::normalize( glm::cross(parentJoint->orientation, animatedOrientation) );
        }
    }
}
 
inline bool
CSCI441::MD5Model::readMD5Anim(
        const char *filename,
        const GLushort targetAnimationIndex
) {
    if (targetAnimationIndex >= _numAnimations) {
        fprintf (stderr, "[.md5anim]: Error: target animation index %u is out of range for currently allocated animations (which is %u)\n", targetAnimationIndex, _numAnimations);
        fprintf (stderr, "[.md5anim]: Hey Developer, if you wish to add an animation to the sequence, use CSCI441::MD5Model::addMD5Anim(const char*)\n");
        return false;
    }
 
    char buff[512];
    MD5JointInfo *jointInfos = nullptr;
    MD5BaseFrameJoint *baseFrame = nullptr;
    GLfloat *animFrameData = nullptr;
    GLint version;
    GLint numAnimatedComponents;
    GLint frameIndex, numFrames, numJoints;
    GLint i;
 
    printf( "[.md5anim]: about to read %s into animation %u\n", filename, targetAnimationIndex );
 
    FILE *fp = fopen( filename, "rb" );
    if( !fp ) {
        fprintf (stderr, "[.md5anim]: Error: couldn't open \"%s\"!\n", filename);
        return false;
    }
 
    while( !feof(fp) ) {
        // Read whole line
        fgets( buff, sizeof(buff), fp );
 
        if( sscanf(buff, " MD5Version %d", &version) == 1 ) {
            if( version != 10 ) {
                // Bad version
                fprintf (stderr, "[.md5anim]: Error: bad animation version\n");
                fclose (fp);
                return false;
            }
        } else if( sscanf(buff, " numFrames %d", &numFrames) == 1 ) {
            // Allocate memory for skeleton frames and bounding boxes
            _animations[targetAnimationIndex]->setNumberOfFrames(numFrames);
        } else if( sscanf(buff, " numJoints %d", &numJoints) == 1 ) {
            if (jointInfos != nullptr) {
                fprintf( stderr, "[.md5anim]: Error: md5anim file malformed. numJoints already specified\n" );
            }
            if( numJoints > 0 ) {
                _animations[targetAnimationIndex]->setNumberOfJoints(numJoints);
 
                // Allocate temporary memory for building skeleton frames
                jointInfos = new MD5JointInfo[numJoints];
                baseFrame = new MD5BaseFrameJoint[numJoints];
            }
        } else if( sscanf(buff, " frameRate %d", &_animations[targetAnimationIndex]->frameRate) == 1 ) {
 
        } else if( sscanf(buff, " numAnimatedComponents %d", &numAnimatedComponents) == 1 ) {
            if (animFrameData != nullptr) {
                fprintf( stderr, "[.md5anim]: Error: md5anim file malformed. numAnimatedComponents already specified\n" );
            }
            if( numAnimatedComponents > 0 ) {
                // Allocate memory for animation frame data
                animFrameData = new GLfloat[numAnimatedComponents];
            }
        } else if( strncmp(buff, "hierarchy {", 11) == 0 ) {
            if (jointInfos == nullptr) {
                fprintf( stderr, "[.md5anim]: Error: md5anim file malformed. numJoints not specified prior to hierarchy\n" );
            } else {
                for(i = 0; i < numJoints; ++i) {
                    // Read whole line
                    fgets( buff, sizeof(buff), fp );
 
                    // Read joint info
                    sscanf(buff, " %s %d %d %d",
                           jointInfos[i].name, &jointInfos[i].parent,
                           &jointInfos[i].flags, &jointInfos[i].startIndex);
                }
            }
        } else if( strncmp(buff, "bounds {", 8) == 0 ) {
            if (_animations[targetAnimationIndex]->getNumberOfFrames() == 0) {
                fprintf( stderr, "[.md5anim]: Error: md5anim file malformed. numFrames not specified prior to bounds\n" );
            } else {
                for(i = 0; i < _animations[targetAnimationIndex]->getNumberOfFrames(); ++i) {
                    // Read whole line
                    fgets( buff, sizeof(buff), fp );
 
                    // Read bounding box
                    sscanf(buff, " ( %f %f %f ) ( %f %f %f )",
                           &_animations[targetAnimationIndex]->getBoundingBox(i).min[0], &_animations[targetAnimationIndex]->getBoundingBox(i).min[1], &_animations[targetAnimationIndex]->getBoundingBox(i).min[2],
                           &_animations[targetAnimationIndex]->getBoundingBox(i).max[0], &_animations[targetAnimationIndex]->getBoundingBox(i).max[1], &_animations[targetAnimationIndex]->getBoundingBox(i).max[2]);
                }
            }
        } else if( strncmp(buff, "baseframe {", 10) == 0 ) {
            if (baseFrame == nullptr) {
                fprintf( stderr, "[.md5anim]: Error: md5anim file malformed. numJoints not specified prior to baseframe\n" );
            } else {
                for(i = 0; i < numJoints; ++i) {
                    // Read whole line
                    fgets( buff, sizeof(buff), fp );
 
                    // Read base frame joint
                    if( sscanf(buff, " ( %f %f %f ) ( %f %f %f )",
                               &baseFrame[i].position[0], &baseFrame[i].position[1], &baseFrame[i].position[2],
                               &baseFrame[i].orientation[0], &baseFrame[i].orientation[1], &baseFrame[i].orientation[2]) == 6 ) {
                        // Compute the w component
                        baseFrame[i].orientation.w = glm::extractRealComponent(baseFrame[i].orientation);
                    }
                }
            }
        } else if(sscanf(buff, " frame %d", &frameIndex) == 1 ) {
            if (animFrameData == nullptr) {
                fprintf( stderr, "[.md5anim]: Error: md5anim file malformed. numAnimatedComponents not specified prior to frame\n" );
            } else if (_animations[targetAnimationIndex]->getNumberOfFrames() == 0) {
                fprintf( stderr, "[.md5anim]: Error: md5anim file malformed. numFrames not specified prior to frame\n" );
            } else if (baseFrame == nullptr) {
                fprintf( stderr, "[.md5anim]: Error: md5anim file malformed. baseframe not specified prior to frame\n" );
            } else if (jointInfos == nullptr) {
                fprintf( stderr, "[.md5anim]: Error: md5anim file malformed. numJoints not specified prior to frame\n" );
            } else {
                // Read frame data
                for(i = 0; i < numAnimatedComponents; ++i)
                    fscanf( fp, "%f", &animFrameData[i] );
 
                // Build frame _skeleton from the collected data
                _buildFrameSkeleton(jointInfos, baseFrame, animFrameData,
                                    _animations[targetAnimationIndex]->getSkeletonFrame(frameIndex),
                                    numJoints);
            }
        }
    }
 
    fclose( fp );
 
    printf( "[.md5anim]: finished reading %s into animation %u\n", filename, targetAnimationIndex );
    printf( "[.md5anim]: read in %d frames of %d joints with %d animated components\n", _animations[targetAnimationIndex]->getNumberOfFrames(), _animations[targetAnimationIndex]->getNumberOfJoints(), numAnimatedComponents );
    printf( "[.md5anim]: animation's frame rate is %d\n", _animations[targetAnimationIndex]->frameRate );
 
    // Free temporary data allocated
    delete[] animFrameData;
    delete[] baseFrame;
    delete[] jointInfos;
 
    // successful loading...set up animation parameters
    _animationInfos[targetAnimationIndex].currFrame = 0;
    _animationInfos[targetAnimationIndex].nextFrame = 1;
 
    _animationInfos[targetAnimationIndex].lastTime = 0.0f;
    _animationInfos[targetAnimationIndex].maxTime = 1.0f / static_cast<GLfloat>(_animations[targetAnimationIndex]->frameRate);
 
    // Allocate memory for animated _skeleton
    if (_animations[targetAnimationIndex]->getNumberOfJoints() == 0) {
        fprintf( stderr, "[.md5anim]: Error: md5anim file malformed. numJoints never specified\n" );
    } else {
        _skeleton = new MD5Joint[_animations[targetAnimationIndex]->getNumberOfJoints()];
    }
 
    if( _checkAnimValidity(targetAnimationIndex) ) {
        _isAnimated = true;
        // compute initial pose
        animate(0.0);
    }
 
    return true;
}
 
inline bool
CSCI441::MD5Model::addMD5Anim(
    const char* filename
) {
    // extend animation array
    auto newAnimations = new MD5Animation*[_numAnimations + 1];
    auto newAnimationInfos = new MD5AnimationState[_numAnimations + 1];
 
    for( int i = 0; i < _numAnimations; ++i ) {
        newAnimations[i] = _animations[i];
        newAnimationInfos[i] = _animationInfos[i];
    }
    newAnimations[_numAnimations] = new MD5Animation();
 
    delete[] _animations;
    delete[] _animationInfos;
 
    _animations = newAnimations;
    _animationInfos = newAnimationInfos;
 
    _numAnimations++;
 
    // read animation into new array position
    fprintf( stdout, "[.md5anim]: preparing to read %s into new animation %u\n", filename, (_numAnimations-1) );
    const bool readSuccess = readMD5Anim(filename, _numAnimations - 1);
 
    if (readSuccess) {
        fprintf( stdout, "[.md5anim]: successfully read %s into new animation %u\n", filename, (_numAnimations-1) );
    } else {
        fprintf( stderr, "[.md5anim]: Error: could not read %s into new animation %u\n", filename, (_numAnimations-1) );
 
        // undo array growth
        newAnimations = new MD5Animation*[_numAnimations-1];
        newAnimationInfos = new MD5AnimationState[_numAnimations-1];
 
        for (int i = 0; i < _numAnimations - 1; ++i) {
            newAnimations[i] = _animations[i];
            newAnimationInfos[i] = _animationInfos[i];
        }
        delete _animations[_numAnimations-1];
 
        delete[] _animations;
        delete[] _animationInfos;
 
        _animations = newAnimations;
        _animationInfos = newAnimationInfos;
 
        _numAnimations--;
    }
 
    return readSuccess;
}
 
inline void
CSCI441::MD5Model::useTargetAnimationIndex(
    const GLushort targetAnimationIndex
) {
    // if target index is within range
    if (targetAnimationIndex < _numAnimations) {
        // update animation to run through
        _currentAnimationIndex = targetAnimationIndex;
 
        // set to base animation
        _animationInfos[targetAnimationIndex].currFrame = 0;
        _animationInfos[targetAnimationIndex].nextFrame = 1;
 
        _animationInfos[targetAnimationIndex].lastTime = 0.0f;
        _animationInfos[targetAnimationIndex].maxTime = 1.0f / static_cast<GLfloat>(_animations[targetAnimationIndex]->frameRate);
 
        animate(0.f);
    }
}
 
inline void
CSCI441::MD5Model::_freeAnim()
{
    delete[] _skeleton;
    _skeleton = nullptr;
 
    for (int i = 0; i < _numAnimations; i++) {
        delete _animations[i];
    }
    delete[] _animations;
    _animations = nullptr;
 
    delete[] _animationInfos;
    _animationInfos = nullptr;
}
 
inline void CSCI441::MD5Model::_moveFromSrc(MD5Model &src) {
    this->_baseSkeleton = src._baseSkeleton;
    src._baseSkeleton = nullptr;
 
    this->_meshes = src._meshes;
    src._meshes = nullptr;
 
    this->_maxVertices = src._maxVertices;
    src._maxVertices = 0;
 
    this->_maxTriangles = src._maxTriangles;
    src._maxTriangles = 0;
 
    this->_vertexArray = src._vertexArray;
    src._vertexArray = nullptr;
 
    this->_texelArray = src._texelArray;
    src._texelArray = nullptr;
 
    this->_vertexIndicesArray = src._vertexIndicesArray;
    src._vertexIndicesArray = nullptr;
 
    this->_vao = src._vao;
    src._vao = 0;
 
    this->_vbo[0] = src._vbo[0];
    this->_vbo[1] = src._vbo[1];
    src._vbo[0] = 0;
    src._vbo[1] = 0;
 
    this->_skeletonVAO = src._skeletonVAO;
    src._skeletonVAO = 0;
 
    this->_skeletonVBO = src._skeletonVBO;
    src._skeletonVBO = 0;
 
    this->_skeleton = src._skeleton;
    src._skeleton = nullptr;
 
    this->_animations = src._animations;
    src._animations = nullptr;
 
    this->_numAnimations = src._numAnimations;
    src._numAnimations = 0;
 
    this->_currentAnimationIndex = src._currentAnimationIndex;
    src._currentAnimationIndex = 0;
 
    this->_isAnimated = src._isAnimated;
    src._isAnimated = false;
 
    this->_animationInfos = src._animationInfos;
    src._animationInfos = nullptr;
}
 
inline void
CSCI441::MD5Model::_interpolateSkeletons(const GLfloat interp)
{
    const MD5Joint *skeletonA = _animations[_currentAnimationIndex]->getSkeletonFrame(_animationInfos[_currentAnimationIndex].currFrame);
    const MD5Joint *skeletonB = _animations[_currentAnimationIndex]->getSkeletonFrame(_animationInfos[_currentAnimationIndex].nextFrame);
 
    for(GLint i = 0; i < _animations[_currentAnimationIndex]->getNumberOfJoints(); ++i) {
        // Copy parent index
        _skeleton[i].parent = skeletonA[i].parent;
 
        // Linear interpolation for position
        _skeleton[i].position = glm::mix(skeletonA[i].position, skeletonB[i].position, interp);
 
        // Spherical linear interpolation for orientation
        _skeleton[i].orientation = glm::slerp(skeletonA[i].orientation, skeletonB[i].orientation, interp);
    }
}
 
// Perform animation related computations.  Calculate the current and
// next frames, given a delta time.
inline void
CSCI441::MD5Model::animate(const GLfloat dt)
{
    const GLint maxFrames = _animations[_currentAnimationIndex]->getNumberOfFrames() - 1;
    if (maxFrames <= 0) return;
 
    _animationInfos[_currentAnimationIndex].lastTime += dt;
 
    // move to next frame
    if( _animationInfos[_currentAnimationIndex].lastTime >= _animationInfos[_currentAnimationIndex].maxTime ) {
        _animationInfos[_currentAnimationIndex].currFrame++;
        _animationInfos[_currentAnimationIndex].nextFrame++;
        _animationInfos[_currentAnimationIndex].lastTime = 0.0;
 
        if( _animationInfos[_currentAnimationIndex].currFrame > maxFrames )
            _animationInfos[_currentAnimationIndex].currFrame = 0;
 
        if( _animationInfos[_currentAnimationIndex].nextFrame > maxFrames )
            _animationInfos[_currentAnimationIndex].nextFrame = 0;
    }
 
    // Interpolate skeletons between two frames
    _interpolateSkeletons( _animationInfos[_currentAnimationIndex].lastTime * static_cast<GLfloat>(_animations[_currentAnimationIndex]->frameRate) );
}
 
#endif//CSCI441_MD5_MODEL_HPP