From df9a04076e9f87cc4ba29dda31a03c67e4961d8a Mon Sep 17 00:00:00 2001 From: apistol78 Date: Fri, 16 Feb 2024 16:36:29 +0100 Subject: [PATCH] Traktor: **WIP** InstanceMesh being rewritten; using GPU culling and indirect draw. --- code/Mesh/Editor/IMeshConverter.h | 3 +- .../Editor/Instance/InstanceMeshConverter.cpp | 27 +- .../Editor/Instance/InstanceMeshConverter.h | 18 +- code/Mesh/Editor/MeshPipeline.cpp | 16 +- .../Editor/Skinned/SkinnedMeshConverter.cpp | 8 +- .../Editor/Skinned/SkinnedMeshConverter.h | 9 +- .../Editor/Static/StaticMeshConverter.cpp | 8 +- code/Mesh/Editor/Static/StaticMeshConverter.h | 9 +- code/Mesh/Instance/InstanceMesh.cpp | 302 +++++---- code/Mesh/Instance/InstanceMesh.h | 41 +- code/Mesh/Instance/InstanceMeshComponent.cpp | 11 +- code/Mesh/Instance/InstanceMeshComponent.h | 3 + .../InstanceMeshComponentRenderer.cpp | 40 +- .../Instance/InstanceMeshComponentRenderer.h | 3 +- code/Mesh/Instance/InstanceMeshResource.cpp | 26 +- code/Mesh/Instance/InstanceMeshResource.h | 1 - code/Render/Vulkan/RenderViewVk.cpp | 25 +- code/Render/Vulkan/RenderViewVk.h | 1 + code/Spray/MeshRenderer.cpp | 2 + code/Terrain/ForestComponent.cpp | 3 +- code/Terrain/RubbleComponent.cpp | 3 +- .../Mesh/Shaders/Instance/Cull/Cull.xdi | 614 ++++++++++++++++++ .../Mesh/Shaders/Instance/Cull/Cull.xdm | 6 + .../Mesh/Shaders/Instance/Cull/Draw.xdi | 207 ++++++ .../Mesh/Shaders/Instance/Cull/Draw.xdm | 6 + .../Shaders/Instance/UnpackInstanceData.xdi | 379 ++++++----- .../Source/System/Shaders/Modules/Frustum.xdi | 29 + .../Source/System/Shaders/Modules/Frustum.xdm | 6 + 28 files changed, 1380 insertions(+), 426 deletions(-) create mode 100644 data/Source/System/Mesh/Shaders/Instance/Cull/Cull.xdi create mode 100644 data/Source/System/Mesh/Shaders/Instance/Cull/Cull.xdm create mode 100644 data/Source/System/Mesh/Shaders/Instance/Cull/Draw.xdi create mode 100644 data/Source/System/Mesh/Shaders/Instance/Cull/Draw.xdm create mode 100644 data/Source/System/Shaders/Modules/Frustum.xdi create mode 100644 data/Source/System/Shaders/Modules/Frustum.xdm diff --git a/code/Mesh/Editor/IMeshConverter.h b/code/Mesh/Editor/IMeshConverter.h index 65b183be1b..9b785aa43b 100644 --- a/code/Mesh/Editor/IMeshConverter.h +++ b/code/Mesh/Editor/IMeshConverter.h @@ -1,6 +1,6 @@ /* * TRAKTOR - * Copyright (c) 2022 Anders Pistol. + * Copyright (c) 2022-2024 Anders Pistol. * * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this @@ -49,7 +49,6 @@ class IMeshConverter : public Object const Guid& materialGuid, const std::map< std::wstring, std::list< MeshMaterialTechnique > >& materialTechniqueMap, const AlignedVector< render::VertexElement >& vertexElements, - int32_t maxInstanceCount, MeshResource* meshResource, IStream* meshResourceStream ) const = 0; diff --git a/code/Mesh/Editor/Instance/InstanceMeshConverter.cpp b/code/Mesh/Editor/Instance/InstanceMeshConverter.cpp index 136d3953af..ca075aeb41 100644 --- a/code/Mesh/Editor/Instance/InstanceMeshConverter.cpp +++ b/code/Mesh/Editor/Instance/InstanceMeshConverter.cpp @@ -1,6 +1,6 @@ /* * TRAKTOR - * Copyright (c) 2022 Anders Pistol. + * Copyright (c) 2022-2024 Anders Pistol. * * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this @@ -11,6 +11,7 @@ #include "Core/Log/Log.h" #include "Core/Math/Half.h" #include "Core/Misc/String.h" +#include "Editor/IPipelineDepends.h" #include "Mesh/Editor/IndexRange.h" #include "Mesh/Editor/MeshVertexWriter.h" #include "Mesh/Editor/Instance/InstanceMeshConverter.h" @@ -27,11 +28,16 @@ #include "Render/Mesh/MeshWriter.h" #include "Render/Mesh/SystemMeshFactory.h" -namespace traktor +namespace traktor::mesh { - namespace mesh + namespace { +const Guid c_shaderInstanceMeshCull(L"{37998131-BDA1-DE45-B175-35B088FEE61C}"); +const Guid c_shaderInstanceMeshDraw(L"{A8FDE33C-D75B-4D4E-848F-7D7CF97F11D0}"); + + } + Ref< MeshResource > InstanceMeshConverter::createResource() const { return new InstanceMeshResource(); @@ -54,17 +60,10 @@ bool InstanceMeshConverter::convert( const Guid& materialGuid, const std::map< std::wstring, std::list< MeshMaterialTechnique > >& materialTechniqueMap, const AlignedVector< render::VertexElement >& vertexElements, - int32_t maxInstanceCount, MeshResource* meshResource, IStream* meshResourceStream ) const { - if (maxInstanceCount <= 0) - { - log::error << L"No per-instance parameter data, max instance count is zero." << Endl; - return false; - } - const model::Model* model = models[0]; T_FATAL_ASSERT(model != nullptr); @@ -213,10 +212,14 @@ bool InstanceMeshConverter::convert( checked_type_cast< InstanceMeshResource* >(meshResource)->m_haveRenderMesh = true; checked_type_cast< InstanceMeshResource* >(meshResource)->m_shader = resource::Id< render::Shader >(materialGuid); checked_type_cast< InstanceMeshResource* >(meshResource)->m_parts = parts; - checked_type_cast< InstanceMeshResource* >(meshResource)->m_maxInstanceCount = maxInstanceCount; return true; } - } +void InstanceMeshConverter::addDependencies(editor::IPipelineDepends* pipelineDepends) +{ + pipelineDepends->addDependency(c_shaderInstanceMeshCull, editor::PdfBuild); + pipelineDepends->addDependency(c_shaderInstanceMeshDraw, editor::PdfBuild); +} + } diff --git a/code/Mesh/Editor/Instance/InstanceMeshConverter.h b/code/Mesh/Editor/Instance/InstanceMeshConverter.h index dbca000ac1..35f7cb190d 100644 --- a/code/Mesh/Editor/Instance/InstanceMeshConverter.h +++ b/code/Mesh/Editor/Instance/InstanceMeshConverter.h @@ -1,6 +1,6 @@ /* * TRAKTOR - * Copyright (c) 2022 Anders Pistol. + * Copyright (c) 2022-2024 Anders Pistol. * * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this @@ -10,10 +10,15 @@ #include "Mesh/Editor/IMeshConverter.h" -namespace traktor +namespace traktor::editor +{ + +class IPipelineDepends; + +} + +namespace traktor::mesh { - namespace mesh - { class InstanceMeshConverter : public IMeshConverter { @@ -28,12 +33,11 @@ class InstanceMeshConverter : public IMeshConverter const Guid& materialGuid, const std::map< std::wstring, std::list< MeshMaterialTechnique > >& materialTechniqueMap, const AlignedVector< render::VertexElement >& vertexElements, - int32_t maxInstanceCount, MeshResource* meshResource, IStream* meshResourceStream ) const override final; + + static void addDependencies(editor::IPipelineDepends* pipelineDepends); }; - } } - diff --git a/code/Mesh/Editor/MeshPipeline.cpp b/code/Mesh/Editor/MeshPipeline.cpp index d882f4b2e4..88fdaade0c 100644 --- a/code/Mesh/Editor/MeshPipeline.cpp +++ b/code/Mesh/Editor/MeshPipeline.cpp @@ -1,6 +1,6 @@ /* * TRAKTOR - * Copyright (c) 2022-2023 Anders Pistol. + * Copyright (c) 2022-2024 Anders Pistol. * * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this @@ -145,7 +145,7 @@ bool buildEmbeddedTexture(editor::IPipelineBuilder* pipelineBuilder, model::Mate } -T_IMPLEMENT_RTTI_FACTORY_CLASS(L"traktor.mesh.MeshPipeline", 38, MeshPipeline, editor::IPipeline) +T_IMPLEMENT_RTTI_FACTORY_CLASS(L"traktor.mesh.MeshPipeline", 39, MeshPipeline, editor::IPipeline) MeshPipeline::MeshPipeline() : m_promoteHalf(false) @@ -230,6 +230,9 @@ bool MeshPipeline::buildDependencies( pipelineDepends->addDependency(it.second, editor::PdfBuild | editor::PdfResource); pipelineDepends->addDependency< render::ShaderGraph >(); + + // Add dependencies from mesh subsystems. + InstanceMeshConverter::addDependencies(pipelineDepends); return true; } @@ -449,7 +452,6 @@ bool MeshPipeline::buildOutput( const int32_t jointCount = models[0]->getJointCount(); const bool vertexColor = haveVertexColors(*models[0]); - int32_t maxInstanceCount = 0; for (const auto& materialPair : materials) { @@ -637,13 +639,6 @@ bool MeshPipeline::buildOutput( if (uniformJointCount * 2 != indexedUniform->getLength()) indexedUniform->setLength(uniformJointCount * 2); // Each bone is represented of a quaternion and a vector thus multiply by 2. } - else if (indexedUniform->getParameterName() == L"InstanceWorld") - { - // Determine how many instances we can use when rendering instanced meshed - // based on how many entries in uniform. - if (maxInstanceCount <= 0 || maxInstanceCount > indexedUniform->getLength() / 2) - maxInstanceCount = indexedUniform->getLength() / 2; // Length of uniform is twice of max number of instances. - } } } @@ -827,7 +822,6 @@ bool MeshPipeline::buildOutput( materialGuid, materialTechniqueMap, vertexElements, - maxInstanceCount, resource, stream )) diff --git a/code/Mesh/Editor/Skinned/SkinnedMeshConverter.cpp b/code/Mesh/Editor/Skinned/SkinnedMeshConverter.cpp index 0e66c4cb01..8e0ec47220 100644 --- a/code/Mesh/Editor/Skinned/SkinnedMeshConverter.cpp +++ b/code/Mesh/Editor/Skinned/SkinnedMeshConverter.cpp @@ -1,6 +1,6 @@ /* * TRAKTOR - * Copyright (c) 2022 Anders Pistol. + * Copyright (c) 2022-2024 Anders Pistol. * * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this @@ -27,10 +27,8 @@ #include "Render/Mesh/MeshWriter.h" #include "Render/Mesh/SystemMeshFactory.h" -namespace traktor +namespace traktor::mesh { - namespace mesh - { Ref< MeshResource > SkinnedMeshConverter::createResource() const { @@ -54,7 +52,6 @@ bool SkinnedMeshConverter::convert( const Guid& materialGuid, const std::map< std::wstring, std::list< MeshMaterialTechnique > >& materialTechniqueMap, const AlignedVector< render::VertexElement >& vertexElements, - int32_t maxInstanceCount, MeshResource* meshResource, IStream* meshResourceStream ) const @@ -264,5 +261,4 @@ bool SkinnedMeshConverter::convert( return true; } - } } diff --git a/code/Mesh/Editor/Skinned/SkinnedMeshConverter.h b/code/Mesh/Editor/Skinned/SkinnedMeshConverter.h index 81928c2299..588a095dc6 100644 --- a/code/Mesh/Editor/Skinned/SkinnedMeshConverter.h +++ b/code/Mesh/Editor/Skinned/SkinnedMeshConverter.h @@ -1,6 +1,6 @@ /* * TRAKTOR - * Copyright (c) 2022 Anders Pistol. + * Copyright (c) 2022-2024 Anders Pistol. * * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this @@ -10,10 +10,8 @@ #include "Mesh/Editor/IMeshConverter.h" -namespace traktor +namespace traktor::mesh { - namespace mesh - { class SkinnedMeshConverter : public IMeshConverter { @@ -28,12 +26,9 @@ class SkinnedMeshConverter : public IMeshConverter const Guid& materialGuid, const std::map< std::wstring, std::list< MeshMaterialTechnique > >& materialTechniqueMap, const AlignedVector< render::VertexElement >& vertexElements, - int32_t maxInstanceCount, MeshResource* meshResource, IStream* meshResourceStream ) const override final; }; - } } - diff --git a/code/Mesh/Editor/Static/StaticMeshConverter.cpp b/code/Mesh/Editor/Static/StaticMeshConverter.cpp index 0417dbfb6b..aa8345b7f5 100644 --- a/code/Mesh/Editor/Static/StaticMeshConverter.cpp +++ b/code/Mesh/Editor/Static/StaticMeshConverter.cpp @@ -1,6 +1,6 @@ /* * TRAKTOR - * Copyright (c) 2022 Anders Pistol. + * Copyright (c) 2022-2024 Anders Pistol. * * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this @@ -26,10 +26,8 @@ #include "Render/Mesh/MeshWriter.h" #include "Render/Mesh/SystemMeshFactory.h" -namespace traktor +namespace traktor::mesh { - namespace mesh - { Ref< MeshResource > StaticMeshConverter::createResource() const { @@ -54,7 +52,6 @@ bool StaticMeshConverter::convert( const Guid& materialGuid, const std::map< std::wstring, std::list< MeshMaterialTechnique > >& materialTechniqueMap, const AlignedVector< render::VertexElement >& vertexElements, - int32_t maxInstanceCount, MeshResource* meshResource, IStream* meshResourceStream ) const @@ -228,5 +225,4 @@ bool StaticMeshConverter::convert( return true; } - } } diff --git a/code/Mesh/Editor/Static/StaticMeshConverter.h b/code/Mesh/Editor/Static/StaticMeshConverter.h index 131a12b91c..65ff80e1c6 100644 --- a/code/Mesh/Editor/Static/StaticMeshConverter.h +++ b/code/Mesh/Editor/Static/StaticMeshConverter.h @@ -1,6 +1,6 @@ /* * TRAKTOR - * Copyright (c) 2022 Anders Pistol. + * Copyright (c) 2022-2024 Anders Pistol. * * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this @@ -10,10 +10,8 @@ #include "Mesh/Editor/IMeshConverter.h" -namespace traktor +namespace traktor::mesh { - namespace mesh - { class StaticMeshConverter : public IMeshConverter { @@ -28,12 +26,9 @@ class StaticMeshConverter : public IMeshConverter const Guid& materialGuid, const std::map< std::wstring, std::list< MeshMaterialTechnique > >& materialTechniqueMap, const AlignedVector< render::VertexElement >& vertexElements, - int32_t maxInstanceCount, MeshResource* meshResource, IStream* meshResourceStream ) const override final; }; - } } - diff --git a/code/Mesh/Instance/InstanceMesh.cpp b/code/Mesh/Instance/InstanceMesh.cpp index 06f3051604..68f6cdb8d2 100644 --- a/code/Mesh/Instance/InstanceMesh.cpp +++ b/code/Mesh/Instance/InstanceMesh.cpp @@ -1,6 +1,6 @@ /* * TRAKTOR - * Copyright (c) 2022 Anders Pistol. + * Copyright (c) 2022-2024 Anders Pistol. * * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this @@ -8,12 +8,15 @@ */ #include #include "Core/Log/Log.h" +#include "Core/Misc/SafeDestroy.h" #include "Mesh/Instance/InstanceMesh.h" #include "Render/Buffer.h" #include "Render/IProgram.h" +#include "Render/IRenderSystem.h" #include "Render/Context/RenderContext.h" #include "Render/Mesh/Mesh.h" #include "World/IWorldRenderPass.h" +#include "World/WorldRenderView.h" namespace traktor::mesh { @@ -23,10 +26,32 @@ namespace traktor::mesh render::Handle s_handleInstanceWorld(L"InstanceWorld"); render::Handle s_handleInstanceWorldLast(L"InstanceWorldLast"); +render::Handle s_handleBoundingBoxMin(L"InstanceMesh_BoundingBoxMin"); +render::Handle s_handleBoundingBoxMax(L"InstanceMesh_BoundingBoxMax"); +render::Handle s_handleView(L"InstanceMesh_View"); +render::Handle s_handleViewInverse(L"InstanceMesh_ViewInverse"); +render::Handle s_handleVisibility(L"InstanceMesh_Visibility"); +render::Handle s_handleCullFrustum(L"InstanceMesh_CullFrustum"); + +render::Handle s_handleDraw(L"InstanceMesh_Draw"); +render::Handle s_handleIndexCount(L"InstanceMesh_IndexCount"); +render::Handle s_handleFirstIndex(L"InstanceMesh_FirstIndex"); + } T_IMPLEMENT_RTTI_CLASS(L"traktor.mesh.InstanceMesh", InstanceMesh, IMesh) +InstanceMesh::InstanceMesh( + render::IRenderSystem* renderSystem, + const resource::Proxy< render::Shader >& shaderCull, + const resource::Proxy< render::Shader >& shaderDraw +) +: m_renderSystem(renderSystem) +, m_shaderCull(shaderCull) +, m_shaderDraw(shaderDraw) +{ +} + const Aabb3& InstanceMesh::getBoundingBox() const { return m_renderMesh->getBoundingBox(); @@ -45,170 +70,181 @@ void InstanceMesh::getTechniques(SmallSet< render::handle_t >& outHandles) const void InstanceMesh::build( render::RenderContext* renderContext, + const world::WorldRenderView& worldRenderView, const world::IWorldRenderPass& worldRenderPass, - AlignedVector< RenderInstance >& instanceWorld, render::ProgramParameters* extraParameters ) const { - InstanceMeshData T_ALIGN16 instanceBatch[MaxInstanceCount]; - InstanceMeshData T_ALIGN16 instanceLastBatch[MaxInstanceCount]; bool haveAlphaBlend = false; - if (instanceWorld.empty()) + if (m_instances.empty()) return; auto it = m_parts.find(worldRenderPass.getTechnique()); if (it == m_parts.end()) return; - // Sort instances by ascending distance; note we're sorting caller's vector. - std::sort(instanceWorld.begin(), instanceWorld.end(), [](const InstanceMesh::RenderInstance& d1, const InstanceMesh::RenderInstance& d2) { - return d1.distance < d2.distance; - }); - const auto& meshParts = m_renderMesh->getParts(); - // Render opaque parts front-to-back. - for (const auto& part : it->second) + // Lazy create the buffers. + if (!m_instanceBuffer) + { + m_instanceBuffer = m_renderSystem->createBuffer(render::BufferUsage::BuStructured, m_instances.size() * sizeof(InstanceMeshData), true); + m_visibilityBuffer = m_renderSystem->createBuffer(render::BufferUsage::BuStructured, m_instances.size() * sizeof(float), false); + + m_drawBuffers.resize(4); + for (uint32_t i = 0; i < 4; ++i) + m_drawBuffers[i] = m_renderSystem->createBuffer(render::BufferUsage::BuStructured | render::BufferUsage::BuIndirect, m_instances.size() * sizeof(render::IndexedIndirectDraw), false); + + m_instanceBufferDirty = true; + } + + // Update buffer is any instance has moved. + if (m_instanceBufferDirty) + { + auto ptr = (InstanceMeshData*)m_instanceBuffer->lock(); + for (const auto& instance : m_instances) + *ptr++ = packInstanceMeshData(instance->transform); + m_instanceBuffer->unlock(); + m_instanceBufferDirty = false; + } + + // Cull instances. + // #todo Compute blocks are executed before render pass, so for shadow map rendering all cascades + // are culled before being rendered. { + Vector4 cullFrustum[6]; + + const Frustum& cf = worldRenderView.getCullFrustum(); + for (int32_t i = 0; i < cf.planes.size(); ++i) + cullFrustum[i] = cf.planes[i].normal().xyz0() + Vector4(0.0f, 0.0f, 0.0f, cf.planes[i].distance()); + for (int32_t i = cf.planes.size(); i < 6; ++i) + cullFrustum[i] = Vector4::zero(); + + auto renderBlock = renderContext->allocNamed< render::ComputeRenderBlock >(L"InstanceMesh cull 1/2"); + + renderBlock->program = m_shaderCull->getProgram().program; + + renderBlock->programParams = renderContext->alloc< render::ProgramParameters >(); + renderBlock->programParams->beginParameters(renderContext); + renderBlock->programParams->setVectorParameter(s_handleBoundingBoxMin, m_renderMesh->getBoundingBox().mn); + renderBlock->programParams->setVectorParameter(s_handleBoundingBoxMax, m_renderMesh->getBoundingBox().mx); + renderBlock->programParams->setVectorArrayParameter(s_handleCullFrustum, cullFrustum, 6); + renderBlock->programParams->setMatrixParameter(s_handleView, worldRenderView.getView()); + renderBlock->programParams->setMatrixParameter(s_handleViewInverse, worldRenderView.getView().inverse()); + renderBlock->programParams->setBufferViewParameter(s_handleInstanceWorld, m_instanceBuffer->getBufferView()); + renderBlock->programParams->setBufferViewParameter(s_handleVisibility, m_visibilityBuffer->getBufferView()); + renderBlock->programParams->endParameters(renderContext); + + renderBlock->workSize[0] = m_instances.size(); + + renderContext->compute(renderBlock); + renderContext->compute< render::BarrierRenderBlock >(render::Stage::Compute, render::Stage::Compute); + } + + // Create draw buffers from visibility buffer. + for (uint32_t i = 0; i < it->second.size(); ++i) + { + const auto& part = it->second[i]; + auto permutation = worldRenderPass.getPermutation(m_shader); permutation.technique = part.shaderTechnique; auto sp = m_shader->getProgram(permutation); if (!sp) continue; - if ((sp.priority & (render::RenderPriority::AlphaBlend | render::RenderPriority::PostAlphaBlend)) != 0) - { - haveAlphaBlend = true; + const auto& primitives = meshParts[part.meshPart].primitives; + + auto renderBlock = renderContext->allocNamed< render::ComputeRenderBlock >(L"InstanceMesh cull 2/2"); + + renderBlock->program = m_shaderDraw->getProgram().program; + + renderBlock->programParams = renderContext->alloc< render::ProgramParameters >(); + renderBlock->programParams->beginParameters(renderContext); + renderBlock->programParams->setFloatParameter(s_handleIndexCount, primitives.getVertexCount() + 0.5f); + renderBlock->programParams->setFloatParameter(s_handleFirstIndex, primitives.offset + 0.5f); + renderBlock->programParams->setBufferViewParameter(s_handleVisibility, m_visibilityBuffer->getBufferView()); + renderBlock->programParams->setBufferViewParameter(s_handleDraw, m_drawBuffers[i]->getBufferView()); + renderBlock->programParams->endParameters(renderContext); + + renderBlock->workSize[0] = m_instances.size(); + + renderContext->compute(renderBlock); + } + + renderContext->compute< render::BarrierRenderBlock >(render::Stage::Compute, render::Stage::Vertex); + + // Add indirect draw for each mesh part. + for (uint32_t i = 0; i < it->second.size(); ++i) + { + const auto& part = it->second[i]; + + auto permutation = worldRenderPass.getPermutation(m_shader); + permutation.technique = part.shaderTechnique; + auto sp = m_shader->getProgram(permutation); + if (!sp) continue; - } - // Setup batch shared parameters. - render::ProgramParameters* batchParameters = renderContext->alloc< render::ProgramParameters >(); - batchParameters->beginParameters(renderContext); + auto renderBlock = renderContext->allocNamed< render::IndirectRenderBlock >(L"InstanceMesh draw"); + renderBlock->distance = 0.0f; + renderBlock->program = sp.program; + renderBlock->programParams = renderContext->alloc< render::ProgramParameters >(); + renderBlock->indexBuffer = m_renderMesh->getIndexBuffer()->getBufferView(); + renderBlock->indexType = m_renderMesh->getIndexType(); + renderBlock->vertexBuffer = m_renderMesh->getVertexBuffer()->getBufferView(); + renderBlock->vertexLayout = m_renderMesh->getVertexLayout(); + renderBlock->primitive = meshParts[part.meshPart].primitives.type; + renderBlock->drawBuffer = m_drawBuffers[i]->getBufferView(); + renderBlock->drawCount = m_instances.size(); + + renderBlock->programParams->beginParameters(renderContext); if (extraParameters) - batchParameters->attachParameters(extraParameters); + renderBlock->programParams->attachParameters(extraParameters); worldRenderPass.setProgramParameters( - batchParameters, + renderBlock->programParams, Transform::identity(), Transform::identity() ); - batchParameters->endParameters(renderContext); - - for (uint32_t batchOffset = 0; batchOffset < instanceWorld.size(); ) - { - const uint32_t batchCount = std::min< uint32_t >(uint32_t(instanceWorld.size()) - batchOffset, m_maxInstanceCount); - - for (uint32_t j = 0; j < batchCount; ++j) - { - instanceBatch[j] = instanceWorld[batchOffset + j].data; - instanceLastBatch[j] = instanceWorld[batchOffset + j].data0; - } - - auto renderBlock = renderContext->allocNamed< render::InstancingRenderBlock >(L"InstanceMesh opaque"); - renderBlock->distance = instanceWorld[batchOffset + batchCount - 1].distance; - renderBlock->program = sp.program; - renderBlock->programParams = renderContext->alloc< render::ProgramParameters >(); - renderBlock->indexBuffer = m_renderMesh->getIndexBuffer()->getBufferView(); - renderBlock->indexType = m_renderMesh->getIndexType(); - renderBlock->vertexBuffer = m_renderMesh->getVertexBuffer()->getBufferView(); - renderBlock->vertexLayout = m_renderMesh->getVertexLayout(); - renderBlock->primitives = meshParts[part.meshPart].primitives; - renderBlock->count = batchCount; - - renderBlock->programParams->beginParameters(renderContext); - renderBlock->programParams->attachParameters(batchParameters); - renderBlock->programParams->setVectorArrayParameter( - s_handleInstanceWorld, - reinterpret_cast< const Vector4* >(instanceBatch), - batchCount * sizeof(InstanceMeshData) / sizeof(Vector4) - ); - renderBlock->programParams->setVectorArrayParameter( - s_handleInstanceWorldLast, - reinterpret_cast< const Vector4* >(instanceLastBatch), - batchCount * sizeof(InstanceMeshData) / sizeof(Vector4) - ); - renderBlock->programParams->endParameters(renderContext); - - renderContext->draw(sp.priority, renderBlock); - - batchOffset += batchCount; - } - } - // Render alpha blend parts back-to-front. - if (haveAlphaBlend) - { - std::reverse(instanceWorld.begin(), instanceWorld.end()); - - for (const auto& part : it->second) - { - auto permutation = worldRenderPass.getPermutation(m_shader); - permutation.technique = part.shaderTechnique; - auto sp = m_shader->getProgram(permutation); - if (!sp) - continue; - - if ((sp.priority & (render::RenderPriority::AlphaBlend | render::RenderPriority::PostAlphaBlend)) == 0) - continue; - - // Setup batch shared parameters. - render::ProgramParameters* batchParameters = renderContext->alloc< render::ProgramParameters >(); - batchParameters->beginParameters(renderContext); - - if (extraParameters) - batchParameters->attachParameters(extraParameters); - - worldRenderPass.setProgramParameters( - batchParameters, - Transform::identity(), - Transform::identity() - ); - batchParameters->endParameters(renderContext); - - for (uint32_t batchOffset = 0; batchOffset < instanceWorld.size(); ) - { - const uint32_t batchCount = std::min< uint32_t >(uint32_t(instanceWorld.size()) - batchOffset, m_maxInstanceCount); - - for (uint32_t j = 0; j < batchCount; ++j) - { - instanceBatch[j] = instanceWorld[batchOffset + j].data; - instanceLastBatch[j] = instanceWorld[batchOffset + j].data0; - } - - auto renderBlock = renderContext->allocNamed< render::InstancingRenderBlock >(L"InstanceMesh blend"); - renderBlock->distance = instanceWorld[batchOffset + batchCount - 1].distance; - renderBlock->program = sp.program; - renderBlock->programParams = renderContext->alloc< render::ProgramParameters >(); - renderBlock->indexBuffer = m_renderMesh->getIndexBuffer()->getBufferView(); - renderBlock->indexType = m_renderMesh->getIndexType(); - renderBlock->vertexBuffer = m_renderMesh->getVertexBuffer()->getBufferView(); - renderBlock->vertexLayout = m_renderMesh->getVertexLayout(); - renderBlock->primitives = meshParts[part.meshPart].primitives; - renderBlock->count = batchCount; - - renderBlock->programParams->beginParameters(renderContext); - renderBlock->programParams->attachParameters(batchParameters); - renderBlock->programParams->setVectorArrayParameter( - s_handleInstanceWorld, - reinterpret_cast< const Vector4* >(instanceBatch), - batchCount * sizeof(InstanceMeshData) / sizeof(Vector4) - ); - renderBlock->programParams->setVectorArrayParameter( - s_handleInstanceWorldLast, - reinterpret_cast< const Vector4* >(instanceLastBatch), - batchCount * sizeof(InstanceMeshData) / sizeof(Vector4) - ); - renderBlock->programParams->endParameters(renderContext); - - renderContext->draw(sp.priority, renderBlock); - - batchOffset += batchCount; - } - } + // #todo Same world buffer + renderBlock->programParams->setBufferViewParameter(s_handleInstanceWorld, m_instanceBuffer->getBufferView()); + renderBlock->programParams->setBufferViewParameter(s_handleInstanceWorldLast, m_instanceBuffer->getBufferView()); + renderBlock->programParams->endParameters(renderContext); + + renderContext->draw(sp.priority, renderBlock); } } +InstanceMesh::Instance* InstanceMesh::allocateInstance() +{ + Instance* instance = new Instance(); + instance->mesh = this; + instance->transform = Transform::identity(); + + m_instances.push_back(instance); + + safeDestroy(m_instanceBuffer); + + return instance; +} + +void InstanceMesh::releaseInstance(Instance* instance) +{ + T_FATAL_ASSERT(instance->mesh == this); + + auto it = std::find(m_instances.begin(), m_instances.end(), instance); + m_instances.erase(it); + delete instance; + + safeDestroy(m_instanceBuffer); +} + +void InstanceMesh::Instance::setTransform(const Transform& transform) +{ + this->mesh->m_instanceBufferDirty = true; + this->transform = transform; +} + } diff --git a/code/Mesh/Instance/InstanceMesh.h b/code/Mesh/Instance/InstanceMesh.h index 72e0eb1c4f..b355098c78 100644 --- a/code/Mesh/Instance/InstanceMesh.h +++ b/code/Mesh/Instance/InstanceMesh.h @@ -1,6 +1,6 @@ /* * TRAKTOR - * Copyright (c) 2022 Anders Pistol. + * Copyright (c) 2022-2024 Anders Pistol. * * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this @@ -8,6 +8,7 @@ */ #pragma once +#include "Core/RefArray.h" #include "Core/Containers/SmallMap.h" #include "Core/Containers/SmallSet.h" #include "Core/Math/Aabb3.h" @@ -29,6 +30,8 @@ namespace traktor::render { +class Buffer; +class IRenderSystem; class ProgramParameters; class RenderContext; class Mesh; @@ -41,6 +44,7 @@ namespace traktor::world class IWorldCulling; class IWorldRenderPass; +class WorldRenderView; } @@ -83,6 +87,12 @@ class T_DLLCLASS InstanceMesh : public IMesh } }; + explicit InstanceMesh( + render::IRenderSystem* renderSystem, + const resource::Proxy< render::Shader >& shaderCull, + const resource::Proxy< render::Shader >& shaderDraw + ); + const Aabb3& getBoundingBox() const; bool supportTechnique(render::handle_t technique) const; @@ -91,18 +101,43 @@ class T_DLLCLASS InstanceMesh : public IMesh void build( render::RenderContext* renderContext, + const world::WorldRenderView& worldRenderView, const world::IWorldRenderPass& worldRenderPass, - AlignedVector< RenderInstance >& instanceWorld, render::ProgramParameters* extraParameters ) const; + // + + struct Instance + { + InstanceMesh* mesh; + Transform transform; + + void setTransform(const Transform& transform); + }; + + Instance* allocateInstance(); + + void releaseInstance(Instance* instance); + + // + private: friend class InstanceMeshResource; resource::Proxy< render::Shader > m_shader; Ref< render::Mesh > m_renderMesh; SmallMap< render::handle_t, AlignedVector< Part > > m_parts; - int32_t m_maxInstanceCount = 0; + + //#todo All instances are bookkeep;ed in InstanceMesh which should be a resource. + Ref< render::IRenderSystem > m_renderSystem; + resource::Proxy< render::Shader > m_shaderCull; + resource::Proxy< render::Shader > m_shaderDraw; + AlignedVector< Instance* > m_instances; + mutable Ref< render::Buffer > m_instanceBuffer; + mutable Ref< render::Buffer > m_visibilityBuffer; + mutable RefArray< render::Buffer > m_drawBuffers; + mutable bool m_instanceBufferDirty = false; }; } diff --git a/code/Mesh/Instance/InstanceMeshComponent.cpp b/code/Mesh/Instance/InstanceMeshComponent.cpp index 8d4dc5f862..d1cdf02bf3 100644 --- a/code/Mesh/Instance/InstanceMeshComponent.cpp +++ b/code/Mesh/Instance/InstanceMeshComponent.cpp @@ -1,6 +1,6 @@ /* * TRAKTOR - * Copyright (c) 2022 Anders Pistol. + * Copyright (c) 2022-2024 Anders Pistol. * * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this @@ -20,14 +20,23 @@ T_IMPLEMENT_RTTI_CLASS(L"traktor.mesh.InstanceMeshComponent", InstanceMeshCompon InstanceMeshComponent::InstanceMeshComponent(const resource::Proxy< InstanceMesh >& mesh) : m_mesh(mesh) { + m_meshInstance = m_mesh->allocateInstance(); } void InstanceMeshComponent::destroy() { + m_mesh->releaseInstance(m_meshInstance); m_mesh.clear(); MeshComponent::destroy(); } +void InstanceMeshComponent::setTransform(const Transform& transform) +{ + MeshComponent::setTransform(transform); + + m_meshInstance->setTransform(transform); +} + Aabb3 InstanceMeshComponent::getBoundingBox() const { return m_mesh->getBoundingBox(); diff --git a/code/Mesh/Instance/InstanceMeshComponent.h b/code/Mesh/Instance/InstanceMeshComponent.h index 8542cb0716..b8445c2f82 100644 --- a/code/Mesh/Instance/InstanceMeshComponent.h +++ b/code/Mesh/Instance/InstanceMeshComponent.h @@ -36,6 +36,8 @@ class T_DLLCLASS InstanceMeshComponent : public MeshComponent virtual void destroy() override final; + virtual void setTransform(const Transform& transform) override; + virtual Aabb3 getBoundingBox() const override final; virtual void build(const world::WorldBuildContext& context, const world::WorldRenderView& worldRenderView, const world::IWorldRenderPass& worldRenderPass) override final; @@ -44,6 +46,7 @@ class T_DLLCLASS InstanceMeshComponent : public MeshComponent private: resource::Proxy< InstanceMesh > m_mesh; + InstanceMesh::Instance* m_meshInstance = nullptr; }; } diff --git a/code/Mesh/Instance/InstanceMeshComponentRenderer.cpp b/code/Mesh/Instance/InstanceMeshComponentRenderer.cpp index 80714367f2..99eb8cc06e 100644 --- a/code/Mesh/Instance/InstanceMeshComponentRenderer.cpp +++ b/code/Mesh/Instance/InstanceMeshComponentRenderer.cpp @@ -53,34 +53,14 @@ void InstanceMeshComponentRenderer::build( auto meshComponent = static_cast< InstanceMeshComponent* >(renderable); auto mesh = meshComponent->getMesh(); - if (!mesh->supportTechnique(worldRenderPass.getTechnique())) + //#todo Doesn't support velocity yet. + if (worldRenderPass.getTechnique() == s_techniqueVelocityWrite) return; - const Aabb3 boundingBox = meshComponent->getBoundingBox(); - const Transform transform = meshComponent->getTransform().get(worldRenderView.getInterval()); - - float distance = 0.0f; - if (!worldRenderView.isBoxVisible( - boundingBox, - transform, - distance - )) + if (!mesh->supportTechnique(worldRenderPass.getTechnique())) return; - const Transform transformLast = meshComponent->getTransform().get(worldRenderView.getInterval() - 1.0f); - - // Skip rendering velocities if mesh hasn't moved since last frame. - if (worldRenderPass.getTechnique() == s_techniqueVelocityWrite) - { - if (transform == transformLast) - return; - } - - m_meshInstances[mesh].push_back(InstanceMesh::RenderInstance( - packInstanceMeshData(transform), - packInstanceMeshData(transformLast), - distance - )); + m_meshes.insert(mesh); } void InstanceMeshComponentRenderer::build( @@ -89,20 +69,16 @@ void InstanceMeshComponentRenderer::build( const world::IWorldRenderPass& worldRenderPass ) { - for (auto& it : m_meshInstances) + for (auto& it : m_meshes) { - if (it.second.empty()) - continue; - - it.first->build( + it->build( context.getRenderContext(), + worldRenderView, worldRenderPass, - it.second, nullptr ); - - it.second.resize(0); } + m_meshes.reset(); } } diff --git a/code/Mesh/Instance/InstanceMeshComponentRenderer.h b/code/Mesh/Instance/InstanceMeshComponentRenderer.h index 89d6bbbd2e..16d57f5872 100644 --- a/code/Mesh/Instance/InstanceMeshComponentRenderer.h +++ b/code/Mesh/Instance/InstanceMeshComponentRenderer.h @@ -58,7 +58,8 @@ class T_DLLCLASS InstanceMeshComponentRenderer : public world::IEntityRenderer ) override final; private: - SmallMap< InstanceMesh*, AlignedVector< InstanceMesh::RenderInstance > > m_meshInstances; + //SmallMap< InstanceMesh*, AlignedVector< InstanceMesh::RenderInstance > > m_meshInstances; + SmallSet< InstanceMesh* > m_meshes; }; } diff --git a/code/Mesh/Instance/InstanceMeshResource.cpp b/code/Mesh/Instance/InstanceMeshResource.cpp index 628bda4479..99802f0647 100644 --- a/code/Mesh/Instance/InstanceMeshResource.cpp +++ b/code/Mesh/Instance/InstanceMeshResource.cpp @@ -1,6 +1,6 @@ /* * TRAKTOR - * Copyright (c) 2022 Anders Pistol. + * Copyright (c) 2022-2024 Anders Pistol. * * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this @@ -13,7 +13,6 @@ #include "Core/Serialization/MemberStl.h" #include "Mesh/Instance/InstanceMesh.h" #include "Mesh/Instance/InstanceMeshResource.h" -#include "Render/Buffer.h" #include "Render/Mesh/Mesh.h" #include "Render/Mesh/MeshReader.h" #include "Render/Mesh/SystemMeshFactory.h" @@ -22,8 +21,15 @@ namespace traktor::mesh { + namespace + { + +const resource::Id< render::Shader > c_shaderInstanceMeshCull(L"{37998131-BDA1-DE45-B175-35B088FEE61C}"); +const resource::Id< render::Shader > c_shaderInstanceMeshDraw(L"{A8FDE33C-D75B-4D4E-848F-7D7CF97F11D0}"); + + } -T_IMPLEMENT_RTTI_FACTORY_CLASS(L"traktor.mesh.InstanceMeshResource", 7, InstanceMeshResource, MeshResource) +T_IMPLEMENT_RTTI_FACTORY_CLASS(L"traktor.mesh.InstanceMeshResource", 8, InstanceMeshResource, MeshResource) Ref< IMesh > InstanceMeshResource::createMesh( const std::wstring& name, @@ -45,7 +51,15 @@ Ref< IMesh > InstanceMeshResource::createMesh( } } - Ref< InstanceMesh > instanceMesh = new InstanceMesh(); + resource::Proxy< render::Shader > shaderCull; + if (!resourceManager->bind(c_shaderInstanceMeshCull, shaderCull)) + return nullptr; + + resource::Proxy< render::Shader > shaderDraw; + if (!resourceManager->bind(c_shaderInstanceMeshDraw, shaderDraw)) + return nullptr; + + Ref< InstanceMesh > instanceMesh = new InstanceMesh(renderSystem, shaderCull, shaderDraw); if (!resourceManager->bind(m_shader, instanceMesh->m_shader)) return nullptr; @@ -66,13 +80,12 @@ Ref< IMesh > InstanceMeshResource::createMesh( } } - instanceMesh->m_maxInstanceCount = std::min< int32_t >(m_maxInstanceCount, InstanceMesh::MaxInstanceCount); return instanceMesh; } void InstanceMeshResource::serialize(ISerializer& s) { - T_ASSERT_M(s.getVersion() >= 7, L"Incorrect version"); + T_ASSERT_M(s.getVersion() >= 8, L"Incorrect version"); MeshResource::serialize(s); @@ -84,7 +97,6 @@ void InstanceMeshResource::serialize(ISerializer& s) Member< std::wstring >, MemberStlList< Part, MemberComposite< Part > > >(L"parts", m_parts); - s >> Member< int32_t >(L"maxInstanceCount", m_maxInstanceCount); } void InstanceMeshResource::Part::serialize(ISerializer& s) diff --git a/code/Mesh/Instance/InstanceMeshResource.h b/code/Mesh/Instance/InstanceMeshResource.h index f98b6e85cd..510d842d95 100644 --- a/code/Mesh/Instance/InstanceMeshResource.h +++ b/code/Mesh/Instance/InstanceMeshResource.h @@ -65,7 +65,6 @@ class T_DLLCLASS InstanceMeshResource : public MeshResource bool m_haveRenderMesh = false; resource::Id< render::Shader > m_shader; std::map< std::wstring, parts_t > m_parts; - int32_t m_maxInstanceCount = 0; }; } diff --git a/code/Render/Vulkan/RenderViewVk.cpp b/code/Render/Vulkan/RenderViewVk.cpp index b6aaec3419..1c70ad9159 100644 --- a/code/Render/Vulkan/RenderViewVk.cpp +++ b/code/Render/Vulkan/RenderViewVk.cpp @@ -1047,8 +1047,8 @@ void RenderViewVk::barrier(Stage from, Stage to) const auto& frame = m_frames[m_currentImageIndex]; vkCmdPipelineBarrier( *frame.graphicsCommandBuffer, - convertStage(from), // VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, - convertStage(to), // VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, + convertStage(from), + convertStage(to), 0, 0, nullptr, 0, nullptr, @@ -1218,12 +1218,19 @@ void RenderViewVk::pushMarker(const std::wstring& marker) if (m_haveDebugMarkers) { auto& frame = m_frames[m_currentImageIndex]; - frame.markers.push_back(wstombs(marker)); + if (!marker.empty()) + { + frame.markers.push_back(wstombs(marker)); + + VkDebugUtilsLabelEXT dul = {}; + dul.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT; + dul.pLabelName = frame.markers.back().c_str(); + vkCmdBeginDebugUtilsLabelEXT(*frame.graphicsCommandBuffer, &dul); - VkDebugUtilsLabelEXT dul = {}; - dul.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT; - dul.pLabelName = frame.markers.back().c_str(); - vkCmdBeginDebugUtilsLabelEXT(*frame.graphicsCommandBuffer, &dul); + frame.markerStack.push_back(true); + } + else + frame.markerStack.push_back(false); } #endif } @@ -1234,7 +1241,9 @@ void RenderViewVk::popMarker() if (m_haveDebugMarkers) { auto& frame = m_frames[m_currentImageIndex]; - vkCmdEndDebugUtilsLabelEXT(*frame.graphicsCommandBuffer); + if (frame.markerStack.back()) + vkCmdEndDebugUtilsLabelEXT(*frame.graphicsCommandBuffer); + frame.markerStack.pop_back(); } #endif } diff --git a/code/Render/Vulkan/RenderViewVk.h b/code/Render/Vulkan/RenderViewVk.h index bab9fb3a48..a464f74e3f 100644 --- a/code/Render/Vulkan/RenderViewVk.h +++ b/code/Render/Vulkan/RenderViewVk.h @@ -140,6 +140,7 @@ class RenderViewVk BufferViewVk boundVertexBuffer; std::list< std::string > markers; + AlignedVector< bool > markerStack; }; struct PipelineEntry diff --git a/code/Spray/MeshRenderer.cpp b/code/Spray/MeshRenderer.cpp index ccca239e13..b0ff7774e2 100644 --- a/code/Spray/MeshRenderer.cpp +++ b/code/Spray/MeshRenderer.cpp @@ -43,6 +43,7 @@ void MeshRenderer::flush( const world::IWorldRenderPass& worldRenderPass ) { +/* for (SmallMap< Ref< mesh::InstanceMesh >, std::pair< pointVector_t, bool > >::iterator i = m_meshes.begin(); i != m_meshes.end(); ++i) { if (i->second.first.empty()) @@ -79,6 +80,7 @@ void MeshRenderer::flush( i->second.first.resize(0); } +*/ } } diff --git a/code/Terrain/ForestComponent.cpp b/code/Terrain/ForestComponent.cpp index 0caafc2307..f6b30f299e 100644 --- a/code/Terrain/ForestComponent.cpp +++ b/code/Terrain/ForestComponent.cpp @@ -165,7 +165,7 @@ void ForestComponent::build( extraParameters->setVectorParameter(s_handleTerrain_WorldExtent, terrain->getHeightfield()->getWorldExtent()); extraParameters->setVectorParameter(s_handleForest_Eye, eye); extraParameters->endParameters(renderContext); - +/* if (worldRenderPass.getTechnique() != s_techniqueShadowWrite) { for (uint32_t i = 0; i < m_lod2Indices.size(); ) @@ -254,6 +254,7 @@ void ForestComponent::build( ); } } +*/ } void ForestComponent::updatePatches() diff --git a/code/Terrain/RubbleComponent.cpp b/code/Terrain/RubbleComponent.cpp index 238efb56fa..7e97f5db0b 100644 --- a/code/Terrain/RubbleComponent.cpp +++ b/code/Terrain/RubbleComponent.cpp @@ -189,7 +189,7 @@ void RubbleComponent::build( extraParameters->setVectorParameter(s_handleRubble_Eye, eye); extraParameters->setFloatParameter(s_handleRubble_MaxDistance, m_data.m_spreadDistance + m_clusterSize); extraParameters->endParameters(renderContext); - +/* for (const auto& cluster : m_clusters) { if (!cluster.visible) @@ -217,6 +217,7 @@ void RubbleComponent::build( ); } } +*/ } void RubbleComponent::updatePatches() diff --git a/data/Source/System/Mesh/Shaders/Instance/Cull/Cull.xdi b/data/Source/System/Mesh/Shaders/Instance/Cull/Cull.xdi new file mode 100644 index 0000000000..1b95a68cad --- /dev/null +++ b/data/Source/System/Mesh/Shaders/Instance/Cull/Cull.xdi @@ -0,0 +1,614 @@ + + + + + {4BAA3A0D-D779-C141-B519-197EEA8640D6} + + + 19 + 103 + + Global + + + {B63DBBD3-72C0-C645-8A24-4893BBF22E30} + + + 248 + 112 + + x + + + {A4DC3ED3-6068-054F-9623-163C10D79FD1} + + + 440 + 36 + + + rotation + translationAndScale + + + + {7E76A642-57F5-1F4D-90C1-E578206B7057} + + + 109 + 20 + + InstanceWorld + + + rotation + DtFloat4 + + + translationAndScale + DtFloat4 + + + + + {FB4B169C-944B-E049-927D-F60F28080923} + + + 733 + 120 + + w + + + {91EC5EF9-EBF6-8546-A91A-4550CAEB6CDE} + + + 733 + 47 + + xyz + + + {91A1C374-33C8-6F4C-B0E5-0D7C530C3452} + + + 318 + 394 + + InstanceMesh_View + Matrix + Frame + + + {012016E9-7DB1-D849-AF8D-3641CE8D9C6C} + + + 269 + 306 + + InstanceMesh_BoundingBoxMin + Vector + Frame + + + {0A7FA3F8-E334-3247-8BFD-E2CD797A56DF} + + + 271 + 346 + + InstanceMesh_BoundingBoxMax + Vector + Frame + + + {A12CD3AB-ABC5-BE47-882A-206186C7504A} + + + 723 + 341 + + Frustum + + + 1 + 1 + 1 + + + {45D674A1-6AC4-6B4E-B7CB-DC7F9C2EC215} + + + + {33456A85-8F14-3C42-AB81-C4A420295395} + Bbmn + + + {81D145C3-26D6-1D41-BA2D-A7787763BF44} + Bbmx + + + {FCE979D2-93DF-EB41-A77E-8ED2EA00ED32} + Translation + + + {FCA0A9DD-854C-A84B-8EA1-027FB3FBBA4A} + View + + + {A7438956-AAFD-EB40-ADC9-B21E773A81CD} + F0 + + + {EF9F0E0B-30EE-9341-8696-74923053C1C6} + F1 + + + {91A52BE7-C53B-8644-9F86-D1ED5D6D952C} + F2 + + + {B3C725BD-B91B-1D43-9A87-FAFE0D6929E3} + F3 + + + {68077A0E-EA55-FB4A-B2ED-E339F1DD8C75} + F4 + + + {25AC5CD8-5141-7542-A755-2D275FEC2137} + F5 + + + + + {C2E0B588-DBCB-F04B-9978-8C1B6593F31A} + Output + Scalar + + + + + + {861D7610-0664-6C4B-A21F-0D64852C2041} + + + 1209 + 249 + + WriteOut + Default + + 1 + 1 + 1 + + + + + {AF60E34F-9E23-4E4B-8874-3FCB33F46C2F} + Buffer + + + {13DDFE53-988C-FE40-B343-7FE23D25E253} + Index + + + {89D6EAF6-DAAD-C647-B640-7F86B233A509} + Input + + + + + + + {32AF829B-BE26-9242-99ED-1189D698205D} + + + 923 + 257 + + InstanceMesh_Visibility + + + visible + DtFloat1 + + + + + {91A8C6C3-38AF-0E49-9137-BEB73CB41DD4} + + + 314 + 540 + + InstanceMesh_CullFrustum + Vector + Frame + 6 + + + {8A540FB9-FC14-2145-9FE1-D6012392EA5A} + + + 146 + 559 + + 0 + + + {E69E3582-F7C5-C942-B7E8-2E8B15C86F02} + + + 317 + 621 + + InstanceMesh_CullFrustum + Vector + Frame + 6 + + + {3CB5F1E8-F997-2248-B431-13C91B1D4269} + + + 149 + 640 + + 1 + + + {A8ACFC3B-DADE-9747-B3A8-92BC9979A3D5} + + + 152 + 723 + + 2 + + + {3BC101A4-B0DB-CF4C-9FBC-E5C149087884} + + + 320 + 704 + + InstanceMesh_CullFrustum + Vector + Frame + 6 + + + {6217607E-D6AB-9F41-BF63-2953F9B27ED2} + + + 159 + 972 + + 5 + + + {95DA8639-D579-DC47-B9B0-5A0CE8240FAC} + + + 156 + 889 + + 4 + + + {BCD4E4FF-4F86-DD4D-8D33-389A6654E31F} + + + 321 + 789 + + InstanceMesh_CullFrustum + Vector + Frame + 6 + + + {D8271D7F-BBF1-5543-B102-9AA7ACD960FE} + + + 153 + 808 + + 3 + + + {E25F4C8F-D947-AC43-871A-0BF42773597C} + + + 324 + 870 + + InstanceMesh_CullFrustum + Vector + Frame + 6 + + + {83194908-DB49-4747-968D-A35FF36BD97C} + + + 327 + 953 + + InstanceMesh_CullFrustum + Vector + Frame + 6 + + + + + + + {AAE82FD3-522F-43C6-A594-2E13D126E5DB} + + + + {F2E22CA6-DFF3-4B20-A70A-0D7A44EACD8C} + + + + + + {ACC77B35-91B5-4405-ABC8-D0DA24D68178} + + + + {0FF6511C-0293-41A8-830E-81978BD01F7F} + + + + + + {ADB4FC1D-3726-4CC5-B4D5-1E2468274325} + + + + {0FF6511C-0293-41A8-840E-81978BD01F7F} + + + + + + {0FF6511C-0293-41A8-860E-81978BD01F7F} + + + + {F2E22CA6-DFF3-4B20-A70A-0D7A44EACD8C} + + + + + + {0FF6511C-0293-41A8-860E-81978BD01F7F} + + + + {F2E22CA6-DFF3-4B20-A70A-0D7A44EACD8C} + + + + + + {ADB4FC1D-3726-4CC5-B4D5-1E2468274325} + + + + {FCE979D2-93DF-EB41-A77E-8ED2EA00ED32} + + + + + + {1E6639B6-8B58-4694-99E7-C058E3583522} + + + + {FCA0A9DD-854C-A84B-8EA1-027FB3FBBA4A} + + + + + + {1E6639B6-8B58-4694-99E7-C058E3583522} + + + + {33456A85-8F14-3C42-AB81-C4A420295395} + + + + + + {1E6639B6-8B58-4694-99E7-C058E3583522} + + + + {81D145C3-26D6-1D41-BA2D-A7787763BF44} + + + + + + {ACC77B35-91B5-4405-ABC8-D0DA24D68178} + + + + {AF60E34F-9E23-4E4B-8874-3FCB33F46C2F} + + + + + + {ADB4FC1D-3726-4CC5-B4D5-1E2468274325} + + + + {13DDFE53-988C-FE40-B343-7FE23D25E253} + + + + + + {C2E0B588-DBCB-F04B-9978-8C1B6593F31A} + + + + {89D6EAF6-DAAD-C647-B640-7F86B233A509} + + + + + + {D33F8931-C90C-4EBA-8A04-A31D3E08FAB7} + + + + {E457DE92-8BE5-4385-9AD3-3903238A8FD9} + + + + + + {D33F8931-C90C-4EBA-8A04-A31D3E08FAB7} + + + + {E457DE92-8BE5-4385-9AD3-3903238A8FD9} + + + + + + {D33F8931-C90C-4EBA-8A04-A31D3E08FAB7} + + + + {E457DE92-8BE5-4385-9AD3-3903238A8FD9} + + + + + + {D33F8931-C90C-4EBA-8A04-A31D3E08FAB7} + + + + {E457DE92-8BE5-4385-9AD3-3903238A8FD9} + + + + + + {D33F8931-C90C-4EBA-8A04-A31D3E08FAB7} + + + + {E457DE92-8BE5-4385-9AD3-3903238A8FD9} + + + + + + {D33F8931-C90C-4EBA-8A04-A31D3E08FAB7} + + + + {E457DE92-8BE5-4385-9AD3-3903238A8FD9} + + + + + + {410A240E-17E1-40F0-82FE-BB8ECD086DCA} + + + + {A7438956-AAFD-EB40-ADC9-B21E773A81CD} + + + + + + {410A240E-17E1-40F0-82FE-BB8ECD086DCA} + + + + {EF9F0E0B-30EE-9341-8696-74923053C1C6} + + + + + + {410A240E-17E1-40F0-82FE-BB8ECD086DCA} + + + + {91A52BE7-C53B-8644-9F86-D1ED5D6D952C} + + + + + + {410A240E-17E1-40F0-82FE-BB8ECD086DCA} + + + + {B3C725BD-B91B-1D43-9A87-FAFE0D6929E3} + + + + + + {410A240E-17E1-40F0-82FE-BB8ECD086DCA} + + + + {68077A0E-EA55-FB4A-B2ED-E339F1DD8C75} + + + + + + {410A240E-17E1-40F0-82FE-BB8ECD086DCA} + + + + {25AC5CD8-5141-7542-A755-2D275FEC2137} + + + + + diff --git a/data/Source/System/Mesh/Shaders/Instance/Cull/Cull.xdm b/data/Source/System/Mesh/Shaders/Instance/Cull/Cull.xdm new file mode 100644 index 0000000000..309999ab5a --- /dev/null +++ b/data/Source/System/Mesh/Shaders/Instance/Cull/Cull.xdm @@ -0,0 +1,6 @@ + + + {37998131-BDA1-DE45-B175-35B088FEE61C} + traktor.render.ShaderGraph + + diff --git a/data/Source/System/Mesh/Shaders/Instance/Cull/Draw.xdi b/data/Source/System/Mesh/Shaders/Instance/Cull/Draw.xdi new file mode 100644 index 0000000000..f724a6ec09 --- /dev/null +++ b/data/Source/System/Mesh/Shaders/Instance/Cull/Draw.xdi @@ -0,0 +1,207 @@ + + + + + {AA20BF80-C68A-D649-9BF9-23BC5F6257F8} + + + 156 + 344 + + x + + + {0C63324D-D49B-7C44-BE53-17ECD5DBE92E} + + + -87 + 356 + + Global + + + {9772F569-3912-1B46-AB4B-157B8CC99284} + + + -4 + 282 + + InstanceMesh_Visibility + + + visible + DtFloat1 + + + + + {B6ABD193-2075-0442-A1B6-92D4C05F99CB} + + + 6 + 239 + + InstanceMesh_Draw + + + indexCount + DtInteger1 + + + instanceCount + DtInteger1 + + + firstIndex + DtInteger1 + + + vertexOffset + DtInteger1 + + + firstInstance + DtInteger1 + + + + + {EF3C22BB-6DAD-ED47-B381-BF0850063421} + + + 355 + 250 + + WriteOut + Default + + 1 + 1 + 1 + + + + + {AF60E34F-9E23-4E4B-8874-3FCB33F46C2F} + DrawBuffer + + + {13DDFE53-988C-FE40-B343-7FE23D25E253} + VisibilityBuffer + + + {89D6EAF6-DAAD-C647-B640-7F86B233A509} + Index + + + {788C47C3-E973-CF48-9A12-5A2751107996} + PrimIndexCount + + + {618C459F-DE31-4E4D-A0ED-6D01AF8C87AF} + PrimFirstIndex + + + + + + + {3491574B-839F-B74B-8747-0C4A10BECB57} + + + 32 + 405 + + InstanceMesh_IndexCount + Scalar + Frame + + + {89C29FEB-0F4E-714E-88DE-0BA91E135B7D} + + + 56 + 442 + + InstanceMesh_FirstIndex + Scalar + Frame + + + + + + + {AAE82FD3-522F-43C6-A594-2E13D126E5DB} + + + + {F2E22CA6-DFF3-4B20-A70A-0D7A44EACD8C} + + + + + + {ADB4FC1D-3726-4CC5-B4D5-1E2468274325} + + + + {89D6EAF6-DAAD-C647-B640-7F86B233A509} + + + + + + {ACC77B35-91B5-4405-ABC8-D0DA24D68178} + + + + {13DDFE53-988C-FE40-B343-7FE23D25E253} + + + + + + {ACC77B35-91B5-4405-ABC8-D0DA24D68178} + + + + {AF60E34F-9E23-4E4B-8874-3FCB33F46C2F} + + + + + + {1E6639B6-8B58-4694-99E7-C058E3583522} + + + + {618C459F-DE31-4E4D-A0ED-6D01AF8C87AF} + + + + + + {1E6639B6-8B58-4694-99E7-C058E3583522} + + + + {788C47C3-E973-CF48-9A12-5A2751107996} + + + + + diff --git a/data/Source/System/Mesh/Shaders/Instance/Cull/Draw.xdm b/data/Source/System/Mesh/Shaders/Instance/Cull/Draw.xdm new file mode 100644 index 0000000000..45059de5a9 --- /dev/null +++ b/data/Source/System/Mesh/Shaders/Instance/Cull/Draw.xdm @@ -0,0 +1,6 @@ + + + {A8FDE33C-D75B-4D4E-848F-7D7CF97F11D0} + traktor.render.ShaderGraph + + diff --git a/data/Source/System/Mesh/Shaders/Instance/UnpackInstanceData.xdi b/data/Source/System/Mesh/Shaders/Instance/UnpackInstanceData.xdi index ff45a65c5b..f311b60e88 100644 --- a/data/Source/System/Mesh/Shaders/Instance/UnpackInstanceData.xdi +++ b/data/Source/System/Mesh/Shaders/Instance/UnpackInstanceData.xdi @@ -1,86 +1,12 @@ - + - - {44CF0DB6-04EA-F346-A6ED-E24386E98551} - - - 125 - 781 - - - - {DC86CDCE-56A5-CF41-86FE-8D6760640B6F} - - - - - 665 - 700 - - InstanceWorld - Vector - Draw - 120 - - - {2A94C3EC-1065-744A-88F4-5EB24707AD6C} - - - - - 665 - 793 - - InstanceWorld - Vector - Draw - 120 - - - {11C485C7-758B-2C4F-AB19-0F8EFB6A63BA} - - - 110 - 886 - - 1 - - - {173A545D-6F56-A64D-94E6-EB66237F789D} - - - 317 - 873 - - - - {F34D68C6-C322-ED44-9E26-08E206FD0708} - - - 109 - 835 - - 2 - - - {1F0C4F04-0FDE-FD4F-AA10-A3113A9D439A} - - - 317 - 775 - - {19913397-AF16-7040-9FB5-8E57B092D98C} - 1242 - 623 + 1362 + 656 Rotation @@ -88,7 +14,7 @@ translation {B12B5D79-F6DD-6F4E-9E62-040B6A429EAC} - 1334 + 1362 721 Translation @@ -97,7 +23,7 @@ translation {5F2B1258-0CF2-E944-9F35-DCAB623B3217} - 1363 + 1362 794 Scale @@ -106,7 +32,7 @@ translation {B3E7E7D8-D5D1-B540-980A-AC2301D4A734} - 1242 + 1240 721 xyz @@ -124,8 +50,8 @@ translation {61220E81-4FE5-374B-90F4-DB8B140CF72E} - 1239 - 1115 + 1240 + 1013 w @@ -133,8 +59,8 @@ translation {9A93E123-A45D-1340-B936-91FF85883ECC} - 1241 - 1042 + 1240 + 940 xyz @@ -143,7 +69,7 @@ translation 1362 - 1115 + 1020 ScaleLast @@ -151,8 +77,8 @@ translation {45936592-3A8C-FA45-8C08-6827D12F9FDD} - 1333 - 1042 + 1362 + 947 TranslationLast @@ -160,224 +86,317 @@ translation {471FD3A8-9A8B-EE4B-B14F-382762CC4870} - 1240 - 906 + 1362 + 874 RotationLast - - {BC627F0B-65F5-0544-8144-A7C4AA319B56} - - - + + {BD8029D8-D20D-AE40-9895-EA83610D8339} + - 653 - 994 + 444 + 748 + + InstanceWorld + + + rotation + DtFloat4 + + + translationAndScale + DtFloat4 + + + + + {5193F279-0901-F345-97E6-238E9D406009} + + + 428 + 825 InstanceWorldLast - Vector - Draw - 120 + + + rotation + DtFloat4 + + + translationAndScale + DtFloat4 + + + + + {A7010216-CD61-7C4F-9DAA-3E2A9D4DDC9B} + + + 786 + 721 + + + rotation + translationAndScale + - - {E1854626-2EF1-D348-9D52-9685C57B84AB} - - - + + {42AD1EFE-8568-A940-AE85-5E663B1BE070} + - 653 - 901 + 781 + 914 + + + rotation + translationAndScale + + + + {CA90CD3D-4575-BF44-A9AB-47FB337A4E60} + + + 1092 + 709 + + + + {3FF226A7-AF06-E349-8D56-0E8616828A7C} + + + 1092 + 762 + + + + {A5E9A8AD-E562-7241-B9B3-7D5DACCC2684} + + + 1092 + 906 + + + + {AE1F4229-0E7C-E340-A5A9-517448A1C520} + + + 1092 + 975 - InstanceWorldLast - Vector - Draw - 120 + + + {8A459FBA-5749-254B-9853-127DB9AF95F8} + + + 493 + 894 + + gl_DrawID + + + 1 + 1 + 1 + + + + + + {897E2C02-E5A3-A643-AAF8-1507B49AC1C3} + Output + Scalar + + + - - {D33F8931-C90C-4EBA-8A04-A31D3E08FAB7} + + {ADB4FC1D-3726-4CC5-B4D5-1E2468274325} - - {D2D716D6-C4A1-471F-894A-D718515F6281} + + {731844D4-AFDC-4EAA-8B41-C4BA2455898F} - - {9E839249-E9B9-4736-8BDD-A95A1C892B42} + + {ADB4FC1D-3726-4CC5-B4D5-1E2468274325} - - {3DE04294-4DEA-4A13-A460-2274647357EA} + + {731844D4-AFDC-4EAA-8B41-C4BA2455898F} - - {D33F8931-C90C-4EBA-8A04-A31D3E08FAB7} + + {ADB4FC1D-3726-4CC5-B4D5-1E2468274325} - - {9F45B2C3-B513-4646-B0C1-663748FD169C} + + {731844D4-AFDC-4EAA-8B41-C4BA2455898F} - - {9E839249-E9B9-4736-8BDD-A95A1C892B42} + + {ADB4FC1D-3726-4CC5-B4D5-1E2468274325} - - {E457DE92-8BE5-4385-9AD3-3903238A8FD9} + + {731844D4-AFDC-4EAA-8B41-C4BA2455898F} - - {32FD3DAA-16C1-44C8-8A1E-E9ECF97F31D2} + + {ACC77B35-91B5-4405-ABC8-D0DA24D68178} - - {E457DE92-8BE5-4385-9AD3-3903238A8FD9} + + {0FF6511C-0293-41A8-830E-81978BD01F7F} - - {61C214E2-B4D2-4905-A50C-7C38F98E8F91} + + {ACC77B35-91B5-4405-ABC8-D0DA24D68178} - - {69997292-C813-490C-910C-620B9AD3A2BB} + + {0FF6511C-0293-41A8-830E-81978BD01F7F} - - {ADB4FC1D-3726-4CC5-B4D5-1E2468274325} + + {0FF6511C-0293-41A8-850E-81978BD01F7F} - - {731844D4-AFDC-4EAA-8B41-C4BA2455898F} + + {93DEEDC9-D4C7-47F8-8D6A-A79DABD6BA6A} - - {ADB4FC1D-3726-4CC5-B4D5-1E2468274325} + + {8FFB3BDB-A00E-4406-994C-0D52FAF04871} - + {731844D4-AFDC-4EAA-8B41-C4BA2455898F} - - {ADB4FC1D-3726-4CC5-B4D5-1E2468274325} + + {0FF6511C-0293-41A8-860E-81978BD01F7F} - {731844D4-AFDC-4EAA-8B41-C4BA2455898F} + {93DEEDC9-D4C7-47F8-8D6A-A79DABD6BA6A} - - {ADB4FC1D-3726-4CC5-B4D5-1E2468274325} + + {8FFB3BDB-A00E-4406-994C-0D52FAF04871} - - {731844D4-AFDC-4EAA-8B41-C4BA2455898F} + + {F2E22CA6-DFF3-4B20-A70A-0D7A44EACD8C} - - {32FD3DAA-16C1-44C8-8A1E-E9ECF97F31D2} + + {8FFB3BDB-A00E-4406-994C-0D52FAF04871} - - {E457DE92-8BE5-4385-9AD3-3903238A8FD9} + + {F2E22CA6-DFF3-4B20-A70A-0D7A44EACD8C} - - {9E839249-E9B9-4736-8BDD-A95A1C892B42} + + {0FF6511C-0293-41A8-850E-81978BD01F7F} - - {E457DE92-8BE5-4385-9AD3-3903238A8FD9} + + {93DEEDC9-D4C7-47F8-8D6A-A79DABD6BA6A} - - {410A240E-17E1-40F0-82FE-BB8ECD086DCA} + + {8FFB3BDB-A00E-4406-994C-0D52FAF04871} - + {731844D4-AFDC-4EAA-8B41-C4BA2455898F} - - {410A240E-17E1-40F0-82FE-BB8ECD086DCA} + + {0FF6511C-0293-41A8-860E-81978BD01F7F} - - {F2E22CA6-DFF3-4B20-A70A-0D7A44EACD8C} + + {93DEEDC9-D4C7-47F8-8D6A-A79DABD6BA6A} - - {410A240E-17E1-40F0-82FE-BB8ECD086DCA} + + {8FFB3BDB-A00E-4406-994C-0D52FAF04871} - + {F2E22CA6-DFF3-4B20-A70A-0D7A44EACD8C} - - {410A240E-17E1-40F0-82FE-BB8ECD086DCA} + + {8FFB3BDB-A00E-4406-994C-0D52FAF04871} - - {731844D4-AFDC-4EAA-8B41-C4BA2455898F} + + {F2E22CA6-DFF3-4B20-A70A-0D7A44EACD8C} - - {410A240E-17E1-40F0-82FE-BB8ECD086DCA} + + {897E2C02-E5A3-A643-AAF8-1507B49AC1C3} - {F2E22CA6-DFF3-4B20-A70A-0D7A44EACD8C} + {0FF6511C-0293-41A8-840E-81978BD01F7F} - - {410A240E-17E1-40F0-82FE-BB8ECD086DCA} + + {897E2C02-E5A3-A643-AAF8-1507B49AC1C3} - {F2E22CA6-DFF3-4B20-A70A-0D7A44EACD8C} + {0FF6511C-0293-41A8-840E-81978BD01F7F} + diff --git a/data/Source/System/Shaders/Modules/Frustum.xdi b/data/Source/System/Shaders/Modules/Frustum.xdi new file mode 100644 index 0000000000..6f8ec7e564 --- /dev/null +++ b/data/Source/System/Shaders/Modules/Frustum.xdi @@ -0,0 +1,29 @@ + + + + + + diff --git a/data/Source/System/Shaders/Modules/Frustum.xdm b/data/Source/System/Shaders/Modules/Frustum.xdm new file mode 100644 index 0000000000..231673bae6 --- /dev/null +++ b/data/Source/System/Shaders/Modules/Frustum.xdm @@ -0,0 +1,6 @@ + + + {45D674A1-6AC4-6B4E-B7CB-DC7F9C2EC215} + traktor.render.ShaderModule + +