kraken_engine/kraken
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

WIP Render Graph Refactoring

Browse Source
This commit is contained in:
Kearwood Gilbert
2024-01-21 18:34:36 -08:00
parent b3269d7b97
commit 6e88d82520
29 changed files with 255 additions and 245 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
kraken/KRAmbientZone.cpp
View File

@@ -31,6 +31,7 @@
#include "KRAmbientZone.h"
#include "KRContext.h"
#include "KRRenderPass.h"
using namespace hydra;
@@ -128,7 +129,7 @@ void KRAmbientZone::render(RenderInfo& ri)
bool bVisualize = ri.camera->settings.debug_display == KRRenderSettings::KRENGINE_DEBUG_DISPLAY_SIREN_AMBIENT_ZONES;
if (ri.renderPass == KRNode::RENDER_PASS_FORWARD_TRANSPARENT && bVisualize) {
if (ri.renderPass->getType() == RenderPassType::RENDER_PASS_FORWARD_TRANSPARENT && bVisualize) {
KRMesh* sphereModel = getContext().getMeshManager()->getMaxLODModel("__sphere");
if (sphereModel) {

3
kraken/KRAudioSource.cpp
View File

@@ -34,6 +34,7 @@
#include "KRAudioManager.h"
#include "KRAudioSample.h"
#include "KRAudioBuffer.h"
#include "KRRenderPass.h"
using namespace hydra;
@@ -196,7 +197,7 @@ void KRAudioSource::render(RenderInfo& ri)
bool bVisualize = false;
if (ri.renderPass == KRNode::RENDER_PASS_FORWARD_TRANSPARENT && bVisualize) {
if (ri.renderPass->getType() == RenderPassType::RENDER_PASS_FORWARD_TRANSPARENT && bVisualize) {
KRMesh* sphereModel = getContext().getMeshManager()->getMaxLODModel("__sphere");
if (sphereModel) {
Matrix4 sphereModelMatrix = getModelMatrix();

3
kraken/KRBone.cpp
View File

@@ -31,6 +31,7 @@
#include "KRBone.h"
#include "KRContext.h"
#include "KRRenderPass.h"
using namespace hydra;
@@ -80,7 +81,7 @@ void KRBone::render(RenderInfo& ri)
bool bVisualize = ri.camera->settings.debug_display == KRRenderSettings::KRENGINE_DEBUG_DISPLAY_BONES;
if (ri.renderPass == KRNode::RENDER_PASS_FORWARD_TRANSPARENT && bVisualize) {
if (ri.renderPass->getType() == RenderPassType::RENDER_PASS_FORWARD_TRANSPARENT && bVisualize) {
KRMesh* sphereModel = getContext().getMeshManager()->getMaxLODModel("__sphere");
if (sphereModel) {
Matrix4 sphereModelMatrix = getModelMatrix();

97
kraken/KRCamera.cpp
View File

@@ -34,6 +34,7 @@
#include "KRDirectionalLight.h"
#include "KRRenderPass.h"
#include "KRPipeline.h"
#include "KRRenderPass.h"
using namespace mimir;
using namespace hydra;
@@ -180,13 +181,13 @@ void KRCamera::renderFrame(VkCommandBuffer& commandBuffer, KRSurface& compositeS
scene.updateOctree(m_viewport);
// ----====---- Pre-stream resources ----====----
scene.render(commandBuffer, compositeSurface, this, m_viewport.getVisibleBounds(), m_viewport, KRNode::RENDER_PASS_PRESTREAM, true);
scene.render(commandBuffer, compositeSurface, this, m_viewport.getVisibleBounds(), m_viewport, compositeSurface.getRenderPass(RenderPassType::RENDER_PASS_PRESTREAM), true);
// ----====---- Generate Shadowmaps for Lights ----====----
if (settings.m_cShadowBuffers > 0) {
GL_PUSH_GROUP_MARKER("Generate Shadowmaps");
scene.render(commandBuffer, compositeSurface, this, m_viewport.getVisibleBounds(), m_viewport, KRNode::RENDER_PASS_GENERATE_SHADOWMAPS, false /*settings.bEnableDeferredLighting*/);
scene.render(commandBuffer, compositeSurface, this, m_viewport.getVisibleBounds(), m_viewport, compositeSurface.getRenderPass(RenderPassType::RENDER_PASS_GENERATE_SHADOWMAPS), false /*settings.bEnableDeferredLighting*/);
GL_POP_GROUP_MARKER;
}
@@ -197,14 +198,14 @@ void KRCamera::renderFrame(VkCommandBuffer& commandBuffer, KRSurface& compositeS
GL_PUSH_GROUP_MARKER("Deferred Lighting - Pass 1 (Opaque)");
// Start render pass
KRRenderPass& deferredGBufferPass = compositeSurface.getDeferredGBufferPass();
deferredGBufferPass.begin(commandBuffer, compositeSurface);
KRRenderPass* deferredGBufferPass = compositeSurface.getRenderPass(RenderPassType::RENDER_PASS_DEFERRED_GBUFFER);
deferredGBufferPass->begin(commandBuffer, compositeSurface);
// Render the geometry
scene.render(commandBuffer, compositeSurface, this, m_viewport.getVisibleBounds(), m_viewport, KRNode::RENDER_PASS_DEFERRED_GBUFFER, false);
scene.render(commandBuffer, compositeSurface, this, m_viewport.getVisibleBounds(), m_viewport, deferredGBufferPass, false);
// End render pass
deferredGBufferPass.end(commandBuffer);
deferredGBufferPass->end(commandBuffer);
GL_POP_GROUP_MARKER;
@@ -225,7 +226,7 @@ void KRCamera::renderFrame(VkCommandBuffer& commandBuffer, KRSurface& compositeS
m_pContext->getTextureManager()->selectTexture(0 /*GL_TEXTURE_2D*/, 7, compositeDepthTexture);
// Render the geometry
scene.render(commandBuffer, compositeSurface, this, m_viewport.getVisibleBounds(), m_viewport, KRNode::RENDER_PASS_DEFERRED_LIGHTS, false);
scene.render(commandBuffer, compositeSurface, this, m_viewport.getVisibleBounds(), m_viewport, compositeSurface.getRenderPass(RenderPassType::RENDER_PASS_DEFERRED_LIGHTS), false);
GL_POP_GROUP_MARKER;
@@ -234,18 +235,18 @@ void KRCamera::renderFrame(VkCommandBuffer& commandBuffer, KRSurface& compositeS
GL_PUSH_GROUP_MARKER("Deferred Lighting - Pass 3 (Opaque)");
// Start render pass
KRRenderPass& deferredOpaquePass = compositeSurface.getDeferredOpaquePass();
deferredOpaquePass.begin(commandBuffer, compositeSurface);
KRRenderPass* deferredOpaquePass = compositeSurface.getRenderPass(RenderPassType::RENDER_PASS_DEFERRED_OPAQUE);
deferredOpaquePass->begin(commandBuffer, compositeSurface);
// Set source to buffers from pass 2
m_pContext->getTextureManager()->selectTexture(0 /*GL_TEXTURE_2D*/, 6, lightAccumulationTexture);
// Render the geometry
// TODO: At this point, we only want to render octree nodes that produced fragments during the 1st pass into the GBuffer
scene.render(commandBuffer, compositeSurface, this, m_viewport.getVisibleBounds(), m_viewport, KRNode::RENDER_PASS_DEFERRED_OPAQUE, false);
scene.render(commandBuffer, compositeSurface, this, m_viewport.getVisibleBounds(), m_viewport, deferredOpaquePass, false);
// End render pass
deferredOpaquePass.end(commandBuffer);
deferredOpaquePass->end(commandBuffer);
GL_POP_GROUP_MARKER;
} else {
@@ -253,11 +254,11 @@ void KRCamera::renderFrame(VkCommandBuffer& commandBuffer, KRSurface& compositeS
GL_PUSH_GROUP_MARKER("Forward Rendering - Opaque");
// Start render pass
KRRenderPass& forwardOpaquePass = compositeSurface.getForwardOpaquePass();
forwardOpaquePass.begin(commandBuffer, compositeSurface);
KRRenderPass* forwardOpaquePass = compositeSurface.getRenderPass(RenderPassType::RENDER_PASS_FORWARD_OPAQUE);
forwardOpaquePass->begin(commandBuffer, compositeSurface);
// Render the geometry
scene.render(commandBuffer, compositeSurface, this, m_viewport.getVisibleBounds(), m_viewport, KRNode::RENDER_PASS_FORWARD_OPAQUE, false);
scene.render(commandBuffer, compositeSurface, this, m_viewport.getVisibleBounds(), m_viewport, forwardOpaquePass, false);
GL_POP_GROUP_MARKER;
@@ -269,19 +270,19 @@ void KRCamera::renderFrame(VkCommandBuffer& commandBuffer, KRSurface& compositeS
std::string shader_name("vulkan_test");
info.shader_name = &shader_name;
info.pCamera = this;
info.renderPass = KRNode::RENDER_PASS_FORWARD_TRANSPARENT;
info.rasterMode = RasterMode::kAlphaBlend;
info.renderPass = forwardOpaquePass;
info.rasterMode = RasterMode::kOpaque;
info.vertexAttributes = sphereMesh->getVertexAttributes();
info.modelFormat = sphereMesh->getModelFormat();
KRPipeline* testPipeline = m_pContext->getPipelineManager()->getPipeline(compositeSurface, info);
testPipeline->bind(commandBuffer, *this, m_viewport, Matrix4(), nullptr, nullptr, nullptr, KRNode::RENDER_PASS_FORWARD_OPAQUE);
testPipeline->bind(commandBuffer, *this, m_viewport, Matrix4(), nullptr, nullptr, nullptr, compositeSurface.getRenderPass(RenderPassType::RENDER_PASS_FORWARD_OPAQUE));
sphereMesh->renderNoMaterials(commandBuffer, info.renderPass, "Vulkan Test", "vulkan_test", 1.0);
}
// ---------- End: Vulkan Debug Code ----------
forwardOpaquePass.end(commandBuffer);
forwardOpaquePass->end(commandBuffer);
}
// ----====---- Sky Box ----====----
@@ -299,13 +300,13 @@ void KRCamera::renderFrame(VkCommandBuffer& commandBuffer, KRSurface& compositeS
PipelineInfo info{};
info.shader_name = &shader_name;
info.pCamera = this;
info.renderPass = KRNode::RENDER_PASS_FORWARD_OPAQUE;
info.renderPass = compositeSurface.getRenderPass(RenderPassType::RENDER_PASS_FORWARD_OPAQUE);
info.rasterMode = RasterMode::kOpaqueNoDepthWrite;
info.cullMode = CullMode::kCullNone;
KRPipeline* pPipeline = getContext().getPipelineManager()->getPipeline(compositeSurface, info);
pPipeline->setImageBinding("diffuseTexture", m_pSkyBoxTexture, getContext().getSamplerManager()->DEFAULT_CLAMPED_SAMPLER);
pPipeline->bind(commandBuffer, *this, m_viewport, Matrix4(), nullptr, nullptr, nullptr, KRNode::RENDER_PASS_FORWARD_OPAQUE);
pPipeline->bind(commandBuffer, *this, m_viewport, Matrix4(), nullptr, nullptr, nullptr, compositeSurface.getRenderPass(RenderPassType::RENDER_PASS_FORWARD_OPAQUE));
// Render a full screen quad
m_pContext->getMeshManager()->bindVBO(commandBuffer, &getContext().getMeshManager()->KRENGINE_VBO_DATA_2D_SQUARE_VERTICES, 1.0f);
@@ -320,7 +321,7 @@ void KRCamera::renderFrame(VkCommandBuffer& commandBuffer, KRSurface& compositeS
GL_PUSH_GROUP_MARKER("Forward Rendering - Transparent");
// Render all transparent geometry
scene.render(commandBuffer, compositeSurface, this, m_viewport.getVisibleBounds(), m_viewport, KRNode::RENDER_PASS_FORWARD_TRANSPARENT, false);
scene.render(commandBuffer, compositeSurface, this, m_viewport.getVisibleBounds(), m_viewport, compositeSurface.getRenderPass(RenderPassType::RENDER_PASS_FORWARD_TRANSPARENT), false);
GL_POP_GROUP_MARKER;
@@ -329,7 +330,7 @@ void KRCamera::renderFrame(VkCommandBuffer& commandBuffer, KRSurface& compositeS
GL_PUSH_GROUP_MARKER("Particle Occlusion Tests");
// ----====---- Perform Occlusion Tests ----====----
scene.render(commandBuffer, compositeSurface, this, m_viewport.getVisibleBounds(), m_viewport, RENDER_PASS_PARTICLE_OCCLUSION, false);
scene.render(commandBuffer, compositeSurface, this, m_viewport.getVisibleBounds(), m_viewport, compositeSurface.getRenderPass(RenderPassType::RENDER_PASS_PARTICLE_OCCLUSION), false);
GL_POP_GROUP_MARKER;
@@ -338,7 +339,7 @@ void KRCamera::renderFrame(VkCommandBuffer& commandBuffer, KRSurface& compositeS
GL_PUSH_GROUP_MARKER("Additive Particles");
// Render all flares
scene.render(commandBuffer, compositeSurface, this, m_viewport.getVisibleBounds(), m_viewport, KRNode::RENDER_PASS_ADDITIVE_PARTICLES, false);
scene.render(commandBuffer, compositeSurface, this, m_viewport.getVisibleBounds(), m_viewport, compositeSurface.getRenderPass(RenderPassType::RENDER_PASS_ADDITIVE_PARTICLES), false);
GL_POP_GROUP_MARKER;
@@ -368,7 +369,7 @@ void KRCamera::renderFrame(VkCommandBuffer& commandBuffer, KRSurface& compositeS
GLDEBUG(glDepthRangef(0.0, 1.0));
}
scene.render(commandBuffer, compositeSurface, this, m_viewport.getVisibleBounds(), volumetricLightingViewport, KRNode::RENDER_PASS_VOLUMETRIC_EFFECTS_ADDITIVE, false);
scene.render(commandBuffer, compositeSurface, this, m_viewport.getVisibleBounds(), volumetricLightingViewport, compositeSurface.getRenderPass(RenderPassType::RENDER_PASS_VOLUMETRIC_EFFECTS_ADDITIVE), false);
GL_POP_GROUP_MARKER;
}
@@ -386,7 +387,7 @@ void KRCamera::renderFrame(VkCommandBuffer& commandBuffer, KRSurface& compositeS
std::string shader_name("visualize_overlay");
info.shader_name = &shader_name;
info.pCamera = this;
info.renderPass = KRNode::RENDER_PASS_FORWARD_TRANSPARENT;
info.renderPass = compositeSurface.getRenderPass(RenderPassType::RENDER_PASS_FORWARD_TRANSPARENT);
info.rasterMode = RasterMode::kAdditive;
info.vertexAttributes = vertices.getVertexAttributes();
info.modelFormat = ModelFormat::KRENGINE_MODEL_FORMAT_STRIP;
@@ -397,7 +398,7 @@ void KRCamera::renderFrame(VkCommandBuffer& commandBuffer, KRSurface& compositeS
Matrix4 matModel = Matrix4();
matModel.scale((*itr).first.size() * 0.5f);
matModel.translate((*itr).first.center());
pVisShader->bind(commandBuffer, *this, m_viewport, matModel, nullptr, nullptr, nullptr, KRNode::RENDER_PASS_FORWARD_TRANSPARENT);
pVisShader->bind(commandBuffer, *this, m_viewport, matModel, nullptr, nullptr, nullptr, compositeSurface.getRenderPass(RenderPassType::RENDER_PASS_FORWARD_TRANSPARENT));
vkCmdDraw(commandBuffer, 14, 1, 0, 0);
}
}
@@ -414,12 +415,12 @@ void KRCamera::renderFrame(VkCommandBuffer& commandBuffer, KRSurface& compositeS
GL_PUSH_GROUP_MARKER("Post Processing");
KRRenderPass& postCompositePass = compositeSurface.getPostCompositePass();
postCompositePass.begin(commandBuffer, compositeSurface);
KRRenderPass* postCompositePass = compositeSurface.getRenderPass(RenderPassType::RENDER_PASS_POST_COMPOSITE);
postCompositePass->begin(commandBuffer, compositeSurface);
renderPost(commandBuffer, compositeSurface);
postCompositePass.end(commandBuffer);
postCompositePass->end(commandBuffer);
GL_POP_GROUP_MARKER;
@@ -594,7 +595,7 @@ void KRCamera::renderPost(VkCommandBuffer& commandBuffer, KRSurface& surface)
std::string shader_name("PostShader");
info.shader_name = &shader_name;
info.pCamera = this;
info.renderPass = KRNode::RENDER_PASS_FORWARD_TRANSPARENT;
info.renderPass = compositeSurface.getRenderPass(RenderPassType::RENDER_PASS_FORWARD_TRANSPARENT);
info.rasterMode = RasterMode::kOpaqueNoTest;
info.modelFormat = ModelFormat::KRENGINE_MODEL_FORMAT_STRIP;
info.vertexAttributes = vertices.getVertexAttributes();
@@ -602,7 +603,7 @@ void KRCamera::renderPost(VkCommandBuffer& commandBuffer, KRSurface& surface)
KRPipeline *postShader = m_pContext->getPipelineManager()->getPipeline(surface, info);
postShader->setPushConstant(KRPipeline::PushConstant::fade_color, m_fade_color);
postShader->bind(commandBuffer, *this, m_viewport, Matrix4(), nullptr, nullptr, nullptr, KRNode::RENDER_PASS_FORWARD_TRANSPARENT);
postShader->bind(commandBuffer, *this, m_viewport, Matrix4(), nullptr, nullptr, nullptr, compositeSurface.getRenderPass(RenderPassType::RENDER_PASS_FORWARD_TRANSPARENT));
m_pContext->getTextureManager()->selectTexture(GL_TEXTURE_2D, 0, compositeDepthTexture);
m_pContext->getTextureManager()->selectTexture(GL_TEXTURE_2D, 1, compositeColorTexture);
@@ -619,13 +620,13 @@ void KRCamera::renderPost(VkCommandBuffer& commandBuffer, KRSurface& surface)
// if(bShowShadowBuffer) {
// KRPipeline *blitShader = m_pContext->getPipelineManager()->getShader("simple_blit", this, false, false, false, 0, false, false, false, false, false, false, false, false, false, false, false, false, false, KRNode::RENDER_PASS_FORWARD_TRANSPARENT);
// KRPipeline *blitShader = m_pContext->getPipelineManager()->getShader("simple_blit", this, false, false, false, 0, false, false, false, false, false, false, false, false, false, false, false, false, false, compositeSurface.getRenderPass(RenderPassType::RENDER_PASS_FORWARD_TRANSPARENT));
//
// for(int iShadow=0; iShadow < m_cShadowBuffers; iShadow++) {
// Matrix4 viewMatrix = Matrix4();
// viewMatrix.scale(0.20, 0.20, 0.20);
// viewMatrix.translate(-0.70, 0.70 - 0.45 * iShadow, 0.0);
// getContext().getPipelineManager()->selectShader(blitShader, KRViewport(getViewportSize(), viewMatrix, Matrix4()), shadowViewports, Matrix4(), Vector3(), NULL, 0, KRNode::RENDER_PASS_FORWARD_TRANSPARENT);
// getContext().getPipelineManager()->selectShader(blitShader, KRViewport(getViewportSize(), viewMatrix, Matrix4()), shadowViewports, Matrix4(), Vector3(), NULL, 0, compositeSurface.getRenderPass(RenderPassType::RENDER_PASS_FORWARD_TRANSPARENT));
// m_pContext->getTextureManager()->selectTexture(1, NULL);
// m_pContext->getMeshManager()->bindVBO(&getContext().getMeshManager()->KRENGINE_VBO_DATA_2D_SQUARE_VERTICES);
// m_pContext->getTextureManager()->_setActiveTexture(0);
@@ -774,8 +775,8 @@ void KRCamera::renderDebug(VkCommandBuffer& commandBuffer, KRSurface& surface)
m_debug_text_vbo_data.load(commandBuffer);
KRRenderPass& debugPass = surface.getDebugPass();
debugPass.begin(commandBuffer, surface);
KRRenderPass* debugPass = surface.getRenderPass(RenderPassType::RENDER_PASS_DEBUG_OVERLAYS);
debugPass->begin(commandBuffer, surface);
KRTexture* fontTexture = m_pContext->getTextureManager()->getTexture("font");
fontTexture->resetPoolExpiry(0.0f, KRTexture::TEXTURE_USAGE_UI);
@@ -785,21 +786,21 @@ void KRCamera::renderDebug(VkCommandBuffer& commandBuffer, KRSurface& surface)
std::string shader_name("debug_font");
info.shader_name = &shader_name;
info.pCamera = this;
info.renderPass = KRNode::RENDER_PASS_FORWARD_TRANSPARENT;
info.renderPass = surface.getRenderPass(RenderPassType::RENDER_PASS_FORWARD_TRANSPARENT);
info.rasterMode = RasterMode::kAlphaBlendNoTest;
info.cullMode = CullMode::kCullNone;
info.vertexAttributes = (1 << KRMesh::KRENGINE_ATTRIB_VERTEX) | (1 << KRMesh::KRENGINE_ATTRIB_TEXUVA);
info.modelFormat = ModelFormat::KRENGINE_MODEL_FORMAT_TRIANGLES;
KRPipeline* fontShader = m_pContext->getPipelineManager()->getPipeline(surface, info);
fontShader->setImageBinding("fontTexture", fontTexture, getContext().getSamplerManager()->DEFAULT_CLAMPED_SAMPLER);
fontShader->bind(commandBuffer, *this, m_viewport, Matrix4(), nullptr, nullptr, nullptr, KRNode::RENDER_PASS_FORWARD_TRANSPARENT);
fontShader->bind(commandBuffer, *this, m_viewport, Matrix4(), nullptr, nullptr, nullptr, surface.getRenderPass(RenderPassType::RENDER_PASS_FORWARD_TRANSPARENT));
m_debug_text_vbo_data.bind(commandBuffer);
vkCmdDraw(commandBuffer, vertex_count, 1, 0, 0);
}
debugPass.end(commandBuffer);
debugPass->end(commandBuffer);
m_debug_text_vertices.unlock();
@@ -944,34 +945,34 @@ std::string KRCamera::getDebugText()
draw_call_count++;
stream << "\n" << draw_call_count << "\t" << (*itr).vertex_count << "\t";
switch ((*itr).pass) {
case KRNode::RENDER_PASS_FORWARD_OPAQUE:
case RenderPassType::RENDER_PASS_FORWARD_OPAQUE:
stream << "opaq";
break;
case KRNode::RENDER_PASS_DEFERRED_GBUFFER:
case RenderPassType::RENDER_PASS_DEFERRED_GBUFFER:
stream << "d gb";
break;
case KRNode::RENDER_PASS_DEFERRED_LIGHTS:
case RenderPassType::RENDER_PASS_DEFERRED_LIGHTS:
stream << "d light";
break;
case KRNode::RENDER_PASS_DEFERRED_OPAQUE:
case RenderPassType::RENDER_PASS_DEFERRED_OPAQUE:
stream << "d opaq";
break;
case KRNode::RENDER_PASS_FORWARD_TRANSPARENT:
case RenderPassType::RENDER_PASS_FORWARD_TRANSPARENT:
stream << "trans";
break;
case KRNode::RENDER_PASS_PARTICLE_OCCLUSION:
case RenderPassType::RENDER_PASS_PARTICLE_OCCLUSION:
stream << "p occl";
break;
case KRNode::RENDER_PASS_ADDITIVE_PARTICLES:
case RenderPassType::RENDER_PASS_ADDITIVE_PARTICLES:
stream << "a part";
break;
case KRNode::RENDER_PASS_VOLUMETRIC_EFFECTS_ADDITIVE:
case RenderPassType::RENDER_PASS_VOLUMETRIC_EFFECTS_ADDITIVE:
stream << "vol add";
break;
case KRNode::RENDER_PASS_GENERATE_SHADOWMAPS:
case RenderPassType::RENDER_PASS_GENERATE_SHADOWMAPS:
stream << "g shadow";
break;
case KRNode::RENDER_PASS_SHADOWMAP:
case RenderPassType::RENDER_PASS_SHADOWMAP:
stream << "shadow";
break;
default:

3
kraken/KRCollider.cpp
View File

@@ -33,6 +33,7 @@
#include "KRCollider.h"
#include "KRContext.h"
#include "KRMesh.h"
#include "KRRenderPass.h"
using namespace hydra;
@@ -217,7 +218,7 @@ void KRCollider::render(RenderInfo& ri)
KRNode::render(ri);
if (ri.renderPass == KRNode::RENDER_PASS_FORWARD_TRANSPARENT && ri.camera->settings.debug_display == KRRenderSettings::KRENGINE_DEBUG_DISPLAY_COLLIDERS) {
if (ri.renderPass->getType() == RenderPassType::RENDER_PASS_FORWARD_TRANSPARENT && ri.camera->settings.debug_display == KRRenderSettings::KRENGINE_DEBUG_DISPLAY_COLLIDERS) {
loadModel();
if (m_model) {

3
kraken/KRDirectionalLight.cpp
View File

@@ -34,6 +34,7 @@
#include "KRDirectionalLight.h"
#include "KRPipeline.h"
#include "KRContext.h"
#include "KRRenderPass.h"
#include "assert.h"
using namespace hydra;
@@ -131,7 +132,7 @@ void KRDirectionalLight::render(RenderInfo& ri)
KRLight::render(ri);
if (ri.renderPass == KRNode::RENDER_PASS_DEFERRED_LIGHTS) {
if (ri.renderPass->getType() == RenderPassType::RENDER_PASS_DEFERRED_LIGHTS) {
// Lights are rendered on the second pass of the deferred renderer
std::vector<KRDirectionalLight*> this_light;

21
kraken/KRLight.cpp
View File

@@ -42,6 +42,7 @@
#include "KRDirectionalLight.h"
#include "KRSpotLight.h"
#include "KRPointLight.h"
#include "KRRenderPass.h"
using namespace hydra;
@@ -231,12 +232,12 @@ void KRLight::render(RenderInfo& ri)
KRNode::render(ri);
if (ri.renderPass == KRNode::RENDER_PASS_GENERATE_SHADOWMAPS && (ri.camera->settings.volumetric_environment_enable || ri.camera->settings.dust_particle_enable || (ri.camera->settings.m_cShadowBuffers > 0 && m_casts_shadow))) {
if (ri.renderPass->getType() == RenderPassType::RENDER_PASS_GENERATE_SHADOWMAPS && (ri.camera->settings.volumetric_environment_enable || ri.camera->settings.dust_particle_enable || (ri.camera->settings.m_cShadowBuffers > 0 && m_casts_shadow))) {
allocateShadowBuffers(configureShadowBufferViewports(ri.viewport));
renderShadowBuffers(ri);
}
if (ri.renderPass == KRNode::RENDER_PASS_ADDITIVE_PARTICLES && ri.camera->settings.dust_particle_enable) {
if (ri.renderPass->getType() == RenderPassType::RENDER_PASS_ADDITIVE_PARTICLES && ri.camera->settings.dust_particle_enable) {
// Render brownian particles for dust floating in air
if (m_cShadowBuffers >= 1 && shadowValid[0] && m_dust_particle_density > 0.0f && m_dust_particle_size > 0.0f && m_dust_particle_intensity > 0.0f) {
@@ -296,7 +297,7 @@ void KRLight::render(RenderInfo& ri)
}
if (ri.renderPass == KRNode::RENDER_PASS_VOLUMETRIC_EFFECTS_ADDITIVE && ri.camera->settings.volumetric_environment_enable && m_light_shafts) {
if (ri.renderPass->getType() == RenderPassType::RENDER_PASS_VOLUMETRIC_EFFECTS_ADDITIVE && ri.camera->settings.volumetric_environment_enable && m_light_shafts) {
std::string shader_name = ri.camera->settings.volumetric_environment_downsample != 0 ? "volumetric_fog_downsampled" : "volumetric_fog";
std::vector<KRDirectionalLight*> this_directional_light;
@@ -321,7 +322,7 @@ void KRLight::render(RenderInfo& ri)
info.point_lights = &this_point_light;
info.directional_lights = &this_directional_light;
info.spot_lights = &this_spot_light;
info.renderPass = KRNode::RENDER_PASS_ADDITIVE_PARTICLES;
info.renderPass = ri.renderPass;
info.rasterMode = RasterMode::kAdditive;
info.cullMode = CullMode::kCullNone;
info.vertexAttributes = (1 << KRMesh::KRENGINE_ATTRIB_VERTEX);
@@ -337,14 +338,14 @@ void KRLight::render(RenderInfo& ri)
pFogShader->setPushConstant(KRPipeline::PushConstant::slice_depth_scale, Vector2::Create(slice_near, slice_spacing));
pFogShader->setPushConstant(KRPipeline::PushConstant::light_color, (m_color * ri.camera->settings.volumetric_environment_intensity * m_intensity * -slice_spacing / 1000.0f));
pFogShader->bind(ri.commandBuffer, *ri.camera, ri.viewport, Matrix4(), &this_point_light, &this_directional_light, &this_spot_light, KRNode::RENDER_PASS_VOLUMETRIC_EFFECTS_ADDITIVE);
pFogShader->bind(ri.commandBuffer, *ri.camera, ri.viewport, Matrix4(), &this_point_light, &this_directional_light, &this_spot_light, ri.renderPass);
m_pContext->getMeshManager()->bindVBO(ri.commandBuffer, &m_pContext->getMeshManager()->KRENGINE_VBO_DATA_VOLUMETRIC_LIGHTING, 1.0f);
vkCmdDraw(ri.commandBuffer, slice_count * 6, 1, 0, 0);
}
if (ri.renderPass == KRNode::RENDER_PASS_PARTICLE_OCCLUSION) {
if (ri.renderPass->getType() == RenderPassType::RENDER_PASS_PARTICLE_OCCLUSION) {
if (m_flareTexture.size() && m_flareSize > 0.0f) {
KRMesh* sphereModel = getContext().getMeshManager()->getMaxLODModel("__sphere");
if (sphereModel) {
@@ -391,7 +392,7 @@ void KRLight::render(RenderInfo& ri)
}
}
if (ri.renderPass == KRNode::RENDER_PASS_ADDITIVE_PARTICLES) {
if (ri.renderPass->getType() == RenderPassType::RENDER_PASS_ADDITIVE_PARTICLES) {
if (m_flareTexture.size() && m_flareSize > 0.0f) {
if (m_occlusionQuery) {
@@ -534,14 +535,14 @@ void KRLight::renderShadowBuffers(RenderInfo& ri)
std::string shader_name("ShadowShader");
info.shader_name = &shader_name;
info.pCamera = ri.camera;
info.renderPass = KRNode::RENDER_PASS_FORWARD_TRANSPARENT;
info.renderPass = ri.renderPass;
info.rasterMode = RasterMode::kOpaqueLessTest; // TODO - This is sub-optimal. Evaluate increasing depth buffer resolution instead of disabling depth test.
info.cullMode = CullMode::kCullNone; // Disabling culling, which eliminates some self-cast shadow artifacts
KRPipeline* shadowShader = m_pContext->getPipelineManager()->getPipeline(*ri.surface, info);
shadowShader->bind(ri.commandBuffer, *ri.camera, m_shadowViewports[iShadow], Matrix4(), nullptr, nullptr, nullptr, KRNode::RENDER_PASS_SHADOWMAP);
shadowShader->bind(ri.commandBuffer, *ri.camera, m_shadowViewports[iShadow], Matrix4(), nullptr, nullptr, nullptr, ri.renderPass);
getScene().render(ri.commandBuffer, *ri.surface, ri.camera, m_shadowViewports[iShadow].getVisibleBounds(), m_shadowViewports[iShadow], KRNode::RENDER_PASS_SHADOWMAP, true);
getScene().render(ri.commandBuffer, *ri.surface, ri.camera, m_shadowViewports[iShadow].getVisibleBounds(), m_shadowViewports[iShadow], ri.renderPass, true);
}
}
}

5
kraken/KRMaterial.cpp
View File

@@ -33,6 +33,7 @@
#include "KRMaterial.h"
#include "KRTextureManager.h"
#include "KRRenderPass.h"
#include "KRContext.h"
@@ -414,14 +415,14 @@ void KRMaterial::bind(const KRNode::RenderInfo& ri, ModelFormat modelFormat, __u
pShader->setPushConstant(KRPipeline::PushConstant::material_ambient, m_ambientColor + ri.camera->settings.ambient_intensity);
if (ri.renderPass == KRNode::RENDER_PASS_FORWARD_OPAQUE) {
if (ri.renderPass->getType() == RenderPassType::RENDER_PASS_FORWARD_OPAQUE) {
// We pre-multiply the light color with the material color in the forward renderer
pShader->setPushConstant(KRPipeline::PushConstant::material_diffuse, Vector3::Create(m_diffuseColor.x * ri.camera->settings.light_intensity.x, m_diffuseColor.y * ri.camera->settings.light_intensity.y, m_diffuseColor.z * ri.camera->settings.light_intensity.z));
} else {
pShader->setPushConstant(KRPipeline::PushConstant::material_diffuse, m_diffuseColor);
}
if (ri.renderPass == KRNode::RENDER_PASS_FORWARD_OPAQUE) {
if (ri.renderPass->getType() == RenderPassType::RENDER_PASS_FORWARD_OPAQUE) {
// We pre-multiply the light color with the material color in the forward renderer
pShader->setPushConstant(KRPipeline::PushConstant::material_specular, Vector3::Create(m_specularColor.x * ri.camera->settings.light_intensity.x, m_specularColor.y * ri.camera->settings.light_intensity.y, m_specularColor.z * ri.camera->settings.light_intensity.z));
} else {

17
kraken/KRMesh.cpp
View File

@@ -37,6 +37,7 @@
#include "KRPipeline.h"
#include "KRPipelineManager.h"
#include "KRContext.h"
#include "KRRenderPass.h"
#include "../3rdparty/forsyth/forsyth.h"
using namespace mimir;
@@ -254,7 +255,7 @@ kraken_stream_level KRMesh::getStreamLevel()
void KRMesh::render(const KRNode::RenderInfo& ri, const std::string& object_name, const Matrix4& matModel, KRTexture* pLightMap, const std::vector<KRBone*>& bones, const Vector3& rim_color, float rim_power, float lod_coverage)
{
//fprintf(stderr, "Rendering model: %s\n", m_name.c_str());
if (ri.renderPass != KRNode::RENDER_PASS_ADDITIVE_PARTICLES && ri.renderPass != KRNode::RENDER_PASS_PARTICLE_OCCLUSION && ri.renderPass != KRNode::RENDER_PASS_VOLUMETRIC_EFFECTS_ADDITIVE) {
if (ri.renderPass->getType() != RenderPassType::RENDER_PASS_ADDITIVE_PARTICLES && ri.renderPass->getType() != RenderPassType::RENDER_PASS_PARTICLE_OCCLUSION && ri.renderPass->getType() != RenderPassType::RENDER_PASS_VOLUMETRIC_EFFECTS_ADDITIVE) {
preStream(lod_coverage);
if (getStreamLevel() == kraken_stream_level::STREAM_LEVEL_OUT) {
@@ -264,7 +265,7 @@ void KRMesh::render(const KRNode::RenderInfo& ri, const std::string& object_name
getMaterials();
int cSubmeshes = (int)m_submeshes.size();
if (ri.renderPass == KRNode::RENDER_PASS_SHADOWMAP) {
if (ri.renderPass->getType() == RenderPassType::RENDER_PASS_SHADOWMAP) {
for (int iSubmesh = 0; iSubmesh < cSubmeshes; iSubmesh++) {
KRMaterial* pMaterial = m_materials[iSubmesh];
@@ -284,7 +285,7 @@ void KRMesh::render(const KRNode::RenderInfo& ri, const std::string& object_name
KRMaterial* pMaterial = m_materials[iSubmesh];
if (pMaterial != NULL && pMaterial == (*mat_itr)) {
if ((!pMaterial->isTransparent() && ri.renderPass != KRNode::RENDER_PASS_FORWARD_TRANSPARENT) || (pMaterial->isTransparent() && ri.renderPass == KRNode::RENDER_PASS_FORWARD_TRANSPARENT)) {
if ((!pMaterial->isTransparent() && ri.renderPass->getType() != RenderPassType::RENDER_PASS_FORWARD_TRANSPARENT) || (pMaterial->isTransparent() && ri.renderPass->getType() == RenderPassType::RENDER_PASS_FORWARD_TRANSPARENT)) {
std::vector<Matrix4> bone_bind_poses;
for (int i = 0; i < (int)bones.size(); i++) {
bone_bind_poses.push_back(getBoneBindPose(i));
@@ -437,7 +438,7 @@ void KRMesh::createDataBlocks(KRMeshManager::KRVBOData::vbo_type t)
}
}
void KRMesh::renderNoMaterials(VkCommandBuffer& commandBuffer, KRNode::RenderPass renderPass, const std::string& object_name, const std::string& material_name, float lodCoverage)
void KRMesh::renderNoMaterials(VkCommandBuffer& commandBuffer, const KRRenderPass* renderPass, const std::string& object_name, const std::string& material_name, float lodCoverage)
{
int submesh_count = getSubmeshCount();
for (int i = 0; i < submesh_count; i++) {
@@ -458,7 +459,7 @@ bool KRMesh::isReady() const
return true;
}
void KRMesh::renderSubmesh(VkCommandBuffer& commandBuffer, int iSubmesh, KRNode::RenderPass renderPass, const std::string& object_name, const std::string& material_name, float lodCoverage)
void KRMesh::renderSubmesh(VkCommandBuffer& commandBuffer, int iSubmesh, const KRRenderPass* renderPass, const std::string& object_name, const std::string& material_name, float lodCoverage)
{
getSubmeshes();
@@ -485,7 +486,7 @@ void KRMesh::renderSubmesh(VkCommandBuffer& commandBuffer, int iSubmesh, KRNode:
if (vertex_draw_count > index_count - index_group_offset) vertex_draw_count = index_count - index_group_offset;
vkCmdDrawIndexed(commandBuffer, vertex_draw_count, 1, index_group_offset, 0, 0);
m_pContext->getMeshManager()->log_draw_call(renderPass, object_name, material_name, vertex_draw_count);
m_pContext->getMeshManager()->log_draw_call(renderPass->getType(), object_name, material_name, vertex_draw_count);
cVertexes -= vertex_draw_count;
index_group_offset = 0;
}
@@ -515,7 +516,7 @@ void KRMesh::renderSubmesh(VkCommandBuffer& commandBuffer, int iSubmesh, KRNode:
vkCmdDrawIndexed(commandBuffer, (MAX_VBO_SIZE - iVertex), 1, iVertex, 0, 0);
break;
}
m_pContext->getMeshManager()->log_draw_call(renderPass, object_name, material_name, (MAX_VBO_SIZE - iVertex));
m_pContext->getMeshManager()->log_draw_call(renderPass->getType(), object_name, material_name, (MAX_VBO_SIZE - iVertex));
cVertexes -= (MAX_VBO_SIZE - iVertex);
iVertex = 0;
@@ -531,7 +532,7 @@ void KRMesh::renderSubmesh(VkCommandBuffer& commandBuffer, int iSubmesh, KRNode:
default:
break;
}
m_pContext->getMeshManager()->log_draw_call(renderPass, object_name, material_name, cVertexes);
m_pContext->getMeshManager()->log_draw_call(renderPass->getType(), object_name, material_name, cVertexes);
cVertexes = 0;
}

5
kraken/KRMesh.h
View File

@@ -56,6 +56,7 @@ using namespace kraken;
class KRMaterial;
class KRNode;
class KRRenderPass;
enum class ModelFormat : __uint8_t
{
@@ -133,7 +134,7 @@ public:
void optimize();
void optimizeIndexes();
void renderNoMaterials(VkCommandBuffer& commandBuffer, KRNode::RenderPass renderPass, const std::string& object_name, const std::string& material_name, float lodCoverage);
void renderNoMaterials(VkCommandBuffer& commandBuffer, const KRRenderPass* renderPass, const std::string& object_name, const std::string& material_name, float lodCoverage);
bool isReady() const;
float getMaxDimension();
@@ -245,7 +246,7 @@ private:
void getSubmeshes();
void getMaterials();
void renderSubmesh(VkCommandBuffer& commandBuffer, int iSubmesh, KRNode::RenderPass renderPass, const std::string& object_name, const std::string& material_name, float lodCoverage);
void renderSubmesh(VkCommandBuffer& commandBuffer, int iSubmesh, const KRRenderPass* renderPass, const std::string& object_name, const std::string& material_name, float lodCoverage);
static bool rayCast(const hydra::Vector3& start, const hydra::Vector3& dir, const hydra::Triangle3& tri, const hydra::Vector3& tri_n0, const hydra::Vector3& tri_n1, const hydra::Vector3& tri_n2, hydra::HitInfo& hitinfo);
static bool sphereCast(const hydra::Matrix4& model_to_world, const hydra::Vector3& v0, const hydra::Vector3& v1, float radius, const hydra::Triangle3& tri, hydra::HitInfo& hitinfo);

3
kraken/KRMeshManager.cpp
View File

@@ -37,6 +37,7 @@
#include "KRMeshCube.h"
#include "KRMeshQuad.h"
#include "KRMeshSphere.h"
#include "KRRenderPass.h"
using namespace mimir;
@@ -441,7 +442,7 @@ size_t KRMeshManager::getActiveVBOCount()
return m_vbosActive.size();
}
void KRMeshManager::log_draw_call(KRNode::RenderPass pass, const std::string& object_name, const std::string& material_name, int vertex_count)
void KRMeshManager::log_draw_call(RenderPassType pass, const std::string& object_name, const std::string& material_name, int vertex_count)
{
if (m_draw_call_logging_enabled) {
draw_call_info info;

5
kraken/KRMeshManager.h
View File

@@ -40,6 +40,7 @@
class KRContext;
class KRMesh;
enum RenderPassType : uint8_t;
class KRMeshManager : public KRResourceManager
{
@@ -191,13 +192,13 @@ public:
struct draw_call_info
{
KRNode::RenderPass pass;
RenderPassType pass;
char object_name[256];
char material_name[256];
int vertex_count;
};
void log_draw_call(KRNode::RenderPass pass, const std::string& object_name, const std::string& material_name, int vertex_count);
void log_draw_call(RenderPassType pass, const std::string& object_name, const std::string& material_name, int vertex_count);
std::vector<draw_call_info> getDrawCalls();

17
kraken/KRModel.cpp
View File

@@ -35,6 +35,7 @@
#include "KRContext.h"
#include "KRMesh.h"
#include "KRNode.h"
#include "KRRenderPass.h"
using namespace hydra;
@@ -197,7 +198,7 @@ void KRModel::loadModel()
void KRModel::render(KRNode::RenderInfo& ri)
{
if (m_lod_visible >= LOD_VISIBILITY_PRESTREAM && ri.renderPass == KRNode::RENDER_PASS_PRESTREAM) {
if (m_lod_visible >= LOD_VISIBILITY_PRESTREAM && ri.renderPass->getType() == RenderPassType::RENDER_PASS_PRESTREAM) {
preStream(ri.viewport);
}
@@ -205,12 +206,12 @@ void KRModel::render(KRNode::RenderInfo& ri)
KRNode::render(ri);
if (ri.renderPass != KRNode::RENDER_PASS_DEFERRED_LIGHTS
&& ri.renderPass != KRNode::RENDER_PASS_ADDITIVE_PARTICLES
&& ri.renderPass != KRNode::RENDER_PASS_PARTICLE_OCCLUSION
&& ri.renderPass != KRNode::RENDER_PASS_VOLUMETRIC_EFFECTS_ADDITIVE
&& ri.renderPass != KRNode::RENDER_PASS_GENERATE_SHADOWMAPS
&& ri.renderPass != KRNode::RENDER_PASS_PRESTREAM) {
if (ri.renderPass->getType() != RenderPassType::RENDER_PASS_DEFERRED_LIGHTS
&& ri.renderPass->getType() != RenderPassType::RENDER_PASS_ADDITIVE_PARTICLES
&& ri.renderPass->getType() != RenderPassType::RENDER_PASS_PARTICLE_OCCLUSION
&& ri.renderPass->getType()!= RenderPassType::RENDER_PASS_VOLUMETRIC_EFFECTS_ADDITIVE
&& ri.renderPass->getType() != RenderPassType::RENDER_PASS_GENERATE_SHADOWMAPS
&& ri.renderPass->getType() != RenderPassType::RENDER_PASS_PRESTREAM) {
loadModel();
if (m_models.size() > 0) {
@@ -246,7 +247,7 @@ void KRModel::render(KRNode::RenderInfo& ri)
m_pLightMap = getContext().getTextureManager()->getTexture(m_lightMap);
}
if (m_pLightMap && ri.camera->settings.bEnableLightMap && ri.renderPass != RENDER_PASS_SHADOWMAP && ri.renderPass != RENDER_PASS_GENERATE_SHADOWMAPS) {
if (m_pLightMap && ri.camera->settings.bEnableLightMap && ri.renderPass->getType() != RENDER_PASS_SHADOWMAP && ri.renderPass->getType() != RENDER_PASS_GENERATE_SHADOWMAPS) {
m_pLightMap->resetPoolExpiry(lod_coverage, KRTexture::TEXTURE_USAGE_LIGHT_MAP);
// TODO - Vulkan refactoring. We need to bind the shadow map in KRMesh::Render
// m_pContext->getTextureManager()->selectTexture(5, m_pLightMap, lod_coverage, KRTexture::TEXTURE_USAGE_LIGHT_MAP);

17
kraken/KRNode.h
View File

@@ -55,6 +55,7 @@ class KRNode;
class KRPointLight;
class KRSpotLight;
class KRDirectionalLight;
class KRRenderPass;
namespace tinyxml2 {
class XMLNode;
class XMLAttribute;
@@ -63,20 +64,6 @@ class XMLAttribute;
class KRNode : public KRContextObject
{
public:
enum RenderPass
{
RENDER_PASS_FORWARD_OPAQUE,
RENDER_PASS_DEFERRED_GBUFFER,
RENDER_PASS_DEFERRED_LIGHTS,
RENDER_PASS_DEFERRED_OPAQUE,
RENDER_PASS_FORWARD_TRANSPARENT,
RENDER_PASS_PARTICLE_OCCLUSION,
RENDER_PASS_ADDITIVE_PARTICLES,
RENDER_PASS_VOLUMETRIC_EFFECTS_ADDITIVE,
RENDER_PASS_GENERATE_SHADOWMAPS,
RENDER_PASS_SHADOWMAP,
RENDER_PASS_PRESTREAM
};
enum LodVisibility
{
@@ -104,7 +91,7 @@ public:
std::vector<KRDirectionalLight*> directional_lights;
std::vector<KRSpotLight*> spot_lights;
KRViewport viewport;
RenderPass renderPass;
const KRRenderPass* renderPass;
};
static void InitNodeInfo(KrNodeInfo* nodeInfo);

3
kraken/KRParticleSystemNewtonian.cpp
View File

@@ -34,6 +34,7 @@
#include "KRParticleSystemNewtonian.h"
#include "KRTexture.h"
#include "KRContext.h"
#include "KRRenderPass.h"
using namespace hydra;
@@ -87,7 +88,7 @@ void KRParticleSystemNewtonian::render(RenderInfo& ri)
KRNode::render(ri);
if (ri.renderPass == KRNode::RENDER_PASS_ADDITIVE_PARTICLES) {
if (ri.renderPass->getType() == RenderPassType::RENDER_PASS_ADDITIVE_PARTICLES) {
if (ri.viewport.visible(getBounds())) {
int particle_count = 10000;

8
kraken/KRPipeline.cpp
View File

@@ -111,7 +111,7 @@ const char* KRPipeline::KRENGINE_PUSH_CONSTANT_NAMES[] = {
"fade_color", // PushConstant::fade_color
};
KRPipeline::KRPipeline(KRContext& context, KrDeviceHandle deviceHandle, KRRenderPass& renderPass, Vector2i viewport_size, Vector2i scissor_size, const PipelineInfo& info, const char* szKey, const std::vector<KRShader*>& shaders, uint32_t vertexAttributes, ModelFormat modelFormat)
KRPipeline::KRPipeline(KRContext& context, KrDeviceHandle deviceHandle, KRRenderPass* renderPass, Vector2i viewport_size, Vector2i scissor_size, const PipelineInfo& info, const char* szKey, const std::vector<KRShader*>& shaders, uint32_t vertexAttributes, ModelFormat modelFormat)
: KRContextObject(context)
, m_deviceHandle(deviceHandle)
{
@@ -459,7 +459,7 @@ KRPipeline::KRPipeline(KRContext& context, KrDeviceHandle deviceHandle, KRRender
pipelineInfo.pColorBlendState = &colorBlending;
pipelineInfo.pDynamicState = nullptr;
pipelineInfo.layout = m_pipelineLayout;
pipelineInfo.renderPass = renderPass.m_renderPass;
pipelineInfo.renderPass = renderPass->m_renderPass;
pipelineInfo.subpass = 0;
pipelineInfo.basePipelineHandle = VK_NULL_HANDLE;
pipelineInfo.basePipelineIndex = -1;
@@ -651,7 +651,7 @@ void KRPipeline::updateDescriptorBinding()
// Vulkan Refactoring
}
bool KRPipeline::bind(VkCommandBuffer& commandBuffer, KRCamera& camera, const KRViewport& viewport, const Matrix4& matModel, const std::vector<KRPointLight*>* point_lights, const std::vector<KRDirectionalLight*>* directional_lights, const std::vector<KRSpotLight*>* spot_lights, const KRNode::RenderPass& renderPass)
bool KRPipeline::bind(VkCommandBuffer& commandBuffer, KRCamera& camera, const KRViewport& viewport, const Matrix4& matModel, const std::vector<KRPointLight*>* point_lights, const std::vector<KRDirectionalLight*>* directional_lights, const std::vector<KRSpotLight*>* spot_lights, const KRRenderPass* renderPass)
{
updateDescriptorBinding();
updateDescriptorSets();
@@ -662,7 +662,7 @@ bool KRPipeline::bind(VkCommandBuffer& commandBuffer, KRCamera& camera, const KR
//int light_point_count = 0;
//int light_spot_count = 0;
// TODO - Need to support multiple lights and more light types in forward rendering
if (renderPass != KRNode::RENDER_PASS_DEFERRED_LIGHTS && renderPass != KRNode::RENDER_PASS_DEFERRED_GBUFFER && renderPass != KRNode::RENDER_PASS_DEFERRED_OPAQUE && renderPass != KRNode::RENDER_PASS_GENERATE_SHADOWMAPS) {
if (renderPass->getType() != RenderPassType::RENDER_PASS_DEFERRED_LIGHTS && renderPass->getType() != RenderPassType::RENDER_PASS_DEFERRED_GBUFFER && renderPass->getType() != RenderPassType::RENDER_PASS_DEFERRED_OPAQUE && renderPass->getType() != RenderPassType::RENDER_PASS_GENERATE_SHADOWMAPS) {
if (directional_lights) {

6
kraken/KRPipeline.h
View File

@@ -207,18 +207,18 @@ public:
CullMode cullMode;
uint32_t vertexAttributes;
ModelFormat modelFormat;
KRNode::RenderPass renderPass;
const KRRenderPass* renderPass;
};
class KRPipeline : public KRContextObject
{
public:
KRPipeline(KRContext& context, KrDeviceHandle deviceHandle, KRRenderPass& renderPass, hydra::Vector2i viewport_size, hydra::Vector2i scissor_size, const PipelineInfo& info, const char* szKey, const std::vector<KRShader*>& shaders, uint32_t vertexAttributes, ModelFormat modelFormat);
KRPipeline(KRContext& context, KrDeviceHandle deviceHandle, KRRenderPass* renderPass, hydra::Vector2i viewport_size, hydra::Vector2i scissor_size, const PipelineInfo& info, const char* szKey, const std::vector<KRShader*>& shaders, uint32_t vertexAttributes, ModelFormat modelFormat);
virtual ~KRPipeline();
const char* getKey() const;
bool bind(VkCommandBuffer& commandBuffer, KRCamera& camera, const KRViewport& viewport, const hydra::Matrix4& matModel, const std::vector<KRPointLight*>* point_lights, const std::vector<KRDirectionalLight*>* directional_lights, const std::vector<KRSpotLight*>* spot_lights, const KRNode::RenderPass& renderPass);
bool bind(VkCommandBuffer& commandBuffer, KRCamera& camera, const KRViewport& viewport, const hydra::Matrix4& matModel, const std::vector<KRPointLight*>* point_lights, const std::vector<KRDirectionalLight*>* directional_lights, const std::vector<KRSpotLight*>* spot_lights, const KRRenderPass* renderPass);
enum class PushConstant : uint8_t
{

11
kraken/KRPipelineManager.cpp
View File

@@ -37,6 +37,7 @@
#include "KRSpotLight.h"
#include "KRPointLight.h"
#include "KRSwapchain.h"
#include "KRRenderPass.h"
#ifndef ANDROID
#include "glslang/Public/ShaderLang.h"
@@ -83,7 +84,7 @@ KRPipeline* KRPipelineManager::getPipeline(KRSurface& surface, const PipelineInf
std::vector<KRShader*> shaders;
shaders.push_back(m_pContext->getShaderManager()->get(*info.shader_name + ".vert", "spv"));
shaders.push_back(m_pContext->getShaderManager()->get(*info.shader_name + ".frag", "spv"));
KRPipeline* pipeline = new KRPipeline(*m_pContext, surface.m_deviceHandle, surface.getForwardOpaquePass(), surface.getDimensions(), surface.getDimensions(), info, info.shader_name->c_str(), shaders, info.vertexAttributes, info.modelFormat);
KRPipeline* pipeline = new KRPipeline(*m_pContext, surface.m_deviceHandle, surface.getRenderPass(RenderPassType::RENDER_PASS_FORWARD_OPAQUE), surface.getDimensions(), surface.getDimensions(), info, info.shader_name->c_str(), shaders, info.vertexAttributes, info.modelFormat);
m_pipelines[key] = pipeline;
@@ -100,7 +101,7 @@ KRPipeline *KRPipelineManager::getPipeline(KRSurface& surface, const PipelineInf
int light_directional_count = 0;
int light_point_count = 0;
int light_spot_count = 0;
if(info.renderPass != KRNode::RENDER_PASS_DEFERRED_LIGHTS && info.renderPass != KRNode::RENDER_PASS_DEFERRED_GBUFFER && info.renderPass != KRNode::RENDER_PASS_DEFERRED_OPAQUE && info.renderPass != KRNode::RENDER_PASS_GENERATE_SHADOWMAPS) {
if(info.renderPass != RenderPassType::RENDER_PASS_DEFERRED_LIGHTS && info.renderPass != RenderPassType::RENDER_PASS_DEFERRED_GBUFFER && info.renderPass != RenderPassType::RENDER_PASS_DEFERRED_OPAQUE && info.renderPass != RenderPassType::RENDER_PASS_GENERATE_SHADOWMAPS) {
if (info.directional_lights) {
light_directional_count = (int)info.directional_lights->size();
}
@@ -236,13 +237,13 @@ KRPipeline *KRPipelineManager::getPipeline(KRSurface& surface, const PipelineInf
stream << "\n#define ENABLE_FADE_COLOR " << (bFadeColorEnabled ? "1" : "0");
stream << "\n#define FOG_TYPE " << info.pCamera->settings.fog_type;
switch(info.renderPass) {
case KRNode::RENDER_PASS_DEFERRED_GBUFFER:
case RenderPassType::RENDER_PASS_DEFERRED_GBUFFER:
stream << "\n#define GBUFFER_PASS " << 1;
break;
case KRNode::RENDER_PASS_DEFERRED_LIGHTS:
case RenderPassType::RENDER_PASS_DEFERRED_LIGHTS:
stream << "\n#define GBUFFER_PASS " << 2;
break;
case KRNode::RENDER_PASS_DEFERRED_OPAQUE:
case RenderPassType::RENDER_PASS_DEFERRED_OPAQUE:
stream << "\n#define GBUFFER_PASS " << 3;
break;
default:

5
kraken/KRPointLight.cpp
View File

@@ -34,6 +34,7 @@
#include "KRPointLight.h"
#include "KRCamera.h"
#include "KRContext.h"
#include "KRRenderPass.h"
using namespace hydra;
@@ -78,9 +79,9 @@ void KRPointLight::render(RenderInfo& ri)
KRLight::render(ri);
bool bVisualize = ri.renderPass == KRNode::RENDER_PASS_FORWARD_TRANSPARENT && ri.camera->settings.bShowDeferred;
bool bVisualize = ri.renderPass->getType() == RenderPassType::RENDER_PASS_FORWARD_TRANSPARENT && ri.camera->settings.bShowDeferred;
if (ri.renderPass == KRNode::RENDER_PASS_DEFERRED_LIGHTS || bVisualize) {
if (ri.renderPass->getType() == RenderPassType::RENDER_PASS_DEFERRED_LIGHTS || bVisualize) {
// Lights are rendered on the second pass of the deferred renderer
std::vector<KRPointLight*> this_light;

29
kraken/KRRenderGraph.cpp
View File

@@ -32,6 +32,7 @@
#include "KRRenderGraph.h"
#include "KRRenderPass.h"
#include "KRSurface.h"
#include "KRDevice.h"
KRRenderGraph::KRRenderGraph(KRContext& context)
: KRContextObject(context)
@@ -43,16 +44,34 @@ KRRenderGraph::~KRRenderGraph()
{
}
void KRRenderGraph::addRenderPass(KRRenderPass *pass)
void KRRenderGraph::addRenderPass(KRDevice& device, const RenderPassInfo& info)
{
m_renderPasses.push_back(pass);
KRRenderPass &pass = m_renderPasses.emplace_back(getContext());
pass.create(device, info);
}
KRRenderPass* KRRenderGraph::getRenderPass(RenderPassType type)
{
for(KRRenderPass& pass : m_renderPasses) {
if (pass.getType() == type) {
return &pass;
}
}
return nullptr;
}
void KRRenderGraph::render(VkCommandBuffer &commandBuffer, KRSurface& surface)
{
for(KRRenderPass* pass : m_renderPasses) {
pass->begin(commandBuffer, surface);
pass->end(commandBuffer);
for(KRRenderPass& pass : m_renderPasses) {
pass.begin(commandBuffer, surface);
pass.end(commandBuffer);
}
}
void KRRenderGraph::destroy(KRDevice& device)
{
for(KRRenderPass& pass : m_renderPasses) {
pass.destroy(device);
}
m_renderPasses.clear();
}

10
kraken/KRRenderGraph.h
View File

@@ -34,9 +34,13 @@
#include "KREngine-common.h"
#include "KRContextObject.h"
#include "KRRenderPass.h"
class KRRenderPass;
class KRSurface;
class KRDevice;
struct RenderPassInfo;
enum RenderPassType : uint8_t;
class KRRenderGraph : public KRContextObject
{
@@ -44,11 +48,13 @@ public:
KRRenderGraph(KRContext& context);
~KRRenderGraph();
void addRenderPass(KRRenderPass* pass);
void addRenderPass(KRDevice& device, const RenderPassInfo& info);
KRRenderPass* getRenderPass(RenderPassType type);
void render(VkCommandBuffer &commandBuffer, KRSurface& surface);
void destroy(KRDevice& device);
private:
std::vector<KRRenderPass*> m_renderPasses;
std::list<KRRenderPass> m_renderPasses;
};

12
kraken/KRRenderPass.cpp
View File

@@ -48,7 +48,7 @@ KRRenderPass::~KRRenderPass()
assert(m_renderPass == VK_NULL_HANDLE);
}
void KRRenderPass::create(KRDevice& device, VkFormat swapChainImageFormat, VkFormat depthImageFormat, const RenderPassInfo& info)
void KRRenderPass::create(KRDevice& device, const RenderPassInfo& info)
{
if (m_renderPass) {
return;
@@ -56,7 +56,7 @@ void KRRenderPass::create(KRDevice& device, VkFormat swapChainImageFormat, VkFor
m_info = info;
VkAttachmentDescription colorAttachment{};
colorAttachment.format = swapChainImageFormat;
colorAttachment.format = info.colorFormat;
colorAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
colorAttachment.loadOp = info.clearColor ? VK_ATTACHMENT_LOAD_OP_CLEAR : VK_ATTACHMENT_LOAD_OP_LOAD;
colorAttachment.storeOp = info.keepColor ? VK_ATTACHMENT_STORE_OP_STORE : VK_ATTACHMENT_STORE_OP_DONT_CARE;
@@ -71,7 +71,7 @@ void KRRenderPass::create(KRDevice& device, VkFormat swapChainImageFormat, VkFor
VkAttachmentDescription depthAttachment{};
depthAttachment.format = depthImageFormat;
depthAttachment.format = info.depthStencilFormat;
depthAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
depthAttachment.loadOp = info.clearDepth ? VK_ATTACHMENT_LOAD_OP_CLEAR : VK_ATTACHMENT_LOAD_OP_LOAD;
depthAttachment.storeOp = info.keepDepth ? VK_ATTACHMENT_STORE_OP_STORE : VK_ATTACHMENT_STORE_OP_DONT_CARE;
@@ -152,3 +152,9 @@ void KRRenderPass::end(VkCommandBuffer& commandBuffer)
{
vkCmdEndRenderPass(commandBuffer);
}
RenderPassType KRRenderPass::getType() const
{
return m_info.type;
}

58
kraken/KRRenderPass.h
View File

@@ -36,32 +36,60 @@
class KRSurface;
enum RenderPassType : uint8_t
{
RENDER_PASS_FORWARD_OPAQUE,
RENDER_PASS_DEFERRED_GBUFFER,
RENDER_PASS_DEFERRED_LIGHTS,
RENDER_PASS_DEFERRED_OPAQUE,
RENDER_PASS_FORWARD_TRANSPARENT,
RENDER_PASS_PARTICLE_OCCLUSION,
RENDER_PASS_ADDITIVE_PARTICLES,
RENDER_PASS_VOLUMETRIC_EFFECTS_ADDITIVE,
RENDER_PASS_GENERATE_SHADOWMAPS,
RENDER_PASS_SHADOWMAP,
RENDER_PASS_PRESTREAM,
RENDER_PASS_POST_COMPOSITE,
RENDER_PASS_DEBUG_OVERLAYS,
RENDER_PASS_BLACK_FRAME,
};
struct RenderPassInfo
{
RenderPassType type;
bool clearColor;
bool keepColor;
hydra::Vector4 clearColorValue;
VkFormat colorFormat;
bool clearDepth;
bool keepDepth;
float clearDepthValue;
bool clearStencil;
bool keepStencil;
uint32_t clearStencilValue;
VkFormat depthStencilFormat;
bool finalPass;
};
class KRRenderPass : public KRContextObject
{
public:
KRRenderPass(KRContext& context);
~KRRenderPass();
struct RenderPassInfo
{
bool clearColor;
bool keepColor;
bool clearDepth;
bool keepDepth;
bool clearStencil;
bool keepStencil;
bool finalPass;
hydra::Vector4 clearColorValue;
float clearDepthValue;
uint32_t clearStencilValue;
};
void create(KRDevice& device, VkFormat swapChainImageFormat, VkFormat depthImageFormat, const RenderPassInfo& info);
void create(KRDevice& device, const RenderPassInfo& info);
void destroy(KRDevice& device);
void begin(VkCommandBuffer& commandBuffer, KRSurface& surface);
void end(VkCommandBuffer& commandBuffer);
RenderPassType getType() const;
// private:
VkRenderPass m_renderPass;
RenderPassInfo m_info;

3
kraken/KRReverbZone.cpp
View File

@@ -31,6 +31,7 @@
#include "KRReverbZone.h"
#include "KRContext.h"
#include "KRRenderPass.h"
using namespace hydra;
@@ -126,7 +127,7 @@ void KRReverbZone::render(RenderInfo& ri)
bool bVisualize = ri.camera->settings.debug_display == KRRenderSettings::KRENGINE_DEBUG_DISPLAY_SIREN_REVERB_ZONES;
if (ri.renderPass == KRNode::RENDER_PASS_FORWARD_TRANSPARENT && bVisualize) {
if (ri.renderPass->getType()== RenderPassType::RENDER_PASS_FORWARD_TRANSPARENT && bVisualize) {
KRMesh* sphereModel = getContext().getMeshManager()->getMaxLODModel("__sphere");
if (sphereModel) {
Matrix4 sphereModelMatrix = getModelMatrix();

11
kraken/KRScene.cpp
View File

@@ -39,6 +39,7 @@
#include "KRSpotLight.h"
#include "KRPointLight.h"
#include "KRAudioManager.h"
#include "KRRenderPass.h"
using namespace mimir;
using namespace hydra;
@@ -102,7 +103,7 @@ std::set<KRLight*>& KRScene::getLights()
return m_lights;
}
void KRScene::render(VkCommandBuffer& commandBuffer, KRSurface& surface, KRCamera* pCamera, unordered_map<AABB, int>& visibleBounds, const KRViewport& viewport, KRNode::RenderPass renderPass, bool new_frame)
void KRScene::render(VkCommandBuffer& commandBuffer, KRSurface& surface, KRCamera* pCamera, unordered_map<AABB, int>& visibleBounds, const KRViewport& viewport, const KRRenderPass* renderPass, bool new_frame)
{
if (new_frame) {
// Expire cached occlusion test results.
@@ -217,7 +218,7 @@ void KRScene::render(KRNode::RenderInfo& ri, KROctreeNode* pOctreeNode, unordere
}
} else {
bool in_viewport = false;
if (ri.renderPass == KRNode::RENDER_PASS_PRESTREAM) {
if (ri.renderPass->getType() == RenderPassType::RENDER_PASS_PRESTREAM) {
// When pre-streaming, objects are streamed in behind and in-front of the camera
AABB viewportExtents = AABB::Create(ri.viewport.getCameraPosition() - Vector3::Create(ri.camera->settings.getPerspectiveFarZ()), ri.viewport.getCameraPosition() + Vector3::Create(ri.camera->settings.getPerspectiveFarZ()));
in_viewport = octreeBounds.intersects(viewportExtents);
@@ -299,7 +300,7 @@ void KRScene::render(KRNode::RenderInfo& ri, KROctreeNode* pOctreeNode, unordere
info.point_lights = &ri.point_lights;
info.directional_lights = &ri.directional_lights;
info.spot_lights = &ri.spot_lights;
info.renderPass = KRNode::RENDER_PASS_FORWARD_TRANSPARENT;
info.renderPass = ri.renderPass;
info.rasterMode = RasterMode::kAdditive;
info.vertexAttributes = vertices.getVertexAttributes();
info.modelFormat = ModelFormat::KRENGINE_MODEL_FORMAT_STRIP;
@@ -307,7 +308,7 @@ void KRScene::render(KRNode::RenderInfo& ri, KROctreeNode* pOctreeNode, unordere
KRPipeline* pPipeline = getContext().getPipelineManager()->getPipeline(*ri.surface, info);
pPipeline->bind(ri.commandBuffer, *info.pCamera, ri.viewport, matModel, info.point_lights, info.directional_lights, info.spot_lights, info.renderPass);
vkCmdDraw(ri.commandBuffer, 14, 1, 0, 0);
m_pContext->getMeshManager()->log_draw_call(ri.renderPass, "octree", "occlusion_test", 14);
m_pContext->getMeshManager()->log_draw_call(ri.renderPass->getType(), "octree", "occlusion_test", 14);
pOctreeNode->endOcclusionQuery();
@@ -352,7 +353,7 @@ void KRScene::render(KRNode::RenderInfo& ri, KROctreeNode* pOctreeNode, unordere
}
// Render child octrees
const int* childOctreeOrder = ri.renderPass == KRNode::RENDER_PASS_FORWARD_TRANSPARENT || ri.renderPass == KRNode::RENDER_PASS_ADDITIVE_PARTICLES || ri.renderPass == KRNode::RENDER_PASS_VOLUMETRIC_EFFECTS_ADDITIVE ? ri.viewport.getBackToFrontOrder() : ri.viewport.getFrontToBackOrder();
const int* childOctreeOrder = ri.renderPass->getType() == RenderPassType::RENDER_PASS_FORWARD_TRANSPARENT || ri.renderPass->getType() == RenderPassType::RENDER_PASS_ADDITIVE_PARTICLES || ri.renderPass->getType() == RenderPassType::RENDER_PASS_VOLUMETRIC_EFFECTS_ADDITIVE ? ri.viewport.getBackToFrontOrder() : ri.viewport.getFrontToBackOrder();
for (int i = 0; i < 8; i++) {
render(ri, pOctreeNode->getChildren()[childOctreeOrder[i]], visibleBounds, remainingOctrees, remainingOctreesTestResults, remainingOctreesTestResultsOnly, false, false);

2
kraken/KRScene.h
View File

@@ -71,7 +71,7 @@ public:
bool sphereCast(const hydra::Vector3& v0, const hydra::Vector3& v1, float radius, hydra::HitInfo& hitinfo, unsigned int layer_mask);
void renderFrame(VkCommandBuffer& commandBuffer, KRSurface& surface, float deltaTime);
void render(VkCommandBuffer& commandBuffer, KRSurface& surface, KRCamera* pCamera, unordered_map<hydra::AABB, int>& visibleBounds, const KRViewport& viewport, KRNode::RenderPass renderPass, bool new_frame);
void render(VkCommandBuffer& commandBuffer, KRSurface& surface, KRCamera* pCamera, unordered_map<hydra::AABB, int>& visibleBounds, const KRViewport& viewport, const KRRenderPass* renderPass, bool new_frame);
void render(KRNode::RenderInfo& ri, KROctreeNode* pOctreeNode, unordered_map<hydra::AABB, int>& visibleBounds, std::vector<KROctreeNode*>& remainingOctrees, std::vector<KROctreeNode*>& remainingOctreesTestResults, std::vector<KROctreeNode*>& remainingOctreesTestResultsOnly, bool bOcclusionResultsPass, bool bOcclusionTestResultsOnly);
void updateOctree(const KRViewport& viewport);

5
kraken/KRSprite.cpp
View File

@@ -42,6 +42,7 @@
#include "KRDirectionalLight.h"
#include "KRSpotLight.h"
#include "KRPointLight.h"
#include "KRRenderPass.h"
using namespace hydra;
@@ -118,7 +119,7 @@ AABB KRSprite::getBounds()
void KRSprite::render(RenderInfo& ri)
{
if (m_lod_visible >= LOD_VISIBILITY_PRESTREAM && ri.renderPass == KRNode::RENDER_PASS_PRESTREAM) {
if (m_lod_visible >= LOD_VISIBILITY_PRESTREAM && ri.renderPass->getType() == RenderPassType::RENDER_PASS_PRESTREAM) {
// Pre-stream sprites, even if the alpha is zero
if (m_spriteTexture.size() && m_pSpriteTexture == NULL) {
if (!m_pSpriteTexture && m_spriteTexture.size()) {
@@ -136,7 +137,7 @@ void KRSprite::render(RenderInfo& ri)
KRNode::render(ri);
if (ri.renderPass == KRNode::RENDER_PASS_ADDITIVE_PARTICLES) {
if (ri.renderPass->getType() == RenderPassType::RENDER_PASS_ADDITIVE_PARTICLES) {
if (m_spriteTexture.size() && m_spriteAlpha > 0.0f) {

109
kraken/KRSurface.cpp
View File

@@ -45,16 +45,10 @@ KRSurface::KRSurface(KRContext& context, KrSurfaceHandle handle, void* platformH
, m_renderFinishedSemaphores{VK_NULL_HANDLE}
, m_inFlightFences{VK_NULL_HANDLE}
, m_frameIndex(0)
, m_renderGraph(context)
, m_blackFrameRenderGraph(context)
, m_renderGraph(std::make_unique<KRRenderGraph>(context))
, m_blackFrameRenderGraph(std::make_unique<KRRenderGraph>(context))
, m_swapChain(std::make_unique<KRSwapchain>(context))
{
m_forwardOpaquePass = std::make_unique<KRRenderPass>(context);
m_deferredGBufferPass = std::make_unique<KRRenderPass>(context);
m_deferredOpaquePass = std::make_unique<KRRenderPass>(context);
m_postCompositePass = std::make_unique<KRRenderPass>(context);
m_debugPass = std::make_unique<KRRenderPass>(context);
m_blackFramePass = std::make_unique<KRRenderPass>(context);
m_swapChain = std::make_unique<KRSwapchain>(context);
}
KRSurface::~KRSurface()
@@ -117,30 +111,8 @@ void KRSurface::destroy()
destroySwapChain();
std::unique_ptr<KRDevice>& device = m_pContext->getDeviceManager()->getDevice(m_deviceHandle);
if (m_forwardOpaquePass) {
m_forwardOpaquePass->destroy(*device);
}
if (m_deferredGBufferPass) {
m_deferredGBufferPass->destroy(*device);
}
if (m_deferredOpaquePass) {
m_deferredOpaquePass->destroy(*device);
}
if (m_postCompositePass) {
m_postCompositePass->destroy(*device);
}
if (m_debugPass) {
m_debugPass->destroy(*device);
}
if (m_blackFramePass) {
m_blackFramePass->destroy(*device);
}
m_renderGraph->destroy(*device);
m_blackFrameRenderGraph->destroy(*device);
for (int i=0; i < KRENGINE_MAX_FRAMES_IN_FLIGHT; i++) {
if (device && m_renderFinishedSemaphores[i] != VK_NULL_HANDLE) {
@@ -200,10 +172,11 @@ KrResult KRSurface::createSwapChain()
}
KRRenderPass::RenderPassInfo info{};
RenderPassInfo info{};
info.clearColor = true;
info.keepColor = true;
info.clearColorValue = Vector4::Zero();
info.colorFormat = selectedSurfaceFormat.format;
info.clearDepth = true;
info.keepDepth = true;
@@ -212,52 +185,61 @@ KrResult KRSurface::createSwapChain()
info.clearStencil = true;
info.keepStencil = true;
info.clearStencilValue = 0;
info.depthStencilFormat = depthImageFormat;
info.finalPass = false;
m_forwardOpaquePass->create(*device, selectedSurfaceFormat.format, depthImageFormat, info);
m_renderGraph.addRenderPass(m_forwardOpaquePass.get());
info.type = RenderPassType::RENDER_PASS_FORWARD_OPAQUE;
m_renderGraph->addRenderPass(*device, info);
info.clearColor = true;
info.keepColor = true;
info.clearDepth = true;
info.keepDepth = true;
info.finalPass = false;
m_deferredGBufferPass->create(*device, selectedSurfaceFormat.format, depthImageFormat, info);
m_renderGraph.addRenderPass(m_deferredGBufferPass.get());
info.type = RenderPassType::RENDER_PASS_DEFERRED_GBUFFER;
m_renderGraph->addRenderPass(*device, info);
info.clearColor = false;
info.keepColor = true;
info.clearDepth = false;
info.keepDepth = true;
info.finalPass = false;
m_deferredOpaquePass->create(*device, selectedSurfaceFormat.format, depthImageFormat, info);
m_renderGraph.addRenderPass(m_deferredOpaquePass.get());
info.type = RenderPassType::RENDER_PASS_DEFERRED_LIGHTS;
m_renderGraph->addRenderPass(*device, info);
info.clearColor = false;
info.keepColor = true;
info.clearDepth = false;
info.keepDepth = true;
info.finalPass = false;
m_debugPass->create(*device, selectedSurfaceFormat.format, depthImageFormat, info);
m_renderGraph.addRenderPass(m_debugPass.get());
info.type = RenderPassType::RENDER_PASS_DEFERRED_OPAQUE;
m_renderGraph->addRenderPass(*device, info);
info.clearColor = false;
info.keepColor = true;
info.clearDepth = false;
info.keepDepth = true;
info.finalPass = false;
info.type = RenderPassType::RENDER_PASS_DEBUG_OVERLAYS;
m_renderGraph->addRenderPass(*device, info);
info.clearColor = false;
info.keepColor = true;
info.clearDepth = false;
info.keepDepth = false;
info.finalPass = true;
m_postCompositePass->create(*device, selectedSurfaceFormat.format, depthImageFormat, info);
m_renderGraph.addRenderPass(m_postCompositePass.get());
info.type = RenderPassType::RENDER_PASS_POST_COMPOSITE;
m_renderGraph->addRenderPass(*device, info);
info.clearColor = true;
info.keepColor = true;
info.clearDepth = true;
info.keepDepth = false;
info.finalPass = true;
m_blackFramePass->create(*device, selectedSurfaceFormat.format, depthImageFormat, info);
info.type = RenderPassType::RENDER_PASS_BLACK_FRAME;
m_blackFrameRenderGraph->addRenderPass(*device, info);
m_blackFrameRenderGraph.addRenderPass(m_blackFramePass.get());
m_swapChain->create(*device, m_surface, selectedSurfaceFormat, depthImageFormat, swapExtent, imageCount, *m_forwardOpaquePass);
m_swapChain->create(*device, m_surface, selectedSurfaceFormat, depthImageFormat, swapExtent, imageCount, *m_renderGraph->getRenderPass(RenderPassType::RENDER_PASS_FORWARD_OPAQUE));
return KR_SUCCESS;
}
@@ -310,34 +292,9 @@ VkFormat KRSurface::getDepthFormat() const
return m_swapChain->m_depthFormat;
}
KRRenderPass& KRSurface::getForwardOpaquePass()
KRRenderPass* KRSurface::getRenderPass(RenderPassType type)
{
return *m_forwardOpaquePass;
}
KRRenderPass& KRSurface::getDeferredGBufferPass()
{
return *m_deferredGBufferPass;
}
KRRenderPass& KRSurface::getDeferredOpaquePass()
{
return *m_deferredOpaquePass;
}
KRRenderPass& KRSurface::getPostCompositePass()
{
return *m_postCompositePass;
}
KRRenderPass& KRSurface::getDebugPass()
{
return *m_debugPass;
}
KRRenderPass& KRSurface::getBlackFramePass()
{
return *m_blackFramePass;
return m_renderGraph->getRenderPass(type);
}
void KRSurface::endFrame()
@@ -348,5 +305,5 @@ void KRSurface::endFrame()
void KRSurface::renderBlackFrame(VkCommandBuffer &commandBuffer)
{
m_blackFrameRenderGraph.render(commandBuffer, *this);
m_blackFrameRenderGraph->render(commandBuffer, *this);
}

20
kraken/KRSurface.h
View File

@@ -38,6 +38,7 @@
class KRDevice;
class KRRenderPass;
class KRSwapchain;
class KRRenderGraph;
class KRSurface : public KRContextObject
{
@@ -57,13 +58,7 @@ public:
KrResult initialize();
KrResult recreateSwapChain();
KRRenderPass& getForwardOpaquePass();
KRRenderPass& getDeferredGBufferPass();
KRRenderPass& getDeferredOpaquePass();
KRRenderPass& getPostCompositePass();
KRRenderPass& getDebugPass();
KRRenderPass& getBlackFramePass();
KRRenderPass* getRenderPass(RenderPassType type);
void endFrame();
KrSurfaceHandle m_handle;
@@ -77,13 +72,6 @@ public:
VkFence m_inFlightFences[KRENGINE_MAX_FRAMES_IN_FLIGHT];
std::unique_ptr<KRSwapchain> m_swapChain;
std::unique_ptr<KRRenderPass> m_forwardOpaquePass;
std::unique_ptr<KRRenderPass> m_deferredGBufferPass;
std::unique_ptr<KRRenderPass> m_deferredOpaquePass;
std::unique_ptr<KRRenderPass> m_postCompositePass;
std::unique_ptr<KRRenderPass> m_debugPass;
std::unique_ptr<KRRenderPass> m_blackFramePass;
// TODO - This needs to be advanced per swap chain
uint64_t m_frameIndex;
@@ -91,6 +79,6 @@ public:
private:
void destroySwapChain();
KrResult createSwapChain();
KRRenderGraph m_renderGraph;
KRRenderGraph m_blackFrameRenderGraph;
std::unique_ptr<KRRenderGraph> m_renderGraph;
std::unique_ptr<KRRenderGraph> m_blackFrameRenderGraph;
};