Merge pull request #542 from BabylonJS/MaxCoating

deltakosh · web-flow · commit e77bbb6470fb · 2019-06-14T09:10:55.000-07:00
Max support for coating
diff --git a/3ds Max/Max2Babylon/Exporter/BabylonExporter.Material.cs b/3ds Max/Max2Babylon/Exporter/BabylonExporter.Material.cs
@@ -3,7 +3,8 @@
 using System.Collections.Generic;
 using Autodesk.Max;
 using BabylonExport.Entities;
-
+using System.Diagnostics;
+
 namespace BabylonExport.Entities
 {
     partial class BabylonMaterial
@@ -487,6 +488,49 @@ private void ExportMaterial(IIGameMaterial materialNode, BabylonScene babylonSce
                     babylonMaterial.emissive = emissionColor.Multiply(emissionWeight);
                 }
 
+                // --- Clear Coat ---
+                float coatWeight = propertyContainer.GetFloatProperty(75);
+                if (coatWeight > 0.0f)
+                {
+                    babylonMaterial.clearCoat.isEnabled = true;
+                    babylonMaterial.clearCoat.indexOfRefraction = propertyContainer.GetFloatProperty(84);
+
+                    ITexmap intensityTexmap = _getTexMap(materialNode, 23);
+                    ITexmap roughnessTexmap = _getTexMap(materialNode, 25);
+                    var coatRoughness = propertyContainer.GetFloatProperty(81);
+                    var coatTexture = ExportClearCoatTexture(intensityTexmap, roughnessTexmap, coatWeight, coatRoughness, babylonScene, name, invertRoughness);
+                    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 = propertyContainer.GetPoint3Property(78).ToArray();
+                    if (coatColor[0] != 1.0f || coatColor[1] != 1.0f || coatColor[2] != 1.0f)
+                    {
+                        babylonMaterial.clearCoat.isTintEnabled = true;
+                        babylonMaterial.clearCoat.tintColor = coatColor;
+                    }
+
+                    babylonMaterial.clearCoat.tintTexture = ExportPBRTexture(materialNode, 24, 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 = ExportPBRTexture(materialNode, 27, babylonScene);
+                }
+
                 // --- Textures ---
                 // 1 - base_color ; 5 - specular_roughness ; 9 - metalness ; 10 - transparent
                 ITexmap colorTexmap = _getTexMap(materialNode, 1);
diff --git a/3ds Max/Max2Babylon/Exporter/BabylonExporter.Texture.cs b/3ds Max/Max2Babylon/Exporter/BabylonExporter.Texture.cs
@@ -171,15 +171,116 @@ private BabylonTexture ExportPBRTexture(IIGameMaterial materialNode, int index,
             return null;
         }
 
-        /// <summary>
-        /// 
-        /// </summary>
-        /// <param name="baseColorTexMap"></param>
-        /// <param name="alphaTexMap">Transparency weight map</param>
-        /// <param name="baseColor"></param>
-        /// <param name="alpha"></param>
-        /// <param name="babylonScene"></param>
-        /// <param name="materialName"></param>
+        private BabylonTexture ExportClearCoatTexture(ITexmap intensityTexMap, ITexmap roughnessTexMap, float coatWeight, float coatRoughness, BabylonScene babylonScene, string materialName, bool invertRoughness)
+        {
+            // --- Babylon texture ---
+            var intensityTexture = _getBitmapTex(intensityTexMap);
+            var roughnessTexture = _getBitmapTex(roughnessTexMap);
+
+            var texture = intensityTexture != null ? intensityTexture : roughnessTexture;
+            if (texture == null)
+            {
+                return null;
+            }
+
+            // Use one as a reference for UVs parameters
+
+            RaiseMessage("Export Clear Coat weight+roughness texture", 2);
+
+            string nameText = Path.GetFileNameWithoutExtension(texture.Map.FullFilePath);
+
+            var textureID = texture.GetGuid().ToString();
+            if (textureMap.ContainsKey(textureID))
+            {
+                return textureMap[textureID];
+            }
+            else
+            {
+                var babylonTexture = new BabylonTexture(textureID)
+                {
+                    name = nameText // TODO - unsafe name, may conflict with another texture name
+                };
+
+                // Level
+                babylonTexture.level = 1.0f;
+
+                // UVs
+                var uvGen = _exportUV(texture.UVGen, babylonTexture);
+
+                // Is cube
+                _exportIsCube(texture.Map.FullFilePath, babylonTexture, false);
+
+                // --- Merge maps ---
+                var hasIntensity = isTextureOk(intensityTexture);
+                var hasRoughness = isTextureOk(roughnessTexture);
+                if (!hasIntensity && !hasRoughness)
+                {
+                    return null;
+                }
+
+                // Set image format
+                ImageFormat imageFormat = ImageFormat.Jpeg;
+                babylonTexture.name += ".jpg";
+
+                if (exportParameters.writeTextures)
+                {
+                    // Load bitmaps
+                    var intensityBitmap = _loadTexture(intensityTexture);
+                    var roughnessBitmap = _loadTexture(roughnessTexture);
+
+                    // Retreive dimensions
+                    int width = 0;
+                    int height = 0;
+                    var haveSameDimensions = _getMinimalBitmapDimensions(out width, out height, intensityBitmap, roughnessBitmap);
+                    if (!haveSameDimensions)
+                    {
+                        RaiseError("Base color and transparency color maps should have same dimensions", 3);
+                    }
+
+                    // Create map
+                    var _intensity = (int)(coatWeight * 255);
+                    var _roughness = (int)(coatRoughness * 255);
+                    Bitmap intensityRoughnessBitmap = new Bitmap(width, height);
+                    for (int x = 0; x < width; x++)
+                    {
+                        for (int y = 0; y < height; y++)
+                        {
+                            var intensityAtPixel = (intensityBitmap == null) ? _intensity : intensityBitmap.GetPixel(x, y).R;
+
+                            Color intensityRoughness;
+                            if (roughnessBitmap == null)
+                            {
+                                intensityRoughness = Color.FromArgb(intensityAtPixel, _roughness, 0);
+                            }
+                            else
+                            {
+                                var roughnessAtPixel = (roughnessBitmap == null) ?
+                                    _roughness :
+                                    invertRoughness ? 255 - roughnessBitmap.GetPixel(x, y).G : roughnessBitmap.GetPixel(x, y).G;
+
+                                intensityRoughness = Color.FromArgb(intensityAtPixel, roughnessAtPixel, 0);
+                            }
+                            intensityRoughnessBitmap.SetPixel(x, y, intensityRoughness);
+                        }
+                    }
+
+                    // Write bitmap
+                    if (isBabylonExported)
+                    {
+                        RaiseMessage($"Texture | write image '{babylonTexture.name}'", 3);
+                        SaveBitmap(intensityRoughnessBitmap, babylonScene.OutputPath, babylonTexture.name, imageFormat);
+                    }
+                    else
+                    {
+                        // Store created bitmap for further use in gltf export
+                        babylonTexture.bitmap = intensityRoughnessBitmap;
+                    }
+                }
+
+                return babylonTexture;
+            }
+        }
+
         /// <returns></returns>
         private BabylonTexture ExportBaseColorAlphaTexture(ITexmap baseColorTexMap, ITexmap alphaTexMap, float[] baseColor, float alpha, BabylonScene babylonScene, string materialName)
         {
diff --git a/SharedProjects/BabylonExport.Entities/BabylonExport.Entities.projitems b/SharedProjects/BabylonExport.Entities/BabylonExport.Entities.projitems
@@ -33,6 +33,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)BabylonMultiMaterial.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)BabylonNode.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)BabylonParticleSystem.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)BabylonPBRClearCoat.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)BabylonPBRMaterial.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)BabylonPBRMetallicRoughnessMaterial.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)BabylonProducer.cs" />
diff --git a/SharedProjects/BabylonExport.Entities/BabylonPBRClearCoat.cs b/SharedProjects/BabylonExport.Entities/BabylonPBRClearCoat.cs
@@ -0,0 +1,37 @@
+﻿using System.Runtime.Serialization;
+namespace BabylonExport.Entities
+{
+    [DataContract]
+    public class BabylonPBRClearCoat
+    {
+        [DataMember]
+        public bool isEnabled { get; set; } = false;
+
+        [DataMember]
+        public float intensity { get; set; } = 1.0f;
+
+        [DataMember]
+        public float roughness { get; set; } = 0.0f;
+
+        [DataMember]
+        public float indexOfRefraction { get; set; } = 1.5f;
+
+        [DataMember]
+        public BabylonTexture texture { get; set; }
+
+        [DataMember]
+        public BabylonTexture bumpTexture { get; set; }
+
+        [DataMember]
+        public bool isTintEnabled { get; set; } = false;
+
+        [DataMember]
+        public float[] tintColor { get; set; } = { 1.0f, 1.0f, 1.0f };
+
+        [DataMember]
+        public float tintThickness { get; set; } = 1.0f;
+
+        [DataMember]
+        public BabylonTexture tintTexture { get; set; }
+    }
+}
diff --git a/SharedProjects/BabylonExport.Entities/BabylonPBRMaterial.cs b/SharedProjects/BabylonExport.Entities/BabylonPBRMaterial.cs
@@ -133,6 +133,9 @@ public class BabylonPBRMaterial : BabylonMaterial
         [DataMember]
         public int maxSimultaneousLights { get; set; }
 
+        [DataMember]
+        public BabylonPBRClearCoat clearCoat { get; set; }
+
         public BabylonPBRMaterial(string id) : base(id)
         {
             SetCustomType("BABYLON.PBRMaterial");
@@ -164,6 +167,8 @@ public BabylonPBRMaterial(string id) : base(id)
             reflectivity = new[] { 1f, 1f, 1f };
             reflection = new[] { 0.5f, 0.5f, 0.5f };
             emissive = new[] { 0f, 0f, 0f };
+
+            clearCoat = new BabylonPBRClearCoat();
         }
 
         public void SetCustomType(string type)
diff --git a/SharedProjects/BabylonExport.Entities/BabylonPBRMetallicRoughnessMaterial.cs b/SharedProjects/BabylonExport.Entities/BabylonPBRMetallicRoughnessMaterial.cs
@@ -67,6 +67,9 @@ public enum TransparencyMode
         [DataMember]
         public bool doubleSided { get; set; }
 
+        [DataMember]
+        public BabylonPBRClearCoat clearCoat { get; set; }
+
         public BabylonPBRMetallicRoughnessMaterial(string id) : base(id)
         {
             customType = "BABYLON.PBRMetallicRoughnessMaterial";
@@ -76,6 +79,8 @@ public BabylonPBRMetallicRoughnessMaterial(string id) : base(id)
             occlusionStrength = 1.0f;
             alphaCutOff = 0.4f;
             transparencyMode = (int)TransparencyMode.OPAQUE;
+
+            clearCoat = new BabylonPBRClearCoat();
         }
 
         public BabylonPBRMetallicRoughnessMaterial(BabylonPBRMetallicRoughnessMaterial original) : base(original)
