update board.

.gitignore

@@ -27,3 +27,4 @@ sysinfo.txt
 .DS_Store
 /Assets/AssetStoreTools*
 /Assets/Extensions*
+/uDesktopDuplication.log

Assets/uDesktopDuplication/Examples/Prefabs/Monitor Plane.prefab.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 42d6b6dbae38a384e882c2c907915139
+timeCreated: 1478889784
+licenseType: Pro
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/uDesktopDuplication/Examples/Scenes/Multiple Monitors Roundly.unity.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 4bae91f55031b98488c9e668031f7387
+timeCreated: 1478610618
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/uDesktopDuplication/Examples/Scenes/Zoom.unity.meta

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

Assets/uDesktopDuplication/Examples/Scripts/Loupe.cs

@@ -0,0 +1,35 @@
+using UnityEngine;
+
+public class Loupe : MonoBehaviour
+{
+    private uDesktopDuplication.Texture uddTexture_;
+    public float zoom = 3f;
+    public float aspect = 1f;
+
+    void Start()
+    {
+        uddTexture_ = GetComponent<uDesktopDuplication.Texture>();
+        uddTexture_.useClip = true;
+    }
+
+    void Update()
+    {
+        uddTexture_.monitorId = uDesktopDuplication.Manager.cursorMonitorId;
+
+        // To get other monitor textures, set dirty flag.
+        foreach (var monitor in uDesktopDuplication.Manager.monitors) {
+            monitor.CreateTexture();
+            monitor.shouldBeUpdated = true;
+        }
+
+        var x = (float)uddTexture_.monitor.cursorX / uddTexture_.monitor.width;
+        var y = (float)uddTexture_.monitor.cursorY / uddTexture_.monitor.height;
+        var w = 1f / zoom;
+        var h = w / aspect * uddTexture_.monitor.aspect;
+        x = Mathf.Clamp(x - w / 2, 0f, 1f - w);
+        y = Mathf.Clamp(y - h / 2, 0f, 1f - h);
+        uddTexture_.clipPos = new Vector2(x, y);
+        uddTexture_.clipScale = new Vector2(w, h);
+    }
+}
+

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

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

Assets/uDesktopDuplication/Examples/Scripts/MultipleMonitorCreator.cs

