Merge pull request mlavik1#94 from vahpy/dvr-optimisation

mlavik1 · web-flow · commit e5fc73a7022a · 2022-04-06T11:35:55.000+02:00
Front-to-Back Direct Volume Rendering + Minor Performance Optimisation
diff --git a/Assets/Editor/VolumeRenderedObjectCustomInspector.cs b/Assets/Editor/VolumeRenderedObjectCustomInspector.cs
@@ -6,6 +6,7 @@ namespace UnityVolumeRendering
     [CustomEditor(typeof(VolumeRenderedObject))]
     public class VolumeRenderedObjectCustomInspector : Editor
     {
+        bool otherSettings = false;
         public override void OnInspectorGUI()
         {
             VolumeRenderedObject volrendObj = (VolumeRenderedObject)target;
@@ -36,11 +37,29 @@ public override void OnInspectorGUI()
             // Show TF button
             if (GUILayout.Button("Edit transfer function"))
             {
-                if(tfMode == TFRenderMode.TF1D)
+                if (tfMode == TFRenderMode.TF1D)
                     TransferFunctionEditorWindow.ShowWindow();
                 else
                     TransferFunction2DEditorWindow.ShowWindow();
             }
+
+            // Other settings for direct volume rendering
+            if (volrendObj.GetRenderMode() == RenderMode.DirectVolumeRendering)
+            {
+                GUILayout.Space(10);
+                otherSettings = EditorGUILayout.Foldout(otherSettings, "Other Settings");
+                if (otherSettings)
+                {
+                    // Temporary back-to-front rendering option
+                    volrendObj.SetDVRBackwardEnabled(GUILayout.Toggle(volrendObj.GetDVRBackwardEnabled(), "Enable Back-to-Front Direct Volume Rendering"));
+
+                    // Early ray termination for Front-to-back DVR
+                    if (!volrendObj.GetDVRBackwardEnabled())
+                    {
+                        volrendObj.SetRayTerminationEnabled(GUILayout.Toggle(volrendObj.GetRayTerminationEnabled(), "Enable early ray termination"));
+                    }
+                }
+            }
         }
     }
 }
diff --git a/Assets/Scripts/VolumeObject/VolumeRenderedObject.cs b/Assets/Scripts/VolumeObject/VolumeRenderedObject.cs
@@ -23,6 +23,9 @@ public class VolumeRenderedObject : MonoBehaviour
 
         private Vector2 visibilityWindow = new Vector2(0.0f, 1.0f);
 
+        private bool rayTerminationEnabled = true;
+        private bool dvrBackward = true;
+
         public SlicingPlane CreateSlicingPlane()
         {
             GameObject sliceRenderingPlane = GameObject.Instantiate(Resources.Load<GameObject>("SlicingPlane"));
@@ -43,22 +46,22 @@ public SlicingPlane CreateSlicingPlane()
 
         public void SetRenderMode(RenderMode mode)
         {
-            if(renderMode != mode)
+            if (renderMode != mode)
             {
                 renderMode = mode;
                 SetVisibilityWindow(0.0f, 1.0f); // reset visibility window
             }
-            UpdateMaaterialProperties();
+            UpdateMaterialProperties();
         }
 
         public void SetTransferFunctionMode(TFRenderMode mode)
         {
             tfRenderMode = mode;
             if (tfRenderMode == TFRenderMode.TF1D && transferFunction != null)
                 transferFunction.GenerateTexture();
-            else if(transferFunction2D != null)
+            else if (transferFunction2D != null)
                 transferFunction2D.GenerateTexture();
-            UpdateMaaterialProperties();
+            UpdateMaterialProperties();
         }
 
         public TFRenderMode GetTransferFunctionMode()
@@ -81,7 +84,7 @@ public void SetLightingEnabled(bool enable)
             if (enable != lightingEnabled)
             {
                 lightingEnabled = enable;
-                UpdateMaaterialProperties();
+                UpdateMaterialProperties();
             }
         }
 
@@ -95,7 +98,7 @@ public void SetVisibilityWindow(Vector2 window)
             if (window != visibilityWindow)
             {
                 visibilityWindow = window;
-                UpdateMaaterialProperties();
+                UpdateMaterialProperties();
             }
         }
 
@@ -104,12 +107,40 @@ public Vector2 GetVisibilityWindow()
             return visibilityWindow;
         }
 
