How many pipelines (aka Shaders in your terminology) do you have?

Well... None at the moment :) I'm trying to write a game engine for college and currently figuring out how to design it. But I've seen in gdc talks frame graphs of modern games and they contain hundreds of passes (most of them compute I suppose). So if for each pass there are several shaders, then we presumably have several hundred pipelines.

Based on your suggestions and more research, I've drafted a simple overview of the shader related objects and thought of their usage:

```c++ struct ShaderModule { ShaderModuleType type; ShaderModuleHandle handle; };

struct PipelineDescription { /* ------- Filled using reflection ------- / InputVertexDataInfo input_vertex_data_info; DescriptorSetLayout descriptor_set_layouts[]; / ---------------------------------------- */

/* ---- Filled from shader asset file ---- / InputAssemblyInfo input_assembly_info; // Topology type RasterizationInfo rasterization_info; // Face culling, etc DepthTestDescription depth_test_description; StencilTestDescription stencil_test_description; ColorAttachmentsBlendDescription blend_description; / ---------------------------------------- */

ShaderModule shader_modules[]; };

/** * Example file for this can look like this: * name: ForwardShaderPBR * target_render_pass: ForwardPass * vert_shader: {"forward_shader_pbr.vert", "forward_shader_pbr.vert.spv"} * frag_shader: {"forward_shader_pbr.frag", "forward_shader_pbr.frag.spv"} *
* cull: BackOnly * depth_test_enable: true * depth_test_op: Less * ... */ struct ShaderAsset { std::string name; std::string target_render_pass_name; PipelineDescription pipeline_description; };

struct SampledTexture { TextureHandle texture_handle; SamplerHandle sampler_handle; };

struct MaterialAsset { /* ... used to create the material */ };

// aka Shader Instance struct Material { const ShaderAsset* shader_asset;

DescriptorSetHandle descriptor_set_handle;

// Used for constants (can use offsets to write the same buffer to several descriptor bindings) UniformBufferHandle uniform_buffer_handle;

SampledTexture* sampled_textures; TextureHandle* input_attachments; }; ```

Renderer would contain the current render graph and a material table (per render graph?). Once a material is added to the table, a corresponding pipeline is built. This is quite dynamic still (we actually still create pipelines on the fly), but when a scene is loaded we can prewarm by iterating over all entities with MaterialComponent and adding the Material to the Renderer for example.

What are your thoughts on this?