@@ -4,17 +4,39 @@ using System.Collections.Generic;
 public class MultipleMonitorCreator : MonoBehaviour
 {
     [SerializeField] GameObject monitorPrefab;
-    [SerializeField] float scale = 1f;
-    [SerializeField] float margin = 1f;
+    [SerializeField] bool removeIfUnsupported = true;
+    [SerializeField] float removeWaitDuration = 5f;
+    bool hasMonitorUnsupportStateChecked = false;
+    float removeWaitTimer_ = 0f;
 
-    private List<GameObject> monitors_ = new List<GameObject>();
-    private float totalWidth_ = 0f;
+    public enum MeshForwardDirection { Y, Z }
+    [Tooltip("Please specify the upper vector direction of the mesh (e.g. Plane's upper direction is Y.)")]
+    public MeshForwardDirection meshForwardDirection = MeshForwardDirection.Z;
+
+    public class MonitorInfo
+    {
+        public GameObject gameObject { get; set; }
+        public Quaternion originalRotation { get; set; }
+        public uDesktopDuplication.Texture uddTexture { get; set; }
+        public Mesh mesh { get; set; }
+    }
+
+    private List<MonitorInfo> monitors_ = new List<MonitorInfo>();
+    public List<MonitorInfo> monitors { get { return monitors_; } }
 
     void Start()
     {
+        uDesktopDuplication.Manager.CreateInstance();
         Create();
     }
 
+    void Update()
+    {
+        if (removeIfUnsupported) {
+            RemoveUnsupportedDisplayAfterRemoveTimer();
+        }
+    }
+
     void OnEnable()
     {
         uDesktopDuplication.Manager.onReinitialized += Recreate;
@@ -25,26 +47,44 @@ public class MultipleMonitorCreator : MonoBehaviour
         uDesktopDuplication.Manager.onReinitialized -= Recreate;
     }
 
-    void Create()
+    void RemoveUnsupportedDisplayAfterRemoveTimer()
     {
-        CreateMonitors();
-        LayoutMonitors();
+        if (!hasMonitorUnsupportStateChecked) {
+            removeWaitTimer_ += Time.deltaTime;
+            if (removeWaitTimer_ > removeWaitDuration) {
+                hasMonitorUnsupportStateChecked = true;
+                foreach (var info in monitors_) {
+                    if (info.uddTexture.monitor.state == uDesktopDuplication.MonitorState.Unsupported) {
+                        Destroy(info.gameObject);
+                    }
+                }
+                monitors_.RemoveAll(info => info.uddTexture.monitor.state == uDesktopDuplication.MonitorState.Unsupported);
+            }
+        }
     }
 
-    void CreateMonitors()
+    void ResetRemoveTimer()
     {
-        // Sort monitors in coordinate order
-        var monitors = uDesktopDuplication.Manager.monitors;
-        monitors.Sort((a, b) => a.left - b.left);
+        hasMonitorUnsupportStateChecked = false;
+        removeWaitTimer_ = 0f;
+    }
+
+    void Create()
+    {
+        ResetRemoveTimer();
 
         // Create monitors
-        var n = monitors.Count;
-        totalWidth_ = 0f;
-        for (int i = 0 ; i < n; ++i) {
+        for (int i = 0; i < uDesktopDuplication.Manager.monitorCount; ++i) {
             // Create monitor obeject
             var go = Instantiate(monitorPrefab);
             go.name = "Monitor " + i;
-            monitors_.Add(go);
+
+            // Expand AABB
+            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);
+            mesh.bounds = new Bounds(mesh.bounds.center, aabbScale);
 
             // Assign monitor
             var texture = go.GetComponent<uDesktopDuplication.Texture>();
@@ -52,37 +92,32 @@ public class MultipleMonitorCreator : MonoBehaviour
             var monitor = texture.monitor;
 
             // Set width / height
-            go.transform.localScale = new Vector3(monitor.widthMeter, go.transform.localScale.y, monitor.heightMeter);
+            if (meshForwardDirection == MeshForwardDirection.Y) {
+                go.transform.localScale = new Vector3(monitor.widthMeter, go.transform.localScale.y, monitor.heightMeter);
+            } else {
+                go.transform.localScale = new Vector3(monitor.widthMeter, monitor.heightMeter, go.transform.localScale.z);
+            }
 
             // Set parent as this object
             go.transform.SetParent(transform);
 
-            // Calc actual size considering mesh size
-            var scaleX = go.GetComponent<MeshFilter>().sharedMesh.bounds.extents.x * 2f;
-            totalWidth_ += monitor.widthMeter * scaleX;
+            // Save
+            var info = new MonitorInfo();
+            info.gameObject = go;
+            info.originalRotation = go.transform.rotation;
+            info.uddTexture = texture;
+            info.mesh = mesh;
+            monitors_.Add(info);
         }
-    }
 
-    void LayoutMonitors()
-    {
-        // Set positions with margin
-        totalWidth_ += margin * (monitors_.Count - 1);
-        var x = -totalWidth_ / 2;
-        foreach (var go in monitors_) {
-            var monitor = go.GetComponent<uDesktopDuplication.Texture>().monitor;
-            var halfScaleX = go.GetComponent<MeshFilter>().sharedMesh.bounds.extents.x;
-            var width = monitor.widthMeter;
-            var halfWidth = width * halfScaleX;
-            x += halfWidth;
-            go.transform.localPosition = new Vector3(x, 0f, 0f);
-            x += halfWidth + margin;
-        }
+        // Sort monitors in coordinate order
+        monitors_.Sort((a, b) => a.uddTexture.monitor.left - b.uddTexture.monitor.left);
     }
 
     void Clear()
     {
-        foreach (var go in monitors_) {
-            Destroy(go);
+        foreach (var info in monitors_) {
+            Destroy(info.gameObject);
         }
         monitors_.Clear();
     }

Assets/uDesktopDuplication/Examples/Scripts/MultipleMonitorLayouter.cs

@@ -0,0 +1,52 @@
+using UnityEngine;
+
+[RequireComponent(typeof(MultipleMonitorCreator))]
+public class MultipleMonitorLayouter : MonoBehaviour
+{
+    protected MultipleMonitorCreator creator_;
+    [SerializeField] bool updateEveryFrame = true;
+    [SerializeField] protected float margin = 0.1f;
+
+    void Start()
+    {
+        creator_ = GetComponent<MultipleMonitorCreator>();
+        Layout();
+    }
+
+    protected virtual void Update()
+    {
+        if (updateEveryFrame) {
+            Layout();
+        }
+    }
+
+    void LateUpdate()
+    {
+        margin = Mathf.Max(margin, 0f);
+    }
+
+    protected virtual void Layout()
+    {
+        var monitors = creator_.monitors;
+        var n = monitors.Count;
+
+        var totalWidth = 0f;
+        foreach (var info in monitors) {
+            var width = info.uddTexture.monitor.widthMeter * (info.mesh.bounds.extents.x * 2f);
+            totalWidth += width;
+        }
+        totalWidth += margin * (n - 1);
+
+        var x = -totalWidth / 2;
+
+        foreach (var info in creator_.monitors) {
+            var monitor = info.uddTexture.monitor;
+            x += (monitor.widthMeter * info.mesh.bounds.extents.x);
+            info.gameObject.transform.localPosition = new Vector3(x, 0f, 0f);
+            info.gameObject.transform.localRotation = info.originalRotation;
+            x += (monitor.widthMeter * info.mesh.bounds.extents.x) + margin;
+        }
+    }
+
+}
+

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

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

Assets/uDesktopDuplication/Examples/Scripts/MultipleMonitorRoundLayouter.cs

@@ -0,0 +1,64 @@
+using UnityEngine;
+
+public class MultipleMonitorRoundLayouter : MultipleMonitorLayouter
+{
+    [SerializeField] float radius = 10f;
+
+    void OnDisable()
+    {
+        foreach (var info in creator_.monitors) {
+            info.uddTexture.bend = uDesktopDuplication.Texture.Bend.Off;
+        }
+    }
+
+    protected override void Layout()
+    {
+        var monitors = creator_.monitors;
+        var n = monitors.Count;
+
+        var totalWidth = 0f;
+        foreach (var info in monitors) {
+            var width = info.uddTexture.monitor.widthMeter * (info.mesh.bounds.extents.x * 2f);
+            totalWidth += width;
+        }
+        totalWidth += margin * (n - 1);
+
+        radius = Mathf.Max(radius, (totalWidth + margin) / (2 * Mathf.PI));
+        var totalAngle = totalWidth / radius;
+
+        float angle = -totalAngle / 2;
+        foreach (var info in monitors) {
+            var uddTex = info.uddTexture;
+            var width = uddTex.monitor.widthMeter * (info.mesh.bounds.extents.x * 2f);
+
+            angle += (width / radius) * 0.5f;
+            uddTex.transform.localPosition = radius * new Vector3(Mathf.Sin(angle), 0f, Mathf.Cos(angle) - 1f);
+            uddTex.transform.localRotation = Quaternion.AngleAxis(angle * Mathf.Rad2Deg, Vector3.up) * info.originalRotation;
+            angle += (width * 0.5f + margin) / radius;
+
+            if (creator_.meshForwardDirection == MultipleMonitorCreator.MeshForwardDirection.Y) {
+                uddTex.bend = uDesktopDuplication.Texture.Bend.Y;
+            } else {
+                uddTex.bend = uDesktopDuplication.Texture.Bend.Z;
+            }
+            uddTex.radius = radius;
+            uddTex.width = uddTex.transform.localScale.x;
+        }
+    }
+
+    protected override void Update()
+    {
+        base.Update();
+
+        var scale = transform.localScale.x;
+        var center = transform.position - Vector3.forward * radius * scale;
+        for (int i = 0; i < 100; ++i) {
+            var a0 = 2 * Mathf.PI * i / 100;
+            var a1 = 2 * Mathf.PI * (i + 1) / 100;
+            var p0 = center + radius * scale * new Vector3(Mathf.Cos(a0), 0f, Mathf.Sin(a0));
+            var p1 = center + radius * scale * new Vector3(Mathf.Cos(a1), 0f, Mathf.Sin(a1));
+            Debug.DrawLine(p0, p1, Color.red);
+        }
+    }
+}
+

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

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

Assets/uDesktopDuplication/Models.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 75494e992a22ea44d9b614d7fd3dc235
+folderAsset: yes
+timeCreated: 1478887431
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/uDesktopDuplication/Models/uDD_Board.fbx.meta

@@ -0,0 +1,78 @@
+fileFormatVersion: 2
+guid: d6b30b913257fee4d8246bf7a2620fcd
+timeCreated: 1478887431
+licenseType: Pro
+ModelImporter:
+  serializedVersion: 19
+  fileIDToRecycleName:
+    100000: //RootNode
+    400000: //RootNode
+    2300000: //RootNode
+    3300000: //RootNode
+    4300000: pCube1
+    4300002: uDD_Board
+    9500000: //RootNode
+  materials:
+    importMaterials: 0
+    materialName: 0
+    materialSearch: 1
+  animations:
+    legacyGenerateAnimations: 4
+    bakeSimulation: 0
+    resampleCurves: 1
+    optimizeGameObjects: 0
+    motionNodeName: 
+    animationImportErrors: 
+    animationImportWarnings: 
+    animationRetargetingWarnings: 
+    animationDoRetargetingWarnings: 0
+    animationCompression: 1
+    animationRotationError: 0.5
+    animationPositionError: 0.5
+    animationScaleError: 0.5
+    animationWrapMode: 0
+    extraExposedTransformPaths: []
+    clipAnimations: []
+    isReadable: 0
+  meshes:
+    lODScreenPercentages: []
+    globalScale: 0.1
+    meshCompression: 0
+    addColliders: 0
+    importBlendShapes: 1
+    swapUVChannels: 0
+    generateSecondaryUV: 0
+    useFileUnits: 1
+    optimizeMeshForGPU: 1
+    keepQuads: 0
+    weldVertices: 1
+    secondaryUVAngleDistortion: 8
+    secondaryUVAreaDistortion: 15.000001
+    secondaryUVHardAngle: 88
+    secondaryUVPackMargin: 4
+    useFileScale: 1
+  tangentSpace:
+    normalSmoothAngle: 60
+    normalImportMode: 0
+    tangentImportMode: 2
+  importAnimation: 0
+  copyAvatar: 0
+  humanDescription:
+    human: []
+    skeleton: []
+    armTwist: 0.5
+    foreArmTwist: 0.5
+    upperLegTwist: 0.5
+    legTwist: 0.5
+    armStretch: 0.05
+    legStretch: 0.05
+    feetSpacing: 0
+    rootMotionBoneName: 
+    hasTranslationDoF: 0
+  lastHumanDescriptionAvatarSource: {instanceID: 0}
+  animationType: 0
+  humanoidOversampling: 1
+  additionalBone: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/uDesktopDuplication/Plugins/x86_64.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 99257566ccd0582439a44abad90e65d4
+folderAsset: yes
+timeCreated: 1478626361
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/uDesktopDuplication/Scripts/Cursor.cs

@@ -1,4 +1,5 @@
 using UnityEngine;
+using UnityEngine.Assertions;
 using System.Collections.Generic;
 
 namespace uDesktopDuplication
@@ -8,14 +9,13 @@ namespace uDesktopDuplication
  RequireComponent(typeof(Texture))]
 public class Cursor : MonoBehaviour
 {
+    [SerializeField] Vector2 modelScale = Vector2.one;
+
     Vector3 worldPosition { get; set; }
 
     private Texture uddTexture_;
     private Monitor monitor { get { return uddTexture_.monitor; } }
-
-    private Texture2D currentTexture_;
-    private Dictionary<Vector2, Texture2D> textures_ = new Dictionary<Vector2, Texture2D>();
-    [SerializeField] Vector2 modelScale = Vector2.one;
+    private Dictionary<int, Texture2D> textures_ = new Dictionary<int, Texture2D>();
 
     void Start()
     {
@@ -27,8 +27,8 @@ public class Cursor : MonoBehaviour
         if (monitor.isCursorVisible) {
             UpdatePosition();
             UpdateTexture();
-            UpdateMaterial();
         }
+        UpdateMaterial();
     }
 
     void UpdatePosition()
@@ -46,14 +46,15 @@ public class Cursor : MonoBehaviour
         var h = monitor.cursorShapeHeight;
         if (w == 0 || h == 0) return;
 
-        var scale = new Vector2(w, h);
-        if (!textures_.ContainsKey(scale)) {
+        var key = w + h * 100;
+        if (!textures_.ContainsKey(key)) {
             var texture = new Texture2D(w, h, TextureFormat.BGRA32, false);
             texture.wrapMode = TextureWrapMode.Clamp;
-            textures_.Add(scale, texture);
+            textures_.Add(key, texture);
         }
 
-        var cursorTexture = textures_[scale];
+        var cursorTexture = textures_[key];
+        Assert.IsNotNull(cursorTexture);
         monitor.GetCursorTexture(cursorTexture.GetNativeTexturePtr());
         uddTexture_.material.SetTexture("_CursorTex", cursorTexture);
     }

Assets/uDesktopDuplication/Scripts/Lib.cs

@@ -39,9 +39,18 @@ public enum MonitorState
 	AccessLost = 6,
 }
 
+public enum DebugMode
+{
+    None = 0,
+    File = 1,
+    UnityLog = 2, /* currently has bug when app exits. */
+}
+
 public static class Lib
 {
     public delegate void MessageHandler(Message message);
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate void DebugLogDelegate(string str);
 
     [DllImport("uDesktopDuplication")]
     public static extern void InitializeUDD();
@@ -54,8 +63,20 @@ public static class Lib
     [DllImport("uDesktopDuplication")]
     public static extern Message PopMessage();
     [DllImport("uDesktopDuplication")]
+    public static extern void EnableDebug();
+    [DllImport("uDesktopDuplication")]
+    public static extern void DisableDebug();
+    [DllImport("uDesktopDuplication")]
+    public static extern void SetDebugMode(DebugMode mode);
+    [DllImport("uDesktopDuplication")]
+    public static extern void SetLogFunc(IntPtr func);
+    [DllImport("uDesktopDuplication")]
+    public static extern void SetErrorFunc(IntPtr func);
+    [DllImport("uDesktopDuplication")]
     public static extern int GetMonitorCount();
     [DllImport("uDesktopDuplication")]
+    public static extern int GetCursorMonitorId();
+    [DllImport("uDesktopDuplication")]
     public static extern int GetTotalWidth();
     [DllImport("uDesktopDuplication")]
     public static extern int GetTotalHeight();
@@ -64,6 +85,8 @@ public static class Lib
     [DllImport("uDesktopDuplication")]
     public static extern IntPtr GetRenderEventFunc();
     [DllImport("uDesktopDuplication")]
+    public static extern int GetId(int id);
+    [DllImport("uDesktopDuplication")]
     public static extern MonitorState GetState(int id);
     [DllImport("uDesktopDuplication")]
     public static extern void GetName(int id, StringBuilder buf, int len);

Assets/uDesktopDuplication/Scripts/Manager.cs

@@ -1,6 +1,7 @@
 using UnityEngine;
 using System.Collections;
 using System.Collections.Generic;
+using System.Runtime.InteropServices;
 
 namespace uDesktopDuplication
 {
@@ -10,21 +11,7 @@ public class Manager : MonoBehaviour
     private static Manager instance_;
     public static Manager instance 
     {
-        get 
-        { 
-            if (instance_) {
-                return instance_;
-            }
-
-            var manager = FindObjectOfType<Manager>();
-            if (manager) {
-                manager.Awake();
-                return manager;
-            }
-
-            var go = new GameObject("uDesktopDuplicationManager");
-            return go.AddComponent<Manager>();
-        }
+        get { return CreateInstance(); }
     }
 
     private List<Monitor> monitors_ = new List<Monitor>();
@@ -38,6 +25,11 @@ public class Manager : MonoBehaviour
         get { return Lib.GetMonitorCount(); }
     }
 
+    static public int cursorMonitorId 
+    {
+        get { return Lib.GetCursorMonitorId(); }
+    }
+
     static public Monitor primary
     {
         get 
@@ -46,18 +38,36 @@ public class Manager : MonoBehaviour
         }
     }
 
+    [SerializeField] DebugMode debugMode = DebugMode.File;
     [SerializeField] int desktopDuplicationApiTimeout = 0;
     [SerializeField] float retryReinitializationDuration = 1f;
 
     private Coroutine renderCoroutine_ = null;
-    private bool shouldReinitialize = false;
-    private float reinitializationTimer = 0f;
+    private bool shouldReinitialize_ = false;
+    private float reinitializationTimer_ = 0f;
 
     public delegate void ReinitializeHandler();
     public static event ReinitializeHandler onReinitialized;
 
+    public static Manager CreateInstance()
+    {
+        if (instance_) {
+            return instance_;
+        }
+
+        var manager = FindObjectOfType<Manager>();
+        if (manager) {
+            manager.Awake();
+            return manager;
+        }
+
+        var go = new GameObject("uDesktopDuplicationManager");
+        return go.AddComponent<Manager>();
+    }
+
     void Awake()
     {
+        Lib.SetDebugMode(debugMode);
         Lib.InitializeUDD();
 
         if (instance_ != null) return;
@@ -91,12 +101,6 @@ public class Manager : MonoBehaviour
         Lib.Update();
         ReinitializeIfNeeded();
         UpdateMessage();
-
-        /*
-        foreach (var monitor in monitors_) {
-            Debug.LogFormat("[{0}] {1}", monitor.id, monitor.state);
-        }
-        */
     }
 
     [ContextMenu("Reinitialize")]
@@ -115,20 +119,20 @@ public class Manager : MonoBehaviour
                 monitor.state == MonitorState.AccessLost || 
                 monitor.state == MonitorState.AccessDenied ||
                 monitor.state == MonitorState.SessionDisconnected) {
-                if (!shouldReinitialize) {
-                    shouldReinitialize = true;
-                    reinitializationTimer = 0f;
+                if (!shouldReinitialize_) {
+                    shouldReinitialize_ = true;
+                    reinitializationTimer_ = 0f;
                     break;
                 }
             }
         }
 
