Added subtractive workflow

Components/Components/Containers/ChiselModelComponent.cs

@@ -209,6 +209,11 @@ public sealed class ChiselModelComponent : ChiselNodeComponent
         public const string kCreateColliderComponentsName = nameof(CreateColliderComponents);
         public const string kAutoRebuildUVsName           = nameof(AutoRebuildUVs);
         public const string kVertexChannelMaskName        = nameof(VertexChannelMask);
+        public const string kSubtractiveEditingName       = nameof(SubtractiveEditing);
+        public const string kSmoothNormalsName            = nameof(SmoothNormals);
+        public const string kSmoothingAngleName           = nameof(SmoothingAngle);
+        public const string kDebugLogBrushesName          = nameof(DebugLogBrushes);
+        public const string kDebugLogOutputName           = nameof(DebugLogOutput);
 
 
         public const string kNodeTypeName = "Model";
@@ -235,6 +240,21 @@ public sealed class ChiselModelComponent : ChiselNodeComponent
         public bool               CreateColliderComponents = true;
         public bool               AutoRebuildUVs           = true;
         public VertexChannelFlags VertexChannelMask        = VertexChannelFlags.All;
+        public bool               SubtractiveEditing      = false;
+        public bool               SmoothNormals           = false;
+        [Range(0, 180)]
+        public float              SmoothingAngle          = 45.0f;
+        [NonSerialized]          bool prevSubtractiveEditing;
+        [NonSerialized]          bool prevSmoothNormals;
+        [NonSerialized]          float prevSmoothingAngle;
+
+        #region Debug
+        // When enabled all brush geometry will be printed out to the console
+        // at the start of the CSG job update
+        public bool DebugLogBrushes = false;
+        // When enabled the generated output mesh data will be printed out after rebuilding
+        public bool DebugLogOutput = false;
+        #endregion
 
 
         public ChiselModelComponent() : base() { }
@@ -286,7 +306,25 @@ internal override CSGTreeNode RebuildTreeNodes()
             var instanceID = GetInstanceID();
             Node = CSGTree.Create(instanceID: instanceID);
             return Node;
-        }		
+        }
+
+        protected override void OnValidateState()
+        {
+            base.OnValidateState();
+
+            if (prevSubtractiveEditing != SubtractiveEditing && generated != null)
+            {
+                FlipGeneratedMeshes();
+                prevSubtractiveEditing = SubtractiveEditing;
+            }
+
+            if ((prevSmoothNormals != SmoothNormals || !Mathf.Approximately(prevSmoothingAngle, SmoothingAngle)) && generated != null)
+            {
+                SmoothGeneratedMeshes();
+                prevSmoothNormals   = SmoothNormals;
+                prevSmoothingAngle = SmoothingAngle;
+            }
+        }
 
         public override void OnInitialize()
         {
@@ -327,7 +365,66 @@ public override void OnInitialize()
                 name == ChiselModelManager.kGeneratedDefaultModelName)
                 IsDefaultModel = true;
 
-			IsInitialized = true;
+            prevSubtractiveEditing = SubtractiveEditing;
+            prevSmoothNormals   = SmoothNormals;
+            prevSmoothingAngle = SmoothingAngle;
+            IsInitialized = true;
+        }
+
+        void FlipGeneratedMeshes()
+        {
+            if (generated == null)
+                return;
+
+            if (generated.renderables != null)
+            {
+                foreach (var renderable in generated.renderables)
+                    if (renderable != null && renderable.sharedMesh)
+                        ChiselMeshUtility.FlipNormals(renderable.sharedMesh);
+            }
+
+            if (generated.debugVisualizationRenderables != null)
+            {
+                foreach (var renderable in generated.debugVisualizationRenderables)
+                    if (renderable != null && renderable.sharedMesh)
+                        ChiselMeshUtility.FlipNormals(renderable.sharedMesh);
+            }
+
+            if (generated.colliders != null)
+            {
+                foreach (var collider in generated.colliders)
+                    if (collider != null && collider.sharedMesh)
+                        ChiselMeshUtility.FlipNormals(collider.sharedMesh);
+            }
+        }
+
+        void SmoothGeneratedMeshes()
+        {
+            if (generated == null)
+                return;
+
+            float angle = SmoothNormals ? SmoothingAngle : 0.0f;
+
+            if (generated.renderables != null)
+            {
+                foreach (var renderable in generated.renderables)
+                    if (renderable != null && renderable.sharedMesh)
+                        ChiselMeshUtility.SmoothNormals(renderable.sharedMesh, angle);
+            }
+
+            if (generated.debugVisualizationRenderables != null)
+            {
+                foreach (var renderable in generated.debugVisualizationRenderables)
+                    if (renderable != null && renderable.sharedMesh)
+                        ChiselMeshUtility.SmoothNormals(renderable.sharedMesh, angle);
+            }
+
+            if (generated.colliders != null)
+            {
+                foreach (var collider in generated.colliders)
+                    if (collider != null && collider.sharedMesh)
+                        ChiselMeshUtility.SmoothNormals(collider.sharedMesh, angle);
+            }
         }
 
 #if UNITY_EDITOR

