From c9256256c3d8b1da2a0cb063b1c8bb9ab8f484f9 Mon Sep 17 00:00:00 2001
From: NUZEROVI <nuvmcdxliv@gmail.com>
Date: Sat, 29 Oct 2022 14:14:35 +0800
Subject: [PATCH] add inverse masking function for de-occlusion component

---
 Assets/Debugging/ShaderDebugging_Mask.cs      |   70 +
 Assets/Debugging/ShaderDebugging_Mask.cs.meta |   11 +
 .../DirectVolumeRenderingMaterial_Mask.mat    |  100 ++
 ...irectVolumeRenderingMaterial_Mask.mat.meta |    8 +
 Assets/Resources/VolumeContainer_Mask.prefab  |   81 ++
 .../VolumeContainer_Mask.prefab.meta          |    7 +
 Assets/Scripts/GUI/UI/AnalysisBtn.cs          |   75 +-
 Assets/Scripts/GUI/UI/BtnEvent.cs             |   32 +-
 .../GUI/UI/BtnSetLensShapePressedColor.cs     |   20 +-
 Assets/Scripts/GUI/UI/BtnSetPressed.cs        |   28 +-
 .../Scripts/GUI/UI/BtnSetSizePressedColor.cs  |   13 +-
 Assets/Scripts/GUI/UI/SliderEvent.cs          |   13 +-
 Assets/Scripts/GUI/UI/ToggleEvent.cs          |   67 +-
 .../InteractiveController/MouseEvent/Hover.cs |   42 +-
 .../VolumeObject/VolumeObjectFactory.cs       |   12 +-
 .../VolumeObject/VolumeObjectFactory_Mask.cs  |   78 ++
 .../VolumeObjectFactory_Mask.cs.meta          |   11 +
 .../VolumeObject/VolumeRenderedObject_Mask.cs |  198 +++
 .../VolumeRenderedObject_Mask.cs.meta         |   11 +
 .../DirectVolumeRenderingShader_Mask.shader   | 1245 +++++++++++++++++
 ...rectVolumeRenderingShader_Mask.shader.meta |    9 +
 21 files changed, 2083 insertions(+), 48 deletions(-)
 create mode 100644 Assets/Debugging/ShaderDebugging_Mask.cs
 create mode 100644 Assets/Debugging/ShaderDebugging_Mask.cs.meta
 create mode 100644 Assets/Materials/DirectVolumeRenderingMaterial_Mask.mat
 create mode 100644 Assets/Materials/DirectVolumeRenderingMaterial_Mask.mat.meta
 create mode 100644 Assets/Resources/VolumeContainer_Mask.prefab
 create mode 100644 Assets/Resources/VolumeContainer_Mask.prefab.meta
 create mode 100644 Assets/Scripts/VolumeObject/VolumeObjectFactory_Mask.cs
 create mode 100644 Assets/Scripts/VolumeObject/VolumeObjectFactory_Mask.cs.meta
 create mode 100644 Assets/Scripts/VolumeObject/VolumeRenderedObject_Mask.cs
 create mode 100644 Assets/Scripts/VolumeObject/VolumeRenderedObject_Mask.cs.meta
 create mode 100644 Assets/Shaders/DirectVolumeRenderingShader_Mask.shader
 create mode 100644 Assets/Shaders/DirectVolumeRenderingShader_Mask.shader.meta

diff --git a/Assets/Debugging/ShaderDebugging_Mask.cs b/Assets/Debugging/ShaderDebugging_Mask.cs
new file mode 100644
index 00000000..b3ba0468
--- /dev/null
+++ b/Assets/Debugging/ShaderDebugging_Mask.cs
@@ -0,0 +1,70 @@
+using UnityEngine;
+
+namespace UnityVolumeRendering
+{
+	public class ShaderDebugging_Mask : MonoBehaviour
+	{
+		public GameObject target_Mask;
+
+		private Material material_Mask;
+		private ComputeBuffer buffer_Mask;
+		public Vector4[] element_Mask;
+		private string label_Mask;
+		private Renderer render_Mask;
+
+		MeshRenderer meshRenderer_Mask;
+		Material mat_Mask;
+
+
+		void Load()
+		{
+			buffer_Mask = new ComputeBuffer(10, 16, ComputeBufferType.Default);
+			element_Mask = new Vector4[10];
+			for(int i=0; i < buffer_Mask.count; i++)
+            {
+				element_Mask[i] = new Vector4(0, 0, 0, 0);	
+			}
+			buffer_Mask.SetData(element_Mask);
+
+			label_Mask = string.Empty;
+			render_Mask = target_Mask.GetComponent<Renderer>();
+			material_Mask = render_Mask.material;
+		}
+
+		void Start()
+		{			
+			Load();
+			VolumeRenderedObject_Mask[] objects_Mask = FindObjectsOfType<VolumeRenderedObject_Mask>();
+			if (objects_Mask.Length == 1)
+			{
+				meshRenderer_Mask = objects_Mask[0].meshRenderer;
+				mat_Mask = meshRenderer_Mask.material;
+			}
+		}
+
+		void Update()
+		{
+			Graphics.ClearRandomWriteTargets();
+			material_Mask.SetPass(0);
+			material_Mask.SetBuffer("buffer_Mask", buffer_Mask);			
+			Graphics.SetRandomWriteTarget(2, buffer_Mask, false);
+
+			buffer_Mask.GetData(element_Mask);
+
+			label_Mask = (element_Mask != null && render_Mask.isVisible) ? element_Mask[0].ToString() : string.Empty;						
+		}
+
+        void OnGUI()
+        {
+            GUIStyle style = new GUIStyle();
+
+            GUI.color = Color.white;
+            style.fontSize = 32;          
+        }
+
+        void OnDestroy()
+		{
+			buffer_Mask.Dispose();		
+		}
+	}
+}
\ No newline at end of file
diff --git a/Assets/Debugging/ShaderDebugging_Mask.cs.meta b/Assets/Debugging/ShaderDebugging_Mask.cs.meta
new file mode 100644
index 00000000..b097c76a
--- /dev/null
+++ b/Assets/Debugging/ShaderDebugging_Mask.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4d8c1e4e62204c24b957f1d3a489ac23
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Materials/DirectVolumeRenderingMaterial_Mask.mat b/Assets/Materials/DirectVolumeRenderingMaterial_Mask.mat
new file mode 100644
index 00000000..ee28aeb1
--- /dev/null
+++ b/Assets/Materials/DirectVolumeRenderingMaterial_Mask.mat
@@ -0,0 +1,100 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: DirectVolumeRenderingMaterial_Mask
+  m_Shader: {fileID: 4800000, guid: a20d4a69f209bf64ea10de5efd333aa5, type: 3}
+  m_ShaderKeywords: MODE_DVR TF2D_ON _MODE_DVR _MODE_MIP
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses:
+  - pass0
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DataTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _GradientTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NoiseTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SegmentTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TFTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _MaxVal: 1
+    - _Metallic: 0
+    - _MinVal: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
diff --git a/Assets/Materials/DirectVolumeRenderingMaterial_Mask.mat.meta b/Assets/Materials/DirectVolumeRenderingMaterial_Mask.mat.meta
new file mode 100644
index 00000000..7e9ccca1
--- /dev/null
+++ b/Assets/Materials/DirectVolumeRenderingMaterial_Mask.mat.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: dff8f83be22f4104b838e8253440b566
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Resources/VolumeContainer_Mask.prefab b/Assets/Resources/VolumeContainer_Mask.prefab
new file mode 100644
index 00000000..50027b17
--- /dev/null
+++ b/Assets/Resources/VolumeContainer_Mask.prefab
@@ -0,0 +1,81 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!1 &1642054173293210335
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 3483431779698201852}
+  - component: {fileID: 4600922654780393457}
+  - component: {fileID: 1185744897911437941}
+  m_Layer: 0
+  m_Name: VolumeContainer_Mask
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &3483431779698201852
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1642054173293210335}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!33 &4600922654780393457
+MeshFilter:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1642054173293210335}
+  m_Mesh: {fileID: 10202, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!23 &1185744897911437941
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1642054173293210335}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_RayTracingMode: 2
+  m_RenderingLayerMask: 4294967295
+  m_RendererPriority: 0
+  m_Materials:
+  - {fileID: 2100000, guid: dff8f83be22f4104b838e8253440b566, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_ReceiveGI: 1
+  m_PreserveUVs: 0
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
+  m_SelectedEditorRenderState: 3
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
diff --git a/Assets/Resources/VolumeContainer_Mask.prefab.meta b/Assets/Resources/VolumeContainer_Mask.prefab.meta
new file mode 100644
index 00000000..f8fda686
--- /dev/null
+++ b/Assets/Resources/VolumeContainer_Mask.prefab.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 222363ee9b11d324c9f631adba97ec3b
+PrefabImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Scripts/GUI/UI/AnalysisBtn.cs b/Assets/Scripts/GUI/UI/AnalysisBtn.cs
index a5dcc22c..1d801feb 100644
--- a/Assets/Scripts/GUI/UI/AnalysisBtn.cs
+++ b/Assets/Scripts/GUI/UI/AnalysisBtn.cs
@@ -19,8 +19,8 @@ public class AnalysisBtn : MonoBehaviour
         public string isoRangeFilePath;
         public string tFFilePath;
         public string segTexturePath;
-        MeshRenderer meshRenderer;
-        Material mat;
+        MeshRenderer meshRenderer, meshRenderer_Mask;
+        Material mat, mat_Mask;
         public float[] isoRange = new float[20];
         public Vector4[] isoCluster = new Vector4[20];
 
@@ -73,6 +73,7 @@ void BtnClick(string btn)
                         endianness = initData.endianness;
                         ImportRawData();
                         GetIsoRangeAndSetTF();
+                        GetIsoRangeAndSetTF_Mask();
                     }
                 }               
                
@@ -106,14 +107,20 @@ private void ImportRawData()
                 }
               
                 VolumeRenderedObject obj = VolumeObjectFactory.CreateObject(dataset);
-              
-                if(eulerX == 180.0f)
+                VolumeRenderedObject_Mask obj_Mask = VolumeObjectFactory_Mask.CreateObject(dataset);
+                
+                if (eulerX == 180.0f)
                 {
                     obj.gameObject.transform.rotation *= Quaternion.AngleAxis(90, Vector3.right);
-                }else if(eulerX == 0.0f)
+                    obj_Mask.gameObject.transform.rotation *= Quaternion.AngleAxis(90, Vector3.right);
+                }
+                else if(eulerX == 0.0f)
                 {
                     obj.gameObject.transform.rotation *= Quaternion.AngleAxis(-90, Vector3.right);
+                    obj_Mask.gameObject.transform.rotation *= Quaternion.AngleAxis(-90, Vector3.right);
                 }
+
+               
             }
             else
             {
@@ -161,12 +168,66 @@ void GetIsoRangeAndSetTF()
             //{
             TransferFunction newTF = TransferFunctionDatabase.LoadTransferFunction(tFFilePath);
             if (newTF != null)
+            {
                 objects[0].transferFunction = newTF;
                 //objects[0].SetVisibilityWindow(0.58f, 1.0f);
                 objects[0].UpdateMaterialProperties();
-           // }
+                // }
+            }
+
+
+        }
+
+
+        void GetIsoRangeAndSetTF_Mask()
+        {
+            VolumeRenderedObject_Mask[] objects_Mask = FindObjectsOfType<VolumeRenderedObject_Mask>();
+            if (objects_Mask.Length == 1)
+            {
+                meshRenderer_Mask = objects_Mask[0].meshRenderer;
+                mat_Mask = meshRenderer_Mask.material;
+            }
+            //if(isoRangeFilePath != "")
+            //{
+            List<string> fileLines = File.ReadAllLines(isoRangeFilePath).ToList();
+
+            int range = 0; //dataset.GetMinDataValue();
+            int Count = 0;
+            foreach (string line in fileLines)
+            {
+                range += int.Parse(line);
+
+                isoRange[Count] = range;
+
+                if (Count == 0)
+                {
+                    isoCluster[Count] = new Vector4(0, isoRange[Count] - 1);
+                }
+                else
+                {
+                    isoCluster[Count] = new Vector4(isoRange[Count - 1], isoRange[Count] - 1);
+                }
+                Count++;
+            }
+
+            mat_Mask.SetInt("_isoCount", Count);
+            mat_Mask.SetFloatArray("_isoRange", isoRange);
+            mat_Mask.SetVectorArray("_isoCluster", isoCluster);
+            // }
+
+            //if (tFFilePath != "")
+            //{
+            TransferFunction newTF = TransferFunctionDatabase.LoadTransferFunction(tFFilePath);
+            if (newTF != null)
+            {
+                objects_Mask[0].transferFunction = newTF;
+                //objects[0].SetVisibilityWindow(0.58f, 1.0f);
+                objects_Mask[0].UpdateMaterialProperties();
+                // }
+            }
+
 
         }
-        
+
     }
 }
