@carbonenginejs/runtime 0.1.0-alpha.0 → 0.1.0-alpha.1

package/dist/trinity/core/device/Tr2RingBuffer/Tr2RingBufferOffsets.js

@@ -0,0 +1,114 @@
+// Source: trinity/trinity/Tr2RingBuffer.h
+// Source: trinity/trinity/Tr2RingBuffer.cpp
+//
+// One shared arena that many objects upload per-frame rows into, and a small
+// per-consumer cursor that remembers where this frame's rows and last frame's
+// rows landed.
+//
+// WHY A RING AND NOT A BUFFER EACH. Every booster set, every morph target, every
+// skinned thing wants a handful of rows on the GPU each frame. A buffer each
+// means an allocation each; one ring means one allocation and an offset each.
+// The offset is what a shader is handed.
+//
+// WHY TWO OBJECTS, which is the part worth reading twice. `Tr2RingBuffer` is the
+// arena and there is one per DATA TYPE. `Tr2RingBufferOffsets` is the cursor and
+// there is one per CONSUMER, held by value. The cursor keeps the PREVIOUS
+// frame's offset as well as this frame's, which is what a pass reading last
+// frame's transforms needs - motion vectors, trails, anything comparing two
+// frames. Collapsing the two into "upload and get an offset back" works today
+// and quietly loses that.
+//
+// THE FRAME FENCE IS THE WHOLE DESIGN. Rows uploaded for a frame cannot be
+// overwritten until the GPU has finished that frame, so the ring records a
+// locked region per upload and only moves its tail past regions whose frame the
+// device reports complete. `SetFrameNumbers` is deliberately pessimistic - it
+// clamps "completed" to two frames behind "recording" no matter what it is
+// told.
+//
+// THREE DIFFERENCES FROM CARBON, EACH FORCED:
+//
+// - Carbon reaches a process-wide render context through a macro; we have none,
+//   so the context is supplied to `GetInstance` and kept. Same reason
+//   `TriDevice`'s capability methods are still unimplemented.
+// - Carbon drives the fence from EveSpaceScene::Update, which reaches the
+//   process-wide render context (`EveSpaceScene.cpp:441-445`). We have no
+//   process-wide context, so nothing ticks a ring per frame yet and a caller
+//   must drive `SetFrameNumbers` itself. The seeding at creation IS Carbon's.
+// - Carbon's `SetFrameNumbers` erases consumed locked regions only when it finds
+//   an incomplete one, so a ring whose regions all complete erases none and the
+//   list grows for the life of the process. That is survivable in a game
+//   session and is not in a browser tab, so the consumed prefix is erased in
+//   both cases. The tail it computes is identical either way.
+
+/** Carbon's `Tr2RingBufferOffsets::INVALID_OFFSET`. */
+const INVALID_OFFSET = 0xffffffff;
+
+/**
+ * Where one consumer's rows landed, this frame and last.
+ *
+ * Held by value in Carbon, so each consumer owns one rather than sharing.
+ */
+class Tr2RingBufferOffsets {
+  /** Carbon's `INVALID_OFFSET`; the "nothing uploaded" state, and a no-draw. */
+  static INVALID_OFFSET = INVALID_OFFSET;
+
+  /** m_currentFrameOffset */
+  #currentFrameOffset = INVALID_OFFSET;
+
+  /** m_previousFrameOffset */
+  #previousFrameOffset = INVALID_OFFSET;
+
+  /**
+   * Where this frame's rows start, in elements.
+   *
+   * @returns {number} The offset, or `INVALID_OFFSET` before an upload.
+   */
+  GetCurrentFrameOffset() {
+    return this.#currentFrameOffset;
+  }
+
+  /**
+   * Where last frame's rows start, in elements.
+   *
+   * @returns {number} The offset, or `INVALID_OFFSET` before a second frame.
+   */
+  GetPreviousFrameOffset() {
+    return this.#previousFrameOffset;
+  }
+
+  /**
+   * Uploads this consumer's rows, ONCE per frame.
+   *
+   * The early return is the interesting line: a second upload in the same frame
+   * is ignored rather than appended, so an object updated twice does not eat
+   * the ring twice. `AdvanceFrame` is what re-arms it.
+   *
+   * @param {Tr2RingBuffer} buffer The arena for this data type.
+   * @param {ArrayBufferView} transforms The packed rows.
+   * @param {number} count How many rows.
+   * @returns {void}
+   */
+  UploadTransforms(buffer, transforms, count) {
+    if (this.#currentFrameOffset !== INVALID_OFFSET) return;
+    this.#currentFrameOffset = buffer.UploadTransforms(transforms, count);
+
+    // First frame: last frame's rows are this frame's, so a shader reading the
+    // previous offset reads something valid rather than nothing.
+    if (this.#previousFrameOffset === INVALID_OFFSET) {
+      this.#previousFrameOffset = this.#currentFrameOffset;
+    }
+  }
+
+  /**
+   * Rolls this frame's offset into last frame's and re-arms the upload.
+   *
+   * @returns {void}
+   */
+  AdvanceFrame() {
+    this.#previousFrameOffset = this.#currentFrameOffset;
+    this.#currentFrameOffset = INVALID_OFFSET;
+  }
+}
+
+export { Tr2RingBufferOffsets };
+//# sourceMappingURL=Tr2RingBufferOffsets.js.map

package/dist/trinity/core/device/Tr2RingBuffer/Tr2RingBufferOffsets.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Tr2RingBufferOffsets.js","sources":["../../../../../../src/trinity/core/device/Tr2RingBuffer/Tr2RingBufferOffsets.js"],"sourcesContent":["// Source: trinity/trinity/Tr2RingBuffer.h\n// Source: trinity/trinity/Tr2RingBuffer.cpp\n//\n// One shared arena that many objects upload per-frame rows into, and a small\n// per-consumer cursor that remembers where this frame's rows and last frame's\n// rows landed.\n//\n// WHY A RING AND NOT A BUFFER EACH. Every booster set, every morph target, every\n// skinned thing wants a handful of rows on the GPU each frame. A buffer each\n// means an allocation each; one ring means one allocation and an offset each.\n// The offset is what a shader is handed.\n//\n// WHY TWO OBJECTS, which is the part worth reading twice. `Tr2RingBuffer` is the\n// arena and there is one per DATA TYPE. `Tr2RingBufferOffsets` is the cursor and\n// there is one per CONSUMER, held by value. The cursor keeps the PREVIOUS\n// frame's offset as well as this frame's, which is what a pass reading last\n// frame's transforms needs - motion vectors, trails, anything comparing two\n// frames. Collapsing the two into \"upload and get an offset back\" works today\n// and quietly loses that.\n//\n// THE FRAME FENCE IS THE WHOLE DESIGN. Rows uploaded for a frame cannot be\n// overwritten until the GPU has finished that frame, so the ring records a\n// locked region per upload and only moves its tail past regions whose frame the\n// device reports complete. `SetFrameNumbers` is deliberately pessimistic - it\n// clamps \"completed\" to two frames behind \"recording\" no matter what it is\n// told.\n//\n// THREE DIFFERENCES FROM CARBON, EACH FORCED:\n//\n// - Carbon reaches a process-wide render context through a macro; we have none,\n//   so the context is supplied to `GetInstance` and kept. Same reason\n//   `TriDevice`'s capability methods are still unimplemented.\n// - Carbon drives the fence from EveSpaceScene::Update, which reaches the\n//   process-wide render context (`EveSpaceScene.cpp:441-445`). We have no\n//   process-wide context, so nothing ticks a ring per frame yet and a caller\n//   must drive `SetFrameNumbers` itself. The seeding at creation IS Carbon's.\n// - Carbon's `SetFrameNumbers` erases consumed locked regions only when it finds\n//   an incomplete one, so a ring whose regions all complete erases none and the\n//   list grows for the life of the process. That is survivable in a game\n//   session and is not in a browser tab, so the consumed prefix is erased in\n//   both cases. The tail it computes is identical either way.\n\n/** Carbon's `Tr2RingBufferOffsets::INVALID_OFFSET`. */\nconst INVALID_OFFSET = 0xffffffff;\n\n/**\n * Where one consumer's rows landed, this frame and last.\n *\n * Held by value in Carbon, so each consumer owns one rather than sharing.\n */\nexport class Tr2RingBufferOffsets\n{\n  /** Carbon's `INVALID_OFFSET`; the \"nothing uploaded\" state, and a no-draw. */\n  static INVALID_OFFSET = INVALID_OFFSET;\n\n  /** m_currentFrameOffset */\n  #currentFrameOffset = INVALID_OFFSET;\n\n  /** m_previousFrameOffset */\n  #previousFrameOffset = INVALID_OFFSET;\n\n  /**\n   * Where this frame's rows start, in elements.\n   *\n   * @returns {number} The offset, or `INVALID_OFFSET` before an upload.\n   */\n  GetCurrentFrameOffset()\n  {\n    return this.#currentFrameOffset;\n  }\n\n  /**\n   * Where last frame's rows start, in elements.\n   *\n   * @returns {number} The offset, or `INVALID_OFFSET` before a second frame.\n   */\n  GetPreviousFrameOffset()\n  {\n    return this.#previousFrameOffset;\n  }\n\n  /**\n   * Uploads this consumer's rows, ONCE per frame.\n   *\n   * The early return is the interesting line: a second upload in the same frame\n   * is ignored rather than appended, so an object updated twice does not eat\n   * the ring twice. `AdvanceFrame` is what re-arms it.\n   *\n   * @param {Tr2RingBuffer} buffer The arena for this data type.\n   * @param {ArrayBufferView} transforms The packed rows.\n   * @param {number} count How many rows.\n   * @returns {void}\n   */\n  UploadTransforms(buffer, transforms, count)\n  {\n    if (this.#currentFrameOffset !== INVALID_OFFSET) return;\n\n    this.#currentFrameOffset = buffer.UploadTransforms(transforms, count);\n\n    // First frame: last frame's rows are this frame's, so a shader reading the\n    // previous offset reads something valid rather than nothing.\n    if (this.#previousFrameOffset === INVALID_OFFSET)\n    {\n      this.#previousFrameOffset = this.#currentFrameOffset;\n    }\n  }\n\n  /**\n   * Rolls this frame's offset into last frame's and re-arms the upload.\n   *\n   * @returns {void}\n   */\n  AdvanceFrame()\n  {\n    this.#previousFrameOffset = this.#currentFrameOffset;\n    this.#currentFrameOffset = INVALID_OFFSET;\n  }\n}\n"],"names":["INVALID_OFFSET","Tr2RingBufferOffsets","GetCurrentFrameOffset","GetPreviousFrameOffset","UploadTransforms","buffer","transforms","count","AdvanceFrame"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,MAAMA,cAAc,GAAG,UAAU;;AAEjC;AACA;AACA;AACA;AACA;AACO,MAAMC,oBAAoB,CACjC;AACE;EACA,OAAOD,cAAc,GAAGA,cAAc;;AAEtC;EACA,mBAAmB,GAAGA,cAAc;;AAEpC;EACA,oBAAoB,GAAGA,cAAc;;AAErC;AACF;AACA;AACA;AACA;AACEE,EAAAA,qBAAqBA,GACrB;IACE,OAAO,IAAI,CAAC,mBAAmB;AACjC,EAAA;;AAEA;AACF;AACA;AACA;AACA;AACEC,EAAAA,sBAAsBA,GACtB;IACE,OAAO,IAAI,CAAC,oBAAoB;AAClC,EAAA;;AAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACEC,EAAAA,gBAAgBA,CAACC,MAAM,EAAEC,UAAU,EAAEC,KAAK,EAC1C;AACE,IAAA,IAAI,IAAI,CAAC,mBAAmB,KAAKP,cAAc,EAAE;IAEjD,IAAI,CAAC,mBAAmB,GAAGK,MAAM,CAACD,gBAAgB,CAACE,UAAU,EAAEC,KAAK,CAAC;;AAErE;AACA;AACA,IAAA,IAAI,IAAI,CAAC,oBAAoB,KAAKP,cAAc,EAChD;AACE,MAAA,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC,mBAAmB;AACtD,IAAA;AACF,EAAA;;AAEA;AACF;AACA;AACA;AACA;AACEQ,EAAAA,YAAYA,GACZ;AACE,IAAA,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC,mBAAmB;AACpD,IAAA,IAAI,CAAC,mBAAmB,GAAGR,cAAc;AAC3C,EAAA;AACF;;;;"}

package/dist/trinity/core/device/{Tr2SuballocatedBuffer.js → Tr2SuballocatedBuffer/Tr2SuballocatedBuffer.js}

@@ -1,6 +1,8 @@
-import { Tr2BufferDescriptionAL } from '../../../trinityal/stub/Tr2BufferALStub.js';
+import { Tr2SuballocatedBufferAllocation } from './Tr2SuballocatedBufferAllocation.js';
+import '../../../../trinityal/stub/Tr2BufferALStub.js';
 import { Tr2CpuUsage } from '#consts/render-context';
-import { Failed } from '../../../trinityal/ALResult.js';
+import { Failed } from '../../../../trinityal/ALResult.js';
+import { Tr2BufferDescriptionAL } from '../../../../trinityal/Tr2BufferAL/Tr2BufferDescriptionAL.js';
 
 // Source: trinity/trinity/Tr2SuballocatedBuffer.h
 //   trinity/trinity/Tr2SuballocatedBuffer.cpp
@@ -29,62 +31,6 @@ const SHARED_BUFFER_BLOCK_SIZE = 32 * 1024 * 1024;
 /** `SHARED_BUFFER_MAX_SIZE` (`TriGeometryRes.h:16`). */
 const SHARED_BUFFER_MAX_SIZE = 2048 * 1024 * 1024;
 
-/**
- * Carbon's `Tr2SuballocatedBuffer::Allocation`: where in which buffer, at
- * what stride.
- */
-class Tr2SuballocatedBufferAllocation {
-  /** The block's `Tr2BufferAL`. */
-  m_buffer = null;
-  m_offset = 0;
-  m_size = 0;
-  m_stride = 0;
-  m_parent = null;
-
-  /** The block's `Tr2BufferAL`. */
-  GetBuffer() {
-    return this.m_buffer;
-  }
-
-  /** The allocation's first byte within that block. */
-  GetOffset() {
-    return this.m_offset;
-  }
-
-  /** The allocation's size in bytes. */
-  GetSize() {
-    return this.m_size;
-  }
-
-  /** Bytes per element, which `GetStartIndex` divides by. */
-  GetStride() {
-    return this.m_stride;
-  }
-
-  /** `m_offset / m_stride`: the first element, which the draw arguments add. */
-  GetStartIndex() {
-    return this.m_stride ? Math.floor(this.m_offset / this.m_stride) : 0;
-  }
-
-  /** Whether the allocation names a block and has any size. */
-  IsValid() {
-    return this.m_buffer !== null && this.m_size > 0;
-  }
-
-  /**
-   * Rewrites the allocation, whole or in part.
-   *
-   * @param {ArrayBufferView} data The bytes.
-   * @param {object} renderContext The context to update through.
-   * @param {number} [offset] Byte offset within the allocation.
-   * @param {number} [size] Bytes to write.
-   * @returns {number} An `ALResult` value.
-   */
-  Update(data, renderContext, offset = 0, size = data.byteLength) {
-    return this.m_buffer.UpdateBuffer(this.m_offset + offset, size, data, renderContext);
-  }
-}
-
 /**
  * Carbon's `Tr2SuballocatedBuffer`: one growable pool of device buffer blocks
  * that hands out `Tr2SuballocatedBufferAllocation` slices.
@@ -196,5 +142,5 @@ function Lcm(a, b) {
   return a * b / Gcd(a, b);
 }
 
-export { SHARED_BUFFER_BLOCK_SIZE, SHARED_BUFFER_MAX_SIZE, Tr2SuballocatedBuffer, Tr2SuballocatedBufferAllocation };
+export { SHARED_BUFFER_BLOCK_SIZE, SHARED_BUFFER_MAX_SIZE, Tr2SuballocatedBuffer };
 //# sourceMappingURL=Tr2SuballocatedBuffer.js.map

package/dist/trinity/core/device/Tr2SuballocatedBuffer/Tr2SuballocatedBuffer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Tr2SuballocatedBuffer.js","sources":["../../../../../../src/trinity/core/device/Tr2SuballocatedBuffer/Tr2SuballocatedBuffer.js"],"sourcesContent":["// Source: trinity/trinity/Tr2SuballocatedBuffer.h\n//   trinity/trinity/Tr2SuballocatedBuffer.cpp\n//\n// Carbon's suballocated device buffer: one big `Tr2BufferAL` that many\n// allocations share, so that a mesh's vertices are `(buffer, offset, stride)`\n// rather than a buffer of their own. `TriGeometryRes` keeps ONE of these for\n// the whole process (`TriGeometryRes.cpp:33-38`, 32 MiB blocks), and a render\n// batch carries the shared buffer plus a stride while the allocation's offset\n// rides `baseVertexLocation` / `startIndexLocation` (`Tr2MeshBase.cpp:372-392`).\n//\n// WHERE THIS DIFFERS. Carbon grows by `Expand()`: a bigger buffer, a GPU copy of\n// the old contents, one buffer still. WebGPU can copy buffer to buffer only\n// inside a command encoder, which a load-time allocation does not have, so this\n// grows by adding a BLOCK: a second `Tr2BufferAL` of the block size, and\n// allocations after it carry that block. A batch binds its allocation's own\n// buffer, so nothing above notices - except that two meshes in different\n// blocks cannot share one stream binding, which they could not anyway.\n//\n// Not ported: `Free` (Carbon's virtual allocator reclaims; ours is append-only\n// until the resource that owns the buffer releases it), `MapForReading`.\nimport { Tr2SuballocatedBufferAllocation } from \"./Tr2SuballocatedBufferAllocation.js\";\nimport { Tr2BufferDescriptionAL } from \"../../../../trinityal/stub/Tr2BufferALStub.js\";\nimport { Tr2CpuUsage } from \"#consts/render-context\";\nimport { Failed } from \"../../../../trinityal/ALResult.js\";\n\n\n/** `SHARED_BUFFER_BLOCK_SIZE` (`TriGeometryRes.h:15`). */\nexport const SHARED_BUFFER_BLOCK_SIZE = 32 * 1024 * 1024;\n\n/** `SHARED_BUFFER_MAX_SIZE` (`TriGeometryRes.h:16`). */\nexport const SHARED_BUFFER_MAX_SIZE = 2048 * 1024 * 1024;\n\n\n/**\n * Carbon's `Tr2SuballocatedBuffer`: one growable pool of device buffer blocks\n * that hands out `Tr2SuballocatedBufferAllocation` slices.\n */\nexport class Tr2SuballocatedBuffer\n{\n  m_name = \"\";\n\n  m_gpuUsage = 0;\n\n  m_blockSize = SHARED_BUFFER_BLOCK_SIZE;\n\n  m_maxSize = SHARED_BUFFER_MAX_SIZE;\n\n  /** The blocks, each a `Tr2BufferAL` of `m_blockSize` bytes. */\n  m_blocks = [];\n\n  /** The next free byte in the last block. */\n  m_offset = 0;\n\n  m_allocations = [];\n\n  /**\n   * @param {string} name A debug name.\n   * @param {number} gpuUsage `Tr2GpuUsage` flags for every block.\n   * @param {number} [blockSize] Bytes per block.\n   * @param {number} [maxSize] Bytes in total before allocation refuses.\n   */\n  constructor(name, gpuUsage, blockSize = SHARED_BUFFER_BLOCK_SIZE, maxSize = SHARED_BUFFER_MAX_SIZE)\n  {\n    this.m_name = String(name ?? \"\");\n    this.m_gpuUsage = gpuUsage;\n    this.m_blockSize = blockSize;\n    this.m_maxSize = maxSize;\n  }\n\n  /**\n   * Reserves `count` elements of `stride` bytes and uploads them.\n   *\n   * Carbon asserts `offset % stride == 0` (`Tr2SuballocatedBuffer.cpp:24-63`):\n   * the offset is element-aligned so `GetStartIndex` is exact. Alignment here\n   * is to the least common multiple of the stride and four, which keeps the\n   * offset both element-aligned and a legal `writeBuffer` offset.\n   *\n   * @param {number} stride Bytes per element.\n   * @param {number} count Elements.\n   * @param {ArrayBufferView|null} data The bytes, or null to reserve only.\n   * @param {object} renderContext The context to create and update through.\n   * @returns {Tr2SuballocatedBufferAllocation|null} The allocation, or null when refused.\n   */\n  Allocate(stride, count, data, renderContext)\n  {\n    if (!Number.isInteger(stride) || stride <= 0 || !Number.isInteger(count) || count <= 0) return null;\n\n    const size = stride * count;\n\n    if (size > this.m_blockSize) return null;\n\n    const alignment = Lcm(stride, 4);\n    let offset = Math.ceil(this.m_offset / alignment) * alignment;\n\n    if (this.m_blocks.length === 0 || offset + size > this.m_blockSize)\n    {\n      if ((this.m_blocks.length + 1) * this.m_blockSize > this.m_maxSize) return null;\n      if (!this.#AddBlock(renderContext)) return null;\n\n      offset = 0;\n    }\n\n    const allocation = new Tr2SuballocatedBufferAllocation();\n\n    allocation.m_buffer = this.m_blocks[this.m_blocks.length - 1];\n    allocation.m_offset = offset;\n    allocation.m_size = size;\n    allocation.m_stride = stride;\n    allocation.m_parent = this;\n\n    this.m_offset = offset + size;\n    this.m_allocations.push(allocation);\n\n    if (data && Failed(allocation.Update(data, renderContext)))\n    {\n      this.m_allocations.pop();\n\n      return null;\n    }\n\n    return allocation;\n  }\n\n  /** Carbon's `OnPrepareResources`: the block is a stride-4 byte pool. */\n  #AddBlock(renderContext)\n  {\n    const description = Tr2BufferDescriptionAL.FromStride(4, this.m_blockSize / 4, this.m_gpuUsage, Tr2CpuUsage.WRITE);\n    const block = renderContext.CreateBuffer(description, null);\n\n    if (!block) return false;\n\n    block.SetName(`${this.m_name} block ${this.m_blocks.length}`);\n    this.m_blocks.push(block);\n    this.m_offset = 0;\n\n    return true;\n  }\n\n  /** The most recent block, Carbon's one buffer. */\n  GetBuffer()\n  {\n    return this.m_blocks[this.m_blocks.length - 1] ?? null;\n  }\n\n  /** Every block this buffer has made. */\n  GetBlocks()\n  {\n    return this.m_blocks;\n  }\n\n  /** Releases every block and forgets every allocation. */\n  ReleaseResources()\n  {\n    for (const block of this.m_blocks) block.Destroy();\n\n    this.m_blocks = [];\n    this.m_offset = 0;\n\n    for (const allocation of this.m_allocations)\n    {\n      allocation.m_buffer = null;\n      allocation.m_size = 0;\n    }\n\n    this.m_allocations = [];\n  }\n}\n\n\nfunction Gcd(a, b)\n{\n  while (b) [ a, b ] = [ b, a % b ];\n\n  return a;\n}\n\nfunction Lcm(a, b)\n{\n  return (a * b) / Gcd(a, b);\n}\n"],"names":["SHARED_BUFFER_BLOCK_SIZE","SHARED_BUFFER_MAX_SIZE","Tr2SuballocatedBuffer","m_name","m_gpuUsage","m_blockSize","m_maxSize","m_blocks","m_offset","m_allocations","constructor","name","gpuUsage","blockSize","maxSize","String","Allocate","stride","count","data","renderContext","Number","isInteger","size","alignment","Lcm","offset","Math","ceil","length","allocation","Tr2SuballocatedBufferAllocation","m_buffer","m_size","m_stride","m_parent","push","Failed","Update","pop","#AddBlock","description","Tr2BufferDescriptionAL","FromStride","Tr2CpuUsage","WRITE","block","CreateBuffer","SetName","GetBuffer","GetBlocks","ReleaseResources","Destroy","Gcd","a","b"],"mappings":"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"}

