Jump to content

  • Log In with Google      Sign In   
  • Create Account


Shader Library design and implementation


Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.

  • You cannot reply to this topic
4 replies to this topic

#1 Anfaenger   Members   -  Reputation: 209

Like
0Likes
Like

Posted 22 May 2013 - 03:35 PM

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();

 

 



Sponsor:

#2 Steve_Segreto   Crossbones+   -  Reputation: 1509

Like
1Likes
Like

Posted 23 May 2013 - 01:34 AM

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. :)



#3 Anfaenger   Members   -  Reputation: 209

Like
0Likes
Like

Posted 24 May 2013 - 01:28 PM

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, 24 May 2013 - 01:28 PM.


#4 Steve_Segreto   Crossbones+   -  Reputation: 1509

Like
1Likes
Like

Posted 25 May 2013 - 03:02 AM

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).



#5 Anfaenger   Members   -  Reputation: 209

Like
0Likes
Like

Posted 25 May 2013 - 01:34 PM

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?






Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.



PARTNERS