\ No newline at end of file
diff --git a/Assets/Scripts/GUI/UI/BtnEvent.cs b/Assets/Scripts/GUI/UI/BtnEvent.cs
index 3e830cae..45465f75 100644
--- a/Assets/Scripts/GUI/UI/BtnEvent.cs
+++ b/Assets/Scripts/GUI/UI/BtnEvent.cs
@@ -9,8 +9,8 @@ public class BtnEvent : MonoBehaviour
     {
         public Button btn;  
   
-        MeshRenderer meshRenderer;
-        Material mat;
+        MeshRenderer meshRenderer, meshRenderer_Mask;
+        Material mat, mat_Mask;
         //float viewCamIndex;   
 
         void Start()
@@ -32,23 +32,34 @@ void BtnClick(string btn)
                 mat = meshRenderer.material;
             }
 
+            VolumeRenderedObject_Mask[] objects_Mask = FindObjectsOfType<VolumeRenderedObject_Mask>();
+            if (objects_Mask.Length == 1)
+            {
+                meshRenderer_Mask = objects_Mask[0].meshRenderer;
+                mat_Mask = meshRenderer_Mask.material;
+            }
+
             if (btn == "RightBtn")
             {
 
-                objects[0].gameObject.transform.rotation *= Quaternion.AngleAxis(90, Vector3.forward);               
+                objects[0].gameObject.transform.rotation *= Quaternion.AngleAxis(90, Vector3.forward);
+                //objects_Mask[0].gameObject.transform.rotation *= Quaternion.AngleAxis(90, Vector3.forward);
             }
             else if (btn == "LeftBtn")
             {
-                objects[0].gameObject.transform.rotation *= Quaternion.AngleAxis(-90, Vector3.forward);               
+                objects[0].gameObject.transform.rotation *= Quaternion.AngleAxis(-90, Vector3.forward);
+                //objects_Mask[0].gameObject.transform.rotation *= Quaternion.AngleAxis(-90, Vector3.forward);
             }
             else if (btn == "DownBtn")
             {
                 objects[0].gameObject.transform.rotation *= Quaternion.AngleAxis(-90, Vector3.right);
+                //objects_Mask[0].gameObject.transform.rotation *= Quaternion.AngleAxis(-90, Vector3.right);
             }
             else if (btn == "UpBtn")
             {
 
-                objects[0].gameObject.transform.rotation *= Quaternion.AngleAxis(90, Vector3.right);               
+                objects[0].gameObject.transform.rotation *= Quaternion.AngleAxis(90, Vector3.right);
+                //objects_Mask[0].gameObject.transform.rotation *= Quaternion.AngleAxis(90, Vector3.right);
             }
 
             var localVector = objects[0].gameObject.transform.InverseTransformDirection(Vector3.forward);
@@ -67,7 +78,16 @@ void BtnClick(string btn)
             mat.SetFloat("RotationX", objects[0].gameObject.transform.rotation.eulerAngles.x);
             mat.SetFloat("RotationY", objects[0].gameObject.transform.rotation.eulerAngles.y);
             mat.SetFloat("RotationZ", objects[0].gameObject.transform.rotation.eulerAngles.z);
-           
+
+            mat_Mask.SetFloat("_localDepth", localDepth);
+            mat_Mask.SetFloat("_depthNP", depthNP);
+
+            mat_Mask.SetFloat("RotationX", objects[0].gameObject.transform.rotation.eulerAngles.x);
+            mat_Mask.SetFloat("RotationY", objects[0].gameObject.transform.rotation.eulerAngles.y);
+            mat_Mask.SetFloat("RotationZ", objects[0].gameObject.transform.rotation.eulerAngles.z);
+
+
+
 
         }
        
diff --git a/Assets/Scripts/GUI/UI/BtnSetLensShapePressedColor.cs b/Assets/Scripts/GUI/UI/BtnSetLensShapePressedColor.cs
index 86d1d033..f0d0a21b 100644
--- a/Assets/Scripts/GUI/UI/BtnSetLensShapePressedColor.cs
+++ b/Assets/Scripts/GUI/UI/BtnSetLensShapePressedColor.cs
@@ -9,8 +9,8 @@ public class BtnSetLensShapePressedColor : MonoBehaviour
     {
         private Button btn;
 
-        MeshRenderer meshRenderer;
-        Material mat;
+        MeshRenderer meshRenderer, meshRenderer_Mask;
+        Material mat, mat_Mask;
 
         void Start()
         {
@@ -30,7 +30,14 @@ public void SetColor(string name)
             {
                 meshRenderer = objects[0].meshRenderer;
                 mat = meshRenderer.material;
-            }    
+            }
+
+            VolumeRenderedObject_Mask[] objects_Mask = FindObjectsOfType<VolumeRenderedObject_Mask>();
+            if (objects_Mask.Length == 1)
+            {
+                meshRenderer_Mask = objects_Mask[0].meshRenderer;
+                mat_Mask = meshRenderer_Mask.material;
+            }
 
             int nums = GameObject.Find("SetLensShapeBtn Group").transform.childCount;
        
@@ -76,9 +83,10 @@ public void SetColor(string name)
         
             //_LensShapeNums[lensNum] = btnIndex;
             mat.SetFloatArray("_LensIndexs", _LensIndexs);
-                //sliderObj.sliNumOn = btnIndex;
-                //sliderObj.GetComponent<Slider>().value = _CircleSize[btnIndex];
-            
+            mat_Mask.SetFloatArray("_LensIndexs", _LensIndexs);
+            //sliderObj.sliNumOn = btnIndex;
+            //sliderObj.GetComponent<Slider>().value = _CircleSize[btnIndex];
+
 
             //mat.SetInt("_CurrentWidgetNum", btnIndex);
 
diff --git a/Assets/Scripts/GUI/UI/BtnSetPressed.cs b/Assets/Scripts/GUI/UI/BtnSetPressed.cs
index 980206dc..ad5d8046 100644
--- a/Assets/Scripts/GUI/UI/BtnSetPressed.cs
+++ b/Assets/Scripts/GUI/UI/BtnSetPressed.cs
@@ -8,7 +8,10 @@ namespace UnityVolumeRendering
     public class BtnSetPressed : MonoBehaviour
     {
         private Button btn;
-
+        private MeshRenderer meshRenderer, meshRenderer_Mask;
+        private Material mat, mat_Mask;
+        private VolumeRenderedObject[] objects;
+        private VolumeRenderedObject_Mask[] objects_Mask;
         void Start()
         {
             btn = this.GetComponent<Button>();
@@ -16,6 +19,13 @@ void Start()
             {
                 btn.onClick.AddListener(() => BtnPressed(btn.name));
             }
+            objects = FindObjectsOfType<VolumeRenderedObject>();
+            objects_Mask = FindObjectsOfType<VolumeRenderedObject_Mask>();
+            if (objects_Mask.Length == 1)
+            {
+                meshRenderer_Mask = objects_Mask[0].meshRenderer;
+                mat_Mask = meshRenderer_Mask.material;
+            }
         }
         public void BtnPressed(string name)
         {
@@ -30,9 +40,7 @@ public void BtnPressed(string name)
 
             if(name == "ResetBtn")
             {
-                VolumeRenderedObject[] objects = FindObjectsOfType<VolumeRenderedObject>();
-                MeshRenderer meshRenderer;
-                Material mat;
+      
                 if (objects.Length == 1)
                 {
                     meshRenderer = objects[0].meshRenderer;
@@ -58,7 +66,17 @@ public void BtnPressed(string name)
                         mat.SetInt("_CurrentWidgetNum", 0);
                         mat.SetFloatArray("_CircleSize", obj[0]._CircleSize);
                         mat.SetFloatArray("_LensIndexs", obj[0]._LensIndexs);
-                        
+
+                        mat_Mask.SetInt("_WidgetNums", obj[0]._WidgetNums);
+                        mat_Mask.SetInt("_RecordNums", obj[0]._RecordNums);
+                        mat_Mask.SetVectorArray("_WidgetPos", obj[0]._WidgetPos);
+                        mat_Mask.SetVectorArray("_WidgetRecorder", obj[0]._WidgetRecorder);
+                        mat_Mask.SetMatrixArray("_RotateMatrix", obj[0].rotMatrixArr);
+                        mat_Mask.SetMatrixArray("_RotateMatrixInverse", obj[0].rotMatrixArrInverse);
+                        mat_Mask.SetInt("_CurrentWidgetNum", 0);
+                        mat_Mask.SetFloatArray("_CircleSize", obj[0]._CircleSize);
+                        mat_Mask.SetFloatArray("_LensIndexs", obj[0]._LensIndexs);
+
                         obj[0].SetColor(0);
                         int nums = GameObject.Find("SetSizeBtn Group").transform.childCount;
                         for (int i = 0; i < nums; i++)
diff --git a/Assets/Scripts/GUI/UI/BtnSetSizePressedColor.cs b/Assets/Scripts/GUI/UI/BtnSetSizePressedColor.cs
index 7319a4a5..122dc761 100644
--- a/Assets/Scripts/GUI/UI/BtnSetSizePressedColor.cs
+++ b/Assets/Scripts/GUI/UI/BtnSetSizePressedColor.cs
@@ -9,8 +9,8 @@ public class BtnSetSizePressedColor : MonoBehaviour
     {
         private Button btn;
 
-        MeshRenderer meshRenderer;
-        Material mat;
+        MeshRenderer meshRenderer, meshRenderer_Mask;
+        Material mat, mat_Mask;
 
         void Start()
         {
@@ -31,6 +31,14 @@ public void SetColor(string name)
                 meshRenderer = objects[0].meshRenderer;
                 mat = meshRenderer.material;
             }
+
+            VolumeRenderedObject_Mask[] objects_Mask = FindObjectsOfType<VolumeRenderedObject_Mask>();
+            if (objects_Mask.Length == 1)
+            {
+                meshRenderer_Mask = objects_Mask[0].meshRenderer;
+                mat_Mask = meshRenderer_Mask.material;
+            }
+
             SliderEvent sliderObj = FindObjectOfType<SliderEvent>();
 
             int nums = GameObject.Find("SetSizeBtn Group").transform.childCount;
@@ -101,6 +109,7 @@ public void SetColor(string name)
             }
 
             mat.SetInt("_CurrentWidgetNum", btnIndex);
+            mat_Mask.SetInt("_CurrentWidgetNum", btnIndex);
 
         }
     }
diff --git a/Assets/Scripts/GUI/UI/SliderEvent.cs b/Assets/Scripts/GUI/UI/SliderEvent.cs
index a973035c..8e671dfa 100644
--- a/Assets/Scripts/GUI/UI/SliderEvent.cs
+++ b/Assets/Scripts/GUI/UI/SliderEvent.cs
@@ -14,8 +14,8 @@ public class SliderEvent : MonoBehaviour
         public string sliname;
         public int widgetNums = 0;
         public int sliNumOn;
-        MeshRenderer meshRenderer;
-        Material mat;
+        MeshRenderer meshRenderer, meshRenderer_Mask;
+        Material mat, mat_Mask;
 
         void Start()
         {
@@ -33,6 +33,13 @@ void Start()
                 meshRenderer = objects[0].meshRenderer;
                 mat = meshRenderer.material;
             }
+
+            VolumeRenderedObject_Mask[] objects_Mask = FindObjectsOfType<VolumeRenderedObject_Mask>();
+            if (objects_Mask.Length == 1)
+            {
+                meshRenderer_Mask = objects_Mask[0].meshRenderer;
+                mat_Mask = meshRenderer_Mask.material;
+            }
         }
 
         public void ValueChange(float v)
@@ -44,6 +51,7 @@ public void ValueChange(float v)
                 hover._CircleSize[sliNumOn] = v;
                 _CircleSize[sliNumOn] = v;
                 mat.SetFloatArray("_CircleSize", _CircleSize);
+                mat_Mask.SetFloatArray("_CircleSize", _CircleSize);
                 //mat.SetFloat("_cySize", v);
             }
 
@@ -55,6 +63,7 @@ public void ValueChange(float v)
                 hover._CircleSize[sliNumOn] = v;
                 _CircleSize[sliNumOn] = v;
                 mat.SetFloatArray("_CircleSize", _CircleSize);
+                mat_Mask.SetFloatArray("_CircleSize", _CircleSize);
             }
 
 
diff --git a/Assets/Scripts/GUI/UI/ToggleEvent.cs b/Assets/Scripts/GUI/UI/ToggleEvent.cs
index 5468bcec..5d5cf219 100644
--- a/Assets/Scripts/GUI/UI/ToggleEvent.cs
+++ b/Assets/Scripts/GUI/UI/ToggleEvent.cs
@@ -11,12 +11,9 @@ public class ToggleEvent : MonoBehaviour
     {
         Toggle m_Toggle;
         GameObject toggleGroupObj;
-        bool isOn;
 
-        MeshRenderer meshRenderer;
-        Material mat;
-        private TFRenderMode tfRenderMode;
-        private RenderMode renderMode;
+        MeshRenderer meshRenderer, meshRenderer_Mask;
+        Material mat, mat_Mask;
 
         [HideInInspector]
         public TransferFunction transferFunction;
@@ -25,6 +22,7 @@ public class ToggleEvent : MonoBehaviour
         public TransferFunction2D transferFunction2D;
 
         VolumeRenderedObject[] objects;
+        VolumeRenderedObject_Mask[] objects_Mask;
         public float[] isoRange = new float[20];
         public Vector4[] isoCluster = new Vector4[20];
 
@@ -57,6 +55,13 @@ void Start()
                 mat = meshRenderer.material;
             }
 
+            objects_Mask = FindObjectsOfType<VolumeRenderedObject_Mask>();
+            if (objects_Mask.Length == 1)
+            {
+                meshRenderer_Mask = objects_Mask[0].meshRenderer;
+                mat_Mask = meshRenderer_Mask.material;
+            }
+
             matSetting();
 
             m_Toggle.onValueChanged.AddListener(delegate
@@ -167,6 +172,9 @@ void matSetting()
                                 meshRenderer = objects[0].meshRenderer;
                                 mat = meshRenderer.material;
 
+                                meshRenderer_Mask = objects_Mask[0].meshRenderer;
+                                mat_Mask = meshRenderer_Mask.material;
+
                                 List<string> fileLines = File.ReadAllLines(isoRangeFilePath).ToList();
 
                                 int range = 0; //dataset.GetMinDataValue();
@@ -192,11 +200,17 @@ void matSetting()
                                 mat.SetFloatArray("_isoRange", isoRange);
                                 mat.SetVectorArray("_isoCluster", isoCluster);
 
-                                
+                                mat_Mask.SetInt("_isoCount", Count);
+                                mat_Mask.SetFloatArray("_isoRange", isoRange);
+                                mat_Mask.SetVectorArray("_isoCluster", isoCluster);
+
+
                                 TransferFunction newTF = TransferFunctionDatabase.LoadTransferFunction(tfPath);
                                 if (newTF != null)
                                     objects[0].transferFunction = newTF;
+                                    objects_Mask[0].transferFunction = newTF;
                                 objects[0].UpdateMaterialProperties();
+                                objects_Mask[0].UpdateMaterialProperties();
                                 resetDefault();
                             }
 
@@ -206,7 +220,9 @@ void matSetting()
                             {
                                 resetDefault();
                                 mat.EnableKeyword("DiggingWidget"); 
-                                mat.DisableKeyword("ErasingWidget");                       
+                                mat.DisableKeyword("ErasingWidget");
+                                mat_Mask.EnableKeyword("DiggingWidget");
+                                mat_Mask.DisableKeyword("ErasingWidget");
                                 SliderEvent[] sliObj = FindObjectsOfType<SliderEvent>();
                                 sliObj[0].sliname = "SLICircleSize";
                             }
@@ -214,7 +230,9 @@ void matSetting()
                             {
                                 resetDefault();
                                 mat.EnableKeyword("ErasingWidget");
-                                mat.DisableKeyword("DiggingWidget");                                
+                                mat.DisableKeyword("DiggingWidget");
+                                mat_Mask.EnableKeyword("ErasingWidget");
+                                mat_Mask.DisableKeyword("DiggingWidget");
                                 SliderEvent[] sliObj = FindObjectsOfType<SliderEvent>();
                                 sliObj[0].sliname = "SLISurface";
                             }
@@ -226,18 +244,28 @@ void matSetting()
                             {
                                 if (i == 0) objects[0].SetLightingEnabled(true);                             
                                 if (i == 1) objects[0].SetLightingEnabled(false);
-                            }                           
+                            }
+                            objects_Mask = FindObjectsOfType<VolumeRenderedObject_Mask>();
+                            if (objects_Mask.Length == 1)
+                            {
+                                if (i == 0) objects_Mask[0].SetLightingEnabled(true);
+                                if (i == 1) objects_Mask[0].SetLightingEnabled(false);
+                            }
                             break;
                         case "Surface Toggle Group":
                             if (i == 0)
                             {
-                                mat.EnableKeyword("Full_ON");
-                                mat.DisableKeyword("PartialOn");
+                                mat.EnableKeyword("ErasingWidget");
+                                mat.DisableKeyword("DiggingWidget");
+                                mat_Mask.EnableKeyword("ErasingWidget");
+                                mat_Mask.DisableKeyword("DiggingWidget");
                             }
                             if (i == 1)
                             {
-                                mat.EnableKeyword("PartialOn");
-                                mat.DisableKeyword("Full_ON");
+                                mat.EnableKeyword("DiggingWidget");
+                                mat.DisableKeyword("ErasingWidget");
+                                mat_Mask.EnableKeyword("DiggingWidget");
+                                mat_Mask.DisableKeyword("ErasingWidget");
                             }
                             break;
                     }
@@ -270,6 +298,17 @@ void resetDefault()
                 mat.SetFloatArray("_CircleSize", obj[0]._CircleSize);
                 mat.SetFloatArray("_LensIndexs", obj[0]._LensIndexs);
 
+                mat_Mask.SetInt("_WidgetNums", obj[0]._WidgetNums);
+                mat_Mask.SetInt("_RecordNums", obj[0]._RecordNums);
+                mat_Mask.SetVectorArray("_WidgetPos", obj[0]._WidgetPos);
+                mat_Mask.SetVectorArray("_WidgetRecorder", obj[0]._WidgetRecorder);
+                mat_Mask.SetMatrixArray("_RotateMatrix", obj[0].rotMatrixArr);
+                mat_Mask.SetMatrixArray("_RotateMatrixInverse", obj[0].rotMatrixArrInverse);
+                mat_Mask.SetInt("_CurrentWidgetNum", 0);
+                mat_Mask.SetFloatArray("_CircleSize", obj[0]._CircleSize);
+                mat_Mask.SetFloatArray("_LensIndexs", obj[0]._LensIndexs);
+
+
                 obj[0].SetColor(0);
 
       
@@ -290,5 +329,7 @@ void resetDefault()
 
         }
 
+      
+
     }
 }
\ No newline at end of file
diff --git a/Assets/Scripts/InteractiveController/MouseEvent/Hover.cs b/Assets/Scripts/InteractiveController/MouseEvent/Hover.cs
index 9f4f7896..becb88b8 100644
--- a/Assets/Scripts/InteractiveController/MouseEvent/Hover.cs
+++ b/Assets/Scripts/InteractiveController/MouseEvent/Hover.cs
@@ -27,8 +27,8 @@ public class Hover : MonoBehaviour
         public Matrix4x4[] camToWorld;
         public Vector4[] camPos;
 
-        MeshRenderer meshRenderer;
-        Material mat;
+        MeshRenderer meshRenderer, meshRenderer_Mask;
+        Material mat, mat_Mask;
 
         public float[] _CircleSize = new float[10];
         public float[] _LensIndexs = new float[10];
@@ -56,6 +56,13 @@ void Start()
                 mat = meshRenderer.material;
             }
 
+            VolumeRenderedObject_Mask[] objects_Mask = FindObjectsOfType<VolumeRenderedObject_Mask>();
+            if (objects_Mask.Length == 1)
+            {
+                meshRenderer_Mask = objects_Mask[0].meshRenderer;
+                mat_Mask = meshRenderer_Mask.material;
+            }
+
             localTrans = GetComponent<Transform>();
             tmpTrans = GetComponent<Transform>();
             myMainCam = Camera.main;
@@ -91,6 +98,14 @@ void Start()
             mat.EnableKeyword("MOUSEDOWN_ON");
             mat.SetFloat("_viewCamIndex", 2);
 
+            mat_Mask.SetMatrixArray("_CamToWorld", camToWorld);
+            mat_Mask.SetVectorArray("_camLocalPos", camPos);
+            mat_Mask.SetFloat("_localDepth", localDepth);
+            mat_Mask.SetFloat("_depthNP", depthNP);
+            mat_Mask.SetFloat("_maxDataVal", objects[0].dataset.GetMaxDataValue());
+            mat_Mask.EnableKeyword("MOUSEDOWN_ON");
+            mat_Mask.SetFloat("_viewCamIndex", 2);
+
         }
         void Update()
         {
@@ -109,6 +124,7 @@ void Update()
                     fullProgress -= FillSpeed * Time.deltaTime;
                     _CircleSize[_WidgetNums - 1] = fullProgress;
                     mat.SetFloatArray("_CircleSize", _CircleSize);
+                    mat_Mask.SetFloatArray("_CircleSize", _CircleSize);
                 }
             }
 
@@ -293,6 +309,16 @@ void PartialOn()
                 mat.SetMatrixArray("_RotateMatrixInverse", rotMatrixArrInverse);
                 mat.SetInt("_CurrentWidgetNum", _WidgetNums - 1);
 
+                mat_Mask.SetFloatArray("_CircleSize", _CircleSize);
+                mat_Mask.SetFloatArray("_LensIndexs", _LensIndexs);
+                mat_Mask.SetInt("_WidgetNums", _WidgetNums);
+                mat_Mask.SetInt("_RecordNums", _RecordNums);
+                mat_Mask.SetVectorArray("_WidgetPos", _WidgetPos);
+                mat_Mask.SetVectorArray("_WidgetRecorder", _WidgetRecorder);
+                mat_Mask.SetMatrixArray("_RotateMatrix", rotMatrixArr);
+                mat_Mask.SetMatrixArray("_RotateMatrixInverse", rotMatrixArrInverse);
+                mat_Mask.SetInt("_CurrentWidgetNum", _WidgetNums - 1);
+
                 //partialStop = true;
                 //_CircleSize[_WidgetNums - 1] = 0.1f;
                 //mat.SetFloatArray("_CircleSize", _CircleSize);
@@ -394,10 +420,22 @@ void FullOn()
                 mat.SetMatrixArray("_RotateMatrixInverse", rotMatrixArrInverse);
                 mat.SetInt("_CurrentWidgetNum", _WidgetNums - 1);
 
+                mat_Mask.SetInt("_WidgetNums", _WidgetNums);
+                mat_Mask.SetInt("_RecordNums", _RecordNums);
+                mat_Mask.SetVectorArray("_WidgetPos", _WidgetPos);
+                mat_Mask.SetVectorArray("_WidgetRecorder", _WidgetRecorder);
+                mat_Mask.SetMatrixArray("_RotateMatrix", rotMatrixArr);
+                mat_Mask.SetMatrixArray("_RotateMatrixInverse", rotMatrixArrInverse);
+                mat_Mask.SetInt("_CurrentWidgetNum", _WidgetNums - 1);
+
+
                 fullStop = true;            
                 _CircleSize[_WidgetNums - 1] = 0.0f;
                 mat.SetFloatArray("_CircleSize", _CircleSize);
                 mat.SetFloatArray("_LensIndexs", _LensIndexs);
+
+                mat_Mask.SetFloatArray("_CircleSize", _CircleSize);
+                mat_Mask.SetFloatArray("_LensIndexs", _LensIndexs);
             }
         }
       
