بلاگ

Rendering text in WebGL opens up a whole new world of unique visual effects and creative possibilities that are often
impossible to achieve with traditional HTML, CSS and JavaScript alone. By the end of this tutorial, we’ll have created
WebGL-rendered text elements that perfectly mimic the underlying HTML structure. Since we’ll be taking an HTML-first
approach, it will be responsive, SEO-friendly and accessible. We’ll be doing every step manually so you’ll gain a
solid understanding of the principles behind merging HTML and WebGL, and text-specific stuff like how to translate CSS
styles into the 3D world.

We’ll be creating the below demo:

We’ll start off with a standard styled HTML setup. Then we’ll recreate the text elements we have inside a 3D world.
From there, we’ll position, scale and make the text responsive with the 3D space. Next, we’ll replicate the “mask
reveal effect” in WebGL. And finally, we’ll apply some scroll-driven post processing effects to the scene.

Below are the core steps we’ll follow to achieve the final result:

1. Create the text as a HTML element and style it regularly using CSS
2. Create a 3D world and recreate the text element within it
3. Merge the 3D and 2D world, so that we can style the 3D text by using our viewport’s dimensions
4. Sync the key properties like position, size and font — from the HTML element to the WebGL text element
5. Hide the original HTML element
6. Be left with only the 3D text, fully styled and positioned in sync with the hidden HTML structure
7. Apply animations and post-processing to enhance our 3D scene

Necessities and Prerequisites

We’ll be using the Three.js library to create the 3D world, so you should already be familiar with its basics. For the
creation of text meshes, we’ll be using the
troika-three-text
library, but you don’t have to be familiar with the library beforehand. If you’ve used HTML, CSS and JavaScript, know
the basics of Three.JS,
you’re good to go.

Let’s get started.

1. Creating the Regular HTML and Making it Responsive

Before diving into the WebGL and Three.js implementation, we first need to create the HTML structure that we’ll later
mimic in the 3D world. I’ve set up a very simple page with some quick responsive content — you can find the
setup content
in the demo repository under
index.html
and
styles.css
.

HTML
:

<div class="content">
  <div class="container">
    <section class="section__heading">
      <h3 data-animation="webgl-text" class="text__2">THREE.JS</h3>
      <h2 data-animation="webgl-text" class="text__1">
        RESPONSIVE AND ACCESSIBLE TEXT
      </h2>
    </section>
    <section class="section__main__content">
      <p data-animation="webgl-text" class="text__2">
        THIS TEXT IS STYLED TO LOOK LIKE A TYPICAL BLOCK OF TEXT ON A STANDARD
        WEBSITE. BUT UNDER THE SURFACE, IT'S BEING RENDERED WITH WEBGL INSTEAD
        OF TRADITIONAL HTML.
      </p>
      <p data-animation="webgl-text" class="text__2">
        THIS OPENS THE DOOR TO CUSTOM SHADER EFFECTS AND INTERACTIONS THAT GO
        BEYOND WHAT'S POSSIBLE WITH TRADITIONAL HTML.
      </p>
      <p data-animation="webgl-text" class="text__2">
        WE KEEP THE UNDERYLING HTML STRUCTURE PRESENT IN THE DOM. RATHER THAN
        CREATING MESHES DIRECTLY IN THREE.JS, THE SCENE IS BUILT BY READING FROM
        THE EXISTING HTML CONTENT. THIS WAY, SCREEN READERS, SEARCH ENGINES, AND
        OTHER TOOLS CAN STILL INTERPRET THE PAGE AS EXPECTED.
      </p>
    </section>
    <section class="section__footer">
      <p data-animation="webgl-text" class="text__3">
        NOW GO CRAZY WITH THE SHADERS :)
      </p>
    </section>
  </div>
</div>

styles.css

:root {
  --clr-text: #fdcdf9;
  --clr-selection: rgba(255, 156, 245, 0.3);
  --clr-background: #212720;
}

@font-face {
  font-family: "Humane";
  src: url("/fonts/Humane-Black.ttf") format("truetype");
  font-weight: 900;
  font-style: normal;
  font-display: swap;
}

@font-face {
  font-family: "Humane";
  src: url("/fonts/Humane-Bold.ttf") format("truetype");
  font-weight: 700;
  font-style: normal;
  font-display: swap;
}

@font-face {
  font-family: "Humane";
  src: url("/fonts/Humane-ExtraBold.ttf") format("truetype");
  font-weight: 800;
  font-style: normal;
  font-display: swap;
}

@font-face {
  font-family: "Humane";
  src: url("/fonts/Humane-ExtraLight.ttf") format("truetype");
  font-weight: 200;
  font-style: normal;
  font-display: swap;
}

@font-face {
  font-family: "Humane";
  src: url("/fonts/Humane-Light.ttf") format("truetype");
  font-weight: 300;
  font-style: normal;
  font-display: swap;
}

@font-face {
  font-family: "Humane";
  src: url("/fonts/Humane-Medium.ttf") format("truetype");
  font-weight: 500;
  font-style: normal;
  font-display: swap;
}

@font-face {
  font-family: "Humane";
  src: url("/fonts/Humane-Regular.ttf") format("truetype");
  font-weight: 400;
  font-style: normal;
  font-display: swap;
}

@font-face {
  font-family: "Humane";
  src: url("/fonts/Humane-SemiBold.ttf") format("truetype");
  font-weight: 600;
  font-style: normal;
  font-display: swap;
}

@font-face {
  font-family: "Humane";
  src: url("/fonts/Humane-Thin.ttf") format("truetype");
  font-weight: 100;
  font-style: normal;
  font-display: swap;
}

