Trying compression

CMakeLists.txt

@@ -13,6 +13,7 @@ set(BUILD_SHARED_LIBS OFF)
 set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
 
 set(VCPKG_INSTALL_OPTIONS "--allow-unsupported")
+set(VCPKG_BUILD_TYPE release)
 
 set(ENGINE_ROOT ${CMAKE_CURRENT_SOURCE_DIR}/src/Engine)
 set(EXTERNAL_ROOT ${CMAKE_CURRENT_SOURCE_DIR}/external)

res/shaders/lib/StaticMeshVertexData.slang

@@ -4,28 +4,61 @@ import MaterialParameter;
 
 struct StaticMeshVertexData
 {
+    float uint16ToFloat(uint16_t value)
+    {
+        return value / 65535.0f;
+    }
+    float3 xAxis( float4 qQuat )
+    {
+        float fTy  = 2.0 * qQuat.y;
+        float fTz  = 2.0 * qQuat.z;
+        float fTwy = fTy * qQuat.w;
+        float fTwz = fTz * qQuat.w;
+        float fTxy = fTy * qQuat.x;
+        float fTxz = fTz * qQuat.x;
+        float fTyy = fTy * qQuat.y;
+        float fTzz = fTz * qQuat.z;
+    
+        return float3( 1.0-(fTyy+fTzz), fTxy+fTwz, fTxz-fTwy );
+    }
+    
+    float3 yAxis( float4 qQuat )
+    {
+        float fTx  = 2.0 * qQuat.x;
+        float fTy  = 2.0 * qQuat.y;
+        float fTz  = 2.0 * qQuat.z;
+        float fTwx = fTx * qQuat.w;
+        float fTwz = fTz * qQuat.w;
+        float fTxx = fTx * qQuat.x;
+        float fTxy = fTy * qQuat.x;
+        float fTyz = fTz * qQuat.y;
+        float fTzz = fTz * qQuat.z;
+    
+        return float3( fTxy-fTwz, 1.0-(fTxx+fTzz), fTyz+fTwx );
+    }
+
 	VertexAttributes getAttributes(uint index)
 	{
 		VertexAttributes attributes;
-		attributes.position_MS = positions[index].xyz;
+		attributes.position_MS = float3(positions[index * 3 + 0], positions[index * 3 + 1], positions[index * 3 + 2]);
 #ifndef POS_ONLY
-		attributes.normal_MS = normals[index].xyz;
+        float4 qtangent = normalize(qtangents[index]);
-		attributes.tangent_MS = tangents[index].xyz;
+        attributes.normal_MS = xAxis(qtangent);
-		attributes.biTangent_MS = biTangents[index].xyz;
+        attributes.tangent_MS = yAxis(qtangent);
+        float biNormalReflection = sign(qtangents[index].w);
+        attributes.biTangent_MS = cross(attributes.normal_MS, attributes.tangent_MS) * biNormalReflection;
 		for(uint i = 0; i < MAX_TEXCOORDS; ++i)
 		{
-			attributes.texCoords[i] = texCoords[i][index];
+			attributes.texCoords[i] = float2(uint16ToFloat(texCoords[i][index * 2 + 0]), uint16ToFloat(texCoords[i][index * 2 + 1]));
 		}
-		attributes.vertexColor = color[index].xyz;
+		attributes.vertexColor = float3(color[index * 3 + 0], color[index * 3 + 1] , color[index * 3 + 2]);
 #endif
 		return attributes;
 	}
-	StructuredBuffer<float4> positions;
+	StructuredBuffer<float> positions;
-	StructuredBuffer<float4> normals;
+	StructuredBuffer<float4> qtangents;
-	StructuredBuffer<float4> tangents;
+	StructuredBuffer<uint16_t> color;
-	StructuredBuffer<float4> biTangents;
+	StructuredBuffer<uint16_t> texCoords[MAX_TEXCOORDS];
-	StructuredBuffer<float4> color;
-	StructuredBuffer<float2> texCoords[MAX_TEXCOORDS];
 };
 layout(set=1)
 ParameterBlock<StaticMeshVertexData> pVertexData;

src/Editor/Asset/MeshLoader.cpp

