chorama 0.0.0

package/src/mesh/attributedata/separate.js

@@ -0,0 +1,180 @@
+import { Affine3, Vector3 } from "../../math/index.js"
+import { copyBuffer } from "../../utils/index.js"
+import { Attribute } from "../attribute/index.js"
+
+export class SeparateAttributeData {
+  /**
+   * Internal storage for attribute data.
+   * @type {Map<string, DataView>}
+   * */
+  #data = new Map()
+
+  /**
+   * Tracks if the attribute data has changed since last checked.
+   * @type {boolean}
+   * */
+  #changed = false
+
+  /**
+   * @package
+   * @returns {boolean}
+   * Indicates if the data has changed since last queried.
+   * Automatically resets the flag.
+   */
+  get changed() {
+    const wasChanged = this.#changed
+    this.#changed = false
+    return wasChanged
+  }
+
+  /**
+   * Sets an attribute data entry.
+   * @param {string} name
+   * @param {DataView<ArrayBufferLike>} data
+   * @returns {this}
+   */
+  set(name, data) {
+    this.#data.set(name, data)
+    this.#changed = true
+    return this
+  }
+
+  /**
+   * Retrieves an attribute data entry.
+   * @param {string} name
+   * @returns {DataView | undefined}
+   */
+  get(name) {
+    return this.#data.get(name)
+  }
+
+  /**
+   * Checks if an attribute exists.
+   * @param {string} name
+   * @returns {boolean}
+   */
+  has(name) {
+    return this.#data.has(name)
+  }
+
+  /**
+   * Deletes an attribute by name.
+   * @param {string} name
+   * @returns {boolean}
+   */
+  delete(name) {
+    const result = this.#data.delete(name)
+    if (result) this.#changed = true
+    return result
+  }
+
+  /**
+   * Clears all attribute data.
+   * @returns {this}
+   */
+  clear() {
+    if (this.#data.size > 0) {
+      this.#data.clear()
+      this.#changed = true
+    }
+    return this
+  }
+
+  keys(){
+    return this.#data.keys()
+  }
+
+  values(){
+    return this.#data.values()
+  }
+
+  entries(){
+    this.#data.entries()
+  }
+
+  /**
+   * Merges this attribute data with another instance.
+   * @param {SeparateAttributeData} other
+   * @returns {SeparateAttributeData}
+   */
+  merge(other) {
+    const newAttributes = new SeparateAttributeData()
+
+    for (const [id, data] of this.#data) {
+      const otherData = other.get(id)
+      if (!otherData) continue
+
+      const newData = new ArrayBuffer(otherData.byteLength + data.byteLength)
+      copyBuffer(data.buffer, newData, 0, data.byteLength)
+      copyBuffer(otherData.buffer, newData, data.byteLength, otherData.byteLength)
+
+      newAttributes.set(id, new DataView(newData))
+    }
+
+    if (newAttributes.#data.size > 0) {
+      newAttributes.#changed = true
+    }
+
+    return newAttributes
+  }
+
+  /**
+   * Transforms attribute data using an affine transformation.
+   * @param {Affine3} affine
+   */
+  transform(affine) {
+    const positions = this.get(Attribute.Position.name)
+    const normals = this.get(Attribute.Normal.name)
+    const tangents = this.get(Attribute.Tangent.name)
+
+    if (positions) {
+      const trPositions = new Float32Array(positions.buffer, positions.byteOffset, positions.byteLength / Float32Array.BYTES_PER_ELEMENT)
+      for (let i = 0; i < trPositions.length; i += 3) {
+        const position = new Vector3(
+          trPositions[i],
+          trPositions[i + 1],
+          trPositions[i + 2],
+        )
+        affine.transform(position)
+        trPositions[i] = position.x
+        trPositions[i + 1] = position.y
+        trPositions[i + 2] = position.z
+      }
+      this.#changed = true
+    }
+
+    if (normals) {
+      const floats = new Float32Array(normals.buffer, normals.byteOffset, normals.byteLength / Float32Array.BYTES_PER_ELEMENT)
+      for (let i = 0; i < floats.length; i += 3) {
+        const normal = new Vector3(
+          floats[i],
+          floats[i + 1],
+          floats[i + 2],
+        )
+        affine.transformWithoutTranslation(normal)
+        floats[i] = normal.x
+        floats[i + 1] = normal.y
+        floats[i + 2] = normal.z
+      }
+      this.#changed = true
+    }
+
+    if (tangents) {
+      const floats = new Float32Array(tangents.buffer, tangents.byteOffset, tangents.byteLength / Float32Array.BYTES_PER_ELEMENT)
+      for (let i = 0; i < floats.length; i += 3) {
+        const tangent = new Vector3(
+          floats[i],
+          floats[i + 1],
+          floats[i + 2],
+        )
+        affine.transformWithoutTranslation(tangent)
+        floats[i] = tangent.x
+        floats[i + 1] = tangent.y
+        floats[i + 2] = tangent.z
+      }
+      this.#changed = true
+    }
+
+    return this
+  }
+}

