The Complete Unity C# Game Developer Bootcamp Part 1 of 2

Grab the latest Unity 2019.1 or newer with Unity Hub, create a Personal edition setup, install and manage versions, enable web, Windows, and Android builds, and prep your first project.

Sign in to Unity Hub with a Unity ID to access the ecosystem, then create a Space Shooter Pro project using the latest Unity version with 3D and 2.5D settings.

Explore the Unity editor basics by navigating the scene view, game view, hierarchy, inspector, and project panels to place objects, manage assets like cameras and lights, and test your game.

Navigate the Unity scene view with left-click selection, hierarchy highlighting, right-click pan and zoom, FX mode for free movement, speed adjustment, and focus with the F key.

Learn to manipulate game objects in Unity using translate and rotate tools, adjust position, rotation, and scale via the transform, and explore stretch, rect, and move/rotate/scale tools.

Learn to create and manipulate 3D game objects in Unity, adjust the main camera transform, and apply colored materials via the albedo channel of the standard shader.

Arrange Unity panels to view scene and game in real time, customize the layout, and save a professional layout to streamline workflow with hierarchy, inspector, and project views.

Create a Unity scene, build a blue player cube with a material, set the camera background to solid black, and raise directional light intensity for the 2D game prototype.

Set the aspect ratio to 16:9 to maintain a consistent hd presentation as you stretch the environment, enabling easier porting to consoles, vr, and mobile.

Define the starting position of the player by creating a C# script, attaching it to the player, and setting transform.position to zero using a vector three.

Move the player along the x and y plane using transform.translate in Unity, while learning to read the scripting API and use vector3 directions like right to adjust position.

Multiply Vector3.right by Time.deltaTime to convert frame-based movement into real-time motion, achieving one meter per second.

Explore variables in c# for unity, covering public and private access, data types (ints, floats, bools, strings), naming, and using the serialize field attribute to expose values in the inspector.

Learn to map horizontal input in Unity with the input manager, moving via A/D or arrows by retrieving the horizontal axis value and applying it with transform.translate.

Capture vertical and horizontal inputs from the input manager and move in Unity with transform.Translate using a direction vector and time.deltatime.

Learn to constrain the player with bounds in Unity, implementing wrap on the x axis and vertical clamps on the y axis using if statements and transform.position.

Review the player wrapping challenge, converting the pseudocode into Unity C# code that teleports the player when x exceeds 11.3 or is less than -11.3, preserving the y coordinate.

Refactor the player class by moving movement logic into a dedicated calculate movement method, call it from update, and clamp the y position with Mathf.Clamp between -3.8 and 0.

Create a laser projectile in unity, convert it into a prefab for runtime instantiation, and apply a blue laser material with optional rigid body physics for firing on space press.

Spawn lasers by pressing the space key using instantiate to clone a laser prefab at the player's position with quaternion identity rotation, after handling input in update.

Create the laser behavior in Unity by writing a laser script that moves the laser north at a constant speed of eight meters per second, applied to the laser prefab.

Move the laser upward with transform.Translate and Vector3.up, scaled by time.deltaTime, using a private float speed set to 8.0f for eight meters per second, inspector-adjustable in the space shooter prototype.

Practice to clean up projectiles by destroying lasers when their y-position reaches eight, preventing endless objects from cluttering the scene; implement per-frame movement and off-screen destruction in the laser script.

Learn how to destroy lasers in Unity using a simple if statement on transform.position.y greater than eight, calling the destroy method on the game object.

Adjust the laser spawn offset from the player's center to prevent clipping, implementing a 0.8 unit y-offset and updating the instantiate method to use the object's position plus offset.

Apply a 0.8 unit vertical offset to lasers spawned at the player's position, ensuring each laser appears 0.8 units above the player when the space key is pressed.

Implement a cooldown system to limit firing of lasers by time.time, using a nextFire and campfire check with a configurable fire rate of 0.5 seconds.

Clean up the laser code and comments, and remove the unused start method. Introduce a dedicated fire laser method and handle input in update to fire on space key.

Create an enemy that mirrors the player by duplicating the player into a red, scaled cube, applying an enemy material, and turning it into a prefab for future spawn management.

Implement enemy behavior in Unity C# by moving enemies down at four meters per second and respawning them at the top for reuse, with optional random x positioning.

Move the enemy down at four meters per second with a configurable speed. When it passes the bottom, respawn at the top and randomize its x position using random range.

Explain hard surface vs trigger collisions in unity, using colliders and rigidbodies with isTrigger to detect hits and destroy lasers and enemies while damaging the player.

Learn to implement collision-based destruction in Unity by destroying enemies on player contact, and destroying lasers on laser contact, using tag checks in the enemy script.

Clean up Unity scripts and set up a spawn manager to spawn enemies for gameplay. Refine player damage and collision logic, add serialized fields, and ensure destruction on life loss.

Create a spawn manager to continuously spawn enemies as the game runs, using timed or randomized intervals in Unity. Attach a Spawn Manager script to an empty holder object.

Spawn enemy prefabs every five seconds in Unity by using a coroutine of type enumerator with yield to wait for seconds.

Learn to build a spawn routine with Unity coroutines and StartCoroutine. Instantiate an enemy prefab at a random x between -8 and 8, then wait five seconds.

organize spawned enemies by instantiating them under an enemy container in the spawn manager, using a stored GameObject reference to set the parent transform.

Learn to stop spawning when the player dies by linking the player to the spawn manager, using a stop spawning flag and GetComponent communication.

Import the custom assets pack, including audio and sprites, into the Unity project, preview the explosions and animations, and convert the 3D prototype to 2D for UI and power-ups.

transition from prototyping to production in Unity by converting the 3D player into a sprite, adding a nebula background, and using 2D mode with sorting layers for proper rendering.

Convert the 3d player to a 2d sprite by attaching the player script, wire laser prefab, tag as player, and adjust sorting layer; convert lasers and cubes to 2d colliders.

Convert the enemy from 3D to 2D by removing mesh components, adding a sprite renderer, using a 2D collider and 2D rigidbody with gravity zero, and set foreground sorting layer.

Rebuild the laser in 2D, drag in a new sprite, add collider and rigidbody, set is trigger, tag the laser, and prefab it for a polished 2D production.

Create and set up a triple shot power-up by assembling three laser prefabs, parenting them into a single triple shot object, and prefab it for efficient instantiation in Unity.

Develop triple shot behavior by using a boolean flag to track when the triple shot is active, switching to three lasers for five seconds after collecting a power-up.

Demonstrates implementing triple shot behavior with a private boolean isTripleShotActive, firing three lasers when active and one when not, by instantiating a triple shot prefab and testing via the inspector.

