+Unity Runtime codeHEADmaster

1 files changed, 476 insertions, 0 deletions

diff --git a/Runtime/Export/GUIUtility.txt b/Runtime/Export/GUIUtility.txt
new file mode 100644
index 0000000..99fcbc9
--- /dev/null
+++ b/Runtime/Export/GUIUtility.txt
@@ -0,0 +1,476 @@
+C++RAW
+
+#include "UnityPrefix.h"
+#include "Runtime/Misc/AssetBundle.h"
+#include "Runtime/Misc/ResourceManager.h"
+#include "Runtime/Mono/MonoBehaviour.h"
+#include "Runtime/IMGUI/GUIStyle.h"
+#include "Runtime/Filters/Misc/Font.h"
+#include "Runtime/Misc/InputEvent.h"
+#include "Runtime/GfxDevice/GfxDevice.h"
+#include "Runtime/Camera/CameraUtil.h"
+#include "Runtime/IMGUI/GUIManager.h"
+#include "Runtime/Utilities/CopyPaste.h"
+#include "Runtime/IMGUI/GUIState.h"
+#include "Runtime/IMGUI/GUIClip.h"
+#include "Runtime/IMGUI/IMGUIUtils.h"
+#include "Runtime/IMGUI/GUIWindows.h"
+#include "Runtime/Input/InputManager.h"
+#include "Runtime/Scripting/ScriptingUtility.h"
+#if UNITY_EDITOR
+
+#include "Editor/Src/EditorHelper.h"
+#include "Editor/Mono/MonoEditorUtility.h"
+#include "Editor/Src/OptimizedGUIBlock.h"
+#include "Editor/Src/AssetPipeline/AssetDatabase.h"
+#include "Editor/Src/Undo/UndoManager.h"
+
+extern float s_GUIStyleIconSizeX;
+extern float s_GUIStyleIconSizeY;
+#endif
+
+using namespace Unity;
+using namespace std;
+
+CSRAW
+
+// Use this define to debug who grabs and releases hotcontrol
+//#define DEBUG_HOTCONTROL
+
+// Use this define to debug controlID consistency together with 's_LogControlID' (default false) to enable logging in 
+// a codepath thats needs tested for consistency. E.g:
+//	if (Event.current.rawType == EventType.MouseUp)
+//		GUIUtility.s_LogControlID = true;
+// And remember to set s_LogControlID to false at end of secion of interest.
+//#define DEBUG_CONTROLID
+
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Collections;
+
+namespace UnityEngine
+{
+
+// Throw this to immediately exit from GUI code.
+// *undocumented*
+CLASS ExitGUIException : System.Exception
+END
+
+// Used by GUIUtility.GetcontrolID to inform the UnityGUI system if a given control can get keyboard focus.
+ENUM FocusType
+	// This control can get keyboard focus on Windows, but not on Mac. Used for buttons, checkboxes and other "pressable" things.
+	Native = 0,
+	// This is a proper keyboard control. It can have input focus on all platforms. Used for TextField and TextArea controls
+	Keyboard = 1,
+	// This control can never recieve keyboard focus.
+	Passive = 2
+END
+
+CSRAW
+
+// Utility class for making new GUI controls. 
+NONSEALED_CLASS GUIUtility 
+
+	/// *listonly* 
+	CSRAW public static int GetControlID (FocusType focus)						
+	{
+		return GetControlID (0, focus);
+	}
+	/// *listonly* 	
+	CUSTOM public static int GetControlID (int hint, FocusType focus)
+	{
+		return GetGUIState().GetControlID (hint, focus);
+	}
+	/// *listonly*
+	CSRAW public static int GetControlID (GUIContent contents,FocusType focus)	
+	{
+		return GetControlID (contents.hash, focus);
+	}
+	/// *listonly* 
+	CSRAW public static int GetControlID (FocusType focus, Rect position)
+	{
+		return Internal_GetNextControlID2 (0, focus, position); 
+	}
+	/// *listonly* 	
+	CSRAW public static int GetControlID (int hint, FocusType focus, Rect position)
+	{
+		return Internal_GetNextControlID2 (hint, focus, position);
+	}
+	// Get a unique ID for a control.
+	CSRAW static public int GetControlID (GUIContent contents, FocusType focus, Rect position)
+	{ 
+		return Internal_GetNextControlID2 (contents.hash, focus, position); 
+	}
+
+	CUSTOM private static int Internal_GetNextControlID2 (int hint, FocusType focusType, Rect rect)
+	{
+		return GetGUIState().GetControlID (hint, focusType, rect);
+	}
+
+	// Get a state object from a controlID.
+	CSRAW public static object GetStateObject (Type t, int controlID)		{ return GUIStateObjects.GetStateObject (t, controlID); }
+
+	// Get an existing state object from a controlID.
+	CSRAW public static object QueryStateObject (Type t, int controlID)		{ return GUIStateObjects.QueryStateObject (t, controlID); }
+
+	CUSTOM static internal int GetPermanentControlID ()
+	{
+		return GetGUIState().m_EternalGUIState->GetNextUniqueID ();
+	}
+	
+CSRAW
+	#if DEBUG_HOTCONTROL
+	static public string s_WhoGrabbedHotControl, s_WhoReleasedHotControl;
+	#endif
+	
+	#if DEBUG_CONTROLID
+	static public bool s_LogControlID = false;
+	#endif
+	
+
+	// The controlID of the current hot control.
+	CSRAW public static int hotControl { get { return Internal_GetHotControl(); } 
+	set { 
+		#if DEBUG_HOTCONTROL
+		if (value != 0)
+		{
+			s_WhoGrabbedHotControl = StackTraceUtility.ExtractStackTrace();
+			Debug.Log("GRABBED " + s_WhoGrabbedHotControl);
+		}
+		else
+		{
+			s_WhoReleasedHotControl = StackTraceUtility.ExtractStackTrace();
+			Debug.Log("RELEASE: " + s_WhoReleasedHotControl);
+		}
+		#endif
+
+		Internal_SetHotControl (value);
+	} }
+	
+	CUSTOM private static int Internal_GetHotControl () 
+	{
+		return IMGUI::GetHotControl (GetGUIState());
+	}
+	CUSTOM private static void Internal_SetHotControl (int value)
+	{
+		IMGUI::SetHotControl (GetGUIState(), value);
+	}
+	
+	CUSTOM internal static void UpdateUndoName ()
+	{
+		#if UNITY_EDITOR
+		GetUndoManager().UpdateUndoName ();
+		#endif
+	}
+	
+	// The controlID of the control that has keyboard focus.
+	CUSTOM_PROP static int keyboardControl
+		{ return IMGUI::GetKeyboardControl (GetGUIState()); }
+		{ IMGUI::SetKeyboardControl (GetGUIState(), value); }
+
+// Keep for debugging keyboardControl (prints the callstack when keyboardControl changes)
+// 	CSRAW public static int keyboardControl
+// 	{
+// 		get { return GetKeyboardControl (); }
+// 		set { Debug.Log ("Set keyboardControl " + value); SetKeyboardControl (value);}
+// 	}
+// 	CUSTOM static int GetKeyboardControl () 		{return IMGUI::GetKeyboardControl (GetGUIState());	}
+// 	CUSTOM static void SetKeyboardControl (int id) 	{IMGUI::SetKeyboardControl (GetGUIState(), id);	}
+
+	//*undocumented*
+	CSRAW public static void ExitGUI ()
+	{
+		// We have to always throw the ExitGUIException otherwise the exiting out of recursive on GUI will not work.
+		throw new ExitGUIException ();
+	}
+
+	CUSTOM internal static void SetDidGUIWindowsEatLastEvent (bool value) {
+		GUIManager::SetDidGUIWindowsEatLastEvent (value);
+	}
+
+	// Get access to the system-wide pasteboard.
+	CUSTOM_PROP static internal string systemCopyBuffer { return scripting_string_new(GetCopyBuffer ()); } { SetCopyBuffer (value); }
+	
+	CSRAW internal static GUISkin GetDefaultSkin() {
+		return Internal_GetDefaultSkin (s_SkinMode);
+	}
+
+	CUSTOM private static GUISkin Internal_GetDefaultSkin (int skinMode) {
+		return GetDefaultSkin (skinMode)->GetInstance ();
+	}
+
+	CUSTOM private static Object Internal_GetBuiltinSkin (int skin) {
+		return GetBuiltinSkin (skin)->GetInstance ();
+	}
+
+	// internal so we can get to it from EditorGUIUtility.GetBuiltinSkin
+	CSRAW internal static GUISkin GetBuiltinSkin (int skin) {
+		return Internal_GetBuiltinSkin (skin) as GUISkin;
+	}
+
+	[NotRenamed] static internal int s_SkinMode;
+	[NotRenamed] static internal int s_OriginalID;
+	CSRAW internal static void BeginGUI (int skinMode, int instanceID, int useGUILayout ) {
+		s_SkinMode = skinMode;
+		s_OriginalID = instanceID;
+		GUI.skin = null;
+
+		// Switch to the correct ID list & clear keyboard loop if we're about to layout (we rebuild it during layout, so we want it cleared beforehand)
+		if (useGUILayout != 0)
+		{
+			GUILayoutUtility.SelectIDList (instanceID, false);
+			GUILayoutUtility.Begin (instanceID);
+		}
+
+		GUI.changed = false;
+	}
+
+	CUSTOM private static void Internal_ExitGUI () 
+	{
+		#if UNITY_EDITOR	
+		OptimizedGUIBlock::Abandon ();
+		s_GUIStyleIconSizeX = 0.0f;
+		s_GUIStyleIconSizeY = 0.0f;
+		#endif
+	}
+
+	// End the 2D GUI.
+	CSRAW internal static void EndGUI (int layoutType)
+	{
+		try
+		{
+			if (Event.current.type == EventType.Layout)
+			{
+				switch (layoutType)
+				{
+				case 0: // kNoLayout
+					break;
+				case 1: // kGameLayout
+					GUILayoutUtility.Layout ();
+					break;
+				case 2: // kEditorLayout
+					GUILayoutUtility.LayoutFromEditorWindow ();
+					break;
+				}
+			}
+			
+			GUILayoutUtility.SelectIDList (s_OriginalID, false);
+			GUIContent.ClearStaticCache();
+		} 
+		finally {
+			Internal_ExitGUI();
+		}
+	}
+	
+	// End the 2D GUI.
+	CSRAW internal static bool EndGUIFromException (System.Exception exception) {
+		// Check if the exception is a ExitGUIException
+		if (exception == null)
+			return false;
+		if (exception as ExitGUIException == null
+#if !UNITY_FLASH && !UNITY_WEBGL
+		 && exception.InnerException as ExitGUIException == null
+#endif		 
+		 )
+			return false;
+
+			Internal_ExitGUI ();
+
+		return true;
+	}
+	
+	// Only allow calling GUI functions from inside OnGUI
+	CSRAW static internal void CheckOnGUI() { 
+		if (Internal_GetGUIDepth () <= 0)
+		{
+			throw new ArgumentException("You can only call GUI functions from inside OnGUI."); 
+		}
+	}
+
+	CUSTOM static internal int Internal_GetGUIDepth ()
+	{
+		return GetGUIState().m_OnGUIDepth;
+	}
+	
+	CUSTOM_PROP static internal bool mouseUsed
+		{ return GetGUIState().m_CanvasGUIState.m_IsMouseUsed != 0; } 
+		{ GetGUIState().m_CanvasGUIState.m_IsMouseUsed = value ? 1 : 0; } 
+	
+	CSRAW
+	
+	static internal Vector2 s_EditorScreenPointOffset = Vector2.zero;
+	static internal bool s_HasKeyboardFocus = false;
+	
+	// Convert a point from GUI position to screen space.
+	CSRAW public static Vector2 GUIToScreenPoint (Vector2 guiPoint)
+	{
+		return GUIClip.Unclip (guiPoint) + s_EditorScreenPointOffset;
+	}
+	
+	// Convert a rect from GUI position to screen space.
+	CSRAW internal static Rect GUIToScreenRect (Rect guiRect)
+	{
+		Vector2 screenPoint = GUIToScreenPoint (new Vector2 (guiRect.x, guiRect.y));
+		guiRect.x = screenPoint.x;
+		guiRect.y = screenPoint.y;
+		return guiRect;
+	}
+	
+	// Convert a point from screen space to GUI position.
+	CSRAW public static Vector2 ScreenToGUIPoint (Vector2 screenPoint)
+	{
+		return GUIClip.Clip (screenPoint) - s_EditorScreenPointOffset;
+	}
+	
+	// Convert a rect from screen space to GUI position.
+	CSRAW public static Rect ScreenToGUIRect (Rect screenRect)
+	{
+		Vector2 guiPoint = ScreenToGUIPoint (new Vector2 (screenRect.x, screenRect.y));
+		screenRect.x = guiPoint.x;
+		screenRect.y = guiPoint.y;
+		return screenRect;
+	}
+	
+	// Helper function to rotate the GUI around a point.
+	public static void RotateAroundPivot (float angle, Vector2 pivotPoint) {
+		Matrix4x4 mat = GUI.matrix;
+		GUI.matrix = Matrix4x4.identity;
+		Vector2 point = GUIClip.Unclip(pivotPoint);
+ 		Matrix4x4 newMat =  Matrix4x4.TRS (point, Quaternion.Euler (0,0,angle), Vector3.one) * Matrix4x4.TRS (-point, Quaternion.identity, Vector3.one);
+		GUI.matrix = newMat *mat;
+	}
+
+	// Helper function to scale the GUI around a point.
+	public static void ScaleAroundPivot (Vector2 scale, Vector2 pivotPoint) {
+		Matrix4x4 mat = GUI.matrix;
+		Vector2 point = GUIClip.Unclip(pivotPoint);
+ 		Matrix4x4 newMat =  Matrix4x4.TRS (point, Quaternion.identity, new Vector3 (scale.x, scale.y, 1)) * Matrix4x4.TRS (-point, Quaternion.identity, Vector3.one);
+		GUI.matrix = newMat * mat;
+	}
+	
+	// Check to see if there's a modal IMGUI window that's currently open
+	CUSTOM_PROP public static bool hasModalWindow
+	{ 
+		GUIState& state = GetGUIState();
+		return state.m_MultiFrameGUIState.m_Windows != NULL && state.m_MultiFrameGUIState.m_Windows->m_ModalWindow != NULL;
+	}
+
+	//*undocumented*
+	CUSTOM_PROP static internal bool textFieldInput 
+	{ return GetInputManager().GetTextFieldInput (); }
+	{ GetInputManager().SetTextFieldInput (value); }
+END
+
+
+CLASS internal GUIClip
+	// Push a clip rect to the stack with pixel offsets.
+	CUSTOM internal static void Push (Rect screenRect, Vector2 scrollOffset, Vector2 renderOffset, bool resetOffset)
+	{
+		GetGUIState().m_CanvasGUIState.m_GUIClipState.Push (IMGUI::GetCurrentEvent(GetGUIState()), screenRect, scrollOffset, renderOffset, resetOffset);
+	}
+
+	// Removes the topmost clipping rectangle, undoing the effect of the latest GUIClip.Push
+	CUSTOM internal static void Pop ()
+	{
+		GetGUIState().m_CanvasGUIState.m_GUIClipState.Pop (IMGUI::GetCurrentEvent(GetGUIState()));
+	}
+
+	// Get the topmost rectangle
+	CUSTOM internal static Rect GetTopRect ()
+	{
+		return GetGUIState().m_CanvasGUIState.m_GUIClipState.GetTopRect ();
+	}
+
+
+	CUSTOM_PROP static bool enabled
+		{ return GetGUIState().m_CanvasGUIState.m_GUIClipState.GetEnabled(); }
+
+
+	// Unclips /pos/ to physical device coordinates.
+	CSRAW static public Vector2 Unclip (Vector2 pos)
+	{
+		Unclip_Vector2(ref pos);
+		return pos;	
+	} 
+	
+	CUSTOM private static void Unclip_Vector2 (ref Vector2 pos)
+	{
+		pos = GetGUIState().m_CanvasGUIState.m_GUIClipState.Unclip (pos);
+	}
+
+	// The topmost physical rect in unclipped coordinates
+	// Used in editor to clip cursor rects inside scrollviews
+	CUSTOM_PROP static Rect topmostRect
+		{ return GetGUIState().m_CanvasGUIState.m_GUIClipState.GetTopMostPhysicalRect (); }
+
+
+	// Unclips /rect/ to physical device coordinates.
+	CSRAW public static Rect Unclip (Rect rect)
+	{
+		Unclip_Rect(ref rect);
+		return rect;	
+	} 
+	CUSTOM private static void Unclip_Rect (ref Rect rect)
+	{
+		rect = GetGUIState().m_CanvasGUIState.m_GUIClipState.Unclip(rect);
+	}
+
+	// Clips /absolutePos/ to drawing coordinates
+	CSRAW static public Vector2 Clip (Vector2 absolutePos)
+	{
+		Clip_Vector2 (ref absolutePos);
+		return absolutePos;
+	}
+	
+	CUSTOM private static void Clip_Vector2 (ref Vector2 absolutePos)
+	{
+		absolutePos = GetGUIState().m_CanvasGUIState.m_GUIClipState.Clip(absolutePos);
+	}
+
+	// Convert /absoluteRect/ to drawing coordinates
+	CSRAW static public Rect Clip (Rect absoluteRect)
+	{
+		Internal_Clip_Rect (ref absoluteRect);
+		return absoluteRect;
+	}
+	
+	CUSTOM static private void Internal_Clip_Rect (ref Rect absoluteRect)
+	{
+		absoluteRect = GetGUIState().m_CanvasGUIState.m_GUIClipState.Clip (absoluteRect);
+	}
+
+	// Reapply the clipping info.
+	CUSTOM internal static void Reapply ()
+	{
+		GetGUIState().m_CanvasGUIState.m_GUIClipState.Reapply (IMGUI::GetCurrentEvent(GetGUIState()));
+	}
+
+	// Set the GUIMatrix. This is here as this class handles all coordinate transforms anyways.
+	CUSTOM internal static Matrix4x4 GetMatrix()
+	{ 
+		return GetGUIState().m_CanvasGUIState.m_GUIClipState.GetMatrix(); 
+	}
+	
+	CUSTOM internal static void SetMatrix (Matrix4x4 m)
+	{
+		GetGUIState().m_CanvasGUIState.m_GUIClipState.SetMatrix(IMGUI::GetCurrentEvent(GetGUIState()), m); 
+	}
+	
+	// The visible rectangle.
+	CUSTOM_PROP static Rect visibleRect
+		{ return GetGUIState().m_CanvasGUIState.m_GUIClipState.GetVisibleRect (); }
+	
+	CSRAW public static Vector2 GetAbsoluteMousePosition ()
+	{
+		Vector2 vec;
+		Internal_GetAbsoluteMousePosition(out vec);
+		return vec;
+	}
+	CUSTOM private static void Internal_GetAbsoluteMousePosition (out Vector2 output)
+	{
+		*output = GetGUIState().m_CanvasGUIState.m_GUIClipState.GetAbsoluteMousePosition();
+	}
+END
+
+CSRAW }