Our First 3D Scene

Before diving into the API details of Angular Three, let’s create a simple scene together to get a feel for what it’s like to use Angular Three.

Create the `SceneGraph` component

This component will be the root of our scene graph.

1
import { Component, CUSTOM_ELEMENTS_SCHEMA, ChangeDetectionStrategy } from '@angular/core';
2

3
@Component({
4
  template: `
5
    <!-- we'll fill this in later -->
6
  `,
7
  schemas: [CUSTOM_ELEMENTS_SCHEMA],
8
  changeDetection: ChangeDetectionStrategy.OnPush,
9
})
10
export class SceneGraph {}

CUSTOM_ELEMENTS_SCHEMA is required to use Angular Three components.
selector is left empty because we’re not rendering SceneGraph as a regular Angular component.

Set up the Canvas

The SceneGraph component will be rendered by the NgtCanvas component.

1
import { Component } from '@angular/core';
2
import { NgtCanvas } from 'angular-three';
3
import { SceneGraph } from './scene-graph.component';
4

5
@Component({
6
  selector: 'app-root',
7
  template: `
8
    <ngt-canvas [sceneGraph]="sceneGraph" />
9
  `,
10
  imports: [NgtCanvas],
11
})
12
export class AppComponent {
13
  protected sceneGraph = SceneGraph;
14
}

NgtCanvas uses the sceneGraph input to render the SceneGraph component with the Custom Renderer as well as sets up the following THREE.js building blocks:

A WebGLRenderer with anti-aliasing enabled and transparent background.
A default PerspectiveCamera with a default position of [x:0, y:0, z:5].
A default Scene
A render loop that renders the scene on every frame
A window:resize event listener that automatically updates the Renderer and Camera when the viewport is resized

Set the dimensions of the canvas

We’ll set up some basic styles in styles.css

1
html,
2
body {
3
 height: 100%;
4
 width: 100%;
5
 margin: 0;
6
}

Next, let’s set some styles for :host in src/app/app.component.ts

1
import { Component } from '@angular/core';
2
import { NgtCanvas } from 'angular-three';
3
import { SceneGraph } from './scene-graph.component';
4

5
@Component({
6
  selector: 'app-root',
7
  template: `
8
    <ngt-canvas [sceneGraph]="sceneGraph" />
9
  `,
10
  imports: [NgtCanvas],
11
  styles: [`
12
    :host {
13
      display: block;
14
      height: 100dvh;
15
    }
16
  `],
17
})
18
export class AppComponent {
19
  protected sceneGraph = SceneGraph;
20
}

NgtCanvas is designed to fill the parent container so we can control the dimensions of the canvas using the parent container’s dimensions.

1
<div class="canvas-container">
2
 <ngt-canvas [sceneGraph]="sceneGraph" />
3
</div>

Extending Angular Three Catalogue

As a custom renderer, Angular Three maintains a single catalogue of entities to render. By default, the catalogue is empty. We can extend the catalogue by calling the extend function and pass in a Record of entities. Angular Three then maps the catalogue to Custom Elements tags with the following naming convention:

1
<ngt-{entityName-in-kebab-case} />

For example:

1
import { extend } from 'angular-three';
2
import { Mesh, BoxGeometry } from 'three';
3

4
extend({
5
  Mesh, // makes ngt-mesh available
6
  BoxGeometry // makes ngt-box-geometry available,
7
  MyMesh: Mesh, // makes ngt-my-mesh available
8
});

The catalogue isn’t limited to THREE.js core entities. We can extend the catalogue with any custom THREE.js entities the same way.

1
import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls';
2

3
extend({
4
 OrbitControls, // makes ngt-orbit-controls available
5
});

We can also extend the entire THREE.js namespace by passing in THREE as the only argument to extend. However, this is not recommended as it brings in all of THREE.js and bloats the bundle size.

1
import { extend } from 'angular-three';
2
import * as THREE from 'three';
3

4
extend(THREE); // everything in THREE is now available

For the purpose of this guide, we’ll extend THREE.js namespace so we do not have to go back and forth to extend more entities as we go.

1
 import { NgtCanvas } from 'angular-three';
2
 import { NgtCanvas, extend } from 'angular-three';
3
 import * as THREE from 'three';
4

5
 extend(THREE);
6

7
/* the rest of the code remains the same */

Render a THREE.js Entity