-        if (shouldReinitialize) {
-            if (reinitializationTimer > retryReinitializationDuration) {
+        if (shouldReinitialize_) {
+            if (reinitializationTimer_ > retryReinitializationDuration) {
                 Reinitialize();
-                shouldReinitialize = false;
+                shouldReinitialize_ = false;
             }
-            reinitializationTimer += Time.deltaTime;
+            reinitializationTimer_ += Time.deltaTime;
         }
     }
 
@@ -163,6 +167,7 @@ public class Manager : MonoBehaviour
 
     void CreateMonitors()
     {
+        monitors.Clear();
         for (int i = 0; i < monitorCount; ++i) {
             monitors.Add(new Monitor(i));
         }

Assets/uDesktopDuplication/Scripts/Monitor.cs

@@ -196,7 +196,7 @@ public class Monitor
         Lib.GetCursorTexture(id, ptr);
     }
 
-    void CreateTexture()
+    public void CreateTexture()
     {
         if (!available) return;
 

Assets/uDesktopDuplication/Scripts/Texture.cs

@@ -13,8 +13,9 @@ public class Texture : MonoBehaviour
         set 
         { 
             monitor_ = value;
-            material = GetComponent<Renderer>().material;
+            material = GetComponent<Renderer>().material; // clone
             material.mainTexture = monitor_.texture;
+            material.SetFloat("_Width", transform.localScale.x);
         }
     }
 
@@ -24,9 +25,65 @@ public class Texture : MonoBehaviour
         set { monitor = Manager.monitors[Mathf.Clamp(value, 0, Manager.monitorCount - 1)]; }
     }
 
+    [Header("Invert UVs")]
     public bool invertX = false;
     public bool invertY = false;
 
+    [Header("Clip")]
+    public bool useClip = false;
+    public Vector2 clipPos = Vector2.zero;
+    public Vector2 clipScale = new Vector2(0.2f, 0.2f);
+
+    public enum Bend
+    {
+        Off = 0,
+        Y = 1,
+        Z = 2,
+    }
+
+    public Bend bend
+    {
+        get 
+        {
+            return (Bend)material.GetInt("_Bend");
+        }
+        set 
+        {
+            switch (value) {
+                case Bend.Off:
+                    material.SetInt("_Bend", 0);
+                    material.DisableKeyword("_BEND_OFF");
+                    material.DisableKeyword("_BEND_Y");
+                    material.DisableKeyword("_BEND_Z");
+                    break;
+                case Bend.Y:
+                    material.SetInt("_Bend", 1);
+                    material.DisableKeyword("_BEND_OFF");
+                    material.EnableKeyword("_BEND_Y");
+                    material.DisableKeyword("_BEND_Z");
+                    break;
+                case Bend.Z:
+                    material.SetInt("_Bend", 2);
+                    material.DisableKeyword("_BEND_OFF");
+                    material.DisableKeyword("_BEND_Y");
+                    material.EnableKeyword("_BEND_Z");
+                    break;
+            }
+        }
+    }
+
+    public float radius
+    {
+        get { return material.GetFloat("_Radius"); }
+        set { material.SetFloat("_Radius", value); }
+    }
+
+    public float width
+    {
+        get { return material.GetFloat("_Width"); }
+        set { material.SetFloat("_Width", value); }
+    }
+
     public Material material
     {
         get;
@@ -55,6 +112,13 @@ public class Texture : MonoBehaviour
     }
 
     void UpdateMaterial()
+    {
+        Invert();
+        Rotate();
+        Clip();
+    }
+
+    void Invert()
     {
         if (invertX) {
             material.EnableKeyword("INVERT_X");
@@ -67,7 +131,10 @@ public class Texture : MonoBehaviour
         } else {
             material.DisableKeyword("INVERT_Y");
         }
+    }
 
+    void Rotate()
+    {
         switch (monitor.rotation)
         {
             case MonitorRotation.Identity:
@@ -94,6 +161,16 @@ public class Texture : MonoBehaviour
                 break;
         }
     }