package/src/mesh/builders/base.js

@@ -0,0 +1,41 @@
+import { abstractClass, abstractMethod } from "../../utils/index.js"
+import { Mesh } from "../mesh.js"
+
+/**
+ * @abstract
+ */
+export class MeshBuilder {
+  attributes = new MeshBuilderVertexAttributes()
+
+  constructor() {
+    abstractClass(this, MeshBuilder)
+  }
+  /**
+   * @returns {Mesh}
+   */
+  build() {
+    abstractMethod(this, MeshBuilder, MeshBuilder.prototype.build.name)
+  }
+}
+
+export class MeshBuilderVertexAttributes {
+  /**
+   * @type {boolean}
+   */
+  position = true
+
+  /**
+   * @type {boolean}
+   */
+  uvs = true
+
+  /**
+   * @type {boolean}
+   */
+  normals = true
+
+  /**
+   * @type {boolean}
+   */
+  tangents = false
+}

package/src/mesh/builders/circle.js

@@ -0,0 +1,63 @@
+import { Attribute } from "../attribute/index.js"
+import { SeparateAttributeData } from "../attributedata/index.js"
+import { Mesh } from "../mesh.js"
+import { MeshBuilder } from "./base.js"
+
+export class Circle3DMeshBuilder extends MeshBuilder {
+  radius = 0.5
+  segments = 32
+  arcStart = 0
+  arcLength = Math.PI * 2
+  /**
+   * @override
+   */
+  build() {
+    const { radius, arcStart: arcstart, arcLength: arclength, segments} = this
+    const vertices = [0, 0, 0]
+    const normals = [0, 0, 1]
+    const uvs = [0.5, 0.5]
+    const indices = []
+    const angleIncrement = arclength / segments
+    const epilson = Math.pow(2, -31)
+
+    for (let angle = arcstart; angle < arcstart + arclength + epilson; angle += angleIncrement) {
+      const cos = Math.cos(angle)
+      const sin = Math.sin(angle)
+
+      vertices.push(
+        radius * cos,
+        radius * sin,
+        0
+      )
+      normals.push(
+        0, 0, 1
+      )
+      uvs.push(
+        (cos + 1) * 0.5, (sin + 1) * 0.5,
+      )
+    }
+    for (let i = 2; i < vertices.length / 3; i++) {
+      indices.push(i - 1, i, 0)
+    }
+
+    const attributes = new SeparateAttributeData()
+
+    attributes
+      .set(
+        Attribute.Position.name,
+        new DataView(new Float32Array(vertices).buffer)
+      )
+      .set(
+        Attribute.Normal.name,
+        new DataView(new Float32Array(normals).buffer)
+      )
+      .set(
+        Attribute.UV.name,
+        new DataView(new Float32Array(uvs).buffer)
+      )
+    const mesh = new Mesh(attributes)
+    mesh.indices = new Uint16Array(indices)
+
+    return mesh
+  }
+}