package/dist/trinity/core/device/Tr2SuballocatedBuffer/Tr2SuballocatedBufferAllocation.js

@@ -0,0 +1,80 @@
+// Source: trinity/trinity/Tr2SuballocatedBuffer.h
+//   trinity/trinity/Tr2SuballocatedBuffer.cpp
+//
+// Carbon's suballocated device buffer: one big `Tr2BufferAL` that many
+// allocations share, so that a mesh's vertices are `(buffer, offset, stride)`
+// rather than a buffer of their own. `TriGeometryRes` keeps ONE of these for
+// the whole process (`TriGeometryRes.cpp:33-38`, 32 MiB blocks), and a render
+// batch carries the shared buffer plus a stride while the allocation's offset
+// rides `baseVertexLocation` / `startIndexLocation` (`Tr2MeshBase.cpp:372-392`).
+//
+// WHERE THIS DIFFERS. Carbon grows by `Expand()`: a bigger buffer, a GPU copy of
+// the old contents, one buffer still. WebGPU can copy buffer to buffer only
+// inside a command encoder, which a load-time allocation does not have, so this
+// grows by adding a BLOCK: a second `Tr2BufferAL` of the block size, and
+// allocations after it carry that block. A batch binds its allocation's own
+// buffer, so nothing above notices - except that two meshes in different
+// blocks cannot share one stream binding, which they could not anyway.
+//
+// Not ported: `Free` (Carbon's virtual allocator reclaims; ours is append-only
+// until the resource that owns the buffer releases it), `MapForReading`.
+
+
+/**
+ * Carbon's `Tr2SuballocatedBuffer::Allocation`: where in which buffer, at
+ * what stride.
+ */
+class Tr2SuballocatedBufferAllocation {
+  /** The block's `Tr2BufferAL`. */
+  m_buffer = null;
+  m_offset = 0;
+  m_size = 0;
+  m_stride = 0;
+  m_parent = null;
+
+  /** The block's `Tr2BufferAL`. */
+  GetBuffer() {
+    return this.m_buffer;
+  }
+
+  /** The allocation's first byte within that block. */
+  GetOffset() {
+    return this.m_offset;
+  }
+
+  /** The allocation's size in bytes. */
+  GetSize() {
+    return this.m_size;
+  }
+
+  /** Bytes per element, which `GetStartIndex` divides by. */
+  GetStride() {
+    return this.m_stride;
+  }
+
+  /** `m_offset / m_stride`: the first element, which the draw arguments add. */
+  GetStartIndex() {
+    return this.m_stride ? Math.floor(this.m_offset / this.m_stride) : 0;
+  }
+
+  /** Whether the allocation names a block and has any size. */
+  IsValid() {
+    return this.m_buffer !== null && this.m_size > 0;
+  }
+
+  /**
+   * Rewrites the allocation, whole or in part.
+   *
+   * @param {ArrayBufferView} data The bytes.
+   * @param {object} renderContext The context to update through.
+   * @param {number} [offset] Byte offset within the allocation.
+   * @param {number} [size] Bytes to write.
+   * @returns {number} An `ALResult` value.
+   */
+  Update(data, renderContext, offset = 0, size = data.byteLength) {
+    return this.m_buffer.UpdateBuffer(this.m_offset + offset, size, data, renderContext);
+  }
+}
+
+export { Tr2SuballocatedBufferAllocation };
+//# sourceMappingURL=Tr2SuballocatedBufferAllocation.js.map

package/dist/trinity/core/device/Tr2SuballocatedBuffer/Tr2SuballocatedBufferAllocation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Tr2SuballocatedBufferAllocation.js","sources":["../../../../../../src/trinity/core/device/Tr2SuballocatedBuffer/Tr2SuballocatedBufferAllocation.js"],"sourcesContent":["// Source: trinity/trinity/Tr2SuballocatedBuffer.h\n//   trinity/trinity/Tr2SuballocatedBuffer.cpp\n//\n// Carbon's suballocated device buffer: one big `Tr2BufferAL` that many\n// allocations share, so that a mesh's vertices are `(buffer, offset, stride)`\n// rather than a buffer of their own. `TriGeometryRes` keeps ONE of these for\n// the whole process (`TriGeometryRes.cpp:33-38`, 32 MiB blocks), and a render\n// batch carries the shared buffer plus a stride while the allocation's offset\n// rides `baseVertexLocation` / `startIndexLocation` (`Tr2MeshBase.cpp:372-392`).\n//\n// WHERE THIS DIFFERS. Carbon grows by `Expand()`: a bigger buffer, a GPU copy of\n// the old contents, one buffer still. WebGPU can copy buffer to buffer only\n// inside a command encoder, which a load-time allocation does not have, so this\n// grows by adding a BLOCK: a second `Tr2BufferAL` of the block size, and\n// allocations after it carry that block. A batch binds its allocation's own\n// buffer, so nothing above notices - except that two meshes in different\n// blocks cannot share one stream binding, which they could not anyway.\n//\n// Not ported: `Free` (Carbon's virtual allocator reclaims; ours is append-only\n// until the resource that owns the buffer releases it), `MapForReading`.\n\n\n/** `SHARED_BUFFER_BLOCK_SIZE` (`TriGeometryRes.h:15`). */\nexport const SHARED_BUFFER_BLOCK_SIZE = 32 * 1024 * 1024;\n\n/** `SHARED_BUFFER_MAX_SIZE` (`TriGeometryRes.h:16`). */\nexport const SHARED_BUFFER_MAX_SIZE = 2048 * 1024 * 1024;\n\n\n/**\n * Carbon's `Tr2SuballocatedBuffer::Allocation`: where in which buffer, at\n * what stride.\n */\nexport class Tr2SuballocatedBufferAllocation\n{\n  /** The block's `Tr2BufferAL`. */\n  m_buffer = null;\n\n  m_offset = 0;\n\n  m_size = 0;\n\n  m_stride = 0;\n\n  m_parent = null;\n\n  /** The block's `Tr2BufferAL`. */\n  GetBuffer()\n  {\n    return this.m_buffer;\n  }\n\n  /** The allocation's first byte within that block. */\n  GetOffset()\n  {\n    return this.m_offset;\n  }\n\n  /** The allocation's size in bytes. */\n  GetSize()\n  {\n    return this.m_size;\n  }\n\n  /** Bytes per element, which `GetStartIndex` divides by. */\n  GetStride()\n  {\n    return this.m_stride;\n  }\n\n  /** `m_offset / m_stride`: the first element, which the draw arguments add. */\n  GetStartIndex()\n  {\n    return this.m_stride ? Math.floor(this.m_offset / this.m_stride) : 0;\n  }\n\n  /** Whether the allocation names a block and has any size. */\n  IsValid()\n  {\n    return this.m_buffer !== null && this.m_size > 0;\n  }\n\n  /**\n   * Rewrites the allocation, whole or in part.\n   *\n   * @param {ArrayBufferView} data The bytes.\n   * @param {object} renderContext The context to update through.\n   * @param {number} [offset] Byte offset within the allocation.\n   * @param {number} [size] Bytes to write.\n   * @returns {number} An `ALResult` value.\n   */\n  Update(data, renderContext, offset = 0, size = data.byteLength)\n  {\n    return this.m_buffer.UpdateBuffer(this.m_offset + offset, size, data, renderContext);\n  }\n}\n"],"names":["Tr2SuballocatedBufferAllocation","m_buffer","m_offset","m_size","m_stride","m_parent","GetBuffer","GetOffset","GetSize","GetStride","GetStartIndex","Math","floor","IsValid","Update","data","renderContext","offset","size","byteLength","UpdateBuffer"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAUA;AACA;AACA;AACA;AACO,MAAMA,+BAA+B,CAC5C;AACE;AACAC,EAAAA,QAAQ,GAAG,IAAI;AAEfC,EAAAA,QAAQ,GAAG,CAAC;AAEZC,EAAAA,MAAM,GAAG,CAAC;AAEVC,EAAAA,QAAQ,GAAG,CAAC;AAEZC,EAAAA,QAAQ,GAAG,IAAI;;AAEf;AACAC,EAAAA,SAASA,GACT;IACE,OAAO,IAAI,CAACL,QAAQ;AACtB,EAAA;;AAEA;AACAM,EAAAA,SAASA,GACT;IACE,OAAO,IAAI,CAACL,QAAQ;AACtB,EAAA;;AAEA;AACAM,EAAAA,OAAOA,GACP;IACE,OAAO,IAAI,CAACL,MAAM;AACpB,EAAA;;AAEA;AACAM,EAAAA,SAASA,GACT;IACE,OAAO,IAAI,CAACL,QAAQ;AACtB,EAAA;;AAEA;AACAM,EAAAA,aAAaA,GACb;AACE,IAAA,OAAO,IAAI,CAACN,QAAQ,GAAGO,IAAI,CAACC,KAAK,CAAC,IAAI,CAACV,QAAQ,GAAG,IAAI,CAACE,QAAQ,CAAC,GAAG,CAAC;AACtE,EAAA;;AAEA;AACAS,EAAAA,OAAOA,GACP;IACE,OAAO,IAAI,CAACZ,QAAQ,KAAK,IAAI,IAAI,IAAI,CAACE,MAAM,GAAG,CAAC;AAClD,EAAA;;AAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACEW,EAAAA,MAAMA,CAACC,IAAI,EAAEC,aAAa,EAAEC,MAAM,GAAG,CAAC,EAAEC,IAAI,GAAGH,IAAI,CAACI,UAAU,EAC9D;AACE,IAAA,OAAO,IAAI,CAAClB,QAAQ,CAACmB,YAAY,CAAC,IAAI,CAAClB,QAAQ,GAAGe,MAAM,EAAEC,IAAI,EAAEH,IAAI,EAAEC,aAAa,CAAC;AACtF,EAAA;AACF;;;;"}

