path: root/Runtime/IMGUI/GUIStyle.cpp

#include "UnityPrefix.h"
#include "Runtime/IMGUI/GUIStyle.h"
#include "Runtime/Camera/RenderLayers/GUITexture.h"
#include "Runtime/Filters/Misc/Font.h"
#include "TextMeshGenerator2.h"
#include "Runtime/GfxDevice/GfxDevice.h"
#include "External/shaderlab/Library/FastPropertyName.h"
#include "Runtime/Shaders/Material.h"
#include "Runtime/Misc/ResourceManager.h"
#include "External/shaderlab/Library/properties.h"
#include "Runtime/Graphics/GeneratedTextures.h"
#include "External/shaderlab/Library/FastPropertyName.h"
#include "Runtime/Graphics/TextureGenerator.h"
#include "External/shaderlab/Library/texenv.h"
#include "Runtime/Shaders/Shader.h"
#include "External/shaderlab/Library/intshader.h"
#include "Runtime/IMGUI/GUIState.h"
#include "Runtime/IMGUI/GUIContent.h"
#include "Runtime/IMGUI/IMGUIUtils.h"
#include "Runtime/IMGUI/GUIManager.h"
#include "Runtime/Misc/BuildSettings.h"
#include "Runtime/Misc/AssetBundle.h"

#if UNITY_EDITOR
#include "Editor/Src/AssetPipeline/AssetDatabase.h"
#include "Editor/Src/OptimizedGUIBlock.h"
#include "Editor/Src/TooltipManager.h"
#include "Editor/Src/Highlighter/HighlighterCore.h"
#include "Editor/Src/EditorResources.h"
#include "Editor/Src/EditorHelper.h"
#endif

const float s_TabSize = 16;
using namespace std;
static Rectf s_GUIClipRect (0,0,1,1);

namespace GUIStyle_Static
{
	PPtr<Font> s_DefaultFont = NULL, s_BuiltinFont = NULL;
} // namespace GUIStyle_Static

// if these are set to 0 icons scale to fit the text
float s_GUIStyleIconSizeX = 0;
float s_GUIStyleIconSizeY = 0;


// A minimal (4x4) texture is not enough because of limited subtexel precision on some cards.
// With large clipping rectangles, one texel in clipping texture can span lots of pixels on screen,
// and because of limited precision there can be one pixel errors.
// E.g. Radeon HD 3850 seems to need at least 16x16 texture.
const float kGUIClipTextureSize = 16.0f;

static Material *kGUITextMaterial = NULL;
static Material *kBlendMaterial = NULL;
static Material *kBlitMaterial = NULL;

inline void GUIClipTexture (Texture2D *tex, unsigned char *data, int x, int y, int maxX, int maxY) 
{
	if (x == 0 || y == 0 || x == maxX - 1 || y == maxY - 1) 
		*data = 0;
	else
		*data = 255;
}

static Texture2D *gGUIClipTexture = NULL;

Texture2D *GUIStyle::GetClipTexture ()
{
	return gGUIClipTexture;
}

void InitializeGUIClipTexture () 
{
	if (gGUIClipTexture)
		return;
	
	gGUIClipTexture = BuildTexture <unsigned char> (int(kGUIClipTextureSize), int(kGUIClipTextureSize), kTexFormatAlpha8, &GUIClipTexture);
	gGUIClipTexture->SetFilterMode (kTexFilterNearest);
	gGUIClipTexture->SetWrapMode(kTexWrapClamp);
	ShaderLab::PropertySheet *props = ShaderLab::g_GlobalProperties;
	ShaderLab::TexEnv *te = props->SetTexture (ShaderLab::Property ("_GUIClipTexture"),gGUIClipTexture);
	te->SetMatrixName (ShaderLab::Property("_GUIClipTextureMatrix"));
	te->SetTexGen (kTexGenEyeLinear);
}

Material* GetGUIBlitMaterial ()
{
	if (!kBlitMaterial) 
	{
		Shader* shader = GetBuiltinResource<Shader> ("Internal-GUITextureBlit.shader");
		kBlitMaterial = Material::CreateMaterial (*shader, Object::kHideAndDontSave);
		InitializeGUIClipTexture();
	}
	
	return kBlitMaterial;
}

Material* GetGUIBlendMaterial ()
{
	if (!kBlendMaterial) 
	{
		Shader* shader = GetBuiltinResource<Shader> ("Internal-GUITextureClip.shader");
		kBlendMaterial = Material::CreateMaterial (*shader, Object::kHideAndDontSave);
		InitializeGUIClipTexture();
	}
	
	return kBlendMaterial;
}

static Material* GetGUITextMaterial () 
{
	if (!kGUITextMaterial) 
	{
		Shader* shader = GetBuiltinResource<Shader> ("Internal-GUITextureClipText.shader");
		kGUITextMaterial = Material::CreateMaterial(*shader, Object::kHideAndDontSave);
		InitializeGUIClipTexture();
	}
	
	return kGUITextMaterial;
}

GUIStyle::GUIStyle()
{
	m_Alignment = 0;
	m_RichText = true;
	m_WordWrap = 0;
	m_Clipping = 0;
	m_ImagePosition = 0;
	m_ContentOffset = Vector2f(0.0f, 0.0f);
	m_ClipOffset = Vector2f(0.0f, 0.0f);
	m_FixedWidth = 0;
	m_FixedHeight = 0;
	m_FontSize = 0;
	m_FontStyle = 0;
	m_StretchWidth = true;
	m_StretchHeight = false;
	
}

GUIStyle::GUIStyle (const GUIStyle &other)
{
	m_Name = other.m_Name;
	m_Normal = other.m_Normal;
	m_Hover = other.m_Hover;
	m_Active = other.m_Active;
	m_Focused = other.m_Focused;
	m_OnNormal = other.m_OnNormal;
	m_OnHover = other.m_OnHover;
	m_OnActive = other.m_OnActive;
	m_OnFocused = other.m_OnFocused;
	m_Border = other.m_Border;
	m_Margin = other.m_Margin;
	m_Padding = other.m_Padding;
	m_Overflow = other.m_Overflow;
	m_Font = other.m_Font;
	m_Alignment = other.m_Alignment;
	m_RichText = other.m_RichText;
	m_WordWrap = other.m_WordWrap;
	m_Clipping = other.m_Clipping;
	m_ImagePosition = other.m_ImagePosition;
	m_ContentOffset = other.m_ContentOffset;
	m_ClipOffset = other.m_ClipOffset;
	m_FixedWidth = other.m_FixedWidth;
	m_FixedHeight = other.m_FixedHeight;
	m_FontSize = other.m_FontSize;
	m_FontStyle = other.m_FontStyle;
	m_StretchWidth = other.m_StretchWidth;
	m_StretchHeight = other.m_StretchHeight;
}


