com.github.asus4.texture-source 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Koki Ibukuro
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/LICENSE.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 81247af5bac164445a8eb7c229b2ea02
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/README.md

@@ -0,0 +1,29 @@
+# Texture Source
+
+TextureSource is an 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`
+
+```
+{
+  "scopedRegistries": [
+    {
+      "name": "npm",
+      "url": "https://registry.npmjs.com",
+      "scopes": [
+        "com.github.asus4"
+      ]
+    }
+  ],
+  "dependencies": {
+    "com.github.asus4.texture-source": "0.1.0",
+    ...// other dependencies
+  }
+}
+```
+
+## Acknowledgement
+
+Inspired from [TestTools](https://github.com/keijiro/TestTools)

package/README.md.meta

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

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

@@ -0,0 +1,24 @@
+#pragma kernel TextureTransform
+
+Texture2D<float4> _InputTex;
+RWTexture2D<float4> _OutputTex;
+int2 _OutputTexSize;
+float4x4 _TransformMatrix;
+
+SamplerState linearClampSampler;
+
+[numthreads(8,8,1)]
+void TextureTransform (uint2 id : SV_DispatchThreadID)
+{
+    if(any(id >= _OutputTexSize))
+    {
+        return; 
+    }
+
+    float2 uv = float2(id.x, id.y) / float2(_OutputTexSize.x, _OutputTexSize.y);    
+    uv = mul(_TransformMatrix, float4(uv, 0, 1)).xy;
+
+    _OutputTex[id] = any(uv < 0) || any(uv > 1)
+        ? float4(0, 0, 0, 1)
+        : _InputTex.SampleLevel(linearClampSampler, uv, 0);
+}

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

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 5cd30b8c168c240338c71105c0213c18
+ComputeShaderImporter:
+  externalObjects: {}
+  currentAPIMask: 65537
+  preprocessorOverride: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

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

package/Resources.meta

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

package/Runtime/BaseTextureSource.cs

@@ -0,0 +1,13 @@
+namespace TextureSource
+{
+    using UnityEngine;
+
+    public abstract class BaseTextureSource : ScriptableObject, ITextureSource
+    {
+        public abstract bool DidUpdateThisFrame { get; }
+        public abstract Texture Texture { get; }
+        public abstract void Start();
+        public abstract void Stop();
+        public abstract void Next();
+    }
+}

package/Runtime/BaseTextureSource.cs.meta

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

package/Runtime/ITextureSource.cs

@@ -0,0 +1,14 @@
+namespace TextureSource
+{
+    using UnityEngine;
+
+    public interface ITextureSource
+    {
+        bool DidUpdateThisFrame { get; }
+        Texture Texture { get; }
+
+        void Start();
+        void Stop();
+        void Next();
+    }
+}

package/Runtime/ITextureSource.cs.meta

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

package/Runtime/TextureSource.asmdef

@@ -0,0 +1,14 @@
+{
+    "name": "TextureSource",
+    "rootNamespace": "",
+    "references": [],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

package/Runtime/TextureSource.asmdef.meta

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

package/Runtime/TextureTransformer.cs

@@ -0,0 +1,74 @@
+namespace TextureSource
+{
+    using UnityEngine;
+
+    public class TextureTransformer : System.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");
+        private static readonly int _TransformMatrix = Shader.PropertyToID("_TransformMatrix");
+
+        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));
+
+        private RenderTexture texture;
+        public readonly int width;
+        public readonly int height;
+
+        public RenderTexture Texture => texture;
+
+        public TextureTransformer(int width, int height)
+        {
+            this.width = width;
+            this.height = height;
+
+            var desc = new RenderTextureDescriptor(width, height, RenderTextureFormat.ARGB32)
+            {
+                enableRandomWrite = true,
+                useMipMap = false,
+                depthBufferBits = 0,
+            };
+            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()
+        {
+            if (texture != null)
+            {
+                texture.Release();
+                Object.Destroy(texture);
+            }
+            texture = null;
+        }
+
+        public RenderTexture Transform(Texture input, Matrix4x4 t)
+        {
+            compute.SetTexture(kernel, _InputTex, input, 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;
+        }
+
+        public RenderTexture Transform(Texture input, Vector2 offset, float eulerRotation, Vector2 scale)
+        {
+            Matrix4x4 trs = Matrix4x4.TRS(
+                new Vector3(-offset.x, -offset.y, 0),
+                Quaternion.Euler(0, 0, -eulerRotation),
+                new Vector3(1f / scale.x, 1f / scale.y, 1));
+            return Transform(input, PopMatrix * trs * PushMatrix);
+        }
+    }
+}

package/Runtime/TextureTransformer.cs.meta

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

package/Runtime/VideoTextureSource.cs

@@ -0,0 +1,111 @@
+namespace TextureSource
+{
+    using System.IO;
+    using UnityEngine;
+    using UnityEngine.Video;
+
+    [CreateAssetMenu(menuName = "ScriptableObject/Texture Source/Video", fileName = "VideoTextureSource")]
+    public class VideoTextureSource : BaseTextureSource
+    {
+        [System.Serializable]
+        public class VideoData
+        {
+            public VideoSource source;
+            public string url;
+            public VideoClip clip;
+
+            public VideoSource Source => clip == null
+                ? VideoSource.Url : VideoSource.VideoClip;
+
+            public string URL
+            {
+                get
+                {
+                    return Path.IsPathRooted(url)
+                        ? url
+                        : Path.Combine(Application.dataPath, url);
+                }
+            }
+        }
+
+        [SerializeField]
+        [Tooltip("Whether to loop the video")]
+        private bool loop = true;
+
+        [SerializeField]
+        [Tooltip("Whether to play sound in the video")]
+        private bool playSound = false;
+
+        [SerializeField]
+        private VideoData[] videos = default;
+
+        private VideoPlayer player;
+        private int currentIndex;
+        private long currentFrame = -1;
+
+        public override bool DidUpdateThisFrame
+        {
+            get
+            {
+                long frame = player.frame;
+                bool isUpdated = frame != currentFrame;
+                currentFrame = frame;
+                return isUpdated;
+            }
+        }
+
+        public override Texture Texture => player.texture;
+
+        public override void Start()
+        {
+            GameObject go = new GameObject(nameof(VideoTextureSource));
+            DontDestroyOnLoad(go);
+            player = go.AddComponent<VideoPlayer>();
+            player.renderMode = VideoRenderMode.APIOnly;
+            player.audioOutputMode = playSound
+                ? VideoAudioOutputMode.Direct
+                : VideoAudioOutputMode.None;
+            player.isLooping = loop;
+
+            currentIndex = Mathf.Min(currentIndex, videos.Length - 1);
+
+            StartVideo(currentIndex);
+        }
+
+        public override void Stop()
+        {
+            if (player == null)
+            {
+                return;
+            }
+            player.Stop();
+            Destroy(player.gameObject);
+            player = null;
+        }
+
+        public override void Next()
+        {
+            currentIndex = (currentIndex + 1) % videos.Length;
+            StartVideo(currentIndex);
+        }
+
+        private void StartVideo(int index)
+        {
+            var data = videos[index];
+            VideoSource source = data.Source;
+            player.source = source;
+            if (source == VideoSource.Url)
+            {
+                player.url = data.URL;
+            }
+            else
+            {
+                player.clip = data.clip;
+            }
+            player.Prepare();
+            player.Play();
+
+            currentFrame = -1;
+        }
+    }
+}

package/Runtime/VideoTextureSource.cs.meta

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

package/Runtime/VirtualTextureSource.cs

@@ -0,0 +1,131 @@
+namespace TextureSource
+{
+    using UnityEngine;
+    using UnityEngine.Events;
+    using UnityEngine.Scripting;
+
+    /// <summary>
+    /// Virtual Texture Source
+    /// </summary>
+    public class VirtualTextureSource : MonoBehaviour
+    {
+        [System.Serializable]
+        public class TextureEvent : UnityEvent<Texture> { }
+        [System.Serializable]
+        public class AspectChangeEvent : UnityEvent<float> { }
+
+        [SerializeField]
+        [Tooltip("A texture source scriptable object")]
+        private BaseTextureSource source = default;
+
+        [SerializeField]
+        [Tooltip("A texture source scriptable object for Editor. If it is null, used source in Editor")]
+        private BaseTextureSource sourceForEditor = null;
+
+        [SerializeField]
+        [Tooltip("If true, the texture is trimmed to the screen aspect ratio. Use this to show in full screen")]
+        private bool trimToScreenAspect = false;
+
+        [Tooltip("Event called when texture updated")]
+        public TextureEvent OnTexture = new TextureEvent();
+
+        [Tooltip("Event called when the aspect ratio changed")]
+        public AspectChangeEvent OnAspectChange = new AspectChangeEvent();
+
+        private ITextureSource activeSource;
+        private float aspect = float.NegativeInfinity;
+        private TextureTransformer transformer;
+
+        public bool DidUpdateThisFrame => activeSource.DidUpdateThisFrame;
+        public Texture Texture => activeSource.Texture;
+
+        private void OnEnable()
+        {
+            activeSource = sourceForEditor != null && Application.isEditor
+                ? sourceForEditor
+                : source;
+
+            if (activeSource == null)
+            {
+                Debug.LogError("Source is not set.", this);
+                enabled = false;
+                return;
+            }
+            activeSource.Start();
+        }
+
+        private void OnDisable()
+        {
+            activeSource?.Stop();
+            transformer?.Dispose();
+            transformer = null;
+        }
+
+        private void Update()
+        {
+            if (!activeSource.DidUpdateThisFrame)
+            {
+                return;
+            }
+
+            Texture tex = trimToScreenAspect
+                ? TrimToScreen(Texture)
+                : Texture;
+            OnTexture?.Invoke(tex);
+
+            float aspect = (float)tex.width / tex.height;
+            if (aspect != this.aspect)
+            {
+                OnAspectChange?.Invoke(aspect);
+                this.aspect = aspect;
+            }
+        }
+
+        // Invoked by UI Events
+        [Preserve]
+        public void NextSource()
+        {
+            activeSource?.Next();
+        }
+
+        private Texture TrimToScreen(Texture texture)
+        {
+            float cameraAspect = (float)texture.width / texture.height;
+            float targetAspect = (float)Screen.width / Screen.height;
+
+            if (Mathf.Abs(cameraAspect - targetAspect) < 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);
+            }
+
+            bool needInitialize = transformer == null || width != transformer.width || height != transformer.height;
+            if (needInitialize)
+            {
+                transformer?.Dispose();
+                transformer = new TextureTransformer(width, height);
+            }
+
+            return transformer.Transform(texture, Vector2.zero, 0, scale);
+        }
+
+        private static int RoundToEven(float n)
+        {
+            return Mathf.RoundToInt(n / 2) * 2;
+        }
+    }
+}

package/Runtime/VirtualTextureSource.cs.meta

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

package/Runtime/WebCamTextureSource.cs

@@ -0,0 +1,156 @@
+namespace TextureSource
+{
+    using System;
+    using System.Linq;
+    using UnityEngine;
+
+    [CreateAssetMenu(menuName = "ScriptableObject/Texture Source/WebCam", fileName = "WebCamTextureSource")]
+    public sealed class WebCamTextureSource : BaseTextureSource
+    {
+        [Flags]
+        public enum WebCamKindFlag
+        {
+            WideAngle = 1 << 0,
+            Telephoto = 1 << 1,
+            ColorAndDepth = 1 << 2,
+            UltraWideAngle = 1 << 3,
+        }
+
+        [Flags]
+        public enum FacingFlag
+        {
+            Front = 1 << 0,
+            Back = 1 << 1,
+        }
+
+        [SerializeField]
+        private WebCamKindFlag kindFilter = WebCamKindFlag.WideAngle | WebCamKindFlag.Telephoto | WebCamKindFlag.UltraWideAngle;
+
+        [SerializeField]
+        private FacingFlag facingFilter = FacingFlag.Front | FacingFlag.Back;
+
+        [SerializeField]
+        private Vector2Int resolution = new Vector2Int(1270, 720);
+
+        [SerializeField]
+        private int frameRate = 60;
+
+        public override bool DidUpdateThisFrame
+        {
+            get
+            {
+                if (webCamTexture == null || webCamTexture.width < 20)
+                {
+                    // On macOS, it returns the 10x10 texture at first several frames.
+                    return false;
+                }
+                return webCamTexture.didUpdateThisFrame;
+            }
+        }
+
+        public override Texture Texture => NormalizeWebCam();
+
+        private WebCamDevice[] devices;
+        private WebCamTexture webCamTexture;
+        private int currentIndex;
+        private TextureTransformer transformer;
+        private int lastUpdatedFrame = -1;
+        private bool isFrontFacing;
+
+        public override void Start()
+        {
+            devices = WebCamTexture.devices.Where(IsMatchFilter).ToArray();
+            StartCamera(currentIndex);
+        }
+
+        public override void Stop()
+        {
+            if (webCamTexture != null)
+            {
+                webCamTexture.Stop();
+                webCamTexture = null;
+            }
+            transformer?.Dispose();
+            transformer = null;
+        }
+
+        public override void Next()
+        {
+            currentIndex = (currentIndex + 1) % devices.Length;
+            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)
+            {
+                return null;
+            }
+
+            if (lastUpdatedFrame == Time.frameCount)
+            {
+                return transformer.Texture;
+            }
+
+            bool isPortrait = webCamTexture.videoRotationAngle == 90 || webCamTexture.videoRotationAngle == 270;
+            int width = webCamTexture.width;
+            int height = webCamTexture.height;
+            if (isPortrait)
+            {
+                (width, height) = (height, width); // swap
+            }
+
+            bool needInitialize = transformer == null || width != transformer.width || height != transformer.height;
+            if (needInitialize)
+            {
+                transformer?.Dispose();
+                transformer = new TextureTransformer(width, height);
+            }
+
+            Vector2 scale;
+            if (isPortrait)
+            {
+                scale = new Vector2(webCamTexture.videoVerticallyMirrored ^ isFrontFacing ? -1 : 1, 1);
+            }
+            else
+            {
+                scale = new Vector2(isFrontFacing ? -1 : 1, webCamTexture.videoVerticallyMirrored ? -1 : 1);
+            }
+            transformer.Transform(webCamTexture, Vector2.zero, -webCamTexture.videoRotationAngle, scale);
+
+            // Debug.Log($"mirrored: {webCamTexture.videoVerticallyMirrored}, angle: {webCamTexture.videoRotationAngle}, isFrontFacing: {isFrontFacing}");
+
+            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/Runtime/WebCamTextureSource.cs.meta

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

package/Runtime.meta

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

package/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "com.github.asus4.texture-source",
+  "displayName": "TextureSource",
+  "author": "Koki Ibukuro",
+  "description": "Virtual Texture Source",
+  "keywords": [
+    "unity"
+  ],
+  "license": "SEE LICENSE IN LICENSE",
+  "unity": "2020.3",
+  "unityRelease": "0f1",
+  "version": "0.1.0",
+  "type": "tool"
+}

package/package.json.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 8e276f3eafd064b0ea82dc12d7dc73b9
+PackageManifestImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: