Shady is a GLSL preprocessor tool for GameMaker that allows you to include pieces of code from other shaders and generate shader variants for code reuse! Support on Itch.io.

The tool is integrated into the compilation process via compiler scripts so you can write reusable shaders inside standard GameMaker shader files with built-in or any other code editor.

It is still in Beta and tested to work with GLSL ES language but should also work with GLSL. HLSL is not (yet?) supported.

1. Download yymps extension file from the release page and import it to your GameMaker project.
2. Download the executable zip archive from the release page for your OS and architecture.
3. Unzip and place the executable into the extension path (YourProject/extensions/Shady).
4. You may also want to add these lines to .gitignore to remove temp Shady files from Git:

*.fsh_mod
*.vsh_mod

Shady is using a custom #pragma syntax with special directives. This isn't breaking the standard shader compiler as unknown custom pragmas are just ignored by it.

You can write shady directives right in the GameMaker shader files, both vertex and fragment.

By default, you're importing definitions from the same type of shader (fragment to fragment, vertex to vertex), but you can also explicitly specify the extension (.fsh/.vsh) of the shader you are importing from.

• import directive:

Syntax:

#pragma shady: import(shader_name)
#pragma shady: import(shader_name.identifier_name)

float random(vec2 st) {
    return fract(sin(dot(st.xy, vec2(12.9898,78.233))) * 43758.5453123);
}

#define GRAYSCALE_FACTOR vec3(0.2126, 0.7152, 0.0722)
vec4 grayscale(vec4 color) {
    return vec4(vec3(dot(color.rgb, GRAYSCALE_FACTOR)), color.a);
}

const vec2 textureScale = vec2(4096.0 / 1920.0, 4096.0 / 1080.0);

void main() {}

varying vec2 v_vTexcoord;
varying vec4 v_vColour;

#pragma shady: import(sh_functions)  // import everything from sh_functions (random, GRAYSCALE_FACTOR, grayscale, textureScale)
#pragma shady: import(sh_functions.random)  // import specific function (random)
#pragma shady: import(sh_functions.textureScale)  // import specific variable (textureScale)

void main() {
    vec4 color = texture2D(gm_BaseTexture, v_vTexcoord);
  
    gl_FragColor = v_vColour * grayscale(color);  // you can then use imported stuff like it's there
}

• Macros and inline directive:

Syntax:

#pragma shady: macro_begin MACRO_NAME
#pragma shady: macro_end
#pragma shady: inline(shader_name.MACRO_NAME)

varying vec2 v_vTexcoord;
varying vec4 v_vColour;

void main() {
    #pragma shady: macro_begin FRAGCOLOR
        gl_FragColor = v_vColour * texture2D(gm_BaseTexture, v_vTexcoord);
    #pragma shady: macro_end
}

varying vec2 v_vTexcoord;
varying vec4 v_vColour;

void main() {
    #pragma shady: inline(sh_macros.FRAGCOLOR)  // inline code from sh_macros FRAGCOLOR macro
}

#pragma shady: macro_begin INVERSE_GRAYSCALE

    #pragma shady: macro_begin INVERSE
        gl_FragColor = vec4(vec3(1.0 - gl_FragColor.rgb), gl_FragColor.a);
    #pragma shady: macro_end

    #pragma shady: macro_begin GRAYSCALE
        gl_FragColor = grayscale(gl_FragColor);
    #pragma shady: macro_end

#pragma shady: macro_end

• variant directive:

Syntax:

#pragma shady: variant(shader_name, [KEYWORD_NAME1], [KEYWORD_NAME2], ...)

varying vec2 v_vTexcoord;
varying vec4 v_vColour;

#pragma shady: import(sh_effects)

void main()
{
    // use #ifdef, #else, #if defined() or #elif defined() to define variant keywords
    #ifdef BLUR
        vec4 color = texture2DBlur(gm_BaseTexture, v_vTexcoord);
    #else
        vec4 color = texture2D(gm_BaseTexture, v_vTexcoord);
    #endif
    
    #ifdef NOISE
        color = noise(color);
    #endif
    
    #ifdef DARKEN
        color = darken(color);
    #endif
    
    gl_FragColor = v_vColour * color;
}

#pragma shady: variant(sh_shader_base, BLUR, DARKEN) // will generate a variant of sh_megashader with BLUR and DARKEN enabled

// any code after is ignored and will be replaced with the source shader code with enabled keywords

• skip_compilation directive:

Syntax:

#pragma shady: skip_compilation

#pragma shady: skip_compilation

varying vec2 v_vTexcoord;
varying vec4 v_vColour;

float random(vec2 st) {
    return fract(sin(dot(st.xy, vec2(12.9898,78.233))) * 43758.5453123);
}

#define GRAYSCALE_FACTOR vec3(0.2126, 0.7152, 0.0722)
vec4 grayscale(vec4 color) {
    return vec4(vec3(dot(color.rgb, GRAYSCALE_FACTOR)), color.a);
}

const vec2 textureScale = vec2(4096.0 / 1920.0, 4096.0 / 1080.0);

void main()
{
    gl_FragColor = v_vColour * texture2D(gm_BaseTexture, v_vTexcoord);
}

// shader skipped by skip_compilation
void main() {}

• Defender^tm is too defensive. Some anti-viruses may yield a false-positive warning on the binaries. There's nothing I can do for now besides waiting for binaries to get trusted over time or getting a paid code sign certificate, which is not cost-effective for the current state of the project. If you're not sure, you can compile the tool yourself from sources using Visual Studio and .NET 8.0.

• "Project Directory Modified". To not see that GameMaker message-box every time any shader is processed navigate to Preferences > General Settings and enable Automatically reload changed files.

  Screenshot

  

• Changes in the shader aren't applying / shader has lost its code. Use Clean option for the Shady executable to flush possibly corrupted cache files. It is hooked to the "Brush" button in GameMaker IDE so you can just press that. Alternatively, you can call shady executable with the --clean option.

• GameMaker's shader compilation errors are reporting the wrong line number. As the preprocessor is "expanding" your added pragma directives and GameMaker's compiler is compiling already expanded sources, you will get error reports on the wrong lines that are from the modified expanded shader source. To view the modified shader to get the idea of what may have gone wrong, navigate to the "shaders" folder of the project, find the directory that has the name of the bugged shader and open the file with the _mod postfix inside the directory.

• Xpanda – uses a custom syntax and is not integrated with the compilation process but supports HLSL.
• glslfy – elder brother for non-GameMaker users.
• Unity Shader Variants.

• Optimize caching to not rewrite unmodified shaders.
• Support more shader languages?

Nikita Musatov - MusNik / KeeVee Games