package/src/mesh/builders/cuboid.js

@@ -0,0 +1,135 @@
+import { Affine3, Quaternion, Vector3 } from "../../math/index.js"
+import { SeparateAttributeData } from "../attributedata/index.js"
+import { Mesh } from "../mesh.js"
+import { PlaneMeshBuilder } from "./plane.js"
+import { MeshBuilder } from "./base.js"
+import { mergeMeshes } from "./utils.js"
+
+export class CuboidMeshBuilder extends MeshBuilder {
+  /**
+   * @type {number}
+   */
+  width = 1
+  /**
+   * @type {number}
+   */
+  height = 1
+  /**
+   * @type {number}
+   */
+  depth = 1
+  /**
+   * @type {number}
+   */
+  widthSegments = 1
+  /**
+   * @type {number}
+   */
+  heightSegments = 1
+  /**
+   * @type {number}
+   */
+  depthSegments = 1
+  /**
+   * @type {CuboidOpenFaces}
+   */
+  openFaces = new CuboidOpenFaces()
+
+  /**
+   * @override
+   */
+  build() {
+    const halfWidth = this.width / 2
+    const halfHeight = this.height / 2
+    const halfDepth = this.depth / 2
+
+    const sideBuilder = new PlaneMeshBuilder()
+    const affine = new Affine3()
+    let meshes = []
+
+    sideBuilder.width = this.width
+    sideBuilder.height = this.height
+    sideBuilder.widthSegments = this.widthSegments
+    sideBuilder.heightSegments = this.heightSegments
+
+    if (!this.openFaces.front) {
+      affine.compose(
+        new Vector3(0, 0, halfDepth),
+        Quaternion.Identity,
+        new Vector3(1, 1, 1)
+      )
+
+      meshes.push(sideBuilder.build().transform(affine))
+    }
+
+    if (!this.openFaces.back) {
+      affine.compose(
+        new Vector3(0, 0, -halfDepth),
+        Quaternion.fromEuler(0, Math.PI, 0),
+        new Vector3(1, 1, 1)
+      )
+
+      meshes.push(sideBuilder.build().transform(affine))
+    }
+
+    sideBuilder.width = this.depth
+    sideBuilder.height = this.height
+    sideBuilder.widthSegments = this.depthSegments
+    sideBuilder.heightSegments = this.heightSegments
+
+    if (!this.openFaces.left) {
+      affine.compose(
+        new Vector3(-halfWidth, 0, 0),
+        Quaternion.fromEuler(0, -Math.PI / 2, 0),
+        new Vector3(1, 1, 1)
+      )
+
+      meshes.push(sideBuilder.build().transform(affine))
+    }
+
+    if (!this.openFaces.right) {
+      affine.compose(
+        new Vector3(halfWidth, 0, 0),
+        Quaternion.fromEuler(0, Math.PI / 2, 0),
+        new Vector3(1, 1, 1)
+      )
+
+      meshes.push(sideBuilder.build().transform(affine))
+    }
+
+    sideBuilder.width = this.width
+    sideBuilder.height = this.depth
+    sideBuilder.widthSegments = this.depthSegments
+    sideBuilder.heightSegments = this.depthSegments
+
+    if (!this.openFaces.top) {
+      affine.compose(
+        new Vector3(0, halfHeight, 0),
+        Quaternion.fromEuler(-Math.PI / 2, 0, 0),
+        new Vector3(1, 1, 1)
+      )
+
+      meshes.push(sideBuilder.build().transform(affine))
+    }
+
+    if (!this.openFaces.bottom) {
+      affine.compose(
+        new Vector3(0, -halfHeight, 0),
+        Quaternion.fromEuler(Math.PI / 2, 0, 0),
+        new Vector3(1, 1, 1)
+      )
+
+      meshes.push(sideBuilder.build().transform(affine))
+    }
+    return mergeMeshes(meshes) || new Mesh(new SeparateAttributeData())
+  }
+}
+
+export class CuboidOpenFaces {
+  top = false
+  bottom = false
+  left = false
+  right = false
+  front = false
+  back = false
+}

