Dynamitos/Seele
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Trying compression

Browse Source
This commit is contained in:
Dynamitos
2024-10-01 11:15:38 +02:00
parent b5f3e8ee4f
commit 4ca43427e2
24 changed files with 199 additions and 203 deletions
Download Patch File Download Diff File Expand all files Collapse all files
CMakeLists.txt
+1
View File
@@ -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
+45 -12
View File
@@ -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;
attributes.tangent_MS = tangents[index].xyz;
attributes.biTangent_MS = biTangents[index].xyz;
float4 qtangent = normalize(qtangents[index]);
attributes.normal_MS = xAxis(qtangent);
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<float4> normals;
StructuredBuffer<float4> tangents;
StructuredBuffer<float4> biTangents;
StructuredBuffer<float4> color;
StructuredBuffer<float2> texCoords[MAX_TEXCOORDS];
StructuredBuffer<float> positions;
StructuredBuffer<float4> qtangents;
StructuredBuffer<uint16_t> color;
StructuredBuffer<uint16_t> texCoords[MAX_TEXCOORDS];
};
layout(set=1)
ParameterBlock<StaticMeshVertexData> pVertexData;
src/Editor/Asset/MeshLoader.cpp
+37 -20
View File
@@ -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);
StaticArray<Array<Vector2>, MAX_TEXCOORDS> texCoords;
Array<Vector> positions(mesh->mNumVertices);
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<Vector4> tangents(mesh->mNumVertices);
Array<Vector4> biTangents(mesh->mNumVertices);
Array<Vector4> colors(mesh->mNumVertices);
Array<Quaternion> normals(mesh->mNumVertices);
Array<U16Vector> 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);
biTangents[i] = Vector4(mesh->mBitangents[i].x, mesh->mBitangents[i].y, mesh->mBitangents[i].z, 1.0f);
} else {
tangents[i] = Vector4(0, 0, 1, 1);
biTangents[i] = Vector4(1, 0, 0, 1);
tangent = Vector(mesh->mTangents[i].x, mesh->mTangents[i].y, mesh->mTangents[i].z);
biTangent = Vector(mesh->mBitangents[i].x, mesh->mBitangents[i].y, mesh->mBitangents[i].z);
}
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
+4 -4
View File
@@ -111,12 +111,12 @@ void TextureLoader::import(TextureImportArgs args, PTextureAsset textureAsset) {
ktxBasisParams basisParams = {
.structSize = sizeof(ktxBasisParams),
.uastc = true,
.threadCount = 14,
.uastcFlags = KTX_PACK_UASTC_LEVEL_SLOWER,
.threadCount = 1,
.uastcFlags = KTX_PACK_UASTC_LEVEL_FASTER,
.uastcRDO = true,
};
KTX_ASSERT(ktxTexture2_CompressBasisEx(kTexture, &basisParams));
KTX_ASSERT(ktxTexture2_DeflateZstd(kTexture, 20));
//KTX_ASSERT(ktxTexture2_CompressBasisEx(kTexture, &basisParams));
//KTX_ASSERT(ktxTexture2_DeflateZstd(kTexture, 20));
char writer[100];
snprintf(writer, sizeof(writer), "%s version %s", "SeeleEngine", "0.0.1");
src/Editor/main.cpp
+11 -11
View File
@@ -65,21 +65,21 @@ int main() {
.filePath = sourcePath / "import/textures/skyboxsun5deg_tn.jpg",
.type = TextureImportType::TEXTURE_CUBEMAP,
});
AssetImporter::importMesh(MeshImportArgs{
.filePath = sourcePath / "import/models/ship.fbx",
.importPath = "ship",
});
//AssetImporter::importMesh(MeshImportArgs{
// .filePath = sourcePath / "import/models/ship.fbx",
// .importPath = "ship",
//});
AssetImporter::importTexture(TextureImportArgs{
.filePath = sourcePath / "import/textures/azeroth.png",
});
AssetImporter::importTexture(TextureImportArgs{
.filePath = sourcePath / "import/textures/azeroth_height.png",
});
// AssetImporter::importMesh(MeshImportArgs{
//AssetImporter::importMesh(MeshImportArgs{
// .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{
// .filePath = sourcePath / "import/models/Volvo/Volvo.fbx",
// .importPath = "Volvo",
// });
AssetImporter::importMesh(MeshImportArgs{
.filePath = sourcePath / "import/models/Volvo/Volvo.fbx",
.importPath = "Volvo",
});
getThreadPool().waitIdle();
vd->commitMeshes();
WindowCreateInfo mainWindowInfo = {
src/Engine/Graphics/Initializer.h
-2
View File
@@ -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
+3 -2
View File
@@ -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
+1 -2
View File
@@ -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
+1 -2
View File
@@ -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
-1
View File
@@ -236,7 +236,6 @@ void DepthCullingPass::publishOutputs() {
.data = nullptr,
},
.numElements = bufferSize,
.dynamic = true,
.name = "DepthMipBuffer",
});
src/Engine/Graphics/RenderPass/LightCullingPass.cpp
-5
View File
@@ -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
-1
View File
@@ -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
-1
View File
@@ -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
-1
View File
@@ -128,7 +128,6 @@ void TextPass::createRenderPass() {
.size = sizeof(Matrix4),
.data = nullptr,
},
.dynamic = true,
});
glyphSampler = graphics->createSampler({
src/Engine/Graphics/RenderPass/UIPass.cpp
+10 -10
View File
@@ -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 = {
.sourceData = {.size = sizeof(uint32), .data = nullptr},
.dynamic = true,
};
numTexturesBuffer = graphics->createUniformBuffer(info);
numTexturesBuffer = graphics->createUniformBuffer(UniformBufferCreateInfo{
.sourceData =
{
.size = sizeof(uint32),
.data = nullptr,
},
});
descriptorSet = descriptorLayout->allocateDescriptorSet();
descriptorSet->updateBuffer(0, 0, uniformBuffer);
src/Engine/Graphics/RenderPass/VisibilityPass.cpp
-1
View File
@@ -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
-3
View File
@@ -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
+59 -94
View File
@@ -18,45 +18,31 @@ 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));
//positions->updateContents(offset * sizeof(Vector4), data.size() * sizeof(Vector4), data.data());
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));
//texCoords[index]->updateContents(offset * sizeof(Vector2), data.size() * sizeof(Vector2), data.data());
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));
//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());
std::memcpy(colData.data() + offset, data.data(), data.size() * sizeof(U16Vector));
// 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<Vector4> tan(numVertices);
Array<Vector4> bit(numVertices);
Array<Vector4> col(numVertices);
Array<Vector4> pos(numVertices);
std::memcpy(pos.data(), posData.data() + offset, numVertices * sizeof(Vector4));
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));
Array<Vector> pos(numVertices);
Array<Quaternion> nor(numVertices);
Array<U16Vector> col(numVertices);
std::memcpy(pos.data(), posData.data() + offset, numVertices * sizeof(Vector));
std::memcpy(nor.data(), norData.data() + offset, numVertices * sizeof(Quaternion));
std::memcpy(col.data(), colData.data() + offset, numVertices * sizeof(U16Vector));
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<Vector4> nor;
Array<Vector4> tan;
Array<Vector4> bit;
Array<Vector4> col;
Array<Vector> pos;
Array<Quaternion> nor;
Array<U16Vector> 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 += nor.size() * sizeof(Vector4);
result += tan.size() * sizeof(Vector4);
result += bit.size() * sizeof(Vector4);
result += col.size() * sizeof(Vector4);
result += pos.size() * sizeof(Vector);
result += nor.size() * sizeof(Quaternion);
result += col.size() * sizeof(U16Vector);
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);
createInfo.vertexBuffer = false;
createInfo.name = "Normals";
createInfo.sourceData.data = (uint8*)norData.data();
normals = graphics->createShaderBuffer(createInfo);
createInfo.name = "Tangents";
createInfo.sourceData.data = (uint8*)tanData.data();
tangents = graphics->createShaderBuffer(createInfo);
createInfo.name = "BiTangents";
createInfo.sourceData.data = (uint8*)bitData.data();
biTangents = graphics->createShaderBuffer(createInfo);
createInfo.name = "Colors";
createInfo.sourceData.data = (uint8*)colData.data();
colors = graphics->createShaderBuffer(createInfo);
createInfo.sourceData.size = verticesAllocated * sizeof(Vector2);
createInfo.name = "TexCoords";
});
normals = graphics->createShaderBuffer(ShaderBufferCreateInfo{
.sourceData =
{
.size = verticesAllocated * sizeof(Quaternion),
.data = (uint8*)norData.data(),
},
.vertexBuffer = false,
.name = "Normals",
});
colors = graphics->createShaderBuffer(ShaderBufferCreateInfo{
.sourceData =
{
.size = verticesAllocated * sizeof(U16Vector),
.data = (uint8*)colData.data(),
},
.vertexBuffer = false,
.name = "Colors",
});
for (size_t i = 0; i < MAX_TEXCOORDS; ++i) {
createInfo.sourceData.data = (uint8*)texData[i].data();
texCoords[i] = graphics->createShaderBuffer(createInfo);
texCoords[i] = graphics->createShaderBuffer(ShaderBufferCreateInfo{
.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(3, 0, biTangents);
descriptorSet->updateBuffer(4, 0, colors);
descriptorSet->updateBuffer(2, 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
+8 -14
View File
@@ -12,12 +12,10 @@ class StaticMeshVertexData : public VertexData {
StaticMeshVertexData();
virtual ~StaticMeshVertexData();
static StaticMeshVertexData* getInstance();
void loadPositions(uint64 offset, const Array<Vector4>& data);
void loadTexCoords(uint64 offset, uint64 index, const Array<Vector2>& data);
void loadNormals(uint64 offset, const Array<Vector4>& data);
void loadTangents(uint64 offset, const Array<Vector4>& data);
void loadBiTangents(uint64 offset, const Array<Vector4>& data);
void loadColors(uint64 offset, const Array<Vector4>& data);
void loadPositions(uint64 offset, const Array<Vector>& data);
void loadTexCoords(uint64 offset, uint64 index, const Array<U16Vector2>& data);
void loadNormals(uint64 offset, const Array<Quaternion>& data);
void loadColors(uint64 offset, const Array<U16Vector>& 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<Vector2> texData[MAX_TEXCOORDS];
Array<Vector4> norData;
Array<Vector4> tanData;
Array<Vector4> bitData;
Array<Vector4> colData;
Array<Vector> posData;
Array<U16Vector2> texData[MAX_TEXCOORDS];
Array<Quaternion> norData;
Array<U16Vector4> colData;
Gfx::ODescriptorLayout descriptorLayout;
Gfx::PDescriptorSet descriptorSet;
};
src/Engine/Graphics/VertexData.cpp
+4 -9
View File
@@ -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
+2 -2
View File
@@ -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
-1
View File
@@ -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
+8
View File
@@ -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
+3 -3
View File
@@ -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",
});
}