Computer Graphics | Étienne Peillard

Course — Introduction to 3D rendering

Tue, 10 Feb 2026 00:00:00 +0000

Introduction to 3D Rendering

How do we create images of virtual worlds?

What is Rendering?

Rendering answers a simple question:

For each pixel on the screen, what color should it be?

An image = a grid of pixels
Rendering = computing the color of each pixel
This depends on:
- Geometry of the scene
- Materials of objects
- Light sources
- Camera position

Two ways to think about rendering

1) Image-first (modern view)

For each pixel:

What light reaches the camera?
How does the surface reflect it?
How do we approximate this efficiently?

2) Geometry-first (historical view)

Transform 3D objects → project → shade → display.

In this course, we start from the image-first view.

Part I — Cameras and Projection

Virtual Camera

A virtual camera is defined by:

Position (isAt)
Viewing direction (lookAt)
Up vector
Field of view (FOV)

Projection: 3D → 2D

We must map 3D points to 2D pixels.

Two main types of projection:

Parallel (orthographic) projection
- No size change with distance
- Useful for technical drawings, CAD, UI

Perspective projection
- Distant objects appear smaller
- Matches human vision and photography

Perspective and Field of View

Key parameters:

Focal length (camera metaphor)
Field of View (FOV):
- Horizontal FOV
- Vertical FOV

Smaller focal length → wider FOV
Larger focal length → narrower FOV

The View Frustum (View Pyramid)

The camera sees only what lies inside a 3D volume:

Near plane
Far plane
Left, right, top, bottom planes

This defines what can potentially appear on screen.

Head Tracking and Dynamic Frustum

In VR / AR:

The frustum deforms with head position
It is defined by:
- The four screen corners
- The viewer’s eye position

This enables correct perspective for each eye.

Part II — From 3D to Pixels: Rasterization (Modern GPU View)

Two Families of Rendering

Rasterization (real-time, GPUs)

Used in games, VR, AR
Very fast
Approximates light behavior

Ray Tracing / Path Tracing (physically based)

Traces rays of light through the scene
More realistic reflections, shadows, global illumination
Historically slow → now accelerated with modern GPUs

The Modern Graphics Pipeline (Simplified)

Vertex Processing
- Transform 3D vertices to screen space
Rasterization
- Convert triangles into pixels (fragments)
Fragment (Pixel) Shading
- Compute color using materials and lights
Post-processing
- Tone mapping, bloom, color grading

Visibility: What do we actually see?

Before shading, the GPU determines visibility:

Back-face Culling

Triangles facing away from the camera are discarded
Saves computation

Depth Buffer (Z-Buffer) — in practice

For each pixel, we store the depth of the closest surface.

If a new fragment is farther away → it is discarded.

This solves hidden surface removal efficiently.

Practical issues with depth

Common problems in real engines:

Z-fighting: precision issues when surfaces are very close
Overdraw: many fragments drawn but not visible
Transparency sorting: complex with alpha blending

(These are key modern graphics concerns.)

Part III — Materials and Lighting (Modern Approach)

How light creates color

At each point on a surface, light interacts with the material:

Three intuitive components (historical model):

Ambient
Diffuse
Specular

Ambient lighting

Each object is shown with an intrinsic intensity:

No external source
Unreal universe of non-reflective light objects

Diffuse lighting

Part of the incident light enters the object and exits with the same intensity in all directions

Specular lighting

Reflection from the surface of the object of incident light that has not penetrated the object, depending on the direction of observation

From Phong to PBR (Modern Materials)

Modern engines use Physically Based Rendering (PBR) instead of classic Phong.

A PBR material is typically defined by:

Albedo (base color)
Roughness (matte vs shiny)
Metallic (metal vs non-metal)
Normal map (fake surface detail)

This ensures:

Realistic lighting
Consistency across different light conditions

Why PBR is better

With Phong:

Energy is not conserved (objects can appear “too bright”)

With PBR:

Energy is conserved
Materials look correct under any lighting

Surface Smoothing

To avoid “faceted” appearance:

Gouraud shading

Interpolate colors across triangles

Phong shading

Interpolate normals, compute lighting per pixel

What is a Material?

In practice, a material includes:

Base color
Roughness
Metallic
Normal map
Transparency (alpha)
Emissive color (self-illumination)

Part IV — Textures (Essential for Realism)

What is a Texture?

A texture is a 2D image mapped onto a 3D surface.

Each vertex gets UV coordinates (u, v) in [0,1].

For each pixel, texture color is interpolated.

Beyond Color: Modern Texture Maps