void GUIStyle::SetDefaultFont (Font *font) 
{
	using namespace GUIStyle_Static;
	if (font != NULL)
		s_DefaultFont = font;
	else 
		s_DefaultFont = GetBuiltinResource<Font> (kDefaultFontName);
}
Font*GUIStyle::GetDefaultFont ()
{
	return GUIStyle_Static::s_DefaultFont;
}

void GUIStyle::Draw (GUIState &state, const Rectf &screenRect, GUIContent &content, int controlID, bool on) const 
{
	InputEvent &evt (*state.m_CurrentEvent);
	int hot = IMGUI::GetHotControl (state);	
	bool enabled = state.m_OnGUIState.m_Enabled;
#if ENABLE_NEW_EVENT_SYSTEM
	bool mouseOver = screenRect.Contains (evt.touch.pos);
#else
	bool mouseOver = screenRect.Contains (evt.mousePosition);
#endif
	bool isHover = mouseOver && state.m_CanvasGUIState.m_GUIClipState.GetEnabled();
	bool isHover2 = isHover && (hot == controlID || hot == 0);
	
	if (isHover) 
		state.m_CanvasGUIState.m_IsMouseUsed = true;
	
	bool isActive = (controlID == hot) && enabled && mouseOver;
	bool hasKey = state.m_MultiFrameGUIState.m_KeyboardControl == controlID && enabled && state.m_OnGUIState.m_ShowKeyboardControl;
	
	Draw (state, screenRect, content, isHover2, isActive, on, hasKey);	
	
	
	//	#if UNITY_GUI_SUPPORT_TOOLTIP
	if (content.m_Tooltip.text != NULL && content.m_Tooltip.length != 0)
	{
		if (isHover || isActive || hot == controlID)
		{
			SetMouseTooltip (state, content.m_Tooltip, screenRect);
		}
		if (hasKey)
			state.m_OnGUIState.SetKeyTooltip (content.m_Tooltip);
	}
	//	#endif 
}

void GUIStyle::SetMouseTooltip (GUIState& state, const UTF16String& tooltip, const Rectf& screenRect)
{
	state.m_OnGUIState.SetMouseTooltip (tooltip);
#if UNITY_EDITOR
	Vector2f v = GetGUIManager().GetGUIPixelOffset();
	v += state.m_CanvasGUIState.m_GUIClipState.Unclip (Vector2f (screenRect.x, screenRect.y));
	GetTooltipManager().SetTooltip (tooltip, Rectf (v.x, v.y, screenRect.width, screenRect.height));
#endif
	
}


void GUIStyle::Draw (GUIState &state, const Rectf &screenRect, GUIContent &content, bool isHover, bool isActive, bool on, bool hasKeyboardFocus) const
{
	#if UNITY_EDITOR
	if (HighlighterCore::s_SearchMode == kHighlightByContent || HighlighterCore::s_SearchMode == kHighlightAuto)
		HighlighterCore::Handle (state, screenRect, content.m_Text);
	#endif

	// always draw of pixel coordinates
	Rectf rounded = ClampRect (screenRect);
	float right = Roundf (rounded.x + rounded.width);
	float bottom = Roundf (rounded.y + rounded.height);
	rounded.x = Roundf(rounded.x);
	rounded.y = Roundf(rounded.y);
	rounded.width = right - rounded.x;
	rounded.height = bottom - rounded.y;
	
	Rectf visibleRect = state.m_CanvasGUIState.m_GUIClipState.GetVisibleRect();
	
	if (bottom < visibleRect.y || rounded.y > visibleRect.GetBottom())
		return;
	
	isHover = state.m_EternalGUIState->m_AllowHover && isHover;
	const GUIStyleState *gss = GetGUIStyleState (state, isHover, isActive, on, hasKeyboardFocus);
	DrawBackground (state, rounded, gss);
	DrawContent (state, rounded, content, gss);
}

void GUIStyle::DrawWithTextSelection (GUIState &state, const Rectf &screenRect, GUIContent &content, bool isHover, bool isActive, bool on, bool hasKeyboardFocus, bool drawSelectionAsComposition, int cursorFirst, int cursorLast, const ColorRGBAf &cursorColor, const ColorRGBAf &selectionColor) const {
	// always draw of pixel coordinates
	Rectf rounded = ClampRect (screenRect);
	rounded.x = Roundf(rounded.x);
	rounded.y = Roundf(rounded.y);
	rounded.width = Roundf(rounded.width);
	rounded.height = Roundf(rounded.height);
	
	const GUIStyleState *gss = GetGUIStyleState (state, isHover, isActive, on, hasKeyboardFocus);
	DrawBackground (state, rounded, gss);
	if (hasKeyboardFocus)
	{
		if (drawSelectionAsComposition)
		{
			DrawTextUnderline (state, rounded, content, cursorFirst, cursorLast, gss);
			// draw cursor.
			DrawTextSelection (state, rounded, content, cursorLast, cursorLast, cursorColor, selectionColor);
		}
		else
			DrawTextSelection (state, rounded, content, cursorFirst, cursorLast, cursorColor, selectionColor);
	}
	DrawContent (state, rounded, content, gss);
}

