com.github.asus4.texture-source 0.2.1 → 0.3.0

package/README.md

@@ -1,7 +1,46 @@
 # Texture Source
 
+[![upm](https://img.shields.io/npm/v/com.github.asus4.texture-source?label=upm)](https://www.npmjs.com/package/com.github.asus4.texture-source)
+
 TextureSource is a utility that provides a consistent API to get the texture from various sources.
 
+![virtual-texture](https://github.com/asus4/TextureSource/assets/357497/e52f80d2-b1be-4cfa-81f7-76cdafe271bc)
+
+## Example API Usage
+
+```c#
+using TextureSource;
+using UnityEngine;
+
+[RequireComponent(typeof(VirtualTextureSource))]
+public class TextureSourceSample: MonoBehaviour
+{
+    private void Start()
+    {
+        // Listen to OnTexture event from VirtualTextureSource
+        // Also able to bind in the inspector
+        if (TryGetComponent(out VirtualTextureSource source))
+        {
+            source.OnTexture.AddListener(OnTexture);
+        }
+    }
+
+    private void OnDestroy()
+    {
+        if (TryGetComponent(out VirtualTextureSource source))
+        {
+            source.OnTexture.RemoveListener(OnTexture);
+        }
+    }
+
+    public void OnTexture(Texture texture)
+    {
+        // Do whatever 🥳
+        // You don't need to think about webcam texture rotation.
+    }   
+}
+```
+
 ## Install via UPM
 
 Add the following setting to `Packages/manifest.json`
@@ -18,7 +57,7 @@ Add the following setting to `Packages/manifest.json`
     }
   ],
   "dependencies": {
-    "com.github.asus4.texture-source": "0.2.1",
+    "com.github.asus4.texture-source": "0.3.0",
     ...// other dependencies
   }
 }
@@ -30,29 +69,37 @@ After installing the library, attach `VirtualTextureSource` to the GameObject.
 
 ![virtual-texture](https://github.com/asus4/TextureSource/assets/357497/e52f80d2-b1be-4cfa-81f7-76cdafe271bc)
 
-Then, right-click on the project panel and create the TexureSource scriptable object that you want to use. You can set different sources for the Editor and Runtime.
+Then, right-click on the project panel and create the TextureSource scriptable object that you want to use. You can set different sources for the Editor and Runtime.
 
 ![scriptable-object](https://github.com/asus4/TextureSource/assets/357497/6c4862e2-5298-4f4e-8cd5-076d54d46db8)
 
 Currently provides the following sources:
 
-#### WebCam Texture Source
+### WebCam Texture Source
 
 Includes collecting device rotation.
 
 ![webcam-texture-source](https://github.com/asus4/TextureSource/assets/357497/407f7372-b214-4ba9-9093-2b39755b905b)
 
-#### Video Texture Source
+### Video Texture Source
 
 Useful when using test videos only in the Editor.
 
 ![video-texture-source](https://github.com/asus4/TextureSource/assets/357497/8e38ed1a-d2d8-4e16-9fc4-e5d4c6d0a888)
 
-#### AR Foundation Texture Source
+### 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.
 
-![ar-faoundation-texture-source](https://github.com/asus4/TextureSource/assets/357497/5ac82a8a-0554-41a2-b9ef-c03ebd60c6ff)
+![ar-foundation-texture-source](https://github.com/asus4/TextureSource/assets/357497/5ac82a8a-0554-41a2-b9ef-c03ebd60c6ff)
 
 ## Acknowledgement
 

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

@@ -1,7 +1,5 @@
 #pragma kernel TextureTransform
 
-#include "Common.hlsl"
-
 Texture2D<float4> _InputTex;
 RWTexture2D<float4> _OutputTex;
 uint2 _OutputTexSize;
@@ -22,10 +20,6 @@ void TextureTransform (uint2 id : SV_DispatchThreadID)
 
     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)
         : c;

package/Runtime/ARCameraBackgroundTextureSource.cs

@@ -6,6 +6,9 @@ namespace TextureSource
     using UnityEngine;
     using UnityEngine.XR.ARFoundation;
 
+    /// <summary>
+    /// Source from ARFoundation
+    /// </summary>
     [CreateAssetMenu(menuName = "ScriptableObject/Texture Source/ARFoundation", fileName = "ARFoundationTextureSource")]
     public sealed class ARFoundationTextureSource : BaseTextureSource
     {

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");

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
     {

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);
         }
 
@@ -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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.github.asus4.texture-source",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "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",

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

@@ -1,8 +0,0 @@
-// 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

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