Today, textures are used for much more than color:

Normal maps → fake fine detail
Roughness maps → control shininess
Metallic maps → define metal areas
Ambient occlusion maps → fake soft shadows

Part V — Modern Rendering Techniques

Shadows

Most real-time engines use shadow maps:

Render the scene from the light’s point of view
Store depth information
Use it to determine shadowed areas

Global Illumination

Two main approaches:

Baked GI (offline)

Precomputed lighting
Very stable, cheap at runtime

Real-time GI

Dynamic lighting updates
Used in modern engines (Unreal Lumen, Unity HDRP)

Screen-Space Effects

Computed directly from the final image:

SSAO (soft ambient shadows)
Screen-space reflections
Motion blur
Bloom
Tone mapping

Stereoscopic Rendering (VR)

For VR, we render:

One image per eye
Two slightly different cameras
Two frustums
Two rasterization passes

Smart engines share work between both eyes when possible.

Conclusion

Modern rendering combines:

Fast rasterization for real-time
Physically based materials (PBR)
Smart approximations (shadow maps, GI, screen-space effects)
Increasing use of ray tracing for realism

Lab — 3D rendering: stylized diorama

Tue, 10 Feb 2026 00:00:00 +0000

🎯 TP Objective

Create a diorama-style scene (a small miniature world) in Unity using URP, working on:

visual composition (staging, readability, focal point),
rendering (lighting, materials, post-processing),
and an initial tech-art dimension (Shader Graph and/or VFX).

The final result must be visually coherent: even if you use external assets, you must harmonize their materials and the lighting atmosphere.

📌 Mandatory requirements (common core)

Your scene must include the following elements:

1) Composition / environment

A readable diorama-style scene (miniature scale, clear framing, focal point).
You may use free assets (Asset Store, Kenney, Poly Pizza, etc.),
but you must modify their materials to ensure visual coherence.

2) Lighting

At least 3 distinct light sources, for example:
- Directional Light (sun),
- Spot Light (to highlight an object),
- Point Light (local ambiance).
Expectation: clear intent (warm/cold atmosphere, contrasts, visual hierarchy).

3) Skybox / environment

A Skybox (HDRI or procedural).
Environment settings (Ambient Light, Reflections).

4) Visual effects

At least 1 Particle System (Shuriken) integrated into the scene
(smoke, dust, snow, fireflies, sparks, bubbles…).
At least 1 URP post-processing Volume, including at minimum:
- Bloom or
- Color Adjustments.

5) Materials and shaders

Use at least one standard URP Material (Lit).
Create at least one custom Shader with Shader Graph, and apply it to an object in the scene.

🧩 Optional features

These options allow you to go further depending on your level and creativity.

A — Advanced Lighting (recommended)

Baked or Mixed lighting.
Use of Light Probes and/or Reflection Probes to improve rendering.

B — VFX Graph (or advanced particles)

An effect using VFX Graph (if compatible with your Unity version),
or an advanced Particle System (collision, noise, trails, forces).

C — Cinematic (Timeline)

A short cinematic of 5 to 10 seconds including:
- camera movement,
- reveal of the focal point,
- variation in lighting or effects.

D — In-editor modeling (ProBuilder)

Create at least two decorative elements with ProBuilder
(base, stylized rock, arch, wall, bridge, platform…).

E — Simple interaction

Implement one basic interaction, for example:

day/night toggle,
color palette switch,
enable/disable particles,
opening a door,
turning on a lantern.

F — Sound atmosphere

Add:

an ambient soundscape (wind, forest, sea, factory, city…),
at least one 3D spatialized sound effect.

🎨 Theme ideas (optional)

To avoid too many similar scenes, you can draw inspiration from these ideas:

Miniature workshop (watchmaker, alchemist, tinkerer).
Ruins in a bubble (temple, statues, vegetation).
Miniature subway station (neon lights, smoke, reflections).
Snowy cabin (snow + warm interior lighting).
Stylized underwater scene (bubbles, simulated caustics, particles).

You may also propose your own theme, as long as it follows the diorama spirit.

📦 Expected deliverables

1) Unity Project

Main scene named: Diorama.unity
Functional project in URP.

2) README (1 page max)

To include in the project (Markdown or PDF):

Title and theme of the diorama,
Checklist of the 5 mandatory requirements,
List of the 2 chosen options (with short justification),
Sources of used assets (links + licenses).

3) Presentation image or video

one fixed “beauty shot”,
one short camera movement (pan, rotation, or tracking shot).

🧮 Indicative grading scheme

