shader

Write GPU shaders in OSL's syntax and turn them into GLSL for raylib windows.

A shader is a small program that runs on the graphics card once for every pixel. GPUs read a language called GLSL. std:shader lets you write the shader in OSL-style syntax (parentheses, number, no semicolons) and turns it into GLSL, with the usual Shadertoy variables already declared (iTime, iResolution, iMouse and friends).

It only translates text. To run the result you use raylib, which compiles it and draws with it.

A shader in OSL style#

Write def mainImage(fragCoord) and return the colour of the pixel at fragCoord. transpile returns the GLSL. This prints the lines that changed:

import "std:shader"

string code = `def mainImage(fragCoord) (
  vec2 uv = fragCoord / iResolution.xy
  number t = iTime * 1.5
  return vec4(uv, 0.5 + 0.5 * sin(t), 1.0)
)`

string glsl = shader.transpile(code)
for line in glsl.split("\n") (
  if line.contains("vec2 uv") or line.contains("float t") or line.contains("fragColor = vec4") (
    log line.trim()
  )
)

number became float, the blocks got braces, every line got its semicolon, and the return became an assignment to fragColor. Rename t to time and run it again. The output follows.

Plain statements#

A shader doesn't need a function at all. Write statements that set fragColor, and uv is there for you (the pixel's position from 0 to 1):

import "std:shader"

string glsl = shader.transpile("fragColor = vec4(uv, 0.0, 1.0)")
log glsl.startsWith("#version 330")
log glsl.contains("fragColor = vec4(uv, 0.0, 1.0);")
log glsl.contains("uniform float iTime;")

Real GLSL passes through#

Code that already has #version and a main is returned unchanged, so you can mix: hand-written GLSL for the hard cases, OSL style for the rest.

import "std:shader"

string handwritten = "#version 330\nvoid main() {}"
log shader.transpile(handwritten) == handwritten

Vertex shaders and the built-ins#

shader.transpile(code, {stage: "vertex"}) makes a vertex shader. shader.vertexDefault() is raylib's standard one, which passes the texture coordinate and colour on. Two example fragment shaders are included:

import "std:shader"

log shader.vertexDefault().contains("gl_Position")
log shader.plasma().contains("mainImage")
log shader.gradient().contains("iTime")

Drawing with it#

Pass the code to raylib.compileShader. It accepts OSL style or GLSL, so you rarely call transpile yourself. shader.use(draw) runs the drawing calls inside it, and uniforms like iTime are set each frame. This needs a window, so it doesn't run here:

import "std:raylib"
import "std:shader"

raylib.initWindow(640, 360, "Plasma").unwrap()
raylib.setTargetFPS(60)

auto plasma = raylib.compileShader(shader.plasma()).unwrap()

while !raylib.windowShouldClose() (
  plasma.setUniform("iTime", raylib.elapsed() / 1000).unwrap()
  plasma.setUniform("iResolution", raylib.vec(640, 360)).unwrap()
  raylib.draw(def() (
    plasma.drawFullscreen().unwrap()
  ))
)
raylib.closeWindow()

Swap shader.plasma() for shader.gradient() and run it on your machine. A shader that the graphics driver rejects fails with a ParseError, and raylib prints the driver's message.

import "std:shader"

string code = "number glow = uv.x * uv.y\nfragColor = vec4(glow, glow, glow, 1.0)"

log code.len

import "std:shader"

string code = "number glow = uv.x * uv.y\nfragColor = vec4(glow, glow, glow, 1.0)"

log code.len

true
true

API reference#