void GUIStyle::CalcMinMaxWidth (GUIContent &content, float *minWidth, float *maxWidth) const {
	// If we have a fixed width, that becoms both min and max
	if (m_FixedWidth != 0) {
		*minWidth = *maxWidth = m_FixedWidth;
		return;
	}
	
	TextMeshGenerator2 &tmgen = TextMeshGenerator2::Get (content.m_Text, &GetCurrentFont(), (TextAnchor)m_Alignment, kAuto, 0, s_TabSize, 1.0f, m_RichText, true, ColorRGBA32(0xffffffff), m_Font ? m_FontSize : 0, m_Font ? m_FontStyle : 0);
	Vector2f size = tmgen.GetSize ();
	// If we're word wrapping, we'll never go below 32 pixels.
	// Ideally, we should get the size of the largest word, but that is just too painful.
	*maxWidth = size.x;
	if (m_WordWrap)
		*minWidth = min (32.0f, size.x);
	else
		*minWidth = size.x;
	
	if (content.m_Image) {
		float iWidth = content.m_Image->GetDataWidth();
		switch (m_ImagePosition) {
			case kImageLeft:
				*minWidth += iWidth;
				*maxWidth += iWidth;
				break;
			case kImageOnly:
				*minWidth = *maxWidth = iWidth;
				break;
			case kImageAbove:
				*minWidth = max (iWidth, *minWidth);
				*maxWidth = max (iWidth, *maxWidth);
				break;
			case kTextOnly:
				break;
		}
	}
	
	*minWidth += m_Padding.left + m_Padding.right;
	*maxWidth += m_Padding.left + m_Padding.right;
}

Vector2f GUIStyle::GetCursorPixelPosition (const Rectf &screenRect, GUIContent &content, int cursorStringIndex) const {
	TextMeshGenerator2 *tmgen = GetGenerator (screenRect, content);
	if (tmgen)
		return tmgen->GetCursorPosition(m_Padding.Remove (screenRect), cursorStringIndex) + (m_ContentOffset + m_ClipOffset);
	else
		return Vector2f (0,0);
}

int GUIStyle::GetCursorStringIndex  (const Rectf &screenRect, GUIContent &content, const Vector2f &cursorPixelPosition) const {
	TextMeshGenerator2 *tmgen = GetGenerator (screenRect, content);
	if (tmgen)
		return tmgen->GetCursorIndexAtPosition(m_Padding.Remove (screenRect), cursorPixelPosition - (m_ContentOffset + m_ClipOffset));
	return 0;
}

Font& GUIStyle::GetCurrentFont () const
{
	using namespace GUIStyle_Static;
	Font* thisFont = m_Font;
	if (thisFont != NULL)
		return *thisFont;
	
	Font* defaultFont = s_DefaultFont;
	if (defaultFont != NULL)
		return *defaultFont;
	
	return GetBuiltinFont ();
}

Font &GUIStyle::GetBuiltinFont ()
{
	Font* builtinFont = GUIStyle_Static::s_BuiltinFont;
	if (builtinFont != NULL)
		return *builtinFont;
	
	GUIStyle_Static::s_BuiltinFont = builtinFont = GetBuiltinResource<Font> (kDefaultFontName);
	if (builtinFont == NULL)
	{
		LogString ("Couldn't load default font or font material!");
	}
	
	return *builtinFont;
}

float GUIStyle::GetLineHeight () const {
	Font& f = GetCurrentFont();
	return f.GetLineSpacing (m_FontSize);
}

int GUIStyle::GetNumCharactersThatFitWithinWidth (const UTF16String &text, float width) const
{
	Font &f = GetCurrentFont();
	
	// Call before GetCharacterWidth to ensure character data has been setup
	f.CacheFontForText (text.text, text.length);

	width -= m_Padding.left + m_Padding.right;
	
	float currentWidth = 0;
	unsigned stringlen = text.length;
	int numChars = stringlen;
	for (int i=0; i<stringlen; i++)
	{
		int c = text[i];
		float characterWidth = f.GetCharacterWidth (c, m_FontSize, m_FontStyle);
		if (characterWidth == 0.f)
		{
			return -1; // failed to get character width
		}

		currentWidth += characterWidth;
		if (currentWidth > width)
		{
			numChars = i;
			break;
		}
	}

	return numChars;
}

float GUIStyle::CalcHeight (GUIContent &content, float width) const {
	if (m_FixedHeight != 0.0f)
		return m_FixedHeight;
	
	Vector2f imageSize (0,0), textSize (0,0);
	Texture *image = content.m_Image;
	if (image != NULL) 
		imageSize = Vector2f (image->GetDataWidth(), image->GetDataHeight());
	
	float contentHeight = 0;
	
	TextMeshGenerator2 *tmgen = GetGenerator (Rectf (0,0,width, 1000), content);
	if (tmgen)
		textSize = tmgen->GetSize ();
	switch (m_ImagePosition) {
		case kImageLeft: {
			contentHeight = max (textSize.y, imageSize.y);
			break;
		}
		case kImageAbove: {
			contentHeight = textSize.y + imageSize.y;
			break;
		}
		case kImageOnly:
			contentHeight = imageSize.y;
			break;
		case kTextOnly: {
			contentHeight = textSize.y;
			break;
		}
	}
	
	return contentHeight + m_Padding.top + m_Padding.bottom;
}

Vector2f GUIStyle::CalcSize (GUIContent &content) const {
	Texture *image = content.m_Image;
	
	if (m_FixedHeight != 0.0f && m_FixedWidth != 0.0f)
		return Vector2f (m_FixedWidth, m_FixedHeight);
	
	Vector2f textSize (0,0), imageSize (0,0);
	if (content.m_Text.length != 0 && m_ImagePosition != kImageOnly) 
		textSize = GetGenerator(Rectf (0,0,0,0), content)->GetSize ();
	if (image != NULL && m_ImagePosition != kTextOnly) 
		imageSize = Vector2f (image->GetDataWidth(), image->GetDataHeight());
	
	Vector2f size (0,0);
	switch (m_ImagePosition) {
		case kImageLeft:
			if (imageSize.x > 0) 
			{
				if ((s_GUIStyleIconSizeX != 0) && (s_GUIStyleIconSizeY != 0))
				{
					imageSize.x = s_GUIStyleIconSizeX;
					imageSize.y = s_GUIStyleIconSizeY;
				}
			}
			size = Vector2f (textSize.x + imageSize.x, max (textSize.y, imageSize.y));
			break;
		case kImageAbove:
			size = Vector2f (max (textSize.x, imageSize.x), textSize.y + imageSize.y);
			break;
		case kImageOnly:
			size = imageSize;
			break;
		case kTextOnly:
			size = textSize;
			break;
	}
	
	// If we 
	if (content.m_Text.length == 0 && image == NULL && m_ImagePosition != kImageOnly)
	{
		size.y = GetCurrentFont().GetLineSpacing(m_FontSize);
	}
	size+= m_Padding.Size ();
	if (m_FixedWidth != 0.0f)
		size.x = m_FixedWidth;
	if (m_FixedHeight != 0.0f)
		size.y = m_FixedHeight;
	return size;
}

