UNIT 2

1. Explain the significance of texture and resources format in DirectX.

In DirectX, textures and resource formats play a crucial role in rendering 2D and 3D graphics efficiently and accurately.
These elements directly influence performance, memory usage, and the visual quality of the graphics being rendered.
Here's a detailed look at their significance:

1. Texture in DirectX

A texture in DirectX refers to an image or bitmap that is applied to the surface of 3D objects to give them detailed
appearances. Textures can represent anything from surface color to complex material properties (such as glossiness,
bump maps, etc.).

● Types of Textures:

o 1D Textures: A single line of pixels used for data like gradients.

o 2D Textures: Regular images, often used for surfaces of objects (walls, floors).
o 3D Textures: Volumetric textures, often used in scientific simulations or medical imaging.
o Cube Maps: A set of six 2D textures forming the faces of a cube, often used for environment mapping
(e.g., skyboxes).
● Significance:

o Realism: Textures help in adding visual details to models without increasing the geometric complexity.
o Performance: DirectX optimizes how textures are stored and retrieved, minimizing memory bandwidth
and improving rendering speed.
o Multitexturing: Multiple textures can be combined to create complex material effects (like reflections or
shadows).

2. Resource Formats in DirectX

A resource format defines how data (like color, depth, stencil, or texture) is stored in memory. These formats
affect the precision and performance of rendering operations. DirectX provides various resource formats to
handle different types of data in a way that balances quality and performance.

● Common Resource Formats:

o Color Formats: Define how colors are stored. Examples include DXGI_FORMAT_R8G8B8A8_UNORM
(8-bit per channel with alpha) or DXGI_FORMAT_R32G32B32_FLOAT (32-bit floating point per
channel).
o Depth and Stencil Formats: Used for depth testing and stencil operations in rendering, e.g.,
DXGI_FORMAT_D24_UNORM_S8_UINT.
o Compression Formats: Some formats, like BC1 (Block Compression), are designed to reduce the
size of textures while preserving visual quality.
2. Explain Following function in pygame with example.

1. pygame.init(): 2. pygame.display.set_mode() 3. pygame.display.set_caption(): 4. pygame.QUIT:

Ans: Pygame is a Python library used to create games and multimedia applications. It provides easy-to-use functions for
handling graphical and audio elements in Python.

1. pygame.init()

This function initializes all the Pygame modules that are needed to start using Pygame. It sets up everything needed for
Pygame to function properly, such as access to hardware like sound and graphics.

import pygame
pygame.init()

Explanation: Calling pygame.init() is necessary before using any other Pygame functions. It initializes the modules
responsible for handling different aspects of the game, like the display, audio, input devices, etc.

import pygame

# Initialize pygame

pygame.init()

# Check if all modules initialized correctly

if pygame.get_init():

print("Pygame initialized successfully!")

2. pygame.display.set_mode()

This function sets the dimensions and properties of the game window. It creates a window or screen where the game will
be displayed.

screen = pygame.display.set_mode((width, height))

(width, height): A tuple specifying the size of the window.

The function returns a Surface object, which is where all the drawing happens.

3. pygame.display.set_caption()
This function sets the title of the game window.
● Usage:
python
Copy code
pygame.display.set_caption("Game Title")
● Explanation: It changes the window title to the specified text. This is useful to give the game a name
visible in the window bar.
● Example:
import pygame

pygame.init()

# Create a game window

screen = pygame.display.set_mode((800, 600))

# Set the window title

 pygame.display.set_caption("My First Pygame Window")

# Game loop to keep the window open

running = True
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
4. pygame.QUIT
This constant represents an event type that signals the user’s intent to close the game window. It’s part of
Pygame’s event handling system and is usually checked in the game loop to know when the user wants to close
the window.
● Usage:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
● Explanation: When the user clicks the close button (X) on the game window, a QUIT event is generated.
It’s important to check for this event in the game loop so you can properly exit the game.

3. Brief about Direct3D. Explain its components or feature level.

Direct3D is a part of Microsoft's DirectX suite, and it is a powerful API used primarily for rendering 3D graphics in
applications like games, simulations, and multimedia software. It provides developers with a set of tools and functions to
interact directly with the graphics hardware (GPU), allowing high-performance rendering.

Key Features of Direct3D

1. Hardware Abstraction: Direct3D abstracts the complexity of interacting directly with different GPU hardware. It
allows developers to focus on rendering techniques without worrying about hardware-specific details.

