學習: Interviewing Graphics Programmers

前陣子在 LinkedIn 上看到一篇好文章，介紹如何準備 Computer Graphics Programming 的面試 (以面試官的角度，但也適合給求職者角度)。想好好記錄一下從該文學到的筆記。

Interviewing Graphics Programmers

Graphics programmers大致可以分成以下 4 個類型 (非絕對)

• RHI programmer
• Tools and asset pipeline programmer
• Technique specialist
• Generalist

以下我試著搜尋資訊外也利用 AI 工具協助給我一些問題解答。接下來的內容當我寫到 to be added (待補充) 代表該問題/文章段落所談專業領域是我本人尚不熟悉的部分，等待未來有機會進一步學習後補充。

O3DE: Render Hardware Interface Overview

RHI Programmer

RHI (Render Hardware Interface) 從 O3DE 官方說明其為圖形繪圖 API 之抽象實現層，為上層遊戲開發(或遊戲引擎開發)提供跨硬體 GPU / 繪圖 API 之統一底層實現。文中提出主要問題：

1. Describe the different ways one could expose buffer data to a shader, and their pros and cons.

• [1] Uniform Buffers: These are read-only buffers that can be used to pass a small amount of data to shaders. They are easy to use and efficient for small amounts of data, but they have size limitations.
• [2] Shader Storage Buffers: These buffers can be read and written in a shader. They are more flexible than uniform buffers and can handle larger amounts of data, but they may be slower due to the need for synchronization.
• [3] Texture Buffers: These are essentially 1D texture data (array) that can be used to pass large amounts of data to a shader. They can be faster than shader storage buffers for read-only data, but they have limitations on the data types they can handle. Accessed via integer index, not supporting texture filtering and mipmapping.
• [4] Push Constants: These are a way to pass a very small amount of data to shaders (via command in command buffer). They are extremely fast, but they have very strict size limitations.
• [5] Images and Samplers: These are used to pass texture data (1D/2D/3D/Cube) to shaders. They allow for filtering, mipmapping and other operations that are not possible with the other buffer types.

2. What is typically meant by the term “texture layout” (aka “image layout”) and why is it significant?

Texture/Image layout describes how the data in a texture is organized in memory. The layout can have a significant impact on performance, as different layouts can be optimized for different types of access patterns. For example, in Vulkan: VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL | VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL | VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL | VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL.

3.What are some memory hazards you can think of that a good renderer would avoid?

Read-after-write/write-after-read (rendering operation is writing to a buffer which a shader is reading from); write-after-write hazards (multiple rendering operations write to the same pixel in render target concurrently). In Vulkan, can use a VKImageMemoryBarrier to ensure that a texture is not read from until all writes to it have completed.
To be added …

4. What is a “descriptor” and what are some strategies you’ve seen for managing them?

A descriptor is a data structure that provides the GPU with the information it needs to access a resource, such as a buffer or a texture (ex: to be accessed by shaders).
To manage descriptor sets, consider:

• (1) Descriptor set pooling
• (2) A single dynamic uniform buffer to work with single descriptor set;
• (3) Group descriptor set layouts
• (4) Update descriptor sets in batches
• (5) Push constants for small data transfer instead.

To be added …

5. What is a “pipeline state object” and what are some strategies you’ve seen for managing them?

Pipeline State Object (PSO) encapsulates all of the state required to execute a draw call, including the shaders to use, the format of the input data, how vertices are rasterized, how fragments are blended, and so on.
To manager PSO, consider:

• (1) Pre-creation/Lazy-creation and caching PSO
• (2) Handle PSO misses, execute drall call with fallback PSO to avoid creating new
• (3) Reduce PSO (states) complexity
• (4) Sort draw calls by PSO.

To be added …

6. Suppose you are told that the game hitches poorly at a particular point in the level. Can you describe your approach to diagnosing the issue?

The most reliable way to diagnose game hitches is profiling. All possible causes from CPU-side to GPU-side should be considered.
Suggest to check:

• (1) If specific gameplay senario? timing? to narrow down problem
• (2) Examine CPU workloads about assets loading, memory allocation and garbage collection, physics/gameplay computation cost, …
• (3) Examine GPU workloads about draw calls count, memory bandwidth (from meshes, textures), rendering complexity (expensive shader computation)
• (4) Level of detail.

