/// <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();
}
}
}
public static void SetBlend(bool value, float rate = 1F)
{
if (value == Blending)
{
return;
}
Blending = value;
Sprite.Flush();
Sprite.End();
if (Blending)
{
Sprite.Begin(SpriteFlags.DoNotSaveState);
Device.RenderState.AlphaBlendEnable = true;
Device.RenderState.SourceBlend = Blend.BlendFactor;
Device.RenderState.DestinationBlend = Blend.One;
Device.RenderState.BlendFactor = Color.FromArgb((byte)(255 * rate), (byte)(255 * rate),
(byte)(255 * rate), (byte)(255 * rate));
}
else
{
Sprite.Begin(SpriteFlags.AlphaBlend);
}
Device.SetRenderTarget(0, CurrentSurface);
}
private void DrawSmallText(string text, PointF pos, Color color)
{
sprite.Begin(SpriteFlags.AlphaBlend);
{
smallFont.DrawText(sprite, text, new Point((int)pos.X, (int)pos.Y), color);
}
sprite.End();
}
public void Begin()
{
device.SetRenderTarget(0, offScreenSurface);
device.BeginScene();
sprite.Begin(SpriteFlags.AlphaBlend);
device.SetSamplerState(0, SamplerStageStates.MagFilter, true);
device.SetSamplerState(0, SamplerStageStates.MinFilter, true);
}
public void DrawIcon(Canvas canvas, float x, float y)
{
_sprite.Begin(this.Flags);
_sprite.Transform = Matrix.Scaling(Scaling.X, Scaling.Y, Scaling.Z) *
Matrix.Translation(x, y, 0);
_sprite.Draw(_texture, Vector3.Empty, Vector3.Empty, Color.White.ToArgb());
_sprite.End();
}
public void BatchDraw(SpriteFlags flags)
{
_sprite_resource.Begin(flags);
lock (this)
{
foreach (AGT_SpriteResource t in _texture_list.Values)
{
t.DrawRelative(_sprite_resource, Scale, X, Y, 0, Color.White.ToArgb());
}
}
_sprite_resource.End();
}
public void Draw()
{
if (IsGameOpen())
{
stateManager.IsDrawing = true;
deviceManager.Device.Clear(ClearFlags.Target, Color.RoyalBlue, 0, 0);
deviceManager.Device.BeginScene();
Sprite s = new Sprite(deviceManager.Device);
s.Begin(SpriteFlags.AlphaBlend);
// Draw Current Map
if (game != null)
{
game.Draw(s);
}
s.End();
s.Dispose();
deviceManager.Device.EndScene();
if (IsGameOpen())
{
deviceManager.Device.Present();
}
stateManager.IsDrawing = false;
}
}
public static void Draw()
{
if (instances == null || instances.Count == 0)
{
return;
}
Game.Device.Rasterizer.State = rs;
spriteDrawer.Begin(SpriteFlags.SaveState);
foreach (KeyValuePair <String, CustomSpriteInstance> entry in instances)
{
CustomSpriteInstance i = instances[entry.Key];
if (i.enabled == false)
{
continue;
}
if (i.blendMode == SpriteBlendMode.Additive)
{
Game.Device.OutputMerger.BlendState = bsAdditive;
}
else
{
Game.Device.OutputMerger.BlendState = bsAlphaBlend;
}
spriteDrawer.DrawImmediate(new CustomSpriteInstance[] { i });
}
spriteDrawer.End();
}
public void DibujarEscena()
{
counter++;
if (counter >= 0)
{
//plaza.Dibujar();
//cielo.Dibujar();
//flag.Draw();
DebugMode.WriteCamaraPos(200, 200);
//Collision.DrawColissions();
road.Draw2();
//
star.Draw();
AsteroidGenerator.DrawAsteroids();
SpcShipGenerator.Draw();
spaceShip.Dibujar();
camara.Draw();
}
//
Sprite.Begin();
Sprite.DrawText(20, 20, "Press mouse left button to move forward", Glut.GLUT_BITMAP_HELVETICA_18);
Sprite.DrawText(20, 50, "Press escape to exit", Glut.GLUT_BITMAP_HELVETICA_18);
Sprite.End();
}
/// <summary>
///
/// </summary>
protected virtual void Idle()
{
SlimDX.Direct3D9.Device device = Device;
device.BeginScene();
// reset the depth buffer to 1.0 and the render target to black
device.Clear(ClearFlags.Target | ClearFlags.ZBuffer,
new Color4(0, 0, 0), 1.0f, 0);
// prepare for drawing sprites. We need transparency and z-order
Sprite.Begin(SpriteFlags.AlphaBlend
| SpriteFlags.SortDepthBackToFront);
OnRender(new RenderEventArgs(this, Device));
System.Diagnostics.Debug.Assert(device != null);
// aaaannnd.... done!
Sprite.End();
// painting done ...
device.EndScene();
// ... so show the result on screen
device.Present();
OnIdleEvent(new EventArgs());
}
protected override void OnPaint(System.Windows.Forms.PaintEventArgs e)
{
if (device.Disposed)
{
return;
}
// Get elapsed time to calculate FPS
ElapsedTime = DXUtil.Timer(DirectXTimer.GetElapsedTime);
device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.CornflowerBlue, 1.0f, 0);
device.BeginScene();
Draw();
// Drawing multiple lines of text on the same sprite is more efficient
using (Sprite s = new Sprite(device))
{
s.Begin(SpriteFlags.AlphaBlend);
int y = 5;
font.DrawText(s, string.Format("FPS: {0}", ((int)(1f / ElapsedTime)).ToString()), new Rectangle(4, y, 0, 0), DrawTextFormat.NoClip, Color.FromArgb(64, 255, 255, 255));
y += 22;
font.DrawText(s, string.Format("Ambient light: {0}%", (int)(ambient * 100)), new Rectangle(4, y, 0, 0), DrawTextFormat.NoClip, Color.FromArgb(64, 255, 255, 255));
s.End();
}
device.EndScene();
device.Present();
// The onPaint event must be called again
this.Invalidate();
}
static void Drawing_OnEndScene(EventArgs args)
{
try
{
foreach (var existingSlide in ExistingSlide)
{
if (S == null || S.IsDisposed)
{
return;
}
const float percentScale = 2;
S.Begin();
var slide = existingSlide;
foreach (var mPos in from enemy in Enemies2
select Drawing.WorldToScreen(slide.Position) into serverPos
let playerServerPos = Drawing.WorldToScreen(Player.Position)
select new Size((int)(serverPos[0] - 62 * 0.3f), (int)(serverPos[1] - 62 * 0.3f)))
{
DirectXDrawer.DrawSprite(S, wButton,
mPos.ScaleSize(percentScale, new Vector2(mPos.Width, mPos.Height)),
new[] { 0.3f * percentScale, 0.3f * percentScale });
}
S.End();
}
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
if (ex.GetType() == typeof(SharpDXException))
{
Game.PrintChat("An error occured. Please re-load LeBlanc app.");
}
}
}
/// <summary>
/// Called when it is time to draw a frame.
/// </summary>
public override void Draw()
{
// Clears the background
Display.ClearBuffers();
// Aplly a rotation
Matrix4 mvp = Matrix4.CreateRotationY(Yaw) * ModelViewMatrix * ProjectionMatrix;
Display.Shader = Shader;
// Uniforms
Shader.SetUniform("modelview", mvp);
Shader.SetUniform("DiffuseMaterial", new float[] { 0.0f, 0.75f, 0.75f });
Shader.SetUniform("LightPosition", new float[] { 0.25f, 0.25f, -1.0f });
Shader.SetUniform("AmbientMaterial", new float[] { 0.04f, 0.04f, 0.04f });
Shader.SetUniform("SpecularMaterial", new float[] { 0.5f, 0.5f, 0.5f });
Shader.SetUniform("Shininess", 50.0f);
if (swap)
{
Torus.Draw();
}
else
{
Trefoil.Draw();
}
// Some dummy text
Sprite.Begin();
Sprite.DrawString(Font, new Vector2(50, 25), Color.White, "Here's an example of draw buffers.");
Sprite.DrawString(Font, new Vector2(50, 50), Color.White, "Press space key to swap mesh.");
Sprite.End();
}
public override void Render(Device device)
{
if (Initialized)
{
// Draw the Panel
Background.Begin(SpriteFlags.AlphaBlend);
if (IsClicked)
{
Background.Draw(Clicked, new Rectangle(0, 0, Size.Width, Size.Height), Vector3.Empty, new Vector3((int)(Position.X + (Parent != null ? Parent.Position.X : 0)), (int)(Position.Y + (Parent != null ? Parent.Position.Y : 0)), 0), BitConverter.ToInt32(new byte[] { 0xFF, 0xFF, 0xFF, (byte)Opacity }, 0));
}
else if (IsMouseOver)
{
Background.Draw(Hover, new Rectangle(0, 0, Size.Width, Size.Height), Vector3.Empty, new Vector3((int)(Position.X + (Parent != null ? Parent.Position.X : 0)), (int)(Position.Y + (Parent != null ? Parent.Position.Y : 0)), 0), BitConverter.ToInt32(new byte[] { 0xFF, 0xFF, 0xFF, (byte)Opacity }, 0));
}
else
{
Background.Draw(Normal, new Rectangle(0, 0, Size.Width, Size.Height), Vector3.Empty, new Vector3((int)(Position.X + (Parent != null ? Parent.Position.X : 0)), (int)(Position.Y + (Parent != null ? Parent.Position.Y : 0)), 0), BitConverter.ToInt32(new byte[] { 0xFF, 0xFF, 0xFF, (byte)Opacity }, 0));
}
// Center and Draw Text
int y = ((150 - (Text.Length * 2)) / 2) - 19;
font.DrawText(Background, Text, new Point((int)(Position.X + (Parent != null ? Parent.Position.X : 0)) + y, (int)(Position.Y + (Parent != null ? Parent.Position.Y : 0)) + 3), Color.Black);
Background.End();
}
}
} // AtualizarCamera()
// [---
public void Renderizar()
{
// Limpa os dispositivos e os buffers de apoio
device.Clear(ClearFlags.Target | ClearFlags.ZBuffer,
Color.CornflowerBlue, 1.0f, 0);
device.BeginScene();
// (...) Todo o código de desenhar vai aqui
// Atualiza a câmera
AtualizarCamera();
AtualizarLuz();
radar.Begin(SpriteFlags.None);
radar.Draw(texturaAlvo, new Rectangle(0, 0, superficie_ntam, superficie_ntam),
new Vector3(0, 0, 0), new Vector3(10, 10, 1.0f), Color.White);
radar.End();
posicao = new Vector3(-50.0f, 0.2f, -200.0f);
rotacao = new Vector3(0, 0, 0);
g_props = new Propriedades3D(posicao, rotacao);
desenharObjeto(objeto3D, g_props);
device.EndScene();
// Apresenta a cena renderizada na tela
device.Present();
// Libera a janela para processar outros eventos
Application.DoEvents();
} // Renderizar()
public void Run()
{
Device device;
SwapChain swapChain;
RenderTargetView renderTarget;
EmptyWindow.CreateDeviceSwapChainAndRenderTarget(mForm, out device, out swapChain, out renderTarget);
// buffer size 1 .. 4096 (0 defaults to 4096)
var sprite = new Sprite(device, 10);
var font = new Font(device, 20, "ARIAL");
Application.Idle +=
delegate
{
device.ClearRenderTargetView(renderTarget, new Color4(1, 0, 0));
var rectangle = new Rectangle(10, 10, 400, 300);
sprite.Begin(SpriteFlags.None);
font.Draw(sprite, "Hello from SlimDX", rectangle, FontDrawFlags.Left,
(uint)Color.Yellow.ToArgb());
sprite.End();
swapChain.Present(0, PresentFlags.None);
Application.DoEvents();
};
Application.Run(mForm);
}
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 {
}
}
}
/// <summary>
/// The render method to draw this widget on the screen.
///
/// Called on the GUI thread.
/// </summary>
/// <param name="drawArgs">The drawing arguments passed from the WW GUI thread.</param>
public void Render(DrawArgs drawArgs)
{
if (!this.m_isInitialized)
{
this.Initialize(drawArgs);
}
if ((m_visible) && (m_enabled))
{
// Draw the interior background
WidgetUtilities.DrawBox(
this.AbsoluteLocation.X,
this.AbsoluteLocation.Y,
m_size.Width,
m_size.Height,
0.0f,
m_BackgroundColor.ToArgb(),
drawArgs.device);
m_sprite.Begin(SpriteFlags.AlphaBlend);
m_sprite.Transform = Matrix.Scaling(this.XScale, this.YScale, 0);
m_sprite.Transform *= Matrix.Translation(AbsoluteLocation.X + m_size.Width / 2, AbsoluteLocation.Y + m_size.Height / 2, 0);
m_sprite.Draw(m_iconTexture.Texture,
new Vector3(m_iconTexture.Width >> 1, m_iconTexture.Height >> 1, 0),
Vector3.Empty,
m_normalColor);
m_sprite.Transform = Matrix.Identity;
m_sprite.End();
UpdateCrosshair(drawArgs);
}
}
/// <summary>
/// Begins the draw operation.
/// </summary>
public void Begin()
{
_direct3D9Device.BeginScene();
_direct3D9Device.Clear(ClearFlags.Target, DirectXHelper.ConvertColor(_graphicsDevice.ClearColor), 0, 0);
_sprite.Transform = Matrix.Identity;
_sprite.Begin(SpriteFlags.AlphaBlend);
}
private void DrawFullscreenQuad(Texture texture)
{
_sprite.Begin(SpriteFlags.None);
//begin the shader effect, only need 1 pass
if (_effect != null)
{
_effect.Begin();
_effect.BeginPass(0);
}
_sprite.Draw(texture, Colors.White.ToColor4());
/*Rectangle dest = new Rectangle(0, 0, Dims, Dims);
* VertexTransformedPositionTexture[] vertices = new VertexTransformedPositionTexture[4];
* vertices[0] = new VertexTransformedPositionTexture(new Point4D(dest.Left - 0.5f, dest.Top - 0.5f, 0, 1), new Point2D(0, 0));
* vertices[1] = new VertexTransformedPositionTexture(new Point4D(dest.Right - 0.5f, dest.Top - 0.5f, 0, 1), new Point2D(1, 0));
* vertices[2] = new VertexTransformedPositionTexture(new Point4D(dest.Right - 0.5f, dest.Bottom - 0.5f, 0, 1), new Point2D(0, 1));
* vertices[3] = new VertexTransformedPositionTexture(new Point4D(dest.Right - 0.5f, dest.Bottom - 0.5f, 0, 1), new Point2D(1, 1));
* _graphics.DrawIndexedUserPrimitives(PrimitiveType.TriangleStrip, 0, 4, 2, new[] { 0, 1, 2, 3},
* Format.Index32, vertices, VertexTransformedPositionTexture.SizeInBytes);*/
if (_effect != null)
{
_effect.EndPass();
_effect.End();
}
_sprite.End();
}
/// <summary>
/// 进行游戏图像渲染帧中的渲染操作
/// </summary>
public void Draw()
{
RenderTarget defRt = renderSys.GetRenderTarget(0);
if (currentGame == null)
{
renderSys.Clear(ClearFlags.Target | ClearFlags.DepthBuffer, ColorValue.Transparent, 1, 0);
}
else
{
currentGame.Render();
}
if (menu != null)
{
menu.Render();
}
renderSys.SetRenderTarget(0, defRt);
sprite.Begin();
if (currentGame != null)
{
currentGame.Render(sprite);
}
if (menu != null)
{
menu.Render(sprite);
}
sprite.End();
}
public void Render()
{
sprite.Begin(SpriteFlags.None);
MdxRender.Device.RenderState.AlphaBlendEnable = true;
MdxRender.Device.RenderState.AlphaTestEnable = false;
MdxRender.Device.RenderState.ZBufferWriteEnable = false;
MdxRender.Device.RenderState.BlendOperation = BlendOperation.Add;
MdxRender.Device.RenderState.SourceBlend = Blend.SourceColor;
MdxRender.Device.RenderState.DestinationBlend = Blend.One;
for (int i = 0; i < lensFlareValues.Reflections.Count; i++)
{
Texture texture = bitmaps[lensFlareValues.Reflections[i].BitmapIndex.Value] as Texture;
if (texture == null)
{
continue;
}
int color = new ColorValue(lensFlareValues.Reflections[i].TintColor.R, lensFlareValues.Reflections[i].TintColor.G, lensFlareValues.Reflections[i].TintColor.B, lensFlareValues.Reflections[i].TintColor.A).ToArgb();
Vector3 position = Vector3.Project(new Vector3(0.0f, 0.0f, 0.0f), MdxRender.Device.Viewport, MdxRender.Device.Transform.Projection, MdxRender.Camera.GetViewMatrix(), MdxRender.Device.Transform.World);
sprite.Draw(texture, new Vector3((float)(bitmaps.BitmapValues.Bitmaps[lensFlareValues.Reflections[i].BitmapIndex.Value].Width.Value / 2), (float)(bitmaps.BitmapValues.Bitmaps[lensFlareValues.Reflections[i].BitmapIndex.Value].Height.Value / 2), 0.0f), new Vector3(position.X, position.Y, 0.0f), color);
}
sprite.End();
}
public void Render()
{
Sprite.Begin(SpriteFlags.AlphaBlend | SpriteFlags.SortDepthFrontToBack);
Sprite.Transform = TransformationMatrix.ToMatrix();
Sprite.Draw(Texture.D3dTexture, SrcRect, TGCVector3.Empty, TGCVector3.Empty, Color);
Sprite.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 DrawOverlay(Texture targetTexture)
{
if (targetTexture == null || _combinedOsdSurface == null)
{
return;
}
try
{
lock (_syncObj)
{
// TemporaryRenderTarget changes RenderTarget to texture and restores settings when done (Dispose)
using (new TemporaryRenderTarget(targetTexture))
{
_sprite.Begin();
_sprite.Draw(_combinedOsdTexture, new ColorBGRA(255, 255, 255, 255) /* White */);
_sprite.End();
}
}
}
catch (Exception ex)
{
BluRayPlayerBuilder.LogError(ex.ToString());
}
}
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 {
}
}
}
/// <summary>
/// Begin the sprite rendering
/// </summary>
public void Begin()
{
if (textSprite != null)
{
textSprite.Begin(SpriteFlags.AlphaBlend | SpriteFlags.SortTexture);
}
}
/// <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);
}
}
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();
}
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();
}
}
//String shader2 = "sampler2D g_samSrcColor;float4 MyShader( float4 Tex : TEXCOORD0 ) : COLOR0{float4 Color;Color = tex2D( g_samSrcColor, Tex.xy);return Color;}";
private void DrawSprite(SlimDX.Direct3D10.Device device)
{
if (_sprite == null)
{
_sprite = new Sprite(device, 1);
_sTexture = Texture2D.FromFile(
device,
@"C:\temp\privet.png");
_srv = new ShaderResourceView(device, _sTexture);
_si[0] = new SpriteInstance(_srv, new Vector2(0, 0), new Vector2(1, 1));
//_sprite.ProjectionTransform = Matrix.OrthoOffCenterLH(0, 800, -600, 0, -10, 10);
_sprite.ViewTransform = Matrix.Transformation2D(Vector2.Zero, 0.0f, new Vector2(2.0f, 2.0f), Vector2.Zero, 0.0f, Vector2.Zero);
using (var bytecode = ShaderBytecode.Compile(shader, "PShader", "ps_4_0", ShaderFlags.EnableBackwardsCompatibility, EffectFlags.None))
pixelShader = new PixelShader(device, bytecode);
}
device.PixelShader.Set(pixelShader);
//if ((DateTime.Now - _lastSprite).TotalMilliseconds > 0)
//{
_sprite.Begin(SpriteFlags.None);
_sprite.DrawImmediate(_si);
_sprite.End();
_lastSprite = DateTime.Now;
//}
}
public static void Draw(Vector2 position, Texture texture, Color?color = null, Vector3?center = null, Rectangle?rectangle = null, float?rotation = null, Vector2?scale = null)
{
var col = color ?? Color.White;
var pos = new Vector3(position, 0);
if (center.HasValue)
{
pos += center.Value;
}
Sprite.Begin(SpriteFlags.AlphaBlend);
if (!rotation.HasValue || !scale.HasValue)
{
Sprite.Draw(texture, col, rectangle, center, pos);
}
else
{
var transform = Sprite.Transform;
Sprite.Transform *= Matrix.Scaling(new Vector3(scale.Value, 0)) * Matrix.RotationZ(rotation.Value) * Matrix.Translation(pos);
Sprite.Draw(texture, col, rectangle, center);
Sprite.Transform = transform;
}
Sprite.End();
}
protected override void OnPaint(System.Windows.Forms.PaintEventArgs e)
{
spritePosition = new Vector3(200f, 200f, 0f);
device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.Blue, 1.0f, 0);
device.BeginScene();
using (Sprite sprite = new Sprite(device)) {
sprite.Begin(SpriteFlags.AlphaBlend);
//render sprites here
sprite.End();
}
device.EndScene();
device.Present();
this.Invalidate();
}
protected override void OnPaint(System.Windows.Forms.PaintEventArgs e)
{
spritePosition = new Vector3(200f, 200f, 0f);
device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.Blue, 1.0f, 0);
device.BeginScene();
using (Sprite sprite = new Sprite(device))
{
sprite.Begin(SpriteFlags.AlphaBlend);
sprite.Draw(tileSet.Texture, tilePosition, spriteCenter, spritePosition,
Color.FromArgb(255,255,255,255));
sprite.End();
}
device.EndScene();
device.Present();
this.Invalidate();
}
void TextureViewer_Load(object sender, EventArgs e)
{
this.Show();
Application.DoEvents();
pp = new PresentParameters();
pp.BackBufferCount = 2;
pp.SwapEffect = SwapEffect.Discard;
pp.Windowed = true;
Direct3D d3d = new Direct3D();
d3d_device = new Device(d3d, 0, DeviceType.Hardware, d3dPanel.Handle, CreateFlags.HardwareVertexProcessing, pp);
texture = Texture.FromFile(d3d_device, texturePath);
int texWidth = texture.GetLevelDescription(0).Width;
int texHeight = texture.GetLevelDescription(0).Height;
d3dPanel.Top = menuStrip1.Height;
d3dPanel.Left = 0;
d3dPanel.ClientSize = new Size(texWidth, texHeight);
this.ClientSize = new System.Drawing.Size(
d3dPanel.Width,
d3dPanel.Height + menuStrip1.Height
);
pp.BackBufferWidth = texWidth;
pp.BackBufferHeight = texHeight;
d3d_device.Reset(pp);
sprite = new Sprite(d3d_device);
while (this.Visible)
{
d3d_device.Clear(ClearFlags.ZBuffer | ClearFlags.Target, new Color4(Color.Black), 1.0f, 0);
d3d_device.BeginScene();
sprite.Begin(SpriteFlags.AlphaBlend);
Rectangle rect = new Rectangle()
{
X = 0,
Y = 0,
Width = texture.GetLevelDescription(0).Width,
Height = texture.GetLevelDescription(0).Height
};
sprite.Draw(texture, rect, new Color4(Color.White));
sprite.End();
d3d_device.EndScene();
d3d_device.Present();
Application.DoEvents();
}
}
protected override void OnPaint(System.Windows.Forms.PaintEventArgs e)
{
if ( device.Disposed ) return;
// Get elapsed time to calculate FPS
ElapsedTime = DXUtil.Timer(DirectXTimer.GetElapsedTime);
device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.CornflowerBlue, 1.0f, 0);
device.BeginScene();
Draw();
// Drawing multiple lines of text on the same sprite is more efficient
using ( Sprite s = new Sprite(device) )
{
s.Begin(SpriteFlags.AlphaBlend);
int y = 5;
font.DrawText(s,string.Format("FPS: {0}",( (int) (1f / ElapsedTime) ).ToString() ),new Rectangle(4,y,0,0),DrawTextFormat.NoClip,Color.FromArgb(64,255,255,255) );
y += 22;
font.DrawText(s,string.Format("Ambient light: {0}%",(int) (ambient*100)),new Rectangle(4,y,0,0),DrawTextFormat.NoClip,Color.FromArgb(64,255,255,255));
s.End();
}
device.EndScene();
device.Present();
// The onPaint event must be called again
this.Invalidate();
}
/// <summary>
/// Renders the scene.
/// </summary>
public void RenderScene(Color background, List<LightObj> lights, Camera camera)
{
bool useGlow = false;
// Sets the variables for the shader.
SetVariables(lights, camera);
//effect.Technique = "Test";
for (int i = 0; i < mesh.Count; i++)
{
if (mesh[i].Emissive.Enable && !mesh[i].Emissive.Path.Equals(""))
{
useGlow = true;
break;
}
}
// If/Else statement to control rendering with emissive glow or not.
if (useGlow)
RenderGlow();
else
BeginRender(background);
// If emissive glow is used, the base scene is rendered to a texture.
if (useGlow)
{
surfRender.BeginScene(renderedScene.GetSurfaceLevel(0), device.Viewport);
device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, background, 1.0f, 0);
}
if (groundPlane.Enabled)
RenderModel((Model)groundPlane, lights[0].Shadows, 0);
// Loops through all the models and renders each.
for (int i = 0; i < mesh.Count; i++)
{
if (mesh[i].Enabled)
RenderModel(mesh[i], lights[0].Shadows, 0);
}
if (showLights)
{
using (Sprite spriteobject = new Sprite(device))
{
foreach (LightObj light in lights)
{
if (!light.Enabled)
continue;
spriteobject.SetWorldViewRH(device.Transform.World, device.Transform.View);
spriteobject.Begin(SpriteFlags.AlphaBlend | SpriteFlags.Billboard | SpriteFlags.SortTexture | SpriteFlags.ObjectSpace);
//spriteobject.Transform = Matrix.Scaling(0.25f, 0.25f, 0.25f);
spriteobject.Draw(lightTexture, Rectangle.Empty, Vector3.Empty, light.Direction, Color.White);
spriteobject.End();
}
}
}
// If emissive glow is used, the textures are set to the shader and rendered to a sprite.
if (useGlow)
{
surfRender.EndScene(Filter.None);
effect.SetValue("renderedScene", renderedScene);
BeginRender(background);
using (Sprite spriteobject = new Sprite(device))
{
prevTechnique = effect.Technique;
effect.Technique = "Bloom";
effect.Begin(FX.None);
spriteobject.Begin(SpriteFlags.None);
effect.BeginPass(0);
spriteobject.Draw(renderedGlow, Rectangle.Empty, new Vector3(0, 0, 0), new Vector3(0, 0, 0), Color.White);
effect.EndPass();
spriteobject.End();
effect.End();
effect.Technique = prevTechnique;
}
}
EndRender();
}
/// <summary>
/// Called once per frame, the call is the entry point for 3d rendering. This
/// function sets up render states, clears the viewport, and renders the scene.
/// </summary>
protected override void Render()
{
RenderBGPointer();
//Clear the backbuffer to a Blue color
device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.Blue, 1.0f, 0);
//Set the view matrix
device.Transform.View = viewMatrix;
//Begin the scene
device.BeginScene();
device.RenderState.ZBufferEnable = false;
device.RenderState.Lighting = false;
spaceSphere.Render();
device.RenderState.Lighting = true;
device.RenderState.ZBufferEnable = true;
device.Transform.World = playerShip.Position.WorldMatrix;
playerShip.Render();
opponentShip.Render();
//Render our targeting pointer
using (Sprite pointerSprite = new Sprite(device)) {
pointerSprite.Begin(SpriteFlags.AlphaBlend);
pointerSprite.Draw(bgPointerTexture, new Rectangle(0, 0, 128, 128),
new Vector3(0, 0, 0), new Vector3(42, this.Height - 250, 0), Color.White);
pointerSprite.Transform = Matrix.Identity;
pointerSprite.Draw(vectorPanel,new Rectangle(0,0,193,173),
new Vector3(0,0,0), new Vector3(10, this.Height- 282, 0), Color.White);
pointerSprite.End();
}
//Output the scores
drawingFont.DrawText(5, 20, Color.Red, playerShip.HostName.ToString() + ":");
drawingFont.DrawText(100,20,Color.Red,playerShip.Score.ToString());
if (remotePlayerActive) {
drawingFont.DrawText(5,45,Color.White, peer.RemotePlayer.Name + ":");
drawingFont.DrawText(100,45, Color.White, opponentShip.Score.ToString());
}
//Display any status messages
if (statusMessageTimer < Constants.StatusMessageDisplayTime) {
drawingFont.DrawText(200, screenCenter.Y, Color.FromArgb(200,220,220,255), statusMessage);
}
if (debugging) {
drawingFont.DrawText(5,5,Color.Yellow,debugText);
}
device.EndScene();
}
/// <summary>
/// Draw the player information.
/// </summary>
/// <param name="device">The direct3D device.</param>
private void DrawInfo(Device device)
{
try
{
int deviceWidth = device.Viewport.Width;
int deviceHeight = device.Viewport.Height;
long frameCounter = _memory.GetFrameCount();
if (frameCounter > 10)
{
if (string.IsNullOrEmpty(_playerOneName))
{
_playerOneName = _memory.GetCharacter(1);
}
if (string.IsNullOrEmpty(_playerTwoName))
{
_playerTwoName = _memory.GetCharacter(2);
}
_sprite = new Sprite(_device);
_sprite.Begin(SpriteFlags.AlphaBlend);
_sprite.Transform
= Matrix.Scaling(new Vector3(_fontSize / (12 / 2), _fontSize / (7 / 2), 0));
_spritePosition = new Vector2(
_fontSize,
(deviceHeight / _fontSize) * 7);
_sprite.Draw(_background, new Vector3(1, 1, 0), new Vector3(_spritePosition, -1), Color.White);
_spritePosition = new Vector2(
deviceWidth - (_fontSize * 13),
(deviceHeight / _fontSize) * 7);
_sprite.Draw(_background, new Vector3(1, 1, 0), new Vector3(_spritePosition, -1), Color.White);
_sprite.End();
_sprite.Dispose();
_sprite = new Sprite(_device);
_sprite.Begin(SpriteFlags.AlphaBlend);
// P1
string playerOneHeader = string.Format("-{0}'s STATS-", _playerOneName);
string playerOnePos = string.Format(
"[{0},{1}]",
_memory.GetPosX(1).ToString("F3"),
_memory.GetPosY(1).ToString("F3"));
string playerOneHealth = string.Format("HP : {0}", _memory.GetHealth(1));
string playerOneStun = string.Format("STUN : {0}", _memory.GetStun(1));
string playerOneEx = string.Format("EX : {0}", _memory.GetEXmeter(1));
string playerOneUltra = string.Format("ULTRA : {0}", _memory.GetUltraMeter(1));
string playerOneScript = string.Format(
"ANIM : {0} ({1})",
_memory.PlayerAnim(1),
_memory.GetAnimFrame(1));
int playerOneInterruptFrame = _memory.GetInterruptFrame(1);
string playerOneInterrupt = string.Format("INTRPT: {0}", playerOneInterruptFrame);
// P2
string playerTwoHeader = string.Format("-{0}'s STATS-", _playerTwoName);
string playerTwoPos = string.Format(
"[{0},{1}]",
_memory.GetPosX(2).ToString("F3"),
_memory.GetPosY(2).ToString("F3"));
string playerTwoHealth = string.Format("HP : {0}", _memory.GetHealth(2));
string playerTwoStun = string.Format("STUN : {0}", _memory.GetStun(2));
string playerTwoEx = string.Format("EX : {0}", _memory.GetEXmeter(2));
string playerTwoUltra = string.Format("ULTRA : {0}", _memory.GetUltraMeter(2));
string playerTwoScript = string.Format(
"ANIM : {0} ({1})",
_memory.PlayerAnim(2),
_memory.GetAnimFrame(2));
int playerTwoInterruptFrame = _memory.GetInterruptFrame(2);
string playerTwoInterrupt = string.Format("INTRPT: {0}", playerTwoInterruptFrame);
string playerOneAdv = string.Format("ADV : {0}", playerOneInterruptFrame - playerTwoInterruptFrame);
string playerTwoAdv = string.Format("ADV : {0}", playerTwoInterruptFrame - playerOneInterruptFrame);
string playerOneStats = string.Join(
"\n",
playerOneHeader,
playerOnePos,
playerOneHealth,
playerOneStun,
playerOneEx,
playerOneUltra,
playerOneScript,
playerOneInterrupt,
playerOneAdv);
string playerTwoStats = string.Join(
"\n",
playerTwoHeader,
playerTwoPos,
playerTwoHealth,
playerTwoStun,
playerTwoEx,
playerTwoUltra,
playerTwoScript,
playerTwoInterrupt,
playerTwoAdv);
_font.DrawString(null, playerOneStats, _fontSize, (deviceHeight / _fontSize) * 8, _textColor);
_font.DrawString(null, playerTwoStats, deviceWidth - (_fontSize * 13), (deviceHeight / _fontSize) * 8, _textColor);
// Both
_font.DrawString(
null,
string.Format("Combo Counter: {0}", _memory.ComboCounter()),
deviceWidth / 20 * 9,
30,
_textColor);
_font.DrawString(
null,
string.Format("Distance: {0}", _memory.GetDistance()),
deviceWidth / 20 * 8,
deviceHeight / 20 * 18,
_textColor);
_font.DrawString(
null,
string.Format("Frame Counter: {0}", frameCounter),
deviceWidth / 20 * 8,
deviceHeight / 20 * 19,
_textColor);
_sprite.End();
_sprite.Dispose();
}
else
{
_playerOneName = string.Empty;
_playerTwoName = string.Empty;
}
}
catch
{
}
}
/// <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>
/// Render the panel. This base class method renders all the widgets
/// (using their current frame). Subclasses may override this
/// to add code for writing text and other UI components as well.
/// </summary>
public void Render()
{
// --------------------- Set Renderstate ------------------
// Set ALL that we care about and rem out the others.
// If I add any here, add them to ALL renderable classes
//*** world matrix ***
//Engine.Device.Transform.World = Matrix.Identity; // Matrix is fixed at 0,0,0
//*** expected vertex format ***
//Engine.Device.VertexFormat = CustomVertex.PositionNormalTextured.Format; // Textured objects
//Engine.Device.VertexFormat = CustomVertex.PositionNormalColored.Format; // Vertex-coloured objects
//*** material ***
//Engine.Device.Material = material;
//*** Once-only texture settings ***
//Engine.Device.SetTexture(0,texture); // Use this texture for all primitives
//Engine.Device.SetTexture(0,null); // Use no texture at all (material-only objects)
//Engine.Device.SamplerState[0].MagFilter = TextureFilter.None; // (texel smoothing option)
//Engine.Device.SamplerState[0].MagFilter = TextureFilter.Linear; // (texel smoothing option)
//Engine.Device.SamplerState[0].AddressU = TextureAddress.Mirror; // Texture mirroring required
//Engine.Device.SamplerState[0].AddressV = TextureAddress.Mirror; // ditto in V direction
//*** Transparency settings ***
//Engine.Device.RenderState.AlphaBlendEnable = true; // enable/disable transparency)
// Vector alpha...
//Engine.Device.RenderState.DiffuseMaterialSource = ColorSource.Color1;
// Material alpha...
// Engine.Device.RenderState.DiffuseMaterialSource = ColorSource.Material;
// Engine.Device.RenderState.SourceBlend = Blend.SourceAlpha; // Source blend
// Engine.Device.RenderState.DestinationBlend = Blend.InvSourceAlpha; // Dest blend
// Texture alpha...
//Engine.Device.TextureState[0].ColorOperation = TextureOperation.Modulate; // Use the following for texture transp
//Engine.Device.TextureState[0].ColorArgument1 = TextureArgument.TextureColor;
//Engine.Device.TextureState[0].ColorArgument2 = TextureArgument.Diffuse;
//Engine.Device.TextureState[0].AlphaOperation = TextureOperation.Modulate;
//Engine.Device.TextureState[0].AlphaArgument1 = TextureArgument.TextureColor;
//Engine.Device.TextureState[0].AlphaArgument2 = TextureArgument.Diffuse;
//*** depth buffering ***
Engine.Device.RenderState.ZBufferEnable = false; // ZBuffer
//*** lighting ***
Engine.Device.RenderState.Lighting = false; // enabled
Engine.Device.RenderState.SpecularEnable = false; // Specular lighting
// --------------------------------------------------------
// Draw all the widgets...
Sprite sprite; // we only need one sprite
using (sprite=new Sprite(Engine.Device))
{
sprite.Begin(SpriteFlags.AlphaBlend);
for (int s=0; s<widgetList.Count; s++)
{
widgetList[s].Draw(sprite); // draw the current anim frame
}
sprite.End();
}
}
protected override void OnPaint(System.Windows.Forms.PaintEventArgs e)
{
try
{
RenderIntoSurface();
m_d3dDevice.Clear(ClearFlags.Target | ClearFlags.ZBuffer, m_clBackColor , 1.0f, 0);
SetupCamera();
m_d3dDevice.BeginScene();
if(this.Editor != null && this.Editor.PhysicalStructure != null && m_d3dDevice != null)
if(Editor.PhysicalStructure.RootBody != null)
{
RigidBodies.RigidBody_DX rbRoot = (RigidBodies.RigidBody_DX)Editor.PhysicalStructure.RootBody;
if(rbRoot.Device == null || m_bReset)
{
rbRoot.InitDevice(m_d3dDevice);
m_bReset = false;
this.Invalidate();
}
else
Editor.PhysicalStructure.Draw(Editor.CommandBar.CommandMode);
}
using (Sprite s = new Sprite(m_d3dDevice))
{
//save the renderTexture to a graphics stream
//gsStream = TextureLoader.SaveToStream(ImageFileFormat.Dds, renderTexture);
//load the renderTexture to a texture object with a color key for transparency
//texTransBillBoard = TextureLoader.FromStream(Device,gsStream,0,0,1,Usage.None,Format.Unknown,Pool.Managed,Filter.None, Filter.None,Color.Black.ToArgb());
//Draw the texture
s.Begin(SpriteFlags.None);
s.Draw(renderTexture, new Rectangle(0,0, RenderSurfaceSize, RenderSurfaceSize), new Vector3(), new Vector3(0,0,0.0f), Color.White);
s.End();
}
m_d3dDevice.EndScene();
m_d3dDevice.Present(this);
}
catch(Microsoft.DirectX.Direct3D.DeviceLostException)
{
try
{
m_d3dDevice.Reset(m_ppPresentParams);
this.Invalidate();
}
catch (DeviceLostException)
{
// If it's still lost or lost again, just do nothing
}
}
catch(Exception ex)
{
Util.Logger.LogMsg(AnimatTools.Interfaces.Logger.enumLogLevel.Error, Util.GetErrorDetails("", ex));
if(Editor.PhysicalStructure.RootBody == null)
return;
}
}
public void drawImage2d(Device i_dev,int i_x,int i_y,INyARRgbRaster i_raster)
{
NyARIntSize s = i_raster.getSize();
if (this._texture == null)
{
this._texture=new NyARD3dTexture(i_dev,s.w,s.h);
}
else if (!this._texture.isEqualSize(s))
{
this._texture.Dispose();
this._texture = new NyARD3dTexture(i_dev, s.w, s.h);
}
this._texture.setRaster(i_raster);
using (Sprite sp = new Sprite(i_dev))
{
sp.Begin(SpriteFlags.None);
sp.Draw((Texture)this._texture, new Rectangle(i_x,i_y, s.w,s.h), Vector3.Empty,new Vector3(i_dev.Viewport.X, i_dev.Viewport.Y, 0),Color.White);
sp.End();
}
}
public void DrawOverlay(Surface targetSurface)
{
Texture subTexture;
Subtitle currentSubtitle;
lock (_syncObj)
{
currentSubtitle = _currentSubtitle;
subTexture = _subTexture;
// Available sub is not due
if (currentSubtitle == null || !currentSubtitle.ShouldDraw)
return;
if (targetSurface == null || targetSurface.Disposed || subTexture == null)
{
if (_drawCount > 0)
ServiceRegistration.Get<ILogger>().Debug("Draw count for last sub: {0}", _drawCount);
_drawCount = 0;
return;
}
_drawCount++;
}
try
{
if (!subTexture.Disposed)
{
// TemporaryRenderTarget changes RenderTarget to texture and restores settings when done (Dispose)
using (new TemporaryRenderTarget(targetSurface))
using (TemporaryRenderState temporaryRenderState = new TemporaryRenderState())
using (Sprite sprite = new Sprite(_device))
{
sprite.Begin(SpriteFlags.AlphaBlend);
// No alpha test here, allow all values
temporaryRenderState.SetTemporaryRenderState(RenderState.AlphaTestEnable, 0);
// Use the SourceAlpha channel and InverseSourceAlpha for destination
temporaryRenderState.SetTemporaryRenderState(RenderState.BlendOperation, (int) BlendOperation.Add);
temporaryRenderState.SetTemporaryRenderState(RenderState.SourceBlend, (int) Blend.SourceAlpha);
temporaryRenderState.SetTemporaryRenderState(RenderState.DestinationBlend, (int) Blend.InverseSourceAlpha);
// Check the target texture dimensions and adjust scaling and translation
SurfaceDescription desc = targetSurface.Description;
Matrix transform = Matrix.Identity;
transform *= Matrix.Translation(currentSubtitle.HorizontalPosition, currentSubtitle.FirstScanLine, 0);
// Subtitle could be smaller for 16:9 anamorphic video (subtitle width: 720, video texture: 1024)
// then we need to scale the subtitle width also.
if (currentSubtitle.ScreenWidth != desc.Width)
transform *= Matrix.Scaling((float) desc.Width / currentSubtitle.ScreenWidth, 1, 1);
sprite.Transform = transform;
sprite.Draw(subTexture, Color.White);
sprite.End();
}
}
}
catch (Exception ex)
{
ServiceRegistration.Get<ILogger>().Debug("Error in DrawOverlay", ex);
}
if (_onTextureInvalidated != null)
_onTextureInvalidated();
}
protected override void OnPaint(System.Windows.Forms.PaintEventArgs e)
{
deltaTime = hrt.ElapsedTime;
UpdateSprite(deltaTime);
device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.Blue, 1.0f, 0);
device.BeginScene();
using (Sprite sprite = new Sprite(device)) {
sprite.Begin(SpriteFlags.None);
//Set rotation center for sprite
spriteCenter.X = spritePosition.X + tileSet.ExtentX;
spriteCenter.Y = spritePosition.Y + tileSet.ExtentY;
//Spin, Shift, Stretch :-)
sprite.Transform = Matrix.RotationZ(angle) * Matrix.Translation(spriteCenter);
sprite.Draw(tileSet.Texture, tilePosition, spriteCenter, spritePosition,
Color.FromArgb(255,255,255,255));
sprite.End();
}
device.EndScene();
device.Present();
this.Invalidate();
}
/// <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>
/// Called once per frame, the call is the entry point for 3d rendering. This
/// function sets up render states, clears the viewport, and renders the scene.
/// </summary>
protected override void Render()
{
RenderBGPointer();
//Clear the backbuffer to a Blue color
device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.Blue, 1.0f, 0);
//Set the view matrix
device.Transform.View = viewMatrix;
//Begin the scene
device.BeginScene();
device.RenderState.ZBufferEnable = false;
device.RenderState.Lighting = false;
spaceSphere.Render();
device.RenderState.Lighting = true;
device.RenderState.ZBufferEnable = true;
device.Transform.World = playerShip.Position.WorldMatrix;
playerShip.Render();
opponentShip.Render();
//Render our targeting pointer
using (Sprite pointerSprite = new Sprite(device)) {
pointerSprite.Begin(SpriteFlags.AlphaBlend);
pointerSprite.Draw(bgPointerTexture, new Rectangle(0, 0, 128, 128),
new Vector3(0, 0, 0), new Vector3(42, this.Height - 250, 0), Color.White);
pointerSprite.Transform = Matrix.Identity;
pointerSprite.Draw(vectorPanel,new Rectangle(0,0,193,173),
new Vector3(0,0,0), new Vector3(10, this.Height- 282, 0), Color.White);
pointerSprite.End();
}
if (debugging) {
drawingFont.DrawText(5,5,Color.Yellow,debugText);
}
device.EndScene();
}