package/dist/trinity/core/index.js

@@ -1,9 +1,12 @@
 export { Tr2MaterialParameterStore } from './Tr2MaterialParameterStore.js';
 export { ITr2Renderable, withITr2Renderable } from './ITr2Renderable.js';
 export { ITr2Updateable, withITr2Updateable } from './ITr2Updateable.js';
-export { Tr2QuadRenderer, Tr2QuadRendererEffectRecord } from './Tr2QuadRenderer.js';
+export { Tr2QuadRendererEffectRecord } from './Tr2QuadRenderer/Tr2QuadRendererEffectRecord.js';
+export { Tr2QuadRenderer } from './Tr2QuadRenderer/Tr2QuadRenderer.js';
 export { Tr2Transform } from './Tr2Transform.js';
-export { GetGlobalGpuResourcePool, GpuResourceHandle, TextureSize2D, Tr2GpuResourcePool } from './Tr2GpuResourcePool.js';
+export { TextureSize2D } from './Tr2GpuResourcePool/TextureSize2D.js';
+export { GetGlobalGpuResourcePool, Tr2GpuResourcePool } from './Tr2GpuResourcePool/Tr2GpuResourcePool.js';
+export { GpuResourceHandle } from './Tr2GpuResourcePool/GpuResourceHandle.js';
 export { Tr2ShadowMap } from './Tr2ShadowMap.js';
 export { AccumulatePriorityAttribute } from './PriorityBlend.js';
 export { TriSettings } from './TriSettings.js';