const GUIStyleState *GUIStyle::GetGUIStyleState (GUIState &state, bool isHover, bool isActive, bool on, bool hasKeyboardFocus) const
{
	const GUIStyleState *t = NULL;
	if (!on) {
		// If the GUI is disabled, return the normal style
		if (isHover)
			t = m_Hover.background ? &m_Hover : t;
		if (hasKeyboardFocus)
			t = m_Focused.background ? &m_Focused : (m_Hover.background ? &m_Hover : t);
		if (isActive && isHover)
			t = m_Active.background ? &m_Active : t;
		if (!state.m_OnGUIState.m_Enabled) 
			t = &m_Normal;
	} else {
		// If the GUI is disabled, return the normal style
		if (isHover)
			t = m_OnHover.background ? &m_OnHover : t;
		if (hasKeyboardFocus)
			t = m_OnFocused.background ? &m_OnFocused : (m_OnHover.background ? &m_OnHover : t);
		if (isActive && isHover)
			t = m_OnActive.background ? &m_OnActive : t;
		if (!state.m_OnGUIState.m_Enabled) 
			t = &m_Normal;
		
		if (t == NULL || !t->background || !state.m_OnGUIState.m_Enabled)
			t = &m_OnNormal;
	}
	
	if (t == NULL || !t->background)
		t = &m_Normal;
	return t;
}

static void DrawClippedTexture (const Rectf &screenRect, Texture *image, float leftBorder, float rightBorder, float topBorder, float bottomBorder, const ColorRGBAf &color)
{
	DrawGUITexture (screenRect, image, int(leftBorder), int(rightBorder), int(topBorder), int(bottomBorder), color, GetGUIBlendMaterial());
}


void GUIStyle::DrawBackground (GUIState &state, const Rectf &screenRect, const GUIStyleState *gss) const {
#if ENABLE_RETAINEDGUI	
	if (state.m_OnGUIState.m_CaptureBlock)
	{
		if (gss->background)
		{
			GUIVertexData* data = new GUIVertexData (&GUIVertexDataFormat::vtxPosColorUV0UV1);
			GUIUtils::BuildImage (m_Overflow.Add (screenRect), m_Border, gss->background, Vector4f(1.0f, 1.0f, 0.0f, 0.0f), *data);
			GUIClipRegion temp (state.m_CanvasGUIState.m_GUIClipState.GetVisibleRect());
			GUIUtils::BuildClipCoords (&temp, *data);
			
			ColorRGBAf backgroundColor = state.m_OnGUIState.m_Color * state.m_OnGUIState.m_BackgroundColor;
			if (!state.m_OnGUIState.m_Enabled)
				backgroundColor.a *= .5f;
			GUIUtils::BuildColor(backgroundColor, *data);
			
			state.m_OnGUIState.m_CaptureBlock->push_back (GUIGraphicsCacheBlock (data, GetGUIBlendMaterial()));
		}
		return;
	}
#endif
	
	Rectf visibleRect = state.m_CanvasGUIState.m_GUIClipState.GetVisibleRect();
	SetGUIClipRect(visibleRect);
	
	if (gss->background) {
		ColorRGBAf backgroundColor = state.m_OnGUIState.m_Color * state.m_OnGUIState.m_BackgroundColor;
		if (!state.m_OnGUIState.m_Enabled)
			backgroundColor *= ColorRGBAf (1,1,1,.5f);
		
#if UNITY_EDITOR
		OptimizedGUIBlock *block = GetCaptureGUIBlock ();
		if (block)
		{
			block->QueueBackground (m_Overflow.Add (screenRect), gss->background, m_Border, backgroundColor, state.m_CanvasGUIState.m_GUIClipState.GetVisibleRect());
			return;
		} 
#endif		
		
		DrawClippedTexture (m_Overflow.Add (screenRect), gss->background, m_Border.left, m_Border.right, m_Border.top, m_Border.bottom, backgroundColor);
	} 
}

void GUIStyle::RenderText (const Rectf &screenRect, TextMeshGenerator2 &tmgen, ColorRGBAf color) const {
	// Configure the shaders
	Font& currentFont = GetCurrentFont();
	
	Material *material = GetGUITextMaterial ();
	
	// now we set color using TextMeshGenerator vertices, rather then using the material, so set material color to white.
	if (IS_CONTENT_NEWER_OR_SAME(kUnityVersion4_2_a1))
		color = ColorRGBA32(0xffffffff);
	
	static SHADERPROP (Color);
	static SHADERPROP (MainTex);
	ShaderLab::PropertySheet& properties = material->GetWritableProperties();
	
	properties.SetVector(kSLPropColor, color.GetPtr());
	
	Texture* fontTexture = currentFont.GetTexture();
	
	// In the case when font is a custum font, GetTexture() will return NULL, so in this case take the main texture from font's material
	if (fontTexture == NULL && currentFont.GetMaterial())
	{
		fontTexture = currentFont.GetMaterial()->GetTexture(kSLPropMainTex);
	}
	
	properties.SetTexture(kSLPropMainTex, fontTexture);
	
	GfxDevice &device = GetGfxDevice ();
	
	float matWorld[16], matView[16];
	
	CopyMatrix(device.GetViewMatrix(), matView);
	CopyMatrix(device.GetWorldMatrix(), matWorld);
	
	Matrix4x4f textMatrix;
	
	Vector2f offset = tmgen.GetTextOffset (screenRect);
	
	textMatrix.SetTranslate (Vector3f (offset.x, offset.y, 0.0f));
	
	device.SetViewMatrix (textMatrix.GetPtr());
	
	int passCount = material->GetPassCount ();	
	for (int i=0;i < passCount ;i++)
	{
		const ChannelAssigns* channels = material->SetPass (i);
		tmgen.RenderRaw (*channels);
	}
	device.SetViewMatrix(matView);
	device.SetWorldMatrix(matWorld);
}