@@ -98,6 +103,7 @@ public BabylonPBRMetallicRoughnessMaterial(BabylonPBRMetallicRoughnessMaterial o
             alphaCutOff = original.alphaCutOff;
             transparencyMode = original.transparencyMode;
             doubleSided = original.doubleSided;
+            clearCoat = original.clearCoat;
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -67,6 +67,9 @@ public enum TransparencyMode`
`67`	`67`	`[DataMember]`
`68`	`68`	`public bool doubleSided { get; set; }`
`69`	`69`
	`70`	`+ [DataMember]`
	`71`	`+ public BabylonPBRClearCoat clearCoat { get; set; }`
	`72`	`+`
`70`	`73`	`public BabylonPBRMetallicRoughnessMaterial(string id) : base(id)`
`71`	`74`	`{`
`72`	`75`	`customType = "BABYLON.PBRMetallicRoughnessMaterial";`
`@@ -76,6 +79,8 @@ public BabylonPBRMetallicRoughnessMaterial(string id) : base(id)`
`76`	`79`	`occlusionStrength = 1.0f;`
`77`	`80`	`alphaCutOff = 0.4f;`
`78`	`81`	`transparencyMode = (int)TransparencyMode.OPAQUE;`
	`82`	`+`
	`83`	`+ clearCoat = new BabylonPBRClearCoat();`
`79`	`84`	`}`
`80`	`85`
`81`	`86`	`public BabylonPBRMetallicRoughnessMaterial(BabylonPBRMetallicRoughnessMaterial original) : base(original)`
`@@ -98,6 +103,7 @@ public BabylonPBRMetallicRoughnessMaterial(BabylonPBRMetallicRoughnessMaterial o`
`98`	`103`	`alphaCutOff = original.alphaCutOff;`
`99`	`104`	`transparencyMode = original.transparencyMode;`
`100`	`105`	`doubleSided = original.doubleSided;`
	`106`	`+ clearCoat = original.clearCoat;`
`101`	`107`	`}`
`102`	`108`	`}`
`103`	`109`	`}`