@@ -16,9 +19,13 @@ export { TriTorque } from './animation/TriTorque.js';
 export { CjsBatchManager } from './batch/CjsBatchManager.js';
 export { CjsTrinityBatchDispatcher } from './batch/CjsTrinityBatchDispatcher.js';
 export { CjsTrinityBatchResolver } from './batch/CjsTrinityBatchResolver.js';
-export { ITriRenderBatchAccumulator } from './batch/ITriRenderBatchAccumulator.js';
-export { CanBeBinned, CompareBatches, OrderOf, Tr2GdprBatchFullPartition, Tr2GdprBatchStableFullPartition, Tr2RenderBatch, TriRenderBatchAreaBlock, TriRenderBatchAreaBlocksWithSharedMaterial } from './batch/Tr2RenderBatch.js';
-export { DefaultKeyGenerator, EffectKeyGenerator, TriRenderBatchAccumulator } from './batch/TriRenderBatchAccumulator.js';
+export { TriRenderBatchAreaBlock } from './batch/TriRenderBatch/TriRenderBatchAreaBlock.js';
+export { TriRenderBatchAreaBlocksWithSharedMaterial } from './batch/TriRenderBatch/TriRenderBatchAreaBlocksWithSharedMaterial.js';
+export { CanBeBinned, CompareBatches, OrderOf, Tr2GdprBatchFullPartition, Tr2GdprBatchStableFullPartition, Tr2RenderBatch } from './batch/TriRenderBatch/Tr2RenderBatch.js';
+export { DefaultKeyGenerator } from './batch/TriRenderBatch/DefaultKeyGenerator.js';
+export { EffectKeyGenerator } from './batch/TriRenderBatch/EffectKeyGenerator.js';
+export { ITriRenderBatchAccumulator } from './batch/TriRenderBatch/ITriRenderBatchAccumulator.js';
+export { TriRenderBatchAccumulator } from './batch/TriRenderBatch/TriRenderBatchAccumulator.js';
 export { TriRenderBatchMap } from './batch/TriRenderBatchMap.js';
 export { Tr2BindingVector3 } from './binding/Tr2BindingVector3.js';
 export { Tr2DynamicBinding } from './binding/Tr2DynamicBinding.js';