diff --git a/Assets/Scripts/VolumeObject/VolumeObjectFactory.cs b/Assets/Scripts/VolumeObject/VolumeObjectFactory.cs
index 12504148..e61efef2 100644
--- a/Assets/Scripts/VolumeObject/VolumeObjectFactory.cs
+++ b/Assets/Scripts/VolumeObject/VolumeObjectFactory.cs
@@ -122,8 +122,9 @@ public static VolumeRenderedObject CreateObject(VolumeDataset dataset)
         {
             GameObject outerObject = new GameObject("VolumeRenderedObject_" + dataset.datasetName);
             VolumeRenderedObject volObj = outerObject.AddComponent<VolumeRenderedObject>();
-
+      
             GameObject meshContainer = GameObject.Instantiate((GameObject)Resources.Load("VolumeContainer"));
+            
             meshContainer.transform.parent = outerObject.transform;
             meshContainer.transform.localScale = Vector3.one;
             meshContainer.transform.localPosition = Vector3.zero;
@@ -142,7 +143,8 @@ public static VolumeRenderedObject CreateObject(VolumeDataset dataset)
             outerObject.transform.localRotation = Quaternion.Euler(90.0f, 0.0f, 0.0f);
 
             MeshRenderer meshRenderer = meshContainer.GetComponent<MeshRenderer>();
-            meshRenderer.sharedMaterial = new Material(meshRenderer.sharedMaterial);
+            meshRenderer.sharedMaterial = new Material(meshRenderer.sharedMaterial);           
+
             volObj.meshRenderer = meshRenderer;
             volObj.dataset = dataset;
 
@@ -153,10 +155,10 @@ public static VolumeRenderedObject CreateObject(VolumeDataset dataset)
             TransferFunction tf = TransferFunctionDatabase.CreateTransferFunction();
             Texture2D tfTexture = tf.GetTexture();
             volObj.transferFunction = tf;
-
+          
             TransferFunction2D tf2D = TransferFunctionDatabase.CreateTransferFunction2D();
             volObj.transferFunction2D = tf2D;
-
+          
             meshRenderer.sharedMaterial.SetTexture("_DataTex", dataset.GetDataTexture());
             meshRenderer.sharedMaterial.SetTexture("_GradientTex", null);
             meshRenderer.sharedMaterial.SetTexture("_NoiseTex", noiseTexture);
@@ -165,7 +167,7 @@ public static VolumeRenderedObject CreateObject(VolumeDataset dataset)
             meshRenderer.sharedMaterial.EnableKeyword("MODE_DVR");
             meshRenderer.sharedMaterial.DisableKeyword("MODE_MIP");
             meshRenderer.sharedMaterial.DisableKeyword("MODE_SURF");
-
+        
             //if(dataset.scaleX != 0.0f && dataset.scaleY != 0.0f && dataset.scaleZ != 0.0f)
             //{
             //    float maxScale = Mathf.Max(dataset.scaleX, dataset.scaleY, dataset.scaleZ);
diff --git a/Assets/Scripts/VolumeObject/VolumeObjectFactory_Mask.cs b/Assets/Scripts/VolumeObject/VolumeObjectFactory_Mask.cs
new file mode 100644
index 00000000..5151b60a
--- /dev/null
+++ b/Assets/Scripts/VolumeObject/VolumeObjectFactory_Mask.cs
@@ -0,0 +1,78 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using SeawispHunter.Maths;
+using System.IO;
+
+namespace UnityVolumeRendering
+{
+    public class VolumeObjectFactory_Mask
+    {
+        public static VolumeRenderedObject_Mask CreateObject(VolumeDataset dataset)
+        {
+            GameObject outerObject = new GameObject("VolumeRenderedObject_" + dataset.datasetName + "_Mask");
+            VolumeRenderedObject_Mask volObj = outerObject.AddComponent<VolumeRenderedObject_Mask>();
+            
+            GameObject meshContainer = GameObject.Instantiate((GameObject)Resources.Load("VolumeContainer_Mask"));       
+
+            meshContainer.transform.parent = outerObject.transform;
+            meshContainer.transform.localScale = Vector3.one;
+            meshContainer.transform.localPosition = Vector3.zero;
+            meshContainer.transform.parent = outerObject.transform;
+
+            int maxDim = Math.Max(dataset.dimX, Math.Max(dataset.dimY, dataset.dimZ));
+            outerObject.transform.localScale = new Vector3((float)Math.Round((decimal)dataset.dimX / maxDim, 2), (float)Math.Round((decimal)dataset.dimY / maxDim, 2), (float)Math.Round((decimal)dataset.dimZ / maxDim, 2));
+
+            GameObject ShaderBuffer_mask = new GameObject("ShaderBuffer_mask");
+            ShaderDebugging_Mask shaderDebugObj = ShaderBuffer_mask.AddComponent<ShaderDebugging_Mask>();
+            shaderDebugObj.target_Mask = meshContainer;
+
+            outerObject.transform.localRotation = Quaternion.Euler(90.0f, 0.0f, 0.0f);
+
+            MeshRenderer meshRenderer = meshContainer.GetComponent<MeshRenderer>();
+            meshRenderer.sharedMaterial = new Material(meshRenderer.sharedMaterial);          
+
+            volObj.meshRenderer = meshRenderer;
+            volObj.dataset = dataset;
+          
+            const int noiseDimX = 512;
+            const int noiseDimY = 512;
+            Texture2D noiseTexture = NoiseTextureGenerator.GenerateNoiseTexture(noiseDimX, noiseDimY);
+
+            TransferFunction tf = TransferFunctionDatabase.CreateTransferFunction();
+            Texture2D tfTexture = tf.GetTexture();
+            volObj.transferFunction = tf;
+          
+            TransferFunction2D tf2D = TransferFunctionDatabase.CreateTransferFunction2D();
+            volObj.transferFunction2D = tf2D;          
+
+            meshRenderer.sharedMaterial.SetTexture("_DataTex", dataset.GetDataTexture());
+            meshRenderer.sharedMaterial.SetTexture("_GradientTex", null);
+            meshRenderer.sharedMaterial.SetTexture("_NoiseTex", noiseTexture);
+            meshRenderer.sharedMaterial.SetTexture("_TFTex", tfTexture);
+
+            meshRenderer.sharedMaterial.EnableKeyword("MODE_DVR");
+            meshRenderer.sharedMaterial.DisableKeyword("MODE_MIP");
+            meshRenderer.sharedMaterial.DisableKeyword("MODE_SURF");
+
+         
+
+            //if(dataset.scaleX != 0.0f && dataset.scaleY != 0.0f && dataset.scaleZ != 0.0f)
+            //{
+            //    float maxScale = Mathf.Max(dataset.scaleX, dataset.scaleY, dataset.scaleZ);
+            //    volObj.transform.localScale = new Vector3(dataset.scaleX / maxScale, dataset.scaleY / maxScale, dataset.scaleZ / maxScale);
+            //}
+
+            //meshRenderer.sharedMaterial.SetFloat("bounds", dataset.bounds);
+            //meshRenderer.sharedMaterial.SetFloat("lowBound", dataset.lowBound);
+            //meshRenderer.sharedMaterial.SetFloat("RotationX", outerObject.transform.rotation.eulerAngles.x);
+            //meshRenderer.sharedMaterial.SetFloat("RotationY", outerObject.transform.rotation.eulerAngles.y);
+            //meshRenderer.sharedMaterial.SetFloat("RotationZ", outerObject.transform.rotation.eulerAngles.z);
+            //meshRenderer.sharedMaterial.SetFloat("ObjDepthX", (float)Math.Round((decimal)dataset.dimX / maxDim, 2));
+            //meshRenderer.sharedMaterial.SetFloat("ObjDepthY", (float)Math.Round((decimal)dataset.dimY / maxDim, 2));
+            //meshRenderer.sharedMaterial.SetFloat("ObjDepthZ", (float)Math.Round((decimal)dataset.dimZ / maxDim, 2));
+
+            return volObj;
+        }
+    }
+}
diff --git a/Assets/Scripts/VolumeObject/VolumeObjectFactory_Mask.cs.meta b/Assets/Scripts/VolumeObject/VolumeObjectFactory_Mask.cs.meta
new file mode 100644
index 00000000..4f783735
--- /dev/null
+++ b/Assets/Scripts/VolumeObject/VolumeObjectFactory_Mask.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e776ef6f1303f2747824739fdc421180
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Scripts/VolumeObject/VolumeRenderedObject_Mask.cs b/Assets/Scripts/VolumeObject/VolumeRenderedObject_Mask.cs
new file mode 100644
index 00000000..13e4f575
--- /dev/null
+++ b/Assets/Scripts/VolumeObject/VolumeRenderedObject_Mask.cs
@@ -0,0 +1,198 @@
+using UnityEngine;
+
+namespace UnityVolumeRendering
+{
+    [ExecuteInEditMode]
+    public class VolumeRenderedObject_Mask : MonoBehaviour
+    {
+        [SerializeField, HideInInspector]
+        public TransferFunction transferFunction;
+
+        [SerializeField, HideInInspector]
+        public TransferFunction2D transferFunction2D;
+
+        [SerializeField, HideInInspector]
+        public VolumeDataset dataset;
+
+        [SerializeField, HideInInspector]
+        public MeshRenderer meshRenderer;
+
+        [SerializeField, HideInInspector]
+        private RenderMode renderMode;
+        [SerializeField, HideInInspector]
+        private TFRenderMode tfRenderMode;
+        [SerializeField, HideInInspector]
+        private bool lightingEnabled;
+
+        [SerializeField, HideInInspector]
+        private Vector2 visibilityWindow = new Vector2(0.0f, 1.0f);
+        [SerializeField, HideInInspector]
+        private bool rayTerminationEnabled = true;
+        [SerializeField, HideInInspector]
+        private bool dvrBackward = false;
+ 
+        public void SetRenderMode(RenderMode mode)
+        {
+            if (renderMode != mode)
+            {
+                renderMode = mode;
+                SetVisibilityWindow(0.0f, 1.0f); // reset visibility window
+            }
+            UpdateMaterialProperties();
+        }
+
+        public void SetTransferFunctionMode(TFRenderMode mode)
+        {
+            tfRenderMode = mode;
+            if (tfRenderMode == TFRenderMode.TF1D && transferFunction != null)
+                transferFunction.GenerateTexture();
+            else if (transferFunction2D != null)
+                transferFunction2D.GenerateTexture();
+            UpdateMaterialProperties();
+        }
+
+        public TFRenderMode GetTransferFunctionMode()
+        {
+            return tfRenderMode;
+        }
+
+        public RenderMode GetRenderMode()
+        {
+            return renderMode;
+        }
+
+        public bool GetLightingEnabled()
+        {
+            return lightingEnabled;
+        }
+
+        public void SetLightingEnabled(bool enable)
+        {
+            if (enable != lightingEnabled)
+            {
+                lightingEnabled = enable;
+                UpdateMaterialProperties();
+            }
+        }
+
+        public void SetVisibilityWindow(float min, float max)
+        {
+            SetVisibilityWindow(new Vector2(min, max));
+        }
+
+        public void SetVisibilityWindow(Vector2 window)
+        {
+            if (window != visibilityWindow)
+            {
+                visibilityWindow = window;
+                UpdateMaterialProperties();
+            }
+        }
+
+        public Vector2 GetVisibilityWindow()
+        {
+            return visibilityWindow;
+        }
+
+        public bool GetRayTerminationEnabled()
+        {
+            return rayTerminationEnabled;
+        }
+
+        public void SetRayTerminationEnabled(bool enable)
+        {
+            if (enable != rayTerminationEnabled)
+            {
+                rayTerminationEnabled = enable;
+                UpdateMaterialProperties();
+            }
+        }
+
+        public bool GetDVRBackwardEnabled()
+        {
+            return dvrBackward;
+        }
+
+        public void SetDVRBackwardEnabled(bool enable)
+        {
+            if (enable != dvrBackward)
+            {
+                dvrBackward = enable;
+                UpdateMaterialProperties();
+            }
+        }
+
+        public void UpdateMaterialProperties()
+        {
+            bool useGradientTexture = tfRenderMode == TFRenderMode.TF2D || renderMode == RenderMode.IsosurfaceRendering || lightingEnabled;
+            meshRenderer.sharedMaterial.SetTexture("_GradientTex", useGradientTexture ? dataset.GetGradientTexture() : null);
+
+            if (tfRenderMode == TFRenderMode.TF2D)
+            {
+                meshRenderer.sharedMaterial.SetTexture("_TFTex", transferFunction2D.GetTexture());
+                meshRenderer.sharedMaterial.EnableKeyword("TF2D_ON");
+            }
+            else
+            {
+                meshRenderer.sharedMaterial.SetTexture("_TFTex", transferFunction.GetTexture());
+                meshRenderer.sharedMaterial.DisableKeyword("TF2D_ON");
+            }
+
+            if (lightingEnabled)
+                meshRenderer.sharedMaterial.EnableKeyword("LIGHTING_ON");
+            else
+                meshRenderer.sharedMaterial.DisableKeyword("LIGHTING_ON");
+
+            switch (renderMode)
+            {
+                case RenderMode.DirectVolumeRendering:
+                    {
+                        meshRenderer.sharedMaterial.EnableKeyword("MODE_DVR");
+                        meshRenderer.sharedMaterial.DisableKeyword("MODE_MIP");
+                        meshRenderer.sharedMaterial.DisableKeyword("MODE_SURF");
+                        break;
+                    }
+                case RenderMode.MaximumIntensityProjectipon:
+                    {
+                        meshRenderer.sharedMaterial.DisableKeyword("MODE_DVR");
+                        meshRenderer.sharedMaterial.EnableKeyword("MODE_MIP");
+                        meshRenderer.sharedMaterial.DisableKeyword("MODE_SURF");
+                        break;
+                    }
+                case RenderMode.IsosurfaceRendering:
+                    {
+                        meshRenderer.sharedMaterial.DisableKeyword("MODE_DVR");
+                        meshRenderer.sharedMaterial.DisableKeyword("MODE_MIP");
+                        meshRenderer.sharedMaterial.EnableKeyword("MODE_SURF");
+                        break;
+                    }
+            }
+
+            meshRenderer.sharedMaterial.SetFloat("_MinVal", visibilityWindow.x);
+            meshRenderer.sharedMaterial.SetFloat("_MaxVal", visibilityWindow.y);
+
+            if (rayTerminationEnabled)
+            {
+                meshRenderer.sharedMaterial.EnableKeyword("RAY_TERMINATE_ON");
+            }
+            else
+            {
+                meshRenderer.sharedMaterial.DisableKeyword("RAY_TERMINATE_ON");
+            }
+
+            if (dvrBackward)
+            {
+                meshRenderer.sharedMaterial.EnableKeyword("DVR_BACKWARD_ON");
+            }
+            else
+            {
+                meshRenderer.sharedMaterial.DisableKeyword("DVR_BACKWARD_ON");
+            }
+        }
+
+        private void Start()
+        {
+            UpdateMaterialProperties();
+        }
+    }
+}
diff --git a/Assets/Scripts/VolumeObject/VolumeRenderedObject_Mask.cs.meta b/Assets/Scripts/VolumeObject/VolumeRenderedObject_Mask.cs.meta
new file mode 100644
index 00000000..88c6d9df
--- /dev/null
+++ b/Assets/Scripts/VolumeObject/VolumeRenderedObject_Mask.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 08dd381bf3069fb4f825fd37c8dc8702
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Shaders/DirectVolumeRenderingShader_Mask.shader b/Assets/Shaders/DirectVolumeRenderingShader_Mask.shader
new file mode 100644
index 00000000..fbd36f01
--- /dev/null
+++ b/Assets/Shaders/DirectVolumeRenderingShader_Mask.shader
@@ -0,0 +1,1245 @@
+Shader "VolumeRendering/DirectVolumeRenderingShader_Mask"
+{
+    Properties
+    {
+        _DataTex("Data Texture (Generated)", 3D) = "" {}
+        _GradientTex("Gradient Texture (Generated)", 3D) = "" {}
+        _NoiseTex("Noise Texture (Generated)", 2D) = "white" {}
+        _TFTex("Transfer Function Texture (Generated)", 2D) = "" {}
+        _SegmentTex("Segment Texture (Generated)", 3D) = "" {}
+        _MinVal("Min val", Range(0.0, 1.0)) = 0.0
+        _MaxVal("Max val", Range(0.0, 1.0)) = 1.0
+    }
+        SubShader
+        {
+            Tags { "Queue" = "Transparent" "RenderType" = "Transparent" }
+            LOD 100
+            Cull Front
+            ZTest LEqual
+            ZWrite On
+            Blend SrcAlpha OneMinusSrcAlpha
+
+            Pass
+            {
+                CGPROGRAM
+                #pragma multi_compile __ MOUSEDOWN_ON
+                #pragma multi_compile __ DiggingWidget ErasingWidget
+                #pragma multi_compile MODE_DVR MODE_MIP MODE_SURF
+                #pragma multi_compile __ TF2D_ON
+                #pragma multi_compile __ CUTOUT_PLANE CUTOUT_BOX_INCL CUTOUT_BOX_EXCL
+                #pragma multi_compile __ LIGHTING_ON
+                #pragma multi_compile DEPTHWRITE_ON DEPTHWRITE_OFF
+                #pragma multi_compile __ DVR_BACKWARD_ON
+                #pragma multi_compile __ RAY_TERMINATE_ON
+                #pragma vertex vert
+                #pragma fragment frag
+                #pragma target 4.5
+                RWStructuredBuffer<float4> buffer: register(u1);
+
+                #include "UnityCG.cginc"
+                #include "SDF.cginc"
+
+                #define MOUSEDOWN_ON DiggingWidget || ErasingWidget
+                #define CUTOUT_ON CUTOUT_PLANE || CUTOUT_BOX_INCL || CUTOUT_BOX_EXCL
+
+                struct vert_in
+                {
+                    float4 vertex : POSITION;
+                    float4 normal : NORMAL;
+                    float2 uv : TEXCOORD0;
+                };
+
+                struct frag_in
+                {
+                    float4 vertex : SV_POSITION;
+                    float2 uv : TEXCOORD0;
+                    float3 vertexLocal : TEXCOORD1;
+                    float3 normal : NORMAL;
+                };
+
+                struct frag_out
+                {
+                    float4 colour : SV_TARGET;
+    #if DEPTHWRITE_ON
+                    float depth : SV_DEPTH;
+    #endif
+                };
+
+                sampler3D _DataTex;
+                sampler3D _GradientTex;
+                sampler2D _NoiseTex;
+                sampler2D _TFTex;
+                sampler3D _SegmentTex;
+
+                float _MinVal;
+                float _MaxVal;
+
+                float _CircleSize[10];
+                float _LensIndexs[10];
+
+                float4 _WidgetPos[10];           // Mouse Click pos
+                float4 _WidgetRecorder[10];
+                int _WidgetNums = 0;
+                int _RecordNums = 0;
+                float4x4 _RenderRotate;
+                float4x4 _RotateMatrix[10];
+                float4x4 _RotateMatrixInverse[10];
+
+                float4 _camLocalPos[6];
+                float4x4 _CamToWorld[6];
+
+                float _localDepth;
+                float _depthNP;
+
+                float _maxDataVal;
+                int _isoCount;
+                float _isoRange[10];
+                float4 _isoCluster[10];
+
+    #if CUTOUT_ON
+                float4x4 _CrossSectionMatrix;
+    #endif
+
+                struct RayInfo
+                {
+                    float3 startPos;
+                    float3 endPos;
+                    float3 direction;
+                    float2 aabbInters;
+                };
+
+                struct RaymarchInfo
+                {
+                    RayInfo ray;
+                    int numSteps;
+                    float numStepsRecip;
+                    float stepSize;
+                };
+
+                float3 getViewRayDir(float3 vertexLocal, int k)
+                {
+                    if (unity_OrthoParams.w == 0)
+                    {
+                        // Perspective
+                        return normalize(ObjSpaceViewDir(float4(vertexLocal, 0.0f)));
+                    }
+                    else
+                    {
+                        // Orthographic
+                        float3 camfwd = mul(_CamToWorld[k], _camLocalPos[k].xyz);
+                        float4 camfwdobjspace = mul(unity_WorldToObject, camfwd);
+                        return normalize(camfwdobjspace);
+                    }
+                }
+
+                // Find ray intersection points with axis aligned bounding box
+                float2 intersectAABB(float3 rayOrigin, float3 rayDir, float3 boxMin, float3 boxMax)
+                {
+                    float3 tMin = (boxMin - rayOrigin) / rayDir;
+                    float3 tMax = (boxMax - rayOrigin) / rayDir;
+                    float3 t1 = min(tMin, tMax);
+                    float3 t2 = max(tMin, tMax);
+                    float tNear = max(max(t1.x, t1.y), t1.z);
+                    float tFar = min(min(t2.x, t2.y), t2.z);
+                    return float2(tNear, tFar);
+                };
+
+                // Get a ray for the specified fragment (back-to-front)
+                RayInfo getRayBack2Front(float3 vertexLocal, int k)
+                {
+                    RayInfo ray;
+                    ray.direction = getViewRayDir(vertexLocal, k);
+                    ray.startPos = vertexLocal + float3(0.5f, 0.5f, 0.5f);
+                    // Find intersections with axis aligned boundinng box (the volume)
+                    ray.aabbInters = intersectAABB(ray.startPos, ray.direction, float3(0.0, 0.0, 0.0), float3(1.0f, 1.0f, 1.0));
+
+                    // Check if camera is inside AABB
+                    const float3 farPos = ray.startPos + ray.direction * ray.aabbInters.y - float3(0.5f, 0.5f, 0.5f);
+                    float4 clipPos = UnityObjectToClipPos(float4(farPos, 1.0f));
+                    ray.aabbInters += min(clipPos.w, 0.0);
+
+                    ray.endPos = ray.startPos + ray.direction * ray.aabbInters.y;
+                    return ray;
+                }
+
+                // Get a ray for the specified fragment (front-to-back)
+                RayInfo getRayFront2Back(float3 vertexLocal, int k)
+                {
+                    RayInfo ray = getRayBack2Front(vertexLocal, k);
+                    ray.direction = -ray.direction;
+                    float3 tmp = ray.startPos;
+                    ray.startPos = ray.endPos;
+                    ray.endPos = tmp;
+                    return ray;
+                }
+
+                RaymarchInfo initRaymarch(RayInfo ray, int maxNumSteps)
+                {
+                    RaymarchInfo raymarchInfo;
+                    raymarchInfo.stepSize = 1.732f/*greatest distance in box*/ / maxNumSteps;
+                    raymarchInfo.numSteps = (int)clamp(abs(ray.aabbInters.x - ray.aabbInters.y) / raymarchInfo.stepSize, 1, maxNumSteps);
+                    raymarchInfo.numStepsRecip = 1.0 / raymarchInfo.numSteps;
+                    return raymarchInfo;
+                }
+
+                // Gets the colour from a 1D Transfer Function (x = density)
+                float4 getTF1DColour(float density)
+                {
+                    return tex2Dlod(_TFTex, float4(density, 0.0f, 0.0f, 0.0f));
+                }
+
+                // Gets the colour from a 2D Transfer Function (x = density, y = gradient magnitude)
+                float4 getTF2DColour(float density, float gradientMagnitude)
+                {
+                    return tex2Dlod(_TFTex, float4(density, gradientMagnitude, 0.0f, 0.0f));
+                }
+
+                // Gets the density at the specified position
+                float getDensity(float3 pos)
+                {
+                    return tex3Dlod(_DataTex, float4(pos.x, pos.y, pos.z, 0.0f));
+                }
+
+                float getSegCluser(float3 pos)
+                {
+                    return tex3Dlod(_SegmentTex, float4(pos.x, pos.y, pos.z, 0.0f));
+                }
+
+                // Gets the gradient at the specified position
+                float3 getGradient(float3 pos)
+                {
+                    return tex3Dlod(_GradientTex, float4(pos.x, pos.y, pos.z, 0.0f)).rgb;
+                }
+
+                // Performs lighting calculations, and returns a modified colour.
+                float3 calculateLighting(float3 col, float3 normal, float3 lightDir, float3 eyeDir, float specularIntensity)
+                {
+                    float ndotl = max(lerp(0.0f, 1.5f, dot(normal, lightDir)), 0.5f); // modified, to avoid volume becoming too dark
+                    float3 diffuse = ndotl * col;
+                    float3 v = eyeDir;
+                    float3 r = normalize(reflect(-lightDir, normal));
+                    float rdotv = max(dot(r, v), 0.0);
+                    float3 specular = pow(rdotv, 32.0f) * float3(1.0f, 1.0f, 1.0f) * specularIntensity;
+                    return diffuse + specular;
+                }
+
+                // Converts local position to depth value
+                float localToDepth(float3 localPos)
+                {
+                    float4 clipPos = UnityObjectToClipPos(float4(localPos, 1.0f));
+
+    #if defined(SHADER_API_GLCORE) || defined(SHADER_API_OPENGL) || defined(SHADER_API_GLES) || defined(SHADER_API_GLES3)
+                    return (clipPos.z / clipPos.w) * 0.5 + 0.5;
+    #else
+                    return clipPos.z / clipPos.w;
+    #endif
+                }
+
+                bool IsCutout(float3 currPos)
+                {
+    #if CUTOUT_ON
+                    // Move the reference in the middle of the mesh, like the pivot
+                    float3 pos = currPos - float3(0.5f, 0.5f, 0.5f);
+
+                    // Convert from model space to plane's vector space
+                    float3 planeSpacePos = mul(_CrossSectionMatrix, float4(pos, 1.0f));
+
+        #if CUTOUT_PLANE
+                    return planeSpacePos.z > 0.0f;
+        #elif CUTOUT_BOX_INCL
+                    return !(planeSpacePos.x >= -0.5f && planeSpacePos.x <= 0.5f && planeSpacePos.y >= -0.5f && planeSpacePos.y <= 0.5f && planeSpacePos.z >= -0.5f && planeSpacePos.z <= 0.5f);
+        #elif CUTOUT_BOX_EXCL
+                    return planeSpacePos.x >= -0.5f && planeSpacePos.x <= 0.5f && planeSpacePos.y >= -0.5f && planeSpacePos.y <= 0.5f && planeSpacePos.z >= -0.5f && planeSpacePos.z <= 0.5f;
+        #endif
+    #else
+                    return false;
+    #endif
+                }
+
+                int findClusterIndex(float density)
+                {
+                    int clusterIndex = -1;
+                    for (int i = 0; i < _isoCount; i++)
+                    {
+                        if (_isoRange[i] > (density * _maxDataVal))
+                        {
+                            clusterIndex = i;
+                            return clusterIndex;
+                        }
+                    }
+                    return clusterIndex;
+                }
+                float2 findIsoRange(float index)
+                {
+                    float2 val = _isoCluster[index] / _maxDataVal;
+                    return val;
+                }
+
+                frag_in vert_main(vert_in v)
+                {
+                    frag_in o;
+                    o.vertex = UnityObjectToClipPos(v.vertex);
+                    o.uv = v.uv;
+                    o.vertexLocal = v.vertex;
+                    o.normal = UnityObjectToWorldNormal(v.normal);
+                    return o;
+                }
+
+                float4 B2F(float dp, RayInfo ray, float zDepthFX, float zDepthFY, float Findex, float noiseVal) {
+    #define MAX_NUM_STEPS 512
+    #define OPACITY_THRESHOLD (1.0 - 1.0 / 255.0)
+
+                    RaymarchInfo raymarchInfo = initRaymarch(ray, MAX_NUM_STEPS);
+
+                    float3 lightDir = normalize(ObjSpaceViewDir(float4(float3(0.0f, 0.0f, 0.0f), 0.0f)));
+
+                    // Create a small random offset in order to remove artifacts
+                    ray.startPos += (2.0f * ray.direction * raymarchInfo.stepSize) * noiseVal;
+
+                    float4 col = float4(0.0f, 0.0f, 0.0f, 0.0f);
+                    float3 rPos, bPos;
+                    int clusterIndex = -1;
+                    float maxAcc = -1.0f;
+
+                    float3 maxPos = float3(-1.0f, -1.0f, -1.0f);
+                    float isoVal;
+                    float minBoundAcc = 0; // init
+                    int pIndex = -1;
+                    int isoIndex;
+                    float3 lastPos;
+                    float lastDensity;
+                    float segDensity;
+                    int lastIndex = -1;
+
+                    for (int iStep = 0; iStep < raymarchInfo.numSteps; iStep++)
+                    {
+                        const float t = iStep * raymarchInfo.numStepsRecip;
+                        const float3 currPos = lerp(ray.startPos, ray.endPos, t);
+
+
+                        // Get the dansity/sample value of the current position
+                        const float density = getDensity(currPos);
+
+                        pIndex = findClusterIndex(density);
+
+                        float4 src = getTF1DColour(density);
+
+                        if (density < _MinVal || density > _MaxVal)   continue;
+                        if (abs(dp) == 1 || abs(dp) == 4) {
+                            if ((currPos.x <= zDepthFX) || (currPos.x < zDepthFY && pIndex == Findex)) {
+                                continue;
+                            }
+                        }
+                        else if (abs(dp) == 2 || abs(dp) == 5) {
+                            if ((currPos.y <= zDepthFX) || (currPos.y < zDepthFY && pIndex == Findex)) {
+                                continue;
+                            }
+                        }
+                        else if (abs(dp) == 3 || abs(dp) == 6) {
+                            if ((currPos.z <= zDepthFX) || (currPos.z < zDepthFY && pIndex == Findex)) {
+                                continue;
+                            }
+                        }
+
+                        col.rgb = src.a * src.rgb + (1.0f - src.a) * col.rgb;
+                        col.a = src.a + (1.0f - src.a) * col.a;
+
+                        if (col.a >= 1.0f)
+                            break;
+
+                        if (clusterIndex == -1) {
+                            maxAcc = max((col.a - minBoundAcc), maxAcc);
+                            maxPos = currPos;
+                            rPos = currPos;
+                            bPos = currPos;
+                            lastDensity = density;
+                            lastPos = currPos;
+                            lastIndex = pIndex;
+                            clusterIndex = pIndex;
+                            minBoundAcc = col.a;
+                            isoIndex = pIndex;
+                            segDensity = getSegCluser(lastPos);
+                        }
+                        else {
+                            if (clusterIndex != pIndex) {
+
+                                if ((col.a - minBoundAcc) > maxAcc) {
+                                    maxAcc = max((col.a - minBoundAcc), maxAcc);
+                                    minBoundAcc = col.a;
+                                    clusterIndex = pIndex;
+                                    rPos = lastPos;
+                                    bPos = currPos;
+                                    isoIndex = lastIndex;
+
+                                    lastPos = currPos;
+                                    lastIndex = pIndex;
+                                    segDensity = getSegCluser(rPos);
+                                }
+
+                            }
+                        }
+                    }
+
+                    if (abs(dp) == 1) {
+                        return float4(rPos.x, bPos.x, isoIndex, segDensity);
+                    }
+                    else if (abs(dp) == 2) {
+                        return float4(rPos.y, bPos.y, isoIndex, segDensity);
+                    }
+                    else if (abs(dp) == 3) {
+                        return float4(rPos.z, bPos.z, isoIndex, segDensity);
+                    }
+                    else {
+                        return float4(0, 0, -1, 0);
+                    }
+                }
+
+                float4 B2F_Inverse(float dp, RayInfo ray, float zDepthIBX, float zDepthIBY, float Bindex, float noiseVal) {
+    #define MAX_NUM_STEPS 512
+    #define OPACITY_THRESHOLD (1.0 - 1.0 / 255.0)
+
+                    RaymarchInfo raymarchInfo = initRaymarch(ray, MAX_NUM_STEPS);
+
+                    float3 lightDir = normalize(ObjSpaceViewDir(float4(float3(0.0f, 0.0f, 0.0f), 0.0f)));
+
+                    // Create a small random offset in order to remove artifacts
+                    ray.startPos += (2.0f * ray.direction * raymarchInfo.stepSize) * noiseVal;
+
+                    float4 col = float4(0.0f, 0.0f, 0.0f, 0.0f);
+                    float3 rPos, bPos;
+                    int clusterIndex = -1;
+                    float maxAcc = -1.0f;
+
+                    float3 maxPos = float3(-1.0f, -1.0f, -1.0f);
+                    float isoVal;
+                    float minBoundAcc = 0; // init
+                    int pIndex = -1;
+                    int isoIndex;
+                    float3 lastPos;
+                    float lastDensity;
+                    float segDensity;
+                    int lastIndex = -1;
+
+                    for (int iStep = 0; iStep < raymarchInfo.numSteps; iStep++)
+                    {
+                        const float t = iStep * raymarchInfo.numStepsRecip;
+                        const float3 currPos = lerp(ray.startPos, ray.endPos, t);
+
+
+                        // Get the dansity/sample value of the current position
+                        const float density = getDensity(currPos);
+
+                        pIndex = findClusterIndex(density);
+
+                        float4 src = getTF1DColour(density);
+
+                        if (density < _MinVal || density > _MaxVal)   continue;
+
+                        if (abs(dp) == 1) {
+                            if ((((currPos.x >= zDepthIBX)) || (currPos.x > zDepthIBY && pIndex == Bindex))) {
+                                continue;
+                            }
+                        }
+                        else if (abs(dp) == 2) {
+                            if ((((currPos.y >= zDepthIBX)) || (currPos.y > zDepthIBY && pIndex == Bindex))) {
+                                continue;
+                            }
+                        }
+                        else if (abs(dp) == 3) {
+                            if ((((currPos.z >= zDepthIBX)) || (currPos.z > zDepthIBY && pIndex == Bindex))) {
+                                continue;
+                            }
+                        }
+
+                        col.rgb = src.a * src.rgb + (1.0f - src.a) * col.rgb;
+                        col.a = src.a + (1.0f - src.a) * col.a;
+
+                        if (col.a >= 1.0f)
+                            break;
+
+                        if (clusterIndex == -1) {
+                            maxAcc = max((col.a - minBoundAcc), maxAcc);
+                            maxPos = currPos;
+                            rPos = currPos;
+                            bPos = currPos;
+                            lastDensity = density;
+                            lastPos = currPos;
+                            lastIndex = pIndex;
+                            clusterIndex = pIndex;
+                            minBoundAcc = col.a;
+                            isoIndex = pIndex;
+                            segDensity = getSegCluser(lastPos);
+                        }
+                        else {
+                            if (clusterIndex != pIndex) {
+
+                                if ((col.a - minBoundAcc) > maxAcc) {
+                                    maxAcc = max((col.a - minBoundAcc), maxAcc);
+                                    minBoundAcc = col.a;
+                                    clusterIndex = pIndex;
+                                    rPos = lastPos;
+                                    bPos = currPos;
+                                    isoIndex = lastIndex;
+
+                                    lastPos = currPos;
+                                    lastIndex = pIndex;
+                                    segDensity = getSegCluser(rPos);
+                                }
+                            }
+                        }
+                    }
+
+                    if (abs(dp) == 1 || abs(dp) == 4) {
+                        return float4(rPos.x, bPos.x, isoIndex, segDensity);
+                    }
+                    else if (abs(dp) == 2 || abs(dp) == 5) {
+                        return float4(rPos.y, bPos.y, isoIndex, segDensity);
+                    }
+                    else if (abs(dp) == 3 || abs(dp) == 6) {
+                        return float4(rPos.z, bPos.z, isoIndex, segDensity);
+                    }
+                    else {
+                        return float4(1.0f, 1.0f, -1.0f, 0.0f);
+                    }
+                }
+
+                float4 F2B(float dp, RayInfo ray, float zDepthFX, float zDepthFY, float Findex, float noiseVal) {
+    #define MAX_NUM_STEPS 512
+    #define OPACITY_THRESHOLD (1.0 - 1.0 / 255.0)
+
+                    RaymarchInfo raymarchInfo = initRaymarch(ray, MAX_NUM_STEPS);
+
+                    float3 lightDir = normalize(ObjSpaceViewDir(float4(float3(0.0f, 0.0f, 0.0f), 0.0f)));
+
+                    // Create a small random offset in order to remove artifacts
+                    ray.startPos += (2.0f * ray.direction * raymarchInfo.stepSize) * noiseVal;
+
+                    float4 col = float4(0.0f, 0.0f, 0.0f, 0.0f);
+                    float3 rPos, bPos;
+                    int clusterIndex = -1;
+                    float maxAcc = -1.0f;
+
+                    float3 maxPos = float3(-1.0f, -1.0f, -1.0f);
+                    float isoVal;
+                    float minBoundAcc = 0; // init
+                    int pIndex = -1;
+                    int isoIndex;
+                    float3 lastPos;
+                    float lastDensity;
+                    float segDensity;
+                    int lastIndex = -1;
+
+                    for (int iStep = 0; iStep < raymarchInfo.numSteps; iStep++)
+                    {
+                        const float t = iStep * raymarchInfo.numStepsRecip;
+                        const float3 currPos = lerp(ray.startPos, ray.endPos, t);
+
+                        // Get the dansity/sample value of the current position
+                        const float density = getDensity(currPos);
+
+
+                        pIndex = findClusterIndex(density);
+
+                        float4 src = getTF1DColour(density);
+                        // Apply visibility window
+                        if (density < _MinVal || density > _MaxVal) continue;
+
+                        if (abs(dp) == 1 || abs(dp) == 4) {
+                            if ((currPos.x <= zDepthFX) || (currPos.x < zDepthFY && pIndex == Findex)) {
+                                continue;
+                            }
+                        }
+                        else if (abs(dp) == 2 || abs(dp) == 5) {
+                            if ((currPos.y <= zDepthFX) || (currPos.y < zDepthFY && pIndex == Findex)) {
+                                continue;
+                            }
+                        }
+                        else if (abs(dp) == 3 || abs(dp) == 6) {
+                            if ((currPos.z <= zDepthFX) || (currPos.z < zDepthFY && pIndex == Findex)) {
+                                continue;
+                            }
+                        }
+
+                        if (density > _MinVal && density < _MaxVal)
+                        {
+
+                            src.rgb *= src.a;
+                            col = (1.0f - col.a) * src + col;
+                        }
+
+                        if (col.a >= 1.0f)
+                            break;
+
+                        //// Early ray termination
+                        //if (col.a > OPACITY_THRESHOLD) {
+                        //    break;
+                        //}
+
+                        if (clusterIndex == -1) {
+                            maxAcc = max((col.a - minBoundAcc), maxAcc);
+                            maxPos = currPos;
+                            rPos = currPos;
+                            bPos = currPos;
+                            lastDensity = density;
+                            lastPos = currPos;
+                            lastIndex = pIndex;
+                            clusterIndex = pIndex;
+                            minBoundAcc = col.a;
+                            isoIndex = pIndex;
+                            segDensity = getSegCluser(lastPos);
+                            // buffer[0] = float4(clusterIndex, col.a, minBoundAcc, maxAcc);
+                        }
+                        else {
+                            if (clusterIndex != pIndex) {
+
+                                if ((col.a - minBoundAcc) > maxAcc) {
+                                    maxAcc = max((col.a - minBoundAcc), maxAcc);
+                                    minBoundAcc = col.a;
+                                    clusterIndex = pIndex;
+                                    rPos = lastPos;
+                                    bPos = currPos;
+                                    isoIndex = lastIndex;
+
+                                    lastPos = currPos;
+                                    lastIndex = pIndex;
+                                    segDensity = getSegCluser(rPos);
+                                    //buffer[0] = float4(clusterIndex, col.a, minBoundAcc, maxAcc);
+                                }
+                            }
+                        }
+                    }
+
+                    if (abs(dp) == 1) {
+                        return float4(rPos.x, bPos.x, isoIndex, segDensity);
+                    }
+                    else if (abs(dp) == 2) {
+                        return float4(rPos.y, bPos.y, isoIndex, segDensity);
+                    }
+                    else if (abs(dp) == 3) {
+                        return float4(rPos.z, bPos.z, isoIndex, segDensity);
+                    }
+                    else {
+                        return float4(0, 0, -1, 0);
+                    }
+                }
+
+                float4 F2B_Inverse(float dp, RayInfo ray, float zDepthIBX, float zDepthIBY, float Bindex, float noiseVal) {
+    #define MAX_NUM_STEPS 512
+    #define OPACITY_THRESHOLD (1.0 - 1.0 / 255.0)
+
+                    RaymarchInfo raymarchInfo = initRaymarch(ray, MAX_NUM_STEPS);
+
+                    float3 lightDir = normalize(ObjSpaceViewDir(float4(float3(0.0f, 0.0f, 0.0f), 0.0f)));
+
+                    // Create a small random offset in order to remove artifacts
+                    ray.startPos += (2.0f * ray.direction * raymarchInfo.stepSize) * noiseVal;
+
+                    float4 col = float4(0.0f, 0.0f, 0.0f, 0.0f);
+                    float3 rPos, bPos;
+                    int clusterIndex = -1;
+                    float maxAcc = -1.0f;
+
+                    float3 maxPos = float3(-1.0f, -1.0f, -1.0f);
+                    float isoVal;
+                    float minBoundAcc = 0; // init
+                    int pIndex = -1;
+                    int isoIndex;
+                    float3 lastPos;
+                    float lastDensity;
+                    float segDensity;
+                    int lastIndex = -1;
+
+                    for (int iStep = 0; iStep < raymarchInfo.numSteps; iStep++)
+                    {
+                        const float t = iStep * raymarchInfo.numStepsRecip;
+                        const float3 currPos = lerp(ray.startPos, ray.endPos, t);
+
+                        // Get the dansity/sample value of the current position
+                        const float density = getDensity(currPos);
+
+                        pIndex = findClusterIndex(density);
+
+                        float4 src = getTF1DColour(density);
+                        // Apply visibility window
+                        if (density < _MinVal || density > _MaxVal) continue;
+
+                        if (abs(dp) == 1 || abs(dp) == 4) {
+                            if ((((currPos.x >= zDepthIBX)) || (currPos.x > zDepthIBY && pIndex == Bindex))) {
+                                continue;
+                            }
+                        }
+                        else if (abs(dp) == 2 || abs(dp) == 5) {
+                            if ((((currPos.y >= zDepthIBX)) || (currPos.y > zDepthIBY && pIndex == Bindex))) {
+                                continue;
+                            }
+                        }
+                        else if (abs(dp) == 3 || abs(dp) == 6) {
+                            if ((((currPos.z >= zDepthIBX)) || (currPos.z > zDepthIBY && pIndex == Bindex))) {
+                                continue;
+                            }
+                        }
+
+                        if (density > _MinVal && density < _MaxVal)
+                        {
+                            src.rgb *= src.a;
+                            col = (1.0f - col.a) * src + col;
+                        }
+
+                        if (col.a >= 1.0f)
+                            break;
+
+                        //// Early ray termination
+                        //if (col.a > OPACITY_THRESHOLD) {
+                        //    break;
+                        //}
+
+                        if (clusterIndex == -1) {
+                            maxAcc = max((col.a - minBoundAcc), maxAcc);
+                            maxPos = currPos;
+                            rPos = currPos;
+                            bPos = currPos;
+                            lastDensity = density;
+                            lastPos = currPos;
+                            lastIndex = pIndex;
+                            clusterIndex = pIndex;
+                            minBoundAcc = col.a;
+                            isoIndex = pIndex;
+                            segDensity = getSegCluser(lastPos);
+                        }
+                        else {
+                            if (clusterIndex != pIndex) {
+
+                                if ((col.a - minBoundAcc) > maxAcc) {
+                                    maxAcc = max((col.a - minBoundAcc), maxAcc);
+                                    minBoundAcc = col.a;
+                                    clusterIndex = pIndex;
+                                    rPos = lastPos;
+                                    bPos = currPos;
+                                    isoIndex = lastIndex;
+
+                                    lastPos = currPos;
+                                    lastIndex = pIndex;
+                                    segDensity = getSegCluser(rPos);
+                                }
+                            }
+                        }
+                    }
+
+                    if (abs(dp) == 1) {
+                        return float4(rPos.x, bPos.x, isoIndex, segDensity);
+                    }
+                    else if (abs(dp) == 2) {
+                        return float4(rPos.y, bPos.y, isoIndex, segDensity);
+                    }
+                    else if (abs(dp) == 3) {
+                        return float4(rPos.z, bPos.z, isoIndex, segDensity);
+                    }
+                    else {
+                        return float4(1.0f, 1.0f, -1.0f, 0.0f);
+                    }
+                }
+
+                float4 AFF2B(RayInfo ray, float3 r1, float3 r2, float noiseVal) {
+    #define MAX_NUM_STEPS 512
+    #define OPACITY_THRESHOLD (1.0 - 1.0 / 255.0)
+
+                    RaymarchInfo raymarchInfo = initRaymarch(ray, MAX_NUM_STEPS);
+
+                    float3 lightDir = normalize(ObjSpaceViewDir(float4(float3(0.0f, 0.0f, 0.0f), 0.0f)));
+
+                    // Create a small random offset in order to remove artifacts
+                    ray.startPos += (2.0f * ray.direction * raymarchInfo.stepSize) * noiseVal;
+
+                    float4 col = float4(0.0f, 0.0f, 0.0f, 0.0f);
+                    float3 rPos, bPos;
+                    int clusterIndex = -1;
+                    float maxAcc = -1.0f;
+
+                    float3 maxPos = float3(-1.0f, -1.0f, -1.0f);
+                    float isoVal;
+                    float minBoundAcc = 0; // init
+                    int pIndex = -1;
+                    int isoIndex;
+                    float3 lastPos;
+                    float lastDensity;
+                    float segDensity;
+                    int lastIndex = -1;
+
+                    for (int iStep = 0; iStep < raymarchInfo.numSteps; iStep++)
+                    {
+                        const float t = iStep * raymarchInfo.numStepsRecip;
+                        const float3 currPos = lerp(ray.startPos, ray.endPos, t);
+
+                        // Get the dansity/sample value of the current position
+                        const float density = getDensity(currPos);
+                        if (density < _MinVal || density > _MaxVal) continue;
+                        pIndex = findClusterIndex(density);
+
+                        float4 src = getTF1DColour(density);
+
+                        bool inside = false;
+
+                        for (int j = 0; j < _WidgetNums - 1; j++) {
+                            if (!(sdCylinder(currPos, r1, r2, _CircleSize[j], _RotateMatrix[j]))) {
+                                float2 visIsoRange = findIsoRange((int)buffer[j].z);
+                                if ((density >= visIsoRange.x && density <= visIsoRange.y)) {
+                                    const float segDensity1 = getSegCluser(currPos);
+                                    if (round(segDensity1) == buffer[j].w) {
+                                        inside = true;
+                                    }
+                                }
+                            }
+                        }
+
+                        if (inside) continue;
+
+                        // Apply visibility window
+                        if (density < _MinVal || density > _MaxVal) continue;
+
+                        if (density > _MinVal && density < _MaxVal)
+                        {
+                            src.rgb *= src.a;
+                            col = (1.0f - col.a) * src + col;
+                        }
+
+                        if (col.a >= 1.0f)
+                            break;
+
+
+                        if (clusterIndex == -1) {
+                            maxAcc = max((col.a - minBoundAcc), maxAcc);
+                            maxPos = currPos;
+                            rPos = currPos;
+                            bPos = currPos;
+                            lastDensity = density;
+                            lastPos = currPos;
+                            lastIndex = pIndex;
+                            clusterIndex = pIndex;
+                            minBoundAcc = col.a;
+                            isoIndex = pIndex;
+                            segDensity = getSegCluser(lastPos);
+                        }
+                        else {
+                            if (clusterIndex != pIndex) {
+
+                                if ((col.a - minBoundAcc) > maxAcc) {
+                                    maxAcc = max((col.a - minBoundAcc), maxAcc);
+                                    minBoundAcc = col.a;
+                                    clusterIndex = pIndex;
+                                    rPos = lastPos;
+                                    bPos = currPos;
+                                    isoIndex = lastIndex;
+
+                                    lastPos = currPos;
+                                    lastIndex = pIndex;
+                                    segDensity = getSegCluser(rPos);
+                                }
+                            }
+                        }
+                    }
+
+                    return float4(rPos.x, rPos.y, isoIndex, rPos.z);
+                }
+
+
+                // Direct Volume Rendering
+                frag_out frag_dvr(frag_in i)
+                {
+                    #define MAX_NUM_STEPS 512
+                    #define OPACITY_THRESHOLD (1.0 - 1.0 / 255.0)
+
+    #ifdef DVR_BACKWARD_ON
+                    RayInfo ray = getRayBack2Front(i.vertexLocal, 0);
+    #else
+                    RayInfo ray = getRayFront2Back(i.vertexLocal, 0);
+    #endif
+                    RaymarchInfo raymarchInfo = initRaymarch(ray, MAX_NUM_STEPS);
+
+                    float3 lightDir = normalize(ObjSpaceViewDir(float4(float3(0.0f, 0.0f, 0.0f), 0.0f)));
+
+                    // Create a small random offset in order to remove artifacts
+                    float noiseVal = tex2D(_NoiseTex, float2(i.uv.x, i.uv.y)).r;
+                    ray.startPos += (2.0f * ray.direction * raymarchInfo.stepSize) * noiseVal;
+
+                    float4 col = float4(0.0f, 0.0f, 0.0f, 0.0f);
+    #ifdef DVR_BACKWARD_ON
+                    float tDepth = 0.0f;
+    #else
+                    float tDepth = raymarchInfo.numStepsRecip * (raymarchInfo.numSteps - 1);
+    #endif
+                    for (int iStep = 0; iStep < raymarchInfo.numSteps; iStep++)
+                    {
+                        const float t = iStep * raymarchInfo.numStepsRecip;
+                        const float3 currPos = lerp(ray.startPos, ray.endPos, t);
+
+    #if MOUSEDOWN_ON
+    #if DiggingWidget
+                        float3 minDep = float3(0.0f, 0.0f, -2.0f), minDepY = float3(0.0f, 0.0f, -2.0f), minDepZ = float3(0.0f, 0.0f, -2.0f);
+                        float3 maxDep = float3(1.0f, 1.0f, -2.0f), maxDepY = float3(1.0f, 1.0f, -2.0f), maxDepZ = float3(1.0f, 1.0f, -2.0f);
+                        int pIndex = -1;
+                        float zDepth = 0.0f;
+                        float zDepthInverse = 1.0f;
+                        float zDepthFX = 0.0f, zDepthFY = 0.0f;
+                        float Findex = -1.0f;
+                        float zDepthBX = 1.0f, zDepthBY = 1.0f;
+                        float Bindex = -1.0f;
+                        bool isMask = false;
+                        pIndex = findClusterIndex(getDensity(currPos));
+                        float dp = 0.0f;
+                        for (uint jStep = 0; jStep < _WidgetNums; jStep++) {
+
+                            float3 r1 = float3(_WidgetPos[jStep].x, _WidgetPos[jStep].y, _WidgetPos[jStep].z);// -0.215 // _WidgetPos[jStep].z
+                            float3 r2 = float3(_WidgetPos[jStep].x, _WidgetPos[jStep].y, _WidgetPos[jStep].z + (-(_WidgetPos[jStep].z)) * 2); // 0.215 //         
+
+                            bool insideLens = false;
+                            if (_LensIndexs[jStep] == 0.1f) { // Cylinder
+                                insideLens = sdCylinder(currPos, r1, r2, _CircleSize[jStep], _RotateMatrix[jStep]);
+                            }
+                            else if (_LensIndexs[jStep] == 0.2f) { // Box
+                                insideLens = sdBox(currPos, float3((_CircleSize[jStep] - 0.01f) / 2, (_CircleSize[jStep] - 0.01f) / 2, 0.5f), _RotateMatrix[jStep], float3(_WidgetPos[jStep].x, _WidgetPos[jStep].y, 0.0f), ((_CircleSize[jStep] - 0.01f) / 2));
+                            }
+                            else if (_LensIndexs[jStep] == 0.3f) { // Vesica
+                                insideLens = sdVesica(currPos, float3(_WidgetPos[jStep].x, _WidgetPos[jStep].y, 0.0f), 0.5f, r2.z - r1.z, _CircleSize[jStep], _RotateMatrix[jStep]);
+                            }
+
+                            if (insideLens) {
+
+                                float4 visData = float4(0.0f, 0.0f, -2.0f, 0.0f);
+                                float4 visDataInverse = float4(1.0f, 1.0f, -2.0f, 0.0f);
+                                if (_depthNP > 0) {
+                                    if (_WidgetRecorder[jStep].z > 0) {
+
+                                        for (uint dStep = 0; dStep < _WidgetRecorder[jStep].z; dStep++) {
+                                            visData = F2B(_localDepth, getRayFront2Back(i.vertexLocal, 0), zDepthFX, zDepthFY, Findex, noiseVal);
+                                            if (_WidgetPos[jStep].w == 1) {
+                                                minDep = visData;
+                                            }
+                                            else if (_WidgetPos[jStep].w == 2) {
+                                                minDepY = visData;
+                                            }
+                                            else if (_WidgetPos[jStep].w == 3) {
+                                                minDepZ = visData;
+                                            }
+                                            zDepthFX = visData.x;
+                                            zDepthFY = visData.y;
+                                            Findex = visData.z;
+                                        }
+                                    }
+
+                                    if (_WidgetRecorder[jStep].w > 0) {
+
+                                        for (uint dStep = 0; dStep < _WidgetRecorder[jStep].w; dStep++) {
+                                            visDataInverse = B2F_Inverse(_localDepth, getRayBack2Front(i.vertexLocal, 0), zDepthBX, zDepthBY, Bindex, noiseVal);
+                                            if (_WidgetPos[jStep].w == 1) {
+                                                maxDep = visDataInverse;
+                                            }
+                                            else if (_WidgetPos[jStep].w == 2) {
+                                                maxDepY = visDataInverse;
+                                            }
+                                            else if (_WidgetPos[jStep].w == 3) {
+                                                maxDepZ = visDataInverse;
+                                            }
+                                            zDepthBX = visDataInverse.x;
+                                            zDepthBY = visDataInverse.y;
+                                            Bindex = visDataInverse.z;
+                                        }
+                                    }
+                                }
+                                else {
+                                    if (_WidgetRecorder[jStep].z > 0) {
+
+                                        for (uint dStep = 0; dStep < _WidgetRecorder[jStep].z; dStep++) {
+                                            visData = B2F(_localDepth, getRayBack2Front(i.vertexLocal, 0), zDepthFX, zDepthFY, Findex, noiseVal);
+                                            if (_WidgetPos[jStep].w == 1) {
+                                                minDep = visData;
+                                            }
+                                            else if (_WidgetPos[jStep].w == 2) {
+                                                minDepY = visData;
+                                            }
+                                            else if (_WidgetPos[jStep].w == 3) {
+                                                minDepZ = visData;
+                                            }
+                                            zDepthFX = visData.x;
+                                            zDepthFY = visData.y;
+                                            Findex = visData.z;
+                                        }
+                                    }
+
+                                    if (_WidgetRecorder[jStep].w > 0) {
+
+                                        for (uint dStep = 0; dStep < _WidgetRecorder[jStep].w; dStep++) {
+                                            visDataInverse = F2B_Inverse(_localDepth, getRayFront2Back(i.vertexLocal, 0), zDepthBX, zDepthBY, Bindex, noiseVal);
+                                            if (_WidgetPos[jStep].w == 1) {
+                                                maxDep = visDataInverse;
+                                            }
+                                            else if (_WidgetPos[jStep].w == 2) {
+                                                maxDepY = visDataInverse;
+                                            }
+                                            else if (_WidgetPos[jStep].w == 3) {
+                                                maxDepZ = visDataInverse;
+                                            }
+                                            zDepthBX = visDataInverse.x;
+                                            zDepthBY = visDataInverse.y;
+                                            Bindex = visDataInverse.z;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+
+                        if ((currPos.x <= minDep.x) || (currPos.x < 1.0f && pIndex == minDep.z)) {
+                            isMask = true;
+                        }
+                        if ((((currPos.x >= maxDep.x)) || (currPos.x > 0.0f && pIndex == maxDep.z))) {
+                            isMask = true;
+                        }
+
+                        if ((currPos.y <= minDepY.x) || (currPos.y < 1.0f && pIndex == minDepY.z)) {
+                            isMask = true;
+                        }
+                        if ((((currPos.y >= maxDepY.x)) || (currPos.y > 0.0f && pIndex == maxDepY.z))) {
+                            isMask = true;
+                        }
+
+                        if ((currPos.z <= minDepZ.x) || (currPos.z < 1.0f && pIndex == minDepZ.z)) {
+                            isMask = true;
+                        }
+                        if ((((currPos.z >= maxDepZ.x)) || (currPos.z > 0.0f && pIndex == maxDepZ.z))) {
+                            isMask = true;
+                        }
+
+                        if (!(isMask)) {
+                            continue;
+                        }
+
+    #elif ErasingWidget
+                        bool isInside = false;
+                        float sameIsoSeg = -1.0f;
+
+                        if (_WidgetNums == 0) {
+                            for (int s = 0; s < 10; s++) {
+                                buffer[s] = float4(0, 0, 0, 0);
+                            }
+                        }
+
+                        for (uint jStep = 0; jStep < _WidgetNums; jStep++) {
+
+                            float3 r1 = float3(_WidgetPos[jStep].x, _WidgetPos[jStep].y, _WidgetPos[jStep].z);
+                            float3 r2 = float3(_WidgetPos[jStep].x, _WidgetPos[jStep].y, _WidgetPos[jStep].z + (-(_WidgetPos[jStep].z)) * 2);
+                            float2 selectCindex;
+
+                            if (buffer[jStep].x == 0) {
+
+                                if ((sdCylinder(currPos, r1, r2, 0.0005f, _RotateMatrix[jStep]))) {
+                                    float4 visData = float4(0.0f, 0.0f, -2.0f, 0.0f);
+                                    float4 visDataInverse = float4(1.0f, 1.0f, -2.0f, 0.0f);
+
+                                    if (_WidgetRecorder[jStep].z > 0) {
+                                        for (uint dStep = 0; dStep < _WidgetRecorder[jStep].z; dStep++) {
+                                            visData = AFF2B(getRayFront2Back(i.vertexLocal, 0), r1, r2, noiseVal);
+                                            selectCindex = float2(visData.z, round(getSegCluser(float3(visData.x, visData.y, visData.w))));
+                                        }
+                                    }
+                                    if (_WidgetRecorder[jStep].w > 0) {
+                                        for (uint dStep = 0; dStep < _WidgetRecorder[jStep].w; dStep++) {
+                                            visDataInverse = AFF2B(getRayFront2Back(i.vertexLocal, 0), r1, r2, noiseVal);
+                                            selectCindex = float2(visDataInverse.z, round(getSegCluser(float3(visDataInverse.x, visDataInverse.y, visDataInverse.w))));
+                                        }
+                                    }
+
+                                    if (jStep == _WidgetNums - 1) {
+                                        if (buffer[jStep].x == 0) {
+                                            buffer[jStep] = max(buffer[jStep], float4(1, 0, selectCindex.x, selectCindex.y));
+                                        }
+                                    }
+                                }
+
+                            }
+                            const float density1 = getDensity(currPos);
+                            if (!(sdCylinder(currPos, r1, r2, _CircleSize[jStep], _RotateMatrix[jStep]))) {
+
+                                float2 visIsoRange = findIsoRange((int)buffer[jStep].z);
+                                if ((density1 >= visIsoRange.x && density1 <= visIsoRange.y)) {
+                                    const float segDensity = getSegCluser(currPos);
+                                    if (round(segDensity) == buffer[jStep].w) {
+                                        isInside = true;
+                                    }
+                                }
+                            }
+                        }
+
+                        if (isInside) continue;
+    #endif
+    #else
+
+    #endif
+
+
+                        // Perform slice culling (cross section plane)
+    #ifdef CUTOUT_ON
+                        if (IsCutout(currPos))
+                            continue;
+    #endif
+
+                        // Get the dansity/sample value of the current position
+                        const float density = getDensity(currPos);
+
+                        // Apply visibility window
+                        if (density < _MinVal || density > _MaxVal) continue;
+
+                        // Calculate gradient (needed for lighting and 2D transfer functions)
+    #if defined(TF2D_ON) || defined(LIGHTING_ON)
+                        float3 gradient = getGradient(currPos);
+    #endif
+
+                        // Apply transfer function
+    #if TF2D_ON
+                        float mag = length(gradient) / 1.75f;
+                        float4 src = getTF2DColour(density, mag);
+    #else
+                        float4 src = getTF1DColour(density);
+    #endif
+
+                        // Apply lighting
+    #if defined(LIGHTING_ON) && defined(DVR_BACKWARD_ON)
+                        src.rgb = calculateLighting(src.rgb, normalize(gradient), lightDir, ray.direction, 0.3f);
+    #elif defined(LIGHTING_ON)
+                        src.rgb = calculateLighting(src.rgb, normalize(gradient), lightDir, -ray.direction, 0.3f);
+    #endif
+
+    #ifdef DVR_BACKWARD_ON
+                        col.rgb = src.a * src.rgb + (1.0f - src.a) * col.rgb;
+                        col.a = src.a + (1.0f - src.a) * col.a;
+
+                        // Optimisation: A branchless version of: if (src.a > 0.15f) tDepth = t;
+                        tDepth = max(tDepth, t * step(0.15, src.a));
+    #else
+                        src.rgb *= src.a;
+                        col = (1.0f - col.a) * src + col;
+
+                        if (col.a > 0.15 && t < tDepth) {
+                            tDepth = t;
+                        }
+    #endif
+
+                        // Early ray termination
+    #if !defined(DVR_BACKWARD_ON) && defined(RAY_TERMINATE_ON)
+                        if (col.a > OPACITY_THRESHOLD) {
+                            break;
+                        }
+    #endif
+                    }
+
+                    // Write fragment output
+                    frag_out output;
+                    output.colour = col;
+    #if DEPTHWRITE_ON
+                    tDepth += (step(col.a, 0.0) * 1000.0); // Write large depth if no hit
+                    const float3 depthPos = lerp(ray.startPos, ray.endPos, tDepth) - float3(0.5f, 0.5f, 0.5f);
+                    output.depth = localToDepth(depthPos);
+    #endif
+                    return output;
+                }
+                //
+                //            // Maximum Intensity Projection mode
+                //            frag_out frag_mip(frag_in i)
+                //            {
+                //                #define MAX_NUM_STEPS 512
+                //
+                //                RayInfo ray = getRayBack2Front(i.vertexLocal);
+                //                RaymarchInfo raymarchInfo = initRaymarch(ray, MAX_NUM_STEPS);
+                //
+                //                float maxDensity = 0.0f;
+                //                float3 maxDensityPos = ray.startPos;
+                //                for (int iStep = 0; iStep < raymarchInfo.numSteps; iStep++)
+                //                {
+                //                    const float t = iStep * raymarchInfo.numStepsRecip;
+                //                    const float3 currPos = lerp(ray.startPos, ray.endPos, t);
+                //                    
+                //#ifdef CUTOUT_ON
+                //                    if (IsCutout(currPos))
+                //                        continue;
+                //#endif
+                //
+                //                    const float density = getDensity(currPos);
+                //                    if (density > maxDensity && density > _MinVal && density < _MaxVal)
+                //                    {
+                //                        maxDensity = density;
+                //                        maxDensityPos = currPos;
+                //                    }
+                //                }
+                //
+                //                // Write fragment output
+                //                frag_out output;
+                //                output.colour = float4(1.0f, 1.0f, 1.0f, maxDensity); // maximum intensity
+                //#if DEPTHWRITE_ON
+                //                output.depth = localToDepth(maxDensityPos - float3(0.5f, 0.5f, 0.5f));
+                //#endif
+                //                return output;
+                //            }
+
+                //            // Surface rendering mode
+                //            // Draws the first point (closest to camera) with a density within the user-defined thresholds.
+                //            frag_out frag_surf(frag_in i)
+                //            {
+                //                #define MAX_NUM_STEPS 1024
+                //
+                //                RayInfo ray = getRayFront2Back(i.vertexLocal);
+                //                RaymarchInfo raymarchInfo = initRaymarch(ray, MAX_NUM_STEPS);
+                //
+                //                // Create a small random offset in order to remove artifacts
+                //                ray.startPos = ray.startPos + (2.0f * ray.direction * raymarchInfo.stepSize) * tex2D(_NoiseTex, float2(i.uv.x, i.uv.y)).r;
+                //
+                //                float4 col = float4(0,0,0,0);
+                //                for (int iStep = 0; iStep < raymarchInfo.numSteps; iStep++)
+                //                {
+                //                    const float t = iStep * raymarchInfo.numStepsRecip;
+                //                    const float3 currPos = lerp(ray.startPos, ray.endPos, t);
+                //                    
+                //#ifdef CUTOUT_ON
+                //                    if (IsCutout(currPos))
+                //                        continue;
+                //#endif
+                //
+                //                    const float density = getDensity(currPos);
+                //                    if (density > _MinVal && density < _MaxVal)
+                //                    {
+                //                        float3 normal = normalize(getGradient(currPos));
+                //                        col = getTF1DColour(density);
+                //                        col.rgb = calculateLighting(col.rgb, normal, -ray.direction, -ray.direction, 0.15);
+                //                        col.a = 1.0f;
+                //                        break;
+                //                    }
+                //                }
+                //
+                //                // Write fragment output
+                //                frag_out output;
+                //                output.colour = col;
+                //#if DEPTHWRITE_ON
+                //                
+                //                const float tDepth = iStep * raymarchInfo.numStepsRecip + (step(col.a, 0.0) * 1000.0); // Write large depth if no hit
+                //                output.depth = localToDepth(lerp(ray.startPos, ray.endPos, tDepth) - float3(0.5f, 0.5f, 0.5f));
+                //#endif
+                //                return output;
+                //            }
+
+                            frag_in vert(vert_in v)
+                            {
+                                return vert_main(v);
+                            }
+
+                            frag_out frag(frag_in i)
+                            {
+                #if MODE_DVR
+                                return frag_dvr(i);
+                                //#elif MODE_MIP
+                                //                return frag_mip(i);
+                                //#elif MODE_SURF
+                                //                return frag_surf(i);
+                                #endif
+                                            }
+
+                                            ENDCG
+                                        }
+        }
+}
diff --git a/Assets/Shaders/DirectVolumeRenderingShader_Mask.shader.meta b/Assets/Shaders/DirectVolumeRenderingShader_Mask.shader.meta
new file mode 100644
index 00000000..21a31b1f
--- /dev/null
+++ b/Assets/Shaders/DirectVolumeRenderingShader_Mask.shader.meta
@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: a20d4a69f209bf64ea10de5efd333aa5
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: