chorama 0.0.0

package/src/plugins/shadow/nodes/shadow.js

@@ -0,0 +1,272 @@
+import { Affine3, Matrix4, Vector3 } from "hisabati"
+import { DirectionalLight, SpotLight, PointLight, PCFShadowFilter, PCSSShadowFilter } from "../../../objects"
+import { Object3D, PerspectiveProjection } from "../../../objects"
+import { Views, View } from "../../../renderer"
+import { ShadowMap } from "../resources/ShadowMap"
+import { assert } from "../../../utils"
+
+const SHADOW_ITEM_BYTE_SIZE = 96
+
+export class ShadowViewNode {
+    subgraph() {
+      return undefined
+    }
+
+    /**
+     * @param {import("src/renderer").RenderGraphContext} graphcontext
+     */
+    execute(graphcontext){
+    const {renderDevice: device, renderer, objects } = graphcontext
+    const { context } = device
+    const shadowMap = renderer.getResource(ShadowMap)
+    const views = renderer.getResource(Views)
+    /** @type {ShadowItem[]}*/
+    const blocks = []
+    
+    assert(shadowMap, "Shadow map not set up.")
+    assert(views, "Views resource missing")
+
+    shadowMap.reset()
+    for (let i = 0; i < objects.length; i++) {
+      const object = /**@type {Object3D} */ (objects[i]);
+
+      object.traverseDFS((object) => {
+        const area = shadowMap.getOrSet(object)
+        const items = object instanceof DirectionalLight ?
+          buildDirectionalShadowPass(object, shadowMap) :
+          object instanceof SpotLight ?
+            buildSpotShadowPass(object, shadowMap) :
+            object instanceof PointLight ?
+              buildPointShadowPass(object, shadowMap) :
+              undefined
+
+        if (!items) {
+          return true
+        }
+
+        area.enabled = true
+        area.spaceIndex = blocks.length
+        blocks.push(items[0])
+        items[1].forEach(e => e.order = -100)
+        views.push(...items[1])
+
+        return true
+      })
+    }
+
+    const data = new ArrayBuffer(blocks.length * SHADOW_ITEM_BYTE_SIZE)
+    const view = new DataView(data)
+
+    for (let i = 0; i < blocks.length; i++) {
+      // SAFETY: The array is dense
+      /**@type {ShadowItem}*/(blocks[i]).write(view, i * SHADOW_ITEM_BYTE_SIZE)
+    }
+
+    renderer.updateUBO(context, {
+      name: "ShadowCasterBlock",
+      data
+    })
+    }
+}
+
+/**
+ * @param {DirectionalLight} light
+ * @param {ShadowMap} shadowMap
+ * @returns {[ShadowItem, View[]] | undefined}
+ */
+function buildDirectionalShadowPass(light, shadowMap) {
+  const shadow = light.shadow
+
+  if (!shadow) return
+
+  const [renderTarget, layer] = shadowMap.getTarget()
+  const shadowItem = new ShadowItem()
+  const projectionMatrix = shadow.projection.asProjectionMatrix(shadow.near, shadow.far)
+  const viewMatrix = Affine3.toMatrix4(light.transform.world).invert()
+  const view = new View({
+    renderTarget,
+    position: light.transform.position,
+    projection: projectionMatrix,
+    view: viewMatrix,
+    near: shadow.near,
+    far: shadow.far,
+    tag: DirectionalLight.name,
+    object: light,
+    renderMask: light.renderMask
+  })
+
+
+  shadowItem.layer = layer
+  shadowItem.bias = shadow.bias
+  shadowItem.normalBias = shadow.normalBias
+  packShadowMode(shadowItem,shadow.filterMode)
+  Matrix4.multiply(projectionMatrix, viewMatrix, shadowItem.matrix)
+
+  return [shadowItem, [view]]
+}
+
+/**
+ * @param {SpotLight} light
+ * @param {ShadowMap} shadowMap
+ * @returns {[ShadowItem, View[]] | undefined}
+ */
+function buildSpotShadowPass(light, shadowMap) {
+  const shadow = light.shadow
+
+  if (!shadow) {
+    return
+  }
+  const [renderTarget, layer] = shadowMap.getTarget()
+  const shadowItem = new ShadowItem()
+  const viewMatrix = Affine3.toMatrix4(light.transform.world).invert()
+  const projectionMatrix = new PerspectiveProjection(light.outerAngle, 1).asProjectionMatrix(
+    shadow.near,
+    light.range
+  )
+  const view = new View({
+    renderTarget,
+    position: light.transform.position,
+    projection: projectionMatrix,
+    view: viewMatrix,
+    near: shadow.near,
+    far: light.range,
+    tag: SpotLight.name,
+    object: light,
+    renderMask: light.renderMask
+  })
+
+  shadowItem.layer = layer
+  shadowItem.bias = shadow.bias
+  shadowItem.normalBias = shadow.normalBias
+  packShadowMode(shadowItem, shadow.filterMode)
+  Matrix4.multiply(projectionMatrix, viewMatrix, shadowItem.matrix)
+
+  return [shadowItem, [view]]
+}
+
+/**
+ * @param {PointLight} light
+ * @param {ShadowMap} shadowMap
+ * @returns {[ShadowItem, View[]] | undefined}
+ * 
+ */
+function buildPointShadowPass(light, shadowMap) {
+  const shadow = light.shadow
+
+  if (!shadow) {
+    return
+  }
+  const shadowItem = new ShadowItem()
+  const sides = [
+    [Vector3.X, Vector3.NegY],
+    [Vector3.NegX, Vector3.NegY],
+    [Vector3.Y, Vector3.Z],
+    [Vector3.NegY, Vector3.NegZ],
+    [Vector3.Z, Vector3.NegY],
+    [Vector3.NegZ, Vector3.NegY]
+  ]
+  const projectionMatrix = new PerspectiveProjection(Math.PI / 2, 1).asProjectionMatrix(
+    shadow.near,
+    light.radius
+  )
+  const views = []
+  let layerId = 0
+
+  for (let i = 0; i < sides.length; i++) {
+    const side = /**@type {[Vector3, Vector3]} */ (sides[i])
+    const [renderTarget, layer] = shadowMap.getTarget()
+
+    const worldMatrix = light.transform.world
+    const viewMatrix = Affine3.toMatrix4(new Affine3()
+      .lookAt(side[0], side[1])
+      .translate(new Vector3(
+        worldMatrix.x,
+        worldMatrix.y,
+        worldMatrix.z
+      )))
+      .invert()
+
+    layerId = layer
+    views.push(new View({
+      renderTarget,
+      view: viewMatrix,
+      projection: projectionMatrix,
+      position: light.transform.position,
+      near: shadow.near,
+      far: light.radius,
+      tag: PointLight.name,
+      object: light,
+      renderMask: light.renderMask
+    }))
+  }
+
+  // Encode clipping planes as they are neccessary for point light shadows
+  // Will be unpacked in the corresponding shader
+  shadowItem.matrix.a = shadow.near;
+  shadowItem.matrix.b = light.radius;
+
+  // We only need the light position for point lights
+  shadowItem.matrix.m = light.transform.world.x
+  shadowItem.matrix.n = light.transform.world.y
+  shadowItem.matrix.o = light.transform.world.z
+  shadowItem.bias = shadow.bias
+  shadowItem.normalBias = shadow.normalBias
+  packShadowMode(shadowItem, shadow.filterMode)
+  shadowItem.layer = layerId - 5
+
+  return [shadowItem, views]
+}
+
+/**
+ * @param {ShadowItem} item
+ * @param {import("../../../objects/light/index.js").ShadowFilteringModes} mode
+ */
+function packShadowMode(item, mode) {
+  if (typeof mode === "undefined") {
+    item.mode = 0
+  } else if (mode instanceof PCFShadowFilter) {
+    item.mode = 1
+    item.pcfRadius = mode.radius
+  } else if (mode instanceof PCSSShadowFilter) {
+    item.mode = 2
+    item.pcfRadius = mode.radius
+    item.pcssSearchRadius = mode.searchRadius
+    item.pcssPenumbra = mode.penumbra
+  }else {
+    throw new Error("Invalid shadow filtering mode")
+  }
+}
+
+export class ShadowItem {
+  matrix = new Matrix4()
+  bias = 0.001
+  normalBias = 0
+  /**
+   * 0 = hard compare, 1 = PCF, 2 = PCSS.
+   * @type {number}
+   */
+  mode = 0
+  pcfRadius = 0
+  pcssSearchRadius = 0
+  pcssPenumbra = 0
+  layer = 0
+  /**
+   * @param {DataView} view
+   * @param {number} offset
+   */
+  write(view, offset) {
+    let i = 0
+    for (const value of this.matrix) {
+      view.setFloat32(offset + (i * 4), value, true)
+      i++
+    }
+    view.setFloat32(offset + 64, this.bias, true)
+    view.setFloat32(offset + 68, this.normalBias, true)
+    view.setFloat32(offset + 72, this.layer, true)
+    view.setUint32(offset + 76, this.mode >>> 0, true)
+    view.setFloat32(offset + 80, this.pcfRadius, true)
+    view.setFloat32(offset + 84, this.pcssSearchRadius, true)
+    view.setFloat32(offset + 88, this.pcssPenumbra, true)
+    view.setFloat32(offset + 92, 0, true)
+  }
+}