+
+    void Clip()
+    {
+        if (useClip) {
+            material.EnableKeyword("USE_CLIP");
+            material.SetVector("_ClipPositionScale", new Vector4(clipPos.x, clipPos.y, clipScale.x, clipScale.y));
+        } else {
+            material.DisableKeyword("USE_CLIP");
+        }
+    }
 }
 
 }

Assets/uDesktopDuplication/Shaders/uDD_Common.cginc

@@ -2,6 +2,7 @@
 #define UDD_COMMON_CGINC
 
 #include "UnityCG.cginc"
+#include "./uDD_Params.cginc"
 
 struct appdata
 {
@@ -48,6 +49,13 @@ float2 uddRotateUV(float2 uv)
     return uv;
 }
 
+float2 uddClipUV(float2 uv)
+{
+    uv.x = _ClipX + uv.x * _ClipWidth;
+    uv.y = _ClipY + uv.y * _ClipHeight;
+    return uv;
+}
+
 inline void uddConvertToLinearIfNeeded(inout fixed3 rgb)
 {
     if (!IsGammaSpace()) {
@@ -55,30 +63,48 @@ inline void uddConvertToLinearIfNeeded(inout fixed3 rgb)
     }
 }
 
-inline fixed4 uddGetScreenTexture(sampler2D tex, float2 uv)
+inline fixed4 uddGetScreenTexture(float2 uv)
 {
-    fixed4 c = tex2D(tex, uv);
+    fixed4 c = tex2D(_MainTex, uv);
     return c;
 }
 
-inline fixed4 uddGetCursorTexture(sampler2D tex, float2 uv, fixed4 cursorPosScale)
+inline fixed4 uddGetCursorTexture(float2 uv)
 {
-    uv.x = (uv.x - cursorPosScale.x) / cursorPosScale.z;
-    uv.y = (uv.y - cursorPosScale.y) / cursorPosScale.w;
-    fixed4 c = tex2D(tex, uv);
-    fixed a = c.a * step(0, uv.x) * step(0, uv.y) * step(uv.x, 1) * step(uv.y, 1);
-    c *= step(0.01, a);
+    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(sampler2D screenTex, sampler2D cursorTex, float2 uv, fixed4 cursorPosScale)
+inline fixed4 uddGetScreenTextureWithCursor(float2 uv)
 {
     uv = uddInvertUV(uv);
-    fixed4 screen = uddGetScreenTexture(screenTex, uddRotateUV(uv));
-    fixed4 cursor = uddGetCursorTexture(cursorTex, uv, cursorPosScale);
+#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;
 }
 
+inline void uddBendVertex(inout float4 v, half radius, half width)
+{
+#if !defined(_BEND_OFF)
+    half angle = width * v.x / radius;
+    #ifdef _BEND_Y
+    radius -= v.y;
+    v.y += radius * (1 - cos(angle));
+    #elif _BEND_Z
+    radius -= v.z;
+    v.z += radius * (1 - cos(angle));
+    #endif
+    v.x = radius * sin(angle) / width;
+#endif
+}
+
 #endif

Assets/uDesktopDuplication/Shaders/uDD_Params.cginc

@@ -4,7 +4,18 @@
 sampler2D _MainTex;
 fixed4 _Color;
 sampler2D _CursorTex;
+
 half4 _CursorPositionScale;
+#define _CursorX _CursorPositionScale.x
+#define _CursorY _CursorPositionScale.y
+#define _CursorWidth _CursorPositionScale.z
+#define _CursorHeight _CursorPositionScale.w
+
+half4 _ClipPositionScale;
+#define _ClipX _ClipPositionScale.x
+#define _ClipY _ClipPositionScale.y
+#define _ClipWidth _ClipPositionScale.z
+#define _ClipHeight _ClipPositionScale.w
 
 #ifndef SURFACE_SHADER
 float4 _MainTex_ST;

Assets/uDesktopDuplication/Shaders/uDD_Standard.shader

@@ -22,19 +22,19 @@ SubShader
     #pragma surface surf Standard fullforwardshadows
     #pragma multi_compile ___ INVERT_X
     #pragma multi_compile ___ INVERT_Y
-    #pragma multi_compile ___ VERTICAL
     #pragma multi_compile ___ ROTATE90 ROTATE180 ROTATE270
+    #pragma multi_compile ___ USE_BEND
+    #pragma multi_compile ___ USE_CLIP
 
     #define SURFACE_SHADER
     #include "./uDD_Common.cginc"
-    #include "./uDD_Params.cginc"
 
     half _Glossiness;
     half _Metallic;
 
     void surf(Input IN, inout SurfaceOutputStandard o) 
     {
-        fixed4 c = uddGetScreenTextureWithCursor(_MainTex, _CursorTex, IN.uv_MainTex, _CursorPositionScale) * _Color;
+        fixed4 c = uddGetScreenTextureWithCursor(IN.uv_MainTex) * _Color;
         o.Albedo = c.rgb;
         o.Metallic = _Metallic;
         o.Smoothness = _Glossiness;

Assets/uDesktopDuplication/Shaders/uDD_Unlit.shader

@@ -5,8 +5,9 @@ Properties
 {
     _Color ("Color", Color) = (1, 1, 1, 1)
     _MainTex ("Texture", 2D) = "white" {}
-    [Toggle(USE_BEND)] _UseBend("UseBend", Float) = 0
-    [PowerSlider(10.0)]_Radius ("Radius", Range(10, 100)) = 30
+    _CursorTex ("Cursor Texture", 2D) = "white" {}
+    [KeywordEnum(Off, Y, Z)] _Bend("Bending", Int) = 0
+    [PowerSlider(10.0)] _Radius("Radius", Range(1, 100)) = 30
     [KeywordEnum(Off, Front, Back)] _Cull("Culling", Int) = 2
 }
 
@@ -20,18 +21,14 @@ Cull [_Cull]
 CGINCLUDE
 
 #include "./uDD_Common.cginc"
-#include "./uDD_Params.cginc"
 
-fixed _Radius;
+half _Radius;
+half _Width;
 
 v2f vert(appdata v)
 {
     v2f o;
-#ifdef USE_BEND
-    half a = v.vertex.x / _Radius;
-    v.vertex.x =  _Radius * sin(a);
-    v.vertex.y += _Radius * (1 - cos(a));
-#endif
+    uddBendVertex(v.vertex, _Radius, _Width);
     o.vertex = UnityObjectToClipPos(v.vertex);
     o.uv = TRANSFORM_TEX(v.uv, _MainTex);
     return o;
@@ -39,7 +36,7 @@ v2f vert(appdata v)
 
 fixed4 frag(v2f i) : SV_Target
 {
-    return uddGetScreenTextureWithCursor(_MainTex, _CursorTex, i.uv, _CursorPositionScale);
+    return uddGetScreenTextureWithCursor(i.uv);
 }
 
 ENDCG
@@ -51,9 +48,9 @@ Pass
     #pragma fragment frag
     #pragma multi_compile ___ INVERT_X
     #pragma multi_compile ___ INVERT_Y
-    #pragma multi_compile ___ VERTICAL
-    #pragma shader_feature ___ USE_BEND
     #pragma multi_compile ___ ROTATE90 ROTATE180 ROTATE270
+    #pragma multi_compile ___ USE_CLIP
+    #pragma multi_compile _BEND_OFF _BEND_Y _BEND_Z
     ENDCG
 }
 

Assets/uDesktopDuplication/Shaders/uDD_Unlit_BlackMask.shader

@@ -6,6 +6,9 @@ Properties
     _Color ("Color", Color) = (1, 1, 1, 1)
     _MainTex ("Texture", 2D) = "white" {}
     _Mask ("Mask", Range(0, 1)) = 0.1
+    _CursorTex ("Cursor Texture", 2D) = "white" {}
+    [KeywordEnum(Off, Y, Z)] _Bend("Bending", Int) = 0
+    [PowerSlider(10.0)] _Radius("Radius", Range(1, 100)) = 30
     [KeywordEnum(Off, Front, Back)] _Cull("Culling", Int) = 2
 }
 
@@ -21,13 +24,15 @@ Blend SrcAlpha OneMinusSrcAlpha
 CGINCLUDE
 
 #include "./uDD_Common.cginc"
-#include "./uDD_Params.cginc"
 
 fixed _Mask;
+half _Radius;
+half _Width;
 
 v2f vert(appdata v)
 {
     v2f o;
+    uddBendVertex(v.vertex, _Radius, _Width);
     o.vertex = UnityObjectToClipPos(v.vertex);
     o.uv = TRANSFORM_TEX(v.uv, _MainTex);
     return o;
@@ -35,7 +40,7 @@ v2f vert(appdata v)
 
 fixed4 frag(v2f i) : SV_Target
 {
-    fixed4 tex = uddGetScreenTextureWithCursor(_MainTex, _CursorTex, i.uv, _CursorPositionScale);
+    fixed4 tex = uddGetScreenTextureWithCursor(i.uv);
     fixed alpha = pow((tex.r + tex.g + tex.b) / 3.0, _Mask);
     return fixed4(tex.rgb * _Color.rgb, alpha * _Color.a);
 }
@@ -49,8 +54,10 @@ Pass
     #pragma fragment frag
     #pragma multi_compile ___ INVERT_X
     #pragma multi_compile ___ INVERT_Y
-    #pragma multi_compile ___ VERTICAL
     #pragma multi_compile ___ ROTATE90 ROTATE180 ROTATE270
+    #pragma multi_compile ___ USE_BEND
+    #pragma multi_compile ___ USE_CLIP
+    #pragma multi_compile _BEND_OFF _BEND_Y _BEND_Z
     ENDCG
 }
 

Assets/uDesktopDuplication/Shaders/uDD_Unlit_Transparent.shader

@@ -5,6 +5,9 @@ Properties
 {
     _Color ("Color", Color) = (1, 1, 1, 1)
     _MainTex ("Texture", 2D) = "white" {}
+    _CursorTex ("Cursor Texture", 2D) = "white" {}
+    [KeywordEnum(Off, Y, Z)] _Bend("Bending", Int) = 0
+    [PowerSlider(10.0)] _Radius("Radius", Range(1, 100)) = 30
     [KeywordEnum(Off, Front, Back)] _Cull("Culling", Int) = 2
 }
 
@@ -20,11 +23,14 @@ Blend SrcAlpha OneMinusSrcAlpha
 CGINCLUDE
 
 #include "./uDD_Common.cginc"
-#include "./uDD_Params.cginc"
+
+half _Radius;
+half _Width;
 
 v2f vert(appdata v)
 {
     v2f o;
+    uddBendVertex(v.vertex, _Radius, _Width);
     o.vertex = UnityObjectToClipPos(v.vertex);
     o.uv = TRANSFORM_TEX(v.uv, _MainTex);
     return o;
@@ -32,7 +38,7 @@ v2f vert(appdata v)
 
 fixed4 frag(v2f i) : SV_Target
 {
-    return fixed4(uddGetScreenTextureWithCursor(_MainTex, _CursorTex, i.uv, _CursorPositionScale).rgb, 1.0) * _Color;
+    return fixed4(uddGetScreenTextureWithCursor(i.uv).rgb, 1.0) * _Color;
 }
 
 ENDCG
@@ -44,8 +50,10 @@ Pass
     #pragma fragment frag
     #pragma multi_compile ___ INVERT_X
     #pragma multi_compile ___ INVERT_Y
-    #pragma multi_compile ___ VERTICAL
     #pragma multi_compile ___ ROTATE90 ROTATE180 ROTATE270
+    #pragma multi_compile ___ USE_BEND
+    #pragma multi_compile ___ USE_CLIP
+    #pragma multi_compile _BEND_OFF _BEND_Y _BEND_Z
     ENDCG
 }
 

Plugins/uDesktopDuplication/uDesktopDuplication/Common.cpp

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <queue>
+#include <unordered_map>
+#include <iostream>
+#include <d3d11.h>
+
+#include "IUnityInterface.h"
+#include "IUnityGraphicsD3D11.h"
+#include "Common.h"
+
+
+extern IUnityInterfaces* g_unity;
+extern std::unique_ptr<MonitorManager> g_manager;
+extern std::queue<Message> g_messages;
+
+
+IUnityInterfaces* GetUnity()
+{
+    return g_unity;
+}
+
+
+ID3D11Device* GetDevice()
+{
+    return GetUnity()->Get<IUnityGraphicsD3D11>()->GetDevice();
+}
+
+
+const std::unique_ptr<MonitorManager>& GetMonitorManager()
+{
+    return g_manager;
+}
+
+
+void SendMessageToUnity(Message message)
+{
+    g_messages.push(message);
+}

Plugins/uDesktopDuplication/uDesktopDuplication/Common.h

@@ -1,15 +1,28 @@
+#pragma once
+
 #include <memory>
-#include "IUnityInterface.h"
+#include <string>
+#include <functional>
 
-class MonitorManager;
 
+// Unity interface and ID3D11Device getters
+struct IUnityInterfaces;
 IUnityInterfaces* GetUnity();
+
+struct ID3D11Device;
 ID3D11Device* GetDevice();
+
+
+// Manager getter
+class MonitorManager;
 const std::unique_ptr<MonitorManager>& GetMonitorManager();
 
+
+// Message is pooled and fetch from Unity.
 enum class Message
 {
     None = -1,
     Reinitialized = 0,
 };
+
 void SendMessageToUnity(Message message);

Plugins/uDesktopDuplication/uDesktopDuplication/Cursor.cpp

@@ -1,9 +1,13 @@
 #include <d3d11.h>
+#include <wrl/client.h>
 #include "Common.h"
+#include "Debug.h"
 #include "MonitorManager.h"
 #include "Monitor.h"
 #include "Cursor.h"
 
+using namespace Microsoft::WRL;
+
 
 Cursor::Cursor(Monitor* monitor)
     : monitor_(monitor)
@@ -13,16 +17,6 @@ Cursor::Cursor(Monitor* monitor)
 
 Cursor::~Cursor()
 {
-    if (apiBuffer_ != nullptr)
-    {
-        delete[] apiBuffer_;
-        apiBuffer_ = nullptr;
-    }
-    if (bgra32Buffer_ != nullptr)
-    {
-        delete[] bgra32Buffer_;
-        bgra32Buffer_ = nullptr;
-    }
 }
 
 
@@ -33,12 +27,19 @@ void Cursor::UpdateBuffer(const DXGI_OUTDUPL_FRAME_INFO& frameInfo)
         return;
     }
 
