public override void Draw(GameTime gametime)
{
game.GraphicsDevice.SetVertexBuffer(vertices);
game.GraphicsDevice.SetVertexInputLayout(inputLayout);
effect.CurrentTechnique.Passes[0].Apply();
game.GraphicsDevice.Draw(PrimitiveType.TriangleList, vertices.ElementCount);
}
public override void PostUpdate(GameTime gameTime)
{
if (parent != null)
{
parent.WorldBound = parent.WorldBound.Merge(this.WorldBound);
}
}
public void Update(GameTime gameTime)
{
if (Screens.Count > 0)
{
Screen foregroundScreen = Screens.Peek();
List<Screen> Temp = Screens.ToList();
foreach (Screen screen in Temp)
{
if (screen.State == Screen.States.FullyClosed)
{
if (screen == foregroundScreen)
Screens.Pop();
else
continue;
}
screen.Update(gameTime, screen == foregroundScreen);
}
}
if (toOpenWhenCleared != null && Screens.Count == 0)
{
OpenScreen(toOpenWhenCleared);
toOpenWhenCleared = null;
}
}
public void Draw(GameTime gameTime)
{
foreach (var ctrl in Controls)
{
ctrl.Draw();
}
}
protected override void Draw(GameTime gameTime)
{
// Use time in seconds directly
var time = (float) gameTime.TotalGameTime.TotalSeconds;
// Clears the screen with the Color.CornflowerBlue
GraphicsDevice.Clear(Color.CornflowerBlue);
GraphicsDevice.SetRasterizerState(_wireframe ? GraphicsDevice.RasterizerStates.WireFrame : GraphicsDevice.RasterizerStates.Default);
_fx.Parameters["World"].SetValue(Matrix.Scaling(2.0f, 2.0f, 2.0f)*
Matrix.RotationX(0.4f*(float) Math.Sin(time*1.45))*
Matrix.RotationY(time*0.9f)*
Matrix.Translation(-2, 0, -4));
foreach (var effectPass in _fx.CurrentTechnique.Passes)
{
effectPass.Apply();
GraphicsDevice.SetVertexBuffer(_vertexBuffer);
GraphicsDevice.SetVertexInputLayout(_vertexInputLayout);
GraphicsDevice.Draw(PrimitiveType.TriangleList, _vertexBuffer.ElementCount);
}
base.Draw(gameTime);
}
public override void Update(Camera camera, GameTime gameTime)
{
base.Update(camera, gameTime);
foreach (var item in Items)
item.Age += (float) gameTime.ElapsedGameTime.TotalSeconds;
Items.RemoveAll(_ => _.Age > _.TimeToLive);
}
public void Draw(GameTime gameTime)
{
foreach (var o in Children.ToList())
{
o.Draw(gameTime);
}
}
public override void Update(GameTime gameTime, int x, int y)
{
base.Update(gameTime, x, y);
if (x != X || y != Y)
throw new ArgumentException("Wrong coordinate");
Update(gameTime);
}
public void Update(Camera camera, GameTime gameTime, ref IGameState gameState)
{
_turnAround ^= _serpents.Camera.KeyboardState.IsKeyPressed(Keys.Down);
SerpentCamera.Move(gameTime);
_serpents.Update(camera, gameTime);
_serpents.UpdateScore();
//camera.UpdateFreeFlyingCamera(gameTime);
switch (_serpents.GameStatus())
{
case Serpents.Result.LevelComplete:
_delayAfterLevelComplete += (float) gameTime.ElapsedGameTime.TotalSeconds;
if (_delayAfterLevelComplete > 3)
{
_serpents.PlayerSerpent.DirectionTaker = null;
gameState = new LevelCompleteState(_serpents);
}
break;
case Serpents.Result.PlayerDied:
_serpents.PlayerSerpent.DirectionTaker = null;
gameState = new DieState(_serpents);
break;
}
}
public override void Update(GameTime gametime)
{
this.PhysicsDescription.ApplyImpulse(PhysicsSystem.toJVector(game.inputManager.SecondaryDirection() * 400f), PhysicsSystem.toJVector(Vector3.Zero));
this.PhysicsDescription.ApplyImpulse(PhysicsSystem.toJVector(game.inputManager.Acceleration() * 400f), PhysicsSystem.toJVector(Vector3.Zero));
base.Update(gametime);
}
public void Draw(GameTime gametime)
{
// Some objects such as the Enemy Controller have no model and thus will not be drawn
if (model != null)
{
// Setup the vertices
//game.GraphicsDevice.SetVertexBuffer(0, myModel.vertices, myModel.vertexStride);
//game.GraphicsDevice.SetVertexInputLayout(myModel.inputLayout);
// Apply the basic effect technique and draw the object
basicEffect.CurrentTechnique.Passes[0].Apply();
//game.GraphicsDevice.Draw(PrimitiveType.TriangleList, myModel.vertices.ElementCount);
// Draw the model
if (type != GameObjectType.Player)
model.Draw(game.GraphicsDevice, basicEffect.World, game.camera.View, game.camera.Projection);
else
model.Draw(game.GraphicsDevice, basicEffect.World, Matrix.LookAtLH(Camera.originalPos, Camera.originalTarget, Camera.originalUp),
game.camera.Projection);
}
else if (texture != null)
{
Vector2 pos2D = new Vector2(pos.X, pos.Y);
game.spriteBatch.Begin();
game.spriteBatch.Draw(texture, pos2D, Color.White);
game.spriteBatch.End();
}
}
/// <summary>
/// Draws game content.
/// </summary>
/// <param name="gameTime">Structure containing information about elapsed game time.</param>
protected override void Draw(GameTime gameTime)
{
// clear the scene to a CornflowerBlue color
GraphicsDevice.Clear(Color.CornflowerBlue);
base.Draw(gameTime);
}
public void Draw(SpriteBatch _spriteBatch, GameTime gameTime)
{
foreach (Entity e in entities)
{
e.Render(_spriteBatch);
}
}
public override void Update(Camera camera, GameTime gameTime)
{
_angle += (float) gameTime.ElapsedGameTime.TotalSeconds;
if (_angle > MathUtil.TwoPi)
_angle -= MathUtil.TwoPi;
_animatedBone.Transform = Matrix.RotationZ(_angle)*_originalBoneTransformation;
}
public override void Draw(GameTime gameTime, SpriteBatch spriteBatch, int x, int y, Rectangle destinationRect)
{
base.Draw(gameTime, spriteBatch, x, y, destinationRect);
if (x != X || y != Y)
throw new ArgumentException("Wrong coordinate");
Draw(gameTime, spriteBatch, destinationRect);
}
public virtual void Draw(GameTime gameTime, bool isInForeground, SpriteBatch spriteBatch)
{
if (State == States.Opening)
OpeningTransition.Update(gameTime);
else if (State == States.Closing)
ClosingTransition.Update(gameTime);
}
public override void Draw(GameTime gametime)
{
effect.Parameters["World"].SetValue(this.WorldMatrix);
effect.Parameters["Projection"].SetValue(game.camera.projection);
effect.Parameters["View"].SetValue(game.camera.view);
effect.Parameters["cameraPos"].SetValue(game.camera.position);
effect.Parameters["worldInvTrp"].SetValue(Matrix.Transpose(Matrix.Invert(this.WorldMatrix)));
// For Rainbow (required)
//effect.Parameters["Time"].SetValue((float)gametime.TotalGameTime.TotalSeconds);
// For Cel (both optional)
effect.Parameters["lightAmbCol"].SetValue<Color4>(Color.Lerp(Color.Red, Color.Blue, (float)Math.Abs((Math.Cos(2.0 * gametime.TotalGameTime.TotalSeconds)))));
effect.Parameters["objectCol"].SetValue<Color4>(new Color4(0.5f, 0.5f, 0.5f, 1.0f));
effect.Parameters["quant"].SetValue<float>(3.0f);
//this.model.Draw(game.GraphicsDevice, this.worldMatrix, game.camera.view, game.camera.projection, effect);
foreach (var pass in this.effect.CurrentTechnique.Passes)
{
pass.Apply();
if (this.model != null)
{
this.model.Draw(game.GraphicsDevice, WorldMatrix, game.camera.view, game.camera.projection, effect);
}
}
if (PhysicsDescription.EnableDebugDraw && PersistentStateManager.debugRender && PhysicsDescription != null)
{
PhysicsDescription.DebugDraw(game.debugDrawer);
}
}
public void Update(GameTime gameTime)
{
foreach (var o in Children.ToList())
{
o.Update(gameTime);
}
}
public override void Update(Camera camera, GameTime gameTime)
{
_shipModel.Update(camera, gameTime);
_angle += gameTime.ElapsedGameTime.TotalSeconds / 100;
_world = Matrix.Scaling(0.8f) * Matrix.RotationY(MathUtil.Pi) * Matrix.Translation(_radius, 1f, 0) * Matrix.RotationY((float)_angle);
_shipModel.World = _world;
}
public override void Update(Camera camera, GameTime gameTime)
{
if (_delayBeforeStart <= 0)
base.Update(camera, gameTime);
else
_delayBeforeStart -= (float) gameTime.ElapsedGameTime.TotalSeconds;
}
protected override void Draw(GameTime gameTime)
{
_graphicsDeviceManager.GraphicsDevice.SetRasterizerState(_rasterizerState);
_water.RenderReflection(_camera);
GraphicsDevice.SetRenderTargets(GraphicsDevice.DepthStencilBuffer, GraphicsDevice.BackBuffer);
_graphicsDeviceManager.GraphicsDevice.Clear(Color.CornflowerBlue);
_movingShip.Draw(_camera);
if(_data.Archipelag!=null)
_data.Archipelag.Draw(_camera);
if(!_data.HiddenWater)
WaterFactory.DrawWaterSurfaceGrid(_water, _camera, null, 0, _data.WaterSurfaceSize, _data.WaterSurfaceScale);
Sky.Draw(_camera);
if (_data.Archipelag != null)
{
_data.Archipelag.DrawSignsAndArchs(_camera, _data.Storage.DrawLines);
_camera.UpdateEffect(_basicEffect);
_data.Archipelag.PlayAround(_basicEffect, _ball);
}
_q.Draw(_camera);
var sb = new StringBuilder();
sb.AppendFormat("FPS: {0}", _fps.FrameRate).AppendLine();
sb.AppendFormat("Pos: {0} Look at: {1} Yaw: {2:0} Pitch: {3:0}", _camera.Position, _camera.Target, MathUtil.RadiansToDegrees(_camera.Yaw), MathUtil.RadiansToDegrees(_camera.Pitch));
_spriteBatch.Begin();
_spriteBatch.DrawString(_arial16Font, sb.ToString(), new Vector2(16, 16), Color.White);
_spriteBatch.End();
base.Draw(gameTime);
}
public override void Render(GameTime gameTime)
{
base.Render(gameTime);
Canvas.Clear(Color.FromBgra(0xFF000000 + 0x010101 * 10));
foreach (var triangle in triangulation) {
Canvas.BeginPath();
Canvas.SetLineStyle(1, Color.Cyan);
Canvas.MoveTo(triangle.Points[0].X * kScale, triangle.Points[0].Y * kScale);
Canvas.LineTo(triangle.Points[1].X * kScale, triangle.Points[1].Y * kScale);
Canvas.LineTo(triangle.Points[2].X * kScale, triangle.Points[2].Y * kScale);
Canvas.LineTo(triangle.Points[0].X * kScale, triangle.Points[0].Y * kScale);
Canvas.FillPath(Color.White);
Canvas.Stroke();
Canvas.BeginPath();
Canvas.SetLineStyle(1, Color.Red);
foreach (var neighbor in triangle.Neighbors.Where(n => n != null)) {
if (neighbor.IsInterior) {
Canvas.MoveTo(triangle.Centroid().X * kScale, triangle.Centroid().Y * kScale);
Canvas.LineTo(neighbor.Centroid().X * kScale, neighbor.Centroid().Y * kScale);
}
}
Canvas.Stroke();
}
}
protected override void Update(GameTime gameTime)
{
if (keyboardManager.GetState().IsKeyDown(Keys.Escape))
Exit();
base.Update(gameTime);
}
public override void Draw( GameTime gameTime )
{
GraphicsDevice.Clear( Color.Black );
SpriteBatch.Begin();
SpriteBatch.DrawString( font, "Loading Scene", new Vector2( 20, 20 ), Color.Red );
SpriteBatch.End();
}
public override void Update(GameTime gametime)
{
var dist_to_player = game.level.player.Position - this.Position;
if (dist_to_player.Length() < playerAvoidRadius)
{
var dir_to_player =Vector3.Normalize(dist_to_player); // avoid player
this.PhysicsDescription.ApplyImpulse(PhysicsSystem.toJVector(dir_to_player) * -0.3f);
}
// attack friendly boids
foreach (var boid in flock.Children.Where(b => ((Boid)b).boidType == Flock.BoidType.Friendly && b != this))
{
var distance = ((Boid)boid).Position - this.Position;
if (distance.Length() < attackRadius)
{
var maxImpulse = 0.006f;
// compare health percentages of prey to self
var healthRatio = (this.health / this.maxHealth) / (Math.Abs(((Boid)boid).health / ((Boid)boid).maxHealth) + 1);
var dir_to_enemy = Vector3.Normalize(distance);
var impulse = healthRatio*maxImpulse;
if (healthRatio < 1)
{
impulse *= 5; // make the boids daring if it's risky
}
this.PhysicsDescription.ApplyImpulse(PhysicsSystem.toJVector(dir_to_enemy) * (float)impulse);
}
}
base.Update(gametime);
}
protected override void Draw(GameTime gameTime)
{
// Clears the screen with the Color.CornflowerBlue
GraphicsDevice.Clear(GraphicsDevice.BackBuffer, Color.CornflowerBlue);
base.Draw(gameTime);
}
public override void QueueRenderCommands(GameTime gameTime, Renderer renderer, IGraphicsContext context)
{
List<TerrainNode> nodesToRender = new List<TerrainNode>();
renderer.EnqueueLight(dlight);
// todo: maybe can parallelize
for (int i = 0; i < rootNodes.Length; i++)
{
if (rootNodes[i] != null)
{
List<TerrainNode> nodesFromThisCubeFace = new List<TerrainNode>();
findNodesToRender(nodesFromThisCubeFace, rootNodes[i], context.CurrentCamera);
nodesToRender.AddRange(nodesFromThisCubeFace);
}
}
int nodeCount = nodesToRender.Count;
NodeCount = nodeCount;
if (nodeCount > 0)
{
TerrainVertex[] vertices = nodesToRender.SelectMany(node => node.Geometry).ToArray();
var command = GenerateRenderCommand();
(command as RenderDeferredCommand<TerrainVertex>).NumVertices = vertices.Length;
vertexBuffer.SetData(vertices);
renderer.EnqueueDeferred(command as IRenderDeferredCommand);
}
}
public override void Draw(GameTime gameTime)
{
base.Draw(gameTime);
GraphicsDevice.SetBlendState(_blend);
_basicEffect.TextureEnabled = false;
_basicEffect.VertexColorEnabled = true;
_basicEffect.World = _manTransform;
_man.Draw(_basicEffect);
_basicEffect.World = _bookshelfTransform;
_bookshelf.Draw(_basicEffect);
_basicEffect.World = _windowTransform;
_window.Draw(_basicEffect);
_basicEffect.World = _curtainTransform;
_curtain.Draw(_basicEffect);
_basicEffect.World = _curtain2Transform;
_curtain2.Draw(_basicEffect);
_basicEffect.World = _borderTransform;
_border.Draw(_basicEffect);
_basicEffect.World = _carpetTransform;
_carpet.Draw(_basicEffect);
_basicEffect.World = _pumpkinTransform;
_pumpkin.Draw(_basicEffect);
_basicEffect.World = _doorTransform1;
_door.Draw(_basicEffect);
_basicEffect.World = _doorTransform3;
_door.Draw(_basicEffect);
_basicEffect.World = _doorTransform4;
_door.Draw(_basicEffect);
_basicEffect.TextureEnabled = true;
_basicEffect.VertexColorEnabled = false;
_basicEffect.Texture = _planeTexture;
_basicEffect.World = _planeTransform;
_plane.Draw(_basicEffect);
_basicEffect.Texture = _wallTexture;
_basicEffect.World = _wallTransform1;
_wall.Draw(_basicEffect);
_basicEffect.World = _wallTransform2;
_wall.Draw(_basicEffect);
_basicEffect.World = _wallTransform3;
_wall.Draw(_basicEffect);
_basicEffect.World = _wallTransform4;
_wall.Draw(_basicEffect);
}
protected override void Draw(GameTime gameTime)
{
// Clear the color using MyData
GraphicsDevice.Clear(loadedMyData.Color);
// Handle base.Draw
base.Draw(gameTime);
}
public override void Draw(GameTime gameTime, SpriteBatch spriteBatch)
{
base.Draw(gameTime, spriteBatch);
spriteBatch.Draw(Sprites[(int)CurrentState].Sheet.Texture, DestinationRect, Sprites[(int)CurrentState].SourceRect, Color.White);
if (Text != "")
spriteBatch.DrawString(font, Text, new Vector2(DestinationRect.X, DestinationRect.Y), Color.White);
}
