示例#1
0
        void OnEnable()
        {
#if UNITY_EDITOR_OSX || UNITY_STANDALONE_OSX || UNITY_EDITOR_LINUX || UNITY_STANDALONE_LINUX
            Debug.Log("[Holoplay] Multi-display not supported on OSX or Linux.");
            bgCam.enabled          = false;
            canvas.targetDisplay   = 0;
            holoplay.targetDisplay = PluginCore.GetLKGunityIndex(0);
            singleDisplayMode      = true;
#else
            singleDisplayMode = false;
            if (!Application.isEditor)
            {
                singleDisplayMode = Display.displays.Length < 2;
            }

            if (singleDisplayMode)
            {
                Debug.Log("[Holoplay] Extended UI: single display mode");
                bgCam.enabled = false;
                return;
            }
            PluginCore.GetLoadResults();
            if (CalibrationManager.GetCalibrationCount() < 1)
            {
                Debug.Log("[Holoplay] No LKG detected for extended UI");
                bgCam.enabled          = false;
                holoplay.targetDisplay = 0;
                return;
            }
            // continue with actual extended ui logic
            // set Holoplay target display to the lkg display
            holoplay.targetDisplay = PluginCore.GetLKGunityIndex(0);
            holoplay.ReloadCalibration(); // must reload calibration after setting targetdisplay
            if (!Application.isEditor)
            {
                Display.displays[holoplay.targetDisplay].Activate();
                // Display.displays[holoplay.targetDisplay].SetRenderingResolution(holoplay.cal.screenHeight,
                // holoplay.cal.screenHeight);
                // TODO: nothing works here
// #if UNITY_STANDALONE_WIN
//                 Display.displays[holoplay.targetDisplay].SetParams(
//                  holoplay.cal.screenWidth, holoplay.cal.screenHeight,
//                  holoplay.cal.xpos, holoplay.cal.ypos
//              );
//              Debug.LogFormat("{0}, {1}, {2}, {3}",
//                     holoplay.cal.screenWidth, holoplay.cal.screenHeight,
//                  holoplay.cal.xpos, holoplay.cal.ypos);
// #endif
            }

            // set the canvas target display to the main display
            canvas.targetDisplay = 0;
            if (bgCam)
            {
                bgCam.enabled       = true;
                bgCam.targetDisplay = 0;
            }
#endif
        }
示例#2
0
        static void CloseExtraHoloplayWindows()
        {
            var currentWindows = Resources.FindObjectsOfTypeAll(gameViewWindowType);

            PluginCore.GetLoadResults();

            if (manualPreviewSettings != null && CalibrationManager.GetCalibrationCount() < 1)
            {
                foreach (EditorWindow w in currentWindows)
                {
                    if (w.name == "Holoplay")
                    {
                        w.Close();
                        Debug.Log("[Holoplay] Closing extra Holoplay window");
                    }
                }
            }
            EditorApplication.update -= CloseExtraHoloplayWindows;
        }
示例#3
0
        // todo: possibly add more vars from the Holoplay for consistency

        // functions
        void OnEnable()
        {
            PluginCore.GetLoadResults();

            // update warning
            int i;

            showUpdateWarning = false;
            for (i = 0; i < CalibrationManager.GetCalibrationCount(); i++)
            {
                if (CalibrationManager.GetCalibration(i).LKGname == "LKG")
                {
                    showUpdateWarning = true;
                }
            }
            initialSetup = true;
            // Debug.Log("onenable");
            Setup(initialSetup);
            initialSetup = false;
        }
示例#4
0
 void OnEnable()
 {
     PluginCore.GetLoadResults();
 }
