PBR support sheen

packages/core/src/material/PBRMaterial.ts

@@ -1,4 +1,4 @@
-import { MathUtil, Vector2, Vector3, Vector4 } from "@galacean/engine-math";
+import { MathUtil, Vector2, Vector3, Vector4, Color } from "@galacean/engine-math";
 import { Engine } from "../Engine";
 import { ShaderProperty } from "../shader";
 import { Shader } from "../shader/Shader";
@@ -25,6 +25,12 @@
   private static _iridescenceTextureProp = ShaderProperty.getByName("material_IridescenceTexture");
   private _iridescenceRange = new Vector2(100, 400);
 
+  private _sheenEnabled = false;
+  private static _sheenColorProp = ShaderProperty.getByName("material_SheenColor");
+  private static _sheenRoughnessProp = ShaderProperty.getByName("material_SheenRoughness");
+  private static _sheenTextureProp = ShaderProperty.getByName("material_SheenTexture");
+  private static _sheenRoughnessTextureProp = ShaderProperty.getByName("material_SheenRoughnessTexture");
+
   /**
    * Index Of Refraction.
    * @defaultValue `1.5`
@@ -190,7 +196,7 @@
 
   /**
    * The range of iridescence thickness, x is minimum, y is maximum.
-   *  @defaultValue `[100, 400]`.
+   *  @defaultValue `[100, 400]`
    */
   get iridescenceThicknessRange(): Vector2 {
     return this._iridescenceRange;
@@ -222,6 +228,66 @@
     }
   }
 
+  /**
+   * Sheen color.
+   * @defaultValue `[0,0,0]`
+   */
+  get sheenColor(): Color {
+    return this.shaderData.getColor(PBRMaterial._sheenColorProp);
+  }
+
+  set sheenColor(value: Color) {
+    const sheenColor = this.shaderData.getColor(PBRMaterial._sheenColorProp);
+    if (value !== sheenColor) {
+      sheenColor.copyFrom(value);
+    }
+  }
+
+  /**
+   * Sheen roughness, from 0.0 to 1.0.
+   * @defaultValue `0.0`
+   */
+  get sheenRoughness(): number {
+    return this.shaderData.getFloat(PBRMaterial._sheenRoughnessProp);
+  }
+
+  set sheenRoughness(value: number) {
+    this.shaderData.setFloat(PBRMaterial._sheenRoughnessProp, value);
+  }
+
+  /**
+   * SheenColor texture, multiply ‘sheenColor’.
+   */
+  get sheenColorTexture(): Texture2D {
+    return <Texture2D>this.shaderData.getTexture(PBRMaterial._sheenTextureProp);
+  }
+
+  set sheenColorTexture(value: Texture2D) {
+    this.shaderData.setTexture(PBRMaterial._sheenTextureProp, value);
+    if (value) {
+      this.shaderData.enableMacro("MATERIAL_HAS_SHEEN_TEXTURE");
+    } else {
+      this.shaderData.disableMacro("MATERIAL_HAS_SHEEN_TEXTURE");
+    }
+  }
+
+  /**
+   * SheenRoughness texture.
+   * @remarks Use alpha channel, and multiply 'sheenRoughness'.
+   */
+  get sheenRoughnessTexture(): Texture2D {
+    return <Texture2D>this.shaderData.getTexture(PBRMaterial._sheenRoughnessTextureProp);
+  }
+
+  set sheenRoughnessTexture(value: Texture2D) {
+    this.shaderData.setTexture(PBRMaterial._sheenRoughnessTextureProp, value);
+    if (value) {
+      this.shaderData.enableMacro("MATERIAL_HAS_SHEEN_ROUGHNESS_TEXTURE");
+    } else {
+      this.shaderData.disableMacro("MATERIAL_HAS_SHEEN_ROUGHNESS_TEXTURE");
+    }
+  }
+
   /**
    * Create a pbr metallic-roughness workflow material instance.
    * @param engine - Engine to which the material belongs
@@ -235,8 +301,27 @@
     shaderData.setFloat(PBRMaterial._iorProp, 1.5);
     shaderData.setVector3(PBRMaterial._anisotropyInfoProp, new Vector3(1, 0, 0));
     shaderData.setVector4(PBRMaterial._iridescenceInfoProp, new Vector4(0, 1.3, 100, 400));
+    shaderData.setColor(PBRMaterial._sheenColorProp, new Color(0, 0, 0));
     // @ts-ignore
     this._iridescenceRange._onValueChanged = this._onIridescenceRangeChanged.bind(this);
+    // @ts-ignore
+    this.sheenColor._onValueChanged = () => {
+      const r = this.sheenColor.r;
+      const g = this.sheenColor.g;
+      const b = this.sheenColor.b;
+      /**
+       * The sheen layer switch.
+       */
+      const enableSheen = r + g + b > 0;
+      if (enableSheen !== this._sheenEnabled) {
+        this._sheenEnabled = enableSheen;
+        if (enableSheen) {
+          this.shaderData.enableMacro("MATERIAL_ENABLE_SHEEN");
+        } else {
+          this.shaderData.disableMacro("MATERIAL_ENABLE_SHEEN");
+        }
+      }
+    };
   }
 
   private _onIridescenceRangeChanged(): void {

packages/loader/src/gltf/extensions/KHR_materials_sheen.ts

@@ -1,0 +1,41 @@
+import { PBRMaterial, Texture2D } from "@galacean/engine-core";
+import { Color } from "@galacean/engine-math";
+import { GLTFMaterialParser } from "../parser/GLTFMaterialParser";
+import { registerGLTFExtension } from "../parser/GLTFParser";
+import { GLTFParserContext, GLTFParserType } from "../parser/GLTFParserContext";
+import { GLTFExtensionMode, GLTFExtensionParser } from "./GLTFExtensionParser";
+import { IKHRMaterialsSheen } from "./GLTFExtensionSchema";
+
+@registerGLTFExtension("KHR_materials_sheen", GLTFExtensionMode.AdditiveParse)
+class KHR_materials_sheen extends GLTFExtensionParser {
+  override additiveParse(context: GLTFParserContext, material: PBRMaterial, schema: IKHRMaterialsSheen): void {
+    const { sheenColorFactor, sheenColorTexture, sheenRoughnessFactor, sheenRoughnessTexture } = schema;
+
+    if (sheenColorFactor) {
+      material.sheenColor.set(
+        Color.linearToGammaSpace(sheenColorFactor[0]),
+        Color.linearToGammaSpace(sheenColorFactor[1]),
+        Color.linearToGammaSpace(sheenColorFactor[2]),
+        undefined
+      );
+    }
+
+    material.sheenRoughness = sheenRoughnessFactor;
+
+    if (sheenColorTexture) {
+      GLTFMaterialParser._checkOtherTextureTransform(sheenColorTexture, "Sheen texture");
+
+      context.get<Texture2D>(GLTFParserType.Texture, sheenColorTexture.index).then((texture) => {
+        material.sheenColorTexture = texture;
+      });
+    }
+
+    if (sheenRoughnessTexture) {
+      GLTFMaterialParser._checkOtherTextureTransform(sheenRoughnessTexture, "SheenRoughness texture");
+
+      context.get<Texture2D>(GLTFParserType.Texture, sheenRoughnessTexture.index).then((texture) => {
+        material.sheenRoughnessTexture = texture;
+      });
+    }
+  }
+}