model.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <cstring>
#include <map>
#include <vector>
 
#include "NNL/common/enum_flag.hpp"
#include "NNL/common/fixed_type.hpp"
#include "NNL/common/io.hpp"
#include "NNL/game_asset/visual/model_common.hpp"
#include "NNL/simple_asset/smodel.hpp"
#include "NNL/utility/static_set.hpp"

#ifdef __DOXYGEN__
#define NNL_UVANIM_MAX_DUR 1000
#endif
 
namespace nnl {

namespace model {
constexpr std::size_t kMaxNumBonePerPrim = 8;

enum class UVAnimationMode : u16 {
  kNone = 0,             
  kContinuousShift = 1,  
 
  kRangedShift = 2,  
 
  kFramedShift = 3  
};

enum class PrimitiveType : u16 {
  kPoints = 0,
  kLines = 1,
  kLineStrip = 2,
  kTriangles = 3,
  kTriangleStrip = 4,
  kTriangleFan = 5,
  kSprites = 6
};

enum class NNL_FLAG_ENUM MaterialFeatures : u16 {
 
  kNone = 0,  
 
  kVertexColors = 0b000000001,  
 
  kLit = 0b000000010,                
  kProjectionMapping = 0b000000100,  
  kAdditiveBlending = 0b000001000,   
 
  kSubtractiveBlending = 0b000010000,  
  kNoDepthWriteDefer = 0b000100000,    
  kAlphaClip = 0b001000000,            
  kSkinning = 0b010000000,             
  kEnvironmentMapping = 0b100000000    
};
 
NNL_DEFINE_ENUM_OPERATORS(MaterialFeatures)
 

struct Bone {
  i16 parent_index = -1;        
  glm::vec3 scale{1.0f};        
  glm::vec3 rotation{0.0f};     
  glm::vec3 translation{0.0f};  
};

struct TextureSwap {
  i16 original_texture_id = 0;
  i16 new_texture_id = 0;
};

struct UVAnimation {
  UVAnimationMode animation_mode = UVAnimationMode::kNone;  
 
  u16 num_frames = 0;  
 
  f32 u_shift = 0;  
  f32 v_shift = 0;  
};

struct Attachment {
  BoneIndex bone_id = 0;      
  u16 attachment_id = 0;      
  glm::mat4 transform{1.0f};  
};

struct BBox {
  BoneIndex bone_index = 0;  
  glm::vec3 min{0.0f};       
  glm::vec3 max{0.0f};       
};

struct Primitive {
  PrimitiveType primitive_type = PrimitiveType::kTriangles;  
  u16 num_elements = 0;                                      
  Buffer vertex_index_buffer;                                
};

struct SubMesh {
  u16 num_bones = 1;  
 
  u32 vertex_format = 0;              
  Buffer indexed_vertex_buffer;       
  std::vector<Primitive> primitives;  
 
  std::array<BoneIndex, kMaxNumBonePerPrim> bone_indices{0};  
  std::vector<u32> display_list;                              
};

struct Mesh {
  std::vector<SubMesh> submeshes;  
  bool use_skinning = false;       
  bool use_bbox = false;           
 
  BBox bbox;            
  u16 material_id = 0;  
};

struct MeshGroup {
  std::vector<Mesh> meshes;  
  f32 u_scale = 1.0f;        
  f32 v_scale = 1.0f;        
  f32 u_offset = 0.0f;       
  f32 v_offset = 0.0f;       
};

struct Material {
  u32 specular = 0xFF000000;   
  u32 diffuse = 0xFFFFFFFF;    
  u32 ambient = 0xFF808080;    
  u32 emissive = 0xFF000000;   
  f32 specular_power = 50.0f;  
  i16 texture_id = -1;         
  u8 uv_animation_id = 0;      
  u8 vfx_group_id = 0;         
  MaterialFeatures features{};  
};

struct Model {
  std::vector<Bone> skeleton;  
 
  bool move_with_root = false;  
 
  std::map<BoneIndex, glm::mat4> inverse_matrix_bone_table;  
 
  std::vector<std::map<BoneTarget, BoneIndex>> bone_target_tables;  
 
  std::vector<TextureSwap> texture_swaps;  
 
  std::vector<Attachment> attachments;  
 
  std::vector<UVAnimation> uv_animations;  
 
