Source file: /examples/mesh/builders/3d.js

import { GUI } from "dat.gui"
import Stats from "stats.js"
import {
  addRenderGraphGuiAddon,
  BasicMaterial,
  Camera,
  CameraPlugin,
  CanvasTarget,
  CapsuleMeshBuilder,
  Circle3DMeshBuilder,
  ConeMeshBuilder,
  CuboidMeshBuilder,
  CylinderMeshBuilder,
  DodecahedronMeshBuilder,
  EllipsoidMeshBuilder,
  ExtrudeMeshBuilder,
  FrustumMeshBuilder,
  HelixMeshBuilder,
  IcosahedronMeshBuilder,
  IcosphereMeshBuilder,
  LatheMeshBuilder,
  MeshMaterial3D,
  MeshMaterialPlugin,
  OctahedronMeshBuilder,
  OrbitCameraControls,
  PolyhedronMeshBuilder,
  PerspectiveProjection,
  PlaneMeshBuilder,
  PrismMeshBuilder,
  PyramidMeshBuilder,
  RingMeshBuilder,
  TetrahedronMeshBuilder,
  TorusKnotMeshBuilder,
  TorusMeshBuilder,
  TubeMeshBuilder,
  Vector2,
  Vector3,
  WedgeMeshBuilder,
  WebGLRenderDevice,
  WebGLRenderer,
  WireframeBuilder,
  TerrainMeshBuilder,
  UVSphereMeshBuilder
} from "chorama"

// Scene setup

const canvas = document.createElement("canvas")
const renderTarget = new CanvasTarget(canvas)
const renderDevice = new WebGLRenderDevice(canvas, {
  depth: true
})
const renderer = new WebGLRenderer({
  renderDevice,
  plugins: [
    new CameraPlugin(),
    new MeshMaterialPlugin(),
  ]
})
const camera = new Camera(renderTarget)
const projection = new PerspectiveProjection()
camera.projection = projection
const cameraControls = new OrbitCameraControls(camera, canvas)
cameraControls.distance = 5
cameraControls.elevation = 0.3

const builder = new PlaneMeshBuilder()
const material = new BasicMaterial()
const object = new MeshMaterial3D(builder.build3d(), material)

document.body.append(canvas)
addEventListener("resize", updateView)
updateView()
requestAnimationFrame(update)

function update() {
  cameraControls.update()
  renderer.render([object, camera], renderDevice)
  requestAnimationFrame(update)
}

function updateView() {
  projection.aspect = innerWidth / innerHeight
}

// GUI

/**
 * @param {number} x
 * @param {number} z
 * @returns {number}
 */
function sampleTerrainHeight(x, z) {
  return Math.sin(x * 2.5) * Math.cos(z * 2.5) * 0.7 + Math.sin((x + z) * 1.5) * 0.25
}

/** @type {Record<string, (x: number, z: number) => number>} */
const terrainHeightModes = {
  Hills: sampleTerrainHeight,
  Flat: () => 0,
  Ridges: (x, z) => Math.sin(x * 4) * 0.18 + Math.cos(z * 3) * 0.15
}

function createExtrudeBuilder() {
  const builder = new ExtrudeMeshBuilder()
  builder.contour = [
    new Vector2(-0.7, -0.45),
    new Vector2(0.1, -0.45),
    new Vector2(0.1, -0.1),
    new Vector2(0.65, -0.1),
    new Vector2(0.65, 0.45),
    new Vector2(-0.7, 0.45)
  ]
  return builder
}

function createLatheBuilder() {
  const builder = new LatheMeshBuilder()
  builder.profile = [
    new Vector2(0, -0.65),
    new Vector2(0.34, -0.6),
    new Vector2(0.48, -0.2),
    new Vector2(0.4, 0.25),
    new Vector2(0.22, 0.58),
    new Vector2(0, 0.72)
  ]
  builder.segments = 24
  return builder
}

