public override void Render(Canvas2D canvas, RendererBase renderer)
{
if (BonusAnimation != null)
{
renderer.Render(canvas, this);
}
}
public override void Render(Canvas2D canvas)
{
base.Render(canvas);
if (CurrentAnimation != null && CurrentAnimation.Frames.Count > 0)
{
canvas.DrawText(Font, Vector2.Zero,
string.Format("Frame: {0}/{1} | Offset: {2};{3} | Origin:{4};{5}",
CurrentAnimation.CurrentFrameIndex + 1, CurrentAnimation.Frames.Count,
CurrentAnimation.CurrentFrame.OffSetX,
CurrentAnimation.CurrentFrame.OffSetY,
(int)CurrentAnimation.CurrentFrame.OriginX,
(int)CurrentAnimation.CurrentFrame.OriginY), ColorU.White);
using (canvas <= Camera.Transformation)
{
CurrentAnimation.Draw(canvas);
if (_drawFrameDebug && CurrentAnimation.Frames.Count > 0)
{
Frame curFrame = CurrentAnimation.CurrentFrame;
canvas.DrawRect(
Rect.FromBox(curFrame.OffSetX - curFrame.SpriteFrame.Width / 2f,
curFrame.OffSetY - curFrame.SpriteFrame.Height / 2, curFrame.SpriteFrame.Width,
curFrame.SpriteFrame.Height), ColorU.Red);
canvas.DrawLine(-5, 0, 5, 0, _originMarkLineStyle, ColorU.GreenYellow);
canvas.DrawLine(0, -5, 0, 5, _originMarkLineStyle, ColorU.GreenYellow);
}
}
}
guiManager.DrawControls(canvas);
}
private void DrawAnimStripDecoration(Canvas2D canvas)
{
//-----------------------------TOP-STRIP------------------------------------------
canvas.DrawLine(0, 2, RenderRegion.Right, 2, new LineStyle(2f, LineStroke.Solid), ColorU.Black);
canvas.DrawLine(0, 2, RenderRegion.Right, 2, new LineStyle(2f, LineStroke.Dashed), ColorU.White);
canvas.DrawLine(0, 3, RenderRegion.Right, 3, new LineStyle(2f, LineStroke.Solid), ColorU.Black);
canvas.DrawLine(0, 3, RenderRegion.Right, 3, new LineStyle(2f, LineStroke.Dashed), ColorU.White);
canvas.DrawLine(0, 4, RenderRegion.Right, 4, new LineStyle(2f, LineStroke.Solid), ColorU.Black);
canvas.DrawLine(0, 4, RenderRegion.Right, 4, new LineStyle(2f, LineStroke.Dashed), ColorU.White);
canvas.DrawLine(0, 5, RenderRegion.Right, 5, new LineStyle(2f, LineStroke.Solid), ColorU.Black);
canvas.DrawLine(0, 5, RenderRegion.Right, 5, new LineStyle(2f, LineStroke.Dashed), ColorU.White);
//-----------------------------BOTTOM-STRIP----------------------------------------
canvas.DrawLine(0, RenderRegion.Bottom - 2, RenderRegion.Right, RenderRegion.Bottom - 2,
new LineStyle(2f, LineStroke.Solid), ColorU.Black);
canvas.DrawLine(0, RenderRegion.Bottom - 2, RenderRegion.Right, RenderRegion.Bottom - 2,
new LineStyle(2f, LineStroke.Dashed), ColorU.White);
canvas.DrawLine(0, RenderRegion.Bottom - 3, RenderRegion.Right, RenderRegion.Bottom - 3,
new LineStyle(2f, LineStroke.Solid), ColorU.Black);
canvas.DrawLine(0, RenderRegion.Bottom - 3, RenderRegion.Right, RenderRegion.Bottom - 3,
new LineStyle(2f, LineStroke.Dashed), ColorU.White);
canvas.DrawLine(0, RenderRegion.Bottom - 4, RenderRegion.Right, RenderRegion.Bottom - 4,
new LineStyle(2f, LineStroke.Solid), ColorU.Black);
canvas.DrawLine(0, RenderRegion.Bottom - 4, RenderRegion.Right, RenderRegion.Bottom - 4,
new LineStyle(2f, LineStroke.Dashed), ColorU.White);
canvas.DrawLine(0, RenderRegion.Bottom - 5, RenderRegion.Right, RenderRegion.Bottom - 5,
new LineStyle(2f, LineStroke.Solid), ColorU.Black);
canvas.DrawLine(0, RenderRegion.Bottom - 5, RenderRegion.Right, RenderRegion.Bottom - 5,
new LineStyle(2f, LineStroke.Dashed), ColorU.White);
//-----------------------------BACKGROUND--------------------------------------------
canvas.DrawFilledRect(0, 7, RenderRegion.Width, RenderRegion.Height - 13, ColorU.Black.MultiplyAlpha(0.6f));
}
public override void OnDraw(Canvas2D canvas)
{
if (SelectRect.Width > 0 && SelectRect.Height > 0)
{
canvas.DrawRect(SelectRect, new LineStyle(2f, LineStroke.Dashed), ColorU.Orange);
}
}
public void Initialize(Control target)
{
_mDevice = new SingleContextDevice(target.Handle);
_mCanvas = _mDevice.Context.Canvas;
Initialized = true;
_mDevice.Context.Resize(target.Size);
}
public override void Render(Canvas2D canvas, RendererBase renderer)
{
if (Sprite != null)
{
renderer.Render(canvas, this);
}
}
public override void DrawWindowBorder(Canvas2D canvas, Color color, float x, float y, float w, float h)
{
var topColor = Color.Lerp(color, Color.White, 0.7f);
canvas.SetLinearGradientFill(new Vector2(x, y), new Vector2(x, y + h), new GradientStop(0, topColor), new GradientStop(1, color));
canvas.DrawRectangle(x, y, w, h);
}
public override void Render(Canvas2D canvas)
{
base.Render(canvas);
if (CurrentSpriteSheet != null)
{
using (canvas <= Camera.Transformation)
{
Rect boundingRect = Rect.FromBox(CurrentSpriteSheet.BoundingRect.LeftTop.Floored,
new Vector2(CurrentSpriteSheet.BoundingRect.Width,
CurrentSpriteSheet.BoundingRect.Height));
canvas.DrawRect(boundingRect, new LineStyle(2f, LineStroke.Solid), ColorU.Red);
canvas.DrawSprite(Vector2.Zero, 0f, CurrentSpriteSheet.Texture.ToSprite(), ColorU.White);
foreach (SpriteSheetFrame frame in CurrentSpriteSheet.Frames)
{
ColorU color;
if (frame.Highlighted && !frame.Selected)
{
color = Configuration.HoverFrameRectColor;
}
else if (frame.Selected)
{
color = Configuration.SelectedFrameRectColor;
}
else
{
color = Configuration.FrameRectColor;
}
Rect frameBoundingRect = frame.RelativeBoundingRect;
canvas.DrawRect(frameBoundingRect, new LineStyle(2f, LineStroke.Solid), color);
}
_stateHandler.Draw(canvas);
//if (GridEnabled && Camera.Zoom > 4f)
//{
// Point start = Camera.ScreenToWorld(Vector2.Zero).ToPoint();
// for (int i = start.X; i < RenderRegion.Width; i++)
// {
// canvas.DrawLine(i, start.Y, i, RenderRegion.Height, ColorU.Gray.MultiplyAlpha(0.5f));
// }
// for (int i = start.Y; i < RenderRegion.Height; i++)
// {
// canvas.DrawLine(start.X, i, RenderRegion.Width, i, ColorU.Gray.MultiplyAlpha(0.5f));
// }
//}
}
}
guiManager.DrawControls(canvas);
}
public void Draw(Canvas2D canvas)
{
if (CurrentState != null)
{
CurrentState.OnDraw(canvas);
}
}
internal override void Render(Canvas2D canvas)
{
skin.DrawWindowShadow(canvas, Left, Top, Width, Height);
skin.DrawWindowBackground(canvas, BackgroundColor, Left, Top, Width, Height);
skin.DrawWindowBorder(canvas, BorderColor, Left, Top, Width, Height);
skin.DrawWindowTopBar(canvas, Left, Top, Width, 38);
skin.DrawWindowTitle(canvas, Left, Top, Width, 40, Text);
}
public override void Draw(Canvas2D canvas, float dt)
{
canvas.Begin();
canvas.DrawQuad(in quad);
canvas.End();
}
public override void Draw(Canvas2D canvas, float dt)
{
canvas.Begin();
canvas.DrawTriangle(vertices[0], vertices[1], vertices[2]);
canvas.End();
}
public override void DrawWindowBackground(Canvas2D canvas, Color color, float x, float y, float w, float h)
{
var bottomColor = Color.Lerp(color, Color.Black, 0.5f);
canvas.SetLinearGradientFill(new Vector2(x, y), new Vector2(x, y + h), new GradientStop(0, color), new GradientStop(1, bottomColor));
canvas.FillRectangle(x, y, w, h);
canvas.SetLinearGradientFill(new Vector2(x + 5, y + 5), new Vector2(x - 5, y + h - 5), new GradientStop(0, Color.Transparent), new GradientStop(0.2f, Color.Transparent), new GradientStop(1f, new Color(1, 1, 1, 0.2f)));
canvas.FillRectangle(x + 5, y + 5, w - 10, h - 10);
}
private void GraphicView_OnUnloaded(object sender, RoutedEventArgs e)
{
foreach (var link in _links)
{
link.Dispose();
}
Canvas2D.RemoveFromVisualTree();
Canvas2D = null;
}
public override void Draw(Canvas2D canvas, float dt)
{
canvas.Begin();
sprite.Draw(canvas);
character.Draw(canvas);
canvas.End();
}
public override void Draw(Canvas2D canvas, float dt)
{
canvas.Begin();
canvas.DrawString("HELLO WORLD ! hello world ! 0123456789", new Vec2(0, 0), Color.Green);
canvas.DrawString("This is OMEGA ENGINE", new Vec2(5, 15), Color.White);
canvas.DrawString($"Draw Calls: {Engine.Canvas.MaxDrawCalls}", new Vec2(5, 25), Color.OrangeRed);
canvas.End();
}
public MainForm() {
InitializeComponent();
device = new SingleContextDevice(panel1.Handle);
device.Context.VerticalSync = false;
canvas = device.Context.Canvas;
GenerateField(true);
toolTip.SetToolTip(trackBar1, "Update speed. Value - " + trackBar1.Value + " ms.");
}
public override void Render(Canvas2D canvas)
{
base.Render(canvas);
DrawAnimStripDecoration(canvas);
using (canvas <= Camera.Transformation)
{
_animationStrip.Draw(canvas);
}
}
public void DrawControls(Canvas2D canvas)
{
foreach (var control in _rootControls)
{
if (!control.Visible)
{
continue;
}
control.Draw(canvas);
}
}
public override void Draw(Canvas2D canvas, float dt)
{
canvas.Begin(left_view);
canvas.DrawQuad(in bg_quad, bg_tile);
canvas.DrawQuad(in quad, texture);
canvas.End();
canvas.Begin(right_view);
canvas.DrawQuad(in bg_quad, bg_tile);
canvas.DrawQuad(in quad, texture);
canvas.End();
}
private void Selector_OnSelectionChanged(object sender, SelectionChangedEventArgs e)
{
var selection = (string)e.AddedItems.SingleOrDefault();
if (selection == null || _points.ContainsKey(selection))
{
return;
}
var(info, port) =
Global.Instance.Receiver.Ports.Single(it => it.Key.ToString() == selection);
port.LinkTo(new ActionBlock <List <Vector3> >(
frame => {
var topic = info.ToString();
var list = _points.GetOrAdd(topic, _ => new List <Vector3>());
var config = _configs.GetOrAdd(topic, _ => {
var it = new GraphicConfig(topic)
{
ShowCount = ViewModelContext.DefaultConfig.ShowCount,
SaveCount = ViewModelContext.DefaultConfig.SaveCount,
Background = ViewModelContext.DefaultConfig.Background,
Connect = ViewModelContext.DefaultConfig.Connect
};
it.PropertyChanged += (__, ___) => Canvas2D.Invalidate();
var ____ = MainList.Dispatcher.RunAsync(
Windows.UI.Core.CoreDispatcherPriority.Normal,
() => {
MainList.Items?.Add(it);
MainList.SelectedItems.Add(it);
});
return(it);
});
if (ViewModelContext.Frozen)
{
return;
}
lock (list) {
if (info.Type == GraphType.Frame)
{
list.Clear();
}
list.AddRange(frame);
var verbose = list.Count - _configs[topic].SaveCount;
if (verbose > 0)
{
list.RemoveRange(0, verbose);
}
}
Canvas2D.Invalidate();
}), new DataflowLinkOptions())
.Also(_links.Add);
}
public virtual void Draw(Canvas2D canvas)
{
if (_children.Count <= 0)
{
return;
}
foreach (var child in _children)
{
child.Draw(canvas);
}
}
public void Render(Canvas2D canvas, RenderTarget target)
{
Vector offset = Vector.Zero;
if (ShakeLength > 0)
{
offset.X = (float)(m_random.NextDouble() - 0.5) * ShakeLength;
offset.Y = (float)(m_random.NextDouble() - 0.5) * ShakeLength;
}
float progress = 1;
canvas.DrawSprite(canvas.Region + offset, target.ToSprite(),
ColorU.White.SemiTransparent(progress));
}
public override void Render(Canvas2D canvas, VisualEnemyUnit unit)
{
if (unit.EnemyUnit.State == EnemyUnit.EnemyState.Dead)
{
_unitExplosion.MoveTo(unit.EnemyUnit.Location * TileSize);
_unitExplosion.Emit(BulletExplosionParticlesCount);
return;
}
Vector pos = unit.EnemyUnit.Location * TileSize;
float directionAngle = unit.EnemyUnit.Direction.Angle;
canvas.DrawSprite(pos, directionAngle,
unit.MovementAnimation.ToSprite(), ColorU.White);
}
public override void Draw(Canvas2D canvas, float dt)
{
canvas.Begin(m_render_target_view);
m_sprite.Draw(canvas);
canvas.End();
canvas.Begin();
m_sprite_target.Draw(canvas);
m_sprite.Draw(canvas);
canvas.End();
}
public override void DrawForeground(Canvas2D canvas)
{
canvas.DrawText(GameFont.Default, new Vector2(20, 20), "Hello", Color.Yellow);
using (canvas <= new Translation(250, 100) <= new Rotation(delta))
{
canvas.DrawLine(new Vector2(0, 0), new Vector2(100, 0), new LineStyle(2, LineStroke.Smooth), Color.Blue);
}
using (canvas <= new Translation(500, 100) <= new Rotation(delta))
{
canvas.DrawFilledRect(new Rect(-100, -100, 100, 100), Color.Yellow);
//canvas.DrawRect(new Rect(0, 0, 100, 100), new LineStyle(1), Color.Yellow);
}
}
public void Draw(Canvas2D canvas)
{
for (int i = 0; i < _frameContainers.Count; i++)
{
var container = _frameContainers[i];
if (_draggingFrame && _originFrameContainer.Equals(container))
{
continue;
}
container.Draw(canvas, _font);
}
if (_draggingFrame)
{
_originFrameContainer.Draw(canvas, _font);
}
}
public override void Render(Canvas2D canvas, VisualPlayerUnit unit)
{
if (unit.PlayerUnit.State == PlayerUnit.PlayerState.Dead &&
!unit.PlayerUnit.World.WorldState.GameComplete)
{
_unitExplosion.MoveTo(unit.PlayerUnit.Location * TileSize);
_unitExplosion.Emit(BulletExplosionParticlesCount);
ActivateShackeEffect(ShakeStrength, ShakeMinimizingSpeed);
return;
}
if (unit.PlayerUnit.State != PlayerUnit.PlayerState.Dead)
{
Vector pos = unit.PlayerUnit.Location * TileSize;
float directionAngle = unit.PlayerUnit.Direction.Angle;
canvas.DrawSprite(pos, directionAngle, unit.MovementAnimation.ToSprite(), ColorU.White);
}
}
public GUIArea(Canvas2D canvas)
{
this.canvas = canvas;
string[] dlls = Directory.GetFiles(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location), "*.dll", SearchOption.TopDirectoryOnly);
foreach(var dll in dlls)
{
var ass = Assembly.LoadFile(dll);
var types = ass.GetTypes();
foreach(var t in types)
{
if(t.IsSubclassOf(typeof(O3DSkin)))
{
skin = Activator.CreateInstance(t) as O3DSkin;
goto found;
}
}
}
found: ;
canvas.Render += canvas_Render;
}
public override void Draw(Canvas2D canvas)
{
canvas.DrawFrame(AbsoluteBoundingRect, Frames[State], FrameBorder,
true, Color);
if (_drawOverlay)
{
canvas.DrawSprite(AbsoluteBoundingRect, Overlay, ColorU.White);
}
var textSize = Canvas2D.MeasureText(Font, Text);
Vector2 textDrawPos = new Vector2(AbsoluteBoundingRect.CenterX - textSize.X / 2,
AbsoluteBoundingRect.CenterY - textSize.Y / 2);
canvas.DrawText(Font, textDrawPos.Floored, Text, TextColor);
base.Draw(canvas);
}
public void Render(Canvas2D canvas)
{
float worldOffsetX = (Game.Window.Width + TileSize - World.Width * TileSize) / 2;
float worldOffsetY = (Game.Window.Height + TileSize - World.Height * TileSize) / 2;
using (canvas <= m_frameBuffer)
{
canvas.Clear(ColorU.Black);
DrawGround(canvas);
using (canvas <= new Translation(worldOffsetX, worldOffsetY))
{
DrawPlayer(canvas, World.Player);
DrawEnemies(canvas, World.Enemies);
RenderWalls(canvas, World.Walls);
DrawBullets(canvas, World.Bullets);
DrawBonuses(canvas, World.Bonuses);
m_renderer.Render(canvas);
}
}
m_renderer.Render(canvas, m_frameBuffer);
DrawWorldEvents(canvas, World);
}
public void Draw(Canvas2D canvas)
{
if (Frames.Count == 0)
{
return;
}
if (EnableOnionSkin)
{
if (_currentFrameIndex > 0)
{
canvas.DrawSprite(Frames[_currentFrameIndex - 1].OffSet,
Frames[_currentFrameIndex - 1].SpriteFrame.Sprite,
ColorU.White.MultiplyAlpha(0.5f));
}
}
Frame frame = Frames[_currentFrameIndex];
canvas.DrawSprite(frame.OffSet, frame.SpriteFrame.Sprite, ColorU.White);
}
public void Draw(Canvas2D canvas)
{
if (_refresh)
{
Console.WriteLine("Redraw Gui");
Blitter.Begin(_surface);
Blitter.Clear();
_root.Draw(Drawer);
if (DebugMode)
{
Blitter.DrawText(10, 10, $"Hovered: {HoveredWidget?.Id ?? "None"}");
Blitter.DrawText(10, 35, $"Active: {ActiveWidget?.Id ?? "None"}");
Blitter.DrawText(10, 65, $"Input Focused: {InputFocusedWidget?.Id ?? "None"}");
//for (int i = 0; i < _widgets.Count; ++i)
//{
// var w = _widgets[i];
// blitter.Text(10, 50 + (i) * 10, $"{w.Id} [ZIndex: {w.ZIndex}]", 1);
//}
}
Blitter.End();
_refresh = false;
}
canvas.Begin();
canvas.DrawQuad(in _quad, _surface);
canvas.End();
}
public virtual void Render(Canvas2D canvas)
{
canvas.Clear(Configuration.BackgroundColor);
if (TransparentBack)
{
var boxWidth = (int)(0.01f * Target.Width);
var qtdeX = (int)Math.Ceiling((double)RenderRegion.Width / boxWidth);
var qtdeY = (int)Math.Ceiling((double)RenderRegion.Height / boxWidth);
var color1 = ColorU.White;
var color2 = ColorU.LightGray;
for (var i = 0; i < qtdeX; i++)
{
for (var j = 0; j < qtdeY; j++)
{
var curColor = i % 2 == j % 2 ? color1 : color2;
canvas.DrawFilledRect(i * boxWidth, j * boxWidth, boxWidth, boxWidth, curColor);
}
}
}
}
public override void OnDraw(Canvas2D canvas)
{
canvas.DrawRect(SelectRect, new LineStyle(2f, LineStroke.Dashed), ColorU.Blue);
}
public override void DrawWindowShadow(Canvas2D canvas, float x, float y, float w, float h)
{
canvas.SetLinearGradientFill(new Vector2(x + 5, y + 5), new Vector2(x + 5, y + h + 5), new GradientStop(0, new Color(0, 0, 0, 0.3f)), new GradientStop(1, new Color(0, 0, 0, 0.1f)));
canvas.FillRectangle(x + 5, y + 5, w, h);
}
public override void Render(Canvas2D canvas)
{
using (canvas <= Blending.Add)
{
_bulletExplosion.Draw(canvas);
_unitExplosion.Draw(canvas);
}
}
public virtual void Render(Canvas2D canvas, RenderTarget target)
{
}
public abstract void Draw(Canvas2D canvas);
public override void Render(Canvas2D canvas, RendererBase renderer)
{
renderer.Render(canvas, this);
}
public virtual void Render(Canvas2D canvas, VisualPlayerUnit unit)
{
}
public override void Draw(Canvas2D canvas)
{
canvas.DrawFrame(AbsoluteBoundingRect, BackGroundSprite, FrameBorder, true, Color);
base.Draw(canvas);
}
public virtual void Render(Canvas2D canvas)
{
}
public override void Render(Canvas2D canvas, VisualBonus unit)
{
canvas.DrawSprite(unit.BonusUnit.Location.X * TileSize, unit.BonusUnit.Location.Y * TileSize,
unit.BonusAnimation.ToSprite(), ColorU.White);
}
public override void Render(Canvas2D canvas, VisualUnit unit)
{
base.Render(canvas, unit);
}
public override void Render(Canvas2D canvas, RenderTarget target)
{
_shakeEffect.Render(canvas, target);
}
public override void OnDraw(Canvas2D canvas)
{
canvas.DrawRect(_frameRect, new LineStyle(2f, LineStroke.Solid), ColorU.Red);
}
internal virtual void Render(Canvas2D canvas)
{
}
public virtual void OnDraw(Canvas2D canvas)
{
}
protected override void DrawSelf(Canvas2D canvas)
{
canvas.DrawSprite(canvas.Region, Gfx.Instance.GetMainMenuBackground(), ColorU.White);
canvas.DrawString(Fonts.Instance.TanksAltFont, BattleGame.ResolutionX / 2 - 2, 190,
"Powered by PS-51", ColorU.Lime);
}
public override void Draw(Canvas2D canvas, float dt)
{
_ui.Draw(canvas);
}
public override void Draw(Canvas2D canvas, float dt)
{
canvas.Begin();
_surface.Draw(canvas);
canvas.End();
}
public virtual void Render(Canvas2D canvas, VisualBulletUnit unit)
{
}
public override void DrawWindowTopBar(Canvas2D canvas, float x, float y, float w, float h)
{
canvas.SetLinearGradientFill(new Vector2(x + 8, y + 8), new Vector2(x + w - 8, y + 8), new GradientStop(0, new Color(0f,0f,0f, 0.5f)), new GradientStop(1, new Color(0f,0f,0f, 0.2f)));
canvas.FillRectangle(x + 8, y + 8, w - 16, h - 16);
}
public void Draw(Canvas2D canvas, SpriteFont font)
{
var drawRect = new Rect(new PointF(X, Y), Size);
ColorU color;
if (Highlighted && !Selected)
{
color = ColorU.Red;
}
else if (Selected)
{
color = ColorU.Yellow;
}
else
{
color = ColorU.WhiteSmoke;
}
//-------------------EXTERNAL-BORDER------------------------------------------------------------
canvas.DrawRect(drawRect.Left - LineStyleExternalRect.Width,
drawRect.Top - LineStyleExternalRect.Width,
drawRect.Width + LineStyleExternalRect.Width * 2,
drawRect.Height + LineStyleExternalRect.Width * 2,
LineStyleExternalRect,
color);
//------------------INTERNAL-BORDER-------------------------------------------------------------
canvas.DrawRect(drawRect, LineStyleInternalRect, ColorU.Black);
//------------------BACKGROUND------------------------------------------------------------------
canvas.DrawFilledRect(drawRect, ColorU.Black.MultiplyAlpha(0.5f));
var frameLabelRect = new Rect(new PointF(drawRect.Left,
drawRect.Top + drawRect.Height + LineStyleExternalRect.Width +
LineStyleInternalRect.Width), new SizeF(drawRect.Width, 20f));
//------------------LABEL------------------------------------------------------------------------
canvas.DrawFilledRect(frameLabelRect, ColorU.Black.MultiplyAlpha(0.5f));
//------------------SPRITE-----------------------------------------------------------------------
if (Frame != null)
{
//using (canvas[0] <= new SamplerState(Configuration.TextureFilterMode, ColorU.White))
//{
canvas.DrawText(font, new Vector2(frameLabelRect.Left + 5f, frameLabelRect.Top),
string.Format("{0}", Frame.Num), ColorU.AliceBlue);
canvas.DrawText(font, new Vector2(frameLabelRect.Left + 30f, frameLabelRect.Top),
string.Format("FrameRate: {0}", 1f / Frame.FrameDuration), ColorU.Red);
if (!Dragged)
{
canvas.DrawSprite(drawRect.CenterX, drawRect.CenterY, Frame.SpriteFrame.Width * Scale.X,
Frame.SpriteFrame.Height * Scale.Y, Frame.SpriteFrame.Sprite, ColorU.White);
}
else
{
canvas.DrawSprite(FrameDrawPos.X, FrameDrawPos.Y, Frame.SpriteFrame.Width * Scale.X,
Frame.SpriteFrame.Height * Scale.Y, Frame.SpriteFrame.Sprite,
ColorU.White);
}
//}
}
}
public override void DrawWindowTitle(Canvas2D canvas, float x, float y, float w, float h, string title)
{
canvas.SetSolidFill(Color.White);
canvas.DrawText(x + 12, y + 12, w - 12, h - 12, SD.SystemFonts.CaptionFont, title);
}
public virtual void Render(Canvas2D canvas, RendererBase renderer)
{
}
public override void Render(Canvas2D canvas, VisualBulletUnit unit)
{
if (unit.BulletUnit.BulletState ==
BattleCore.Units.BulletUnit.BulletUnitState.Dead)
{
var possiblePlayerUnit = unit.BulletUnit.DeadOn as PlayerUnit;
if (possiblePlayerUnit != null)
{
ActivateShackeEffect(ShakeStrength, ShakeMinimizingSpeed);
}
_bulletExplosion.MoveTo(unit.BulletUnit.Location * TileSize);
_bulletExplosion.Emit(BulletExplosionParticlesCount);
}
else
{
Vector pos = unit.BulletUnit.Location * TileSize;
float directionAngle = unit.BulletUnit.Direction.Angle;
canvas.DrawSprite(pos, directionAngle, unit.FlightAnimation.ToSprite(), ColorU.White);
}
}
public override void Render(Canvas2D canvas, VisualWallUnit unit)
{
canvas.DrawSprite(unit.WallUnit.Location.X * TileSize, unit.WallUnit.Location.Y * TileSize,
unit.Sprite, ColorU.White);
}
public virtual void Render(Canvas2D canvas, VisualBonus unit)
{
}
