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 static _sheenProp = ShaderProperty.getByName("material_Sheen");
+  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`
@@ -222,6 +228,84 @@
     }
   }
 
+  /**
+   * The sheen layer intensity, from 0.0 to 1.0.
+   * @defaultValue `0`
+   */
+  get sheen(): number {
+    return this.shaderData.getFloat(PBRMaterial._sheenProp);
+  }
+
+  set sheen(value: number) {
+    if (!!this.shaderData.getFloat(PBRMaterial._sheenProp) !== !!value) {
+      if (value === 0) {
+        this.shaderData.disableMacro("MATERIAL_ENABLE_SHEEN");
+      } else {
+        this.shaderData.enableMacro("MATERIAL_ENABLE_SHEEN");
+      }
+    }
+    this.shaderData.setFloat(PBRMaterial._sheenProp, value);
+  }
+
+  /**
+   * 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);
+  }
+
+  /**
+   * Sheen color 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");
+    }
+  }
+
+  /**
+   * Sheen roughness texture, 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,6 +319,7 @@
     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(1, 1, 1));
     // @ts-ignore
     this._iridescenceRange._onValueChanged = this._onIridescenceRangeChanged.bind(this);
   }

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 = new Color(
+        Color.linearToGammaSpace(sheenColorFactor[0]),
+        Color.linearToGammaSpace(sheenColorFactor[1]),
+        Color.linearToGammaSpace(sheenColorFactor[2]),
+        sheenColorFactor[3]
+      );
+    }
+
+    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;
+      });
+    }
+  }
+}