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;
 }