function createTubeBuilder() {
  const builder = new TubeMeshBuilder()
  builder.points = [
    new Vector3(0, -0.5, 0),
    new Vector3(0.3, -0.2, 0.2),
    new Vector3(0.5, 0.1, 0.55),
    new Vector3(0.25, 0.35, 0.9),
    new Vector3(-0.15, 0, 1.2),
    new Vector3(0.12, -0.3, 1.45)
  ]
  builder.radius = 0.07
  builder.radialSegments = 12
  return builder
}

function createPolyhedronBuilder() {
  const builder = new PolyhedronMeshBuilder()
  builder.vertices = [
    new Vector3(-1, -1, -1),
    new Vector3(1, -1, -1),
    new Vector3(1, 1, -1),
    new Vector3(-1, 1, -1),
    new Vector3(-1, -1, 1),
    new Vector3(1, -1, 1),
    new Vector3(1, 1, 1),
    new Vector3(-1, 1, 1)
  ]
  builder.faces = [
    [0, 1, 2, 3],
    [4, 7, 6, 5],
    [0, 4, 5, 1],
    [1, 5, 6, 2],
    [2, 6, 7, 3],
    [4, 0, 3, 7]
  ]
  return builder
}

const builderOptions = [
  { name: "Plane", create: () => new PlaneMeshBuilder() },
  { name: "Circle", create: () => new Circle3DMeshBuilder() },
  { name: "Ring", create: () => new RingMeshBuilder() },
  { name: "Extrude", create: createExtrudeBuilder },
  { name: "Prism", create: () => new PrismMeshBuilder() },
  { name: "Wedge", create: () => new WedgeMeshBuilder() },
  { name: "Capsule", create: () => new CapsuleMeshBuilder() },
  { name: "Cone", create: () => new ConeMeshBuilder() },
  { name: "Cuboid", create: () => new CuboidMeshBuilder() },
  { name: "Cylinder", create: () => new CylinderMeshBuilder() },
  { name: "Dodecahedron", create: () => new DodecahedronMeshBuilder() },
  { name: "Ellipsoid", create: () => new EllipsoidMeshBuilder() },
  { name: "Frustum", create: () => new FrustumMeshBuilder() },
  { name: "Helix", create: () => new HelixMeshBuilder() },
  { name: "Icosahedron", create: () => new IcosahedronMeshBuilder() },
  { name: "Icosphere", create: () => new IcosphereMeshBuilder() },
  { name: "Lathe", create: createLatheBuilder },
  { name: "Octahedron", create: () => new OctahedronMeshBuilder() },
  { name: "Polyhedron", create: createPolyhedronBuilder },
  { name: "Pyramid", create: () => new PyramidMeshBuilder() },
  { name: "Terrain", create: () => {
    const builder = new TerrainMeshBuilder()
    builder.width = 2
    builder.depth = 2
    builder.widthSegments = 24
    builder.depthSegments = 24
    builder.heightScale = 0.35
    builder.sampleHeight = terrainHeightModes["Hills"] ?? sampleTerrainHeight
    return builder
  } },
  { name: "Tetrahedron", create: () => new TetrahedronMeshBuilder() },
  { name: "Torus", create: () => new TorusMeshBuilder() },
  { name: "Torus Knot", create: () => new TorusKnotMeshBuilder() },
  { name: "Tube", create: createTubeBuilder },
  { name: "UV Sphere", create: () => new UVSphereMeshBuilder() }
]

let meshBuilder = createBuilder("Plane")

const settings = {
  builder: "Plane",
  wireframe: false,
  terrainPattern: "Hills"
}
const controls = new GUI()
const settingsFolder = controls.addFolder("Settings")
settingsFolder
  .add(settings, "builder", builderOptions.map((option) => option.name))
  .name("Builder")
  .onChange(selectBuilder)
settingsFolder
  .add(settings, "wireframe")
  .name("Wireframe")
  .onChange(rebuildMesh)
