// coroutine to update the ScreenCap at the end of the current frame
private IEnumerator UpdateScreenCapCoroutine(xARMScreenCap screenCapToUpdate)
{
yield return(new WaitForEndOfFrame());
xARMManager.ReadScreenCapFromGameView(screenCapToUpdate);
xARMManager.ScreenCapUpdateInProgress = false;
}
private static void addOrUpdateScreenCap(xARMScreenCap screenCapToAdd, xARMScreenCap screenCapToReplace = null)
{
int screenCapIndex;
// replace existing SC
if (screenCapToReplace is xARMScreenCap)
{
// find SC to replace
screenCapIndex = getScreenCapIndex(screenCapToReplace);
// no SC to replace > find SC to update
if (screenCapIndex == -1)
{
screenCapIndex = getScreenCapIndex(screenCapToAdd);
}
}
else
{
screenCapIndex = getScreenCapIndex(screenCapToAdd);
}
if (screenCapIndex >= 0) // update (don't add duplicates)
// values to keep
{
bool origEnabledState = AvailScreenCaps[screenCapIndex].Enabled;
AvailScreenCaps[screenCapIndex] = screenCapToAdd;
AvailScreenCaps[screenCapIndex].Enabled = origEnabledState;
}
else // add
{
AvailScreenCaps.Add(screenCapToAdd);
}
}
public static void ChangeActiveScreenCap(int screenCapIndex)
{
if (screenCapIndex >= activeScreenCaps.Count)
{
screenCapIndex = 0; // reset if active SC list is shorter now
}
xARMManager.Config.PreviewSelectedScreenCapIndex = screenCapIndex;
// repaint window on next update
repaintNextUpdate = true;
if (activeScreenCaps.Count > 0)
{
xARMScreenCap previousScreenCap = selectedScreenCap;
selectedScreenCap = activeScreenCaps[screenCapIndex]; // get Ref to selected SC
xARMManager.DefaultGameViewResolution = selectedScreenCap.Resolution; // set as new default resolution
// change GameView resolution if activated and selection was changed
if (xARMManager.Config.GameViewInheritsPreviewSize && !selectedScreenCap.Equals(previousScreenCap))
{
// switch Game View resolution via next Update() (doesn't work correctly inside OnGUI)
resizeGameViewToNewDefault = true;
}
}
}
public static void ChangeActiveScreenCap(int screenCapIndex)
{
// ensure correct index
if (screenCapIndex >= activeScreenCaps.Count)
{
screenCapIndex = 0;
}
else if (screenCapIndex < 0)
{
screenCapIndex = activeScreenCaps.Count - 1;
}
xARMManager.Config.PreviewSelectedScreenCapIndex = screenCapIndex;
// repaint windows on next update
xARMManager.RepaintAllWindows();
if (activeScreenCaps.Count > 0)
{
xARMScreenCap previousScreenCap = SelectedScreenCap;
SelectedScreenCap = activeScreenCaps[screenCapIndex]; // get Ref to selected SC
xARMManager.DefaultGameViewResolution = SelectedScreenCap.Resolution; // set as new default resolution
// change GameView resolution if activated and selection was changed
if (xARMManager.Config.GameViewInheritsPreviewSize && !SelectedScreenCap.Equals(previousScreenCap))
{
// switch Game View resolution via next Update() (doesn't work correctly inside OnGUI)
resizeGameViewToNewDefault = true;
}
}
}
private static void addOrReplaceScreenCap(xARMScreenCap screenCapToAdd, xARMScreenCap screenCapToReplace)
{
int screenCapIndexToReplace = getScreenCapIndex(screenCapToReplace);
int screenCapIndexToAdd = getScreenCapIndex(screenCapToAdd);
if (screenCapIndexToReplace >= 0) // replace
// values to keep
{
bool origEnabledState = AvailScreenCaps[screenCapIndexToReplace].Enabled;
AvailScreenCaps[screenCapIndexToReplace] = screenCapToAdd;
AvailScreenCaps[screenCapIndexToReplace].Enabled = origEnabledState;
}
else if (screenCapIndexToAdd >= 0) // update (don't add duplicates)
// values to keep
{
bool origEnabledState = AvailScreenCaps[screenCapIndexToAdd].Enabled;
AvailScreenCaps[screenCapIndexToAdd] = screenCapToAdd;
AvailScreenCaps[screenCapIndexToAdd].Enabled = origEnabledState;
}
else // add
{
AvailScreenCaps.Add(screenCapToAdd);
}
}
public static void UpdateScreenCapAtEOF(xARMScreenCap screenCap)
{
// capture Render at EndOfFrame
Proxy.StartUpdateScreenCapCoroutine(screenCap);
// force EndOfFrame - to execute yield
GameView.Repaint();
}
// export ScreenCap as PNG file
private static void ExportScreenCapToFile(xARMScreenCap screenCap, string path)
{
FileStream fs = new FileStream(path, FileMode.Create);
BinaryWriter bw = new BinaryWriter(fs);
bw.Write(screenCap.Texture.EncodeToPNG());
bw.Close();
fs.Close();
}
private IEnumerator WaitXFrames(xARMScreenCap screenCap, int frameCount)
{
while (frameCount > 0)
{
yield return(null); // wait until next frame
frameCount--;
}
xARMManager.UpdateScreenCapAtEOF(screenCap);
}
public static void ReadScreenCapFromGameView(xARMScreenCap screenCap)
{
int width = (int)screenCap.Resolution.x;
int height = (int)screenCap.Resolution.y;
// check if the GameView has the correct size
if (screenCap.Resolution.x == Screen.width && screenCap.Resolution.y == Screen.height)
{
// read screen to Tex2D
Texture2D screenTex = new Texture2D(width, height, TextureFormat.RGB24, false);
screenTex.ReadPixels(new Rect(0, 0, width, height), 0, 0, false);
screenTex.Apply(false, false); // readable to enable export as file
// update ScreenCap
screenCap.Texture = screenTex;
screenCap.LastUpdateTime = lastChangeInEditorTime;
screenCap.LastUpdateTryTime = lastChangeInEditorTime;
screenCap.UpdatedSuccessful = true;
// repaint editor windows
if (myxARMPreviewWindow)
{
myxARMPreviewWindow.Repaint();
}
if (myxARMGalleryWindow)
{
myxARMGalleryWindow.Repaint();
}
}
else
{
// mark this ScreenCap as not updated and display message
screenCap.LastUpdateTryTime = lastChangeInEditorTime;
screenCap.UpdatedSuccessful = false;
#if UNITY_4_0 || UNITY_4_0_1 || UNITY_4_1 || UNITY_4_2 || UNITY_4_3 || UNITY_4_5 || UNITY_4_6 || UNITY_4_7 || UNITY_5_0 || UNITY_5_1 || UNITY_5_2 || UNITY_5_3
xARMGalleryWindow.WarningBoxText = "Could not update all ScreenCaps. Switch 'GameView' to 'Free Aspect'.";
xARMPreviewWindow.WarningBoxText = "Could not update all ScreenCaps. Switch 'GameView' to 'Free Aspect'.";
#else // 5.4+
// detect HiDPI mode and toolbar offset
AutoDetectGameViewSettings(screenCap.Resolution, new Vector2(Screen.width, Screen.height));
xARMGalleryWindow.WarningBoxText = "Could not update all ScreenCaps. Ensure 'GameView' is set to 'Free Aspect' and retry (Auto detect of HiDPI mode and toolbar offset was executed).";
xARMPreviewWindow.WarningBoxText = "Could not update all ScreenCaps. Ensure 'GameView' is set to 'Free Aspect' and retry (Auto detect of HiDPI mode and toolbar offset was executed).";
#endif
}
// run custom code
if (OnPostScreenCapUpdate != null)
{
OnPostScreenCapUpdate();
}
UpdatingScreenCap = null;
}
public static bool IsToUpdate(xARMScreenCap screenCap)
{
if (screenCap.LastUpdateTime != lastChangeInEditorTime && screenCap.LastUpdateTryTime != lastChangeInEditorTime)
{
return(true);
}
else
{
return(false);
}
}
// coroutine to update the ScreenCap at the end of the current frame
private IEnumerator UpdateScreenCapCoroutine(xARMScreenCap screenCapToUpdate)
{
yield return(new WaitForEndOfFrame());
// final check if this yield is still relevant
if (xARMManager.TargetGameViewResolution == screenCapToUpdate.Resolution) //
{
xARMManager.ReadScreenCapFromGameView(screenCapToUpdate);
}
xARMManager.ScreenCapUpdateInProgress = false;
}
private static int getScreenCapIndex(xARMScreenCap screenCapToCheck)
{
for (int x = 0; x < AvailScreenCaps.Count; x++)
{
if (AvailScreenCaps[x] == screenCapToCheck)
{
return(x);
}
}
return(-1);
}
private static void DrawGallery()
{
int entriesPerRow = xARMManager.Config.GalleryScreenCapsPerRow;
EditorGUILayout.BeginVertical();
EditorGUILayout.BeginHorizontal();
for (int x = 0; x < activeScreenCaps.Count; x++)
{
xARMScreenCap currScreenCap = activeScreenCaps[x];
// begin new row?
if (x % entriesPerRow == 0)
{
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
}
DrawScreenCap(currScreenCap, x);
// last entry?
if (x == activeScreenCaps.Count - 1)
{
// fill last row to ensure same/correct size of last row entries
int entriesInLastRow = activeScreenCaps.Count % entriesPerRow;
if (entriesInLastRow < entriesPerRow && entriesInLastRow != 0 && !xARMManager.Config.UseFixedScreenCapSize)
{
int entriesToFill = entriesPerRow - entriesInLastRow;
// add invisible dummy entries
for (int y = 0; y < entriesToFill; y++)
{
// use same layout cammands as below for similar spacing
EditorGUILayout.BeginVertical();
GUILayoutUtility.GetAspectRect(currScreenCap.Aspect, GUILayout.MinWidth(screenCapMinWidth), GUILayout.MinHeight(screenCapMinHeight));
EditorGUILayout.BeginHorizontal();
EditorGUILayout.EndHorizontal();
EditorGUILayout.EndVertical();
}
}
}
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.EndVertical();
}
// Draws an default (=bultin) ScreenCap entry line
private static void DrawDefaultScreenCapEntry(xARMScreenCap screenCap)
{
GUILayout.BeginHorizontal("box");
GUILayout.Space(spacing);
screenCap.Enabled = GUILayout.Toggle(screenCap.Enabled, "", GUILayout.Width(labelWidthEnabled));
GUILayout.Label(screenCap.Group.ToString(), GUILayout.Width(labelWidthGroup));
GUILayout.Label(screenCap.Name, GUILayout.Width(labelWidthName));
GUILayout.Label(screenCap.Diagonal.ToString() + charInch, GUILayout.Width(labelWidthDiagonal));
GUILayout.Label(screenCap.DPILabel, GUILayout.Width(labelWidthDPILabel));
GUILayout.Label(screenCap.DPI.ToString(), GUILayout.Width(labelWidthDPI));
GUILayout.Label(screenCap.AspectLabel, GUILayout.Width(labelWidthAspectLabel));
GUILayout.Label(screenCap.Resolution.x + "x" + screenCap.Resolution.y + "px", GUILayout.Width(labelWidthResolution));
if (screenCap.IsLandscape)
{
GUILayout.Label(screenCap.ResolutionLabel + " " + charLandscape, GUILayout.Width(labelWidthResolutionLabel));
GUILayout.Label("Landscape", GUILayout.Width(labelWidthFormat));
}
else
{
GUILayout.Label(screenCap.ResolutionLabel + " " + charPortrait, GUILayout.Width(labelWidthResolutionLabel));
GUILayout.Label("Portrait", GUILayout.Width(labelWidthFormat));
}
if (screenCap.StatisticsPositioning == 999)
{
GUILayout.Label("n/a", GUILayout.Width(labelWidthStatsPos));
}
else
{
GUILayout.Label(screenCap.StatisticsPositioning.ToString() + ".", GUILayout.Width(labelWidthStatsPos));
}
if (screenCap.StatisticsUsedPercent == -1f)
{
GUILayout.Label("n/a", GUILayout.Width(labelWidthStatsPerc));
}
else
{
GUILayout.Label(screenCap.StatisticsUsedPercent.ToString() + "%", GUILayout.Width(labelWidthStatsPerc));
}
GUILayout.Label(screenCap.Description, GUILayout.MinWidth(labelMinWidthDescription));
GUILayout.EndHorizontal();
}
private static void addOrUpdateScreenCap(xARMScreenCap screenCapToAdd)
{
int screenCapIndex = getScreenCapIndex(screenCapToAdd);
if (screenCapIndex >= 0) // update (don't add duplicates)
// values to keep
{
bool origEnabledState = AvailScreenCaps[screenCapIndex].Enabled;
AvailScreenCaps[screenCapIndex] = screenCapToAdd;
AvailScreenCaps[screenCapIndex].Enabled = origEnabledState;
}
else // add
{
AvailScreenCaps.Add(screenCapToAdd);
}
}
public static void UpdateScreenCap(xARMScreenCap screenCap)
{
// make current ScreenCap available to delegates
UpdatingScreenCap = screenCap;
ResizeGameView(screenCap.Resolution);
// run custom code
if (OnPreScreenCapUpdate != null)
{
OnPreScreenCapUpdate();
}
xARMManager.ScreenCapUpdateInProgress = true;
// wait x frames to ensure correct results with other (lazy) plugins
Proxy.StartWaitXFramesCoroutine(screenCap, xARMManager.Config.FramesToWait);
}
public static void ReadScreenCapFromGameView(xARMScreenCap screenCap)
{
int width = (int)screenCap.Resolution.x;
int height = (int)screenCap.Resolution.y;
// check if the GameView has the correct size
if (screenCap.Resolution.x == Screen.width && screenCap.Resolution.y == Screen.height)
{
// read screen to Tex2D
Texture2D screenTex = new Texture2D(width, height, TextureFormat.RGB24, false);
screenTex.ReadPixels(new Rect(0, 0, width, height), 0, 0, false);
screenTex.Apply(false, false); // readable to enable export as file
// update ScreenCap
screenCap.Texture = screenTex;
screenCap.LastUpdateTime = lastChangeInEditorTime;
screenCap.LastUpdateTryTime = lastChangeInEditorTime;
screenCap.UpdatedSuccessful = true;
// repaint editor windows
if (myxARMPreviewWindow)
{
myxARMPreviewWindow.Repaint();
}
if (myxARMGalleryWindow)
{
myxARMGalleryWindow.Repaint();
}
}
else
{
// mark this ScreenCap as not updated and display message
screenCap.LastUpdateTryTime = lastChangeInEditorTime;
screenCap.UpdatedSuccessful = false;
xARMGalleryWindow.WarningBoxText = "Could not update all ScreenCaps. Switch 'GameView' to 'Free Aspect'.";
xARMPreviewWindow.WarningBoxText = "Could not update all ScreenCaps. Switch 'GameView' to 'Free Aspect'.";
}
// run custom code
if (OnPostScreenCapUpdate != null)
{
OnPostScreenCapUpdate();
}
}
// save one SC as file
public static void SaveScreenCapFile(xARMScreenCap screenCap)
{
if (screenCap.Texture.width != 4) // not placeholder
{
string defaultFileName = screenCap.Name + " " + screenCap.Diagonal + " " + screenCap.DPILabel + " " + screenCap.Resolution.x + "x" + screenCap.Resolution.y + ".png";
// open export to file panel
string exportFilePath = EditorUtility.SaveFilePanel("Export ScreenCap as PNG", xARMManager.Config.ExportPath, defaultFileName, "png");
// export
if (exportFilePath.Length > 0)
{
ExportScreenCapToFile(screenCap, exportFilePath);
}
}
else
{
Debug.LogWarning("xARM: ScreenCap not exported. Please update it before export.");
}
}
public static void UpdateScreenCap(xARMScreenCap screenCap)
{
ResizeGameView(screenCap.Resolution);
// run custom code
if (OnPreScreenCapUpdate != null)
{
OnPreScreenCapUpdate();
}
xARMManager.ScreenCapUpdateInProgress = true;
// wait x frames to ensure correct results with other (lazy) plugins
if (xARMManager.CurrEditorMode == EditorMode.Play) // don't wait in Play mode
{
Proxy.StartWaitXFramesCoroutine(screenCap, 0);
}
else
{
Proxy.StartWaitXFramesCoroutine(screenCap, xARMManager.Config.FramesToWait);
}
}
private static void DrawGallery()
{
EditorGUILayout.BeginVertical();
EditorGUILayout.BeginHorizontal();
for (int x = 0; x < activeScreenCaps.Count; x++)
{
xARMScreenCap currScreenCap = activeScreenCaps[x];
// start new row
if (x % xARMManager.Config.GalleryScreenCapsPerRow == 0)
{
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
}
DrawScreenCap(currScreenCap, x);
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.EndVertical();
}
// coroutine to wait a few frames between resolution change and SC update
public void StartWaitXFramesCoroutine(xARMScreenCap screenCap, int frameCount)
{
StartCoroutine(WaitXFrames(screenCap, frameCount));
}
void Update()
{
#if UNITY_3_3 || UNITY_3_4 || UNITY_3_5
// trace Game View position
xARMManager.SaveGameViewPosition();
#else
// do tracing via Proxy.Update()
#endif
// ensures a xARM Proxy exists
xARMManager.CreateProxyGO();
// finalize SC update
if (xARMManager.PreviewIsUpdating && !xARMManager.ScreenCapUpdateInProgress)
{
xARMManager.PreviewIsUpdating = false;
xARMManager.FinalizeScreenCapUpdate();
}
// update SC if auto update is enabled or Update1x was clicked
if (((xARMManager.Config.PreviewAutoUpdateInEditorMode && xARMManager.CurrEditorMode == EditorMode.Edit) || // Edit
(xARMManager.Config.PreviewAutoUpdateInPauseMode && xARMManager.CurrEditorMode == EditorMode.Pause) || // Pause
(xARMManager.Config.PreviewAutoUpdateInPlayMode && xARMManager.CurrEditorMode == EditorMode.Play) || // Play
updateOnce) &&
!xARMManager.GalleryIsUpdating &&
!xARMManager.ScreenCapUpdateInProgress)
{
// limit SC updates
if (!updateOnce && xARMManager.CurrEditorMode == EditorMode.Edit) // limit auto update in Edit mode
{
updateInterval = 1f / xARMManager.Config.PreviewUpdateIntervalLimitEdit;
}
else if (!updateOnce && xARMManager.CurrEditorMode == EditorMode.Play) // limit auto update in Play mode
{
updateInterval = 1f / xARMManager.Config.PreviewUpdateIntervalLimitPlay;
}
else
{
updateInterval = 0f; // do not limit update interval
}
if (EditorApplication.timeSinceStartup > lastUpdateTime + updateInterval) // limit updates per sec
{
lastUpdateTime = EditorApplication.timeSinceStartup;
if (SelectedScreenCap is xARMScreenCap && xARMManager.ProxyGO && !xARMManager.GalleryIsUpdating)
{
xARMScreenCap currScreenCap = SelectedScreenCap;
// update screencap only if it's outdated (try one time) OR update1x is clicked
if (xARMManager.IsToUpdate(currScreenCap) || updateOnce)
{
// run custom code
if (xARMManager.PreviewIsUpdating == false && xARMManager.OnStartScreenCapUpdate != null)
{
xARMManager.OnStartScreenCapUpdate();
}
xARMManager.PreviewIsUpdating = true;
xARMManager.UpdateScreenCap(currScreenCap);
updateOnce = false;
}
}
}
}
// ensure a next frame while waiting for one
if (xARMManager.ScreenCapUpdateInProgress && xARMManager.PreviewIsUpdating) // while SC update
{
xARMManager.EnsureNextFrame();
}
else if (postGameViewResizeFramesToGo > 0) // after GV's resolution is changed by selection in Preview
{
xARMManager.EnsureNextFrame();
postGameViewResizeFramesToGo--;
}
if (activeScreenCaps.Count == 0)
{
InfoBoxText = "No ScreenCaps active. Open xARM Options to activate target Aspect Ratios and Resolutions.";
}
else
{
InfoBoxText = "";
}
// resize Game View to new default resolution
if (resizeGameViewToNewDefault)
{
resizeGameViewToNewDefault = false;
xARMManager.ResizeGameViewToDefault();
postGameViewResizeFramesToGo = xARMManager.Config.FramesToWait;
}
// repaint window
if (RepaintNextUpdate)
{
myWindow.Repaint();
RepaintNextUpdate = false;
}
}
public void StartUpdateScreenCapCoroutine(xARMScreenCap screenCapToUpdate)
{
StartCoroutine(UpdateScreenCapCoroutine(screenCapToUpdate));
}
// update one ScreenCap per Update()
void Update()
{
#if UNITY_3_3 || UNITY_3_4 || UNITY_3_5
// trace Game View position
xARMManager.SaveGameViewPosition();
#else
// do tracing via Proxy.Update()
#endif
// ensures a xARM Proxy exists
xARMManager.CreateProxyGO();
// finalize SC update (set default GV size etc.)
if (xARMManager.AllScreenCapsUpdatedRecently() && !xARMManager.FinalizeScreenCapInProgress)
{
// reset 1xUpdate
if (updateOnce)
{
screenCapsToUpdateOnce = 0;
updateOnce = false;
}
xARMManager.GalleryIsUpdating = false;
xARMManager.FinalizeScreenCapInProgress = true;
xARMManager.FinalizeScreenCapUpdate();
}
// ensure some frames after default resolution is set
else if (xARMManager.AllScreenCapsUpdatedRecently() && xARMManager.FinalizeScreenCapInProgress)
{
// still frames to go?
if (postUpdateFramesToGo <= 0)
{
xARMManager.SetAllScreenCapsUpdated();
xARMManager.FinalizeScreenCapInProgress = false;
}
else
{
xARMManager.EnsureNextFrame();
postUpdateFramesToGo--;
}
}
// auto update or 1xUpdate
else if (((xARMManager.Config.GalleryAutoUpdateInEditorMode && xARMManager.CurrEditorMode == EditorMode.Edit) || // Editor mode
(xARMManager.Config.GalleryAutoUpdateInPauseMode && xARMManager.CurrEditorMode == EditorMode.Pause) || // Pause mode
updateOnce) && // 1x Update
!xARMManager.ScreenCapUpdateInProgress)
{ // update ScreenCap
// limit SC-block updates
if (!updateOnce && !xARMManager.GalleryIsUpdating && xARMManager.CurrEditorMode == EditorMode.Edit) // limit auto update in Edit mode (only for SC-blocks)
{
updateInterval = 1f / xARMManager.Config.GalleryUpdateIntervalLimitEdit;
}
else
{
updateInterval = 0f; // do not limit update interval
}
if (EditorApplication.timeSinceStartup > lastUpdateTime + updateInterval) // limit updates per sec
{
lastUpdateTime = EditorApplication.timeSinceStartup;
// cache list
activeScreenCaps = xARMManager.ActiveScreenCaps;
// execute update?
if (activeScreenCaps.Count != 0 && xARMManager.ProxyGO && !xARMManager.PreviewIsUpdating && !xARMManager.GameViewHasFocus)
{
// find next screenCap to update
if (currScreenCapIndex >= activeScreenCaps.Count)
{
currScreenCapIndex = 0;
}
xARMScreenCap currScreenCap = activeScreenCaps[currScreenCapIndex];
// update screencap only if it's outdated (try one time) OR update1x is clicked
if (xARMManager.IsToUpdate(currScreenCap) || updateOnce)
{
xARMManager.GalleryIsUpdating = true;
xARMManager.UpdateScreenCap(currScreenCap);
currScreenCapIndex++;
// decrease Update1x-to-go count
if (updateOnce && screenCapsToUpdateOnce > 0)
{
screenCapsToUpdateOnce--;
}
// number os frames to step after all SCs are updated
postUpdateFramesToGo = xARMManager.Config.FramesToWait;
}
else // skip SC
{
currScreenCapIndex++;
}
}
}
}
// ensure a next frame while waiting for one
if (xARMManager.ScreenCapUpdateInProgress && xARMManager.GalleryIsUpdating)
{
xARMManager.EnsureNextFrame();
}
if (activeScreenCaps.Count == 0)
{
InfoBoxText = "No ScreenCaps active. Open xARM Options to activate target Aspect Ratios and Resolutions.";
}
else
{
InfoBoxText = "";
}
// repaint window
if (repaintNextUpdate)
{
myWindow.Repaint();
repaintNextUpdate = false;
}
}
private static void DrawScreenCap(xARMScreenCap screenCap, int screenCapIndex)
{
Rect screenCapRect, screenCapBox;
float screenCapPXOnScreen; // SC px width
// create Box and Rect
if (xARMManager.Config.UseFixedScreenCapSize)
{
screenCapBox = EditorGUILayout.BeginVertical("box", GUILayout.Width(xARMManager.Config.FixedScreenCapSize.x), GUILayout.Height(xARMManager.Config.FixedScreenCapSize.y));
screenCapRect = GUILayoutUtility.GetRect(xARMManager.Config.FixedScreenCapSize.x, xARMManager.Config.FixedScreenCapSize.y);
screenCapPXOnScreen = xARMManager.Config.FixedScreenCapSize.x;
}
else
{
screenCapBox = EditorGUILayout.BeginVertical("box");
screenCapRect = GUILayoutUtility.GetAspectRect(screenCap.Aspect, GUILayout.MinWidth(screenCapMinWidth), GUILayout.MinHeight(screenCapMinHeight));
screenCapPXOnScreen = myWindow.position.width / xARMManager.Config.GalleryScreenCapsPerRow; // estimate SC width
}
// draw SC
if (screenCap.UpdatedSuccessful)
{
#if UNITY_3_3 || UNITY_3_4 || UNITY_3_5
// standard draw (with Play mode tint)
GUI.DrawTexture(screenCapRect, screenCap.Texture, ScaleMode.ScaleToFit);
#else
// draw ScreenCap in prepared rect (use EditorGUI.DrawTextureTransparent to draw it without Play mode tint)
EditorGUI.DrawTextureTransparent(screenCapRect, screenCap.Texture, ScaleMode.ScaleToFit);
#endif
// select SC in xARM Preview on click
if (screenCapBox.Contains(Event.current.mousePosition))
{
if (Event.current.type == EventType.MouseDown && Event.current.button == 0)
{
xARMPreviewWindow.ChangeActiveScreenCap(screenCapIndex);
}
}
}
else
{
#if UNITY_3_3 || UNITY_3_4
GUILayout.Label("ScreenCap could not been updated");
#else
EditorGUILayout.HelpBox("ScreenCap could not been updated", MessageType.Warning, true); // Unity 3.3 Error
#endif
}
GUILayout.Space(2);
// description
EditorGUILayout.BeginHorizontal();
if (screenCap.IsLandscape)
{
GUILayout.Label(screenCap.Name + " " + screenCap.Diagonal + charInch + " " + screenCap.DPILabel + " (" + screenCap.AspectLabel + ")" + "\n" +
screenCap.Resolution.x + "x" + screenCap.Resolution.y + "px (" + screenCap.ResolutionLabel + " " + charLandscape + ")", labelStyle);
}
else
{
GUILayout.Label(screenCap.Name + " " + screenCap.Diagonal + charInch + " " + screenCap.DPILabel + " (" + screenCap.AspectLabel + ")" + "\n" +
screenCap.Resolution.x + "x" + screenCap.Resolution.y + "px (" + screenCap.ResolutionLabel + " " + charPortrait + ")", labelStyle);
}
// scale ratio
if (xARMManager.Config.EditorDPI > 0)
{
float scaleRatioPhySizeInch = xARMManager.Config.ScaleRatioInch;
float scaleRatioPhySizePX = xARMManager.Config.EditorDPI * scaleRatioPhySizeInch; // phy size of fingerprint with Editor DPI
float screenCapPhySizeOnScreen = screenCap.Resolution.x * xARMManager.Config.EditorDPI / screenCap.DPI; // phy size of SC with Editor DPI
if (Event.current.type.Equals(EventType.Repaint))
{
screenCapPXOnScreen = screenCapRect.width; // get precise SC width
}
float scaleRatioPX = scaleRatioPhySizePX * screenCapPXOnScreen / screenCapPhySizeOnScreen; // px widht/height of fingerprint
Rect scaleRatioRect = GUILayoutUtility.GetRect(scaleRatioPX, scaleRatioPX, GUILayout.ExpandWidth(false), GUILayout.ExpandHeight(false));
GUI.DrawTexture(scaleRatioRect, EditorGUIUtility.whiteTexture, ScaleMode.ScaleToFit, false);
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.EndVertical();
}