TextMeshGenerator2* GUIStyle::GetGenerator (const Rectf &screenRect, GUIContent &content, ColorRGBA32 color) const
{
	if (!IS_CONTENT_NEWER_OR_SAME(kUnityVersion4_2_a1))
		color = 0xffffffff;
	return IMGUI::GetGenerator (m_Padding.Remove (screenRect), content, GetCurrentFont(), (TextAnchor)m_Alignment, m_WordWrap, m_RichText, color, m_FontSize, m_FontStyle, (ImagePosition)m_ImagePosition);
}

TextMeshGenerator2* GUIStyle::GetGenerator (const Rectf &screenRect, GUIContent &content) const
{
	ColorRGBA32 color = 0xffffffff;
	if (IS_CONTENT_NEWER_OR_SAME(kUnityVersion4_2_a1))
	{
		GUIState &state = GetGUIState();
		ColorRGBAf imageColor = state.m_OnGUIState.m_Color * state.m_OnGUIState.m_ContentColor;
		ColorRGBAf textColor = m_Normal.textColor * imageColor;
		if (!state.m_OnGUIState.m_Enabled) {
			textColor.a *= .5f;
		}
		color = textColor;
	}
	return IMGUI::GetGenerator (m_Padding.Remove (screenRect), content, GetCurrentFont(), (TextAnchor)m_Alignment, m_WordWrap, m_RichText, color, m_FontSize, m_FontStyle, (ImagePosition)m_ImagePosition);
}


void GUIStyle::CalcContentRects (const Rectf &contentRect, Vector2f imageSize, Vector2f textSize, Rectf &imageRect, Rectf &textRect, float &width, float &height, int imagePosition, int alignment, Vector2f contentOffset)
{
	// Sum them up depending on contents layout.
	width = 0;
	height = 0;
	switch (imagePosition) {
		case kImageLeft:
			// Scale the image down if we need the room
			if (imageSize.x > 0) 
			{
				if ((s_GUIStyleIconSizeX == 0) || (s_GUIStyleIconSizeY == 0))
				{
					float imageScale = clamp (min ((contentRect.Width() - textSize.x) / imageSize.x, contentRect.Height() / imageSize.y), 0.0f, 1.0f);
					
					imageSize.x = Roundf (imageSize.x * imageScale);
					imageSize.y = Roundf (imageSize.y * imageScale);
				}
				else
				{
					imageSize.x = s_GUIStyleIconSizeX;
					imageSize.y = s_GUIStyleIconSizeY;
				}
			}
			
			width = imageSize.x + textSize.x;
			height = max (imageSize.y, textSize.y);
			break;
		case kImageAbove:
			// Scale the image down if we need the room
			if (imageSize.x > 0) 
			{
				if ((s_GUIStyleIconSizeX == 0) || (s_GUIStyleIconSizeY == 0))
				{
					float imageScale = clamp (min ((contentRect.Height() - textSize.y) / imageSize.y, contentRect.Width() / imageSize.x), 0.0f, 1.0f);
					imageSize.x = Roundf (imageSize.x * imageScale);
					imageSize.y = Roundf (imageSize.y * imageScale);
				}
				else
				{
					imageSize.x = s_GUIStyleIconSizeX;
					imageSize.y = s_GUIStyleIconSizeY;
				}
			}
			
			width = max (imageSize.x, textSize.x);
			height = imageSize.y + textSize.y;
			break;
		case kImageOnly:
			// Scale the image down if we need the room
			if (imageSize.x > 0) 
			{
				if ((s_GUIStyleIconSizeX == 0) || (s_GUIStyleIconSizeY == 0))
				{
					float imageScale = min (min (contentRect.Width() / imageSize.x, contentRect.Height() / imageSize.y), 1.0f);
					imageSize.x = Roundf (imageSize.x * imageScale);
					imageSize.y = Roundf (imageSize.y * imageScale);
				}
				else
				{
					imageSize.x = s_GUIStyleIconSizeX;
					imageSize.y = s_GUIStyleIconSizeY;
				}
			}
			
			width = imageSize.x;
			height = imageSize.y;
			break;
		case kTextOnly:
			width = textSize.x;
			height = textSize.y;
			break;
	}
	
	// We now have the combined sizes - need to know where to put them.
	float xAlign = 0, yAlign = 0;
	switch (alignment) {
		case kUpperLeft:
			xAlign = 0; yAlign = 0; break;
		case kUpperCenter:
			xAlign = .5f; yAlign = 0; break;
		case kUpperRight:
			xAlign = 1; yAlign = 0; break;
		case kMiddleLeft:	
			xAlign = 0; yAlign = .5f; break;
		case kMiddleCenter:
			xAlign = .5f; yAlign = .5f; break;
		case kMiddleRight:
			xAlign = 1; yAlign = .5f; break;
		case kLowerLeft:
			xAlign = 0; yAlign = 1; break;
		case kLowerCenter:
			xAlign = .5f; yAlign = 1; break;
		case kLowerRight:
			xAlign = 1; yAlign = 1; break;
	}
	// We need to round as centering the text can position it on half a pixel
	float x = Roundf (contentRect.x + (contentRect.width - width) * xAlign + contentOffset.x);
	float y = Roundf (contentRect.y + (contentRect.height - height) * yAlign + contentOffset.y);
	
	switch (imagePosition) {
		case kImageLeft:
			if (imageSize.x > 0.0f)
				imageRect = Rectf (x, y + (height - imageSize.y) * .5f, imageSize.x, imageSize.y);
			if (textSize.x > 0.0f && imageSize.x > 0.0f)
				textRect = Rectf (x + imageSize.x + 1, y + (height - textSize.y) * .5f, textSize.x, textSize.y);
			else if (textSize.x > 0.0f)
				textRect = Rectf (x, y + (height - textSize.y) * .5f, textSize.x, textSize.y);
			break;
		case kImageAbove:
			if (imageSize.x > 0.0f)
				imageRect = Rectf (Roundf (x + (width - imageSize.x) * .5f), y, imageSize.x, imageSize.y);
			if (textSize.x > 0.0f)
				textRect = Rectf (Roundf (x + (width - textSize.x) * .5f), y + imageSize.y, textSize.x, textSize.y);
			
			break;
		case kImageOnly:
			if (imageSize.x > 0.0f)
				imageRect = Rectf (Roundf (x + (width - imageSize.x) * .5f), y, imageSize.x, imageSize.y);
			break;
		case kTextOnly:
			if (textSize.x > 0.0f)
				textRect = Rectf (x, y, textSize.x, textSize.y);
			break;
	}
}