Criterion	Weight
Composition & artistic direction	30 %
Material coherence	25 %
Lighting, Skybox & Post-process	20 %
Shader Graph (quality + integration)	15 %
Chosen options (relevance)	10 %

Bonus: overall polish (small animations, details, simple optimization).

📚 Useful resources

Lab — Unity 3D basics

Mon, 02 Feb 2026 00:00:00 +0000

Getting started · 3D creation

Duration: 2–3 hours
Environment: Unity 6.3 LTS · URP
Level: Unity beginner

A first introduction to Unity for students familiar with computing who have never used the engine. You will build a cube scene, add physics and interactions, navigate in first person, launch objects, import a car and build an executable.

Unity 6.3 LTS (6000.3) must be installed. Project creation, package installation and resource imports take place during the session. Completion time will depend on your C# experience.

Lab files Download resources Ground texture and car model · ZIP Read first Lab report guidelines Report expectations and outline

Documentation Unity 6.3 manual Unity Learn

Brest campus only School PC configuration

Definitions throughout the lab

Terms with a dotted underline have a definition: hover over or click them. You can also reach them with Tab and use Enter or Space; Escape closes the tooltip.

Lab outline

Prepare the project

In , select 6.3 LTS and create a Universal 3D ( ) project. Use the same 6000.3.xf1 patch throughout the session. The and controller used here target URP.
are your project resources: scenes, , materials, , and . They are stored in the Assets folder shown in the window. Organize them by creating Scenes, Materials, Textures, Prefabs and Scripts through right-click in Assets > Create > Folder; reuse Scenes if it already exists. In Project, find the open scene (usually SampleScene), rename it UnityBasics using Rename (or F2), and move it into Assets/Scenes if needed. Save the scene with Ctrl+S.
Open Window > Package Management > . In , search for (com.unity.inputsystem) and click Install if it is not installed. The version used when testing this lab is 1.20.0. Under Edit > Project Settings > Player > Other Settings > Configuration > , select Input System Package (New) only if it is not already selected, then accept the requested restart. Under In Project in the Package Manager, check that (com.unity.ugui) is installed: it provides the , and click/hover interfaces used later. If missing, find it in Unity Registry and install it.
Add the official first/third person controller to your account and import it through My Assets in the Package Manager. Accept installation of its dependencies when prompted, then return to UnityBasics.
Download and extract the lab resources (resources-unity63.zip). From your file explorer, drag grid_grey.png into Assets/Textures in Project. The archive also contains Ford_Mondeo.zip: extract it to obtain the Ford_Mondeo folder, containing car.obj, car.mtl and .tga textures. Keep this folder for Load a , where you will import it into Unity as a whole.

The Unity 3D Editor

A scene generally contains , and possibly a for URP rendering. Window layouts can vary.

Unity 6.3 LTS screenshot. Labels 6 and 7 point to the and tabs; click them to display their contents.

Number	Window	Purpose
1		Navigate and manipulate scene objects.
2		View and their parent/child relationships.
3		View and edit all , including scripts.
4	Project	View assets: scenes, textures, materials, prefabs, scripts…
5	/ Pause / Step	Run, pause and advance execution one frame at a time.
6	Game	View the camera’s rendered output.
7	Console	Read messages, warnings and errors.

Fundamental concepts

Before manipulating objects, take a moment to understand the relationships between project resources, scene objects and their components. The following boxes provide reference points for the session.

Select an object and press F in Scene to frame it. Use Move, Rotate and Scale (W, E, R, outside text fields). Hold the right mouse button to look around Scene; movement keys then let you navigate. selects the manipulation coordinate system. See navigation and positioning.

Create a simple scene

We will create a floor and a stack of twelve blue cubes.

Add GameObject > 3D Object > Plane, named Ground, with position (0, 0, 0), rotation (0, 0, 0) and scale (10, 1, 10). A plane is 10 × 10 units at scale 1, giving 100 × 100 units here. One unit represents approximately one meter; the plane is finite.
Add a cube Cube, with scale (1, 1, 1) and position (0, 3, 0).

Key concept

Material, shader and texture: three different roles

The Mesh defines geometry. The Renderer displays it using one or more materials. A material is an asset: it selects a shader and supplies parameters such as color and textures.

The shader calculates the surface’s appearance; a texture is an image used in that calculation. Several materials can use the same texture, and several objects can share a material.

