Javier Amador

Shaders, live: GLSL in the browser (and HLSL alongside)

2026-07-13T00:00:00Z

Note to self: mockup post to test the {% shader %} embed and glsl / hlsl highlighting. Safe to delete before launch.

Half of technical-art writing is "here's the code, here's what it does." A static screenshot loses the motion; a wall of code loses the intuition. So on this site a shader can run right in the page, with its source shown directly beneath it.

A live one — edit it yourself

The code below the canvas is the shader driving it, and it's editable: change a number, tweak the colours, and the canvas recompiles as you type. Try bumping the 0.4 in the ramp or swapping the green/amber values. Broke it? The last working version keeps running and the compile error shows over the canvas; hit revert to restore the original.

Domain-warped flow — five cheap sine folds over a green→amber ramp. Editable: type to recompile.

fragment.glsl · live

void mainImage(out vec4 O, in vec2 I)
{
    // Centre the coords and keep them square regardless of canvas size.
    vec2 uv = (2.0 * I - iResolution.xy) / iResolution.y;

    // Domain warping: fold the space back on itself a few times.
    float t = iTime * 0.15;
    for (float i = 1.0; i < 6.0; i++) {
        uv.x += 0.32 / i * sin(i * 2.4 * uv.y + t * 2.0 + i);
        uv.y += 0.30 / i * cos(i * 1.9 * uv.x + t * 1.7 + i);
    }

    // Ramp between a mossy green and a warm amber.
    float v = 0.5 + 0.5 * sin(uv.x * 2.0 + uv.y * 2.0 + iTime * 0.4);
    vec3 green = vec3(0.30, 0.48, 0.32);
    vec3 amber = vec3(0.93, 0.78, 0.42);
    vec3 col = mix(green, amber, v) * (0.7 + 0.3 * v);

    O = vec4(col, 1.0);
}

The embed follows the Shadertoy convention, so anything you prototype there drops straight in: write mainImage(out vec4, in vec2) and you get iResolution, iTime, and iMouse for free.

It reads the pointer, too

iMouse.xy is the cursor in pixels — hover the canvas below and the glow follows you.

Move your cursor over me — a soft light tracking iMouse.

fragment.glsl

void mainImage(out vec4 O, in vec2 I)
{
    vec2 uv = I / iResolution.xy;
    vec2 m  = iMouse.xy / iResolution.xy;

    // Fall off from the cursor; drift to centre before it's ever touched.
    if (iMouse.xy == vec2(0.0)) m = vec2(0.5);
    float d = distance(uv, m);
    float glow = smoothstep(0.45, 0.0, d);

    vec3 col = mix(vec3(0.11, 0.12, 0.10), vec3(0.47, 0.68, 0.51), glow);
    O = vec4(col, 1.0);
}

The HLSL side

WebGL only speaks GLSL, so HLSL can't run here — but it still gets first-class highlighting, which is what you want when the source of truth is an Unreal Custom node or a Unity surface function. Here's a rim-light term I reach for constantly:

// Unreal "Custom" node — Fresnel rim term.
// In:  N (float3 world normal), V (float3 view dir), power, scale, tint
// Out: float3 additive rim colour
float3 RimLight(float3 N, float3 V, float power, float scale, float3 tint)
{
    float fresnel = pow(saturate(1.0 - dot(normalize(N), normalize(V))), power);
    return tint * (fresnel * scale);
}

When a preview actually helps, I port the effect to a GLSL mainImage and drop it in a live canvas next to the HLSL — same maths, running proof. The HLSL stays the reference; the GLSL is the demo.

That's the whole system: GLSL runs, HLSL is shown, and the source is never a screenshot.

Multi-tag test: shading a stylised waterfall

2026-07-13T00:00:00Z

Note to self: throwaway post to test posts that carry more than one category (categories: [environment, shaders]). It should appear under both the environment and shaders filters on /blog/. Delete before launch.

A waterfall is a nice test case because it sits squarely between two disciplines: the environment art of the rock shelf and surrounding scatter, and the shader work that sells the moving water. This post is tagged with both.

The environment side

The silhouette does most of the work. A modular rock kit gives the ledge its stepped profile, and a light scatter of wet pebbles and moss breaks up the hard edges where the water meets stone.

The shader side

The water itself is two scrolling normal maps at different speeds, plus a foam mask driven by depth so the white water gathers where the surface meets geometry. Nothing fancy — just enough motion to read as "falling."

Why tag it twice

Some work genuinely belongs to more than one topic. Tagging this under both environment and shaders means it surfaces whichever lens a reader is browsing through — and it's a good check that the filter matches on any of a post's tags, not just the first.

