How to Build a 3D Mesh Programmatically in TypeScript

Step 1: Install @aspose/3d

npm install @aspose/3d

No native addons or system libraries are required. The package includes TypeScript type definitions.

Minimum tsconfig.json:

{
  "compilerOptions": {
    "target": "ES2020",
    "module": "commonjs",
    "moduleResolution": "node",
    "esModuleInterop": true,
    "strict": true
  }
}

Step 2: Create a Scene and Node

A Scene is the top-level container. All geometry must be attached to a Node inside the scene tree:

import { Scene } from '@aspose/3d';

const scene = new Scene();
const node = scene.rootNode.createChildNode('triangle');

createChildNode(name) creates a named node and wires it as a child of the current node. The returned Node object is where you will attach the mesh in Step 7.

Step 3: Create a Mesh Object

Mesh holds vertex positions and polygon definitions. Construct one with an optional name:

import { Mesh } from '@aspose/3d/entities';

const mesh = new Mesh('triangle');

The mesh starts empty: no vertices and no faces. You add them in the next steps.

Step 4: Add Control Points (Vertices)

Control points are the vertex positions in local space. Push Vector4 values into mesh.controlPoints. The fourth component (w) is 1 for positions:

import { Vector4 } from '@aspose/3d/utilities';

mesh.controlPoints.push(new Vector4(0.0, 0.0, 0.0, 1.0)); // index 0
mesh.controlPoints.push(new Vector4(1.0, 0.0, 0.0, 1.0)); // index 1
mesh.controlPoints.push(new Vector4(0.5, 1.0, 0.0, 1.0)); // index 2

You reference these positions by their zero-based index when defining polygon faces.

Step 5: Create Polygon Faces

createPolygon() defines a face by listing the vertex indices in order. Three indices make a triangle:

mesh.createPolygon(0, 1, 2);

You can also define quads (four indices) or arbitrary polygons for formats that support them. For glTF, the library will automatically triangulate quads and n-gons on export.

Step 6: Add Vertex Normals

Normals improve rendering quality. Use mesh.createElement() to create a VertexElementNormal and fill its data array with one normal per control point:

import { VertexElementNormal } from '@aspose/3d/entities';
import { VertexElementType, MappingMode, ReferenceMode } from '@aspose/3d/entities';

const normals = mesh.createElement(
    VertexElementType.Normal,
    MappingMode.ControlPoint,
    ReferenceMode.Direct
) as VertexElementNormal;

normals.data.push(new Vector4(0, 0, 1, 0)); // normal for vertex 0 (pointing +Z)
normals.data.push(new Vector4(0, 0, 1, 0)); // normal for vertex 1
normals.data.push(new Vector4(0, 0, 1, 0)); // normal for vertex 2

MappingMode.ControlPoint means one normal per vertex. ReferenceMode.Direct means the data array is indexed directly by the polygon vertex index.

Step 7: Attach the Mesh and Save to glTF

Assign the mesh to the node via node.entity, then save the scene:

import { GltfSaveOptions, GltfFormat } from '@aspose/3d/formats/gltf';

node.entity = mesh;

const saveOpts = new GltfSaveOptions();
scene.save('triangle.gltf', GltfFormat.getInstance(), saveOpts);
console.log('Triangle mesh saved to triangle.gltf');

To produce a single self-contained .glb file instead, set saveOpts.binaryMode = true and change the output file extension to .glb.