@@ -477,37 +477,56 @@ void MeshLoader::loadGlobalMeshes(const aiScene* scene, const Array<PMaterialIns
         collider.boundingbox.adjust(Vector(mesh->mAABB.mMax.x, mesh->mAABB.mMax.y, mesh->mAABB.mMax.z));
         work.add([=, this, &globalMeshes]() {
             // assume static mesh for now
-            Array<Vector4> positions(mesh->mNumVertices);
+            Array<Vector> positions(mesh->mNumVertices);
-            StaticArray<Array<Vector2>, MAX_TEXCOORDS> texCoords;
+            StaticArray<Array<U16Vector2>, MAX_TEXCOORDS> texCoords;
             for (size_t i = 0; i < MAX_TEXCOORDS; ++i) {
                 texCoords[i].resize(mesh->mNumVertices);
             }
-            Array<Vector4> normals(mesh->mNumVertices);
+            Array<Quaternion> normals(mesh->mNumVertices);
-            Array<Vector4> tangents(mesh->mNumVertices);
+            Array<U16Vector> colors(mesh->mNumVertices);
-            Array<Vector4> biTangents(mesh->mNumVertices);
-            Array<Vector4> colors(mesh->mNumVertices);
 
             for (int32 i = 0; i < mesh->mNumVertices; ++i) {
-                positions[i] = Vector4(mesh->mVertices[i].x, mesh->mVertices[i].y, mesh->mVertices[i].z, 1.0f);
+                positions[i] = Vector(mesh->mVertices[i].x, mesh->mVertices[i].y, mesh->mVertices[i].z);
                 for (size_t j = 0; j < MAX_TEXCOORDS; ++j) {
                     if (mesh->HasTextureCoords(j)) {
-                        texCoords[j][i] = Vector2(mesh->mTextureCoords[j][i].x, mesh->mTextureCoords[j][i].y);
+                        texCoords[j][i] = U16Vector2(mesh->mTextureCoords[j][i].x * 65535, mesh->mTextureCoords[j][i].y * 65535);
                     } else {
-                        texCoords[j][i] = Vector2(0, 0);
+                        texCoords[j][i] = U16Vector2(0, 0);
                     }
                 }
-                normals[i] = Vector4(mesh->mNormals[i].x, mesh->mNormals[i].y, mesh->mNormals[i].z, 1.0f);
+                Vector normal = Vector(mesh->mNormals[i].x, mesh->mNormals[i].y, mesh->mNormals[i].z);
+                Vector tangent = Vector(1, 0, 0);
+                Vector biTangent = Vector(0, 0, 1);
                 if (mesh->HasTangentsAndBitangents()) {
-                    tangents[i] = Vector4(mesh->mTangents[i].x, mesh->mTangents[i].y, mesh->mTangents[i].z, 1.0f);
+                    tangent = Vector(mesh->mTangents[i].x, mesh->mTangents[i].y, mesh->mTangents[i].z);
-                    biTangents[i] = Vector4(mesh->mBitangents[i].x, mesh->mBitangents[i].y, mesh->mBitangents[i].z, 1.0f);
+                    biTangent = Vector(mesh->mBitangents[i].x, mesh->mBitangents[i].y, mesh->mBitangents[i].z);
-                } else {
-                    tangents[i] = Vector4(0, 0, 1, 1);
-                    biTangents[i] = Vector4(1, 0, 0, 1);
                 }
+                Matrix3 tbn = {normal, biTangent, tangent};
+
+                Quaternion qTangent(tbn);
+                qTangent = glm::normalize(qTangent);
+
+                if (qTangent.w < 0)
+                    qTangent = -qTangent;
+
+                const float bias = 1.0f / 32767.0f;
+
+                if (qTangent.w < bias) {
+                    double normFactor = sqrt(1 - bias * bias);
+                    qTangent.w = bias;
+                    qTangent.x *= normFactor;
+                    qTangent.y *= normFactor;
+                    qTangent.z *= normFactor;
+                }
+                Vector naturalBinormal = glm::cross(tangent, normal);
+                if (glm::dot(naturalBinormal, biTangent) <= 0)
+                    qTangent = -qTangent;
+                normals[i] = qTangent;
+
                 if (mesh->HasVertexColors(0)) {
-                    colors[i] = Vector4(mesh->mColors[0][i].r, mesh->mColors[0][i].g, mesh->mColors[0][i].b, 1.0f);
+                    colors[i] = U16Vector(mesh->mColors[0][i].r * 65535, mesh->mColors[0][i].g * 65535, mesh->mColors[0][i].b * 65535);
                 } else {
-                    colors[i] = Vector4(1, 1, 1, 1);
+                    colors[i] = U16Vector(1, 1, 1);
                 }
             }
             vertexData->loadPositions(offset, positions);
@@ -516,8 +535,6 @@ void MeshLoader::loadGlobalMeshes(const aiScene* scene, const Array<PMaterialIns
                 vertexData->loadTexCoords(offset, i, texCoords[i]);
             }
             vertexData->loadNormals(offset, normals);
-            vertexData->loadTangents(offset, tangents);
-            vertexData->loadBiTangents(offset, biTangents);
             vertexData->loadColors(offset, colors);
 
             Array<uint32> indices(mesh->mNumFaces * 3);
@@ -566,7 +583,7 @@ void MeshLoader::import(MeshImportArgs args, PMeshAsset meshAsset) {
     Assimp::Importer importer;
     importer.ReadFile(args.filePath.string().c_str(),
                       (uint32)(aiProcess_FlipUVs | aiProcess_Triangulate | aiProcess_SortByPType | aiProcess_GenBoundingBoxes |
-                               aiProcess_GenSmoothNormals | aiProcess_GenUVCoords | aiProcess_FindDegenerates));
+                               aiProcess_GenUVCoords | aiProcess_FindDegenerates));
     const aiScene* scene = importer.ApplyPostProcessing(aiProcess_CalcTangentSpace);
     std::cout << importer.GetErrorString() << std::endl;
 

src/Editor/Asset/TextureLoader.cpp

@@ -111,12 +111,12 @@ void TextureLoader::import(TextureImportArgs args, PTextureAsset textureAsset) {
     ktxBasisParams basisParams = {
         .structSize = sizeof(ktxBasisParams),
         .uastc = true,
-        .threadCount = 14,
+        .threadCount = 1,
-        .uastcFlags = KTX_PACK_UASTC_LEVEL_SLOWER,
+        .uastcFlags = KTX_PACK_UASTC_LEVEL_FASTER,
         .uastcRDO = true,
     };
-    KTX_ASSERT(ktxTexture2_CompressBasisEx(kTexture, &basisParams));
+    //KTX_ASSERT(ktxTexture2_CompressBasisEx(kTexture, &basisParams));
-    KTX_ASSERT(ktxTexture2_DeflateZstd(kTexture, 20));
+    //KTX_ASSERT(ktxTexture2_DeflateZstd(kTexture, 20));
 
     char writer[100];
     snprintf(writer, sizeof(writer), "%s version %s", "SeeleEngine", "0.0.1");

src/Editor/main.cpp

@@ -65,10 +65,10 @@ int main() {
             .filePath = sourcePath / "import/textures/skyboxsun5deg_tn.jpg",
             .type = TextureImportType::TEXTURE_CUBEMAP,
         });
-        AssetImporter::importMesh(MeshImportArgs{
+        //AssetImporter::importMesh(MeshImportArgs{
-            .filePath = sourcePath / "import/models/ship.fbx",
+        //    .filePath = sourcePath / "import/models/ship.fbx",
-            .importPath = "ship",
+        //    .importPath = "ship",
-        });
+        //});
         AssetImporter::importTexture(TextureImportArgs{
             .filePath = sourcePath / "import/textures/azeroth.png",
         });
@@ -79,7 +79,7 @@ int main() {
         //   .filePath = sourcePath / "import/models/after-the-rain-vr-sound/source/Whitechapel.glb",
         //   .importPath = "Whitechapel",
         //});
-        // AssetImporter::importMesh(MeshImportArgs{
+        // AssetImporter::importMesh(MeshImportArgs{521
         //     .filePath = sourcePath / "import/models/city-suburbs/source/city-suburbs.obj",
         //     .importPath = "suburbs",
         // });
@@ -87,10 +87,10 @@ int main() {
         //     .filePath = sourcePath / "import/models/minecraft-medieval-city.fbx",
         //     .importPath = "minecraft",
         // });
-        // AssetImporter::importMesh(MeshImportArgs{
+        AssetImporter::importMesh(MeshImportArgs{
-        //     .filePath = sourcePath / "import/models/Volvo/Volvo.fbx",
+            .filePath = sourcePath / "import/models/Volvo/Volvo.fbx",
-        //     .importPath = "Volvo",
+            .importPath = "Volvo",
-        // });
+        });
         getThreadPool().waitIdle();
         vd->commitMeshes();
         WindowCreateInfo mainWindowInfo = {

src/Engine/Graphics/Initializer.h

@@ -91,7 +91,6 @@ struct IndexBufferCreateInfo {
 };
 struct UniformBufferCreateInfo {
     DataSource sourceData = DataSource();
-    uint8 dynamic = 0;
     std::string name = "Unnamed";
 };
 struct ShaderBufferCreateInfo {
@@ -99,7 +98,6 @@ struct ShaderBufferCreateInfo {
     uint64 numElements = 1;
     uint32 clearValue = 0;
     uint8 createCleared = 0;
-    uint8 dynamic = 0;
     uint8 vertexBuffer = 0;
     std::string name = "Unnamed";
 };

src/Engine/Graphics/Meshlet.cpp

@@ -166,7 +166,7 @@ void completeMeshlet(Array<Meshlet>& meshlets, Meshlet& current) {
     };
 }
 
-bool addTriangle(const Array<Vector4>& positions, Meshlet& current, Triangle& tri) {
+bool addTriangle(const Array<Vector>& positions, Meshlet& current, Triangle& tri) {
     int f1 = findIndex(current, tri.indices[0]);
     int f2 = findIndex(current, tri.indices[1]);
     int f3 = findIndex(current, tri.indices[2]);
@@ -184,11 +184,12 @@ bool addTriangle(const Array<Vector4>& positions, Meshlet& current, Triangle& tr
     return true;
 }
 
-void Meshlet::build(const Array<Vector4>& positions, const Array<uint32>& indices, Array<Meshlet>& meshlets) {
+void Meshlet::build(const Array<Vector>& positions, const Array<uint32>& indices, Array<Meshlet>& meshlets) {
     Meshlet current = {
         .numVertices = 0,
         .numPrimitives = 0,
     };
+    // TODO:
     // Array<uint32> optimizedIndices = indices;
     // tipsifyIndexBuffer(indices, positions.size(), 25, optimizedIndices);
     Array<Triangle> triangles(indices.size() / 3);

src/Engine/Graphics/Meshlet.h

@@ -2,7 +2,6 @@
 #include "Graphics/Enums.h"
 #include "Math/AABB.h"
 
-
 namespace Seele {
 struct Meshlet {
     AABB boundingBox;
@@ -10,6 +9,6 @@ struct Meshlet {
     uint8 primitiveLayout[Gfx::numPrimitivesPerMeshlet * 3]; // indices into the uniqueVertices array, only uint8 needed
     uint32 numVertices;
     uint32 numPrimitives;
-    static void build(const Array<Vector4>& positions, const Array<uint32>& indices, Array<Meshlet>& meshlets);
+    static void build(const Array<Vector>& positions, const Array<uint32>& indices, Array<Meshlet>& meshlets);
 };
 } // namespace Seele

src/Engine/Graphics/RenderPass/BasePass.cpp

@@ -250,7 +250,7 @@ void BasePass::render() {
     }
     
     // commands.add(waterRenderer->render(viewParamsSet));
-    commands.add(terrainRenderer->render(viewParamsSet));
+    // commands.add(terrainRenderer->render(viewParamsSet));
     
     // Skybox
     {
@@ -580,7 +580,6 @@ void BasePass::createRenderPass() {
                     .size = sizeof(SkyboxData),
                     .data = (uint8*)&skyboxData,
                 },
-            .dynamic = true,
         });
 
         pipelineLayout = graphics->createPipelineLayout("SkyboxLayout");

src/Engine/Graphics/RenderPass/DepthCullingPass.cpp

@@ -236,7 +236,6 @@ void DepthCullingPass::publishOutputs() {
                 .data = nullptr,
             },
         .numElements = bufferSize,
-        .dynamic = true,
         .name = "DepthMipBuffer",
     });
 

src/Engine/Graphics/RenderPass/LightCullingPass.cpp

@@ -90,7 +90,6 @@ void LightCullingPass::publishOutputs() {
                 .data = (uint8*)&dispatchParams,
                 .owner = Gfx::QueueType::COMPUTE,
             },
-        .dynamic = false,
         .name = "DispatchParams",
     });
     dispatchParamsBuffer->pipelineBarrier(Gfx::SE_ACCESS_TRANSFER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT,
@@ -186,7 +185,6 @@ void LightCullingPass::publishOutputs() {
                 .owner = Gfx::QueueType::COMPUTE,
             },
         .numElements = 1,
-        .dynamic = true,
         .name = "oLightIndexCounter",
     };
     oLightIndexCounter = graphics->createShaderBuffer(structInfo);
@@ -200,7 +198,6 @@ void LightCullingPass::publishOutputs() {
                 .data = nullptr,
                 .owner = Gfx::QueueType::COMPUTE,
             },
-        .dynamic = false,
         .name = "oLightIndexList",
     };
     oLightIndexList = graphics->createShaderBuffer(structInfo);
@@ -285,7 +282,6 @@ void LightCullingPass::setupFrustums() {
                 .data = (uint8*)&dispatchParams,
                 .owner = Gfx::QueueType::COMPUTE,
             },
-        .dynamic = false,
         .name = "FrustumDispatch",
     });
     frustumDispatchParamsBuffer->pipelineBarrier(Gfx::SE_ACCESS_TRANSFER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT,
@@ -298,7 +294,6 @@ void LightCullingPass::setupFrustums() {
                 .owner = Gfx::QueueType::COMPUTE,
             },
         .numElements = numThreads.x * numThreads.y * numThreads.z,
-        .dynamic = false,
         .name = "FrustumBuffer",
     });
     frustumBuffer->pipelineBarrier(Gfx::SE_ACCESS_TRANSFER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT, Gfx::SE_ACCESS_SHADER_WRITE_BIT,

src/Engine/Graphics/RenderPass/RenderPass.cpp

@@ -14,7 +14,6 @@ RenderPass::RenderPass(Gfx::PGraphics graphics, PScene scene) : graphics(graphic
                 .size = sizeof(ViewParameter),
                 .data = (uint8*)&viewParams,
             },
-        .dynamic = true,
         .name = "viewParamsBuffer",
     };
     viewParamsBuffer = graphics->createUniformBuffer(uniformInitializer);

src/Engine/Graphics/RenderPass/TerrainRenderer.cpp

@@ -30,7 +30,6 @@ TerrainRenderer::TerrainRenderer(Gfx::PGraphics graphics, PScene scene, Gfx::PDe
                 .data = (uint8*)payloads.data(),
             },
         .numElements = payloads.size(),
-        .dynamic = true,
         .name = "TilesBuffer",
     });
     tilesBuffer->pipelineBarrier(Gfx::SE_ACCESS_TRANSFER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT, Gfx::SE_ACCESS_SHADER_READ_BIT,

src/Engine/Graphics/RenderPass/TextPass.cpp

@@ -128,7 +128,6 @@ void TextPass::createRenderPass() {
                 .size = sizeof(Matrix4),
                 .data = nullptr,
             },
-        .dynamic = true,
     });
 
     glyphSampler = graphics->createSampler({

src/Engine/Graphics/RenderPass/UIPass.cpp

@@ -118,23 +118,23 @@ void UIPass::createRenderPass() {
     descriptorLayout->create();
 
     Matrix4 projectionMatrix = glm::ortho(0, 1, 1, 0);
-    UniformBufferCreateInfo info = {
+
+    Gfx::OUniformBuffer uniformBuffer = graphics->createUniformBuffer(UniformBufferCreateInfo{
         .sourceData =
             {
                 .size = sizeof(Matrix4),
                 .data = (uint8*)&projectionMatrix,
             },
-        .dynamic = false,
+    });
-    };
-    Gfx::OUniformBuffer uniformBuffer = graphics->createUniformBuffer(info);
     Gfx::OSampler backgroundSampler = graphics->createSampler({});
 
-    info = {
+    numTexturesBuffer = graphics->createUniformBuffer(UniformBufferCreateInfo{
-        .sourceData = {.size = sizeof(uint32), .data = nullptr},
+        .sourceData =
-        .dynamic = true,
+            {
-    };
+                .size = sizeof(uint32),
-
+                .data = nullptr,
-    numTexturesBuffer = graphics->createUniformBuffer(info);
+            },
+    });
 
     descriptorSet = descriptorLayout->allocateDescriptorSet();
     descriptorSet->updateBuffer(0, 0, uniformBuffer);

src/Engine/Graphics/RenderPass/VisibilityPass.cpp

@@ -81,7 +81,6 @@ void VisibilityPass::publishOutputs() {
     cullingBuffer = graphics->createShaderBuffer(ShaderBufferCreateInfo{
         .clearValue = 0xffffffff,
         .createCleared = true,
-        .dynamic = true,
         .name = "CullingBuffer",
     });
     resources->registerBufferOutput("CULLINGBUFFER", cullingBuffer);

src/Engine/Graphics/RenderPass/WaterRenderer.cpp

@@ -19,7 +19,6 @@ WaterRenderer::WaterRenderer(Gfx::PGraphics graphics, PScene scene, Gfx::PDescri
                 .size = sizeof(MaterialParams),
                 .data = (uint8*)&materialParams,
             },
-        .dynamic = true,
         .name = "WaterMaterialParams",
     });
     materialUniforms->pipelineBarrier(Gfx::SE_ACCESS_TRANSFER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT,
@@ -31,7 +30,6 @@ WaterRenderer::WaterRenderer(Gfx::PGraphics graphics, PScene scene, Gfx::PDescri
             {
                 .size = sizeof(ComputeParams),
             },
-        .dynamic = true,
         .name = "WaterComputeParams",
     });
     paramsBuffer->pipelineBarrier(Gfx::SE_ACCESS_TRANSFER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT, Gfx::SE_ACCESS_UNIFORM_READ_BIT,
@@ -107,7 +105,6 @@ WaterRenderer::WaterRenderer(Gfx::PGraphics graphics, PScene scene, Gfx::PDescri
                 .data = (uint8*)spectrums.data(),
             },
         .numElements = 8,
-        .dynamic = true,
         .name = "Spectrums",
     });
     spectrumBuffer->pipelineBarrier(Gfx::SE_ACCESS_TRANSFER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT, Gfx::SE_ACCESS_SHADER_READ_BIT,

src/Engine/Graphics/StaticMeshVertexData.cpp

@@ -18,44 +18,30 @@ StaticMeshVertexData* StaticMeshVertexData::getInstance() {
     return &instance;
 }
 
-void StaticMeshVertexData::loadPositions(uint64 offset, const Array<Vector4>& data) {
+void StaticMeshVertexData::loadPositions(uint64 offset, const Array<Vector>& data) {
     assert(offset + data.size() <= head);
-    std::memcpy(posData.data() + offset, data.data(), data.size() * sizeof(Vector4));
+    std::memcpy(posData.data() + offset, data.data(), data.size() * sizeof(Vector));
     // positions->updateContents(offset * sizeof(Vector4), data.size() * sizeof(Vector4), data.data());
     dirty = true;
 }
 
-void StaticMeshVertexData::loadTexCoords(uint64 offset, uint64 index, const Array<Vector2>& data) {
+void StaticMeshVertexData::loadTexCoords(uint64 offset, uint64 index, const Array<U16Vector2>& data) {
     assert(offset + data.size() <= head);
-    std::memcpy(texData[index].data() + offset, data.data(), data.size() * sizeof(Vector2));
+    std::memcpy(texData[index].data() + offset, data.data(), data.size() * sizeof(U16Vector2));
     // texCoords[index]->updateContents(offset * sizeof(Vector2), data.size() * sizeof(Vector2), data.data());
     dirty = true;
 }
 
-void StaticMeshVertexData::loadNormals(uint64 offset, const Array<Vector4>& data) {
+void StaticMeshVertexData::loadNormals(uint64 offset, const Array<Quaternion>& data) {
     assert(offset + data.size() <= head);
-    std::memcpy(norData.data() + offset, data.data(), data.size() * sizeof(Vector4));
+    std::memcpy(norData.data() + offset, data.data(), data.size() * sizeof(Quaternion));
     // normals->updateContents(offset * sizeof(Vector4), data.size() * sizeof(Vector4), data.data());
     dirty = true;
 }
 
-void StaticMeshVertexData::loadTangents(uint64 offset, const Array<Vector4>& data) {
+void StaticMeshVertexData::loadColors(uint64 offset, const Array<U16Vector>& data) {
     assert(offset + data.size() <= head);
-    std::memcpy(tanData.data() + offset, data.data(), data.size() * sizeof(Vector4));
+    std::memcpy(colData.data() + offset, data.data(), data.size() * sizeof(U16Vector));
-    //tangents->updateContents(offset * sizeof(Vector4), data.size() * sizeof(Vector4), data.data());
-    dirty = true;
-}
-
-void StaticMeshVertexData::loadBiTangents(uint64 offset, const Array<Vector4>& data) {
-    assert(offset + data.size() <= head);
-    std::memcpy(bitData.data() + offset, data.data(), data.size() * sizeof(Vector4));
-    // biTangents->updateContents(offset * sizeof(Vector4), data.size() * sizeof(Vector4), data.data());
-    dirty = true;
-}
-
-void StaticMeshVertexData::loadColors(uint64 offset, const Array<Vector4>& data) {
-    assert(offset + data.size() <= head);
-    std::memcpy(colData.data() + offset, data.data(), data.size() * sizeof(Vector4));
     // colors->updateContents(offset * sizeof(Vector4), data.size() * sizeof(Vector4), data.data());
     dirty = true;
 }
@@ -67,26 +53,20 @@ void StaticMeshVertexData::serializeMesh(MeshId id, uint64 numVertices, ArchiveB
         std::unique_lock l(vertexDataLock);
         offset = meshOffsets[id];
     }
-    Array<Vector2> tex[MAX_TEXCOORDS];
+    Array<U16Vector2> tex[MAX_TEXCOORDS];
     for (size_t i = 0; i < MAX_TEXCOORDS; ++i) {
         tex[i].resize(numVertices);
-        std::memcpy(tex[i].data(), texData[i].data() + offset, numVertices * sizeof(Vector2));
+        std::memcpy(tex[i].data(), texData[i].data() + offset, numVertices * sizeof(U16Vector2));
         Serialization::save(buffer, tex[i]);
     }
-    Array<Vector4> nor(numVertices);
+    Array<Vector> pos(numVertices);
-    Array<Vector4> tan(numVertices);
+    Array<Quaternion> nor(numVertices);
-    Array<Vector4> bit(numVertices);
+    Array<U16Vector> col(numVertices);
-    Array<Vector4> col(numVertices);
+    std::memcpy(pos.data(), posData.data() + offset, numVertices * sizeof(Vector));
-    Array<Vector4> pos(numVertices);
+    std::memcpy(nor.data(), norData.data() + offset, numVertices * sizeof(Quaternion));
-    std::memcpy(pos.data(), posData.data() + offset, numVertices * sizeof(Vector4));
+    std::memcpy(col.data(), colData.data() + offset, numVertices * sizeof(U16Vector));
-    std::memcpy(nor.data(), norData.data() + offset, numVertices * sizeof(Vector4));
-    std::memcpy(tan.data(), tanData.data() + offset, numVertices * sizeof(Vector4));
-    std::memcpy(bit.data(), bitData.data() + offset, numVertices * sizeof(Vector4));
-    std::memcpy(col.data(), colData.data() + offset, numVertices * sizeof(Vector4));
     Serialization::save(buffer, pos);
     Serialization::save(buffer, nor);
-    Serialization::save(buffer, tan);
-    Serialization::save(buffer, bit);
     Serialization::save(buffer, col);
 }
 
@@ -97,32 +77,24 @@ uint64 StaticMeshVertexData::deserializeMesh(MeshId id, ArchiveBuffer& buffer) {
         std::unique_lock l(vertexDataLock);
         offset = meshOffsets[id];
     }
-    Array<Vector2> tex[MAX_TEXCOORDS];
+    Array<U16Vector2> tex[MAX_TEXCOORDS];
     for (size_t i = 0; i < MAX_TEXCOORDS; ++i) {
         Serialization::load(buffer, tex[i]);
         loadTexCoords(offset, i, tex[i]);
-        result += tex[i].size() * sizeof(Vector2);
+        result += tex[i].size() * sizeof(U16Vector2);
     }
-    Array<Vector4> pos;
+    Array<Vector> pos;
-    Array<Vector4> nor;
+    Array<Quaternion> nor;
-    Array<Vector4> tan;
+    Array<U16Vector> col;
-    Array<Vector4> bit;
-    Array<Vector4> col;
     Serialization::load(buffer, pos);
     Serialization::load(buffer, nor);
-    Serialization::load(buffer, tan);
-    Serialization::load(buffer, bit);
     Serialization::load(buffer, col);
     loadPositions(offset, pos);
     loadNormals(offset, nor);
-    loadTangents(offset, tan);
-    loadBiTangents(offset, bit);
     loadColors(offset, col);
-    result += pos.size() * sizeof(Vector4);
+    result += pos.size() * sizeof(Vector);
-    result += nor.size() * sizeof(Vector4);
+    result += nor.size() * sizeof(Quaternion);
-    result += tan.size() * sizeof(Vector4);
+    result += col.size() * sizeof(U16Vector);
-    result += bit.size() * sizeof(Vector4);
-    result += col.size() * sizeof(Vector4);
     return result;
 }
 
@@ -150,8 +122,6 @@ void StaticMeshVertexData::destroy() {
     }
     positions = nullptr;
     normals = nullptr;
-    tangents = nullptr;
-    biTangents = nullptr;
     colors = nullptr;
     descriptorSet = nullptr;
     descriptorLayout = nullptr;
@@ -168,8 +138,6 @@ Gfx::PDescriptorSet StaticMeshVertexData::getVertexDataSet() { return descriptor
 void StaticMeshVertexData::resizeBuffers() {
     posData.resize(verticesAllocated);
     norData.resize(verticesAllocated);
-    tanData.resize(verticesAllocated);
-    bitData.resize(verticesAllocated);
     colData.resize(verticesAllocated);
     for (size_t i = 0; i < MAX_TEXCOORDS; ++i) {
         texData[i].resize(verticesAllocated);
@@ -177,54 +145,51 @@ void StaticMeshVertexData::resizeBuffers() {
 }
 
 void StaticMeshVertexData::updateBuffers() {
-    ShaderBufferCreateInfo createInfo = {
+    positions = graphics->createShaderBuffer(ShaderBufferCreateInfo{
         .sourceData =
             {
-                .size = verticesAllocated * sizeof(Vector4),
+                .size = verticesAllocated * sizeof(Vector),
                 .data = (uint8*)posData.data(),
             },
-        .numElements = verticesAllocated,
-        .dynamic = true,
         .vertexBuffer = true,
         .name = "Positions",
-    };
+    });
-    positions = graphics->createShaderBuffer(createInfo);
+    normals = graphics->createShaderBuffer(ShaderBufferCreateInfo{
-    createInfo.vertexBuffer = false;
+        .sourceData =
-    createInfo.name = "Normals";
+            {
-    createInfo.sourceData.data = (uint8*)norData.data();
+                .size = verticesAllocated * sizeof(Quaternion),
-    normals = graphics->createShaderBuffer(createInfo);
+                .data = (uint8*)norData.data(),
-    createInfo.name = "Tangents";
+            },
-    createInfo.sourceData.data = (uint8*)tanData.data();
+        .vertexBuffer = false,
-    tangents = graphics->createShaderBuffer(createInfo);
+        .name = "Normals",
-    createInfo.name = "BiTangents";
+    });
-    createInfo.sourceData.data = (uint8*)bitData.data();
+    colors = graphics->createShaderBuffer(ShaderBufferCreateInfo{
-    biTangents = graphics->createShaderBuffer(createInfo);
+        .sourceData =
-    createInfo.name = "Colors";
+            {
-    createInfo.sourceData.data = (uint8*)colData.data();
+                .size = verticesAllocated * sizeof(U16Vector),
-    colors = graphics->createShaderBuffer(createInfo);
+                .data = (uint8*)colData.data(),
-    createInfo.sourceData.size = verticesAllocated * sizeof(Vector2);
+            },
-    createInfo.name = "TexCoords";
+        .vertexBuffer = false,
+        .name = "Colors",
+    });
     for (size_t i = 0; i < MAX_TEXCOORDS; ++i) {
-        createInfo.sourceData.data = (uint8*)texData[i].data();
+        texCoords[i] = graphics->createShaderBuffer(ShaderBufferCreateInfo{
-        texCoords[i] = graphics->createShaderBuffer(createInfo);
+            .sourceData =
+                {
+                    .size = verticesAllocated * sizeof(U16Vector2),
+                    .data = (uint8*)texData[i].data(),
+                },
+            .vertexBuffer = false,
+            .name = "TexCoords",
+        });
     }
-    posData.clear();
-    for (size_t i = 0; i < MAX_TEXCOORDS; ++i) {
-        texData[i].clear();
-    }
-    norData.clear();
-    tanData.clear();
-    bitData.clear();
-    colData.clear();
     descriptorLayout->reset();
     descriptorSet = descriptorLayout->allocateDescriptorSet();
     descriptorSet->updateBuffer(0, 0, positions);
     descriptorSet->updateBuffer(1, 0, normals);
-    descriptorSet->updateBuffer(2, 0, tangents);
+    descriptorSet->updateBuffer(2, 0, colors);
-    descriptorSet->updateBuffer(3, 0, biTangents);
-    descriptorSet->updateBuffer(4, 0, colors);
     for (size_t i = 0; i < MAX_TEXCOORDS; ++i) {
-        descriptorSet->updateBuffer(5, i, texCoords[i]);
+        descriptorSet->updateBuffer(3, i, texCoords[i]);
     }
     descriptorSet->writeChanges();
 }

src/Engine/Graphics/StaticMeshVertexData.h

@@ -12,12 +12,10 @@ class StaticMeshVertexData : public VertexData {
     StaticMeshVertexData();
     virtual ~StaticMeshVertexData();
     static StaticMeshVertexData* getInstance();
-    void loadPositions(uint64 offset, const Array<Vector4>& data);
+    void loadPositions(uint64 offset, const Array<Vector>& data);
-    void loadTexCoords(uint64 offset, uint64 index, const Array<Vector2>& data);
+    void loadTexCoords(uint64 offset, uint64 index, const Array<U16Vector2>& data);
-    void loadNormals(uint64 offset, const Array<Vector4>& data);
+    void loadNormals(uint64 offset, const Array<Quaternion>& data);
-    void loadTangents(uint64 offset, const Array<Vector4>& data);
+    void loadColors(uint64 offset, const Array<U16Vector>& data);
-    void loadBiTangents(uint64 offset, const Array<Vector4>& data);
-    void loadColors(uint64 offset, const Array<Vector4>& data);
     virtual void serializeMesh(MeshId id, uint64 numVertices, ArchiveBuffer& buffer) override;
     virtual uint64 deserializeMesh(MeshId id, ArchiveBuffer& buffer) override;
     virtual void init(Gfx::PGraphics graphics) override;
@@ -35,15 +33,11 @@ class StaticMeshVertexData : public VertexData {
     Gfx::OShaderBuffer positions;
     Gfx::OShaderBuffer texCoords[MAX_TEXCOORDS];
     Gfx::OShaderBuffer normals;
-    Gfx::OShaderBuffer tangents;
-    Gfx::OShaderBuffer biTangents;
     Gfx::OShaderBuffer colors;
-    Array<Vector4> posData;
+    Array<Vector> posData;
-    Array<Vector2> texData[MAX_TEXCOORDS];
+    Array<U16Vector2> texData[MAX_TEXCOORDS];
-    Array<Vector4> norData;
+    Array<Quaternion> norData;
-    Array<Vector4> tanData;
+    Array<U16Vector4> colData;
-    Array<Vector4> bitData;
-    Array<Vector4> colData;
     Gfx::ODescriptorLayout descriptorLayout;
     Gfx::PDescriptorSet descriptorSet;
 };

src/Engine/Graphics/VertexData.cpp

@@ -11,7 +11,7 @@
 
 using namespace Seele;
 
-constexpr static uint64 NUM_DEFAULT_ELEMENTS = 17962284;
+constexpr static uint64 NUM_DEFAULT_ELEMENTS = 36;
 uint64 VertexData::meshletCount = 0;
 
 void VertexData::resetMeshData() {
@@ -82,7 +82,8 @@ void VertexData::updateMesh(uint32 meshletOffset, PMesh mesh, Component::Transfo
     matInstanceData.instanceData.add(inst);
     matInstanceData.instanceMeshData.add(data);
     matInstanceData.cullingOffsets.add(meshletOffset);
-    for (size_t i = 0; i < 0; ++i) {
+
+    /* for (size_t i = 0; i < 0; ++i) {
         auto bounding = meshlets[data.meshletOffset + i].bounding;
         StaticArray<Vector, 8> corners;
         Vector min = bounding.min; // bounding.center - bounding.radius * Vector(1, 1, 1);
@@ -119,7 +120,7 @@ void VertexData::updateMesh(uint32 meshletOffset, PMesh mesh, Component::Transfo
         addDebugVertex(DebugVertex{.position = corners[7], .color = meshlets[data.meshletOffset + i].color});
         addDebugVertex(DebugVertex{.position = corners[5], .color = meshlets[data.meshletOffset + i].color});
         addDebugVertex(DebugVertex{.position = corners[7], .color = meshlets[data.meshletOffset + i].color});
-    }
+    }*/
 }
 
 void VertexData::createDescriptors() {
@@ -226,7 +227,6 @@ void VertexData::commitMeshes() {
                 .data = (uint8*)meshlets.data(),
             },
         .numElements = meshlets.size(),
-        .dynamic = false,
         .name = "MeshletBuffer",
     });
     vertexIndicesBuffer = graphics->createShaderBuffer(ShaderBufferCreateInfo{
@@ -236,7 +236,6 @@ void VertexData::commitMeshes() {
                 .data = (uint8*)vertexIndices.data(),
             },
         .numElements = vertexIndices.size(),
-        .dynamic = false,
         .name = "VertexIndicesBuffer",
     });
 
@@ -247,7 +246,6 @@ void VertexData::commitMeshes() {
                 .data = (uint8*)primitiveIndices.data(),
             },
         .numElements = primitiveIndices.size(),
-        .dynamic = false,
         .name = "PrimitiveIndicesBuffer",
     });
     updateBuffers();
@@ -352,15 +350,12 @@ void VertexData::init(Gfx::PGraphics _graphics) {
     instanceDataLayout->create();
 
     cullingOffsetBuffer = graphics->createShaderBuffer(ShaderBufferCreateInfo{
-        .dynamic = true,
         .name = "MeshletOffset",
     });
     instanceBuffer = graphics->createShaderBuffer(ShaderBufferCreateInfo{
-        .dynamic = true,
         .name = "InstanceBuffer",
     });
     instanceMeshDataBuffer = graphics->createShaderBuffer(ShaderBufferCreateInfo{
-        .dynamic = true,
         .name = "MeshDataBuffer",
     });
     resizeBuffers();

src/Engine/Graphics/Vulkan/Buffer.cpp

@@ -390,7 +390,7 @@ void Buffer::pipelineBarrier(VkAccessFlags srcAccess, VkPipelineStageFlags srcSt
 UniformBuffer::UniformBuffer(PGraphics graphics, const UniformBufferCreateInfo& createInfo)
     : Gfx::UniformBuffer(graphics->getFamilyMapping(), createInfo),
       Vulkan::Buffer(graphics, createInfo.sourceData.size, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, createInfo.sourceData.owner,
-                     createInfo.dynamic, createInfo.name) {
+                     true, createInfo.name) {
     if (createInfo.sourceData.size > 0 && createInfo.sourceData.data != nullptr) {
         getAlloc()->updateContents(createInfo.sourceData.offset, createInfo.sourceData.size, createInfo.sourceData.data);
     }
@@ -421,7 +421,7 @@ ShaderBuffer::ShaderBuffer(PGraphics graphics, const ShaderBufferCreateInfo& cre
                          (createInfo.vertexBuffer ? VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR |
                                                         VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT
                                                   : 0),
-                     createInfo.sourceData.owner, createInfo.dynamic, createInfo.name, createInfo.createCleared, createInfo.clearValue) {
+                     createInfo.sourceData.owner, true, createInfo.name, createInfo.createCleared, createInfo.clearValue) {
     if (createInfo.sourceData.size > 0 && createInfo.sourceData.data != nullptr) {
         getAlloc()->updateContents(createInfo.sourceData.offset, createInfo.sourceData.size, createInfo.sourceData.data);
     }

src/Engine/Material/Material.cpp

@@ -58,7 +58,6 @@ void Material::init(Gfx::PGraphics graphics) {
     });
     layout->create();
     floatBuffer = graphics->createShaderBuffer(ShaderBufferCreateInfo{
-        .dynamic = true,
         .name = "MaterialFloatBuffer",
     });
 }

src/Engine/Math/Vector.h

@@ -26,6 +26,14 @@ typedef glm::ivec2 IVector2;
 typedef glm::ivec3 IVector;
 typedef glm::ivec4 IVector4;
 
+typedef glm::u16vec2 U16Vector2;
+typedef glm::u16vec3 U16Vector;
+typedef glm::u16vec4 U16Vector4;
+
+typedef glm::i16vec2 I16Vector2;
+typedef glm::i16vec3 I16Vector;
+typedef glm::i16vec4 I16Vector4;
+
 typedef glm::quat Quaternion;
 
 Vector parseVector(const char*);

src/Engine/Scene/LightEnvironment.cpp

@@ -19,13 +19,13 @@ LightEnvironment::LightEnvironment(Gfx::PGraphics graphics) : graphics(graphics)
     });
     layout->create();
     lightEnvBuffer = graphics->createUniformBuffer(UniformBufferCreateInfo{
-        .dynamic = true,
+        .name = "LightEnv",
     });
     directionalLights = graphics->createShaderBuffer(ShaderBufferCreateInfo{
-        .dynamic = true,
+        .name = "DirectionalLights",
     });
     pointLights = graphics->createShaderBuffer(ShaderBufferCreateInfo{
-        .dynamic = true,
+        .name = "PointLights",
     });
 }