Now that we have extended the THREE.js namespace, we can render a THREE.js entity. Let’s render a cube with a Mesh and BoxGeometry from THREE.js.

1
import { Component, CUSTOM_ELEMENTS_SCHEMA, ChangeDetectionStrategy } from '@angular/core';
2

3
@Component({
4
  template: `
5
   <ngt-mesh>
6
     <ngt-box-geometry />
7
   </ngt-mesh>
8
  `,
9
  schemas: [CUSTOM_ELEMENTS_SCHEMA],
10
  changeDetection: ChangeDetectionStrategy.OnPush,
11
})
12
export class SceneGraph {}

And here’s the result:

Animation

The best way to animate a THREE.js entity is to participate in the animation loop with injectBeforeRender. Let’s animate the cube by rotating it on the X and Y axes.

1
import { Component, CUSTOM_ELEMENTS_SCHEMA, ChangeDetectionStrategy, ElementRef, viewChild } from '@angular/core';
2

3
import { injectBeforeRender } from 'angular-three';
4
import { Mesh } from 'three';
5

6
@Component({
7
  template: `
8

9
    <ngt-mesh #mesh>
10
      <ngt-box-geometry />
11
    </ngt-mesh>
12
  `,
13
  schemas: [CUSTOM_ELEMENTS_SCHEMA],
14
  changeDetection: ChangeDetectionStrategy.OnPush,
15
})
16
export class SceneGraph {
17

18
  meshRef = viewChild.required<ElementRef<Mesh>>('mesh');
19

20
  constructor() {
21

22
    injectBeforeRender(() => {
23
      const mesh = this.meshRef().nativeElement;
24
      mesh.rotation.x += 0.01;
25
      mesh.rotation.y += 0.01;
26
    });
27
  }
28
}

Make a Component

Using Angular means we can make components out of our template. Let’s do that for our cube

src/app/cube.component.ts
src/app/scene-graph.component.ts

1
import { Component, CUSTOM_ELEMENTS_SCHEMA, ElementRef, viewChild } from '@angular/core';
2
import { injectBeforeRender } from 'angular-three';
3
import { Mesh } from 'three';
4

5
@Component({
6
  selector: 'app-cube',
7
  template: `
8
    <ngt-mesh #mesh>
9
      <ngt-box-geometry />
10
    </ngt-mesh>
11
  `,
12
schemas: [CUSTOM_ELEMENTS_SCHEMA]
13
})
14
export class Cube {
15
  meshRef = viewChild.required<ElementRef<Mesh>>('mesh');
16

17
  constructor() {
18
    injectBeforeRender(({ delta }) => {
19
      const mesh = this.meshRef().nativeElement;
20
      mesh.rotation.x += delta;
21
      mesh.rotation.y += delta;
22
    });
23
  }
24
}

1
import { Component, CUSTOM_ELEMENTS_SCHEMA, ChangeDetectionStrategy } from '@angular/core';
2
import { Cube } from './cube.component';
3

4
@Component({
5
  template: `
6
   <ngt-mesh>
7
     <ngt-box-geometry />
8
   </ngt-mesh>
9
   <app-cube />
10
  `,
11
  imports: [Cube],
12
  schemas: [CUSTOM_ELEMENTS_SCHEMA],
13
  changeDetection: ChangeDetectionStrategy.OnPush,
14
})
15
export class SceneGraph {}

Everything is the same as before, except we now have a Cube component that can have its own state and logic.

We will add 2 states hovered and clicked to the cube component:

When the cube is hovered, we’ll change its color
When the cube is clicked, we’ll change its scale

1
  import { Component, CUSTOM_ELEMENTS_SCHEMA, ElementRef, viewChild } from '@angular/core';
2
  import { Component, CUSTOM_ELEMENTS_SCHEMA, ElementRef, viewChild, signal } from '@angular/core';
3
import { injectBeforeRender } from 'angular-three';
4
import { Mesh } from 'three';
5

