com.github.asus4.texture-source 0.1.2 → 0.2.0

package/README.md

@@ -1,12 +1,12 @@
 # Texture Source
 
-TextureSource is an utility for using CV in Unity. It enables you to choose multiple input sources in Editor.
+TextureSource is a utility for using CV in Unity. It enables you to choose multiple input sources in Editor.
 
 ## Install via UPM
 
-Add following setting to `Packages/manifest.json`
+Add the following setting to `Packages/manifest.json`
 
-```
+```json
 {
   "scopedRegistries": [
     {
@@ -18,7 +18,7 @@ Add following setting to `Packages/manifest.json`
     }
   ],
   "dependencies": {
-    "com.github.asus4.texture-source": "0.1.0",
+    "com.github.asus4.texture-source": "0.1.3",
     ...// other dependencies
   }
 }

package/Resources/com.github.asus4.texture-source/Common.hlsl

@@ -0,0 +1,8 @@
+// Ported from RenderPipeLine-Core, to support both URP and Built-in RP in one shader
+// com.unity.render-pipelines.core copyright © 2020 Unity Technologies ApS
+// Licensed under the Unity Companion License for Unity-dependent projects--see [Unity Companion License](http://www.unity3d.com/legal/licenses/Unity_Companion_License).
+
+float3 FastSRGBToLinear(float3 c)
+{
+    return c * (c * (c * 0.305306011 + 0.682171111) + 0.012522878);
+}

package/Resources/com.github.asus4.texture-source/Common.hlsl.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: d73b9c13ee77b4bb48a8ff20c23c9709
+ShaderIncludeImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Resources/com.github.asus4.texture-source/TextureTransform.compute

@@ -1,5 +1,7 @@
 #pragma kernel TextureTransform
 
+#include "Common.hlsl"
+
 Texture2D<float4> _InputTex;
 RWTexture2D<float4> _OutputTex;
 uint2 _OutputTexSize;
@@ -18,7 +20,13 @@ void TextureTransform (uint2 id : SV_DispatchThreadID)
     float2 uv = (float2)id / float2(_OutputTexSize - 1.0);
     uv = mul(_TransformMatrix, float4(uv, 0, 1)).xy;
 
+    float4 c = _InputTex.SampleLevel(linearClampSampler, uv, 0);
+
+#ifndef UNITY_NO_LINEAR_COLORSPACE
+    c.rgb = FastSRGBToLinear(c.rgb);
+#endif // !UNITY_COLORSPACE_GAMMA
+
     _OutputTex[id] = any(uv < 0) || any(uv > 1)
         ? float4(0, 0, 0, 1)
-        : _InputTex.SampleLevel(linearClampSampler, uv, 0);
+        : c;
 }

package/Runtime/ARCameraBackgroundTextureSource.cs

@@ -0,0 +1,144 @@
+// Only available with AR Foundation
+#if MODULE_ARFOUNDATION_ENABLED
+namespace TextureSource
+{
+    using System;
+    using UnityEngine;
+    using UnityEngine.XR.ARFoundation;
+
+    [CreateAssetMenu(menuName = "ScriptableObject/Texture Source/ARFoundation", fileName = "ARFoundationTextureSource")]
+    public sealed 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(() =>
+        {
+            string shaderName = Application.platform switch
+            {
+                RuntimePlatform.Android => "Unlit/ARCoreBackground",
+                RuntimePlatform.IPhonePlayer => "Unlit/ARKitBackground",
+#if UNITY_ANDROID
+                _ => "Unlit/ARCoreBackground",
+#elif UNITY_IOS
+                _ => "Unlit/ARKitBackground",
+#else
+                _ => 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;
+
+        public override void Start()
+        {
+            cameraManager = FindAnyObjectByType<ARCameraManager>();
+            if (cameraManager == null)
+            {
+                throw new InvalidOperationException("ARCameraManager is not found");
+            }
+
+            var shader = ARCameraBackgroundShader.Value;
+            material = new Material(shader);
+
+            cameraManager.frameReceived += OnFrameReceived;
+        }
+
+        public override void Stop()
+        {
+            if (cameraManager != null)
+            {
+                cameraManager.frameReceived -= OnFrameReceived;
+            }
+
+            if (texture != null)
+            {
+                texture.Release();
+                Destroy(texture);
+                texture = null;
+            }
+
+            if (material != null)
+            {
+                Destroy(material);
+                material = null;
+            }
+        }
+
+        public override void Next()
+        {
+            if (cameraManager == null)
+            {
+                return;
+            }
+            // Switch the camera facing direction.
+            cameraManager.requestedFacingDirection = cameraManager.currentFacingDirection switch
+            {
+                CameraFacingDirection.World => CameraFacingDirection.User,
+                CameraFacingDirection.User => CameraFacingDirection.World,
+                _ => CameraFacingDirection.World,
+            };
+        }
+
+        private void OnFrameReceived(ARCameraFrameEventArgs args)
+        {
+            // Find best texture size
+            int bestWidth = 0;
+            int bestHeight = 0;
+            int count = args.textures.Count;
+            for (int i = 0; i < count; i++)
+            {
+                var tex = args.textures[i];
+                bestWidth = Math.Max(bestWidth, tex.width);
+                bestHeight = Math.Max(bestHeight, tex.height);
+                material.SetTexture(args.propertyNameIds[i], tex);
+            }
+
+            // Swap if screen is portrait
+            float screenAspect = (float)Screen.width / Screen.height;
+            if (bestWidth > bestHeight && screenAspect < 1f)
+            {
+                (bestWidth, bestHeight) = (bestHeight, bestWidth);
+            }
+
+            // 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);
+
+            if (args.displayMatrix.HasValue)
+            {
+                material.SetMatrix(_DisplayTransformID, args.displayMatrix.Value);
+            }
+
+            Graphics.Blit(null, texture, material);
+
+            lastUpdatedFrame = Time.frameCount;
+        }
+
+        private void EnsureRenderTexture(int width, int height)
+        {
+            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.Create();
+            }
+        }
+    }
+}
+#endif // MODULE_ARFOUNDATION_ENABLED

package/Runtime/ARCameraBackgroundTextureSource.cs.meta

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

package/Runtime/TextureSource.asmdef

@@ -1,7 +1,9 @@
 {
     "name": "TextureSource",
     "rootNamespace": "",
-    "references": [],
+    "references": [
+        "GUID:a9420e37d7990b54abdef6688edbe313"
+    ],
     "includePlatforms": [],
     "excludePlatforms": [],
     "allowUnsafeCode": false,
@@ -9,6 +11,12 @@
     "precompiledReferences": [],
     "autoReferenced": true,
     "defineConstraints": [],
-    "versionDefines": [],
+    "versionDefines": [
+        {
+            "name": "com.unity.xr.arfoundation",
+            "expression": "4.0.0",
+            "define": "MODULE_ARFOUNDATION_ENABLED"
+        }
+    ],
     "noEngineReferences": false
 }

package/Runtime/TextureTransformer.cs

@@ -1,11 +1,10 @@
 namespace TextureSource
 {
+    using System;
     using UnityEngine;
 
-    public class TextureTransformer : System.IDisposable
+    public class TextureTransformer : IDisposable
     {
-        private static ComputeShader compute;
-        private static int kernel;
         private static readonly int _InputTex = Shader.PropertyToID("_InputTex");
         private static readonly int _OutputTex = Shader.PropertyToID("_OutputTex");
         private static readonly int _OutputTexSize = Shader.PropertyToID("_OutputTexSize");
@@ -14,14 +13,24 @@ namespace TextureSource
         private static readonly Matrix4x4 PopMatrix = Matrix4x4.Translate(new Vector3(0.5f, 0.5f, 0));
         private static readonly Matrix4x4 PushMatrix = Matrix4x4.Translate(new Vector3(-0.5f, -0.5f, 0));
 
+        public static readonly Lazy<ComputeShader> DefaultComputeShader = new(()
+            => Resources.Load<ComputeShader>("com.github.asus4.texture-source/TextureTransform"));
+
+        private readonly ComputeShader compute;
+        private readonly int kernel;
         private RenderTexture texture;
         public readonly int width;
         public readonly int height;
 
         public RenderTexture Texture => texture;
 
-        public TextureTransformer(int width, int height)
+        public TextureTransformer(int width, int height, ComputeShader shader = null)
         {
+            compute = shader != null
+                ? shader
+                : DefaultComputeShader.Value;
+            kernel = compute.FindKernel("TextureTransform");
+
             this.width = width;
             this.height = height;
 
@@ -30,16 +39,10 @@ namespace TextureSource
                 enableRandomWrite = true,
                 useMipMap = false,
                 depthBufferBits = 0,
+                // sRGB = QualitySettings.activeColorSpace == ColorSpace.Linear,
             };
             texture = new RenderTexture(desc);
             texture.Create();
-
-            if (compute == null)
-            {
-                const string SHADER_PATH = "com.github.asus4.texture-source/TextureTransform";
-                compute = Resources.Load<ComputeShader>(SHADER_PATH);
-                kernel = compute.FindKernel("TextureTransform");
-            }
         }
 
         public void Dispose()
@@ -47,11 +50,17 @@ namespace TextureSource
             if (texture != null)
             {
                 texture.Release();
-                Object.Destroy(texture);
+                UnityEngine.Object.Destroy(texture);
             }
             texture = null;
         }
 
+        /// <summary>
+        /// Transform with a matrix
+        /// </summary>
+        /// <param name="input">A input texture</param>
+        /// <param name="t">A matrix</param>
+        /// <returns>The transformed texture</returns>
         public RenderTexture Transform(Texture input, Matrix4x4 t)
         {
             compute.SetTexture(kernel, _InputTex, input, 0);
@@ -62,6 +71,14 @@ namespace TextureSource
             return texture;
         }
 
+        /// <summary>
+        /// Transform with offset, rotation, and scale
+        /// </summary>
+        /// <param name="input">A input texture</param>
+        /// <param name="offset">A 2D offset</param>
+        /// <param name="eulerRotation">A rotation in euler angles</param>
+        /// <param name="scale">A scale</param>
+        /// <returns>The transformed texture</returns>
         public RenderTexture Transform(Texture input, Vector2 offset, float eulerRotation, Vector2 scale)
         {
             Matrix4x4 trs = Matrix4x4.TRS(
@@ -70,5 +87,25 @@ namespace TextureSource
                 new Vector3(1f / scale.x, 1f / scale.y, 1));
             return Transform(input, PopMatrix * trs * PushMatrix);
         }
+
+        /// <summary>
+        /// Transform with multiple textures
+        /// </summary>
+        /// <param name="propertyIds">An array of property name IDs associated with each texture</param>
+        /// <param name="textures">An array of textures</param>
+        /// <param name="t">A matrix</param>
+        /// <returns>The transformed texture</returns>
+        public RenderTexture Transform(ReadOnlySpan<int> propertyIds, ReadOnlySpan<Texture> textures, Matrix4x4 t)
+        {
+            for (int i = 0; i < propertyIds.Length; i++)
+            {
+                compute.SetTexture(kernel, propertyIds[i], textures[i], 0);
+            }
+            compute.SetTexture(kernel, _OutputTex, texture, 0);
+            compute.SetInts(_OutputTexSize, texture.width, texture.height);
+            compute.SetMatrix(_TransformMatrix, t);
+            compute.Dispatch(kernel, Mathf.CeilToInt(texture.width / 8f), Mathf.CeilToInt(texture.height / 8f), 1);
+            return texture;
+        }
     }
 }

