vertexde.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "NNL/common/contract.hpp"
#include "NNL/common/fixed_type.hpp"
#include "NNL/common/io.hpp"
#include "NNL/simple_asset/smodel.hpp"
namespace nnl {
namespace vertexde {
namespace fmt_code {
constexpr u32 k0 = 0;  
 
constexpr u32 k8 = 1;   
constexpr u32 k16 = 2;  
constexpr u32 k32 = 3;  
 
constexpr u32 k565 = 4;   
constexpr u32 k5551 = 5;  
constexpr u32 k4444 = 6;  
constexpr u32 k8888 = 7;  
}  // namespace fmt_code
namespace fmt_shift {
constexpr u32 kUV = 0;
 
constexpr u32 kColor = 2;
 
constexpr u32 kNormal = 5;
 
constexpr u32 kPosition = 7;
 
constexpr u32 kWeight = 9;
 
constexpr u32 kIndex = 11;
 
constexpr u32 kWeightNum = 14;
 
constexpr u32 kMorphNum = 18;
 
constexpr u32 kThrough = 23;
}  // namespace fmt_shift
namespace fmt_mask {
constexpr u32 kUV = 0b0'00'000'0'000'0'00'00'00'00'000'11;
 
constexpr u32 kColor = 0b0'00'000'0'000'0'00'00'00'00'111'00;
 
constexpr u32 kNormal = 0b0'00'000'0'000'0'00'00'00'11'000'00;
 
constexpr u32 kPosition = 0b0'00'000'0'000'0'00'00'11'00'000'00;
 
constexpr u32 kWeight = 0b0'00'000'0'000'0'00'11'00'00'000'00;
 
constexpr u32 kIndex = 0b0'00'000'0'000'0'11'00'00'00'000'00;
 
constexpr u32 kWeightNum = 0b0'00'000'0'111'0'00'00'00'00'000'00;
 
constexpr u32 kMorphNum = 0b0'00'111'0'000'0'00'00'00'00'000'00;
 
constexpr u32 kThrough = 0b1'00'000'0'000'0'00'00'00'00'000'00;
}  // namespace fmt_mask


namespace fmt {
constexpr u32 kUV8 = fmt_code::k8 << fmt_shift::kUV;
constexpr u32 kUV16 = fmt_code::k16 << fmt_shift::kUV;
constexpr u32 kUV32 = fmt_code::k32 << fmt_shift::kUV;
constexpr u32 kColor565 = fmt_code::k565 << fmt_shift::kColor;
constexpr u32 kColor5551 = fmt_code::k5551 << fmt_shift::kColor;
constexpr u32 kColor4444 = fmt_code::k4444 << fmt_shift::kColor;
constexpr u32 kColor8888 = fmt_code::k8888 << fmt_shift::kColor;
constexpr u32 kNormal8 = fmt_code::k8 << fmt_shift::kNormal;
constexpr u32 kNormal16 = fmt_code::k16 << fmt_shift::kNormal;
constexpr u32 kNormal32 = fmt_code::k32 << fmt_shift::kNormal;
constexpr u32 kPosition8 = fmt_code::k8 << fmt_shift::kPosition;
constexpr u32 kPosition16 = fmt_code::k16 << fmt_shift::kPosition;
constexpr u32 kPosition32 = fmt_code::k32 << fmt_shift::kPosition;
constexpr u32 kWeight8 = fmt_code::k8 << fmt_shift::kWeight;
constexpr u32 kWeight16 = fmt_code::k16 << fmt_shift::kWeight;
constexpr u32 kWeight32 = fmt_code::k32 << fmt_shift::kWeight;
constexpr u32 kIndex8 = fmt_code::k8 << fmt_shift::kIndex;
constexpr u32 kIndex16 = fmt_code::k16 << fmt_shift::kIndex;
 
// kIndex32: technically exists but unused

constexpr u32 kThrough = 1 << fmt_shift::kThrough;

constexpr inline u32 kWeightNum(u32 weight_num) {
  NNL_EXPECTS_DBG(weight_num > 0 && weight_num <= 8);
  return ((weight_num - 1) << fmt_shift::kWeightNum);
}

constexpr inline u32 kMorphNum(u32 morph_num) {
  NNL_EXPECTS_DBG(morph_num > 0 && morph_num <= 8);
  return ((morph_num - 1) << fmt_shift::kMorphNum);
}
}  // namespace fmt

std::vector<SVertex> Decode(BufferView vertex_buffer, u32 vertex_format, std::array<u16, 8> bone_indices = {0});
Buffer Encode(const std::vector<SVertex>& vertices, u32 vertex_format, std::array<u16, 8> bone_indices = {0});  // Main


constexpr std::array<u32, 8> format_sizes{0, 1, 2, 4, 2, 2, 2, 4};
 
// through
inline u32 GetThrough(u32 vertex_format) { return (vertex_format & fmt_mask::kThrough) >> fmt_shift::kThrough; }
 
// WEIGHTS
inline u32 GetWeightFormat(u32 vertex_format) { return (vertex_format & fmt_mask::kWeight) >> fmt_shift::kWeight; }
inline u32 GetWeightSize(u32 vertex_format) { return format_sizes.at(GetWeightFormat(vertex_format)); }
inline u32 GetWeightNum(u32 vertex_format) {
  return GetWeightFormat(vertex_format) != 0 ? ((vertex_format & fmt_mask::kWeightNum) >> fmt_shift::kWeightNum) + 1
                                             : 0;
}
 
// UV
inline u32 GetUVFormat(u32 vertex_format) { return (vertex_format & fmt_mask::kUV) >> fmt_shift::kUV; }
inline u32 GetUVSize(u32 vertex_format) { return format_sizes.at(GetUVFormat(vertex_format)); }
inline u32 GetUVNum(u32 vertex_format) { return GetUVFormat(vertex_format) != 0 ? 2 : 0; }
 
// COLOR
inline u32 GetColorFormat(u32 vertex_format) { return (vertex_format & fmt_mask::kColor) >> fmt_shift::kColor; }
inline u32 GetColorSize(u32 vertex_format) { return format_sizes.at(GetColorFormat(vertex_format)); }
inline u32 GetColorNum(u32 vertex_format) { return GetColorFormat(vertex_format) != 0 ? 1 : 0; }
 
// NORMAL
inline u32 GetNormalFormat(u32 vertex_format) { return (vertex_format & fmt_mask::kNormal) >> fmt_shift::kNormal; }
inline u32 GetNormalSize(u32 vertex_format) { return format_sizes.at(GetNormalFormat(vertex_format)); }
inline u32 GetNormalNum(u32 vertex_format) { return GetNormalFormat(vertex_format) != 0 ? 3 : 0; }
 
// POSITION
inline u32 GetPositionFormat(u32 vertex_format) {
  return (vertex_format & fmt_mask::kPosition) >> fmt_shift::kPosition;
}

inline u32 GetPositionSize(u32 vertex_format) { return format_sizes.at(GetPositionFormat(vertex_format)); }
inline u32 GetPositionNum(u32 vertex_format) { return GetPositionFormat(vertex_format) != 0 ? 3 : 0; }
 
// MORPHING
inline u32 GetMorphNum(u32 vertex_format) {
  return ((vertex_format & fmt_mask::kMorphNum) >> fmt_shift::kMorphNum) + 1;
}
 
// INDEX
inline u32 GetIndexFormat(u32 vertex_format) { return (vertex_format & fmt_mask::kIndex) >> fmt_shift::kIndex; }
inline u32 GetIndexSize(u32 vertex_format) { return format_sizes.at(GetIndexFormat(vertex_format)); }
 
// HAS
inline bool HasWeights(u32 vertex_format) { return static_cast<bool>(GetWeightFormat(vertex_format)); }
inline bool HasUV(u32 vertex_format) { return static_cast<bool>(GetUVFormat(vertex_format)); }
inline bool HasColor(u32 vertex_format) { return static_cast<bool>(GetColorFormat(vertex_format)); }
inline bool HasNormal(u32 vertex_format) { return static_cast<bool>(GetNormalFormat(vertex_format)); }
inline bool HasPosition(u32 vertex_format) { return static_cast<bool>(GetPositionFormat(vertex_format)); }
 
// IS
inline bool IsIndexed(u32 vertex_format) { return static_cast<bool>(GetIndexFormat(vertex_format)); }

inline bool IsThrough(u32 vertex_format) { return static_cast<bool>(GetThrough(vertex_format)); }
 
// INDICES
inline bool Is8Indices(u32 vertex_format) {
  return (vertexde::GetIndexFormat(vertex_format) == vertexde::fmt_code::k8);
}

inline bool Is16Indices(u32 vertex_format) {
  return (vertexde::GetIndexFormat(vertex_format) == vertexde::fmt_code::k16);
}
 
// WEIGHTS
inline bool Is8Weights(u32 vertex_format) {
  return (vertexde::GetWeightFormat(vertex_format) == vertexde::fmt_code::k8);
}

inline bool Is16Weights(u32 vertex_format) {
  return (vertexde::GetWeightFormat(vertex_format) == vertexde::fmt_code::k16);
}

inline bool Is32Weights(u32 vertex_format) {
  return (vertexde::GetWeightFormat(vertex_format) == vertexde::fmt_code::k32);
}

inline bool IsFixedWeights(u32 vertex_format) { return (Is8Weights(vertex_format) || Is16Weights(vertex_format)); }
 
// UV
inline bool Is8UV(u32 vertex_format) { return (vertexde::GetUVFormat(vertex_format) == vertexde::fmt_code::k8); }
inline bool Is16UV(u32 vertex_format) { return (vertexde::GetUVFormat(vertex_format) == vertexde::fmt_code::k16); }
inline bool Is32UV(u32 vertex_format) { return (vertexde::GetUVFormat(vertex_format) == vertexde::fmt_code::k32); }
inline bool IsFixedUV(u32 vertex_format) { return (Is8UV(vertex_format) || Is16UV(vertex_format)); }
 
// COLOR
inline bool Is565Color(u32 vertex_format) {
  return (vertexde::GetColorFormat(vertex_format) == vertexde::fmt_code::k565);
}

inline bool Is5551Color(u32 vertex_format) {
  return (vertexde::GetColorFormat(vertex_format) == vertexde::fmt_code::k5551);
}

inline bool Is4444Color(u32 vertex_format) {
  return (vertexde::GetColorFormat(vertex_format) == vertexde::fmt_code::k4444);
}

inline bool Is8888Color(u32 vertex_format) {
  return (vertexde::GetColorFormat(vertex_format) == vertexde::fmt_code::k8888);
}
 
// NORMAL

inline bool Is8Normal(u32 vertex_format) {
  return (vertexde::GetNormalFormat(vertex_format) == vertexde::fmt_code::k8);
}

inline bool Is16Normal(u32 vertex_format) {
  return (vertexde::GetNormalFormat(vertex_format) == vertexde::fmt_code::k16);
}

inline bool Is32Normal(u32 vertex_format) {
  return (vertexde::GetNormalFormat(vertex_format) == vertexde::fmt_code::k32);
}

inline bool IsFixedNormal(u32 vertex_format) { return (Is8Normal(vertex_format) || Is16Normal(vertex_format)); }
 
// POSITION
inline bool Is8Position(u32 vertex_format) {
  return (vertexde::GetPositionFormat(vertex_format) == vertexde::fmt_code::k8);
}

inline bool Is16Position(u32 vertex_format) {
  return (vertexde::GetPositionFormat(vertex_format) == vertexde::fmt_code::k16);
}

inline bool Is32Position(u32 vertex_format) {
  return (vertexde::GetPositionFormat(vertex_format) == vertexde::fmt_code::k32);
}

inline bool IsFixedPosition(u32 vertex_format) { return (Is8Position(vertex_format) || Is16Position(vertex_format)); }
std::string GetDescription(u32 vertex_format);
struct VertexLayout {
  u32 offset_weights = 0;
  u32 offset_uv = 0;
  u32 offset_color = 0;
  u32 offset_normal = 0;
  u32 offset_position = 0;
  u32 vertex_size = 0;
};

VertexLayout GetLayout(u32 vertex_format);
 
}  // namespace vertexde

}  // namespace nnl