body {
  background: var(--clr-background);
}

canvas {
  position: fixed;
  top: 0;
  left: 0;
  width: 100vw;
  height: 100vh;
  pointer-events: none;
}

::selection {
  background-color: var(--clr-selection);
  color: var(--clr-text);
}

::-moz-selection {
  background-color: var(--clr-selection);
  color: var(--clr-text);
}

.text__1,
.text__2,
.text__3 {
  color: var(--clr-text);
  text-align: center;
  margin-block-start: 0;
  margin-block-end: 0;
}

.content {
  width: 100%;
  font-family: Humane;
  font-size: 0.825vw;

  @media (max-width: 768px) {
    font-size: 2vw;
  }
}
.container {
  display: flex;
  flex-direction: column;
  align-items: center;

  width: 70em;
  gap: 17.6em;
  padding: 6em 0;

  @media (max-width: 768px) {
    width: 100%;
  }
}

.container section {
  display: flex;
  flex-direction: column;
  align-items: center;
  height: auto;
}

.section__main__content {
  gap: 5.6em;
}

.text__1 {
  font-size: 19.4em;
  font-weight: 700;
  max-width: 45em;

  @media (max-width: 768px) {
    font-size: 13.979em;
  }
}

.text__2 {
  font-size: 4.9em;
  max-width: 7.6em;
  letter-spacing: 0.01em;
}

.text__3 {
  font-size: 13.979em;
  max-width: 2.4em;
}

A Few Key Notes about the Setup

• The
  <canvas>
  element is set to cover the entire screen, fixed in place behind the main content. We want a full screen canvas
  covering the entire screen behind our main content at all times.
• All text elements intended for WebGL rendering are marked with data-animation=”webgl-text” for clarity and easy
  selection when we begin scripting.

The purpose of this setup is to function as the “placeholder” that we can mimic in our 3D implementation. So, it’s
important to
position and style your text at this stage
to ensure it matches the final sizing and positioning that you want to achieve. All text formatting properties like
font-size, letter-spacing, line-height etc. are the properties you want to focus on, because we’ll later read these
computed styles directly from the DOM during the WebGL phase. Color is optional here, as we can handle text coloring
later with shaders inside WebGL.

That’s it for the HTML and CSS setup! It’s all we need for the foundation to move onto our JavaScript and WebGL
implementation.

2. Initial 3D World Setup

Let’s move onto the JavaScript and WebGL implementation. I’ll be using TypeScript, but you can easily follow along
with vanilla JavaScript if you prefer. I’m assuming you’re already familiar with the basics of Three.js, so I’ll focus
on explaining the high-level setup rather than covering every detail.

Below is the starter TypeScript and Three.JS base that I’ll be using for this demo.

// main.ts

import Commons from "./classes/Commons";
import * as THREE from "three";

/**
 * Main entry-point.
 * Creates Commons and Scenes
 * Starts the update loop
 * Eventually creates Postprocessing and Texts.
  */
class App {
  private commons!: Commons;

  scene!: THREE.Scene;

  constructor() {
    document.addEventListener("DOMContentLoaded", async () => {
      await document.fonts.ready; // Important to wait for fonts to load when animating any texts.

      this.commons = Commons.getInstance();
      this.commons.init();

      this.createScene();
      
      this.addEventListeners();

      this.update();
    });
  }

  private createScene() {
    this.scene = new THREE.Scene();
  }

  /**
   * The main loop handler of the App
   * The update function to be called on each frame of the browser.
   * Calls update on all other parts of the app
   */
  private update() {
    this.commons.update();

    this.commons.renderer.render(this.scene, this.commons.camera);

    window.requestAnimationFrame(this.update.bind(this));
  }

  private addEventListeners() {
    window.addEventListener("resize", this.onResize.bind(this));
  }

  private onResize() {
    this.commons.onResize();
  }
}

export default new App();

// Commons.ts

import { PerspectiveCamera, WebGLRenderer, Clock } from "three";

import Lenis from "lenis";

export interface Screen {
  width: number;
  height: number;
  aspect: number;
}

export interface Sizes {
  screen: Screen;
  pixelRatio: number
}

/**
 * Singleton class for Common stuff.
 * Camera
 * Renderer
 * Lenis
 * Time
 */
export default class Commons {
  private constructor() {}
  
  private static instance: Commons;

  lenis!: Lenis;
  camera!: PerspectiveCamera;
  renderer!: WebGLRenderer;

  private time: Clock = new Clock();
  elapsedTime!: number;

  sizes: Sizes = {
    screen: {
      width: window.innerWidth,
      height: window.innerHeight,
      aspect: window.innerWidth / window.innerHeight,
    },
    pixelRatio: this.getPixelRatio(),
  };

  private distanceFromCamera: number = 1000;

  /**
   * Function to be called to either create Commons Singleton instance, or to return existing one.
   * TODO AFTER: Call instances init() function.
   * @returns Commons Singleton Instance.
   */
  static getInstance() {
    if (this.instance) return this.instance;

    this.instance = new Commons();
    return this.instance;
  }

  /**
   * Initializes all-things Commons. To be called after instance is set.
   */
  init() {
    this.createLenis();
    this.createCamera();
    this.createRenderer();
  }

  /**
   * Creating Lenis instance.
   * Sets autoRaf to true so we don't have to manually update Lenis on every frame.
   * Resets possible saved scroll position.
   */
  private createLenis() {
    this.lenis = new Lenis({ autoRaf: true, duration: 2 });
  }

  private createCamera() {
    this.camera = new PerspectiveCamera(
      70,
      this.sizes.screen.aspect,
      200,
      2000
    );
    this.camera.position.z = this.distanceFromCamera;
    this.camera.updateProjectionMatrix();
  }