6
@Component({
7
  selector: 'app-cube',
8
  template: `
9
    <ngt-mesh
10
      #mesh
11
      [scale]="clicked() ? 1.5 : 1"
12
      (pointerover)="hovered.set(true)"
13
      (pointerout)="hovered.set(false)"
14
      (click)="clicked.set(!clicked())"
15
    >
16
      <ngt-box-geometry />
17
      <ngt-mesh-basic-material [color]="hovered() ? 'darkred' : 'mediumpurple'" />
18
    </ngt-mesh>
19
  `,
20
  schemas: [CUSTOM_ELEMENTS_SCHEMA]
21
})
22
export class Cube {
23
  meshRef = viewChild.required<ElementRef<Mesh>>('mesh');
24

25
  hovered = signal(false);
26
  clicked = signal(false);
27

28
  constructor() {
29
    injectBeforeRender(() => {
30
      const mesh = this.meshRef().nativeElement;
31
      mesh.rotation.x += 0.01;
32
      mesh.rotation.y += 0.01;
33
    });
34
  }
35
}

Our cube is now interactive!

Render another Cube

Just like any other Angular component, we can render another cube by adding another <app-cube /> tag to the template. However, we need to render the cube in different positions so we can see them both on the scene.

Let’s do that by adding a position input to the Cube component

1
  import { Component, CUSTOM_ELEMENTS_SCHEMA, ElementRef, viewChild, signal } from '@angular/core';
2
  import { Component, CUSTOM_ELEMENTS_SCHEMA, ElementRef, viewChild, signal, input } from '@angular/core';
3

4
  import { injectBeforeRender } from 'angular-three';
5
  import { injectBeforeRender, NgtVector3 } from 'angular-three';
6
import { Mesh } from 'three';
7

8
@Component({
9
  selector: 'app-cube',
10
  template: `
11
    <ngt-mesh
12
      #mesh
13
      [position]="position()"
14
      [scale]="clicked() ? 1.5 : 1"
15
      (pointerover)="hovered.set(true)"
16
      (pointerout)="hovered.set(false)"
17
      (click)="clicked.set(!clicked())"
18
    >
19
      <ngt-box-geometry />
20
      <ngt-mesh-basic-material [color]="hovered() ? 'darkred' : 'mediumpurple'" />
21
    </ngt-mesh>
22
  `,
23
  schemas: [CUSTOM_ELEMENTS_SCHEMA]
24
})
25
export class Cube {
26
  position = input<NgtVector3>([0, 0, 0]);
27

28
  meshRef = viewChild.required<ElementRef<Mesh>>('mesh');
29

30
  hovered = signal(false);
31
  clicked = signal(false);
32

33
  constructor() {
34
    injectBeforeRender(() => {
35
      const mesh = this.meshRef().nativeElement;
36
      mesh.rotation.x += 0.01;
37
      mesh.rotation.y += 0.01;
38
    });
39
  }
40
}

position input is a NgtVector3 which is an expanded version of THREE.Vector3. It can accept:

A THREE.Vector3 instance
A tuple of [x, y, z]
A scalar value that will be used for all axes

1
import { Component, CUSTOM_ELEMENTS_SCHEMA, ChangeDetectionStrategy } from '@angular/core';
2
import { Cube } from './cube.component';
3

4
@Component({
5
  template: `
6
   <app-cube />
7
   <app-cube [position]="[1.5, 0, 0]" />
8
   <app-cube [position]="[-1.5, 0, 0]" />
9
  `,
10
  imports: [Cube],
11
  schemas: [CUSTOM_ELEMENTS_SCHEMA],
12
  changeDetection: ChangeDetectionStrategy.OnPush,
13
})
14
export class SceneGraph {}

and now we have 2 cubes that have their own states, and react to events independently.

Lighting

Let’s add some lights to our scene to make the cubes look more dynamic as they look bland at the moment.

1
import { Component, CUSTOM_ELEMENTS_SCHEMA, ChangeDetectionStrategy } from '@angular/core';
2
import { Cube } from './cube.component';
3

4
@Component({
5
  template: `
6
    <ngt-ambient-light [intensity]="0.5" />
7
    <ngt-spot-light [position]="10" [intensity]="0.5 * Math.PI" [angle]="0.15" [penumbra]="1" [decay]="0" />
8
    <ngt-point-light [position]="-10" [intensity]="0.5 * Math.PI" [decay]="0" />
9

10
    <app-cube [position]="[1.5, 0, 0]" />
11
    <app-cube [position]="[-1.5, 0, 0]" />
12
  `,
13
  imports: [Cube],
14
  schemas: [CUSTOM_ELEMENTS_SCHEMA],
15
  changeDetection: ChangeDetectionStrategy.OnPush,
16
})
17
export class SceneGraph {
18
  protected readonly Math = Math;
19
}