package/src/plugins/shadow/nodes/shadowOccluder.js

@@ -0,0 +1,112 @@
+import { assert } from "../../../utils"
+import { PrimitiveTopology } from "../../../constants"
+import { WebGLRenderDevice, GPUMesh, Shader } from "../../../core"
+import { DirectionalLight, PointLight, SpotLight } from "../../../objects"
+import { MeshMaterial3D, Object3D } from "../../../objects"
+import { RenderItem, Views } from "../../../renderer/index.js"
+import { WebGLRenderer } from "../../../renderer/index"
+import { basicVertex } from "../../../shader/index.js"
+import { ShadowPipelines } from "../resources"
+
+export class ShadowOccluderNode {
+    subgraph() {
+        return undefined
+    }
+
+    /**
+     * @param {import("../../../renderer/graph/index.js").RenderGraphContext} context
+     */
+    execute(context) {
+        const { renderer, renderDevice, objects } = context
+        const views = renderer.getResource(Views)
+        const shadowPipelines = renderer.getResource(ShadowPipelines)
+
+        assert(views, "Views resource missing")
+        assert(shadowPipelines, "ShadowPipelines resource missing")
+
+        for (const view of views.items()) {
+            if (
+                view.tag !== DirectionalLight.name &&
+                view.tag !== PointLight.name &&
+                view.tag !== SpotLight.name
+            ) {
+                continue
+            }
+
+            /**@type {RenderItem[]} */
+            const opaqueStage = []
+
+            for (let i = 0; i < objects.length; i++) {
+                const object = /**@type {Object3D} */ (objects[i])
+                object.traverseDFS((child) => {
+                    if (!child.renderMask.test(view.renderMask)) {
+                        return true
+                    }
+
+                    if (!(child instanceof MeshMaterial3D)) {
+                        return true
+                    }
+                    const gpuMesh = renderer.caches.getMesh(renderDevice, child.mesh, renderer.attributes)
+                    const item = new RenderItem({
+                        pipelineId: getRenderPipelineId(renderDevice, renderer, gpuMesh, shadowPipelines),
+                        transform: child.transform.world,
+                        mesh: gpuMesh,
+                        uniforms: {},
+                        tag: ""
+                    })
+
+                    opaqueStage.push(item)
+                    return true
+                })
+            }
+
+            view.renderStage.opaque = opaqueStage
+        }
+    }
+}
+
+/**
+ * @param {WebGLRenderDevice} device
+ * @param {WebGLRenderer} renderer
+ * @param {GPUMesh} mesh
+ * @param {ShadowPipelines} pipelines
+ * @returns {number}
+ */
+function getRenderPipelineId(device, renderer, mesh, pipelines) {
+    const { caches, includes, defines: globalDefines } = renderer
+    const pipelineid = pipelines.get(mesh.layoutHash)
+
+    if (pipelineid !== undefined) {
+        return pipelineid
+    }
+
+    const layout = caches.getMeshVertexLayout(mesh.layoutHash)
+
+    assert(layout, "Invalid mesh layout")
+    /**
+     * @type {import("src/core").WebGLRenderPipelineDescriptor}
+     */
+    const descriptor = {
+        //cullFace:CullFace.None,
+        depthWrite: true,
+        topology: PrimitiveTopology.Triangles,
+        vertexLayout: layout,
+        vertex: new Shader({
+            source: basicVertex
+        })
+    }
+
+
+    for (const [name, value] of globalDefines) {
+        descriptor.vertex.defines.set(name, value)
+        descriptor.fragment?.source?.defines?.set(name, value)
+    }
+    for (const [name, value] of includes) {
+        descriptor.vertex.includes.set(name, value)
+        descriptor.fragment?.source?.includes?.set(name, value)
+    }
+    const [_, newId] = caches.createRenderPipeline(device, descriptor)
+
+    pipelines.set(mesh.layoutHash, newId)
+    return newId
+}

