//private void init()
//{
// _transform = this.gameObject.transform2();
//}
private void render()
{
if (frame >= frames.Count || frame < 0)
{
return;
}
var src = AxisAlignedBox.FromRect(frames[frame].point * size, frames[frame].size);
Root.instance.graphics.Draw(renderQuere,
material,
gameObject.transform.DerivedPosition + offset,
src,
color,
gameObject.transform.DerivedOrientation + rotation,
Vector2.Zero,//origin,
size * gameObject.transform.DerivedScale,
spriteEffect,
gameObject.transform.DerivedDepth);
//var end = ProjectPointFromCenterRotation(100);
//Root.instance.graphics.DrawLine(renderQuere, material, _transform.DerivedPosition, end, color);
}
/// <summary>
/// Allows for merging two boxes together (combining).
/// </summary>
/// <param name="box">Source box.</param>
public void Merge(AxisAlignedBox box)
{
if (box.IsNull)
{
// nothing to merge with in this case, just return
return;
}
else if (box.IsInfinite)
{
this.IsInfinite = true;
}
else if (this.IsNull)
{
SetExtents(box.Minimum, box.Maximum);
}
else if (!this.IsInfinite)
{
if (box.minVector.X < minVector.X)
{
minVector.X = box.minVector.X;
}
if (box.maxVector.X > maxVector.X)
{
maxVector.X = box.maxVector.X;
}
if (box.minVector.Y < minVector.Y)
{
minVector.Y = box.minVector.Y;
}
if (box.maxVector.Y > maxVector.Y)
{
maxVector.Y = box.maxVector.Y;
}
UpdateCorners();
}
}
public void draw(int renderQueue, int sprite, AxisAlignedBox rectangle, Color color, float depth)
{
draw(renderQueue, sprite, rectangle, color, SpriteEffects.None, depth);
}
public void draw(int sprite, AxisAlignedBox rectangle, Color color)
{
draw(sprite, rectangle, color, SpriteEffects.None, 0f);
}
/// <summary>
/// Tests whether this ray intersects the given box.
/// </summary>
/// <param name="box"></param>
/// <returns>
/// Struct containing info on whether there was a hit, and the distance from the
/// origin of this ray where the intersect happened.
/// </returns>
public IntersectResult Intersects(AxisAlignedBox box)
{
return(Utility.Intersects(this, box));
}
/// <summary>
/// Returns whether or not this Circle interects a box.
/// </summary>
/// <param name="box"></param>
/// <returns>True if the box intersects, false otherwise.</returns>
public bool Intersects(AxisAlignedBox box)
{
return(Utility.Intersects(this, box));
}
internal void Draw(RenderManager graphics, GUIContent content, GUIDrawArguments drawArgs)
{
var size = drawArgs.position.Size;
if (fixedWidth > 0f)
{
size.X = fixedWidth;
}
if (fixedHeight > 0f)
{
size.Y = fixedHeight;
}
drawArgs.content = AxisAlignedBox.FromRect(drawArgs.position.minVector + padding.min, size - padding.max - padding.min);
var textSize = Vector2.Zero;
if (!string.IsNullOrEmpty(content.text))
{
if (wordWrap)
{
textSize = font.MeasureString(content.text, drawArgs.content.Size);
}
else
{
textSize = font.MeasureString(content.text);
}
}
var remainingWidth = drawArgs.content.Width - textSize.X;
var remainingHeight = drawArgs.content.Height - textSize.Y;
var drawIcon = content.icon != null;
var drawText = !string.IsNullOrEmpty(content.text);
var state = getState(drawArgs);
if (remainingWidth <= 0 && imagePosition == ImagePosition.ImageLeft)
{
textSize.X = drawArgs.content.Width;
drawIcon = false;
}
else if (remainingHeight <= 0 && imagePosition == ImagePosition.ImageAbove)
{
textSize.Y = drawArgs.content.Height;
drawIcon = false;
}
var material = state.material;// Root.instance.resources.createMaterialFromTexture("content/textures/gui/box.png")
if (material != null)
{
if (border.min == Vector2.Zero && border.max == Vector2.Zero)
{
graphics.Draw(material, drawArgs.position, state.backgroundColor);
}
else
{
var src = AxisAlignedBox.FromRect(Vector2.Zero, material.textureSize);
var dstRects = drawArgs.position.fromRectOffset(border);
var srcRects = src.fromRectOffset(border);
for (var i = 0; i < dstRects.Length; i++)
{
if (dstRects[i].Width > 0 && dstRects[i].Height > 0)
{
graphics.Draw(material, dstRects[i], srcRects[i], state.backgroundColor);
}
}
}
}
if (drawIcon && imagePosition == ImagePosition.ImageLeft)
{
AxisAlignedBox icon, text;
computeTextAndIconLeft(content, drawArgs.content, textSize, remainingWidth, out icon, out text);
graphics.Draw(content.icon, icon, Color.White);
font.DrawText(graphics.currentRenderQueue, text.minVector, this.fontSize, content.text, state.textColor, 0f, text.Width);
}
else if (drawIcon && imagePosition == ImagePosition.ImageAbove)
{
AxisAlignedBox icon, text;
computeTextAndIconAbove(content, drawArgs.content, textSize, remainingHeight, out icon, out text);
graphics.Draw(content.icon, icon, Color.White);
if (wordWrap)
{
font.DrawWrappedOnWordText(graphics.currentRenderQueue, text.minVector, this.fontSize, content.text, state.textColor, 0f, text.Size);
}
else
{
font.DrawText(graphics.currentRenderQueue, text.minVector, this.fontSize, content.text, state.textColor, 0f, text.Width);
}
}
else if (drawText && imagePosition != ImagePosition.ImageOnly)
{
var position = computePosition(drawArgs.content, textSize);
if (wordWrap)
{
font.DrawWrappedOnWordText(graphics.currentRenderQueue, position.minVector, this.fontSize, content.text, state.textColor, 0f, position.Size);
}
else
{
font.DrawText(graphics.currentRenderQueue, position.minVector, this.fontSize, content.text, state.textColor, 0f, position.Width);
}
}
else if (drawIcon && imagePosition != ImagePosition.TextOnly)
{
var position = computePosition(drawArgs.content, content.icon.textureSize);
graphics.Draw(content.icon, position, Color.White);
graphics.DrawRect(position, Color.Blue);
}
}
internal void Draw(RenderManager graphics, AxisAlignedBox position, Material image, bool isHover, bool isActive, bool on, bool hasKeyboardFocus)
{
Draw(graphics, position, new GUIContent(image), isHover, isActive, on, hasKeyboardFocus);
}
internal void Draw(RenderManager graphics, AxisAlignedBox position, bool isHover, bool isActive, bool on, bool hasKeyboardFocus)
{
Draw(graphics, position, GUIContent.none, isHover, isActive, on, hasKeyboardFocus);
}
internal void computeTextAndIconAbove(GUIContent content, AxisAlignedBox area, Vector2 textSize, float remainingHeight, out AxisAlignedBox icon, out AxisAlignedBox text)
{
var textSizeOver2 = textSize / 2;
var positionSizeOver2 = area.Size / 2;
var drawPosition = area.minVector;
var scaleSize = Vector2.One * Utility.Min(remainingHeight, area.Height);
var iconSize = Utility.ScaleToSize(content.icon.textureSize, scaleSize);
var iconSizeOver2 = iconSize / 2;
var iconPosition = area.minVector;
switch (alignment)
{
case GUIAnchor.UpperLeft:
drawPosition.Y += iconSize.Y;
break;
case GUIAnchor.MiddleLeft:
{
var size = (area.Height - (iconSize.Y + textSize.Y)) / 2;
iconPosition.Y += size;
drawPosition.Y = iconPosition.Y + iconSize.Y;
}
break;
case GUIAnchor.LowerLeft:
drawPosition.Y = area.Y1 - textSize.Y;
iconPosition.Y = drawPosition.Y - iconSize.Y;
break;
case GUIAnchor.UpperRight:
drawPosition.X = area.X1 - textSize.X;
drawPosition.Y += iconSize.Y;
iconPosition.X += area.Width - iconSize.X;
break;
case GUIAnchor.MiddleRight:
{
var sizeH = (area.Height - (iconSize.Y + textSize.Y)) / 2;
drawPosition.X = area.X1 - textSize.X;
iconPosition.X = area.X1 - iconSize.X;
iconPosition.Y += sizeH;
drawPosition.Y = iconPosition.Y + iconSize.Y;
}
break;
case GUIAnchor.LowerRight:
drawPosition.Y = area.Y1 - textSize.Y;
drawPosition.X = area.X1 - textSize.X;
iconPosition.X = area.X1 - iconSize.X;
iconPosition.Y = drawPosition.Y - iconSize.Y;
break;
case GUIAnchor.UpperCenter:
drawPosition.X = area.X0 + positionSizeOver2.X - textSizeOver2.X;
iconPosition.X += positionSizeOver2.X - iconSizeOver2.X;
drawPosition.Y += iconSize.Y;
break;
case GUIAnchor.MiddleCenter:
{
var sizeH = (area.Height - (iconSize.Y + textSize.Y)) / 2;
iconPosition.X += positionSizeOver2.X - iconSizeOver2.X;
iconPosition.Y += sizeH;
drawPosition.X = area.X0 + positionSizeOver2.X - textSizeOver2.X;
drawPosition.Y = iconPosition.Y + iconSize.Y;
break;
}
case GUIAnchor.LowerCenter:
drawPosition.Y = area.Y1 - textSize.Y;
drawPosition.X = area.X0 + positionSizeOver2.X - textSizeOver2.X;
iconPosition.X += positionSizeOver2.X - iconSizeOver2.X;
iconPosition.Y = drawPosition.Y - iconSize.Y;
break;
}
switch (alignment)
{
case GUIAnchor.LowerLeft:
case GUIAnchor.MiddleLeft:
case GUIAnchor.UpperLeft:
if (textSize.X > iconSize.X)
{
iconPosition.X += textSizeOver2.X - iconSizeOver2.X;
}
else
{
drawPosition.X += iconSizeOver2.X - textSizeOver2.X;
}
break;
case GUIAnchor.LowerRight:
case GUIAnchor.MiddleRight:
case GUIAnchor.UpperRight:
if (textSize.X > iconSize.X)
{
iconPosition.X -= textSizeOver2.X - iconSizeOver2.X;
}
else
{
drawPosition.X -= iconSizeOver2.X - textSizeOver2.X;
}
break;
}
icon = AxisAlignedBox.FromRect(iconPosition + contentOffset, iconSize);
text = AxisAlignedBox.FromRect(drawPosition + contentOffset, textSize);
}
public virtual void renderItem(Material material, int renderQueue, Vector2 position, AxisAlignedBox src,
Color color, float rotation, Vector2 origin, Vector2 size, Vector2 scale, SpriteEffects spriteEffect)
{
if (material != null)
{
Root.instance.graphics.Draw(renderQueue,
material,
position,
src,
color,
rotation,
origin,
size * scale,
spriteEffect, 0f);
}
}
public bool Contains(AxisAlignedBox box)
{
return(Contains(box.minVector) && Contains(box.maxVector));
}
