collision.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "NNL/common/enum_flag.hpp"
#include "NNL/common/fixed_type.hpp"
#include "NNL/common/io.hpp"
#include "NNL/simple_asset/smodel.hpp"
#include "NNL/utility/array3d.hpp"
namespace nnl {
namespace collision {

enum class NNL_FLAG_ENUM SurfaceFeatures : u16 {
  kNone = 0,              
  kDirt = 0b0000'0001,    
  kDirt2 = 0b0000'0010,   
  kSand = 0b0000'0011,    
  kStone = 0b0000'0100,   
  kGrass = 0b0000'0101,   
  kWater = 0b0000'0110,   
  kWood = 0b0000'0111,    
  kStone2 = 0b0000'1000,  
  kMetal = 0b0000'1001,   
  // flags
  kShadow = 0b0001'0000,              
  kPassThrowables = 0b010'0000'0000,  
  kPassCamera = 0b100'0000'0000       
};
 
NNL_DEFINE_ENUM_OPERATORS(SurfaceFeatures)
enum class NNL_FLAG_ENUM PushFeatures : u16 {
  kNone = 0,           
  kPushBack = 0b01,    
  kPushIfStuck = 0b10  
};
 
NNL_DEFINE_ENUM_OPERATORS(PushFeatures)
struct Triangle {
  std::array<u16, 3> indices_vertices{0};  
  u16 index_normal = 0;                    
  u16 index_vertex_min = 0;                
  u16 index_vertex_max = 0;                
  PushFeatures push_features{};            
  SurfaceFeatures surface_features{};      
};

struct Edge {
  std::array<u16, 2> indices_vertices{0};  
  u16 index_vertex_min = 0;                
  u16 index_vertex_max = 0;                
  u16 index_normal = 0;                    
  SurfaceFeatures surface_features{};
};

struct CollisionTest {
  std::vector<u16> triangle_indices;       
  std::vector<u16> triangle_wall_indices;  
  std::vector<u16> edge_wall_indices;      
};

struct Collision {
  u16 shift_value = 5;                         
  glm::vec3 origin_point{0.0f};                
  std::vector<glm::vec3> vertices;             
  std::vector<glm::vec3> normals;              
  std::vector<Triangle> triangles;             
  std::vector<Edge> edges;                     
  utl::Array3D<CollisionTest> coordinate_map;  
};

SModel Convert(const Collision& collision);
struct ConvertParam {
  PushFeatures push_features{};
  SurfaceFeatures surface_features{};
};
 
Collision Convert(SModel&& smodel, const ConvertParam& mesh_params = {}, bool auto_wall = true, u32 shift = 5);
Collision Convert(SModel&& smodel, const std::vector<ConvertParam>& mesh_params, bool auto_wall = true, u32 shift = 5);

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

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

[[nodiscard]] Buffer Export(const Collision& collision);
 
void Export(const Collision& collision, const std::filesystem::path& path);
 
void Export(const Collision& collision, Writer& f);

std::vector<ConvertParam> GenerateConvertParam(const Collision& collision);
 
namespace raw {
 
NNL_PACK(struct RHeader {
  Vec4<f32> origin_point{0, 0, 0, 1.0f};  // 0x0
  Vec3<u32> bbox_dimension{0};            // 0x10 width, height, depth shifted by shift_value
  u32 offset_coordinate_map = 0;          // 0x1C
  u32 offset_vertex_table = 0;            // 0x20
  u32 offset_normal_table = 0;            // 0x24
  u32 offset_triangles = 0;               // 0x28
  u32 offset_edges = 0;                   // 0x2C
  u32 offset_collision_tests = 0;         // 0x30
  u32 file_size = 0;                      // 0x34
  u32 unknown = 0;                        // 0x38 always 0; offset to
                                          // unused indices_triangles_edges?
  u16 shift_value = 0;                    // 0x3C
  u16 num_triangles = 0;                  // 0x3E 0 in NUC2
});
 
static_assert(sizeof(RHeader) == 0x40);
 
NNL_PACK(struct RTriangle {
  u32 calculation = 0;       // 0x0
  u16 index_vertex_0 = 0;    // 0x4
  u16 index_vertex_1 = 0;    // 0x6
  u16 index_vertex_2 = 0;    // 0x8
  u16 index_normal = 0;      // 0xA
  u16 index_vertex_min = 0;  // 0xC
  u16 index_vertex_max = 0;  // 0xE
  u16 push_features = 0;     // 0x10
  u16 surface_features = 0;  // 0x12
});
 
static_assert(sizeof(RTriangle) == 0x14);  // In NUC2 the size is 0x18(?)
 
NNL_PACK(struct REdge {
  u32 calculation = 0;       // 0x0
  u16 index_vertex_0 = 0;    // 0x4
  u16 index_vertex_1 = 0;    // 0x6
  u16 index_vertex_min = 0;  // 0x8 //MIN point line
  u16 index_vertex_max = 0;  // 0xA //max point line
  u16 index_normal = 0;      // 0xC
  u16 mask = 0;              // 0xE
});
 
static_assert(sizeof(REdge) == 0x10);
 
NNL_PACK(struct RCollisionTest {
  u32 offset_triangle_indices = 0;       // 0x0
  u32 offset_triangle_wall_indices = 0;  // 0x4
  u32 offset_edge_indices = 0;           // 0x8
  u16 num_triangle_indices = 0;          // 0xC
  u16 num_triangle_wall_indices = 0;     // 0xE
  u16 num_edge_indices = 0;              // 0x10
  u16 padding = 0;                       // 0x12
});
 
static_assert(sizeof(RCollisionTest) == 0x14);
 
struct RCollision {
  RHeader header;
  std::vector<Vec4<f32>> vertices;
  std::vector<Vec4<f32>> normals;
  std::vector<RTriangle> triangles;
  std::vector<REdge> edges;
  std::vector<RCollisionTest> collision_tests;
  std::vector<u16> indices_triangles_edges;  // indices to geometric shapes for collision tests
  std::vector<u16> coordinate_map;           // array[z][y][x]
};
 
RCollision Parse(Reader& f);
 
Collision Convert(const RCollision& rcollision);
}  // namespace raw
 
}  // namespace collision

}  // namespace nnl