  /**
   * createRenderer(): Creates the common WebGLRenderer to be used.
   */
  private createRenderer() {
    this.renderer = new WebGLRenderer({
      alpha: true, // Sets scene background to transparent, so our body background defines the background color
    });

    this.renderer.setSize(this.sizes.screen.width, this.sizes.screen.height);

    this.renderer.setPixelRatio(this.sizes.pixelRatio);

	  // Creating canvas element and appending to body element.
    document.body.appendChild(this.renderer.domElement); 
  }

  /**
   * Single source of truth to get pixelRatio.
   */
  getPixelRatio() {
    return Math.min(window.devicePixelRatio, 2);
  }

  /**
   * Resize handler function is called from the entry-point (main.ts)
   * Updates the Common screen dimensions.
   * Updates the renderer.
   * Updates the camera.
   */
  onResize() {
    this.sizes.screen = {
      width: window.innerWidth,
      height: window.innerHeight,
      aspect: window.innerWidth / window.innerHeight,
    };
    this.sizes.pixelRatio = this.getPixelRatio();

    this.renderer.setSize(this.sizes.screen.width, this.sizes.screen.height);
    this.renderer.setPixelRatio(this.sizes.pixelRatio);

    this.onResizeCamera();
  }

  /**
   * Handler function that is called from onResize handler.
   * Updates the perspective camera with the new adjusted screen dimensions
   */
  private onResizeCamera() {
    this.camera.aspect = this.sizes.screen.aspect;
    this.camera.updateProjectionMatrix();
  }

  /**
   * Update function to be called from entry-point (main.ts)
   */
  update() {
    this.elapsedTime = this.time.getElapsedTime();
  }
}

A Note About Smooth Scroll

When syncing HTML and WebGL worlds,
you should use a custom scroll
. This is because the native scroll in browsers updates the scroll position at irregular intervals and does not thus
guarantee frame-perfect updates with our requestAnimationFrame loop and our WebGL world, causing a
jittery and unsynchronized movement
.

By integrating a custom scroll (Lenis in this case), we ensure our scroll updates perfectly match the frame updates of
our WebGL world.

Right now we are seeing an empty 3D world, continuously being rendered.

We’re only missing one thing to get something visible in our 3D world: the creation of the text elements. So let’s
move onto creating our WebGLText class next.

3. Creating WebGLText Class and Texts Meshes

For the creation of the text meshes, we’ll be using
troika-three-text
library.

npm i troika-three-text

We’ll now create a reusable

WebGLText
class

. This will handle turning each HTML element into a 3D text mesh, using Troika and our Three.js scene.

Here’s the basic setup:

// WebGLText.ts

import Commons from "./Commons";
import * as THREE from "three";

// @ts-ignore
import { Text } from "troika-three-text";

interface Props {
  scene: THREE.Scene;
  element: HTMLElement;
}

export default class WebGLText {
  commons: Commons;

  scene: THREE.Scene;
  element: HTMLElement;

  computedStyle: CSSStyleDeclaration;
  font!: string; // Path to our .ttf font file.
  bounds!: DOMRect;
  color!: THREE.Color;
  material!: THREE.ShaderMaterial;
  mesh!: Text;

  // We assign the correct font bard on our element's font weight from here
  weightToFontMap: Record<string, string> = {
    "900": "/fonts/Humane-Black.ttf",
    "800": "/fonts/Humane-ExtraBold.ttf",
    "700": "/fonts/Humane-Bold.ttf",
    "600": "/fonts/Humane-SemiBold.ttf",
    "500": "/fonts/Humane-Medium.ttf",
    "400": "/fonts/Humane-Regular.ttf",
    "300": "/fonts/Humane-Light.ttf",
    "200": "/fonts/Humane-ExtraLight.ttf",
    "100": "/fonts/Humane-Thin.ttf",
  };
  
  private y: number = 0; // Scroll-adjusted bounds.top
  
  private isVisible: boolean = false;

  constructor({ scene, element }: Props) {
    this.commons = Commons.getInstance();

    this.scene = scene;
    this.element = element;

    this.computedStyle = window.getComputedStyle(this.element); // Saving initial computed style.
  }
}

We have access to the
Text class
from Troika, which allows us to create text meshes elements and apply styling to it using familiar properties like
fontSize, letterSpacing, and font. I’ll cover everything you need to style your text responsively in this tutorial,
but I implore you to take a look at the full documentation and its possibilities
here
.

Troika doesn’t ship with TypeScript definitions out of the box, so if you’re using TS, you can quickly get around this
by creating a type declaration file in the root of your project. It’s not pretty, but it gets the job done while
keeping TypeScript happy.

// troika.d.ts

declare module "troika-three-text" {
  const value: any;
  export default value;
}

Let’s start by creating new methods called createFont(), createColor() and createMesh().

createFont()
: Selects the appropriate .ttf file based on the DOM element’s font-weight. If a match isn’t found, we fall back to
the regular weight. Adjust the mapping to match your own font files and multiple font families if needed.

// WebGLText.ts 

private createFont() {
    this.font =
      this.weightToFontMap[this.computedStyle.fontWeight] ||
      "/fonts/Humane-Regular.ttf";
}

createColor()
: Converts the computed CSS color into a THREE.Color instance:

// WebGLText.ts 

private createColor() {
    this.color = new THREE.Color(this.computedStyle.color);
}

createMesh():
Instantiates the text mesh and sets some basic properties. Copies the text’s inner text and sets it onto the mesh.
Adds the mesh to our Three.JS scene. We anchor the text from the left-center to match typical HTML layout
expectations.