package/src/mesh/builders/cylinder.js

@@ -0,0 +1,131 @@
+import { Affine3, Quaternion, Vector3 } from "../../math/index.js"
+import { Attribute } from "../attribute/index.js"
+import { SeparateAttributeData } from "../attributedata/index.js"
+import { Mesh } from "../mesh.js"
+import { Circle3DMeshBuilder } from "./circle.js"
+import { mergeMeshes } from "./utils.js"
+
+export class CylinderMeshBuilder {
+  radiusTop = 0.5
+  radiusBottom = 0.5
+  height = 1
+  radialSegments = 32
+  heightSegments = 1
+  arcStart = 0
+  arcLength = Math.PI * 2
+  /**
+   * @type {CylinderOpenEnds}
+   */
+  openEnds = {
+    top: false,
+    bottom: false
+  }
+
+  build() {
+    const halfHeight = this.height / 2
+    const capBuilder = new Circle3DMeshBuilder()
+    const transform = new Affine3()
+    const torso = generateTorso.call(this)
+    const meshes = [torso]
+
+    capBuilder.segments = this.radialSegments
+    capBuilder.arcStart = this.arcStart
+    capBuilder.arcLength = this.arcLength
+
+    if (!this.openEnds.top) {
+      transform.compose(
+        new Vector3(0, halfHeight, 0),
+        Quaternion.fromEuler(-Math.PI / 2, 0, -Math.PI * 0.5),
+        new Vector3(1, 1, 1)
+      )
+      capBuilder.radius = this.radiusTop
+      meshes.push(capBuilder.build().transform(transform))
+    }
+    if (!this.openEnds.bottom) {
+      transform.compose(
+        new Vector3(0, -halfHeight, 0),
+        Quaternion.fromEuler(-Math.PI / 2, 0, -Math.PI * 0.5),
+        new Vector3(1, 1, 1)
+      )
+      capBuilder.radius = this.radiusBottom
+      meshes.push(capBuilder.build().transform(transform))
+    }
+    return mergeMeshes(meshes) || torso
+  }
+}
+
+/**
+ * @this {CylinderMeshBuilder}
+ * @returns {Mesh}
+ */
+function generateTorso() {
+  const { radiusTop, radiusBottom, height, radialSegments, heightSegments, arcStart: thetaStart, arcLength: thetaLength } = this
+  const indices = [];
+  const positions = [];
+  const normals = [];
+  const uvs = [];
+
+  const halfHeight = height / 2;
+  const attributes = new SeparateAttributeData()
+  const mesh = new Mesh(attributes)
+  const normal = new Vector3();
+  const slope = (radiusBottom - radiusTop) / height;
+
+  for (let y = 0; y <= heightSegments; y++) {
+    const v = y / heightSegments;
+    const radius = v * (radiusBottom - radiusTop) + radiusTop;
+
+    for (let x = 0; x <= radialSegments; x++) {
+      const u = x / radialSegments;
+      const theta = u * thetaLength + thetaStart;
+      const sinTheta = Math.sin(theta);
+      const cosTheta = Math.cos(theta);
+
+      positions.push(
+        radius * sinTheta,
+        - v * height + halfHeight,
+        radius * cosTheta
+      );
+
+      normal.set(sinTheta, slope, cosTheta).normalize();
+      normals.push(normal.x, normal.y, normal.z);
+
+      uvs.push(u, 1 - v);
+    }
+  }
+
+  for (let x = 0; x < radialSegments; x++) {
+    for (let y = 0; y < heightSegments; y++) {
+      const a = y * (radialSegments + 1) + x
+      const b = (y + 1) * (radialSegments + 1) + x
+      const c = (y + 1) * (radialSegments + 1) + (x + 1)
+      const d = (y) * (radialSegments + 1) + (x + 1)
+
+      indices.push(a, b, d);
+      indices.push(b, c, d);
+    }
+  }
+
+
+  attributes
+    .set(
+      Attribute.Position.name,
+      new DataView(new Float32Array(positions).buffer)
+    )
+    .set(
+      Attribute.Normal.name,
+      new DataView(new Float32Array(normals).buffer)
+    )
+    .set(
+      Attribute.UV.name,
+      new DataView(new Float32Array(uvs).buffer)
+    )
+  mesh.indices = new Uint16Array(indices)
+  return mesh
+}
+
+/**
+ * @typedef CylinderOpenEnds
+ * @property {boolean} top
+ * @property {boolean} bottom
+ */