Create a triple shot power up with a 2D collider and rigid body, move it down at speed three, and destroy on player collection via on trigger 2D.

Review explains implementing the triple shot power-up as a scrolling collectible: translate down with a speed variable, detect offscreen destruction, and handle player collision to collect and destroy the power-up.

Implement a triple shot power-up in Unity by enabling a public tripleShotActive method and using a coroutine to disable after five seconds via script communication.

Set up a triple shot power-up by communicating between the power-up and player scripts, enabling triple shot, and starting a five-second power-down coroutine that disables it.

Implement parent destruction in the laser script so that when lasers are destroyed after power-down, their parent objects are also removed, preventing leftover triple-shot objects.

Identify and destroy the parent object of a laser when present by checking transform.parent for null, then destroy the parent game object to remove the entire hierarchy.

Animate the triple shot power up by creating an animation clip, using the animator controller, and applying keyframes in Unity’s dope sheet to control looping.

Modify spawn manager to include the triple shot power up and add a spawn power up routine that triggers every 3 to 7 seconds at a random x and y=7.

Spawn a triple shot power up at a random x between -8 and 8 with y fixed at 7, using a coroutine and prefab instantiation, then repeat every 3–7 seconds.

Organize the project by creating dedicated prefab folders for enemy and power ups, and tidy up scripts by removing unnecessary comments to prep for more power ups.

Modular power up creation teaches building a speed power up with reusable power up logic using a single script and power up IDs to distinguish triple shot, speed, and shields.

Explore a modular power-up system in Unity, mapping ids to triple shot, speed, and shields, with clean if-else logic and future switch-based optimization.

Switch on the power up id to replace dozens of if-else checks with a clean switch statement, using cases, break, and a default, improving readability and efficiency in Unity.

Learn to implement a speed power up that increases speed from five to 8.5 m/s, then reverts after five seconds, integrated with the movement system and power up collection.

Learn to implement a speed boost power up in Unity by using a speed multiplier, activation and cooldown via a coroutine, and updating player movement with conditional speed scaling.

refactor the spawn manager by replacing hardcoded instantiation with a power ups array that maps IDs to prefabs and randomizes spawns for speed boost, triple shot, and shield.

Animate the speed boost powerup using the provided speed sprite animation, apply the override to the prefab, and ensure the animation carries when instantiated in the scene.

Animate the speed boost power up by creating a new animation clip, adding sprites, and arranging frames in the dopesheet. Test animator, apply overrides, and ensure speed plays on launch.

Drag the first frame into the hierarchy, rename and resize it, attach the required components, and assign it power-up behavior, then preview the shield animation in the next video.

Set up shield power up by adding a 2D circle collider and rigidbody 2D with gravity scale zero. Attach the power-up script, assign its ID, and animate into a prefab.

Integrate the shield power up into the spawn manager, extend logic to support three power ups, and randomly instantiate zero, one, or two for varied spawns.

Implement the shields power up in Unity, enabling one-hit invincibility by returning in the damage method when shields are active, then deactivating on the next hit; test in the editor.

Implement shield behavior in Unity with a private isShieldsActive boolean and a ShieldsActive method, granting one-hit invincibility before deactivating shields and wiring shield power-ups via OnTriggerEnter.

Make the shield a child of the player and toggle the shield visualizer on collection and off when inactive, using a variable reference and a ShieldsActive method.

Visualize shields in Unity by wiring a shield visualizer as a private GameObject, assigning it in the inspector, and toggling it with SetActive(true/false) to show or hide on damage.

Animate the shield visualizer by creating a new shields_visualizer_anim clip, dragging all sprites into the dope sheet editor, previewing, saving, and testing with the animator on the active shield object.

Create a live-updating score display in Unity by building a UI canvas and a score text, anchored to the top-right and scaled with screen size.

set up a UI manager to update the on screen score by binding a score variable to a text component, initializing at 50 and adding ten when enemies are destroyed.

Learn to implement a player score system in Unity with C# by adding ten points for destroying enemies, caching getcomponent calls via a player reference, and updating the UI efficiently.

Implement the lives display by swapping sprites in a UI image based on lives, starting with three and updating as they decrease, using a sprite array and update lives method.

Create a UI text named game over on the canvas, set its message to game over in white, and display it when the player runs out of three lives.

Display the game over text when three lives are depleted by wiring a UI manager field, dragging the text into the inspector, and toggling the text object on.

Practice building a flicker effect for the game over text in Unity by toggling the text component or the game object's active state to simulate a retro arcade flicker.

Learn to implement a game over text flicker using a UI manager, coroutines, and a flicker routine that toggles text every 0.5 seconds.

Implement a restart feature: show a white 'press the R key to restart the level' message during game over, and load a new scene when the R key is pressed.

Press the R key to restart the level after game over, using a game manager's game over flag and scene manager to reload the current scene.

Create a Unity main menu for a galaxy shooter with a nebula title screen and a new game button that loads the game scene via scene manager, plus credits.

Apply vfx and audio to explosions, thrusters, and asteroid destruction using sprite animations and prefabs, then control enemy death with a trigger in the animator, plus post-processing and deployment options.

Implement enemy explosion in Unity by accessing the animator component, using GetComponent and SetTrigger to fire the death animation on collision or destruction, then destroy the enemy.

Set up the enemy's animator, trigger the on enemy death animation, and destroy the object after the clip. Freeze movement by zeroing speed and disable has exit time for transitions.

place a rotatable asteroid that starts an enemy wave when shot, using a circle collider and 2D rigidbody. prefab the asteroid, create a behavior script, and experiment with rotation speed.

Define a rotateSpeed field, expose it in the inspector, and rotate the asteroid with transform.Rotate on the z axis using Vector3.forward and Time.deltaTime; disable gravity.

Instantiate an explosion prefab at the asteroid’s position when a laser collision occurs, and animate the explosion using a dedicated animation. Destroy the explosion after three seconds to clean up.

Explore implementing asteroid explosions in Unity: detect laser collision with Ontriggerenter 2D, instantiate an explosion prefab at the asteroid, destroy the asteroid and laser, and add a self-destroying explosion script.

Connect the asteroid to the spawn manager by using GameObject.Find and GetComponent, then call a public start spawning method when destroyed, and delay spawning with WaitForSeconds.

Attach a thruster sprite to the player, adjust its scale and position, and create a thruster animation in the Unity animation window using the first to last frames.

Visualize player damage by adding left and right engine thrusters, positioning them above the sprite, and enabling engines as lives decrease until game over at three hits.

Explore implementing player damage visualization by wiring left and right engine thrusters, enabling them as lives decrease, and animating engine failure with inspector setup and animator controllers.

