com.github.asus4.texture-source 0.3.2 → 0.3.4

package/README.md

@@ -57,7 +57,7 @@ Add the following setting to `Packages/manifest.json`
     }
   ],
   "dependencies": {
-    "com.github.asus4.texture-source": "0.3.1",
+    "com.github.asus4.texture-source": "0.3.3",
     ...// other dependencies
   }
 }

package/Runtime/ARFoundationDepthTextureSource.cs

@@ -82,6 +82,21 @@ namespace TextureSource
 
         private void OnOcclusionFrameReceived(AROcclusionFrameEventArgs args)
         {
+#if MODULE_ARFOUNDATION_6_1_ENABLED
+            var textures = args.externalTextures;
+            if (textures.Count == 0)
+            {
+                return;
+            }
+
+            var keywords = args.shaderKeywords;
+            SetMaterialKeywords(material, keywords.enabledKeywords, keywords.disabledKeywords);
+
+            foreach(var exTex in textures)
+            {
+                material.SetTexture(exTex.propertyId, exTex.texture);
+            }
+#else
             if (args.textures.Count == 0)
             {
                 return;
@@ -95,6 +110,7 @@ namespace TextureSource
                 var tex = args.textures[i];
                 material.SetTexture(args.propertyNameIds[i], tex);
             }
+#endif // MODULE_ARFOUNDATION_6_1_ENABLED
         }
     }
 }

package/Runtime/ARFoundationTextureSource.cs

@@ -137,7 +137,7 @@ namespace TextureSource
             lastUpdatedFrame = Time.frameCount;
         }
 
-        protected static void SetMaterialKeywords(Material material, List<string> enabledKeywords, List<string> disabledKeywords)
+        protected static void SetMaterialKeywords(Material material, IReadOnlyList<string> enabledKeywords, IReadOnlyList<string> disabledKeywords)
         {
             if (enabledKeywords != null)
             {

package/Runtime/TextureSource.asmdef

@@ -2,7 +2,9 @@
     "name": "TextureSource",
     "rootNamespace": "",
     "references": [
-        "GUID:a9420e37d7990b54abdef6688edbe313"
+        "GUID:a9420e37d7990b54abdef6688edbe313",
+        "GUID:92703082f92b41ba80f0d6912de66115",
+        "GUID:dc960734dc080426fa6612f1c5fe95f3"
     ],
     "includePlatforms": [],
     "excludePlatforms": [],
@@ -16,6 +18,11 @@
             "name": "com.unity.xr.arfoundation",
             "expression": "4.0.0",
             "define": "MODULE_ARFOUNDATION_ENABLED"
+        },
+        {
+            "name": "com.unity.xr.arfoundation",
+            "expression": "6.1.0",
+            "define": "MODULE_ARFOUNDATION_6_1_ENABLED"
         }
     ],
     "noEngineReferences": false

package/Shaders/ARCoreBackgroundDepth.shader

@@ -6,9 +6,13 @@
         _EnvironmentDepth("Texture", 2D) = "black" {}
     }
 
