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

Remove octree-level fragment query occlusion culling. This will be replaced with a method involving hi-z buffers and mesh shaders.

Browse Source
This commit is contained in:
Kearwood Gilbert
2025-11-30 15:47:27 -08:00
parent b6179a2496
commit 19020e3c01
8 changed files with 54 additions and 287 deletions
Download Patch File Download Diff File Expand all files Collapse all files

39
kraken/KROctreeNode.cpp
View File

@@ -42,10 +42,6 @@ KROctreeNode::KROctreeNode(KROctreeNode* parent, const AABB& bounds) : m_bounds(
for (int i = 0; i < 8; i++) {
m_children[i] = NULL;
}
m_occlusionQuery = 0;
m_occlusionTested = false;
m_activeQuery = false;
}
KROctreeNode::KROctreeNode(KROctreeNode* parent, const AABB& bounds, int iChild, KROctreeNode* pChild) : m_bounds(bounds)
@@ -58,10 +54,6 @@ KROctreeNode::KROctreeNode(KROctreeNode* parent, const AABB& bounds, int iChild,
}
m_children[iChild] = pChild;
pChild->m_parent = this;
m_occlusionQuery = 0;
m_occlusionTested = false;
m_activeQuery = false;
}
KROctreeNode::~KROctreeNode()
@@ -71,37 +63,6 @@ KROctreeNode::~KROctreeNode()
delete m_children[i];
}
}
if (m_occlusionTested) {
GLDEBUG(glDeleteQueriesEXT(1, &m_occlusionQuery));
}
}
void KROctreeNode::beginOcclusionQuery()
{
if (!m_occlusionTested) {
GLDEBUG(glGenQueriesEXT(1, &m_occlusionQuery));
#if TARGET_OS_IPHONE || defined(ANDROID)
GLDEBUG(glBeginQueryEXT(GL_ANY_SAMPLES_PASSED_EXT, m_occlusionQuery));
#else
GLDEBUG(glBeginQuery(GL_SAMPLES_PASSED, m_occlusionQuery));
#endif
m_occlusionTested = true;
m_activeQuery = true;
}
}
void KROctreeNode::endOcclusionQuery()
{
if (m_activeQuery) {
// Only end a query if we started one
#if TARGET_OS_IPHONE || defined(ANDROID)
GLDEBUG(glEndQueryEXT(GL_ANY_SAMPLES_PASSED_EXT));
#else
GLDEBUG(glEndQuery(GL_SAMPLES_PASSED));
#endif
}
}

8
kraken/KROctreeNode.h
View File

@@ -62,14 +62,6 @@ public:
bool canShrinkRoot() const;
KROctreeNode* stripChild();
void beginOcclusionQuery();
void endOcclusionQuery();
int m_occlusionQuery;
bool m_occlusionTested;
bool m_activeQuery;
bool lineCast(const hydra::Vector3& v0, const hydra::Vector3& v1, hydra::HitInfo& hitinfo, unsigned int layer_mask);
bool rayCast(const hydra::Vector3& v0, const hydra::Vector3& dir, hydra::HitInfo& hitinfo, unsigned int layer_mask);
bool sphereCast(const hydra::Vector3& v0, const hydra::Vector3& v1, float radius, hydra::HitInfo& hitinfo, unsigned int layer_mask);

23
kraken/KRViewport.cpp
View File

@@ -210,12 +210,6 @@ void KRViewport::calculateDerivedValues()
}
}
unordered_map<AABB, int>& KRViewport::getVisibleBounds()
{
return m_visibleBounds;
}
float KRViewport::getLODBias() const
{
return m_lodBias;
@@ -314,20 +308,3 @@ bool KRViewport::visible(const AABB& b) const
return is_visible;
}
void KRViewport::expireOcclusionResults(long frame)
{
// Expire cached occlusion test results.
// Cached "failed" results are expired on the next frame (marked with .second of -1)
// Cached "success" results are expired after KRENGINE_OCCLUSION_TEST_EXPIRY frames (marked with .second of the last frame
std::set<AABB> expired_visible_bounds;
for (unordered_map<AABB, int>::iterator visible_bounds_itr = m_visibleBounds.begin(); visible_bounds_itr != m_visibleBounds.end(); visible_bounds_itr++) {
if ((*visible_bounds_itr).second == -1 || (*visible_bounds_itr).second + KRENGINE_OCCLUSION_TEST_EXPIRY < frame) {
expired_visible_bounds.insert((*visible_bounds_itr).first);
}
}
for (std::set<AABB>::iterator expired_visible_bounds_itr = expired_visible_bounds.begin(); expired_visible_bounds_itr != expired_visible_bounds.end(); expired_visible_bounds_itr++) {
m_visibleBounds.erase(*expired_visible_bounds_itr);
}
}