Install the post-processing package from the Unity package manager to apply image effects and filters, acting like a Photoshop for your game, and recompile your project.

Create a global post-processing profile and apply bloom, color grading, and tonemapping by configuring a post-process volume and the main camera's post-process layer.

Create an audio manager with a background object and audio source, attach a music clip, and enable play on awake and looping to bring the game to life.

Learn to play the laser shot sound after the visual effect by storing the audio clip in a variable and using an audio source in the player script when space is pressed.

Learn to add a laser sound in unity by using an audio source and clip, assign the laser clip, retrieve the audio source with get component, and play on fire.

Implement an explosion sound in Unity C# by playing it when destroying the asteroid, the enemy, or the player, and research solutions during the challenge review.

Attach an audio source to asteroids, enemies, and explosions, assign the explosion clip, and play it when the explosion prefab instantiates, testing across player and enemy interactions.

Play the power up sound when you collect a power up to provide immediate audio feedback during gameplay.

Learn to play a power-up sound in Unity by using play clip at point to play a clip at the power-up's position, avoiding audio cutoff when the object is destroyed.

Explore deployment options for games by building WebGL, PC/Mac, and Android mobile versions to share your game with friends, family, and the world.

Learn how to build a Unity game for pc, mac, and linux, configure build settings and player options, and manage full screen, windowed mode, and quit behavior.

Build a unity webgl game by selecting the webgl platform, switching color space to gamma in player settings, compiling, and deploying the index.html to a web server.

Improve the space shooter by cleaning up and enhancing its features in this extra section, and share ideas like a wave system, multiplayer, or co-op in our community.

Fixes an enemy explosion bug by destroying the collider 2D after a hit to prevent multiple explosions and sounds from repeated collisions.

Add enemy fire by implementing randomized shooting every 3 to 7 seconds, with bullets descending toward the player in Unity C#.

Add enemy fire by instantiating enemy lasers under container, use a laser script for enemy and player lasers, and loop through lasers to assign them, with a 3–7 cooldown.

Use the game manager to quit the application when the escape key is pressed, enabling a clean exit from full screen gameplay.

Use a simple check for the escape key to call application.quit in full-screen Unity game. Note that quit is ignored in the editor and requires a build to test.

Set the triple shot prefab z-axis to zero and align each laser's z, apply overrides, then test in play to ensure bullets spawn at the correct position.

Master virtual reality basics in unity using no code tools as you tackle the VR pentathlon, five mini projects on spatial interaction with the XR Interaction Toolkit.

Set up a Meta Quest 2 as a developer device from scratch. Pair with the Meta Quest app, sign in, update software, and configure guardian boundaries and Quest Home.

Download and install the Oculus Rift software, configure Quest 2 for PC VR using Air Link or link cable, enable unknown sources, and get up and running with Unity.

Create a new Unity project with the URP template, install XR Plugin Management, and enable the Oculus plugin to connect Unity to Oculus Link.

Install the XR interaction toolkit and switch to the new input system. Explore starter assets, presets, and the input actions asset to customize bindings and study an XR origin setup.

Explore the xr interaction toolkit demo scene with teleportation areas and anchors, grab interactables in kinematic, instantaneous, and velocity tracked modes, and a ui example.

Explore XR interaction toolkit by building an XR rig with locomotion, then use grab and activate interactables, socket interactors, and a 3D UI that activates to knock down a building.

Build a simplified XR origin from the XR interaction toolkit, positioning the player's perspective at the scene origin and adjusting x, z, and rotation for a usable VR experience.

Explore the XR origin component and its role in room scale VR, including camera offset, main camera, and left and right hand controllers, while comparing floor-based and device tracking origins.

Enable the input action manager to activate all actions from the new input system on enable, and listen for headset data including head position, hand position, and button presses.

Explore XR controller component in Unity's interaction toolkit, handling position, rotation, tracking state, and actions like select and UI press. Presets wire left and right controllers and assign hand models.

Discover how the ray interactor creates a visible raycast with the line renderer and XR line visual to interact with distance objects, and start adding locomotion to the XR rig.

Configure the main camera as the head using a tracked pose driver that applies XR head mounted display eye position and rotation, with default XR origin bindings for head tracking.

Connect the locomotion system to the XR origin to manage movement requests from move providers, acting as a gatekeeper between systems. Use the help button to view the documentation.

Learn to use the XR interaction toolkit by reading the documentation, following the locomotion guide, and configuring the XR origin with input actions, a locomotion system, snap turn, and teleportation.

Add a snap turn provider to the locomotion system, compare it with continuous turning for comfort, and set 45-degree turns with debounce time and preset input mappings.

Add a continuous move provider in VR, configure move speed and gravity, choose a forward source (main camera or left hand controller), and resolve conflicting snap turns alongside teleportation.

Attach a collider to the XR origin, switch to a character controller, and use the character controller driver with a continuous move provider to auto adjust height and enable collision.

Add a teleportation provider to the XR rig, linking it to the locomotion system and XR origin, to enable teleport actions after setting up continuous movement and snap turns.

Add the teleportation provider, teleportation areas, and anchors to ground planes; configure the teleportation trigger to grip press via XR controller select actions, with hover cues indicating selectability.

Learn to manage two controllers for interaction and teleportation in Unity using the action based controller manager to switch between ray interactor and teleport interactor via activate and cancel actions.

Set up the xr origin with an action based controller manager and ray interactor, add direct and teleport interactors, and configure xr interaction group to map teleport to joystick forward.

Learn to isolate interactions with the interaction layer mask, letting the teleport interactor target only teleport objects while the ray interactor handles everything else, then validate left-hand behavior.

Explore curved raycasts for teleporting, choosing between projectile and bezier curves. Adjust velocity, acceleration, ground height boost, flight time boost, and sample frequency for a smoother teleport path.

Change the teleport line color in Unity by updating the line interactor's color scheme to a blue gradient for valid targets, creating a more teleporty feel.

Spawn a ground teleport reticle from the line visual component to show your destination, using the default directional reticle and enabling match directional input to align direction after teleport.

Create and apply new materials for the teleport reticle and blocked version, adjust blue and red emission, and switch to fade rendering for transparency; observe consistent updates across all prefabs.

Place teleportation anchors around the obstacle course to enhance navigation and accessibility, using the teleport pad prefab from starter assets and experimenting with anchor placements for faster travel.

Place teleport anchors aligned with the blue forward arrow to set the facing direction. Test the pads and tune configuration options to smooth the teleport process.

Debugs teleportation by adjusting anchor selection and ray interactor settings, compares prefab and XR rig, and aligns select action options to improve consistency.

Navigate the xr rig with teleportation and anchors, completing event one and advancing to event two, then begin exploring grab interactables in the next section.