2. Rendering Pipeline: Direct3D uses a programmable pipeline, which allows developers to write shaders that run
directly on the GPU. This is essential for applying custom lighting, textures, and other graphical effects.

3. High Performance: Direct3D is optimized for high-performance applications, especially games. It makes efficient
use of hardware resources and supports multi-threaded rendering, allowing better utilization of modern
multi-core processors.

4. 3D Rendering: Direct3D provides support for 3D models, meshes, textures, lighting, and shading, enabling the
creation of immersive 3D environments.

5. Cross-Platform Compatibility: While Direct3D is primarily used for Windows platforms, it is often incorporated
into engines that support other platforms by providing similar abstractions (with engines like Unreal Engine or
Unity).

Direct3D Feature Levels

Feature Levels in Direct3D define a set of hardware capabilities and features supported by a device (GPU). These levels
ensure that an application can target different hardware while maintaining compatibility.

1. Direct3D 9 (Feature Level 9_1 to 9_3):

o Older hardware.

o Supports basic shader model 2.0.

 o Limited texture and render target support.

2. Direct3D 10 (Feature Level 10_0 to 10_1):

o Shader model 4.0 and 4.1 support.

o Introduced geometry shaders.

o Improved rendering techniques like anti-aliasing and HDR.

3. Direct3D 11 (Feature Level 11_0 to 11_1):

o Introduced shader model 5.0.

o Improved compute shaders: Allows GPU-based calculations for non-graphics tasks.

4. Direct3D 12 (Feature Level 12_0 and 12_1):

o Introduced low-level API access to the GPU.

o Explicit multi-GPU support: Allows developers to use multiple GPUs more effectively.

o Enhanced resource management and memory control.

4. Explain 2D and 3D Game Development with Pygame.

Pygame is a popular Python library for creating games and multimedia applications. It is most often used for 2D game
development, but some basic 3D concepts can be simulated in Pygame as well. Here's an overview of 2D and 3D game
development using Pygame.
1. 2D Game Development with Pygame
Pygame is designed primarily for 2D game development. It provides a simple interface for handling 2D graphics, sound,
and user inputs. In 2D game development, you work with 2D images (sprites) and manage movement, collisions, and
animations.
Key Components for 2D Game Development
1. Surfaces: In Pygame, everything is drawn on a Surface object, which can represent the game screen or other
off-screen images. Surfaces are where 2D drawing, image loading, and rendering occur.
screen = pygame.display.set_mode((800, 600)) # Create a surface representing the
window
2. Sprites: Sprites are objects in the game, such as characters or objects, that can move, interact, and be drawn on
the screen. Pygame provides a Sprite class for managing and rendering game objects easily.
class Player(pygame.sprite.Sprite):
def __init__(self):
super().__init__()
self.image = pygame.image.load("player.png")
self.rect = self.image.get_rect()
3. Game Loop: The core of any game is the game loop, where the game continuously checks for input, updates the
game state, and renders the screen.
running = True
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
# Game logic, updating player position, checking collisions, etc.
pygame.display.flip() # Update the display
 4. Collision Detection: Pygame offers built-in functions to handle collision detection between sprites or between a
sprite and a specific area of the screen.
if pygame.sprite.collide_rect(sprite1, sprite2):
# Handle collision

2. 3D Game Development with Pygame

Although Pygame is primarily focused on 2D games, basic 3D concepts can be simulated using tricks like scaling,
perspective transformations, and rotation. However, Pygame does not natively support 3D rendering like other engines
(e.g., Unity or Unreal). If true 3D rendering is required, Pygame would typically be used in conjunction with other
libraries, such as PyOpenGL.

Simulating 3D Concepts in Pygame

1. Isometric and 3D-like Projections: 2D games with isometric perspectives (diagonal view) can simulate a 3D
effect. Isometric graphics use a specific scaling and perspective technique to make it appear as if the player is
looking down on a 3D world.

2. Scaling and Depth: By scaling objects (making them smaller or larger) based on their position, you can give the
illusion of depth. For example, objects further away will appear smaller, and objects closer to the camera appear
larger.

3. Simple 3D Rotations: Pygame has no native support for true 3D rotations, but you can simulate it in 2D by
rotating 2D images using pygame.transform.rotate().

