Added ClearCoat material (WIP)

build/SharpGLTF.CodeGen/Constants.cs

@@ -29,6 +29,8 @@ namespace SharpGLTF
 
         public static string KhronosDracoSchemaFile => System.IO.Path.Combine(KhronosSchemaDir, "KHR_draco_mesh_compression", "schema");
         public static string KhronosPbrSpecGlossSchemaFile => System.IO.Path.Combine(KhronosSchemaDir, "KHR_materials_pbrSpecularGlossiness", "schema", "glTF.KHR_materials_pbrSpecularGlossiness.schema.json");
+
+        public static string KhronosPbrClearCoatSchemaFile => System.IO.Path.Combine(KhronosSchemaDir, "KHR_materials_clearcoat", "schema", "glTF.KHR_materials_clearcoat.schema.json");
         public static string KhronosUnlitSchemaFile => System.IO.Path.Combine(KhronosSchemaDir, "KHR_materials_unlit", "schema", "glTF.KHR_materials_unlit.schema.json");
         public static string KhronosModelLightsPunctualSchemaFile => System.IO.Path.Combine(KhronosSchemaDir, "KHR_lights_punctual", "schema", "glTF.KHR_lights_punctual.schema.json");
         public static string KhronosNodeLightsPunctualSchemaFile => System.IO.Path.Combine(KhronosSchemaDir, "KHR_lights_punctual", "schema", "node.KHR_lights_punctual.schema.json");

build/SharpGLTF.CodeGen/Program.cs

@@ -24,8 +24,9 @@ namespace SharpGLTF
 
             _ProcessMainSchema();
 
-            _ProcessKhronosPBRExtension();
+            _ProcessKhronosSpecularGlossinessExtension();
             _ProcessKhronosUnlitExtension();
+            _ProcessKhronosClearCoatExtension();
             _ProcessKhronosModelLightsPunctualExtension();
             _ProcessKhronosNodeLightsPunctualExtension();
             _ProcessKhronosTextureTransformExtension();
@@ -91,7 +92,7 @@ namespace SharpGLTF
 
         #region Extensions code generation
 
-        private static void _ProcessKhronosPBRExtension()
+        private static void _ProcessKhronosSpecularGlossinessExtension()
         {
             var ctx = LoadSchemaContext(Constants.KhronosPbrSpecGlossSchemaFile);
             ctx.IgnoredByCodeEmitter("glTF Property");
@@ -122,6 +123,30 @@ namespace SharpGLTF
             ProcessSchema("ext.Unlit.g", ctx);
         }
 
