upload cursor texture in native plugin.

Assets/uDesktopDuplication/Examples/Scenes/Meta Data.unity.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: aac40d1b58f3f8940be815779d89b5a4
+timeCreated: 1479544409
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/uDesktopDuplication/Examples/Scripts/GazePointAnalyzer.cs

@@ -0,0 +1,181 @@
+using UnityEngine;
+using MeshForwardDirection = uDesktopDuplication.Texture.MeshForwardDirection;
+
+[RequireComponent(typeof(uDesktopDuplication.Texture))]
+public class GazePointAnalyzer : MonoBehaviour
+{
+    uDesktopDuplication.Texture uddTexture_;
+
+    [Tooltip("This needs a small calculation cost.")]
+    public bool calcAveragePos = true;
+
+    private Vector2 averageCoord_ = Vector2.zero;
+    private Vector2 averageCoordVelocity_ = Vector2.zero;
+    public Vector3 averagePos
+    {
+        get { return GetWorldPositionFromCoord((int)averageCoord_.x, (int)averageCoord_.y); }
+    }
+    private Vector2 preCursorCoord_ = Vector2.zero;
+
+    [Header("Filters")]
+    [Range(0f, 1f)] public float moveRectFilter = 0.05f;
+    [Range(0f, 1f)] public float mouseFilter = 0.05f;
+    [Range(0f, 1f)] public float dirtyRectFilter = 0.01f;
+    [Range(0f, 1f)] public float noEventFilter = 0.01f;
+    [Range(0f, 1f)] public float velocityFilter = 0.1f;
+
+    [Header("Debug")]
+    public bool drawAveragePos;
+    public bool drawMoveRects;
+    public bool drawDirtyRects;
+
+    void Start()
+    {
+        uddTexture_ = GetComponent<uDesktopDuplication.Texture>();
+        averageCoord_ = new Vector2(uddTexture_.monitor.width / 2, uddTexture_.monitor.height / 2);
+    }
+
+    public Vector3 GetWorldPositionFromCoord(int u, int v)
+    {
+        var monitor = uddTexture_.monitor;
+
+        // Mesh & Scale information
+        var mesh = GetComponent<MeshFilter>().sharedMesh;
+        var width  = transform.localScale.x * (mesh.bounds.extents.x * 2f);
+        var height = transform.localScale.y * (mesh.bounds.extents.y * 2f);
+
+        // Local position (scale included).
+        var x =  (float)(u - monitor.width  / 2) / monitor.width;
+        var y = -(float)(v - monitor.height / 2) / monitor.height;
+        var localPos = new Vector3(width * x, height * y, 0f);
+
+        // Bending
+        if (uddTexture_.bend) {
+            var radius = uddTexture_.radius;
+            var angle = localPos.x / radius;
+            if (uddTexture_.meshForwardDirection == MeshForwardDirection.Y) {
+                localPos.y -= radius * (1f - Mathf.Cos(angle));
+            } else {
+                localPos.z -= radius * (1f - Mathf.Cos(angle));
+            }
+            localPos.x  = radius * Mathf.Sin(angle);
+        }
+
+        // To world position
+        return transform.position + (transform.rotation * localPos);
+    }
+
+    void CalcAveragePos()
+    {
+        if (!calcAveragePos) return;
+
+        var coord = Vector2.zero;
+        var monitor = uddTexture_.monitor;
+        var cursorCoord = new Vector2(monitor.cursorX, monitor.cursorY);
+        var filter = 0f;
+
+        // move rect
+        if (monitor.moveRectCount > 0) {
+            foreach (var rects in monitor.moveRects) {
+                var rect = rects.destination;
+                var center = new Vector2(
+                    (rect.right  + rect.left) / 2, 
+                    (rect.bottom + rect.top)  / 2);
+                coord += center;
+            }
+            coord /= monitor.moveRectCount;
+            filter = moveRectFilter;
+        } 
+        // mouse
+        else if (
+            monitor.isCursorVisible && 
+            cursorCoord != preCursorCoord_ &&
+            (cursorCoord - preCursorCoord_).magnitude > 5 &&
+            monitor.cursorX >= 0 && 
+            monitor.cursorY >= 0) 
+        {
+            coord = cursorCoord;
+            filter = mouseFilter;
+        } 
+        // dirty rect
+        else if (monitor.dirtyRectCount > 0) {
+            var totalWeights = 0f;
+            foreach (var rect in monitor.dirtyRects) {
+                var center = new Vector2(
+                    (rect.right  + rect.left) / 2, 
+                    (rect.bottom + rect.top)  / 2);
+                var weight = 1f / Mathf.Sqrt((rect.right - rect.left) * (rect.bottom - rect.top));
+                coord += center * weight;
+                totalWeights += weight;
+            }
+            coord /= totalWeights;
+            filter = dirtyRectFilter;
+        } 
+        // no event
+        else {
+            coord = new Vector2(monitor.width / 2, monitor.height / 2);
+            filter = noEventFilter;
+        }
+
+        var cf = (filter / ((1f / 60) / Time.deltaTime));
+        var vf = (velocityFilter / ((1f / 60) / Time.deltaTime));
+        var targetCoord = averageCoord_ + (coord - averageCoord_) * cf;
+        var targetVelocity = targetCoord - averageCoord_;
+
+        if (float.IsNaN(targetCoord.x) || float.IsNaN(targetCoord.y)) return;
+        if (float.IsNaN(targetVelocity.x) || float.IsNaN(targetVelocity.y)) return;
+
+        averageCoordVelocity_ += (targetVelocity - averageCoordVelocity_) * vf;
+        averageCoord_ += averageCoordVelocity_;
+        averageCoord_.x = Mathf.Clamp(averageCoord_.x, 0, monitor.width);
+        averageCoord_.y = Mathf.Clamp(averageCoord_.y, 0, monitor.height);
+
+        preCursorCoord_ = cursorCoord;
+    }
+
+    void Update()
+    {
+        CalcAveragePos();
+        DebugDraw();
+    }
+
+    void DebugDraw()
+    {
+        if (drawAveragePos) DrawAveragePos();
+        if (drawDirtyRects) DrawDirtyRects();
+        if (drawMoveRects)  DrawMoveRects();
+    }
+
+    void DrawRect(uDesktopDuplication.RECT rect, Color color)
+    {
+        var p0 = GetWorldPositionFromCoord(rect.left,  rect.top);
+        var p1 = GetWorldPositionFromCoord(rect.right, rect.top);
+        var p2 = GetWorldPositionFromCoord(rect.right, rect.bottom);
+        var p3 = GetWorldPositionFromCoord(rect.left,  rect.bottom);
+
+        Debug.DrawLine(p0, p1, color);
+        Debug.DrawLine(p1, p2, color);
+        Debug.DrawLine(p2, p3, color);
+        Debug.DrawLine(p3, p0, color);
+    }
+
+    void DrawAveragePos()
+    {
+        Debug.DrawLine(transform.position, averagePos, Color.yellow);
+    }
+
+    void DrawMoveRects()
+    {
+        foreach (var rect in uddTexture_.monitor.moveRects) {
+            DrawRect(rect.source, Color.blue);
+            DrawRect(rect.destination, Color.green);
+        }
+    }
+
+    void DrawDirtyRects()
+    {
+        foreach (var rect in uddTexture_.monitor.dirtyRects) {
+            DrawRect(rect, Color.red);
+        }
+    }
+}

Assets/uDesktopDuplication/Examples/Scripts/GazePointAnalyzer.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 52d402bdca823cc42925c9d65993ee59
+timeCreated: 1479546123
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/uDesktopDuplication/Examples/Scripts/Loupe.cs

@@ -1,18 +1,22 @@
 using UnityEngine;
 
+[RequireComponent(typeof(uDesktopDuplication.Texture)),
+ RequireComponent(typeof(uDesktopDuplication.Cursor))]
 public class Loupe : MonoBehaviour
 {
     private uDesktopDuplication.Texture uddTexture_;
+    private uDesktopDuplication.Cursor uddCursor_;
     public float zoom = 3f;
     public float aspect = 1f;
 
     void Start()
     {
         uddTexture_ = GetComponent<uDesktopDuplication.Texture>();
+        uddCursor_  = GetComponent<uDesktopDuplication.Cursor>();
         uddTexture_.useClip = true;
     }
 
-    void Update()
+    void LateUpdate()
     {
         CheckVariables();
 
@@ -26,11 +30,12 @@ public class Loupe : MonoBehaviour
         }
 
         var monitor = uddTexture_.monitor;
-        var cursorX = monitor.isCursorVisible ? monitor.cursorX : monitor.systemCursorX;
-        var cursorY = monitor.isCursorVisible ? monitor.cursorY : monitor.systemCursorY;
-
-        var x = (float)cursorX / monitor.width;
-        var y = (float)cursorY / monitor.height;
+        var x = monitor.isCursorVisible ? 
+            uddCursor_.coord.x : 
+            (float)monitor.systemCursorX / monitor.width;
+        var y = monitor.isCursorVisible ? 
+            uddCursor_.coord.y : 
+            (float)monitor.systemCursorY / monitor.height;
         var w = 1f / zoom;
         var h = w / aspect * monitor.aspect;
         x = Mathf.Clamp(x - w / 2, 0f, 1f - w);
@@ -40,7 +45,7 @@ public class Loupe : MonoBehaviour
     }
 
     void CheckVariables()
-    {
+    {
         if (zoom < 1f) zoom = 1f;
         if (aspect < 0.01f) aspect = 0.01f;
     }

Assets/uDesktopDuplication/Examples/Scripts/MultipleMonitorAnalyzer.cs

@@ -0,0 +1,69 @@
+using UnityEngine;
+
+[RequireComponent(typeof(MultipleMonitorCreator))]
+public class MultipleMonitorAnalyzer : MonoBehaviour
+{
+    MultipleMonitorCreator creator_;
+    Vector3 gazePoint_ = Vector3.zero;
+    public Vector3 gazePoint 
+    { 
+        get { return gazePoint_; } 
+        private set 
+        {
+            gazePoint_ += (value - gazePoint) * (gazePointFilter / (1f / 60 / Time.deltaTime));
+        }
+    }
+
+    [Header("Filters")]
+    [Range(0f, 1f)] public float gazePointFilter = 0.1f;
+    [Range(0f, 1f)] public float moveRectFilter = 0.05f;
+    [Range(0f, 1f)] public float mouseFilter = 0.05f;
+    [Range(0f, 1f)] public float dirtyRectFilter = 0.01f;
+    [Range(0f, 1f)] public float noEventFilter = 0.01f;
+    [Range(0f, 1f)] public float velocityFilter = 0.1f;
+
+    [Header("Debug")]
+    [SerializeField] bool drawGazePoint;
+    [SerializeField] bool drawAveragePos;
+    [SerializeField] bool drawMoveRects;
+    [SerializeField] bool drawDirtyRects;
+
+    void Start()
+    {
+        creator_ = GetComponent<MultipleMonitorCreator>();
+    }
+
+    void Update()
+    {
+        var cursorMonitorId = uDesktopDuplication.Manager.cursorMonitorId;
+        for (int i = 0; i < creator_.monitors.Count; ++i) {
+            var info = creator_.monitors[i];
+            var analyzer = 
+                info.gameObject.GetComponent<GazePointAnalyzer>() ??
+                info.gameObject.AddComponent<GazePointAnalyzer>();
+            UpdateAnalyzer(analyzer);
+            if (info.uddTexture.monitorId == cursorMonitorId) {
+                gazePoint = analyzer.averagePos;
+            }
+        }
+
+        if (drawGazePoint) DrawGazePoint();
+    }
+
+    void DrawGazePoint()
+    {
+        Debug.DrawLine(transform.position, gazePoint, Color.magenta);
+    }
+
+    void UpdateAnalyzer(GazePointAnalyzer analyzer)
+    {
+        analyzer.moveRectFilter = moveRectFilter;
+        analyzer.mouseFilter = mouseFilter;
+        analyzer.dirtyRectFilter = dirtyRectFilter;
+        analyzer.noEventFilter = noEventFilter;
+        analyzer.velocityFilter = velocityFilter;
+        analyzer.drawAveragePos = drawAveragePos;
+        analyzer.drawMoveRects = drawMoveRects;
+        analyzer.drawDirtyRects = drawDirtyRects;
+    }
+}

Assets/uDesktopDuplication/Examples/Scripts/MultipleMonitorAnalyzer.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: dbdfccef47068644b81b671bb4e6e166
+timeCreated: 1479620455
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/uDesktopDuplication/Examples/Scripts/MultipleMonitorCreator.cs

@@ -1,12 +1,13 @@
 using UnityEngine;
+using UnityEngine.Assertions;
 using System.Collections.Generic;
 using MeshForwardDirection = uDesktopDuplication.Texture.MeshForwardDirection;
+using MonitorState = uDesktopDuplication.MonitorState;
 
 public class MultipleMonitorCreator : MonoBehaviour
 {
     [Tooltip("Create monitors using this prefab.")]
-    [SerializeField] 
-    GameObject monitorPrefab;
+    public GameObject monitorPrefab;
 
     public enum ScaleMode
     {
@@ -16,35 +17,31 @@ public class MultipleMonitorCreator : MonoBehaviour
     }
 
     [Tooltip("Real: DPI-based real scale \nFixed: Same width \nPixel: bigger if screen resolution is high.")]
-    [SerializeField] 
-    ScaleMode scaleMode = ScaleMode.Fixed;
+    public ScaleMode scaleMode = ScaleMode.Fixed;
 
-    [Tooltip("Use this sacle as width if scaleMode is Fixed.")]
-    [SerializeField] 
-    float scale = 0.5f;
+    [Tooltip("Use this scale as width if scaleMode is Fixed.")]
+    public float scale = 0.5f;
 
     [Tooltip("Please specify the surface direction of the mesh (e.g. Plane => Y.)")]
     public MeshForwardDirection meshForwardDirection = MeshForwardDirection.Z;
 
     [Tooltip("Remove unsupported monitors automatically after removeWaitDuration.")]
-    [SerializeField] 
-    bool removeIfUnsupported = true;
+    public bool removeIfUnsupported = true;
 
     [Tooltip("Remove unsupported monitors automatically after removeWaitDuration.")]
-    [SerializeField] 
-    float removeWaitDuration = 5f;
+    public float removeWaitDuration = 5f;
 
     [Tooltip("Remove all childrens (for debug).")]
-    [SerializeField] 
-    bool removeChildrenWhenClear = true;
+    public bool removeChildrenWhenClear = true;
 
-    bool hasMonitorUnsupportStateChecked = false;
+    bool hasMonitorUnsupportStateChecked_ = false;
     float removeWaitTimer_ = 0f;
 
     public class MonitorInfo
     {
         public GameObject gameObject { get; set; }
         public Quaternion originalRotation { get; set; }
+        public Vector3 originalLocalScale { get; set; }
         public uDesktopDuplication.Texture uddTexture { get; set; }
         public Mesh mesh { get; set; }
     }
@@ -52,6 +49,15 @@ public class MultipleMonitorCreator : MonoBehaviour
     private List<MonitorInfo> monitors_ = new List<MonitorInfo>();
     public List<MonitorInfo> monitors { get { return monitors_; } }
 
+    public class SavedMonitorInfo
+    {
+        public float widthScale = 1f;
+        public float heightScale = 1f;
+    }
+
+    private List<SavedMonitorInfo> savedInfoList_ = new List<SavedMonitorInfo>();
+    public List<SavedMonitorInfo> savedInfoList { get { return savedInfoList_; } }
+
     void Start()
     {
         uDesktopDuplication.Manager.CreateInstance();
@@ -81,23 +87,23 @@ public class MultipleMonitorCreator : MonoBehaviour
 
     void RemoveUnsupportedDisplayAfterRemoveTimer()
     {
-        if (!hasMonitorUnsupportStateChecked) {
+        if (!hasMonitorUnsupportStateChecked_) {
             removeWaitTimer_ += Time.deltaTime;
             if (removeWaitTimer_ > removeWaitDuration) {
-                hasMonitorUnsupportStateChecked = true;
-                foreach (var info in monitors_) {
-                    if (info.uddTexture.monitor.state == uDesktopDuplication.MonitorState.Unsupported) {
+                hasMonitorUnsupportStateChecked_ = true;
+                foreach (var info in monitors) {
+                    if (info.uddTexture.monitor.state == MonitorState.Unsupported) {
                         Destroy(info.gameObject);
                     }
                 }
-                monitors_.RemoveAll(info => info.uddTexture.monitor.state == uDesktopDuplication.MonitorState.Unsupported);
+                monitors.RemoveAll(info => info.uddTexture.monitor.state == MonitorState.Unsupported);
             }
         }
     }
 
     void ResetRemoveTimer()
     {
-        hasMonitorUnsupportStateChecked = false;
+        hasMonitorUnsupportStateChecked_ = false;
         removeWaitTimer_ = 0f;
     }
 
@@ -106,13 +112,21 @@ public class MultipleMonitorCreator : MonoBehaviour
         ResetRemoveTimer();
 
         // Create monitors
-        for (int i = 0; i < uDesktopDuplication.Manager.monitorCount; ++i) {
+        var n = uDesktopDuplication.Manager.monitors.Count;
+        for (int i = 0; i < n; ++i) {
             // Create monitor obeject
             var go = Instantiate(monitorPrefab);
             go.name = "Monitor " + i;
 
+            // Saved infomation
+            if (savedInfoList.Count == i) {
+                savedInfoList.Add(new SavedMonitorInfo());
+                Assert.AreEqual(i, savedInfoList.Count - 1);
+            }
+            var savedInfo = savedInfoList[i];
+
             // Expand AABB
-            var mesh = go.GetComponent<MeshFilter>().sharedMesh;
+            var mesh = go.GetComponent<MeshFilter>().mesh; // clone
             var aabbScale = mesh.bounds.size;
             aabbScale.y = Mathf.Max(aabbScale.y, aabbScale.x);
             aabbScale.z = Mathf.Max(aabbScale.z, aabbScale.x);
@@ -131,14 +145,18 @@ public class MultipleMonitorCreator : MonoBehaviour
                     height = monitor.heightMeter;
                     break;
                 case ScaleMode.Fixed:
-                    width = scale * (monitor.isHorizontal ? 1f : monitor.aspect);
-                    height = scale * (monitor.isHorizontal ? 1f / monitor.aspect : 1f);
+                    width = scale * (monitor.isHorizontal ? monitor.aspect : 1f);
+                    height = scale * (monitor.isHorizontal ? 1f : 1f / monitor.aspect);
                     break;
                 case ScaleMode.Pixel:
                     width = scale * (monitor.isHorizontal ? 1f : monitor.aspect) * ((float)monitor.width / 1920);
                     height = scale * (monitor.isHorizontal ? 1f / monitor.aspect : 1f) * ((float)monitor.width / 1920);
                     break;
             }
+
+            width *= savedInfo.widthScale;
+            height *= savedInfo.heightScale;
+
             if (meshForwardDirection == MeshForwardDirection.Y) {
                 go.transform.localScale = new Vector3(width, go.transform.localScale.y, height);
             } else {
@@ -152,18 +170,19 @@ public class MultipleMonitorCreator : MonoBehaviour
             var info = new MonitorInfo();
             info.gameObject = go;
             info.originalRotation = go.transform.rotation;
+            info.originalLocalScale = go.transform.localScale;
             info.uddTexture = texture;
             info.mesh = mesh;
-            monitors_.Add(info);
+            monitors.Add(info);
         }
 
         // Sort monitors in coordinate order
-        monitors_.Sort((a, b) => a.uddTexture.monitor.left - b.uddTexture.monitor.left);
+        monitors.Sort((a, b) => a.uddTexture.monitor.left - b.uddTexture.monitor.left);
     }
 
     void Clear()
     {
-        foreach (var info in monitors_) {
+        foreach (var info in monitors) {
             Destroy(info.gameObject);
         }
         if (removeChildrenWhenClear) {
@@ -171,7 +190,7 @@ public class MultipleMonitorCreator : MonoBehaviour
                 Destroy(transform.GetChild(i).gameObject);
             }
         }
-        monitors_.Clear();
+        monitors.Clear();
     }
 
     [ContextMenu("Recreate")]

Assets/uDesktopDuplication/Examples/Scripts/MultipleMonitorLayouter.cs

@@ -4,9 +4,9 @@
 public class MultipleMonitorLayouter : MonoBehaviour
 {
     protected MultipleMonitorCreator creator_;
-    [SerializeField] bool updateEveryFrame = true;
-    [SerializeField] protected float margin = 0.1f;
-    [SerializeField][Range(0f, 10f)] protected float thickness = 1f;
+    public bool updateEveryFrame = true;
+    public float margin = 0.1f;
+    [Range(0f, 10f)] public float thickness = 1f;
 
     void Start()
     {
@@ -30,7 +30,7 @@ public class MultipleMonitorLayouter : MonoBehaviour
 
         var totalWidth = 0f;
         foreach (var info in monitors) {
-            var width = info.gameObject.transform.localEulerAngles.x * (info.mesh.bounds.extents.x * 2f);
+            var width = info.gameObject.transform.localScale.x * (info.mesh.bounds.extents.x * 2f);
             totalWidth += width;
         }
         totalWidth += margin * (n - 1);
@@ -38,7 +38,7 @@ public class MultipleMonitorLayouter : MonoBehaviour
         var x = -totalWidth / 2;
 
         foreach (var info in monitors) {
-            var width = info.gameObject.transform.localEulerAngles.x;
+            var width = info.gameObject.transform.localScale.x;
             x += (width * info.mesh.bounds.extents.x);
             info.gameObject.transform.localPosition = new Vector3(x, 0f, 0f);
             info.gameObject.transform.localRotation = info.originalRotation;

Assets/uDesktopDuplication/Examples/Scripts/MultipleMonitorRoundLayouter.cs

@@ -1,9 +1,12 @@
 using UnityEngine;
+using MeshForwardDirection = uDesktopDuplication.Texture.MeshForwardDirection;
 
 public class MultipleMonitorRoundLayouter : MultipleMonitorLayouter
 {
-    [SerializeField] float radius = 10f;
-    [SerializeField] Vector3 offsetAngle = Vector3.zero;
+    [SerializeField] bool debugDraw = true;
+
+    public float radius = 10f;
+    public Vector3 offsetAngle = Vector3.zero;
 
     void OnDisable()
     {
@@ -17,6 +20,28 @@ public class MultipleMonitorRoundLayouter : MultipleMonitorLayouter
         var monitors = creator_.monitors;
         var n = monitors.Count;
 
+        // Keep the local scale z of monitors as 1 to bend them correctly.
+        // And save width / height to use same values after reinitialization.
+        for (int i = 0; i < n; ++i) {
+            var info = monitors[i];
+            var savedInfo = creator_.savedInfoList[i];
+            var scale = info.gameObject.transform.localScale;
+            if (creator_.meshForwardDirection == MeshForwardDirection.Y) {
+                scale.y = 1f;
+                savedInfo.widthScale = scale.x / info.originalLocalScale.x;
+                savedInfo.heightScale = scale.z / info.originalLocalScale.z;
+            } else {
+                scale.z = 1f;
+                savedInfo.widthScale = scale.x / info.originalLocalScale.x;
+                savedInfo.heightScale = scale.y / info.originalLocalScale.y;
+            }
+            info.gameObject.transform.localScale = scale;
+        }
+
+        // keep thicness plus value.
+        thickness = Mathf.Max(thickness, 0f);
+
+        // calculate total width
         var totalWidth = 0f;
         foreach (var info in monitors) {
             var width = info.gameObject.transform.localScale.x * (info.mesh.bounds.extents.x * 2f);
@@ -24,9 +49,13 @@ public class MultipleMonitorRoundLayouter : MultipleMonitorLayouter
         }
         totalWidth += margin * (n - 1);
 
+        // expand radius if total width is larger than the circumference.
         radius = Mathf.Max(radius, (totalWidth + margin) / (2 * Mathf.PI));
+
+        // total angle of monitors
         var totalAngle = totalWidth / radius;
 
+        // layout
         float angle = -totalAngle / 2;
         var offsetRot = Quaternion.Euler(offsetAngle);
         foreach (var info in monitors) {
@@ -53,7 +82,12 @@ public class MultipleMonitorRoundLayouter : MultipleMonitorLayouter
     protected override void Update()
     {
         base.Update();
+        if (debugDraw) DebugDraw();
+    }
 
+    void DebugDraw()
+    {
+        // draw the circumference in the scene view.
         var scale = transform.localScale.x;
         var center = transform.position - Vector3.forward * radius * scale;
         for (int i = 0; i < 100; ++i) {

Assets/uDesktopDuplication/Examples/Scripts/ToggleMonitors.cs

@@ -6,10 +6,12 @@ public class ToggleMonitors : MonoBehaviour
     {
         if (Input.GetKeyDown(KeyCode.Tab)) {
             var texture = GetComponent<uDesktopDuplication.Texture>();
+            var id = texture.monitorId;
+            var n = uDesktopDuplication.Manager.monitorCount;
             if (Input.GetKey(KeyCode.LeftShift) || Input.GetKey(KeyCode.RightShift)) {
-                texture.monitorId--;
+                texture.monitorId = (id - 1 < 0) ? 0 : (id - 1);
             } else {
-                texture.monitorId++;
+                texture.monitorId = (id + 1 >= n) ? (n - 1) : (id + 1);
             }
         }
     }

Assets/uDesktopDuplication/Scripts/Cursor.cs

@@ -1,21 +1,18 @@
 using UnityEngine;
-using UnityEngine.Assertions;
-using System.Collections.Generic;
 
 namespace uDesktopDuplication
 {
 
-[AddComponentMenu("uDesktopDuplication/Cursor"), 
- RequireComponent(typeof(Texture))]
+[AddComponentMenu("uDesktopDuplication/Cursor"), RequireComponent(typeof(Texture))]
 public class Cursor : MonoBehaviour
 {
     [SerializeField] Vector2 modelScale = Vector2.one;
 
-    Vector3 worldPosition { get; set; }
+    public Vector3 worldPosition { get; set; }
+    public Vector2 coord { get; set; }
 
     private Texture uddTexture_;
     private Monitor monitor { get { return uddTexture_.monitor; } }
-    private Dictionary<int, Texture2D> textures_ = new Dictionary<int, Texture2D>();
 
     void Start()
     {
@@ -26,9 +23,8 @@ public class Cursor : MonoBehaviour
     {
         if (monitor.isCursorVisible) {
             UpdatePosition();
-            UpdateTexture();
         }
-        UpdateMaterial();
+        UpdateCoords();
     }
 
     void UpdatePosition()
@@ -40,32 +36,11 @@ public class Cursor : MonoBehaviour
         worldPosition = transform.TransformPoint(localPos);
     }
 
-    void UpdateTexture()
-    {
-        var w = monitor.cursorShapeWidth;
-        var h = monitor.cursorShapeHeight;
-        if (w == 0 || h == 0) return;
-
-        var key = w + h * 100;
-        if (!textures_.ContainsKey(key)) {
-            var texture = new Texture2D(w, h, TextureFormat.BGRA32, false);
-            texture.wrapMode = TextureWrapMode.Clamp;
-            textures_.Add(key, texture);
-        }
-
-        var cursorTexture = textures_[key];
-        Assert.IsNotNull(cursorTexture);
-        monitor.GetCursorTexture(cursorTexture.GetNativeTexturePtr());
-        uddTexture_.material.SetTexture("_CursorTex", cursorTexture);
-    }
-
-    void UpdateMaterial()
+    void UpdateCoords()
     {
         var x = monitor.isCursorVisible ? (float)monitor.cursorX / monitor.width : -9999f;
         var y = monitor.isCursorVisible ? (float)monitor.cursorY / monitor.height : -9999f;
-        var w = (float)monitor.cursorShapeWidth  / monitor.width;
-        var h = (float)monitor.cursorShapeHeight / monitor.height;
-        uddTexture_.material.SetVector("_CursorPositionScale", new Vector4(x, y, w, h));
+        coord = new Vector2(x, y);
     }
 }
 

Assets/uDesktopDuplication/Scripts/Lib.cs

@@ -14,6 +14,7 @@ public enum Message
 
 public enum CursorShapeType
 {
+    Unspecified = 0,
     MonoChrome = 1,
     Color = 2,
     MaskedColor = 4,
@@ -30,13 +31,13 @@ public enum MonitorRotation
 
 public enum MonitorState
 {
-	NotSet = -1,
-	Available = 0,
-	InvalidArg = 1,
-	AccessDenied = 2,
-	Unsupported = 3,
-	CurrentlyNotAvailable = 4,
-	SessionDisconnected = 5,
+    NotSet = -1,
+    Available = 0,
+    InvalidArg = 1,
+    AccessDenied = 2,
+    Unsupported = 3,
+    CurrentlyNotAvailable = 4,
+    SessionDisconnected = 5,
     AccessLost = 6,
     TextureSizeInconsistent = 7,
     Unknown = 999,
@@ -49,6 +50,26 @@ public enum DebugMode
     UnityLog = 2, /* currently has bug when app exits. */
 }
 
+[StructLayout(LayoutKind.Sequential)]
+public struct RECT
+{
+    [MarshalAs(UnmanagedType.I4)]
+    public int left;
+    [MarshalAs(UnmanagedType.I4)]
+    public int top;
+    [MarshalAs(UnmanagedType.I4)]
+    public int right;
+    [MarshalAs(UnmanagedType.I4)]
+    public int bottom;
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public struct DXGI_OUTDUPL_MOVE_RECT
+{
+    public RECT source;
+    public RECT destination;
+}
+
 public static class Lib
 {
     public delegate void MessageHandler(Message message);
@@ -133,6 +154,14 @@ public static class Lib
     public static extern void GetCursorTexture(int id, System.IntPtr ptr);
     [DllImport("uDesktopDuplication")]
     public static extern int SetTexturePtr(int id, IntPtr ptr);
+    [DllImport("uDesktopDuplication")]
+    public static extern int GetMoveRectCount(int id);
+    [DllImport("uDesktopDuplication", EntryPoint = "GetMoveRects")]
+    private static extern IntPtr GetMoveRects_Internal(int id);
+    [DllImport("uDesktopDuplication")]
+    public static extern int GetDirtyRectCount(int id);
+    [DllImport("uDesktopDuplication", EntryPoint = "GetDirtyRects")]
+    private static extern IntPtr GetDirtyRects_Internal(int id);
 
     public static string GetName(int id)
     {
@@ -140,6 +169,32 @@ public static class Lib
         GetName(id, buf, buf.Capacity);
         return buf.ToString();
     }
+
+    public static DXGI_OUTDUPL_MOVE_RECT[] GetMoveRects(int id)
+    {
+        var count = GetMoveRectCount(id);
+        var rects = new DXGI_OUTDUPL_MOVE_RECT[count];
+        var ptr = GetMoveRects_Internal(id);
+        var size = Marshal.SizeOf(typeof(DXGI_OUTDUPL_MOVE_RECT));
+        for (int i = 0; i < count; ++i) {
+            var data = new IntPtr(ptr.ToInt64() + size * i);
+            rects[i] = (DXGI_OUTDUPL_MOVE_RECT)Marshal.PtrToStructure(data, typeof(DXGI_OUTDUPL_MOVE_RECT));
+        }
+        return rects;
+    }
+
+    public static RECT[] GetDirtyRects(int id)
+    {
+        var count = GetDirtyRectCount(id);
+        var rects = new RECT[count];
+        var ptr = GetDirtyRects_Internal(id);
+        var size = Marshal.SizeOf(typeof(RECT));
+        for (int i = 0; i < count; ++i) {
+            var data = new IntPtr(ptr.ToInt64() + size * i);
+            rects[i] = (RECT)Marshal.PtrToStructure(data, typeof(RECT));
+        }
+        return rects;
+    }
 }
 
 }

Assets/uDesktopDuplication/Scripts/Manager.cs

@@ -15,15 +15,17 @@ public class Manager : MonoBehaviour
 
     public static Manager CreateInstance()
     {
-        if (instance_) {
-            return instance_;
-        }
+        if (instance_ != null) return instance_;
 
         var manager = FindObjectOfType<Manager>();
-        if (manager) return manager;
+        if (manager) {
+            instance_ = manager;
+            return manager;
+        }
 
         var go = new GameObject("uDesktopDuplicationManager");
-        return go.AddComponent<Manager>();
+        instance_ = go.AddComponent<Manager>();
+        return instance_;
     }
 
     private List<Monitor> monitors_ = new List<Monitor>();
@@ -57,6 +59,7 @@ public class Manager : MonoBehaviour
     private Coroutine renderCoroutine_ = null;
     private bool shouldReinitialize_ = false;
     private float reinitializationTimer_ = 0f;
+    private bool isFirstFrame_ = true;
 
     public delegate void ReinitializeHandler();
     public static event ReinitializeHandler onReinitialized;
@@ -72,16 +75,23 @@ public class Manager : MonoBehaviour
 
     void Awake()
     {
-        Lib.SetDebugMode(debugMode);
-        Lib.InitializeUDD();
-        Lib.SetTimeout(desktopDuplicationApiTimeout);
+        // for simple singleton
 
-        if (instance_ != null) {
+        if (instance_ == this) {
+            return;
+        }
+
+        if (instance_ != null && instance_ != this) {
             Destroy(gameObject);
             return;
         }
+
         instance_ = this;
 
+        Lib.SetDebugMode(debugMode);
+        Lib.SetTimeout(desktopDuplicationApiTimeout);
+        Lib.InitializeUDD();
+
         CreateMonitors();
     }
 
@@ -94,6 +104,9 @@ public class Manager : MonoBehaviour
     void OnEnable()
     {
         renderCoroutine_ = StartCoroutine(OnRender());
+        if (!isFirstFrame_) {
+            Reinitialize();
+        }
     }
 
     void OnDisable()
@@ -109,6 +122,7 @@ public class Manager : MonoBehaviour
         Lib.Update();
         ReinitializeIfNeeded();
         UpdateMessage();
+        isFirstFrame_ = false;
     }
 
     [ContextMenu("Reinitialize")]
@@ -128,11 +142,12 @@ public class Manager : MonoBehaviour
 
         for (int i = 0; i < monitors.Count; ++i) {
             var monitor = monitors[i];
+            var state = monitor.state;
             if (
-                monitor.state == MonitorState.NotSet ||
-                monitor.state == MonitorState.AccessLost || 
-                monitor.state == MonitorState.AccessDenied ||
-                monitor.state == MonitorState.SessionDisconnected
+                state == MonitorState.NotSet ||
+                state == MonitorState.AccessLost || 
+                state == MonitorState.AccessDenied ||
+                state == MonitorState.SessionDisconnected
             ) {
                 reinitializeNeeded = true;
                 break;

Assets/uDesktopDuplication/Scripts/Monitor.cs

@@ -202,6 +202,26 @@ public class Monitor
         get { return Lib.GetCursorShapeType(id); }
     }
 
+    public int moveRectCount
+    { 
+        get { return Lib.GetMoveRectCount(id); }
+    }
+
+    public DXGI_OUTDUPL_MOVE_RECT[] moveRects
+    {
+        get { return Lib.GetMoveRects(id); }
+    }
+
+    public int dirtyRectCount
+    { 
+        get { return Lib.GetDirtyRectCount(id); }
+    }
+
+    public RECT[] dirtyRects
+    {
+        get { return Lib.GetDirtyRects(id); }
+    }
+
     public bool shouldBeUpdated
     {
         get; 
@@ -220,6 +240,7 @@ public class Monitor
     }
 
     private Texture2D texture_;
+    private System.IntPtr texturePtr_;
     public Texture2D texture 
     {
         get 
@@ -232,8 +253,8 @@ public class Monitor
 
     public void Render()
     {
-        if (texture_ && available) {
-            Lib.SetTexturePtr(id, texture_.GetNativeTexturePtr());
+        if (texture_ && available && texturePtr_ != System.IntPtr.Zero) {
+            Lib.SetTexturePtr(id, texturePtr_);
             GL.IssuePluginEvent(Lib.GetRenderEventFunc(), id);
         }
     }
@@ -270,6 +291,7 @@ public class Monitor
         var w = isHorizontal ? width : height;
         var h = isHorizontal ? height : width;
         texture_ = new Texture2D(w, h, TextureFormat.BGRA32, false);
+        texturePtr_ = texture_.GetNativeTexturePtr();
     }
 
     public void DestroyTexture()
@@ -277,6 +299,7 @@ public class Monitor
         if (texture_) {
             Object.Destroy(texture_);
             texture_ = null;
+            texturePtr_ = System.IntPtr.Zero;
         }
     }
 

Assets/uDesktopDuplication/Scripts/Texture.cs

@@ -3,7 +3,7 @@
 namespace uDesktopDuplication
 {
 
-[AddComponentMenu("uDesktopDuplication/Texture")] 
+[AddComponentMenu("uDesktopDuplication/Texture"), RequireComponent(typeof(Cursor))] 
 public class Texture : MonoBehaviour
 {
     private Monitor monitor_;
@@ -13,12 +13,15 @@ public class Texture : MonoBehaviour
         set 
         { 
             monitor_ = value;
-            material = GetComponent<Renderer>().material; // clone
-            material.mainTexture = monitor_.texture;
-            material.SetFloat("_Width", transform.localScale.x);
+            if (monitor_ != null) {
+                material = GetComponent<Renderer>().material; // clone
+                material.mainTexture = monitor_.texture;
+                material.SetFloat("_Width", transform.localScale.x);
+            }
         }
     }
 
+    private int lastMonitorId_ = 0;
     public int monitorId
     { 
         get { return monitor.id; }
@@ -50,8 +53,10 @@ public class Texture : MonoBehaviour
         {
             if (value) {
                 material.EnableKeyword("BEND_ON");
+                material.SetInt("_Bend", 1);
             } else {
                 material.DisableKeyword("BEND_ON");
+                material.SetInt("_Bend", 0);
             }
         }
     }
@@ -67,13 +72,13 @@ public class Texture : MonoBehaviour
             switch (value) {
                 case MeshForwardDirection.Y:
                     material.SetInt("_Forward", 0);
-                    material.EnableKeyword("_BEND_Y");
-                    material.DisableKeyword("_BEND_Z");
+                    material.EnableKeyword("_FORWARD_Y");
+                    material.DisableKeyword("_FORWARD_Z");
                     break;
                 case MeshForwardDirection.Z:
                     material.SetInt("_Forward", 1);
-                    material.DisableKeyword("_BEND_Y");
-                    material.EnableKeyword("_BEND_Z");
+                    material.DisableKeyword("_FORWARD_Y");
+                    material.EnableKeyword("_FORWARD_Z");
                     break;
             }
         }
@@ -105,10 +110,7 @@ public class Texture : MonoBehaviour
 
     void Awake()
     {
-        if (!GetComponent<Cursor>())
-        {
-            gameObject.AddComponent<Cursor>();
-        }
+        AddCursorIfNotAttached();
     }
 
     void OnEnable()
@@ -126,14 +128,32 @@ public class Texture : MonoBehaviour
 
     void Update()
     {
+        KeepMonitor();
         monitor.shouldBeUpdated = true;
         UpdateMaterial();
     }
 
+    void KeepMonitor()
+    {
+        if (monitor == null) {
+            Reinitialize();
+        } else {
+            lastMonitorId_ = monitorId;
+        }
+    }
+
+    void AddCursorIfNotAttached()
+    {
+        if (!GetComponent<Cursor>())
+        {
+            gameObject.AddComponent<Cursor>();
+        }
+    }
+
     void Reinitialize()
     {
         // Monitor instance is released here when initialized.
-        monitor = Manager.GetMonitor(monitor.id);
+        monitor = Manager.GetMonitor(lastMonitorId_);
     }
 
     void UpdateMaterial()

Assets/uDesktopDuplication/Shaders/uDD_Common.cginc

@@ -64,32 +64,14 @@ inline void uddConvertToLinearIfNeeded(inout fixed3 rgb)
 }
 
 inline fixed4 uddGetScreenTexture(float2 uv)
-{
-    fixed4 c = tex2D(_MainTex, uv);
-    return c;
-}
-
-inline fixed4 uddGetCursorTexture(float2 uv)
-{
-    uv.x = (uv.x - _CursorX) / _CursorWidth;
-    uv.y = (uv.y - _CursorY) / _CursorHeight;
-    fixed4 c = tex2D(_CursorTex, uv);
-    fixed a = step(0, uv.x) * step(0, uv.y) * step(uv.x, 1) * step(uv.y, 1);
-    c.a *= step(0.01, a);
-    return c;
-}
-
-inline fixed4 uddGetScreenTextureWithCursor(float2 uv)
 {
     uv = uddInvertUV(uv);
 #ifdef USE_CLIP
     uv = uddClipUV(uv);
 #endif
-    fixed4 screen = uddGetScreenTexture(uddRotateUV(uv));
-    fixed4 cursor = uddGetCursorTexture(uv);
-    fixed4 color = lerp(screen, cursor, cursor.a);
-    uddConvertToLinearIfNeeded(color.rgb);
-    return color;
+    fixed4 c = tex2D(_MainTex, uddRotateUV(uv));
+    uddConvertToLinearIfNeeded(c.rgb);
+    return c;
 }
 
 inline void uddBendVertex(inout float4 v, half radius, half width, half thickness)
@@ -97,13 +79,13 @@ inline void uddBendVertex(inout float4 v, half radius, half width, half thicknes
 #ifdef BEND_ON
     half angle = width * v.x / radius;
     #ifdef _FORWARD_Z
-    v.y *= thickness;
-    radius -= v.y;
-    v.y += radius * (1 - cos(angle));
-    #elif _FORWARD_Y
     v.z *= thickness;
-    radius -= v.z;
-    v.z += radius * (1 - cos(angle));
+    radius += v.z;
+    v.z -= radius * (1 - cos(angle));
+    #elif _FORWARD_Y
+    v.y *= thickness;
+    radius += v.y;
+    v.y += radius * (1 - cos(angle));
     #endif
     v.x = radius * sin(angle) / width;
 #else

Assets/uDesktopDuplication/Shaders/uDD_Standard.shader

@@ -34,7 +34,7 @@ SubShader
 
     void surf(Input IN, inout SurfaceOutputStandard o) 
     {
-        fixed4 c = uddGetScreenTextureWithCursor(IN.uv_MainTex) * _Color;
+        fixed4 c = uddGetScreenTexture(IN.uv_MainTex) * _Color;
         o.Albedo = c.rgb;
         o.Metallic = _Metallic;
         o.Smoothness = _Glossiness;

Assets/uDesktopDuplication/Shaders/uDD_Unlit.shader

@@ -39,7 +39,7 @@ v2f vert(appdata v)
 
 fixed4 frag(v2f i) : SV_Target
 {
-    return uddGetScreenTextureWithCursor(i.uv);
+    return uddGetScreenTexture(i.uv);
 }
 
 ENDCG

Assets/uDesktopDuplication/Shaders/uDD_Unlit_BlackMask.shader

@@ -43,7 +43,7 @@ v2f vert(appdata v)
 
 fixed4 frag(v2f i) : SV_Target
 {
-    fixed4 tex = uddGetScreenTextureWithCursor(i.uv);
+    fixed4 tex = uddGetScreenTexture(i.uv);
     fixed alpha = pow((tex.r + tex.g + tex.b) / 3.0, _Mask);
     return fixed4(tex.rgb * _Color.rgb, alpha * _Color.a);
 }

Assets/uDesktopDuplication/Shaders/uDD_Unlit_Transparent.shader

@@ -41,7 +41,7 @@ v2f vert(appdata v)
 
 fixed4 frag(v2f i) : SV_Target
 {
-    return fixed4(uddGetScreenTextureWithCursor(i.uv).rgb, 1.0) * _Color;
+    return fixed4(uddGetScreenTexture(i.uv).rgb, 1.0) * _Color;
 }
 
 ENDCG

Plugins/uDesktopDuplication/uDesktopDuplication/Common.cpp

@@ -36,4 +36,4 @@ const std::unique_ptr<MonitorManager>& GetMonitorManager()
 void SendMessageToUnity(Message message)
 {
     g_messages.push(message);
-}
+}

Plugins/uDesktopDuplication/uDesktopDuplication/Common.h

@@ -17,23 +17,93 @@ class MonitorManager;
 const std::unique_ptr<MonitorManager>& GetMonitorManager();
 
 
-template <class T>
-auto MakeUniqueWithReleaser(T* ptr)
-{
-    const auto deleter = [](T* ptr) 
-    { 
-        if (ptr != nullptr) ptr->Release();
-    };
-    return std::unique_ptr<T, decltype(deleter)>(ptr, deleter);
-}
-
-
 // Message is pooled and fetch from Unity.
 enum class Message
 {
     None = -1,
     Reinitialized = 0,
-	TextureSizeChanged = 1,
+    TextureSizeChanged = 1,
 };
 
-void SendMessageToUnity(Message message);
+void SendMessageToUnity(Message message);
+
+
+// Buffer
+template <class T>
+class Buffer
+{
+public:
+    Buffer() {}
+    ~Buffer() {}
+
+    void ExpandIfNeeded(UINT size)
+    {
+        if (size > size_)
+        {
+            size_ = size;
+            value_ = std::make_unique<T[]>(size);
+        }
+    }
+
+    void Reset()
+    {
+        value_.reset();
+        size_ = 0;
+    }
+
+    UINT Size() const
+    {
+        return size_;
+    }
+
+    T* Get() const
+    {
+        return value_.get();
+    }
+
+    T* Get(UINT offset) const
+    {
+        return (value_.get() + offset);
+    }
+
+    template <class U>
+    U* As() const
+    {
+        return reinterpret_cast<U*>(Get());
+    }
+
+    template <class U>
+    U* As(UINT offset) const
+    {
+        return reinterpret_cast<U*>(Get(offset));
+    }
+
+    operator bool() const
+    {
+        return value_ != nullptr;
+    }
+
+    const T operator [](UINT index) const
+    {
+        if (index >= size_)
+        {
+            Debug::Error("Array index out of range: ", index, size_);
+            return T(0);
+        }
+        return value_[index];
+    }
+
+    T& operator [](UINT index)
+    {
+        if (index >= size_)
+        {
+            Debug::Error("Array index out of range: ", index, size_);
+            return value_[0];
+        }
+        return value_[index];
+    }
+
+private:
+    std::unique_ptr<T[]> value_;
+    UINT size_ = 0;
+};

Plugins/uDesktopDuplication/uDesktopDuplication/Cursor.cpp

@@ -1,6 +1,5 @@
 #include <d3d11.h>
 #include <wrl/client.h>
-#include "Common.h"
 #include "Debug.h"
 #include "MonitorManager.h"
 #include "Monitor.h"
@@ -47,32 +46,26 @@ void Cursor::UpdateBuffer(const DXGI_OUTDUPL_FRAME_INFO& frameInfo)
         return;
     }
 
-    // Increase the buffer size if needed
-    if (frameInfo.PointerShapeBufferSize > apiBufferSize_)
+	apiBuffer_.ExpandIfNeeded(frameInfo.PointerShapeBufferSize);
+    if (!apiBuffer_) 
     {
-        apiBufferSize_ = frameInfo.PointerShapeBufferSize;
-        apiBuffer_ = std::make_unique<BYTE[]>(apiBufferSize_);
+        return;
     }
 
-	if (!apiBuffer_) 
-	{
-		return;
-	}
-
     // Get mouse pointer information
     UINT bufferSize;
     DXGI_OUTDUPL_POINTER_SHAPE_INFO shapeInfo;
-	const auto hr = monitor_->GetDeskDupl()->GetFramePointerShape(
-		apiBufferSize_,
-		apiBuffer_.get(),
-		&bufferSize,
-		&shapeInfo);
+    const auto hr = monitor_->GetDeskDupl()->GetFramePointerShape(
+        apiBuffer_.Size(),
+        apiBuffer_.Get(),
+        &bufferSize,
+        &shapeInfo);
 
     if (FAILED(hr))
     {
         Debug::Error("Cursor::UpdateBuffer() => GetFramePointerShape() failed.");
-        apiBuffer_.reset();
-        apiBufferSize_ = 0;
+        apiBuffer_.Reset();
+        return;
     }
 
     shapeInfo_ = shapeInfo;
@@ -86,64 +79,136 @@ void Cursor::UpdateTexture()
         return;
     }
 
-    // cursor type
-    const bool isMono = GetType() == DXGI_OUTDUPL_POINTER_SHAPE_TYPE_MONOCHROME;
-    const bool isColorMask = GetType() == DXGI_OUTDUPL_POINTER_SHAPE_TYPE_MASKED_COLOR;
+    // Check desktop texure
+    if (monitor_->GetUnityTexture() == nullptr) 
+    {
+        Debug::Error("Cursor::UpdateTexture() => Monitor::GetUnityTexture() is null.");
+        return;
+    }
 
-    // Size
-    const auto w0 = GetWidth();
-    const auto h0 = GetHeight();
-    const auto p = GetPitch();
-    auto w = w0;
-    auto h = h0;
+    // Cursor information
+    const auto cursorImageWidth = GetWidth();
+    const auto cursorImageHeight = GetHeight();
+    const auto cursorImagePitch = GetPitch();
+
+    // Captured size
+    auto capturedImageWidth = cursorImageWidth;
+    auto capturedImageHeight = cursorImageHeight;
 
     // Convert the buffer given by API into BGRA32
-    const UINT bgraBufferSize = w0 * h0 * 4;
-    if (bgraBufferSize > bgra32BufferSize_)
+    const UINT bgraBufferSize = cursorImageWidth * cursorImageHeight * 4;
+	bgraBuffer_.ExpandIfNeeded(bgraBufferSize);
+    
+    // Check buffers
+    if (!bgraBuffer_ || !apiBuffer_) 
     {
-        bgra32BufferSize_ = bgraBufferSize;
-        bgra32Buffer_ = std::make_unique<BYTE[]>(bgra32BufferSize_);
+        return;
     }
-    if (!bgra32Buffer_) return;
 
-    // If masked, copy the desktop image and merge it with masked image.
-    if (isMono || isColorMask)
+    // Calculate information to capture desktop image under cursor.
+    D3D11_BOX box;
+    const auto monitorRot = static_cast<DXGI_MODE_ROTATION>(monitor_->GetRotation());
+    auto colMin = 0;
+    auto colMax = cursorImageWidth;
+    auto rowMin = 0;
+    auto rowMax = cursorImageHeight;
+
     {
-        const auto mw = monitor_->GetWidth();
-        const auto mh = monitor_->GetHeight();
+        const auto monitorWidth = monitor_->GetWidth();
+        const auto monitorHeight = monitor_->GetHeight();
+        const auto isVertical = 
+            monitorRot == DXGI_MODE_ROTATION_ROTATE90 || 
+            monitorRot == DXGI_MODE_ROTATION_ROTATE270;
+        const auto desktopImageWidth  = !isVertical ? monitorWidth  : monitorHeight;
+        const auto desktopImageHeight = !isVertical ? monitorHeight : monitorWidth;
+
         auto x = x_;
         auto y = y_;
-        auto colMin = 0;
-        auto colMax = w0;
-        auto rowMin = 0;
-        auto rowMax = h0;
 
         if (x < 0)
         {
             x = 0;
-            w = w0 + x_;
-            colMin = w0 - w;
+            capturedImageWidth = cursorImageWidth + x_;
+            colMin = cursorImageWidth - capturedImageWidth;
         }
-        if (x + w >= mw) 
+        if (x + capturedImageWidth >= monitorWidth) 
         {
-            w = mw - x_;
-            colMax = w;
+            capturedImageWidth = monitorWidth - x_;
+            colMax = capturedImageWidth;
         }
         if (y < 0)
         {
             y = 0;
-            h = h0 + y_;
-            rowMin = h0 - h;
+            capturedImageHeight = cursorImageHeight + y_;
+            rowMin = cursorImageHeight - capturedImageHeight;
         }
-        if (y + h >= mh) 
+        if (y + capturedImageHeight >= monitorHeight) 
         {
-            h = mh - y_;
-            rowMax = h;
+            capturedImageHeight = monitorHeight - y_;
+            rowMax = capturedImageHeight;
         }
 
+        box.front = 0;
+        box.back = 1;
+
+        switch (monitorRot)
+        {
+            case DXGI_MODE_ROTATION_ROTATE90:
+            {
+                box.left   = y;
+                box.top    = monitorWidth - x - capturedImageWidth;
+                box.right  = y + capturedImageWidth;
+                box.bottom = monitorWidth - x;
+                break;
+            }
+            case DXGI_MODE_ROTATION_ROTATE180:
+            {
+                box.left   = monitorWidth - x - capturedImageWidth;
+                box.top    = monitorHeight - y - capturedImageHeight;
+                box.right  = monitorWidth - x;
+                box.bottom = monitorHeight - y;
+                break;
+            }
+            case DXGI_MODE_ROTATION_ROTATE270:
+            {
+                box.left   = monitorHeight - y - capturedImageHeight;
+                box.top    = x;
+                box.right  = monitorHeight - y;
+                box.bottom = x + capturedImageWidth;
+                break;
+            }
+            case DXGI_MODE_ROTATION_IDENTITY:
+            case DXGI_MODE_ROTATION_UNSPECIFIED:
+            {
+                box.left   = x;
+                box.top    = y;
+                box.right  = x + capturedImageWidth;
+                box.bottom = y + capturedImageHeight;
+                break;
+            }
+        }
+
+        if (box.left   <  0 || 
+            box.top    <  0 || 
+            box.right  > static_cast<UINT>(desktopImageWidth) || 
+            box.bottom > static_cast<UINT>(desktopImageHeight))
+        {
+            Debug::Error("Cursor::UpdateTexture() => box is out of area.");
+            Debug::Error(
+                "    ",
+                "(", box.left, ", ", box.top, ")", 
+                " ~ (", box.right, ", ", box.bottom, ") > ",
+                "(", desktopImageWidth, ", ", desktopImageHeight, ")");
+            return;
+        }
+    }
+
+    // Create texture
+    ComPtr<ID3D11Texture2D> texture;
+    {
         D3D11_TEXTURE2D_DESC desc;
-        desc.Width = w;
-        desc.Height = h;
+        desc.Width = capturedImageWidth;
+        desc.Height = capturedImageHeight;
         desc.MipLevels = 1;
         desc.ArraySize = 1;
         desc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
@@ -154,85 +219,97 @@ void Cursor::UpdateTexture()
         desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
         desc.MiscFlags = 0;
 
-        ComPtr<ID3D11Texture2D> texture;
-        if (FAILED(GetDevice()->CreateTexture2D(&desc, nullptr, &texture))) 
+        if (FAILED(GetDevice()->CreateTexture2D(&desc, nullptr, &texture)))
         {
             Debug::Error("Cursor::UpdateTexture() => GetDevice()->CreateTexture2D() failed.");
             return;
         }
+    }
 
-        D3D11_BOX box;
-        box.front = 0;
-        box.back = 1;
-        box.left = x;
-        box.top = y;
-        box.right = x + w;
-        box.bottom = y + h;
+    // Copy desktop image to the texture
+    {
+        ComPtr<ID3D11DeviceContext> context;
+        GetDevice()->GetImmediateContext(&context);
+        context->CopySubresourceRegion(texture.Get(), 0, 0, 0, 0, monitor_->GetUnityTexture(), 0, &box);
+    }
 
-        if (monitor_->GetUnityTexture() == nullptr) 
+    // Get mapped surface
+    ComPtr<IDXGISurface> surface;
+    if (FAILED(texture.As(&surface)))
+    {
+        Debug::Error("Cursor::UpdateTexture() => texture->QueryInterface() failed.");
+        return;
+    }
+
+    DXGI_MAPPED_RECT mappedSurface;
+    if (FAILED(surface->Map(&mappedSurface, DXGI_MAP_READ)))
+    {
+        Debug::Error("Cursor::UpdateTexture() => surface->Map() failed.");
+        return;
+    }
+
+    // Finally, get the desktop texture under the mouse cursor.
+    const auto desktop32 = reinterpret_cast<UINT*>(mappedSurface.pBits);
+    const UINT desktopPitch = mappedSurface.Pitch / sizeof(UINT);
+
+    // Take the monitor orientation into consideration.
+    const auto getDesktop32 = [&](int col, int row)
+    {
+        switch (monitorRot)
         {
-            Debug::Error("Cursor::UpdateTexture() => Monitor::GetUnityTexture() is null.");
-            return;
+            case DXGI_MODE_ROTATION_ROTATE90:
+                return desktop32[(capturedImageWidth - 1 - col) * desktopPitch + row];
+            case DXGI_MODE_ROTATION_ROTATE180:
+                return desktop32[(capturedImageHeight - 1 - row) * desktopPitch + (capturedImageWidth - 1 - col)];
+            case DXGI_MODE_ROTATION_ROTATE270:
+                return desktop32[col * desktopPitch + (capturedImageHeight - 1 - row)];
+            case DXGI_MODE_ROTATION_IDENTITY:
+            case DXGI_MODE_ROTATION_UNSPECIFIED:
+                return desktop32[row * desktopPitch + col];
         }
+    };
 
-		{
-			ComPtr<ID3D11DeviceContext> context;
-			GetDevice()->GetImmediateContext(&context);
-			context->CopySubresourceRegion(texture.Get(), 0, 0, 0, 0, monitor_->GetUnityTexture(), 0, &box);
-		}
+    // Access RGBA values at the same time
+    Buffer<BYTE> output;
+    output.ExpandIfNeeded(bgraBuffer_.Size());
+    auto output32 = output.As<UINT>();
 
-        ComPtr<IDXGISurface> surface;
-        if (FAILED(texture.As(&surface)))
+    switch (GetType())
+    {
+        case DXGI_OUTDUPL_POINTER_SHAPE_TYPE_MONOCHROME:
         {
-            Debug::Error("Cursor::UpdateTexture() => texture->QueryInterface() failed.");
-            return;
-        }
-
-        DXGI_MAPPED_RECT mappedSurface;
-        if (FAILED(surface->Map(&mappedSurface, DXGI_MAP_READ)))
-        {
-            Debug::Error("Cursor::UpdateTexture() => surface->Map() failed.");
-            return;
-        }
-
-        // Finally, get the texture behind the mouse cursor.
-        const auto desktop32 = reinterpret_cast<UINT*>(mappedSurface.pBits);
-        const UINT desktopPitch = mappedSurface.Pitch / sizeof(UINT);
-
-        // Access RGBA values at the same time
-        auto output32 = reinterpret_cast<UINT*>(bgra32Buffer_.get());
-
-        if (isMono)
-        {
-            for (int row = rowMin, y = 0; row < rowMax; ++row, ++y) 
+            for (int row = rowMin, y = 0; row < rowMax; ++row, ++y)
             {
-                for (int col = colMin, x = 0; col < colMax; ++col, ++x) 
+                for (int col = colMin, x = 0; col < colMax; ++col, ++x)
                 {
+                    const int i = col + row * cursorImageWidth;
+
                     BYTE mask = 0b10000000 >> (col % 8);
-                    const int i = row * w0 + col;
-                    const BYTE andMask = apiBuffer_[col / 8 + row * p] & mask;
-                    const BYTE xorMask = apiBuffer_[col / 8 + (row + h) * p] & mask;
+                    const BYTE andMask = apiBuffer_[col / 8 + row * cursorImagePitch] & mask;
+                    const BYTE xorMask = apiBuffer_[col / 8 + (row + capturedImageHeight) * cursorImagePitch] & mask;
                     const UINT andMask32 = andMask ? 0xFFFFFFFF : 0x00000000;
                     const UINT xorMask32 = xorMask ? 0xFFFFFFFF : 0x00000000;
-                    output32[i] = (desktop32[y * desktopPitch + x] & andMask32) ^ xorMask32;
+
+                    output32[i] = (getDesktop32(x, y) & andMask32) ^ xorMask32;
                 }
             }
+            break;
         }
-        else // DXGI_OUTDUPL_POINTER_SHAPE_TYPE_MASKED_COLOR
+        case DXGI_OUTDUPL_POINTER_SHAPE_TYPE_MASKED_COLOR:
         {
-            const auto buffer32 = reinterpret_cast<UINT*>(apiBuffer_.get());
+            const auto buffer32 = apiBuffer_.As<UINT>();
 
-            for (int row = rowMin, y = 0; row < rowMax; ++row, ++y) 
+            for (int row = rowMin, y = 0; row < rowMax; ++row, ++y)
             {
-                for (int col = colMin, x = 0; col < colMax; ++col, ++x) 
+                for (int col = colMin, x = 0; col < colMax; ++col, ++x)
                 {
-                    const int i = col + row * w0;
-                    const int j = col + row * p / sizeof(UINT);
+                    const int i = col + row * cursorImageWidth;
+                    const int j = col + row * cursorImagePitch / sizeof(UINT);
 
                     UINT mask = 0xFF000000 & buffer32[j];
                     if (mask)
                     {
-                        output32[i] = (desktop32[y * desktopPitch + x] ^ buffer32[j]) | 0xFF000000;
+                        output32[i] = (getDesktop32(x, y) ^ buffer32[j]) | 0xFF000000;
                     }
                     else
                     {
@@ -240,28 +317,92 @@ void Cursor::UpdateTexture()
                     }
                 }
             }
+            break;
         }
-
-        if (FAILED(surface->Unmap()))
+        case DXGI_OUTDUPL_POINTER_SHAPE_TYPE_COLOR:
         {
-            return;
+            const auto buffer32 = apiBuffer_.As<UINT>();
+            auto output32 = bgraBuffer_.As<UINT>();
+
+            for (int row = rowMin, y = 0; row < rowMax; ++row, ++y)
+            {
+                for (int col = colMin, x = 0; col < colMax; ++col, ++x)
+                {
+                    const int i = 4 * (col + row * cursorImageWidth);
+
+                    const auto desktop32 = getDesktop32(x, y);
+                    const auto desktop = (BYTE*)(&desktop32);
+                    const auto desktopB = desktop[0];
+                    const auto desktopG = desktop[1];
+                    const auto desktopR = desktop[2];
+                    const auto desktopA = desktop[3];
+
+                    const auto cursorB = apiBuffer_[i + 0];
+                    const auto cursorG = apiBuffer_[i + 1];
+                    const auto cursorR = apiBuffer_[i + 2];
+                    const auto cursorA = apiBuffer_[i + 3];
+
+                    const auto a0 = cursorA / 255.f;
+                    const auto a1 = 1.f - a0;
+
+                    output[i + 0] = static_cast<BYTE>(cursorB * a0 + desktopB * a1);
+                    output[i + 1] = static_cast<BYTE>(cursorG * a0 + desktopG * a1);
+                    output[i + 2] = static_cast<BYTE>(cursorR * a0 + desktopR * a1);
+                    output[i + 3] = desktopA;
+                }
+            }
+            break;
+        }
+        default:
+        {
+            Debug::Error("Cursor::UpdateTexture() => Unknown cursor type");
+            break;
         }
     }
-    else // DXGI_OUTDUPL_POINTER_SHAPE_TYPE_COLOR
+
+    // Rotation
+    auto bgraBuffer32 = bgraBuffer_.As<UINT>();
+    for (int row = rowMin, y = 0; row < rowMax; ++row, ++y)
     {
-        auto output32 = reinterpret_cast<UINT*>(bgra32Buffer_.get());
-        const auto buffer32 = reinterpret_cast<UINT*>(apiBuffer_.get());
-        for (int i = 0; i < w * h; ++i) 
+        for (int col = colMin, x = 0; col < colMax; ++col, ++x)
         {
-            output32[i] = buffer32[i];
+            const auto i = col + row * cursorImageWidth;
+            switch (monitorRot)
+            {
+                case DXGI_MODE_ROTATION_ROTATE90:
+                    bgraBuffer32[i] = output32[col * cursorImageHeight + (cursorImageHeight - 1 - row)];
+                    break;
+                case DXGI_MODE_ROTATION_ROTATE180:
+                    bgraBuffer32[i] = output32[(cursorImageHeight - 1 - row) * cursorImageWidth + (cursorImageWidth - 1 - col)];
+                    break;
+                case DXGI_MODE_ROTATION_ROTATE270:
+                    bgraBuffer32[i] = output32[(cursorImageWidth - 1 - col) * cursorImageHeight + row];
+                    break;
+                case DXGI_MODE_ROTATION_IDENTITY:
+                case DXGI_MODE_ROTATION_UNSPECIFIED:
+                    bgraBuffer32[i] = output32[i];
+                    break;
+            }
         }
     }
+
+    {
+        ComPtr<ID3D11DeviceContext> context;
+        GetDevice()->GetImmediateContext(&context);
+        context->UpdateSubresource(monitor_->GetUnityTexture(), 0, &box, bgraBuffer_.Get(), GetWidth() * 4, 0);
+    }
+
+    if (FAILED(surface->Unmap()))
+    {
+        Debug::Error("Cursor::UpdateTexture() => surface->Unmap() failed.");
+        return;
+    }
 }
 
 
 void Cursor::GetTexture(ID3D11Texture2D* texture)
 {
-    if (bgra32Buffer_ == nullptr)
+    if (!bgraBuffer_)
     {
         Debug::Error("Cursor::GetTexture() => bgra32Buffer is null.");
         return;
@@ -288,7 +429,7 @@ void Cursor::GetTexture(ID3D11Texture2D* texture)
 
     ComPtr<ID3D11DeviceContext> context;
     GetDevice()->GetImmediateContext(&context);
-    context->UpdateSubresource(texture, 0, nullptr, bgra32Buffer_.get(), GetWidth() * 4, 0);
+    context->UpdateSubresource(texture, 0, nullptr, bgraBuffer_.Get(), GetWidth() * 4, 0);
 }
 
 

Plugins/uDesktopDuplication/uDesktopDuplication/Cursor.h

@@ -3,6 +3,7 @@
 #include <d3d11.h>
 #include <dxgi1_2.h>
 #include <memory>
+#include "Common.h"
 
 class Monitor;
 
@@ -30,10 +31,8 @@ private:
     bool isVisible_ = false;
     int x_ = -1;
     int y_ = -1;
-    std::unique_ptr<BYTE[]> apiBuffer_ = nullptr;
-    UINT apiBufferSize_ = 0;
-    std::unique_ptr<BYTE[]> bgra32Buffer_ = nullptr;
-    UINT bgra32BufferSize_ = 0;
+    Buffer<BYTE> apiBuffer_;
+	Buffer<BYTE> bgraBuffer_;
     DXGI_OUTDUPL_POINTER_SHAPE_INFO shapeInfo_;
     LARGE_INTEGER timestamp_;
 };

Plugins/uDesktopDuplication/uDesktopDuplication/Debug.cpp

@@ -28,6 +28,6 @@ void Debug::Finalize()
         Debug::Log("Stop");
         fs_.close();
     }
-	Debug::SetLogFunc(nullptr);
-	Debug::SetErrorFunc(nullptr);
+    Debug::SetLogFunc(nullptr);
+    Debug::SetErrorFunc(nullptr);
 }

Plugins/uDesktopDuplication/uDesktopDuplication/Debug.h

@@ -87,34 +87,34 @@ private:
         Flush(level);
     }
 
-	static void OutputTime()
-	{
-		auto t = time(nullptr);
-		tm tm;
-		localtime_s(&tm, &t);
-		char buf[64];
-		strftime(buf, 64, "%F %T", &tm);
+    static void OutputTime()
+    {
+        auto t = time(nullptr);
+        tm tm;
+        localtime_s(&tm, &t);
+        char buf[64];
+        strftime(buf, 64, "%F %T", &tm);
         Output("[");;
         Output(buf);
         Output("]");
-	}
+    }
 
 public:
     template <class Arg, class... RestArgs>
     static void Log(Arg&& arg, RestArgs&&... restArgs)
     {
-		Output("[uDD::Log]");
-		OutputTime();
-		Output(" ");
+        Output("[uDD::Log]");
+        OutputTime();
+        Output(" ");
         _Log(Level::Log, std::forward<Arg>(arg), std::forward<RestArgs>(restArgs)...);
     }
 
     template <class Arg, class... RestArgs>
     static void Error(Arg&& arg, RestArgs&&... restArgs)
     {
-		Output("[uDD::Err]");
-		OutputTime();
-		Output(" ");
+        Output("[uDD::Err]");
+        OutputTime();
+        Output(" ");
         _Log(Level::Error, std::forward<Arg>(arg), std::forward<RestArgs>(restArgs)...);
     }
 

Plugins/uDesktopDuplication/uDesktopDuplication/Monitor.cpp

@@ -1,6 +1,5 @@
 #include <d3d11.h>
 #include <ShellScalingAPI.h>
-#include "Common.h"
 #include "Debug.h"
 #include "Cursor.h"
 #include "MonitorManager.h"
@@ -18,94 +17,94 @@ Monitor::Monitor(int id)
 
 Monitor::~Monitor()
 {
-	if (deskDupl_) 
-	{
-		deskDupl_->Release();
-		deskDupl_ = nullptr;
-	}
+    if (deskDupl_) 
+    {
+        deskDupl_->Release();
+        deskDupl_ = nullptr;
+    }
 }
 
 
 void Monitor::Initialize(IDXGIOutput* output)
 {
-	if (FAILED(output->GetDesc(&outputDesc_)))
-	{
-		Debug::Error("Monitor::Initialize() => IDXGIOutput::GetDesc() failed.");
-		return;
-	}
+    if (FAILED(output->GetDesc(&outputDesc_)))
+    {
+        Debug::Error("Monitor::Initialize() => IDXGIOutput::GetDesc() failed.");
+        return;
+    }
 
     monitorInfo_.cbSize = sizeof(MONITORINFOEX);
-	if (!GetMonitorInfo(outputDesc_.Monitor, &monitorInfo_))
-	{
-		Debug::Error("Monitor::Initialize() => GetMonitorInfo() failed.");
-		return;
-	}
-	else
-	{
-		const auto rect = monitorInfo_.rcMonitor;
-		width_ = rect.right - rect.left;
-		height_ = rect.bottom - rect.top;
-	}
+    if (!GetMonitorInfo(outputDesc_.Monitor, &monitorInfo_))
+    {
+        Debug::Error("Monitor::Initialize() => GetMonitorInfo() failed.");
+        return;
+    }
+    else
+    {
+        const auto rect = monitorInfo_.rcMonitor;
+        width_ = rect.right - rect.left;
+        height_ = rect.bottom - rect.top;
+    }
 
-	if (FAILED(GetDpiForMonitor(outputDesc_.Monitor, MDT_RAW_DPI, &dpiX_, &dpiY_)))
-	{
-		Debug::Error("Monitor::Initialize() => GetDpiForMonitor() failed.");
-		return;
-	}
+    if (FAILED(GetDpiForMonitor(outputDesc_.Monitor, MDT_RAW_DPI, &dpiX_, &dpiY_)))
+    {
+        Debug::Error("Monitor::Initialize() => GetDpiForMonitor() failed.");
+        // DPI is set as -1, so the application has to use the appropriate value.
+    }
 
     auto output1 = reinterpret_cast<IDXGIOutput1*>(output);
     switch (output1->DuplicateOutput(GetDevice().Get(), &deskDupl_))
     {
         case S_OK:
-		{
-			state_ = State::Available;
-			Debug::Log("Monitor::Initialize() => OK.");
-			Debug::Log("    ID    : ", GetId());
-			Debug::Log("    Size  : (", GetWidth(), ", ", GetHeight(), ")");
-			Debug::Log("    DPI   : (", GetDpiX(), ", ", GetDpiY(), ")");
-			break;
-		}
+        {
+            state_ = State::Available;
+            Debug::Log("Monitor::Initialize() => OK.");
+            Debug::Log("    ID    : ", GetId());
+            Debug::Log("    Size  : (", GetWidth(), ", ", GetHeight(), ")");
+            Debug::Log("    DPI   : (", GetDpiX(), ", ", GetDpiY(), ")");
+            break;
+        }
         case E_INVALIDARG:
-		{
-			state_ = State::InvalidArg;
-			Debug::Error("Monitor::Initialize() => Invalid arguments.");
-			break;
-		}
+        {
+            state_ = State::InvalidArg;
+            Debug::Error("Monitor::Initialize() => Invalid arguments.");
+            break;
+        }
         case E_ACCESSDENIED:
-		{
-			// For example, when the user presses Ctrl + Alt + Delete and the screen
-			// switches to admin screen, this error occurs. 
-			state_ = State::AccessDenied;
-			Debug::Error("Monitor::Initialize() => Access denied.");
-			break;
-		}
+        {
+            // For example, when the user presses Ctrl + Alt + Delete and the screen
+            // switches to admin screen, this error occurs. 
+            state_ = State::AccessDenied;
+            Debug::Error("Monitor::Initialize() => Access denied.");
+            break;
+        }
         case DXGI_ERROR_UNSUPPORTED:
-		{
-			// If the display adapter on the computer is running under the Microsoft Hybrid system,
-			// this error occurs.
-			state_ = State::Unsupported;
-			Debug::Error("Monitor::Initialize() => Unsupported display.");
-			break;
-		}
+        {
+            // If the display adapter on the computer is running under the Microsoft Hybrid system,
+            // this error occurs.
+            state_ = State::Unsupported;
+            Debug::Error("Monitor::Initialize() => Unsupported display.");
+            break;
+        }
         case DXGI_ERROR_NOT_CURRENTLY_AVAILABLE:
-		{
-			// When other application use Desktop Duplication API, this error occurs.
-			state_ = State::CurrentlyNotAvailable;
-			Debug::Error("Monitor::Initialize() => Currently not available.");
-			break;
-		}
+        {
+            // When other application use Desktop Duplication API, this error occurs.
+            state_ = State::CurrentlyNotAvailable;
+            Debug::Error("Monitor::Initialize() => Currently not available.");
+            break;
+        }
         case DXGI_ERROR_SESSION_DISCONNECTED:
-		{
+        {
             state_ = State::SessionDisconnected;
             Debug::Error("Monitor::Initialize() => Session disconnected.");
-			break;
-		}
+            break;
+        }
         default:
-		{
-			state_ = State::Unknown;
-			Debug::Error("Monitor::Render() => Unknown Error.");
-			break;
-		}
+        {
+            state_ = State::Unknown;
+            Debug::Error("Monitor::Render() => Unknown Error.");
+            break;
+        }
     }
 }
 
@@ -123,47 +122,48 @@ void Monitor::Render(UINT timeout)
         switch (hr)
         {
             case DXGI_ERROR_ACCESS_LOST:
-			{
-				// If any monitor setting has changed (e.g. monitor size has changed),
-				// it is necessary to re-initialize monitors.
-				Debug::Log("Monitor::Render() => DXGI_ERROR_ACCESS_LOST.");
-				state_ = State::AccessLost;
-				break;
-			}
+            {
+                // If any monitor setting has changed (e.g. monitor size has changed),
+                // it is necessary to re-initialize monitors.
+                Debug::Log("Monitor::Render() => DXGI_ERROR_ACCESS_LOST.");
+                state_ = State::AccessLost;
+                break;
+            }
             case DXGI_ERROR_WAIT_TIMEOUT:
-			{
-				// This often occurs when timeout value is small and it is not problem. 
-				// Debug::Log("Monitor::Render() => DXGI_ERROR_WAIT_TIMEOUT.");
-				break;
-			}
+            {
+                // This often occurs when timeout value is small and it is not problem. 
+                // Debug::Log("Monitor::Render() => DXGI_ERROR_WAIT_TIMEOUT.");
+                break;
+            }
             case DXGI_ERROR_INVALID_CALL:
-			{
-				Debug::Error("Monitor::Render() => DXGI_ERROR_INVALID_CALL.");
-				break;
-			}
+            {
+                Debug::Error("Monitor::Render() => DXGI_ERROR_INVALID_CALL.");
+                break;
+            }
             case E_INVALIDARG:
-			{
-				Debug::Error("Monitor::Render() => E_INVALIDARG.");
-				break;
-			}
+            {
+                Debug::Error("Monitor::Render() => E_INVALIDARG.");
+                break;
+            }
             default:
-			{
-				state_ = State::Unknown;
-				Debug::Error("Monitor::Render() => Unknown Error.");
-				break;
-			}
+            {
+                state_ = State::Unknown;
+                Debug::Error("Monitor::Render() => Unknown Error.");
+                break;
+            }
         }
         return;
     }
 
+    // Get texture
     if (unityTexture_)
     {
         ID3D11Texture2D* texture;
-		if (FAILED(resource.CopyTo(&texture)))
-		{
-			Debug::Error("Monitor::Render() => resource.As() failed.");
-			return;
-		}
+        if (FAILED(resource.CopyTo(&texture)))
+        {
+            Debug::Error("Monitor::Render() => resource.As() failed.");
+            return;
+        }
 
         D3D11_TEXTURE2D_DESC srcDesc, dstDesc;
         texture->GetDesc(&srcDesc);
@@ -175,10 +175,10 @@ void Monitor::Render(UINT timeout)
             Debug::Error("    Source : (", srcDesc.Width, ", ", srcDesc.Height, ")");
             Debug::Error("    Dest   : (", dstDesc.Width, ", ", dstDesc.Height, ")");
             //Debug::Log("    => Try modifying width/height using reported value from DDA.");
-			//width_ = srcDesc.Width;
-			//height_ = srcDesc.Height;
-			state_ = MonitorState::TextureSizeInconsistent;
-			//SendMessageToUnity(Message::TextureSizeChanged);
+            //width_ = srcDesc.Width;
+            //height_ = srcDesc.Height;
+            state_ = MonitorState::TextureSizeInconsistent;
+            //SendMessageToUnity(Message::TextureSizeChanged);
         }
         else
         {
@@ -188,8 +188,8 @@ void Monitor::Render(UINT timeout)
         }
     }
 
-    cursor_->UpdateBuffer(frameInfo);
-    cursor_->UpdateTexture();
+    UpdateMetadata(frameInfo);
+    UpdateCursor(frameInfo);
 
     if (FAILED(deskDupl_->ReleaseFrame()))
     {
@@ -198,6 +198,109 @@ void Monitor::Render(UINT timeout)
 }
 
 
+void Monitor::UpdateCursor(const DXGI_OUTDUPL_FRAME_INFO& frameInfo)
+{
+    cursor_->UpdateBuffer(frameInfo);
+    cursor_->UpdateTexture();
+}
+
+
+void Monitor::UpdateMetadata(const DXGI_OUTDUPL_FRAME_INFO& frameInfo)
+{
+    metaData_.ExpandIfNeeded(frameInfo.TotalMetadataBufferSize);
+    UpdateMoveRects(frameInfo);
+    UpdateDirtyRects(frameInfo);
+}
+
+
+void Monitor::UpdateMoveRects(const DXGI_OUTDUPL_FRAME_INFO& frameInfo)
+{
+    moveRectSize_ = metaData_.Size();
+
+    const auto hr = deskDupl_->GetFrameMoveRects(
+        moveRectSize_,
+        metaData_.As<DXGI_OUTDUPL_MOVE_RECT>(), 
+        &moveRectSize_);
+
+    if (FAILED(hr))
+    {
+        switch (hr)
+        {
+            case DXGI_ERROR_ACCESS_LOST:
+            {
+                Debug::Log("Monitor::Render() => DXGI_ERROR_ACCESS_LOST (GetFrameMoveRects()).");
+                break;
+            }
+            case DXGI_ERROR_MORE_DATA:
+            {
+                Debug::Error("Monitor::Render() => DXGI_ERROR_MORE_DATA (GetFrameMoveRects()).");
+                break;
+            }
+            case DXGI_ERROR_INVALID_CALL:
+            {
+                Debug::Error("Monitor::Render() => DXGI_ERROR_INVALID_CALL (GetFrameMoveRects()).");
+                break;
+            }
+            case E_INVALIDARG:
+            {
+                Debug::Error("Monitor::Render() => E_INVALIDARG (GetFrameMoveRects()).");
+                break;
+            }
+            default:
+            {
+                Debug::Error("Monitor::Render() => Unknown Error (GetFrameMoveRects()).");
+                break;
+            }
+        }
+        return;
+    }
+}
+
+
+void Monitor::UpdateDirtyRects(const DXGI_OUTDUPL_FRAME_INFO& frameInfo)
+{
+    dirtyRectSize_ = metaData_.Size() - moveRectSize_;
+
+    const auto hr = deskDupl_->GetFrameDirtyRects(
+        dirtyRectSize_,
+        metaData_.As<RECT>(moveRectSize_ /* offset */), 
+        &dirtyRectSize_);
+
+    if (FAILED(hr))
+    {
+        switch (hr)
+        {
+            case DXGI_ERROR_ACCESS_LOST:
+            {
+                Debug::Log("Monitor::Render() => DXGI_ERROR_ACCESS_LOST (GetFrameDirtyRects()).");
+                break;
+            }
+            case DXGI_ERROR_MORE_DATA:
+            {
+                Debug::Error("Monitor::Render() => DXGI_ERROR_MORE_DATA (GetFrameDirtyRects()).");
+                break;
+            }
+            case DXGI_ERROR_INVALID_CALL:
+            {
+                Debug::Error("Monitor::Render() => DXGI_ERROR_INVALID_CALL (GetFrameDirtyRects()).");
+                break;
+            }
+            case E_INVALIDARG:
+            {
+                Debug::Error("Monitor::Render() => E_INVALIDARG (GetFrameDirtyRects()).");
+                break;
+            }
+            default:
+            {
+                Debug::Error("Monitor::Render() => Unknown Error (GetFrameDirtyRects()).");
+                break;
+            }
+        }
+        return;
+    }
+}
+
+
 int Monitor::GetId() const
 {
     return id_;
@@ -296,11 +399,35 @@ int Monitor::GetDpiY() const
 
 int Monitor::GetWidth() const
 {
-	return width_;
+    return width_;
 }
 
 
 int Monitor::GetHeight() const
 {
-	return height_;
+    return height_;
+}
+
+
+int Monitor::GetMoveRectCount() const
+{
+    return moveRectSize_ / sizeof(DXGI_OUTDUPL_MOVE_RECT);
+}
+
+
+DXGI_OUTDUPL_MOVE_RECT* Monitor::GetMoveRects() const
+{
+    return metaData_.As<DXGI_OUTDUPL_MOVE_RECT>();
+}
+
+
+int Monitor::GetDirtyRectCount() const
+{
+    return dirtyRectSize_ / sizeof(RECT);
+}
+
+
+RECT* Monitor::GetDirtyRects() const
+{
+    return metaData_.As<RECT>(moveRectSize_);
 }

Plugins/uDesktopDuplication/uDesktopDuplication/Monitor.h

@@ -4,6 +4,7 @@
 #include <dxgi1_2.h>
 #include <wrl/client.h>
 #include <memory>
+#include "Common.h"
 
 class Cursor;
 
@@ -17,7 +18,7 @@ enum class MonitorState
     CurrentlyNotAvailable = 4,
     SessionDisconnected = 5,
     AccessLost = 6,
-	TextureSizeInconsistent = 7,
+    TextureSizeInconsistent = 7,
     Unknown = 999,
 };
 
@@ -50,15 +51,27 @@ public:
     int GetDpiY() const;
     IDXGIOutputDuplication* GetDeskDupl();
     const std::unique_ptr<Cursor>& GetCursor();
+	int GetMoveRectCount() const;
+	DXGI_OUTDUPL_MOVE_RECT* GetMoveRects() const;
+	int GetDirtyRectCount() const;
+	RECT* GetDirtyRects() const;
 
 private:
+	void UpdateCursor(const DXGI_OUTDUPL_FRAME_INFO& frameInfo);
+	void UpdateMetadata(const DXGI_OUTDUPL_FRAME_INFO& frameInfo);
+	void UpdateMoveRects(const DXGI_OUTDUPL_FRAME_INFO& frameInfo);
+	void UpdateDirtyRects(const DXGI_OUTDUPL_FRAME_INFO& frameInfo);
+
     int id_ = -1;
     UINT dpiX_ = -1, dpiY_ = -1;
-	int width_ = -1, height_ = -1;
+    int width_ = -1, height_ = -1;
     State state_ = State::NotSet;
     std::unique_ptr<Cursor> cursor_;
     IDXGIOutputDuplication* deskDupl_ = nullptr;
     ID3D11Texture2D* unityTexture_ = nullptr;
     DXGI_OUTPUT_DESC outputDesc_;
     MONITORINFOEX monitorInfo_;
+	Buffer<BYTE> metaData_;
+	UINT moveRectSize_ = 0;
+	UINT dirtyRectSize_ = 0;;
 };

Plugins/uDesktopDuplication/uDesktopDuplication/MonitorManager.cpp

@@ -35,11 +35,11 @@ void MonitorManager::Initialize()
 
     // Get factory
     ComPtr<IDXGIFactory1> factory;
-	if (FAILED(CreateDXGIFactory1(IID_PPV_ARGS(&factory))))
-	{
-		Debug::Error("MonitorManager::Initialize() => CreateDXGIFactory1() failed.");
-		return;
-	}
+    if (FAILED(CreateDXGIFactory1(IID_PPV_ARGS(&factory))))
+    {
+        Debug::Error("MonitorManager::Initialize() => CreateDXGIFactory1() failed.");
+        return;
+    }
 
     // Check all display adapters
     int id = 0;
@@ -47,7 +47,7 @@ void MonitorManager::Initialize()
     for (int i = 0; (factory->EnumAdapters1(i, &adapter) != DXGI_ERROR_NOT_FOUND); ++i) 
     {
         // Search the main monitor from all outputs
-		ComPtr<IDXGIOutput> output;
+        ComPtr<IDXGIOutput> output;
         for (int j = 0; (adapter->EnumOutputs(j, &output) != DXGI_ERROR_NOT_FOUND); ++j) 
         {
             auto monitor = std::make_shared<Monitor>(id++);
@@ -81,24 +81,24 @@ void MonitorManager::Reinitialize()
 bool MonitorManager::HasMonitorCountChanged() const
 {
     ComPtr<IDXGIFactory1> factory;
-	if (FAILED(CreateDXGIFactory1(IID_PPV_ARGS(&factory))))
-	{
-		Debug::Error("MonitorManager::CheckMonitorConnection() => CreateDXGIFactory1() failed.");
-		return false;
-	}
+    if (FAILED(CreateDXGIFactory1(IID_PPV_ARGS(&factory))))
+    {
+        Debug::Error("MonitorManager::CheckMonitorConnection() => CreateDXGIFactory1() failed.");
+        return false;
+    }
 
     int id = 0;
     ComPtr<IDXGIAdapter1> adapter;
     for (int i = 0; (factory->EnumAdapters1(i, &adapter) != DXGI_ERROR_NOT_FOUND); ++i) 
     {
-		ComPtr<IDXGIOutput> output;
+        ComPtr<IDXGIOutput> output;
         for (int j = 0; (adapter->EnumOutputs(j, &output) != DXGI_ERROR_NOT_FOUND); ++j) 
         {
             id++;
         }
     }
 
-	return monitors_.size() != id;
+    return monitors_.size() != id;
 }
 
 

Plugins/uDesktopDuplication/uDesktopDuplication/main.cpp

@@ -36,14 +36,30 @@ extern "C"
 
     UNITY_INTERFACE_EXPORT void UNITY_INTERFACE_API FinalizeUDD()
     {
-        if (g_manager)
+        if (!g_manager) return;
+
+        g_manager.reset();
+
+        std::queue<Message> empty;
+        g_messages.swap(empty);
+
+        Debug::Finalize();
+    }
+
+    void UNITY_INTERFACE_API OnGraphicsDeviceEvent(UnityGfxDeviceEventType event)
+    {
+        switch (event)
         {
-            g_manager.reset();
-
-            std::queue<Message> empty;
-            g_messages.swap(empty);
-
-            Debug::Finalize();
+            case kUnityGfxDeviceEventInitialize:
+            {
+                InitializeUDD();
+                break;
+            }
+            case kUnityGfxDeviceEventShutdown:
+            {
+                FinalizeUDD();
+                break;
+            }
         }
     }
 
@@ -51,10 +67,16 @@ extern "C"
     {
         g_unity = unityInterfaces;
         InitializeUDD();
+
+        auto unityGraphics = g_unity->Get<IUnityGraphics>();
+        unityGraphics->RegisterDeviceEventCallback(OnGraphicsDeviceEvent);
     }
 
     UNITY_INTERFACE_EXPORT void UNITY_INTERFACE_API UnityPluginUnload()
     {
+        auto unityGraphics = g_unity->Get<IUnityGraphics>();
+        unityGraphics->UnregisterDeviceEventCallback(OnGraphicsDeviceEvent);
+
         FinalizeUDD();
         g_unity = nullptr;
     }
@@ -361,4 +383,40 @@ extern "C"
             monitor->SetUnityTexture(d3d11Texture);
         }
     }
+
+    UNITY_INTERFACE_EXPORT int UNITY_INTERFACE_API GetMoveRectCount(int id)
+    {
+        if (!g_manager) return -1;
+        if (auto monitor = g_manager->GetMonitor(id))
+        {
+            return monitor->GetMoveRectCount();
+        }
+    }
+
+    UNITY_INTERFACE_EXPORT void* UNITY_INTERFACE_API GetMoveRects(int id)
+    {
+        if (!g_manager) return nullptr;
+        if (auto monitor = g_manager->GetMonitor(id))
+        {
+            return monitor->GetMoveRects();
+        }
+    }
+
+    UNITY_INTERFACE_EXPORT int UNITY_INTERFACE_API GetDirtyRectCount(int id)
+    {
+        if (!g_manager) return -1;
+        if (auto monitor = g_manager->GetMonitor(id))
+        {
+            return monitor->GetDirtyRectCount();
+        }
+    }
+
+    UNITY_INTERFACE_EXPORT void* UNITY_INTERFACE_API GetDirtyRects(int id)
+    {
+        if (!g_manager) return nullptr;
+        if (auto monitor = g_manager->GetMonitor(id))
+        {
+            return monitor->GetDirtyRects();
+        }
+    }
 }

Plugins/uDesktopDuplication/uDesktopDuplication/uDesktopDuplication.vcxproj

@@ -112,10 +112,11 @@
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <ClCompile>
       <WarningLevel>Level3</WarningLevel>
-      <Optimization>MaxSpeed</Optimization>
+      <Optimization>Full</Optimization>
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <SDLCheck>true</SDLCheck>
+      <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
     </ClCompile>
     <Link>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>

README.md

@@ -1,6 +1,9 @@
 uDesktopDuplication
 ===================
 
+![MIT License](http://img.shields.io/badge/license-MIT-blue.svg?style=flat)
+![Build Status](http://unitybuildbadge.azurewebsites.net/api/status/7566d616-2916-4c99-bb14-e7ab9501cf7e)
+
 **uDesktopDuplication** is an Unity asset to use the realtime screen capture as `Texture2D` using Desktop Duplication API.