Q-Computer Graphics refers to the creation, manipulation, and representation of visual images using computer

systems. It involves both the hardware and software necessary to create digital visuals, including images, videos,
animations, and 3D models. The field has evolved from simple 2D shapes to sophisticated, lifelike representations used
in a wide variety of applications.
Components of Computer Graphics:
1. Hardware:*Graphics Processing Unit (GPU): Specialized hardware designed for handling complex graphic
rendering and processing tasks.Monitors and Displays: Devices that present graphical content to the user, such
as screens, virtual reality headsets, or projectors.Input Devices: Tools like mouse, keyboard, touchscreens, and
drawing tablets, used to interact with the graphical system.
2. Software:*Graphics Software: Applications like Photoshop, Illustrator, AutoCAD, or Blender that provide the
tools for creating, editing, and manipulating images.Rendering Engines: Software that converts 3D models or
scenes into 2D images, taking into account lighting, textures, and perspective.Game Engines: Platforms like
Unity or Unreal Engine that integrate computer graphics into interactive experiences like video games.
Types of Computer Graphics:*Raster Graphics: Represent images as a grid of pixels. Each pixel has color
information. Common file formats include JPG, PNG, and GIF.Vector Graphics: Represent images using mathematical
equations, such as points, lines, and curves. These are resolution-independent and often used in logos and illustrations.
Common file formats include SVG, EPS, and PDF.3D Graphics: Involves the creation of three-dimensional objects and
environments. These can be rotated and viewed from different angles, and are used in simulations, video games, and
virtual reality.
Applications of Computer Graphics:*Entertainment and Media:Video Games: Creating immersive worlds,
characters, and interactive environments.Movies and Animation: Special effects, 3D animation, and visual effects in
films.Virtual Reality (VR) and Augmented Reality (AR): Immersive experiences in entertainment, training, and
simulations.
1. Design and Art:
o Graphic Design: Visual communication in advertisements, websites, logos, and brand materials.Digital
Art: Artwork created with computer-based tools, including digital painting, 3D modeling, and
illustration.
2. Medical Imaging:
o Radiology: Visualization of X-rays, CT scans, MRIs, and ultrasounds.Surgical Planning and
Simulation: 3D models of organs or tissues to assist in surgery preparation or training.
3. Engineering and Architecture:
o CAD (Computer-Aided Design): Creating 2D and 3D designs for buildings, machinery, and
products.Simulation: Modeling physical environments or systems to predict behavior, such as wind
tunnels or traffic flow.
4. Education and Training:
o Simulations: Virtual environments used to simulate real-world situations (e.g., flight simulators or
medical procedures).Interactive Learning: Educational content, such as interactive diagrams, 3D
models, and virtual classrooms.
5. Web Development:
o User Interface (UI) and User Experience (UX): Designing visually appealing and functional websites
and apps using graphics, animations, and visual hierarchies.
6. Advertising and Marketing:
o Visual Advertising: Creating eye-catching visuals for social media, print ads, billboards, and
commercials.Product Visualization: Showcasing products with 3D renders or augmented reality tools to
attract consumers.
Q-Advantages of Flood Fill:
1. Simplicity:The algorithm is easy to understand and implement, especially using a simple recursive approach.
2. Flexible Region Filling:Can fill any connected region, whether the shape is irregular or complex, as long as the
area is connected (i.e., has pixels that are adjacent).
3. Efficiency with Open Regions:Works well for filling regions that are not enclosed by a boundary and are
surrounded by a space of another color.
4. Memory Usage (in some cases):When implemented iteratively with BFS or DFS, the flood fill algorithm can
use minimal memory for small areas or relatively simple shapes.
Disadvantages of Flood Fill:
1. Stack Overflow in Recursion:The recursive version of the algorithm can cause stack overflow errors if the
region to be filled is too large or deep. This is because the recursion can consume a large amount of memory,
especially for deeply nested regions.
2. Inefficiency with Large Regions:Flood fill may take longer to fill large regions, as it needs to check and
process all neighboring pixels, especially if there are many unconnected pixels in the image.
3. Slow in Complex or Large Areas:The algorithm can be slower than expected in areas with a lot of connected
pixels, as it might need to visit each pixel multiple times, increasing the computation time.
4. Color Boundary Assumption:Flood fill assumes that the boundary is of a different color or value. If the
boundary shares a color with the fill region, the algorithm may not work correctly and might "spill" into
unintended areas.
Boundary Fill Algorithm:The Boundary Fill algorithm works by starting from a point inside the region and filling the
area by coloring adjacent pixels, but it stops when it encounters a boundary (a pixel of a certain color).
Advantages of Boundary Fill:*Works Well for Enclosed Regions:Particularly useful for regions that are completely
enclosed by a boundary, such as a closed shape or figure. It is ideal when the boundary color is well-defined.No Risk of
Stack Overflow:Since it doesn't rely on recursion, the boundary fill algorithm does not suffer from stack overflow
issues, unlike the recursive flood fill.Efficient for Bounded Regions:The algorithm is efficient when the region is
well-defined and enclosed by a boundary, reducing the amount of unnecessary fill operations compared to flood
fill.Good for Polygon Filling:Ideal for filling areas defined by a clear polygon, where the boundary is well-defined, and
no overflow into non-enclosed areas is desired.
Disadvantages of Boundary Fill:Dependent on Boundary Color:The algorithm relies on the boundary being a
distinct color or pixel value. If the boundary is too similar to the fill color, the algorithm may fail or "spill" outside the
desired area.
1. Limited to Enclosed Areas:It is not as useful for open or irregular regions (e.g., when filling a shape that is not
closed), as it needs a distinct boundary to stop the fill.
2. Complexity in Handling Irregular Boundaries:For regions with complex or irregular boundaries, the
boundary fill can be inefficient because the algorithm must process each edge pixel individually.
3. Inefficient for Large Regions:The algorithm may struggle with very large areas with complex boundaries,
leading to inefficiency and slower performance.
Q-The Midpoint Circle Drawing Algorithm is an efficient algorithm used to draw a circle on a computer screen or
raster graphics environment. This algorithm is based on decision-making to determine the next pixel to plot as we draw
the circle, ensuring that the circle is drawn with the correct shape and smoothness. It is efficient because it calculates
only one octant (or one segment) of the circle and then mirrors the points to other octants, exploiting the circle’s
symmetry.
Circle Equation:The equation of a circle with a center at (h,k) and radius r is given by:
(x−h)2+(y−k)2=r2
In the case of the midpoint circle algorithm, we generally assume the center of the circle is at the origin (0,0) for
simplicity, so the equation becomes:
x2+y2=r2
Steps of the Midpoint Circle Drawing Algorithm:
1. Initialization:The algorithm starts by choosing an initial point on the circle. For simplicity, this is taken as
(x,y)=(0,r).*The initial decision parameter is calculated as:
p0=1 −r
2. Plot the Initial Points:Plot the first point at (0,r), and because of the symmetry of the circle, we can
immediately plot points in all 8 octants (symmetrical positions).
3. Iterative Process:For each step k, a decision is made whether to move horizontally or diagonally (i.e., along the
boundary of the circle). The decision is based on the value of the decision parameter pk.
o Decision Parameter Update:If pk<0, the next point is horizontally to the right (increment x).*If pk≥0,
the next point is diagonally (increment both xand y).
4. Update the Decision Parameter: After plotting a point, the decision parameter is updated based on the
direction of the movement. The new decision parameter pk+1 is calculated as follows:
o If moving horizontally:
pk+1=pk+2x+1
o If moving diagonally:
pk+1=pk+2x−2y+1
5. Repeat the process until x≥y, meaning we have plotted all points in the first octant, and the circle is completed
by mirroring the points in the other seven octants.
Symmetry of the Circle:Because of the symmetry of the circle, once we compute the points in one octant, we can
reflect those points over the other seven octants. The octants of the circle correspond to the following points:
• First octant: (x,y)
• Second octant: (−x,y)
• Third octant: (−x,−y)
• Fourth octant: (x,−y)
• Fifth octant: (y,x)
• Sixth octant: (−y,x)
• Seventh octant: (−y,−x)
• Eighth octant: (y,−x)
By mirroring the computed points in these other octants, we efficiently draw the entire circle.
Example: Drawing a Circle with Radius r=5-Let’s walk through an example where we want to draw a circle with a
radius of 555 using the Midpoint Circle Drawing Algorithm.
1. Initial Setup:Start with (x,y) = (0, 5) (the topmost point of the circle).*The initial decision parameter is:
p0=1−r=1−5=−4
2. Plot Points:Since p0<0, we move horizontally, so the next point is (1,5).*Update the decision parameter:
p1=p0+2x+1=−4+2(1)+1=−1
3. Next Step:Again, p1<0, so we move horizontally to (2,5)(2, 5)(2,5).*Update the decision parameter:
p2=p1+2x+1=−1+2(2)+1=2
4. Next Step:Now, p2≥0, so we move diagonally to (3,4).*Update the decision parameter:
p3=p2+2x−2y+1=2+2(3)−2(4)+1=−1
5. Next Step:Again, p3<0, so we move horizontally to (4,4).*Update the decision parameter:
p4=p3+2x+1=−1+2(4)+1=6
6. Next Step:Now, p4≥0, so we move diagonally to (5,3).*Update the decision parameter:
p5=p4+2x−2y+1=6+2(5)−2(3)+1=4
7. Stop Condition:Since x=5x = 5x=5 and y=3, we have completed the first octant.
8. Mirror the Points:The points computed in the first octant are:
▪ (0,5),(1,5)(1, 5), (2,5),(3,4), (4,4), (5,3)
These points can be mirrored in the other seven octants to get the full circle.
Final Circle Points:
Using the points from the first octant and reflecting them, we get the following points for the complete circle (mirrored
in all eight octants):
• (0,5),(1,5),(2,5),(3,4),(4,4), (5,3)
• (5,3),(4,4),(3,4),(2,5),(1,5),(0,5)
• ... and so on for other octants.
Q-Bresenham's line algorithm is an efficient way to draw a straight line between two points on a raster grid. It avoids
floating-point arithmetic and uses only integer addition, subtraction, and bit-shifting operations, making it highly
efficient for computer graphics.*The algorithm determines which pixel should be the next one along the line by using a
decision parameter that decides whether to move in the x-direction or y-direction (or both) for each step.
Bresenham's Line Algorithm (for a line from (x1, y1) to (x2, y2)):
Input: Two endpoints (x1,y1) and (x2,y2).
Output: A set of points that form the straight line from (x1,y1) to (x2,y2).