+    isVisible_ = frameInfo.PointerPosition.Visible != 0;
+    if (isVisible_) 
+    {
+        GetMonitorManager()->SetCursorMonitorId(monitor_->GetId());
+    }
+
     x_ = frameInfo.PointerPosition.Position.x;
     y_ = frameInfo.PointerPosition.Position.y;
-    if (frameInfo.PointerPosition.Visible != 0) {
-        GetMonitorManager()->SetCursorMonitorId(monitor_->GetId());
-        timestamp_ = frameInfo.LastMouseUpdateTime;
-        isVisible_ = frameInfo.PointerPosition.Visible != 0;
+    timestamp_ = frameInfo.LastMouseUpdateTime;
+
+    if (!IsCursorOnParentMonitor())
+    {
+        return;
     }
 
     if (frameInfo.PointerShapeBufferSize == 0)
@@ -49,54 +50,95 @@ void Cursor::UpdateBuffer(const DXGI_OUTDUPL_FRAME_INFO& frameInfo)
     // Increase the buffer size if needed
     if (frameInfo.PointerShapeBufferSize > apiBufferSize_)
     {
-        if (apiBuffer_) delete[] apiBuffer_;
-        apiBuffer_ = new BYTE[frameInfo.PointerShapeBufferSize];
         apiBufferSize_ = frameInfo.PointerShapeBufferSize;
+        apiBuffer_ = std::make_unique<BYTE[]>(apiBufferSize_);
     }
-    if (apiBuffer_ == nullptr) return;
+    if (!apiBuffer_) return;
 
     // Get mouse pointer information
     UINT bufferSize;
+    DXGI_OUTDUPL_POINTER_SHAPE_INFO shapeInfo;
     const auto hr = monitor_->GetDeskDupl()->GetFramePointerShape(
-        frameInfo.PointerShapeBufferSize,
-        reinterpret_cast<void*>(apiBuffer_),
+        apiBufferSize_,
+        reinterpret_cast<void*>(apiBuffer_.get()),
         &bufferSize,
-        &shapeInfo_);
+        &shapeInfo);
+
     if (FAILED(hr))
     {
-        delete[] apiBuffer_;
-        apiBuffer_ = nullptr;
+        Debug::Error("Cursor::UpdateBuffer() => GetFramePointerShape() failed.");
+        apiBuffer_.reset();
         apiBufferSize_ = 0;
     }