Import hand models to replace virtual hands in the XR rig and enable grab interactables in VR by attaching hands from filebase and testing with the XR origin.

Add hand models to your XR rig using model prefab, linking left and right hands to the XR controller components so they track the controllers, with rotations adjustable if needed.

Apply a transparent blue material to VR hands using prefabs. Experiment with shader graph ideas, such as a Fresnel effect, to customize the hands, and animate them for grip input.

Import and set up hand animations in Unity with the XR interaction toolkit, selecting default and fist FBX files for left and right hands, and explain bone structures driving animation.

Open the left or right hand prefab, inspect the parent object and its capsule colliders, and learn how a skinned mesh renderer uses bones to animate and collide.

Preview hand animations on the model, then fix name mismatches with the underscore replace tool by converting underscores to colons to restore the left hand fist animation.

Create a runtime animator controller as a state machine to cycle left hand animations based on conditions, assign it to the left hand animator, and open its window.

Create animation states for hands using a simple state machine in the animator controller. Define open and closed states, add transitions, and configure state speeds in the inspector.

Assign animations to states by setting open state's default motion and closed state's fist motion; lock the inspector and drag the left hand motion (fbx take 001) into each state.

Learn to create and manage state transitions in Unity by linking open and closed animation states, inspector options, and disabling exit time to trigger transitions only when something happens.

Add parameters and triggers to control unity animations, using select and deselect to drive transitions for left and right hand xr controllers with the xr interaction toolkit.

Replicate the left hand animation approach for the right hand. Identify which parts stay the same and which require adjustments.

Duplicate the left hand animation controller, swap to the right hand, and assign its animator controller. Observe open/close transitions driven by select and deselect parameters enabling grabbing in Unity.

Wire up XR interaction toolkit components to make basketball prefabs grabbable in this overview. The hoop's collider and rigid body work with the hoop script to update the scoreboard.

Modify basketball prefabs by adding a sphere collider to define physical boundaries and enable automatic sizing, preparing for the upcoming grab interactable component.

Add an XR grab interactable to a prefab, explore movement type and interaction options, including interaction layer mask, then use ray interactor to grab, throw, and refine the character controller.

Set the XR origin's character controller radius to 0.25 meters to reduce collisions and keep a safe distance from basketballs, and use the direct interactor for grabbing Grabbable objects.

Learn to prevent collision between an XR origin and grab interactables using physics layers and the layer collision matrix, unchecking XR origin and grab interactables to solve movement weirdness.

Use dynamic attach in the XR interaction toolkit to grab objects at the grab point, not the center. Adjust attach transform, snap to collider volume, and rotation settings for picks.

Convert the left hand into a direct interactor only, eliminating ray interactions and aligning with the right hand’s direct interactor setup.

Remove the ray interactor visuals, add an XR direct interactor to the left hand, fix the interaction manager reference, and demonstrate isTrigger sphere collider behavior for both hands.

Adjust basketball physics by creating a physics material, tuning bounciness and friction, and altering mass and throw velocity to simulate realistic throws and score points in the hoop.

Apply a physic material to the ground to control bounce, balancing ground and ball bounciness, then experiment with separate materials for different areas.

Replace basketballs with tennis ball, football, and beach ball in a Unity scene, create prefabs, and organize them in the correct hierarchy for reusable dynamic objects.

Turn the tennis ball into an interactable object by enabling pick up, throw, and collision with other objects, using the basketball as a reference.

Make the tennis ball interactable by adding a sphere collider, rigidbody, and XR grab interactable, adjust throw velocity, mass, and enable dynamic attach for realistic grabbing and respawn.

Create a physics material for the tennis ball in Unity, adjusting bounce to suit the ball, as demonstrated for basketball and ground, and review the solution video.

Create and assign a tennis ball physics material to its sphere collider, adjust bounciness and friction, and switch to continuous collision detection to prevent floor penetration and refine feel.

Dial in the tennis ball feel by tweaking rigid body mass and throw velocity on the grab interactable to score with the basketball net, reinforcing Unity physics mechanics.

Dial in the tennis ball feel by adjusting throw velocity scale, mass, and drag to form a natural arc and place ball on the grab interactable layer for XR origin.

Apply the same changes to the football and beach ball to make them feel unique, exploring different parameters and collider options beyond a sphere collider.

Tune colliders to match football and beach ball shapes, apply rigidbodies and grab interactables to prefabs, adjust mass, drag, throw velocity, physics materials, and add two balls.

We complete event number two by testing throws with tennis balls, a football, and a beach ball to score points and verify mechanics, then move on to the shooting event.

Advance to event three to activate interactables with the handgun and pistol controller script; targets with colliders respond to trigger pulls with muzzle flash and a hit prefab.

Take on a challenge to make the pistol grabbable by testing different colliders to best match its shape and feel, with a solution video to review results.

Make the pistol grabbable by adding an xr grab interactable, a rigidbody, and a handle-focused compound collider, limit grabs to the handle, and adjust the xr origin.

Use an attach transform to align the hand with the gun, creating an attach point for a precise grip. Iterate by moving the point and testing until it fits.

connect the activate event on a grab interactable to the pistol controller's trigger pull method, so pulling the Oculus Touch trigger produces a muzzle flash and gun firing.

Tag all targets as target to enable hit detection, trigger muzzle flash, and provide hit feedback via raycast and hit prefab. The video sets up sound effects next.

Learn to add a gunshot sound effect by configuring an audio source on the gun, setting play on awake off, 3D spatial blend, and triggering play through an interaction.

Add a second pistol to your Unity scene by importing a one-handed gun, making it grabbable, and configuring a pistol controller script to mirror the first pistol's functionality.

Learn how to add a second pistol to a Unity scene by importing FBX, unpacking the prefab, and setting up a pistol controller with colliders, grab interactable, and 3D audio.

Import and place a two-handed shotgun as a grab interactable in the scene, exploring two-handed weapon setup and interaction within Unity.

Rename the object to shotgun, add a box collider, adjust the bounding volume, and create a ray point with an attach transform to enable XR grab interactable behavior.

Learn to implement two-handed interaction for a shotgun with the XR interaction Toolkit, switching between single and multi-hand modes, and configuring a secondary attached transform for natural hand placement.

Add a shotgun sound by locating a shotgun audio file in the file base and playing it when the grabbable object is activated, matching the revolver and pistol setup.

Implement a shotgun sound by adding an audio source, playing on activation with 3D spatial blend, importing and assigning the shotgun clip, and confirming three working guns in the scene.

Add a sword as a grabbable melee weapon in the scene, enabling two-handed grabs and experimenting with movement types, including kinematic or velocity tracking.

