com.github.asus4.texture-source 0.2.2 → 0.3.1

package/README.md

@@ -57,7 +57,7 @@ Add the following setting to `Packages/manifest.json`
     }
   ],
   "dependencies": {
-    "com.github.asus4.texture-source": "0.2.2",
+    "com.github.asus4.texture-source": "0.3.1",
     ...// other dependencies
   }
 }
@@ -87,6 +87,14 @@ Useful when using test videos only in the Editor.
 
 ![video-texture-source](https://github.com/asus4/TextureSource/assets/357497/8e38ed1a-d2d8-4e16-9fc4-e5d4c6d0a888)
 
+### Image Texture Source
+
+Test with static images.
+
+`OnTexture` event is invoked every frame if the `sendContinuousUpdate` is enabled.
+
+![image-texture-source](https://github.com/asus4/TextureSource/assets/357497/3d7eef4b-40c5-40b4-8403-b70f394ce938)
+
 ### AR Foundation Texture Source
 
 Provides AR camera texture access. It supports both ARCore/ARKit.

package/Runtime/ARFoundationDepthTextureSource.cs

@@ -0,0 +1,101 @@
+// Only available with AR Foundation
+#if MODULE_ARFOUNDATION_ENABLED
+namespace TextureSource
+{
+    using System.Collections;
+    using System.Collections.Generic;
+    using UnityEngine;
+    using UnityEngine.XR.ARFoundation;
+
+    /// <summary>
+    /// The same with ARFoundationTextureSource but depth is encoded into alpha channel
+    /// (Experimental feature, only available with the latest AR Foundation)
+    /// </summary>
+    [CreateAssetMenu(menuName = "ScriptableObject/Texture Source/ARFoundation Depth", fileName = "ARFoundationDepthTextureSource")]
+    public sealed class ARFoundationDepthTextureSource : ARFoundationTextureSource
+    {
+        public enum DepthMode
+        {
+            Depth01,
+            RawDistance,
+        }
+
+        [SerializeField]
+        private DepthMode depthMode = DepthMode.Depth01;
+
+        // [HideInInspector]
+        [SerializeField]
+        private Shader shaderForARCore;
+        // [HideInInspector]
+        [SerializeField]
+        private Shader shaderForARKit;
+
+        private AROcclusionManager occlusionManager;
+
+        protected override RenderTextureFormat PreferredRenderTextureFormat => RenderTextureFormat.ARGBHalf;
+
+        protected override Shader ARCameraBackgroundShader
+        {
+            get
+            {
+                return Application.platform switch
+                {
+                    RuntimePlatform.Android => shaderForARCore,
+                    RuntimePlatform.IPhonePlayer => shaderForARKit,
+#if UNITY_ANDROID
+                    _ => shaderForARCore,
+#elif UNITY_IOS
+                    _ => shaderForARKit,
+#else
+                    _ => throw new NotSupportedException($"ARFoundationTextureSource is not supported on {Application.platform}"),
+#endif
+                };
+            }
+        }
+
+        public override void Start()
+        {
+            occlusionManager = FindAnyObjectByType<AROcclusionManager>();
+            if (occlusionManager == null)
+            {
+                throw new System.InvalidOperationException("Requires AROcclusionManager to use ARFoundationDepthTextureSource");
+            }
+            occlusionManager.frameReceived += OnOcclusionFrameReceived;
+
+            base.Start();
+
+            if (depthMode == DepthMode.RawDistance)
+            {
+                material.EnableKeyword("TEXTURE_SOURCE_RAW_DISTANCE");
+            }
+        }
+
+        public override void Stop()
+        {
+            if (occlusionManager != null)
+            {
+                occlusionManager.frameReceived -= OnOcclusionFrameReceived;
+            }
+
+            base.Stop();
+        }
+
+        private void OnOcclusionFrameReceived(AROcclusionFrameEventArgs args)
+        {
+            if (args.textures.Count == 0)
+            {
+                return;
+            }
+
+            SetMaterialKeywords(material, args.enabledMaterialKeywords, args.disabledMaterialKeywords);
+
+            int count = args.textures.Count;
+            for (int i = 0; i < count; i++)
+            {
+                var tex = args.textures[i];
+                material.SetTexture(args.propertyNameIds[i], tex);
+            }
+        }
+    }
+}
+#endif // MODULE_ARFOUNDATION_ENABLED

package/Runtime/ARFoundationDepthTextureSource.cs.meta

@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: e468045a73ccc46f1afb6f48292c11b1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences:
+  - shaderForARKit: {fileID: 4800000, guid: c8b0b30194e1b4026abc942f037e6f86, type: 3}
+  - shaderForARCore: {fileID: 4800000, guid: a68a981b98d2c47b881e7e696a7b0f1f, type: 3}
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/{ARCameraBackgroundTextureSource.cs → ARFoundationTextureSource.cs}

@@ -3,38 +3,48 @@
 namespace TextureSource
 {
     using System;
+    using System.Collections.Generic;
     using UnityEngine;
     using UnityEngine.XR.ARFoundation;
 
+    /// <summary>
+    /// Source from ARFoundation
+    /// </summary>
     [CreateAssetMenu(menuName = "ScriptableObject/Texture Source/ARFoundation", fileName = "ARFoundationTextureSource")]
-    public sealed class ARFoundationTextureSource : BaseTextureSource
+    public class ARFoundationTextureSource : BaseTextureSource
     {
         private static readonly int _DisplayTransformID = Shader.PropertyToID("_UnityDisplayTransform");
 
         private ARCameraManager cameraManager;
         private RenderTexture texture;
-        private Material material;
         private int lastUpdatedFrame = -1;
 
-        private static readonly Lazy<Shader> ARCameraBackgroundShader = new(() =>
+        protected Material material;
+
+        public override bool DidUpdateThisFrame => lastUpdatedFrame == Time.frameCount;
+        public override Texture Texture => texture;
+
+        protected virtual RenderTextureFormat PreferredRenderTextureFormat => RenderTextureFormat.ARGB32;
+
+        protected virtual Shader ARCameraBackgroundShader
         {
-            string shaderName = Application.platform switch
+            get
             {
-                RuntimePlatform.Android => "Unlit/ARCoreBackground",
-                RuntimePlatform.IPhonePlayer => "Unlit/ARKitBackground",
+                string shaderName = Application.platform switch
+                {
+                    RuntimePlatform.Android => "Unlit/ARCoreBackground",
+                    RuntimePlatform.IPhonePlayer => "Unlit/ARKitBackground",
 #if UNITY_ANDROID
-                _ => "Unlit/ARCoreBackground",
+                    _ => "Unlit/ARCoreBackground",
 #elif UNITY_IOS
-                _ => "Unlit/ARKitBackground",
+                    _ => "Unlit/ARKitBackground",
 #else
-                _ => throw new NotSupportedException($"ARFoundationTextureSource is not supported on {Application.platform}"),
+                    _ => throw new NotSupportedException($"ARFoundationTextureSource is not supported on {Application.platform}"),
 #endif
-            };
-            return Shader.Find(shaderName);
-        });
-
-        public override bool DidUpdateThisFrame => lastUpdatedFrame == Time.frameCount;
-        public override Texture Texture => texture;
+                };
+                return Shader.Find(shaderName);
+            }
+        }
 
         public override void Start()
         {
@@ -43,9 +53,7 @@ namespace TextureSource
             {
                 throw new InvalidOperationException("ARCameraManager is not found");
             }
-
-            var shader = ARCameraBackgroundShader.Value;
-            material = new Material(shader);
+            material = new Material(ARCameraBackgroundShader);
 
             cameraManager.frameReceived += OnFrameReceived;
         }
@@ -86,8 +94,12 @@ namespace TextureSource
             };
         }
 
