Pixel Bender Shaders

by ... posted on
SHADERS

The following document contains the source code for various Pixel Bender shaders I wrote. I learned most of these from Programming Vertex & Pixel Shaders (2004).

The shaders were initially published in a compiled form (as PBJ files - nice pun) sometime in Q1 2010 but their source code (*.PBK) is now here for archival purposes. The source code below can serve as a good starting point for learning pixel shader writing.

Brightness 

<languageVersion : 1.0;>

kernel Brightness
<   namespace : "com.goldenxp";
    vendor : "goldenxp";
    version : 1;
    description : "Basic Brightness filter";
>
{
    input image4 src;
    output pixel4 dst;
    parameter float scale 
    <
        minValue:float(0);
        maxValue:float(2);
        defaultValue:float(1);
    >;

    void
    evaluatePixel()
    {
        float4x4 mBright = float4x4(
        scale, 0, 0, 0,
        0, scale, 0, 0,
        0, 0, scale, 0,
        0, 0, 0, 1        
        );
        float4 rgba = sampleNearest(src,outCoord());
        dst = mBright * rgba;
    }
}

Invert 

<languageVersion : 1.0;>

kernel Invert
<   namespace : "com.goldenxp";
    vendor : "goldenxp";
    version : 1;
    description : "Basic invert filter";
>
{
    input image4 src;
    output pixel4 dst;

    void
    evaluatePixel()
    {
        float4 rgba = sampleNearest(src,outCoord());
        dst.rgb = float3(1.0,1.0,1.0)- rgba.rgb;
        dst.a = rgba.a;
    }
}

Edge Detect 

<languageVersion : 1.0;>

kernel EdgeDetect
<   namespace : "com.goldenxp";
    vendor : "goldenxp";
    version : 1;
    description : "Edge Detection (Laplacian) filter";
>
{
    input image4 src;
    output pixel4 dst;

    void
    evaluatePixel()
    {        
        float2 px = pixelSize(src);
        float4 color = float4(0,0,0,0);
        float4 rgba = sampleNearest(src, outCoord());
        
        color += sampleNearest(src, outCoord() + float2( 0, px.y ) );
        color += sampleNearest(src, outCoord() + float2( 0, -px.y ) );
        color += sampleNearest(src, outCoord() + float2( px.x, 0 ) );
        color += sampleNearest(src, outCoord() + float2( -px.x, 0 ) );
        color -= sampleNearest(src, outCoord());
        color -= sampleNearest(src, outCoord());
        color -= sampleNearest(src, outCoord());
        color -= sampleNearest(src, outCoord());
     
        color.a = rgba.a;
        
        dst = color;
    }
}

Sharpen 

<languageVersion : 1.0;>

kernel Sharpen
<   namespace : "com.goldenxp";
    vendor : "goldenxp";
    version : 1;
    description : "Sharpen filter";
>
{
    input image4 src;
    output pixel4 dst;

    void
    evaluatePixel()
    {        
        float2 px = pixelSize(src);        
        float4 color = float4(0,0,0,0);
        float4 rgba = sampleNearest(src, outCoord());
        
        color += sampleNearest(src, outCoord());
        color += sampleNearest(src, outCoord());
        color += sampleNearest(src, outCoord());
        color += sampleNearest(src, outCoord());
        color += sampleNearest(src, outCoord());
        color -= sampleNearest(src, outCoord() + float2( 0, px.y ) );
        color -= sampleNearest(src, outCoord() + float2( 0, -px.y ) );
        color -= sampleNearest(src, outCoord() + float2( px.x, 0 ) );
        color -= sampleNearest(src, outCoord() + float2( -px.x, 0 ) );
        color.rgb = clamp(float3(0),float3(1),color.rgb);
     
        color.a = rgba.a;
        
        dst = color;
    }
}

Desaturate 

<languageVersion : 1.0;>

kernel Desaturation
<   namespace : "com.goldenxp";
    vendor : "goldenxp";
    version : 1;
    description : "Basic desaturation filter";
>
{
    input image4 src;
    output pixel4 dst;

    void
    evaluatePixel()
    {
        float4x4 mDesat = float4x4(
        0.33, 0.33, 0.33, 0,
        0.33, 0.33, 0.33, 0,
        0.33, 0.33, 0.33, 0,
        0, 0, 0, 1
        );
        float4 rgba = sampleNearest(src,outCoord());
        dst = mDesat * rgba;
    }
}

Saturate 

<languageVersion : 1.0;>

kernel Saturate
<   namespace : "com.goldenxp";
    vendor : "goldenxp";
    version : 1;
    description : "Saturation control";
>
{
    input image4 src;
    output pixel4 dst;
    parameter float saturate
    <
        minValue:float(-1);
        maxValue:float(10);
        defaultValue:float(2);
    >;

    void
    evaluatePixel()
    {
        float red = 0.3086;
        float green = 0.6094;
        float blue = 0.0820;
        float s = saturate;
        
        float4x4 mSaturate = float4x4(
            (1.0-s) * red + s, (1.0-s)*red, (1.0-s)*red, 0,
            (1.0-s) * green, (1.0-s) * green + s, (1.0-s) * green, 0,
            (1.0-s) * blue, (1.0-s) * blue, (1.0-s) * blue + s, 0,
            0, 0, 0, 1
        );
        
        float4 rgba = sampleNearest(src,outCoord());
        dst = mSaturate * rgba;
    }
}

Edge Normals 

<languageVersion : 1.0;>