+
+    shapeInfo_ = shapeInfo;
 }
 
 
 void Cursor::UpdateTexture()
 {
+    if (!IsCursorOnParentMonitor())
+    {
+        return;
+    }
+
     // cursor type
     const bool isMono = GetType() == DXGI_OUTDUPL_POINTER_SHAPE_TYPE_MONOCHROME;
     const bool isColorMask = GetType() == DXGI_OUTDUPL_POINTER_SHAPE_TYPE_MASKED_COLOR;
 
     // Size
-    const auto w = GetWidth();
-    const auto h = GetHeight();
+    const auto w0 = GetWidth();
+    const auto h0 = GetHeight();
     const auto p = GetPitch();
+    auto w = w0;
+    auto h = h0;
 
     // Convert the buffer given by API into BGRA32
-    const UINT bgraBufferSize = w * h * 4;
+    const UINT bgraBufferSize = w0 * h0 * 4;
     if (bgraBufferSize > bgra32BufferSize_)
     {
-        if (bgra32Buffer_) delete[] bgra32Buffer_;
-        bgra32Buffer_ = new BYTE[bgraBufferSize];
         bgra32BufferSize_ = bgraBufferSize;
+        bgra32Buffer_ = std::make_unique<BYTE[]>(bgra32BufferSize_);
     }
-    if (bgra32Buffer_ == nullptr) return;
+    if (!bgra32Buffer_) return;
 
     // If masked, copy the desktop image and merge it with masked image.
     if (isMono || isColorMask)
     {
         HRESULT hr;
 
+        const auto mw = monitor_->GetWidth();
+        const auto mh = monitor_->GetHeight();
+        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;
+        }
+        if (x + w >= mw) 
+        {
+            w = mw - x_;
+            colMax = w;
+        }
+        if (y < 0)
+        {
+            y = 0;
+            h = h0 + y_;
+            rowMin = h0 - h;
+        }
+        if (y + h >= mh) 
+        {
+            h = mh - y_;
+            rowMax = h;
+        }
+
         D3D11_TEXTURE2D_DESC desc;
         desc.Width = w;
         desc.Height = h;
@@ -110,31 +152,39 @@ void Cursor::UpdateTexture()
         desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
         desc.MiscFlags = 0;
 
-        ID3D11Texture2D* texture = nullptr;
+        ComPtr<ID3D11Texture2D> texture;
         hr = GetDevice()->CreateTexture2D(&desc, nullptr, &texture);
         if (FAILED(hr)) 
         {
+            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;
+        box.left = x;
+        box.top = y;
+        box.right = x + w;
+        box.bottom = y + h;
 
-        ID3D11DeviceContext* context;
-        GetDevice()->GetImmediateContext(&context);
-        context->CopySubresourceRegion(texture, 0, 0, 0, 0, monitor_->GetUnityTexture(), 0, &box);
-        context->Release();
+        if (monitor_->GetUnityTexture() == nullptr) 
+        {
+            Debug::Error("Cursor::UpdateTexture() => Monitor::GetUnityTexture() is null.");
+            return;
+        }
 
-        IDXGISurface* surface = nullptr;
-        hr = texture->QueryInterface(__uuidof(IDXGISurface), (void**)&surface);
-        texture->Release();
+        {
+            ComPtr<ID3D11DeviceContext> context;
+            GetDevice()->GetImmediateContext(&context);
+            context->CopySubresourceRegion(texture.Get(), 0, 0, 0, 0, monitor_->GetUnityTexture(), 0, &box);
+        }
+
+        ComPtr<IDXGISurface> surface;
+        hr = texture.As<IDXGISurface>(&surface);
         if (FAILED(hr))
         {
+            Debug::Error("Cursor::UpdateTexture() => texture->QueryInterface() failed.");
             return;
         }
 
@@ -142,7 +192,7 @@ void Cursor::UpdateTexture()
         hr = surface->Map(&mappedSurface, DXGI_MAP_READ);
         if (FAILED(hr))
         {
-            surface->Release();
+            Debug::Error("Cursor::UpdateTexture() => surface->Map() failed.");
             return;
         }
 
@@ -151,40 +201,39 @@ void Cursor::UpdateTexture()
         const UINT desktopPitch = mappedSurface.Pitch / sizeof(UINT);
 
         // Access RGBA values at the same time
-        auto output32 = reinterpret_cast<UINT*>(bgra32Buffer_);
+        auto output32 = reinterpret_cast<UINT*>(bgra32Buffer_.get());
 
         if (isMono)
         {
-            for (int row = 0; row < h; ++row) 
+            for (int row = rowMin, y = 0; row < rowMax; ++row, ++y) 
             {
-                BYTE mask = 0x80;
-                for (int col = 0; col < w; ++col) 
+                for (int col = colMin, x = 0; col < colMax; ++col, ++x) 
                 {
-                    const int i = row * w + col;
+                    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 UINT andMask32 = andMask ? 0xFFFFFFFF : 0xFF000000;
-                    const UINT xorMask32 = xorMask ? 0x00FFFFFF : 0x00000000;
-                    output32[i] = (desktop32[row * desktopPitch + col] & andMask32) ^ xorMask32;
-                    mask = (mask == 0x01) ? 0x80 : (mask >> 1);
+                    const UINT andMask32 = andMask ? 0xFFFFFFFF : 0x00000000;
+                    const UINT xorMask32 = xorMask ? 0xFFFFFFFF : 0x00000000;
+                    output32[i] = (desktop32[y * desktopPitch + x] & andMask32) ^ xorMask32;
                 }
             }
         }
         else // DXGI_OUTDUPL_POINTER_SHAPE_TYPE_MASKED_COLOR
         {
-            const auto buffer32 = reinterpret_cast<UINT*>(apiBuffer_);
+            const auto buffer32 = reinterpret_cast<UINT*>(apiBuffer_.get());
 
-            for (int row = 0; row < h; ++row) 
+            for (int row = rowMin, y = 0; row < rowMax; ++row, ++y) 
             {
-                for (int col = 0; col < w; ++col) 
+                for (int col = colMin, x = 0; col < colMax; ++col, ++x) 
                 {
-                    const int i = row * w + col;
-                    const int j = row * p / sizeof(UINT) + col;
+                    const int i = col + row * w0;
+                    const int j = col + row * p / sizeof(UINT);
 
                     UINT mask = 0xFF000000 & buffer32[j];
                     if (mask)
                     {
-                        output32[i] = (desktop32[row * desktopPitch + col] ^ buffer32[j]) | 0xFF000000;
+                        output32[i] = (desktop32[y * desktopPitch + x] ^ buffer32[j]) | 0xFF000000;
                     }
                     else
                     {
@@ -195,7 +244,6 @@ void Cursor::UpdateTexture()
         }
 
         hr = surface->Unmap();
-        surface->Release();
         if (FAILED(hr))
         {
             return;
@@ -203,25 +251,46 @@ void Cursor::UpdateTexture()
     }
     else // DXGI_OUTDUPL_POINTER_SHAPE_TYPE_COLOR
     {
-        auto output32 = reinterpret_cast<UINT*>(bgra32Buffer_);
-        const auto buffer32 = reinterpret_cast<UINT*>(apiBuffer_);
+        auto output32 = reinterpret_cast<UINT*>(bgra32Buffer_.get());
+        const auto buffer32 = reinterpret_cast<UINT*>(apiBuffer_.get());
         for (int i = 0; i < w * h; ++i) 
         {
             output32[i] = buffer32[i];
         }
     }
-
-    return;
 }
 
 
 void Cursor::GetTexture(ID3D11Texture2D* texture)
 {
-    if (bgra32Buffer_ == nullptr) return;
-    ID3D11DeviceContext* context;
+    if (bgra32Buffer_ == nullptr)
+    {
+        Debug::Error("Cursor::GetTexture() => bgra32Buffer is null.");
+        return;
+    }
+
+    if (texture == nullptr)
+    {
+        Debug::Error("Cursor::GetTexture() => The given texture is null.");
+        return;
+    }
+
+    D3D11_TEXTURE2D_DESC desc;
+    texture->GetDesc(&desc);
+    if ((int)desc.Width < GetWidth() || (int)desc.Height < GetHeight())
+    {
+        char buf[256];
+        sprintf_s(buf, 256,
+            "Cursor::GetTexture() => The given texture has smaller width / height.\n"
+            "Given => (%d, %d)  Buffer => (%d, %d)",
+            desc.Width, desc.Height, GetWidth(), GetHeight());
+        Debug::Error(buf);
+        return;
+    }
+
+    ComPtr<ID3D11DeviceContext> context;
     GetDevice()->GetImmediateContext(&context);
-    context->UpdateSubresource(texture, 0, nullptr, bgra32Buffer_, shapeInfo_.Width * 4, 0);
-    context->Release();
+    context->UpdateSubresource(texture, 0, nullptr, bgra32Buffer_.get(), GetWidth() * 4, 0);
 }
 
 
@@ -267,3 +336,9 @@ int Cursor::GetType() const
 {
     return shapeInfo_.Type;
 }
+
+
+bool Cursor::IsCursorOnParentMonitor() const
+{
+    return GetMonitorManager()->GetCursorMonitorId() == monitor_->GetId();
+}

Plugins/uDesktopDuplication/uDesktopDuplication/Cursor.h

@@ -1,3 +1,5 @@
+#pragma once
+
 #include <d3d11.h>
 #include <dxgi1_2.h>
 #include <memory>
@@ -22,13 +24,15 @@ public:
     int GetType() const;
 
 private:
+    bool IsCursorOnParentMonitor() const;
+
     Monitor* monitor_;
     bool isVisible_ = false;
     int x_ = -1;
     int y_ = -1;
-    BYTE* apiBuffer_ = nullptr;
+    std::unique_ptr<BYTE[]> apiBuffer_ = nullptr;
     UINT apiBufferSize_ = 0;
-    BYTE* bgra32Buffer_ = nullptr;
+    std::unique_ptr<BYTE[]> bgra32Buffer_ = nullptr;
     UINT bgra32BufferSize_ = 0;
     DXGI_OUTDUPL_POINTER_SHAPE_INFO shapeInfo_;
     LARGE_INTEGER timestamp_;

Plugins/uDesktopDuplication/uDesktopDuplication/Debug.cpp

@@ -0,0 +1,84 @@
+#pragma once
+
+#include <cstdio>
+#include "Debug.h"
+
+
+decltype(Debug::mode_)    Debug::mode_ = Debug::Mode::kFile;
+decltype(Debug::logFunc_) Debug::logFunc_ = nullptr;
+decltype(Debug::errFunc_) Debug::errFunc_ = nullptr;
+decltype(Debug::fs_)      Debug::fs_;
+
+
+void Debug::Initialize()
+{
+    if (mode_ == Mode::kFile)
+    {
+        fs_.open("uDesktopDuplication.log");
+    }
+}
+
+
+void Debug::Finalize()
+{
+    fs_.close();
+}
+
+
+void Debug::Log(const char* msg)
+{
+    switch (mode_)
+    {
+        case Mode::kNone:
+        {
+            break;
+        }
+        case Mode::kFile:
+        {
+            if (fs_.good())
+            {
+                fs_ << "[uDD::Log] " << msg << std::endl;
+            }
+            break;
+        }
+        case Mode::kUnityLog:
+        {
+            if (logFunc_ == nullptr) 
+            {
+                char buf[256];
+                sprintf_s(buf, 256, "[uDD::Log] %s", msg);
+                logFunc_(buf);
+                break;
+            }
+        }
+    }
+}
+
+
+void Debug::Error(const char* msg)
+{
+    switch (mode_)
+    {
+        case Mode::kNone:
+        {
+            break;
+        }
+        case Mode::kFile:
+        {
+            if (fs_.good())
+            {
+                fs_ << "[uDD::Err] " << msg << std::endl;
+            }
+            break;
+        }
+        case Mode::kUnityLog:
+        {
+            if (logFunc_ == nullptr) 
+            {
+                char buf[256];
+                sprintf_s(buf, 256, "[uDD::Err] %s", msg);
+                errFunc_(buf);
+            }
+        }
+    }
+}

Plugins/uDesktopDuplication/uDesktopDuplication/Debug.h

@@ -0,0 +1,33 @@
+#pragma once
+#include <fstream>
+#include "IUnityInterface.h"
+
+// Logging
+class Debug
+{
+public:
+    enum class Mode
+    {
+        kNone = 0,
+        kFile = 1,
+        kUnityLog = 2,
+    };
+
+    using DebugLogFuncPtr = void(UNITY_INTERFACE_API *)(const char*);
+
+    static void SetMode(Mode mode) { mode_ = mode; }
+    static void Initialize();
+    static void Finalize();
+    static void SetLogFunc(DebugLogFuncPtr func) { logFunc_ = func; }
+    static void SetErrorFunc(DebugLogFuncPtr func) { errFunc_ = func; }
+
+public:
+    static void Log(const char* msg);
+    static void Error(const char* msg);
+
+private:
+    static Mode mode_;
+    static std::ofstream fs_;
+    static DebugLogFuncPtr logFunc_;
+    static DebugLogFuncPtr errFunc_;
+};

Plugins/uDesktopDuplication/uDesktopDuplication/Monitor.cpp

@@ -1,10 +1,13 @@
 #include <d3d11.h>
 #include <ShellScalingAPI.h>
 #include "Common.h"
+#include "Debug.h"
 #include "Cursor.h"
 #include "MonitorManager.h"
 #include "Monitor.h"
 
+using namespace Microsoft::WRL;
+
 
 Monitor::Monitor(int id)
     : id_(id)
@@ -13,7 +16,12 @@ Monitor::Monitor(int id)
 }
 
 
-HRESULT Monitor::Initialize(IDXGIOutput* output)
+Monitor::~Monitor()
+{
+}
+
+
+void Monitor::Initialize(IDXGIOutput* output)
 {
     output->GetDesc(&outputDesc_);
     monitorInfo_.cbSize = sizeof(MONITORINFOEX);
@@ -29,55 +37,46 @@ HRESULT Monitor::Initialize(IDXGIOutput* output)
     {
         case S_OK:
             state_ = State::Available;
+            Debug::Log("Monitor::Initialize() => OK.");
             break;
         case E_INVALIDARG:
             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;
         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;
         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;
         case DXGI_ERROR_SESSION_DISCONNECTED:
             state_ = State::SessionDisconnected;
+            Debug::Error("Monitor::Initialize() => Session disconnected.");
             break;
     }
-
-    return hr;
 }
 
 
-Monitor::~Monitor()
+void Monitor::Render(UINT timeout)
 {
-    if (deskDupl_ != nullptr)
-    {
-        deskDupl_->Release();
-    }
-}
+    if (!deskDupl_) return;
 
-
-HRESULT Monitor::Render(UINT timeout)
-{
-    if (deskDupl_ == nullptr)
-    {
-        return S_OK;
-    }
-
-    if (unityTexture_ == nullptr) return 0;
-
-    IDXGIResource* resource = nullptr;
+    ComPtr<IDXGIResource> resource;
     DXGI_OUTDUPL_FRAME_INFO frameInfo;
+    HRESULT hr;
 
-    const auto hr = deskDupl_->AcquireNextFrame(timeout, &frameInfo, &resource);
+    hr = deskDupl_->AcquireNextFrame(timeout, &frameInfo, &resource);
     if (FAILED(hr))
     {
         switch (hr)
@@ -85,33 +84,43 @@ HRESULT Monitor::Render(UINT timeout)
             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;
             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;
             case DXGI_ERROR_INVALID_CALL:
+                Debug::Error("Monitor::Render() => DXGI_ERROR_INVALID_CALL.");
                 break;
             case E_INVALIDARG:
+                Debug::Error("Monitor::Render() => E_INVALIDARG.");
+                break;
+            default:
                 break;
         }
-        return hr;
+        return;
     }
 
-    ID3D11Texture2D* texture;
-    resource->QueryInterface(__uuidof(ID3D11Texture2D), reinterpret_cast<void**>(&texture));
+    if (unityTexture_)
+    {
+        ComPtr<ID3D11Texture2D> texture;
+        resource.As<ID3D11Texture2D>(&texture);
 
-    ID3D11DeviceContext* context;
-    GetDevice()->GetImmediateContext(&context);
-    context->CopyResource(unityTexture_, texture);
-    context->Release();
+        ComPtr<ID3D11DeviceContext> context;
+        GetDevice()->GetImmediateContext(&context);
+        context->CopyResource(unityTexture_, texture.Get());
+    }
 
     cursor_->UpdateBuffer(frameInfo);
     cursor_->UpdateTexture();
 
-    resource->Release();
-    deskDupl_->ReleaseFrame();
-
-    return S_OK;
+    hr = deskDupl_->ReleaseFrame();
+    if (FAILED(hr))
+    {
+        Debug::Error("Monitor::Render() => ReleaseFrame() failed.");
+    }
 }
 
 
@@ -139,7 +148,7 @@ ID3D11Texture2D* Monitor::GetUnityTexture() const
 }
 
 
-IDXGIOutputDuplication* Monitor::GetDeskDupl() 
+const ComPtr<IDXGIOutputDuplication>& Monitor::GetDeskDupl() 
 { 
     return deskDupl_; 
 }

Plugins/uDesktopDuplication/uDesktopDuplication/Monitor.h

@@ -1,5 +1,8 @@
+#pragma once
+
 #include <d3d11.h>
 #include <dxgi1_2.h>
+#include <wrl/client.h>
 #include <memory>
 
 class Cursor;
@@ -23,8 +26,8 @@ public:
 
     explicit Monitor(int id);
     ~Monitor();
-    HRESULT Initialize(IDXGIOutput* output);
-    HRESULT Render(UINT timeout = 0);
+    void Initialize(IDXGIOutput* output);
+    void Render(UINT timeout = 0);
     void GetCursorTexture(ID3D11Texture2D* texture);
 
 public:
@@ -43,7 +46,7 @@ public:
     int GetRotation() const;
     int GetDpiX() const;
     int GetDpiY() const;
-    IDXGIOutputDuplication* GetDeskDupl();
+    const Microsoft::WRL::ComPtr<IDXGIOutputDuplication>& GetDeskDupl();
     const std::unique_ptr<Cursor>& GetCursor();
 
 private:
@@ -51,7 +54,7 @@ private:
     UINT dpiX_ = -1, dpiY_ = -1;
     State state_ = State::NotSet;
     std::unique_ptr<Cursor> cursor_;
-    IDXGIOutputDuplication* deskDupl_ = nullptr;
+    Microsoft::WRL::ComPtr<IDXGIOutputDuplication> deskDupl_;
     ID3D11Texture2D* unityTexture_ = nullptr;
     DXGI_OUTPUT_DESC outputDesc_;
     MONITORINFOEX monitorInfo_;

Plugins/uDesktopDuplication/uDesktopDuplication/MonitorManager.cpp

@@ -1,5 +1,6 @@
 #include <d3d11.h>
 #include <dxgi1_2.h>
+#include <wrl/client.h>
 #include <vector>
 #include <string>
 #include <algorithm>
@@ -12,6 +13,8 @@
 #include "Cursor.h"
 #include "MonitorManager.h"
 
+using namespace Microsoft::WRL;
+
 
 MonitorManager::MonitorManager()
 {
@@ -30,26 +33,23 @@ void MonitorManager::Initialize()
     Finalize();
 
     // Get factory
-    IDXGIFactory1* factory;
-    CreateDXGIFactory1(__uuidof(IDXGIFactory1), reinterpret_cast<void**>(&factory));
+    ComPtr<IDXGIFactory1> factory;
+    CreateDXGIFactory1(IID_PPV_ARGS(&factory));
 
     // Check all display adapters
     int id = 0;
-    IDXGIAdapter1* adapter;
+    ComPtr<IDXGIAdapter1> adapter;
     for (int i = 0; (factory->EnumAdapters1(i, &adapter) != DXGI_ERROR_NOT_FOUND); ++i) 
     {
         // Search the main monitor from all outputs
-        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++);
-            monitor->Initialize(output);
+            monitor->Initialize(output.Get());
             monitors_.push_back(monitor);
-            output->Release();
         }
-        adapter->Release();
     }