-        private void UpdateMaaterialProperties()
+        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();
+            }
+        }
+
+        private void UpdateMaterialProperties()
         {
             bool useGradientTexture = tfRenderMode == TFRenderMode.TF2D || renderMode == RenderMode.IsosurfaceRendering || lightingEnabled;
             meshRenderer.sharedMaterial.SetTexture("_GradientTex", useGradientTexture ? dataset.GetGradientTexture() : null);
 
-            if(tfRenderMode == TFRenderMode.TF2D)
+            if (tfRenderMode == TFRenderMode.TF2D)
             {
                 meshRenderer.sharedMaterial.SetTexture("_TFTex", transferFunction2D.GetTexture());
                 meshRenderer.sharedMaterial.EnableKeyword("TF2D_ON");
@@ -120,7 +151,7 @@ private void UpdateMaaterialProperties()
                 meshRenderer.sharedMaterial.DisableKeyword("TF2D_ON");
             }
 
-            if(lightingEnabled)
+            if (lightingEnabled)
                 meshRenderer.sharedMaterial.EnableKeyword("LIGHTING_ON");
             else
                 meshRenderer.sharedMaterial.DisableKeyword("LIGHTING_ON");
@@ -152,11 +183,29 @@ private void UpdateMaaterialProperties()
 
             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()
         {
-            UpdateMaaterialProperties();
+            UpdateMaterialProperties();
         }
     }
 }
diff --git a/Assets/Shaders/DirectVolumeRenderingShader.shader b/Assets/Shaders/DirectVolumeRenderingShader.shader
@@ -26,6 +26,8 @@
             #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
 
@@ -233,8 +235,13 @@
             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);
+#else
+                RayInfo ray = getRayFront2Back(i.vertexLocal);
+#endif
                 RaymarchInfo raymarchInfo = initRaymarch(ray, MAX_NUM_STEPS);
 
                 float3 lightDir = normalize(ObjSpaceViewDir(float4(float3(0.0f, 0.0f, 0.0f), 0.0f)));
@@ -243,7 +250,11 @@
                 ray.startPos += (2.0f * ray.direction * raymarchInfo.stepSize) * tex2D(_NoiseTex, float2(i.uv.x, i.uv.y)).r;
 
                 float4 col = float4(0.0f, 0.0f, 0.0f, 0.0f);
-                float tDepth = 0.0;
+#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;
@@ -258,6 +269,9 @@
                     // 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);
@@ -272,18 +286,33 @@
 #endif
 
                     // Apply lighting
-#ifdef LIGHTING_ON
+#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
 
-                    // Optimisation: A branchless version of: if (density < _MinVal || density > _MaxVal) src.a = 0.0f;
-                    src.a *= step(_MinVal, density) * step(density, _MaxVal);
-
-                    col.rgb = src.a * src.rgb + (1.0f - src.a)*col.rgb;
-                    col.a = src.a + (1.0f - src.a)*col.a;
+#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 (src.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
diff --git a/CREDITS.md b/CREDITS.md
@@ -12,5 +12,7 @@ Image sequence import. Other contributions.
 GUI for modifying slicing plane positiomn/orientation.
 - [btsai-dev](https://github.com/btsai-dev)
 Memory leak fix
+- [Vahid](https://github.com/vahpy)
+Texture downscaling, optimisation.
 
 Feel free to add yourself to this list when contributing to this project.

Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,7 @@ namespace UnityVolumeRendering`
`6`	`6`	`[CustomEditor(typeof(VolumeRenderedObject))]`
`7`	`7`	`public class VolumeRenderedObjectCustomInspector : Editor`
`8`	`8`	`{`
	`9`	`+ bool otherSettings = false;`
`9`	`10`	`public override void OnInspectorGUI()`
`10`	`11`	`{`
`11`	`12`	`VolumeRenderedObject volrendObj = (VolumeRenderedObject)target;`
`@@ -36,11 +37,29 @@ public override void OnInspectorGUI()`
`36`	`37`	`// Show TF button`
`37`	`38`	`if (GUILayout.Button("Edit transfer function"))`
`38`	`39`	`{`
`39`		`- if(tfMode == TFRenderMode.TF1D)`
	`40`	`+ if (tfMode == TFRenderMode.TF1D)`
`40`	`41`	`TransferFunctionEditorWindow.ShowWindow();`
`41`	`42`	`else`
`42`	`43`	`TransferFunction2DEditorWindow.ShowWindow();`
`43`	`44`	`}`
	`45`	`+`
	`46`	`+ // Other settings for direct volume rendering`
	`47`	`+ if (volrendObj.GetRenderMode() == RenderMode.DirectVolumeRendering)`
	`48`	`+ {`
	`49`	`+ GUILayout.Space(10);`
	`50`	`+ otherSettings = EditorGUILayout.Foldout(otherSettings, "Other Settings");`
	`51`	`+ if (otherSettings)`
	`52`	`+ {`
	`53`	`+ // Temporary back-to-front rendering option`
	`54`	`+ volrendObj.SetDVRBackwardEnabled(GUILayout.Toggle(volrendObj.GetDVRBackwardEnabled(), "Enable Back-to-Front Direct Volume Rendering"));`
	`55`	`+`
	`56`	`+ // Early ray termination for Front-to-back DVR`
	`57`	`+ if (!volrendObj.GetDVRBackwardEnabled())`
	`58`	`+ {`
	`59`	`+ volrendObj.SetRayTerminationEnabled(GUILayout.Toggle(volrendObj.GetRayTerminationEnabled(), "Enable early ray termination"));`
	`60`	`+ }`
	`61`	`+ }`
	`62`	`+ }`
`44`	`63`	`}`
`45`	`64`	`}`
`46`	`65`	`}`