Overview

Sunday was a “polish” day. I spent time actually playing the game and realized the Frost Effect didn’t feel quite right. It was either too subtle or kicked in too early. I refactored the entire intensity logic to make it feel more natural and responsive to the player’s performance.

1. Refactoring Intensity

The original code had a “Minimum Intensity” logic, meaning there was always a little bit of frost on the screen. The Problem: It degraded the visual clarity of the Mixed Reality pass-through. If you’re doing well (0 enemies), your vision should be crystal clear.

The Fix:

Removed Minimum Intensity: If the enemy count is 0, the frost is 0. Adjusted Max Values: I tuned the upper limit so that at “Critical Mass” (15 enemies), the frost is overwhelming but doesn’t completely blind you (capped at 1.7 scale). Simplified Math: I cleaned up the calculation logic. Instead of complex curves, it’s now a cleaner linear mapping that feels more predictable.

3. Unity

screenshot of frost tuning

Overview

Saturday was about defining the look and feel of the game. I decided to steer the art direction towards a “Medium Low Poly” style. It’s not super blocky (like Minecraft), but it keeps things geometric and readable, which is perfect for VR performance and readability.

1. The Frost Effect (Upgrade)

I wasn’t 100% happy with just slapping a texture on a quad. I updated the frost shader to use a different approach with a new Low-Poly Icy Material. It creates a crystallized look that creeps into your vision (animated movements), matching the new sharp, geometric art style of the world.

2. The New Thermal Lance

The original placeholder weapon had to go. I modeled a proper Thermal Lance (actually more like a welding gun at this point) in Blender, keeping with the medium low-poly aesthetic. Custom Materials: I wathced a tutorial on how to properly import materials from Blender to Unity. Integration: I hooked up all the existing logic (Heat, Shooting, Welding) to this new model.

3. Result

The game is starting to look cohesive. the wall debris, icy visor and now the weapon all share this “Medium Low Poly” language. The next model that has to be updated is the enemy (for the 4th time by now).

4. Unity

screenshot of new lance and frost

5. Resources

https://www.youtube.com/watch?v=yloupOUjMOA –> materials from blender to unity https://www.youtube.com/watch?v=mCpRxFP2J1c –> icy low poly visor

Overview

Thursday was about feedback—telling the player visually when things are going wrong. I added an Alarm System for when enemies breach, and a Frost Effect that freezes your visor as the situation gets worse.

1. The Frost Effect: Use the “Right” Way? No.

I wanted a vignette of ice to creep in from the corners of your vision. Naturally, I tried to do this the “official” Unity/Meta way. I spent an entire day wrestling with the URP Post-Processing Stack and Scriptable Renderer Features.

The Challenge: In Mixed Reality, getting a transparent shader to properly overlay on top of the Passthrough Layer (the real-world video feed) appereantly wasn’t as easy as i thought. I watched tutorials and tried to set up a Full Screen Blit pass. Nothing worked. It was either invisible, or just didnt want to setup properly in Unity.

The “Dumb” Solution: After wasting hours, I deleted the entire Rendering logic and did something stupidly simple: I created a primitive Quad (a flat 3D plane), put the frost material on it, and parented it directly to the CenterEyeAnchor of the OVRCameraRig.

It literally just floats a few centimeters in front of your face. Result: It looks (almost) exactly the same as a fancy Post-Processing effect.

2. Alarm System

I also implemented a global visual alarm. When a wall breaks, the whole HUD flashes red and displays “BREACH DETECTED”. This uses a CanvasGroup to pulse the alpha of the warning text, ensuring you don’t miss the fact that a monster is walking into your living room. I did this kind of the same way, by making the canvas float infront of the player’s eyes.

3. Unity

screenshot of frost effect

4. Resources

https://www.youtube.com/watch?v=mCpRxFP2J1c https://www.youtube.com/watch?v=mNpC6nB4uFM

Overview

Wednesday was a bit of a mixed bag. I tried to improve the occlusion system to make enemies hide better behind real-world objects, i also tried to make the enemies not spawn under objects such as beds and couches, but it didn’t go as planned. However, I did manage to fix a really annoying visual glitch with the thermal lance effects.

1. Struggles

After adding the basic occlusion yesterday, I wanted to make it “smarter.” I tried to tweak the shader to handle edge cases where the enemy would clip through the wall slightly. the enemies seemed to be ‘stuck’ in the floor, also the enemy can come through a broken piece of wall underneath an object, this all has to do with the occlusion i added yesterday. It seems like it changed some things in the logic, but it needs to be there, otherwise you can see enemies through walls and object. I spent about 3 hours tweaking depth tests trying to fix the segmenting of the walls (who are also under objects)

The Result: Failed. Every change I made either made the wall invisible or made the enemy invisible at the wrong time.

2. Fixing Z-Fighting

The one win of the day was fixing the “Lance Impact” effect. When you shoot the wall, a glowing “heat scorch” decal appears. Because this decal was spawned exactly ON the wall surface (Distance = 0), the graphics card got confused about which pixels should be on top (The Wall or The Decal). This caused a flickering effect known as Z-Fighting. This issue also has to do with the new occlusion logic, but with this its mostly fixed.

