- name
>
SKILL.md
The skill file stays in the publisher's repository.
Paste the copied command in a terminal. It installs this SKILL.md into that agent.
npx skills add gamedev-skills/awesome-gamedev-agent-skills --skill shader-programming -a cursor -yPaste the copied command in a terminal. It installs this SKILL.md into that agent.
npx skills add gamedev-skills/awesome-gamedev-agent-skills --skill shader-programming -a claude-code -yPaste the copied command in a terminal. It installs this SKILL.md into that agent.
npx skills add gamedev-skills/awesome-gamedev-agent-skills --skill shader-programming -a codex -yPaste the copied command in a terminal. It installs this SKILL.md into that agent.
npx skills add gamedev-skills/awesome-gamedev-agent-skills --skill shader-programming -a grok -ySend the copied message in a Grok Bot chat. The Bot fetches this SKILL.md from GitHub and adds it to the skills all your Bots share.
Install this skill: https://github.com/gamedev-skills/awesome-gamedev-agent-skills/tree/HEAD/skills/disciplines/shader-programmingFrom the publisher
Shaders run per vertex and per pixel on the GPU. The pipeline, coordinate spaces, UV tricks and
the maths behind common effects port across engines; only the dialect and built-in names
change. This skill owns that technique in GLSL with HLSL equivalents. Load the engine skill
(godot-shaders, threejs-materials-lighting, pixijs-rendering) as well for the syntax,
built-ins and how the material is wired.
Not this skill: Godot shading language syntax and pipeline (godot-shaders), three.js
ShaderMaterial vs TSL (threejs-materials-lighting), PixiJS filters (pixijs-rendering),
particle systems (unreal-niagara), post-process stack settings (the engine's renderer docs),
per-pixel cost in a profiler (performance-optimization).
mix, step, smoothstep and clamp to branches on per-pixel values: pixels run
in lockstep, so a branch that differs between neighbours runs both sides. A branch on a
uniform is cheap.GLSL fragment snippets for desktop #version 330; each compiles with glslangValidator under
that header. For GLSL ES 3.00 (WebGL 2, three.js ShaderMaterial, PixiJS filters) add
precision highp float; and set uniform defaults from code: ES rejects uniform float edge = 0.05; with "cannot initialize this type of qualifier", while Godot's shading language accepts
it. HLSL forms and the longer effects are in references/effects.md.
uniform sampler2D tex;
uniform vec4 tint; // multiply tints without clipping; (1,1,1,1) is unchanged
in vec2 uv;
out vec4 frag;
void main() {
vec4 c = texture(tex, uv); // HLSL: tex.Sample(samp, uv)
frag = c * tint;
}
uniform sampler2D tex;
uniform float time; // seconds since start, supplied by the engine
uniform vec2 scroll_speed; // UV units per second
in vec2 uv;
out vec4 frag;
void main() {
vec2 scrolled = fract(uv + scroll_speed * time); // HLSL: frac(...)
frag = texture(tex, scrolled);
}
// Drive with an absolute time uniform, not a per-frame accumulator. With mipmaps, fract()
// leaves a thin seam where the UV jumps from 1 to 0; prefer a repeat sampler and drop fract().
// Hide pixels where noise < threshold; tint a thin band at the boundary.
uniform sampler2D tex;
uniform sampler2D noise_tex; // grayscale noise, 0..1
uniform float amount; // 0 = fully visible, 1 = fully dissolved
uniform float edge = 0.05; // width of the glowing edge band
uniform vec4 edge_color;
in vec2 uv;
out vec4 frag;
void main() {
vec4 c = texture(tex, uv);
float n = texture(noise_tex, uv).r;
float cut = amount * (1.0 + edge) - edge; // edge band starts below 0 -> none at amount 0
if (n <= cut) discard; // cut away dissolved pixels (all of them at 1)
float e = smoothstep(cut, cut + edge, n); // 0 at the edge -> 1 inside; keep edge > 0
frag = mix(edge_color, c, e); // HLSL: lerp(edge_color, c, e)
}
// WRONG: thresholding at `amount` directly — at amount 0 every pixel with
// n < edge is still tinted, so the "fully visible" sprite shows glowing specks.
in vec3 world_normal; // world space, interpolated from the vertex stage
in vec3 view_dir; // surface -> camera, world space
uniform float power = 3.0;
uniform vec3 rim_color;
out vec4 frag;
void main() {
// Interpolation does not preserve unit length, even with normalized vertex outputs.
vec3 normal = normalize(world_normal);
vec3 view = normalize(view_dir);
float f = pow(1.0 - clamp(dot(normal, view), 0.0, 1.0), power);
frag = vec4(rim_color * f, 1.0); // add to lighting; f peaks at the silhouette
}
glslangValidator path/to/effect.frag (the stage comes from
the suffix: .vert, .frag). Compile the ES variant too when it ships to the web: put
#version 300 es and precision highp float; at the top. For WGSL run
naga path/to/shader.wgsl. For Godot .gdshader files use the headless compile check in
godot-shaders.amount 0
shows no edge colour and at 1 discards everything; a vignette at strength 0 leaves the image
unchanged. Read the maths off the code, or render a test quad in the engine and read pixels
back.dot() drifts. Normalize in
the fragment stage.smoothstep edges. The GLSL spec leaves smoothstep(e0, e1, x) undefined when
e0 >= e1, so smoothstep(1.0, 0.5, d) may work on one GPU and not another. Write
1.0 - smoothstep(0.5, 1.0, d).discard disables early depth testing and can cost more on tiled mobile GPUs; use alpha
blending where the effect allows it.mediump time or large UVs shimmer and step. Use highp for
coordinates and time, and wrap time in the engine before it grows large.mix/lerp, fract/frac, texture()/.Sample(), vec2/float2,
M * v/mul(M, v), and mod vs fmod, which differ for negative numbers. Keep the source
engine's multiply order rather than swapping operands by reflex.ShaderMaterial renders nothing under three.js WebGPURenderer: that renderer only
runs node materials (TSL) on both of its backends. Keep WebGLRenderer for raw GLSL or port the
effect to TSL.GlProgram options need a vertex
string as well. Pass Pixi's default filter vertex shader (exported as defaultFilterVert) or
your own.references/effects.md: read when you need the GLSL-to-HLSL mapping table, clip-space and
matrix-order notes for porting, the full 2D outline, vignette and colour-grading shaders,
per-engine notes (Godot, Unity URP, Unreal, three.js, PixiJS), or the performance checklist.godot-shaders: Godot shading language, built-ins, render modes and a compile check.threejs-materials-lighting, pixijs-rendering: web material and filter wiring.procedural-gen: the noise that drives dissolve and procedural textures.performance-optimization: measuring what an effect costs per frame.Last verified: 2026-11-11.
#version 330, and under #version 300 es once uniform initializers are removed; with
initializers the ES compile fails with "cannot initialize this type of qualifier"
(https://github.com/KhronosGroup/glslang/releases/tag/16.6.0).WebGPURenderer runs node materials only.Filter.from passes gl to GlProgram.from, whose options type requires
vertex and fragment; defaultFilterVert is exported from src/filters/index.ts
(https://github.com/pixijs/pixijs/tree/v8.22.0/src/filters).© 2026 Skills Rack.
---name: shader-programmingdescription: >---# skills/disciplines/shader-programming/SKILL.mdFAQ
Download skills/disciplines/shader-programming/SKILL.md from the publisher, or copy the path and open the repository. PlugMCP lists the skill and does not host the file.
The publisher keeps it at https://github.com/gamedev-skills/awesome-gamedev-agent-skills.
Claude, Cursor, Codex, and Grok Build can read a SKILL.md you add from the publisher's repository. Grok Bot installs it when you send the skill's GitHub folder link in a chat.