  std::vector<MeshGroup> mesh_groups;  
 
  std::vector<Material> materials;  
};

enum class CompLvl {
  kNone = 0,    
  kMedium = 1,  
  kMax = 2      
};

struct ConvertParam {
  CompLvl compress_lvl = CompLvl::kMedium;  
 
  u32 force_vertex_format = 0;    
  bool indexed = true;            
  bool use_bbox = false;          
  bool optimize_weights = false;  
  bool use_strips = true;         
  bool stitch_strips = true;      
  bool join_submeshes = true;     
};

Model Convert(SModel&& smodel, const std::vector<ConvertParam>& mesh_params, bool move_with_root = false);
Model Convert(SModel&& smodel, const ConvertParam& mesh_params = {}, bool move_with_root = false);
SModel Convert(const Model& model);

bool IsOfType(BufferView buffer);
 
bool IsOfType(const std::filesystem::path& path);
 
bool IsOfType(Reader& f);

Model Import(BufferView buffer);
 
Model Import(const std::filesystem::path& path);
 
Model Import(Reader& f);
[[nodiscard]] Buffer Export(const Model& model);
 
void Export(const Model& model, const std::filesystem::path& path);
 
void Export(const Model& model, Writer& f);  // Main


enum GeCmd : u32 {
  kReturn = 0x0B'00'00'00,          
  kSetVertexType = 0x12'00'00'00,   
  kSetBaseAddress = 0x10'00'00'00,  
  kSetVramAddress = 0x01'00'00'00,  
  kDrawPrimitives = 0x04'00'00'00,  
};

enum HumanoidRigTarget : BoneTarget {
  kRoot = 0,
  kHips = 1,
  kSpine = 2,
  kSpine1 = 3,
  kNeck = 4,
  kHead = 5,
  kLeftShoulder = 6,
  kLeftArm = 7,
  kLeftForeArm = 8,
  kLeftHand = 9,
  kRightShoulder = 0xA,
  kRightArm = 0xB,
  kRightForeArm = 0xC,
  kRightHand = 0xD,
  kLeftUpLeg = 0xE,
  kLeftLeg = 0xF,
  kLeftFoot = 0x10,
  kRightUpLeg = 0x11,
  kRightLeg = 0x12,
  kRightFoot = 0x13,
  // the rest might vary depending on the asset
  kBodyPart20 = 0x14,
  kBodyPart21 = 0x15,
  kBodyPart22 = 0x16,
  kBodyPart23 = 0x17,
  kBodyPart24 = 0x18,
  kBodyPart25 = 0x19,
  kBodyPart26 = 0x1A,
  kBodyPart27 = 0x1B,
  kBodyPart28 = 0x1C,
  kBodyPart29 = 0x1D,
};

constexpr std::array<std::string_view, 30> bone_target_names{
    "Root",         "Hips",       "Spine",       "Spine1",     "Neck",          "Head",
    "LeftShoulder", "LeftArm",    "LeftForeArm", "LeftHand",   "RightShoulder", "RightArm",
    "RightForeArm", "RightHand",  "LeftUpLeg",   "LeftLeg",    "LeftFoot",      "RightUpLeg",
    "RightLeg",     "RightFoot",  "BodyPart20",  "BodyPart21", "BodyPart22",    "BodyPart23",
    "BodyPart24",   "BodyPart25", "BodyPart26",  "BodyPart27", "BodyPart28",    "BodyPart29"};

std::vector<STriangle> ExtractTriangles(const SubMesh& submesh, bool skip_degenerate = true);
struct TriangleGroup {
  utl::StaticSet<BoneIndex, kMaxNumBonePerPrim> bones;  
  std::vector<u32> indices;                             
};

std::vector<TriangleGroup> GroupTrianglesByBones(const std::vector<u32>& indices, const std::vector<SVertex>& vertices,
                                                 u32 max_num_triangles = std::numeric_limits<u16>::max() / 3,
                                                 bool join_bone_sets = true);
BBox GenerateBBox(const SMesh& mesh, glm::mat4 transform = glm::mat4(1.0f));

Mesh Convert(SMesh&& smesh, const ConvertParam& param = {});
SMesh Convert(const Mesh& mesh);
ConvertParam GenerateConvertParam(const Mesh& mesh);
std::vector<ConvertParam> GenerateConvertParam(const Model& model);
std::vector<Bone> Convert(const SSkeleton& skeleton);

void SetBoneNames(SSkeleton& skeleton, const std::vector<std::map<BoneTarget, BoneIndex>>& bone_target_tables,
                  bool is_character = true);
std::vector<std::map<BoneTarget, BoneIndex>> GenerateBoneTargetTables(const SSkeleton& skeleton);
SSkeleton Convert(const std::vector<Bone>& bones);

std::map<BoneIndex, glm::mat4> GenerateInverseMatrixBoneTable(const SModel& smodel);

UVAnimation Convert(const SUVChannel& suv_anim_channel);

SUVChannel Convert(const UVAnimation& uv_anim);

Material Convert(const SMaterial& smat);

SMaterial Convert(const Material& mat);
  // Auxiliary
 
namespace raw {


constexpr u32 kMagicBytes = 0x16'81'00'01;
 
NNL_PACK(struct RHeader {
  u32 magic_bytes = kMagicBytes;
  u32 offset_bones = 0;                      // 0x4;
  u32 offset_inverse_matrices = 0;           // 0x8
  u32 offset_inverse_matrix_bone_table = 0;  // 0xC
  u32 offset_mesh_groups = 0;                // 0x10
  u16 num_bones = 0;                         // 0x14
  u16 num_mesh_groups = 0;                   // 0x16
  u16 num_inverse_matrices = 0;              // 0x18
  u16 num_vfx_groups = 0;                    // 0x1A
  u32 header_size = sizeof(RHeader);         // 0x1C probably...
  u16 move_with_root = 0;                    // 0x20
  u16 num_bone_target_tables = 0;            // 0x22; 2 is max
  u32 offset_bone_target_tables = 0;         // 0x24
  u16 num_attachment_matrices = 0;           // 0x28;
  u16 num_uv_animations = 0;                 // 0x2A
  u32 offset_attachment_matrices = 0;        // 0x2C
  u32 offset_uv_animations = 0;              // 0x30
 
  u16 num_textures = 0;          // 0x34 total number of used textures
  u16 num_texture_swaps = 0;     // 0x36
  u32 offset_texture_swaps = 0;  // 0x38
  u32 address = 0;               // 0x3C memory location, filled dynamically
});
 
static_assert(sizeof(RHeader) == 0x40);
 
NNL_PACK(struct RBone {
  Vec3<f32> scale{0.0f};
  i16 parent_index = 0;
  Vec3<i16> rotation{0};  // pitch; yaw; roll; as normalized ints
  Vec3<f32> translation{0.0f};
});
 
static_assert(sizeof(RBone) == 0x20);
 
NNL_PACK(struct RBBox {
  u16 bone_index = 0;
  u8 padding[0xE] = {0};
  Vec4<f32> vertices[8] = {0.0f};
  // 0 minX, minY, minZ
  // 1 maxX, minY, minZ
  // 2 minX, maxY, minZ
  // 3 maxX, maxY, minZ
  // 4 minX, minY, maxZ
  // 5 maxX, minY, maxZ
  // 6 minX, maxY, maxZ
  // 7 maxX, maxY, maxZ
});
 
static_assert(sizeof(RBBox) == 0x90);
 
NNL_PACK(struct RAttachment {
  u16 bone_id = 0;
  u16 attachment_id = 0;
});
 
static_assert(sizeof(RAttachment) == 0x4);
 
NNL_PACK(struct RUVAnimation {
  u16 animation_mode = 0;
  u16 num_frames = 0;
  f32 u_shift = 0;
  f32 v_shift = 0;
  u32 unknown = 0;  // reserved (?)
});
 
static_assert(sizeof(RUVAnimation) == 0x10);
 
NNL_PACK(struct RTextureSwap {
  u32 id = 0;  // not used
  i16 original_texture_id = 0;
  i16 new_texture_id = 0;
});
 
static_assert(sizeof(RTextureSwap) == 0x8);
 
NNL_PACK(struct RBoneTargetHeader {
  u32 offset = 0;
  u32 num_entries = 0;
});
 
static_assert(sizeof(RBoneTargetHeader) == 0x8);
 
NNL_PACK(struct RBoneTargetEntry {
  u16 bone_index = 0;
  u16 role_id = 0;
});
 
static_assert(sizeof(RBoneTargetEntry) == 0x4);
 
struct RBoneTargetTables {
  std::vector<RBoneTargetHeader> header;
  std::vector<std::vector<RBoneTargetEntry>> entries;
};
 
NNL_PACK(struct RMeshGroup {
  u32 offset_meshes = 0;  // 0x0
  u16 num_meshes = 0;     // 0x4
  u16 padding = 0;        // 0x6
  f32 u_scale = 0.0f;     // 0x8
  f32 v_scale = 0.0f;     // 0xC
  f32 u_offset = 0.0f;    // 0x10
  f32 v_offset = 0.0f;    // 0x14
});
 
static_assert(sizeof(RMeshGroup) == 0x18);
 
NNL_PACK(struct RMesh {
  u32 offset_submeshes = 0;   // 0x0
  u16 num_submeshes = 0;      // 0x24
  u16 material_features = 0;  // 0x6
  u32 specular = 0;           // 0x8
  u32 diffuse = 0;            // 0xC
  u32 ambient = 0;            // 0x10
  u32 emissive = 0;           // 0x14
  f32 specular_power = 0.0f;  // 0x18
  i16 texture_id = 0;         // 0x1C
  u16 use_bbox = false;       // 0x1E
  u32 offset_bbox = 0;        // 0x20 if not used, set to the first offset to submeshes
  u16 material_id = 0;        // 0x24 note: there is no separate array of
                              // materials in the binary format. This number is used to
                              // determine if the next mesh uses the same material or not
  u8 vfx_group_id = 0;        // 0x26
  u8 uv_animation_id = 0;     // 0x27
});
 
static_assert(sizeof(RMesh) == 0x28);
 
NNL_PACK(struct RSubMesh {
  u16 num_bones = 0;       // 0x0
  u16 num_primitives = 0;  // 0x2
 
  u32 vertex_format = 0;                               // 0x4
  u32 offset_indexed_vertex_buffer = 0;                // 0x8
  u32 offset_primitives = 0;                           // 0xC
  u16 inv_mat_bone_indices[kMaxNumBonePerPrim] = {0};  // 0x10 note: entries in the "inverse matrix to bone" table!
  u32 offset_display_list = 0;                         // 0x20
});
 
static_assert(sizeof(RSubMesh) == 0x24);
 
NNL_PACK(struct RPrimitive {
  u16 primitive_type = 0;
  u16 num_elements = 0;
  u32 offset_buffer = 0;           // offset to vertex buffer or to index buffer
  u32 buffer_size = 0;             // aligned to 0x40
  u32 ptr_vram_vertex_buffer = 0;  // set by the game
});
 
static_assert(sizeof(RPrimitive) == 0x10);
 
struct RModel {
  RHeader header;
 