4. Using OpenGL for 3D: If actual 3D rendering is required, Pygame can be used as a windowing system, and
OpenGL can be used to handle 3D graphics. Libraries like PyOpenGL provide access to the OpenGL API for
rendering 3D models and environments.

5. Define lambert’s law and explain its use in lightning calculation

Lambert's Law, also known as Lambert’s Cosine Law, is a fundamental principle used in computer graphics to calculate
diffuse lighting on a surface. The law is named after Johann Heinrich Lambert, who formulated it in the 18th century. It
describes how light intensity perceived on a surface depends on the angle of incidence of the light relative to that
surface.

Lambert’s Cosine Law

The law states that:

The intensity of light (I) on a surface is directly proportional to the cosine of the angle (θ) between the light source
direction and the surface normal.

Mathematically:

Where:

● I is the observed intensity of the light on the surface.

● I​o is the intensity of the incoming light.

● θ is the angle between the direction of the light source and the normal vector of the surface.
1. Diffuse Lighting

Lambert’s Law is primarily used in calculating diffuse lighting, which is the light that is scattered equally in all directions
by a surface. Unlike specular reflections (which are shiny and mirror-like), diffuse reflections spread the light evenly,
making the object appear evenly lit regardless of the viewing angle.

Example in Computer Graphics:

Imagine a scene where a light source is shining on a surface. The amount of light that each point on the surface receives
depends on the angle between the surface normal at that point and the direction of the incoming light. Using Lambert's
Law, we can compute how bright each point on the surface should be.

For example, in a 3D rendering engine:

● If a surface is directly facing a light source (light direction is aligned with the surface normal), the point will be
fully illuminated.

● If the surface is at a steep angle relative to the light source, the point will appear dimmer.

● If the surface is facing away from the light source, it will receive no light and will appear dark.
6. Explain in detail the stages in rendering pipeline.

The Rendering Pipeline (or Graphics Pipeline) is the process that transforms 3D models into a 2D image on the screen.
This process occurs in several stages, where the computer (CPU and GPU) processes vertex, geometry, texture, lighting,
and pixel data to render a final image.

The pipeline can be broken down into two main categories: Fixed Function Pipeline and Programmable Pipeline.

1. Vertex Processing (Vertex Shader Stage):

Input: 3D vertices from the 3D models (positions, colors, normals, textures).

Task: The vertex shader processes individual vertices and applies transformations,
including translation, scaling, and rotation, to convert model-space coordinates into
world-space or view-space coordinates.

Operations: This stage involves:

● Transformation of vertex positions using a model-view matrix.

● Calculation of normals (for lighting).

● Application of vertex lighting (such as ambient, diffuse, and specular light).

Output: The transformed vertices are output in clip space, ready for the next stage.

2. Primitive Assembly and Tessellation

● Input: Transformed vertices from the vertex shader.

● Task: In this stage, the vertices are assembled into geometric primitives
such as triangles, lines, or points. These are the building blocks of 3D
objects.

Output: New, subdivided, or unchanged primitives, which move on to the next stage.

3. Geometry Shader

● Input: Primitives from the primitive assembly stage.

● Task: The geometry shader can modify, create, or discard whole primitives (like triangles, lines) on-the-fly.

Operations: This stage is often used for:

● Creating extra geometry (e.g., fur, grass, or particles).

● Removing unnecessary parts of the scene.

7. Write a short note on B-splines.

B-splines (Basis Splines) are a type of spline curve that is widely used in computer graphics, computer-aided design
(CAD), and animation. They are a generalization of Bézier curves and offer more flexibility, especially for complex shapes.
B-spline curve shape before changing the position of control point P1 –

B-spline curve shape after changing the position of control point P1 –

You can see in the above figure that only the segment-1st shape as we have only changed the control point P1, and the
shape of segment-2nd remains intact.

Types of B-Splines:

1. Uniform B-Splines:

o In a uniform B-spline, the knots are evenly spaced in the knot vector. This means that each segment of
the curve is affected equally by the control points.

2. Non-Uniform B-Splines (NURBS):

o NURBS (Non-Uniform Rational B-Splines) are an extension of B-splines where the knot vector can be
non-uniform, giving more control over the shape of the curve.

Applications of B-Splines:

1. Computer Graphics and Animation:

● B-splines are used to create smooth curves and surfaces, especially in 3D modeling and animation. They allow
animators to control shapes easily and make them appear smooth and natural.

