colbox.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <glm/glm.hpp>
#include <map>
 
#include "NNL/common/fixed_type.hpp"
#include "NNL/common/io.hpp"
#include "NNL/game_asset/behavior/action_common.hpp"
#include "NNL/game_asset/visual/model_common.hpp"
#include "tsl/ordered_map.h"
namespace nnl {

namespace colbox {
struct CollisionBox14 {
  model::BoneTarget bone_target = 0;  
  u16 unknown2 = 0;                   
  glm::vec3 translation{0.0f};        
  f32 size = 4.0f;                    
};

struct CollisionBox18 {
  model::BoneTarget bone_target = 0;  
  u16 unknown2 = 0;                   
  glm::vec3 translation{0.0f};        
 
  f32 size = 4.0f;       
  f32 unknown14 = 0.0f;  
};

struct CollisionBox20 {
  model::BoneTarget bone_target = 0;  
  u16 distance_attack = 0;            
  glm::vec3 translation{0.0f};        
  glm::vec3 translation_2{0.0f};      
  f32 size = 0;                       
};

struct HitboxConfig {
  u16 dmg_start_frame = 0;               
  u16 dmg_end_frame = 0;                 
  u16 effect_id = 0;                     
  u8 unknownC = 1;                       
  u8 unknownD = 0;                       
  u16 unknownE = 0;                      
  std::vector<CollisionBox20> colboxes;  
};

struct ColBoxConfig {
  std::vector<CollisionBox14> col_enviroment;  
  std::vector<CollisionBox14> col_unknown;     
  std::vector<CollisionBox18> col_entities;    
  std::vector<CollisionBox14> col_damage;      
  tsl::ordered_map<action::Id, std::vector<HitboxConfig>>
      col_attack;  
};

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

ColBoxConfig Import(BufferView buffer);
 
ColBoxConfig Import(const std::filesystem::path& path);
 
ColBoxConfig Import(Reader& f);

[[nodiscard]] Buffer Export(const ColBoxConfig& colbox_config);
 
void Export(const ColBoxConfig& colbox_config, const std::filesystem::path& path);
 
void Export(const ColBoxConfig& colbox_config, Writer& f);
namespace raw {

constexpr u32 kMagicBytes = 0xFF'FF'00'01;
 
NNL_PACK(struct RHeader {
  u32 magic_bytes = kMagicBytes;
  u32 offset_colbox_enviroment = 0;  // 0x4
  u32 offset_colbox_entities = 0;    // 0x8
  u32 offset_colbox_dmg = 0;         // 0xC
  u32 offset_colbox_unknown = 0;     // 0x10 not used; no refernces in the code
  u32 offset_colbox_attack = 0;      // 0x14 RHitboxHeader
 
  u32 offset_unknown = 0;         // 0x18
  u32 offset_reserved_0 = 0;      // 0x1C unused
  u32 offset_reserved_1 = 0;      // 0x20
  u32 offset_reserved_2 = 0;      // 0x24
  u32 offset_reserved_3 = 0;      // 0x28
  u16 num_colbox_attack = 0;      // 0x2C
  u16 num_unknown = 0;            // 0x2E always 0
  u16 num_colbox_enviroment = 0;  // 0x30
  u16 num_colbox_entities = 0;    // 0x32
  u16 num_colbox_dmg = 0;         // 0x34
  u16 num_colbox_unknown = 0;     // 0x36 equals to 1 in NSLAR, not used
  u16 num_reserved_0 = 0;
  u16 num_reserved_1 = 0;
  u16 num_reserved_2 = 0;
  u16 num_reserved_3 = 0;
});
 
static_assert(sizeof(RHeader) == 0x40);
 
NNL_PACK(struct RCollisionBox14 {
  u16 bone_target = 0;          // 0x0
  u16 unknown2 = 0;             // 0x2
  Vec3<f32> translation{0.0f};  // 0x4
 
  f32 size = 0.0f;  // 0x10
});
 
static_assert(sizeof(RCollisionBox14) == 0x14);
 
NNL_PACK(struct RCollisionBox18 {
  u16 bone_target = 0;          // 0x0
  u16 unknown2 = 0;             // 0x2
  Vec3<f32> translation{0.0f};  // 0x4
  f32 size = 0.0f;              // 0x10
  f32 unknown14 = 0.0f;         // 0x14
});
 
static_assert(sizeof(RCollisionBox18) == 0x18);
 
NNL_PACK(struct RHitboxHeader {
  u32 offset_hitboxes = 0;  // 0x0
  u16 num_hitboxes = 0;     // 0x4
  u16 action_id = 0;        // 0x6 The upper 2 bits - action category, the rest (0x3FFF)
                            // - action index.
});
 
static_assert(sizeof(RHitboxHeader) == 0x8);
 
NNL_PACK(struct RHitbox {
  u32 offset_colboxes = 0;  // 0x0
  u16 num_colboxes = 0;     // 0x4 RColBox20
  u16 dmg_start = 0;        // 0x6
  u16 dmg_end = 0;          // 0x8
  u16 effect_id = 0;        // 0xA
  u8 unknownC = 0;          // 0xC
  u8 unknownD = 0;          // 0xD
  u16 unknownE = 0;         // 0xE
});
 
static_assert(sizeof(RHitbox) == 0x10);
 
NNL_PACK(struct RCollisionBox20 {
  u16 bone_target = 0;            // 0x0
  u16 distance_attack = 0;        // 0x2
  Vec3<f32> translation{0.0f};    // 0x4
  Vec3<f32> translation_2{0.0f};  // 0x10
 
  f32 size = 0;  // 0x1C
});
 
static_assert(sizeof(RCollisionBox20) == 0x20);
 
struct RCollisionBoxConfig {
  RHeader header;
  std::vector<RCollisionBox14> col_enviroment;
  std::vector<RCollisionBox14> colbox_unknown;
  // some unknown structures may be here (see 0x2E in RHeader)
  std::vector<RCollisionBox18> colbox_entities;
  std::vector<RCollisionBox14> colbox_damage;
  std::vector<RHitboxHeader> colbox_attack;
 
  // Maps of offsets (used in the structures above) to their data:
  std::map<u32, std::vector<RHitbox>> hitboxes;                 // see RHitboxHeader
  std::map<u32, std::vector<RCollisionBox20>> hitbox_colboxes;  // see RHitbox
};
 
RCollisionBoxConfig Parse(Reader& f);
 
ColBoxConfig Convert(const RCollisionBoxConfig& rhitbox_config);
}  // namespace raw
}  // namespace colbox

}  // namespace nnl