+        private static void _ProcessKhronosClearCoatExtension()
+        {
+            var ctx = LoadSchemaContext(Constants.KhronosPbrClearCoatSchemaFile);
+            ctx.IgnoredByCodeEmitter("glTF Property");
+            ctx.IgnoredByCodeEmitter("glTF Child of Root Property");
+            ctx.IgnoredByCodeEmitter("Texture Info");
+            ctx.IgnoredByCodeEmitter("Material Normal Texture Info");
+
+            /*
+            ctx.FindClass("KHR_materials_pbrSpecularGlossiness glTF extension")
+                .GetField("diffuseFactor")
+                .SetDataType(typeof(System.Numerics.Vector4), true)
+                .SetDefaultValue("Vector4.One")
+                .SetItemsRange(0);
+
+            ctx.FindClass("KHR_materials_pbrSpecularGlossiness glTF extension")
+                .GetField("specularFactor")
+                .SetDataType(typeof(System.Numerics.Vector3), true)
+                .SetDefaultValue("Vector3.One")
+                .SetItemsRange(0);*/
+
+            ProcessSchema("ext.ClearCoat.g", ctx);
+        }
+
         private static void _ProcessKhronosModelLightsPunctualExtension()
         {
             var ctx = LoadSchemaContext(Constants.KhronosModelLightsPunctualSchemaFile);            
@@ -231,8 +256,9 @@ namespace SharpGLTF
 
             newEmitter.SetRuntimeName("KHR_materials_pbrSpecularGlossiness glTF extension", "MaterialPBRSpecularGlossiness");
             newEmitter.SetRuntimeName("KHR_materials_unlit glTF extension", "MaterialUnlit");
+            newEmitter.SetRuntimeName("KHR_materials_clearcoat glTF extension", "MaterialClearCoat");
+
 
-            
 
             newEmitter.SetRuntimeName("light", "PunctualLight");
             newEmitter.SetRuntimeName("light/spot", "PunctualLightSpot");

src/SharpGLTF.Core/Schema2/Generated/ext.ClearCoat.g.cs

@@ -0,0 +1,76 @@
+//------------------------------------------------------------------------------------------------
+//      This file has been programatically generated; DON´T EDIT!
+//------------------------------------------------------------------------------------------------
+
+#pragma warning disable SA1001
+#pragma warning disable SA1027
+#pragma warning disable SA1028
+#pragma warning disable SA1121
+#pragma warning disable SA1205
+#pragma warning disable SA1309
+#pragma warning disable SA1402
+#pragma warning disable SA1505
+#pragma warning disable SA1507
+#pragma warning disable SA1508
+#pragma warning disable SA1652
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Numerics;
+using System.Text.Json;
+
+namespace SharpGLTF.Schema2
+{
+	using Collections;
+
+	/// <summary>
+	/// glTF extension that defines the clearcoat material layer.
+	/// </summary>
+	partial class MaterialClearCoat : ExtraProperties
+	{
+	
+		private const Double _clearcoatFactorDefault = 0;
+		private const Double _clearcoatFactorMinimum = 0;
+		private const Double _clearcoatFactorMaximum = 1;
+		private Double? _clearcoatFactor = _clearcoatFactorDefault;
+		
+		private MaterialNormalTextureInfo _clearcoatNormalTexture;
+		
+		private const Double _clearcoatRoughnessFactorDefault = 0;
+		private const Double _clearcoatRoughnessFactorMinimum = 0;
+		private const Double _clearcoatRoughnessFactorMaximum = 1;
+		private Double? _clearcoatRoughnessFactor = _clearcoatRoughnessFactorDefault;
+		
+		private TextureInfo _clearcoatRoughnessTexture;
+		
+		private TextureInfo _clearcoatTexture;
+		
+	
+		protected override void SerializeProperties(Utf8JsonWriter writer)
+		{
+			base.SerializeProperties(writer);
+			SerializeProperty(writer, "clearcoatFactor", _clearcoatFactor, _clearcoatFactorDefault);
+			SerializePropertyObject(writer, "clearcoatNormalTexture", _clearcoatNormalTexture);
+			SerializeProperty(writer, "clearcoatRoughnessFactor", _clearcoatRoughnessFactor, _clearcoatRoughnessFactorDefault);
+			SerializePropertyObject(writer, "clearcoatRoughnessTexture", _clearcoatRoughnessTexture);
+			SerializePropertyObject(writer, "clearcoatTexture", _clearcoatTexture);
+		}
+	
+		protected override void DeserializeProperty(string jsonPropertyName, ref Utf8JsonReader reader)
+		{
+			switch (jsonPropertyName)
+			{
+				case "clearcoatFactor": _clearcoatFactor = DeserializePropertyValue<Double?>(ref reader); break;
+				case "clearcoatNormalTexture": _clearcoatNormalTexture = DeserializePropertyValue<MaterialNormalTextureInfo>(ref reader); break;
+				case "clearcoatRoughnessFactor": _clearcoatRoughnessFactor = DeserializePropertyValue<Double?>(ref reader); break;
+				case "clearcoatRoughnessTexture": _clearcoatRoughnessTexture = DeserializePropertyValue<TextureInfo>(ref reader); break;
+				case "clearcoatTexture": _clearcoatTexture = DeserializePropertyValue<TextureInfo>(ref reader); break;
+				default: base.DeserializeProperty(jsonPropertyName,ref reader); break;
+			}
+		}
+	
+	}
+
+}

src/SharpGLTF.Core/Schema2/gltf.ExtensionsFactory.cs

@@ -19,6 +19,7 @@ namespace SharpGLTF.Schema2
             RegisterExtension<Material, MaterialPBRSpecularGlossiness>("KHR_materials_pbrSpecularGlossiness");
 
             RegisterExtension<Material, MaterialUnlit>("KHR_materials_unlit");
+            RegisterExtension<Material, MaterialClearCoat>("KHR_materials_clearcoat");
 
             RegisterExtension<ModelRoot, KHR_lights_punctualglTFextension>("KHR_lights_punctual");
             RegisterExtension<Node, KHR_lights_punctualnodeextension>("KHR_lights_punctual");

src/SharpGLTF.Core/Schema2/gltf.Material.cs

@@ -106,6 +106,7 @@ namespace SharpGLTF.Schema2
             // if (_pbrMetallicRoughness != null) ++shaderCount; this is the fallback
             if (this.GetExtension<MaterialPBRSpecularGlossiness>() != null) ++shaderCount;
             if (this.GetExtension<MaterialUnlit>() != null) ++shaderCount;
+            if (this.GetExtension<MaterialClearCoat>() != null) ++shaderCount;
         }
 
         #endregion