2. Data Interpolation:

● B-splines are used in numerical analysis for interpolating data points smoothly. They are effective at creating
smooth curves that pass through or near a given set of points.
8. Explain depth buffering.

Depth buffering, commonly referred to as Z-buffering, is a computer graphics technique used to determine
which objects or parts of objects are visible in a 3D scene and which are hidden behind other objects.
When viewing a picture containing non transparent objects and surfaces, it is not possible to see those objects
from view which are behind from the objects closer to eye. To get the realistic screen image, removal of these
hidden surfaces is must. The identification and removal of these surfaces is called as the Hidden-surface
problem.
Z-buffer, which is also known as the Depth-buffer method is one of the commonly used method for hidden
surface detection.
Let’s consider an example to understand the algorithm in a better way. Assume the polygon given is as below :

In starting, assume that the depth of each pixel is infinite.

As the z value i.e, the depth value at every place in the given polygon is 3, on applying the algorithm, the result
is:
Now, let’s change the z values. In the figure given below, the z values goes from 0 to 3.

In starting, the depth of each pixel will be infinite as :

Now, the z values generated on the pixel will be different which are as shown below :

Applications
1. Hidden Surface Removal:
Ensures only visible parts of objects are rendered in 3D graphics.
2. Shadow Mapping:
Used to compute depth from the light's perspective for realistic shadow rendering.
3. 3D Rendering Pipelines:
Essential in modern rendering engines like OpenGL, DirectX, and Vulkan.
9. Brief about game loop in Pygame.
The game loop is the core structure of any game. It is a continuous loop that keeps the game running, updating
its state, and rendering the graphics on the screen. In Pygame, the game loop typically performs three primary
tasks:
1. Process Input (Event Handling): Detect and respond to user inputs like keyboard presses, mouse clicks,
or joystick movements.
2. Update Game State: Change the game's state based on the input, elapsed time, or other factors (e.g.,
moving objects, checking collisions, or applying physics).
3. Render Output (Drawing): Render the updated game state to the screen, including redrawing the
background, sprites, and UI elements.
Setting up the Game Loop
Step 1: Declare a Boolean variable to true which will be used to check whether our player wants to keep
playing our game or not.
keepGameRunning=true
Step 2: Create a while loop and check our above Boolean variable that whether it is true or not. If true keep
the loop running which suggests keeping our game loop running. In this while loop check for events and if the
event is quit then set the above variable too false to exit our game loop and end our pygame window.
while keepGameRunning:
for event in pygame.event.get():
if event.type == pygame.QUIT:
keepGameRunning = False
In the below code, we are creating a simple game loop that creates a pygame window and checks if the event
type is quit and, if it is true then quit the game.
import pygame
pygame.init()
# displaying a window of height
# 500 and width 400
pygame.display.set_mode((400, 500))
# Setting name for window
pygame.display.set_caption('GeeksforGeeks')
# creating a bool value which checks
running = True
while running:
 for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
10. Explain in brief game logic and its subsystems

Game logic is the central component of a game that governs its rules, behavior, and mechanics. It defines what
happens in the game and how the game reacts to events. Game logic ties together various systems to ensure a
cohesive and interactive experience.
Key Responsibilities of Game Logic

1. Control Game Flow: Determines the sequence of events, game progression, and states (e.g., main
menu, gameplay, pause, game over).
2. Manage Game Rules: Enforces rules like score calculation, win/lose conditions, and restrictions.
3. Interact with Subsystems: Coordinates input handling, physics, AI, rendering, and audio to create a
seamless experience.

Subsystems of Game Logic

Game logic interacts with several subsystems, each with a specific function:
1. Input Handling

● Purpose: Detects user input from devices like keyboards, mice, or controllers and translates them into
in-game actions.
● Example: Moving a character when the arrow keys are pressed.

2. Role in Game Logic:

● Maps input to gameplay actions (e.g., W to move forward, SPACE to jump).

● Handles game commands like pausing or exiting.

3. Artificial Intelligence (AI)

● Purpose: Controls the behavior of non-player characters (NPCs) or enemies.

● Example: A computer-controlled enemy chasing the player.

Role in Game Logic:

● Processes AI algorithms for decision-making (e.g., pathfinding, attack strategies).

● Adapts NPC actions to the player’s behavior.

4. State Management