Next, we will want to change the Material of the cube to MeshStandardMaterial so that it can be lit by the lights.

1
import { Component, CUSTOM_ELEMENTS_SCHEMA, ElementRef, viewChild, signal, input } from '@angular/core';
2
import { injectBeforeRender, NgtVector3 } from 'angular-three';
3
import { Mesh } from 'three';
4

5
@Component({
6
  selector: 'app-cube',
7
  template: `
8
    <ngt-mesh
9
      #mesh
10
      [position]="position()"
11
      [scale]="clicked() ? 1.5 : 1"
12
      (pointerover)="hovered.set(true)"
13
      (pointerout)="hovered.set(false)"
14
      (click)="clicked.set(!clicked())"
15
    >
16
      <ngt-box-geometry />
17
      <ngt-mesh-basic-material [color]="hovered() ? 'darkred' : 'mediumpurple'" />
18
      <ngt-mesh-standard-material [color]="hovered() ? 'darkred' : 'mediumpurple'" />
19
    </ngt-mesh>
20
  `,
21
  schemas: [CUSTOM_ELEMENTS_SCHEMA],
22
})
23
export class Cube {
24
  position = input<NgtVector3>([0, 0, 0]);
25

26
  meshRef = viewChild.required<ElementRef<Mesh>>('mesh');
27

28
  hovered = signal(false);
29
  clicked = signal(false);
30

31
  constructor() {
32
    injectBeforeRender(() => {
33
      const mesh = this.meshRef().nativeElement;
34
      mesh.rotation.x += 0.01;
35
      mesh.rotation.y += 0.01;
36
    });
37
  }
38
}

Our cubes look better now, with dimensionality, showing that they are 3D objects.

Bonus: Take control of the camera

Who hasn’t tried to grab the scene and move it around? Let’s take control of the camera and make it move around with OrbitControls.

1
npm install three-stdlib
2
# yarn add three-stdlib
3
# pnpm add three-stdlib

three-stdlib provides a better API to work with THREE.js extra modules like OrbitControls.

1
import { Component, CUSTOM_ELEMENTS_SCHEMA, ChangeDetectionStrategy } from '@angular/core';
2
import { injectStore, extend, NgtArgs } from 'angular-three';
3
import { OrbitControls } from 'three-stdlib';
4
import { Cube } from './cube.component';
5

6
extend({ OrbitControls }); // makes ngt-orbit-controls available
7

8
@Component({
9
  template: `
10
    <ngt-ambient-light [intensity]="0.5" />
11
    <ngt-spot-light [position]="10" [intensity]="0.5 * Math.PI" [angle]="0.15" [penumbra]="1" [decay]="0" />
12
    <ngt-point-light [position]="-10" [intensity]="0.5 * Math.PI" [decay]="0" />
13

14
    <app-cube [position]="[1.5, 0, 0]" />
15
    <app-cube [position]="[-1.5, 0, 0]" />
16

17
   <ngt-orbit-controls *args="[camera(), glDomElement()]" />
18
   <ngt-grid-helper />
19
  `,
20
  imports: [Cube],
21
  imports: [Cube, NgtArgs],
22
  schemas: [CUSTOM_ELEMENTS_SCHEMA],
23
  changeDetection: ChangeDetectionStrategy.OnPush,
24
})
25
export class SceneGraph {
26
  protected readonly Math = Math;
27

28
  private store = injectStore();
29
  protected camera = this.store.select('camera');
30
  protected glDomElement = this.store.select('gl', 'domElement');
31
}

If we were to use OrbitControls in a vanilla THREE.js application, we would need to instantiate it with the camera and WebGLRenderer#domElement.

With Angular Three, we use NgtArgs structural directive to pass Constructor Arguments to the underlying element.

To access the camera and glDomElement, we use injectStore to access the state of the canvas.

And that concludes our guide. We have learned how to create a basic scene, add some lights, and make our cubes interactive. We also learned how to use NgtArgs to pass arguments to the underlying THREE.js elements. Finally, we learned how to use injectStore to access the state of the canvas.

What’s next?

Now that we have a basic understanding of how to create a scene, we can start building more complex scenes.

Try different geometries and materials
Try different lights
Immerse yourself in the world of THREE.js