Steps:
1. Initialization:
o Calculate the differences:
Δx=x2−x1
Δy=y2−y1
o Set the initial points as (x,y)=(x1,y1).
o Determine the step direction:
If Δx<0, set dx=−1, otherwise set dx=1.
If Δy<0, set dy=−1, otherwise set dy=1.
o Initialize the decision parameter:
▪ If ∣Δx∣>∣Δy∣|, set p=2Δy−Δx (the error term).
▪ Otherwise, set p=2Δx−Δy.
2. Plot the First Point:Plot the starting point (x1,y1).
3. Iterate through the pointsFor each step, depending on the decision parameter:
 ▪ If p>0, move diagonally (increment both x and y).
▪ Otherwise, move horizontally or vertically depending on whether Δx or Δy is greater.
4. Update the Decision Parameter:
o If ∣Δx∣>∣Δy∣, update ppp as follows:
p=p+2Δy(if moving horizontally)}p=p+2Δy(if moving horizontally)
o If ∣Δx∣<∣Δy∣, update p as follows:
p=p+2Δx(if moving vertically)
5. Repeat until the end point (x2,y2) is reached.

Bresenham's Line Algorithm (Pseudocode):

function BresenhamLine(x1, y1, x2, y2):
# Calculate differences
dx = abs(x2 - x1)
dy = abs(y2 - y1)

# Determine step direction

if x1 < x2: stepX = 1 else stepX = -1
if y1 < y2: stepY = 1 else stepY = -1

# Initialize decision parameter

if dx > dy: p = 2 * dy - dx
else: p = 2 * dx - dy

# Plot the starting point

plot(x1, y1)

# Iterate through each point

if dx > dy:
for x = x1 to x2:
if p > 0:
y1 += stepY
p -= 2 * dx
p += 2 * dy
plot(x, y1)
else:
for y = y1 to y2:
 if p > 0:
x1 += stepX
p -= 2 * dy
p += 2 * dx
plot(x1, y)

