From 5de09d07e99a46cfd67ea2d937a4b74ec17a006c Mon Sep 17 00:00:00 2001 From: shenlei Date: Mon, 12 Oct 2026 18:09:31 +0900 Subject: [PATCH] Sort blended draws by bounds centre instead of first vertex Back-to-front order for blended, non-depth-writing, water and additive draws now uses the bounds centre of the vertices the draw indexes. The centre of shared (immutable) geometry is cached per index range and validated against the owning pointer; per-frame geometry is recomputed. Depth-writing opaque draws keep the first-vertex tie-break. Co-Authored-By: Claude Opus 5.5 --- src/eter_render/Gr2ModelRenderer.cpp | 54 +++++++++++++++++++++++----- src/eter_render/Gr2ModelRenderer.h | 13 +++++++ tests/hardware_scene_test.cpp | 22 ++++++++++++ 3 files changed, 80 insertions(+), 9 deletions(-) diff --git a/src/eter_render/Gr2ModelRenderer.cpp b/src/eter_render/Gr2ModelRenderer.cpp index 93726db1..5e4b6b4e 100644 --- a/src/eter_render/Gr2ModelRenderer.cpp +++ b/src/eter_render/Gr2ModelRenderer.cpp @@ -819,6 +819,38 @@ void Gr2SceneRenderer::RenderSceneGPU(SDL_Renderer* renderer, const std::vector< RenderSceneGPU(renderer, m_scratchDrawPtrs); } +void Gr2SceneRenderer::DrawSortCenter(const Render3DDraw& draw, float out[3]) { + const auto& mesh = draw.Mesh(); + const auto indices = draw.Indices(); + SortCenterKey key{draw.geometry.get(), draw.first_index, draw.index_count}; + if (draw.geometry) { + auto it = m_sortCenterCache.find(key); + if (it != m_sortCenterCache.end()) { + if (it->second.owner.lock() == draw.geometry) { + std::memcpy(out, it->second.c, sizeof(it->second.c)); + return; + } + m_sortCenterCache.erase(it); // freed geometry whose address was reused + } + } + const size_t vertexCount = mesh.positions.size() / 3; + float lo[3] = {INFINITY, INFINITY, INFINITY}, hi[3] = {-INFINITY, -INFINITY, -INFINITY}; + for (size_t i = 0; i < indices.size; ++i) { + const uint32_t v = indices.data[i]; + if (v >= vertexCount) continue; + const float* p = &mesh.positions[size_t(v) * 3]; + for (int a = 0; a < 3; ++a) { lo[a] = std::min(lo[a], p[a]); hi[a] = std::max(hi[a], p[a]); } + } + if (lo[0] > hi[0]) return; // no valid vertex: keep the caller's fallback + for (int a = 0; a < 3; ++a) out[a] = 0.5f * (lo[a] + hi[a]); + if (draw.geometry) { + if (m_sortCenterCache.size() >= 8192) m_sortCenterCache.clear(); + auto& entry = m_sortCenterCache[key]; + entry.owner = draw.geometry; + std::memcpy(entry.c, out, sizeof(entry.c)); + } +} + void Gr2SceneRenderer::RenderSceneGPU(SDL_Renderer* renderer, const std::vector& draws) { if (!renderer || draws.empty()) return; ++m_textureFrame; @@ -853,15 +885,6 @@ void Gr2SceneRenderer::RenderSceneGPU(SDL_Renderer* renderer, const std::vector< ord.texture=m_hardware->Texture(d.texture0,data->width,data->height,data->rgba.data());} if(!ord.texture)continue; } - { - float cx = sortedMesh.positions[0], cy = sortedMesh.positions[1], cz = sortedMesh.positions[2]; - float wx = cx * d.world[0] + cy * d.world[4] + cz * d.world[8] + d.world[12]; - float wy = cx * d.world[1] + cy * d.world[5] + cz * d.world[9] + d.world[13]; - float wz = cx * d.world[2] + cy * d.world[6] + cz * d.world[10] + d.world[14]; - float dx = wx - m_eye[0], dy = wy - m_eye[1], dz = wz - m_eye[2]; - ord.depth = dx * dx + dy * dy + dz * dz; - } - if (!d.z_enable) { ord.priority = 0; // Skybox } else if (d.terrain) { @@ -875,6 +898,19 @@ void Gr2SceneRenderer::RenderSceneGPU(SDL_Renderer* renderer, const std::vector< } else { ord.priority = 1; // Opaque } + { + // Order-dependent draws (blended, no depth write) sort by the bounds centre of the + // vertices they reference; for depth-writing opaque draws depth is only a tie-break. + float c[3] = {sortedMesh.positions[0], sortedMesh.positions[1], sortedMesh.positions[2]}; + if (ord.priority >= 4 || d.alpha_blend || !d.z_write) DrawSortCenter(d, c); + float cx = c[0], cy = c[1], cz = c[2]; + float wx = cx * d.world[0] + cy * d.world[4] + cz * d.world[8] + d.world[12]; + float wy = cx * d.world[1] + cy * d.world[5] + cz * d.world[9] + d.world[13]; + float wz = cx * d.world[2] + cy * d.world[6] + cz * d.world[10] + d.world[14]; + float dx = wx - m_eye[0], dy = wy - m_eye[1], dz = wz - m_eye[2]; + ord.depth = dx * dx + dy * dy + dz * dz; + } + m_scratchSortedDraws.push_back(ord); } diff --git a/src/eter_render/Gr2ModelRenderer.h b/src/eter_render/Gr2ModelRenderer.h index 8fd93150..204713d9 100644 --- a/src/eter_render/Gr2ModelRenderer.h +++ b/src/eter_render/Gr2ModelRenderer.h @@ -170,6 +170,19 @@ private: // Persistent scratch buffers to eliminate per-draw heap allocation churn in RenderSceneGPU std::vector m_scratchSortedDraws; + // Local bounds centre of a shared geometry's index range (immutable, so cached across frames). + struct SortCenterKey { + const Render3DDraw* geometry; std::uint32_t first, count; + bool operator==(const SortCenterKey& o) const { return geometry==o.geometry && first==o.first && count==o.count; } + }; + struct SortCenterHash { + size_t operator()(const SortCenterKey& k) const { + return std::hash{}(k.geometry) ^ (size_t(k.first) * 0x9E3779B97F4A7C15ull) ^ (size_t(k.count) << 1); + } + }; + struct SortCenter { std::weak_ptr owner; float c[3]; }; + std::unordered_map m_sortCenterCache; + void DrawSortCenter(const Render3DDraw& draw, float out[3]); std::vector m_scratchDrawPtrs; std::vector m_scratchGpuXverts; std::vector m_scratchSdlVertices; diff --git a/tests/hardware_scene_test.cpp b/tests/hardware_scene_test.cpp index c919545d..d5172f86 100644 --- a/tests/hardware_scene_test.cpp +++ b/tests/hardware_scene_test.cpp @@ -133,6 +133,28 @@ int main() { assert(raster.GetDecodedTextureBytes()==16); raster.Clear();raster.RenderScene(cpu,{shared});assert(raster.GetTextureDecodeCount()==decodes+2); SDL_DestroySurface(cpu);std::filesystem::remove(path); + // Blended draws sort back to front by the bounds centre of their indexed vertices: the far + // blue triangle's unindexed vertex 0 sits right before the eye and must not pull it in front. + ava2::Render3DDraw nearRed; + nearRed.positions={-.9f,-.9f,-.5f,.9f,-.9f,-.5f,0,.9f,-.5f}; + nearRed.indices={0,1,2};nearRed.diffuse={0xffff0000,0xffff0000,0xffff0000}; + nearRed.lighting=false;nearRed.fog=false;nearRed.cull_mode=1;nearRed.alpha_blend=true;nearRed.z_write=false; + ava2::Render3DDraw farBlue=nearRed; + farBlue.positions={0,0,-1.95f,-2,-2,1,2,-2,1,0,2,1}; + farBlue.indices={1,2,3};farBlue.diffuse=std::vector(4,0xff0000ff); + auto readOrder=[&](const std::vector& commands) { + SDL_SetRenderDrawColor(renderer,0,0,0,255);SDL_RenderClear(renderer); + raster.RenderSceneGPU(renderer,commands); + auto* surface=SDL_RenderReadPixels(renderer,nullptr);assert(surface); + Uint32 pixel;std::memcpy(&pixel,static_cast(surface->pixels)+32*surface->pitch+32*SDL_BYTESPERPIXEL(surface->format),SDL_BYTESPERPIXEL(surface->format)); + Uint8 r,g,b,a;SDL_GetRGBA(pixel,SDL_GetPixelFormatDetails(surface->format),nullptr,&r,&g,&b,&a); + SDL_DestroySurface(surface);SDL_RenderPresent(renderer); + return std::array{r,g,b}; + }; + auto order=readOrder({nearRed,farBlue});assert(order[0]>245&&order[2]<5); + order=readOrder({farBlue,nearRed});assert(order[0]>245&&order[2]<5); + auto sharedBlue=ava2::Render3DDraw::ShareGeometry(farBlue); + for(int frame=0;frame<2;++frame){order=readOrder({nearRed,sharedBlue});assert(order[0]>245&&order[2]<5);} } { ava2::HardwareScene resident(device);