+
         private void OnFrameReceived(ARCameraFrameEventArgs args)
         {
+            // The shader doesn't work for some reason when set ARKIT_BACKGROUND_URP 
+            // SetMaterialKeywords(material, args.enabledMaterialKeywords, args.disabledMaterialKeywords);
+
             // Find best texture size
             int bestWidth = 0;
             int bestHeight = 0;
@@ -109,11 +121,11 @@ namespace TextureSource
 
             // Create render texture
             Utils.GetTargetSizeScale(
-               new Vector2Int(bestWidth, bestHeight), screenAspect,
-                out Vector2Int dstSize, out Vector2 scale);
-            EnsureRenderTexture(dstSize.x, dstSize.y);
-
-            // SetMaterialKeywords(material, args.enabledMaterialKeywords, args.disabledMaterialKeywords);
+                new Vector2Int(bestWidth, bestHeight),
+                screenAspect,
+                out Vector2Int dstSize,
+                out Vector2 scale);
+            EnsureRenderTexture(ref texture, dstSize.x, dstSize.y, 24, PreferredRenderTextureFormat);
 
             if (args.displayMatrix.HasValue)
             {
@@ -125,17 +137,35 @@ namespace TextureSource
             lastUpdatedFrame = Time.frameCount;
         }
 
-        private void EnsureRenderTexture(int width, int height)
+        protected static void SetMaterialKeywords(Material material, List<string> enabledKeywords, List<string> disabledKeywords)
+        {
+            if (enabledKeywords != null)
+            {
+                foreach (var keyword in enabledKeywords)
+                {
+                    material.EnableKeyword(keyword);
+                }
+            }
+            if (disabledKeywords != null)
+            {
+                foreach (var keyword in disabledKeywords)
+                {
+                    material.DisableKeyword(keyword);
+                }
+            }
+        }
+
+        public static void EnsureRenderTexture(ref RenderTexture texture,
+            int width, int height,
+            int depth, RenderTextureFormat format)
         {
             if (texture == null || texture.width != width || texture.height != height)
             {
                 if (texture != null)
                 {
                     texture.Release();
-                    texture = null;
                 }
-                int depth = 32;
-                texture = new RenderTexture(width, height, depth, RenderTextureFormat.ARGB32);
+                texture = new RenderTexture(width, height, depth, format);
                 texture.Create();
             }
         }

