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);