Q-Bresenham's Circle Drawing Algorithm:Bresenham's circle drawing algorithm is a highly efficient algorithm to
draw circles by determining the points on the circle using integer-only calculations, avoiding floating-point arithmetic.
Like the line algorithm, it utilizes the symmetry of the circle to reduce computations and mirror points across the
octants.
Bresenham's Circle Algorithm (for a circle with center (xc, yc) and radius r):
Input: Center of the circle (xc,yc) and the radius r.
Output: A set of points that form the circle.

Steps:
1. Initialization:Start with initial values x=0 and y=r.*Calculate the initial decision parameter:
p=3−2r.
2. Plot Points:Plot the initial points based on the symmetry of the circle:
▪ (x+xc,y+yc)
▪ (x+xc,−y+yc)
▪ (−x+xc,y+yc)
▪ (−x+xc,−y+yc)
▪ (y+xc,x+yc)
▪ (y+xc,−x+yc)
▪ (−y+xc,x+yc)
▪ (−y+xc,−x+yc)
3. Iterate through points:For each step, depending on the value of the decision parameter p, update the values of
x and y as follows:*If p<0, the next point is horizontally to the right (increment x).*If p≥0, the next point is
diagonally (increment both x and y).
4. Update the Decision Parameter:
o If p<0:
p=p+4x+6
o If p≥0:
p=p+4(x−y)+10
5. Repeat the process until x≥y

Bresenham's Circle Algorithm (Pseudocode):

function BresenhamCircle(xc, yc, r):
# Initial values
x=0
y=r
p=3-2*r

# Plot the initial points

plot(xc, yc + r)
plot(xc, yc - r)
plot(xc + r, yc)
plot(xc - r, yc)

# Iterate through the points

while x < y:
# Plot points in all octants
plot(xc + x, yc + y)
plot(xc - x, yc + y)
plot(xc + x, yc - y)
plot(xc - x, yc - y)
plot(xc + y, yc + x)
plot(xc - y, yc + x)
plot(xc + y, yc - x)
plot(xc - y, yc - x)

# Update the decision parameter

if p < 0:
p=p+4*x+6
else:
p = p + 4 * (x - y) + 10
y -= 1
x += 1

Q-Polygon filling algorithms are essential in computer graphics for coloring or "filling" the interior of a polygon with
a specific color or pattern. These algorithms are primarily used in raster-based graphics (like 2D bitmap images) and are
crucial for applications such as rendering, games, CAD, and more.
Objective of Polygon Filling:The goal of a polygon filling algorithm is to identify which pixels or points inside a
polygon should be colored based on certain criteria. This task is particularly challenging because polygons can have
complex shapes, varying numbers of vertices, and different types of boundaries.
Types of Polygon Filling Algorithms:
There are two primary types of polygon filling algorithms:
1. Scanline Filling Algorithm
2. Flood Fill Algorithm
3. Edge Fill Algorithm (or Seed Fill)
In this explanation, we will focus on the Scanline Filling Algorithm, as it is one of the most widely used algorithms for
polygon filling.
Q-Scanline Filling Algorithm:The Scanline Filling Algorithm is one of the most efficient methods for filling a
polygon. It works by processing the image row by row (scanline by scanline) and determining which pixels fall inside
the polygon at each horizontal scanline.
Steps of the Scanline Filling Algorithm:Input:A polygon with vertices defined by their coordinates
(x1,y1),(x2,y2),…,(xn,yn).*The color or pattern that will be used to fill the interior of the polygon.Sorting the
Edges:First, sort all edges of the polygon based on their y-coordinates. This step ensures that we process edges from top
to bottom.*The edges of the polygon are stored as pairs of xxx-coordinates along with the corresponding
y-coordinates.*For each edge, store the following information:*The y-minimum and y-maximum coordinates (i.e., the
vertical range of the edge).*The slope of the edge, which helps in determining the x-coordinate as we move down a
scanline.
1. Create a List of Active Edges:As we process each scanline, an Active Edge Table (AET) is used to keep track
of the edges that intersect with the current scanline.*For each scanline, we update the list of active edges by
adding new edges that cross the scanline and removing edges that no longer intersect the scanline as we move
down.*Active edges are sorted by their x-coordinates at each scanline.
2. Filling the Interior:Once we have the sorted active edges for the current scanline, we proceed to fill the
polygon:Pairing edges: The active edges create pairs that define horizontal segments where the polygon is
filled. These pairs are used to determine the range of pixels to fill in.*The algorithm will color all the pixels
between each pair of intersections of edges with the scanline.*For example, if the current scanline intersects two
edges at x1and x2, where x1<x2, then all pixels between x1 and x2 are filled.
3. Updating the AET:After processing each scanline, the algorithm updates the Active Edge Table (AET) for the
next scanline:*Remove edges that have passed below the scanline (i.e., the ones whose y-maximum is less than
the current scanline’s y-coordinate).*Update the x-coordinates of the remaining active edges using their slopes.
4. Repeat the process for all scanlines from the top of the polygon to the bottom.
5. Termination:The algorithm stops when it has processed all scanlines that intersect the polygon, and all interior
pixels have been filled.

Example of Scanline Filling:Let’s consider an example of a polygon with 4 vertices (a square) with coordinates
(x1,y1)=(1,1), (x2,y2)=(1,4)(x_2, y_2) = (1, 4),(x_3, y_3) = (4, 4)and (x4,y4)=(4,1).
1. Sorting Edges:The edges are sorted based on their y-coordinates. Each edge is represented by a pair of
coordinates and a slope:
▪ Edge 1: From (1,1)to (1,4) (Vertical line)
▪ Edge 2: From (1,4) to (4,4) (Horizontal line)
▪ Edge 3: From (4,4)to (4,1)(Vertical line)
▪ Edge 4: From (4,1)to (1,1) (Horizontal line)
 2. Scanline Processing:Start with the first scanline (y = 1). At this point, edges 1 and 4 intersect the scanline.*In