● Purpose: Tracks the current state of the game and transitions between states.
● Example: Switching from the main menu to gameplay or a pause screen.

Role in Game Logic:

 ● Manages states like start screen, playing, paused, and game over.
● Ensures smooth transitions between states.

11. Explain Pygame music and mixer module

Pygame Music and Mixer Module

The Pygame mixer module provides functionality for adding audio to your games. It allows you to play sound
effects and background music, offering control over volume, playback, looping, and more. The module works
with popular audio formats like .mp3, .ogg, .wav, etc.
Before playing any sound or music, the mixer must be initialized. This is often done automatically when
Pygame is initialized using pygame.init(). However, you can manually initialize the mixer with specific settings.
pygame.mixer.init(frequency=44100, size=-16, channels=2, buffer=512)

● frequency: The sample rate, typically 44100 Hz.

● size: The size of each sample. -16 for 16-bit audio.
● channels: Number of audio channels (1 for mono, 2 for stereo).
● buffer: The size of the internal buffer, usually 512 or 1024.

Loading Music
To load a music file:
pygame.mixer.music.load("background.mp3")
Playing Music
To start playing the loaded music:
pygame.mixer.music.play(loops=0)

● loops: Number of times the music will loop. 0 means play once, -1 means loop indefinitely.

Stopping Music
To stop the currently playing music:
pygame.mixer.music.stop()
Pausing and Resuming

● Pause:

pygame.mixer.music.pause()

● Unpause/Resume:

pygame.mixer.music.unpause()

Features of Pygame Mixer

1. Background Music: Play long audio tracks with playback control.

2. Sound Effects: Handle short, repeatable sounds efficiently.
3. Multiple Sounds: Play multiple sounds simultaneously (e.g., background music + sound effects).
4. Volume Control: Adjust volume individually for music and sound effects.
 5. Cross-Platform: Works on major platforms, ensuring portability of your game audio.

12. Brief about Direct3D. How to setup in Visual studio environment.

Direct3D is a graphics API within Microsoft's DirectX suite, used for rendering 3D graphics in real-time
applications such as games and simulations. It provides access to advanced features of modern GPUs, enabling
developers to create high-performance, visually rich applications. Direct3D supports features like hardware
acceleration, programmable shaders, and vertex manipulation.

Key Features of Direct3D

1. High-Performance Rendering: Utilizes GPU capabilities for rendering 2D and 3D graphics.

2. Programmable Pipeline: Supports custom shaders (vertex, pixel, and geometry shaders).
3. Cross-Hardware Compatibility: Works on a wide range of GPUs and hardware configurations.
4. Advanced Features:
o Real-time lighting and shadow effects.
o Texture mapping and blending.
o Anti-aliasing for smoother visuals.
5. Integration with Windows: Built into Windows, making it the go-to API for Windows-based gaming.

Setting Up Direct3D in Visual Studio (Simplified)

1. Install Visual Studio
o Download Visual Studio (latest version) from the official site.
o Select the Desktop development with C++ workload during installation.
2. Install DirectX SDK (Optional)
o Modern Visual Studio versions include DirectX via the Windows SDK.
o For legacy components, download DirectX SDK (June 2010) and add its Include and Lib
directories to your project settings.
3. Create a New Project
o Open Visual Studio and create a Win32 Project or Windows Desktop Application.
o Choose an empty project without predefined settings.
4. Configure Project Settings
o Go to Project Properties:
▪ Under VC++ Directories, add DirectX SDK paths for Include and Lib.

▪ Under Linker > Input > Additional Dependencies, add:

d3d11.lib; dxgi.lib; d3dcompiler.lib;

That's it! You’re ready to start coding with Direct3D.
13. Explain the types of Bezier Curve. What is Bezier curve ?
A Bézier Curve is a parametric curve frequently used in computer graphics, animation, and modeling. It
provides a smooth curve that can be scaled, transformed, or manipulated easily. The shape of the curve is
controlled by a set of control points that define its direction and curvature.
The Bézier curve is defined mathematically using a parametric equation:

Types of Bézier Curves

Bézier curves are classified based on the number of control points or the degree of the curve:

1. Linear Bézier Curve (Degree 1)

● Number of Control Points: 2
● The simplest Bézier curve, essentially a straight line between two control points P0 and P1​.
● Parametric equation: B(t)=(1−t)P0​+tP1​
● Shape: Straight line.