-    factory->Release();
 }
 
 

Plugins/uDesktopDuplication/uDesktopDuplication/MonitorManager.h

@@ -1,3 +1,5 @@
+#pragma once
+
 #include <d3d11.h>
 #include <dxgi1_2.h>
 #include <vector>

Plugins/uDesktopDuplication/uDesktopDuplication/main.cpp

@@ -7,9 +7,9 @@
 
 #include "IUnityInterface.h"
 #include "IUnityGraphics.h"
-#include "IUnityGraphicsD3D11.h"
 
 #include "Common.h"
+#include "Debug.h"
 #include "Monitor.h"
 #include "Cursor.h"
 #include "MonitorManager.h"
@@ -18,36 +18,9 @@
 #pragma comment(lib, "Shcore.lib")
 
 
-namespace
-{
-    IUnityInterfaces* g_unity = nullptr;
-    std::unique_ptr<MonitorManager> g_manager;
-    std::queue<Message> g_messages;
-}
-
-
-IUnityInterfaces* GetUnity()
-{
-    return g_unity;
-}
-
-
-ID3D11Device* GetDevice()
-{
-    return GetUnity()->Get<IUnityGraphicsD3D11>()->GetDevice();
-}
-
-
-const std::unique_ptr<MonitorManager>& GetMonitorManager()
-{
-    return g_manager;
-}
-
-
-void SendMessageToUnity(Message message)
-{
-    g_messages.push(message);
-}
+IUnityInterfaces* g_unity = nullptr;
+std::unique_ptr<MonitorManager> g_manager;
+std::queue<Message> g_messages;
 
 
 extern "C"