void GUIStyle::DrawContent (GUIState &state, const Rectf &screenRect, GUIContent &content, const GUIStyleState *gss) const 
{
	Vector2f textSize (0,0), imageSize (0,0);
	TextMeshGenerator2 *tmgen = NULL;
	
	// we now have the location of the contents in the rects. Now to draw it.
	// Setup the color
	ColorRGBAf imageColor = state.m_OnGUIState.m_Color * state.m_OnGUIState.m_ContentColor;
	ColorRGBAf textColor = gss->textColor * imageColor;
	if (!state.m_OnGUIState.m_Enabled) {
		textColor.a *= .5f;
		imageColor.a *= .5f;
	}

	if (m_ImagePosition != kImageOnly && content.m_Text.length != 0)
	{
		tmgen = GetGenerator (screenRect, content, textColor);
		textSize = tmgen->GetSize();
	}
	
	// TODO: If we use word wrapping and imageLeft we should somehow subtract the width...
	Texture *image = content.m_Image;
	if (image != NULL && m_ImagePosition != kTextOnly)
		imageSize = Vector2f (image->GetDataWidth(), image->GetDataHeight());	
	
	Rectf imageRect (0,0,0,0), textRect (0,0,0,0);
	float width, height;
	Rectf contentRect = m_Padding.Remove (screenRect);
	CalcContentRects (contentRect, imageSize, textSize, imageRect, textRect, width, height, m_ImagePosition, m_Alignment, m_ContentOffset);
	
#if ENABLE_RETAINEDGUI
	if (state.m_OnGUIState.m_CaptureBlock)
	{
		GUIVertexData* data = new GUIVertexData (&GUIVertexDataFormat::vtxPosColorUV0UV1);
		GUIUtils::BuildText(textRect, *tmgen, *data);
		
		GUIClipRegion temp (state.m_CanvasGUIState.m_GUIClipState.GetVisibleRect());
		GUIUtils::BuildClipCoords (&temp, *data);
		
		GUIUtils::BuildColor(textColor, *data);
		
		state.m_OnGUIState.m_CaptureBlock->push_back (GUIGraphicsCacheBlock (data, GetGUITextMaterial()));
		return;
	}
#endif
	// We know where the various components go, now we draw them (with lots of clipping shit)
	Rectf visibleRect = state.m_CanvasGUIState.m_GUIClipState.GetVisibleRect();
	
#if UNITY_EDITOR
	OptimizedGUIBlock *block = GetCaptureGUIBlock ();
	if (block)
	{
		Rectf newClipRect, clipRect = visibleRect;
		if (m_Clipping != kOverflow && (width > contentRect.width || height > contentRect.height)) 
		{
			newClipRect = contentRect;
			newClipRect.x += (m_ContentOffset.x + m_ClipOffset.x);
			newClipRect.y += (m_ContentOffset.y + m_ClipOffset.y);
			newClipRect.Clamp (clipRect);
		} else {
			newClipRect = clipRect;	
		}
		
		// Queue the text for later processing
		if (textRect.width != 0.0f) 
		{
			block->QueueText (textRect, tmgen, newClipRect);
		}
		// Render image
		if (imageRect.width != 0.0f)  
			block->QueueTexture (imageRect, image, imageColor, clipRect);
		return;
	} 
#endif
	
	// Do clipping of content
	bool needClipping = false;
	Rectf newClipRect;
	if (m_Clipping != kOverflow && (width > contentRect.width || height > contentRect.height)) {
		needClipping = true;
		newClipRect = contentRect;
		newClipRect.x += (m_ContentOffset.x + m_ClipOffset.x);
		newClipRect.y += (m_ContentOffset.y + m_ClipOffset.y);
		newClipRect.Clamp (visibleRect);
		if (newClipRect.width == 0.0f || newClipRect.height == 0.0f)
			return;
		SetGUIClipRect (newClipRect);
	} else {
		SetGUIClipRect(visibleRect);
	}
	
	// Render text
	if (textRect.width != 0.0f && tmgen != NULL)
	{
		RenderText (textRect, *tmgen, textColor);
	}
	// Render image
	if (imageRect.width != 0.0f)  
		DrawClippedTexture (imageRect, image, 0,0,0,0,imageColor);
	
	// If we used custom clipping, restore it
	if (needClipping)
		SetGUIClipRect (visibleRect);
	
}

Rectf GUIStyle::ClampRect (const Rectf &screenRect) const
{
	return Rectf (screenRect.x, screenRect.y, m_FixedWidth ? m_FixedWidth : screenRect.Width(), m_FixedHeight ? m_FixedHeight : screenRect.Height());
}

void GUIStyle::DrawCursor(GUIState &state, const Rectf &screenRect, GUIContent &content, int position, const ColorRGBAf &cursorColor) const
{
	if (!state.m_OnGUIState.m_Enabled)
		return;
	
	Texture *tex = builtintex::GetWhiteTexture();
	Font& currentFont = GetCurrentFont();
	
	float lineHeight = currentFont.GetLineSpacing (m_FontSize);
	Material *material = GetGUIBlendMaterial();
	
	ColorRGBA32 textureColor = cursorColor * state.m_OnGUIState.m_Color;
	Vector2f cursorPos = GetCursorPixelPosition (screenRect, content, position) - m_ClipOffset;
	DrawGUITexture(Rectf (cursorPos.x, cursorPos.y, 1, lineHeight),tex,textureColor,material);
}

