+Unity Runtime codeHEADmaster

1 files changed, 419 insertions, 0 deletions

diff --git a/Runtime/IMGUI/GUIClip.cpp b/Runtime/IMGUI/GUIClip.cpp
new file mode 100644
index 0000000..203c1e9
--- /dev/null
+++ b/Runtime/IMGUI/GUIClip.cpp
@@ -0,0 +1,419 @@
+#include "UnityPrefix.h"
+#include "Runtime/IMGUI/GUIClip.h"
+#include "Runtime/Graphics/ScreenManager.h"
+#include "Runtime/Camera/CameraUtil.h"
+#include "Runtime/IMGUI/GUIStyle.h"
+#include "Runtime/Graphics/RenderTexture.h"
+#include "Runtime/Camera/RenderManager.h"
+#include "Runtime/Math/Quaternion.h"
+
+static const float ko1 = -10000, ko2 = 10000, ko3= 0, ko4 = 0;
+
+GUIClipState::GUIClipState()
+{ 
+	m_Enabled = 0;
+}
+
+GUIClipState::~GUIClipState ()
+{
+}
+
+
+/// Push a clip rect to the stack with pixel offsets.
+/// This is the low-level function for doing clipping rectangles. Unless you're working with embedded
+/// temporary render buffers, this is most likely not what you want.
+/// /absoluteRect/ is the absolute device coordinates this element will be mapped to.
+/// /scrollOffset/ is a scrolling offset to apply.
+/// /renderOffset/ is the rendering offset of the absoluteRect from source to destination. Used to map from an on-screen rectangle to a 
+/// destination inside a render buffer.
+void GUIClipState::Push (InputEvent& event, const Rectf& screenRect, Vector2f scrollOffset, const Vector2f& renderOffset, bool resetOffset)
+{
+	if (m_GUIClips.empty())
+	{
+		ErrorString("GUIClip pushing empty stack not allowed.");
+		return;
+	}
+	
+	GUIClip& topmost = m_GUIClips.back ();
+	// build absolute offsets by adding parent's position & scroll to the screenRect's positions
+	float physicalxMin = screenRect.x + topmost.physicalRect.x + topmost.scrollOffset.x;
+	float physicalxMax = screenRect.GetXMax() + topmost.physicalRect.x + topmost.scrollOffset.x;
+	float physicalyMin = screenRect.y + topmost.physicalRect.y + topmost.scrollOffset.y;
+	float physicalyMax = screenRect.GetYMax() + topmost.physicalRect.y + topmost.scrollOffset.y;
+	
+	// If the user tries to push a GUIClip with an xMin that goes outside the parent's clipping, we cannot allow that
+	// so we move the xMin in and use scrollOffset to hide this.
+	if (physicalxMin < topmost.physicalRect.x)
+	{ 
+		scrollOffset.x += physicalxMin - topmost.physicalRect.x;
+		physicalxMin = topmost.physicalRect.x;
+	}
+	
+	// Clip top side (yMin) to the parent as well.
+	if (physicalyMin < topmost.physicalRect.y)
+	{
+		scrollOffset.y += physicalyMin - topmost.physicalRect.y;
+		physicalyMin = topmost.physicalRect.y;
+	}
+	
+	// Clip right side (xMax) as well.
+	if (physicalxMax > topmost.physicalRect.GetXMax())
+	{
+		physicalxMax = topmost.physicalRect.GetXMax();
+	}
+	
+	// Clip bottom side (yMax) as well.
+	if (physicalyMax > topmost.physicalRect.GetYMax())
+	{
+		physicalyMax = topmost.physicalRect.GetYMax();
+	}
+	
+	// if the new GUIClip is completely outside parent, sizes can get negative.
+	// We just make them be 0, so no rendering is performed.
+	if (physicalxMax <= physicalxMin)
+		physicalxMax = physicalxMin;
+	if (physicalyMax <= physicalyMin)
+		physicalyMax = physicalyMin;
+	
+	// Build the rect straight away
+	Rectf absoluteRect = MinMaxRect (physicalxMin, physicalyMin, physicalxMax, physicalyMax);
+	
+	if (!resetOffset)
+	{
+		// Maintian global render offset
+		m_GUIClips.push_back(GUIClip (screenRect, absoluteRect, scrollOffset, topmost.renderOffset + renderOffset, topmost.globalScrollOffset + scrollOffset));
+	}
+	else
+	{
+		// Maintian global scroll offset
+		m_GUIClips.push_back (GUIClip (screenRect, absoluteRect, scrollOffset, 
+									 Vector2f(absoluteRect.x + scrollOffset.x + renderOffset.x, absoluteRect.y + scrollOffset.y + renderOffset.y),
+									 topmost.globalScrollOffset + scrollOffset));
+	}
+		
+	Apply(event, m_GUIClips.back());		
+}
+		
+/// Removes the topmost clipping rectangle, undoing the effect of the latest GUIClip.Push
+void GUIClipState::Pop (InputEvent& event)
+{
+	if (m_GUIClips.size() < 2)
+	{
+		ErrorString("Invalid GUIClip stack popping");
+		return;
+	}
+	
+	m_GUIClips.pop_back();
+	Apply(event, m_GUIClips.back());		
+}
+	
+Vector2f GUIClipState::Unclip (const Vector2f& pos)
+{
+	if (!m_GUIClips.empty())
+	{
+		GUIClip& topmost = m_GUIClips.back();
+		Vector3f res; 
+		m_Matrix.PerspectiveMultiplyPoint3 (Vector3f (pos.x, pos.y, 0.0F), res);
+		return Vector2f(res.x, res.y) + topmost.scrollOffset + Vector2f (topmost.physicalRect.x, topmost.physicalRect.y);
+	}
+	else
+	{
+		return Vector2f (0,0);
+	}
+}
+
+Rectf GUIClipState::Unclip (const Rectf& rect)
+{
+	if (!m_GUIClips.empty())
+	{
+		GUIClip& topmost = m_GUIClips.back();
+
+		return Rectf (rect.x + topmost.scrollOffset.x + topmost.physicalRect.x,
+		              rect.y + topmost.scrollOffset.y + topmost.physicalRect.y,
+					  rect.width, rect.height);
+	}
+	else
+	{
+		return Rectf (0,0,0,0);
+	}
+}
+	
+/// Clips /absolutePos/ to drawing coordinates
+/// Used for reconverting values calculated from ::ref::Unclip
+Vector2f GUIClipState::Clip (const Vector2f& absolutePos)
+{
+	if (!m_GUIClips.empty())
+	{
+		GUIClip& topmost = m_GUIClips.back();
+		
+		Vector3f transformedPoint;
+		m_InverseMatrix.PerspectiveMultiplyPoint3(Vector3f(absolutePos.x, absolutePos.y, 0.0F), transformedPoint);
+		
+		//	return (Vector2)s_InverseMatrix.MultiplyPoint (absolutePos) - topmost.globalScrollOffset - new Vector2 (topmost.physicalRect.x, topmost.physicalRect.y);
+		Vector2f res = Vector2f(transformedPoint.x, transformedPoint.y) - topmost.scrollOffset - Vector2f (topmost.physicalRect.x, topmost.physicalRect.y);		
+		return Vector2f(res.x, res.y);
+	}
+	else
+	{
+		return Vector2f (0,0);
+	}
+}
+
+/// Convert /absoluteRect/ to drawing coordinates
+/// Used for reconverting values calculated from ::ref::Unclip
+Rectf GUIClipState::Clip (const Rectf& absoluteRect)
+{
+	if (!m_GUIClips.empty())
+	{
+		GUIClip& topmost = m_GUIClips.back();
+		
+		return Rectf (absoluteRect.x - topmost.globalScrollOffset.x - topmost.physicalRect.x,
+					  absoluteRect.y - topmost.globalScrollOffset.y - topmost.physicalRect.y,
+					  absoluteRect.width, absoluteRect.height);
+	}
+	else
+	{
+		return Rectf (0,0,0,0);
+	}
+}
+
+// Return the rect for the topmost clip in screen space
+Rectf GUIClipState::GetTopRect ()
+{
+	if (!m_GUIClips.empty())
+	{
+		GUIClip& topmost = m_GUIClips.back();
+		return topmost.screenRect;
+	}
+	else
+	{
+		return Rectf (0,0,0,0);
+	}
+}
+
+
+/// Reapply the clipping info.
+/// Call this after switching render buffers.
+void GUIClipState::Reapply (InputEvent& event)
+{
+	if (!m_GUIClips.empty())
+		Apply (event, m_GUIClips.back());
+}
+
+
+void GUIClipState::SetMatrix (InputEvent& event, const Matrix4x4f& m)
+{ 
+	m_Matrix = m;
+	
+	Matrix4x4f inverse;
+	bool success = Matrix4x4f::Invert_Full(m, inverse);
+	if (!success)
+	{
+		ErrorString ("Ignoring invalid matrix assinged to GUI.matrix - the matrix needs to be invertible. Did you scale by 0 on Z-axis?");
+		return;
+	}
+	
+	m_Matrix = m;	// Store the value
+	m_InverseMatrix = inverse;
+	Reapply (event);		// Reapply the toplevel cliprect.
+}
+
+/// constructor
+GUIClip::GUIClip (const Rectf& iscreenRect, const Rectf& iphysicalRect, const Vector2f& iscrollOffset, const Vector2f& irenderOffset, const Vector2f& iglobalScrollOffset)
+{
+	//		Debug.Log ("GUIClipping: " + physicalRect + scrollOffset + renderOffset + globalScrollOffset);
+	
+	screenRect = iscreenRect;
+	physicalRect = iphysicalRect;
+	scrollOffset = iscrollOffset;
+	renderOffset = irenderOffset;
+	globalScrollOffset = iglobalScrollOffset;
+}
+
+// Recalculate the mouse values from the absolute screen position into local GUI coordinates, taking cliprects & all into account.
+void GUIClipState::CalculateMouseValues (InputEvent& event)
+{
+	if (!m_GUIClips.empty())
+	{
+#if ENABLE_NEW_EVENT_SYSTEM
+		event.touch.pos = Clip (m_AbsoluteMousePosition);
+#else
+		event.mousePosition = Clip (m_AbsoluteMousePosition);
+#endif
+		
+		// Check if we're outside the cliprect & set the event ignore flag
+		Vector3f res;
+		m_InverseMatrix.PerspectiveMultiplyPoint3 (Vector3f(m_AbsoluteMousePosition.x, m_AbsoluteMousePosition.y, 0.0F), res);
+
+		GUIClip& topmost = m_GUIClips.back();
+		m_Enabled = topmost.physicalRect.Contains (res.x, res.y) ? -1 : 0;
+		
+		// scrollwheel is a specialcase
+		if (event.type != InputEvent::kScrollWheel)
+		{
+#if ENABLE_NEW_EVENT_SYSTEM
+			event.touch.deltaPos = event.touch.pos - Clip (m_AbsoluteLastMousePosition);
+#else
+			event.delta = event.mousePosition - Clip (m_AbsoluteLastMousePosition);
+#endif
+		}
+	}
+}
+
+/// Apply the current clip rect to OpenGL's viewport & scissor rects.
+void GUIClipState::Apply (InputEvent& event, GUIClip &topmost)
+{
+	// Warp the current event to the correct place in the new coordinate space
+	
+	CalculateMouseValues (event);
+
+	m_VisibleRect = Rectf (-topmost.scrollOffset.x, -topmost.scrollOffset.y, topmost.physicalRect.width, topmost.physicalRect.height);
+
+	// From here on out, we're only setting up OpenGL, so abort if we're not repainting
+	if (event.type != InputEvent::kRepaint)
+		return;
+	
+	// Calculate the viewport (where we end up on screen)
+	Rectf r = topmost.physicalRect;
+	
+	if (r.width < 0) r.width = 0;
+	if (r.height < 0) r.height = 0;
+	
+	r.x -= topmost.renderOffset.x;
+	r.y -= topmost.renderOffset.y;
+	
+	
+	r.x = RoundfToInt(r.x);
+	r.y = RoundfToInt (r.y);
+	r.width = RoundfToIntPos (r.width);
+	r.height = RoundfToIntPos (r.height);
+	
+	Matrix4x4f viewportMatrix;
+	viewportMatrix.SetIdentity();
+	
+	float width, height;
+	RenderTexture *rTex = RenderTexture::GetActive ();
+	if (rTex)
+	{
+		width = rTex->GetWidth ();
+		height = rTex->GetHeight ();
+	}
+	else
+	{
+		width = GetScreenManager ().GetWidth ();
+		height = GetScreenManager ().GetHeight (); 
+	}
+		
+	Vector3f scaleFac = Vector3f (r.width / width, r.height / height,1);
+	Vector3f move;
+	m_Matrix.PerspectiveMultiplyPoint3 (Vector3f (r.x, r.y,0), move);
+	
+	///@TODO: OPTIMIZE non rotation
+	viewportMatrix.SetTRS(Vector3f(move.x * scaleFac.x, move.y * scaleFac.y, 0.0F), Quaternionf::identity(), scaleFac);
+	
+	SetGLViewport (Rectf (0,0, width, height));
+	
+	// The ortho bounds passed to LoadPixelMatrix gets multiplied by the matrix as well
+	// We need to counter that for the scroll offsets - so stuff like scale doesn't apply to scrolling
+	Vector3f sOffset;
+	m_Matrix.PerspectiveMultiplyPoint3 (Vector3f(-topmost.scrollOffset.x, -topmost.scrollOffset.y, 0.0F), sOffset);
+	sOffset.x *= scaleFac.x;
+	sOffset.y *= scaleFac.y;
+	
+	// Scale X & Y
+	// Upload the client coordinate system.
+	// Here we multiply in the scaleFac on the scrollOffsets - its something with Matrix ordering - a case of "iterative debugging": I kept chanigng it (at random) until it worked...
+	Matrix4x4f pixelMatrix;
+	MultiplyMatrices4x4 (&viewportMatrix, &m_Matrix, &pixelMatrix);
+	LoadPixelMatrix(
+					sOffset.x, Roundf (topmost.physicalRect.width) + sOffset.x, 
+					Roundf (topmost.physicalRect.height) + sOffset.y, sOffset.y,
+					pixelMatrix
+					);
+	GUIStyle::SetGUIClipRect(m_VisibleRect);
+}
+
+/// Load the pixel matrix and also multiply in a GUIMatrix
+void GUIClipState::LoadPixelMatrix(float left, float right, float bottom, float top, const Matrix4x4f& mat)
+{
+	Rectf rect( left, bottom, right-left, top-bottom );
+	Matrix4x4f matrix;
+	CalcPixelMatrix (rect, matrix);
+	
+	// Important: apply half-texel offsets after multiplying the matrix!
+	matrix *= mat;
+	ApplyTexelOffsetsToPixelMatrix( true, matrix );
+	
+	GfxDevice& device = GetGfxDevice();
+	device.SetProjectionMatrix(matrix);
+	device.SetViewMatrix (Matrix4x4f::identity.GetPtr()); // implicitly sets world to identity
+}
+
+Rectf GUIClipState::GetTopMostPhysicalRect ()
+{
+	return m_GUIClips.back().physicalRect;
+}
+
+//////@TODO:
+//	CSRAW public override string ToString () {
+//		return System.String.Format ("GUIClip: physicalRect {0}, scrollOffset {1}, renderOffset {2}, globalScrollOffset{3}", physicalRect, scrollOffset, renderOffset, globalScrollOffset);
+//	}
+
+/// Set up the clip rect to contain the entire display.
+/// called by GUI.Begin to initialize the view.
+void GUIClipState::BeginOnGUI (InputEvent& event)
+{	
+#if ENABLE_NEW_EVENT_SYSTEM
+	m_AbsoluteMousePosition = event.touch.pos;
+	m_AbsoluteLastMousePosition = m_AbsoluteMousePosition - event.touch.deltaPos;
+#else
+	m_AbsoluteMousePosition = event.mousePosition;
+	m_AbsoluteLastMousePosition = m_AbsoluteMousePosition - event.delta;
+#endif
+	m_Matrix.SetIdentity();
+	m_InverseMatrix.SetIdentity();
+	
+	m_GUIClips.resize (0);
+	// Push in a really large screen, so GUI.matrix scales doesn't crop the root level.
+	m_GUIClips.push_back (GUIClip (Rectf (ko1, ko1, 40000,40000), Rectf (ko1, ko1, 40000,40000), Vector2f (ko2, ko2), Vector2f (ko3,ko3), Vector2f (ko4,ko4)));
+	
+	Apply (event, m_GUIClips.back());
+}
+
+void GUIClipState::SetAbsoluteMousePosition (const Vector2f& val)
+{
+	m_AbsoluteMousePosition = val;
+}
+
+/// *End the current GUI stuff.
+void GUIClipState::EndOnGUI (InputEvent &event)
+{
+	InputEvent::Type eventType = event.type;
+	if (m_GUIClips.size() != 1 && eventType != InputEvent::kIgnore && eventType != InputEvent::kUsed)
+	{
+		if (m_GUIClips.size() > 1)
+		{
+			ErrorString ("GUI Error: You are pushing more GUIClips than you are popping. Make sure they are balanced)");
+		}
+		else
+		{
+			ErrorString ("GUI Error: You are popping more GUIClips than you are pushing. Make sure they are balanced)");
+			return;	
+		}
+	}
+	m_GUIClips.pop_back();
+	// Make sure we restore the mouse values. Otherwise things like GUi.Matrix's modifications to 
+	// MouseEvents will seep into the next OnGUI
+#if ENABLE_NEW_EVENT_SYSTEM
+	event.touch.deltaPos = m_AbsoluteMousePosition - m_AbsoluteLastMousePosition;
+	event.touch.pos = m_AbsoluteMousePosition;
+#else
+	event.delta = m_AbsoluteMousePosition - m_AbsoluteLastMousePosition;
+	event.mousePosition = m_AbsoluteMousePosition;
+#endif
+}
+
+void GUIClipState::EndThroughException ()
+{
+	m_GUIClips.resize(0);
+}