@@ -28,21 +35,23 @@ export { TriValueBinding } from './binding/TriValueBinding.js';
 export { EFFECT_CONSTANTS, PER_FRAME_PS, PER_FRAME_VS, PER_OBJECT_PS, PER_OBJECT_VS, Tr2Renderer } from './Tr2Renderer.js';
 export { AdjustTextureCoordsToViewport, FillAndSetConstants, SCREEN_QUAD_FLOATS, SCREEN_VERTEX_BYTES, SCREEN_VERTEX_FLOATS, SetConstants, SetupScreenQuad, SetupScreenQuadInCameraSpace } from './Tr2RenderUtils.js';
 export { BLIT_EFFECT_PATH, BLIT_FILTERED_EFFECT_PATH, Filtering, Tr2Blitter } from './Tr2Blitter.js';
+export { Tr2Denoiser } from './Tr2Denoiser.js';
 export { Tr2RenderContext } from './context/Tr2RenderContext.js';
 export { Tr2PrimaryRenderContext } from './context/Tr2PrimaryRenderContext.js';
-export { Tr2VisibilityEvent, Tr2VisibilityResults } from './context/Tr2VisibilityResults.js';
+export { Tr2VisibilityResults } from './context/Tr2VisibilityResults/Tr2VisibilityResults.js';
+export { Tr2VisibilityEvent } from './context/Tr2VisibilityResults/Tr2VisibilityEvent.js';
 export { CjsDirectTrinityStepExecutor } from './context/CjsDirectTrinityStepExecutor.js';