package/src/plugins/shadow/nodes/shadowOpaquePass.js

@@ -0,0 +1,73 @@
+import { Camera } from "../../../objects/index.js"
+import { RenderItem, Views } from "../../../renderer/index.js"
+import { assert } from "../../../utils/index.js"
+import { Affine3 } from "../../../math/index.js"
+
+/**
+ * @param {import("../../../renderer/index.js").View} view
+ * @param {import("../../../core/index.js").WebGLRenderDevice} device
+ * @param {import("../../../renderer/renderer.js").WebGLRenderer} renderer
+ */
+function renderItems(view, device, renderer) {
+  const { renderStage, renderTarget } = view
+  const opaquePhase = renderStage.opaque
+
+  const context = device.context
+  const caches = renderer.caches
+  const { clearColor, clearDepth, clearStencil, viewport, scissor } = renderTarget
+
+  const framebuffer = caches.getFrameBuffer(device, renderTarget)
+  framebuffer.setViewport(context, viewport, scissor || viewport)
+  framebuffer.clear(context, clearColor, clearDepth, clearStencil)
+
+  if (!opaquePhase) {
+    return
+  }
+
+  const pass = device.beginRenderPass()
+  for (let i = 0; i < opaquePhase.length; i++) {
+    // SAFETY: List is dense
+    const { pipelineId, mesh, transform } = /**@type {RenderItem}*/(opaquePhase[i])
+    const pipeline = caches.getRenderPipeline(pipelineId)
+
+    if (!pipeline) {
+      continue
+    }
+
+    const modelInfo = pipeline.uniforms.get("model")
+    const transformMatrix = Affine3.toMatrix4(transform)
+
+    pass.setPipeline(pipeline)
+
+    if (modelInfo) {
+      context.uniformMatrix4fv(modelInfo.location, false, new Float32Array(transformMatrix))
+    }
+    pass.draw(mesh)
+  }
+  pass.end()
+}
+
+export class ShadowOpaquePassNode {
+  subgraph() {
+    return undefined
+  }
+
+  /**
+   * @param {import("../../../renderer/graph/index.js").RenderGraphContext} context
+   */
+  execute(context) {
+    const { renderer, renderDevice } = context
+    const views = renderer.getResource(Views)
+
+    assert(views, "Views resource missing")
+
+    for (const view of views.items()) {
+      if (view.tag === Camera.name) {
+        continue
+      }
+
+      renderer.updateUBO(renderDevice.context, view.getData())
+      renderItems(view, renderDevice, renderer)
+    }
+  }
+}

