Lighting Optimization

Challenge

Each scene (neighborhood) featured a high density of light sources, predominantly streetlights. These lights were rendering dynamic shadows in real-time, every frame. Most of the streetlights utilized point lights, which emit light omnidirectionally and require six shadow map passes per light, significantly impacting performance. In contrast, spotlights only require a single shadow pass, offering a more efficient alternative when appropriate.

Solution

Optimized Light Count: Capped the number of active light sources within each scene to ensure consistent performance.
Replace Point Lights with Spotlights: Swapped out point lights for spotlights where appropriate. This reduced the number of shadow passes needed, significantly boosting efficiency while preserving the intended look and feel.
Distance-Based Shadow Optimization: Implemented distance-based shadow quality adjustments (e.g., shadow cascades or level-of-detail techniques) to optimize rendering for distant shadows.
Shadow Update Scheduler: Developed a system to stagger shadow updates over multiple frames, reducing unnecessary per-frame calculations. Shadows are refreshed only when required, improving efficiency without noticeable visual drawbacks.
Efficient Light Management: Imposed a hard limit on the total number of dynamic lights and managed their activation based on proximity and visibility, further improving frame rates.

Result

These changes led to smoother performance, reduced rendering overhead, and an overall better visual experience, especially in scenes with complex lighting setups.

Material & Batching Optimization

Challenge

The project wasn’t fully leveraging Unity’s SRP Batching system, leading to unnecessary draw calls and reduced rendering efficiency. The root of the issue was a custom outline system that modified object materials directly at runtime by adding custom material properties. This process created new material instances for each object, preventing Unity from batching them together.

In Unity’s Scriptable Render Pipelines (URP and HDRP), SRP Batching is a powerful optimization that reduces draw calls by grouping objects that share the same material and shader pass. However, when a material is modified or duplicated at runtime, Unity treats it as a unique material, breaking the batching process and increasing the rendering workload.

Solution

To resolve the batching issues and improve performance, I implemented the following strategies:

Developed a material caching system that reuses existing materials whenever possible. Instead of creating a new material instance each time an object was highlighted or painted, the system checks if an identical material already exists and reuses it. This significantly reduced the number of unique material instances in the scene, enabling SRP Batching to function more effectively.
Reworked the highlight system to avoid modifying existing materials directly. Instead, I implemented a temporary material swap approach: when an object needs to be highlighted, it temporarily switches to a predefined highlight material and reverts back to the original material afterward. This method maintained batching compatibility while still delivering the desired visual feedback.

Result

These optimizations reduced draw calls and improved overall rendering efficiency. By maintaining material consistency across objects, the project was able to take full advantage of SRP Batching, resulting in smoother performance—especially in scenes with many dynamically highlighted or outlined objects.

Environment & Vegetation Optimization

Challenge

The project’s vegetation and environment setup was outdated and inefficient, leading to performance issues across the scenes. It relied on a combination of Nature Renderer, MicroSplat, and The Vegetation Engine (TVE). However, the systems weren’t properly integrated or optimized:

Trees were manually placed in each neighborhood and lacked instanced batching, causing excessive draw calls.
Grass was incorrectly painted as trees, adding unnecessary complexity to the rendering pipeline.
The environment assets, such as roads and buildings, were high-poly and fragmented into multiple separate meshes —for example, road sections were split into 1x1 chunks instead of being unified into a single mesh.
Overall, the environment was not leveraging Level of Detail (LOD) or impostor systems to reduce geometry complexity at distance.

Solution

To improve performance and streamline the environment pipeline, I implemented the following changes:

Upgraded the vegetation system from The Vegetation Engine to Visual Engine, alongside the latest Nature Renderer. This provided improved support for batching, LODs, and optimized shaders.
Repainted and configured vegetation, ensuring all trees were managed by Nature Renderer’s depth buffer batching system, dramatically improving draw call efficiency for large areas of foliage.
Integrated LODs and impostors for all vegetation assets. Trees and large plants transitioned through multiple LOD levels and, at far distances, were replaced with low-cost impostors, significantly reducing the poly count in each scene.
Migrated from The Vegetation Engine to Visual Engine, gaining finer control over grass shaders and feature usage. By selectively enabling only necessary shader features, I reduced overdraw and shader complexity, improving grass rendering performance without sacrificing visual quality.
Combined fragmented environment meshes into larger, optimized assets:
- Road meshes were merged into unified sections instead of 1x1 chunks.
- Buildings and houses were grouped and optimized to reduce poly counts and improve culling efficiency.
- Other static environment assets were consolidated where appropriate, minimizing draw calls and improving scene organization.

Result

These improvements led to a significant reduction in poly counts and draw calls, improved rendering efficiency, and smoother performance across all neighborhood scenes—while maintaining or enhancing visual fidelity.

Systems & Performance Optimization

Challenge

Throughout the project, several scripts were inefficiently handling updates and object management. Common issues included:

Excessive looping through all objects in the scene whenever a change occurred, leading to unnecessary processing and performance drops.
Inefficient object generation, where new objects were frequently instantiated without proper memory management or reuse strategies.
Mass placement systems that relied on costly raycasting operations, even for small changes, causing performance bottlenecks.
Connection systems that performed broad checks across every object in the scene to determine potential connections, resulting in slow and unoptimized behavior.

Solution

To address these issues and optimize both performance and system scalability, I implemented the following improvements:

Replaced frequent looping and polling with a centralized event system. Objects now listen for and respond to specific events, eliminating unnecessary checks across all objects and significantly reducing CPU overhead during updates.
Designed and integrated an object pooling system to manage frequently used objects. Instead of instantiating and destroying objects repeatedly, the system reuses inactive objects from a pool, reducing memory allocation, garbage collection, and instantiation costs.
Refactored the mass placement system to avoid per-object raycasts. Introduced an area selection system using planes and bounding volumes, allowing for efficient placement of multiple objects with minimal computational overhead.
Overhauled the connection-finding logic by introducing a relevance-based filtering system. Instead of evaluating every object in the scene for potential connections, the system limits checks to objects within a defined area and matching allowed types. This spatial filtering greatly improved connection processing times and overall responsiveness.

Result

These optimizations streamlined the project’s core systems, resulting in improved performance, reduced CPU and memory usage, and a more scalable architecture. The event-driven model and pooling system, in particular, had a significant impact on reducing unnecessary computation and memory overhead.

Addressables Management & Memory Optimization

Challenge

The initial version of the game utilized Unity’s Addressables system, but the group setup and overall management were not properly implemented. As a result:

Entire neighborhood scenes were loaded into memory at once, due to inefficient addressable packing and grouping.
Object previews in the in-game store caused the full object (mesh, textures, materials) to be loaded and held in memory, even after it was no longer visible or deleted from the scene.
Over time, memory usage continuously increased, leading to memory leaks and degraded performance.

Solution

To resolve these issues and improve memory management, I implemented a comprehensive overhaul of the Addressables workflow:

Developed a custom editor tool to automate Addressables grouping, organizing assets into logical groups based on their usage (e.g., by neighborhood, UI elements, store previews). This improved both the granularity and efficiency of asset loading and unloading, ensuring that only relevant content was kept in memory at any given time.
Replaced live object previews in the store with a static thumbnail system. A custom tool was created to pre-generate thumbnails for all previewable items directly within the editor. The game now loads lightweight images instead of the full 3D assets during preview, drastically reducing unnecessary memory consumption and load times.
Implemented a system to explicitly release memory when objects are removed from the scene. This provided better control over what remained in memory and prevented unused assets from lingering after deletion.

Result

These improvements resulted in significantly better memory management, preventing unnecessary memory bloat and enabling dynamic loading and unloading of neighborhoods and objects. The static thumbnail system alone greatly reduced runtime memory usage during store interactions, and the overall experience became smoother and more responsive.

Steam Integration & Multiplayer Stability Improvements

Challenge

The project relied heavily on PlayFab for user data management and multiplayer services. This created several issues:

Players were unable to play offline, as all user data was tied to PlayFab’s cloud services.
The Steam integration was outdated, limiting the use of Steam’s networking capabilities.
The multiplayer experience suffered from frequent desynchronization issues, negatively impacting player experience and coop gameplay stability.

Solution

To address these challenges and improve both offline support and multiplayer functionality, I implemented the following changes:

Migrated all user data storage and file management from PlayFab to Steam’s infrastructure, allowing players to access the game and their data offline. This improved user flexibility and reduced reliance on external cloud services.
Updated the project to utilize Steam’s latest NetCode and Steam Relay services. This enabled the creation of peer-to-peer coop lobbies, allowing players to connect directly through Steam without relying on external servers.
Additionally, file transfers between players were streamlined through Steam’s network, improving reliability and reducing latency. These upgrades significantly enhanced the stability of multiplayer sessions, eliminating many of the desync issues that previously plagued the game.

Result

The game now supports offline play, with seamless data management through Steam. Multiplayer lobbies are more stable and reliable, providing players with a smoother coop experience and greatly improved network performance.

Case study

Hometopia

Ultimate home design and building game, offering unmatched customization and stunning graphics

Unity
C#
Steam
HDRP

Steam Website Youtube

Hometopia

Start of development:: 2019
I am in the project:: 2023-25

Contribution to project

Perfomance x6
Realistic Light
Better memory managment
New Multiplayer experience
Exceptional furniture modification

Case impression

The hometopia team was amazing, everyone was really proactive and this played a great role in project transformation, cause everyone took a responsibility for what they were doing and did that exceptionally

A bumpy Early Access release

I joined just a month before realease to Early Access, the project wasn't prepared, performance was dreadfull, as result:

Up To x8 faster Ligth performanceDue to changing Point Light to Spot Light primarily in streetlightsRead more

Reduction of GPU load in high density scenesDue to proper usage of SRP Batching Read more

Rejuvenate Vegetation and TerrainDue to updating outdated plugins and changing their workflowRead more

No more lags when players paint wallsOptimized lots of irrational algorithms in core mechanicsRead more

Performance is better, but we eat lot of RAM

After the long performance improvement, we are facing the ever increasing Memory usage, solution?

Improving memory control with AddressablesDue to changing how addressables used and releasedRead more

So we better now, but what about multiplayer

Multiplayer from first day in Early Access, has really serious lags and desync issues

Better Co-Op experienceDue to changing whole multiplayer structure Read more

before

after

Release and Latest

Стара версія

Нова версія

before

after

Release and Latest

Стара версія

Нова версія

before

after

Release and Latest

Стара версія

Нова версія

before

after

Release and Latest

Стара версія

Нова версія

All projectsLet’s talk