Add a melee sword to the scene, unpack the prefab, add the grab interactable component, and set blade, hilt, and handle colliders for two-handed grabbing with velocity tracking.

Add a rocket launcher to your scene by wiring the rocket prefab using the existing script and unity events to launch the rocket, incorporating two-handed interactions and sound playback.

Drag in the rocket launcher, add a grab interactable and box collider, configure two-handed grab points, enable kinematic movement, and implement rocket firing with a prefab, sound, and explosion.

Add a rigidbody and a trigger capsule collider to the rocket prefab, disable gravity, set istrigger, and test the ontriggerenter explosion in the rocket collision lesson.

Explore the escape room using a socket interactor to dock a key into the keyhole, turning a drawer into a grab interactable to open the door.

Examine how to make a cabinet drawer in Unity using a configurable joint for linear movement, lock axes, and prepare for VR by attaching a handle with a fixed joint.

Attach a handle as a child of the top drawer, connect it with a fixed joint, and test that grabbing opens the drawer in vr.

Understand why the handle is a separate rigid body with a fixed joint, not the whole draw as a grab interactable, to preserve controlled physics.

Tackle a challenge to convert the key into a grabbable object in Unity, reinforcing repeated techniques for making objects grabbable.

Make the key a grabbable object by adding a box collider and a grab interactable, then plan to fix the drawer collision in the next video.

Add a collider to the drawer to interact with the key, evaluate mesh, cube, and box options, then use a bottom box collider to prevent the key from dropping.

Configure a socket interactor on the keyhole to accept the grabbable key, enable a live preview, and trigger hover and select events as you dock the key in.

Use interaction layer masks to restrict a socket to key objects only by creating a key layer and assigning it to the socket and the key.

Examine how the door's animator controller, avatar, and a door open trigger drive a transition from the closed state to the open animation when the socket activates.

Learn to connect a socket interactor to a door animator, using the select enter event to trigger the door open animation via the set trigger name door open.

Add a head socket and wear a hat as a socket object, then preview the result in a mirror by importing a crown asset and placing it on a table.

Create a new socket interactor on the head-mounted camera to socket a hat, add an optional interaction layer mask to restrict hats, and preview the result in the mirror.

Convert the crown into a grab interactable with a hat layer mask. Add a hat socket on the main camera and test in VR for a player hat inventory.

Create a key socket as a child of the chosen tracked point (XR origin, main camera, or left and right hand) and attach a socket interactor to accept the key.

Attach a key pocket socket to the xr origin, shrink and hide the key, and use a trigger collider to grab and store keys for door access.

Import a food asset into the scene, turn it into a grab interactable with a collider, and create a dedicated food interaction layer mask for picking up and eating.

Create a head-mounted food socket in Unity and connect it to the Food Eater script and a socket interactor to eat food when hovered or selected, destroying the food.

Duplicate the hat socket to create a food socket, connect the food eater to the socket interactor, and test hover and select interactions to eat food with XR interaction toolkit.

Explore gaze interaction concepts in the demo scene: gaze hover, gaze assisted, and gaze select, using raycasts from the headset center with eye-tracking on future headsets in mind.

Learn how gaze interaction works with XR simple interactables, enabling gaze interaction and selection on an XR rig by adding a gaze interactor and a gaze-specific XR controller.

Add an XR gaze interactor to the main camera, wiring eye gaze position, rotation, and tracking state to reveal the lock when looking at the mirror.

Configure the mirror as a simple interactable by adding an interactable script and a box collider set to trigger, enabling gaze interaction. Test hover vs gaze reveals issues to troubleshoot.

Troubleshoot and align the gaze interactor with head tracking by un-parenting it from the main camera and using a sibling relationship, ensuring accurate gaze at mirrors.

build a two-step interaction where the mirror's lock appears only after you put on the king's hat, using component enablement to control responses.

Wear the hat to enable the mirror's simple interactable, then gaze at the mirror to activate the keyhole and unlock the door.

Execute the escape room puzzle by retrieving the key from the drawer, using the crown and mirror to reveal a hidden keyhole, and escaping to the next section.

Build 3D controls to operate an excavator and demolish a building in event five of the VR pentathlon, then add a 2D UI controllable with controller raises.

Reposition the XR origin and use an excavator controller to move the cab, arm, bucket, and tracks, adjusting drive speed and limits with 3D UI elements that accept float inputs.

Import the Xri examples project as a Unity package to borrow assets for excavator controls, since programming isn’t covered in this course.

Explore the XR interaction toolkit examples, including grab and activate interactables and teleportation, and see how existing components are extended into a joystick, lever, and slider in Unity.

Design and place a lever in a Unity scene using XR 3D UI prefabs, enabling an up-and-down arm motion and prepping for interfacing with the excavator controller script.

Use a two-position VR lever to move excavator arm, mapping on to 1 and off to 0. Discover inverted activate and deactivate, raise arm limits to 270, and start deactivated.

Explore the lever assembly and change the default lever value to stop snapping. Unchecking the value option makes the lever lift the excavator arm as intended.

Tackle a second lever in Unity, planning the start position and possible inversion to lower the arm, and decide how deactivating the lever moves the arm.

Add a second lever and flip it to oppose the first. Set it to -50 and 180-degree y flip, wire to move the excavator arm with negative activation; challenge complete.

Drag the joystick prefab into the scene and test its gamepad-like behavior, even in VR, with separate x and y axes that drive forward, backward, and turning via Unity events.

Control an excavator with a joystick, mapping x and y axes to rotate tracks and move forward with dynamic, analog inputs, and prepare to rotate the cab next.

Add a wheel to rotate the cab, wiring a Unity event to the excavator controller with a dynamic float starting at zero, and test in play mode.

Learn to control an excavator bucket using a dial or wheel with the ZR knob script, adjusting clamped motion and twist sensitivity for full 3D UI control.

Use the joystick to rotate the demolition crane, raise the arm, and knock off the building’s top layers, then drive forward to complete the destruction and review 3D UI coverage.

Explore Unity 2d UI on world space canvases in VR using the XR interaction toolkit. Learn how render modes, canvas scaler, and tracked device graphic raycaster enable VR UI interactions.

Create a 3D UI label in Unity using Text Mesh Pro on a canvas, switch from screen space overlay to world space, and place the 'arm up down' text.

Take on a practical challenge to add more text labels on a single canvas, creating multiple text objects to label everything, then continue to the next lesson.

Label and organize 3D UI elements by creating and positioning canvases, naming tracks move rotate, cab rotate, and bucket. Proceed by creating another canvas to continue labeling the UI.

Create and position an excavator control canvas with a bold title, add a semi-transparent backdrop, and name elements clearly for future slider integration.