the next step, we calculate where the active edges intersect with the scanline and pair them.
3. Fill Pixels:The algorithm will fill pixels between the intersection points of edges at each scanline. For instance,
between the intersection points of edges 1 and 3 at y=2, and between edges 2 and 4 at y=3.
Edge Fill Algorithm (Alternative Approach):The Edge Fill Algorithm works by processing the edges of the polygon
and then determining which pixels fall inside the polygon by following the edges.
Steps of the Edge Fill Algorithm:
1. For each edge of the polygon, find the intersections with horizontal scanlines.
2. Identify whether the scanline lies inside or outside the polygon using a rule like odd-even rule or non-zero
winding rule.
3. Fill the pixels based on whether the scanline intersects an odd or even number of times with the polygon's edges.
This method is useful when the polygon has complex, self-intersecting boundaries.
Advantages of the Scanline Algorithm:Efficiency: The scanline algorithm is generally faster for complex polygons as
it processes horizontal lines (scanlines) and only updates active edges.Handling of Arbitrary Polygons: It works well
for polygons of any shape, including concave polygons.Memory Efficiency: The active edge table is relatively small
and requires minimal memory to store edges during the scanline process.
Disadvantages:Complexity for Complex Polygons: It can be difficult to handle polygons with self-intersections or
very irregular shapes.Edge Sorting: Sorting the edges initially can add to the complexity of the algorithm.Handling
Floating Point Operations: Calculating the intersections and updating the active edge table might require
floating-point operations for higher precision.
Q-Port mapping and transformation are two concepts that are typically discussed in networking, particularly in the
context of Network Address Translation (NAT) and firewall configurations, where they enable communication between
devices across different networks.Port Mapping:Port mapping refers to the process of forwarding traffic that comes to
a specific port on one device (usually a router or firewall) to another port or device on a different network. It essentially
tells the router how to direct incoming network traffic to a specific internal server or device based on the destination
port number.*Port mapping is commonly used in NAT configurations to allow devices inside a private network to
communicate with the outside world while keeping the internal IPs hidden.
Example of Port Mapping: Suppose you have a web server inside your local network, and it listens on port 80
(HTTP). You want people from the internet to be able to access it through your public IP address. However, your router
has a private IP for your internal network, like 192.168.1.100.
Port Mapping Configuration:The router is configured to map traffic coming to its public IP address on port 8080 to
the internal server's IP address 192.168.1.100 on port 80.This means when someone visits http://<public-ip>:8080, the
router will forward that traffic to 192.168.1.100:80.
So, the mapping would look like this:External (Public): Port 8080Internal (Private): 192.168.1.100:80
The traffic will be correctly forwarded from the public IP to the private IP based on this port mapping.
Port Transformation:Port transformation refers to modifying the port number as part of the forwarding process. It
typically occurs when the router or firewall not only forwards packets based on the destination port but also changes the
port number in the process.This is commonly used in Dynamic NAT or PAT (Port Address Translation) where multiple
devices inside a private network might share the same public IP but need different ports for communication.
Example of Port Transformation: Suppose you have two internal devices:
o A web server running on 192.168.1.100:80
o A mail server running on 192.168.1.101:25
You want both of these servers to be accessible from the internet, but you only have one public IP (203.0.113.5). Here,
port transformation can be used to avoid conflicts.
Transformation Configuration:Traffic coming to 203.0.113.5:8080 should be forwarded to 192.168.1.100:80.*Traffic
coming to 203.0.113.5:8081 should be forwarded to 192.168.1.101:25.
Here, the router or firewall would transform the incoming port numbers so that traffic on different external ports (8080,
8081) is mapped to different internal services.
Transformation Process:Public IP 203.0.113.5:8080 → Internal IP 192.168.1.100:80 (Web server)*Public IP
203.0.113.5:8081 → Internal IP 192.168.1.101:25 (Mail server)
Q- Viewing Transformation Pipeline-In the context of data processing and data transformation, the transformation
pipeline refers to the sequence of steps involved in converting raw data into a useful or desired format. This pipeline is
common in scenarios such as ETL (Extract, Transform, Load), data integration, machine learning, or image/video
processing. The key idea is to view how raw data flows through different transformation stages until it reaches its final
form.
Key Stages in a Transformation Pipeline:
1. Extraction: The first step, where data is retrieved from various sources (e.g., databases, flat files, APIs, sensors).
2. Transformation: The core part where the data undergoes various changes, such as cleaning, filtering,
aggregating, enriching, or converting formats.
3. Loading: The final step, where transformed data is loaded into its target destination, such as a database, data
warehouse, or data lake.
To understand this better, let's break down a real-world example of a transformation pipeline.
Example: Transformation Pipeline for an E-commerce Business
Scenario:An e-commerce business wants to generate customer insights by transforming raw sales data into useful
reports. The raw data is extracted from different sources, and it needs to be processed before analysis.
Step-by-Step Breakdown of the Transformation Pipeline:
1. Extraction:Data is collected from multiple sources:
▪ Sales transactions from a relational database.
▪ Customer demographics from a CRM system.
▪ Product data from an inventory management system.
2. Transformation: The raw data goes through several transformations:
o Data Cleaning: Removing invalid entries like transactions with missing prices or customer records
without addresses.
o Data Aggregation: Summing up sales per product category, calculating the total revenue for a given
time period.
o Filtering: Excluding data that isn't relevant for analysis, such as sales from discontinued products.
o Join Operations: Combining customer demographics with their transaction records to get complete
information for analysis.
o Data Enrichment: Adding calculated fields like Average Order Value (AOV) or Customer Lifetime
Value (CLV), based on the sales data.
o Format Conversion: Converting date formats, currency units, or time zones to a consistent format
across the dataset.
The transformation process may look like this:
Raw Data (sales, customer, product info)
↓
Data Cleaning (remove invalid records)
↓
Aggregation (total sales per product category)
↓
Filtering (exclude discontinued products)
↓
Joining (merge customer info with transaction data)
↓
Enrichment (calculate metrics like AOV, CLV)
↓
Format Conversion (standardize date and currency)
3. Loading: After transformation, the data is loaded into the final destination, which could be a data warehouse or
a reporting tool.*The data might be loaded into a SQL database for further analysis.*A dashboard like Tableau
or Power BI could be connected to the data source for real-time reporting and visualization.

