public override void render(Display display, RenderTarget rt, AddSpriteDelegate addSprite)
{
if (DataAccessor == null || !isVisible(DataAccessor.indicator()))
{
return;
}
if (Gradient.Count == 0)
{
addGradientColor(0f, Default.BarColor);
}
/*
* Vector2 position = PositionType == ValueType.Relative ? Position * display.RenderArea.Size : Position;
* Vector2 size = SizeType == ValueType.Relative ? Size * display.RenderArea.Size : Size;
* float borderSize = borderSizeType_ == ValueType.Relative ? borderSize_ * (size.X < size.Y ? size.X : size.Y) : borderSize_;
* float tileSpace = tileSpaceType_ == ValueType.Relative ? tileSpace_ * (size.X < size.Y ? size.X : size.Y) : tileSpace_;
*
* renderStyledBar_(addSprite, rt, position, size, rotation_, DataAccessor.min() < 0.0, tiles_, tileSpace, tileName_,
* (float)DataAccessor.indicator(), Gradient, borderSize, borderColor_, backgroundColor_);
*/
base.render(display, rt, addSprite);
Vector2 size = RenderData.OuterSize;
float tileSpace = tileSpaceType_ == ValueType.Relative ? tileSpace_ * (size.X < size.Y ? size.X : size.Y) : tileSpace_;
renderStyledBar_(addSprite, rt, RenderData.Position, RenderData.InnerSize, rotation_, DataAccessor.min() < 0.0, tiles_, tileSpace, tileName_,
(float)DataAccessor.indicator(), Gradient, 0f, Color.Black, Color.Black);
}
public override void render(Display display, RenderTarget rt, AddSpriteDelegate addSprite)
{
Color color = Color;
bool visible = true;
if (DataAccessor != null)
{
visible = isVisible(DataAccessor.indicator());
getGradientColorLerp((float)DataAccessor.indicator(), Gradient, out color);
}
if (!visible || (!toggleShow_ && blink_))
{
return;
}
//Vector2 size = SizeType == ValueType.Relative ? Size * display.RenderArea.Size : Size;
base.render(display, rt, addSprite);
icon_(addSprite, rt, iconName_,
//PositionType == ValueType.Relative ? Position * display.RenderArea.Size : Position,
RenderData.Position,
RenderData.InnerSize,
thicknessSizeType_ == ValueType.Relative ? thickness_ * RenderData.InnerSize.X : thickness_,
rotation_, color);
}
protected static void renderSimpleBar(AddSpriteDelegate addSprite, RenderTarget rt, Vector2 position, Vector2 size,
float rotation, bool doubleSided, int tiles, float tileSpace, string tileName, float ratio, Dictionary <float, Color> gradient,
float borderSize, Color borderColor, Color backgroundColor)
{
Vector2 innerSize = size - (borderSize * 2f);
Vector2 rtPosition = position + rt.DisplayOffset;
/*
* if (borderSize > 0f)
* addSprite(new MySprite(SpriteType.TEXTURE, IconNameSquareSimple, rtPosition, size, borderColor, rotation: rotation));
* if (backgroundColor.A > 0 || borderSize > 0f)
* addSprite(new MySprite(SpriteType.TEXTURE, IconNameSquareSimple, rtPosition, innerSize, backgroundColor, rotation: rotation));
*/
Vector2 barSize;
Vector2 barPosition;
if (doubleSided)
{
barSize = new Vector2(innerSize.X, innerSize.Y * ratio * 0.5f);
barPosition = new Vector2(0f, -barSize.Y * 0.5f);
}
else
{
barSize = new Vector2(innerSize.X, innerSize.Y * ratio);
barPosition = new Vector2(0f, (innerSize.Y * 0.5f) - barSize.Y * 0.5f);
}
barPosition.Rotate(rotation);
Color color;
getGradientColorLerp(ratio, gradient, out color);
addSprite(new MySprite(SpriteType.TEXTURE, IconNameSquareSimple, barPosition + rtPosition, barSize, color, rotation: rotation));
}
public override void render(Display display, RenderTarget rt, AddSpriteDelegate addSprite)
{
base.render(display, rt, addSprite);
RenderDataBattery renderData = RenderData as RenderDataBattery;
float positionX = renderData.Position.X + rt.DisplayOffset.X - (renderData.InnerSize.X * 0.5f) + (renderData.Size.X * 0.5f);
float positionY = renderData.Position.Y + rt.DisplayOffset.Y - (renderData.InnerSize.Y * 0.5f) + (renderData.Size.Y * 0.5f);
float offsetX = renderData.Size.X;
float offsetY = renderData.Size.Y;
// draw batteries
for (int r = 0; r < renderData.Rows; r++)
{
for (int c = 0; c < renderData.Cols; c++)
{
int index = (renderData.Cols * r) + c;
if (index >= renderData.Batteries.Count)
{
break;
}
IMyBatteryBlock battery = renderData.Batteries[index];
Vector2 position = new Vector2(positionX + (offsetX * c), positionY + (offsetY * r));
drawSingleBattery(position, renderData.Scale,
battery.CurrentStoredPower / battery.MaxStoredPower,
(battery.CurrentInput / battery.MaxInput) - (battery.CurrentOutput / battery.MaxOutput),
DataCollectorBase <IMyBatteryBlock> .isOn(battery),
battery.ChargeMode, addSprite);
}
}
}
protected static void renderTiledBar(AddSpriteDelegate addSprite, RenderTarget rt, Vector2 position, Vector2 size,
float rotation, bool doubleSided, int tiles, float tileSpace, string tileName, float ratio, Dictionary <float, Color> gradient,
float borderSize, Color borderColor, Color backgroundColor)
{
Vector2 innerSize = size - (borderSize * 2f);
Vector2 rtPosition = position + rt.DisplayOffset;
/*
* if (borderSize > 0f)
* addSprite(new MySprite(SpriteType.TEXTURE, IconNameSquareSimple, rtPosition, size, borderColor, rotation: rotation));
* if (backgroundColor.A > 0 || borderSize > 0f)
* addSprite(new MySprite(SpriteType.TEXTURE, IconNameSquareSimple, rtPosition, innerSize, backgroundColor, rotation: rotation));
*/
if (doubleSided)
{
innerSize.Y *= 0.5f;
}
Vector2 tileSize = new Vector2(innerSize.X - (borderSize > 0f ? tileSpace * 2f : 0f),
(innerSize.Y - (tileSpace * (tiles + (borderSize > 0f ? 1 : 0)))) / tiles);
float yOffset = 0f;
if (doubleSided)
{
yOffset = -(tileSize.Y * 0.5f + tileSpace);
}
else
{
yOffset = innerSize.Y * 0.5f - tileSize.Y * 0.5f - tileSpace;
}
float tileStep = tileSize.Y + tileSpace;
float step = 1f / tiles;
Color color;
if (ratio >= 0f)
{
for (int t = 0; t < Math.Round(ratio / step); t++)
{
Vector2 tilePosition = new Vector2(0f, -(t * tileStep) + yOffset);
tilePosition.Rotate(rotation);
getGradientColorLerp(t * step, gradient, out color);
addSprite(new MySprite(SpriteType.TEXTURE, tileName, tilePosition + rtPosition, tileSize, color, rotation: rotation));
}
}
else
{
for (int t = 1; t <= -Math.Round(ratio / step); t++)
{
Vector2 tilePosition = new Vector2(0f, (t * tileStep) + yOffset);
tilePosition.Rotate(rotation);
getGradientColorLerp(-t * step, gradient, out color);
addSprite(new MySprite(SpriteType.TEXTURE, tileName, tilePosition + rtPosition, tileSize, color, rotation: rotation));
}
}
}
protected static void renderSegmentedBar(AddSpriteDelegate addSprite, RenderTarget rt, Vector2 position, Vector2 size,
float rotation, bool doubleSided, int tiles, float tileSpace, string tileName, float ratio, Dictionary <float, Color> gradient,
float borderSize, Color borderColor, Color backgroundColor)
{
Vector2 innerSize = size - (borderSize * 2f);
Vector2 rtPosition = position + rt.DisplayOffset;
/*
* if (borderSize > 0f)
* addSprite(new MySprite(SpriteType.TEXTURE, IconNameSquareSimple, rtPosition, size, borderColor, rotation: rotation));
* if (backgroundColor.A > 0 || borderSize > 0f)
* addSprite(new MySprite(SpriteType.TEXTURE, IconNameSquareSimple, rtPosition, innerSize, backgroundColor, rotation: rotation));
*/
float startRatio = ratio;
float innerSizeOffset = 0f;
if (doubleSided)
{
startRatio = ratio >= 0f ? ratio : 0f;
innerSizeOffset = -innerSize.Y * 0.25f;
innerSize.Y *= 0.5f;
}
KeyValuePair <float, Color>[] colors = gradient.ToArray();
for (int c = 0; c < colors.Length && startRatio > 0f; ++c)
{
if (colors[c].Key > startRatio)
{
continue;
}
float curRatio = startRatio - colors[c].Key;
Vector2 barSize = new Vector2(innerSize.X, innerSize.Y * curRatio);
Vector2 barPosition = new Vector2(0f, -(colors[c].Key * innerSize.Y) + ((innerSize.Y - barSize.Y) * 0.5f) + innerSizeOffset);
barPosition.Rotate(rotation);
addSprite(new MySprite(SpriteType.TEXTURE, IconNameSquareSimple, barPosition + rtPosition, barSize, colors[c].Value, rotation: rotation));
startRatio -= curRatio;
}
for (int d = 0; d < colors.Length && startRatio > ratio; d++)
{
if (colors[d].Key >= 0f)
{
continue;
}
float curRatio = (colors[d].Key < ratio ? ratio : colors[d].Key) - startRatio;
Vector2 barSize = new Vector2(innerSize.X, innerSize.Y * curRatio);
Vector2 barPosition = new Vector2(0f, -(startRatio * innerSize.Y) + ((innerSize.Y - barSize.Y) * 0.5f) + innerSizeOffset);
barPosition.Rotate(rotation);
addSprite(new MySprite(SpriteType.TEXTURE, IconNameSquareSimple, barPosition + rtPosition, barSize, colors[d].Value, rotation: rotation));
startRatio += curRatio;
}
}
protected static void renderEllipseBar(AddSpriteDelegate addSprite, RenderTarget rt, Vector2 position, Vector2 size,
float degreeStart, float degreeEnd, float blockThickness, float ratio,
Dictionary <float, Color> gradient, bool lerp, Color backgroundColor)
{
Vector2 rtPosition = position + rt.DisplayOffset;
Vector2 halfSize = size * 0.5f;
float range = Math.Abs(degreeEnd - degreeStart);
float length = (float)(Math.PI * Math.Sqrt(2f * (halfSize.X * halfSize.X + halfSize.Y * halfSize.Y)));
float thickness = Math.Max(size.X, size.Y) * ((blockThickness * 0.01f) * (range / 360f));
float step = range / (length / thickness);
float max = range * ratio;
// render marker
for (float c = 0, degree = degreeStart + step; degree < degreeEnd; degree += step, c += step)
{
if (c >= max)
{
break;
}
float t = (degree / 180f) * (float)Math.PI + (degree < 0f ? (float)Math.PI * 2f : 0f);
Vector2 point = new Vector2(
-halfSize.X * (float)Math.Cos(t),
-halfSize.Y * (float)Math.Sin(t));
// axis vector
Vector2 axis;
if (degree >= 0f && degree < 180f)
{
axis = new Vector2(-1f, 0f);
}
else// if (degree >= 180f && degree < 360f)
{
axis = new Vector2(1f, 0f);
}
float delta = (float)Math.Acos(Vector2.Dot(Vector2.Normalize(point), axis));
Color color;
if (lerp)
{
getGradientColorLerp(c / range, gradient, out color);
}
else
{
getGradientColor(c / range, gradient, out color);
}
addSprite(new MySprite(SpriteType.TEXTURE, IconNameSquareSimple,
(point * 0.5f) + rtPosition,
new Vector2(point.Length(), thickness),
color, rotation: delta));
}
addSprite(new MySprite(SpriteType.TEXTURE, IconNameCircle, rtPosition, size * 0.5f, backgroundColor));
addSprite(new MySprite(SpriteType.TEXTURE, "CircleHollow", rtPosition, size * 1.06f, backgroundColor));
}
void drawChargeModeIndicator(AddSpriteDelegate addSprite, Vector2 position, float size, float rotation, Color color)
{
addSprite(new MySprite(SpriteType.TEXTURE, "AH_BoreSight",
new Vector2(position.X, position.Y - size * 0.2f),
new Vector2(size, size), color, rotation: rotation));
addSprite(new MySprite(SpriteType.TEXTURE, "AH_BoreSight",
new Vector2(position.X, position.Y + size * 0.2f),
new Vector2(size, size), color, rotation: rotation));
}
protected static void renderTextLine(Display display, RenderTarget rt, AddSpriteDelegate addSprite,
string font, float fontSize, Vector2 position, Color fontColor, string textLine, TextAlignment alignment)
{
// fix font position
Vector2 offset = new Vector2(rt.DisplayOffset.X, rt.DisplayOffset.Y - (0.61f * (fontSize * Default.CharHeight)));
MySprite sprite = MySprite.CreateText(textLine, font, fontColor, fontSize, alignment);
sprite.Position = position + offset;
addSprite(sprite);
}
public override void render(Display display, RenderTarget rt, AddSpriteDelegate addSprite)
{
base.render(display, rt, addSprite);
RenderDataList renderData = RenderData as RenderDataList;
Vector2 iconPosition = renderData.IconPosition;
Vector2 barPosition = renderData.BarPosition;
float textPositionY = renderData.TextPositionY;
// render name
for (int l = autoScrollLine_; l < (renderData.Lines + autoScrollLine_) && l < renderData.Container.Count; l++)
{
var entry = renderData.Container[l];
// draw icon
if (iconShow_)
{
string iconType = $"{entry.type.TypeId}/{entry.type.SubtypeId}";
if (RenderTarget.spriteExist(iconType))
{
addSprite(new MySprite(SpriteType.TEXTURE, iconType, iconPosition + rt.DisplayOffset, renderData.IconSize, Color.White));
}
iconPosition.Y += renderData.LineHeight;
}
// draw bar
if (barShow_)
{
barRenderMethod_(addSprite, rt, barPosition, renderData.BarSize, (float)Math.PI * 0.5f, false, renderData.BarTiles,
renderData.BarTileSpacing, IconNameSquareSimple, (float)entry.indicator, Gradient, 0f, Default.BarBorderColor, barBackground_);
barPosition.Y += renderData.LineHeight;
}
// draw text
if (textShow_)
{
renderTextLine(display, rt, addSprite, Template.Font, renderData.FontSize,
new Vector2(renderData.TextLeftPositionX, textPositionY),
getGradientColor((float)entry.indicator), entry.name, TextAlignment.LEFT);
if (textStyle_ != TextStyle.OnlyName)
{
renderTextLine(display, rt, addSprite, Template.Font, renderData.FontSize,
new Vector2(renderData.TextRightPositionX, textPositionY),
getGradientColor((float)entry.indicator), getRightText(entry), TextAlignment.RIGHT);
}
textPositionY += renderData.LineHeight;
}
}
}
public override void render(Display display, RenderTarget rt, AddSpriteDelegate addSprite)
{
if (!isVisible(DataAccessor.indicator()))
{
return;
}
renderEllipseBar(addSprite, rt, renderData_.position, renderData_.size, minDegree_, maxDegree_,
thickness_, renderData_.ratio, Gradient, colorLerp_, Template.BackgroundColor);
if (icon_ != null)
{
icon_(addSprite, rt, iconName_, renderData_.position, renderData_.iconSize, 1f, 0f, renderData_.iconColor);
}
}
public virtual void render(Display display, RenderTarget rt, AddSpriteDelegate addSprite)
{
// Render Background
if (RenderData.BackgroundColor.A > 0 && RenderData.BackgroundIcon != null)
{
RenderData.BackgroundIcon(addSprite, rt, RenderData.BackgroundIconName, RenderData.Position, RenderData.BackgroundSize,
RenderData.BackgroundThickness, RenderData.BackgroundRotation, RenderData.BackgroundColor);
}
// Render border
if (RenderData.BorderThickness > 0 && RenderData.BorderIcon != null)
{
RenderData.BorderIcon(addSprite, rt, RenderData.BorderName, RenderData.Position, RenderData.OuterSize,
RenderData.BorderThickness, RenderData.BorderRotation, RenderData.BorderColor);
}
}
public override void render(Display display, RenderTarget rt, AddSpriteDelegate addSprite)
{
RenderDataText renderData = RenderData as RenderDataText;
if (!renderData.Visible)
{
return;
}
for (int c = 0; c < renderData.Lines.Count; c++)
{
renderTextLine(display, rt, addSprite, Font, renderData.FontSize,
new Vector2(renderData.TextPosition.X, renderData.TextPosition.Y + (c * renderData.LineHeight)),
renderData.FontColor, renderData.Lines[c], TextAlignment);
}
}
static void renderIconDelimiter(AddSpriteDelegate addSprite, RenderTarget rt, string name,
Vector2 position, Vector2 size, float thickness, float rotation, Color color)
{
Vector2 rtPosition = position + rt.DisplayOffset;
Vector2 posBar = new Vector2(rtPosition.X + size.Y * 0.5f, rtPosition.Y);
addSprite(new MySprite(SpriteType.TEXTURE, IconNameSquareSimple, posBar, new Vector2(size.X - size.Y, size.Y), color, rotation: rotation));
Vector2 posEndLeft = new Vector2(-size.X * 0.5f + size.Y * 0.5f, 0f);
posEndLeft.Rotate(rotation);
addSprite(new MySprite(SpriteType.TEXTURE, IconNameCircle, posEndLeft + rtPosition, new Vector2(size.Y, size.Y), color));
Vector2 posEndRight = new Vector2(size.X * 0.5f - size.Y * 0.5f, 0f);
posEndRight.Rotate(rotation);
addSprite(new MySprite(SpriteType.TEXTURE, IconNameCircle, posEndRight + rtPosition, new Vector2(size.Y, size.Y), color));
}
public override void render(Display display, RenderTarget rt, AddSpriteDelegate addSprite)
{
if (DataAccessor == null || !isVisible(DataAccessor.indicator()))
{
return;
}
if (Gradient.Count == 0)
{
addGradientColor(0f, Default.BarColor);
}
//Vector2 position = PositionType == ValueType.Relative ? Position * display.RenderArea.Size : Position;
//Vector2 size = SizeType == ValueType.Relative ? Size * display.RenderArea.Size : Size;
base.render(display, rt, addSprite);
// draw slider
renderSlider(addSprite, rt, RenderData.Position, RenderData.InnerSize, DataAccessor.min() < 0.0,
(float)DataAccessor.indicator(), Gradient, sliderOrientation_, sliderWidth_, sliderColor_);
}
public override void render(Display display, RenderTarget rt, AddSpriteDelegate addSprite)
{
// render info text
string text = "Size=" + rt.Size.X.ToString("0000.00") + ";" + rt.Size.Y.ToString("0000.00");
var fontSize = display.measureLineInPixels(text, "debug", 1f);
float fontScale = Math.Min((rt.Size.X * 0.8f) / fontSize.X, (rt.Size.Y * 0.8f) / fontSize.Y);
var font = MySprite.CreateText(text, "debug", Color.White, fontScale);
font.Position = new Vector2(rt.Size.X * 0.5f, fontSize.Y * fontScale + 10.0f) + rt.DisplayOffset;
addSprite(font);
// render edges
Vector2 blockSize = new Vector2(20f, 20f);
addSprite(new MySprite(SpriteType.TEXTURE, IconNameSquareSimple, (rt.Size / 2f) + rt.DisplayOffset, blockSize, Color.White));
addSprite(new MySprite(SpriteType.TEXTURE, IconNameSquareSimple, (blockSize / 2f) + rt.DisplayOffset, blockSize, Color.Red));
addSprite(new MySprite(SpriteType.TEXTURE, IconNameSquareSimple, new Vector2(rt.Size.X - blockSize.X / 2f, blockSize.Y / 2f) + rt.DisplayOffset, blockSize, Color.Green));
addSprite(new MySprite(SpriteType.TEXTURE, IconNameSquareSimple, new Vector2(blockSize.X / 2f, rt.Size.Y - blockSize.Y / 2f) + rt.DisplayOffset, blockSize, Color.Blue));
addSprite(new MySprite(SpriteType.TEXTURE, IconNameSquareSimple, (rt.Size - (blockSize / 2f)) + rt.DisplayOffset, blockSize, Color.Yellow));
}
static void renderIconBorderSimple(AddSpriteDelegate addSprite, RenderTarget rt, string name,
Vector2 position, Vector2 size, float thickness, float rotation, Color color)
{
Vector2 rtPosition = position + rt.DisplayOffset;
Vector2 halfSize = size * 0.5f;
float halfThickness = thickness * 0.5f;
// top
Vector2 pos = new Vector2(0f, -halfSize.Y + halfThickness);
pos.Rotate(rotation);
addSprite(new MySprite(SpriteType.TEXTURE, IconNameSquareSimple,
pos + rtPosition,
new Vector2(size.X, thickness),
color, rotation: rotation));
// bottom
pos = new Vector2(0f, halfSize.Y - halfThickness);
pos.Rotate(rotation);
addSprite(new MySprite(SpriteType.TEXTURE, IconNameSquareSimple,
pos + rtPosition,
new Vector2(size.X, thickness),
color, rotation: rotation));
// left
pos = new Vector2(-halfSize.X + halfThickness, 0f);
pos.Rotate(rotation);
addSprite(new MySprite(SpriteType.TEXTURE, IconNameSquareSimple,
pos + rtPosition,
new Vector2(thickness, size.Y),
color, rotation: rotation));
// right
pos = new Vector2(halfSize.X - halfThickness, 0f);
pos.Rotate(rotation);
addSprite(new MySprite(SpriteType.TEXTURE, IconNameSquareSimple,
pos + rtPosition,
new Vector2(thickness, size.Y),
color, rotation: rotation));
}
void drawSingleBattery(Vector2 position, float scale, float capacity, float load, bool onoff, ChargeMode chargeMode, AddSpriteDelegate addSprite)
{
float borderSize = 8f * scale;
float capacityBorder = borderSize * 0.5f;
Vector2 poleSize = new Vector2(batterySize_.X * 0.5f, 10f) * scale;
Vector2 backgroundSize = new Vector2(batterySize_.X * scale, (batterySize_.Y * scale) - poleSize.Y);
Vector2 InnerSectionSize = backgroundSize - borderSize;
Color borderColor = onoff == false ? borderColors_[0] :
(chargeMode == ChargeMode.Recharge ? borderColors_[3] :
(chargeMode == ChargeMode.Discharge ? borderColors_[4] :
(load <= 0f ? borderColors_[1] : borderColors_[2])));
// draw plus pole
addSprite(new MySprite(SpriteType.TEXTURE, IconNameSquareSimple,
new Vector2(position.X, position.Y - backgroundSize.Y * 0.5f),
poleSize, borderColor));
// draw background
addSprite(new MySprite(SpriteType.TEXTURE, IconNameSquareSimple,
new Vector2(position.X, position.Y + poleSize.Y * 0.5f),
backgroundSize, borderColor));
// draw inner section
addSprite(new MySprite(SpriteType.TEXTURE, IconNameSquareSimple,
new Vector2(position.X, position.Y + poleSize.Y * 0.5f),
InnerSectionSize, Template.BackgroundColor));
// react on on/off state
if (onoff == true)
{
// draw capacity marker
Vector2 capacitySize = new Vector2(InnerSectionSize.X - capacityBorder * 2f,
(InnerSectionSize.Y - (capacityBorder * (capacitySegments_ + 1f))) / capacitySegments_);
float capacityYOffset = capacitySize.Y + capacityBorder;
float capacityYPosition = position.Y + (poleSize.Y + InnerSectionSize.Y - capacitySize.Y) * 0.5f - capacityBorder;
for (int s = 0; s < 6; s++)
{
float lerp = (1f / capacitySegments_) * s;
if (capacity <= lerp)
{
break;
}
addSprite(new MySprite(SpriteType.TEXTURE, IconNameSquareSimple,
new Vector2(position.X, capacityYPosition - (capacityYOffset * s)),
capacitySize, Color.Lerp(barColors_[0], barColors_[1], lerp)));
}
if (chargeMode == ChargeMode.Recharge)
{
drawChargeModeIndicator(addSprite, new Vector2(position.X, position.Y + poleSize.Y * 0.5f),
InnerSectionSize.X * 1.3f, (float)(Math.PI * 1.5), borderColor);
}
else if (chargeMode == ChargeMode.Discharge)
{
drawChargeModeIndicator(addSprite, new Vector2(position.X, position.Y + poleSize.Y * 0.5f),
InnerSectionSize.X * 1.3f, (float)(Math.PI * 0.5), borderColor);
}
}
else
{
addSprite(new MySprite(SpriteType.TEXTURE, "Cross",
new Vector2(position.X, position.Y + poleSize.Y * 0.5f),
new Vector2(InnerSectionSize.X, InnerSectionSize.X) * 0.9f,
Color.Red));
}
}
protected void renderSlider(AddSpriteDelegate addSprite, RenderTarget rt, Vector2 position, Vector2 size, bool doubleSided,
float ratio, Dictionary <float, Color> barGradient, SliderOrientation sliderOrientation, float sliderWidth, Color sliderColor)
{
ratio = !doubleSided ? ((ratio * 2f) - 1f) * 0.5f : ratio * 0.5f;
bool vertical = sliderOrientation == SliderOrientation.Left || sliderOrientation == SliderOrientation.Right;
float rotation = vertical ? 0f : (float)Math.PI * 0.5f;
Vector2 rtPosition = position + rt.DisplayOffset;
Vector2 sliderSize;
Vector2 sliderPosition;
Vector2 barPosition;
Vector2 barSize;
const float barHeightFactor = 0.8f;
const float sliderHeightFactor = 0.9f;
if (vertical)
{
sliderSize = new Vector2(size.X * sliderHeightFactor, sliderWidth * size.Y);
barSize = new Vector2(size.X * barHeightFactor, size.Y - sliderSize.Y);
if (sliderOrientation == SliderOrientation.Left)
{
barPosition = new Vector2(position.X + (size.X - barSize.X) * 0.5f, position.Y);
sliderPosition = new Vector2(rtPosition.X - (size.X - sliderSize.X) * 0.5f, rtPosition.Y - ratio * barSize.Y);
}
else
{
barPosition = new Vector2(position.X - (size.X - barSize.X) * 0.5f, position.Y);
sliderPosition = new Vector2(rtPosition.X + (size.X - sliderSize.X) * 0.5f, rtPosition.Y - ratio * barSize.Y);
}
}
else
{
sliderSize = new Vector2(sliderWidth * size.X, size.Y * sliderHeightFactor);
barSize = new Vector2(size.Y * barHeightFactor, size.X - sliderSize.X);
if (sliderOrientation == SliderOrientation.Top)
{
barPosition = new Vector2(position.X, position.Y + (size.Y - barSize.X) * 0.5f);
sliderPosition = new Vector2(rtPosition.X + ratio * barSize.Y, rtPosition.Y - (size.Y - sliderSize.Y) * 0.5f);
}
else
{
barPosition = new Vector2(position.X, position.Y - (size.Y - barSize.X) * 0.5f);
sliderPosition = new Vector2(rtPosition.X + ratio * barSize.Y, rtPosition.Y + (size.Y - sliderSize.Y) * 0.5f);
}
}
if (doubleSided == true)
{
Dictionary <float, Color> clamped = new Dictionary <float, Color>();
foreach (var pair in barGradient)
{
clamped.Add((pair.Key * 0.5f) + 0.5f, pair.Value);
}
renderSegmentedBar(addSprite, rt, barPosition, barSize, rotation, false, 0, 0f, "", 1f, clamped, 0f, Color.White, new Color(0, 0, 0, 0));
}
else
{
renderSegmentedBar(addSprite, rt, barPosition, barSize, rotation, false, 0, 0f, "", 1f, barGradient, 0f, Color.White, new Color(0, 0, 0, 0));
}
// draw slider
if (vertical)
{
if (sliderOrientation == SliderOrientation.Left)
{
addSprite(new MySprite(SpriteType.TEXTURE, IconNameCircle,
new Vector2(sliderPosition.X - sliderSize.X * 0.5f + sliderSize.Y * 0.5f, sliderPosition.Y),
new Vector2(sliderSize.X), sliderColor));
addSprite(new MySprite(SpriteType.TEXTURE, "Triangle",
new Vector2(sliderPosition.X + sliderSize.X * 0.5f - sliderSize.Y * 0.5f, sliderPosition.Y),
new Vector2(sliderSize.Y, sliderSize.Y),
sliderColor, rotation: (float)(Math.PI * 0.5f)));
addSprite(new MySprite(SpriteType.TEXTURE, IconNameSquareSimple,
new Vector2(sliderPosition.X - sliderSize.Y * 0.25f, sliderPosition.Y),
new Vector2(sliderSize.X - sliderSize.Y * 1.5f, sliderSize.Y),
sliderColor));
}
else
{
addSprite(new MySprite(SpriteType.TEXTURE, IconNameCircle,
new Vector2(sliderPosition.X + sliderSize.X * 0.5f - sliderSize.Y * 0.5f, sliderPosition.Y),
new Vector2(sliderSize.X), sliderColor));
addSprite(new MySprite(SpriteType.TEXTURE, "Triangle",
new Vector2(sliderPosition.X - sliderSize.X * 0.5f + sliderSize.Y * 0.5f, sliderPosition.Y),
new Vector2(sliderSize.Y, sliderSize.Y),
sliderColor, rotation: (float)(Math.PI * 1.5f)));
addSprite(new MySprite(SpriteType.TEXTURE, IconNameSquareSimple,
new Vector2(sliderPosition.X + sliderSize.Y * 0.25f, sliderPosition.Y),
new Vector2(sliderSize.X - sliderSize.Y * 1.5f, sliderSize.Y),
sliderColor));
}
}
else
{
if (sliderOrientation == SliderOrientation.Top)
{
addSprite(new MySprite(SpriteType.TEXTURE, IconNameCircle,
new Vector2(sliderPosition.X, sliderPosition.Y - sliderSize.Y * 0.5f + sliderSize.X * 0.5f),
new Vector2(sliderSize.X), sliderColor));
addSprite(new MySprite(SpriteType.TEXTURE, "Triangle",
new Vector2(sliderPosition.X, sliderPosition.Y + sliderSize.Y * 0.5f - sliderSize.X * 0.5f),
new Vector2(sliderSize.X, sliderSize.X),
sliderColor, rotation: (float)(Math.PI)));
addSprite(new MySprite(SpriteType.TEXTURE, IconNameSquareSimple,
new Vector2(sliderPosition.X, sliderPosition.Y - sliderSize.X * 0.25f),
new Vector2(sliderSize.X, sliderSize.Y - sliderSize.X * 1.5f),
sliderColor));
}
else
{
addSprite(new MySprite(SpriteType.TEXTURE, IconNameCircle,
new Vector2(sliderPosition.X, sliderPosition.Y + sliderSize.Y * 0.5f - sliderSize.X * 0.5f),
new Vector2(sliderSize.X), sliderColor));
addSprite(new MySprite(SpriteType.TEXTURE, "Triangle",
new Vector2(sliderPosition.X, sliderPosition.Y - sliderSize.Y * 0.5f + sliderSize.X * 0.5f),
new Vector2(sliderSize.X, sliderSize.X),
sliderColor));
addSprite(new MySprite(SpriteType.TEXTURE, IconNameSquareSimple,
new Vector2(sliderPosition.X, sliderPosition.Y + sliderSize.X * 0.25f),
new Vector2(sliderSize.X, sliderSize.Y - sliderSize.X * 1.5f),
sliderColor));
}
}
}
static void renderSEIcon(AddSpriteDelegate addSprite, RenderTarget rt, string name,
Vector2 position, Vector2 size, float thickness, float rotation, Color color)
{
addSprite(new MySprite(SpriteType.TEXTURE, name, position + rt.DisplayOffset, size, color, rotation: rotation));
}
