Jump to content
  • Advertisement
Sign in to follow this  
Anfaenger

Shader Library design and implementation

This topic is 1949 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

If you intended to correct an error in the post then please contact us.

Recommended Posts

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
Advertisement

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

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

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

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
Sign in to follow this  

  • Advertisement
×

Important Information

By using GameDev.net, you agree to our community Guidelines, Terms of Use, and Privacy Policy.

We are the game development community.

Whether you are an indie, hobbyist, AAA developer, or just trying to learn, GameDev.net is the place for you to learn, share, and connect with the games industry. Learn more About Us or sign up!

Sign me up!