-export { CjsShadowMapExecutor } from './context/CjsShadowMapExecutor.js';
 export { CjsTrinityStepExecutor } from './context/CjsTrinityStepExecutor.js';
-export { CjsVolumetricsExecutor } from './context/CjsVolumetricsExecutor.js';
-export { Tr2BindlessResourcesAL, Tr2RenderContextALStub } from '../../trinityal/stub/Tr2RenderContextALStub.js';
+export { Tr2BindlessResourcesAL } from '../../trinityal/stub/Tr2RenderContextALStub/Tr2BindlessResourcesAL.js';
+export { Tr2RenderContextALStub } from '../../trinityal/stub/Tr2RenderContextALStub/Tr2RenderContextALStub.js';
 export { TriDevice } from './device/TriDevice.js';
 export { Tr2UpscalingTechniqueInfo } from './device/Tr2UpscalingTechniqueInfo.js';
 export { Tr2SwapChain } from './device/Tr2SwapChain.js';
 export { Tr2DepthStencil } from './device/Tr2DepthStencil.js';
 export { Tr2RenderTarget } from './device/Tr2RenderTarget.js';
 export { Tr2GpuBuffer } from './device/Tr2GpuBuffer.js';
-export { Tr2RingBuffer, Tr2RingBufferOffsets } from './device/Tr2RingBuffer.js';
+export { Tr2RingBufferOffsets } from './device/Tr2RingBuffer/Tr2RingBufferOffsets.js';
+export { Tr2RingBuffer } from './device/Tr2RingBuffer/Tr2RingBuffer.js';
 export { Tr2RuntimeGpuBuffer } from './device/Tr2RuntimeGpuBuffer.js';
 export { Tr2LightManager } from './lighting/Tr2LightManager.js';
 export { Tr2ShLightingManager } from './lighting/Tr2ShLightingManager.js';
@@ -62,11 +71,27 @@ export { Tr2InstancedMesh } from './mesh/Tr2InstancedMesh.js';
 export { Tr2SerializedMorphAnimation } from './mesh/Tr2SerializedMorphAnimation.js';
 export { Tr2DirectInstanceData } from './mesh/Tr2DirectInstanceData.js';
 export { Tr2RuntimeInstanceData } from './mesh/Tr2RuntimeInstanceData.js';
