OrdinaryMagician/vkdoom_m
OrdinaryMagician/vkdoom_m
1
Fork 0
Code Activity

Group mesh buffers

Browse source
This commit is contained in:
Magnus Norddahl 2023-12-06 13:26:55 +01:00
commit 6a77924207
8 changed files with 125 additions and 122 deletions
Download patch file Download diff file Expand all files Collapse all files

30
src/common/rendering/hwrenderer/data/hw_levelmesh.cpp
View file

@ -24,7 +24,7 @@ LevelMeshSurface* LevelMesh::Trace(const FVector3& start, FVector3 direction, fl
return nullptr;
}
hitSurface = hitmesh->GetSurface(hitmesh->MeshSurfaceIndexes[hit.triangle]);
hitSurface = hitmesh->GetSurface(hitmesh->Mesh.SurfaceIndexes[hit.triangle]);
auto portal = hitSurface->portalIndex;
if (!portal)
@ -67,28 +67,28 @@ LevelSubmesh::LevelSubmesh()
// Default empty mesh (we can't make it completely empty since vulkan doesn't like that)
float minval = -100001.0f;
float maxval = -100000.0f;
MeshVertices.Push({ minval, minval, minval });
MeshVertices.Push({ maxval, minval, minval });
MeshVertices.Push({ maxval, maxval, minval });
MeshVertices.Push({ minval, minval, minval });
MeshVertices.Push({ minval, maxval, minval });
MeshVertices.Push({ maxval, maxval, minval });
MeshVertices.Push({ minval, minval, maxval });
MeshVertices.Push({ maxval, minval, maxval });
MeshVertices.Push({ maxval, maxval, maxval });
MeshVertices.Push({ minval, minval, maxval });
MeshVertices.Push({ minval, maxval, maxval });
MeshVertices.Push({ maxval, maxval, maxval });
Mesh.Vertices.Push({ minval, minval, minval });
Mesh.Vertices.Push({ maxval, minval, minval });
Mesh.Vertices.Push({ maxval, maxval, minval });
Mesh.Vertices.Push({ minval, minval, minval });
Mesh.Vertices.Push({ minval, maxval, minval });
Mesh.Vertices.Push({ maxval, maxval, minval });
Mesh.Vertices.Push({ minval, minval, maxval });
Mesh.Vertices.Push({ maxval, minval, maxval });
Mesh.Vertices.Push({ maxval, maxval, maxval });
Mesh.Vertices.Push({ minval, minval, maxval });
Mesh.Vertices.Push({ minval, maxval, maxval });
Mesh.Vertices.Push({ maxval, maxval, maxval });
for (int i = 0; i < 3 * 4; i++)
MeshElements.Push(i);
Mesh.Elements.Push(i);
UpdateCollision();
}
void LevelSubmesh::UpdateCollision()
{
Collision = std::make_unique<TriangleMeshShape>(MeshVertices.Data(), MeshVertices.Size(), MeshElements.Data(), MeshElements.Size());
Collision = std::make_unique<TriangleMeshShape>(Mesh.Vertices.Data(), Mesh.Vertices.Size(), Mesh.Elements.Data(), Mesh.Elements.Size());
}
void LevelSubmesh::GatherSurfacePixelStats(LevelMeshSurfaceStats& stats)

15
src/common/rendering/hwrenderer/data/hw_levelmesh.h
View file

@ -256,12 +256,15 @@ public:
virtual unsigned int GetSurfaceIndex(const LevelMeshSurface* surface) const { return 0xffffffff; }
virtual int GetSurfaceCount() { return 0; }
TArray<FFlatVertex> MeshVertices;
TArray<uint32_t> MeshElements;
TArray<int> MeshSurfaceIndexes;
TArray<int> MeshUniformIndexes;
TArray<SurfaceUniforms> MeshSurfaceUniforms;
TArray<FMaterialState> MeshSurfaceMaterials;
struct
{
TArray<FFlatVertex> Vertices;
TArray<uint32_t> Elements;
TArray<int> SurfaceIndexes;
TArray<int> UniformIndexes;
TArray<SurfaceUniforms> Uniforms;
TArray<FMaterialState> Materials;
} Mesh;
TArray<LevelMeshPortal> Portals;

2
src/common/rendering/vulkan/accelstructs/vk_lightmap.cpp
View file