// WebGLText.ts 
private createMesh() {
  this.mesh = new Text();

  this.mesh.text = this.element.innerText; // Copying HTML content over to the mesh
  this.mesh.font = this.font;

  // Anchor the text to the left-center (instead of center-center)
  this.mesh.anchorX = "0%";
  this.mesh.anchorY = "50%";

  this.mesh.color = this.color;

  this.scene.add(this.mesh);
}

⚠️ When copying text contents over to the Mesh, avoid using innerHTML or textContent and use innerText instead as it
gives the most layout-accurate and consistent results.

setStaticValues
(): Let’s also create a baby setStaticValues() method which will set the critical properties of our text mesh based on
the computedStyle.

We sets values like font size based on computed CSS. We’ll expand this more as we sync more styles down the line.

We want to call all these methods in the constructor like this:

// WebGLText.ts 
 constructor({ scene, element }: Props) {
  this.commons = Commons.getInstance();

  this.scene = scene;
  this.element = element;

  this.computedStyle = window.getComputedStyle(this.element); // Saving initial computed style.

  this.createFont();
  this.createColor();
  this.createMesh();
  this.setStaticValues();
}

Instantiating Text Elements from DOM

Finally, let’s update our App class (main.ts), and hook this all up by scanning for DOM elements with a
data-animation=”webgl-text” attribute — creating a WebGLText instance for each one:

// main.ts

texts!: Array<WebGLText>;

// ...

private createWebGLTexts() {
  const texts = document.querySelectorAll('[data-animation="webgl-text"]');

  if (texts) {
    this.texts = Array.from(texts).map((el) => {
      const newEl = new WebGLText({
        element: el as HTMLElement,
        scene: this.scene,
      });

      return newEl;
    });
  }
}

Make sure to call this method in the constructor on initialization. This will populate our scene with styled text
meshes based on our DOM content.

That’s all we need to have our text meshes visible, it’s not the prettiest sight to behold, but at least we got
everything working:

Next Challenge: Screen vs. 3D Space Mismatch

Even though we copy the font size directly from the DOM, the scale looks different in 3D. That’s because
WebGL units don’t map 1:1 with screen pixels
, and they operate in different coordinate systems. This mismatch will become even more obvious if we start
positioning and animating elements.

To get true visual parity between our DOM elements and WebGL text, we need to bridge the gap between screen space and
3D space. Let’s tackle that next so our text sizes and positions actually match with what we see in the browser.

4. Syncing Dimensions

The major problem when syncing HTML and WebGL dimensions is that things between them aren’t exactly pixel-perfect.
This is because the DOM and WebGL don’t “speak the same units” by default.

• Web browsers work in screen pixels.
• WebGL uses arbitrary units

Our goal is simple:

💡 Make one unit in the WebGL scene equal one pixel on the screen.

To achieve this, we’ll adjust the camera’s field of view (FOV) so that visible area through the camera exactly matches
the dimensions of the browser window in pixels.

So, we’ll create a
syncDimensions()
function under our Commons class, which calculates our camera’s field of view such that 1 unit in the WebGL scene
corresponds to 1 pixel on the screen —
at a given distance from the camera.

 // Commons.ts 
/**
  * Helper function that is called upon creation and resize
  * Updates the camera's fov according to the new dimensions such that the window's pixels match with that of WebGL scene
  */
private syncDimensions() {
  this.camera.fov =
    2 *
    Math.atan(this.sizes.screen.height / 2 / this.distanceFromCamera) *
    (180 / Math.PI);
}

This function will be called once when we create the camera, and every time that the screen is resized.

//Commons.ts

private createCamera() {
  this.camera = new PerspectiveCamera(
    70,
    this.sizes.screen.aspect,
    200,
    2000
  );
  this.camera.position.z = this.distanceFromCamera;
  this.syncDimensions(); // Syncing dimensions
  this.camera.updateProjectionMatrix();
}

// ...

private onResizeCamera() {
  this.syncDimensions(); // Syncing dimensions

  this.camera.aspect = this.sizes.screen.aspect;
  this.camera.updateProjectionMatrix();
}

Let’s break down what’s actually going on here using the image below:

We know:

• The height of the screen
• The distance from camera (Z)
• The FOV of the camera is the vertical angle (fov y in the image)

So our main goal is to set how wide (vertical angle) we see according to our screen height.

Because the Z (distance from camera) and half of the screen height
forms a right triangle
(distance + height), we can solve for the angle using some basic trigonometry, and compute the FOV using the inverse
tangent (
atan
) of this triangle.

Step-by-step Breakdown of the Formula

this.sizes.screen.height / 2

→ This gives us half the screen’s pixel height — the opposite side of our triangle.

this.distanceFromCamera

→ This is the adjacent side of the triangle — the distance from the camera to the 3D scene.

Math.atan(opposite / adjacent)

→ Calculates half of the vertical FOV (in radians).

*2

→ Since atan only gives half of the angle, we multiply it by 2 to get the full FOV.

* (180 / Math.PI)

→ Converts the angle from radians to degrees (Three.js expects degrees for PerspectiveCamera’s fov)

So the final formula comes down to:

this.camera.fov =
  2 *
  Math.atan(this.sizes.screen.height / 2 / this.distanceFromCamera) *
  (180 / Math.PI);

That’s all we need to sync our dimensions, and this setup ensures that 1 unit in WebGL = 1 pixel on screen.

Let’s move back to the text implementation.

5. Setting Text Properties and Positioning

Now that we’ve synced the WebGL scene to our screen’s pixel dimensions, we can start mapping HTML styles to our 3D
text.

