/// <summary>
/// Draws the Icon Background Texture
/// </summary>
/// <param name="InitSprite">Indicates whether to initialize the Sprite object or not (if it's already initialized)</param>
/// <param name="Size">Size of the destination rectangle</param>
/// <param name="Center">Point of the center of the background</param>
public void DrawIconBg(bool InitSprite, Size Size, Point Center)
{
try
{
if (Global.Configuration.Images.IconBackgroundImagePath != "" && IconBg != null)
{
if (InitSprite)
{
SpritePainter.Begin(SpriteFlags.AlphaBlend);
}
SpritePainter.Draw2D(IconBg.Texture,
Rectangle.Empty,
//new Size(IconBgDesc.Width,IconBgDesc.Height),
new SizeF(Size.Width, Size.Height),
new Point(Center.X - Size.Width / 2, Center.Y - Size.Height / 2),
Color.FromArgb(Global.Configuration.Appearance.IconBackgroundAlpha, Color.White).ToArgb());
if (InitSprite)
{
SpritePainter.End();
}
}
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message + "\n" + ex.StackTrace);
if (InitSprite)
{
SpritePainter.End();
}
}
}
void XTimer_Tick(object sender, EventArgs e)
{
XDevice.BeginScene();
XSprite.Begin(SpriteFlags.AlphaBlend);
if (FadeState == 0)
{
XSprite.Draw2D(FadeTexture, new Rectangle(0, 0, 1, 1), new SizeF(XDevice.DisplayMode.Width, XDevice.DisplayMode.Height), Point.Empty, FadeColor);
Particle.DrawParticles();
}
else
{
Particle.DrawParticles();
XSprite.Draw2D(FadeTexture, new Rectangle(0, 0, 1, 1), new SizeF(XDevice.DisplayMode.Width, XDevice.DisplayMode.Height), Point.Empty, Color.FromArgb(FadeState, Color.Black));
if (FadeState == 255)
{
Particle.ClearParticles();
Particle.AddControlPoints(Settings.Default.ParticleControlCount);
Particle.AddParticles(Settings.Default.ParticleCount);
FadeState = 0;
FadeTimer.Start();
}
else
{
FadeState += FADE_STEP;
if (FadeState > 255)
{
FadeState = 255;
}
}
}
XSprite.End();
IH.Draw();
XDevice.EndScene();
XDevice.Present();
}
public void Present()
{
// device.Clear(ClearFlags.Target, Color.Black, 0.0f, 0);
device.BeginScene();
sprite.Begin(SpriteFlags.None);
device.SetSamplerState(0, SamplerStageStates.MagFilter, true);
device.SetSamplerState(0, SamplerStageStates.MinFilter, true);
sprite.Draw2D(offScreenImage, new Rectangle(0, 0, Mafia.SCREEN_WIDTH, Mafia.SCREEN_HEIGHT), new Size(Mafia.SCREEN_WIDTH * 2, Mafia.SCREEN_HEIGHT * 2), new Point(0, 0), Color.White);
sprite.End();
device.EndScene();
device.Present();
// 描画が重いとき再現用。
// System.Threading.Thread.Sleep(100);
}
protected override void OnPaint(PaintEventArgs pe)
{
if ((this.m_FormRenderFrame.Device != null) && (this.m_FormRenderFrame.Texture != null) && (this.Visible) && (this.WindowState != FormWindowState.Minimized))
{
try {
this.m_FormRenderFrame.Device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.Black, 1F, 0);
SurfaceDescription surfaceDescription = this.m_FormRenderFrame.Texture.GetLevelDescription(0);
Size size = new Size(surfaceDescription.Width, surfaceDescription.Height);
Size targetSize = new Size(Math.Max(1, (Int32)((Single)size.Width * this.m_ZoomFactor)), Math.Max(1, (Int32)((Single)size.Height * this.m_ZoomFactor)));
if (this.Size != targetSize)
{
this.Size = targetSize;
}
this.m_FormRenderFrame.Device.BeginScene();
Sprite sprite = new Sprite(this.m_FormRenderFrame.Device);
sprite.Begin(SpriteFlags.None);
sprite.Draw2D(this.m_FormRenderFrame.Texture, new Rectangle(new Point(0, 0), size), new SizeF(((Single)size.Width * this.m_ZoomFactor), ((Single)size.Height * this.m_ZoomFactor)), new PointF(0F, 0F), Color.FromArgb(255, 255, 255, 255));
sprite.End();
sprite.Dispose();
this.m_FormRenderFrame.Device.EndScene();
this.m_FormRenderFrame.Device.Present();
} catch {
}
}
}
private void RenderSprite(
Sprite sprite,
Texture texture,
Size srcSize,
RectangleF dstRect,
bool antiAlias)
{
var srcRect = new Rectangle(
0,
0,
srcSize.Width,
srcSize.Height);
sprite.Begin(SpriteFlags.None);
try
{
if (!antiAlias)
{
Allocator.Device.SetSamplerState(0, SamplerStageStates.MinFilter, (int)TextureFilter.Point);
Allocator.Device.SetSamplerState(0, SamplerStageStates.MagFilter, (int)TextureFilter.Point);
Allocator.Device.SetSamplerState(0, SamplerStageStates.MipFilter, (int)TextureFilter.Point);
}
sprite.Draw2D(
texture,
srcRect,
dstRect.Size,
dstRect.Location,
-1);
}
finally
{
sprite.End();
}
}
/// <summary>
/// Renders the Screenshot
/// </summary>
/// <param name="InitSprite">Tells the render method if it should Begin() the Sprite object or not</param>
public void Render(bool InitSprite)
{
try
{
// only draw if ready
if (CanDraw)
{
// init if needed
if (InitSprite)
{
SpritePainter.Begin(SpriteFlags.AlphaBlend);
}
// draw
SpritePainter.Draw2D(ScreenCapture.Texture,
Rectangle.Empty,
new SizeF(ScreenCapture.Description.Width, ScreenCapture.Description.Height),
new Point(0, 0),
Color.FromArgb(Alpha, Color.White));
// stop if needed
if (InitSprite)
{
SpritePainter.End();
}
}
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message + "\n" + ex.StackTrace);
}
}
protected override void OnPaint(PaintEventArgs pe)
{
if ((this.m_FormRenderFrame.Device != null) && (this.m_FormRenderFrame.Texture != null) && (this.Visible) && (this.WindowState != FormWindowState.Minimized)) {
try {
this.m_FormRenderFrame.Device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.Black, 1F, 0);
SurfaceDescription surfaceDescription = this.m_FormRenderFrame.Texture.GetLevelDescription(0);
Size size = new Size(surfaceDescription.Width, surfaceDescription.Height);
Size targetSize = new Size(Math.Max(1, (Int32)((Single)size.Width * this.m_ZoomFactor)), Math.Max(1, (Int32)((Single)size.Height * this.m_ZoomFactor)));
if (this.Size != targetSize) {
this.Size = targetSize;
}
this.m_FormRenderFrame.Device.BeginScene();
Sprite sprite = new Sprite(this.m_FormRenderFrame.Device);
sprite.Begin(SpriteFlags.None);
sprite.Draw2D(this.m_FormRenderFrame.Texture, new Rectangle(new Point(0, 0), size), new SizeF(((Single)size.Width * this.m_ZoomFactor), ((Single)size.Height * this.m_ZoomFactor)), new PointF(0F, 0F), Color.FromArgb(255, 255, 255, 255));
sprite.End();
sprite.Dispose();
this.m_FormRenderFrame.Device.EndScene();
this.m_FormRenderFrame.Device.Present();
} catch {
}
}
}
private void DrawImage(Device gd, Sprite s, Texture t, int X, int Y)
{
position.X = X;
position.Y = Y;
s.Begin(SpriteFlags.AlphaBlend);
s.Draw2D(t, rotationPoint, 0f, position, Color.White);
s.End();
}
public void Draw(Device dev)
{
m_Sprite.Begin(SpriteFlags.AlphaBlend);
{
m_Sprite.Draw2D(m_Texture, new Rectangle(0, 0, m_TexWidth, m_TexHeight), m_Size, new PointF(m_X, m_Y), m_Color);
}
m_Sprite.End();
}
public void Draw(Device dev)
{
m_Sprite.Begin(SpriteFlags.AlphaBlend);
{
m_Sprite.Draw2D(m_Texture, new Rectangle(0, 0, m_TexWidth, m_TexHeight), m_SizeScaled, m_RotationCenter, m_Rotation,
new PointF(m_X + m_SizeScaled.Width / 2, m_Y + m_SizeScaled.Height / 2), m_Color);
}
m_Sprite.End();
}
public void Draw(Sprite sprite, int grid_size)
{
if (m_file_texture != null)
{
sprite.Begin(SpriteFlags.AlphaBlend);
sprite.Draw2D(m_file_texture, m_source, new Rectangle(0, 0, grid_size, grid_size), new Point((int)((float)m_location.X * ((float)grid_size / ((float)grid_size / (float)m_source.Width))),
(int)(float)(m_location.Y * ((float)grid_size / ((float)grid_size / (float)m_source.Height)))), Color.White);
sprite.End();
}
}
//public ControlElement(Device device, string text, Point position, Size size,
// Texture textureNormal, Texture textureHover, Texture textureClick)
//{
// this.device = device;
// this.elementSprite = new Sprite(device);
// this.text = text;
// this.position = position;
// this.size = size;
// this.textureNormal = textureNormal;
// this.textureHover = textureHover;
// this.textureClick = textureClick;
// this.textureCurrent = this.textureNormal;
//}
public virtual void Draw()
{
if (this.textureCurrent != null)
{
elementSprite.Begin(SpriteFlags.AlphaBlend);
elementSprite.Draw2D(textureCurrent, Rectangle.Empty, this.size, (PointF)this.position, Color.White.ToArgb());
this.font.DrawText(elementSprite, this.text, textPosition, textColor);
elementSprite.End();
}
}
public void RenderHUDLogos()
{
var d3dDevice = D3DDevice.Instance.Device;
//TgcTexture textura;
var sprite = new Sprite(d3dDevice);
sprite.Begin(SpriteFlags.AlphaBlend);
sprite.Draw2D(texturaLogo, Rectangle.Empty, new SizeF(80, 80), new PointF(D3DDevice.Instance.Width - 155, D3DDevice.Instance.Height - 90), Color.Blue);
sprite.End();
}
private void Render()
{
device.Clear(ClearFlags.Target, Color.CornflowerBlue, 0, 1);
device.BeginScene();
using (Sprite s = new Sprite(device))
{
s.Begin(SpriteFlags.AlphaBlend);
s.Draw2D(texture_background, new Rectangle(0, 0, 0, 0), new Rectangle(0, 0, device.Viewport.Width, device.Viewport.Height), new Point(0, 0), 0f, new Point(0, 0), Color.White);
s.Draw2D(texture_score, new Rectangle(0, 0, 0, 0), new Rectangle(0, 0, 200, 200), new Point(0, 0), 0f, new Point(45, -30), Color.White);
font.DrawText(s, "Level ", new Point(100, 60), Color.Black);
font.DrawText(s, "Hits ", new Point(100, 90), Color.Black);
font.DrawText(s, "Score ", new Point(100, 120), Color.Black);
foreach (Characters c in ch)
{
if (c.type == 0)
{
s.Draw2D(texture_cat, new Rectangle(0, 0, 0, 0), new Rectangle(0, 0, 200, 200), new Point(0, 0), 0f, new Point((int)(c.CharacterCoordinates.X), (int)c.CharacterCoordinates.Y), Color.White);
}
if (c.type == 1)
{
s.Draw2D(texture_bird, new Rectangle(0, 0, 0, 0), new Rectangle(0, 0, 200, 200), new Point(0, 0), 0f, new Point((int)(c.CharacterCoordinates.X + (int)(0.2)), (int)c.CharacterCoordinates.Y + (int)(0.2)), Color.White);
}
if (c.type == 2)
{
s.Draw2D(texture_snake, new Rectangle(0, 0, 0, 0), new Rectangle(0, 0, 200, 200), new Point(0, 0), 0f, new Point((int)(c.CharacterCoordinates.X + (int)(0.8)), (int)c.CharacterCoordinates.Y + (int)(0.8)), Color.White);
}
}
s.Draw2D(texture_milk, new Rectangle(0, 0, 0, 0), new Rectangle(0, 0, 200, 200), new Point(0, 0), 0f, new Point((int)x2, (int)y2), Color.White);
s.End();
}
device.EndScene();
device.Present();
}
void Render()
{
if (d3dDevice != null)
{
d3dDevice.Clear(ClearFlags.Target | ClearFlags.ZBuffer, splitContainer1.Panel2.BackColor, 1.0f, 0);
d3dDevice.BeginScene();
sprite.Begin(SpriteFlags.AlphaBlend);
d3dDevice.SamplerState[0].AddressU = TextureAddress.Wrap;
d3dDevice.SamplerState[0].AddressV = TextureAddress.Wrap;
sprite.Draw2D(gridTexture, gridRect, grideSize, gridIndex, Color.Green);
sprite.Flush();
d3dDevice.SetTransform(TransformType.World, Matrix.Transformation2D(new Vector2(centerPoint.X, centerPoint.Y), 0, world_scale, Vector2.Empty, 0, world_trans));
if (selectedFrame != null)
{
sprite.Draw2D(selectedFrame.texture, selectedFrame.centerPoint, 0, centerPoint, Color.White);
}
sprite.Draw2D(centerPointTexture, centerPointCP, centerPointTextureRotation, centerPoint, centerPointTextureColor);
sprite.End();
d3dDevice.EndScene();
d3dDevice.Present();
}
}
public void RenderHUD()
{
var d3dDevice = D3DDevice.Instance.Device;
//TgcTexture textura;
var sprite = new Sprite(d3dDevice);
sprite.Begin(SpriteFlags.AlphaBlend);
for (var i = 0; i < Env.Personaje.vidas; i++)
{
sprite.Draw2D(texturaVida, Rectangle.Empty, new SizeF(32, 32), new PointF(20 + 32 * i, 650), Color.Red);
}
sprite.End();
}
/// <summary>
/// This method uses Draw2D to easily draw the sprite to screen space.
/// </summary>
public void Draw(Sprite sprite)
{
sprite.Draw2D(tex, srcRect,
//The destination size
new SizeF(spriteWidth, spriteHeight),
//The center point (For Draw2D, this value is relative to the source image, not the scaled end image)
new PointF(srcRect.Width / 2f, srcRect.Height / 2f),
//The angle of rotation is simply the direction of the sprite
direction,
//the position is calculated from the center of the sprite
new PointF(position.X, position.Y),
Color.White);
}
/// <summary>
/// Funkce zajisti vykreslovani konzole
/// </summary>
public static void RenderConsole()
{
console.Begin(SpriteFlags.AlphaBlend);
console.Draw2D(background, srcRectangle, size, new System.Drawing.PointF(), Color.FromArgb(170, 255, 255, 255));
for (int t = 0; t < consoleTexts.Count; t++)
{
f.DrawText(console, consoleTexts[t], 15, t * (int)(3f / 2f * (float)fontsize) + 8, Color.White);
}
f.DrawText(console, "> " + command + "_", 15, (int)(size.Height - 3f / 2f * (float)fontsize), Color.White);
console.End();
}
} //take any texture image as bg.
private void Render()
{
device.Clear(ClearFlags.Target, Color.CornflowerBlue, 0, 1);
device.BeginScene();
using (Sprite s = new Sprite(device))
{
s.Begin(SpriteFlags.AlphaBlend);
s.Draw2D(texture, new Rectangle(0, 0, 0, 0), new Rectangle(0, 0,
device.Viewport.Width, device.Viewport.Height), new Point(0, 0), 0f, new
Point(0, 0), Color.DarkSlateGray);
font.DrawText(s, "TYCS-6070", new Point(0, 0), Color.White);
s.End();
}
device.EndScene();
device.Present();
}
public void Draw(Device gd, Sprite s, Texture t)
{
if (Current_BullStatus == status_BullStatus.miss)
{
return;
}
RiseCount++;
X = BX + (int)(RiseCount * (step * 4 / Distance) * DX);
Y = Y + (int)(RiseCount * (step / 32 / Distance) * DY);
position.X = X;
position.Y = Y;
s.Begin(SpriteFlags.AlphaBlend);
for (int j = 0; j < 16; j++)
{
for (int i = 0; i < bullcount; i++)
{
if (i <= bullcount / 2 - 1)
{//(bullcount/2 - i) *
position.X = X - (bullcount / 2 - i) * RiseCount;
position.Y = Y - (bullcount / 2 - i) * (bullcount / 2 - i) * RiseCount / 30 + 30;
}
else if (i >= bullcount / 2 + 1)
{//(i - bullcount/2) *
position.X = X + (i - bullcount / 2) * RiseCount;
position.Y = Y - (i - bullcount / 2) * (i - bullcount / 2) * RiseCount / 30 + 30;
}
else
{
position.X = X;
position.Y = Y + 30;
}
s.Draw2D(t, rotationPoint, j * 0.4f, position, Color.White);
}
}
/*position.X = X + RiseCount * RiseCount;
* position.Y = Y;
* s.Draw2D(t, rotationPoint, 0, position, Color.White);*/
s.End();
if (Y > 600)
{
Current_BullStatus = status_BullStatus.miss;
}
}
private void DrawImage(Device gd, Sprite s_boom, List <Texture> showPicture, int X, int Y)
{
if (currentFrame >= frameCount - 1)
{
currentFrame = 0;
}
else
{
currentFrame++;
}
position.X = X;
position.Y = Y;
s_boom.Begin(SpriteFlags.AlphaBlend);
s_boom.Draw2D(showPicture[currentFrame], rotationPoint, 0f, position, Color.White);
s_boom.End();
}
public virtual void Render()
{
try
{
var device = GameAppFramework.GetGameAppFramework().Device;
device.Clear(ClearFlags.Target, Color.HotPink, 0, 1);
device.BeginScene();
using (Sprite MenuSprite = new Sprite(device))
{
MenuSprite.Begin(SpriteFlags.AlphaBlend);
MenuSprite.Draw2D(background, new Rectangle(0, 0, 0, 0), new Rectangle(0, 0, device.Viewport.Width, device.Viewport.Height), new Point(0, 0), 0f, new Point(0, 0), Color.White);
font.DrawText(MenuSprite, "EXITING................", new Point((device.Viewport.Width / 2) - 200, device.Viewport.Height / 2), Color.White);
MenuSprite.End();
}
device.EndScene();
device.Present();
}
catch (Exception e) { };
}
/////////////////////////////////////////////////////////////////////////
////////////////////////////////RENDER///////////////////////////////////
/////////////////////////////////////////////////////////////////////////
public void render(float deltaTime, TgcFrustum frustum)
{
foreach (var mesh in objectsInFront)
{
if (!librosAgarrados.Contains(mesh))
{
var resultadoColisionFrustum = TgcCollisionUtils.classifyFrustumAABB(frustum, mesh.BoundingBox);
if (resultadoColisionFrustum != TgcCollisionUtils.FrustumResult.OUTSIDE)
{
mesh.Render();
}
}
}
efectoOlas.SetValue("time", tiempoOlas);
personajePrincipal.animateAndRender(deltaTime);
HUD.Begin(SpriteFlags.AlphaBlend | SpriteFlags.SortDepthFrontToBack);
posVidas = D3DDevice.Instance.Device.Viewport.Width - vida.Width;
for (int i = 0; i < cantVidas; i++)
{
HUD.Transform = TGCMatrix.Translation(new TGCVector3(posVidas, 0, 0));
HUD.Draw(vida.D3dTexture, Rectangle.Empty, Vector3.Empty, Vector3.Empty, Color.OrangeRed);
posVidas -= vida.Width;
}
librosAdquiridos.cambiarTexto(cantidadLibrosAdquiridos.ToString());
librosAdquiridos.cambiarTamañoLetra(28);
librosAdquiridos.cambiarColor(Color.BlueViolet);
librosAdquiridos.Render();
HUD.Draw2D(fisicaLib.D3dTexture, Rectangle.Empty, new SizeF(90, 90), new PointF(D3DDevice.Instance.Width - 95, D3DDevice.Instance.Height - 145), Color.White);
HUD.End();
emisorDeParticulas1.render(deltaTime);
emisorDeParticulas2.render(deltaTime);
emisorDeParticulas3.render(deltaTime);
}
void DoDraw(Device dev)
{
if (m_RogueForm == null)
{
return;
}
///////////////////////////////////
// Render the scene to the texture
///////////////////////////////////
m_RenderToSurface.BeginScene(m_RenderSurface);
{
/////////
// Clear
/////////
dev.Clear(ClearFlags.Target, m_ClearColor, 1.0f, 0);
///////////////////
// Render each gfx
///////////////////
foreach (IGfx gfx in m_Gfxs)
{
gfx.Draw(dev);
}
}
m_RenderToSurface.EndScene(Filter.None);
//////////////////////////////////////////////////////
// Then draw scene texture scaled to fit whole canvas
//////////////////////////////////////////////////////
m_Device.BeginScene();
{
m_Sprite.Begin(SpriteFlags.None);
{
m_Sprite.Draw2D(m_RenderTexture, new Rectangle(0, 0, RogueGame.CANVAS_WIDTH, RogueGame.CANVAS_HEIGHT),
new SizeF(m_RogueForm.ClientRectangle.Width, m_RogueForm.ClientRectangle.Height), PointF.Empty, Color.White);
}
m_Sprite.End();
}
m_Device.EndScene();
}
public void Render()
{
try
{
Microsoft.DirectX.Direct3D.Device device = GameAppFramework.GetGameAppFramework().Device;
device.Clear(ClearFlags.Target, Color.HotPink, 0, 1);
device.BeginScene();
using (Sprite MenuSprite = new Sprite(device))
{
MenuSprite.Begin(SpriteFlags.AlphaBlend);
MenuSprite.Draw2D(background, new Rectangle(0, 0, 0, 0), new Rectangle(0, 0, device.Viewport.Width, device.Viewport.Height), new Point(0, 0), 0f, new Point(0, 0), Color.White);
font.DrawText(MenuSprite, "Press Space to START", new Point((device.Viewport.Width / 2) - 200, device.Viewport.Height / 2), Color.White);
font.DrawText(MenuSprite, "Press Escape to END", new Point((device.Viewport.Width / 2) - 200, (device.Viewport.Height / 2) + 100), Color.White);
MenuSprite.End();
}
device.EndScene();
device.Present();
}
catch (Exception e) { };
}
public void Draw(Device gd, Sprite s, Texture t)
{
if (Current_BullStatus == status_BullStatus.miss)
{
return;
}
RiseCount++;
X = BX + (int)(RiseCount * (step * 4 / Distance) * DX);
Y = Y + (int)(RiseCount * (step / 32 / Distance) * DY);
position.X = X;
position.Y = Y;
s.Begin(SpriteFlags.AlphaBlend);
s.Draw2D(t, rotationPoint, 0f, position, Color.White);
s.End();
if (Y > 600)
{
Current_BullStatus = status_BullStatus.miss;
}
}
private void Form1_MouseClick_1(object sender, MouseEventArgs e)
{
device.Clear(ClearFlags.Target, Color.CornflowerBlue, 0, 1);
device.BeginScene();
using (Sprite s = new Sprite(device))
{
s.Begin(SpriteFlags.AlphaBlend);
s.Draw2D(texture_blood, new Rectangle(0, 0, 200, 200), new Rectangle(0, 0, 0, 0), new Point(0, 0), 0f, new Point(e.X - 100, e.Y - 100), Color.White);
s.End();
}
device.EndScene();
device.Present();
int toDel = -1;
for (int i = 0; i < ch.Count; i++)
{
Characters cat = ch[i];
if ((e.X >= cat.CharacterCoordinates.X && e.X <= cat.CharacterCoordinates.X + 150) &&
(e.Y >= cat.CharacterCoordinates.Y && e.Y <= cat.CharacterCoordinates.Y + 150))
{
using (soundPlayer4 = new SoundPlayer(@"C:\Users\андрей\Documents\Visual Studio 2015\Projects\NewGame\NewGame\bin\Debug\Gun.wav"))
{
soundPlayer4.Play();
}
toDel = i;
newHit();
newScore(50);
break;
}
if (hits % 5 == 0)
{
// newLevel(1);
}
}
if (toDel != -1)
{
ch.Remove(ch[toDel]);
}
}
public void DrawFrame()
{
// Drawing vertices
sprite.Begin(SpriteFlags.None);
foreach (Vertex vertex in vertices)
{
vertex.Update();
if (vertex.marked)
{
vertices.Remove(vertex);
break;
}
sprite.Draw2D(Vertex.img, Rectangle.Empty, Rectangle.Empty,
Vertex.center, 0f, vertex.position, vertex.color);
}
sprite.End();
// Drawing edges
line.Begin();
foreach (Edge edge in edges)
{
edge.Update();
if (!vertices.Contains(edge.start) || !vertices.Contains(edge.end))
{
edges.Remove(edge);
break;
}
if (edge.marked)
{
edges.Remove(edge);
break;
}
Vector2[] coords = { edge.start.toVector2(), edge.end.toVector2() };
line.Draw(coords, edge.color);
}
line.End();
}
public void Draw(Device gd, Sprite s, Texture t)
{
if (Current_Status != status.active)
{
return;
}
MovingCount++;
X = BX + (int)(MovingCount * (step / Distance) * DX);
Y = (int)(MovingCount * (step / Distance) * DY);
//G.DrawImage(BmpBeeList[0], X, Y);
position.X = X;
position.Y = Y;
s.Begin(SpriteFlags.AlphaBlend);
s.Draw2D(t, rotationPoint, 0f, position, Color.White);
s.End();
if (Y > 600)
{
Current_Status = status.pass;
}
}
/// <summary>
/// Animate and draw
/// </summary>
/// <param name="sprite"></param>
public override void Draw(Sprite sprite)
{
// move knob if the mouse is down
if (movement != 0)
{
state += movement * Scene.ElapsedTime * 0.5f;
if (state < 0)
state = 0;
else if (state > 1)
state = 1;
if (OnChange != null) // IF there's at least one handler hooked in
OnChange(this, state); // trigger an OnChange event
}
// calc angle from switch position
float angle = ((float)state - 0.5f) * (halfAngle * 2.0f);
// Draw the rotated DECAL (frame0)...
// rotating form of Draw2D() positions the CENTRE at xy instead of the top-left pixel,
// So I must calculate the centre position from the top-left posn (in destination coordinates)
PointF destCentre = ToScreenOffset(centre);
PointF posn = new PointF(destPosn.X + destCentre.X, destPosn.Y + destCentre.Y);
sprite.Draw2D(texture, srcRect, destSize, centre, angle, posn, Color.White);
// Draw the LUMINOSITY image (frame 1)...
Rectangle lumRect = new Rectangle(baseWidth, 0, baseWidth, baseHeight);
sprite.Draw2D(texture, lumRect, destSize, destPosn, Color.White);
}
public static void DrawParticles()
{
double acc, accAngle;
Vector2 diff;
foreach (Vector2 CP in ControlPoints)
{
foreach (Particle P in Particles)
{
diff = CP - P.Position;
acc = GRAVITY / (Math.Pow(diff.X, 2) + Math.Pow(diff.Y, 2));
if (acc > MAX_ACC)
{
acc = MAX_ACC;
}
accAngle = Math.Atan(diff.Y / diff.X);
if (double.IsNaN(accAngle))
{
accAngle = 0;
}
if (diff.X < 0)
{
accAngle += Math.PI;
}
P.Velocity.X += (float)(Math.Cos(accAngle) * acc);
P.Velocity.Y += (float)(Math.Sin(accAngle) * acc);
}
}
float clipX1 = -CLIP;
float clipY1 = -CLIP;
float clipX2 = XDevice.DisplayMode.Width + CLIP;
float clipY2 = XDevice.DisplayMode.Height + CLIP;
XSprite.Begin(SpriteFlags.AlphaBlend);
foreach (Particle P in Particles)
{
P.Position += P.Velocity;
XSprite.Draw2D(P.Texture, PointF.Empty, 0, new PointF(P.Position.X, P.Position.Y), Color.White);
if (P.Position.X < clipX1)
{
P.Position.X = clipX1;
}
if (P.Position.Y < clipY1)
{
P.Position.Y = clipY1;
}
if (P.Position.X > clipX2)
{
P.Position.X = clipX2;
}
if (P.Position.Y > clipY2)
{
P.Position.Y = clipY2;
}
}
XSprite.End();
}
/// <summary>
/// Draws the given texture to the given point on the screen.
/// </summary>
/// <param name="texture">The texture to draw.</param>
/// <param name="point">Where to display the texture on the screen.</param>
/// <param name="scale">The amount to scale the x value of the Sprite.</param>
public void drawHealth(Texture texture, Point point, float scale)
{
Size healthSize = new Size((int)((this.width * 0.288f) * scale),
(int)(this.height * 0.060));
this.healthBarSize = new Size((int)(this.width * 0.530f),
(int)(this.height * 0.24));
using (Sprite s = new Sprite(device))
{
Point newPoint = new Point((int)(this.width * 0.0344) + point.X,
(int)(this.height * 0.0736) + point.Y);
Size healthBack = new Size((int)(this.width-(this.width-newPoint.X+30)),
(int)(this.height * 0.120));
s.Begin(SpriteFlags.AlphaBlend);
s.Draw2D(ContentLoader.GUIBack, Rectangle.Empty,
healthBack, new Point(newPoint.X-30, 0), Color.White);
s.Draw2D(healthTexture, new Rectangle(point, healthSize),
healthSize, newPoint, Color.Red);
s.Draw2D(texture, Rectangle.Empty, healthBarSize, point, Color.Black);
s.End();
}
}
/// <summary>
/// Draws the radar.
/// </summary>
public void drawRadar()
{
using (Sprite s = new Sprite(device))
{
s.Begin(SpriteFlags.AlphaBlend);
Point playerP = new Point((int)player.Location.X + radarPoint.X,
(int)player.Location.Z + radarPoint.Y);
s.Draw2D(ContentLoader.Radar, Rectangle.Empty, new Size((int)(playerP.X * 2), (int)((this.height-playerP.Y) * 2)),
new Point(0, (int)(this.height - (this.height - playerP.Y) * 2)), Color.White);
s.Draw2D(this.radarEnemyTexture, Rectangle.Empty,
this.enemySize, playerP, Color.LightSkyBlue);
s.Draw2D(ContentLoader.GUIBack, Rectangle.Empty, new Size((int)(this.width * 0.15f), 120),
new Point(0, 0), Color.White);
foreach (Enemy e in enemies)
{
Point point = new Point(
(int)(radarPoint.X + e.Location.X * Math.Cos(player.Head.Rotation.X) - e.Location.Z * Math.Sin(player.Head.Rotation.X)),
(int)(radarPoint.Y - e.Location.X * Math.Sin(player.Head.Rotation.X) - e.Location.Z * Math.Cos(player.Head.Rotation.X)));
s.Draw2D(this.radarEnemyTexture, Rectangle.Empty,
this.enemySize, point, Color.Red);
}
s.End();
}
}
public void Draw( Sprite sprite, int grid_size )
{
if (m_file_texture != null)
{
sprite.Begin(SpriteFlags.AlphaBlend);
sprite.Draw2D(m_file_texture, m_source, new Rectangle(0, 0, grid_size, grid_size), new Point((int)((float)m_location.X * ((float)grid_size / ((float)grid_size / (float)m_source.Width))),
(int)(float)(m_location.Y * ((float)grid_size / ((float)grid_size / (float)m_source.Height)))), Color.White);
sprite.End();
}
}
/// <summary>
/// Draw this gauge as a sprite (using current animation frame).
/// Called every video frame
/// </summary>
/// <param name="sprite"></param>
public override void Draw(Sprite sprite)
{
if (enabled)
{
// Draw the background texture
sprite.Draw2D(texture, srcRect, destSize, destPosn, Color.White);
// Draw our children on top
foreach (Widget w in widgetList)
{
w.Draw(sprite);
}
}
}
public void Render()
{
device.VertexShader = null;
device.PixelShader = null;
Camera cam = Camera.GetCameraInstance();
device.Transform.View = cam.GetMatrixView();
device.Transform.Projection = cam.GetMatrixProjection();
sprite.Begin(SpriteFlags.AlphaBlend);
sprite.Draw2D(empty, srcRectangle, size, liveEmpty, Color.FromArgb(255, 255, 255, 255));
sprite.Draw2D(live, liveRectangle, liveSize, livePoint, Color.FromArgb(255, 255, 255, 255));
sprite.Draw2D(empty, srcRectangle, size, manaEmpty, Color.FromArgb(255, 255, 255, 255));
sprite.Draw2D(mana, manaRectangle, manaSize, manaPoint, Color.FromArgb(255, 255, 255, 255));
sprite.Draw2D(empty, srcRectangle, size, energyEmpty, Color.FromArgb(255, 255, 255, 255));
sprite.Draw2D(energy, energyRectangle, energySize, energyPoint, Color.FromArgb(255, 255, 255, 255));
sprite.End();
RenderText();
//for (int t = 0; t < sentences.Count; t++)
//{
// Matrix m = Matrix.Identity;
// m *= Matrix.RotationX((float)Math.PI);
// m *= Matrix.Translation(sentences[t].position) * Matrix.Translation(0, 40, 0);
// sprite3d.SetWorldViewLH(m, device.Transform.View);
// sprite3d.Begin(SpriteFlags.ObjectSpace | SpriteFlags.Billboard | SpriteFlags.AlphaBlend);
// sprite3d.Draw2D(sentences[t].texture, new PointF(0,2),
// (float)Math.PI, new PointF(-sentences[t].rect.Width / 2, -16), Color.FromArgb(255, 255, 255, 255));
// sprite3d.End();
//}
device.Transform.Projection = cam.GetMatrixProjection();
sprite3d.Transform = Matrix.Identity;
if (canRenderNpcInfo)
{
NpcInfo = form.Game.GetAllNpcInfo();
for (int i = 0; i < NpcInfo.Count; i++)
{
if (NpcInfo[i].Character.name == "Player")
{
setEnergy((int)NpcInfo[i].Status.energy);
setLive((int)(100 * NpcInfo[i].Status.hp / (float)(NpcInfo[i].Character.hp)));
setMana((int)(100 * NpcInfo[i].Status.mana / (float)(NpcInfo[i].Character.mana)));
continue;
}
StringFormat stringFormat = new StringFormat();
stringFormat.FormatFlags = StringFormatFlags.NoClip;
double percents = (1 - ((double)NpcInfo[i].Status.hp / (double)NpcInfo[i].Character.hp)) * 64;
npcRectange.X = (int)percents;
GeneralObject npcGeneral = getNpcGeneralObjectByName(NpcInfo[i].Character.name);
Matrix world = npcGeneral.GetMatrixWorld();
Vector3 min = npcGeneral.GetBoundingBoxRelativeMinimum();
Vector3 max = npcGeneral.GetBoundingBoxRelativeMaximum();
min = Vector3.TransformCoordinate(min, npcGeneral.GetMatrixWorldBoundingBoxMesh());
max = Vector3.TransformCoordinate(max, npcGeneral.GetMatrixWorldBoundingBoxMesh());
Vector3 delta = max - min;
world *= Matrix.Translation(0, delta.Y, 0);
device.Transform.World = world;
sprite3d.SetWorldViewLH(device.Transform.World, device.Transform.View);
sprite3d.Begin(SpriteFlags.ObjectSpace | SpriteFlags.Billboard | SpriteFlags.AlphaBlend);
sprite3d.Draw(empty2, npcScrRectange, center, new Vector3(0, 0, 0), Color.White);
sprite3d.Draw(live2, npcRectange, center, new Vector3(0, 0, 0), Color.White);
sprite3d.End();
Matrix current = Matrix.Identity;
Matrix hh = cam.GetMatrixView();
Vector3 vect1 = new Vector3(world.M41 / world.M44, 0, world.M43 / world.M44);
Vector3 vect2 = new Vector3(hh.M41 / hh.M44, 0, hh.M43 / hh.M44);
Vector3 direction = vect2 - vect1;
vect1.Normalize();
vect2.Normalize();
float vect3 = Vector3.Dot(vect1, vect2);
double number = vect3;
double angle = Math.Acos(number);
if (direction.X > 0 && direction.Z > 0)
{
angle *= -1;
}
if (direction.X < 0 && direction.Z > 0)
{
angle *= -1;
}
current *= Matrix.Scaling(0.5f, 0.5f, 0.5f);
current *= Matrix.RotationZ((float)Math.PI);
current *= Matrix.RotationY((float)angle);
current.M41 = world.M41;
current.M42 = world.M42;
current.M43 = world.M43;
current.M44 = world.M44;
current *= Matrix.Translation(0, 15f, 0);
sprite3d.SetWorldViewLH(current, device.Transform.View);
device.Transform.World = current;
sprite3d.Begin(SpriteFlags.ObjectSpace | SpriteFlags.AlphaBlend);
Rectangle textRect = f.MeasureString(s, NpcInfo[i].Character.name, DrawTextFormat.Left, Color.DarkRed);
textRect.X -= (int)((float)textRect.Width * 0.5f);
Color textColor = Color.DarkRed;
if (NpcInfo[i].Character.type == WiccanRede.AI.NPCType.villager)
{
textColor = Color.DarkGreen;
}
f.DrawText(sprite3d, NpcInfo[i].Character.name, textRect, DrawTextFormat.Left, textColor);
sprite3d.End();
}
}
}
/// <summary>
/// Draw this gauge as a sprite (using current animation frame).
/// Called every video frame
/// Subclasses should override this to do any animation, then call this base method to draw the result
/// </summary>
/// <param name="sprite"></param>
public virtual void Draw(Sprite sprite)
{
// By default we use an UNROTATED sprite draw command. Widget classes should use a different
// form of Draw2D() if they need a certain rotation (e.g. rotating knobs)
// NOTE: Could change the colour here for FX such as flashes
if (enabled)
sprite.Draw2D(texture, srcRect, destSize, destPosn, Color.White);
}
/// <summary>
/// Animate and draw
/// </summary>
/// <param name="sprite"></param>
public override void Draw(Sprite sprite)
{
// calc angle from switch position
float angle = ((float)state - midState) * increment;
// Draw the rotated DECAL (frame0)...
// rotating form of Draw2D() positions the CENTRE at xy instead of the top-left pixel,
// So I must calculate the centre position from the top-left posn (in destination coordinates)
PointF destCentre = ToScreenOffset(centre);
PointF posn = new PointF(destPosn.X + destCentre.X, destPosn.Y + destCentre.Y);
sprite.Draw2D(texture, srcRect, destSize, centre, angle, posn, Color.White);
// Draw the LUMINOSITY image (frame 1)...
Rectangle lumRect = new Rectangle(baseWidth, 0, baseWidth, baseHeight);
sprite.Draw2D(texture, lumRect, destSize, destPosn, Color.White);
}
/// <summary>
/// Animate and draw
/// </summary>
/// <param name="sprite"></param>
public override void Draw(Sprite sprite)
{
// move knob if the mouse is down
if (movement != 0)
{
float oldState = state;
state += movement * Scene.ElapsedTime * 1f;
delta = state - oldState; // we return the delta
state %= (float)Math.PI * 2; // keep orientation in range +/-2PI
if (OnChange != null) // IF there's at least one handler hooked in
OnChange(this, delta); // trigger an OnChange event
}
// Draw the rotated DECAL (frame0)...
// rotating form of Draw2D() positions the CENTRE at xy instead of the top-left pixel,
// So I must calculate the centre position from the top-left posn (in destination coordinates)
PointF destCentre = ToScreenOffset(centre);
PointF posn = new PointF(destPosn.X + destCentre.X, destPosn.Y + destCentre.Y);
sprite.Draw2D(texture, srcRect, destSize, centre, state, posn, Color.White);
// Draw the LUMINOSITY image (frame 1)...
Rectangle lumRect = new Rectangle(baseWidth, 0, baseWidth, baseHeight);
sprite.Draw2D(texture, lumRect, destSize, destPosn, Color.White);
}
/// <summary>
/// Animate and draw
/// </summary>
/// <param name="sprite"></param>
public override void Draw(Sprite sprite)
{
// update state towards target
if (slew)
state = (state * 7 + target) / 8;
else
state = target;
// calc angle from state
float angle = ((float)state - 0.5f) * (halfAngle * 2.0f);
// If there's a shadow, draw that first
if (shadowOffsetBase.X != 0)
{
PointF shadow = new PointF(destPosn.X + shadowOffsetDest.X + destSize.Width / 2, destPosn.Y + shadowOffsetDest.Y + destSize.Height / 2);
sprite.Draw2D(texture, shadowSrcRect, destSize, centre, angle, shadow, Color.White);
}
// rotating form of Draw2D() positions the CENTRE at xy instead of the top-left pixel,
// So I must calculate the centre position from the top-left posn (in destination coordinates)
PointF posn = new PointF(destPosn.X + destSize.Width / 2, destPosn.Y + destSize.Height / 2);
// Need to call a different Draw2D() so that we can rotate the sprite
sprite.Draw2D(texture, srcRect, destSize, centre, angle, posn, Color.White);
}