Q-The viewport is the area of the browser where the content of the web page is visible to the user. It's essentially the
portion of the browser window that displays the webpage, excluding things like browser toolbars, scrollbars, and
borders.*The viewport is defined by the dimensions of the visible part of the page that is accessible for rendering
content. The content inside the webpage is sized and rendered according to the viewport's dimensions, which may
change when the user zooms in/out or resizes the window.*In CSS, the viewport is often used when defining layout
properties. For example, the vw (viewport width) and vh (viewport height) units in CSS are based on the viewport's
size.
Example of viewport usage:When you set an element's width to 100vw, it means the element will take up 100% of the
viewport's width, regardless of the browser window's size.*When the page content is scrolled, only the viewport area is
visible, and the rest of the content is hidden and accessible via scrolling.
Viewport Characteristics:The viewport size can change dynamically based on the browser's size.*It refers to the
visible area of the page in the browser window.*The viewport does not include the browser's chrome (like the address
bar or navigation bar).
Q-Window-The window refers to the entire browser window, including everything inside it, such as the visible
viewport area, toolbars, scrollbars, and even the browser's chrome (like the browser's navigation bar and buttons).*The
window represents the entire browser interface, and it includes the viewport along with additional UI elements such as
the address bar, bookmarks, and other parts of the browser.*The dimensions of the window include the space taken by
the browser's chrome, and it is typically larger than the viewport.
Example of window usage:When a user resizes their browser window, the window's size changes, but the viewport
size might change proportionally depending on the layout.
Window Characteristics:The window includes the entire browser environment.*The size of the window may be bigger
than the viewport because it includes non-content elements like the address bar and browser borders.*The window can
be resized, minimized, or maximized, affecting both the viewport size and the overall window size.
Q-Clipping refers to the process of limiting or restricting the rendering of a particular area of an element or content so
that it is visible only within a specified boundary. When clipping is applied, any content that extends beyond the defined
boundary is cut off or hidden, essentially making it invisible to the user. This can be useful in various scenarios, such as
creating custom shapes, hiding overflow, or restricting visual areas for specific content.*In the context of web
development (especially CSS and graphical elements), clipping can be applied to visual elements such as images, divs,
and text.
Types of Clipping
1. CSS Clipping:*Clip-path: A CSS property that allows you to define a clipping region for an element. It works
by clipping an element’s content within the specified shape, such as a rectangle, circle, polygon, or other
geometric shapes.Overflow: Another property in CSS that can be used to control how content is clipped when it
overflows a container (e.g., overflow: hidden, overflow: scroll).
2. Canvas and SVG Clipping:*Canvas: In the <canvas> element, you can use JavaScript methods like clip() to
define clipping paths for drawing.SVG: SVG also allows clipping paths to define which areas of an SVG
element are visible, using the clipPath element.
Text Clippin *Text clipping refers to restricting the visible portion of text within a defined area, where any portion of
the text that exceeds the boundary of this area is hidden or cut off. It’s commonly used in UI elements where text needs
to fit into a fixed-size container, such as buttons, cards, or containers that have limited space for text.
Ways to Implement Text Clipping
1. Using CSS text-overflow Property:The text-overflow property is used in conjunction with the overflow
property to control how the overflow of text content is handled when it does not fit within the
container.*Common values for text-overflow include:ellipsis: Adds an ellipsis (...) at the end of clipped text.clip:
Clips the text without adding any indication of truncation.
Example of Text Clipping with Ellipsis:
html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Text Clipping Example</title>
<style>
.clipped-text {
width: 200px;
white-space: nowrap;
overflow: hidden;
text-overflow: ellipsis;
border: 1px solid #000;
}
</style>
</head>
<body>
<div class="clipped-text">
This is a very long text that will be clipped with ellipsis.
</div>
</body>
</html>
Q-Liang Barsky Algo.-The algorithm works by parameterizing the line equation and checking if the line segment is
inside, outside, or intersecting the clipping window. It uses parametric form of the line equation and compares the
parameters against the boundaries of the clipping window.
Key Concepts
• Line Equation (Parametric Form):
x=x0+t⋅(x1−x0)
y=y0+t⋅(y1−y0)
Where:
o (x0,y0) is the starting point of the line.
o (x1,y1) is the ending point of the line.
o t is a parameter between 0 and 1 that represents the points along the line segment.
• Clipping Region:The clipping region is usually a rectangle defined by its minimum and maximum coordinates,
(xmin,ymin) and (xmax,ymax).
Liang-Barsky Algorithm Steps
1. Parameterize the line:
The line is represented in parametric form, where ttt varies from 0 (start point) to 1 (end point).
2. Check for intersection:
The algorithm compares the line segment against the four sides of the clipping window: left, right, bottom, and
top.
3. Clipping Conditions: For each boundary, the line is tested using the following conditions:
o Left Boundary: xmin
o Right Boundary: xmax
o Bottom Boundary: ymin
o Top Boundary: ymax
For each of these boundaries, we check the value of t (the parameter). If ttt falls outside the [0, 1] range, the portion of
the line outside the window is discarded. If t is between 0 and 1, the line is clipped at that boundary.
4. Calculate Intersections:
For each boundary, we calculate the intersection points and update the line segment accordingly.
5. Final Results:
After applying the tests for all four boundaries, the resulting line segment (if any) is the clipped portion of the
original line.
Liang-Barsky Clipping Formula
For each of the four boundaries, we need to determine if the line intersects the boundary:
• For the left boundary (x=xmin):
t=xmin−x0---x1-x0
If t is between 0 and 1, the intersection point occurs at this value of t.
• For the right boundary (x=xmax):
t=xmax−x0---x1-x0
 • For the bottom boundary (y=ymin):
t=ymin−y0---y1-y0
• For the top boundary (y=ymax):
t=ymax−y0---y1-y0
Liang-Barsky Algorithm Pseudocode
Here is the pseudocode for the Liang-Barsky line clipping algorithm:
python
def liang_barsky_clip(x0, y0, x1, y1, xmin, ymin, xmax, ymax):
# Initialize the parameters
t0 = 0.0
t1 = 1.0
dx = x1 - x0
dy = y1 - y0

# Left boundary (x = xmin)

p = -dx
q = x0 - xmin
if p == 0 and q < 0:
return None
r=q/p
if p < 0:
if r > t1:
return None
elif r > t0:
t0 = r
elif p > 0:
if r < t0:
return None
elif r < t1:
t1 = r

# Right boundary (x = xmax)

p = dx
q = xmax - x0
if p == 0 and q < 0:
return None
r=q/p
if p < 0:
if r > t1:
return None
elif r > t0:
t0 = r
elif p > 0:
if r < t0:
return None
elif r < t1:
t1 = r

# Bottom boundary (y = ymin)

p = -dy
q = y0 - ymin
if p == 0 and q < 0:
return None
r=q/p
if p < 0:
if r > t1:
return None
elif r > t0:
t0 = r
elif p > 0:
if r < t0:
return None
elif r < t1:
t1 = r

# Top boundary (y = ymax)