settingsFolder.open()

/** @type {GUI | undefined} */
let builderPropertiesFolder

/**
 * @param {string} name
 */
function selectBuilder(name) {
  meshBuilder = createBuilder(name)
  rebuildMesh()
  updateBuilderProperties()
}

/**
 * @param {string} name
 */
function createBuilder(name) {
  const option = builderOptions.find((option) => option.name === name)
  if (!option) {
    throw new Error(`Unknown 3D mesh builder: ${name}`)
  }
  return option.create()
}

function rebuildMesh() {
  const mesh = meshBuilder.build3d()
  object.mesh = settings.wireframe
    ? new WireframeBuilder(mesh).build3d()
    : mesh
}

function updateBuilderProperties() {
  if (builderPropertiesFolder) {
    controls.removeFolder(builderPropertiesFolder)
  }

  builderPropertiesFolder = controls.addFolder(`${settings.builder} Properties`)
  addBuilderProperties(builderPropertiesFolder)
  builderPropertiesFolder.open()
}

/**
 * @param {GUI} folder
 */
function addBuilderProperties(folder) {
  const builder = /** @type {Record<string, any>} */ (meshBuilder)
  addObjectProperties(folder, builder)

  for (const property of ["contour", "profile", "points", "vertices"]) {
    addVectorArrayProperties(folder, builder, property)
  }

  if (settings.builder === "Terrain") {
    folder
      .add(settings, "terrainPattern", Object.keys(terrainHeightModes))
      .name("Height Pattern")
      .onChange((name) => {
        const sampleHeight = terrainHeightModes[name]
        if (!sampleHeight) return

        builder["sampleHeight"] = sampleHeight
        rebuildMesh()
      })
  }
}

/**
 * @param {GUI} folder
 * @param {Record<string, any>} target
 */
function addObjectProperties(folder, target) {
  for (const [property, value] of Object.entries(target)) {
    if (typeof value === "number" || typeof value === "boolean") {
      folder.add(target, property).name(formatLabel(property)).onFinishChange(rebuildMesh)
      continue
    }

    if (value && typeof value === "object" && !Array.isArray(value) && !(value instanceof Set)) {
      const nestedFolder = folder.addFolder(formatLabel(property))
      addObjectProperties(nestedFolder, /** @type {Record<string, any>} */ (value))
    }
  }
}

/**
 * @param {GUI} folder
 * @param {Record<string, any>} target
 * @param {string} property
 */
function addVectorArrayProperties(folder, target, property) {
  const values = target[property]
  if (!Array.isArray(values) || values.length === 0) return

  const axes = ["x", "y", "z"].filter((axis) =>
    values.some((point) => point && typeof point[axis] === "number")
  )
  if (axes.length === 0) return

  const valuesFolder = folder.addFolder(formatLabel(property))
  for (let i = 0; i < values.length; i++) {
    const point = values[i]
    if (!point || typeof point !== "object") continue

    const pointFolder = valuesFolder.addFolder(`Point ${i + 1}`)
    for (const axis of axes) {
      if (typeof point[axis] !== "number") continue
      pointFolder.add(point, axis).name(axis.toUpperCase()).onFinishChange(rebuildMesh)
    }
  }
}

/**
 * @param {string} name
 * @returns {string}
 */
function formatLabel(name) {
  return name
    .replace(/([a-z])([A-Z])/g, "$1 $2")
    .replace(/^./, (character) => character.toUpperCase())
}

updateBuilderProperties()

addRenderGraphGuiAddon({
  gui: controls,
  renderer
})

// Stats

const stats = new Stats()
stats.showPanel(1)
document.body.append(stats.dom)
stats.dom.removeAttribute("style")
stats.dom.classList.add("performance-monitor")

function updateStats() {
  stats.update()
  requestAnimationFrame(updateStats)
}

requestAnimationFrame(updateStats)