5
kraken/KRViewport.h
View File

@@ -69,14 +69,11 @@ public:
// Overload assignment operator
KRViewport& operator=(const KRViewport& v);
unordered_map<hydra::AABB, int>& getVisibleBounds();
const std::set<KRLight*>& getVisibleLights();
void setVisibleLights(const std::set<KRLight*> visibleLights);
bool visible(const hydra::AABB& b) const;
float coverage(const hydra::AABB& b) const;
void expireOcclusionResults(long frame);
private:
hydra::Vector2 m_size;
@@ -96,6 +93,4 @@ private:
int m_backToFrontOrder[8];
void calculateDerivedValues();
unordered_map<hydra::AABB, int> m_visibleBounds; // AABB's that output fragments in the last frame
};

15
kraken/nodes/KRCamera.cpp
View File

@@ -181,6 +181,8 @@ void KRCamera::render(KRNode::RenderInfo& ri)
{
// ----====---- Debug Overlays ----====----
/*
* // TODO: Implement octree visualization that is not dependent on the no longer present fragment query based occlusion testing
if (settings.debug_display == KRRenderSettings::KRENGINE_DEBUG_DISPLAY_OCTREE) {
KRMeshManager::KRVBOData& vertices = getContext().getMeshManager()->KRENGINE_VBO_DATA_3D_CUBE_VERTICES;
@@ -193,17 +195,8 @@ void KRCamera::render(KRNode::RenderInfo& ri)
info.vertexAttributes = vertices.getVertexAttributes();
info.modelFormat = ModelFormat::KRENGINE_MODEL_FORMAT_STRIP;
KRPipeline* pVisShader = getContext().getPipelineManager()->getPipeline(*ri.surface, info);
m_pContext->getMeshManager()->bindVBO(ri.commandBuffer, &vertices, 1.0f);
for (unordered_map<AABB, int>::iterator itr = m_viewport.getVisibleBounds().begin(); itr != m_viewport.getVisibleBounds().end(); itr++) {
Matrix4 matModel = Matrix4();
matModel.scale((*itr).first.size() * 0.5f);
matModel.translate((*itr).first.center());
pVisShader->bind(ri, matModel);
vkCmdDraw(ri.commandBuffer, 14, 1, 0, 0);
}
}
*/
renderDebug(ri);
}
@@ -259,8 +252,6 @@ void KRCamera::renderFrame(VkCommandBuffer& commandBuffer, KRSurface& compositeS
scene.updateOctree(m_viewport);
m_viewport.expireOcclusionResults(getContext().getCurrentFrame());
renderGraph.render(commandBuffer, compositeSurface, this);
}

1
kraken/nodes/KRLight.cpp
View File

@@ -477,7 +477,6 @@ void KRLight::renderShadowBuffers(RenderInfo& ri)
ri.viewport = &m_shadowViewports[iShadow];
shadowShader->bind(ri, Matrix4());
m_shadowViewports[iShadow].expireOcclusionResults(m_pContext->getCurrentFrame());
getScene().render(ri);
}
}

247
kraken/resources/scene/KRScene.cpp
View File