In this lab: CubeBlue uses URP Lit with a blue color; GroundGrid also uses a Base Map texture. The material must use a shader compatible with the project’s URP pipeline.
Create CubeBlue in Assets/Materials (Assets > Create > Material). Select the and a blue color. Drag the material onto the cube.
Create GroundGrid, also using URP Lit, and drag grid_grey.png into its Base Map. Assign this material to the plane. Click the grid_grey.png texture in the Project window: its import settings appear in the Inspector. Check that = Repeat; this is normally already selected. If you change it, click Apply. Try material = (100, 100) and adjust it. A material describes appearance; a texture is an image used by a material.

Key concept

Tags: identifying objects in scripts

A tag is a label assigned to a GameObject, separate from its name. Scripts can find objects with a specific tag. Each GameObject has one tag; several objects can share it.

In this lab: MainCamera lets Camera.main find the active camera. Naming an object “Main Camera” is insufficient: also check its Tag field in the Inspector.
Place the camera, for example at (8, 6, -12) with rotation (20, -30, 0). Adjust the framing in Game to see the floor and cube. Keep its MainCamera .

Add a to the cube using Add Component. Keep enabled and disabled. The cube already has a ; the plane also has a . Run the scene: the cube falls and stays on the floor. The displays the object, the Collider defines its collision shape and the Rigidbody enables physics simulation.
Key concept

Prefabs: reusing an object while keeping the link
A prefab is an asset storing a GameObject, its components and children. Each copy placed in the scene is an instance linked to the template. Here, twelve cubes will share CubePrefab.

Two ways to edit the template, outside Play:
- From Project: select CubePrefab to adjust its Inspector settings, or double-click it to edit its structure in Prefab Mode.
- From an instance: change a cube’s Mass, for example. This is a local override. In Overrides, at the top of the Inspector, use Apply to transfer it to the template, or Apply All to transfer all changes.
Instances inherit template changes unless they have their own override on that property. Revert removes an override to restore the template value. Moving a cube remains specific to that instance.

Apply or revert overrides.
Stop Play. Drag the cube from Hierarchy into Assets/Prefabs and name the asset CubePrefab. Create twelve instances in two columns of six cubes that converge toward the top, as shown below. Keep scale (1, 1, 1), rotation (0, 0, 0) and Z 0 for every cube.

Tip — when working with many objects: duplication with Ctrl+D (Cmd+D on macOS), multiple selection and Inspector numeric expressions such as L(a,b) for distributing objects evenly can save time. For this lab’s twelve cubes, simply position the instances to reproduce the shape shown below.

Test the stack. Double-click CubePrefab and change , then . slows rotation. Compare the instances, then restore Mass to 1 and Linear Damping to 0.

Observe: without damping, a larger mass does not make an object fall faster. It changes the response to the same impulse, which you will test later. Contact friction is configured through a on the Collider and differs from damping. Values changed only on an instance may be : inspect them if a prefab change does not propagate.

Animate a scene object

A C# script derived from becomes a component. We will create a script that simply rotates the cubes.

Key concept

Start, Update and the MonoBehaviour lifecycle

Unity calls these methods automatically: you do not need a loop or to call them yourself. Keep their names and signatures correct, such as void Start(); remove unused empty methods.

Start(): prepare once, before the active component’s first Update. Here, you will enable input or store the initial color. Disabling and re-enabling the component does not run Start again.
Update(): act every frame, while the component and its GameObject are active. You will rotate the cube using Time.deltaTime and detect shots here.

For mouse interactions, you will obtain the Renderer or Rigidbody directly using GetComponent in the method that needs it.

For reference: other common methods

Method	When is it called?	Typical use
`Awake()`	Once, on initialization on an active GameObject, before Start; even if the component is disabled.	Prepare internal references.
`OnEnable()`	Each time the component becomes enabled on an active GameObject.	Subscribe to events.
`FixedUpdate()`	At the fixed physics simulation rate.	Apply continuous forces to a Rigidbody.
`LateUpdate()`	Every frame, after Update calls.	Update a camera after objects move.
`OnDisable()`	When the component or its GameObject is disabled.	Remove event subscriptions.
`OnDestroy()`	When a previously active object is destroyed.	Release resources owned by the component.

Simplified sequence for an active component: Awake → OnEnable → Start, then Update → LateUpdate every frame. FixedUpdate runs at its own rate: a frame can contain zero, one or several physics steps. This sequence does not specify script order across different GameObjects.

Lifecycle and execution order · MonoBehaviour methods.

Write RotateCube

In Assets/Scripts, create Assets > Create > Scripting > MonoBehaviour Script, named RotateCube. Open it in your C# editor; the class name must match the file.

Required check

Before coding: check autocomplete