Add a premade UI slider with min -1, max 1, start value 0; wire its on value changed Unity event to rotate the cab via the excavator controller.

Add a tracked device graphic raycaster from the XR interaction toolkit to enable canvas interaction, so pointing the ray highlights the canvas and the 2d cab rotation slider works.

Add three more sliders to control track movement, track rotation, and bucket movement, linking them to the excavator controller methods to enable near full control of the excavator.

Add three more sliders to control cab rotation, bucket rotation, tracks rotation, and forward movement, set the bucket to -1 to 1, align vertical orientation, and test the integration.

Use boolean levers instead of a slider to drive the arm, with a dynamic move arm method. Hook controls to move arm, rotate bucket, tracks, and cab via a joystick.

Add a ui button to the excavator controller canvas at the top right as an exit labeled with an X, and use onClick to deactivate and reactivate the canvas.

Create a 3d grip button from UI 3d prefabs, wire its on press to activate the excavator control canvas, set default off, and enable a 2d label for controls.

Explore the user interface by guiding an excavator to move and rotate tracks to demolish a building. Reuse the excavator controls panel to repeat the demolition.

Learn to create AR experiences using Unity's AR Foundation and XR Interaction Toolkit for Android and iOS. Build custom AR mechanics in C#.

Identify device compatibility for mobile AR by comparing iOS and Android, ARKit and ARCore, then build iPhone apps on Mac and Android on Windows, testing with Unity device simulator.

Install the Unity editor (2020 2.3 LTS) and enable Android and iOS build support to begin AR development, noting platform constraints and preparing to demonstrate cross-platform builds.

If you're on Mac and want to build for iPhone, install Xcode from Mac App Store, since Unity exports an Xcode project that you sign and build to your device.

Select the correct Unity editor version (2022.3), set up a URP project, install the 3D URP core template, name it Magic Box R, and create the project to build.

Import AR Foundation to enable multi-platform AR in Unity by abstracting ARCore and ARKit, allowing once-builds to run on Android and iOS, with features like image, object, and face tracking.

Install ARKit for iPhone on Mac or ARCore for Android on Windows or Mac, with plans to install both; once one is installed, you’re ready to move on.

Switch the build platform in Unity to iOS or Android to target your device, then verify the change when the Unity logo appears beside the chosen platform.

Enable the AR plugin in Unity via XR Plugin Management, selecting platform-specific plugins: ARKit for iOS, ARCore for Android, or Oculus OpenXR for stand-alone builds.

Install and explore the XR interaction toolkit, enabling AR interactions with gesture interactor and interactables for placement, selection, translation, scale, and rotation, and adjust project settings to build without coding.

Create a simple augmented reality app that tracks and highlights planes, rendering a plane on a detected surface to demonstrate AR Foundation.

Create an XR origin in Unity from the XR section with the AR template, then delete the scene's main camera so the XR origin controls the project perspective.

Examine the XR origin setup with camera offset, main camera, and left and right controllers for a mobile AR experience; tracked pose driver and input actions move the main camera.

Add an AR session game object with the AR session component to enable tracking and pass positional data to the XR origin, making AR features functional in the scene.

Learn how AR Foundation detects planes, uses an AR plane manager to spawn a plane prefab, and visualize horizontal, vertical, or both planes with an AR default plane prefab.

Learn to set up an AR plane manager on the XR origin, choose horizontal plane detection, and prepare to create the corresponding prefab in Unity.

Create an AR default plane prefab and link it to plane detection, so a prefab is created for every detected plane.

Test the AR app by enabling XR simulation in project settings, then run the editor to verify plane detection and display before building to devices.

Install sample environments from the XR environment window and explore categories like bedrooms, backyards, and kitchen to test your app across diverse spaces without real devices.

Launch the XR simulator in Unity, view the game scene loading in the hierarchy, planes pop up, but a step was missed.

Add an AR background renderer feature to every URP renderer asset (balanced, high, performant) to pass the camera feed into the game view and render AR planes.

Fix ar default plane rendering by replacing the standard debug plane material with a urp shader material, then apply a transparent yellow plane to the mesh renderer.

Learn how to test your iOS app using a normal Apple ID, understanding why the Apple Developer Program is optional for testing, and how builds expire after two days.

Switch to the iOS build platform, enable development build, and enable ARKit support to request camera permission; tune player settings such as company name, product name, version, and icons.

Build an iOS Xcode project using the build or build and run option, place the iOS build in an iOS build folder, then Xcode opens for fixes.

Add your device to the devices list in Xcode, enable developer mode and trust this computer on the device, restart, and proceed to signing the app after the build failure.

Add your Apple ID to Xcode accounts to sign your iOS app and obtain a provisioning profile for building on devices.

Enable automatic signing to auto-fill provisioning details, select your personal development team, and automatically create a signing certificate so the Unity iOS app runs on a real device.

Launch the unity app on an iPhone by pressing the play button in Xcode to deploy to a real device, track planes, and view live debug logs for debugging.

Switch your Unity project from iOS to Android by changing build settings, and note that larger projects may re-import assets, though this new project will finish quickly.

Enable USB debugging on Android devices by navigating to developer options, turning on USB debugging, and approving the connection, then refresh the device list and select your phone to build.

Raise the minimum Android API level to 24 for ARCore, switch scripting backend to IL2CPP, enable 64-bit architecture, and remove Vulkan to use OpenGL ES 3.

Deploy Unity AR apps to Android devices by using build and run to automatically install the APK on your phone, verify plane tracking works, and test on Android.

Harness AR Foundation raycasts with the XR Interaction Toolkit to place a virtual object on tracked planes when the user taps the screen, using the built-in physics raycast.

AR raycasts optimize performance and accuracy for AR environments, while physics raycasts can hit planes with mesh colliders; both can interact with physics objects.

Learn ARRaycast sample code to talk to the component, perform touch-raycasts or a ray data type, and access plane alignment and hit details for object placement.

Learn to use the XR Interaction Toolkit to place objects on planes in AR by tapping the screen, using the AR placement interactable, raycast manager, and AR gesture interactor.

Add an AR raycast manager to the XR origin alongside the AR plane manager, via AR Foundation, to perform AR raycasts; optionally spawn a prefab on hit.

Add an XR placement interactable and its XR interaction manager, specify the XR origin, and use interactable events to trigger actions in custom scripts when an object is placed.

Specify a placement prefab by creating a default cube at 0,0,0, scaled to 0.1 m, and drag it into the placement prefab field to instantiate on raycast hit.

Place the AR gesture interactor on the main camera and connect its XR interaction manager. Tap to trigger the placement interactor's raycast and place the cube at the hit point.

Load XR simulation, observe tracking, and tap to place cubes on planes; note simulator incompatibility between XR Interaction Toolkit and AR Foundation, with a fix in 2.5 and real-device demo.