void GUIStyle::DrawTextSelection (GUIState &state, const Rectf &screenRect, GUIContent &content, int first, int last, const ColorRGBAf &cursorColor, const ColorRGBAf &selectionColor) const {
	if (!state.m_OnGUIState.m_Enabled)
		return;
	Texture *tex = builtintex::GetWhiteTexture();
	
	Font& currentFont = GetCurrentFont();
	
	float lineHeight = currentFont.GetLineSpacing (m_FontSize);
	Material *material = GetGUIBlendMaterial();
	
	Rectf visibleRect = state.m_CanvasGUIState.m_GUIClipState.GetVisibleRect();
	SetGUIClipRect(visibleRect);
	
	// If the style uses clipping, just apply it - there's only ever one of these anyways
	Rectf innerRect = m_Padding.Remove (screenRect);
	Rectf clipRect;
	if (m_Clipping) {
		clipRect = visibleRect;
		innerRect.Clamp (visibleRect);
		innerRect.x += (m_ContentOffset.x + m_ClipOffset.x);
		innerRect.y += (m_ContentOffset.y + m_ClipOffset.y);
		
		SetGUIClipRect (innerRect);
	}
	
	// We don't have a selection, only a cursor position
	if (first == last) {
		ColorRGBA32 textureColor = cursorColor * state.m_OnGUIState.m_Color;
		Vector2f cursorPos = GetCursorPixelPosition (screenRect, content, first) - m_ClipOffset;	
		
		// if we auto-size the GUIStyle to the text, and the cursor is after the last character, it always gets clipped.
		// Move it one pixel to the left, so it does not clip
		if (first == content.m_Text.length && cursorPos.x >= screenRect.x + screenRect.width)
			cursorPos.x--;
		
#if UNITY_EDITOR
		OptimizedGUIBlock *block = GetCaptureGUIBlock ();
		if (block)
		{
			block->QueueTexture (Rectf (cursorPos.x, cursorPos.y, 1, lineHeight),tex,textureColor,visibleRect);			
		} else {
			DrawGUITexture(Rectf (cursorPos.x, cursorPos.y, 1, lineHeight),tex,textureColor,material);			
		}
#else
		DrawGUITexture(Rectf (cursorPos.x, cursorPos.y, 1, lineHeight),tex,textureColor,material);
#endif	
	} else {
		ColorRGBA32 textureColor = selectionColor * state.m_OnGUIState.m_Color;
		
		int min = first < last ? first : last;
		int max = first > last ? first : last;
		
		Vector2f minPos = GetCursorPixelPosition (screenRect, content, min) - m_ClipOffset;
		Vector2f maxPos = GetCursorPixelPosition (screenRect, content, max) - m_ClipOffset;
		
		if (minPos.y == maxPos.y) 
		{
#if UNITY_EDITOR
			OptimizedGUIBlock *block = GetCaptureGUIBlock ();
			if (block)
			{
				block->QueueTexture (Rectf (minPos.x, minPos.y, maxPos.x - minPos.x + 1, lineHeight), tex, textureColor, visibleRect);
			} else {
#endif	
				DrawGUITexture (Rectf (minPos.x, minPos.y, maxPos.x - minPos.x + 1, lineHeight), tex, textureColor, material);
#if UNITY_EDITOR
			}
#endif
		} else {
#if UNITY_EDITOR
			OptimizedGUIBlock *block = GetCaptureGUIBlock ();
			if (block)
			{
				// draw the first line - including end part
				block->QueueTexture (Rectf (minPos.x, minPos.y, innerRect.GetRight() - minPos.x, lineHeight), tex, textureColor, visibleRect);
				// Draw the middle part
				block->QueueTexture (Rectf (innerRect.x, minPos.y + lineHeight, innerRect.Width(), maxPos.y - minPos.y - lineHeight), tex, textureColor, visibleRect);
				// Draw the bottom line - up to selection
				if (maxPos.x != innerRect.x)		// Don't draw silly 1px line at the left when a newline is selected
					block->QueueTexture (Rectf (innerRect.x, maxPos.y, maxPos.x - innerRect.x + 1, lineHeight), tex, textureColor, visibleRect);
			} else {
#endif	
				// draw the first line - including end part
				DrawGUITexture (Rectf (minPos.x, minPos.y, innerRect.GetRight() - minPos.x, lineHeight), tex, textureColor, material);
				// Draw the middle part
				DrawGUITexture (Rectf (innerRect.x, minPos.y + lineHeight, innerRect.Width(), maxPos.y - minPos.y - lineHeight), tex, textureColor, material);
				// Draw the bottom line - up to selection
				if (maxPos.x != innerRect.x)		// Don't draw silly 1px line at the left when a newline is selected
					DrawGUITexture (Rectf (innerRect.x, maxPos.y, maxPos.x - innerRect.x + 1, lineHeight), tex, textureColor, material);
#if UNITY_EDITOR
			}
#endif
		}
	}
	if (m_Clipping) 
		SetGUIClipRect (clipRect);
	
}