Math test: the rendering equation, briefly

2026-07-13T00:00:00Z

Note to self: mockup post to test KaTeX (inline + block, fractions, integrals, Greek, matrices). Delete before launch.

Almost everything a technical artist touches in lighting traces back to one equation. It looks intimidating written out, but each piece has a plain-language job. Here it is.

The equation

The outgoing radiance $L_o$ from a point $x$ in direction $\omega_o$ is the emitted light plus everything reflected from the hemisphere $\Omega$ above the surface:

L_o(x, \omega_o) = L_e(x, \omega_o) + \int_{\Omega} f_r(x, \omega_i, \omega_o)\, L_i(x, \omega_i)\,(\omega_i \cdot n)\, d\omega_i

Reading it left to right: take the emitted light $L_e$ , then add up — that's the integral $\int_\Omega$ — the contribution of every incoming direction $\omega_i$ , weighted by how the surface reflects it and how grazing the angle is.

The pieces

$L_i(x, \omega_i)$ — the light arriving from direction $\omega_i$ .
$f_r(x, \omega_i, \omega_o)$ — the BRDF, the surface's rule for turning incoming light into outgoing light.
$\omega_i \cdot n$ — the cosine term, $\cos\theta_i$ . Light hitting head-on counts fully; light at a grazing angle barely counts at all.

That cosine is why a floor looks bright underfoot and dim toward the horizon.

A concrete BRDF

For a simple diffuse surface with albedo $\rho$ , the BRDF is just a constant:

f_r = \frac{\rho}{\pi}

The $\pi$ in the denominator is the part everyone forgets — it's what keeps energy conserved so a surface never reflects more light than it receives.

Specular is where it gets interesting. The Fresnel term, using Schlick's approximation, is:

F(\theta) = F_0 + (1 - F_0)\,(1 - \cos\theta)^5

where $F_0$ is the reflectance at normal incidence. For most dielectrics $F_0 \approx 0.04$ , which is why even matte plastic gets a bright rim at grazing angles.

Why the integral is hard

We can't evaluate $\int_\Omega$ exactly in real time, so we approximate it. Monte Carlo integration samples $N$ random directions and averages:

\int_{\Omega} f(\omega)\, d\omega \approx \frac{1}{N} \sum_{k=1}^{N} \frac{f(\omega_k)}{p(\omega_k)}

The $p(\omega_k)$ is the probability of picking each sample — importance sampling just means choosing $p$ to match where $f$ is large, so you spend samples where they matter.

A tiny bit of linear algebra

Transforming a normal isn't the same as transforming a position. If $M$ is your model matrix, normals must use the inverse-transpose:

n' = (M^{-1})^{\mathsf{T}}\, n

For a rotation like

R = \begin{bmatrix} \cos\theta & -\sin\theta \\ \sin\theta & \cos\theta \end{bmatrix}

the inverse-transpose equals $R$ itself, which is why pure rotations never distort your normals — but non-uniform scale does, and that is the usual culprit behind broken lighting.

Wrapping up

You rarely type these equations into a shader directly, but knowing what each term does turns "the lighting looks wrong" into a diagnosis. The cosine, the $\pi$ , the Fresnel rim — each one is a knob with a physical meaning.

If the math above rendered as crisp symbols rather than raw dollar signs, KaTeX is working.

Scroll test: building a modular rock kit

2026-07-13T00:00:00Z

Note to self: this is a throwaway post to test the back-to-top button and how a long article reads. Delete it before launch.

Modular kits are the backbone of any large environment. Instead of sculpting a whole cliff face as one giant mesh, you build a small set of reusable pieces and assemble them like LEGO. Done well, a kit of eight rocks can dress an entire canyon and still tile cleanly at every seam. This post walks through how I approach one.

Why modular

The temptation early on is to sculpt everything bespoke. It looks great in isolation, but it does not scale: memory balloons, iteration slows to a crawl, and the moment a level designer wants the cliff two metres taller you are back in ZBrush for an afternoon.

A kit flips that trade. You spend more time up front on a handful of pieces, and in return you get:

Fast blockouts — designers grey-box with the real assets from day one.
Consistent silhouette — every rock shares the same material and wear language.
Cheap memory — a few textures and meshes, instanced hundreds of times.
Painless changes — retexture once, and the whole canyon updates.

The base set

I usually start with the smallest set that still reads as varied. Eight shapes is my comfort zone:

A large hero boulder with a strong directional silhouette.
Two medium blockers that hide seams between larger pieces.
Three small scatter rocks for breaking up flat ground.
A wide, flat "shelf" piece for ledges and steps.
A tall spire for verticality and reading distance.