The Fix: I added a tiny offset to the spawn logic. Now, when the raycast hits the wall, the decal is spawned 2cm (0.02f) away from the surface, along the normal. Vector3 spawnPos = hit.point + (hit.normal * 0.02f);

3. Result

Visuals: The flickering is completely gone. The heat marks look solid and stable, even when you move your head around. The occlusion is back to the “Basic but Functional” version from Tuesday.

4. Unity

4. Unity

screenshot of lance impact

Overview

Tuesday was all about making the “Invasion” feel real. Up until now, enemies just spawned in the room (or in the void). I wanted them to actually feel like they were coming from the cold outside into your warm room. This required a complete rewrite of the spawning logic and some shader magic.

1. The Breach Mechanic

I moved the enemy spawning logic into the DestructibleGlobalMeshManager. Now, the destruction of a wall and the spawning of an enemy are linked events.

The Logic:

A wall segment breaks (opening a hole). The code calculates a vector from the Player to the Wall. It extends this vector 4 meters outward (behind the real wall). It spawns the enemy there and tells it to walk through the new hole. The Result: the wall breaks, and you see an enemy coming at you from the snowy void outside. It’s much simpler but way more immersive than just fading them in.

2. Refactoring Spawning

Previously, I had a separate EnemySpawner script that just picked random spots. It was messy and didn’t know about the walls. By moving this into the DestructibleManager, I can control exactly when and where enemies appear. No more enemies spawning inside furniture or floating in the ceiling. They always come from a breach.

3. URP Occlusion Shader

To make this work visually, I needed a way to hide the enemies while they were still “behind” the unbroken walls. In Mixed Reality, the “real” wall isn’t a digital object, so it doesn’t automatically block virtual objects.

The Solution: I added created a URP Occlusion Shader. This is a special material that checks the “Depth Buffer” but renders nothing (invisible). I applied this to the invisible room mesh.

Result: It acts like a “Collision Mask” for light. The real-world wall now correctly “hides” the virtual enemy standing behind it. The enemy only becomes visible when it steps through the hole (where the occlusion mesh is removed). Same with object such as tables, couches and everything else that is scanned before playing.

4. Unity

screenshot of enemy breaching

Overview

Sunday was a big day for mechanics. I finally implemented a proper heat/cooldown system for the lance so you can’t just spam it forever. I also refactored the entire welding logic because the old one was a mess, and fixed a 4-day long bug where I couldn’t see the UI.

1. The Heat Mechanic

The Thermal Lance is a powerful weapon, but it needed a downside. I added a heat system that builds up as you fire.

Heating Up: Firing adds heat over time (takes 5 seconds to max out). Overheat: If you hit 100% heat, the weapon jams. You have to wait for it to fully cool down (0%) before you can shoot again. Visuals: I added a new Cooldown UI on the HUD. The bar goes from Yellow to Red as it gets hotter.

2. Refactoring Welding

The old welding code was barely working. It had trouble identifying which wall you were trying to fix. I rewrote the target identification logic ( GetHitboxFromObject ) so it’s super reliable now.

The Fix: I also decoupled the UI from the wall objects. Now the code reliably tracks exactly how long you’ve been welding a specific hole and updates the UI accordingly, the UI now floats in front of the players eyes.

Visuals: I also changed how the target to ‘weld’ the hole looks, it now displays a welding icon so the player knows why to hit the orange icon.

3. Result

Current State:

You have to manage your heat while shooting enemies. If a wall breaks, you can reliably repair it with the new progress bar. The UI actually shows up now.

4. Unity

screenshot of cooldown ui

Overview

Tuesday and Wednesday were focused on making the environment interactive. I moved from having static walls to a system where the walls can actually break, and you have to repair the damage. Later on i want to make the enemies come in the room through these holes.

1. Breaking the Walls

The game uses the Room Scan data (from the initial Mixed Reality setup) to understand where your real-world walls are. There’s a script that takes this mesh and segments it. the segmented parts get destroyed so that a hole appears in your wall.

The Effect: The wall disappears, creating a hole. The North Pole: Behind the walls, we placed a 360-degree Skybox of a snowy landscape. So when a wall breaks, it looks like your room is actually sitting in the middle of the North Pole.

2. The Repair Mechanic

Once a wall is broken, we needed a way to bring it back. I initially tried to make it so you could just shoot the broken wall pieces to fix them, but the collision detection was unreliable.

The Solution: We added a dedicated Repair Hitbox.

When a wall breaks, a specific object (a cube) spawns in the center of the hole. To repair the wall, you aim your Thermal Lance at this object and hold the trigger for 2 seconds. This object handles the collision and the progress bar. When the bar fills up, the object destroys itself, and the original wall mesh is turned back on.

Problem: Currently only the cube is visible, the progressbar is not, it might be clipped in the cube or behind the wall, i have no clue currently.

3. Result

This creates a simple loop:

A timer (every 4 seconds) makes a segment on the wall dissapear. A Repair Object appears in the hole. Player shoots the object for 2 seconds to fix the wall. It makes the room feel like part of the game rather than just a background.

