com.github.asus4.texture-source 0.3.5 → 0.3.6-rc4

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2022 Koki Ibukuro
+Copyright (c) 2026 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

package/Runtime/BaseTextureSource.cs

@@ -12,5 +12,23 @@ namespace TextureSource
         public abstract void Start();
         public abstract void Stop();
         public abstract void Next();
+
+        /// <summary>
+        /// The transform matrix that is applied in the <see cref="TextureTransformer"/>.
+        /// Defaults to identity matrix.
+        /// </summary>
+        public virtual Matrix4x4 TransformMatrix => Matrix4x4.identity;
+
+        /// <summary>
+        /// The size after transform. Defaults to the texture size.
+        /// </summary>
+        public virtual Vector2Int TransformSize
+        {
+            get
+            {
+                Texture tex = Texture;
+                return tex == null ? Vector2Int.zero : new Vector2Int(tex.width, tex.height);
+            }
+        }
     }
 }

package/Runtime/TextureTransformer.cs

@@ -83,12 +83,21 @@ namespace TextureSource
         /// <param name="scale">A scale</param>
         /// <returns>The transformed texture</returns>
         public RenderTexture Transform(Texture input, Vector2 offset, float eulerRotation, Vector2 scale)
+        {
+            return Transform(input, BuildMatrix(offset, eulerRotation, scale));
+        }
+
+        /// <summary>
+        /// Build a destination-UV → source-UV sampling matrix from offset, rotation, and scale.
+        /// Same convention used by <see cref="Transform(Texture, Vector2, float, Vector2)"/>.
+        /// </summary>
+        public static Matrix4x4 BuildMatrix(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);
+            return PopMatrix * trs * PushMatrix;
         }
 
         /// <summary>

package/Runtime/VirtualTextureSource.cs

@@ -32,7 +32,7 @@ namespace TextureSource
         [Tooltip("Event called when the aspect ratio changed")]
         public AspectChangeEvent OnAspectChange = new AspectChangeEvent();
 
-        private ITextureSource activeSource;
+        private BaseTextureSource activeSource;
         private float aspect = float.NegativeInfinity;
         private TextureTransformer transformer;
 
@@ -67,7 +67,11 @@ namespace TextureSource
 
         private void OnDisable()
         {
-            activeSource?.Stop();
+            if (activeSource != null)
+            {
+                activeSource.Stop();
+                activeSource = null;
+            }
             transformer?.Dispose();
             transformer = null;
         }
@@ -79,9 +83,7 @@ namespace TextureSource
                 return;
             }
 
-            Texture tex = trimToScreenAspect
-                ? TrimToScreen(Texture)
-                : Texture;
+            Texture tex = Transform();
             OnTexture?.Invoke(tex);
 
             float aspect = (float)tex.width / tex.height;
@@ -99,33 +101,52 @@ namespace TextureSource
             activeSource?.Next();
         }
 
-        private Texture TrimToScreen(Texture texture)
+        private Texture Transform()
         {
-            float srcAspect = (float)texture.width / texture.height;
-            float dstAspect = (float)Screen.width / Screen.height;
+            Texture originalTex = activeSource.Texture;
+            Matrix4x4 transformMatrix = activeSource.TransformMatrix;
+            Vector2Int transformSize = activeSource.TransformSize;
+
+            bool needTrim = false;
+            Vector2Int dstSize = transformSize;
+            Matrix4x4 matrix = transformMatrix;
 
-            // Allow 1% mismatch
-            if (Mathf.Abs(srcAspect - dstAspect) < 0.01f)
+            if (trimToScreenAspect)
             {
-                return texture;
+                float srcAspect = (float)transformSize.x / transformSize.y;
+                float dstAspect = (float)Screen.width / Screen.height;
+                // Allow 1% mismatch
+                needTrim = Mathf.Abs(srcAspect - dstAspect) >= 0.01f;
+                if (needTrim)
+                {
+                    Utils.GetTargetSizeScale(transformSize, dstAspect, out dstSize, out Vector2 scale);
+                    var trimMatrix = TextureTransformer.BuildMatrix(Vector2.zero, 0, scale);
+                    matrix = transformMatrix * trimMatrix;
+                }
             }
 
-            Utils.GetTargetSizeScale(
-                new Vector2Int(texture.width, texture.height), dstAspect,
-                out Vector2Int dstSize, out Vector2 scale);
-
-            bool needInitialize = transformer == null || dstSize.x != transformer.width || dstSize.y != transformer.height;
-            if (needInitialize)
+            if (!needTrim && transformMatrix.isIdentity)
             {
-                transformer?.Dispose();
-                // 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 originalTex;
             }
 
-            return transformer.Transform(texture, Vector2.zero, 0, scale);
+            EnsureTransformer(dstSize, originalTex);
+            return transformer.Transform(originalTex, matrix);
+        }
+
+        private void EnsureTransformer(Vector2Int size, Texture tex)
+        {
+            if (transformer != null && transformer.width == size.x && transformer.height == size.y)
+            {
+                // No need to recreate
+                return;
+            }
+            // Recreate transformer with new size
+            transformer?.Dispose();
+            RenderTextureFormat format = (tex is RenderTexture renderTex)
+                ? renderTex.format
+                : RenderTextureFormat.ARGB32;
+            transformer = new TextureTransformer(size.x, size.y, format);
         }
     }
 }