The trick is that none of these should look finished on their own. A modular piece that looks perfect in isolation is usually too distinctive to repeat.

A note on scale

Model everything to real-world scale from the start. If your engine treats one unit as one metre, a hero boulder around three metres tall feels right next to a human character. Getting this wrong early means refitting every texture density later.

Sculpting for tiling

The seams are where modular kits live or die. Two habits keep them invisible:

Keep the contact edges flat and consistent in height, so pieces butt together without gaps or intersections poking through.
Push the interesting detail toward the centre of each piece, away from the seam, so the eye is drawn to the silhouette rather than the join.

Here is the rough density I aim for when I retopologise:

hero boulder     ~4,000 tris
medium blocker   ~1,500 tris
small scatter     ~600 tris
shelf             ~1,200 tris
spire            ~2,000 tris

Those are starting points, not rules. A rock read from thirty metres away can shed half its triangles and nobody will notice.

Texturing the set

I bake a single trim-friendly material and drive variation with vertex colours rather than unique textures per rock. A three-channel mask goes a long way:

Red — moss and lichen in the crevices.
Green — sand and dust accumulation on upward faces.
Blue — wet, darkened rock near the base.

Blending those in the shader means one material serves a mossy forest floor and a dry desert mesa, just by changing the mask weights per instance.

Wear and edges

Edge wear is the cheapest way to sell "rock". A curvature map driving a lighter, chipped colour along convex edges reads as chunks that have broken away over time. Keep it subtle — the moment every edge is bright, the illusion collapses into a cartoon.

Placing the kit

With the pieces built, dressing a scene becomes a composition problem rather than a modelling one. A few habits that help:

Rotate and scale aggressively. The same boulder at 0.8x and rotated 140 degrees reads as a different rock. Non-uniform scale within reason is your friend.
Bury the seams. Sink scatter rocks slightly into the ground and let smaller pieces hide the joins between big ones.
Vary the spacing. Nature clumps. Tight clusters with open gaps look far more believable than an even scatter.

The goal is that a player never counts eight rocks. They see a canyon.

Lighting and final read

None of this matters if the lighting flattens it. I always dress and light in tandem: a grazing key light rakes across the silhouettes and makes the sculpted detail earn its triangles. Ambient occlusion in the crevices ties the pieces to the ground and hides the last of the seams.

A quick checklist

Before I call a kit done, I run through this:

Do the pieces tile at every rotation without gaps?
Does the silhouette read from the intended viewing distance?
Is the triangle budget justified by what the camera actually sees?
Can I redress the kit into a different biome with only mask changes?
Would a level designer be able to build with it without asking me anything?

If the answer to all five is yes, the kit is ready to ship — and I never have to open ZBrush just because someone wanted the cliff a little taller.

Wrapping up

Modular kits are less about modelling skill and more about restraint and planning. Build the smallest set that reads as varied, keep the seams boring, and let placement and lighting do the heavy lifting. Your future self — and every designer on the team — will thank you.

Scroll back up with the little arrow in the corner. That is what it is here to test.

A tiny shader for wind

2026-06-24T00:00:00Z

Wind is one of those effects that sells a scene instantly. Here's the smallest version I keep reaching for.

The idea

Offset each vertex by a sine wave, scaled by how high up the vertex sits — so the trunk stays put and the tips move most.

float sway = sin(time + worldPos.x) * heightMask;
position.xz += sway * strength;

Written out, the horizontal offset for a vertex is $o = A \sin(\omega t + \phi)\, m_h$ , where $m_h$ is the height mask and $A$ , $\omega$ , $\phi$ are amplitude, frequency and phase:

o = A \sin(\omega t + \phi)\, m_h

Add a second wave at a different frequency and you get something that reads as natural motion rather than a metronome.

Building a stylised forest floor

2026-06-02T00:00:00Z

A quick breakdown of how I approach a stylised forest floor — from the base material layers to the scatter pass that ties everything together.

Starting with the ground material

The base is three blended layers: soil, moss, and scattered leaf litter. Keeping each layer independent means I can tune coverage without repainting.

Soil — the darkest value, does most of the shadow work.
Moss — a cooler mid-tone that reads as "damp".
Leaf litter — warm accents, used sparingly.

The trick with stylised work is restraint: let a few strong shapes carry the read.

The scatter pass

Once the material reads well up close, I scatter meshes across it — small rocks, ferns, and fallen branches — using vertex colours to mask density.

That's the whole loop: material first, scatter second, lighting last.