-export { ITr2InstanceData, ITr2InstanceDataInstanceData, withITr2InstanceData } from './mesh/ITr2InstanceData.js';
-export { ITr2ImpostorSource, ITr2ImpostorSourceImpostorHash, withITr2ImpostorSource } from './mesh/ITr2ImpostorSource.js';
+export { ITr2InstanceDataInstanceData } from './mesh/ITr2InstanceData/ITr2InstanceDataInstanceData.js';
+export { ITr2InstanceData, withITr2InstanceData } from './mesh/ITr2InstanceData/ITr2InstanceData.js';
+export { ITr2ImpostorSourceImpostorHash } from './mesh/ITr2ImpostorSource/ITr2ImpostorSourceImpostorHash.js';
+export { ITr2ImpostorSource, withITr2ImpostorSource } from './mesh/ITr2ImpostorSource/ITr2ImpostorSource.js';
 export { RawData, RawDataEncoders, RawDataType } from './rawData/RawData.js';
 export { TriPoolAllocator } from './rawData/TriPoolAllocator.js';
-export { Tr2PerObjectData } from './rawData/Tr2PerObjectData.js';
+export { Tr2PerObjectData } from './rawData/perObjectData/Tr2PerObjectData.js';
+export { Tr2PerObjectDataPSBuffer } from './rawData/perObjectData/Tr2PerObjectDataPSBuffer.js';
+export { Tr2PerObjectDataStandard } from './rawData/perObjectData/Tr2PerObjectDataStandard.js';
+export { EveBasicPerObjectData } from './rawData/perObjectData/EveBasicPerObjectData.js';
+export { EveBoosterSetPerObjectData } from './rawData/perObjectData/EveBoosterSetPerObjectData.js';
+export { EveChildBoosterSetPerObjectData } from './rawData/perObjectData/EveChildBoosterSetPerObjectData.js';
+export { EveChildBulletStormPerObjectData } from './rawData/perObjectData/EveChildBulletStormPerObjectData.js';
+export { EveChildSpherePinPerObjectData } from './rawData/perObjectData/EveChildSpherePinPerObjectData.js';
+export { EveDecalPerObjectData } from './rawData/perObjectData/EveDecalPerObjectData.js';
+export { EveLensflarePerObjectData } from './rawData/perObjectData/EveLensflarePerObjectData.js';
+export { EveMissileWarheadPerObjectData } from './rawData/perObjectData/EveMissileWarheadPerObjectData.js';
+export { EveSceneStaticParticlesPerObjectData } from './rawData/perObjectData/EveSceneStaticParticlesPerObjectData.js';
+export { EveSpherePinPerObjectData } from './rawData/perObjectData/EveSpherePinPerObjectData.js';
+export { EveTurretSetPerObjectData } from './rawData/perObjectData/EveTurretSetPerObjectData.js';
+export { StretchPerObjectData } from './rawData/perObjectData/StretchPerObjectData.js';
 export { Tr2ManipulationTool } from './tool/Tr2ManipulationTool.js';
 export { Tr2RotationTool } from './tool/Tr2RotationTool.js';
 export { Tr2ScalingTool } from './tool/Tr2ScalingTool.js';
@@ -76,7 +101,8 @@ export { TriVariable } from './variable/TriVariable.js';
 export { TriFloat } from './variable/TriFloat.js';
 export { SendEventToAudEmitter, TriObserverLocal } from './variable/TriObserverLocal.js';
 export { Tr2ExpressionTermInfo } from './variable/Tr2ExpressionTermInfo.js';
-export { Tr2VertexDefinition, Tr2VertexDefinitionItem } from './vertex/Tr2VertexDefinition.js';
+export { Tr2VertexDefinitionItem } from './vertex/Tr2VertexDefinition/Tr2VertexDefinitionItem.js';
+export { Tr2VertexDefinition } from './vertex/Tr2VertexDefinition/Tr2VertexDefinition.js';
 export { CarbonUsageFromChannel, CarbonUsageFromCmf, CarbonVertexElements } from './vertex/vertexUsage.js';
 export { FLOAT_MAX, PlaneDotCoord, PlaneDotNormal, TriFrustum } from './view/TriFrustum.js';
 export { TriFrustumOrtho } from './view/TriFrustumOrtho.js';
@@ -88,5 +114,6 @@ export { convertProjectionCoordToWorldPickRay, screenToProjection } from './view
 export { TR2_PICK_TYPE_DEFAULT, Tr2PickType } from './view/Tr2PickType.js';
 export { Tr2VolumetricsRenderer } from './volumetrics/Tr2VolumetricsRenderer.js';
 export { Tr2StreamingBitmapSaver } from './Tr2StreamingBitmapSaver.js';
-export { Tr2TextureArray, Tr2TextureArrayElement } from './Tr2TextureArray.js';
+export { Tr2TextureArrayElement } from './Tr2TextureArray/Tr2TextureArrayElement.js';
+export { Tr2TextureArray } from './Tr2TextureArray/Tr2TextureArray.js';
 //# sourceMappingURL=index.js.map

package/dist/trinity/core/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/trinity/core/lighting/Tr2LightManager.js

@@ -4,7 +4,7 @@ import { carbon, impl, type } from '#schema';
 import { num } from '#math/num';
 import { vec3 } from '#math/vec3';
 import { ShadowQuality } from '../../generated/trinityCore/enums.js';
-import { Tr2TextureArray as _Tr2TextureArray } from '../Tr2TextureArray.js';
+import { Tr2TextureArray as _Tr2TextureArray } from '../Tr2TextureArray/Tr2TextureArray.js';
 
 let _initStatic, _initProto, _initClass;
 
@@ -594,6 +594,11 @@ new class extends _identity {
       // cutoff - absent at the cutoff, full brightness FADE_SIZE above it.
       return Math.min((size - this.#adjustedCutoff) / FADE_SIZE, 1);
     }
+
+    /**
+     * Returns the light's projected pixel size, or its radius when no frustum is
+     * set.
+     */
     #ScreenSize(record) {
       if (!this.#frustum) return record.radius;
       return this.#frustum.GetPixelSizeAccross(record.position, record.radius);