Hey there! Since you’re focused on learning the standard, industry-adopted approaches rather than just chasing raw performance, let’s walk through your options and the go-to implementation for multiple shadow maps in deferred shading.

First, let’s validate your initial ideas, then dive into the standard approach:

Your Proposed Solutions: Pros & Cons Recap #

You’ve already nailed the tradeoffs of each option, so let’s reinforce that:

• Option 1: Simple to implement, but feels like heavy matrix math per pixel. However, this is actually the foundation of the standard approach—we just optimize it to keep performance in check.
• Option 2: Reduces per-pixel matrix work, but bloats your G-buffer dramatically. Storing light-space positions for every light eats up valuable texture bandwidth and memory, and scales terribly as you add more lights. This is rarely used for dynamic multi-light setups.
• Option 3: Minimizes output and computation, but sacrifices all soft shadow support. It’s only viable for static, hard-shadow-only scenarios (like baked lightmaps), not dynamic multi-light pipelines.

The Standard, Industry-Used Approach: Optimized Option 1 #

The go-to method for multiple shadow maps in deferred shading is indeed calculating light-space positions per light during the deferred lighting pass, but with key optimizations that make the performance overhead manageable:

1. Per-Light Culling (Not Per-Pixel All Lights) #

Instead of processing every light for every pixel across the entire screen, deferred shading pipelines typically:

• First render your G-buffer (storing world-space position, normals, albedo, etc.).
• For each dynamic light, perform a scissored/tiled pass that only processes pixels within the light’s influence area (e.g., a point light’s bounding sphere, a directional light’s frustum).

This means you’re not running matrix math for every light on every pixel—only for pixels that the light actually affects. For small lights, this might only be a few hundred pixels instead of millions, drastically reducing total computation.

2. Efficient Matrix Multiplication #

Modern GPUs are highly optimized for vector/matrix operations, so multiplying a world-space position (from your G-buffer) by a light’s view-projection matrix is surprisingly fast. You can also optimize this further:

• Store world-space positions in your G-buffer (instead of view-space) to simplify light-space calculations for any light type.
• Precompute light matrices on the CPU and pass them as uniforms to the shader—no need to calculate them on the GPU per frame.
• For directional lights, leverage orthogonal projection properties (e.g., inverse matrices are transposes) to simplify calculations if needed.

3. Flexibility for All Shadow Types #

This approach supports every shadow technique you might want to learn:

• Hard shadows (basic shadow map comparison)
• Soft shadows (PCF, PCSS, VSM, ESM)
• Cascaded Shadow Maps (CSM) for directional lights (just switch between different light matrices/shadow maps based on the pixel’s distance from the camera)

It’s the same approach used in engines like Unity and Unreal for their deferred pipelines because it balances performance, flexibility, and scalability.

Bonus Learning Tips #

If you’re looking to deepen your understanding, here are a few extra topics to explore:

• Shadow Map Reuse: For static lights, precompute shadow maps once instead of updating them every frame.
• Tiled/Clustered Deferred Shading: These advanced deferred variants group pixels into tiles/clusters and only process lights that affect each cluster, further reducing overhead for large numbers of lights.
• Hardware-Accelerated Shadow Sampling: Modern GPUs have built-in support for optimized shadow sampling (e.g., hardware PCF), which can speed up your shadow calculations without extra shader code.

Final Takeaway #

For learning standard deferred shading with multiple shadow maps, start with the optimized version of your Option 1. It’s the most flexible, scalable, and widely adopted approach, and it will let you experiment with all types of shadow techniques as you continue learning.

内容的提问来源于stack exchange，提问作者florent teppe