smodel.hpp

Go to the documentation of this file.

#pragma once
 
#include <functional>
#include <glm/glm.hpp>
#include <string>
#include <vector>
 
#include "NNL/common/enum_flag.hpp"
#include "NNL/common/fixed_type.hpp"
#include "NNL/simple_asset/sanimation.hpp"
#include "NNL/simple_asset/svalue.hpp"
 
namespace nnl {


constexpr std::size_t kMaxNumBoneWeight = 8;

struct SVertex {
  glm::vec3 position{0.0f};  
 
  glm::vec3 normal{0.0f, 1.0f, 0.0f};  
 
  glm::vec2 uv{0.0f};  
 
  glm::vec4 color{1.0f, 1.0f, 1.0f, 1.0f};  
 
  std::array<u16, kMaxNumBoneWeight> bones{0};  
 
  std::array<float, kMaxNumBoneWeight> weights{1.0f};  

  void Transform(const glm::mat4& transform);

  bool HasAlpha() const;

  bool IsApproxEqual(const SVertex& rhs) const;

  void NormalizeWeights();

  void QuantWeights(unsigned int steps = 128);

  void SortWeights();

  void LimitWeights(unsigned int max_weights = 3);

  void ResetWeights();

  void ResetNormals();

  void ResetUVs();

  void ResetColors();

  friend SVertex operator*(const glm::mat4& transform, SVertex vertex);
 
  friend SVertex operator*(const SVertex& vertex, float scalar);
};

struct STriangle {
  std::array<SVertex, 3> vertices;  

  const SVertex& operator[](std::size_t index) const;

  SVertex& operator[](std::size_t index);

  bool IsDegenerate() const;

  void ReverseWindingOrder();
};

struct SMesh {
  std::string name;  
 
  std::vector<u32> indices;  
 
  std::vector<SVertex> vertices;  
 
  std::size_t material_id = 0;  
 
  std::map<std::size_t, std::vector<std::size_t>> material_variants;  
 
  std::size_t mesh_group = 0;  
 
  bool uses_uv = false;      
  bool uses_normal = false;  
  bool uses_color = false;   
 
  SValue extras;  

  [[nodiscard]] static SMesh FromTriangles(const std::vector<STriangle>& triangles);

  void Join(const SMesh& smesh);

  glm::vec3 CalculateCenter() const;

  void ReverseWindingOrder();

  void Transform(const glm::mat4& transform);
  void TransformUV(const glm::mat3& transform);

  void RemoveDuplicateVertices();

  static std::pair<std::vector<u32>, std::vector<SVertex>> RemoveDuplicateVertices(
      const std::vector<u32>& indices, const std::vector<SVertex>& vertices);

  void GenerateSmoothNormals();

  void GenerateFlatNormals();

  std::pair<glm::vec3, glm::vec3> FindMinMax() const;

  std::pair<glm::vec2, glm::vec2> FindMinMaxUV() const;

  bool IsAffectedByFewBones() const;

  bool HasAlphaVertex() const;

  void NormalizeWeights();

  void NormalizeNormals();

  void QuantWeights(unsigned int steps = 128);

  void SortWeights();

  void LimitWeightsPerVertex(unsigned int max_weights = 3);

  void LimitWeightsPerTriangle(unsigned int max_weights = 8);

  void ResetWeights();

  void ResetNormals();

  void ResetUVs();

  void ResetColors();
};

struct SBone {
  std::string name;  
 
  glm::vec3 scale{1.0f, 1.0f, 1.0f};  
 
  glm::quat rotation{1.0f, 0.0f, 0.0f, 0.0f};  
 
  glm::vec3 translation{0.0f, 0.0f, 0.0f};  
 
  glm::mat4 inverse{1.0f};  
 
  std::vector<SBone> children;  
  glm::mat4 GetTransform() const;
  void SetTransform(const glm::mat4& transform);
};

struct SSkeleton {
  std::vector<SBone> roots;  

  std::vector<glm::mat4> GetGlobalMatrices() const;

  std::vector<glm::mat4> GetSkinningMatrices() const;

  void UpdateInverseMatrices();

  std::vector<std::reference_wrapper<const SBone>> GetBoneRefs() const;

  std::vector<std::reference_wrapper<SBone>> GetBoneRefs();
};

enum class NNL_FLAG_ENUM SBlendMode : u8 {
  kOpaque = 0b00000,  
  kAlpha = 0b00001,   
  kClip = 0b00010,    
  kAdd = 0b00100,     
  kSub = 0b01000      
};
 
NNL_DEFINE_ENUM_OPERATORS(SBlendMode);

enum class STextureProjection {
  kUV = 0,          
  kMatrix = 1,      
  kEnvironment = 2  
};

struct SMaterial {
  std::string name;  
 
  glm::vec3 specular{0.0f};  
  glm::vec3 diffuse{1.0f};   
  glm::vec3 ambient{0.5f};   
  glm::vec3 emissive{0.0f};  
 
  float opacity = 1.0f;  
 
  float specular_power = 50.0f;  
 
  int texture_id = -1;  
 
  bool lit = false;  
 
  u16 vfx_group_id = 0;  
 
  SBlendMode alpha_mode = SBlendMode::kOpaque;  
 
  STextureProjection projection_mode = STextureProjection::kUV;  
 
  SValue extras;  

  bool operator==(const SMaterial& rhs) const;
};

struct SAttachment {
  std::string name = "";  
 
  std::size_t id = 0;    
  std::size_t bone = 0;  
 
  glm::vec3 scale{1.0f, 1.0f, 1.0f};           
  glm::quat rotation{1.0f, 0.0f, 0.0f, 0.0f};  
  glm::vec3 translation{0.0f, 0.0f, 0.0f};     
 
  glm::mat4 GetTransform() const;
 
  void SetTransform(const glm::mat4& transform);
};

 
struct SModel {
  SSkeleton skeleton;  
 
  std::vector<SAttachment> attachments;  
 
  std::vector<SMesh> meshes;  
 
  std::vector<SMaterial> materials;  
 
  std::vector<std::string> material_variants;  
 
  std::vector<SUVAnimation> uv_animations;  

  glm::vec3 CalculateCenter() const;

  bool TryBakeBindShape();

  void Transform(const glm::mat4& matrix);

  void TransformUV(const glm::mat3& matrix);

  void RemoveDuplicateMaterials();

  void GenerateSmoothNormals();

  void GenerateFlatNormals();

  std::pair<glm::vec3, glm::vec3> FindMinMax() const;

  glm::mat4 Normalize();

  std::vector<std::pair<glm::vec2, glm::vec2>> NormalizeUV();

  void NormalizeWeights();

  void NormalizeNormals();

  void QuantWeights(unsigned int steps = 128);

  void SortWeights();

  void LimitWeightsPerVertex(unsigned int max_weights = 3);

  void LimitWeightsPerTriangle(unsigned int max_weights = 8);

  void ResetWeights();

  void ResetNormals();

  void ResetUVs();

  void ResetColors();
};

}  // namespace nnl