Wait for the C# editor to load the project. Inside Update(), try these temporary entries one at a time:

Type	Expected suggestions
`transform.`	`Rotate`, `position`…
`Vector3.`	`up`, `forward`…
`Time.`	`deltaTime`…

The list must suggest Unity API members, not just words already present in the file. If it does not open automatically, try Ctrl+Space. Remove the test entries before saving.

Do not continue until these suggestions work. In Unity, check Edit > Preferences > External Tools > External Script Editor, then reopen the script from Project. With VS Code, check that the Microsoft Unity extension and its C# dependencies are enabled. Consult the configuration guide or ask your instructor for help.

Declare speed as a field of the RotateCube class. Place this declaration inside the class braces, but outside methods such as Start() and Update(). This field stores the component’s rotation speed; it is not a method-local variable. The annotation exposes it in the Inspector.

[SerializeField] private float speed = 90f; // degrees per second

In , called once per frame, use:

transform.Rotate(Vector3.up, speed * Time.deltaTime, Space.Self);

is the elapsed time since the previous frame, making the speed independent of the frame rate. Rotating by 3° per frame would produce different speeds on different machines.

Test on one cube. Select an instance in Hierarchy. Drag RotateCube.cs from Project onto this cube or into its Inspector; alternatively, click Add Component, search for RotateCube and select it. Check that the component appears in the Inspector. Enter Play: only this cube rotates, because transform refers to the GameObject the script is attached to.
Extend the behavior to the other cubes. Stop Play. Adding the component to this instance is an override. In Overrides, at the top of its Inspector, select the added RotateCube component and use Apply to apply it to the prefab. The CubePrefab template now contains this component and other instances inherit it. Enter Play to see all cubes rotate.
Alternatively, edit the template directly. Open CubePrefab from Project and attach RotateCube using the same drag-and-drop or Add Component. To rotate only a few cubes, attach the script to the chosen instances without applying it to the prefab. Add it only once per cube, so two RotateCube components do not combine their rotations.
Test several speeds in the Inspector. Then, outside Play mode, temporarily replace the declaration with public float speed = 90f;, followed by private float speed = 90f;. Save and let Unity compile each time: does Speed still appear in the Inspector? Finish by restoring [SerializeField] private float speed = 90f;.

Check: the cubes rotate and speed is adjustable in the Inspector without editing code.

Input and interactions

Extend Assets/Scripts/RotateCube.cs so the cube starts stationary and each R press starts or stops its rotation.

Import Input System. Add using UnityEngine.InputSystem; at the top of the file, keeping using UnityEngine;.
Declare the action. Inside the class, alongside speed and outside methods, add a private activateRotation field of type , exposed with [SerializeField]. Initialize it with new InputAction(...) and these three arguments in order: the name "ActivateRotation", the type InputActionType.Button and the "<Keyboard>/r".
Store the rotation state. Add a private rotating field of type bool, initialized to false. It indicates whether the cube should rotate; it does not need to appear in the Inspector. Keep the existing speed field.
Write the toggle method. Add a private ToggleRotation method that returns void and takes an InputAction.CallbackContext context parameter. In its body, assign rotating the opposite of its current value using the ! operator: false becomes true, and vice versa. Input System supplies context; you do not need to use it here.
Subscribe in Start(). Subscribe ToggleRotation to the performed event of activateRotation using +=, writing the method name without parentheses. This subscription specifies which method to call when the action triggers.

Enable the action in Start(). After subscribing, call Enable() on activateRotation. This second statement allows the action to receive input: subscribing alone is not enough.
Make rotation conditional in Update(). Keep the previous exercise’s transform.Rotate(...) statement, but place it inside an if that checks rotating. The cube then rotates only when this boolean is true.
Check in Unity. Save, wait for compilation and inspect the RotateCube component: its action should be Button, bound to R. These settings are the initial values provided by the code. As with Speed, you can edit them in the Inspector; editing a prefab instance creates an override. For this test, keep R and the default press behavior.

Check: enter Play and click inside Game. Cubes start stationary; pressing R makes them rotate, releasing R changes nothing, and pressing again stops them.

Action documentation.

Simple mouse interaction

We will make each cube red while the mouse hovers over it, restore its original color when the mouse moves away, and push it with a left click.

To detect these interactions, we will add an EventSystem to the scene and a Physics Raycaster to the camera. The former dispatches mouse events; the latter identifies the object under the pointer using its colliders. Our MouseInteraction script will then receive these events through three methods: OnPointerEnter when hovering begins, OnPointerExit when it ends, and OnPointerClick for clicks.