src/SharpGLTF.Core/Schema2/gltf.MaterialsFactory.cs

@@ -19,6 +19,7 @@ namespace SharpGLTF.Schema2
 
             this.RemoveExtensions<MaterialPBRSpecularGlossiness>();
             this.RemoveExtensions<MaterialUnlit>();
+            this.RemoveExtensions<MaterialClearCoat>();
         }
 
         /// <summary>
@@ -37,9 +38,26 @@ namespace SharpGLTF.Schema2
             }
 
             this.RemoveExtensions<MaterialUnlit>();
+            this.RemoveExtensions<MaterialClearCoat>();
             this.SetExtension(new MaterialPBRSpecularGlossiness(this));
         }
 
+        public void InitializeClearCoat(bool useFallback = false)
+        {
+            if (useFallback)
+            {
+                if (this._pbrMetallicRoughness == null) this._pbrMetallicRoughness = new MaterialPBRMetallicRoughness();
+            }
+            else
+            {
+                this._pbrMetallicRoughness = null;
+            }
+
+            this.RemoveExtensions<MaterialUnlit>();
+            this.RemoveExtensions<MaterialPBRSpecularGlossiness>();
+            this.SetExtension(new MaterialClearCoat(this));
+        }
+
         /// <summary>
         /// Initializes this <see cref="Material"/> instance with Unlit attributes.
         /// </summary>
@@ -66,6 +84,13 @@ namespace SharpGLTF.Schema2
                 foreach (var c in channels) yield return c;
             }
 
+            var clearCoat = this.GetExtension<MaterialClearCoat>();
+            if (clearCoat != null)
+            {
+                var channels = clearCoat.GetChannels(this);
+                foreach (var c in channels) yield return c;
+            }
+
             yield return new MaterialChannel
                 (
                 this, "Normal",
@@ -262,4 +287,62 @@ namespace SharpGLTF.Schema2
     {
         internal MaterialUnlit(Material material) { }
     }
+
+    internal sealed partial class MaterialClearCoat
+    {
+        internal MaterialClearCoat(Material material) { }
+
+        protected override IEnumerable<ExtraProperties> GetLogicalChildren()
+        {
+            return base.GetLogicalChildren().ConcatItems(_clearcoatTexture, _clearcoatRoughnessTexture, _clearcoatNormalTexture);
+        }
+
+        private TextureInfo _GetClearCoatTexture(bool create)
+        {
+            if (create && _clearcoatTexture == null) _clearcoatTexture = new TextureInfo();
+            return _clearcoatTexture;
+        }
+
+        private TextureInfo _GetClearCoatRoughnessTexture(bool create)
+        {
+            if (create && _clearcoatRoughnessTexture == null) _clearcoatRoughnessTexture = new TextureInfo();
+            return _clearcoatRoughnessTexture;
+        }
+
+        private MaterialNormalTextureInfo _GetClearCoatNormalTexture(bool create)
+        {
+            if (create && _clearcoatNormalTexture == null) _clearcoatNormalTexture = new MaterialNormalTextureInfo();
+            return _clearcoatNormalTexture;
+        }
+
+        public IEnumerable<MaterialChannel> GetChannels(Material material)
+        {
+            yield return new MaterialChannel
+                (
+                material, "ClearCoat",
+                _GetClearCoatTexture,
+                (float)_clearcoatFactorDefault,
+                () => (float)this._clearcoatFactor.AsValue(_clearcoatFactorDefault),
+                value => this._clearcoatFactor = value
+                );
+
+            yield return new MaterialChannel
+                (
+                material, "ClearCoatRoughness",
+                _GetClearCoatRoughnessTexture,
+                (float)_clearcoatRoughnessFactorDefault,
+                () => (float)this._clearcoatRoughnessFactor.AsValue(_clearcoatRoughnessFactorDefault),
+                value => this._clearcoatRoughnessFactor = value
+                );
+
+            yield return new MaterialChannel
+                (
+                material, "ClearCoatNormal",
+                _GetClearCoatNormalTexture,
+                MaterialNormalTextureInfo.ScaleDefault,
+                () => _GetClearCoatNormalTexture(false)?.Scale ?? MaterialNormalTextureInfo.ScaleDefault,
+                value => _GetClearCoatNormalTexture(true).Scale = value
+                );
+        }
+    }
 }