+    /////////////////////////////////////////////////////////////////////////////////////////////////
+    // GLSL shader for OpenGLES 3. GLES3 cannot use HLSL shader like Vulkan because of dependency on
+    // GL_OES_EGL_image_external_essl3 extension. Thus they are kept in different subshaders.
+    /////////////////////////////////////////////////////////////////////////////////////////////////
     SubShader
     {
-        Name "ARCore Background (Before Opaques)"
+        Name "ARCore Background (Before Opaques) for GLES3"
         Tags
         {
             "Queue" = "Background"
@@ -31,22 +35,28 @@
 
             GLSLPROGRAM
 
-            #pragma multi_compile_local __ ARCORE_ENVIRONMENT_DEPTH_ENABLED
-            #pragma multi_compile_local __ TEXTURE_SOURCE_RAW_DISTANCE
-
             #pragma only_renderers gles3
 
+            #pragma multi_compile_local __ ARCORE_ENVIRONMENT_DEPTH_ENABLED
+            #pragma multi_compile_local __ ARCORE_IMAGE_STABILIZATION_ENABLED
+
             #include "UnityCG.glslinc"
 
 #ifdef SHADER_API_GLES3
 #extension GL_OES_EGL_image_external_essl3 : require
 #endif // SHADER_API_GLES3
 
+#ifndef ARCORE_IMAGE_STABILIZATION_ENABLED
+#define ARCORE_TEXCOORD_TYPE vec2
+#else // ARCORE_IMAGE_STABILIZATION_ENABLED
+#define ARCORE_TEXCOORD_TYPE vec3
+#endif // !ARCORE_IMAGE_STABILIZATION_ENABLED
+
             // Device display transform is provided by the AR Foundation camera background renderer.
             uniform mat4 _UnityDisplayTransform;
 
 #ifdef VERTEX
-            varying vec2 textureCoord;
+            varying ARCORE_TEXCOORD_TYPE textureCoord;
 
             void main()
             {
@@ -54,14 +64,22 @@
                 // Transform the position from object space to clip space.
                 gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
 
+#ifdef ARCORE_IMAGE_STABILIZATION_ENABLED
+                textureCoord = gl_MultiTexCoord0.xyz;
+#else
                 // Remap the texture coordinates based on the device rotation.
-                textureCoord = (_UnityDisplayTransform * vec4(gl_MultiTexCoord0.x, 1.0f - gl_MultiTexCoord0.y, 1.0f, 0.0f)).xy;
+                // _UnityDisplayTransform is provided as "Row Major" for all mobile platforms, so use the
+                // 'Row Vector * Matrix' operator. The GLSL '*' operator is overloaded to use a row vector
+                // when a matrix is left-multiplied by a vector. Refer to this doc for more information:
+                // https://en.wikibooks.org/wiki/GLSL_Programming/Vector_and_Matrix_Operations#Operators
+                textureCoord = (vec4(gl_MultiTexCoord0.x, gl_MultiTexCoord0.y, 1.0f, 0.0f) * _UnityDisplayTransform).xy;
+#endif
 #endif // SHADER_API_GLES3
             }
 #endif // VERTEX
 
 #ifdef FRAGMENT
-            varying vec2 textureCoord;
+            varying ARCORE_TEXCOORD_TYPE textureCoord;
             uniform samplerExternalOES _MainTex;
             uniform float _UnityCameraForwardScale;
 
@@ -70,17 +88,17 @@
 #endif // ARCORE_ENVIRONMENT_DEPTH_ENABLED
 
 #if defined(SHADER_API_GLES3) && !defined(UNITY_COLORSPACE_GAMMA)
-            float GammaToLinearSpaceExact (float value)
+            float GammaToLinearSpaceExact(float value)
             {
                 if (value <= 0.04045F)
                     return value / 12.92F;
                 else if (value < 1.0F)
-                    return pow((value + 0.055F)/1.055F, 2.4F);
+                    return pow((value + 0.055F) / 1.055F, 2.4F);
                 else
                     return pow(value, 2.2F);
             }
 
-            vec3 GammaToLinearSpace (vec3 sRGB)
+            vec3 GammaToLinearSpace(vec3 sRGB)
             {
                 // Approximate version from http://chilliant.blogspot.com.au/2012/08/srgb-approximations-for-hlsl.html?m=1
                 return sRGB * (sRGB * (sRGB * 0.305306011F + 0.682171111F) + 0.012522878F);
@@ -88,7 +106,6 @@
                 // Precise version, useful for debugging, but the pow() function is too slow.
                 // return vec3(GammaToLinearSpaceExact(sRGB.r), GammaToLinearSpaceExact(sRGB.g), GammaToLinearSpaceExact(sRGB.b));
             }
-
 #endif // SHADER_API_GLES3 && !UNITY_COLORSPACE_GAMMA
 
             float ConvertDistanceToDepth(float d)
@@ -111,11 +128,16 @@
             void main()
             {
 #ifdef SHADER_API_GLES3
-                vec3 result = texture(_MainTex, textureCoord).xyz;
+#ifdef ARCORE_IMAGE_STABILIZATION_ENABLED
+                vec2 tc = textureCoord.xy / textureCoord.z;
+#else
+                vec2 tc = textureCoord;
+#endif
+                vec3 result = texture(_MainTex, tc).xyz;
                 float depth = 1.0;
 
 #ifdef ARCORE_ENVIRONMENT_DEPTH_ENABLED
-                float distance = texture(_EnvironmentDepth, textureCoord).x;
+                float distance = texture(_EnvironmentDepth, tc).x;
                 depth = ConvertDistanceToDepth(distance);
 #endif // ARCORE_ENVIRONMENT_DEPTH_ENABLED
 
@@ -134,5 +156,154 @@
         }
     }
 
+    /////////////////////////////////////////////////////////////////////////////////////////////
+    // HLSL shader for Vulkan. It should be kept the same with GLES3 except for the syntax diff.
+    /////////////////////////////////////////////////////////////////////////////////////////////
+    SubShader
+    {
+        Name "ARCore Background (Before Opaques) for Vulkan"
+        Tags
+        {
+            "Queue" = "Background"
+            "RenderType" = "Background"
+            "ForceNoShadowCasting" = "True"
+        }
+
+        Pass
+        {
+            Name "AR Camera Background (ARCore)"
+            Cull Off
+            ZTest Always
+            ZWrite On
+            Lighting Off
+            LOD 100
+            Tags
+            {
+                "LightMode" = "Always"
+            }
+
+            HLSLPROGRAM
+
+            #pragma only_renderers vulkan
+
+            #pragma multi_compile_local __ ARCORE_ENVIRONMENT_DEPTH_ENABLED
+            #pragma multi_compile_local __ ARCORE_IMAGE_STABILIZATION_ENABLED
+
+            #include "UnityCG.cginc"
+
+            #pragma vertex vert
+            #pragma fragment frag
+
+#ifndef ARCORE_IMAGE_STABILIZATION_ENABLED
+#define ARCORE_TEXCOORD_TYPE float2
+#else // ARCORE_IMAGE_STABILIZATION_ENABLED
+#define ARCORE_TEXCOORD_TYPE float3
+#endif // !ARCORE_IMAGE_STABILIZATION_ENABLED
+
+            // Device display transform is provided by the AR Foundation camera background renderer.
+            float4x4 _UnityDisplayTransform;
+
+            struct vertexInput
+            {
+                float4 vertex : POSITION;
+                float3 uv : TEXCOORD0;
+            };
+
+            struct v2f
+            {
+                float4 position : SV_POSITION;
+                ARCORE_TEXCOORD_TYPE textureCoord : TEXCOORD0;
+            };
+
+            v2f vert(vertexInput i)
+            {
+                v2f o;
+
+                // Transform the position from object space to clip space.
+                o.position = UnityObjectToClipPos(i.vertex.xyz);
+
+#ifdef ARCORE_IMAGE_STABILIZATION_ENABLED
+                o.textureCoord = i.uv.xyz;
+#else
+                // Remap the texture coordinates based on the device rotation.
+                // _UnityDisplayTransform is provided as "Row Major" for all mobile platforms, so use the
+                // 'Row Vector * Matrix' operator. In HLSL, with mul(x, y) if x is a vector, it treated
+                // as a row vector. For more information:
+                // https://learn.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-mul
+                o.textureCoord = mul(float4(i.uv.x, i.uv.y, 1.0f, 0.0f), _UnityDisplayTransform).xy;
+#endif
+                return o;
+            }
+
+            sampler2D _MainTex;
+            float _UnityCameraForwardScale;
+
+#ifdef ARCORE_ENVIRONMENT_DEPTH_ENABLED
+            sampler2D _EnvironmentDepth;
+#endif // ARCORE_ENVIRONMENT_DEPTH_ENABLED
+
+#ifndef UNITY_COLORSPACE_GAMMA
+            float3 GammaToLinearSpace(float3 sRGB)
+            {
+                // Approximate version from http://chilliant.blogspot.com.au/2012/08/srgb-approximations-for-hlsl.html?m=1
+                return sRGB * (sRGB * (sRGB * 0.305306011F + 0.682171111F) + 0.012522878F);
+            }
+#endif // !UNITY_COLORSPACE_GAMMA
+
+            float ConvertDistanceToDepth(float d)
+            {
+#if TEXTURE_SOURCE_RAW_DISTANCE
+                return d;
+#else
+                d = _UnityCameraForwardScale > 0.0 ? _UnityCameraForwardScale * d : d;
+
+                float zBufferParamsW = 1.0 / _ProjectionParams.y;
+                float zBufferParamsY = _ProjectionParams.z * zBufferParamsW;
+                float zBufferParamsX = 1.0 - zBufferParamsY;
+                float zBufferParamsZ = zBufferParamsX * _ProjectionParams.w;
+
+                // Clip any distances smaller than the near clip plane, and compute the depth value from the distance.
+                return (d < _ProjectionParams.y) ? 1.0f : ((1.0 / zBufferParamsZ) * ((1.0 / d) - zBufferParamsW));
+#endif // TEXTURE_SOURCE_RAW_DISTANCE
+            }
+
+            struct fragOutput
+            {
+                float4 color : SV_Target;
+                float depth : SV_Depth;
+            };
+
+            fragOutput frag(v2f i)
+            {
+#ifdef ARCORE_IMAGE_STABILIZATION_ENABLED
+                float2 tc = i.textureCoord.xy / i.textureCoord.z;
+#else
+                float2 tc = i.textureCoord;
+#endif
+                float3 result = tex2D(_MainTex, tc).xyz;
+                float depth = 1.0;
+
+#ifdef ARCORE_ENVIRONMENT_DEPTH_ENABLED
+                float distance = tex2D(_EnvironmentDepth, tc).x;
+                depth = ConvertDistanceToDepth(distance);
+#endif // ARCORE_ENVIRONMENT_DEPTH_ENABLED
+
+#ifndef UNITY_COLORSPACE_GAMMA
+                result = GammaToLinearSpace(result);
+#endif // !UNITY_COLORSPACE_GAMMA
+
+                fragOutput o;
+
+                // o.color = float4(result, 1.0);
+                o.color = float4(result, depth);
+                o.depth = 1.0 - depth; // Unity Vulkan uses reverse Z.
+
+                return o;
+            }
+
+            ENDHLSL
+        }
+    }
+
     FallBack Off
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.github.asus4.texture-source",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "displayName": "TextureSource",
   "description": "Simplify WebCamera and test video handling for using Computer Vision in Unity",
   "unity": "2020.3",