Test tap to place on a device by building for iOS, running on the phone, and tapping to place multiple cubes on a plane, offsetting to sit on the plane.

Add interaction by implementing the selection, translation, scale, and rotation interactables for the cube, with selection visualization created on touch to designate the selected cube for translation, scaling, or rotation.

Learn to place a cube on a tracked plane by creating a zero-position parent, offsetting the child by half its scale, and recreating the prefab.

Add an AR selection interactable to the placement prefab and attach it to the parent to preserve offset. Define the collider, enable single selection, and set up a selection visualization.

Create and apply colorful materials to a plane and cube, organize assets, and control selection visuals to showcase an interactable placement prefab in Unity.

Test AR selection interactable by tapping placed blue cubes to select or deselect, with only one object selected at a time using the XR Interaction Toolkit and plane tracking.

Add the R translation interactable to the placement prefab to enable dragging placed objects with a finger, constrain translation to a horizontal plane, and use a collider.

Test and demonstrate AR translation interactable by building and running, tracking planes, placing cubes, and dragging selected objects with smooth finger-following movement using the XR Interaction Toolkit.

Add the R scale interactable to resize objects with pinch gestures, configure minimum and maximum scale, elasticity, and sensitivity in Unity, and test it in the next video.

Test the AR scale interactable by building and running, place a cube, pinch to scale up or down, then select and move or scale multiple objects.

Experiment with elasticity and elastic ratio limit on the R scale interactable to make the cube bounce at the minimum or maximum scale.

Experiment with the elastic ratio and elasticity to create a smooth, bouncy scale interaction for a cube, adding polish as it hits those limits.

Implement an AR rotation interactable that rotates the selected object with twist or drag gestures, configure it in the prefab, and test in the project to refine sensitivity.

Test ar rotation interactables in unity, rotating with two fingers while translating and scaling a cube, using ar gestures and xr interaction toolkit, and preview ar annotation interactable next.

Explore how the Unity AR annotation interactable floats labels over objects, hides them when you aren’t looking or are out of range, and supports multiple annotations on one object.

Implement the r annotation interactable by adding it to placement prefab, linking its visualization object, and configuring max fov offset angle and annotation range (0.25, 10) from the documentation.

Create an annotation visualization by adding a Text Mesh Pro world-space canvas labeled 'cube', tying it to an annotation interactable that activates on selection and remains off by default.

Increase the activation area for the annotation interactable and experiment with different colliders to reliably trigger the pop-up above the cube.

Increase the annotation's max fov center offset angle and set the collider volume to improve the annotation appearing when pointing your phone at the cube, then test.

Remove the stray red line by disabling the XR ray interactor, line visual, and line renderer on the left and right controllers, ensuring clean builds while preserving interaction with objects.

Take on a hands-on challenge to recreate the placement interactable for a new primitive (sphere, capsule, or cylinder), duplicating selection, translate, scale, rotate, and annotation, and updating the prefab.

Create a sphere placement interactable prefab with an empty parent and a scaled sphere, then add translation, rotation, and elastic-scale interactions plus annotation visualization for placement and selection.

Replace primitive objects with polished assets from GameDev HQ's File Base by importing the File Base plugin into Unity and opening the File Base menu to browse and import assets.

Import assets from filebase to create an AR experience, place and adjust cubes and spheres, and explore crime scene assets, with FBX imports and future material updates.

Fix pink shader issues by converting built-in materials to URP in the materials folder, and update shaders to universal render pipeline shaders so crime scene assets reference the new material.

Duplicate a primitive to create a pylon placement prefab, swap in a cone scaled to real life size, and add a box collider with updated annotations.

Swap the placement prefab for a pylon and test the interaction. Then build a system to switch between placement prefabs and place the cone by tapping and scaling.

Create another placement prefab using a different asset from the pack, such as a crime scene asset, following the same process shown earlier for the pylon.

Duplicate the placement prefab, replace asset with evidence bag, unpack, update colliders and annotations, and test in a build; then set up a 2d user interface to choose between prefabs.

Create a simple menu system with on-screen UI buttons to switch the AR placement interactables between the evidence prefab and the pylon prefab, enabling on-the-fly changes.

Create a screen space canvas to host 2D UI elements, using the canvas scaler and graphic raycaster to anchor bottom buttons while previewing portrait and landscape layouts.

Add a button to the Unity canvas by selecting UI and button Text Mesh Pro, creating a centered button with an image and a button component, and note rect transform.

Anchor presets pin a UI button to bottom center, making it adapt to screen changes; use scale with screen size and adjust match area to fit portrait and landscape.

Enable a UI button in Unity by applying hover color tint, wiring an onClick event to perform actions, and optionally hide the button by deactivating its game object.

Create a button bar by using a horizontal layout group and a button parent to automatically arrange cone and evidence buttons at the bottom, responsive to screen size and orientation.

Make buttons communicate with the placement interactable to set the placement prefab, switching to the cone or evidence bag objects for placement, with no prefab by default.

Test UI buttons on a real device to switch between placing cones or evidence, while continuing to manipulate existing objects as before.

Add a plus button that toggles the add-item menu, enabling the cone and evidence buttons for placement and then turning itself off after an item is placed.

Practice using Unity events to reset the main menu after playing, making the plus button active and the cone buttons inactive, while leveraging placement interactable events.

implement the placement menu reset: on object placed, toggle cone, evidence, and add buttons, then set the placement prefab to none to return to the initial state.

Learn to build your first AR app in Unity with plane tracking, placing cones via a plus button, and manipulating them by selecting, moving, scaling, and rotating.

Develop a custom examine mechanic in Unity using C# that toggles objects between world and screen space; tap to place, drag to examine, and tap again to return.

Create a fresh scene in the scenes folder named object placer, then a second scene called object examiners, and tidy assets by using a prefab folder for placement prefabs.

Tap to place a cube by programming a custom interaction, ensuring the scene tracks planes and places a prefab on the tracked plane.

Tap to place an examinable cube prefab on tracked planes using an XR origin with plane and raycast managers, a gesture interactor, and an AR session.

Plan and implement examinable placement prefabs that parent to a camera-controlled examine target, using an examinable manager to enforce single-object examination and support offset positioning.

Create your first C# MonoBehaviour script by renaming the default to examiner so the class matches the file name; then make an Examinable script to attach to objects.

Open your Examinable script in Visual Studio by double-clicking it. If it won’t open, check editor in Unity preferences and use Regenerate Project Files to relink Unity and Visual Studio.

Explore how Monobehaviour enables scripts to be used as components in Unity, with start and update methods, and learn to attach scripts to game objects for console logs.

