World Coordinates

The mathematical coordinate space where the scene is defined.

Orthographic 2D Projection

Shows 2D graphics without making faraway objects look smaller. It keeps everything the same size regardless of depth.

Window

A selected rectangular region of the world space to be displayed.

Viewport

The sub-region of the screen/display where the window is mapped.

Screen Coordinates

The actual physical pixels on the device monitor.

Window-to-Viewport Mapping

To convert a point (x, y) in the world window to a point (sx, sy) in the screen viewport, we use proportional mapping:

Where W = Window, V = Viewport, L=Left, R=Right, T=Top, B=Bottom.

OpenGL Implementation

In OpenGL, the coordinate system origin (0,0) is natively at the lower-left corner. Setting up the mapping requires three tasks:

1. Define World Window: gluOrtho2D(left, right, bottom, top); (preceded by glMatrixMode(GL_PROJECTION); glLoadIdentity();)
2. Define Viewport: glViewport(left, bottom, width, height);
3. Draw: Execute glBegin() and glEnd() calls which are then automatically mapped.

How it Works

DDA uses floating-point arithmetic to calculate the next pixel on a line by incrementally adding the slope to either x or y. It relies on two key mathematical functions:

• Floor Function: Converts real values into integers (e.g., +8.5 to 8, -8.5 to -9).
• Sign Function: Returns +1, 0, or -1 depending on whether the argument is >0, =0, or <0.

• Compute dx = x2 - x1 and dy = y2 - y1
• steps = max(|dx|, |dy|)
• xInc = dx / steps, yInc = dy / steps

Characteristics

Advantages:

• Simplest algorithm, no special skills required.
• Faster than directly using the standard line equation.

Disadvantages:

• Orientation dependence makes end point accuracy poor.
• Time-consuming floating-point arithmetic.
• Precision errors shift calculated points on long lines.

Decision Parameter

Bresenham's algorithm uses a decision parameter P to choose between the East (E) or North-East (NE) pixel.

• Initial P₀: 2dy - dx
• If P < 0: Choose E pixel. P_{k+1} = P_k + 2dy
• If P ≥ 0: Choose NE pixel. P_{k+1} = P_k + 2dy - 2dx

Solved Example: (2, 5) to (10, 8)

dy = 3, dx = 8, 2dy = 6, 2dx = 16
Initial P₀ = -2

Since P₀ < 0 → P₁ = -2 + 6 = 4. Pixel: (3, 5)

DDA vs Bresenham

Common Clipping Strategies

• Check every point: Correct but slow.
• Clip coordinates directly: Not accurate.
• Compute intersections with boundaries: The correct method (used in Cohen-Sutherland).

Outcodes

Every point is assigned a 4-bit binary code (TBRL) indicating its position relative to the clipping window (Top, Bottom, Right, Left).

1001 | 1000 | 1010
------------------
0001 | 0000 | 0010
------------------
0101 | 0100 | 0110

Algorithm Steps

1. Compute outcodes for P1 and P2.
2. Trivially Accept: Both outcodes are 0000.
3. Trivially Reject: Logical AND of outcodes != 0000.
4. Clip: Find intersection with window boundary and repeat.

Four Cases for Each Edge

When traversing from vertex V1 to V2 against a clipping boundary:

• Inside → Inside: Add V2.
• Inside → Outside: Add Intersection (I).
• Outside → Outside: Add nothing.
• Outside → Inside: Add Intersection (I) and V2.

Algorithm Flow

The entire polygon is clipped against the Left edge, producing a new polygon. This new polygon is then clipped against the Right edge, then Top, then Bottom.

Phong Reflection Model

Combines three components to simulate light interacting with a surface:

• Ambient: Constant background light scattered everywhere. Defined by coefficients kar, kag, kab (amounts of red, green, blue reflected).
• Diffuse: Light scattered equally in all directions, representing a dull material appearance.
• Specular: Highlight from reflected light, representing a shiny appearance.

Shading Models

• Flat Shading: One normal per polygon. Blocky appearance.
• Gouraud (Smooth): Normals at vertices, interpolate colors.
• Phong Shading: Interpolate normals, compute lighting per pixel. Best quality.

UV Coordinates

Textures use a 2D coordinate system (U, V) ranging from 0.0 to 1.0. These are mapped to the (X, Y, Z) vertices of 3D geometry.

OpenGL Workflow

• glGenTextures() - Name the texture
• glBindTexture() - Bind texture to its name
• glTexParameteri() - Specify texture parameters
• glTexEnvf() - Specify application mode
• glTexImage2D() - Create the texture object
• glEnable(GL_TEXTURE_2D) - Enable texture mapping

Elements of Realism

• Geometry: High polygon counts for detail.
• Lighting: Global illumination and shadows.
• Materials: Physically Based Rendering (PBR).
• Textures: High resolution and normal mapping.

Real-Time Ray Tracing

Calculating the exact path of light rays in real-time, enabling perfect reflections and soft shadows.

AI Graphics (DLSS)

Using Deep Learning to upscale lower resolution images to high resolution in real-time without performance hits.

Digital Twins

Creating exact digital 3D replicas of physical factories, cities, or machines for monitoring and testing.

Metaverse

Interconnected virtual 3D spaces meant for social interaction, work, and entertainment.