package/src/mesh/builders/index.js

@@ -0,0 +1,7 @@
+export * from './base.js'
+export * from './plane.js'
+export * from './circle.js'
+export * from './cylinder.js'
+export * from './cuboid.js'
+export * from './uvsphere.js'
+export * from './wireframe.js'

package/src/mesh/builders/plane.js

@@ -0,0 +1,73 @@
+import { Attribute } from "../attribute/attribute.js";
+import { SeparateAttributeData } from "../attributedata/separate.js";
+import { Mesh } from "../mesh.js";
+import { MeshBuilder } from "./base.js";
+
+export class PlaneMeshBuilder extends MeshBuilder {
+  width = 1
+  height = 1
+  widthSegments = 1
+  heightSegments = 1
+
+  /**
+   * @override
+   */
+  build() {
+    const positions = []
+    const normals = []
+    const uvs = []
+    const indices = []
+
+    const widthHalf = this.width / 2;
+    const heightHalf = this.height / 2;
+    const gridX = this.widthSegments
+    const gridY = this.heightSegments
+    const gridX1 = gridX + 1;
+    const gridY1 = gridY + 1;
+    const segmentWidth = this.width / gridX;
+    const segmentHeight = this.height / gridY
+
+    for (let i = 0; i < gridY1; i++) {
+      const dy = i * segmentHeight - heightHalf;
+      for (let y = 0; y < gridX1; y++) {
+        const dx = y * segmentWidth - widthHalf;
+
+        positions.push(dx, -dy, 0);
+        normals.push(0, 0, 1);
+        uvs.push(y / gridX, 1 - (i / gridY));
+      }
+    }
+
+    for (let x = 0; x < gridY; x++) {
+      for (let y = 0; y < gridX; y++) {
+        const a = y + gridX1 * x;
+        const b = y + gridX1 * (x + 1);
+        const c = (y + 1) + gridX1 * (x + 1);
+        const d = (y + 1) + gridX1 * x;
+
+        indices.push(a, b, d);
+        indices.push(b, c, d);
+      }
+    }
+
+    const attributes = new SeparateAttributeData()
+
+    attributes
+      .set(
+        Attribute.Position.name,
+        new DataView(new Float32Array(positions).buffer)
+      )
+      .set(
+        Attribute.Normal.name,
+        new DataView(new Float32Array(normals).buffer)
+      )
+      .set(
+        Attribute.UV.name,
+        new DataView(new Float32Array(uvs).buffer)
+      )
+    const mesh = new Mesh(attributes)
+    mesh.indices = new Uint16Array(indices)
+    return mesh
+  }
+}
+

package/src/mesh/builders/utils.js

@@ -0,0 +1,20 @@
+import { Mesh } from "../mesh.js"
+
+/**
+ * @param {Mesh[]} meshes
+ */
+export function mergeMeshes(meshes) {
+  let result = meshes[0]
+
+  if (!result) {
+    return
+  }
+
+  for (let i = 1; i < meshes.length; i++) {
+    const nextMesh = /**@type {Mesh}*/ (meshes[i])
+
+    result = result.merge(nextMesh)
+  }
+
+  return result
+}