Model.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <string>
#include <vector>
#include "Math.hpp"
#include "Image.hpp"
#include "File.hpp"
#include "Material.hpp"
 
namespace glm {
  template<class Archive> void serialize(Archive& archive, small3d::Vec3& v) { archive(v.x, v.y, v.z); }
  template<class Archive> void serialize(Archive& archive, small3d::Vec4& v) { archive(v.x, v.y, v.z, v.w); }
  template<class Archive> void serialize(Archive& archive, small3d::Mat4& m) { archive(m[0], m[1], m[2], m[3]); }
}
 
namespace small3d {
 
  class Model {
 
  private:
 
    uint32_t positionBufferObjectId = 0;
    uint32_t indexBufferObjectId = 0;
    uint32_t normalsBufferObjectId = 0;
    uint32_t uvBufferObjectId = 0;
    uint32_t jointBufferObjectId = 0;
    uint32_t weightBufferObjectId = 0;
 
    uint32_t currentAnimation = 0;
    std::vector<uint64_t> numPoses;
 
    // Original transformation matrix (from armature/skin),
    // as read from a file
    Mat4 origTransformation = Mat4(1.0f);
 
    // Original rotation (from armature/skin), as read from a
    // file (in quaternion form)
    Quat origRotation = { 0.0f, 0.0f, 0.0f, 1.0f };
 
    // brief Original translation, as read from a file
    Vec3 origTranslation = Vec3(0.0f, 0.0f, 0.0f);
 
    // brief Original scale, as read from a file
    Vec3 origScale = Vec3(1.0f, 1.0f, 1.0f);
 
 
  public:
 
    Material material;
 
    struct AnimationComponent {
      uint32_t input = 0;
      std::vector<Quat> rotationAnimation;
      std::vector<Vec3> translationAnimation;
      std::vector<Vec3> scaleAnimation;
      std::vector<float> times;
      template <class Archive>
      void serialize(Archive& archive) {
        archive(input, rotationAnimation, translationAnimation, scaleAnimation, times);
      }
    };
 
    struct Animation {
      std::string name;
      std::vector<AnimationComponent> animationComponents;
      template <class Archive>
      void serialize(Archive& archive) {
        archive(name, animationComponents);
      }
    };
 
    struct Joint {
      uint32_t node = 0;
      std::string name;
      Mat4 inverseBindMatrix = Mat4(1.0f);
      Quat rotation = { 1.0f, 0.0f, 0.0f, 0.0f };
      Vec3 scale = Vec3(1.0f, 1.0f, 1.0f);
      Vec3 translation = Vec3(0.0f, 0.0f, 0.0f);
      Mat4 transformation = Mat4(1.0f);
      std::vector<uint32_t> children;
      std::vector<Animation> animations;
 
      template <class Archive>
      void serialize(Archive& archive) {
        archive(node, name, inverseBindMatrix, rotation, scale, translation,
          transformation, children, animations);
      }
    };
 
    Vec3 scale = Vec3(1.0f, 1.0f, 1.0f);
 
    static const uint32_t MAX_JOINTS_SUPPORTED = 32;
 
    std::shared_ptr<Image> defaultTextureImage;
 
    std::vector<float> vertexData;
 
    uint32_t vertexDataByteSize = 0;
 
    std::vector<uint16_t> indexData;
 
    uint32_t indexDataByteSize = 0;
 
    std::vector<float> normalsData;
 
    uint32_t normalsDataByteSize = 0;
 
    std::vector<float> textureCoordsData;
 
    uint32_t textureCoordsDataByteSize = 0;
 
    std::vector<uint8_t> jointData;
 
    uint32_t jointDataByteSize = 0;
 
    std::vector<float> weightData;
 
    uint32_t weightDataByteSize = 0;
 
    std::vector<Joint> joints;
 
    std::vector<Animation> animations;
 
    bool noShadow = false;
 
    Model();
 
    explicit Model(File& file, const std::string& meshName = "") ;
 
    explicit Model(File&& file, const std::string& meshName = "");
 
    uint64_t getNumPoses();
    
    size_t getNumAnimations();
 
    void setAnimation(uint32_t animationIdx);
 
 
    Mat4 getTransform(uint32_t animationIdx, uint64_t currentPose, float seconds = 0.0f);
 
    Mat4 getJointTransform(size_t jointIdx, uint32_t animationIdx, uint64_t currentPose, float seconds = 0.0f);
 
    Vec3 getOriginalScale();
 
    void saveBinary(const std::string& binaryFilePath);
 
    template <class Archive>
    void serialize(Archive& archive) {
      archive(currentAnimation,
        numPoses,
        origTransformation,
        origRotation,
        origTranslation,
        origScale,
        material,
        scale,
        defaultTextureImage,
        vertexData,
        vertexDataByteSize,
        indexData,
        indexDataByteSize,
        normalsData,
        normalsDataByteSize,
        textureCoordsData,
        textureCoordsDataByteSize,
        jointData,
        jointDataByteSize,
        weightData,
        weightDataByteSize,
        joints,
        animations
        );
    }
 
    friend class GlbFile;
    friend class Renderer;
   
  };
}