更進階的專家問題 (待進一步學習)：

1. Texture Streaming System
2. Render graph architecture and automatic barrier placement
3. Shader compiltion pipeline
4. Swapchains and frame pacing
5. Reduce input latency
6. Instrumentation for diagnosing Timeout Detection and Recovery (TDRs)

Tools and Assets Pipeline

主旨在開發輔助工具用以協助(技術)美術同仁在美術(素材)製程上的各式各樣需求。

Technique Specialist

作者列舉出幾個非常專業的 Graphics / Rendering 技術工作，面談過程中作者重視幾個重點：[1] 為什麼這是困難的？[2] 目前的工作單位如何解決該問題？[3] 舉出常見的解決方案。

1. Volumetric Rendering

Illustrates depth of volume representing certain media by simulating the absorption and scattering of light through the media. Volume data is a 3D grid of voxels. Volumetric rendering traces all rays through volume to calculate the contribution of each voxel along the ray to final image (also called ray marching).
Chanllenges: It is computationally intensive. And huge volume data requires a lot of memory.
Optimizations:

• (1) Consider lower resolution of volume data, to reduce memory assumption and ray marching calculation
• (2) Implement depth pre-pass can help early termination. When ray accumulated (fog) intensity reach limit or the ray already hit occluded surface, it should stop marching early
• (3) GPU accelerated (compute/fragment) shader to process ray-marching in parallel
• (4) Froxelization: divide view frustom into froxels (frustom voxel) to calcualte the (fog) densities, and re-use density for pixels within the froxel
• (5) Re-use results of previous frame with cost of potential artifacts.

2. Terrain

Typically terrain is generated from height map representing its landscape. An open world game require a very very large scale of terrain, meaning developers have to deal with huge terrain (height) data and performance of rendering lots of terrain triangles while present very detailed terrain up close at the same time.
Optimizations:

• (1) Level of detail (LOD), rendering detailed geometry up close and simplified geometry (fewer triangles) in distant view
• (2) Frustum culling / occlusion culling, avoid rendering triangles not in current view (or cannot be seen)
• (3) Divide the (open) world (into grids partition) and streaming necessary terrain data into memory for terrain processing only if required (for current and neighbor grids)
• (4) For artistic editing requirements, editor tools (sculpt brush) and splat-map shaders to enhance realistic terrain details (splat map’s RGBA channels decide the final detail blending result).

3. Atmospheric Effect

To me atmospheric effect often means rendering involves atmospheric scattering.
To list techniques related to atmospheric effect:

• (1) Fog: often implemented as a simple distance-based effect, where more obscured the further from the camera. More advanced techniques might use volumetric fog
• (2) Sky Color: sky color changes based on the time of day and weather conditions. This can be simulated using a skybox (a large cube that surrounds the scene) with a texture that changes over time, or a more complex procedural atmospheric scattering model
• (3) Clouds: from simple 2D billboarded textures, to volumetric rendering techniques that simulate the complex light scattering within a cloud
• (4) Haze: haze or atmospheric scattering can be simulated using a technique called Rayleigh scattering, which models how light is scattered by particles in the atmosphere
• (5) God Rays: beams of sunlight that appear when the sun is obscured by objects. They can be simulated using volumetric light scattering.

4. Particles

Particle system can be said is the fundamental and the most important part for VFX (fire/projectile/dust/droplets/bubble/…) in game.
The following describe overview:

• (1) Particle Systems: a collection of many individual particles that act together as a group. The behavior of the particles is controlled by the system’s parameters, such as emission rate, lifetime, velocity, and color over time
• (2) Emitter: determines where and when new particles are created. Emitters can have various shapes like point, line, circle, or even a mesh
• (3) Particle Behavior: each particle can have its own behavior, defined by factors like speed, direction, color, size, and lifespan. These behaviors can be influenced by forces like gravity or wind
• (4) Rendering: can be rendered as simple 2D sprites/billboards, or as 3D objects. Use different blending modes to create different visual effects
• (5) Optimization: performance-intensive, so techniques like culling off-screen particles, limiting the maximum number of particles, and using simpler rendering techniques (LOD of shaders and fewer animated frame rate) for distant particles.

5. Anti-Aliasing