2. Quadratic Bézier Curve (Degree 2)

● Number of Control Points: 3
● A parabolic curve determined by three points: start point, end point, and one control point.
● Shape: Can form curves with one inflection.
3. Higher-Degree Bézier Curves (Degree n>3)

● Number of Control Points: n+1

● These curves are formed by adding more control points.
 ● Provide greater control but are computationally expensive.
● Not commonly used in practice because they are harder to manipulate.

Applications of Bézier Curves

Computer Graphics: Drawing smooth curves and shapes.
Animation: Defining motion paths for objects.
Font Design: Constructing smooth letter shapes.

14. What is Blending? Explain the Blending equation, Blend Operations , Blend Factors and Blend State. Write a
Note on Blending.
Blending is a graphics technique used to combine two or more layers of color information to create a final
rendered image. It determines how the source color (the color being drawn) and the destination color (the
color already in the framebuffer) interact to produce a new color. Blending is widely used for effects like
transparency, anti-aliasing, and compositing.
Blending Equation
The blending equation determines how the source and destination colors are combined. Mathematically, it is
expressed as:

Blend Operations
Blend operations define how the source and destination colors are mathematically combined. Common blend
operations include:
Blend State
The blend state is a configuration that specifies how blending should be applied. It includes:
1. Enable or Disable Blending:
o Blending can be turned on or off for specific rendering operations.
2. Blend Equation:
o Specifies the mathematical operation for combining colors (e.g., add, subtract).
3. Blend Factors:
o Defines the weights for source and destination colors.

15. What is Direct3d? Explain the resemblance between Direct3D and DirectX? Explain component object
model(com) and any two Interfaces provided by Direct3D?
Direct3D is a graphics API (Application Programming Interface) developed by Microsoft. It is part of the larger
DirectX suite and is specifically used for rendering 3D graphics in applications such as video games,
simulations, and multimedia programs. Direct3D provides developers with tools and libraries to access the
hardware acceleration capabilities of GPUs (Graphics Processing Units) for rendering high-performance 3D
graphics.
Resemblance Between Direct3D and DirectX
1. DirectX as a Suite:
o DirectX is a collection of APIs for handling multimedia tasks, such as graphics, sound, input, and
networking.
o Direct3D is a component of the DirectX suite, specifically focused on 3D graphics rendering.
2. Shared Purpose:
o Both DirectX and Direct3D aim to improve the performance of multimedia applications by
directly accessing hardware.
3. Compatibility:
o Improvements in Direct3D often coincide with updates to DirectX, ensuring compatibility with
the latest hardware and features.

Component Object Model (COM)

The Component Object Model (COM) is a platform-independent, object-oriented architecture developed by
Microsoft. It is used to enable inter-process communication and dynamic object creation. Direct3D is built on
COM, allowing developers to create and manage graphics resources through interfaces.
Key Features of COM in Direct3D
1. Interface-Based Design:
o Objects in COM expose functionality through interfaces, which are collections of methods.
2. Versioning:
o Interfaces are immutable, ensuring backward compatibility.
3. Dynamic Linking:
o Components can be loaded and linked at runtime.
Advantages of Direct3D with COM

1. Hardware Abstraction:
o Developers can use Direct3D without worrying about low-level hardware details.
2. Scalability:
o COM ensures that applications can scale across different hardware and driver implementations.

16. Explain the following lightning a. Diffuse lighting b. Ambient lighting c. Specular lighting
a. Diffuse Lighting
Diffuse lighting simulates light scattering evenly across a surface when it hits it. This type of lighting gives
objects a soft, uniform illumination that emphasizes their shape and texture, making them appear more
realistic. It depends on the angle between the light source and the surface but is unaffected by the viewer's
position.
Example: The even lighting on a wall in a room during daytime.

b. Ambient Lighting
Ambient lighting represents the indirect light that bounces around in an environment, illuminating surfaces
uniformly without a specific source or direction. It prevents complete darkness in shadowed areas and creates
a base level of brightness in a scene.
Example: The general light in a room from multiple indirect sources like windows and reflections.

c. Specular Lighting
Specular lighting models the bright highlights that occur when light reflects sharply off a shiny surface, creating
a mirror-like effect. The intensity of this highlight depends on the viewer's position relative to the light source
and the surface.
Example: The gleam on a polished car or a glass surface under a spotlight.
4o