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

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.0",
     ...// 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/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.2",
+  "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",