@@ -146,31 +146,15 @@ void KRScene::render(KRNode::RenderInfo& ri)
}
std::vector<KROctreeNode*> remainingOctrees;
std::vector<KROctreeNode*> remainingOctreesTestResults;
std::vector<KROctreeNode*> remainingOctreesTestResultsOnly;
if (m_nodeTree.getRootNode() != NULL) {
remainingOctrees.push_back(m_nodeTree.getRootNode());
}
std::vector<KROctreeNode*> newRemainingOctrees;
std::vector<KROctreeNode*> newRemainingOctreesTestResults;
while ((!remainingOctrees.empty() || !remainingOctreesTestResults.empty())) {
newRemainingOctrees.clear();
newRemainingOctreesTestResults.clear();
while ((!remainingOctrees.empty())) {
for (std::vector<KROctreeNode*>::iterator octree_itr = remainingOctrees.begin(); octree_itr != remainingOctrees.end(); octree_itr++) {
render(ri, resourceRequests, *octree_itr, newRemainingOctrees, newRemainingOctreesTestResults, remainingOctreesTestResultsOnly);
render(ri, resourceRequests, *octree_itr);
}
for (std::vector<KROctreeNode*>::iterator octree_itr = remainingOctreesTestResults.begin(); octree_itr != remainingOctreesTestResults.end(); octree_itr++) {
render_occlusionResultsPass(ri, *octree_itr, newRemainingOctrees, false);
}
remainingOctrees = newRemainingOctrees;
remainingOctreesTestResults = newRemainingOctreesTestResults;
}
newRemainingOctrees.clear();
newRemainingOctreesTestResults.clear();
for (std::vector<KROctreeNode*>::iterator octree_itr = remainingOctreesTestResultsOnly.begin(); octree_itr != remainingOctreesTestResultsOnly.end(); octree_itr++) {
render_occlusionResultsPass(ri, *octree_itr, newRemainingOctrees, true);
remainingOctrees.clear();
}
// TODO: WIP Refactoring, this will be moved to the streaming system
@@ -179,9 +163,8 @@ void KRScene::render(KRNode::RenderInfo& ri)
}
}
void KRScene::render(KRNode::RenderInfo& ri, std::list<KRResourceRequest>& resourceRequests, KROctreeNode* pOctreeNode, std::vector<KROctreeNode*>& remainingOctrees, std::vector<KROctreeNode*>& remainingOctreesTestResults, std::vector<KROctreeNode*>& remainingOctreesTestResultsOnly)
void KRScene::render(KRNode::RenderInfo& ri, std::list<KRResourceRequest>& resourceRequests, KROctreeNode* pOctreeNode)
{
unordered_map<AABB, int>& visibleBounds = ri.viewport->getVisibleBounds();
if (pOctreeNode) {
AABB octreeBounds = pOctreeNode->getBounds();
@@ -196,198 +179,68 @@ void KRScene::render(KRNode::RenderInfo& ri, std::list<KRResourceRequest>& resou
}
if (in_viewport) {
// ----====---- Rendering and occlusion test pass ----====----
bool bVisible = false;
bool bNeedOcclusionTest = true;
if (!ri.camera->settings.getEnableRealtimeOcclusion()) {
bVisible = true;
bNeedOcclusionTest = false;
}
if (!bVisible) {
// Assume bounding boxes are visible without occlusion test queries if the camera is inside the box.
// The near clipping plane of the camera is taken into consideration by expanding the match area
AABB cameraExtents = AABB::Create(ri.viewport->getCameraPosition() - Vector3::Create(ri.camera->settings.getPerspectiveNearZ()), ri.viewport->getCameraPosition() + Vector3::Create(ri.camera->settings.getPerspectiveNearZ()));
bVisible = octreeBounds.intersects(cameraExtents);
if (bVisible) {
// Record the frame number in which the camera was within the bounds
visibleBounds[octreeBounds] = getContext().getCurrentFrame();
bNeedOcclusionTest = false;
// Add lights that influence this octree level and its children to the stack
int directional_light_count = 0;
int spot_light_count = 0;
int point_light_count = 0;
for (std::set<KRNode*>::iterator itr = pOctreeNode->getSceneNodes().begin(); itr != pOctreeNode->getSceneNodes().end(); itr++) {
KRNode* node = (*itr);
KRDirectionalLight* directional_light = dynamic_cast<KRDirectionalLight*>(node);
if (directional_light) {
ri.directional_lights.push_back(directional_light);
directional_light_count++;
}
KRSpotLight* spot_light = dynamic_cast<KRSpotLight*>(node);
if (spot_light) {
ri.spot_lights.push_back(spot_light);
spot_light_count++;
}
KRPointLight* point_light = dynamic_cast<KRPointLight*>(node);
if (point_light) {
ri.point_lights.push_back(point_light);
point_light_count++;
}
}
if (!bVisible) {
// Check if a previous occlusion query has returned true, taking advantage of temporal consistency of visible elements from frame to frame
// If the previous frame rendered this octree, then attempt to render it in this frame without performing a pre-occlusion test
unordered_map<AABB, int>::iterator match_itr = visibleBounds.find(octreeBounds);
if (match_itr != visibleBounds.end()) {
if ((*match_itr).second == -1) {
// We have already tested these bounds with a negative result
bNeedOcclusionTest = false;
} else {
bVisible = true;
// We set bNeedOcclusionTest to false only when the previous occlusion test is old and we need to perform an occlusion test to record if this octree node was visible for the next frame
bNeedOcclusionTest = false;
// Render objects that are at this octree level
for (std::set<KRNode*>::iterator itr = pOctreeNode->getSceneNodes().begin(); itr != pOctreeNode->getSceneNodes().end(); itr++) {
//assert(pOctreeNode->getBounds().contains((*itr)->getBounds())); // Sanity check
if (ri.renderPass->getType() == RenderPassType::RENDER_PASS_PRESTREAM) {
if ((*itr)->getLODVisibility() >= KRNode::LOD_VISIBILITY_PRESTREAM) {
(*itr)->preStream(*ri.viewport, resourceRequests);
}
}
}
if (!bVisible && bNeedOcclusionTest) {
// Optimization: If this is an empty octree node with only a single child node, then immediately try to render the child node without an occlusion test for this higher level, as it would be more expensive than the occlusion test for the child
if (pOctreeNode->getSceneNodes().empty()) {
int child_count = 0;
for (int i = 0; i < 8; i++) {
if (pOctreeNode->getChildren()[i] != NULL) child_count++;
}
if (child_count == 1) {
bVisible = true;
bNeedOcclusionTest = false;
}
}
}
if (bNeedOcclusionTest) {
pOctreeNode->beginOcclusionQuery();
Matrix4 matModel = Matrix4();
matModel.scale(octreeBounds.size() * 0.5f);
matModel.translate(octreeBounds.center());
Matrix4 mvpmatrix = matModel * ri.viewport->getViewProjectionMatrix();
KRMeshManager::KRVBOData& vertices = getContext().getMeshManager()->KRENGINE_VBO_DATA_3D_CUBE_VERTICES;
getContext().getMeshManager()->bindVBO(ri.commandBuffer, &vertices, 1.0f);
PipelineInfo info{};
std::string shader_name("occlusion_test");
info.shader_name = &shader_name;
info.pCamera = ri.camera;
info.point_lights = &ri.point_lights;
info.directional_lights = &ri.directional_lights;
info.spot_lights = &ri.spot_lights;
info.renderPass = ri.renderPass;
info.rasterMode = RasterMode::kAdditive;
info.vertexAttributes = vertices.getVertexAttributes();
info.modelFormat = ModelFormat::KRENGINE_MODEL_FORMAT_STRIP;
KRPipeline* pPipeline = getContext().getPipelineManager()->getPipeline(*ri.surface, info);
pPipeline->bind(ri, matModel);
vkCmdDraw(ri.commandBuffer, 14, 1, 0, 0);
m_pContext->getMeshManager()->log_draw_call(ri.renderPass->getType(), "octree", "occlusion_test", 14);
pOctreeNode->endOcclusionQuery();
if (bVisible) {
// Schedule a pass to get the result of the occlusion test only for future frames and passes, without rendering the model or recurring further
remainingOctreesTestResultsOnly.push_back(pOctreeNode);
} else {
// Schedule a pass to get the result of the occlusion test and continue recursion and rendering if test is true
remainingOctreesTestResults.push_back(pOctreeNode);
if ((*itr)->getLODVisibility() > KRNode::LOD_VISIBILITY_PRESTREAM)
{
ri.reflectedObjects.push_back(*itr);
(*itr)->render(ri);
ri.reflectedObjects.pop_back();
}
}
}
if (bVisible) {
// Render child octrees
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();
// Add lights that influence this octree level and its children to the stack
int directional_light_count = 0;
int spot_light_count = 0;
int point_light_count = 0;
for (std::set<KRNode*>::iterator itr = pOctreeNode->getSceneNodes().begin(); itr != pOctreeNode->getSceneNodes().end(); itr++) {
KRNode* node = (*itr);
KRDirectionalLight* directional_light = dynamic_cast<KRDirectionalLight*>(node);
if (directional_light) {
ri.directional_lights.push_back(directional_light);
directional_light_count++;
}
KRSpotLight* spot_light = dynamic_cast<KRSpotLight*>(node);
if (spot_light) {
ri.spot_lights.push_back(spot_light);
spot_light_count++;
}
KRPointLight* point_light = dynamic_cast<KRPointLight*>(node);
if (point_light) {
ri.point_lights.push_back(point_light);
point_light_count++;
}
}
for (int i = 0; i < 8; i++) {
render(ri, resourceRequests, pOctreeNode->getChildren()[childOctreeOrder[i]]);
}
// Render objects that are at this octree level
for (std::set<KRNode*>::iterator itr = pOctreeNode->getSceneNodes().begin(); itr != pOctreeNode->getSceneNodes().end(); itr++) {
//assert(pOctreeNode->getBounds().contains((*itr)->getBounds())); // Sanity check
if (ri.renderPass->getType() == RenderPassType::RENDER_PASS_PRESTREAM) {
if ((*itr)->getLODVisibility() >= KRNode::LOD_VISIBILITY_PRESTREAM) {
(*itr)->preStream(*ri.viewport, resourceRequests);
}
} else {
if ((*itr)->getLODVisibility() > KRNode::LOD_VISIBILITY_PRESTREAM)
{
ri.reflectedObjects.push_back(*itr);
(*itr)->render(ri);
ri.reflectedObjects.pop_back();
}
}
}
// Render child octrees
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, resourceRequests, pOctreeNode->getChildren()[childOctreeOrder[i]], remainingOctrees, remainingOctreesTestResults, remainingOctreesTestResultsOnly);
}
// Remove lights added at this octree level from the stack
while (directional_light_count--) {
ri.directional_lights.pop_back();
}
while (spot_light_count--) {
ri.spot_lights.pop_back();
}
while (point_light_count--) {
ri.point_lights.pop_back();
}
// Remove lights added at this octree level from the stack
while (directional_light_count--) {
ri.directional_lights.pop_back();
}
while (spot_light_count--) {
ri.spot_lights.pop_back();
}
while (point_light_count--) {
ri.point_lights.pop_back();
}
}
}
}
void KRScene::render_occlusionResultsPass(KRNode::RenderInfo& ri, KROctreeNode* pOctreeNode, std::vector<KROctreeNode*>& remainingOctrees, bool bOcclusionTestResultsOnly)
{
unordered_map<AABB, int>& visibleBounds = ri.viewport->getVisibleBounds();
if (pOctreeNode) {
AABB octreeBounds = pOctreeNode->getBounds();
// ----====---- Occlusion results pass ----====----
if (pOctreeNode->m_occlusionTested) {
int params = 0;
GLDEBUG(glGetQueryObjectuivEXT(pOctreeNode->m_occlusionQuery, GL_QUERY_RESULT_EXT, &params));
if (params) {
// Record the frame number that the test has passed on
visibleBounds[octreeBounds] = getContext().getCurrentFrame();
if (!bOcclusionTestResultsOnly) {
// Schedule a pass to perform the rendering
remainingOctrees.push_back(pOctreeNode);
}
} else {
// Record -1 to indicate that the visibility test had failed
visibleBounds[octreeBounds] = -1;
}
GLDEBUG(glDeleteQueriesEXT(1, &pOctreeNode->m_occlusionQuery));
pOctreeNode->m_occlusionTested = false;
pOctreeNode->m_occlusionQuery = 0;
}
}
// fprintf(stderr, "Octree culled: (%f, %f, %f) - (%f, %f, %f)\n", pOctreeNode->getBounds().min.x, pOctreeNode->getBounds().min.y, pOctreeNode->getBounds().min.z, pOctreeNode->getBounds().max.x, pOctreeNode->getBounds().max.y, pOctreeNode->getBounds().max.z);
}
std::string KRScene::getExtension()
{
return "krscene";

3
kraken/resources/scene/KRScene.h
View File

@@ -92,8 +92,7 @@ public:
std::set<KRLight*>& getLights();
private:
void render(KRNode::RenderInfo& ri, std::list<KRResourceRequest>& resourceRequests, KROctreeNode* pOctreeNode, std::vector<KROctreeNode*>& remainingOctrees, std::vector<KROctreeNode*>& remainingOctreesTestResults, std::vector<KROctreeNode*>& remainingOctreesTestResultsOnly);
void render_occlusionResultsPass(KRNode::RenderInfo& ri, KROctreeNode* pOctreeNode, std::vector<KROctreeNode*>& remainingOctrees, bool bOcclusionTestResultsOnly);
void render(KRNode::RenderInfo& ri, std::list<KRResourceRequest>& resourceRequests, KROctreeNode* pOctreeNodey);
KRNode* m_pRootNode;