Add GameObject > UI > Event System if missing. Keep one active EventSystem. It must use : replace Standalone Input Module if present. Use Assign Default Actions if UI action references are empty.
Add Physics Raycaster through Add Component on the active camera tagged MainCamera. Cubes must have colliders and belong to a included in the raycaster mask.
Create a new MouseInteraction.cs script in Assets/Scripts and complete it in the following steps. Import UnityEngine.EventSystems and implement the three interfaces IPointerClickHandler, IPointerEnterHandler and IPointerExitHandler. Define OnPointerClick, OnPointerEnter and OnPointerExit, each public, returning void and taking PointerEventData eventData.

Key concept

Reminder: an interface is a contract

A C# interface describes methods a class must provide, including their names, parameters and return types. The implementing class writes those methods’ behavior; it can implement multiple interfaces.

Syntax: after :, list the base class, then the interfaces separated by commas:

public class MouseInteraction : MonoBehaviour,
 IPointerClickHandler, IPointerEnterHandler, IPointerExitHandler

Inside the class braces, define the methods required by the interfaces.

Here: IPointerClickHandler requires an OnPointerClick method. The EventSystem recognizes this interface and calls that method on a click. You decide what the cube does in its body. The other two interfaces follow the same principle for the beginning and end of hovering.

Learn more about C# interfaces — Microsoft Learn.

Prepare the component. Initially leave the three interaction methods empty, save and check that the script compiles. Add MouseInteraction to CubePrefab so every cube has this behavior. All changes below belong in MouseInteraction.cs. Nothing is needed in Update(): the interaction methods will be called on mouse events.
Remember the starting color. Declare a private initialColor field of type Color inside the class, outside methods. In Start(), obtain the cube’s Renderer using gameObject. followed by <Renderer>(). Then access its material.color property and store that color in initialColor. Each cube therefore remembers its own color at startup.
Turn the cube red on hover. In OnPointerEnter, obtain the Renderer in the same way and assign Color.red to its material.color property. Test: save, enter Play and hover over a cube in Game: only that cube should turn red.
Restore the color on exit. In OnPointerExit, assign initialColor to the same material.color property instead. Test: move the mouse away from the cube: it should return to its starting color. Use material, which lets you change this cube’s appearance individually.
Push the cube on left click. In OnPointerClick, add an if comparing eventData.button to PointerEventData.InputButton.Left. Inside it, obtain the Rigidbody with gameObject.GetComponent<Rigidbody>(), then call its AddForce method with two arguments: the direction .transform.forward multiplied by 5f, and for a single push. Test: left click pushes the cube in the camera’s viewing direction; right click does not push it.

Check: only the hovered cube turns red; left click pushes it, right click does not. MonoBehaviour lifecycle.

Integrate a first person controller into your scene using the official First Person + Third Person | Character Controllers package. It provides the scripts needed to move the character with the keyboard and look around with the mouse.

After importing through Package Manager > My Assets, open Assets/Starter Assets/Sample/FirstPersonController/Playground.unity in Project, the first person demonstration scene, and test it. Inspect movement, jump, sprint and look bindings in its Input Actions asset: keys depend on its configuration and your keyboard.
Identify the character with , the rendering camera with Camera / / , and the Cinemachine Camera controlling tracking. A tracking target such as PlayerCameraRoot is a Transform; it is not necessarily the rendering camera.
In Hierarchy, select MainCamera, PlayerFollowCamera, PlayerCapsule, UI_EventSystem and UI_TouchScreenInput together, as outlined in the screenshot below, and copy them. Open UnityBasics, the lab’s scene, then paste them. Copy these objects together to preserve the first person references.

Remove duplicates after pasting. Disable the GameObject of UnityBasics’ original fixed camera and keep the copied MainCamera. Delete the EventSystem created in the previous section and keep the copied UI_EventSystem. There must be one active EventSystem, one active rendering camera tagged MainCamera and one active AudioListener. Also keep PlayerFollowCamera, which controls the rendering camera through Cinemachine. Place the character near the stack, for example X 0, Z -8, with its bottom just above the floor.
Test navigation and notice what changed. Check that the controller’s ground mask includes the Ground layer. Enter Play and click inside Game: test movement, look, jump and sprint. The character works, but red hover and cube clicks no longer work as before: the cursor is locked and the new camera does not yet have a raycaster. If the controller produces footstep or jump sounds, identify them too.
Restore interactions at the screen center. Stop Play. Add Physics Raycaster to the copied MainCamera. Select UI_EventSystem and, in its Input System UI Input Module component, expand Advanced and set Cursor Lock Behavior = Screen Center. Enter Play again with the cursor locked and mouse look enabled: the cube aimed at in the screen center turns red, and left click pushes it. Physics Raycaster now detects the object ahead of you at the image center.
Restore a free mouse pointer. Stop Play. On PlayerCapsule, in the controller’s input component (Starter Assets Inputs), uncheck Cursor Locked and Cursor Input For Look. Enter Play again: the mouse is visible, moving it no longer turns your head, and you can hover over and click cubes with the pointer, as in the previous section. Screen Center only forces the screen center when the cursor is locked.

