FShade: first-class shaders for F#

FShade is a library that extends F# with a domain specific language for shaders. It provides high-level utilities for working with first-class shaders inlcuding composition-, modification- and preprocessing-tools. It focuses on graphics shaders but also provides reusable utilities for compiling F# functions to other c-like languages.

FShade uses primitive vector-/matrix-types from Aardvark.Base for representing their shader-language counterparts but could (on demand) be extended to use others too.

Example

This example implements a very basic vertex shader that can be compiled using FShade.

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

type Data = { pos : V4d; tc : V2d }

let shader (d : Data) =
    vertex {
        let mvp : M44d = uniform?ModelViewProjMatrix
        return { pos = mvp * d.pos; tc = 2.0 * d.tc }
    }

Effects

FShade represents shader code using Effect which assigns shader code to the available pipeline stages. The available stages are the ones currently available in modern graphics APIs:

• Vertex
• TessControl
• TessEval
• Geometry
• Fragment

Each Effect can provide code for a subset of these stages and can be composed with others using Effect.compose as described in Composition. Effect also exposes some other functions for creating/transforming/inspecting effects.

The shader from above can be translated to an effect by using

1: 

let effect = Effect.ofFunction shader

Compilation

FShade's compilation process consists of three stages which successively lower the abstraction level.

Module

Module serves as the common interface for FShade's compiler and provides a list of entry-point definitions (using F#'s Expr) Effect.toModule translates an Effect to one of these.

CModule

CModules represent the content of c-files which can consist or various value-/type-definitions. In order to compile a Module one can use ModuleCompiler. Note that in this step needs information about intrinsic functions. Therefore ModuleCompiler.compile requires a Backend as argument which knows about the intrinsic (predefined) functions and types for the current target language.

Assembler

FShade defines a GLSL 'Assembler' that simply transforms a CModule to GLSL code. This is done by simply visiting the entire CModule while emitting appropriate c-code. This way assemblers don't need to stick to any specific interface and other assemblers may produce other output-types. For example SpirV would need to produce byte[] instead of strings.

Here's an example compiling an effect to GLSL illustrating the compiler-stages.

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
13: 
14: 
15: 
16: 

effect
    // Effect -> Module (the config specifies desired outputs, etc.)
    |> Effect.toModule { 
        EffectConfig.empty with 
            lastStage = ShaderStage.Vertex
            outputs = Map.ofList ["pos", (typeof<V4d>, 0)]
        }

    // Module -> CModule
    |> ModuleCompiler.compile glsl410

    // CModule -> string
    |> GLSL.Assembler.assemble glsl410  

    // show the code
    |> printfn "%s"

#version 410

layout(std140)
uniform Global
{
    mat4x4 ModelViewProjMatrix;
};

#ifdef Vertex

layout(location = 0) in vec4 pos;
layout(location = 0) out vec4 posOut;
void main()
{
    posOut = (ModelViewProjMatrix * pos);
}

#endif

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