package/Runtime/Utils.cs

@@ -0,0 +1,33 @@
+namespace TextureSource
+{
+    using UnityEngine;
+
+    internal static class Utils
+    {
+        public static void GetTargetSizeScale(
+            Vector2Int srcSize, float dstAspect,
+            out Vector2Int dstSize, out Vector2 scale)
+        {
+            float srcAspect = (float)srcSize.x / srcSize.y;
+            int width, height;
+            if (srcAspect > dstAspect)
+            {
+                width = RoundToEven(srcSize.y * dstAspect);
+                height = srcSize.y;
+                scale = new Vector2((float)srcSize.x / width, 1);
+            }
+            else
+            {
+                width = srcSize.x;
+                height = RoundToEven(srcSize.x / dstAspect);
+                scale = new Vector2(1, (float)srcSize.y / height);
+            }
+            dstSize = new Vector2Int(width, height);
+        }
+
+        private static int RoundToEven(float n)
+        {
+            return Mathf.RoundToInt(n / 2) * 2;
+        }
+    }
+}

package/Runtime/Utils.cs.meta

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

package/Runtime/VirtualTextureSource.cs

@@ -39,6 +39,17 @@ namespace TextureSource
         public bool DidUpdateThisFrame => activeSource.DidUpdateThisFrame;
         public Texture Texture => activeSource.Texture;
 