Cursor Lock Behavior configuration.

Dynamic object creation

Instantiate copies a GameObject or a component and its object. Prefabs allow object creation without a hidden template in the scene. We will launch yellow cubes forward on right click.

Create a Projectile cube, sized (0.25, 0.25, 0.25), with a yellow URP Lit material, Box Collider and Rigidbody, mass 1, gravity enabled and Is Kinematic disabled. Turn it into ProjectilePrefab and remove its scene instance. It has neither RotateCube nor MouseInteraction, to avoid copying the targets’ actions and behaviors.
In Assets/Scripts, create a new CreateOnClick.cs script and attach it to the camera that actually has Camera, rather than the Cinemachine target. Complete this script in the following steps. Declare [SerializeField] private Rigidbody projectilePrefab; and drag ProjectilePrefab into that field: this reference provides direct physics access.
Import UnityEngine.InputSystem and declare a Button InputAction named fire, bound to <Mouse>/rightButton. Enable it in Start() as before. Here, instead of subscribing to performed, query the action in Update() with fire.WasPressedThisFrame(): this method returns true only for the frame in which the button has just been pressed.
Calculate the starting position. In Update(), put the following operations inside an if checking the press detected in step 3. Declare a local Vector3 variable named position: start from the camera’s position (transform.position) and add its forward direction (transform.forward) multiplied by 2f. The projectile will appear two units in front of it.
Create the projectile. Call with three arguments: projectilePrefab, the calculated position and the camera’s rotation (transform.rotation). Store the result in a local Rigidbody variable named projectile so you can act on this new instance.
Launch the projectile. As with pushing the cubes, call AddForce on the newly created Rigidbody. Use the camera’s forward direction multiplied by 12f, with ForceMode.Impulse.
Remove the projectile after a delay. Call Destroy with the instance’s GameObject (projectile.gameObject) and a delay of 8f seconds. Keep this call inside the same if: each projectile will have its own lifetime.

Yellow comes from the prefab material; you can also change the instance renderer’s color. Spawning in front of the player avoids creating it inside the character. Also check for free space in front of the camera: two units do not guarantee avoiding a nearby wall.

Observe: compare trajectories and pushes by changing mass and impulse. An impulse is applied once; a continuous force would be applied at the simulation rate in . Destroy removes the object, here after eight seconds. Instantiate, AddForce.

Load a mesh

Import the Ford Mondeo, make its windows transparent and define its collisions.

Unzip Ford_Mondeo.zip from the lab resources. The car.obj file contains the car’s mesh and the .tga files are its textures.
In Project, create Assets/Models (right-click in Assets > Create > Folder). From your file explorer, drag the entire extracted Ford_Mondeo folder into Assets/Models in Project. Wait for the import to finish, then drag car.obj from Project into Hierarchy to create a scene instance. Select this instance and set Transform > Scale to (0.01, 0.01, 0.01) as a starting point. Check its size against the one-meter cubes, then adjust its size, rotation and position if necessary. Base Map textures should already be assigned.
Extract the materials to edit them. Select the car.obj asset in Project, then open the Materials tab of its Import Settings in the Inspector. Materials are included in the model: click Extract Materials… and choose a folder, such as Assets/Materials/Car. They become material assets you can edit.
Make the windows transparent. Identify the material used by the windows and select the extracted material in Project. In its Inspector, using the Universal Render Pipeline/Lit shader, set Surface Type = Transparent and Blending Mode = Alpha. Open the Base Map color and reduce its value, for example to 0.3. Observe the window transparency in the scene.
Launch cubes at the car and try walking through it. A visible mesh does not automatically provide a collider. Add Box Colliders for a simple approximation or on suitable parts of the stationary car.

A non- Mesh Collider suits scenery without a dynamic Rigidbody. For a moving physical car, prefer compound primitive colliders or convex Mesh Colliders with a Rigidbody on the root. More detailed collisions can cost more computation. Mesh Colliders, URP Lit.

