10 Computer Graphics Interview Questions and Answers

Computer graphics is a crucial field in technology, encompassing everything from video game design and virtual reality to simulations and visual effects in movies. Mastery of computer graphics involves understanding both the theoretical foundations and practical applications, including algorithms, data structures, and rendering techniques. This field requires a blend of creativity and technical skill, making it a dynamic and challenging area of study.

This article offers a curated selection of interview questions designed to test and enhance your knowledge of computer graphics. By working through these questions, you will gain a deeper understanding of key concepts and be better prepared to demonstrate your expertise in interviews.

Computer Graphics Interview Questions and Answers

1. Explain the difference between raster and vector graphics.

Raster graphics consist of a grid of pixels, each with a specific color value, and are resolution-dependent, making them suitable for complex images like photographs. Common formats include JPEG, PNG, and GIF. Vector graphics, however, use mathematical equations to define shapes, making them resolution-independent and ideal for precise images like logos and technical drawings. Formats include SVG, EPS, and PDF.

2. Describe how the z-buffer algorithm works.

The z-buffer algorithm maintains a depth buffer to store depth information for each pixel. During rendering, it compares the depth of incoming pixels with existing values in the z-buffer. If a pixel is closer, its color and depth are updated; otherwise, it is discarded. The process involves initializing the z-buffer, computing pixel depths for each polygon, and updating the buffer as needed.

3. What are shaders, and what role do they play in rendering?

Shaders are programs running on the GPU to control rendering stages. They create visual effects and determine object drawing. Types include vertex shaders for transforming 3D to 2D coordinates, fragment shaders for pixel coloring, geometry shaders for generating new geometry, and compute shaders for general tasks. Shaders are written in languages like GLSL and HLSL.

Vertex Shader (GLSL):

#version 330 core
layout(location = 0) in vec3 aPos;
layout(location = 1) in vec3 aColor;

out vec3 ourColor;

void main()
{
    gl_Position = vec4(aPos, 1.0);
    ourColor = aColor;
}

Fragment Shader (GLSL):

#version 330 core
out vec4 FragColor;

in vec3 ourColor;

void main()
{
    FragColor = vec4(ourColor, 1.0);
}

4. Explain the concept of anti-aliasing and its importance.

Anti-aliasing reduces aliasing artifacts, such as jagged edges, by averaging pixel colors at shape boundaries. This creates smoother transitions and more natural edges. Methods include Supersampling Anti-Aliasing (SSAA), Multisample Anti-Aliasing (MSAA), and Fast Approximate Anti-Aliasing (FXAA), each varying in computational intensity and efficiency.

5. Implement a simple ray tracing algorithm to determine the intersection of a ray with a sphere.

Ray tracing simulates light interaction with objects. To find a ray-sphere intersection, solve a quadratic equation derived from the ray and sphere equations. The discriminant determines intersection nature: negative means no intersection, zero indicates tangency, and positive indicates two intersections.

Python implementation:

import numpy as np

def ray_sphere_intersection(ray_origin, ray_direction, sphere_center, sphere_radius):
    oc = ray_origin - sphere_center
    a = np.dot(ray_direction, ray_direction)
    b = 2.0 * np.dot(oc, ray_direction)
    c = np.dot(oc, oc) - sphere_radius * sphere_radius
    discriminant = b * b - 4 * a * c

    if discriminant < 0:
        return None
    else:
        t1 = (-b - np.sqrt(discriminant)) / (2.0 * a)
        t2 = (-b + np.sqrt(discriminant)) / (2.0 * a)
        return t1, t2

# Example usage
ray_origin = np.array([0, 0, 0])
ray_direction = np.array([1, 1, 1])
sphere_center = np.array([5, 5, 5])
sphere_radius = 3

intersections = ray_sphere_intersection(ray_origin, ray_direction, sphere_center, sphere_radius)
print(intersections)

6. Describe the Phong reflection model and its components.

The Phong reflection model simulates light reflection with three components: ambient reflection for constant illumination, diffuse reflection for light scattering on rough surfaces, and specular reflection for bright spots on shiny surfaces. The model combines these to calculate pixel color using a formula involving light intensities, material coefficients, and vectors for normal, light, reflection, and viewer directions.

7. Implement a function to generate a perspective projection matrix.

A perspective projection matrix creates depth illusion by transforming 3D coordinates to 2D. It includes parameters like field of view, aspect ratio, and clipping planes. Here’s a Python function to generate it:

import numpy as np

def perspective_projection_matrix(fov, aspect, near, far):
    f = 1 / np.tan(np.radians(fov) / 2)
    depth = near - far

    return np.array([
        [f / aspect, 0, 0, 0],
        [0, f, 0, 0],
        [0, 0, (far + near) / depth, (2 * far * near) / depth],
        [0, 0, -1, 0]
    ])

# Example usage
fov = 90
aspect = 16/9
near = 0.1
far = 100
matrix = perspective_projection_matrix(fov, aspect, near, far)
print(matrix)

8. Discuss the differences between forward and deferred shading.

Forward shading renders each object individually, performing lighting calculations per pixel, making it suitable for scenes with few lights. It is simple but inefficient with many lights. Deferred shading renders in multiple passes, storing geometric data in G-buffers for efficient lighting calculations, handling many lights well but with higher complexity and memory use.

9. Explain the purpose and usage of Framebuffer Objects (FBOs).

Framebuffer Objects (FBOs) enable off-screen rendering for complex effects like post-processing and shadow mapping. By rendering to an off-screen buffer, images can be manipulated before display. Here’s an OpenGL example:

// Generate and bind the framebuffer
GLuint fbo;
glGenFramebuffers(1, &fbo);
glBindFramebuffer(GL_FRAMEBUFFER, fbo);

// Create a texture to attach to the framebuffer
GLuint texture;
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);

// Check if the framebuffer is complete
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
    // Handle framebuffer not complete
}

// Render to the framebuffer
glBindFramebuffer(GL_FRAMEBUFFER, fbo);
glViewport(0, 0, width, height);
// Render your scene here

// Bind the default framebuffer
glBindFramebuffer(GL_FRAMEBUFFER, 0);

10. Explain normal mapping and how it enhances the appearance of 3D models.

Normal mapping enhances 3D models by altering surface normals to create detailed appearances without high-polygon models. A normal map, created from a high-resolution model, is applied to a lower-resolution version. It contains RGB values corresponding to normal vectors, affecting light interaction during shading.