Add Compute Shader by Pema:

- Add compute shader to offload the expensive bounding box finder
  - The compute shader was created by Pema Malling! ( https://github.com/pema99/ )
- Add shader to just draw the highlight using an input rectangle
- Add Compute Shader toggle (default on)

Author: hai-vr

Assets/Hai/BlendshapeViewer/Scripts/Editor/BlendshapeViewerDiffCompute.cs

@@ -0,0 +1,60 @@
+/*
+Copyright 2022 Pema Malling
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+using System.Linq;
+using UnityEditor;
+using UnityEngine;
+
+namespace Hai.BlendshapeViewer.Scripts.Editor
+{
+    public class BlendshapeViewerDiffCompute
+    {
+        private readonly ComputeShader _computeShader;
+
+        public BlendshapeViewerDiffCompute()
+        {
+            _computeShader = FindComputeShader();
+        }
+
+        public Vector4 Compute(Texture2D textureA, Texture2D textureB)
+        {
+            var results = new int[4];
+            var buf = new ComputeBuffer(4, sizeof(int));
+            buf.SetData(results);
+            var computeShader = _computeShader;
+
+            var csMain = computeShader.FindKernel("DiffCompute");
+
+            computeShader.SetTexture(csMain, "InputA", textureA);
+            computeShader.SetTexture(csMain, "InputB", textureB);
+            computeShader.SetBuffer(csMain, "ResultBuffer", buf);
+
+            computeShader.Dispatch(csMain, textureA.width / 8, textureB.height / 8, 1);
+
+            buf.GetData(results);
+            return new Vector4(results[0], results[1], results[2], results[3]);
+        }
+
+        private static ComputeShader FindComputeShader()
+        {
+            var assetPathOrEmpty = AssetDatabase.GUIDToAssetPath("569e5a4e6b0efc74b93a42db6d069724");
+            var defaultPath = "Assets/Hai/BlendshapeViewer/Scripts/Editor/DiffCompute.compute";
+            var computeShader = AssetDatabase.LoadAssetAtPath<ComputeShader>(assetPathOrEmpty == "" ? defaultPath : assetPathOrEmpty)
+                                ?? FindAmongAllComputeShaders();
+            return computeShader;
+        }
+
+        private static ComputeShader FindAmongAllComputeShaders()
+        {
+            return Resources.FindObjectsOfTypeAll<ComputeShader>()
+                .First(o => o.name.Contains("DiffCompute"));
+        }
+    }
+}

Assets/Hai/BlendshapeViewer/Scripts/Editor/BlendshapeViewerDiffCompute.cs.meta

@@ -13,6 +13,7 @@ public class BlendshapeViewerEditorWindow : EditorWindow
         public bool autoUpdateOnFocus = true;
         public int thumbnailSize = 100;
         public bool showHotspots;
+        public bool useComputeShader = true;
         public Texture2D[] tex2ds = new Texture2D[0];
         private Vector2 _scrollPos;
         private SkinnedMeshRenderer _generatedFor;
@@ -52,7 +53,13 @@ private void OnGUI()
                 EditorGUILayout.PropertyField(serializedObject.FindProperty(nameof(showHotspots)));
             }
             EditorGUILayout.EndHorizontal();
+            EditorGUILayout.BeginHorizontal();
             EditorGUILayout.PropertyField(serializedObject.FindProperty(nameof(autoUpdateOnFocus)));
+            if (SystemInfo.supportsComputeShaders)
+            {
+                EditorGUILayout.PropertyField(serializedObject.FindProperty(nameof(useComputeShader)));
+            }
+            EditorGUILayout.EndHorizontal();
             EditorGUILayout.IntSlider(serializedObject.FindProperty(nameof(thumbnailSize)), 100, 300);
 
             EditorGUI.BeginDisabledGroup(skinnedMesh == null || AnimationMode.InAnimationMode());
@@ -156,7 +163,7 @@ private void Generate()
             var module = new BlendshapeViewerGenerator();
             try
             {
-                module.Begin(skinnedMesh, showHotspots ? 0.95f : 0);
+                module.Begin(skinnedMesh, showHotspots ? 0.95f : 0, useComputeShader);
                 Texture2D neutralTexture = null;
                 if (showDifferences)
                 {

Assets/Hai/BlendshapeViewer/Scripts/Editor/BlendshapeViewerEditorWindow.cs

@@ -7,14 +7,18 @@ public class BlendshapeViewerGenerator
     {
         private Material _material;
         private SkinnedMeshRenderer _skinnedMesh;
+        private bool _useComputeShader;
         private Camera _camera;
         private float _overlay;
+        private BlendshapeViewerDiffCompute _diffCompute;
 
-        public void Begin(SkinnedMeshRenderer skinnedMesh, float overlay)
+        public void Begin(SkinnedMeshRenderer skinnedMesh, float overlay, bool useComputeShader)
         {
             _skinnedMesh = skinnedMesh;
             _overlay = overlay;
-            _material = new Material(Shader.Find("Hai/BlendshapeViewer"));
+            _useComputeShader = SystemInfo.supportsComputeShaders && useComputeShader;
+
+            _material = new Material(_useComputeShader ? Shader.Find("Hai/BlendshapeViewerRectOnly") : Shader.Find("Hai/BlendshapeViewer"));
             _material.SetFloat("_Hotspots", _overlay);
             _camera = new GameObject().AddComponent<Camera>();
 
@@ -27,6 +31,11 @@ public void Begin(SkinnedMeshRenderer skinnedMesh, float overlay)
             _camera.nearClipPlane = sceneCamera.nearClipPlane;
             _camera.farClipPlane = sceneCamera.farClipPlane;
             _camera.orthographicSize = sceneCamera.orthographicSize;
+
+            if (_useComputeShader)
+            {
+                _diffCompute = new BlendshapeViewerDiffCompute();
+            }
         }
 
         public void Terminate()
@@ -86,6 +95,10 @@ public void Diff(Texture2D source, Texture2D neutralTexture, Texture2D newTextur
         {
             var diff = RenderTexture.GetTemporary(newTexture.width, newTexture.height, 24);
             _material.SetTexture("_NeutralTex", neutralTexture);
+            if (_useComputeShader)
+            {
+                _material.SetVector("_Rect", _diffCompute.Compute(source, neutralTexture));
+            }
             Graphics.Blit(source, diff, _material);
             RenderTextureTo(diff, newTexture);
             RenderTexture.ReleaseTemporary(diff);

Assets/Hai/BlendshapeViewer/Scripts/Editor/BlendshapeViewerGenerator.cs

@@ -0,0 +1,40 @@
+/*
+Copyright 2022 Pema Malling
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#pragma kernel DiffCompute
+
+Texture2D<float4> InputA;
+Texture2D<float4> InputB;
+RWStructuredBuffer<int> ResultBuffer; // [minX, minY, maxX, maxY]
+
+[numthreads(8,8,1)]
+void DiffCompute (uint3 id : SV_DispatchThreadID)
+{
+    float3 diff = InputA[id.xy].xyz - InputB[id.xy].xyz;
+    if (dot(diff, diff) > 0.01)
+    {
+        // handle first occurrence, this branch needs to be here because stupid compiler
+        if (ResultBuffer[0] == 0)
+        {
+            InterlockedCompareStore(ResultBuffer[0], 0, id.x);
+            InterlockedCompareStore(ResultBuffer[1], 0, id.y);
+            InterlockedCompareStore(ResultBuffer[2], 0, id.x);
+            InterlockedCompareStore(ResultBuffer[3], 0, id.y);
+        }
+
+        // calc AABB points
+        {
+            InterlockedMin(ResultBuffer[0], id.x);
+            InterlockedMin(ResultBuffer[1], id.y);
+            InterlockedMax(ResultBuffer[2], id.x);
+            InterlockedMax(ResultBuffer[3], id.y);
+        }
+    }
+}

Assets/Hai/BlendshapeViewer/Scripts/Editor/DiffCompute.compute

@@ -0,0 +1,78 @@
+Shader "Hai/BlendshapeViewerRectOnly"
+{
+    Properties
+    {
+        _MainTex ("Morphed Texture", 2D) = "white" {}
+        _NeutralTex ("Neutral Texture", 2D) = "white" {}
+        _Hotspots ("Hotspots", Range(0, 1)) = 0
+        _Rect ("Rect", Vector) = (0, 0, 0, 0)
+    }
+    SubShader
+    {
+        Tags { "RenderType"="Opaque" }
+        LOD 100
+
+        Pass
+        {
+            CGPROGRAM
+            #pragma vertex vert
+            #pragma fragment frag
+
+            #include "UnityCG.cginc"
+
+            struct appdata
+            {
+                float4 vertex : POSITION;
+                float2 uv : TEXCOORD0;
+            };
+
+            struct v2f
+            {
+                float2 uv : TEXCOORD0;
+                UNITY_FOG_COORDS(1)
+                float4 vertex : SV_POSITION;
+            };
+
+            sampler2D _MainTex;
+            float4 _MainTex_ST;
+            float4 _MainTex_TexelSize;
+
+            sampler2D _NeutralTex;
+            float4 _NeutralTex_ST;
+
+            float _Hotspots;
+            float4 _Rect;
+
+            v2f vert (appdata v)
+            {
+                v2f o;
+                o.vertex = UnityObjectToClipPos(v.vertex);
+                o.uv = TRANSFORM_TEX(v.uv, _MainTex);
+
+                return o;
+            }
+
+            fixed4 frag (v2f i) : SV_Target
+            {
+                float width = _MainTex_TexelSize.z;
+                float height = _MainTex_TexelSize.w;
+
+                float4 difference = _Rect;
+                difference = difference + float4(-1, -1, 1, 1) * 2; // Margin
+
+                fixed4 col = tex2D(_MainTex, i.uv);
+                if (i.uv.x < difference.x / width || i.uv.x > difference.z / width
+                    || i.uv.y < difference.y / height || i.uv.y > difference.w / height) {
+                        col.xyz = col.xyz * 0.2;
+                }
+                if (_Hotspots > 0.01) {
+                    fixed3 neutral = tex2D(_NeutralTex, i.uv).xyz;
+                    fixed3 morphed = tex2D(_MainTex, i.uv).xyz;
+                    col = lerp(col, length(neutral - morphed) * float4(1, 0, 0, 1), _Hotspots);
+                }
+                return col;
+            }
+            ENDCG
+        }
+    }
+}