549 lines
14 KiB
C#
549 lines
14 KiB
C#
using System;
|
|
using EnergyBarToolkit;
|
|
using UnityEngine;
|
|
|
|
public abstract class EnergyBarOnGUIBase : EnergyBarBase
|
|
{
|
|
protected enum MaterialType
|
|
{
|
|
StandardTransparent = 0,
|
|
StandardTransparentPre = 1,
|
|
HorizontalFill = 2,
|
|
HorizontalFillPre = 3,
|
|
VerticalFill = 4,
|
|
VerticalFillPre = 5,
|
|
ExpandFill = 6,
|
|
ExpandFillPre = 7,
|
|
RadialFill = 8,
|
|
RadialFillPre = 9
|
|
}
|
|
|
|
public enum ResizeMode
|
|
{
|
|
None = 0,
|
|
Fixed = 1,
|
|
Stretch = 2,
|
|
KeepRatio = 3
|
|
}
|
|
|
|
protected const string ShaderStandardTransparentName = "Custom/Energy Bar Toolkit/Unlit";
|
|
|
|
protected const string ShaderStandardTransparentPreName = "Custom/Energy Bar Toolkit/Unlit Pre";
|
|
|
|
protected const string ShaderHorizontalFillName = "Custom/Energy Bar Toolkit/Horizontal Fill";
|
|
|
|
protected const string ShaderHorizontalFillPreName = "Custom/Energy Bar Toolkit/Horizontal Fill Pre";
|
|
|
|
protected const string ShaderVerticalFillName = "Custom/Energy Bar Toolkit/Vertical Fill";
|
|
|
|
protected const string ShaderVerticalFillPreName = "Custom/Energy Bar Toolkit/Vertical Fill Pre";
|
|
|
|
protected const string ShaderExpandFillName = "Custom/Energy Bar Toolkit/Expand Fill";
|
|
|
|
protected const string ShaderExpandFillPreName = "Custom/Energy Bar Toolkit/Expand Fill Pre";
|
|
|
|
protected const string ShaderRadialFillName = "Custom/Energy Bar Toolkit/Radial Fill";
|
|
|
|
protected const string ShaderRadialFillPreName = "Custom/Energy Bar Toolkit/Radial Fill Pre";
|
|
|
|
protected const string ShaderParamProgress = "_Progress";
|
|
|
|
protected const string ShaderParamColor = "_Color";
|
|
|
|
protected const string ShaderParamInvert = "_Invert";
|
|
|
|
protected const string ShaderParamVisibleRect = "_Rect";
|
|
|
|
public Tex[] texturesBackground = new Tex[0];
|
|
|
|
public Tex[] texturesForeground = new Tex[0];
|
|
|
|
public bool premultipliedAlpha;
|
|
|
|
public int guiDepth = 1;
|
|
|
|
public GameObject anchorObject;
|
|
|
|
public Camera anchorCamera;
|
|
|
|
public ResizeMode resizeMode;
|
|
|
|
public Pivot pivot;
|
|
|
|
public bool positionSizeFromTransform;
|
|
|
|
public bool positionSizeFromTransformNormalized;
|
|
|
|
public bool labelOutlineEnabled = true;
|
|
|
|
public Color labelOutlineColor = Color.black;
|
|
|
|
public Pivot labelPivot;
|
|
|
|
public GUISkin labelSkin;
|
|
|
|
private Material[] materials;
|
|
|
|
public abstract Vector2 SizePixels { get; set; }
|
|
|
|
public abstract Vector2 TextureSizePixels { get; }
|
|
|
|
protected override void OnEnable()
|
|
{
|
|
base.OnEnable();
|
|
CreateMaterial();
|
|
base.useGUILayout = true;
|
|
if (Application.isPlaying)
|
|
{
|
|
Debug.LogWarning("OnGUI renderers are deprecated and shouldn't be used anymore. Please switch to new rendering methods. http://goo.gl/cNio5k");
|
|
}
|
|
}
|
|
|
|
protected override void OnDisable()
|
|
{
|
|
base.OnDisable();
|
|
}
|
|
|
|
protected void OnGUI()
|
|
{
|
|
GUI.depth = guiDepth;
|
|
}
|
|
|
|
protected Material MaterialStandard()
|
|
{
|
|
if (premultipliedAlpha)
|
|
{
|
|
return materials[1];
|
|
}
|
|
return materials[0];
|
|
}
|
|
|
|
protected Material MaterialHorizFill()
|
|
{
|
|
if (premultipliedAlpha)
|
|
{
|
|
return materials[3];
|
|
}
|
|
return materials[2];
|
|
}
|
|
|
|
protected Material MaterialVertFill()
|
|
{
|
|
if (premultipliedAlpha)
|
|
{
|
|
return materials[5];
|
|
}
|
|
return materials[4];
|
|
}
|
|
|
|
protected Material MaterialExpandFill()
|
|
{
|
|
if (premultipliedAlpha)
|
|
{
|
|
return materials[7];
|
|
}
|
|
return materials[6];
|
|
}
|
|
|
|
protected Material MaterialRadialFill()
|
|
{
|
|
if (premultipliedAlpha)
|
|
{
|
|
return materials[9];
|
|
}
|
|
return materials[8];
|
|
}
|
|
|
|
private void CreateMaterial()
|
|
{
|
|
if (materials == null || materials.Length == 0)
|
|
{
|
|
int num = Enum.GetNames(typeof(MaterialType)).Length;
|
|
materials = new Material[num];
|
|
materials[0] = new Material(Shader.Find("Custom/Energy Bar Toolkit/Unlit"));
|
|
materials[1] = new Material(Shader.Find("Custom/Energy Bar Toolkit/Unlit Pre"));
|
|
materials[2] = new Material(Shader.Find("Custom/Energy Bar Toolkit/Horizontal Fill"));
|
|
materials[3] = new Material(Shader.Find("Custom/Energy Bar Toolkit/Horizontal Fill Pre"));
|
|
materials[4] = new Material(Shader.Find("Custom/Energy Bar Toolkit/Vertical Fill"));
|
|
materials[5] = new Material(Shader.Find("Custom/Energy Bar Toolkit/Vertical Fill Pre"));
|
|
materials[6] = new Material(Shader.Find("Custom/Energy Bar Toolkit/Expand Fill"));
|
|
materials[7] = new Material(Shader.Find("Custom/Energy Bar Toolkit/Expand Fill Pre"));
|
|
materials[8] = new Material(Shader.Find("Custom/Energy Bar Toolkit/Radial Fill"));
|
|
materials[9] = new Material(Shader.Find("Custom/Energy Bar Toolkit/Radial Fill Pre"));
|
|
Material[] array = materials;
|
|
foreach (Material material in array)
|
|
{
|
|
material.hideFlags = HideFlags.DontSave;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void DestroyMaterial()
|
|
{
|
|
Material[] array = materials;
|
|
foreach (Material obj in array)
|
|
{
|
|
if (Application.isPlaying)
|
|
{
|
|
UnityEngine.Object.Destroy(obj);
|
|
}
|
|
else
|
|
{
|
|
UnityEngine.Object.DestroyImmediate(obj);
|
|
}
|
|
}
|
|
materials = null;
|
|
}
|
|
|
|
protected void ShaderSetProgress(float progress, Material mat)
|
|
{
|
|
mat.SetFloat("_Progress", progress);
|
|
}
|
|
|
|
protected void ShaderSetInvert(bool invert, Material mat)
|
|
{
|
|
mat.SetFloat("_Invert", invert ? 1 : 0);
|
|
}
|
|
|
|
protected void ShaderSetColor(Color color, Material mat)
|
|
{
|
|
mat.SetColor("_Color", color);
|
|
}
|
|
|
|
protected void ShaderSetVisibleRect(Rect visibleRect, Material mat)
|
|
{
|
|
mat.SetVector("_Rect", ToVector4(visibleRect));
|
|
}
|
|
|
|
protected void GUIDrawBackground()
|
|
{
|
|
if (texturesBackground == null)
|
|
{
|
|
return;
|
|
}
|
|
Rect drawAreaRect = DrawAreaRect;
|
|
Tex[] array = texturesBackground;
|
|
foreach (Tex tex in array)
|
|
{
|
|
Texture2D texture = tex.texture;
|
|
if (texture != null)
|
|
{
|
|
DrawTexture(drawAreaRect, texture, tex.color);
|
|
}
|
|
}
|
|
}
|
|
|
|
protected void GUIDrawForeground()
|
|
{
|
|
if (texturesForeground == null)
|
|
{
|
|
return;
|
|
}
|
|
Rect drawAreaRect = DrawAreaRect;
|
|
Tex[] array = texturesForeground;
|
|
foreach (Tex tex in array)
|
|
{
|
|
Texture2D texture = tex.texture;
|
|
if (texture != null)
|
|
{
|
|
DrawTexture(drawAreaRect, texture, tex.color);
|
|
}
|
|
}
|
|
}
|
|
|
|
protected void DrawTexture(Rect rect, Texture2D texture, Color tint)
|
|
{
|
|
Material material = MaterialStandard();
|
|
material.SetColor("_Color", ComputeColor(tint));
|
|
Graphics.DrawTexture(rect, texture, material);
|
|
}
|
|
|
|
protected void DrawTexture(Rect rect, Texture2D texture, Rect coords, Color tint)
|
|
{
|
|
Material material = MaterialStandard();
|
|
material.SetColor("_Color", ComputeColor(tint));
|
|
Graphics.DrawTexture(rect, texture, coords, 0, 0, 0, 0, material);
|
|
}
|
|
|
|
protected void DrawTextureHorizFill(Rect rect, Texture2D texture, Rect visibleRect, Color color, bool invert, float progress)
|
|
{
|
|
Material material = MaterialHorizFill();
|
|
material.SetColor("_Color", ComputeColor(color));
|
|
material.SetFloat("_Invert", invert ? 1 : 0);
|
|
material.SetFloat("_Progress", progress);
|
|
material.SetVector("_Rect", ToVector4(visibleRect));
|
|
Graphics.DrawTexture(rect, texture, material);
|
|
}
|
|
|
|
protected void DrawTextureVertFill(Rect rect, Texture2D texture, Rect visibleRect, Color color, bool invert, float progress)
|
|
{
|
|
Material material = MaterialVertFill();
|
|
material.SetColor("_Color", ComputeColor(color));
|
|
material.SetFloat("_Invert", invert ? 1 : 0);
|
|
material.SetFloat("_Progress", progress);
|
|
material.SetVector("_Rect", ToVector4(visibleRect));
|
|
Graphics.DrawTexture(rect, texture, material);
|
|
}
|
|
|
|
protected void DrawTextureExpandFill(Rect rect, Texture2D texture, Rect visibleRect, Color color, bool invert, float progress)
|
|
{
|
|
Material material = MaterialExpandFill();
|
|
material.SetColor("_Color", ComputeColor(color));
|
|
material.SetFloat("_Invert", invert ? 1 : 0);
|
|
material.SetFloat("_Progress", progress);
|
|
material.SetVector("_Rect", ToVector4(visibleRect));
|
|
Graphics.DrawTexture(rect, texture, material);
|
|
}
|
|
|
|
protected void DrawTextureRadialFill(Rect rect, Texture2D texture, Color color, bool invert, float progress, float offset, float length)
|
|
{
|
|
Material material = MaterialRadialFill();
|
|
material.SetColor("_Color", ComputeColor(color));
|
|
material.SetFloat("_Invert", invert ? 1 : 0);
|
|
material.SetFloat("_Progress", progress);
|
|
material.SetFloat("_Offset", offset);
|
|
material.SetFloat("_Length", length);
|
|
Graphics.DrawTexture(rect, texture, material);
|
|
}
|
|
|
|
protected void GUIDrawLabel()
|
|
{
|
|
if (labelEnabled)
|
|
{
|
|
GUISkin skin = labelSkin;
|
|
if (skin == null)
|
|
{
|
|
skin = GUI.skin;
|
|
}
|
|
float num = 1f;
|
|
string text = LabelFormatResolve(labelFormat);
|
|
Vector2 vector = skin.label.CalcSize(new GUIContent(text));
|
|
if (labelOutlineEnabled)
|
|
{
|
|
float num2 = num * 2f;
|
|
vector.x += num2;
|
|
vector.y += num2;
|
|
}
|
|
Vector2 labelPositionPixels = base.LabelPositionPixels;
|
|
Rect r = new Rect(labelPositionPixels.x, labelPositionPixels.y, vector.x, vector.y);
|
|
r = ApplyLabelPivot(r);
|
|
GUI.color = labelColor;
|
|
if (labelOutlineEnabled)
|
|
{
|
|
LabelWithOutline(r, text, skin.label, labelOutlineColor, num);
|
|
}
|
|
else
|
|
{
|
|
GUI.Label(r, text, skin.label);
|
|
}
|
|
GUI.color = Color.white;
|
|
}
|
|
}
|
|
|
|
private Rect ApplyLabelPivot(Rect r)
|
|
{
|
|
switch (labelPivot)
|
|
{
|
|
case Pivot.TopLeft:
|
|
return r;
|
|
case Pivot.Top:
|
|
return new Rect(r.x - r.width / 2f, r.y, r.width, r.height);
|
|
case Pivot.TopRight:
|
|
return new Rect(r.x - r.width, r.y, r.width, r.height);
|
|
case Pivot.Right:
|
|
return new Rect(r.x - r.width, r.y - r.height / 2f, r.width, r.height);
|
|
case Pivot.BottomRight:
|
|
return new Rect(r.x - r.width, r.y - r.height, r.width, r.height);
|
|
case Pivot.Bottom:
|
|
return new Rect(r.x - r.width / 2f, r.y - r.height, r.width, r.height);
|
|
case Pivot.BottomLeft:
|
|
return new Rect(r.x, r.y - r.height, r.width, r.height);
|
|
case Pivot.Left:
|
|
return new Rect(r.x, r.y - r.height / 2f, r.width, r.height);
|
|
case Pivot.Center:
|
|
return new Rect(r.x - r.width / 2f, r.y - r.height / 2f, r.width, r.height);
|
|
default:
|
|
Debug.LogError("Unknown pivot: " + labelPivot);
|
|
return r;
|
|
}
|
|
}
|
|
|
|
private void LabelWithOutline(Rect rect, string text, GUIStyle style, Color color, float size)
|
|
{
|
|
Color color2 = GUI.color;
|
|
GUI.color = color;
|
|
Vector2[] array = new Vector2[4]
|
|
{
|
|
new Vector2(1f, 0f),
|
|
new Vector2(-1f, 0f),
|
|
new Vector2(0f, 1f),
|
|
new Vector2(0f, -1f)
|
|
};
|
|
for (int i = 0; i < array.Length; i++)
|
|
{
|
|
Vector2 vector = array[i];
|
|
Rect position = new Rect(rect.x + vector.x * size, rect.y + vector.y * size, rect.width, rect.height);
|
|
GUI.Label(position, text, style);
|
|
}
|
|
GUI.color = color2;
|
|
GUI.Label(rect, text, style);
|
|
}
|
|
|
|
protected Vector2 TransformScale()
|
|
{
|
|
if (positionSizeFromTransform)
|
|
{
|
|
Vector3 lossyScale = base.transform.lossyScale;
|
|
return new Vector2(lossyScale.x, lossyScale.y);
|
|
}
|
|
return Vector2.one;
|
|
}
|
|
|
|
protected Vector2 RealPosition(Vector2 pos, Vector2 bounds)
|
|
{
|
|
Vector2 vector = Vector2.zero;
|
|
if (positionSizeFromTransform)
|
|
{
|
|
vector = ((!positionSizeFromTransformNormalized) ? new Vector2(base.transform.position.x, 0f - base.transform.position.y) : new Vector2(base.transform.position.x * (float)Screen2.width, (0f - base.transform.position.y) * (float)Screen2.height));
|
|
pos.Scale(base.transform.lossyScale);
|
|
}
|
|
Vector2 vector2 = Vector2.zero;
|
|
Vector2 vector3 = Vector2.zero;
|
|
switch (pivot)
|
|
{
|
|
case Pivot.TopLeft:
|
|
vector2 = Vector2.zero;
|
|
vector3 = Vector2.zero;
|
|
break;
|
|
case Pivot.Top:
|
|
vector2 = new Vector2(Screen2.width / 2, 0f);
|
|
vector3 = new Vector2(bounds.x / 2f, 0f);
|
|
break;
|
|
case Pivot.TopRight:
|
|
vector2 = new Vector2(Screen2.width, 0f);
|
|
vector3 = new Vector2(bounds.x, 0f);
|
|
break;
|
|
case Pivot.Right:
|
|
vector2 = new Vector2(Screen2.width, Screen2.height / 2);
|
|
vector3 = new Vector2(bounds.x, bounds.y / 2f);
|
|
break;
|
|
case Pivot.BottomRight:
|
|
vector2 = new Vector2(Screen2.width, Screen2.height);
|
|
vector3 = new Vector2(bounds.x, bounds.y);
|
|
break;
|
|
case Pivot.Bottom:
|
|
vector2 = new Vector2(Screen2.width / 2, Screen2.height);
|
|
vector3 = new Vector2(bounds.x / 2f, bounds.y);
|
|
break;
|
|
case Pivot.BottomLeft:
|
|
vector2 = new Vector2(0f, Screen2.height);
|
|
vector3 = new Vector2(0f, bounds.y);
|
|
break;
|
|
case Pivot.Left:
|
|
vector2 = new Vector2(0f, Screen2.height / 2);
|
|
vector3 = new Vector2(0f, bounds.y / 2f);
|
|
break;
|
|
case Pivot.Center:
|
|
vector2 = new Vector2(Screen2.width / 2, Screen2.height / 2);
|
|
vector3 = new Vector2(bounds.x / 2f, bounds.y / 2f);
|
|
break;
|
|
}
|
|
if (anchorObject != null)
|
|
{
|
|
Camera camera = ((!(anchorCamera != null)) ? Camera.main : anchorCamera);
|
|
vector2 = camera.WorldToScreenPoint(anchorObject.transform.position);
|
|
vector2.y = (float)Screen2.height - vector2.y;
|
|
}
|
|
return vector + vector2 - vector3 + pos;
|
|
}
|
|
|
|
protected override Color ComputeColor(Color localColor)
|
|
{
|
|
Color color = base.ComputeColor(localColor);
|
|
if (premultipliedAlpha)
|
|
{
|
|
color = PremultiplyAlpha(color);
|
|
}
|
|
return color;
|
|
}
|
|
|
|
protected Vector2 GetSizePixels(Vector2 manualSize)
|
|
{
|
|
Vector2 result;
|
|
switch (resizeMode)
|
|
{
|
|
case ResizeMode.None:
|
|
result = TextureSizePixels;
|
|
break;
|
|
case ResizeMode.Fixed:
|
|
result = manualSize;
|
|
break;
|
|
case ResizeMode.Stretch:
|
|
result = new Vector2(manualSize.x * (float)Screen2.width, manualSize.y * (float)Screen2.height);
|
|
break;
|
|
case ResizeMode.KeepRatio:
|
|
{
|
|
Vector2 textureSizePixels = TextureSizePixels;
|
|
float num = manualSize.y * (float)Screen2.height;
|
|
float x = textureSizePixels.x / textureSizePixels.y * num;
|
|
result = new Vector2(x, num);
|
|
break;
|
|
}
|
|
default:
|
|
Debug.LogError("Unknown resize mode: " + resizeMode);
|
|
result = manualSize;
|
|
break;
|
|
}
|
|
result.Scale(TransformScale());
|
|
return result;
|
|
}
|
|
|
|
protected void SetSizePixels(ref Vector2 manualSize, Vector2 value)
|
|
{
|
|
switch (resizeMode)
|
|
{
|
|
case ResizeMode.None:
|
|
break;
|
|
case ResizeMode.Fixed:
|
|
manualSize = value;
|
|
break;
|
|
case ResizeMode.Stretch:
|
|
manualSize = new Vector2(value.x / (float)Screen2.width, value.y / (float)Screen2.height);
|
|
break;
|
|
case ResizeMode.KeepRatio:
|
|
{
|
|
Vector2 textureSizePixels = TextureSizePixels;
|
|
float num = value.y / (float)Screen2.height;
|
|
float x = textureSizePixels.x / textureSizePixels.y * num;
|
|
manualSize = new Vector2(x, num);
|
|
break;
|
|
}
|
|
default:
|
|
Debug.LogError("Unknown resize mode: " + resizeMode);
|
|
manualSize = value;
|
|
break;
|
|
}
|
|
}
|
|
|
|
public void ResetSize()
|
|
{
|
|
SizePixels = TextureSizePixels;
|
|
}
|
|
|
|
protected override bool IsVisible()
|
|
{
|
|
if (!base.IsVisible())
|
|
{
|
|
return false;
|
|
}
|
|
if (anchorObject != null)
|
|
{
|
|
Camera camera = ((!(anchorCamera != null)) ? Camera.main : anchorCamera);
|
|
Vector3 lhs = anchorObject.transform.position - camera.transform.position;
|
|
float num = Vector3.Dot(lhs, camera.transform.forward);
|
|
return num >= 0f;
|
|
}
|
|
return true;
|
|
}
|
|
}
|