Mesh.h

/*
 * This file is part of Bubba-3D.
 *
 * Bubba-3D is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Bubba-3D is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with Bubba-3D. If not, see http://www.gnu.org/licenses/.
 */
#pragma once

#include <string>
#include <vector>
#include "linmath/float3.h"
#include "Material.h"
#include "AABB2.h"
#include "assimp/material.h"
#include <Sphere.h>
#include <assimp/scene.h>
#include <map>
#include <assimp/Importer.hpp>
#include <memory>


class BoneTransformer;
class Triangle;
class Chunk;
struct BoneInfluenceOnVertex;

class Mesh {
public:
    Mesh();

    ~Mesh() = default;

    void loadMesh(const std::string &fileName);

    std::vector<Triangle *> getTriangles();

    AABB* getAABB();

    Sphere getSphere();

    std::vector<Chunk>* getChunks();
    std::vector<Material>* getMaterials();

    bool hasAnimations();

    std::vector<chag::float4x4> getBoneTransforms(float totalElapsedTimeInSeconds);

private:
    void initMesh(const aiScene *pScene, const std::string &fileNameOfMesh);
    void initMeshFromAiMesh(unsigned int index, const aiMesh *paiMesh);
    void initChunkFromAiMesh(const aiMesh *paiMesh, Chunk &chunk);
    void initVerticesFromAiMesh(const aiMesh *paiMesh, Chunk &chunk);
    void initIndicesFromAiMesh(const aiMesh *paiMesh, Chunk &chunk);

    void initBonesFromAiMesh(const aiMesh *paiMesh, Chunk &bones);
    void assertAllVertexWeightsSumToOne(Chunk &chunk);


    void initMaterials(const aiScene *pScene, const std::string &fileNameOfMesh);
    void initMaterialTextures(Material *material, std::string fileNameOfMesh,
                              const aiMaterial *loadedMaterial);
    void initMaterialColors(Material *material, const aiMaterial *loadedMaterial);
    void initMaterialShininess(Material *material, const aiMaterial *loadedMaterial);

    chag::float3 getColorFromMaterial(const char* colorTypeString, unsigned int type,
                                      unsigned int index, const aiMaterial &material);

    std::string getPathOfTexture(const std::string &fileNameOfMesh,
                                 std::string textureName);

    std::string getDirectoryFromPath(const std::string &fileName);

    std::string cleanFileName(std::string filePath);

    Texture* getTexture(const aiMaterial *material, const std::string &fileNameOfMesh,
                        aiTextureType type);

    void setupChunkForRendering(Chunk &chunk);

    void setupSphere(std::vector<chag::float3> *positions);

    void createTriangles();
    Triangle* createTriangleFromPositions(std::vector<chag::float3> positionBuffer,
                                          std::vector<unsigned int> indices,
                                          unsigned int startIndex);

    std::vector<Triangle *> triangles;
    std::vector<Material> materials;
    std::vector<Chunk> m_chunks;

    std::shared_ptr<BoneTransformer> boneTransformer;
    Assimp::Importer importer;

    Sphere sphere;
    AABB m_aabb;

    unsigned int numAnimations;

};