Refactor 2d render pipeline

packages/core/src/2d/assembler/IAssembler.ts → packages/core/src/2d/assembler/ISpriteAssembler.ts

@@ -3,8 +3,9 @@ import { Renderer } from "../../Renderer";
 /**
  * @internal
  */
-export interface IAssembler {
-  resetData(renderer: Renderer): void;
+export interface ISpriteAssembler {
+  resetData(renderer: Renderer, vertexCount?: number): void;
   updatePositions?(renderer: Renderer): void;
   updateUVs?(renderer: Renderer): void;
+  updateColor?(renderer: Renderer): void;
 }

packages/core/src/2d/assembler/SimpleSpriteAssembler.ts

@@ -1,35 +1,33 @@
-import { BoundingBox, Matrix, Vector2, Vector3 } from "@galacean/engine-math";
+import { BoundingBox, Matrix } from "@galacean/engine-math";
 import { StaticInterfaceImplement } from "../../base/StaticInterfaceImplement";
 import { SpriteMask } from "../sprite";
 import { SpriteRenderer } from "../sprite/SpriteRenderer";
-import { IAssembler } from "./IAssembler";
+import { ISpriteAssembler } from "./ISpriteAssembler";
 
 /**
  * @internal
  */
-@StaticInterfaceImplement<IAssembler>()
+@StaticInterfaceImplement<ISpriteAssembler>()
 export class SimpleSpriteAssembler {
-  static _rectangleTriangles: number[] = [0, 1, 2, 2, 1, 3];
-  static _worldMatrix: Matrix = new Matrix();
+  static _rectangleTriangles = [0, 1, 2, 2, 1, 3];
+  static _worldMatrix = new Matrix();
 
   static resetData(renderer: SpriteRenderer | SpriteMask): void {
-    const { _verticesData: verticesData } = renderer;
-    const { positions, uvs } = verticesData;
-    verticesData.vertexCount = positions.length = uvs.length = 4;
-    for (let i = 0; i < 4; i++) {
-      positions[i] ||= new Vector3();
-      uvs[i] ||= new Vector2();
-    }
-    verticesData.triangles = SimpleSpriteAssembler._rectangleTriangles;
+    const manager = renderer._getChunkManager();
+    const lastSubChunk = renderer._subChunk;
+    lastSubChunk && manager.freeSubChunk(lastSubChunk);
+    const subChunk = manager.allocateSubChunk(4);
+    subChunk.indices = SimpleSpriteAssembler._rectangleTriangles;
+    renderer._subChunk = subChunk;
   }
 
   static updatePositions(renderer: SpriteRenderer | SpriteMask): void {
     const { width, height, sprite } = renderer;
     const { x: pivotX, y: pivotY } = sprite.pivot;
-    // Renderer's worldMatrix;
-    const { _worldMatrix: worldMatrix } = SimpleSpriteAssembler;
+    // Renderer's worldMatrix
+    const worldMatrix = SimpleSpriteAssembler._worldMatrix;
     const { elements: wE } = worldMatrix;
-    // Parent's worldMatrix.
+    // Parent's worldMatrix
     const { elements: pWE } = renderer.entity.transform.worldMatrix;
     const sx = renderer.flipX ? -width : width;
     const sy = renderer.flipY ? -height : height;
@@ -45,25 +43,46 @@ export class SimpleSpriteAssembler {
     //  |   |
     //  0 - 1
     // ---------------
-    // Update positions.
+    // Update positions
     const spritePositions = sprite._getPositions();
-    const { positions } = renderer._verticesData;
-    for (let i = 0; i < 4; i++) {
+    const subChunk = renderer._subChunk;
+    const vertices = subChunk.chunk.vertices;
+    for (let i = 0, o = subChunk.vertexArea.start; i < 4; ++i, o += 9) {
       const { x, y } = spritePositions[i];
-      positions[i].set(wE[0] * x + wE[4] * y + wE[12], wE[1] * x + wE[5] * y + wE[13], wE[2] * x + wE[6] * y + wE[14]);
+      vertices[o] = wE[0] * x + wE[4] * y + wE[12];
+      vertices[o + 1] = wE[1] * x + wE[5] * y + wE[13];
+      vertices[o + 2] = wE[2] * x + wE[6] * y + wE[14];
     }
 
     BoundingBox.transform(sprite._getBounds(), worldMatrix, renderer._bounds);
   }
 
   static updateUVs(renderer: SpriteRenderer | SpriteMask): void {
     const spriteUVs = renderer.sprite._getUVs();
-    const renderUVs = renderer._verticesData.uvs;
     const { x: left, y: bottom } = spriteUVs[0];
     const { x: right, y: top } = spriteUVs[3];
-    renderUVs[0].set(left, bottom);
-    renderUVs[1].set(right, bottom);
-    renderUVs[2].set(left, top);
-    renderUVs[3].set(right, top);
+    const subChunk = renderer._subChunk;
+    const vertices = subChunk.chunk.vertices;
+    const offset = subChunk.vertexArea.start + 3;
+    vertices[offset] = left;
+    vertices[offset + 1] = bottom;
+    vertices[offset + 9] = right;
+    vertices[offset + 10] = bottom;
+    vertices[offset + 18] = left;
+    vertices[offset + 19] = top;
+    vertices[offset + 27] = right;
+    vertices[offset + 28] = top;
+  }
+
+  static updateColor(renderer: SpriteRenderer): void {
+    const subChunk = renderer._subChunk;
+    const { r, g, b, a } = renderer.color;
+    const vertices = subChunk.chunk.vertices;
+    for (let i = 0, o = subChunk.vertexArea.start + 5; i < 4; ++i, o += 9) {
+      vertices[o] = r;
+      vertices[o + 1] = g;
+      vertices[o + 2] = b;
+      vertices[o + 3] = a;
+    }
   }
 }

packages/core/src/2d/assembler/SlicedSpriteAssembler.ts

@@ -1,35 +1,31 @@
-import { Matrix, Vector2, Vector3 } from "@galacean/engine-math";
+import { Matrix } from "@galacean/engine-math";
 import { StaticInterfaceImplement } from "../../base/StaticInterfaceImplement";
 import { SpriteRenderer } from "../sprite/SpriteRenderer";
-import { IAssembler } from "./IAssembler";
-import { SimpleSpriteAssembler } from "./SimpleSpriteAssembler";
+import { ISpriteAssembler } from "./ISpriteAssembler";
 
 /**
  * @internal
  */
-@StaticInterfaceImplement<IAssembler>()
+@StaticInterfaceImplement<ISpriteAssembler>()
 export class SlicedSpriteAssembler {
-  static _rectangleTriangles: number[] = [
+  static _rectangleTriangles = [
     0, 1, 4, 1, 5, 4, 1, 2, 5, 2, 6, 5, 2, 3, 6, 3, 7, 6, 4, 5, 8, 5, 9, 8, 5, 6, 9, 6, 10, 9, 6, 7, 10, 7, 11, 10, 8,
     9, 12, 9, 13, 12, 9, 10, 13, 10, 14, 13, 10, 11, 14, 11, 15, 14
   ];
-  static _worldMatrix: Matrix = new Matrix();
+  static _worldMatrix = new Matrix();
+
   static resetData(renderer: SpriteRenderer): void {
-    const { _verticesData: verticesData } = renderer;
-    const { positions, uvs } = verticesData;
-    verticesData.vertexCount = positions.length = uvs.length = 16;
-    for (let i = 0; i < 16; i++) {
-      positions[i] ||= new Vector3();
-      uvs[i] ||= new Vector2();
-    }
-    verticesData.triangles = SlicedSpriteAssembler._rectangleTriangles;
+    const manager = renderer._getChunkManager();
+    const lastSubChunk = renderer._subChunk;
+    lastSubChunk && manager.freeSubChunk(lastSubChunk);
+    const subChunk = manager.allocateSubChunk(16);
+    subChunk.indices = SlicedSpriteAssembler._rectangleTriangles;
+    renderer._subChunk = subChunk;
   }
 
   static updatePositions(renderer: SpriteRenderer): void {
     const { width, height, sprite } = renderer;
-    const { positions, uvs } = renderer._verticesData;
     const { border } = sprite;
-    const spriteUVs = sprite._getUVs();
     // Update local positions.
     const spritePositions = sprite._getPositions();
     const { x: left, y: bottom } = spritePositions[0];
@@ -81,7 +77,7 @@ export class SlicedSpriteAssembler {
     const localTransX = renderer.width * pivotX;
     const localTransY = renderer.height * pivotY;
     // Renderer's worldMatrix.
-    const { _worldMatrix: worldMatrix } = SlicedSpriteAssembler;
+    const worldMatrix = SlicedSpriteAssembler._worldMatrix;
     const { elements: wE } = worldMatrix;
     // Parent's worldMatrix.
     const { elements: pWE } = renderer.entity.transform.worldMatrix;
@@ -104,18 +100,15 @@ export class SlicedSpriteAssembler {
     //  0 - 4 - 8  - 12
     // ------------------------
     // Assemble position and uv.
-    for (let i = 0; i < 4; i++) {
+    const subChunk = renderer._subChunk;
+    const vertices = subChunk.chunk.vertices;
+    for (let i = 0, o = subChunk.vertexArea.start; i < 4; i++) {
       const rowValue = row[i];
-      const rowU = spriteUVs[i].x;
-      for (let j = 0; j < 4; j++) {
+      for (let j = 0; j < 4; j++, o += 9) {
         const columnValue = column[j];
-        const idx = i * 4 + j;
-        positions[idx].set(
-          wE[0] * rowValue + wE[4] * columnValue + wE[12],
-          wE[1] * rowValue + wE[5] * columnValue + wE[13],
-          wE[2] * rowValue + wE[6] * columnValue + wE[14]
-        );
-        uvs[idx].set(rowU, spriteUVs[j].y);
+        vertices[o] = wE[0] * rowValue + wE[4] * columnValue + wE[12];
+        vertices[o + 1] = wE[1] * rowValue + wE[5] * columnValue + wE[13];
+        vertices[o + 2] = wE[2] * rowValue + wE[6] * columnValue + wE[14];
       }
     }
 
@@ -125,5 +118,28 @@ export class SlicedSpriteAssembler {
     renderer._bounds.transform(worldMatrix);
   }
 
-  static updateUVs(renderer: SpriteRenderer): void {}
+  static updateUVs(renderer: SpriteRenderer): void {
+    const subChunk = renderer._subChunk;
+    const vertices = subChunk.chunk.vertices;
+    const spriteUVs = renderer.sprite._getUVs();
+    for (let i = 0, o = subChunk.vertexArea.start + 3; i < 4; i++) {
+      const rowU = spriteUVs[i].x;
+      for (let j = 0; j < 4; j++, o += 9) {
+        vertices[o] = rowU;
+        vertices[o + 1] = spriteUVs[j].y;
+      }
+    }
+  }
+
+  static updateColor(renderer: SpriteRenderer): void {
+    const subChunk = renderer._subChunk;
+    const { r, g, b, a } = renderer.color;
+    const vertices = subChunk.chunk.vertices;
+    for (let i = 0, o = subChunk.vertexArea.start + 5; i < 16; ++i, o += 9) {
+      vertices[o] = r;
+      vertices[o + 1] = g;
+      vertices[o + 2] = b;
+      vertices[o + 3] = a;
+    }
+  }
 }