@@ -57,12 +30,20 @@ extern "C"
         if (g_unity && !g_manager)
         {
             g_manager = std::make_unique<MonitorManager>();
+            Debug::Initialize();
         }
     }
 
     UNITY_INTERFACE_EXPORT void UNITY_INTERFACE_API FinalizeUDD()
     {
         g_manager.reset();
+
+        std::queue<Message> empty;
+        g_messages.swap(empty);
+
+        Debug::SetLogFunc(nullptr);
+        Debug::SetErrorFunc(nullptr);
+        Debug::Finalize();
     }
 
     UNITY_INTERFACE_EXPORT void UNITY_INTERFACE_API UnityPluginLoad(IUnityInterfaces* unityInterfaces)
@@ -73,8 +54,8 @@ extern "C"
 
     UNITY_INTERFACE_EXPORT void UNITY_INTERFACE_API UnityPluginUnload()
     {
-        g_unity = nullptr;
         FinalizeUDD();
+        g_unity = nullptr;
     }
 
     void UNITY_INTERFACE_API OnRenderEvent(int id)
@@ -103,7 +84,7 @@ extern "C"
         g_manager->Update();
     }
 
-    UNITY_INTERFACE_EXPORT Message PopMessage()
+    UNITY_INTERFACE_EXPORT Message UNITY_INTERFACE_API PopMessage()
     {
         if (g_messages.empty()) return Message::None;
 
@@ -112,12 +93,33 @@ extern "C"
         return message;
     }
 
+    UNITY_INTERFACE_EXPORT void UNITY_INTERFACE_API SetDebugMode(Debug::Mode mode)
+    {
+        Debug::SetMode(mode);
+    }
+
+    UNITY_INTERFACE_EXPORT void UNITY_INTERFACE_API SetLogFunc(Debug::DebugLogFuncPtr func)
+    {
+        Debug::SetLogFunc(func);
+    }
+
+    UNITY_INTERFACE_EXPORT void UNITY_INTERFACE_API SetErrorFunc(Debug::DebugLogFuncPtr func)
+    {
+        Debug::SetErrorFunc(func);
+    }
+
     UNITY_INTERFACE_EXPORT size_t UNITY_INTERFACE_API GetMonitorCount()
     {
         if (!g_manager) return 0;
         return g_manager->GetMonitorCount();
     }
 
+    UNITY_INTERFACE_EXPORT int UNITY_INTERFACE_API GetCursorMonitorId()
+    {
+        if (!g_manager) return -1;
+        return g_manager->GetCursorMonitorId();
+    }
+
     UNITY_INTERFACE_EXPORT int UNITY_INTERFACE_API GetTotalWidth()
     {
         if (!g_manager) return 0;
@@ -136,6 +138,15 @@ extern "C"
         g_manager->SetTimeout(timeout);
     }
 
+    UNITY_INTERFACE_EXPORT void UNITY_INTERFACE_API GetId(int id)
+    {
+        if (!g_manager) return;
+        if (auto monitor = g_manager->GetMonitor(id))
+        {
+            monitor->GetId();
+        }
+    }
+
     UNITY_INTERFACE_EXPORT MonitorState UNITY_INTERFACE_API GetState(int id)
     {
         if (!g_manager) return MonitorState::NotSet;

Plugins/uDesktopDuplication/uDesktopDuplication/uDesktopDuplication.vcxproj

@@ -89,7 +89,7 @@
       <SDLCheck>true</SDLCheck>
     </ClCompile>
     <PostBuildEvent>
-      <Command>copy /Y "$(SolutionDir)$(Platform)\$(Configuration)\$(TargetFileName)" "$(SolutionDir)..\..\Assets\$(ProjectName)\Plugins"</Command>
+      <Command>copy /Y "$(SolutionDir)$(Platform)\$(Configuration)\$(TargetFileName)" "$(SolutionDir)..\..\Assets\$(ProjectName)\Plugins\x86_64"</Command>
     </PostBuildEvent>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
@@ -122,10 +122,12 @@
       <OptimizeReferences>true</OptimizeReferences>
     </Link>
     <PostBuildEvent>
-      <Command>copy /Y "$(SolutionDir)$(Platform)\$(Configuration)\$(TargetFileName)" "$(SolutionDir)..\..\Assets\$(ProjectName)\Plugins"</Command>
+      <Command>copy /Y "$(SolutionDir)$(Platform)\$(Configuration)\$(TargetFileName)" "$(SolutionDir)..\..\Assets\$(ProjectName)\Plugins\x86_64"</Command>
     </PostBuildEvent>
   </ItemDefinitionGroup>
   <ItemGroup>
+    <ClCompile Include="Common.cpp" />
+    <ClCompile Include="Debug.cpp" />
     <ClCompile Include="MonitorManager.cpp" />
     <ClCompile Include="Main.cpp" />
     <ClCompile Include="Monitor.cpp" />
@@ -133,6 +135,7 @@
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="Common.h" />
+    <ClInclude Include="Debug.h" />
     <ClInclude Include="MonitorManager.h" />
     <ClInclude Include="include\IUnityGraphics.h" />
     <ClInclude Include="include\IUnityGraphicsD3D11.h" />

Plugins/uDesktopDuplication/uDesktopDuplication/uDesktopDuplication.vcxproj.filters

@@ -19,11 +19,14 @@
     <ClInclude Include="Cursor.h" />
     <ClInclude Include="Common.h" />
     <ClInclude Include="MonitorManager.h" />
+    <ClInclude Include="Debug.h" />
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Monitor.cpp" />
     <ClCompile Include="Cursor.cpp" />
     <ClCompile Include="Main.cpp" />
     <ClCompile Include="MonitorManager.cpp" />
+    <ClCompile Include="Common.cpp" />
+    <ClCompile Include="Debug.cpp" />
   </ItemGroup>
 </Project>