Turn the examinable script from printing on start to printing something every frame, exploring how to output continuously each frame.

Learn to print every frame by placing output in the update loop, understand the difference between start and update, and observe a live frame render rate in Unity.

Create an Examinable Manager script and a game object named Examinable manager in the scene, then attach the script as a component to set up from the start.

Create an examinable manager script, rename it correctly, then create an empty game object named examinable manager and add the script as a component to keep it in the scene.

Attach the Examinable script to the placement prefab so every placed cube is examinable. Make sure the prefab already defines the Examinable interaction by default for all placements.

Add the examinable script to placement prefabs and ensure each cube is examinable, then open both scripts in Visual Studio to verify communication with the Examinable manager.

Switch to dark mode in Visual Studio across macOS and Windows, using preferences and appearance options to set a dark theme for easier viewing.

Learn how to declare variables and strings in Unity, set a default value, print to the console at start, and use the inspector to vary output without hard coding.

Expose and serialize variables to edit in the inspector by using public, private, or serialize field, allowing external scripts and the editor to read or override values.

Create a null examine target as a child of the main camera. Add a serialized transform field on examinable manager and drag the target into the inspector to reference it.

Learn to access data on a transform component using dot notation, read properties like local position and local rotation, and print the game object's name to show data flow.

Learn to connect an examinable prefab to its examinable manager using a serialized field and a one-time start call to find object of type examinable manager.

Tap the cube to trigger a selection interactable event, have the Examinable manager move it to the examined target, and set its parent so it follows the camera.

Create custom public methods in Unity objects and invoke them via Unity events, wiring an examinable object's request examine method to the select entered event.

Expose the method as public to let other scripts and Unity events call it from the editor. Save the change, select Examinable, and see the requestExamine method ready to run.

Learn to decouple selection by having the examinable script call the examinable manager's public perform examine method via a reference and dot notation, triggered by the select entered unity event.

Pass the examinable as a parameter to the perform examine method, use this to reference the calling instance, and move and parent the examinable to a new target.

Access the examinable's transform, set its world space position to the examined target, and parent it to that target to follow the camera with a five centimeter offset.

Rework print statements to use the Xcode console and indicate when examine is requested. Clean up the examinable manager and remove unnecessary prints for clearer feedback.

Test the examine mechanic by building and running the scene with a tracked plane and an examinable cube, then adjust the target distance to reveal it.

Adjust the target position by trial and error, place and examine a cube in Unity, and watch it appear in front and follow the phone as it's parented.

Learn to implement unexamined behavior in a Unity C# game by adding two empty methods, perform unexamined and request unexamined, to return an examined object to its original position.

Create two methods: request unexamined in the examinable class and in the examinable manager, and implement perform unexamined; this completes the challenge.

Cache the examinable's position at the start of the perform examine method by storing its current Vector3 in a private cached position field, enabling undo later.

Store a reference to the examinable as a class field. Initialize current examined object to null and set it in the perform examine method to access the cached position.

Write the perform unexamined method to reset the current examined object's transform to the cached position, set its parent to null, and update naming for readability.

Save the script, call examinableManager.performUnexamined to request the unexamined with empty parentheses, and print the status to the console before wiring it up in the editor.

Hook up the request unexamine method for the examinable cube by wiring the select exited event to unexamine, while the select entered triggers the examine.

Tap to place and toggle cubes, verify examine and unexamine actions through console messages, and identify the need to remember rotation in addition to position for the mechanic.

Install Android Logcat from the Unity registry via the Package Manager, then connect your Android device and filter logs by your app to debug on-device errors, warnings, and print statements.

Cache the object's rotation alongside its position by using a quaternion, storing the current rotation in cached rotation, and applying it during unexamine to restore world-space orientation.

Update the perform unexamined method to cache and restore rotation, completing the rotation restoration like the position process by setting the current object's rotation to the cached rotation.

Update the PerformUnexamine method with one line of code to restore the object's rotation by applying the cached rotation from the transform component, completing the challenge.

Test the examine mechanic with rotation to see how rotation affects interactions, using cubes to observe improved examining and preparing for more interactivity in the next lesson.

Interact with objects by dragging to rotate them and reveal clues, using Unity's input touch count in the update loop to respond when the screen is touched.

Learn to access touch input in Unity with the get touch method, retrieve the first touch's position and phase, and print touch data to drive object movement.

Limit per-frame checks to when an object is being examined by introducing a private bool is examining and guarding with a nested if that prints the touch position.

Learn how to detect finger movement in Unity using the touch phase enum to rotate an object, compare touch.phase to touch.phase.moved, and print the movement or position each frame.

Use the delta position to measure movement since the last frame and rotate an object with finger movement.

Rotate the current examined object in Unity using the touch delta position mapped to transform.rotate, with z fixed at zero; plan to add rotation speed control in the next video.

Multiply the touch delta rotation by a serialized rotate speed to slow rotation, exposing a float in the examinable manager for easy in-editor tweaking.

Cache the object's local scale in a private Vector3 called cached scale, then restore it after examination by reapplying the cached scale to the object's local scale.

Add a per-object scale modifier in Unity by introducing examine scale offset in the Examinable class, expose it publicly, and convert it to a Vector3 for local scale updates.

Set a local vector three offset for the examinable's scale by caching its transform, multiplying by the examine scale offset, and applying the offset scale for viewing.

Replace the placement prefab with a chosen asset to test the examinable system, ensuring it is marked as examinable and the scale offset fits the screen.

Replace the Examinable cube with a real asset by importing a stapler, converting to URP, and wiring the selection interactable and the placement interactable to examine and place.

Explore creating an interactive Unity scene by solving a gem-order puzzle using selection interactables and an examinable skull to reveal a new gem.

Create a new scene, set the magic box as the startup (index zero) in build settings, and import the magic box starting point prefab with office tools and gems.

Tackle a hands-on challenge to set up a placement interactable, creating XR origin and placing a magic box starting point on a plane using the raycast manager and plane manager.

Set up the XR origin and AR plane tracking, add a gesture interactor and a placement interactable, then ensure tapping places a single starting point via an on-place event.

Make the skull in the magic box starting point prefab examinable by applying the examinable script, building on prior examples to explore interactive objects.

Make the skull examinable by creating an examinable manager, setting the examine target under the XR origin, adding the examinable script, and wiring the selection interactor to reveal the clue.

Plan the three gem objects with gem and selection components to test order, illuminate taps, and trigger the box opening via the box manager and animator.

Create a box manager class on the prefab to hold the correct gem order and compare it to the input, triggering the lid animation via the animator when they match.

Create a correct gem order and an entered gem order using colors blue, green, and red; compare them after three taps and open the box with the box animator.