If everything’s wired up correctly, you should see that the font size of the WebGL-rendered text matches the size of
the underlying HTML, although the positioning is still off.

Let’s sync more styling properties and positioning.

Before we can position the 3D text, we need to get the DOM element’s position and size. We’ll create a new method in
the WebGLText class called
createBounds()
,
and use the browser’s built-in getBoundingClientRect() method:

// WebGLText.ts

private createBounds() {
  this.bounds = this.element.getBoundingClientRect();
  this.y = this.bounds.top + this.commons.lenis.actualScroll;
}

And call this in the constructor:

  // WebGLText.ts

constructor({ scene, element }: Props) {
  this.commons = Commons.getInstance();

  this.scene = scene;
  this.element = element;

  this.computedStyle = window.getComputedStyle(this.element); // Saving initial computed style.

  this.createFont();
  this.createColor();
  this.createBounds(); // Creating bounds
  this.createMesh();
  this.setStaticValues();
}

Next, we’ll pull important typographic properties from the DOM (computed style) and pass them to the 3D mesh, so that
it behaves like our native HTML text. (Again, you can see the full documentation and possible properties of troika
here
). Below I’ve included the most important ones.

  // WebGLText.ts 

private setStaticValues() {
  const { fontSize, letterSpacing, lineHeight, whiteSpace, textAlign } =
    this.computedStyle;

  const fontSizeNum = window.parseFloat(fontSize);

  this.mesh.fontSize = fontSizeNum;

  this.mesh.textAlign = textAlign;

  // Troika defines letter spacing in em's, so we convert to them
  this.mesh.letterSpacing = parseFloat(letterSpacing) / fontSizeNum;

  // Same with line height
  this.mesh.lineHeight = parseFloat(lineHeight) / fontSizeNum;

  // Important to define maxWidth for the mesh, so that our text doesn't overflow
  this.mesh.maxWidth = this.bounds.width;

  // Match whiteSpace behavior (e.g., 'pre', 'nowrap')
  this.mesh.whiteSpace = whiteSpace;
}

Troika accepts some of the properties in local em units, so we have to convert pixels into em’s by dividing the pixel
values by the font size.

Also, it’s important to set a maximum width (in pixels) to constrain the mesh’s layout — this prevents text from
overflowing and ensures proper text wrapping.

And finally, let’s create an
update()
function to be called on each frame that consistently positions our mesh according to the underlying DOM position.

This is what it looks like:

//WebGLText.ts

update() {
  this.mesh.position.y =
    -this.y +
    this.commons.lenis.animatedScroll +
    this.commons.sizes.screen.height / 2 -
    this.bounds.height / 2;

  this.mesh.position.x =
    this.bounds.left - this.commons.sizes.screen.width / 2;
}

Breakdown:

• this.y
  shifts the mesh upward by the element’s absolute Y offset.
• lenis.animatedScroll
  re-applies the live animated scroll position.
• Together, they give the current relative position inside the viewport.

Since our WebGL coordinate system is centered in the middle of the screen (Y = 0 is center), we also:

• Add half the screen height (to convert from DOM top-left origin to WebGL center origin)
• Subtract half the text height to vertically center the text
• Subtract half the screen width

Now, we call this update function for each of the text instances in our entry-file:

  // main.ts

private update() {
  this.commons.update();

  this.commons.renderer.render(this.scene, this.commons.camera);


  if (this.texts) {
    this.texts.forEach((el) => el.update());
  }

  window.requestAnimationFrame(this.update.bind(this));
}

And now, the
texts will perfectly follow DOM counterparts
, even as the user scrolls.

Let’s finalize our base text class implementation before diving into effects:

Resizing

We need to ensure that our WebGL text updates correctly on window resize events. This means
recreating the computedStyle, bounds, and static values
whenever the window size changes.

Here’s the resize event handler:

 // WebGLText.ts

onResize() {
  this.computedStyle = window.getComputedStyle(this.element);
  this.createBounds();
  this.setStaticValues();
}

And, call it in the entry-point for each of the text instances:

  // main.ts

private onResize() {
  this.commons.onResize();

  // Resizing texts
  if (this.texts) {
    this.texts.forEach((el) => el.onResize());
  }
}

Once everything is working responsively and perfectly synced with the DOM, we can finally
hide the original HTML text by setting it transparent
— but we’ll keep it in place so it’s still selectable and accessible to the user.

// WebGLText.ts

this.createFont();
this.createColor();
this.createBounds();
this.createMesh();
this.setStaticValues();

this.element.style.color = "transparent"; // Hide DOM element

We should now have our perfectly responsive text meshes, and the user only sees the rendered WebGL text, while the DOM
element remains fully intact for accessibility.

Let’s add some effects!

6. Adding a Custom shader and Replicating Mask Reveal Animations

Troika also lets us use custom shader materials for meshes, giving us the flexibility to create complex effects beyond
just setting colors.

Let’s set up our initial custom shaders:

Fragment Shader:

// text.frag

uniform vec3 uColor;
varying vec2 vUv;

void main() {
  gl_FragColor = vec4(uColor, 1.0); // Applying our custom color.
}

The fragment shader defines the color of the text using the uColor uniform.

Vertex Shader:

// text.vert
varying vec2 vUv;

void main() {
  vUv = uv;
  gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
}

The vertex shader passes the texture coordinates (uv) to the fragment shader for the text rendering.

Shader File Imports using Vite

To handle shader files more easily, we can use the
vite-plugin-glsl
plugin together with Vite to directly import shader files like .frag and .vert in code:

npm i vite-plugin-glsl -D

// vite.config.ts

