• Home
  • Documentation
  • Forum
  • Blog
  • Users
    • Map
    • Userlist
    • Businesses
    • Userpages
    • Connections
  • Contributions
    • All
    • Store
  • Downloads
    • vvvv beta
    • vvvv beta previews
  • Store

    Show / Hide Table of Contents

    Shader Snippets

    Why reinvent the wheel? There're some handy little functions for the everyday HLSL writer. Please add your snippets in this wiki page.

    General snippets

    get clipping planes of a Perspective Projection

    float4x4 tPI: PROJECTIONINVERSE;  
    float FarPlane = 1 / (tPI[2][3] + tPI[3][3]);  
    float NearPlane = 1 / distance(tPI[2][3], tPI[3][3]);
    

    VertexShader snippets

    apply rotation to vertices via texture

    rotation function:

    float4x4 Vrotate(float rotX,   
    		 float rotY, 
    		 float rotZ)
      {
       rotX *= TwoPi;
       rotY *= TwoPi;
       rotZ *= TwoPi;
       float sx = sin(rotX);
       float cx = cos(rotX);
       float sy = sin(rotY);
       float cy = cos(rotY);
       float sz = sin(rotZ);
       float cz = cos(rotZ);
    
       return float4x4( cz*cy+sz*sx*sy, sz*cx, cz*-sy+sz*sx*cy, 0,
                       -sz*cy+cz*sx*sy, cz*cx, sz*sy+cz*sx*cy , 0,
                        cx * sy       ,-sx   , cx * cy        , 0,
                        0             , 0    , 0              , 1);
      }
    
    

    use the function like this:

    PosO = mul(PosO, Vrotate(Sampler.r, Sampler.g, Sampler.b));  
    NormO = mul(NormO, Vrotate(Sampler.r, Sampler.g, Sampler.b));  
    
    

    Sampler.rgb are the corresponding values from the texture

    Render to Texture/UV (useful for e.g. texture baking)

    Calculate screenspace coordinates based on UV instead of object space and pass it to PS

    Out.Pos = float4((TexCd.xy-0.5)*2*float2(1,-1),0,1);  
    
    

    PixelShader snippets for Image processing

    invert

    rgb-inversion

    col.rgb = 1 - col.rgb;
    

    contrast

    col.rgb = ((col.rgb - 0.5) * var) + 0.5;
    

    if var > 1, the contrast is greater. var = 0 gives a grey picture
    The 0.5 can be replaced with a variable to give a gamma or centre
    point for the contrast as well, for more fine tuning...

    black&white

    const float4 lumcoeff = {0.299, 0.587, 0.114, 0};  
    col = dot(col, lumcoeff);
    

    the dot product of the color (col) and the luminace coefficients results in a correct b&w image

    lumakey

    const float4 lumcoeff = {0.299, 0.587, 0.114, 0};  
    float luma = length(dot(col, lumcoeff));  
    col.a = step(var, luma);
    

    var is the keying amount. the rest works like the b&w conversion.

    scene alpha

    return(tex2D(Samp, float2(IN.TexCd.xy)).wwww);
    

    Texture input must be in A8R8G8B8 format.

    buffer to texture

    R:TARGETSIZE;

    StructuredBuffer<float4> sb;
    float2 R:TARGETSIZE; 
    float4 P0(float4 pos: SV_POSITION, float2 uv: TEXCOORD0): SV_Target
    {
    	return sb[pos.x + (pos.y * R.x)];
    }
    
    technique10 Template 
    {
    	pass P0 <string format="R32G32B32A32_Float";>
    	{ SetPixelShader(CompileShader(ps_4_0, P0())); }
    } 
    

    working alpha channel in 3d

    needs 2 passes so connect an iobox with 2 rows to the pass pin and fill it with 0,1

    technique workingalpha  
    {  
        pass P0
        {
            VertexShader = compile vs_1_0 VS();
            PixelShader  = compile ps_2_0 PS();
            AlphaBlendEnable = false;
    
            AlphaTestEnable = true;
            AlphaFunc = Greater;
            AlphaRef = 245;
    
            ZEnable = true;
            ZWriteEnable = true;
    
            CullMode = None;
        }
        pass P1
        {
            VertexShader = compile vs_1_0 VS();
            PixelShader  = compile ps_2_0 PS();
            AlphaBlendEnable = true;
            SrcBlend = SrcAlpha;
            DestBlend = InvSrcAlpha;
    
            AlphaTestEnable = true;
            AlphaFunc = LessEqual;
            AlphaRef = 245;
    
            ZEnable = true;
            ZWriteEnable = false;
    
            CullMode = None;
        }
    }
    

    DX11 Set DepthBuffer

    Put this up near the start of your shader
    DepthStencilState DisableDepth
    {
    DepthEnable = FALSE; DepthWriteMask = ZERO; DepthFunc = LESS_EQUAL;

    StencilEnable  = FALSE;
    

    };

    and add this when you create the pass
    and SetVertexShader etc
    SetDepthStencilState( DisableDepth, 0 );

    DX11 Access TextureArray

    // declare array of N textures
    Texture2D MyTextureArray[N];

    // sample texture of index I from array (0 to N-1)
    MyTextureArray[I].Sample(MySampler, UV);

    Will the real texture array please stand up

    note that the above is an array of textures- which is NOT the same thing as a actual texture array! Example of that below:

    //Control Texture Array
    bool useControlMap;
    Texture2DArray cTex <string uiname="Texture";>;
    SamplerState sam //can be set in vvvv
    {
    Filter = MIN_MAG_MIP_LINEAR; AddressU = Wrap; AddressV = Wrap; };

    float controlTexSample(float2 uv, float iid)
    {
    float control = 1; if (useControlMap) { uint d,textureCount; cTex.GetDimensions(d,d,textureCount); float3 coords = float3(uv, iid % textureCount); //make sure Instance ID buffer is in floats control *= cTex.SampleLevel(sam,coords,0).r; } return control; }

    Set Output-TextureFormat for DX11-TXF-Shader

    pass P0 <string format="R32G32B32A32_float";>  
        {SetPixelShader(CompileShader(ps_4_0,fCOLOR()));}
    
    

    Defines (or pre-processor directives)

    Use pre-processors as in other C inspired languages. These will actually transform the text of your code before compilation.

    1. define MYDEFINE 4
    float MyFunc()  
    {  
        return MYDEFINE;
    }  
    // result: 4  
    
    

    Conditional:

    1. define MYCONDITION 2
    float MyFunc()  
    {  
    1. if MYCONDITION==2
        return 2;
    1. else
        return 0;
    1. endif
    }  
    // result: 2  
    
    

    Check if thing is defined:

    1. define MYCONDITION 2
    float MyFunc()  
    {  
    1. if defined(MYCONDITION)
        return 2;
    1. else
        return 0;
    1. endif
    }  
    // result: 2  
    
    

    DX11: Define from vvvv

    All shader nodes in DX11 (layers, tfx and gfx) have a hidden pin called "Defines" which awaits a spread of string formatted like that:

    DEFINENAME=stuff  
    
    

    Every time you change the Defines spread shader is recompiled. Example tricks:

    Change tfx pass format without changing the code:

    // define a default value to avoid compilation errors  
    1. if !defined(PASSFORMAT)
    1. define PASSFORMAT "R8_UNorm"
    1. endif
    
    ...  
    
    pass P0 <string format=PASSFORMAT;>  
        {SetPixelShader(CompileShader(ps_4_0,fCOLOR()));}
    
    

    from vvvv:

    PASSFORMAT="R16G16B16A16_Float"  
    
    
    • Improve this Doc

    © 2020 by vvvv group. Imprint | Privacy Policy.
    Thanks to DocFX for building this website. Analytics by Plausible.

    Back to top