Optionalgl: WebGLRenderingContext
the current WebGL rendering
context (renderer.gl — undefined on non-WebGL renderers, which
simply skips the GLSL realization)
a string containing the GLSL vertex
source, OR a sources object {vertex, fragment, wgsl, precision, label} carrying one realization per backend (any omittable)
Optionalfragment: string
a string containing the GLSL fragment source
Optionalprecision: string
float precision ('lowp', 'mediump' or 'highp').
// create a basic shader
let myShader = new me.GLShader(
// WebGL rendering context
gl,
// vertex shader
[
"void main() {",
" gl_Position = doMathToMakeClipspaceCoordinates;",
"}"
].join("\n"),
// fragment shader
[
"void main() {",
" gl_FragColor = doMathToMakeAColor;",
"}"
].join("\n")
)
// use the shader
myShader.bind();
the location attributes of the shader
Readonlydestroyedtrue once destroy has been called. After this flag is
true, every method on the shader is a silent no-op — callers
holding a stale reference (e.g. a still-registered update loop)
do not crash the frame.
the active gl rendering context
Readonlyistrue when this shader carries a WebGL realization: a
{vertex, fragment} GLSL pair compiled against a live context.
Readonlyistrue when this shader carries a WebGPU realization: a complete
wgsl module (see the class docs for the module contract).
optional debug label, carried onto the GPU shader module (shows up in browser GPU error messages and profilers)
a reference to the shader program (once compiled)
When true, a renderable will NOT auto-destroy this shader when it is
removed from its postEffects (via the shader setter,
removePostEffect, clearPostEffects) or when the renderable itself
is destroyed. Set this on a shader shared across several renderables so
one of them going away doesn't free the GL program still used by the
others — you then own its lifecycle and call destroy yourself.
Readonlysuspendedtrue while the WebGL context is lost (and until it's
restored). The GL program/attributes/uniforms are released
during the suspended window but the shader source code is
preserved so _onContextRestored can rebuild the
program against the new context. User code generally doesn't
read this — methods short-circuit internally — but it's
available for diagnostic / debug-plugin tooling.
the uniforms of the shader
the complete WGSL module source, when GLShader#isWebGPU
Installs this shader program as part of current rendering state
Create an independent copy of this shader, compiled as its own GL program from the same vertex + fragment sources (and precision), with every uniform value set so far replayed onto the copy. Use it when several renderables need the same custom shader with different uniform values — a single instance has a single set of uniforms.
Ownership and lifecycle state do NOT carry over: the clone's
shared flag is always reset to false, even when cloning
a shared shader — the clone is caller-owned and will be auto-destroyed
by the renderable it is assigned to, unless you explicitly set
shared = true on it yourself. Note that ShaderEffect (which wraps
a GLShader by composition) has its own clone() with the same
semantics, which additionally copies its effect-level state (extra
setTexture bindings).
a new, caller-owned shader (shared === false)
destroy this shader objects resources (program, attributes, uniforms). Idempotent — calling destroy twice (or after a context-lost suspend) is safe. Unsubscribes from the renderer's context lost / restored events so a destroyed shader is never automatically resurrected.
returns the location of an attribute variable in this shader program
the name of the attribute variable whose location to get.
number indicating the location of the variable name if found. Returns -1 otherwise
activate the given vertex attribute for this shader.
Note: since 20.0 the engine no longer calls this per frame — each
WebGLBatcher captures its attribute layout once into an immutable
vertex-state object (VAO) at init (see WebGLBatcher.createVertexState).
Kept public for custom callers managing their own vertex setup.
Custom shaders hosted by a built-in batcher must declare that
batcher's attributes first, in layout order — attribute locations
are bound in declaration order and the vertex state is frozen.
the current WebGL rendering context
an array of vertex attributes
the size of a single vertex in bytes
a complete custom shader program. Historically a WebGL-only GLSL program (the class keeps its name for compatibility), since 20.0 it can carry one realization per GPU backend — a
{vertex, fragment}GLSL pair for the WebGL renderer and/or a completewgslmodule for the WebGPU renderer — mirroring how ShaderEffect carries one body per shading language. The GLShader#isWebGL / GLShader#isWebGPU flags report which realizations exist; a renderer hosts the one it speaks and anything else degrades to the built-in shading (never fatal).The WGSL module contract (custom
Meshshaders)The
wgslsource is a complete module hosted by the mesh batchers: entry points must be namedvertex_main(@vertex) andfragment_main(@fragment), over the frozen mesh vertex layout —@location(0) aVertex : vec3f,@location(1) aRegion : vec2f,@location(2) aColor : vec4f, plus@location(3) aNormal : vec3fon the 48-bytelitlayout. Bind groups (declare only what is read): group 0FrameUniforms {projection : mat4x4<f32>, lineWidth : f32}, group 1 the mesh texture + sampler, group 2 theLight3dBlock(lit host only), group 3MeshUniforms {model, view : mat4x4<f32>, tint, params, emissive : vec4f}(params.x= alpha cutout). The vertex stage owns the projection (projection * view * model) and must remap the GL-convention clip z:(clip.z + clip.w) * 0.5. WGSL validation is asynchronous and never throws — a failing module logs its errors once and the mesh falls back to the built-in shading.