+        public BaseTextureSource Source
+        {
+            get => source;
+            set => source = value;
+        }
+        public BaseTextureSource SourceForEditor
+        {
+            get => sourceForEditor;
+            set => sourceForEditor = value;
+        }
+
         private void OnEnable()
         {
             activeSource = sourceForEditor != null && Application.isEditor
@@ -90,42 +101,27 @@ namespace TextureSource
 
         private Texture TrimToScreen(Texture texture)
         {
-            float cameraAspect = (float)texture.width / texture.height;
-            float targetAspect = (float)Screen.width / Screen.height;
+            float srcAspect = (float)texture.width / texture.height;
+            float dstAspect = (float)Screen.width / Screen.height;
 
-            if (Mathf.Abs(cameraAspect - targetAspect) < 0.01f)
+            // Allow 1% mismatch
+            if (Mathf.Abs(srcAspect - dstAspect) < 0.01f)
             {
                 return texture;
             }
 
-            int width, height;
-            Vector2 scale;
-            if (cameraAspect > targetAspect)
-            {
-                width = RoundToEven(texture.height * targetAspect);
-                height = texture.height;
-                scale = new Vector2((float)texture.width / width, 1);
-            }
-            else
-            {
-                width = texture.width;
-                height = RoundToEven(texture.width / targetAspect);
-                scale = new Vector2(1, (float)texture.height / height);
-            }
+            Utils.GetTargetSizeScale(
+                new Vector2Int(texture.width, texture.height), dstAspect,
+                out Vector2Int dstSize, out Vector2 scale);
 
-            bool needInitialize = transformer == null || width != transformer.width || height != transformer.height;
+            bool needInitialize = transformer == null || dstSize.x != transformer.width || dstSize.y != transformer.height;
             if (needInitialize)
             {
                 transformer?.Dispose();
-                transformer = new TextureTransformer(width, height);
+                transformer = new TextureTransformer(dstSize.x, dstSize.y);
             }
 
             return transformer.Transform(texture, Vector2.zero, 0, scale);
         }
-
-        private static int RoundToEven(float n)
-        {
-            return Mathf.RoundToInt(n / 2) * 2;
-        }
     }
 }

package/Runtime/WebCamTextureSource.cs

@@ -57,12 +57,48 @@ namespace TextureSource
         private int lastUpdatedFrame = -1;
         private bool isFrontFacing;
 
+        public WebCamKindFlag KindFilter
+        {
+            get => kindFilter;
+            set => kindFilter = value;
+        }
+
+        public FacingFlag FacingFilter
+        {
+            get => facingFilter;
+            set => facingFilter = value;
+        }
+
+        public Vector2Int Resolution
+        {
+            get => resolution;
+            set => resolution = value;
+        }
+
+        public bool IsFrontFacing => isFrontFacing;
+
+        public int FrameRate
+        {
+            get => frameRate;
+            set => frameRate = value;
+        }
+
         public override void Start()
         {
             devices = WebCamTexture.devices.Where(IsMatchFilter).ToArray();
             StartCamera(currentIndex);
         }
 
+        private void StartCamera(int index)
+        {
+            Stop();
+            WebCamDevice device = devices[index];
+            webCamTexture = new WebCamTexture(device.name, resolution.x, resolution.y, frameRate);
+            webCamTexture.Play();
+            isFrontFacing = device.isFrontFacing;
+            lastUpdatedFrame = -1;
+        }
+
         public override void Stop()
         {
             if (webCamTexture != null)
@@ -80,17 +116,6 @@ namespace TextureSource
             StartCamera(currentIndex);
         }
 
-        private void StartCamera(int index)
-        {
-            Stop();
-            WebCamDevice device = devices[index];
-            webCamTexture = new WebCamTexture(device.name, resolution.x, resolution.y, frameRate);
-            webCamTexture.Play();
-            isFrontFacing = device.isFrontFacing;
-            lastUpdatedFrame = -1;
-            Debug.Log($"Started camera:{device.name}");
-        }
-
         private RenderTexture NormalizeWebCam()
         {
             if (webCamTexture == null)

package/package.json

@@ -1,14 +1,22 @@
 {
   "name": "com.github.asus4.texture-source",
+  "version": "0.2.0",
   "displayName": "TextureSource",
-  "author": "Koki Ibukuro",
-  "description": "Virtual Texture Source",
-  "keywords": [
-    "unity"
-  ],
-  "license": "SEE LICENSE IN LICENSE",
+  "description": "Simplify WebCamera and test video handling for using Computer Vision in Unity",
   "unity": "2020.3",
   "unityRelease": "0f1",
-  "version": "0.1.2",
-  "type": "tool"
+  "keywords": [
+    "unity",
+    "cv"
+  ],
+  "documentationUrl": "https://github.com/asus4/TextureSource/tree/main",
+  "changelogUrl": "https://github.com/asus4/TextureSource/releases",
+  "licensesUrl": "https://github.com/asus4/TextureSource/blob/main/Packages/com.github.asus4.texture-source/LICENSE",
+  "author": {
+    "name": "Koki Ibukuro",
+    "url": "https://github.com/asus4"
+  },
+  "dependencies": {
+    "com.unity.modules.video": "1.0.0"
+  }
 }