Components/Components/Generated/ChiselGeneratedObjects.cs

@@ -5,6 +5,7 @@
 using UnityEngine.Profiling;
 using Unity.Jobs;
 using UnityEngine.Pool;
+using System.Text;
 
 namespace Chisel.Components
 {        
@@ -607,6 +608,18 @@ public int FinishMeshUpdates(ChiselModelComponent model,
                 meshUpdates.meshDataArray = default;
                 Profiler.EndSample();
 
+                if (model.SubtractiveEditing)
+                {
+                    for (int i = 0; i < foundMeshes.Count; i++)
+                        ChiselMeshUtility.FlipNormals(foundMeshes[i]);
+                }
+
+                if (model.SmoothNormals)
+                {
+                    for (int i = 0; i < foundMeshes.Count; i++)
+                        ChiselMeshUtility.SmoothNormals(foundMeshes[i], model.SmoothingAngle);
+                }
+
                 // TODO: user meshDataArray data to determine if colliders are visible or not, then we can move this before the Apply
                 Profiler.BeginSample("UpdateColliders");
                 ChiselColliderObjects.UpdateProperties(model, this.colliders);
@@ -660,6 +673,24 @@ public int FinishMeshUpdates(ChiselModelComponent model,
                 colliderDebugVisualization.renderMaterials = new Material[] { ChiselProjectSettings.CollisionSurfacesMaterial };
                 // }}
 
+                if (model.DebugLogOutput)
+                {
+                    var sb = new System.Text.StringBuilder();
+                    sb.AppendLine("Output Mesh Debug Info:");
+                    for (int m = 0; m < foundMeshes.Count; m++)
+                    {
+                        var mesh = foundMeshes[m];
+                        sb.AppendLine($"Mesh {m} vertices:");
+                        var verts = mesh.vertices;
+                        for (int v = 0; v < verts.Length; v++)
+                            sb.AppendLine($"  v{v}: {verts[v]}");
+                        var tris = mesh.triangles;
+                        for (int t = 0; t < tris.Length; t += 3)
+                            sb.AppendLine($"  t{t / 3}: {tris[t]}, {tris[t + 1]}, {tris[t + 2]}");
+                    }
+                    UnityEngine.Debug.Log(sb.ToString());
+                }
+
                 var foundMeshCount = foundMeshes.Count;
                 foundMeshes.Clear();
                 return foundMeshCount;

Components/Utility/ChiselMeshUtility.cs

@@ -0,0 +1,36 @@
+using System;
+using UnityEngine;
+
+namespace Chisel.Components
+{
+    internal static class ChiselMeshUtility
+    {
+        public static void FlipNormals(Mesh mesh)
+        {
+            if (!mesh)
+                return;
+
+            var normals = mesh.normals;
+            if (normals != null && normals.Length > 0)
+            {
+                for (int i = 0; i < normals.Length; i++)
+                    normals[i] = -normals[i];
+                mesh.normals = normals;
+            }
+
+            for (int s = 0; s < mesh.subMeshCount; s++)
+            {
+                var indices = mesh.GetTriangles(s);
+                Array.Reverse(indices);
+                mesh.SetTriangles(indices, s);
+            }
+        }
+
+        public static void SmoothNormals(Mesh mesh, float angle)
+        {
+            if (!mesh)
+                return;
+            NormalSolver.RecalculateNormals(mesh, angle);
+        }
+    }
+}