/// <summary>
/// The size of the message on screen. This is using UILabel.relativeSize.
/// </summary>
/// <param name="msg">the current version of the message</param>
public override Vector2 GetSize(ScoreMessage msg)
{
textMesh.text = msg.Text;
return new Vector2(
textMesh.GetComponent<Renderer>().bounds.size.x,
textMesh.GetComponent<Renderer>().bounds.size.y);
}
/// <summary>
/// Calculates the size using the GUIStyle from the message.
/// </summary>
/// <param name="msg">the current version of the message</param>
public override Vector2 GetSize(ScoreMessage msg)
{
GUIContent msgText = new GUIContent(msg.Text);
Vector2 size = msg.style.CalcSize(msgText);
float maxWidth = msg.MaxWidth;
if (size.x > maxWidth) {
msg.style.wordWrap = true;
size.x = maxWidth;
size.y = msg.style.CalcHeight(msgText, size.x);
}
return size;
}
public override void Initialize(ScoreMessage msg)
{
Vector2 sd = rt.sizeDelta;
sd.x = msg.MaxWidth;
rt.sizeDelta = sd;
text.text = msg.Text;
rt.anchorMin = rt.anchorMax = new Vector2(0, 1);
// set the alignment correctly
if (fixAlignment) {
text.alignment = (TextAnchor)NGAlignment.ConvertAlignment(msg.InnerAnchor, NGAlignment.AlignmentType.TextAnchor);
}
// set the anchor and pivot correctly depending on ScreenAlign
if (fixPivot) {
Vector2 pivot = Vector2.zero; // min and max are the same, so is Pivot
switch (NGAlignment.Horizontal(msg.InnerAnchor)) {
case NGAlignment.HorizontalAlign.Left:
pivot.x = 0;
break;
case NGAlignment.HorizontalAlign.Center:
pivot.x = 0.5F;
break;
case NGAlignment.HorizontalAlign.Right:
pivot.x = 1;
break;
}
switch (NGAlignment.Vertical(msg.InnerAnchor)) {
case NGAlignment.VerticalAlign.Bottom:
pivot.y = 0;
break;
case NGAlignment.VerticalAlign.Middle:
pivot.y = 0.5F;
break;
case NGAlignment.VerticalAlign.Top:
pivot.y = 1;
break;
}
rt.pivot = pivot;
}
DoLayout();
}
private void ApplyScoreFlashAnchorToTextMesh(ScoreMessage msg)
{
textMesh.anchor = (TextAnchor)NGAlignment.ConvertAlignment(msg.InnerAnchor, NGAlignment.AlignmentType.TextAnchor);
textMesh.alignment = (TextAlignment)NGAlignment.ConvertAlignment(msg.InnerAnchor, NGAlignment.AlignmentType.TextAlignment);
}
private Rect GetPaddingWidthPosition(ScoreMessage msg, float width, bool isPadding)
{
Rect maxPos = GetMaxRectPosition(msg, width);
Rect paddingWidthPos = new Rect(maxPos);
paddingWidthPos.width = paddingWidthPos.height = 28;
paddingWidthPos.y = isPadding ? paddingWidthPos.y - paddingWidthPos.height : paddingWidthPos.y + maxPos.height;
if (!NGAlignment.IsRight(msg.InnerAnchor)) {
paddingWidthPos.x += maxPos.width - paddingWidthPos.width;
} // otherwise: location is already fine :-)
return paddingWidthPos;
}
private void DrawWorldOffsetPositionHandle(ScoreMessage msg)
{
if (msg.FollowLocation != null) {
Handles.color = Color.white;
Handles.DrawLine(
msg.FollowLocation.CurrentOriginalPosition,
msg.FollowLocation.CurrentTranslatedPosition);
}
Vector3 offsetRelativeToPosition = msg.FollowLocation.CurrentOriginalPosition + designed.PositionWorld.Value;
Vector3 newOffsetRelativeToPosition = Handles.PositionHandle(offsetRelativeToPosition, Quaternion.identity);
if (newOffsetRelativeToPosition != offsetRelativeToPosition) {
designed.PositionWorld = newOffsetRelativeToPosition - msg.FollowLocation.CurrentOriginalPosition;
changed = true;
}
}
private void DrawPositionHandles(ScoreMessage msg)
{
Vector2 msgPos = FlipY(msg.Position);
Vector2 refPoint = msg.OriginalPosition;
Vector2 scrOri = FlipY(refPoint);
Vector3 pointA = ScreenToWorldPoint(msgPos);
Vector3 pointB = ScreenToWorldPoint(scrOri);
Vector3 pointX = ScreenToWorldPoint(new Vector2(scrOri.x, msgPos.y));
Vector3 pointY = ScreenToWorldPoint(new Vector2(msgPos.x, scrOri.y));
Handles.color = Color.blue;
Handles.DrawLine(pointA, pointB);
Handles.DrawLine(pointB, pointY);
Handles.DrawLine(pointB, pointX);
Handles.color = Color.red;
Handles.DrawLine(pointA, pointX);
Handles.color = Color.green;
Handles.DrawLine(pointA, pointY);
}
private void DrawMaxWidthBox(bool isSceneView, ScoreMessage msg, float width, float alpha, Color color, bool isPadding)
{
Rect maxPos = GetMaxRectPosition(msg, width);
color.a = IsDraggingPosition && isSceneView ? 0.1F : alpha;
GUI.color = color;
GUI.Box(maxPos, "");
if (isSceneView) {
NGDragButton button = isPadding ? DragButtonPadding : DragButtonWidth;
button.maxPosition.x = EditorSceneViewGUI.GetScreenWidth(isSceneView);
button.maxPosition.y = EditorSceneViewGUI.GetScreenHeight(isSceneView);
color.a = IsDraggingPosition && isSceneView ? 0.1F : (designed.LockScreenAlign ? 0.8F : 0.5F);
GUI.color = color;
button.position = GetPaddingWidthPosition(msg, width, isPadding);
Vector2 diff = button.DrawMe();
float diffX = diff.x;
if (diffX != 0) {
NGAlignment.HorizontalAlign align = NGAlignment.Horizontal(msg.InnerAnchor);
changed = true;
if (isPadding) {
if (align != NGAlignment.HorizontalAlign.Right) {
diffX *= -1F; // invert
}
designed.MinPaddingX += diffX;
} else {
if (align == NGAlignment.HorizontalAlign.Right) {
diffX *= -1F; // invert
}
if (align == NGAlignment.HorizontalAlign.Center) {
diffX *= 2F; // 1 pixel => left / right => 2 pixels
}
designed.MaxWidth += diffX;
}
}
if (isPadding && IsDraggingPadding || !isPadding && IsDraggingWidth) {
if (isPadding) {
DragButtonPadding.DrawToolTip(isSceneView,
"Padding: {0}", designed.MinPaddingX);
} else {
DragButtonWidth.DrawToolTip(isSceneView,
"Max Width: {0}", designed.MaxWidth);
}
// drawing handles has to be done outside of "Handles.BeginGUI()" and Handles.EndGUI() => OnSceneViewGUI()
}
}
}
private void DrawEditorGUIDesignPosition(ScoreMessage msg, float size)
{
DragButtonPosition.position.width = DragButtonPosition.position.height = size * 2;
if (designed.LockInnerAnchor) {
DragButtonPosition.position.x = msg.Position.x - size;
DragButtonPosition.position.y = msg.Position.y - size;
} else {
DragButtonPosition.position.x = msg.Position.x + size * 2.5F;
if (NGAlignment.IsRight(designed.ScreenAlign)) {
DragButtonPosition.position.x = msg.Position.x - size * 3.5F;
}
DragButtonPosition.position.y = msg.Position.y + size * 2.5F;
if (NGAlignment.IsBottom(designed.ScreenAlign)) {
DragButtonPosition.position.y = msg.Position.y - size * 3.5F;
}
}
GUI.color = Color.white;
DragButtonPosition.maxPosition.x = EditorSceneViewGUI.GetScreenWidth(isSceneView);
DragButtonPosition.maxPosition.y = EditorSceneViewGUI.GetScreenHeight(isSceneView);
Vector2 dragDistance = DragButtonPosition.DrawMe();
Vector2 designedPosition = designed.Position;
if (NGAlignment.IsRight(designed.ScreenAlign)) {
designedPosition.x -= dragDistance.x;
} else {
designedPosition.x += dragDistance.x;
}
if (NGAlignment.IsBottom(designed.ScreenAlign)) {
designedPosition.y -= dragDistance.y;
} else {
designedPosition.y += dragDistance.y;
}
if (designed.Position != designedPosition) {
designed.Position = designedPosition;
changed = true;
}
if (IsDraggingPosition) {
DragButtonPosition.DrawToolTip(isSceneView,
"({0:0}, {1:0})", designed.Position.x, designed.Position.y);
// drawing handles has to be done outside of "Handles.BeginGUI()" and Handles.EndGUI() => OnSceneViewGUI()
}
}
public override void Initialize(ScoreMessage msg) {
// for ScoreFlash, the anchor always needs to be "top-left"!
rt.anchorMin = rt.anchorMax = new Vector2(0, 1);
// set the anchor and pivot correctly depending on ScreenAlign
Vector2 pivot = Vector2.zero; // min and max are the same, so is Pivot
switch (NGAlignment.Horizontal(msg.InnerAnchor)) {
case NGAlignment.HorizontalAlign.Left:
pivot.x = 0;
break;
case NGAlignment.HorizontalAlign.Center:
pivot.x = 0.5F;
break;
case NGAlignment.HorizontalAlign.Right:
pivot.x = 1;
break;
}
switch (NGAlignment.Vertical(msg.InnerAnchor)) {
case NGAlignment.VerticalAlign.Bottom:
pivot.y = 0;
break;
case NGAlignment.VerticalAlign.Middle:
pivot.y = 0.5F;
break;
case NGAlignment.VerticalAlign.Top:
pivot.y = 1;
break;
}
rt.pivot = pivot;
}
/// <summary>
/// Update the message. The implementation needs
/// to make sure that you update position, scale, color and outline
/// color as well as the text.
/// </summary>
/// <param name="msg">the current version of the message</param>
public override void UpdateMessage(ScoreMessage msg)
{
this.msg = msg;
}
/// <summary>
/// Update the message. This only handles text and position because
/// that's all that is supported by GUIText (shame on you, GUIText!)
/// </summary>
/// <param name="msg">the current version of the message</param>
public override void UpdateMessage(ScoreMessage msg)
{
myGuiText.enabled = msg.IsVisible;
myGuiText.text = msg.Text;
if (myMaterial != null) {
myMaterial.color = msg.CurrentTextColor;
}
myGuiText.anchor = (TextAnchor)NGAlignment.ConvertAlignment(msg.InnerAnchor, NGAlignment.AlignmentType.TextAnchor);
myGuiText.alignment = (TextAlignment)NGAlignment.ConvertAlignment(msg.InnerAnchor, NGAlignment.AlignmentType.TextAlignment);
// we need to convert screen position from pixel based to
// "0-1"-based:
Vector3 position = new Vector3(
msg.Position.x / EditorSceneViewGUI.GetScreenWidth(msg.IsSceneView),
1F - (msg.Position.y / EditorSceneViewGUI.GetScreenHeight(msg.IsSceneView)));
myGuiText.transform.position = position;
}
/// <summary>
/// The size of the message on screen. Depending on the underlying GUI system
/// you are using, there may be different ways of calculating the
/// size. This needs to be in screen coordinates.
/// </summary>
/// <param name="msg">the current version of the message</param>
public override Vector2 GetSize(ScoreMessage msg)
{
myGuiText.text = msg.Text;
Rect size = myGuiText.GetScreenRect();
return new Vector2(size.width, size.height);
}
/// <summary>
/// Update the message.
/// </summary>
/// <param name="msg">the current version of the message</param>
public override void UpdateMessage(ScoreMessage msg)
{
// are we visible (we may be behind the player when rendering ScoreFlashFollow3D stuff)
text.enabled= msg.IsVisible;
// if the text has changed, we might have to re-layout
if (!msg.Text.Equals(text.text)) {
DoLayout();
Rect pos = msg.Position;
pos.height = rt.sizeDelta.y;
msg.Position = pos;
}
// push text and color to Unity UI
text.text = msg.Text;
text.color = msg.CurrentTextColor;
// if we have background images registered, push color to those
for (int i = 0; i < coloredGraphics.Count; i++) {
coloredGraphics[i].color = AlphaMultiplyColor(coloredGraphicsOrigColor[i], msg.CurrentTextColor);
}
Vector2 position = new Vector2(msg.Position.x, msg.Position.y);
if (canvas != null && canvasRT != null) {
Vector2 screenSize = new Vector2(canvas.pixelRect.width, canvas.pixelRect.height);
Vector2 viewPortSize = canvasRT.sizeDelta;
position = new Vector2(
position.x * viewPortSize.x / screenSize.x,
position.y * viewPortSize.y / screenSize.y);
}
// convert our coordinate system into Unity UI's coordinate system
//Vector2 pos = NGAlignment.GetAlignBasedOffset(msg.InnerAnchor, msg.Position);
rt.anchoredPosition = new Vector2(position.x, -position.y);
// ... ok, I guess there's are kind of obvious, aren't they?
transform.localScale = msg.Scale * Vector3.one;
transform.localRotation = Quaternion.Euler(0, 0, -msg.Rotation);
}
private Rect DrawAlignmentButton(ScoreMessage msg, Rect buttonPosition, NGAlignment.ScreenAlign align, string text, Texture icon)
{
Vector2 clampedPosition = new Vector2(Mathf.Clamp(designed.Position.x, -100F, 100F), Mathf.Clamp(designed.Position.y, -100F, 100F));
if (!designed.SupportsScreenAlign) {
align = NGAlignment.ScreenAlign.MiddleCenter;
}
if (msg != null) {
clampedPosition = Vector2.zero;
}
Vector2 posForButton = (msg == null)
? NGAlignment.GetScreenBasedReferencePosition(align, clampedPosition, isSceneView)
: msg.OriginalPosition;
Vector2 offset = NGAlignment.GetAlignBasedOffset(align, buttonPosition);
buttonPosition.x = Mathf.Clamp(posForButton.x + offset.x, 0F, EditorSceneViewGUI.GetScreenWidth(isSceneView) - buttonPosition.width);
buttonPosition.y = Mathf.Clamp(posForButton.y + offset.y, 0F, EditorSceneViewGUI.GetScreenHeight(isSceneView) - buttonPosition.height);
Color col = GUI.color;
if (IsDraggingPosition) {
col.a = 0.4F;
}
if (clampedPosition != designed.Position) {
col.a = 0.2F;
}
if (msg != null) {
col.a = 1F;
}
GUI.color = col;
if (msg == null) {
if (GUI.Button(buttonPosition, text)) {
designed.ScreenAlign = align;
}
} else { // otherwise: reset position
if (GUI.Button(buttonPosition, icon)) {
designed.Position = Vector2.zero;
changed = true;
}
}
return buttonPosition;
}
private void DrawEditorGUIDesignInnerAnchor(ScoreMessage msg, float size)
{
Rect pos = msg.Position;
pos.width = pos.height = size;
if (!designed.LockInnerAnchor && !IsDraggingPosition) {
pos.x = msg.Position.x + size * 0.5F; pos.y = msg.Position.y + size * 0.5F;
if (EditorSceneViewGUI.Toggle(pos, designed.InnerAnchor != NGAlignment.ScreenAlign.TopLeft)) {
designed.InnerAnchor = NGAlignment.ScreenAlign.TopLeft;
changed = true;
}
pos.x = msg.Position.x - size * 0.5F; pos.y = msg.Position.y + size * 0.5F;
if (EditorSceneViewGUI.Toggle(pos, designed.InnerAnchor != NGAlignment.ScreenAlign.TopCenter)) {
designed.InnerAnchor = NGAlignment.ScreenAlign.TopCenter;
changed = true;
}
pos.x = msg.Position.x - size * 1.5F; pos.y = msg.Position.y + size * 0.5F;
if (EditorSceneViewGUI.Toggle(pos, designed.InnerAnchor != NGAlignment.ScreenAlign.TopRight)) {
designed.InnerAnchor = NGAlignment.ScreenAlign.TopRight;
changed = true;
}
pos.x = msg.Position.x + size * 0.5F; pos.y = msg.Position.y - size * 0.5F;
if (EditorSceneViewGUI.Toggle(pos, designed.InnerAnchor != NGAlignment.ScreenAlign.MiddleLeft)) {
designed.InnerAnchor = NGAlignment.ScreenAlign.MiddleLeft;
changed = true;
}
pos.x = msg.Position.x - size * 0.5F; pos.y = msg.Position.y - size * 0.5F;
if (EditorSceneViewGUI.Toggle(pos, designed.InnerAnchor != NGAlignment.ScreenAlign.MiddleCenter)) {
designed.InnerAnchor = NGAlignment.ScreenAlign.MiddleCenter;
changed = true;
}
pos.x = msg.Position.x - size * 1.5F; pos.y = msg.Position.y - size * 0.5F;
if (EditorSceneViewGUI.Toggle(pos, designed.InnerAnchor != NGAlignment.ScreenAlign.MiddleRight)) {
designed.InnerAnchor = NGAlignment.ScreenAlign.MiddleRight;
changed = true;
}
pos.x = msg.Position.x + size * 0.5F; pos.y = msg.Position.y - size * 1.5F;
if (EditorSceneViewGUI.Toggle(pos, designed.InnerAnchor != NGAlignment.ScreenAlign.BottomLeft)) {
designed.InnerAnchor = NGAlignment.ScreenAlign.BottomLeft;
changed = true;
}
pos.x = msg.Position.x - size * 0.5F; pos.y = msg.Position.y - size * 1.5F;
if (EditorSceneViewGUI.Toggle(pos, designed.InnerAnchor != NGAlignment.ScreenAlign.BottomCenter)) {
designed.InnerAnchor = NGAlignment.ScreenAlign.BottomCenter;
changed = true;
}
pos.x = msg.Position.x - size * 1.5F; pos.y = msg.Position.y - size * 1.5F;
if (EditorSceneViewGUI.Toggle(pos, designed.InnerAnchor != NGAlignment.ScreenAlign.BottomRight)) {
designed.InnerAnchor = NGAlignment.ScreenAlign.BottomRight;
changed = true;
}
} else {
pos.x = msg.Position.x - size * 0.5F; pos.y = msg.Position.y - size * 0.5F;
GUI.Box(pos, "");
}
pos.width = designed.DefaultScoreFlash.editorIconSet.lockOpen.width;
pos.height = designed.DefaultScoreFlash.editorIconSet.lockOpen.height;
pos.x = msg.Position.x + size * 1.5F; pos.y = msg.Position.y - size * 0.5F;
if (pos.x + 2 * pos.width + 3 > Screen.width - 2) {
pos.x = msg.Position.x - size * 2.5F - 2 * pos.width + 6;
}
// when we're going too far right for the tooltip, where should the tool tip start
float xOnFlip = msg.Position.x - size * 2.5F;
GUIContent lockClosed;
GUIContent lockOpen;
bool newLocked = false;
if (designed.SupportsScreenAlign && designed.SupportsInnerAnchor) {
lockClosed = new GUIContent(designed.DefaultScoreFlash.editorIconSet.lockClosed, "Define arbitrary inner anchors");
lockOpen = new GUIContent(designed.DefaultScoreFlash.editorIconSet.lockOpen, "Lock Inner Anchors to Screen Align");
newLocked = EditorSceneViewGUI.ToggleWithToolTip(pos, xOnFlip, designed.LockInnerAnchor, lockClosed, lockOpen);
if (newLocked != designed.LockInnerAnchor) {
designed.LockInnerAnchor = newLocked;
changed = true;
}
pos.x += pos.width + 3;
}
if (designed.SupportsScreenAlign) {
lockClosed = new GUIContent(designed.DefaultScoreFlash.editorIconSet.lockClosed, "Show Buttons for Screen Alignment");
lockOpen = new GUIContent(designed.DefaultScoreFlash.editorIconSet.lockOpen, "Hide Buttons for Screen Alignment");
newLocked = EditorSceneViewGUI.ToggleWithToolTip(pos, xOnFlip, designed.LockScreenAlign, lockClosed, lockOpen);
if (newLocked != designed.LockScreenAlign) {
designed.LockScreenAlign = newLocked;
changed = true;
}
}
}
/// <summary>
/// The size of the message on screen. This is using RectTransform.sizeDelta.
/// </summary>
/// <param name="msg">the current version of the message</param>
public override Vector2 GetSize(ScoreMessage msg) {
return rt.sizeDelta;
}
private void DrawEditorGUIDesignScreenAlignment(ScoreMessage msg)
{
Rect buttonPosition = new Rect(0, 0, 120, 40);
NGAlignment.ScreenAlign oldAlign = designed.ScreenAlign;
if (designed.SupportsScreenAlign && !designed.LockScreenAlign) {
foreach (NGAlignment.ScreenAlign align in System.Enum.GetValues(typeof(NGAlignment.ScreenAlign))) {
if (align != designed.ScreenAlign) {
buttonPosition = DrawAlignmentButton(null, buttonPosition, align, align.ToString(), null);
}
}
}
if (designed.Position.sqrMagnitude > 43 * 43) {
buttonPosition.width = buttonPosition.height = 28;
DrawAlignmentButton(msg, buttonPosition, designed.ScreenAlign, null, designed.DefaultScoreFlash.editorIconSet.moveReset);
}
if (oldAlign != designed.ScreenAlign) {
changed = true;
}
}
/// <summary>
/// Update the message.
/// </summary>
/// <param name="msg">the current version of the message</param>
public override void UpdateMessage(ScoreMessage msg) {
// push only the alpha channel of the color
background.color = AlphaMultiplyColor(origColorBackground, msg.CurrentTextColor);
title.color = AlphaMultiplyColor(origColorName, msg.CurrentTextColor);
description.color = AlphaMultiplyColor(origColorDescription, msg.CurrentTextColor);
Vector2 position = new Vector2(msg.Position.x, msg.Position.y);
if (canvas != null && canvasRT != null) {
Vector2 screenSize = new Vector2(canvas.pixelRect.width, canvas.pixelRect.height);
Vector2 viewPortSize = canvasRT.sizeDelta;
position = new Vector2(
position.x * viewPortSize.x / screenSize.x,
position.y * viewPortSize.y / screenSize.y);
}
// convert our coordinate system into Unity UI's coordinate system
//Vector2 pos = NGAlignment.GetAlignBasedOffset(msg.InnerAnchor, msg.Position);
rt.anchoredPosition = new Vector2(position.x, -position.y);
// ... ok, I guess there's are kind of obvious, aren't they?
transform.localScale = msg.Scale * Vector3.one;
transform.localRotation = Quaternion.Euler(0, 0, -msg.Rotation);
}
private void DrawPaddingWidthHandles(ScoreMessage msg, bool isPadding)
{
bool isRight = NGAlignment.IsRight(msg.InnerAnchor);
float width = isPadding ? msg.MaxWidthViaPadding : msg.MaxWidthViaWidth;
Rect dragHandle = GetPaddingWidthPosition(msg, width, isPadding);
dragHandle.y += dragHandle.height * 0.5F;
if (!isRight && isPadding || isRight && !isPadding) {
dragHandle.x += dragHandle.width;
}
Vector2 msgPos = FlipY(dragHandle);
Vector2 scrOri = Vector2.zero;
if (isPadding) {
if (!isRight) {
scrOri = new Vector2(EditorSceneViewGUI.GetScreenWidth(isSceneView), msgPos.y);
} else {
scrOri = new Vector2(0, msgPos.y);
}
} else {
if (!isRight) {
scrOri = new Vector2(msgPos.x - width + dragHandle.width, msgPos.y);
} else {
scrOri = new Vector2(msgPos.x + width - dragHandle.width, msgPos.y);
}
}
Vector3 pointA = ScreenToWorldPoint(msgPos);
Vector3 pointB = ScreenToWorldPoint(scrOri);
Handles.color = isPadding ? Color.green : Color.cyan;
Handles.DrawLine(pointA, pointB);
}
/// <summary> /// The size of the message on screen. Depending on the underlying GUI system /// you are using, there may be different ways of calculating the /// size. This needs to be in screen coordinates. /// </summary> /// <param name="msg">the current version of the message</param> public abstract Vector2 GetSize(ScoreMessage msg);
private bool DrawWidthLock(ScoreMessage msg, bool oldIsMax, Rect lockPos, Rect localPos)
{
lockPos.width = designed.DefaultScoreFlash.editorIconSet.lockOpen.width;
lockPos.height = designed.DefaultScoreFlash.editorIconSet.lockOpen.height;
// trying to find a position for the lock that makes sense ... and can be used all the time ;-)
if (!NGAlignment.IsRight(msg.InnerAnchor)) {
lockPos.x += localPos.width + 3;
} else {
lockPos.x -= lockPos.width + 3;
}
lockPos.y = localPos.y + localPos.height + 3F;
float xOnFlip = lockPos.x - lockPos.width;
GUIContent lockClosed = new GUIContent(designed.DefaultScoreFlash.editorIconSet.lockClosed, "Set Max Width to Current");
GUIContent lockOpen = new GUIContent(designed.DefaultScoreFlash.editorIconSet.lockOpen, "Set Max Width to Max");
return EditorSceneViewGUI.ToggleWithToolTip(lockPos, xOnFlip, oldIsMax, lockClosed, lockOpen);
}
/// <summary>
/// Can be used to initialize the message renderer.
/// </summary>
/// <param name="msg">the initial of the message</param>
public virtual void Initialize(ScoreMessage msg)
{
}
private Rect GetMaxRectPosition(ScoreMessage msg, float width)
{
Rect maxPos = new Rect(msg.Position);
maxPos.width = width;
Vector2 alignBasedOffsetMax = NGAlignment.GetAlignBasedOffset(msg.InnerAnchor, maxPos);
maxPos.x += alignBasedOffsetMax.x;
maxPos.y += alignBasedOffsetMax.y;
return maxPos;
}
/// <summary> /// Update the message. The implementation needs /// to make sure that you update position, scale, rotation color and outline /// color as well as the text ... and whether the message is currently visible! /// </summary> /// <remarks> /// See also: /// <list type="bullet"> /// <item><description><see cref="ScoreMessage.IsVisible"/></description></item> /// <item><description><see cref="ScoreMessage.Text"/></description></item> /// <item><description><see cref="ScoreMessage.position"/></description></item> /// <item><description><see cref="ScoreMessage.rotation"/></description></item> /// <item><description><see cref="ScoreMessage.scale"/></description></item> /// <item><description><see cref="ScoreMessage.CurrentTextColor"/></description></item> /// <item><description><see cref="ScoreMessage.OutlineColor"/></description></item> /// </list> /// </remarks> /// <param name="msg">the current version of the message</param> public abstract void UpdateMessage(ScoreMessage msg);
/// <summary>
/// Update the message.
/// </summary>
/// <param name="msg">the current version of the message</param>
public override void UpdateMessage(ScoreMessage msg)
{
transform.position = msg.FollowLocation.CurrentTranslatedPosition;
transform.LookAt(msg.Follow3D.referenceCamera.transform.position, msg.Follow3D.referenceCamera.transform.up);
// are we visible (we may be behind the player when rendering ScoreFlashFollow3D stuff)
textMesh.GetComponent<Renderer>().enabled = msg.IsVisible;
//textMeshPro.lineLength = msg.MaxWidth;
// push text and color to NGUI
textMesh.text = msg.Text;
textMesh.color = msg.CurrentTextColor;
Vector2 pos = new Vector2(msg.Position.x + msg.Position.width * 0.5F, msg.Position.y + msg.Position.height * 0.5F);
pos -= msg.OriginalPosition;
// convert our coordinate system into World coordinate system
Vector3 position = new Vector3(
pos.x * positionScale,
-pos.y * positionScale,
0); // any value > 0 will do ;-)
textTransform.localPosition = position;
// ... ok, I guess there's are kind of obvious, aren't they?
textMesh.transform.localScale = msg.Scale * Vector3.one;
textTransform.localRotation = Quaternion.Euler(0, 180, -msg.Rotation);
}
/// <summary>
/// Update the message.
/// </summary>
/// <param name="msg">the current version of the message</param>
public override void UpdateMessage(ScoreMessage msg)
{
// are we visible (we may be behind the player when rendering ScoreFlashFollow3D stuff)
textMesh.GetComponent<Renderer>().enabled = msg.IsVisible;
// msg.MaxWidth; // not supported by text mesh
// push text and color to NGUI
textMesh.text = msg.Text;
textMesh.color = msg.CurrentTextColor;
// convert our coordinate system into World coordinate system
Vector3 position = new Vector3(
msg.Position.x - 0.5F * Screen.width,
0.5F * Screen.height - msg.Position.y,
10F); // any value > 0 will do ;-)
transform.localPosition = position;
// ... ok, I guess there's are kind of obvious, aren't they?
textMesh.transform.localScale = msg.Scale * Vector3.one;
transform.localRotation = Quaternion.Euler(0, 0, -msg.Rotation);
}
public override void Initialize(ScoreMessage msg)
{
textMesh.text = msg.Text;
// msg.MaxWidth; // not supported by text mesh
// We can't use this, yet, because NGAlignment doesn't support Text Mesh Pro, yet
// I might clean this up in a future version; on the other hand, it's a nice example for adding
// a custom renderer for a GUI framework that's not supported "out-of-the-box" ;-)
//NGAlignment.ConvertAlignment(msg.InnerAnchor, NGAlignment.AlignmentType.NGUI_Pivot);
ApplyScoreFlashAnchorToTextMesh(msg);
}
/// <summary>
/// The size of the message on screen. This is using
/// text.preferredWith and text.preferredHeight.
/// </summary>
/// <param name="msg">the current version of the message</param>
public override Vector2 GetSize(ScoreMessage msg)
{
if (csf != null) {
text.text = msg.Text;
DoLayout();
return new Vector2(text.preferredWidth, rt.sizeDelta.y);
} else {
return rt.sizeDelta;
}
}