init

shared/Scene/VtxData.h

@@ -0,0 +1,111 @@
+#pragma once
+
+#include <stdint.h>
+
+#include <glm/glm.hpp>
+
+#include "shared/Utils.h"
+#include "shared/UtilsMath.h"
+
+constexpr const uint32_t kMaxLODs = 7;
+
+// All offsets are relative to the beginning of the data block (excluding headers with a Mesh list)
+struct Mesh final {
+  // Number of LODs in this mesh. Strictly less than MAX_LODS, last LOD offset is used as a marker only
+  uint32_t lodCount = 1;
+
+  // The total count of all previous vertices in this mesh file
+  uint32_t indexOffset = 0;
+
+  uint32_t vertexOffset = 0;
+
+  // Vertex count (for all LODs)
+  uint32_t vertexCount = 0;
+
+  // Offsets to LOD indices data. The last offset is used as a marker to calculate the size
+  uint32_t lodOffset[kMaxLODs + 1] = { 0 };
+
+  uint32_t materialID = 0;
+
+  inline uint32_t getLODIndicesCount(uint32_t lod) const { return lod < lodCount ? lodOffset[lod + 1] - lodOffset[lod] : 0; }
+
+  // Any additional information, such as mesh name, can be added here...
+};
+
+struct MeshFileHeader {
+  // Unique 64-bit value to check integrity of the file
+  uint32_t magicValue = 0x12345678;
+
+  // Number of mesh descriptors following this header
+  uint32_t meshCount = 0;
+
+  // How much space index data takes in bytes
+  uint32_t indexDataSize = 0;
+
+  // How much space vertex data takes in bytes
+  uint32_t vertexDataSize = 0;
+
+  // According to your needs, you may add additional metadata fields...
+};
+
+enum MaterialFlags {
+  sMaterialFlags_CastShadow    = 0x1,
+  sMaterialFlags_ReceiveShadow = 0x2,
+  sMaterialFlags_Transparent   = 0x4,
+};
+
+struct Material {
+  vec4 emissiveFactor      = vec4(0.0f, 0.0f, 0.0f, 0.0f);
+  vec4 baseColorFactor     = vec4(1.0f, 1.0f, 1.0f, 1.0f);
+  float roughness          = 1.0f;
+  float transparencyFactor = 1.0f;
+  float alphaTest          = 0.0f;
+  float metallicFactor     = 0.0f;
+  // index into MeshData::textureFiles
+  int baseColorTexture = -1;
+  int emissiveTexture  = -1;
+  int normalTexture    = -1;
+  int opacityTexture   = -1;
+  uint32_t flags       = sMaterialFlags_CastShadow | sMaterialFlags_ReceiveShadow;
+};
+
+struct MeshData {
+  lvk::VertexInput streams = {};
+  std::vector<uint32_t> indexData;
+  std::vector<uint8_t> vertexData;
+  std::vector<Mesh> meshes;
+  std::vector<BoundingBox> boxes;
+  std::vector<Material> materials;
+  std::vector<std::string> textureFiles;
+  MeshFileHeader getMeshFileHeader() const
+  {
+    return {
+      .meshCount      = (uint32_t)meshes.size(),
+      .indexDataSize  = (uint32_t)(indexData.size() * sizeof(uint32_t)),
+      .vertexDataSize = (uint32_t)vertexData.size(),
+    };
+  }
+};
+
+static_assert(sizeof(BoundingBox) == sizeof(float) * 6);
+
+bool isMeshDataValid(const char* fileName);
+bool isMeshMaterialsValid(const char* fileName);
+bool isMeshHierarchyValid(const char* fileName);
+MeshFileHeader loadMeshData(const char* meshFile, MeshData& out);
+void loadMeshDataMaterials(const char* meshFile, MeshData& out);
+void saveMeshData(const char* fileName, const MeshData& m);
+void saveMeshDataMaterials(const char* fileName, const MeshData& m);
+
+void recalculateBoundingBoxes(MeshData& m);
+
+// combine a list of meshes to a single mesh container
+MeshFileHeader mergeMeshData(MeshData& m, const std::vector<MeshData*> md);
+
+// use to write values into MeshData::vertexData
+template <typename T> inline void put(std::vector<uint8_t>& v, const T& value)
+{
+  const size_t pos = v.size();
+  v.resize(v.size() + sizeof(value));
+  memcpy(v.data() + pos, &value, sizeof(value));
+}