import { defineConfig } from "vite";
import glsl from "vite-plugin-glsl";

export default defineConfig({
  plugins: [
    glsl({
      include: [
        "**/*.glsl",
        "**/*.wgsl",
        "**/*.vert",
        "**/*.frag",
        "**/*.vs",
        "**/*.fs",
      ],
      warnDuplicatedImports: true,
      defaultExtension: "glsl",
      watch: true,
      root: "/",
    }),
  ],
});

If you’re using TypeScript, you also need to declare the modules for shader files so TypeScript can understand how to
import them:

// shaders.d.ts

declare module "*.frag" {
  const value: string;
  export default value;
}

declare module "*.vert" {
  const value: string;
  export default value;
}

declare module "*.glsl" {
  const value: string;
  export default value;
}

Creating Custom Shader Materials

Let’s now create our custom ShaderMaterial and apply it to our mesh:

// WebGLText.ts

// Importing shaders
import fragmentShader from "../../shaders/text/text.frag";
import vertexShader from "../../shaders/text/text.vert";

//...

this.createFont();
this.createColor();
this.createBounds();
this.createMaterial(); // Creating material
this.createMesh();
this.setStaticValues();

//...

private createMaterial() {
   this.material = new THREE.ShaderMaterial({
     fragmentShader,
     vertexShader
       uniforms: {
       uColor: new THREE.Uniform(this.color), // Passing our color to the shader
     },
   });
 }

In the
createMaterial()
method, we define the
ShaderMaterial
using the imported shaders and pass in the uColor uniform, which allows us to dynamically control the color of the
text based on our DOM-element.

And now, instead of setting the color directly on the default mesh material, we apply our new custom material:

  // WebGLText.ts

private createMesh() {
  this.mesh = new Text();

  this.mesh.text = this.element.innerText; // Always use innerText (not innerHTML or textContent).
  this.mesh.font = this.font;

  this.mesh.anchorX = "0%";
  this.mesh.anchorY = "50%";

  this.mesh.material = this.material; //Using custom material instead of color
}

At this point, we are using our custom shader material, but so far, nothing in our output has changed. Let’s now setup
show and hide animations using our custom shader, and replicate the mask reveal effect.

Setting up Reveal Animations

We’ll create an animation that uses a progress uniform (uProgress) to control the visibility and reveal progress of
the text. The animation will be controlled using the motion library.

First, we must install
motion
and import its
animate
and
inView
functions to our WebGLText class.

npm i motion

// WebGLText.ts

import { inView, animate } from "motion";

Now, let’s configure our class so that when the text steps into view,
the show() function is called
, and when it steps away,
the hide() function is called
. These methods also control the current visibility variable
this.isVisible
. These functions will control the uProgress variable, and animate it between 0 and 1.

For this, we also must setup an addEventListeners() function:

 // WebGLText.ts

/**
  * Inits visibility tracking using motion's inView function.
  * Show is called when the element steps into view, and hide is called when the element steps out of view
  */
private addEventListeners() {
  inView(this.element, () => {
    this.show();

    return () => this.hide();
  });
}

show() {
  this.isVisible = true;

  animate(
    this.material.uniforms.uProgress,
    { value: 1 },
    { duration: 1.8, ease: [0.25, 1, 0.5, 1] }
  );
}

hide() {
  animate(
    this.material.uniforms.uProgress,
    { value: 0 },
    { duration: 1.8, onComplete: () => (this.isVisible = false) }
  );
}

Just make sure to call addEventListeners() in your constructor after setting up the class.

Updating the Shader Material for Animation

We’ll also add two additional uniform variables in our material for the animations:

• uProgress
  : Controls the reveal progress (from 0 to 1).
• uHeight
  : Used by the vertex shader to calculate vertical position offset.

Updated
createMaterial()
method:

 // WebGLText.ts

private createMaterial() {
  this.material = new THREE.ShaderMaterial({
    fragmentShader,
    vertexShader,
    uniforms: {
      uProgress: new THREE.Uniform(0),
      uHeight: new THREE.Uniform(this.bounds.height),
      uColor: new THREE.Uniform(this.color),
    },
  });
}

Since the uHeight is dependent on bounds, we also want to update the uniform variable upon resizing:

  // WebGLText.ts

onResize() {
  this.computedStyle = window.getComputedStyle(this.element);
  this.createBounds();
  this.setStaticValues();
  this.material.uniforms.uHeight.value = this.bounds.height;
}

We now have the text class instance automatically calling show() and hide(), and animating the uProgress according to
the visibility of our underlying DOM-element.

For performance, you might want to update the update() method to only calculate a new position when the mesh is
visible:

update() {
  if (this.isVisible) {
    this.mesh.position.y =
      -this.y +
      this.commons.lenis.animatedScroll +
      this.commons.sizes.screen.height / 2 -
      this.bounds.height / 2;

    this.mesh.position.x =
      this.bounds.left - this.commons.sizes.screen.width / 2;
  }
}

Mask Reveal Theory and Shader Implementation

Creating a mask reveal effect with custom shaders in WebGL is surprisingly simple when we break it down into two
separate movements: one happening in the fragment shader and the other in the vertex shader. You might’ve seen this
effect happen in WebGL on the page of
Zajno
, for example.

Instead of overcomplicating the concept with complex masks or thinking about “lifting it up” behind a window (as we do
in traditional HTML), we can think of it as two distinct actions that work together.

1. Fragment Shader
   : We clip the text vertically, revealing it gradually from top to bottom.
2. Vertex Shader
   : We translate the text’s position from the bottom to the top by its height.

Together these two movements create the illusion of the text lifting itself up from behind a mask.

