refactor: opt code

galacean · Dec 26, 2024 · ce75450 · ce75450
1 parent 0a776c4
commit ce75450
Show file tree

Hide file tree

Showing 2 changed files with 74 additions and 51 deletions.
diff --git a/packages/core/src/material/BaseMaterial.ts b/packages/core/src/material/BaseMaterial.ts
@@ -24,11 +24,11 @@ export class BaseMaterial extends Material {
   protected static _emissiveColorProp: ShaderProperty = ShaderProperty.getByName("material_EmissiveColor");
   protected static _emissiveTextureProp: ShaderProperty = ShaderProperty.getByName("material_EmissiveTexture");
 
-  private static _alphaCutoffProp: ShaderProperty = ShaderProperty.getByName("material_AlphaCutoff");
+  protected static _alphaCutoffProp: ShaderProperty = ShaderProperty.getByName("material_AlphaCutoff");
   private static _alphaCutoffMacro: ShaderMacro = ShaderMacro.getByName("MATERIAL_IS_ALPHA_CUTOFF");
 
   private _renderFace: RenderFace = RenderFace.Front;
-  private _isTransparent: boolean = false;
+  protected _isTransparent: boolean = false;
   private _blendMode: BlendMode = BlendMode.Normal;
 
   /**
@@ -73,24 +73,7 @@ export class BaseMaterial extends Material {
   }
 
   set isTransparent(value: boolean) {
-    if (value !== this._isTransparent) {
-      this.setIsTransparent(0, value);
-
-      const { shaderData } = this;
-      if (value) {
-        // Use alpha test queue to simulate transparent shadow
-        shaderData.setFloat(BaseMaterial._shadowCasterRenderQueueProp, RenderQueueType.AlphaTest);
-      } else {
-        const alphaCutoff = shaderData.getFloat(BaseMaterial._alphaCutoffProp);
-        if (alphaCutoff) {
-          shaderData.setFloat(BaseMaterial._shadowCasterRenderQueueProp, RenderQueueType.AlphaTest);
-        } else {
-          shaderData.setFloat(BaseMaterial._shadowCasterRenderQueueProp, RenderQueueType.Opaque);
-        }
-      }
-
-      this._isTransparent = value;
-    }
+    this._seIsTransparent(value);
   }
 
   /**
@@ -119,35 +102,7 @@ export class BaseMaterial extends Material {
   }
 
   set alphaCutoff(value: number) {
-    const { shaderData } = this;
-    if (shaderData.getFloat(BaseMaterial._alphaCutoffProp) !== value) {
-      if (value) {
-        shaderData.enableMacro(BaseMaterial._alphaCutoffMacro);
-        shaderData.setFloat(BaseMaterial._shadowCasterRenderQueueProp, RenderQueueType.AlphaTest);
-      } else {
-        shaderData.disableMacro(BaseMaterial._alphaCutoffMacro);
-        if (this._isTransparent) {
-          shaderData.setFloat(BaseMaterial._shadowCasterRenderQueueProp, RenderQueueType.AlphaTest);
-        } else {
-          shaderData.setFloat(BaseMaterial._shadowCasterRenderQueueProp, RenderQueueType.Opaque);
-        }
-      }
-
-      const { renderStates } = this;
-      for (let i = 0, n = renderStates.length; i < n; i++) {
-        const renderState = renderStates[i];
-        if (value > 0) {
-          renderState.renderQueueType = renderState.blendState.targetBlendState.enabled
-            ? RenderQueueType.Transparent
-            : RenderQueueType.AlphaTest;
-        } else {
-          renderState.renderQueueType = renderState.blendState.targetBlendState.enabled
-            ? RenderQueueType.Transparent
-            : RenderQueueType.Opaque;
-        }
-      }
-      shaderData.setFloat(BaseMaterial._alphaCutoffProp, value);
-    }
+    this._setAlphaCutoff(value);
   }
 
   /**
@@ -279,4 +234,57 @@ export class BaseMaterial extends Material {
     target._isTransparent = this._isTransparent;
     target._blendMode = this._blendMode;
   }
+
+  protected _seIsTransparent(value: boolean): void {
+    if (value !== this._isTransparent) {
+      this.setIsTransparent(0, value);
+
+      const { shaderData } = this;
+      if (value) {
+        // Use alpha test queue to simulate transparent shadow
+        shaderData.setFloat(BaseMaterial._shadowCasterRenderQueueProp, RenderQueueType.AlphaTest);
+      } else {
+        const alphaCutoff = shaderData.getFloat(BaseMaterial._alphaCutoffProp);
+        if (alphaCutoff) {
+          shaderData.setFloat(BaseMaterial._shadowCasterRenderQueueProp, RenderQueueType.AlphaTest);
+        } else {
+          shaderData.setFloat(BaseMaterial._shadowCasterRenderQueueProp, RenderQueueType.Opaque);
+        }
+      }
+
+      this._isTransparent = value;
+    }
+  }
+
+  protected _setAlphaCutoff(value: number): void {
+    const { shaderData } = this;
+    if (shaderData.getFloat(BaseMaterial._alphaCutoffProp) !== value) {
+      if (value) {
+        shaderData.enableMacro(BaseMaterial._alphaCutoffMacro);
+        shaderData.setFloat(BaseMaterial._shadowCasterRenderQueueProp, RenderQueueType.AlphaTest);
+      } else {
+        shaderData.disableMacro(BaseMaterial._alphaCutoffMacro);
+        if (this._isTransparent) {
+          shaderData.setFloat(BaseMaterial._shadowCasterRenderQueueProp, RenderQueueType.AlphaTest);
+        } else {
+          shaderData.setFloat(BaseMaterial._shadowCasterRenderQueueProp, RenderQueueType.Opaque);
+        }
+      }
+
+      const { renderStates } = this;
+      for (let i = 0, n = renderStates.length; i < n; i++) {
+        const renderState = renderStates[i];
+        if (value > 0) {
+          renderState.renderQueueType = renderState.blendState.targetBlendState.enabled
+            ? RenderQueueType.Transparent
+            : RenderQueueType.AlphaTest;
+        } else {
+          renderState.renderQueueType = renderState.blendState.targetBlendState.enabled
+            ? RenderQueueType.Transparent
+            : RenderQueueType.Opaque;
+        }
+      }
+      shaderData.setFloat(BaseMaterial._alphaCutoffProp, value);
+    }
+  }
 }
diff --git a/packages/core/src/material/PBRMaterial.ts b/packages/core/src/material/PBRMaterial.ts
@@ -4,6 +4,7 @@ import { ShaderMacro, ShaderProperty } from "../shader";
 import { Shader } from "../shader/Shader";
 import { RenderQueueType } from "../shader/enums/RenderQueueType";
 import { Texture2D } from "../texture/Texture2D";
+import { BaseMaterial } from "./BaseMaterial";
 import { PBRBaseMaterial } from "./PBRBaseMaterial";
 import { RefractionMode } from "./enums/Refraction";
 
@@ -320,16 +321,30 @@ export class PBRMaterial extends PBRBaseMaterial {
     }
   }
 
+  /**
+   * @inheritdoc
+   */
+  override get isTransparent(): boolean {
+    return this._isTransparent;
+  }
+
   override set isTransparent(value: boolean) {
-    super.isTransparent = value;
+    this._seIsTransparent(value);
     if (this.transmission > 0) {
       // If transmission enabled, always use transparent queue to ensure get correct opaque texture
       this.renderState.renderQueueType = RenderQueueType.Transparent;
     }
   }
 
+  /**
+   * @inheritdoc
+   */
+  override get alphaCutoff(): number {
+    return this.shaderData.getFloat(BaseMaterial._alphaCutoffProp);
+  }
+
   override set alphaCutoff(value: number) {
-    super.alphaCutoff = value;
+    this._setAlphaCutoff(value);
     if (this.transmission > 0) {
       // If transmission enabled, always use transparent queue to ensure get correct opaque texture
       this.renderState.renderQueueType = RenderQueueType.Transparent;