refactor: rename MacroMap to ShaderProgramMap and remove generic abstraction

Author: GuoLei1990

packages/core/src/Engine.ts

@@ -33,7 +33,7 @@ import { Shader } from "./shader/Shader";
 import { ShaderMacro } from "./shader/ShaderMacro";
 import { ShaderMacroCollection } from "./shader/ShaderMacroCollection";
 import { ShaderPool } from "./shader/ShaderPool";
-import { MacroMap } from "./shader/MacroMap";
+import { ShaderProgramMap } from "./shader/ShaderProgramMap";
 import { ShaderProgram } from "./shader/ShaderProgram";
 import { RenderState } from "./shader/state/RenderState";
 import { Texture2D, TextureFormat } from "./texture";
@@ -113,7 +113,7 @@ export class Engine extends EventDispatcher {
   /* @internal */
   _renderCount: number = 0;
   /* @internal */
-  _shaderProgramMaps: MacroMap<ShaderProgram>[] = [];
+  _shaderProgramMaps: ShaderProgramMap[] = [];
   /** @internal */
   _fontMap: Record<string, Font> = {};
   /** @internal */
@@ -542,15 +542,15 @@ export class Engine extends EventDispatcher {
   /**
    * @internal
    */
-  _getShaderProgramMap(index: number, trackMaps?: MacroMap<ShaderProgram>[]): MacroMap<ShaderProgram> {
+  _getShaderProgramMap(index: number, trackMaps?: ShaderProgramMap[]): ShaderProgramMap {
     const shaderProgramMaps = this._shaderProgramMaps;
     let map = shaderProgramMaps[index];
     if (!map) {
       const length = index + 1;
       if (length > shaderProgramMaps.length) {
         shaderProgramMaps.length = length;
       }
-      shaderProgramMaps[index] = map = new MacroMap<ShaderProgram>(this);
+      shaderProgramMaps[index] = map = new ShaderProgramMap(this);
       trackMaps?.push(map);
     }
     return map;

packages/core/src/shader/Shader.ts

@@ -241,7 +241,7 @@ export class Shader implements IReferable {
           for (let k = passShaderProgramMaps.length - 1; k >= 0; k--) {
             const map = passShaderProgramMaps[k];
             if (map.engine !== engine) continue;
-            map.clear((program) => program.destroy());
+            map.destroy();
             passShaderProgramMaps.splice(k, 1);
           }
         }

packages/core/src/shader/ShaderPass.ts

@@ -7,7 +7,7 @@ import { ShaderFactory, InstanceLayout } from "../shaderlib/ShaderFactory";
 import { ShaderMacro } from "./ShaderMacro";
 import { ShaderMacroCollection } from "./ShaderMacroCollection";
 import { ShaderPart } from "./ShaderPart";
-import { MacroMap } from "./MacroMap";
+import { ShaderProgramMap } from "./ShaderProgramMap";
 import { ShaderProgram } from "./ShaderProgram";
 import { ShaderProperty } from "./ShaderProperty";
 import { ShaderLanguage } from "./enums/ShaderLanguage";
@@ -54,7 +54,7 @@ export class ShaderPass extends ShaderPart {
   /** @internal */
   _renderStateDataMap: Record<number, ShaderProperty> = {};
   /** @internal */
-  _shaderProgramMaps: MacroMap<ShaderProgram>[] = [];
+  _shaderProgramMaps: ShaderProgramMap[] = [];
 
   private _vertexSource?: string;
   private _fragmentSource?: string;
@@ -165,7 +165,7 @@ export class ShaderPass extends ShaderPart {
     const shaderProgramMaps = this._shaderProgramMaps;
     for (let i = 0, n = shaderProgramMaps.length; i < n; i++) {
       const map = shaderProgramMaps[i];
-      map.clear((program) => program.destroy());
+      map.destroy();
       delete map.engine._shaderProgramMaps[this._shaderPassId];
     }
     shaderProgramMaps.length = 0;

packages/core/src/shader/MacroMap.ts …ages/core/src/shader/ShaderProgramMap.tspackages/core/src/shader/MacroMap.ts renamed to packages/core/src/shader/ShaderProgramMap.ts packages/core/src/shader/MacroMap.ts renamed to packages/core/src/shader/ShaderProgramMap.ts

@@ -1,27 +1,28 @@
 import { Engine } from "../Engine";
 import { ShaderMacroCollection } from "./ShaderMacroCollection";
+import { ShaderProgram } from "./ShaderProgram";
 
-type Tree<T> = {
-  [key: number]: Tree<T> | T;
+type Tree = {
+  [key: number]: Tree | ShaderProgram;
 };
 
 /**
- * Map keyed by ShaderMacroCollection bitmask.
+ * Map keyed by ShaderMacroCollection bitmask, caching ShaderProgram instances.
  * @internal
  */
-export class MacroMap<T> {
+export class ShaderProgramMap {
   engine: Engine;
 
   private _cacheHierarchyDepth: number = 1;
-  private _cacheMap: Tree<T> = Object.create(null);
-  private _lastQueryMap: Record<number, T>;
+  private _cacheMap: Tree = Object.create(null);
+  private _lastQueryMap: Record<number, ShaderProgram>;
   private _lastQueryKey: number;
 
   constructor(engine?: Engine) {
     this.engine = engine;
   }
 
-  get(macros: ShaderMacroCollection): T | null {
+  get(macros: ShaderMacroCollection): ShaderProgram | null {
     let cacheMap = this._cacheMap;
     const maskLength = macros._length;
     const cacheHierarchyDepth = this._cacheHierarchyDepth;
@@ -35,54 +36,52 @@ export class MacroMap<T> {
     const maxEndIndex = this._cacheHierarchyDepth - 1;
     for (let i = 0; i < maxEndIndex; i++) {
       const subMask = endIndex < i ? 0 : mask[i];
-      let subCache = <Tree<T>>cacheMap[subMask];
+      let subCache = <Tree>cacheMap[subMask];
       subCache || (cacheMap[subMask] = subCache = Object.create(null));
       cacheMap = subCache;
     }
 
     const cacheKey = endIndex < maxEndIndex ? 0 : mask[maxEndIndex];
-    const value = (<Record<number, T>>cacheMap)[cacheKey];
+    const value = (<Record<number, ShaderProgram>>cacheMap)[cacheKey];
     if (!value) {
       this._lastQueryKey = cacheKey;
-      this._lastQueryMap = <Record<number, T>>cacheMap;
+      this._lastQueryMap = <Record<number, ShaderProgram>>cacheMap;
     }
     return value;
   }
 
-  cache(value: T): void {
+  cache(value: ShaderProgram): void {
     this._lastQueryMap[this._lastQueryKey] = value;
   }
 
-  clear(callback?: (value: T) => void): void {
-    if (callback) {
-      this._recursiveForEach(0, this._cacheMap, callback);
-    }
+  destroy(): void {
+    this._recursiveForEach(0, this._cacheMap);
     this._cacheMap = Object.create(null);
     this._cacheHierarchyDepth = 1;
   }
 
-  private _recursiveForEach(hierarchy: number, cacheMap: Tree<T>, callback: (value: T) => void): void {
+  private _recursiveForEach(hierarchy: number, cacheMap: Tree): void {
     if (hierarchy === this._cacheHierarchyDepth - 1) {
       for (let k in cacheMap) {
-        callback(<T>cacheMap[k]);
+        (<ShaderProgram>cacheMap[k]).destroy();
       }
       return;
     }
     ++hierarchy;
     for (let k in cacheMap) {
-      this._recursiveForEach(hierarchy, <Tree<T>>cacheMap[k], callback);
+      this._recursiveForEach(hierarchy, <Tree>cacheMap[k]);
     }
   }
 
   private _resizeCacheMapHierarchy(
-    cacheMap: Tree<T>,
+    cacheMap: Tree,
     hierarchy: number,
     currentHierarchy: number,
     increaseHierarchy: number
   ): void {
     if (hierarchy == currentHierarchy - 1) {
       for (let k in cacheMap) {
-        const value = <T>cacheMap[k];
+        const value = <ShaderProgram>cacheMap[k];
         let subCacheMap = cacheMap;
         for (let i = 0; i < increaseHierarchy; i++) {
           subCacheMap[i == 0 ? k : 0] = subCacheMap = Object.create(null);
@@ -92,7 +91,7 @@ export class MacroMap<T> {
     } else {
       hierarchy++;
       for (let k in cacheMap) {
-        this._resizeCacheMapHierarchy(<Tree<T>>cacheMap[k], hierarchy, currentHierarchy, increaseHierarchy);
+        this._resizeCacheMapHierarchy(<Tree>cacheMap[k], hierarchy, currentHierarchy, increaseHierarchy);
       }
     }
   }