p = dy
q = ymax - y0
if p == 0 and q < 0:
return None
r=q/p
if p < 0:
 if r > t1:
return None
elif r > t0:
t0 = r
elif p > 0:
if r < t0:
return None
elif r < t1:
t1 = r

# Calculate the clipped line coordinates

x0_clipped = x0 + t0 * dx
y0_clipped = y0 + t0 * dy
x1_clipped = x0 + t1 * dx
y1_clipped = y0 + t1 * dy

return (x0_clipped, y0_clipped, x1_clipped, y1_clipped)

Explanation of the Code
1. Initialization:We start by initializing the parameters t0=0 and t1=1 for the clipping range. These parameters
define the portion of the line segment that lies within the clipping window.
2. Left and Right Boundaries:The line is tested against the left and right boundaries using the parametric
equations. If the line does not intersect or if the intersection point falls outside the range [0, 1], the line is
discarded.
3. Top and Bottom Boundaries:The line is then tested against the top and bottom boundaries using similar logic.
4. Clipped Line Coordinates:If the line is not entirely outside the clipping window, the algorithm calculates the
clipped line segment's new coordinates using the parameters t0 and t1.
5. Return the Clipped Line:Finally, the clipped line's endpoints are returned.
Q-4-bit code-Each endpoint of the line segment is assigned a 4-bit code based on its position relative to the clipping
window. These bits represent whether the point is to the left, right, above, or below the clipping window. The clipping
window is usually defined by the coordinates of the lower-left corner (xmin,ymin) and the upper-right corner
(xmax,ymax).
The 4-bit code for each endpoint is calculated as follows:Bit 1 (left): Set to 1 if the point is to the left of the window
(x<xmin), otherwise set to 0.Bit 2 (right): Set to 1 if the point is to the right of the window (x>xmax), otherwise set to
0.Bit 3 (below): Set to 1 if the point is below the window (y<ymin), otherwise set to 0.Bit 4 (above): Set to 1 if the
point is above the window (y>ymax), otherwise set to 0.
Thus, a point can be represented by a 4-bit code where each bit corresponds to one of the four conditions: left, right,
below, and above.
The 4-Bit Code ExampleLet's assume we have a clipping window defined by:
• xmin=10,ymin=10
• xmax=20,ymax=20
Now, consider a point P(x,y):
1. If x=5 and y=15, the point is to the left of the window, so its 4-bit code is 1000 (left).
2. If x=25 and y=15, the point is to the right of the window, so its 4-bit code is 0100 (right).
3. If x=15 and y=5, the point is below the window, so its 4-bit code is 0010 (below).
4. If x=15 and y=25, the point is above the window, so its 4-bit code is 0001 (above).
5. If x=15 and y=15, the point is inside the window, so its 4-bit code is 0000.
Steps of the Cohen-Sutherland (4-bit code) Algorithm
1. Assign 4-bit codes: For each endpoint of the line, assign a 4-bit code using the method described above.
2. Check the region of the line:If both endpoints have a 4-bit code of 0000, the entire line is inside the clipping
window and can be accepted as is.*If the bitwise AND of the two endpoints' codes is non-zero (i.e., the
endpoints are in the same region of the clipping window), the entire line is outside the clipping window, and the
line can be rejected.*Otherwise, the line intersects the clipping window, and further clipping calculations are
needed.
3. Clipping logic:If the line intersects the clipping window, the algorithm uses the 4-bit codes to determine which
part of the line is outside the window and calculates the intersection points. The line is then subdivided into
smaller segments and rechecked.
To calculate the intersection points:*Find the intersection of the line with the appropriate window boundary (left, right,
top, or bottom).*Update the endpoint's position to this intersection point.*Reassign the 4-bit codes to the updated
endpoints and repeat the process.
4. Termination: The process continues until either the line is completely inside the clipping window or no further
intersections need to be calculated.
Algorithm DetailsLet’s break down the algorithm into steps:
1. Step 1: Assign 4-bit codes to the two endpoints of the line segment.
2. Step 2: Check if both endpoints are inside the clipping window:*If both codes are 0000, accept the line as it is
(it’s inside the window).*If the bitwise AND of the two codes is non-zero, reject the line (it’s entirely outside the
window).
3. Step 3: Otherwise, find the region that is outside the window and calculate the intersection point with the
clipping window. For example:If a point is to the left of the window (code = 1000), calculate the intersection
with the left boundary of the window (x=xmin).*If a point is to the right of the window (code = 0100), calculate
the intersection with the right boundary (x=xmax).*If a point is below the window (code = 0010), calculate the
intersection with the bottom boundary (y=ymin).*If a point is above the window (code = 0001), calculate the
intersection with the top boundary (y=ymax).
4. Step 4: Update the endpoint that is outside the window to the intersection point, and recompute the 4-bit code
for the updated endpoint.
5. Step 5: Repeat the process until both endpoints are inside the clipping window, or you determine that the line is
completely outside the window.
Example of the Cohen-Sutherland AlgorithmLet’s use a simple example to walk through the 4-bit code algorithm:
Clipping Window:
• xmin=10
• xmax=20
Line Segment:Start point P1=(5,5), End point P2=(25,25)
Step 1: Assign 4-bit codes to both endpoints:
 • P1=(5,5) → Code: 0011 (below and left)
• P2=(25,25) → Code: 0100 (right)
Step 2: The codes are not both 0000, and the bitwise AND of the codes is 0000, so the line is not entirely inside or
outside. We need to find the intersection.
• Clip the left boundary: The line intersects the left boundary at x=10, y=10.
• Update the endpoint P1=(10,10), and recalculate the 4-bit code.
o New code for P1=(10,10) → 0000 (inside).
Step 3: Now, P1 is inside the clipping window, and we only need to clip the right side of the window for P2P_2P2.
• Clip the right boundary: The line intersects the right boundary at x=20.
• Update the endpoint P2=(20,20), and recalculate the 4-bit code.
o New code for P2=(20,20) → 0000 (inside).
Now both endpoints are inside the clipping window, so the clipped line segment is from P1=(10,10)P_1 = (10, 10) to P2
=(20,20).
Q-Parallel projection is a type of projection where the projection rays are parallel to each other. The objects are
projected onto a projection plane without any perspective distortion, meaning that objects retain their shape and size
regardless of their distance from the viewer.
Characteristics:*Parallel Rays: In parallel projection, the projection rays are parallel to each other and are usually
directed along the z-axis (in 3D space).No Distortion: Objects that are farther away from the viewer appear the same
size as objects that are closer. There is no perspective scaling.Uniform Scale: The scale of objects remains consistent
regardless of depth (distance from the viewer).Object Shape: The shape of an object is preserved, and there is no
foreshortening. Parallel lines in the object will remain parallel after projection.
Types of Parallel Projections:*Orthographic Projection: This is a special case of parallel projection where the
projection rays are perpendicular to the projection plane. It is commonly used in engineering and architectural
drawings.*Oblique Projection: The projection rays are still parallel, but they are not perpendicular to the projection
plane. The object is projected at an angle, often creating a distorted image.
Example:In an orthographic projection, if you were looking at a cube, you would see all six faces as squares of equal
size, regardless of the cube’s distance from the viewer.
Applications:
• Engineering drawings
• CAD (Computer-Aided Design)
• Architectural design
• Maps