示例#5
0
        void Setup(bool reloadCalibration = false)
        {
            // Debug.Log("set up multiplxing");
            // if there's no holoplays, just return
            if (holoplays == null || holoplays.Length == 0)
            {
                return;
            }
            // limit rows and columns to 8 units
            columns = Mathf.Clamp(columns, 1, 8);
            rows    = Mathf.Clamp(rows, 1, 8 / columns);
            if (holoplays.Length > 8)
            {
                Debug.Log("[Holoplay] Multiplex cannot support more than 8 Holoplay Captures");
                System.Array.Resize(ref holoplays, 8);
            }
            // return if it's not automatic arrangement
            if (!automaticArrangement)
            {
                return;
            }

            LoadResults loadResults = PluginCore.GetLoadResults();

            if (!loadResults.calibrationFound)
            {
                return;
            }
            // first sort displays
            List <DisplayPositioner> targetDisplayPositions = new List <DisplayPositioner>();

            for (int lkg = 0; lkg < CalibrationManager.GetCalibrationCount(); lkg++)
            {
                targetDisplayPositions.Add(new DisplayPositioner()
                {
                    targetLKG     = lkg,
                    targetDisplay = PluginCore.GetLKGunityIndex(lkg),
                    position      = new Vector2Int(
                        Mathf.RoundToInt(CalibrationManager.GetCalibration(lkg).xpos / 100f),
                        Mathf.RoundToInt(CalibrationManager.GetCalibration(lkg).ypos / 100f)
                        )
                });
            }
            targetDisplayPositions.Sort();

            // automatic arrangement
            int   i = 0;
            float totalCenterSweep      = 0f;
            float horizontalOffsetSweep = 0f;
            float verticalOffsetSweep   = 0f;

            if (columns > 1)
            {
                // hard coded magic number of 8 for now
                totalCenterSweep      = 8f * Holoplay.Instance.cal.aspect * (columns - 1f) / Holoplay.Instance.cal.viewCone;
                horizontalOffsetSweep = 2f * (columns - 1f);
            }
            if (rows > 1)
            {
                verticalOffsetSweep = -2f * (rows - 1f);                 // -Holoplay.Instance.fov * 0.5f * (rows - 1f);
            }
            for (int x = 0; x < columns; x++)
            {
                for (int y = 0; y < rows; y++)
                {
                    var h = holoplays[i];
                    h.gameObject.SetActive(true);
                    h.size = size;
                    int   yi      = rows - 1 - y;
                    float xOffset = x - (columns - 1) * 0.5f;
                    float yOffset = yi - (rows - 1) * 0.5f;
                    float span    = size * (1f + separation);
                    h.transform.localPosition = new Vector3(2f * xOffset * h.cal.aspect * span, 2f * yOffset * span);
                    float offsetLerpX = columns > 1 ? ((float)x / (columns - 1f) - 0.5f) : 0f;
                    float offsetLerpY = rows > 1 ? ((float)y / (rows - 1f) - 0.5f) : 0f;
                    h.centerOffset            = offsetLerpX * totalCenterSweep * frustumShifting;
                    h.horizontalFrustumOffset = offsetLerpX * horizontalOffsetSweep * frustumShifting;
                    h.verticalFrustumOffset   = offsetLerpY * verticalOffsetSweep * frustumShifting;
                    if (reloadCalibration)
                    {
                        if (targetDisplayPositions.Count > i)
                        {
                            h.targetDisplay = targetDisplayPositions[i].targetDisplay;
                            h.targetLKG     = targetDisplayPositions[i].targetLKG;
                            h.cal.index     = h.targetLKG;
                            // Debug.Log(h.name + " is set to be target at display " + h.targetDisplay);
                            h.ReloadCalibration();
                            if (Display.displays.Length > h.targetDisplay)
                            {
                                // Debug.Log("active display:"+h.targetDisplay);
                                Display.displays[h.targetDisplay].Activate();
                                Display.displays[h.targetDisplay].SetRenderingResolution(h.cal.screenWidth, h.cal.screenHeight);
                            }
                        }
                        else
                        {
                            Debug.LogWarning("[Holoplay] Not enough displays connected for current multiview setup");
                        }
                    }
                    i++;
                }
            }
            // disable the inactive ones
            while (i < 8)
            {
                holoplays[i].gameObject.SetActive(false);
                i++;
            }
        }
示例#6
0
        public static void HandlePreview(bool toggling = true)
        {
            // set standalone resolution
            // PluginCore.GetLoadResults();
            if (Holoplay.Instance != null)
            {
                Holoplay.Instance.ReloadCalibration();
            }
            else
            {
                PluginCore.GetLoadResults();
            }

            // close the window if its open
            var  currentWindows = Resources.FindObjectsOfTypeAll(gameViewWindowType);
            bool windowWasOpen  = false;

            foreach (EditorWindow w in currentWindows)
            {
                if (w.name == "Holoplay")
                {
                    w.Close();
                    windowWasOpen = true;
                }
                else
                {
                    // to avoid ugliness, if there is a game window open
                    // make sure it takes the same resolution
                    SetResolution(w);
                }
            }
            if (toggling)
            {
                if (windowWasOpen)
                {
                    return;
                }
            }
            else
            {
                if (!windowWasOpen)
                {
                    return;
                }
            }

            /*
             *      logic for multiplexing
             *      - get number of holoplays in the scene
             *      - for the target display of each Holoplay
             *              - create a window on that display
             *              - just assign
             */
            var hps = GameObject.FindObjectsOfType <Holoplay>();

            // open up a preview in the looking glass even if no holoplays found
            if (hps.Length == 0)
            {
                SetupPreviewWindow(new Calibration(0), 0, 0);
            }
            foreach (var hp in hps)
            {
                // Debug.Log(string.Format("set up preview window for lkg index {0}, target lkg {1}, target display {2}, {3}", hp.cal.index, hp.targetLKG, hp.targetDisplay, hp.name));
                SetupPreviewWindow(hp.cal, hp.targetLKG, hp.targetDisplay);
            }
        }