Anti-aliasing (AA) is for solving jagged artifacts (aliasing). Common AA techniqies:

• [1] Multisample Anti-Aliasing (MSAA): a common technique that works by taking multiple samples per pixel, then averaging the color of the pixel based on the samples. It provides a good balance between performance and quality, while it requires more memory and GPU processing power.
  GPU steps:

(1). Sample Generation: For each pixel the GPU generates multiple sub-pixel samples. The number of samples is determined by the level of MSAA being used (2x, 4x, 8x, etc.)
(2). Sample Testing: Each sample is tested for coverage (whether it's inside a polygon), depth (how far it is from the camera), and stencil values
(3). Sample Shading: One or more of the samples are shaded to determine their color. In traditional MSAA, only one sample is shaded and that color is used for all samples. In more advanced forms of MSAA, like NVIDIA's Coverage Sample Anti-Aliasing (CSAA), more samples can be shaded
(4). Sample Combination: The colors of the samples are combined to produce the final color of the pixel. This is typically done by averaging the colors, but other methods can be used as well.

• [3] Fast Approximate Anti-Aliasing (FXAA): post-processing technique that smooths edges in the final image. It’s fast and easy to implement, but can make the image look blurry.
• [4] Temporal Anti-Aliasing (TAA): uses information from previous frames to smooth edges in the current frame. It can produce high-quality results, but can also introduce ghosting artifacts.
• [5] Subpixel Morphological Anti-Aliasing (SMAA): combines approaches starting by a morphological technique to detect edges where aliasing is likely to occur; calculates ablending weight for each edge based on local pixel patterns; finally blending pixels with calculated weights along edges.

Talk more about NVIDIA DLSS (Deep Learning Super Sampling): is an AI-powered technology uses AI to upscale lower-resolution images in real-time, providing images that look as good as native high-resolution rendering, but with a lower performance cost.
How does it work:

• (1) Training: NVIDIA trains a neural network model on high-resolution, anti-aliased images of a game. The model learns how to predict high-resolution, anti-aliased images from lower-resolution ones
• (2) Inference: During gameplay, the game renders at a lower resolution, then the DLSS model upscales the image to a higher resolution. This is done on the Tensor Cores of NVIDIA’s RTX series GPUs, which are designed for AI computations
• (3) Temporal Feedback: DLSS also uses information from previous frames to improve the quality of the current frame.

6. Shadows

The most important technique to develop real-time shadow is shadow mapping. The idea is to render the scene from the light’s perspective, creating depth-map representing a “shadow map”. Then, when rendering the scene from the camera’s perspective, the shadow map is used to determine if each pixel is in shadow or not (target pixel’s depth is behind the shadow maps’ depth or not).
Several shadow mapping improvement techniques are created:

• [1] Percentage-Closer Filtering (PCF): takes multiple samples from the shadow map around the pixel being rendered, and averaging the results to soften the edges of shadows, making them look more realistic.
• [2] Cascaded Shadow Maps (CSM): an extension of shadow mapping used for directional lights (like the sun). The idea is to use multiple shadow maps with different resolutions, allowing for high-resolution shadows near the camera and lower-resolution shadows further away. This way improves shadow quality a lot far away from camera while maintains very detailed shadow quality up close.
• [3] Variance Shadow Maps (VSM): an extension method for faster and more accurate filtering to generate realistic soft shadow.
  Overview:

(1) Shadow Map Generation: starts by rendering a shadow map from the light’s perspective. However, instead of storing just the depth value for each pixel, VSM stores two values: the depth, and the square of the depth.
(2) Shadow Map Filtering: the shadow map is then blurred using a Gaussian filter or similar. Because we have stored the depth and square of the depth, we can do this blurring operation in a way that preserves the distribution of depths within each pixel, which is not possible with traditional shadow mapping.
(3) Shadow Testing: rendering the scene from the camera’s perspective, instead of a simple binary test, VSM uses the stored depth and square of depth to calculate a “shadow probability” that gives a soft transition from light to shadow.

Advantage: allows for efficient hardware filtering, which can produce high-quality soft shadows with good performance.
Disadvantage: also suffer from a problem known as “light bleeding”, where shadows from one object incorrectly affect other objects. Various techniques have been proposed to mitigate this issue, such as using a higher precision shadow map or applying a bias to the depth values.

Besides shadow mapping, the following are also techniques to render shadows:

• Screen Space Shadows: renders shadows directly in screen space using generated depth buffer during rendering.
  Overview:

(1) Depth Buffer: After the scene is rendered, the depth buffer contains the distance from the camera to every pixel in the scene.
(2) Shadow Casting: For each pixel in the scene, a ray is traced in the direction of the light source. If the ray intersects another object (i.e., if there's a closer pixel in the direction of the light), then the original pixel is in shadow.
(3) Shadow Rendering: The shadow information is then used to darken the appropriate pixels in the final image.

Advantage: able to produce very detailed shadows, since they operate directly on the rendered pixels.
Disadvantage: can only cast shadows from visible objects in view, since they rely on the depth buffer which only contains information about visible objects. This means they can’t cast shadows from off-screen objects.

• Ray Tracing Shadows: with the advent of real-time ray tracing in modern GPUs, shadows can be rendered by tracing rays from the light source. This can produce very realistic shadows, including accurate soft shadows and shadows from transparent objects.
• Shadow Volume: an (old) method to work with stencil buffer to generate hard-edged shadows, but very performance intensive.
  Overview:

(1) Shadow Volume Generation: for each light source and each object in the scene, a “shadow volume” is created. This is a 3D shape that extends from the object in the direction of the light. Any point inside this volume is in shadow.
(2) Stencil Buffer Operations: shadow volumes (shapes) are then rendered into the stencil buffer, to mask out shadow parts of the scene. When rendering a shadow volume, the stencil value is incremented for each front face of the volume that is drawn, and decremented for each back face. This results in a stencil buffer where the value is non-zero for pixels that are in shadow.
(3) Scene Rendering: rendering the scene from the camera’s perspective. For each pixel, If the stencil value is non-zero, the pixel is in shadow and is drawn darker. If the stencil value is zero, the pixel is lit normally.

7. Color Treatment

To talk about techniques referring to alter/correct color result, including:

• [1] Color Correction: adjusting the brightness, contrast, saturation, and color balance of the image.
• [2] Color Grading: A more artistic form of color correction, used to give an image a particular “look” or “mood”. Adjusts color based on the specified LUT texture.
• [3] Gamma Correction: adjusting the brightness of an image to account for the non-linear way in which human eyes perceive light. This is often necessary when displaying an image on a digital screen.
• [4] High Dynamic Range (HDR) Rendering: rendering an image that includes a wider range of brightness levels than can be displayed on a standard screen (using HDR-format texture). This can create a more realistic image, but requires special techniques, tone mapping to adjust the result image in a post processsing stage.

8. Global Illumiation

To my knowledge, I’ll describe how Unity engine provides global illumination (GI) rendering features.

• Real-time GI: Unity’s real-time GI updates the lighting in your scene as changes occur, which is useful for dynamic scenes with moving lights or objects. It uses a technique called Enlighten to calculate the indirect lighting in the scene.
• Baked GI: For static scenes, Unity can precompute the GI and store it in lightmaps, which are textures that store the lighting information. This can provide high-quality lighting with less runtime cost. Unity uses a lightmapper (either Enlighten or Progressive Lightmapper) to calculate the lightmaps.
• Mixed GI: Unity also supports a mixed mode, where direct lighting is real-time but indirect lighting is baked into lightmaps. This can be a good compromise between quality and performance.
• Light Probes: For dynamic objects that can’t use lightmaps, Unity provides light probes, which store the lighting information at various points in the scene. The lighting for the dynamic objects is then interpolated from the nearest light probes.
• Reflection Probes and Environment Lighting: Unity also provides tools for capturing and using reflected light, which is an important part of GI.

To be added …

Generalist

考慮到通用人才，面談過程可能會問的問題範圍較廣：

1. What happens when you sample a texture in a shader?

At first, you need to prepare texture data in video memory. Follow these steps:

• (1) Create texture object with necessary resolution and format decided.
• (2) Upload texture data (using API like glTexImage2D in OpenGL or CreateTexture2D in DirectX).
• (3) Texture Binding: the texture needs to be bound to a specific texture unit so that it can be accessed by the shader (using API like glActiveTexture and glBindTexture in OpenGL).
• (4) Sampler Uniform: In the shader, a uniform variable of a sampler type (like sampler2D in GLSL) is used to access the texture. The location of this uniform is set to the index of the texture unit to which the texture was bound.

Texture Sampling: Finally, in the shader, a function like texture (in GLSL) or Texture2D.Sample (in HLSL) is used to sample the texture. The process involves:

• (1) Texture Coordinates: specifies where in the texture you want to sample, with texture coordinates, also known as UV coordinates.
• (2) Interpolation: if the texture coordinates don’t correspond exactly to a pixel in the texture, the GPU will interpolate the color from the nearest pixels. Bilinear filtering uses the four nearest pixels to calculate the color, while trilinear filtering also takes into account mipmap levels.
• (3) Mipmapping: if mipmaps are used, the GPU will select the appropriate mipmap level based on the distance and angle of the surface to the camera. Mipmaps are smaller versions of the texture that are used to avoid aliasing when the texture is viewed from a distance or at a steep angle.
• (4) Wrapping: if the texture coordinates are outside the range of 0 to 1, the GPU will handle this according to the texture’s wrap mode, including clamped to the range 0 to 1, or repeat mode, the texture is tiled.

2. Given two spheres, determine if they intersect

If distance < (S1-radius + S2-radius)
  then S1 & S2 are intersected

// To improve performance if presume distance between is not too large,
// square root calculation for distance can be avoided using comparison
If squared-distance < (S1-radius + S2-radius)²
  then S1 & S2 are intersected

3. What is meant by shader occupancy, and what affects occupancy?

Shader occupancy is a measure of how efficiently a GPU is being utilized when running a shader program. It refers to the number of active threads (or warps/wavefronts) per multiprocessor relative to the maximum number of threads that the multiprocessor can support. High occupancy does not guarantee maximum performance, but low occupancy can limit performance.
Factors affect shader occupancy:

• (1) Register Usage: each thread running a shader requires a certain number of registers. If a shader uses many registers, fewer threads can run concurrently, reducing occupancy.
• (2) Shared Memory Usage: if a shader uses a lot of shared memory, fewer threads can run concurrently.
• (3) Thread Divergence: GPUs execute threads in groups (warps in CUDA, wavefronts in AMD). If threads within a group take different execution paths due to conditional statements, the GPU has to execute each path separately, reducing effective occupancy.
• (4) Number of Threads per Block: number of threads in a block (or work group), if too low, the GPU may not be able to fully utilize its resources.
• (5) Hardware Limitations: different GPUs have different numbers of multiprocessors, registers, shared memory, and maximum thread counts.

To be added …

4. Author a shader that produces a checkerboard pattern

// GLSL
void main() 
{
    // Calculate the position of the current fragment in texture coordinates (0.0 to 1.0)
    vec2 position = gl_FragCoord.xy / u_resolution.xy;
    // Scale the position to get a checkerboard pattern
    vec2 checkPosition = floor(position * 8.0);
    // Calculate the color based on the position
    float checkColor = mod(checkPosition.x + checkPosition.y, 2.0);
    // Output the color
    gl_FragColor = vec4(vec3(checkColor), 1.0);
}

////////////////////////////////////////////////////////////////////
// HLSL
float4 main(float2 uv : TEXCOORD0) : SV_TARGET
{
    // Scale the UV coordinates to get a checkerboard pattern
    float2 checkPosition = floor(uv * 8.0f);
    // Calculate the color based on the position
    float checkColor = fmod(checkPosition.x + checkPosition.y, 2.0f);
    // Output the color
    return float4(checkColor, checkColor, checkColor, 1.0f);
}

5. What is a BxDF and what are some requirements for a function to be a valid BxDF?

A BxDF, or Bidirectional Scattering Distribution Function, is a function that defines how light is scattered when it hits a surface in computer graphics. It’s a fundamental concept in physically based rendering (PBR).
The BxDF takes an incoming light direction and an outgoing direction (both relative to the surface normal), and returns the ratio of reflected radiance along the outgoing direction to the incident irradiance from the incoming direction. There are several types of BxDFs, each representing a different type of surface behavior:

• [1] BRDF (Bidirectional Reflectance Distribution Function): This is the most common type of BxDF. It defines how light is reflected off a surface.
• [2] BTDF (Bidirectional Transmittance Distribution Function): This type of BxDF is used for transparent materials and defines how light is transmitted through a surface.
• [3] BSDF (Bidirectional Scattering Distribution Function): This is a general term that can refer to either a BRDF, a BTDF, or a combination of both.

To implement a valid BxDF rendering function, the following points should be satisfied (though to improve performance or achieve a particular visual effect, many use approximations or simplifications):

• (1) Positivity: the BxDF should never return a negative value. Physically, this means that a surface cannot remove light.
• (2) Hemispherical Symmetry: the BxDF should be symmetric with respect to the incoming and outgoing directions. This means that swapping the incoming and outgoing directions should not change the value of the BxDF. This property is also known as Helmholtz reciprocity.
• (3) Energy Conservation: the total amount of light scattered by the BxDF should not exceed the amount of light incident on the surface. In other words, a surface cannot reflect more light than it receives.
• (4) Normalization: When integrated over the entire hemisphere, the BxDF should equal 1. This ensures that the average reflectance of a surface is properly represented.

To be added …

6. Is branching on a GPU slow? If it depends, what does it depend on?

Originally GPU is not designed to handle branching, therefore it will have lower performance when dealing with branching. But for modern GPU, it depends on several factors:

• (1) Divergence: threads in groups (known as warps in CUDA or wavefronts in AMD’s terminology), if all threads in a group take the same branch, the cost is relatively low. If threads take different branches (a situation known as divergence), the GPU must execute each branch separately, which can significantly reduce performance.
• (2) Branch Predictability: some GPU architectures have limited branch prediction capabilities. If a branch is predictable (i.e., it usually goes one way), the cost can be relatively low. However, unpredictable branches can cause stalls and reduce performance.
• (3) Depth of Branching: nested branches can also reduce performance, as they increase the complexity of the control flow and can lead to more divergence.
• (4) Workload Balance: a branch causes some threads to do significantly more work than others, it can lead to imbalanced workloads and underutilization of the GPU.

7. What is a “Moiré pattern” and why might it show up?

A Moiré pattern is a type of interference pattern that is created when two or more sets of lines or grids are overlaid at an angle, or when they have slightly different mesh sizes. These patterns appear as waves or ripples and can change appearance with the relative position of the overlaid patterns. In computer graphics, Moiré patterns can occur unintentionally due to aliasing, when a high-frequency pattern (like a fine grid or a herringbone texture) is under-sampled. This can happen when the pattern is displayed at a size or resolution that is too low to represent its detail correctly.
To be added …

8. Why is a z-prepass useful? When would it not be useful?

Z-prepass renders the depth information (Z-buffer) before the actual rendering pass. It is useful for reasons:

• (1) Early-Z rejection: the GPU can perform an early depth test and potentially skip the fragment shader for pixels that are occluded by other geometry. This can significantly reduce the fragment shader workload and improve performance, especially in scenes with high depth complexity; Overdraw reduction: ensuring that only the front-most geometry contributes to the final image.
• (2) Consistent Z-buffer: in some cases, a Z-prepass can help ensure a consistent Z-buffer, which can be important for techniques that rely on accurate depth information, such as deferred shading or shadow mapping.

There are situations where it might not be useful or could even negatively impact performance:

• (1) Low Depth Complexity: where there is little to no overlap of objects from the camera’s perspective (low depth complexity). If there’s little occlusion, the benefit is minimal.
• (2) High Vertex Processing Cost: Z-prepass requires an extra pass over all the geometry to generate the depth buffer. If the vertex processing cost is high (complex vertex shaders, high polygon count), this extra pass can be expensive.
• (3) Bandwidth Limitations: updating the depth buffer in a Z-prepass can increase memory bandwidth usage, which can be a bottleneck on some hardware.
• (4) Deferred Shading: all the material properties are calculated and stored in a G-buffer in a single pass. Since the depth information is calculated in this pass, a separate Z-prepass might not provide additional benefits.
• (5) Alpha-Tested or Transparent Geometry: Z-prepass is typically used with opaque geometry. For alpha-tested or transparent geometry, the depth cannot be determined in a prepass.
• (6) State Changes: the extra pass from a Z-prepass could introduce additional state changes and reduce performance.

9. What is “gamma”?

Most display devices (monitors, TVs) have a non-linear response to the input (color) signal, so to compensate, gamma color space refers to non-linear relationship between a pixel’s numerical value and its actual luminance. Gamma correction is to optimize the usage of bits when encoding an image by making the quantization levels perceptually uniform. Without gamma correction, the encoded luminance would be disproportionately allocated to the brighter areas of an image, which could lead to visible banding artifacts in the darker areas. For rendering, the process calculates (ex: blending) in a linear color space and then converts the final result to a gamma color space for display.
Here are (GLSL) shader snippets demonstrate simple gamma correction:

// Gamma Correction in a Fragment Shader
// Assume 'color' is the linear color output from your shader calculations
vec3 linearColor = color;
// Apply gamma correction (assuming a gamma of 2.2)
vec3 gamma = vec3(1.0 / 2.2);
vec3 correctedColor = pow(linearColor, gamma);
// Output the gamma corrected color
gl_FragColor = vec4(correctedColor, 1.0);

// Gamma Decoding (Inverse Gamma Correction) in a Fragment Shader
// Assume 'color' is the gamma corrected color input (e.g., from a texture)
vec3 gammaCorrectedColor = color;
// Apply inverse gamma correction (assuming a gamma of 2.2)
vec3 gamma = vec3(2.2);
vec3 linearColor = pow(gammaCorrectedColor, gamma);
// Now 'linearColor' can be used in shader calculations

10. Your “hello triangle” fails to produce a triangle. What are some problems you’d anticipate?

To me it is a whole rendering pipeline problem to watch. From mesh data, transformation, camera projection, material/shader, to render pass and destination render texture/frame buffer to debug with. Let’s check it out one-by-one:

• [1] Mesh & transformation & camera projection: Examine whether it is a valid triangle mesh (make sure not de-generated one) and analyze the exact vertex attributes in the vertex buffer. Calculate the actual Model-View-Projection (MVP) transformation used to render this triangle to determine if it is culled by the camera. Additionally, be mindful of Z-buffer precision. Even on PC/console platforms, an extremely large-scale far clipping distance can sometimes cause the depth buffer to lack sufficient numerical precision for comparing depths near the near/far clipping planes.
• [2] Material/Shader: Examine the material parameters that influence the shader’s final result calculation. Are there any incorrect vertex position calculations, perhaps for vertex offset or animation purposes? Are the final fragment colors, calculated according to the blend mode/equations (considering texture mapping), visible? Ensure they are not fully transparent. Also, verify if front/back face culling, and the depth/stencil buffer comparison state settings are functioning correctly.
• [3] Render pass/Render texture/Frame buffer: Even if it is successfully drawn, there are still aspects that need validation. What are the render passes involved in rendering that triangle within the frame? Ensure it is not obscured or that the entire screen isn’t cleared immediately after drawn. Also, verify if the triangle is rendered onto the correct render texture/frame buffer (eventually displayed on screen).

11. What makes a GPU fast? What are some tradeoffs made in achieving that acceleration?

A GPU’s speed is influenced by several factors:

• Core Count: GPUs have a high number of cores designed for parallel processing, which is ideal for tasks like rendering graphics and performing computations on large datasets.
• Clock Speed: The clock speed of a GPU, measured in MHz, also contributes to its speed. A higher clock speed means more operations can be performed per second.
• Memory: GPUs have their own dedicated high-speed memory (VRAM, ex: GDDR6X), which allows for faster data processing.
• Hardware Specialization: GPUs have specialized hardware for tasks such as texture mapping, interpolation, and depth testing to be efficiently as fast as possible.
• Pipelining: GPUs use a technique called pipelining to overlap the execution of instructions, which can significantly increase throughput

Of course, there are trade-offs:

• Power Consumption: High-speed GPUs can consume a lot of power, which can lead to increased energy costs and heat generation.
• Size and Cooling: Powerful GPUs often require more space and better cooling, which can limit their use in smaller or more compact systems.
• Application Compatibility: Some applications may not be optimized to take full advantage of a GPU’s capabilities, leading to underutilization.
• Complexity: Programming for GPUs can be more complex due to the need to parallelize tasks, manage memory, and deal with hardware-specific issues.
• Latency: While GPUs are great at processing large blocks of data quickly (high throughput), they typically have higher latency than CPUs for individual tasks.