Let’s update our fragment shader code:

//text.frag

uniform float uProgress; // Our progress value between 0 and 1

uniform vec3 uColor;
varying vec2 vUv;

void main() {
  // Calculate the reveal threshold (bottom to top reveal)
  float reveal = 1.0 - vUv.y;
  
  // Discard fragments above the reveal threshold based on progress
  if (reveal > uProgress) discard;

  // Apply the color to the visible parts of the text
  gl_FragColor = vec4(uColor, 1.0);
}

• When uProgress is 0, the mesh is fully clipped out, and nothing is visible
• When uProgress increases towards 1, the mesh reveals itself from top to bottom.

For the vertex shader, we can simply pass the new uniform called uHeight, which stands for the height of our
DOM-element (this.bounds.height), and translate the output vertically according to it and uProgress.

//text.vert

uniform float uProgress;
uniform float uHeight; // Total height of the mesh passed in from JS

varying vec2 vUv;

void main() {
  vUv = uv;
  
  vec3 transformedPosition = position;

  // Push the mesh upward as it reveals
  transformedPosition.y -= uHeight * (1.0 - uProgress);
  
  gl_Position = projectionMatrix * modelViewMatrix * vec4(transformedPosition, 1.0);
}

• uHeight
  : Total height of the DOM-element (and mesh), passed in from JS.
• When
  uProgress
  is
  0
  , the mesh is fully pushed down.
• As
  uProgress
  reaches
  1
  , it resolves to its natural position.

Now, we should have a beautifully on-scroll animating scene, where the texts reveal themselves as in regular HTML when
they scroll into view.

To spice things up, let’s add some scroll-velocity based post processing effects to our scene as the final step!

7. Adding Post-processing

Now that we’ve built our animated WebGL text with custom shaders and scroll-triggered reveals, we can push the visuals
further with
post-processing
.

Post-processing allows us to apply full-screen visual effects after the scene has been rendered. This is done by
passing the final image through a series of custom shader passes.

So, in this final section, we’ll:

• Set up a PostProcessing class using Three.js’s EffectComposer
• Add a custom RGB shift and wave distortion effect
• Drive the distortion strength dynamically using the scroll velocity from our Lenis custom scroll instance

Creating a PostProcessing class with EffectComposer

Let’s create a PostProcessing class that will be intialized from our entry-point, and which will handle everything
regarding postprocessing using Three.JS’s EffectComposer. Read more about the EffectComposer class
here from Three.js’s documentation
. We’ll also create new fragment and vertex shaders for the postprocessing class to use.

// PostProcessing.ts

import {
  EffectComposer,
  RenderPass,
  ShaderPass,
} from "three/examples/jsm/Addons.js";
import Commons from "./Commons";
import * as THREE from "three";

// Importing postprocessing shaders
import fragmentShader from "../../shaders/postprocessing/postprocessing.frag";
import vertexShader from "../../shaders/postprocessing/postprocessing.vert";

interface Props {
  scene: THREE.Scene;
}

export default class PostProcessing {
  // Scene and utility references
  private commons: Commons;
  private scene: THREE.Scene;

  private composer!: EffectComposer;

  private renderPass!: RenderPass;
  private shiftPass!: ShaderPass;

  constructor({ scene }: Props) {
    this.commons = Commons.getInstance();

    this.scene = scene;

    this.createComposer();
    this.createPasses();
  }

  private createComposer() {
    this.composer = new EffectComposer(this.commons.renderer);
    this.composer.setPixelRatio(this.commons.sizes.pixelRatio);
    this.composer.setSize(
      this.commons.sizes.screen.width,
      this.commons.sizes.screen.height
    );
  }

  private createPasses() {
    // Creating Render Pass (final output) first.
    this.renderPass = new RenderPass(this.scene, this.commons.camera);
    this.composer.addPass(this.renderPass);

    // Creating Post-processing shader for wave and RGB-shift effect.
    const shiftShader = {
      uniforms: {
        tDiffuse: { value: null },      // Default input from previous pass
        uVelocity: { value: 0 },        // Scroll velocity input
        uTime: { value: 0 },            // Elapsed time for animated distortion
      },
      vertexShader,
      fragmentShader,
    };

    this.shiftPass = new ShaderPass(shiftShader);
    this.composer.addPass(this.shiftPass);
  }

  /**
   * Resize handler for EffectComposer, called from entry-point.
   */
  onResize() {
    this.composer.setPixelRatio(this.commons.sizes.pixelRatio);
    this.composer.setSize(
      this.commons.sizes.screen.width,
      this.commons.sizes.screen.height
    );
  }

  update() {
    this.shiftPass.uniforms.uTime.value = this.commons.elapsedTime;

    this.composer.render();
  }
}

Since we don’t have our postprocessing shaders created yet, make sure you create placeholder postprocessing.frag and
postprocessing.vert shaders so the imports don’t fail.

Example placeholders below:

//postprocessing.frag

uniform sampler2D tDiffuse;
uniform float uVelocity;
uniform float uTime;

varying vec2 vUv;

void main() {
    gl_FragColor = texture2D(tDiffuse, vUv);
}

//postprocessing.vert
varying vec2 vUv;

void main() {
    vUv = uv;
        
    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
}

Breakdown of the PostProcessing class

Constructor:
Initializes the class by storing the provided scene, grabbing the shared Commons instance, and then calling
createComposer()
and
createPasses()
.

createComposer():
Sets up the EffectComposer with the correct pixel ratio and canvas size:

• EffectComposer wraps the WebGL renderer and allows chaining of multiple render passes.
• Sized according to current viewport dimensions and pixel ratio

