Compute Shaders

FShade also provides an API for compute shaders which is not part of the effect/composition system. We opted for a very low abstraction here, since compute shaders are used vor various tasks and cannot easily be represented as pure functions. Here's a little example of a very basic compute shader adding two arrays/buffers.

1: 
2: 
3: 
4: 
5: 
6: 

[<LocalSize(X = 64)>]
let add (l : float32[]) (r : float32[]) =
    compute {
        let id = getGlobalId().X
        l.[id] <- l.[id] + r.[id]
    }

compute shaders can (like Effects) be compiled to a Module which in turn can be assembled to GLSL using the default pipeline. note that all array-inputs are translated to storage-buffers.

1: 
2: 
3: 
4: 
5: 

ComputeShader.ofFunction maxLocalSize add
    |> ComputeShader.toModule
    |> ModuleCompiler.compileGLSL430
    |> GLSL.code
    |> printfn "%s"

#version 440

layout (local_size_x = 64, local_size_y = 1, local_size_z = 1) in;
layout(std430,binding=0) buffer l_ssb  { float l[]; };
layout(std430,binding=1) buffer r_ssb  { float r[]; };
void main()
{
    int id = ivec3(gl_GlobalInvocationID).x;
    l[id] = (l[id] + r[id]);
}

Special functions

the compute API includes various special-functions like

• getGlobalId()
• getLocalId()
• getWorkGoupId()

Here's a shader using some of those built-in functions.

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
13: 
14: 
15: 
16: 
17: 
18: 
19: 
20: 
21: 
22: 
23: 
24: 
25: 
26: 
27: 
28: 
29: 

// missing glsl builtins can be imported like this
[<GLSLIntrinsic("atomicAdd({0}, {1})")>]
let atomicAdd (r : ref<int>) (v : int) = onlyInShaderCode "atomicAdd"

[<LocalSize(X = 64)>]
let builtIns (a : int[]) (img : IntImage2d<Formats.r32i>) =
    compute {
        // note that the argument to allocateShared must be a compile-time constant
        let shared      = allocateShared<int> 64

        let globalId    = getGlobalId()
        let groupCount  = getWorkGroupCount()
        let groupSize   = getWorkGroupSize()
        let groupId     = getWorkGroupId()
        let localId     = getLocalId()
        let localIndex  = getLocalIndex()

        shared.[localId.X] <- a.[globalId.X]
        barrier()
        
        img.AtomicAdd(globalId.XY, 10) |> ignore
        
        atomicAdd &&a.[globalId.X] 10

        a.[globalId.X] <- 123

    }
    
ComputeShader.printGLSL builtIns

#version 440

layout(binding = 0, r32i)
uniform iimage2D cs_img;

shared int shared_intx64[64];

layout (local_size_x = 64, local_size_y = 1, local_size_z = 1) in;
layout(std430,binding=0) buffer a_ssb  { int a[]; };
void main()
{
    ivec3 globalId = ivec3(gl_GlobalInvocationID);
    ivec3 groupCount = ivec3(gl_NumWorkGroups);
    ivec3 groupSize = ivec3(gl_WorkGroupSize);
    ivec3 groupId = ivec3(gl_WorkGroupID);
    ivec3 localId = ivec3(gl_LocalInvocationID);
    int localIndex = int(gl_LocalInvocationIndex);
    shared_intx64[localId.x] = a[globalId.x];
    barrier();
    imageAtomicAdd(cs_img, globalId.xy, 10);
    atomicAdd(a[globalId.x], 10);
    a[globalId.x] = 123;
}

Optimization

Due to the imperative nature of compute shaders we turned off several optimizations in the compiler by default. For example reordering statements may actually change the shader's results here. Our optimizations (designed for regular shaders) currently assume that shaders are functionally pure. We'll fix that in future FShade releases, but for the moment users need to perform some optimizations by hand.

• FShade
• Home page
• Get Library via NuGet
• Source Code on GitHub
• Documentation
• Technical Overview
• Composition
• Types
• Tessellation Shaders
• Compute Shaders