4. Unity

5. Resources

https://www.youtube.com/watch?v=FepNBOXLo9Y

Overview

A game isn’t a game if you can’t lose. Up until now, we had the melting of enemies and enemies that spawned, but no real “Game Loop.” Sunday and Monday were dedicated to wrapping the core mechanics in a proper structure: Start Screens, Game Over states, and the logic to switch between them. Another small chenge i made was making the enemy blob vertex points move to make it feel more alive. This went quite quick without too many issues.

1. The Goal

In Mixed Reality, you can’t just slap a 2D menu on the screen like in a PC game. It feels unnatural and breaks the illusion of the enemies being in your room. We needed:

Floating Menus: UI that exists in 3D space, floating comfortably in front of the player. Input Switching: You need a laser pointer to click buttons, but a Thermal Lance to fight enemies. You can’t have both active at once without it feeling clunky.

2. The Tech: World Space Canvases

Unity’s UI system is powerful, but for VR/MR, we use World Space render mode. This detaches the UI from the “screen” and turns it into a physical object in the world. We built a central brain to handle the state of the game. It manages the transition between two distinct modes:

Menu Mode: Visuals: Shows the Start or Game Over floating panels. Input: Activates the XR Ray Interactor (your standard VR/MR laser pointer). Gameplay: Pauses enemy spawning and hides the weapon.

Combat Mode: Visuals: Hides all menus. Input: Deactivates the Ray Interactor and enables the Thermal Lance. Gameplay: Begins the enemy waves and enables wall destruction.

3. The “Too Many Enemies” Fail State

Currently it’s a pressure-based lose condition. Instead of a health bar, you lose if you let the infestation get out of control.

The Limit: If 15 enemies are alive at once, the containment is breached. The Result: The game immediately stops, the weapon deactivates, and the “Game Over” UI floats in front of you, offering a Restart and Quit button.

Note: This will later be optimised, for now this is enough to have the game working.

4. Result

We now have a full, playable loop. You put on the headset, see a floating “Start” button, click it, and your controller transforms into a Thermal Lance. You fight to keep the population down, and if you get overwhelmed, the system shuts down and resets. The enemies look more alive

5. Unity

6. Resources

https://www.youtube.com/watch?v=iVfa_azjnNI https://www.youtube.com/watch?v=2KSLO9JnxHA

Overview

I spent a few days stuck on a really annoying issue. I was trying to get the enemies (blobs) to spawn from the walls using the room scan data. The code looked fine, the logic was there, but nothing was showing up in the game.

What I Tried

I checked pretty much everything I could think of:

I checked if the prefabs were null. I checked if they were spawning inside the walls or at the wrong coordinates. I messed with the materials and shaders to make sure they weren’t just transparent. I checked the camera layers. I even made them huge just in case they were too small to see. The strange part was that the i didnt get any warnings or errors, even when focusing on different parts of the game nothing changed. that’s when i knew it wasn’t a mistake in the code, but something general. which made it harder to solve, no one on the internet could help me and ai also didn’t give a clear explenation, ai was just guessing stuff that i know didn’t have anything to do with my issue

The Fix

I decided to go over ALL of my settings to see if there was something strange, it turned out to be something really simple. I was just in the wrong scene. This must have happened when my Unity crashed and opened a recovered scene instead of the one i was actually loading in my meta quest.

I was editing the scripts and prefabs in the SampleScene, but whenever I hit Play in Unity, it was loading a recoveredScene I had open. So the code was technically running, but it was spawning objects in a completely different scene than the one I was looking at.

Lesson Learned

Always check which scene is actually active. I assumed I was testing my changes, but I was looking at an empty scene the whole time.

Overview

For the past few days, our enemies have been simple blue balls. They moved and they died, but they didn’t look like the “frozen icy sludge” creatures I imagined. Yesterday, we finally tackled the visuals, using Unity Shader Graph to bring the ice blobs to life.

1. The Goal

The concept for the enemies is that they should look like an icy virus. They shouldn’t look like solid blocks of ice (too clean) or just water (too fluid). Right now it tends to look more like a solid ice ball though, this is because i’m new to creating my own shaders, so hopefully by the end of the project i will be able to make the inside of the ice ball more ‘liquid looking’.

2. The Tech: Unity Shader Graph

To achieve this look without expensive textures, I built a custom shader (and used a free ice texture from the unity asset store to give it an extra touch). Here are the key components:

Fresnel Effect This is used for anything “icy” or “ghostly”. The Fresnel node highlights the edges of the object where the surface normal is perpendicular to the camera. This gives the blobs a glowing, frozen rim light that separates them from the real-world background.

Transparency & Refraction The material is set to Transparent. This allows you to see slightly “into” the blob, giving it volume. We also added a slight distortion (refraction) to the background behind it, making it feel like a dense, refractive material.

3. Result

The blue balls are gone. It now looks more like an icy ball. There are still some improvements to be made, but for now it’ll do.

4. Unity

5. References

https://www.youtube.com/watch?v=Gym5JWHgjkk&t=3s I watched this video about how to use the nodes to create a icy shader