shadow_collision.hpp

Go to the documentation of this file.

#pragma once
 
#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 shadow_collision {
struct Triangle {
  std::array<u16, 3> indices_vertices{0};  
  u16 shadow_features = 0;                 
};

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

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

SModel Convert(const Collision& collision);
Collision Convert(SModel&& smodel, bool auto_cull = true, u32 shift = 1);

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);
 
namespace raw {
NNL_PACK(struct RHeader {
  Vec4<f32> origin_point{0, 0, 0, 1.0f};  // 0x0
  Vec3<u32> bbox_dimension{0};            // width, height, depth, shifted by shift value
  u32 offset_coordinate_map = 0;          // 0x1C
  u32 offset_vertex_table = 0;            // 0x20
  u32 offset_triangles = 0;               // 0x24
  u32 offset_collision_tests = 0;
  u16 shift_value = 0;  //+5 is always added to it
  u16 unknown = 0;
});
 
static_assert(sizeof(RHeader) == 0x30);
 
NNL_PACK(struct RTriangle {
  u16 index_vertex_0 = 0;   // 0x0
  u16 index_vertex_1 = 0;   // 0x2
  u16 index_vertex_2 = 0;   // 0x4
  u16 shadow_features = 0;  // 0x6  unused in NSLAR, in NUC2 this can disable shadow (1) and possibly more
  u32 calculation = 0;      // 0x8
});
 
static_assert(sizeof(RTriangle) == 0xC);
 
NNL_PACK(struct RCollisionTest {
  u32 offset_triangle_indices = 0;  // 0x0
  u16 num_triangle_indices = 0;     // 0x4
  u16 padding = 0;                  // 0x6
});
 
static_assert(sizeof(RCollisionTest) == 0x8);
 
struct RCollision {
  RHeader header;
  std::vector<Vec4<f32>> vertices;
  std::vector<RTriangle> triangles;
  std::vector<RCollisionTest> collision_tests;
  std::vector<u16> indices_triangles;  // indices to faces to test
  std::vector<u16> coordinate_map;
};
 
RCollision Parse(Reader& f);
 
Collision Convert(const RCollision& rcollision);
}  // namespace raw
 
}  // namespace shadow_collision

}  // namespace nnl