package/Runtime/WebCamTextureSource.cs

@@ -50,14 +50,33 @@ namespace TextureSource
             }
         }
 
-        public override Texture Texture => NormalizeWebCam();
+        public override Texture Texture => webCamTexture;
+
+        public override Matrix4x4 TransformMatrix
+        {
+            get
+            {
+                EnsureNormalizeCacheFresh();
+                return transformMatrix;
+            }
+        }
+
+        public override Vector2Int TransformSize
+        {
+            get
+            {
+                EnsureNormalizeCacheFresh();
+                return transformSize;
+            }
+        }
 
         private WebCamDevice[] devices;
         private WebCamTexture webCamTexture;
         private int currentIndex;
-        private TextureTransformer transformer;
         private int lastUpdatedFrame = -1;
         private bool isFrontFacing;
+        private Matrix4x4 transformMatrix = Matrix4x4.identity;
+        private Vector2Int transformSize;
 
         public CameraFacing[] FacingPriorities
         {
@@ -125,8 +144,7 @@ namespace TextureSource
                 webCamTexture.Stop();
                 webCamTexture = null;
             }
-            transformer?.Dispose();
-            transformer = null;
+            lastUpdatedFrame = -1;
         }
 
         public override void Next()
@@ -135,16 +153,17 @@ namespace TextureSource
             StartCamera(currentIndex);
         }
 
-        private RenderTexture NormalizeWebCam()
+        private void EnsureNormalizeCacheFresh()
         {
             if (webCamTexture == null)
             {
-                return null;
+                transformSize = Vector2Int.zero;
+                transformMatrix = Matrix4x4.identity;
+                return;
             }
-
             if (lastUpdatedFrame == Time.frameCount)
             {
-                return transformer.Texture;
+                return;
             }
 
             bool isPortrait = webCamTexture.videoRotationAngle == 90 || webCamTexture.videoRotationAngle == 270;
@@ -154,13 +173,7 @@ namespace TextureSource
             {
                 (width, height) = (height, width); // swap
             }
-
-            bool needInitialize = transformer == null || width != transformer.width || height != transformer.height;
-            if (needInitialize)
-            {
-                transformer?.Dispose();
-                transformer = new TextureTransformer(width, height, RenderTextureFormat.ARGB32);
-            }
+            transformSize = new Vector2Int(width, height);
 
             Vector2 scale;
             if (isPortrait)
@@ -171,12 +184,9 @@ namespace TextureSource
             {
                 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}");
+            transformMatrix = TextureTransformer.BuildMatrix(Vector2.zero, -webCamTexture.videoRotationAngle, scale);
 
             lastUpdatedFrame = Time.frameCount;
-            return transformer.Texture;
         }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.github.asus4.texture-source",
-  "version": "0.3.5",
+  "version": "0.3.6-rc4",
   "displayName": "TextureSource",
   "description": "Simplify WebCamera and test video handling for using Computer Vision in Unity",
   "unity": "2020.3",
@@ -11,6 +11,11 @@
   ],
   "documentationUrl": "https://github.com/asus4/TextureSource/tree/main",
   "changelogUrl": "https://github.com/asus4/TextureSource/releases",
+  "repository": {
+    "url": "https://github.com/asus4/TextureSource",
+    "type": "git",
+    "revision": "16b280c6c160c50c1f0d9a1458514de9c4b3c0be"
+  },
   "license": "MIT",
   "licensesUrl": "https://github.com/asus4/TextureSource/blob/main/Packages/com.github.asus4.texture-source/LICENSE",
   "author": {
@@ -19,10 +24,5 @@
   },
   "dependencies": {
     "com.unity.modules.video": "1.0.0"
-  },
-  "repository": {
-    "url": "git@github.com:asus4/TextureSource.git",
-    "type": "git",
-    "revision": "3e3715d52fe0d78fdb0c63aa5671d7d5d6cac2d0"
   }
 }