package/src/plugins/shadow/resources/ShadowMap.js

@@ -0,0 +1,99 @@
+import { Object3D } from "../../../objects";
+import { TextureType, TextureFormat, TextureWrap, TextureFilter } from "../../../constants";
+import { ImageRenderTarget } from "../../../rendertarget";
+import { Texture, Sampler } from "../../../texture";
+
+
+export class ShadowMap {
+
+  /**
+   * @private
+   */
+  counter = 0;
+  /**
+   * @type {ImageRenderTarget[]}
+   */
+  targets = [];
+
+  shadowAtlas = new Texture({
+    type: TextureType.Texture2DArray,
+    format: TextureFormat.Depth32Float
+  });
+
+  sampler = new Sampler({
+    wrapR: TextureWrap.Clamp,
+    wrapS: TextureWrap.Clamp,
+    wrapT: TextureWrap.Clamp,
+    minificationFilter: TextureFilter.Nearest,
+    magnificationFilter: TextureFilter.Nearest,
+    mipmapFilter: undefined
+  });
+
+  maxDepth = 10;
+
+  /**
+   * @param {number} maxShadows
+   */
+  constructor(maxShadows) {
+    this.maxDepth = maxShadows;
+  }
+
+  /**
+   * @type {Map<Object3D, ShadowArea>}
+   */
+  inner = new Map();
+
+  reset() {
+    this.counter = 0;
+    this.inner.forEach((area) => {
+      area.enabled = false;
+    });
+  }
+  /**
+   * @return {[ImageRenderTarget, number]}
+   */
+  getTarget() {
+    const layer = this.counter;
+    const target = this.targets[layer];
+
+    if (this.counter > this.maxDepth) {
+      console.error('Maximum shadows reached, some shadows will be ignored');
+    }
+
+    this.counter++;
+    if (target) {
+      return [target, layer];
+    }
+
+    const newTarget = new ImageRenderTarget({
+      depthTexture: this.shadowAtlas,
+      width: 2048,
+      height: 2048,
+      depth: this.maxDepth,
+      layer: layer
+    });
+    this.targets[layer] = newTarget;
+
+    return [newTarget, layer];
+  }
+  /**
+   * @param {Object3D} object
+   */
+  getOrSet(object) {
+    const item = this.inner.get(object);
+
+    if (item) {
+      return item;
+    }
+
+    const newItem = new ShadowArea();
+
+    this.inner.set(object, newItem);
+    return newItem;
+  }
+}
+
+export class ShadowArea {
+  enabled = false;
+  spaceIndex = -1;
+}

package/src/plugins/shadow/resources/index.js

@@ -0,0 +1,2 @@
+export * from './ShadowMap.js'
+export * from './shadowpipelines.js'

package/src/plugins/shadow/resources/shadowpipelines.js

@@ -0,0 +1,25 @@
+export class ShadowPipelines {
+
+  /**
+   * Layout hash is the key, pipeline id the value.
+   * @private
+   * @type {Map<number, number>}
+   */
+  pipelines = new Map()
+
+  /**
+   * @param {number} layoutHash
+   * @returns {number | undefined}
+   */
+  get(layoutHash) {
+    return this.pipelines.get(layoutHash)
+  }
+
+  /**
+   * @param {number} layoutHash
+   * @param {number} pipelineId
+   */
+  set(layoutHash, pipelineId) {
+    this.pipelines.set(layoutHash, pipelineId)
+  }
+}

package/src/plugins/shadow/shadow.js

@@ -0,0 +1,31 @@
+import { Plugin, SortViewsNode, WebGLRenderer } from "../../renderer/index.js";
+import { ShadowMap, ShadowPipelines } from "./resources/index.js";
+import { ShadowOccluderNode, ShadowOpaquePassNode, ShadowViewNode } from "./nodes/index.js";
+import { CameraOpaquePassNode } from "../camera/index.js";
+
+export class ShadowPlugin extends Plugin {
+  /**
+   * @override
+   * @param {WebGLRenderer} renderer
+   */
+  init(renderer) {
+    const maxShadows = 10
+    renderer.setResource(new ShadowMap(maxShadows))
+    renderer.setResource(new ShadowPipelines())
+    renderer.defines.set('MAX_SHADOW_CASTERS', maxShadows.toString())
+
+    renderer.renderGraph.addNode(ShadowViewNode.name, new ShadowViewNode())
+    renderer.renderGraph.addNode(ShadowOccluderNode.name, new ShadowOccluderNode())
+    renderer.renderGraph.addNode(ShadowOpaquePassNode.name, new ShadowOpaquePassNode())
+    renderer.renderGraph.addDependency(ShadowViewNode.name, ShadowOccluderNode.name)
+    renderer.renderGraph.addDependency(ShadowOccluderNode.name, SortViewsNode.name)
+    renderer.renderGraph.addDependency(SortViewsNode.name, ShadowOpaquePassNode.name)
+    renderer.renderGraph.addDependency(ShadowOpaquePassNode.name, CameraOpaquePassNode.name)
+    
+  }
+
+  /**
+   * @override
+   */
+  preprocess() {}
+}

package/src/plugins/skeletonhelper/index.js

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