  std::vector<RBone> bones;
  // padding to 0x10
  std::vector<Mat4<f32>> inverse_matrices;
  std::vector<RTextureSwap> texture_swaps;
  std::vector<u16> inverse_matrix_bone_table;
  // padding to 0x4
  RBoneTargetTables bone_target_tables;
  // padding to 0x10
  std::vector<Mat4<f32>> attachment_matrices;
  std::vector<RAttachment> attachments;
  // padding to 0x4
  std::vector<RUVAnimation> uv_animations;
  // padding to 0x10
  std::vector<RMeshGroup> mesh_groups;
  // Maps of offsets (used in the structures above) to their data:
  std::map<u32, std::vector<RMesh>> meshes;
  std::map<u32, RBBox> bboxes;
  std::map<u32, std::vector<RSubMesh>> submeshes;
  std::map<u32, std::vector<RPrimitive>> primitives;
  std::map<u32, std::vector<u32>> display_lists;
  std::map<u32, Buffer> vertex_buffers;          // stores vertex buffers or
                                                 // index buffers
  std::map<u32, Buffer> indexed_vertex_buffers;  // stores vertex buffers
                                                 // when indexed drawing is used
};
 
std::vector<Bone> Convert(const std::vector<raw::RBone>& rbones);
 
Model Convert(RModel&& rmodel);
 
RModel Parse(Reader& f);
 
std::vector<raw::RBone> Convert(const std::vector<Bone>& bones);
  // Raw
}  // namespace raw
 
}  // namespace model
  // Model
}  // namespace nnl