chorama 0.0.0

package/src/mesh/builders/uvsphere.js

@@ -0,0 +1,80 @@
+import { Attribute } from "../attribute/index.js";
+import { SeparateAttributeData } from "../attributedata/index.js";
+import { Mesh } from "../mesh.js";
+import { MeshBuilder } from "./base.js";
+
+export class UVSphereMeshBuilder extends MeshBuilder {
+  /**
+   * @type {number}
+   */
+  radius = 0.5
+  /**
+   * @type {number}
+   */
+  longitudeSegments = 32
+  /**
+   * @type {number}
+   */
+  latitudeSegments = 32
+  /**
+   * @override
+   */
+  build() {
+    const vertices = [];
+    const normals = [];
+    const uvs = [];
+    const indices = [];
+
+    for (let i = 0; i <= this.latitudeSegments; i++) {
+      const phi = Math.PI * (-0.5 + (i / this.latitudeSegments));
+      const cosphi = Math.cos(phi)
+      const sinphi = Math.sin(phi)
+
+      for (let j = 0; j <= this.longitudeSegments; j++) {
+        const theta = 2 * Math.PI * (j / this.longitudeSegments);
+        const costheta = Math.cos(theta)
+        const sintheta = Math.sin(theta)
+
+        const x = this.radius * costheta * cosphi
+        const y = this.radius * sintheta * cosphi
+        const z = this.radius * sinphi
+        const nx = costheta * cosphi
+        const ny = sintheta * cosphi;
+        const nz = sinphi;
+        const u = 1.0 - (j / this.longitudeSegments);
+        const v = 1.0 - (i / this.latitudeSegments);
+
+        vertices.push(x, y, z);
+        normals.push(nx, ny, nz);
+        uvs.push(u, v);
+      }
+    }
+
+    for (let i = 0; i < this.latitudeSegments; i++) {
+      for (let j = 0; j < this.longitudeSegments; j++) {
+        const p0 = i * (this.longitudeSegments + 1) + j;
+        const p1 = p0 + this.longitudeSegments + 1;
+        indices.push(p0, p0 + 1, p1, p1, p0 + 1, p1 + 1);
+      }
+    }
+    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/wireframe.js

@@ -0,0 +1,62 @@
+import { assert } from "../../utils/index.js"
+import { Attribute } from "../attribute/index.js"
+import { PrimitiveTopology } from "../../constants/index.js"
+import { Mesh } from "../mesh.js"
+
+export class WireframeBuilder {
+  mesh
+  /**
+   * @param {Mesh} mesh
+   */
+  constructor(mesh) {
+    this.mesh = mesh
+  }
+  build() {
+    const { indices, attributes } = this.mesh
+    const edges = new Set()
+    /**@type {number[]} */
+    const lineIndices = []
+
+    if (indices) {
+      // Triangle list
+      for (let i = 0; i < indices.length; i += 3) {
+        const a = /**@type {number}*/ (indices[i]),
+          b = /**@type {number}*/ (indices[i + 1]),
+          c = /**@type {number}*/ (indices[i + 2]);
+        addEdge(edges, lineIndices, a, b);
+        addEdge(edges, lineIndices, b, c);
+        addEdge(edges, lineIndices, c, a);
+      }
+    } else {
+      const position = attributes.get(Attribute.Position.name)
+
+      assert(position, "No position data found")
+      for (let i = 0; i < position.byteLength / (4 * 3); i += 3) {
+        addEdge(edges, lineIndices, i, i + 1);
+        addEdge(edges, lineIndices, i + 1, i + 2);
+        addEdge(edges, lineIndices, i + 2, i);
+      }
+    }
+
+    const mesh = new Mesh(this.mesh.attributes)
+    mesh.indices = new Uint32Array(lineIndices)
+    mesh.topology = PrimitiveTopology.Lines
+
+    return mesh
+  }
+}
+
+/**
+ * Adds an edge to the list, avoiding duplicates.
+ * @param {Set<string>} edgeMap
+ * @param {number[]} out
+ * @param {number} a
+ * @param {number} b
+ */
+function addEdge(edgeMap, out, a, b) {
+  const key = a < b ? `${a}_${b}` : `${b}_${a}`;
+  if (!edgeMap.has(key)) {
+    edgeMap.add(key);
+    out.push(a, b);
+  }
+}

package/src/mesh/index.js

@@ -0,0 +1,4 @@
+export * from "./attribute/index.js"
+export * from "./attributedata/index.js"
+export * from "./builders/index.js"
+export * from "./mesh.js"

package/src/mesh/mesh.js

@@ -0,0 +1,149 @@
+import { PrimitiveTopology } from "../constants/index.js"
+import { Attribute } from "./attribute/index.js"
+import { SeparateAttributeData } from "./attributedata/separate.js"
+import { Affine3 } from "../math/index.js"
+
+export class Mesh {
+  /**
+   * @type {Uint8Array | Uint16Array | Uint32Array | undefined}
+   */
+  #indices
+
+  /**
+   * @type {SeparateAttributeData}
+   */
+  #attributes
+
+  /**
+   * @type {PrimitiveTopology}
+   */
+  topology = PrimitiveTopology.Triangles
+
+  /**
+   * Tracks if the attribute data has changed since last checked.
+   * @type {boolean}
+   * */
+  #changed = false
+
+  /**
+   * @param {SeparateAttributeData} attributes
+   */
+  constructor(attributes) {
+    this.#attributes = attributes
+  }
+
+  /**
+   * @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 || this.attributes.changed
+  }
+
+  /**
+   * @type {Uint8Array | Uint16Array | Uint32Array | undefined}
+   */
+  get indices() {
+    return this.#indices
+  }
+  set indices(value) {
+    this.#indices = value
+    this.#changed = true
+  }
+
+  /**
+   * @type {SeparateAttributeData}
+   */
+  get attributes() {
+    return this.#attributes
+  }
+  set attributes(value) {
+    this.#attributes = value
+    this.#changed = true
+  }
+
+  /**
+   * @param {Affine3} affine
+   */
+  transform(affine) {
+    this.attributes.transform(affine)
+    return this
+  }
+
+  /**
+   * @param {Mesh} other
+   */
+  merge(other) {
+    const newAttributes = this.attributes.merge(other.attributes)
+    const newMesh = new Mesh(newAttributes)
+
+    if (this.indices && other.indices) {
+      const positions = this.attributes.get(Attribute.Position.name)
+
+      if (!positions) {
+        return newMesh
+      }
+
+      // TODO: Remove this hardcoding and use the attribute map instead
+      const attributeCount = positions.byteLength / (3 * 4)
+      const offset = this.indices.length
+
+      const newIndices = new Uint16Array(this.indices.length + other.indices.length)
+
+      for (let i = 0; i < this.indices.length; i++) {
+        const index = /**@type {number} */(this.indices[i]);
+
+        newIndices[i] = index
+      }
+
+      for (let i = 0; i < other.indices.length; i++) {
+        const index = /**@type {number} */(other.indices[i]);
+
+        newIndices[i + offset] = index + attributeCount
+      }
+      newMesh.indices = newIndices
+    } else if (!this.indices && !this.indices) {
+      // Do nothing because attributes are already merged
+    } else {
+      // TODO: How do we merge an indexed and non-indexed mesh?
+      throw "Invalid merge, both meshes must either have indices or not have them."
+    }
+    return newMesh
+  }
+
+  normalizeJointWeights() {
+    const weights = this.attributes.get(Attribute.JointWeight.name)
+
+    if (!weights) return
+
+    const data = new Float32Array(
+      weights.buffer,
+      weights.byteOffset,
+      weights.byteLength / Float32Array.BYTES_PER_ELEMENT
+    )
+
+    for (let i = 0; i < data.length; i += 4) {
+      const sum = /**@type {number}*/(data[i]) +
+        /**@type {number}*/ (data[i + 1]) +
+        /**@type {number}*/ (data[i + 2]) +
+        /**@type {number}*/ (data[i + 3])
+
+      if (sum === 0) {
+        data[i] = 0
+        data[i + 1] = 0
+        data[i + 2] = 0
+        data[i + 3] = 0
+      } else {
+        const inv = 1 / sum
+        data[i] = /**@type {number}*/(data[i]) * inv
+        data[i + 1] = /**@type {number}*/ (data[i + 1]) * inv
+        data[i + 2] = /**@type {number}*/(data[i + 2]) * inv
+        data[i + 3] = /**@type {number}*/(data[i + 3]) * inv
+      }
+    }
+  }
+}

package/src/objects/bone.js

@@ -0,0 +1,17 @@
+import { Object3D } from "./object3d.js";
+
+export class Bone3D extends Object3D {
+  index = -1
+  
+  /**
+   * @override
+   * @param {Map<Object3D, Object3D>} [entityMap]
+   */
+  clone(entityMap){
+    const clone = super.clone(entityMap)
+
+    clone.index = this.index
+    
+    return clone
+  }
+}

package/src/objects/camera/camera.js

@@ -0,0 +1,56 @@
+import { Affine3, Matrix4 } from "../../math/index.js"
+import { Object3D } from "../object3d.js"
+import { RenderTarget } from "../../rendertarget/index.js"
+import { PerspectiveProjection, Projection } from "./projection.js"
+
+export class Camera extends Object3D {
+	near = 0.1
+	
+	far = 2000
+
+	/**
+	 * @type {RenderTarget}
+	 */
+	target
+	/**
+	 * @type {Projection}
+	 */
+	projection = new PerspectiveProjection()
+
+	/**
+	 * @type {Matrix4}
+	 */
+	view = new Matrix4()
+	
+	/**
+	 * @param {RenderTarget} target
+	 */
+	constructor(target){
+		super()
+		this.target = target
+	}
+	/**
+	 * @override
+	 */
+	update() {
+		super.update()
+		const inverseTransform = Affine3.toMatrix4(
+			Affine3.invert(this.transform.world)
+		)
+		this.view.copy(inverseTransform)
+	}
+	
+	getData() {
+		const { near, far } = this
+		return {
+			name: "CameraBlock",
+			data: new Float32Array([
+				...this.view,
+				...this.projection.asProjectionMatrix(near, far),
+				...this.transform.position,
+				this.near,
+				this.far
+			]).buffer
+		}
+	}
+}

package/src/objects/camera/index.js

@@ -0,0 +1,2 @@
+export * from './camera.js'
+export * from './projection.js'

package/src/objects/camera/projection.js

@@ -0,0 +1,203 @@
+import { Matrix4 } from '../../math/index.js'
+
+export class Projection {
+
+  /**
+   * @returns {Matrix4}
+   * @param {number} _near
+   * @param {number} _far
+   */
+  asProjectionMatrix(_near, _far) {
+    return new Matrix4()
+  }
+
+  /**
+   * @returns {boolean}
+   */
+  isPerspective() {
+    return false
+  }
+
+  /**
+   * @returns {boolean}
+   */
+  isOrthographic() {
+    return false
+  }
+}
+
+export class PerspectiveProjection extends Projection {
+
+  /**
+   * @readonly
+   * @type {ProjectionType}
+   */
+  type = ProjectionType.Perspective
+
+  /**
+   * @type {number}
+   */
+  fov
+
+  /**
+   * @type {number}
+   */
+  aspect
+
+  /**
+   * @param {number} fov 
+   * @param {number} aspect 
+   */
+  constructor(fov = Math.PI / 2, aspect = 1) {
+    super()
+    this.fov = fov
+    this.aspect = aspect
+  }
+
+  /**
+   * @override
+   */
+  isPerspective() {
+    return true
+  }
+
+  /**
+   * @param {number} near
+   * @param {number} far
+   * @returns {Matrix4}
+   * @override
+   */
+  asProjectionMatrix(near, far) {
+    const top = near * Math.tan(0.5 * this.fov)
+    const height = 2 * top
+    const width = this.aspect * height
+    const left = -0.5 * width
+
+    return PerspectiveProjection.from(left, left + width, top, top - height, near, far)
+  }
+  
+  /**
+   * @param {number} left
+   * @param {number} right
+   * @param {number} top
+   * @param {number} bottom
+   * @param {number} near
+   * @param {number} far
+   * @param {Matrix4} out
+   */
+  static from(left, right, top, bottom, near, far, out = new Matrix4()) {
+    const x = 2 * near / (right - left)
+    const y = 2 * near / (top - bottom)
+
+    const a = (right + left) / (right - left)
+    const b = (top + bottom) / (top - bottom)
+
+    const c = -(far + near) / (far - near)
+    const d = (-2 * far * near) / (far - near)
+
+    out.a = x
+    out.b = 0
+    out.c = 0
+    out.d = 0
+    out.e = 0
+    out.f = y
+    out.g = 0
+    out.h = 0
+    out.i = a
+    out.j = b
+    out.k = c
+    out.l = -1
+    out.m = 0
+    out.n = 0
+    out.o = d
+    out.p = 0
+
+    return out
+  }
+}
+
+export class OrthographicProjection extends Projection {
+
+  /**
+   * @readonly
+   * @type {ProjectionType}
+   */
+  type = ProjectionType.Orthographic
+  constructor(left = -1, right = 1, top = 1, bottom = -1) {
+    super()
+    this.left = left
+    this.right = right
+    this.top = top
+    this.bottom = bottom
+  }
+
+  /**
+   * @override
+   */
+  isOrthographic() {
+    return true
+  }
+
+  /**
+   * @param {number} near
+   * @param {number} far
+   * @returns {Matrix4}
+   * @override
+   */
+  asProjectionMatrix(near, far) {
+    return OrthographicProjection.from(this.left, this.right, this.top, this.bottom, near, far)
+  }
+
+  /**
+   * @param {number} left
+   * @param {number} right
+   * @param {number} top
+   * @param {number} bottom
+   * @param {number} near
+   * @param {number} far
+   * @param {Matrix4} out
+   */
+  static from(left, right, top, bottom, near, far, out = new Matrix4()) {
+
+    const w = 1.0 / (right - left)
+    const h = 1.0 / (top - bottom)
+    const p = 1.0 / (far - near)
+
+    const x = (right + left) * w
+    const y = (top + bottom) * h
+
+    const z = (far + near) * p
+    const zInv = -2 * p
+
+    out.a = 2 * w
+    out.b = 0
+    out.c = 0
+    out.d = 0
+
+    out.e = 0
+    out.f = 2 * h
+    out.g = 0
+    out.h = 0
+
+    out.i = 0
+    out.j = 0
+    out.k = zInv
+    out.l = 0
+
+    out.m = -x
+    out.n = -y
+    out.o = -z
+    out.p = 1
+
+    return out
+  }
+}
+
+/**
+ * @readonly
+ * @enum {number}
+ */
+export const ProjectionType = /**@type {const}*/({
+  Perspective: 0,
+  Orthographic: 1
+})

package/src/objects/debug/index.js

@@ -0,0 +1 @@
+export * from './skeleton.js'

package/src/objects/debug/skeleton.js

@@ -0,0 +1,28 @@
+import { Bone3D } from "../bone.js";
+import { MeshMaterial3D } from "../mesh.js";
+import { Object3D } from "../object3d.js";
+
+/**
+ * @class
+ */
+export class SkeletonHelper extends Object3D {
+  /**
+   * @type {Bone3D}
+   */
+  rootBone
+
+  /**
+   * @type {MeshMaterial3D}
+   */
+  skinnedMesh
+  /**
+   * @param {Bone3D} rootBone
+   * @param {MeshMaterial3D} skinnedMesh
+   */
+  constructor(rootBone, skinnedMesh) {
+    super()
+    this.rootBone = rootBone
+    this.skinnedMesh = skinnedMesh
+  }
+}
+

package/src/objects/index.js

@@ -0,0 +1,7 @@
+export * from './camera/index.js'
+export * from './light/index.js'
+export * from './debug/index.js'
+export * from './object3d.js'
+export * from './mesh.js'
+export * from './skybox.js'
+export * from './bone.js'

package/src/objects/light/ambient.js

@@ -0,0 +1,20 @@
+import { Color } from '../../math/index.js'
+import { Object3D } from '../object3d.js'
+
+export class AmbientLight extends Object3D {
+  intensity = 1
+  color = new Color(1, 1, 1)
+
+  getData() {
+    return {
+      name: "AmbientLightBlock",
+      data: new Float32Array([
+        this.intensity,
+        0,
+        0,
+        0,
+        ...this.color
+      ]).buffer
+    }
+  }
+}

package/src/objects/light/directional.js

@@ -0,0 +1,29 @@
+import { Color, Vector3 } from '../../math/index.js'
+import { Object3D } from '../object3d.js'
+import { OrthographicShadow } from './shadow/index.js'
+
+export class DirectionalLight extends Object3D {
+  intensity = 1.0
+  color = new Color()
+
+  /**
+   * @type {OrthographicShadow | undefined}
+   */
+  shadow
+
+  /**
+   */
+  pack() {
+    const direction = this.transform.world.transformWithoutTranslation(new Vector3(0, 0, -1))
+
+    return [
+      ...this.color,
+      ...direction,
+      this.intensity,
+      0,
+      0,
+      0,
+      0
+    ]
+  }
+}

package/src/objects/light/index.js

@@ -0,0 +1,5 @@
+export * from "./ambient.js"
+export * from "./directional.js"
+export * from "./spot.js"
+export * from "./point.js"
+export * from "./shadow/index.js"

package/src/objects/light/point.js

@@ -0,0 +1,32 @@
+import { Color, Vector3 } from '../../math/index.js'
+import { Object3D } from '../object3d.js'
+import { SpotLightShadow } from './shadow/index.js'
+
+export class PointLight extends Object3D {
+  color = new Color()
+  radius = 1.0
+  decay = 2
+  intensity = 1.0
+
+  /**
+   * @type {SpotLightShadow | undefined}
+   */
+  shadow
+
+  pack() {
+    const worldPosition = new Vector3(
+      this.transform.world.x,
+      this.transform.world.y,
+      this.transform.world.z
+    )
+    return [
+      ...this.color,
+      ...worldPosition,
+      this.intensity,
+      Math.max(0, this.radius),
+      this.decay,
+      0,
+      0
+    ]
+  }
+}