Sign in to follow this  
Anfaenger

Shader Library design and implementation

Recommended Posts

Anfaenger    825

I'm trying to come up with a good design for a convenient and low-overhead shader library abstracting away low-level graphics API details and allowing me to focus on shaders/game renderer development.

 

Basically, i'm pursuing the following goals:

 

1) minimal memory footprint - no string names at run-time, minimal amount of metadata if any;

 

2) support for hot-reloading modified shader files;

 

3) support for caching compiled shader bytecode and filtering out duplicates;

 

How are such shader libraries usually built and how should it be used in actual engine code?

Are there any more performant alternatives to DirectX effects?

 

The first problem can be solved by storing name hashes instead of full strings (in C++ code compile-time string hashing could be used).

The second one is tough for me, because my shader techniques can depend on global stuff (constant buffers, sampler states and shader resources) and before reloading changed technique i'll have to 'link' it (to avoid recreating those globals).

 

Right now, my pipeline structure conceptually looks like this:

struct Pipeline
{
              // global stuff
	Array< RenderTargetResource >		renderTargets;
	Array< DepthStencilStateResource >	depthStencilStates;
	Array< RasterizerStateResource >	rasterizerStates;
	Array< SamplerStateResource >		samplerStates;
	Array< BlendStateResource >		blendStates;
	Array< StateBlock >			stateBlocks;

	Array< CBufferResource >	constantBuffers;       //<= global constant buffers (e.g. cbPerFrame, per-view, per-instance)
             // handles to shader sampler states are stored in the 'samplerStates' array above
	Array< ShaderResource >	shaderResources;   //<= 

	Array< ShaderTechnique >	techniques;

              // all created shader programs (VS/GS/PS) for fixing-up HShaderProgram handles in technique passes (when serialized, they store indices into this array in place of handles)
	Array< HShaderProgram >	programs[ ShaderType::Count ];

	// this is used for locating shader cache on disk
	String		name;
};

// technique: name and array of passes

// pass - array of shader instances (combinations, identified by a bitmask), default shader instance id,
// and parameter bindings info (cbuffers,samplers,textures) in the form {array, start, count}

 

Global shader resources are shared between different shader programs, e.g. updating a global constant buffer would look so:

 

SetStateBlock(Default); // Default is LessEqZNoStencil, NoBlending, CullBack.

CBuffer& perFrame = pipeline.GetCBufferByName("cbPerFrame");

cbPerFrame* data = cast(cbPerFrame*) perFrame.ToPtr();

...

perFrame.Commit();

 

 

Share this post


Link to post
Share on other sites
Steve_Segreto    2080

You're definitely on the right track with your line of thinking. As far as I know, these kinds of libraries are built organically from the ground up to meet the needs of the project. Another need that you might not have considered is "shader permutations" or "shader explosions" problem. After all you don't want to have a system that creates shaders at such a fine-grain level that there are 8000 of them loaded and being used as the user runs through your game. :)

Share this post


Link to post
Share on other sites
Anfaenger    825

What's the most efficient way to do redundancy checking (to avoid extraneous Direct3D API function calls for binding pipeline resources) ?

 

my goal is to minimize the low-level graphics wrapper overhead as much as possible.

(i use small integer handles everywhere instead of pointers. i decided to use 8-bit handles for all immutable render states (DepthStencil, Rasterizer, Sampler and Blend - they are created at the start) and all constant buffers (i have a fixed pool of CBs). i can only have 8 CBs/samplers bound simultaneously so i can concatenate the whole pipeline state into a few 64-bit integers and use bitwise instructions to calculate 'delta' and issue the corresponding Set* calls if needed.)

Edited by Anfaenger

Share this post


Link to post
Share on other sites
Steve_Segreto    2080

I'm not sure about d3d11. In d3d9 I've seen engines using manager classes to avoid redundant render state and vertex/pixel shader constant setting (i.e. they would just maintain application local values for renderstates and shader constants and opt out of making the d3d9 device calls to change state if the local value already matched the desired value).

Share this post


Link to post
Share on other sites
Anfaenger    825

Are there open-source implementations of stateless, 'packetized' renderers that i can learn from?

Could you give me an example of a stateless low-level graphics API? What functions should it contain?

Share this post


Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now

Sign in to follow this