@ -191,7 +191,7 @@ void VkLightmap::Render()
if (targetSurface->Submesh != mesh->StaticMesh.get())
{
surfaceIndexOffset = mesh->StaticMesh->GetSurfaceCount();
firstIndexOffset = mesh->StaticMesh->MeshElements.Size();
firstIndexOffset = mesh->StaticMesh->Mesh.Elements.Size();
}
LightmapRaytracePC pc;

74
src/common/rendering/vulkan/accelstructs/vk_raytrace.cpp
View file

@ -100,12 +100,12 @@ void VkRaytrace::UploadMeshes(bool dynamicOnly)
{
SubmeshBufferLocation location;
location.Submesh = submesh;
location.VertexSize = submesh->MeshVertices.Size();
location.IndexSize = submesh->MeshElements.Size();
location.VertexSize = submesh->Mesh.Vertices.Size();
location.IndexSize = submesh->Mesh.Elements.Size();
location.NodeSize = (int)submesh->Collision->get_nodes().size();
location.SurfaceIndexSize = submesh->MeshSurfaceIndexes.Size();
location.SurfaceIndexSize = submesh->Mesh.SurfaceIndexes.Size();
location.SurfaceSize = submesh->GetSurfaceCount();
location.SurfaceUniformsSize = submesh->MeshSurfaceUniforms.Size();
location.UniformsSize = submesh->Mesh.Uniforms.Size();
locations.Push(location);
}
@ -119,14 +119,14 @@ void VkRaytrace::UploadMeshes(bool dynamicOnly)
cur.NodeOffset = prev.NodeOffset + prev.NodeSize;
cur.SurfaceIndexOffset = prev.SurfaceIndexOffset + prev.SurfaceIndexSize;
cur.SurfaceOffset = prev.SurfaceOffset + prev.SurfaceSize;
cur.SurfaceUniformsOffset = prev.SurfaceUniformsOffset + prev.SurfaceUniformsSize;
cur.UniformsOffset = prev.UniformsOffset + prev.UniformsSize;
if (
cur.VertexOffset + cur.VertexSize > GetMaxVertexBufferSize() ||
cur.IndexOffset + cur.IndexSize > GetMaxIndexBufferSize() ||
cur.NodeOffset + cur.NodeSize > GetMaxNodeBufferSize() ||
cur.SurfaceOffset + cur.SurfaceSize > GetMaxSurfaceBufferSize() ||
cur.SurfaceUniformsOffset + cur.SurfaceUniformsSize > GetMaxSurfaceUniformsBufferSize() ||
cur.UniformsOffset + cur.UniformsSize > GetMaxUniformsBufferSize() ||
cur.SurfaceIndexOffset + cur.SurfaceIndexSize > GetMaxSurfaceIndexBufferSize())
{
I_FatalError("Dynamic accel struct buffers are too small!");
@ -141,13 +141,13 @@ void VkRaytrace::UploadMeshes(bool dynamicOnly)
for (unsigned int i = start; i < end; i++)
{
const SubmeshBufferLocation& cur = locations[i];
transferBufferSize += cur.Submesh->MeshVertices.Size() * sizeof(FFlatVertex);
transferBufferSize += cur.Submesh->MeshUniformIndexes.Size() * sizeof(int);
transferBufferSize += cur.Submesh->MeshElements.Size() * sizeof(uint32_t);
transferBufferSize += cur.Submesh->Mesh.Vertices.Size() * sizeof(FFlatVertex);
transferBufferSize += cur.Submesh->Mesh.UniformIndexes.Size() * sizeof(int);
transferBufferSize += cur.Submesh->Mesh.Elements.Size() * sizeof(uint32_t);
transferBufferSize += cur.Submesh->Collision->get_nodes().size() * sizeof(CollisionNode);
transferBufferSize += cur.Submesh->MeshSurfaceIndexes.Size() * sizeof(int);
transferBufferSize += cur.Submesh->Mesh.SurfaceIndexes.Size() * sizeof(int);
transferBufferSize += cur.Submesh->GetSurfaceCount() * sizeof(SurfaceInfo);
transferBufferSize += cur.Submesh->MeshSurfaceUniforms.Size() * sizeof(SurfaceUniforms);
transferBufferSize += cur.Submesh->Mesh.Uniforms.Size() * sizeof(SurfaceUniforms);
}
if (!dynamicOnly)
transferBufferSize += Mesh->StaticMesh->Portals.Size() * sizeof(PortalInfo);
@ -207,8 +207,8 @@ void VkRaytrace::UploadMeshes(bool dynamicOnly)
const SubmeshBufferLocation& cur = locations[i];
auto submesh = cur.Submesh;
size_t copysize = submesh->MeshVertices.Size() * sizeof(FFlatVertex);
memcpy(data + datapos, submesh->MeshVertices.Data(), copysize);
size_t copysize = submesh->Mesh.Vertices.Size() * sizeof(FFlatVertex);
memcpy(data + datapos, submesh->Mesh.Vertices.Data(), copysize);
if (copysize > 0)
cmdbuffer->copyBuffer(transferBuffer.get(), VertexBuffer.get(), datapos, cur.VertexOffset * sizeof(FFlatVertex), copysize);
datapos += copysize;
@ -220,8 +220,8 @@ void VkRaytrace::UploadMeshes(bool dynamicOnly)
const SubmeshBufferLocation& cur = locations[i];
auto submesh = cur.Submesh;
size_t copysize = submesh->MeshUniformIndexes.Size() * sizeof(int);
memcpy(data + datapos, submesh->MeshUniformIndexes.Data(), copysize);
size_t copysize = submesh->Mesh.UniformIndexes.Size() * sizeof(int);
memcpy(data + datapos, submesh->Mesh.UniformIndexes.Data(), copysize);
if (copysize > 0)
cmdbuffer->copyBuffer(transferBuffer.get(), UniformIndexBuffer.get(), datapos, cur.VertexOffset * sizeof(int), copysize);
datapos += copysize;
@ -234,10 +234,10 @@ void VkRaytrace::UploadMeshes(bool dynamicOnly)
auto submesh = cur.Submesh;
uint32_t* indexes = (uint32_t*)(data + datapos);
for (int j = 0, count = submesh->MeshElements.Size(); j < count; ++j)
*(indexes++) = cur.VertexOffset + submesh->MeshElements[j];
for (int j = 0, count = submesh->Mesh.Elements.Size(); j < count; ++j)
*(indexes++) = cur.VertexOffset + submesh->Mesh.Elements[j];
size_t copysize = submesh->MeshElements.Size() * sizeof(uint32_t);
size_t copysize = submesh->Mesh.Elements.Size() * sizeof(uint32_t);
if (copysize > 0)
cmdbuffer->copyBuffer(transferBuffer.get(), IndexBuffer.get(), datapos, cur.IndexOffset * sizeof(uint32_t), copysize);
datapos += copysize;
@ -274,10 +274,10 @@ void VkRaytrace::UploadMeshes(bool dynamicOnly)
auto submesh = cur.Submesh;
int* indexes = (int*)(data + datapos);
for (int j = 0, count = submesh->MeshSurfaceIndexes.Size(); j < count; ++j)
*(indexes++) = cur.SurfaceIndexOffset + submesh->MeshSurfaceIndexes[j];
for (int j = 0, count = submesh->Mesh.SurfaceIndexes.Size(); j < count; ++j)
*(indexes++) = cur.SurfaceIndexOffset + submesh->Mesh.SurfaceIndexes[j];
size_t copysize = submesh->MeshSurfaceIndexes.Size() * sizeof(int);
size_t copysize = submesh->Mesh.SurfaceIndexes.Size() * sizeof(int);
if (copysize > 0)
cmdbuffer->copyBuffer(transferBuffer.get(), SurfaceIndexBuffer.get(), datapos, cur.SurfaceIndexOffset * sizeof(int), copysize);
datapos += copysize;
@ -325,10 +325,10 @@ void VkRaytrace::UploadMeshes(bool dynamicOnly)
const SubmeshBufferLocation& cur = locations[i];
auto submesh = cur.Submesh;
for (int j = 0, count = submesh->MeshSurfaceUniforms.Size(); j < count; j++)
for (int j = 0, count = submesh->Mesh.Uniforms.Size(); j < count; j++)
{
auto& surfaceUniforms = submesh->MeshSurfaceUniforms[j];
auto& material = submesh->MeshSurfaceMaterials[j];
auto& surfaceUniforms = submesh->Mesh.Uniforms[j];
auto& material = submesh->Mesh.Materials[j];
if (material.mMaterial)
{
auto source = material.mMaterial->Source();
@ -342,10 +342,10 @@ void VkRaytrace::UploadMeshes(bool dynamicOnly)
}
SurfaceUniforms* uniforms = (SurfaceUniforms*)(data + datapos);
size_t copysize = submesh->MeshSurfaceUniforms.Size() * sizeof(SurfaceUniforms);
memcpy(uniforms, submesh->MeshSurfaceUniforms.Data(), copysize);
size_t copysize = submesh->Mesh.Uniforms.Size() * sizeof(SurfaceUniforms);
memcpy(uniforms, submesh->Mesh.Uniforms.Data(), copysize);
if (copysize > 0)
cmdbuffer->copyBuffer(transferBuffer.get(), SurfaceUniformsBuffer.get(), datapos, cur.SurfaceUniformsOffset * sizeof(SurfaceUniforms), copysize);
cmdbuffer->copyBuffer(transferBuffer.get(), SurfaceUniformsBuffer.get(), datapos, cur.UniformsOffset * sizeof(SurfaceUniforms), copysize);
datapos += copysize;
}
@ -380,12 +380,12 @@ void VkRaytrace::UploadMeshes(bool dynamicOnly)
int VkRaytrace::GetMaxVertexBufferSize()
{
return Mesh->StaticMesh->MeshVertices.Size() + MaxDynamicVertices;
return Mesh->StaticMesh->Mesh.Vertices.Size() + MaxDynamicVertices;
}
int VkRaytrace::GetMaxIndexBufferSize()
{
return Mesh->StaticMesh->MeshElements.Size() + MaxDynamicIndexes;
return Mesh->StaticMesh->Mesh.Elements.Size() + MaxDynamicIndexes;
}
int VkRaytrace::GetMaxNodeBufferSize()
@ -398,14 +398,14 @@ int VkRaytrace::GetMaxSurfaceBufferSize()
return Mesh->StaticMesh->GetSurfaceCount() + MaxDynamicSurfaces;
}
int VkRaytrace::GetMaxSurfaceUniformsBufferSize()
int VkRaytrace::GetMaxUniformsBufferSize()
{
return Mesh->StaticMesh->MeshSurfaceUniforms.Size() + MaxDynamicSurfaceUniforms;
return Mesh->StaticMesh->Mesh.Uniforms.Size() + MaxDynamicUniforms;
}
int VkRaytrace::GetMaxSurfaceIndexBufferSize()
{
return Mesh->StaticMesh->MeshSurfaceIndexes.Size() + MaxDynamicSurfaceIndexes;
return Mesh->StaticMesh->Mesh.SurfaceIndexes.Size() + MaxDynamicSurfaceIndexes;
}
void VkRaytrace::CreateBuffers()
@ -462,7 +462,7 @@ void VkRaytrace::CreateBuffers()
SurfaceUniformsBuffer = BufferBuilder()
.Usage(VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT)
.Size(GetMaxSurfaceUniformsBufferSize() * sizeof(SurfaceUniforms))
.Size(GetMaxUniformsBufferSize() * sizeof(SurfaceUniforms))
.DebugName("SurfaceUniformsBuffer")
.Create(fb->GetDevice());
@ -489,7 +489,7 @@ VkRaytrace::BLAS VkRaytrace::CreateBLAS(LevelSubmesh* submesh, bool preferFastBu
accelStructBLDesc.geometry.triangles.vertexStride = sizeof(FFlatVertex);
accelStructBLDesc.geometry.triangles.indexType = VK_INDEX_TYPE_UINT32;
accelStructBLDesc.geometry.triangles.indexData.deviceAddress = IndexBuffer->GetDeviceAddress() + indexOffset * sizeof(uint32_t);
accelStructBLDesc.geometry.triangles.maxVertex = vertexOffset + submesh->MeshVertices.Size() - 1;
accelStructBLDesc.geometry.triangles.maxVertex = vertexOffset + submesh->Mesh.Vertices.Size() - 1;
buildInfo.type = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR;
buildInfo.flags = preferFastBuild ? VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR : VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR;
@ -497,7 +497,7 @@ VkRaytrace::BLAS VkRaytrace::CreateBLAS(LevelSubmesh* submesh, bool preferFastBu
buildInfo.geometryCount = 1;
buildInfo.ppGeometries = geometries;
uint32_t maxPrimitiveCount = submesh->MeshElements.Size() / 3;
uint32_t maxPrimitiveCount = submesh->Mesh.Elements.Size() / 3;
VkAccelerationStructureBuildSizesInfoKHR sizeInfo = { VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR };
vkGetAccelerationStructureBuildSizesKHR(fb->GetDevice()->device, VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR, &buildInfo, &maxPrimitiveCount, &sizeInfo);
@ -545,7 +545,7 @@ void VkRaytrace::CreateStaticBLAS()
void VkRaytrace::CreateDynamicBLAS()
{
DynamicBLAS = CreateBLAS(Mesh->DynamicMesh.get(), true, Mesh->StaticMesh->MeshVertices.Size(), Mesh->StaticMesh->MeshElements.Size());
DynamicBLAS = CreateBLAS(Mesh->DynamicMesh.get(), true, Mesh->StaticMesh->Mesh.Vertices.Size(), Mesh->StaticMesh->Mesh.Elements.Size());
}
void VkRaytrace::CreateTopLevelAS()
@ -657,7 +657,7 @@ void VkRaytrace::UpdateDynamicBLAS()
deletelist->Add(std::move(DynamicBLAS.AccelStructBuffer));
deletelist->Add(std::move(DynamicBLAS.AccelStruct));
DynamicBLAS = CreateBLAS(Mesh->DynamicMesh.get(), true, Mesh->StaticMesh->MeshVertices.Size(), Mesh->StaticMesh->MeshElements.Size());
DynamicBLAS = CreateBLAS(Mesh->DynamicMesh.get(), true, Mesh->StaticMesh->Mesh.Vertices.Size(), Mesh->StaticMesh->Mesh.Elements.Size());
}
void VkRaytrace::UpdateTopLevelAS()

8
src/common/rendering/vulkan/accelstructs/vk_raytrace.h
View file

@ -55,8 +55,8 @@ struct SubmeshBufferLocation
int SurfaceIndexSize = 0;
int SurfaceOffset = 0;
int SurfaceSize = 0;
int SurfaceUniformsOffset = 0;
int SurfaceUniformsSize = 0;
int UniformsOffset = 0;
int UniformsSize = 0;
};
class VkRaytrace
@ -103,7 +103,7 @@ private:
int GetMaxIndexBufferSize();
int GetMaxNodeBufferSize();
int GetMaxSurfaceBufferSize();
int GetMaxSurfaceUniformsBufferSize();
int GetMaxUniformsBufferSize();
int GetMaxSurfaceIndexBufferSize();
VulkanRenderDevice* fb = nullptr;
@ -127,7 +127,7 @@ private:
static const int MaxDynamicVertices = 100'000;
static const int MaxDynamicIndexes = 100'000;
static const int MaxDynamicSurfaces = 100'000;
static const int MaxDynamicSurfaceUniforms = 100'000;
static const int MaxDynamicUniforms = 100'000;
static const int MaxDynamicSurfaceIndexes = 25'000;
static const int MaxDynamicNodes = 10'000;

