Add coating to maya

Author: sebavan

Maya/Exporter/BabylonExporter.Material.cs

@@ -383,6 +383,61 @@ private void ExportMaterial(MFnDependencyNode materialDependencyNode, BabylonSce
                 float emissionWeight = materialDependencyNode.findPlug("emission").asFloat();
                 babylonMaterial.emissive = materialDependencyNode.findPlug("emissionColor").asFloatArray().Multiply(emissionWeight);
 
+
+                var list = new List<string>();
+
+                for (int i = 0; i < materialDependencyNode.attributeCount; i++)
+                {
+                    var attr = materialDependencyNode.attribute((uint)i);
+                    var plug = materialDependencyNode.findPlug(attr);
+                    //string aliasName;
+                    //materialDependencyNode.getPlugsAlias(plug, out aliasName);
+                    System.Diagnostics.Debug.WriteLine(plug.name + i.ToString());
+                }
+
+                // --- Clear Coat ---
+                float coatWeight = materialDependencyNode.findPlug("coat").asFloat();
+                MFnDependencyNode intensityCoatTextureDependencyNode = getTextureDependencyNode(materialDependencyNode, "coat");
+                if (coatWeight > 0.0f || intensityCoatTextureDependencyNode != null)
+                {
+                    babylonMaterial.clearCoat.isEnabled = true;
+                    babylonMaterial.clearCoat.indexOfRefraction = materialDependencyNode.findPlug("coatIOR").asFloat();
+
+                    var coatRoughness = materialDependencyNode.findPlug("coatRoughness").asFloat();
+                    MFnDependencyNode roughnessCoatTextureDependencyNode = getTextureDependencyNode(materialDependencyNode, "coatRoughness");
+                    var coatTexture = ExportCoatTexture(intensityCoatTextureDependencyNode, roughnessCoatTextureDependencyNode, babylonScene, name, coatWeight, coatRoughness);
+                    if (coatTexture != null)
+                    {
+                        babylonMaterial.clearCoat.texture = coatTexture;
+                        babylonMaterial.clearCoat.roughness = 1.0f;
+                        babylonMaterial.clearCoat.intensity = 1.0f;
+                    }
+                    else
+                    {
+                        babylonMaterial.clearCoat.intensity = coatWeight;
+                        babylonMaterial.clearCoat.roughness = coatRoughness;
+                    }
+
+                    float[] coatColor = materialDependencyNode.findPlug("coatColor").asFloatArray();
+                    if (coatColor[0] != 1.0f || coatColor[1] != 1.0f || coatColor[2] != 1.0f)
+                    {
+                        babylonMaterial.clearCoat.isTintEnabled = true;
+                        babylonMaterial.clearCoat.tintColor = coatColor;
+                    }
+
+                    babylonMaterial.clearCoat.tintTexture = ExportTexture(materialDependencyNode, "coatColor", babylonScene);
+                    if (babylonMaterial.clearCoat.tintTexture != null)
+                    {
+                        babylonMaterial.clearCoat.tintColor = new[] { 1.0f, 1.0f, 1.0f };
+                        babylonMaterial.clearCoat.isTintEnabled = true;
+                    }
+
+                    // EyeBall deduction...
+                    babylonMaterial.clearCoat.tintThickness = 0.65f;
+
+                    babylonMaterial.clearCoat.bumpTexture = ExportTexture(materialDependencyNode, "coatNormal", babylonScene);
+                }
+
                 // --- Textures ---
 
                 // Base color & alpha

Maya/Exporter/BabylonExporter.Texture.cs

@@ -329,6 +329,84 @@ private BabylonTexture ExportORMTexture(BabylonScene babylonScene, MFnDependency
             return babylonTexture;
         }
 
+        private BabylonTexture ExportCoatTexture(MFnDependencyNode intensityTextureDependencyNode, MFnDependencyNode roughnessTextureDependencyNode, BabylonScene babylonScene, string materialName, float intensity, float roughness)
+        {
+            // Prints
+            if (intensityTextureDependencyNode != null)
+            {
+                Print(intensityTextureDependencyNode, logRankTexture, "Print ExportCoatTexture intensityTextureDependencyNode");
+            }
+            if (roughnessTextureDependencyNode != null)
+            {
+                Print(roughnessTextureDependencyNode, logRankTexture, "Print ExportCoatTexture roughnessTextureDependencyNode");
+            }
+
+            // Use one as a reference for UVs parameters
+            var textureDependencyNode = intensityTextureDependencyNode != null ? intensityTextureDependencyNode : roughnessTextureDependencyNode;
+            if (textureDependencyNode == null)
+            {
+                return null;
+            }
+
+            var id = textureDependencyNode.uuid().asString();
+            var babylonTexture = new BabylonTexture(id)
+            {
+                name = materialName + "_coat" + ".jpg" // TODO - unsafe name, may conflict with another texture name
+            };
+
+            // Level
+            babylonTexture.level = 1.0f;
+
+            // Alpha
+            babylonTexture.hasAlpha = false;
+            babylonTexture.getAlphaFromRGB = false;
+
+            // UVs
+            _exportUV(textureDependencyNode, babylonTexture);
+
+            // Is cube
+            string sourcePath = getSourcePathFromFileTexture(textureDependencyNode);
+            if (sourcePath == null)
+            {
+                return null;
+            }
+            if (sourcePath == "")
+            {
+                RaiseError("Texture path is missing.", logRankTexture + 1);
+                return null;
+            }
+            _exportIsCube(sourcePath, babylonTexture, false);
+
+
+            // --- Merge base color and opacity maps ---
+
+            if (CopyTexturesToOutput)
+            {
+                // Load bitmaps
+                var intensityBitmap = LoadTexture(intensityTextureDependencyNode);
+                var roughnessBitmap = LoadTexture(roughnessTextureDependencyNode);
+
+                // Merge bitmaps
+                Bitmap[] bitmaps = new Bitmap[] { intensityBitmap, roughnessBitmap, null, null };
+                int[] defaultValues = new int[] { (int)(intensity * 255), (int)(roughness * 255), 0, 1 };
+                Bitmap coatBitmap = MergeBitmaps(bitmaps, defaultValues, "Coat intensity and roughness");
+                
+                // Write bitmap
+                if (isBabylonExported)
+                {
+                    RaiseMessage($"Texture | write image '{babylonTexture.name}'", logRankTexture + 1);
+                    SaveBitmap(coatBitmap, babylonScene.OutputPath, babylonTexture.name, System.Drawing.Imaging.ImageFormat.Jpeg);
+                }
+                else
+                {
+                    // Store created bitmap for further use in gltf export
+                    babylonTexture.bitmap = coatBitmap;
+                }
+            }
+
+            return babylonTexture;
+        }
+
         private BabylonTexture ExportBaseColorAlphaTexture(MFnDependencyNode baseColorTextureDependencyNode, MFnDependencyNode opacityTextureDependencyNode, BabylonScene babylonScene, string materialName, Color defaultBaseColor, float defaultOpacity = 1.0f)
         {
             // Prints

SharedProjects/BabylonExport.Entities/BabylonPBRClearCoat.cs

@@ -1,4 +1,5 @@
 using System.Runtime.Serialization;
+
 namespace BabylonExport.Entities
 {
     [DataContract]