Building Bleakwood Village: A Linux-Native Unity HDRP Breakdown

08 Oct, 2026

I recently completed an intensive production cycle building "Bleakwood Village"— an atmospheric, game-ready environment heavily inspired by the dark, twisted, organic art direction of Bloodborne and Dark Souls 3. Here is a look at the environment in motion:

Here is the technical breakdown of how I took this scene from a primitive blockout to a fully interactive, playable desktop build natively on Linux (Fedora KDE Wayland/X11).

🏛️ Phase 1: Starting Blockout and Overcoming Engine Mismatches

I initiated the project structure in Unity's High Definition Render Pipeline (HDRP). One of the first technical challenges involved porting assets into a clean pipeline. For instance, when bringing in placeholder character rigs, I encountered a major SRP batching breakdown:

A BatchDrawCommand is using a pass from the shader "Universal Render Pipeline/Lit" that is not SRP Batcher compatible.

Because HDRP cannot natively batch URP materials, I re-authored the placeholder material setups to standard HDRP/Lit workflows. This immediately restored compatibility with the GPU Resident Drawer and established a zero-error baseline before building any custom kits. I then proceeded to blockout several aspects of the scene, including the huts and trees that were to be placed across the scene. This process is meant to be experimental and nothing is final.

🪵 Phase 2: High-Performance Modular Wood Kits

To capture the rickety, sagging, and water-damaged architecture of the settlement's outskirts, I designed custom, non-uniform dilapidated wooden kits and stone foundations in Blender. Individual pieces were combined into cohesive structural "chunks" before engine import to minimize CPU hierarchy tracking and keep draw calls heavily optimized via the SRP Batcher.

Instead of importing hundreds of individual loose planks into Unity—which introduces massive CPU transform hierarchy bloat and slows down lighting bakes—I utilized a Combined Chunk Architecture:

1. The Construction Collection: Built individual modular planks, posts, and framing beams as a baseline source deck.
2. The Structural Join: Assembled the chaotic, overlapping walls directly in Blender and joined them (Ctrl + J) into singular mesh units (e.g., SM_Hut_FrontWall).
3. The Pivot Reset: Unified all origins to a single master pivot, allowing the entire house to snap together flawlessly at engine coordinates 0,0,0. Loose individual plank prefabs were kept strictly as a minor scatter kit to decorate the floors and add micro-imperfections, balancing AAA visual density with clean draw-call performance.

I then authored custom tileable landscape textures, waterlogged wood grains, and damp stone surfaces inside InstaMAT. Maintained strict, consistent texel densities across all assets to prevent resolution stretching close to the camera lens.

🌲 Phase 3: Foliage Optimization & Asset Sourcing

For a dark fantasy horror theme, I committed 100% to dead, gnarled, and rotting flora. I customized my terrain layers and mud properties inside InstaMAT, dialing up the water sliders and adding footprints to create a damp, stagnant forest trail. To keep performance perfectly fluid, I instituted a strict foliage budget:

• Dead Canopy Trees: 18k triangles at LOD0.
• Leaved Variation Trees: 35k triangles at LOD0.
• LOD Stepping: Configured a strict -50% triangle reduction rule per LOD tier, ensuring the vertex pipeline aggressively scaled down as elements receded into the background.

💡 Phase 4: Volumetric Atmosphere & Color Splitting

The mood of Bleakwood Village relies entirely on Complementary Color Temperature Splitting. Many portfolios fall into the trap of using uniform color overlays; I designed the lighting across distinct temperature bands:

• The Backdrop: Set the global ambient sky and directional moonlight to a crisp, desaturated cool cyan tint (7500K - 9000K).
• The Focal Contrast: Placed a dim, warm amber point light source (2000K) inside the lodge interior, allowing the light to spill out dramatically through the broken wall slats.
• The Fog Intervention: Placed an HDRP Volumetric Fog volume directly between the two zones.

When the warm-hued directional light hits the fog from behind, it carves sharp, layered silhouettes. When the warm internal lamp strikes the fog from the front, it creates a localized, glowing haze that naturally draws the viewer's eye down the path.

⚙️ Phase 5: Building the Interactive C# Flow Manager

To deliver a truly immersive portfolio experience, I didn't want a passive video loop. I wrote a modular C# Scene Manager utilizing Unity's New Input System to build a fluid interactive state pipeline.

When the project boots, the player and gameplay tracking rigs are completely turned off (SetActive(false)), allowing an endless cinematic Cinemachine timeline flyby to play with zero background CPU rendering costs.

• Pressing E or Enter: Stops the timeline execution loop, hides the corner UI text prompt, and wakes up the gameplay controller. Cinemachine automatically calculates the lens offset and smoothly interpolates the view down to the player.
• Pressing Q: Seamlessly puts the character back to sleep, turns the tracking timeline back on, and morphs the UI prompt text back to explore instructions.
• Pressing P: Triggers a custom diagnostic high-resolution capture utility, forcing 10 cameras to render a single-frame 4K PNG snapshot directly to the native OS pictures directory before immediately dropping back out of the render loop to preserve frames.

🏆 Final Conclusion

Building an advanced environment piece natively on Linux requires navigating real pipeline hurdles. By enforcing clean texel densities, strict material sharing, and optimized script barriers, Bleakwood Village serves as a complete demonstration of my readiness to jump straight into a studio production line.

The playable standalone build is live on my Itch.io page, and the cinematic sequence is live on YouTube.

Thanks for reading!