package/Runtime/BaseTextureSource.cs

@@ -2,6 +2,9 @@ namespace TextureSource
 {
     using UnityEngine;
 
+    /// <summary>
+    /// Abstract class for the source.
+    /// </summary>
     public abstract class BaseTextureSource : ScriptableObject, ITextureSource
     {
         public abstract bool DidUpdateThisFrame { get; }

package/Runtime/ITextureSource.cs

@@ -2,6 +2,9 @@ namespace TextureSource
 {
     using UnityEngine;
 
+    /// <summary>
+    /// Interface for the source
+    /// </summary>
     public interface ITextureSource
     {
         bool DidUpdateThisFrame { get; }

package/Runtime/ImageTextureSource.cs

@@ -0,0 +1,58 @@
+namespace TextureSource
+{
+    using UnityEngine;
+
+    /// <summary>
+    /// Source from image texture
+    /// </summary>
+    [CreateAssetMenu(menuName = "ScriptableObject/Texture Source/Image", fileName = "ImageTextureSource")]
+    public class ImageTextureSource : BaseTextureSource
+    {
+        [SerializeField]
+        private Texture[] textures = default;
+
+        [SerializeField]
+        private bool sendContinuousUpdate = false;
+
+        public override bool DidUpdateThisFrame
+        {
+            get
+            {
+                if (sendContinuousUpdate)
+                {
+                    return true;
+                }
+
+                bool updated = isUpdated;
+                isUpdated = false;
+                return updated;
+            }
+        }
+
+        public override Texture Texture => textures[currentIndex];
+
+        private int currentIndex = 0;
+        private bool isUpdated = false;
+
+        public override void Start()
+        {
+            if (textures.Length == 0)
+            {
+                Debug.LogError("No texture is set");
+                return;
+            }
+            isUpdated = true;
+        }
+
+        public override void Stop()
+        {
+            isUpdated = false;
+        }
+
+        public override void Next()
+        {
+            currentIndex = (currentIndex + 1) % textures.Length;
+            isUpdated = true;
+        }
+    }
+}

package/Runtime/ImageTextureSource.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b51cafa6a901147349bf2af15e41f6a5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/TextureTransformer.cs

@@ -3,6 +3,9 @@ namespace TextureSource
     using System;
     using UnityEngine;
 
+    /// <summary>
+    /// Transforms 2D texture with any arbitrary matrix
+    /// </summary>
     public class TextureTransformer : IDisposable
     {
         private static readonly int _InputTex = Shader.PropertyToID("_InputTex");
@@ -24,7 +27,7 @@ namespace TextureSource
 
         public RenderTexture Texture => texture;
 
-        public TextureTransformer(int width, int height, ComputeShader shader = null)
+        public TextureTransformer(int width, int height, RenderTextureFormat format, ComputeShader shader = null)
         {
             compute = shader != null
                 ? shader
@@ -34,7 +37,7 @@ namespace TextureSource
             this.width = width;
             this.height = height;
 
-            var desc = new RenderTextureDescriptor(width, height, RenderTextureFormat.ARGB32)
+            var desc = new RenderTextureDescriptor(width, height, format)
             {
                 enableRandomWrite = true,
                 useMipMap = false,

package/Runtime/Utils.cs

@@ -2,6 +2,9 @@ namespace TextureSource
 {
     using UnityEngine;
 
+    /// <summary>
+    /// Internal utility functions
+    /// </summary>
     internal static class Utils
     {
         public static void GetTargetSizeScale(

package/Runtime/VideoTextureSource.cs

@@ -4,6 +4,9 @@ namespace TextureSource
     using UnityEngine;
     using UnityEngine.Video;
 
+    /// <summary>
+    /// Source from video player
+    /// </summary>
     [CreateAssetMenu(menuName = "ScriptableObject/Texture Source/Video", fileName = "VideoTextureSource")]
     public class VideoTextureSource : BaseTextureSource
     {

package/Runtime/VirtualTextureSource.cs

@@ -5,7 +5,7 @@ namespace TextureSource
     using UnityEngine.Scripting;
 
     /// <summary>
-    /// Virtual Texture Source
+    /// Invokes texture update event from the provided texture source ScriptableObject asset.
     /// </summary>
     public class VirtualTextureSource : MonoBehaviour
     {
@@ -118,7 +118,11 @@ namespace TextureSource
             if (needInitialize)
             {
                 transformer?.Dispose();
-                transformer = new TextureTransformer(dstSize.x, dstSize.y);
+                // Copy the format if the source is a RenderTexture
+                RenderTextureFormat format = (texture is RenderTexture renderTex)
+                    ? renderTex.format :
+                    RenderTextureFormat.ARGB32;
+                transformer = new TextureTransformer(dstSize.x, dstSize.y, format);
             }
 
             return transformer.Transform(texture, Vector2.zero, 0, scale);

package/Runtime/WebCamTextureSource.cs

@@ -4,30 +4,32 @@ namespace TextureSource
     using System.Linq;
     using UnityEngine;
 
+    /// <summary>
+    /// Source from WebCamTexture
+    /// </summary>
     [CreateAssetMenu(menuName = "ScriptableObject/Texture Source/WebCam", fileName = "WebCamTextureSource")]
     public sealed class WebCamTextureSource : BaseTextureSource
     {
-        [Flags]
-        public enum WebCamKindFlag
+        /// <summary>
+        /// Facing direction of the camera
+        /// </summary>
+        public enum CameraFacing
         {
-            WideAngle = 1 << 0,
-            Telephoto = 1 << 1,
-            ColorAndDepth = 1 << 2,
-            UltraWideAngle = 1 << 3,
-        }
-
-        [Flags]
-        public enum FacingFlag
-        {
-            Front = 1 << 0,
-            Back = 1 << 1,
+            Front,
+            Back,
         }
 
         [SerializeField]
-        private WebCamKindFlag kindFilter = WebCamKindFlag.WideAngle | WebCamKindFlag.Telephoto | WebCamKindFlag.UltraWideAngle;
+        [Tooltip("Priorities of Camera Facing Direction")]
+        private CameraFacing[] facingPriorities = new CameraFacing[] {
+            CameraFacing.Back, CameraFacing.Front
+        };
 
         [SerializeField]
-        private FacingFlag facingFilter = FacingFlag.Front | FacingFlag.Back;
+        [Tooltip("Priorities of WebCamKind")]
+        private WebCamKind[] kindPriority = new WebCamKind[] {
+            WebCamKind.WideAngle, WebCamKind.Telephoto, WebCamKind.UltraWideAngle,
+        };
 
         [SerializeField]
         private Vector2Int resolution = new Vector2Int(1270, 720);
@@ -57,16 +59,16 @@ namespace TextureSource
         private int lastUpdatedFrame = -1;
         private bool isFrontFacing;
 
-        public WebCamKindFlag KindFilter
+        public CameraFacing[] FacingPriorities
         {
-            get => kindFilter;
-            set => kindFilter = value;
+            get => facingPriorities;
+            set => facingPriorities = value;
         }
 
-        public FacingFlag FacingFilter
+        public WebCamKind[] KindPriorities
         {
-            get => facingFilter;
-            set => facingFilter = value;
+            get => kindPriority;
+            set => kindPriority = value;
         }
 
         public Vector2Int Resolution
@@ -85,7 +87,24 @@ namespace TextureSource
 
         public override void Start()
         {
-            devices = WebCamTexture.devices.Where(IsMatchFilter).ToArray();
+            static CameraFacing GetFacing(WebCamDevice device)
+            {
+                return device.isFrontFacing ? CameraFacing.Front : CameraFacing.Back;
+            }
+
+            // Sort with facing, then kind
+            devices = WebCamTexture.devices
+                .Where(d => facingPriorities.Contains(GetFacing(d)) && kindPriority.Contains(d.kind))
+                .OrderBy(d => Array.IndexOf(facingPriorities, GetFacing(d)))
+                .ThenBy(d => Array.IndexOf(kindPriority, d.kind))
+                .ToArray();
+
+            if (devices.Length == 0)
+            {
+                Debug.LogError("No available camera found for the given priorities. Falling back to the default.");
+                devices = WebCamTexture.devices;
+            }
+
             StartCamera(currentIndex);
         }
 
@@ -140,7 +159,7 @@ namespace TextureSource
             if (needInitialize)
             {
                 transformer?.Dispose();
-                transformer = new TextureTransformer(width, height);
+                transformer = new TextureTransformer(width, height, RenderTextureFormat.ARGB32);
             }
 
             Vector2 scale;
@@ -159,23 +178,5 @@ namespace TextureSource
             lastUpdatedFrame = Time.frameCount;
             return transformer.Texture;
         }
-
-        private bool IsMatchFilter(WebCamDevice device)
-        {
-            WebCamKindFlag kind = device.kind switch
-            {
-                WebCamKind.WideAngle => WebCamKindFlag.WideAngle,
-                WebCamKind.Telephoto => WebCamKindFlag.Telephoto,
-                WebCamKind.ColorAndDepth => WebCamKindFlag.ColorAndDepth,
-                WebCamKind.UltraWideAngle => WebCamKindFlag.UltraWideAngle,
-                _ => throw new NotImplementedException($"Unknown WebCamKind: {device.kind}"),
-            };
-            FacingFlag facing = device.isFrontFacing
-                ? FacingFlag.Front
-                : FacingFlag.Back;
-
-            return kindFilter.HasFlag(kind)
-                && facingFilter.HasFlag(facing);
-        }
     }
 }

package/Shaders/ARCoreBackgroundDepth.shader

@@ -0,0 +1,138 @@
+Shader "Unlit/TextureSource/ARCoreBackgroundDepth"
+{
+    Properties
+    {
+        _MainTex("Texture", 2D) = "white" {}
+        _EnvironmentDepth("Texture", 2D) = "black" {}
+    }
+
+    SubShader
+    {
+        Name "ARCore Background (Before Opaques)"
+        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"
+            }
+
+            GLSLPROGRAM
+
+            #pragma multi_compile_local __ ARCORE_ENVIRONMENT_DEPTH_ENABLED
+            #pragma multi_compile_local __ TEXTURE_SOURCE_RAW_DISTANCE
+
+            #pragma only_renderers gles3
+
+            #include "UnityCG.glslinc"
+
+#ifdef SHADER_API_GLES3
+#extension GL_OES_EGL_image_external_essl3 : require
+#endif // SHADER_API_GLES3
+
+            // Device display transform is provided by the AR Foundation camera background renderer.
+            uniform mat4 _UnityDisplayTransform;
+
+#ifdef VERTEX
+            varying vec2 textureCoord;
+
+            void main()
+            {
+#ifdef SHADER_API_GLES3
+                // Transform the position from object space to clip space.
+                gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+                // 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;
+#endif // SHADER_API_GLES3
+            }
+#endif // VERTEX
+
+#ifdef FRAGMENT
+            varying vec2 textureCoord;
+            uniform samplerExternalOES _MainTex;
+            uniform float _UnityCameraForwardScale;
+
+#ifdef ARCORE_ENVIRONMENT_DEPTH_ENABLED
+            uniform sampler2D _EnvironmentDepth;
+#endif // ARCORE_ENVIRONMENT_DEPTH_ENABLED
+
+#if defined(SHADER_API_GLES3) && !defined(UNITY_COLORSPACE_GAMMA)
+            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);
+                else
+                    return pow(value, 2.2F);
+            }
+
+            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);
+
+                // 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)
+            {
+#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
+            }
+
+            void main()
+            {
+#ifdef SHADER_API_GLES3
+                vec3 result = texture(_MainTex, textureCoord).xyz;
+                float depth = 1.0;
+
+#ifdef ARCORE_ENVIRONMENT_DEPTH_ENABLED
+                float distance = texture(_EnvironmentDepth, textureCoord).x;
+                depth = ConvertDistanceToDepth(distance);
+#endif // ARCORE_ENVIRONMENT_DEPTH_ENABLED
+
+#ifndef UNITY_COLORSPACE_GAMMA
+                result = GammaToLinearSpace(result);
+#endif // !UNITY_COLORSPACE_GAMMA
+
+                // gl_FragColor = vec4(result, 1.0);
+                gl_FragColor = vec4(result, depth);
+                gl_FragDepth = depth;
+#endif // SHADER_API_GLES3
+            }
+
+#endif // FRAGMENT
+            ENDGLSL
+        }
+    }
+
+    FallBack Off
+}

package/Shaders/ARCoreBackgroundDepth.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: a68a981b98d2c47b881e7e696a7b0f1f
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Shaders/ARKitBackgroundDepth.shader

@@ -0,0 +1,199 @@
+Shader "Unlit/TextureSource/ARKitBackgroundDepth"
+{
+    Properties
+    {
+        _textureY ("TextureY", 2D) = "white" {}
+        _textureCbCr ("TextureCbCr", 2D) = "black" {}
+        _HumanStencil ("HumanStencil", 2D) = "black" {}
+        _HumanDepth ("HumanDepth", 2D) = "black" {}
+        _EnvironmentDepth ("EnvironmentDepth", 2D) = "black" {}
+    }
+
+    SubShader
+    {
+        Tags
+        {
+            "Queue" = "Background"
+            "RenderType" = "Background"
+            "ForceNoShadowCasting" = "True"
+        }
+
+        Pass
+        {
+            Cull Off
+            ZTest Always
+            ZWrite On
+            Lighting Off
+            LOD 100
+            Tags
+            {
+                "LightMode" = "Always"
+            }
+
+
+            HLSLPROGRAM
+
+            #pragma vertex vert
+            #pragma fragment frag
+
+            #pragma multi_compile_local __ ARKIT_BACKGROUND_URP
+            #pragma multi_compile_local __ ARKIT_HUMAN_SEGMENTATION_ENABLED ARKIT_ENVIRONMENT_DEPTH_ENABLED
+            #pragma multi_compile_local __ TEXTURE_SOURCE_RAW_DISTANCE
+
+
+#if ARKIT_BACKGROUND_URP
+
+            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
+            #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Color.hlsl"
+
+            #define ARKIT_TEXTURE2D_HALF(texture) TEXTURE2D(texture)
+            #define ARKIT_SAMPLER_HALF(sampler) SAMPLER(sampler)
+            #define ARKIT_TEXTURE2D_FLOAT(texture) TEXTURE2D(texture)
+            #define ARKIT_SAMPLER_FLOAT(sampler) SAMPLER(sampler)
+            #define ARKIT_SAMPLE_TEXTURE2D(texture,sampler,texcoord) SAMPLE_TEXTURE2D(texture,sampler,texcoord)
+
+#else // Legacy RP
+
+            #include "UnityCG.cginc"
+
+            #define real4 half4
+            #define real4x4 half4x4
+            #define TransformObjectToHClip UnityObjectToClipPos
+            #define FastSRGBToLinear GammaToLinearSpace
+
+            #define ARKIT_TEXTURE2D_HALF(texture) UNITY_DECLARE_TEX2D_HALF(texture)
+            #define ARKIT_SAMPLER_HALF(sampler)
+            #define ARKIT_TEXTURE2D_FLOAT(texture) UNITY_DECLARE_TEX2D_FLOAT(texture)
+            #define ARKIT_SAMPLER_FLOAT(sampler)
+            #define ARKIT_SAMPLE_TEXTURE2D(texture,sampler,texcoord) UNITY_SAMPLE_TEX2D(texture,texcoord)
+
+#endif
+
+
+            struct appdata
+            {
+                float3 position : POSITION;
+                float2 texcoord : TEXCOORD0;
+            };
+
+            struct v2f
+            {
+                float4 position : SV_POSITION;
+                float2 texcoord : TEXCOORD0;
+            };
+
+            struct fragment_output
+            {
+                real4 color : SV_Target;
+                // float depth : SV_Depth;
+            };
+
+
+            CBUFFER_START(UnityARFoundationPerFrame)
+            // Device display transform is provided by the AR Foundation camera background renderer.
+            float4x4 _UnityDisplayTransform;
+            float _UnityCameraForwardScale;
+            CBUFFER_END
+
+
+            v2f vert (appdata v)
+            {
+                // Transform the position from object space to clip space.
+                float4 position = TransformObjectToHClip(v.position);
+
+                // Remap the texture coordinates based on the device rotation.
+                float2 texcoord = mul(float4(v.texcoord, 1.0f, 1.0f), _UnityDisplayTransform).xy;
+
+                v2f o;
+                o.position = position;
+                o.texcoord = texcoord;
+                return o;
+            }
+
+
+            CBUFFER_START(ARKitColorTransformations)
+            static const real4x4 s_YCbCrToSRGB = real4x4(
+                real4(1.0h,  0.0000h,  1.4020h, -0.7010h),
+                real4(1.0h, -0.3441h, -0.7141h,  0.5291h),
+                real4(1.0h,  1.7720h,  0.0000h, -0.8860h),
+                real4(0.0h,  0.0000h,  0.0000h,  1.0000h)
+            );
+            CBUFFER_END
+
+
+            inline float ConvertDistanceToDepth(float d)
+            {
+#if TEXTURE_SOURCE_RAW_DISTANCE
+                return d;
+#else
+                // Account for scale
+                d = _UnityCameraForwardScale > 0.0 ? _UnityCameraForwardScale * d : d;
+
+                // Clip any distances smaller than the near clip plane, and compute the depth value from the distance.
+                return (d < _ProjectionParams.y) ? 0.0f : ((1.0f / _ZBufferParams.z) * ((1.0f / d) - _ZBufferParams.w));
+#endif // TEXTURE_SOURCE_RAW_DISTANCE
+            }
+
+
+            ARKIT_TEXTURE2D_HALF(_textureY);
+            ARKIT_SAMPLER_HALF(sampler_textureY);
+            ARKIT_TEXTURE2D_HALF(_textureCbCr);
+            ARKIT_SAMPLER_HALF(sampler_textureCbCr);
+#if ARKIT_ENVIRONMENT_DEPTH_ENABLED
+            ARKIT_TEXTURE2D_FLOAT(_EnvironmentDepth);
+            ARKIT_SAMPLER_FLOAT(sampler_EnvironmentDepth);
+#elif ARKIT_HUMAN_SEGMENTATION_ENABLED
+            ARKIT_TEXTURE2D_HALF(_HumanStencil);
+            ARKIT_SAMPLER_HALF(sampler_HumanStencil);
+            ARKIT_TEXTURE2D_FLOAT(_HumanDepth);
+            ARKIT_SAMPLER_FLOAT(sampler_HumanDepth);
+#endif // ARKIT_HUMAN_SEGMENTATION_ENABLED
+
+
+            fragment_output frag (v2f i)
+            {
+                // Sample the video textures (in YCbCr).
+                real4 ycbcr = real4(ARKIT_SAMPLE_TEXTURE2D(_textureY, sampler_textureY, i.texcoord).r,
+                                    ARKIT_SAMPLE_TEXTURE2D(_textureCbCr, sampler_textureCbCr, i.texcoord).rg,
+                                    1.0h);
+
+                // Convert from YCbCr to sRGB.
+                real4 videoColor = mul(s_YCbCrToSRGB, ycbcr);
+
+#if !UNITY_COLORSPACE_GAMMA
+                // If rendering in linear color space, convert from sRGB to RGB.
+                videoColor.xyz = FastSRGBToLinear(videoColor.xyz);
+#endif // !UNITY_COLORSPACE_GAMMA
+
+                // Assume the background depth is the back of the depth clipping volume.
+                float depthValue = 0.0f;
+
+#if ARKIT_ENVIRONMENT_DEPTH_ENABLED
+                // Sample the environment depth (in meters).
+                float envDistance = ARKIT_SAMPLE_TEXTURE2D(_EnvironmentDepth, sampler_EnvironmentDepth, i.texcoord).r;
+
+                // Convert the distance to depth.
+                depthValue = ConvertDistanceToDepth(envDistance);
+#elif ARKIT_HUMAN_SEGMENTATION_ENABLED
+                // Check the human stencil, and skip non-human pixels.
+                if (ARKIT_SAMPLE_TEXTURE2D(_HumanStencil, sampler_HumanStencil, i.texcoord).r > 0.5h)
+                {
+                    // Sample the human depth (in meters).
+                    float humanDistance = ARKIT_SAMPLE_TEXTURE2D(_HumanDepth, sampler_HumanDepth, i.texcoord).r;
+
+                    // Convert the distance to depth.
+                    depthValue = ConvertDistanceToDepth(humanDistance);
+                }
+#endif // ARKIT_HUMAN_SEGMENTATION_ENABLED
+
+                fragment_output o;
+                o.color = real4(videoColor.x, videoColor.y, videoColor.z, depthValue);
+                // o.color = real4(depthValue, depthValue, depthValue, 0.5h);
+                // o.depth = depthValue;
+                return o;
+            }
+
+            ENDHLSL
+        }
+    }
+}

package/Shaders/ARKitBackgroundDepth.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: c8b0b30194e1b4026abc942f037e6f86
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Shaders.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 72ce354a7d6da4f62bd4862f571441a8
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.github.asus4.texture-source",
-  "version": "0.2.2",
+  "version": "0.3.1",
   "displayName": "TextureSource",
   "description": "Simplify WebCamera and test video handling for using Computer Vision in Unity",
   "unity": "2020.3",
@@ -11,6 +11,7 @@
   ],
   "documentationUrl": "https://github.com/asus4/TextureSource/tree/main",
   "changelogUrl": "https://github.com/asus4/TextureSource/releases",
+  "license": "MIT",
   "licensesUrl": "https://github.com/asus4/TextureSource/blob/main/Packages/com.github.asus4.texture-source/LICENSE",
   "author": {
     "name": "Koki Ibukuro",