2
src/maploader/maploader.cpp
View file

@ -3350,7 +3350,7 @@ bool MapLoader::LoadLightmap(MapData* map)
{
auto& realSurface = *surface.targetSurface;
auto* vertices = &submesh->MeshVertices[realSurface.startVertIndex];
auto* vertices = &submesh->Mesh.Vertices[realSurface.startVertIndex];
auto* newUVs = &zdrayUvs[surface.uvOffset];
for (uint32_t i = 0; i < surface.uvCount; ++i)

16
src/rendering/hwrenderer/doom_levelmesh.cpp
View file

@ -253,17 +253,17 @@ void DoomLevelMesh::DumpMesh(const FString& objFilename, const FString& mtlFilen
auto f = fopen(objFilename.GetChars(), "w");
fprintf(f, "# DoomLevelMesh debug export\n");
fprintf(f, "# MeshVertices: %u, MeshElements: %u, Surfaces: %u\n", submesh->MeshVertices.Size(), submesh->MeshElements.Size(), submesh->Surfaces.Size());
fprintf(f, "# MeshVertices: %u, MeshElements: %u, Surfaces: %u\n", submesh->Mesh.Vertices.Size(), submesh->Mesh.Elements.Size(), submesh->Surfaces.Size());
fprintf(f, "mtllib %s\n", mtlFilename.GetChars());
double scale = 1 / 10.0;
for (const auto& v : submesh->MeshVertices)
for (const auto& v : submesh->Mesh.Vertices)
{
fprintf(f, "v %f %f %f\n", v.x * scale, v.y * scale, v.z * scale);
}
for (const auto& v : submesh->MeshVertices)
for (const auto& v : submesh->Mesh.Vertices)
{
fprintf(f, "vt %f %f\n", v.lu, v.lv);
}
@ -296,9 +296,9 @@ void DoomLevelMesh::DumpMesh(const FString& objFilename, const FString& mtlFilen
bool useErrorMaterial = false;
int highestUsedAtlasPage = -1;
for (unsigned i = 0, count = submesh->MeshElements.Size(); i + 2 < count; i += 3)
for (unsigned i = 0, count = submesh->Mesh.Elements.Size(); i + 2 < count; i += 3)
{
auto index = submesh->MeshSurfaceIndexes[i / 3];
auto index = submesh->Mesh.SurfaceIndexes[i / 3];
if (index != lastSurfaceIndex)
{
@ -326,9 +326,9 @@ void DoomLevelMesh::DumpMesh(const FString& objFilename, const FString& mtlFilen
// fprintf(f, "f %d %d %d\n", MeshElements[i] + 1, MeshElements[i + 1] + 1, MeshElements[i + 2] + 1);
fprintf(f, "f %d/%d %d/%d %d/%d\n",
submesh->MeshElements[i + 0] + 1, submesh->MeshElements[i + 0] + 1,
submesh->MeshElements[i + 1] + 1, submesh->MeshElements[i + 1] + 1,
submesh->MeshElements[i + 2] + 1, submesh->MeshElements[i + 2] + 1);
submesh->Mesh.Elements[i + 0] + 1, submesh->Mesh.Elements[i + 0] + 1,
submesh->Mesh.Elements[i + 1] + 1, submesh->Mesh.Elements[i + 1] + 1,
submesh->Mesh.Elements[i + 2] + 1, submesh->Mesh.Elements[i + 2] + 1);
}

100
src/rendering/hwrenderer/doom_levelsubmesh.cpp
View file

@ -66,12 +66,12 @@ void DoomLevelSubmesh::Reset()
{
Surfaces.Clear();
WallPortals.Clear();
MeshVertices.Clear();
MeshElements.Clear();
MeshSurfaceIndexes.Clear();
MeshUniformIndexes.Clear();
MeshSurfaceUniforms.Clear();
MeshSurfaceMaterials.Clear();
Mesh.Vertices.Clear();
Mesh.Elements.Clear();
Mesh.SurfaceIndexes.Clear();
Mesh.UniformIndexes.Clear();
Mesh.Uniforms.Clear();
Mesh.Materials.Clear();
}
void DoomLevelSubmesh::CreateStaticSurfaces(FLevelLocals& doomMap)
@ -134,31 +134,31 @@ void DoomLevelSubmesh::CreateStaticSurfaces(FLevelLocals& doomMap)
wallpart.DrawWall(&disp, state, false);
int pipelineID = 0;
int startVertIndex = MeshVertices.Size();
int startVertIndex = Mesh.Vertices.Size();
for (auto& it : state.mSortedLists)
{
const MeshApplyState& applyState = it.first;
pipelineID = screen->GetLevelMeshPipelineID(applyState.applyData, applyState.surfaceUniforms, applyState.material);
int uniformsIndex = MeshSurfaceUniforms.Size();
MeshSurfaceUniforms.Push(applyState.surfaceUniforms);
MeshSurfaceMaterials.Push(applyState.material);
int uniformsIndex = Mesh.Uniforms.Size();
Mesh.Uniforms.Push(applyState.surfaceUniforms);
Mesh.Materials.Push(applyState.material);
for (MeshDrawCommand& command : it.second.mDraws)
{
for (int i = command.Start, end = command.Start + command.Count; i < end; i++)
{
MeshVertices.Push(state.mVertices[i]);
MeshUniformIndexes.Push(uniformsIndex);
Mesh.Vertices.Push(state.mVertices[i]);
Mesh.UniformIndexes.Push(uniformsIndex);
}
}
for (MeshDrawCommand& command : it.second.mIndexedDraws)
{
for (int i = command.Start, end = command.Start + command.Count; i < end; i++)
{
MeshVertices.Push(state.mVertices[state.mIndexes[i]]);
MeshUniformIndexes.Push(uniformsIndex);
Mesh.Vertices.Push(state.mVertices[state.mIndexes[i]]);
Mesh.UniformIndexes.Push(uniformsIndex);
}
}
}
@ -176,8 +176,8 @@ void DoomLevelSubmesh::CreateStaticSurfaces(FLevelLocals& doomMap)
surf.sectorGroup = sectorGroup[front->Index()];
surf.alpha = float(side->linedef->alpha);
surf.startVertIndex = startVertIndex;
surf.numVerts = MeshVertices.Size() - startVertIndex;
surf.plane = ToPlane(MeshVertices[startVertIndex].fPos(), MeshVertices[startVertIndex + 1].fPos(), MeshVertices[startVertIndex + 2].fPos(), MeshVertices[startVertIndex + 3].fPos());
surf.numVerts = Mesh.Vertices.Size() - startVertIndex;
surf.plane = ToPlane(Mesh.Vertices[startVertIndex].fPos(), Mesh.Vertices[startVertIndex + 1].fPos(), Mesh.Vertices[startVertIndex + 2].fPos(), Mesh.Vertices[startVertIndex + 3].fPos());
surf.texture = wallpart.texture;
surf.PipelineID = pipelineID;
Surfaces.Push(surf);
@ -231,9 +231,9 @@ void DoomLevelSubmesh::CreateStaticSurfaces(FLevelLocals& doomMap)
const MeshApplyState& applyState = it.first;
pipelineID = screen->GetLevelMeshPipelineID(applyState.applyData, applyState.surfaceUniforms, applyState.material);
uniformsIndex = MeshSurfaceUniforms.Size();
MeshSurfaceUniforms.Push(applyState.surfaceUniforms);
MeshSurfaceMaterials.Push(applyState.material);
uniformsIndex = Mesh.Uniforms.Size();
Mesh.Uniforms.Push(applyState.surfaceUniforms);
Mesh.Materials.Push(applyState.material);
foundDraw = true;
break;
@ -260,7 +260,7 @@ void DoomLevelSubmesh::CreateStaticSurfaces(FLevelLocals& doomMap)
for (subsector_t* sub : section.subsectors)
{
int startVertIndex = MeshVertices.Size();
int startVertIndex = Mesh.Vertices.Size();
for (int i = 0, end = sub->numlines; i < end; i++)
{
@ -276,8 +276,8 @@ void DoomLevelSubmesh::CreateStaticSurfaces(FLevelLocals& doomMap)
ffv.lv = 0.0f;
ffv.lindex = -1.0f;
MeshVertices.Push(ffv);
MeshUniformIndexes.Push(uniformsIndex);
Mesh.Vertices.Push(ffv);
Mesh.UniformIndexes.Push(uniformsIndex);
}
surf.TypeIndex = sub->Index();
@ -330,16 +330,16 @@ void DoomLevelSubmesh::CreateIndexes()
{
LevelSubmeshDrawRange range;
range.PipelineID = it.first >> 32;
range.Start = MeshElements.Size();
range.Start = Mesh.Elements.Size();
for (unsigned int i : it.second)
{
DoomLevelMeshSurface& s = Surfaces[i];
int numVerts = s.numVerts;
unsigned int pos = s.startVertIndex;
FFlatVertex* verts = &MeshVertices[pos];
FFlatVertex* verts = &Mesh.Vertices[pos];
s.Vertices = verts;
s.startElementIndex = MeshElements.Size();
s.startElementIndex = Mesh.Elements.Size();
s.numElements = 0;
if (s.Type == ST_CEILING)
@ -348,10 +348,10 @@ void DoomLevelSubmesh::CreateIndexes()
{
if (!IsDegenerate(verts[0].fPos(), verts[j - 1].fPos(), verts[j].fPos()))
{
MeshElements.Push(pos);
MeshElements.Push(pos + j - 1);
MeshElements.Push(pos + j);
MeshSurfaceIndexes.Push((int)i);
Mesh.Elements.Push(pos);
Mesh.Elements.Push(pos + j - 1);
Mesh.Elements.Push(pos + j);
Mesh.SurfaceIndexes.Push((int)i);
s.numElements += 3;
}
}
@ -362,10 +362,10 @@ void DoomLevelSubmesh::CreateIndexes()
{
if (!IsDegenerate(verts[0].fPos(), verts[j - 1].fPos(), verts[j].fPos()))
{
MeshElements.Push(pos + j);
MeshElements.Push(pos + j - 1);
MeshElements.Push(pos);
MeshSurfaceIndexes.Push((int)i);
Mesh.Elements.Push(pos + j);
Mesh.Elements.Push(pos + j - 1);
Mesh.Elements.Push(pos);
Mesh.SurfaceIndexes.Push((int)i);
s.numElements += 3;
}
}
@ -374,23 +374,23 @@ void DoomLevelSubmesh::CreateIndexes()
{
if (!IsDegenerate(verts[0].fPos(), verts[2].fPos(), verts[1].fPos()))
{
MeshElements.Push(pos + 0);
MeshElements.Push(pos + 1);
MeshElements.Push(pos + 2);
MeshSurfaceIndexes.Push((int)i);
Mesh.Elements.Push(pos + 0);
Mesh.Elements.Push(pos + 1);
Mesh.Elements.Push(pos + 2);
Mesh.SurfaceIndexes.Push((int)i);
s.numElements += 3;
}
if (!IsDegenerate(verts[0].fPos(), verts[2].fPos(), verts[3].fPos()))
{
MeshElements.Push(pos + 0);
MeshElements.Push(pos + 2);
MeshElements.Push(pos + 3);
MeshSurfaceIndexes.Push((int)i);
Mesh.Elements.Push(pos + 0);
Mesh.Elements.Push(pos + 2);
Mesh.Elements.Push(pos + 3);
Mesh.SurfaceIndexes.Push((int)i);
s.numElements += 3;
}
}
}
range.Count = MeshElements.Size() - range.Start;
range.Count = Mesh.Elements.Size() - range.Start;
if ((it.first & 1) == 0)
DrawList.Push(range);
@ -683,7 +683,7 @@ void DoomLevelSubmesh::PackLightmapAtlas(int lightmapStartIndex)
// calculate final texture coordinates
for (int i = 0; i < (int)surf->numVerts; i++)
{
auto& vertex = MeshVertices[surf->startVertIndex + i];
auto& vertex = Mesh.Vertices[surf->startVertIndex + i];
vertex.lu = (vertex.lu + x) / (float)LMTextureSize;
vertex.lv = (vertex.lv + y) / (float)LMTextureSize;
vertex.lindex = (float)surf->AtlasTile.ArrayIndex;
@ -704,13 +704,13 @@ BBox DoomLevelSubmesh::GetBoundsFromSurface(const LevelMeshSurface& surface) con
{
for (int j = 0; j < 3; j++)
{
if (MeshVertices[i].fPos()[j] < low[j])
if (Mesh.Vertices[i].fPos()[j] < low[j])
{
low[j] = MeshVertices[i].fPos()[j];
low[j] = Mesh.Vertices[i].fPos()[j];
}
if (MeshVertices[i].fPos()[j] > hi[j])
if (Mesh.Vertices[i].fPos()[j] > hi[j])
{
hi[j] = MeshVertices[i].fPos()[j];
hi[j] = Mesh.Vertices[i].fPos()[j];
}
}
}
@ -824,10 +824,10 @@ void DoomLevelSubmesh::BuildSurfaceParams(int lightMapTextureWidth, int lightMap
for (int i = 0; i < surface.numVerts; i++)
{
FVector3 tDelta = MeshVertices[surface.startVertIndex + i].fPos() - surface.translateWorldToLocal;
FVector3 tDelta = Mesh.Vertices[surface.startVertIndex + i].fPos() - surface.translateWorldToLocal;
MeshVertices[surface.startVertIndex + i].lu = (tDelta | surface.projLocalToU);
MeshVertices[surface.startVertIndex + i].lv = (tDelta | surface.projLocalToV);
Mesh.Vertices[surface.startVertIndex + i].lu = (tDelta | surface.projLocalToU);
Mesh.Vertices[surface.startVertIndex + i].lv = (tDelta | surface.projLocalToV);
}
// project tCoords so they lie on the plane