createPasses():
This method sets up all rendering passes applied to the scene.

• RenderPass
  : The first pass that simply renders the scene with the main camera as regular.
• ShaderPass (shiftPass)
  : A custom full-screen shader pass that we’ll create and which will create the RGB shift and wavy distortion
  effects.

update():
Method called on every frame. Updates the uTime uniform so we can animate effects over time, and renders the final
post-processed image using
composer.render()

Initializing Post-processing

To wire the post-processing system into our existing app, we update our main.ts:

  //main.ts
private postProcessing!: PostProcessing;

//....

constructor() {
  document.addEventListener("DOMContentLoaded", async () => {
    await document.fonts.ready;

    this.commons = Commons.getInstance();
    this.commons.init();

    this.createScene();
    this.createWebGLTexts();
    this.createPostProcessing(); // Creating post-processing
    this.addEventListeners();

    this.update();
  });
}

// ...

private createPostProcessing() {
  this.postProcessing = new PostProcessing({ scene: this.scene });
}

// ...

private update() {
  this.commons.update();
  
  if (this.texts) {
    this.texts.forEach((el) => el.update());
  }
  
  // Don't need line below as we're rendering everything using EffectComposer.
  // this.commons.renderer.render(this.scene, this.commons.camera);
  
  this.postProcessing.update(); // Post-processing class handles rendering of output from now on

  
  window.requestAnimationFrame(this.update.bind(this));
}


private onResize() {
  this.commons.onResize();

  if (this.texts) {
    this.texts.forEach((el) => el.onResize());
  }

  this.postProcessing.onResize(); // Resize post-processing
}

So in the new update() function, instead of rendering directly from there, we now hand off rendering responsibility to
the PostProcessing class.

Creating Post-processing Shader and Wiring Scroll Velocity

We want to modify the PostProcessing class further, so that we update the postprocessing fragment shader with the
current scroll velocity from Lenis.

For this, I’m adding a new property lerpedVelocity and lerpFactor, which control the smoothed out velocity. The raw
velocity values from lenis can be spiky and sudden, especially with fast scrolling or scroll jumps. If we pass that
raw value directly into a shader, it can cause a really jittery output.

private lerpedVelocity = 0; // Smoothed scroll velocity for post-processing.
private lerpFactor = 0.05; // Controls how quickly lerpedVelocity follows the real velocity

// ...

update() {
    this.shiftPass.uniforms.uTime.value = this.commons.elapsedTime;

  // Reading current velocity form lenis instance.
  const targetVelocity = this.commons.lenis.velocity;

  // We use the lerped velocity as the actual velocity for the shader, just for a smoother experience.
  this.lerpedVelocity +=
    (targetVelocity - this.lerpedVelocity) * this.lerpFactor;

  this.shiftPass.uniforms.uVelocity.value = this.lerpedVelocity;

  this.composer.render();
}

Post-processing Shaders

For the vertex shader, we can keep all things default, we pass the texture coordinates to the fragment shader.

//postprocessing.vert

varying vec2 vUv;

void main() {
  vUv = uv;
        
  gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
}

And for the fragment shader:

//postprocessing.frag

uniform sampler2D tDiffuse;
uniform float uVelocity;
uniform float uTime;

varying vec2 vUv;

void main() {
  vec2 uv = vUv;
  
  // Calculating wave distortion based on velocity
  float waveAmplitude = uVelocity * 0.0009;
  float waveFrequency = 4.0 + uVelocity * 0.01;
  
  // Applying wave distortion to the UV coordinates
  vec2 waveUv = uv;
  waveUv.x += sin(uv.y * waveFrequency + uTime) * waveAmplitude;
  waveUv.y += sin(uv.x * waveFrequency * 5. + uTime * 0.8) * waveAmplitude;
  
  // Applying the RGB shift to the wave-distorted coordinates
  float r = texture2D(tDiffuse, vec2(waveUv.x, waveUv.y + uVelocity * 0.0005)).r;
  vec2 gb = texture2D(tDiffuse, waveUv).gb;

  gl_FragColor = vec4(r, gb, r);
}

Breakdown

// Calculating wave distortion based on velocity
float waveAmplitude = uVelocity * 0.0009;
float waveFrequency = 4.0 + uVelocity * 0.01;

Wave amplitude controls how strongly the wave effect distorts the screen according to our scroll velocity.

Wave frequency controls how frequently the waves occur.

Next, we distort the UV-coordinates using sin functions and the uTime uniform:

// Applying wave distortion to the UV coordinates
vec2 waveUv = uv;
waveUv.x += sin(uv.y * waveFrequency + uTime) * waveAmplitude;
waveUv.y += sin(uv.x * waveFrequency * 5. + uTime * 0.8) * waveAmplitude;

The red channel is offset slightly based on the velocity, creating the RGB shift effect.

// Applying the RGB shift to the wave-distorted coordinates
float r = texture2D(tDiffuse, vec2(waveUv.x, waveUv.y + uVelocity * 0.0005)).r;
vec2 gb = texture2D(tDiffuse, waveUv).gb;

gl_FragColor = vec4(r, gb, r);

This will create a subtle color separation in the final image that shifts according to our scroll velocity.

Finally, we combine red, green, blue, and alpha into the output color.

8. Final Result

And there you have it! We’ve created a responsive text scene, with scroll-triggered mask reveal animations and
wavy/rgb shifted post-processing.

This setup provides a solid, modular foundation for building more advanced WebGL text effects. If you’re curious to explore further, consider adding particles, fluid simulations, audio reactivity, or more complex materials and shaders. If you’re interested in breakdowns of any of these, feel free to reach out on X.

Thanks so much for following along 🙌