Q- Perspective Projection-Perspective projection is a type of projection where the projection rays converge at a single
point called the viewer's eye or vanishing point. This creates a sense of depth, where objects appear smaller the farther
away they are from the viewer, mimicking the way humans perceive the world.
Characteristics:*Converging Rays: In perspective projection, the rays converge toward a single point (the eye or
camera).*Depth Distortion: Objects farther from the viewer appear smaller, and objects closer appear larger. This is the
essence of perspective.*Foreshortening: Objects that are at an angle to the viewer will appear compressed or distorted
along the projection axis (depth axis).*Vanishing Point: Parallel lines that are not parallel to the viewer will appear to
converge toward a vanishing point in the distance.
Types of Perspective Projections:*One-point Perspective: All parallel lines converge to a single vanishing point on
the horizon. This is commonly used for scenes where the viewer is facing a flat surface (like a road or railroad
tracks).*Two-point Perspective: The lines converge to two different vanishing points, often used for viewing corners of
buildings or objects.*Three-point Perspective: The lines converge to three vanishing points (one on the horizon and
two above or below the horizon), creating a more dramatic view, typically for tall buildings or objects seen from a very
low or high angle.
Example:In a perspective projection of a road extending into the distance, the width of the road will appear to narrow
as it gets farther away, and the road will appear to "disappear" at a vanishing point.
Applications:
• 3D graphics rendering: Used in video games, simulations, and visual effects.
• Art and photography: To create depth and realism in drawings and photographs.
• Architecture and design: To simulate realistic views of structures.
Explanation of How They Work:
1. Parallel Projection:In parallel projection, each point of an object is projected along lines parallel to each other.
Imagine shining a light from a parallel direction onto an object and casting its shadow onto a flat surface. The
shadow's shape would be the same as the object, with no change in size due to distance.*In the case of
orthographic projection, the projection rays are perpendicular to the view plane, so the depth is entirely
removed, and all object features are displayed at their full size and proportion.
2. Perspective Projection:In perspective projection, the rays converge at a single point, much like the way light
rays enter a camera lens or how human vision works. As objects move away from the viewer, the rays that
define their size get closer together, making the object appear smaller. This creates a sense of depth and mimics
real-world viewing conditions.*This technique is essential for creating 3D views on 2D surfaces and is widely
used in computer graphics, where the simulation of depth and scale is needed to make scenes appear realistic.
Q-A vanishing point is a key concept in perspective projection used in art, photography, and 3D graphics. It is the point
in the image where parallel lines appear to converge as they recede into the distance. This phenomenon creates a sense
of depth and realism in two-dimensional representations of three-dimensional scenes.
Key Features:
1. Convergence of Parallel Lines: In perspective drawing, parallel lines that are not parallel to the viewer (e.g.,
railway tracks or the edges of a building) appear to meet at a single point on the horizon, known as the vanishing
point. The farther the lines are from the viewer, the closer they appear to converge at the vanishing point.
2. Types of Vanishing Points:*One-point Perspective: All parallel lines converge to a single vanishing point.
This is commonly used when looking at a scene head-on, such as a straight road or railway tracks.Two-point
Perspective: Two sets of parallel lines converge toward two vanishing points. This is used when viewing a
corner of an object or building.Three-point Perspective: Three sets of parallel lines converge toward three
vanishing points, often used for dramatic perspectives, such as looking up at a tall building from below.
3. Role in Depth Perception: The vanishing point is crucial for creating the illusion of depth in a 2D drawing or
image. As objects move farther from the viewer, they appear smaller and their parallel lines seem to converge
toward the vanishing point, giving the impression of distance.
Q-An interpolation spline is a type of spline that passes through every data point exactly. The curve generated by an
interpolation spline is constrained to touch all the given points, ensuring that the spline interpolates the data perfectly.
Characteristics:*Exact Fit: The curve passes through all the given data points.Error-Free at Data Points: The error
between the spline and the data points is zero at all the interpolation points.Continuous and Smooth: Typically,
interpolation splines are designed to be continuous in both the function and its derivatives, ensuring smoothness (e.g.,
the second derivative is continuous for cubic splines).Overfitting Risk: If the number of data points is large,
interpolation splines can become very "wiggly" or overfitted, especially if the data contains noise. This happens because
the spline tries to pass through every point exactly, even if the points are noisy or irregular.
Example:*Cubic Spline Interpolation: This is a popular interpolation method where a cubic polynomial is used to
interpolate between data points. It ensures that the resulting curve is smooth and continuous, with no sharp bends.
Use Cases:*Precise data modeling: When it's necessary to fit a curve that exactly passes through a given set of points,
like in interpolation of scientific measurements.*Computer Graphics: In applications where exact control over the
path is needed.
Q- Approximation Splines-An approximation spline is a type of spline where the curve does not necessarily pass
through all data points. Instead, the curve is fitted to the data in such a way that it minimizes the overall error between
the curve and the points. The goal is to find a curve that represents the "general shape" of the data rather than exactly
fitting each point.
Characteristics:*Error Minimization: The curve minimizes the error between the spline and the data points, often
using some form of least squares fitting.Smooth Fit: The spline may not pass through all points but aims to provide the
best smooth fit to the data.No Overfitting: Approximation splines are less prone to overfitting compared to
interpolation splines. This is because they allow some flexibility and can handle noisy data better by smoothing out
fluctuations.Generally Smooth: While the spline may not pass through every point, it is still designed to be smooth and
continuous.
Example:*Least Squares Approximation: A commonly used method where a spline (often a cubic or quadratic) is fit
to data by minimizing the sum of squared differences between the data points and the curve.*B-Splines: Basis splines
(B-splines) are a family of splines often used in approximation, as they provide smooth curves that do not necessarily
pass through all the points.
Q-A Bézier curve is a parametric curve used in computational graphics and design. It is defined by a set of control
points. The curve is generated using a weighted average of these points based on the parameter t, which usually ranges
from 0 to 1.
Types of Bézier Curves:
1. Linear Bézier Curve (Degree 1):
o Defined by two control points P0 and P1.
o The equation for the linear Bézier curve is: B(t)=(1−t)P0+tP1for t∈[0,1]
o This is simply a straight line between P0 and P1.
2. Quadratic Bézier Curve (Degree 2):
o Defined by three control points P0, and P2.
o The equation for the quadratic Bézier curve is: B(t)=(1−t)2P0+2(1−t)tP1+t2P2fort∈[0,1]
o This creates a smooth curve that starts at P0P_0P0, passes near P1, and ends at P2.
3. Cubic Bézier Curve (Degree 3):
o Defined by four control points P0, P1, P2, and P3.
o The equation for the cubic Bézier curve is: B(t)=(1−t)3P0+3(1−t)2tP1+3(1−t)t2P2+t3P3fort∈[0,1]
o This creates a more complex and flexible curve, widely used in applications such as animation and font
design.
Properties of Bézier Curves:
1. Starts and Ends at the First and Last Control Points: A Bézier curve always passes through its first and last
control points, i.e., B(0)=P0 and B(1)=Pn.
2. Monotonicity: The Bézier curve is contained within the convex hull of its control points. It never goes outside
the area defined by the convex hull.
3. Smoothness: Bézier curves are smooth and continuous; they do not have any sharp corners or discontinuities in
their first derivative.
4. Local Control: Moving a control point only affects the shape of the curve locally, making it easy to modify the
curve interactively.
 5. Parameterization: The parameter t moves along the curve from 0 to 1, providing a continuous flow from the