void GUIStyle::DrawTextUnderline (GUIState &state, const Rectf &screenRect, GUIContent &content, int first, int last, const GUIStyleState *gss) const
{
	if (!state.m_OnGUIState.m_Enabled)
		return;
	
	Rectf visibleRect = state.m_CanvasGUIState.m_GUIClipState.GetVisibleRect();
	
	SetGUIClipRect(visibleRect);
	
	Texture *tex = builtintex::GetWhiteTexture();
	Font& currentFont = GetCurrentFont();
	
	float lineHeight = currentFont.GetLineSpacing (m_FontSize);
	Material *material = GetGUIBlendMaterial();
	
	// If the style uses clipping, just apply it - there's only ever one of these anyways
	Rectf innerRect = m_Padding.Remove (screenRect);
	Rectf clipRect;
	
	if (m_Clipping) {
		clipRect = visibleRect;
		innerRect.Clamp (visibleRect);
		innerRect.x += (m_ContentOffset.x + m_ClipOffset.x);
		innerRect.y += (m_ContentOffset.y + m_ClipOffset.y);
		
		SetGUIClipRect (innerRect);
	}
	
	{
		ColorRGBA32 textColor = gss->textColor * state.m_OnGUIState.m_Color * state.m_OnGUIState.m_ContentColor;
		
		int min = first < last ? first : last;
		int max = first > last ? first : last;
		
		Vector2f pos = GetCursorPixelPosition (screenRect, content, min) - m_ClipOffset;
		Vector2f maxPos = GetCursorPixelPosition (screenRect, content, max) - m_ClipOffset;
		
		float underlineSize = std::max(1.0f, lineHeight*0.03f);
		float underlineOffset = lineHeight*0.95f-underlineSize;
		
		while(pos.y < maxPos.y - 0.01)
		{
#if UNITY_EDITOR
			OptimizedGUIBlock *block = GetCaptureGUIBlock ();
			if (block)
			{
				block->QueueTexture (Rectf (pos.x, pos.y+underlineOffset, innerRect.GetRight() - pos.x + 1, underlineSize), tex, textColor, visibleRect);
			} else
#endif	
				DrawGUITexture (Rectf (pos.x, pos.y+underlineOffset, innerRect.GetRight() - pos.x + 1, underlineSize), tex, textColor, material);
			pos.y += ceilf(lineHeight);
			pos.x = innerRect.x;
		}
#if UNITY_EDITOR
		OptimizedGUIBlock *block = GetCaptureGUIBlock ();
		if (block)
		{
			block->QueueTexture (Rectf (pos.x, pos.y+underlineOffset, maxPos.x - pos.x + 1, underlineSize), tex, textColor, visibleRect);
		} else
#endif	
			DrawGUITexture (Rectf (pos.x, pos.y+underlineOffset, maxPos.x - pos.x + 1, underlineSize), tex, textColor, material);
	}
	if (m_Clipping) 
		SetGUIClipRect (clipRect);
}

void GUIStyle::SetStyleState (int stateIndex, ColorRGBAf textColor, Texture2D *background) {
	GUIStyleState *gss = &m_Normal;
	gss += stateIndex;
	gss->background = background;
	gss->textColor = textColor;
}

void GUIStyle::SetGUIClipRect (const Rectf &screenRect)
{
	s_GUIClipRect = screenRect;
	Matrix4x4f clipMatrix;
	clipMatrix.SetIdentity();
	// In a divide-by-zero case, set these to infinity, so we don't render anything.
	if (screenRect.width > 0.0f)
		clipMatrix.Get (0,0) = (kGUIClipTextureSize-2.0f)/kGUIClipTextureSize / screenRect.width;
	else 
		clipMatrix.Get (0,0) = numeric_limits<float>::infinity ();
	if (screenRect.height > 0.0f)
		clipMatrix.Get (1,1) = (kGUIClipTextureSize-2.0f)/kGUIClipTextureSize / screenRect.height;
	else 
		clipMatrix.Get (1,1) = numeric_limits<float>::infinity ();
	clipMatrix.Get (0,3) = -screenRect.x * clipMatrix.Get (0,0) + 1.0f/kGUIClipTextureSize;
	clipMatrix.Get (1,3) = -screenRect.y * clipMatrix.Get (1,1) + 1.0f/kGUIClipTextureSize;
	clipMatrix.Get (2,2) = clipMatrix.Get (3,3) = 0;		// Kill all perspective/depth: Just put 1 in ZW texcoords
	clipMatrix.Get (2,3) = clipMatrix.Get (3,3) = 1;		// Kill all perspective/depth: Just put 1 in ZW texcoords
	GetGfxDevice().GetBuiltinParamValues().SetMatrixParam(kShaderMatGUIClip, clipMatrix);
}

Rectf GUIStyle::GetGUIClipRect ()
{
	return s_GUIClipRect;
}

MonoBehaviour* GetBuiltinSkin (int skin)
{
	// 0 == Game, 1 == Editor Light, 2 = Editor Dark
	static PPtr<MonoBehaviour> skinObject[3] = { NULL, NULL, NULL };

#if UNITY_EDITOR
		// Load skins (editor version)
		if (!skinObject[0] || !skinObject[1] || !skinObject[2])
		{
			// If this is a devel buildwe want to try and load the skins from the opened project
			// (super useful when skinning the app).
			if (IsDeveloperBuild ()) 
			{
				// Try to load the skins from the current project
				skinObject[0] = dynamic_pptr_cast<MonoBehaviour*> (GetMainAsset ("Assets/DefaultResources/GameSkin/GameSkin.GUISkin"));
				skinObject[1] = dynamic_pptr_cast<MonoBehaviour*> (GetMainAsset (AppendPathName ("Assets/Editor Default Resources/", EditorResources::kLightSkinPath)));
				skinObject[2] = dynamic_pptr_cast<MonoBehaviour*> (GetMainAsset (AppendPathName ("Assets/Editor Default Resources/", EditorResources::kDarkSkinPath)));
			}
			
			// Load the game skin.
			// We can not mark this object as dont save, because that will make it not be unloaded when unloading the player.
			// When that happens in the player the serialized state will be lost. So instead we let it be unloaded and on next
			// load it will be reloaded from disk.
			if (!skinObject[0]) 
			{
				Object *obj = GetBuiltinResourceManager ().GetResource (ClassID(MonoBehaviour), "GameSkin/GameSkin.guiskin");
				skinObject[0] = static_cast<MonoBehaviour*> (obj);
			}
			
			// Load the light inspector skin.
			if (!skinObject[1])
				skinObject[1] = GetEditorAssetBundle()->Get<MonoBehaviour>(EditorResources::kLightSkinPath);
			
			// Load the dark inspector skin.
			if (!skinObject[2])
				skinObject[2] = GetEditorAssetBundle()->Get<MonoBehaviour>(EditorResources::kDarkSkinPath);
		}
#else
		// Players are much easier: we just load the game skin.
		if (!skinObject[0]) 
		{
			Object *obj = GetBuiltinResourceManager ().GetResource (ClassID(MonoBehaviour), "GameSkin/GameSkin.guiskin");
			skinObject[0] = static_cast<MonoBehaviour*> (obj);
		}
#endif

	return skinObject[skin];
}

MonoBehaviour* GetDefaultSkin (int skinMode)
{
#if UNITY_EDITOR
	if (skinMode == 0)
		return GetBuiltinSkin (0);
	return GetBuiltinSkin (GetEditorResources().GetSkinIdx () + 1);
#else
	return GetBuiltinSkin (0);
#endif
}