Check: plausible scale, visible textures, transparent windows and collisions with the character and projectiles.

Build an executable

Stop Play and save UnityBasics.
Open File > . Choose Linux, Windows or macOS for your machine and create/activate its profile if needed. The corresponding build module must be installed through Unity Hub.
In , add the scene using Add Open Scenes. Check that it is enabled and first; remove demonstration scenes. A profile can override the shared list: check the list actually used.
Click , choose a dedicated folder outside Assets, such as Builds/Linux, then run the application. Build And Run runs it immediately.
Test navigation, R, clicks, physics and materials outside the editor. Distribute the whole build folder. Explore > Resolution and Presentation for resolution and fullscreen behavior.

The Web platform also supports a browser build with its module. It requires an HTTP server: directly opening the HTML file is insufficient. Start with a local build in this session. Build Profiles.

Going further

Choose one direction to extend the scene you have just built. The variations suggested throughout the lab — holding R, pushing while pressed and switching mouse modes — are a good first step.

Customize shooting. Expose projectile impulse, lifetime and spawn distance in the Inspector with [SerializeField]. Compare settings without changing the code.
Build a small course. Reuse your prefabs to place obstacles and targets. Use layers to choose which objects can collide or be targeted.
Give the scene an atmosphere. Change the and lighting in Window > Rendering > Lighting. To go further, study Static objects and : do not mark moving cubes as static. Baked lighting.
Add a visual effect. Create smoke with a , then adjust emission and lifetime. Documentation. Then explore Visual Effect Graph or custom materials with for URP.
Animate part of the scenery. Make a door open using Animation and . For delayed events, explore . Animation, coroutines.
Display information on screen. Add a UI showing the number of projectiles created. Choose Unity UI or UI Toolkit using the UI systems comparison.

For a later project, you could also import a Humanoid character and animations, study Inverse Kinematics, compare custom controllers based on CharacterController or Rigidbody, or make a car drivable with WheelCollider. These topics need more time: Avatar, IK, vehicles.

To strengthen your scripts, explore , reference checks and managing subscriptions when a component is disabled or destroyed.

Resources

For understanding and programming:

Need	Resource
Look up an editor concept or setting	Unity 6.3 Manual
Understand a C# method’s arguments	Unity 6.3 Scripting API: search for `Instantiate`, `AddForce` or `GetComponent`, for example.
Explore actions and bindings	Input System documentation
Continue with guided exercises	Unity Learn
Find the files used here	Lab resources and first/third person controller

To enrich the scene: ambientCG for textures and materials, Poly Haven for HDRIs, textures and models, and Mixamo for characters and animations. Before importing an asset, check its usage conditions and, for a Unity package, Unity 6.3 / URP compatibility.

Continue after this lab: A first virtual reality application builds on these foundations to introduce headset tracking, controllers, teleportation and object manipulation with OpenXR and XR Interaction Toolkit.

Troubleshooting

Start with Console: fix the first red error before testing again. Double-click the message to open the relevant line. When asking for help, provide the lab step, the expected result and the exact message.

Symptom	What to check
No Unity autocomplete	Repeat the check at the start of Write RotateCube. Check the external editor and its extensions, then reopen the script from Unity.
Script does not compile or cannot be added	Check file and class names, `using` directives, braces and methods required by interfaces.
R does nothing	Click inside Game. Check RotateCube is attached and enabled, its binding is R, and `Start()` contains both the subscription and `Enable()`. Also check Active Input Handling = Input System Package (New).
No red hover or click response	Check the cube’s collider and MouseInteraction, Physics Raycaster on the active rendering camera, and one EventSystem with Input System UI Input Module. When navigating, set Advanced > Cursor Lock Behavior = Screen Center to aim with the locked cursor.
Cube turns red but does not move on click	Use left click. Check the cube’s Rigidbody, Is Kinematic disabled and the active camera’s MainCamera tag.
No projectile or missing reference	Check CreateOnClick on the rendering camera, the right-click action and the Projectile Prefab field. The assigned prefab needs a Rigidbody.
Player passes through the ground or car	Check their colliders; for the ground, also check its layer and the controller’s ground mask.
Pink material or opaque windows	Check the Universal Render Pipeline/Lit shader. For windows, edit the extracted material: Surface Type = Transparent, then reduce Base Map alpha.
A change does not propagate to cubes	Check whether you edited the prefab or an instance and whether the instance has an override.
Build shows the wrong scene	Check the active profile’s Scene List: `UnityBasics` must be checked and first.