So you asked, here a little debunk about Threat Interactive. I will not lose anymore my time on this, I don't want to start a drama or a war, so if there is an answer, i will not responde. I'm not interested in, i just want people to stop... use those video as a proof when this is not, cause this is really annoying for usshow more

Just precision cause i make some abstraction : i said thing like "nanite doesn't have drawcall". That not true. Drawcall isn't an issue anymore with nanite, but still have drawcall, it's just an abstraction.

I think also at a moment i speak about GPU when this is CPU.

There is also probably some other approximation, if you have any question, or want to go deeper, please do. There is also better, and more compentent dev who are preparing some blog article to explain this in depht, more that what i've covered.

Oh no, i guess he doesn't like to be proved wrong, funny for someone who "expose" others.

📢 My Favorite Video Yet! 📢 "Their efforts were as futile as their understanding was limited." ✝️ Want to know the truth they couldn’t erase? ⬇️ 🙏 Please subscribe if this resonates with you. Let’s spread the word. Christ is KING! ✝️

@ThreatInteract Great job digging into all of this. Those videos have really bothered me with how incorrect it all is.

@ThreatInteract Such a pleasure from you, loved your game.

Oh boy this is gonna be long. Just watched a disappointing video by @Aherys_ attempting to "debunk" @ThreatInteract 's UE5 analysis. As a technical developer, I'm concerned by the lack of depth and dismissive tone towards legitimate optimization concerns. I had to sit though his poor presentation with zero technical details and half broken English for 20 minutes. May god have mercy on me. - The core issue isn't whether Nanite/Lumen work - they're impressive technologies. It's about understanding their trade-offs and using the right tool for each scenario. Optimization isn't binary - it's about making informed choices. - Let's talk technical facts: Dynamic computation ALWAYS scales with complexity. This is fundamental CS - more variables = more computation (Read about David Wolpert and William Macready no free lunch theorem) - This is why we often prefer static dispatch over virtual calls - Use compile-time optimizations over runtime - Use compile-time code generation - Prebake data when possible - The scene optimization TI demonstrated wasn't "wrong" - it was a textbook example of reducing computational complexity through attenuation radius adjustment and geometry merging. These principles remain valid regardless of rendering technology. - Lumen's probe-based GI system has specific scaling characteristics. While it handles clustered lights efficiently, distributed small lights can increase probe density requirements and memory bandwidth usage. - Nanite's virtualized geometry is brilliant for complex meshes but comes with streaming/memory overhead. For simple geometry, traditional LOD can be more efficient. - The reality is: prebaked lighting isn't "bad", dynamic lighting isn't always "good". Static solutions will always offer better performance when scene constraints are known. That's not opinion - it's computer science. - What's concerning is seeing a "game developer" dismiss these nuances with empirical observations rather than technical analysis. Our industry needs more rigorous technical discourse, not dismissive handwaving. - Instead of mocking optimization techniques, let's have real discussions about trade-offs and use cases. UE5's features are powerful tools, but like any tool, knowing when and how to use them is crucial. That was TI's point, and it remains valid. - Let's dive deeper into Nanite vs traditional LOD systems, since this seems to be a point of confusion. The trade-offs are more nuanced than "Nanite good, LOD bad" - Traditional LOD with 3-5 levels has predictable memory patterns and fixed footprint. This means better cache coherency and less storage thrashing. Your entire mesh set stays resident - crucial for performance-critical scenes. - Developer knowledge is KEY here. You know your game's requirements. A background mountain range doesn't need the same detail as player-accessible areas. With traditional LOD, you can optimize specifically for these cases. - Consider memory hierarchy: L1/L2 cache -> RAM -> Storage. Traditional LOD keeps everything in RAM with predictable access patterns. Nanite requires constant reads, which are orders of magnitude slower. 1. Each mesh can have different LOD levels across its surface based on pixel coverage: - Close parts might be high detail - Far parts might be low detail - This varies continuously across the surface - Changes dynamically as camera moves 2. This creates a massive memory pressure because: - Each visible mesh potentially needs multiple LOD clusters loaded simultaneously - Moving the camera even slightly can change which parts need what detail - Cache coherency becomes extremely difficult to maintain - Constant cluster swapping as pixel coverage changes 3. Compare to traditional LOD: - Entire mesh uses same LOD level - Predictable memory access patterns - Single LOD state per mesh - The cluster-based hierarchy in Nanite is impressive, but comes with overhead. For simple geometry (walls, floors, basic props), this preprocessing and streaming overhead can exceed the benefits of virtualization. - Memory fragmentation is another factor. With fixed LOD levels, memory layout is stable. Nanite's dynamic streaming can lead to fragmentation - Think about development workflow: Traditional LOD lets you manually optimize crucial areas. You can reduce polygon count where it won't impact visual quality, something Nanite can't determine automatically. - This extends to platform-specific optimization. With traditional LOD, you can create specific levels for different hardware capabilities. Nanite's one-size-fits-all approach might not be optimal across all platforms. - The "perfect" solution would be to combines both: Use Nanite for complex, detailed assets where its strengths shine, and traditional LOD for simple geometry where overhead isn't justified. - This is why TI's analysis was spot-on. It's not about dismissing new technology, but understanding when and where to apply it. Optimization is about making informed choices based on specific requirements. - Game development isn't about using the latest tech everywhere - it's about building efficient, scalable systems that work for YOUR game's needs. Anyone suggesting otherwise is missing fundamental engineering principles. - Let's break down Lumen vs traditional lighting approaches. - Traditional dynamic lighting scales linearly - O(n) with light count. Each light = separate shadow maps, draw calls, and memory allocation. While "simple", it's predictable. - Lumen's unified lighting solution is clever - using probe-based GI with shared data structures. But probe systems have inherent limitations: resolution-dependent sampling, interpolation artifacts, and temporal stability issues. - Small, precise lights are particularly challenging for Lumen. The probe grid needs higher density to capture detail, increasing memory bandwidth and computation. Miss a detail between probes? Visual artifacts. - Think about temporal coherence: Moving small lights create noise patterns requiring more samples for clean results. Traditional dynamic lights don't suffer from this - their boundaries are exact and stable. - Performance scaling isn't simple. While Lumen handles clustered lights efficiently, distributed small lights can saturate probe grids. Each active grid area = overhead. More separate lighting regions = higher cost. - Memory bandwidth becomes crucial. Probe systems require constant sampling and interpolation. Traditional lighting's more straightforward approach often results in better cache utilization for localized effects. - This is why hybrid approaches should be considered. - Static/prebaked lighting isn't obsolete. When you know scene constraints at dev time, prebaked solutions will ALWAYS be more efficient. - The dismissal of these nuances by @Aherys is concerning. Real game development requires understanding these trade-offs. Different projects have different needs - no single solution fits all. - @ThreatInteract 's analysis highlighted these exact points. It's about using the right tool for the job. Lumen is powerful but has trade-offs.

@ThreatInteract It’s always a treat watching clickbaiters and attention seekers getting crushed by the experts. Thanks for the detailed video.

@ThreatInteract My pleasure !

@ThreatInteract I think you already gave this too much of your precious time. But it's a good and clear explanation, thanks :)

@ThreatInteract 🥰