start to the end.
Applications:Graphics and Animation: Used to define paths, motions, and transitions.Font Design: To describe the
shapes of characters in digital fonts.CAD and CAM: To define curves and paths in design software.
Q-Bézier Surfaces- is a two-dimensional surface generated by extending the concept of Bézier curves into two
parameters (usually denoted as uuu and vvv). A Bézier surface is defined by a grid of control points arranged in a matrix
(a rectangular array).*A Bézier surface is defined by a set of control points Pi,jP_{i,j}Pi,j, where iii and j represent the
indices in the 2D grid. The surface is created by blending these control points in a similar manner to Bézier curves.
where u and v are parameters ranging from 0 to 1.
For higher-degree surfaces, the equation becomes more complex, and the degree of the surface in both the u- and
v-directions increases.
Properties of Bézier Surfaces:
1. Bounded by Control Points: Like Bézier curves, Bézier surfaces are bounded by the convex hull of their
control points. This means the surface will always lie within the convex hull formed by the control points.
2. Local Control: Moving a single control point will affect the shape of the surface locally, just like Bézier curves.
This allows easy modification of the surface.
3. Smoothness: Bézier surfaces are continuous and smooth, with no abrupt changes or breaks in the surface.
4. Continuity: The surface is continuous across the entire surface, and its partial derivatives (in both uuu and vvv
directions) are continuous as well, making the surface smooth.
Types Bilinear Bézier Surface: Defined by four control points (degree 1 in both u and v).*Bicubic Bézier Surface:
Defined by 16 control points (degree 3 in both u and v), commonly used in practice for smooth surfaces.
Applications:Surface Modeling: Bézier surfaces are widely used in 3D modeling to define smooth surfaces, such as
the surfaces of cars, characters, and objects.CAD Systems: Used to model complex surfaces in industrial design and
architectural modeling.Animation: To create smooth transitions between surfaces in computer-generated imagery (CGI)
and 3D animation.
Q-Hidden Surface Elimination (HSE) is a critical concept in computer graphics and 3D rendering that addresses the
challenge of determining which surfaces or parts of surfaces are visible to the viewer and which are obscured by other
objects. In a 3D scene, objects may overlap, and surfaces that are further away from the viewer might be hidden behind
closer objects. HSE algorithms are used to remove or "hide" these non-visible surfaces, ensuring that only the visible
parts of a scene are rendered.
The goal of HSE is to correctly determine the visibility of each surface based on its relative position to other surfaces in
the scene. This is important for creating realistic images because it prevents objects that are "behind" others from being
drawn, which would create visual artifacts.
Key Concepts of Hidden Surface Elimination:
1. Depth Information: The depth of an object refers to its distance from the viewer. Surfaces that are closer to the
viewer obscure surfaces that are farther away.
2. Visibility Determination: The process of determining which surfaces should be rendered based on their
visibility relative to other surfaces.
3. Z-buffering: A commonly used technique for HSE that maintains a depth value for each pixel to track which
surfaces are closest to the viewer.
Methods of Hidden Surface EliminationThere are several algorithms and techniques used to perform hidden surface
elimination, with the most common ones being:
1. Z-Buffer Algorithm (Depth Buffer Algorithm)The Z-buffering technique is one of the most widely used methods
for hidden surface elimination in rasterization (the process of converting 3D models into 2D images). It works by
comparing the depth of each pixel that needs to be rendered.
How Z-buffering Works:A buffer (called the Z-buffer) is maintained for each pixel in the image, where each entry
corresponds to the depth of the closest object at that pixel's position.*For every new pixel being rendered, the depth of
the new object at that pixel is compared to the depth already stored in the Z-buffer.*If the new depth is closer (i.e.,
smaller), the pixel is updated with the new object’s color, and the Z-buffer is updated with the new depth.*If the new
depth is farther away (i.e., larger), the pixel is not updated.*This technique ensures that only the nearest surface is
visible, and all hidden surfaces are discarded.
Advantages :Simple and efficient: It is relatively easy to implement and does not require sorting of objects.Works
with complex scenes: It can handle both solid objects and transparent surfaces in a single pass.
Disadvantages *Memory usage: The Z-buffer requires additional memory for depth values (typically one depth value
per pixel).Artifacts: Z-buffering can suffer from precision issues, especially in scenes with large depth ranges (leading
to depth fighting or z-fighting).