kernel NormalMap
<   namespace : "com.goldenxp";
    vendor : "goldenxp";
    version : 1;
    description : "Edge Detection from Normals pass";
>
{
    input image4 normalmap;
    output pixel4 dst;

    void
    evaluatePixel()
    {
        float4 rgba = sampleNearest(normalmap,outCoord());
        rgba.rgb = 2.0 * rgba.rgb - 1.0;
        float2 px = pixelSize(normalmap);
        float outline = 0.0; 
        outline = clamp(1.0-dot(rgba.rgb, 2.0*sampleNearest(normalmap, outCoord() + float2(px.x,0)).rgb-1.0), 0.0, 1.0);
        outline += clamp(1.0-dot(rgba.rgb, 2.0*sampleNearest(normalmap, outCoord() + float2(-px.x,0)).rgb-1.0 ), 0.0, 1.0);
        outline += clamp(1.0-dot(rgba.rgb, 2.0*sampleNearest(normalmap, outCoord() + float2(0,px.y)).rgb-1.0), 0.0, 1.0);
        outline += clamp(1.0-dot(rgba.rgb, 2.0*sampleNearest(normalmap, outCoord() + float2(0,-px.y)).rgb-1.0), 0.0, 1.0);
        
        dst.rgb = float3(outline);
        dst.a = rgba.a;
    }
}

Normal Map 

<languageVersion : 1.0;>

kernel NormalMap
<   namespace : "com.goldenxp";
    vendor : "goldenxp";
    version : 1;
    description : "Diffuse lighting from Normals pass";
>
{
    input image4 normalmap;
    output pixel4 dst;
    parameter float3 lightDirection
    <
    minValue:float3(-1);maxValue:float3(1);
    defaultValue:float3(0.4,0.5,0);
    >;
    parameter pixel3 dark<defaultValue:float3(0);>;
    parameter pixel3 light<defaultValue:float3(1);>;
    parameter float specular<minValue:0.0;maxValue:100.0;defaultValue:0.0;>;
    parameter float specular_intensity<minValue:0.0;maxValue:1.0;defaultValue:1.0;>;

    void
    evaluatePixel()
    {
        float4 rgba = sampleNearest(normalmap,outCoord());
        rgba.rgb = 2.0 * rgba.rgb - 1.0;
        float3 color = mix(dark,light,dot(lightDirection, rgba.rgb));
        if (specular != 0.0) {
            float spec = dot(lightDirection+float3(0,0,1),rgba.rgb);
            color +=  float3( specular_intensity * pow( spec , specular ) );
        }
        
        dst.rgb = color;
        dst.a = rgba.a;
    }
}

Color Remap 

<languageVersion : 1.0;>

kernel ColorRemap
<   namespace : "com.goldenxp";
    vendor : "goldenxp";
    version : 1;
    description : "Color remapping filter";
>
{
    input image4 src;
    output pixel4 dst;
    parameter pixel3 color1< defaultValue:float3(0.3,0.2,0.1); >;
    parameter pixel3 color2< defaultValue:float3(1.0,0.5,0.3); >;

    void
    evaluatePixel()
    {
        float4 rgba = sampleNearest(src,outCoord());
       
        float3x3 mLuminance = float3x3(
        0.3086, 0.3086, 0.3086, 
        0.6094, 0.6094, 0.6094, 
        0.0820, 0.0820, 0.0820
        );        
        
        float3 col = mLuminance * rgba.rgb;
               
        dst.rgb = mix(color1, color2, col.r) ;
        dst.a = rgba.a;
    }
}

UV Remaps 

<languageVersion : 1.0;>

kernel UVMap
<   namespace : "com.goldenxp";
    vendor : "goldenxp";
    version : 1;
    description : "UV Mapping (crude - no samples)";
>
{
    input image4 uv_pass;
    input image4 texture;
    parameter float sizeX <defaultValue:128.0; minValue:2.0; maxValue:2048.0;>;
    parameter float sizeY <defaultValue:128.0; minValue:2.0; maxValue:2048.0;>;
    output pixel4 dst;

    void
    evaluatePixel()
    {       
        float4 rgba = sampleNearest(texture, outCoord() );
        float2 px = pixelSize(uv_pass);
        float4 tex = sampleNearest(uv_pass, float2(sizeX*rgba.r, sizeY*rgba.g));
        dst.rgb = tex.rgb;
        dst.a = rgba.a;
    }
}

Anaglyph 

<languageVersion : 1.0;>

kernel Anaglyph
<   namespace : "com.goldenxp";
    vendor : "goldenxp";
    version : 1;
    description : "Anaglyph Red/Cyan Stereo filter";
>
{
    input image4 leftImage;
    input image4 rightImage;
    output pixel4 dst;

    void
    evaluatePixel()
    {
        float4 left = sampleNearest(leftImage,outCoord());
        float4 right = sampleNearest(rightImage,outCoord());
        
        left = float4(left.r,0,0,left.a);
        right = float4(0,right.g,right.b,right.a);
        
        dst.rgb = left.rgb + right.rgb;
        dst.a = left.a;
    }
}

Template

This has never been published before since it’s just a template. BONUS!

<languageVersion : 1.0;>

kernel Nameless
<   namespace : "com.goldenxp";
    vendor : "goldenxp";
    version : 1;
    description : "nameless";
>
{
    input image4 leftImage;

    output pixel4 dst;

    void
    evaluatePixel()
    {
        float4 rgba = sampleNearest(leftImage,outCoord());
        

        dst = rgba;
    }
}