/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
protected override void Update(GameTime gameTime)
{
// Allows the game to exit
if (inputHandler.KeyboardManager.KeyPress(Keys.Escape))
{
this.Exit();
}
float speedTran = .1f;
float speedRot = .01f;
if (inputHandler.KeyboardManager.KeyPress(Keys.F1))
{
renderer.DebugDeferred = !renderer.DebugDeferred;
}
if (inputHandler.KeyboardManager.KeyPress(Keys.Space))
{
renderer.DirectionalLights[0].CastShadow = !renderer.DirectionalLights[0].CastShadow;
}
if (inputHandler.KeyboardManager.KeyDown(Keys.W) || inputHandler.GamePadManager.ButtonDown(PlayerIndex.One, Buttons.DPadUp))
{
camera.Translate(Vector3.Forward * speedTran);
}
if (inputHandler.KeyboardManager.KeyDown(Keys.S) || inputHandler.GamePadManager.ButtonDown(PlayerIndex.One, Buttons.DPadDown))
{
camera.Translate(Vector3.Backward * speedTran);
}
if (inputHandler.KeyboardManager.KeyDown(Keys.A) || inputHandler.GamePadManager.ButtonDown(PlayerIndex.One, Buttons.DPadLeft))
{
camera.Translate(Vector3.Left * speedTran);
}
if (inputHandler.KeyboardManager.KeyDown(Keys.D) || inputHandler.GamePadManager.ButtonDown(PlayerIndex.One, Buttons.DPadRight))
{
camera.Translate(Vector3.Right * speedTran);
}
if (inputHandler.KeyboardManager.KeyDown(Keys.Left) || inputHandler.GamePadManager.State[PlayerIndex.One].ThumbSticks.Right.X < 0)
{
camera.Rotate(Vector3.Up, speedRot);
}
if (inputHandler.KeyboardManager.KeyDown(Keys.Right) || inputHandler.GamePadManager.State[PlayerIndex.One].ThumbSticks.Right.X > 0)
{
camera.Rotate(Vector3.Up, -speedRot);
}
if (inputHandler.KeyboardManager.KeyDown(Keys.Up) || inputHandler.GamePadManager.State[PlayerIndex.One].ThumbSticks.Right.Y > 0)
{
camera.Rotate(Vector3.Right, speedRot);
}
if (inputHandler.KeyboardManager.KeyDown(Keys.Down) || inputHandler.GamePadManager.State[PlayerIndex.One].ThumbSticks.Right.Y < 0)
{
camera.Rotate(Vector3.Right, -speedRot);
}
base.Update(gameTime);
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
protected override void Update(GameTime gameTime)
{
kbm.PreUpdate(gameTime);
base.Update(gameTime);
if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed || kbm.KeyDown(Keys.Escape))
{
Exit();
}
// Camera controls..
float speedTran = .1f;
float speedRot = .01f;
if (kbm.KeyDown(Keys.W) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Left.Y > 0)
{
camera.Translate(Vector3.Forward * speedTran);
}
if (kbm.KeyDown(Keys.S) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Left.Y < 0)
{
camera.Translate(Vector3.Backward * speedTran);
}
if (kbm.KeyDown(Keys.A) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Left.X < 0)
{
camera.Translate(Vector3.Left * speedTran);
}
if (kbm.KeyDown(Keys.D) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Left.X > 0)
{
camera.Translate(Vector3.Right * speedTran);
}
if (kbm.KeyDown(Keys.Left) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Right.X < 0)
{
camera.Rotate(Vector3.Up, speedRot);
}
if (kbm.KeyDown(Keys.Right) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Right.X > 0)
{
camera.Rotate(Vector3.Up, -speedRot);
}
if (kbm.KeyDown(Keys.Up) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Right.Y > 0)
{
camera.Rotate(Vector3.Right, speedRot);
}
if (kbm.KeyDown(Keys.Down) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Right.Y < 0)
{
camera.Rotate(Vector3.Right, -speedRot);
}
if (kbm.KeyPress(Keys.Space))
{
skySphere.ReaTime = !skySphere.ReaTime;
}
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
protected override void Update(GameTime gameTime)
{
if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed || Keyboard.GetState().IsKeyDown(Keys.Escape))
{
Exit();
}
float speedTran = .1f;
float speedRot = .01f;
KeyboardState thisKBState = Keyboard.GetState();
if (thisKBState.IsKeyDown(Keys.W) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Left.Y > 0)
{
camera.Translate(Vector3.Forward * speedTran);
}
if (thisKBState.IsKeyDown(Keys.S) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Left.Y < 0)
{
camera.Translate(Vector3.Backward * speedTran);
}
if (thisKBState.IsKeyDown(Keys.A) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Left.X < 0)
{
camera.Translate(Vector3.Left * speedTran);
}
if (thisKBState.IsKeyDown(Keys.D) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Left.X > 0)
{
camera.Translate(Vector3.Right * speedTran);
}
if (thisKBState.IsKeyDown(Keys.Left) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Right.X < 0)
{
camera.Rotate(Vector3.Up, speedRot);
}
if (thisKBState.IsKeyDown(Keys.Right) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Right.X > 0)
{
camera.Rotate(Vector3.Up, -speedRot);
}
if (thisKBState.IsKeyDown(Keys.Up) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Right.Y > 0)
{
camera.Rotate(Vector3.Right, speedRot);
}
if (thisKBState.IsKeyDown(Keys.Down) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Right.Y < 0)
{
camera.Rotate(Vector3.Right, -speedRot);
}
if (thisKBState.IsKeyDown(Keys.F1))
{
SetMap(0);
}
if (thisKBState.IsKeyDown(Keys.F2))
{
SetMap(1);
}
if (thisKBState.IsKeyDown(Keys.F3))
{
SetMap(2);
}
base.Update(gameTime);
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
protected override void Update(GameTime gameTime)
{
// Allows the game to exit
if (inputHandler.KeyboardManager.KeyPress(Keys.Escape))
{
this.Exit();
}
float x = (float)Math.Cos(gameTime.TotalGameTime.TotalSeconds) * 10;
float y = 1;// MathHelper.Clamp((float)Math.Cos(gameTime.TotalGameTime.TotalSeconds), 0, 1);
float z = (float)Math.Sin(gameTime.TotalGameTime.TotalSeconds) * 10;
Vector3 lp = tailInstancer.Position;
tailInstancer.Position = new Vector3(x, y, z - 10);
GameComponentHelper.LookAt(lp, 1, tailInstancer.Position, ref tailInstancer.Rotation, Vector3.Down);
float speedTran = .1f;
float speedRot = .01f;
if (inputHandler.KeyboardManager.KeyPress(Keys.F1))
{
renderer.DebugDeferred = !renderer.DebugDeferred;
}
if (inputHandler.KeyboardManager.KeyPress(Keys.Space))
{
renderer.DirectionalLights[0].CastShadow = !renderer.DirectionalLights[0].CastShadow;
}
if (inputHandler.KeyboardManager.KeyDown(Keys.W) || inputHandler.GamePadManager.ButtonDown(PlayerIndex.One, Buttons.DPadUp))
{
camera.Translate(Vector3.Forward * speedTran);
}
if (inputHandler.KeyboardManager.KeyDown(Keys.S) || inputHandler.GamePadManager.ButtonDown(PlayerIndex.One, Buttons.DPadDown))
{
camera.Translate(Vector3.Backward * speedTran);
}
if (inputHandler.KeyboardManager.KeyDown(Keys.A) || inputHandler.GamePadManager.ButtonDown(PlayerIndex.One, Buttons.DPadLeft))
{
camera.Translate(Vector3.Left * speedTran);
}
if (inputHandler.KeyboardManager.KeyDown(Keys.D) || inputHandler.GamePadManager.ButtonDown(PlayerIndex.One, Buttons.DPadRight))
{
camera.Translate(Vector3.Right * speedTran);
}
if (inputHandler.KeyboardManager.KeyDown(Keys.Left) || inputHandler.GamePadManager.State[PlayerIndex.One].ThumbSticks.Right.X < 0)
{
camera.Rotate(Vector3.Up, speedRot);
}
if (inputHandler.KeyboardManager.KeyDown(Keys.Right) || inputHandler.GamePadManager.State[PlayerIndex.One].ThumbSticks.Right.X > 0)
{
camera.Rotate(Vector3.Up, -speedRot);
}
if (inputHandler.KeyboardManager.KeyDown(Keys.Up) || inputHandler.GamePadManager.State[PlayerIndex.One].ThumbSticks.Right.Y > 0)
{
camera.Rotate(Vector3.Right, speedRot);
}
if (inputHandler.KeyboardManager.KeyDown(Keys.Down) || inputHandler.GamePadManager.State[PlayerIndex.One].ThumbSticks.Right.Y < 0)
{
camera.Rotate(Vector3.Right, -speedRot);
}
if (inputHandler.KeyboardManager.KeyPress(Keys.F2))
{
snowInstancer.Enabled = !snowInstancer.Enabled;
}
if (inputHandler.KeyboardManager.KeyPress(Keys.F3))
{
tailInstancer.Enabled = !tailInstancer.Enabled;
}
if (inputHandler.KeyboardManager.KeyPress(Keys.F4))
{
smokeInstancer.Enabled = !smokeInstancer.Enabled;
}
box.Rotate(Vector3.Up, .01f);
box1.Rotate(Vector3.Up + Vector3.Left, .01f);
box2.Rotate(Vector3.Left, .01f);
base.Update(gameTime);
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
protected override void Update(GameTime gameTime)
{
kbm.PreUpdate(gameTime);
base.Update(gameTime);
if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed || kbm.KeyDown(Keys.Escape))
{
Exit();
}
// Camera controls..
float speedTran = .1f;
float speedRot = .01f;
if (kbm.KeyDown(Keys.W) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Left.Y > 0)
{
camera.Translate(Vector3.Forward * speedTran);
}
if (kbm.KeyDown(Keys.S) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Left.Y < 0)
{
camera.Translate(Vector3.Backward * speedTran);
}
if (kbm.KeyDown(Keys.A) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Left.X < 0)
{
camera.Translate(Vector3.Left * speedTran);
}
if (kbm.KeyDown(Keys.D) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Left.X > 0)
{
camera.Translate(Vector3.Right * speedTran);
}
if (kbm.KeyDown(Keys.Left) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Right.X < 0)
{
camera.Rotate(Vector3.Up, speedRot);
}
if (kbm.KeyDown(Keys.Right) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Right.X > 0)
{
camera.Rotate(Vector3.Up, -speedRot);
}
if (kbm.KeyDown(Keys.Up) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Right.Y > 0)
{
camera.Rotate(Vector3.Right, speedRot);
}
if (kbm.KeyDown(Keys.Down) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Right.Y < 0)
{
camera.Rotate(Vector3.Right, -speedRot);
}
#region Light & Shade I
if (ShowLightAndShader[0])
{
// Light controls
if (kbm.KeyDown(Keys.I) || GamePad.GetState(PlayerIndex.One).DPad.Up == ButtonState.Pressed)
{
light.Position += Vector3.Forward;
}
if (kbm.KeyDown(Keys.K) || GamePad.GetState(PlayerIndex.One).DPad.Down == ButtonState.Pressed)
{
light.Position += Vector3.Backward;
}
if (kbm.KeyDown(Keys.J) || GamePad.GetState(PlayerIndex.One).DPad.Left == ButtonState.Pressed)
{
light.Position += Vector3.Left;
}
if (kbm.KeyDown(Keys.L) || GamePad.GetState(PlayerIndex.One).DPad.Right == ButtonState.Pressed)
{
light.Position += Vector3.Right;
}
if (kbm.KeyDown(Keys.U) || GamePad.GetState(PlayerIndex.One).Buttons.RightShoulder == ButtonState.Pressed)
{
light.Position += Vector3.Up;
}
if (kbm.KeyDown(Keys.O) || GamePad.GetState(PlayerIndex.One).Buttons.LeftShoulder == ButtonState.Pressed)
{
light.Position += Vector3.Down;
}
}
#endregion
#region Light & Shade II
else if (ShowLightAndShader[1])
{
if (kbm.KeyDown(Keys.I) || GamePad.GetState(PlayerIndex.One).DPad.Up == ButtonState.Pressed)
{
lights[currentLightEdit].Position += Vector3.Forward;
}
if (kbm.KeyDown(Keys.K) || GamePad.GetState(PlayerIndex.One).DPad.Down == ButtonState.Pressed)
{
lights[currentLightEdit].Position += Vector3.Backward;
}
if (kbm.KeyDown(Keys.J) || GamePad.GetState(PlayerIndex.One).DPad.Left == ButtonState.Pressed)
{
lights[currentLightEdit].Position += Vector3.Left;
}
if (kbm.KeyDown(Keys.L) || GamePad.GetState(PlayerIndex.One).DPad.Right == ButtonState.Pressed)
{
lights[currentLightEdit].Position += Vector3.Right;
}
if (kbm.KeyDown(Keys.U) || GamePad.GetState(PlayerIndex.One).Buttons.RightShoulder == ButtonState.Pressed)
{
lights[currentLightEdit].Position += Vector3.Up;
}
if (kbm.KeyDown(Keys.O) || GamePad.GetState(PlayerIndex.One).Buttons.LeftShoulder == ButtonState.Pressed)
{
lights[currentLightEdit].Position += Vector3.Down;
}
if (kbm.KeyDown(Keys.F3) || (GamePad.GetState(PlayerIndex.One).Triggers.Left > 0 && GamePad.GetState(PlayerIndex.One).Buttons.LeftStick == ButtonState.Pressed))
{
lights[currentLightEdit].LightIntensity -= .01f;
}
if (kbm.KeyDown(Keys.F4) || (GamePad.GetState(PlayerIndex.One).Triggers.Right > 0 && GamePad.GetState(PlayerIndex.One).Buttons.LeftStick == ButtonState.Pressed))
{
lights[currentLightEdit].LightIntensity += .01f;
}
if (kbm.KeyDown(Keys.F5) || (GamePad.GetState(PlayerIndex.One).Triggers.Left > 0 && GamePad.GetState(PlayerIndex.One).Buttons.LeftStick == ButtonState.Pressed))
{
lights[currentLightEdit].SpecularIntensity -= .01f;
}
if (kbm.KeyDown(Keys.F6) || (GamePad.GetState(PlayerIndex.One).Triggers.Right > 0 && GamePad.GetState(PlayerIndex.One).Buttons.LeftStick == ButtonState.Pressed))
{
lights[currentLightEdit].SpecularIntensity += .01f;
}
lights[currentLightEdit].LightIntensity = MathHelper.Clamp(lights[currentLightEdit].LightIntensity, 0, 1);
lights[currentLightEdit].SpecularIntensity = MathHelper.Clamp(lights[currentLightEdit].SpecularIntensity, 0, 1);
if (kbm.KeyDown(Keys.Space))
{
currentLightEdit++;
if (currentLightEdit > 2)
{
currentLightEdit = 0;
}
}
}
#endregion
#region Light & Shade III
else if (ShowLightAndShader[5])
{
if (kbm.KeyDown(Keys.I) || GamePad.GetState(PlayerIndex.One).DPad.Up == ButtonState.Pressed)
{
lightVIII.Position += Vector3.Forward;
}
if (kbm.KeyDown(Keys.K) || GamePad.GetState(PlayerIndex.One).DPad.Down == ButtonState.Pressed)
{
lightVIII.Position += Vector3.Backward;
}
if (kbm.KeyDown(Keys.J) || GamePad.GetState(PlayerIndex.One).DPad.Left == ButtonState.Pressed)
{
lightVIII.Position += Vector3.Left;
}
if (kbm.KeyDown(Keys.L) || GamePad.GetState(PlayerIndex.One).DPad.Right == ButtonState.Pressed)
{
lightVIII.Position += Vector3.Right;
}
if (kbm.KeyDown(Keys.U) || GamePad.GetState(PlayerIndex.One).Buttons.RightShoulder == ButtonState.Pressed)
{
lightVIII.Position += Vector3.Up;
}
if (kbm.KeyDown(Keys.O) || GamePad.GetState(PlayerIndex.One).Buttons.LeftShoulder == ButtonState.Pressed)
{
lightVIII.Position += Vector3.Down;
}
}
#endregion
if (kbm.KeyPress(Keys.D1))
{
SetLightAndShade(0);
}
if (kbm.KeyPress(Keys.D2))
{
SetLightAndShade(1);
}
if (kbm.KeyPress(Keys.D3))
{
SetLightAndShade(2);
}
if (kbm.KeyPress(Keys.D4))
{
SetLightAndShade(3);
}
if (kbm.KeyPress(Keys.D5))
{
SetLightAndShade(4);
}
if (kbm.KeyPress(Keys.D6))
{
SetLightAndShade(5);
}
// Ambient Levels
if (kbm.KeyDown(Keys.F1) || GamePad.GetState(PlayerIndex.One).Triggers.Left > 0)
{
AmbientIntensity -= .01f;
}
if (kbm.KeyDown(Keys.F2) || GamePad.GetState(PlayerIndex.One).Triggers.Right > 0)
{
AmbientIntensity += .01f;
}
AmbientIntensity = MathHelper.Clamp(AmbientIntensity, 0, 1);
skullAmbient.AmbientIntensity = AmbientIntensity;
sphereAmbient.AmbientIntensity = AmbientIntensity;
teapotAmbient.AmbientIntensity = AmbientIntensity;
skullAmbientDiffuse.AmbientIntensity = AmbientIntensity;
sphereAmbientDiffuse.AmbientIntensity = AmbientIntensity;
teapotAmbientDiffuse.AmbientIntensity = AmbientIntensity;
skullAmbientDiffuse.LightPosition = light.Position;
sphereAmbientDiffuse.LightPosition = light.Position;
teapotAmbientDiffuse.LightPosition = light.Position;
skullDiffuse.LightPosition = light.Position;
sphereDiffuse.LightPosition = light.Position;
teapotDiffuse.LightPosition = light.Position;
skullAmbient.Enabled = ShowLightAndShader[0];
sphereAmbient.Enabled = ShowLightAndShader[0];
teapotAmbient.Enabled = ShowLightAndShader[0];
skullDiffuse.Enabled = ShowLightAndShader[0];
sphereDiffuse.Enabled = ShowLightAndShader[0];
teapotDiffuse.Enabled = ShowLightAndShader[0];
skullAmbientDiffuse.Enabled = ShowLightAndShader[0];
sphereAmbientDiffuse.Enabled = ShowLightAndShader[0];
teapotAmbientDiffuse.Enabled = ShowLightAndShader[0];
light.Enabled = ShowLightAndShader[0];
skullAmbientDiffuseColorLight.AmbientColor = AmbientColor;
skullAmbientDiffuseColorLight.AmbientIntensity = AmbientIntensity;
skullAmbientDiffuseColorLight.Enabled = ShowLightAndShader[1];
sphereAmbientDiffuseColorLight.AmbientColor = AmbientColor;
sphereAmbientDiffuseColorLight.AmbientIntensity = AmbientIntensity;
sphereAmbientDiffuseColorLight.Enabled = ShowLightAndShader[1];
teapotAmbientDiffuseColorLight.AmbientColor = AmbientColor;
teapotAmbientDiffuseColorLight.AmbientIntensity = AmbientIntensity;
teapotAmbientDiffuseColorLight.Enabled = ShowLightAndShader[1];
skullAmbientDiffuseColorMultiLight.AmbientColor = AmbientColor;
skullAmbientDiffuseColorMultiLight.AmbientIntensity = AmbientIntensity;
skullAmbientDiffuseColorMultiLight.Enabled = ShowLightAndShader[1];
sphereAmbientDiffuseColorMultiLight.AmbientColor = AmbientColor;
sphereAmbientDiffuseColorMultiLight.AmbientIntensity = AmbientIntensity;
sphereAmbientDiffuseColorMultiLight.Enabled = ShowLightAndShader[1];
teapotAmbientDiffuseColorMultiLight.AmbientColor = AmbientColor;
teapotAmbientDiffuseColorMultiLight.AmbientIntensity = AmbientIntensity;
teapotAmbientDiffuseColorMultiLight.Enabled = ShowLightAndShader[1];
skullAmbientDiffuseColorBlinnPhongLight.AmbientColor = AmbientColor;
skullAmbientDiffuseColorBlinnPhongLight.AmbientIntensity = AmbientIntensity;
skullAmbientDiffuseColorBlinnPhongLight.Enabled = ShowLightAndShader[1];
sphereAmbientDiffuseColorBlinnPhongLight.AmbientColor = AmbientColor;
sphereAmbientDiffuseColorBlinnPhongLight.AmbientIntensity = AmbientIntensity;
sphereAmbientDiffuseColorBlinnPhongLight.Enabled = ShowLightAndShader[1];
teapotAmbientDiffuseColorBlinnPhongLight.AmbientColor = AmbientColor;
teapotAmbientDiffuseColorBlinnPhongLight.AmbientIntensity = AmbientIntensity;
teapotAmbientDiffuseColorBlinnPhongLight.Enabled = ShowLightAndShader[1];
for (int l = 0; l < lights.Count; l++)
{
lights[l].Enabled = ShowLightAndShader[1];
}
float modelRotSpeed = .001f;
colorPlanet.Rotate(Vector3.Down, modelRotSpeed);
colorGlowPlanet.Rotate(Vector3.Down, modelRotSpeed);
colorGlowBumpPlanet.Rotate(Vector3.Down, modelRotSpeed);
colorGlowBumpReflectPlanet.Rotate(Vector3.Down, modelRotSpeed);
earth.Rotate(Vector3.Down, modelRotSpeed);
colorPlanet.Enabled = ShowLightAndShader[2];
colorGlowPlanet.Enabled = ShowLightAndShader[2];
colorGlowBumpPlanet.Enabled = ShowLightAndShader[2];
colorGlowBumpReflectPlanet.Enabled = ShowLightAndShader[2];
lightIII.Enabled = ShowLightAndShader[2];
skyBox.Enabled = ShowLightAndShader[3] || ShowLightAndShader[4];
skullGlass.Enabled = ShowLightAndShader[3];
sphereGlass.Enabled = ShowLightAndShader[3];
teapotGlass.Enabled = ShowLightAndShader[3];
skullGlassFrez.Enabled = ShowLightAndShader[3];
sphereGlassFrez.Enabled = ShowLightAndShader[3];
teapotGlassFrez.Enabled = ShowLightAndShader[3];
skullGlassFrezFree.Enabled = ShowLightAndShader[3];
sphereGlassFrezFree.Enabled = ShowLightAndShader[3];
teapotGlassFrezFree.Enabled = ShowLightAndShader[3];
skullRefract.Enabled = ShowLightAndShader[4];
sphereRefract.Enabled = ShowLightAndShader[4];
teapotRefract.Enabled = ShowLightAndShader[4];
skullReflect.Enabled = ShowLightAndShader[4];
sphereReflect.Enabled = ShowLightAndShader[4];
teapotReflect.Enabled = ShowLightAndShader[4];
skullReflectRefract.Enabled = ShowLightAndShader[4];
sphereReflectRefract.Enabled = ShowLightAndShader[4];
teapotReflectRefract.Enabled = ShowLightAndShader[4];
skullRC3DGlass.Enabled = ShowLightAndShader[4];
sphereRC3DGlass.Enabled = ShowLightAndShader[4];
teapotRC3DGlass.Enabled = ShowLightAndShader[4];
earth.Enabled = ShowLightAndShader[5];
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
protected override void Update(GameTime gameTime)
{
kbm.PreUpdate(gameTime);
base.Update(gameTime);
if (kbm.KeyPress(Keys.Space))
{
}
if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed || kbm.KeyDown(Keys.Escape))
{
Exit();
}
// Camera controls..
float speedTran = .1f;
float speedRot = .01f;
if (kbm.KeyDown(Keys.W) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Left.Y > 0)
{
camera.Translate(Vector3.Forward * speedTran);
}
if (kbm.KeyDown(Keys.S) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Left.Y < 0)
{
camera.Translate(Vector3.Backward * speedTran);
}
if (kbm.KeyDown(Keys.A) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Left.X < 0)
{
camera.Translate(Vector3.Left * speedTran);
}
if (kbm.KeyDown(Keys.D) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Left.X > 0)
{
camera.Translate(Vector3.Right * speedTran);
}
if (kbm.KeyDown(Keys.Left) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Right.X < 0)
{
camera.Rotate(Vector3.Up, speedRot);
}
if (kbm.KeyDown(Keys.Right) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Right.X > 0)
{
camera.Rotate(Vector3.Up, -speedRot);
}
if (kbm.KeyDown(Keys.Up) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Right.Y > 0)
{
camera.Rotate(Vector3.Right, speedRot);
}
if (kbm.KeyDown(Keys.Down) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Right.Y < 0)
{
camera.Rotate(Vector3.Right, -speedRot);
}
if (kbm.KeyPress(Keys.F1))
{
Fire3D.Enabled = true;
Fire.Enabled = !Fire3D.Enabled;
Fire2.Enabled = !Fire3D.Enabled;
Fire3.Enabled = !Fire3D.Enabled;
}
if (kbm.KeyPress(Keys.F2))
{
Fire.Enabled = true;
Fire2.Enabled = !Fire.Enabled;
Fire3.Enabled = !Fire.Enabled;
Fire3D.Enabled = !Fire.Enabled;
}
if (kbm.KeyPress(Keys.F3))
{
Fire2.Enabled = true;
Fire.Enabled = !Fire2.Enabled;
Fire3.Enabled = !Fire2.Enabled;
Fire3D.Enabled = !Fire2.Enabled;
}
if (kbm.KeyPress(Keys.F4))
{
Fire3.Enabled = true;
Fire.Enabled = !Fire3.Enabled;
Fire2.Enabled = !Fire3.Enabled;
Fire3D.Enabled = !Fire3.Enabled;
}
if (Fire.Enabled || Fire2.Enabled || Fire3.Enabled)
{
if (kbm.KeyDown(Keys.R))
{
Fire.Oxygen += .001f;
Fire2.Oxygen += .001f;
Fire3.Oxygen += .001f;
}
if (kbm.KeyDown(Keys.F))
{
Fire.Oxygen -= .001f;
Fire2.Oxygen -= .001f;
Fire3.Oxygen -= .001f;
}
if (kbm.KeyDown(Keys.T))
{
Fire.MinFuel += 1;
Fire2.MinFuel += 1;
Fire3.MinFuel += 1;
}
if (kbm.KeyDown(Keys.G))
{
Fire.MinFuel -= 1;
Fire2.MinFuel -= 1;
Fire3.MinFuel -= 1;
}
if (kbm.KeyDown(Keys.Y))
{
Fire.MaxFuel += 1;
Fire2.MaxFuel += 1;
Fire3.MaxFuel += 1;
}
if (kbm.KeyDown(Keys.H))
{
Fire.MaxFuel -= 1;
Fire2.MaxFuel -= 1;
Fire3.MaxFuel -= 1;
}
if (kbm.KeyPress(Keys.Space))
{
Fire.ShowDebug = !Fire.ShowDebug;
Fire2.ShowDebug = Fire.ShowDebug;
Fire3.ShowDebug = Fire.ShowDebug;
}
}
if (Fire3D.Enabled)
{
if (kbm.KeyDown(Keys.R))
{
Fire3D.NoiseFrequency += .001f;
}
if (kbm.KeyDown(Keys.F))
{
Fire3D.NoiseFrequency -= .001f;
}
if (kbm.KeyDown(Keys.T))
{
Fire3D.NoiseStrength += .001f;
}
if (kbm.KeyDown(Keys.G))
{
Fire3D.NoiseStrength -= .001f;
}
if (kbm.KeyDown(Keys.Y))
{
Fire3D.TimeScale += .01f;
}
if (kbm.KeyDown(Keys.H))
{
Fire3D.TimeScale -= .01f;
}
if (kbm.KeyDown(Keys.U))
{
Fire3D.AnimationSpeed += .0001f;
}
if (kbm.KeyDown(Keys.J))
{
Fire3D.AnimationSpeed -= .0001f;
}
if (kbm.KeyDown(Keys.I))
{
Fire3D.Color = SetColor(Fire3D.Color.ToVector4() + new Vector4(0.01f, 0, 0, 1));
}
if (kbm.KeyDown(Keys.K))
{
Fire3D.Color = SetColor(Fire3D.Color.ToVector4() - new Vector4(0.01f, 0, 0, 1));
}
if (kbm.KeyDown(Keys.O))
{
Fire3D.Color = SetColor(Fire3D.Color.ToVector4() + new Vector4(0, 0.01f, 0, 1));
}
if (kbm.KeyDown(Keys.L))
{
Fire3D.Color = SetColor(Fire3D.Color.ToVector4() - new Vector4(0, 0.01f, 0, 1));
}
if (kbm.KeyDown(Keys.P))
{
Fire3D.Color = SetColor(Fire3D.Color.ToVector4() + new Vector4(0, 0, 0.01f, 1));
}
if (kbm.KeyDown(Keys.OemSemicolon))
{
Fire3D.Color = SetColor(Fire3D.Color.ToVector4() - new Vector4(0, 0, 0.01f, 1));
}
Fire3D.NoiseFrequency = MathHelper.Clamp(Fire3D.NoiseFrequency, 0, 1);
Fire3D.NoiseStrength = MathHelper.Clamp(Fire3D.NoiseStrength, 0, 1);
Fire3D.TimeScale = MathHelper.Clamp(Fire3D.TimeScale, 0, 2);
Fire3D.AnimationSpeed = MathHelper.Clamp(Fire3D.AnimationSpeed, 0, 1);
}
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
protected override void Update(GameTime gameTime)
{
// Allows the game to exit
if (inputHandler.KeyboardManager.KeyPress(Keys.Escape))
{
this.Exit();
}
float speedTran = .1f;
float speedRot = .01f;
if (inputHandler.KeyboardManager.KeyPress(Keys.F1))
{
renderer.DebugDeferred = !renderer.DebugDeferred;
}
if (inputHandler.KeyboardManager.KeyPress(Keys.Space))
{
renderer.DirectionalLights[0].CastShadow = !renderer.DirectionalLights[0].CastShadow;
}
if (inputHandler.KeyboardManager.KeyDown(Keys.W) || inputHandler.GamePadManager.ButtonDown(PlayerIndex.One, Buttons.DPadUp))
{
camera.Translate(Vector3.Forward * speedTran);
}
if (inputHandler.KeyboardManager.KeyDown(Keys.S) || inputHandler.GamePadManager.ButtonDown(PlayerIndex.One, Buttons.DPadDown))
{
camera.Translate(Vector3.Backward * speedTran);
}
if (inputHandler.KeyboardManager.KeyDown(Keys.A) || inputHandler.GamePadManager.ButtonDown(PlayerIndex.One, Buttons.DPadLeft))
{
camera.Translate(Vector3.Left * speedTran);
}
if (inputHandler.KeyboardManager.KeyDown(Keys.D) || inputHandler.GamePadManager.ButtonDown(PlayerIndex.One, Buttons.DPadRight))
{
camera.Translate(Vector3.Right * speedTran);
}
if (inputHandler.KeyboardManager.KeyDown(Keys.Left) || inputHandler.GamePadManager.State[PlayerIndex.One].ThumbSticks.Right.X < 0)
{
camera.Rotate(Vector3.Up, speedRot);
}
if (inputHandler.KeyboardManager.KeyDown(Keys.Right) || inputHandler.GamePadManager.State[PlayerIndex.One].ThumbSticks.Right.X > 0)
{
camera.Rotate(Vector3.Up, -speedRot);
}
if (inputHandler.KeyboardManager.KeyDown(Keys.Up) || inputHandler.GamePadManager.State[PlayerIndex.One].ThumbSticks.Right.Y > 0)
{
camera.Rotate(Vector3.Right, speedRot);
}
if (inputHandler.KeyboardManager.KeyDown(Keys.Down) || inputHandler.GamePadManager.State[PlayerIndex.One].ThumbSticks.Right.Y < 0)
{
camera.Rotate(Vector3.Right, -speedRot);
}
for (int d = 0; d < dudes.Count; d++)
{
dudes[d].TranslateOO(Vector3.Forward * .0325f);
if (dudes[d].Position.X < -10)
{
dudes[d].Position.Z = MathHelper.Lerp(-sqr, sqr, (float)rnd.NextDouble()) - 10;
dudes[d].Position.X = 10;
}
dudes[d].Update(gameTime);
}
base.Update(gameTime);
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
protected override void Update(GameTime gameTime)
{
// Allows the game to exit
if (inputHandler.KeyboardManager.KeyPress(Keys.Escape))
{
this.Exit();
}
float speedTran = .1f;
float speedRot = .01f;
if (inputHandler.KeyboardManager.KeyPress(Keys.F1))
{
renderer.DebugDeferred = !renderer.DebugDeferred;
}
if (inputHandler.KeyboardManager.KeyPress(Keys.Space))
{
renderer.DirectionalLights[0].CastShadow = !renderer.DirectionalLights[0].CastShadow;
renderer.DirectionalLights[1].CastShadow = !renderer.DirectionalLights[1].CastShadow;
}
if (inputHandler.KeyboardManager.KeyDown(Keys.T))
{
directionalIntensity += .01f;
if (directionalIntensity > 1)
{
directionalIntensity = 1;
}
renderer.DirectionalLights[0].Intensity = directionalIntensity;
}
if (inputHandler.KeyboardManager.KeyDown(Keys.G))
{
directionalIntensity -= .01f;
if (directionalIntensity < 0)
{
directionalIntensity = 0;
}
renderer.DirectionalLights[0].Intensity = directionalIntensity;
}
if (inputHandler.KeyboardManager.KeyDown(Keys.Y))
{
coneAngle += .01f;
if (coneAngle > .999f)
{
coneAngle = .999f;
}
foreach (IConeLight cone in renderer.ConeLights)
{
cone.Angle = coneAngle;
}
}
if (inputHandler.KeyboardManager.KeyDown(Keys.H))
{
coneAngle -= .01f;
if (coneAngle < .001f)
{
coneAngle = .001f;
}
foreach (IConeLight cone in renderer.ConeLights)
{
cone.Angle = coneAngle;
}
}
if (inputHandler.KeyboardManager.KeyDown(Keys.U))
{
codeDecay += .1f;
if (codeDecay > 10)
{
codeDecay = 10;
}
foreach (IConeLight cone in renderer.ConeLights)
{
cone.Decay = codeDecay;
}
}
if (inputHandler.KeyboardManager.KeyDown(Keys.J))
{
codeDecay -= .1f;
if (codeDecay < 0)
{
codeDecay = 0;
}
foreach (IConeLight cone in renderer.ConeLights)
{
cone.Decay = codeDecay;
}
}
if (inputHandler.KeyboardManager.KeyDown(Keys.W) || inputHandler.GamePadManager.ButtonDown(PlayerIndex.One, Buttons.DPadUp))
{
camera.Translate(Vector3.Forward * speedTran);
}
if (inputHandler.KeyboardManager.KeyDown(Keys.S) || inputHandler.GamePadManager.ButtonDown(PlayerIndex.One, Buttons.DPadDown))
{
camera.Translate(Vector3.Backward * speedTran);
}
if (inputHandler.KeyboardManager.KeyDown(Keys.A) || inputHandler.GamePadManager.ButtonDown(PlayerIndex.One, Buttons.DPadLeft))
{
camera.Translate(Vector3.Left * speedTran);
}
if (inputHandler.KeyboardManager.KeyDown(Keys.D) || inputHandler.GamePadManager.ButtonDown(PlayerIndex.One, Buttons.DPadRight))
{
camera.Translate(Vector3.Right * speedTran);
}
if (inputHandler.KeyboardManager.KeyDown(Keys.Left) || inputHandler.GamePadManager.State[PlayerIndex.One].ThumbSticks.Right.X < 0)
{
camera.Rotate(Vector3.Up, speedRot);
}
if (inputHandler.KeyboardManager.KeyDown(Keys.Right) || inputHandler.GamePadManager.State[PlayerIndex.One].ThumbSticks.Right.X > 0)
{
camera.Rotate(Vector3.Up, -speedRot);
}
if (inputHandler.KeyboardManager.KeyDown(Keys.Up) || inputHandler.GamePadManager.State[PlayerIndex.One].ThumbSticks.Right.Y > 0)
{
camera.Rotate(Vector3.Right, speedRot);
}
if (inputHandler.KeyboardManager.KeyDown(Keys.Down) || inputHandler.GamePadManager.State[PlayerIndex.One].ThumbSticks.Right.Y < 0)
{
camera.Rotate(Vector3.Right, -speedRot);
}
if (inputHandler.KeyboardManager.KeyPress(Keys.Q) || inputHandler.GamePadManager.ButtonPress(PlayerIndex.One, Buttons.A))
{
shots.Add(new BaseDeferredObject(this, "Models/sphere"));
shots[shots.Count - 1].TextureMaterials.Add("Textures/white");
shots[shots.Count - 1].GlowMaterials.Add("Textures/white");
shots[shots.Count - 1].Scale = Vector3.One * .125f;
shots[shots.Count - 1].color = Color.DodgerBlue;
shotVelocity.Add(shots[shots.Count - 1], camera.World.Forward * .25f);
shots[shots.Count - 1].Position = camera.Position;
shotLights.Add(shots[shots.Count - 1], new DeferredPointLight(shots[shots.Count - 1].Position, shots[shots.Count - 1].color, 10, 1, false));
renderer.PointLights.Add(shotLights[shots[shots.Count - 1]]);
Components.Add(shots[shots.Count - 1]);
}
List <BaseDeferredObject> dropShots = new List <BaseDeferredObject>();
foreach (BaseDeferredObject shot in shots)
{
if (shot.Visible)
{
shot.TranslateAA(shotVelocity[shot]);
shotLights[shot].Position = shot.Position;
if (shot.Position.Length() > 30)
{
Components.Remove(shot);
shotVelocity.Remove(shot);
renderer.PointLights.Remove(shotLights[shot]);
shotLights.Remove(shot);
dropShots.Add(shot);
}
}
}
foreach (BaseDeferredObject shot in dropShots)
{
shots.Remove(shot);
}
dropShots.Clear();
dude.TranslateOO(Vector3.Forward * .0325f);
if (dude.Position.Z < -25)
{
dude.Position = new Vector3(MathHelper.Lerp(-10, 10, (float)rnd.NextDouble()), -1, 25);
}
base.Update(gameTime);
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
protected override void Update(GameTime gameTime)
{
msm.PreUpdate(gameTime);
kbm.PreUpdate(gameTime);
base.Update(gameTime);
if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed || kbm.KeyDown(Keys.Escape))
{
Exit();
}
// Camera controls..
float speedTran = .1f;
float speedRot = .01f;
if (kbm.KeyDown(Keys.W) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Left.Y > 0)
{
camera.Translate(Vector3.Forward * speedTran);
}
if (kbm.KeyDown(Keys.S) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Left.Y < 0)
{
camera.Translate(Vector3.Backward * speedTran);
}
if (kbm.KeyDown(Keys.A) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Left.X < 0)
{
camera.Translate(Vector3.Left * speedTran);
}
if (kbm.KeyDown(Keys.D) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Left.X > 0)
{
camera.Translate(Vector3.Right * speedTran);
}
if (kbm.KeyDown(Keys.Left) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Right.X < 0)
{
camera.Rotate(Vector3.Up, speedRot);
}
if (kbm.KeyDown(Keys.Right) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Right.X > 0)
{
camera.Rotate(Vector3.Up, -speedRot);
}
if (kbm.KeyDown(Keys.Up) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Right.Y > 0)
{
camera.Rotate(Vector3.Right, speedRot);
}
if (kbm.KeyDown(Keys.Down) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Right.Y < 0)
{
camera.Rotate(Vector3.Right, -speedRot);
}
float cdv = .1f;
if (kbm.KeyDown(Keys.R))
{
cube.HatchDencity += cdv;
bunny.HatchDencity += cdv;
earth.HatchDencity += cdv;
}
if (kbm.KeyDown(Keys.F))
{
cube.HatchDencity -= cdv;
bunny.HatchDencity -= cdv;
earth.HatchDencity -= cdv;
}
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
protected override void Update(GameTime gameTime)
{
kbm.PreUpdate(gameTime);
base.Update(gameTime);
if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed || kbm.KeyDown(Keys.Escape))
{
Exit();
}
earth.Rotate(Vector3.Up, .0001f);
// Camera controls..
float speedTran = .1f;
float speedRot = .01f;
if (kbm.KeyDown(Keys.W) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Left.Y > 0)
{
camera.Translate(Vector3.Forward * speedTran);
}
if (kbm.KeyDown(Keys.S) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Left.Y < 0)
{
camera.Translate(Vector3.Backward * speedTran);
}
if (kbm.KeyDown(Keys.A) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Left.X < 0)
{
camera.Translate(Vector3.Left * speedTran);
}
if (kbm.KeyDown(Keys.D) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Left.X > 0)
{
camera.Translate(Vector3.Right * speedTran);
}
if (kbm.KeyDown(Keys.Left) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Right.X < 0)
{
camera.Rotate(Vector3.Up, speedRot);
}
if (kbm.KeyDown(Keys.Right) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Right.X > 0)
{
camera.Rotate(Vector3.Up, -speedRot);
}
if (kbm.KeyDown(Keys.Up) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Right.Y > 0)
{
camera.Rotate(Vector3.Right, speedRot);
}
if (kbm.KeyDown(Keys.Down) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Right.Y < 0)
{
camera.Rotate(Vector3.Right, -speedRot);
}
if (kbm.KeyPress(Keys.F1))
{
selectedEffect = bloom;
}
if (kbm.KeyPress(Keys.F2))
{
selectedEffect = GodRays;
}
if (kbm.KeyPress(Keys.F3))
{
selectedEffect = dof;
}
if (kbm.KeyPress(Keys.F4))
{
selectedEffect = fog;
}
if (kbm.KeyPress(Keys.F5))
{
selectedEffect = haze;
}
if (kbm.KeyPress(Keys.F6))
{
selectedEffect = radialBlur;
}
if (kbm.KeyPress(Keys.F7))
{
selectedEffect = ripple;
}
if (kbm.KeyPress(Keys.F8))
{
selectedEffect = sun;
}
if (kbm.KeyPress(Keys.F9))
{
selectedEffect = sepia;
}
if (kbm.KeyPress(Keys.F10))
{
selectedEffect = greyScale;
}
if (kbm.KeyPress(Keys.F11))
{
selectedEffect = invert;
}
if (kbm.KeyPress(Keys.F12))
{
selectedEffect = deRezed;
}
if (kbm.KeyPress(Keys.D1))
{
selectedEffect = colorFilter;
}
if (kbm.KeyPress(Keys.D2))
{
selectedEffect = bleach;
}
if (kbm.KeyPress(Keys.D3))
{
selectedEffect = scanLines;
}
if (selectedEffect != null)
{
if (kbm.KeyPress(Keys.Space))
{
selectedEffect.Enabled = !selectedEffect.Enabled;
}
if (selectedEffect == bloom)
{
if (kbm.KeyPress(Keys.G))
{
bloom.Glare = !bloom.Glare;
}
if (kbm.KeyDown(Keys.Y))
{
bloom.BloomThreshold = MathHelper.Min(bloom.BloomThreshold + .001f, 1f);
}
if (kbm.KeyDown(Keys.H))
{
bloom.BloomThreshold = MathHelper.Max(bloom.BloomThreshold - .001f, 0.0f);
}
if (kbm.KeyDown(Keys.U))
{
bloom.BlurAmount = MathHelper.Min(bloom.BlurAmount + .1f, 4);
}
if (kbm.KeyDown(Keys.J))
{
bloom.BlurAmount = MathHelper.Max(bloom.BlurAmount - .1f, 0.1f);
}
}
else if (selectedEffect == GodRays)
{
if (kbm.KeyDown(Keys.R))
{
GodRays.LightSourceSize = MathHelper.Min(GodRays.LightSourceSize + .5f, 10000);
}
if (kbm.KeyDown(Keys.F))
{
GodRays.LightSourceSize = MathHelper.Max(GodRays.LightSourceSize - .5f, .5f);
}
if (kbm.KeyDown(Keys.T))
{
GodRays.Density = MathHelper.Min(GodRays.Density + .01f, 1);
}
if (kbm.KeyDown(Keys.G))
{
GodRays.Density = MathHelper.Max(GodRays.Density - .01f, 0);
}
if (kbm.KeyDown(Keys.Y))
{
GodRays.Decay = MathHelper.Min(GodRays.Decay + .0001f, 1);
}
if (kbm.KeyDown(Keys.H))
{
GodRays.Decay = MathHelper.Max(GodRays.Decay - .0001f, 0);
}
if (kbm.KeyDown(Keys.U))
{
GodRays.Weight = MathHelper.Min(GodRays.Weight + .001f, 1);
}
if (kbm.KeyDown(Keys.J))
{
GodRays.Weight = MathHelper.Max(GodRays.Weight - .001f, 0);
}
if (kbm.KeyDown(Keys.I))
{
GodRays.Exposure = MathHelper.Min(GodRays.Exposure + .001f, 1);
}
if (kbm.KeyDown(Keys.K))
{
GodRays.Exposure = MathHelper.Max(GodRays.Exposure - .001f, 0);
}
if (kbm.KeyDown(Keys.O))
{
GodRays.BrightThreshold = MathHelper.Min(GodRays.BrightThreshold + .01f, .999f);
}
if (kbm.KeyDown(Keys.L))
{
GodRays.BrightThreshold = MathHelper.Max(GodRays.BrightThreshold - .01f, 0);
}
}
else if (selectedEffect == dof)
{
if (kbm.KeyDown(Keys.R))
{
dof.DiscRadius = MathHelper.Min(dof.DiscRadius + .1f, camera.Viewport.MaxDepth);
}
if (kbm.KeyDown(Keys.F))
{
dof.DiscRadius = MathHelper.Max(dof.DiscRadius - .1f, 0);
}
if (kbm.KeyDown(Keys.T))
{
dof.FocalDistance = MathHelper.Min(dof.FocalDistance + .1f, camera.Viewport.MaxDepth);
}
if (kbm.KeyDown(Keys.G))
{
dof.FocalDistance = MathHelper.Max(dof.FocalDistance - .1f, 0);
}
if (kbm.KeyDown(Keys.Y))
{
dof.FocalRange = MathHelper.Min(dof.FocalRange + .1f, camera.Viewport.MaxDepth);
}
if (kbm.KeyDown(Keys.H))
{
dof.FocalRange = MathHelper.Max(dof.FocalRange - .1f, 0);
}
}
else if (selectedEffect == fog)
{
if (kbm.KeyDown(Keys.R))
{
fog.FogDistance = MathHelper.Min(fog.FogDistance + .1f, camera.Viewport.MaxDepth);
}
if (kbm.KeyDown(Keys.F))
{
fog.FogDistance = MathHelper.Max(fog.FogDistance - .1f, 1);
}
if (kbm.KeyDown(Keys.T))
{
fog.FogRange = MathHelper.Min(fog.FogRange + .1f, camera.Viewport.MaxDepth);
}
if (kbm.KeyDown(Keys.G))
{
fog.FogRange = MathHelper.Max(fog.FogRange - .1f, 1);
}
if (kbm.KeyDown(Keys.Y))
{
fog.FogColor = SetColor(fog.FogColor.ToVector4() + new Vector4(.01f, 0, 0, 0));
}
if (kbm.KeyDown(Keys.H))
{
fog.FogColor = SetColor(fog.FogColor.ToVector4() - new Vector4(.01f, 0, 0, 0));
}
if (kbm.KeyDown(Keys.U))
{
fog.FogColor = SetColor(fog.FogColor.ToVector4() + new Vector4(0, .01f, 0, 0));
}
if (kbm.KeyDown(Keys.J))
{
fog.FogColor = SetColor(fog.FogColor.ToVector4() - new Vector4(0, .01f, 0, 0));
}
if (kbm.KeyDown(Keys.I))
{
fog.FogColor = SetColor(fog.FogColor.ToVector4() + new Vector4(0, 0, .01f, 0));
}
if (kbm.KeyDown(Keys.K))
{
fog.FogColor = SetColor(fog.FogColor.ToVector4() - new Vector4(0, 0, .01f, 0));
}
if (kbm.KeyDown(Keys.O))
{
fog.FogColor = SetColor(fog.FogColor.ToVector4() + new Vector4(0, 0, 0, .01f));
}
if (kbm.KeyDown(Keys.L))
{
fog.FogColor = SetColor(fog.FogColor.ToVector4() - new Vector4(0, 0, 0, .01f));
}
}
else if (selectedEffect == haze)
{
if (kbm.KeyPress(Keys.H))
{
haze.High = !haze.High;
}
}
else if (selectedEffect == radialBlur)
{
if (kbm.KeyDown(Keys.R))
{
radialBlur.Scale = MathHelper.Min(radialBlur.Scale + .001f, 1);
}
if (kbm.KeyDown(Keys.F))
{
radialBlur.Scale = MathHelper.Max(radialBlur.Scale - .001f, 0);
}
}
else if (selectedEffect == ripple)
{
if (kbm.KeyDown(Keys.T))
{
ripple.Distortion = MathHelper.Min(ripple.Distortion + .01f, 100);
}
if (kbm.KeyDown(Keys.G))
{
ripple.Distortion = MathHelper.Max(ripple.Distortion - .01f, 0);
}
if (kbm.KeyDown(Keys.Y))
{
ripple.ScreenPosition = SetVector2(ripple.ScreenPosition + new Vector2(.001f, 0));
}
if (kbm.KeyDown(Keys.H))
{
ripple.ScreenPosition = SetVector2(ripple.ScreenPosition - new Vector2(.001f, 0));
}
if (kbm.KeyDown(Keys.U))
{
ripple.ScreenPosition = SetVector2(ripple.ScreenPosition + new Vector2(0, .001f));
}
if (kbm.KeyDown(Keys.J))
{
ripple.ScreenPosition = SetVector2(ripple.ScreenPosition + new Vector2(0, .001f));
}
}
else if (selectedEffect == colorFilter)
{
if (kbm.KeyDown(Keys.R))
{
colorFilter.Bright = MathHelper.Min(colorFilter.Bright + .001f, 1);
}
if (kbm.KeyDown(Keys.F))
{
colorFilter.Bright = MathHelper.Max(colorFilter.Bright - .001f, 0);
}
if (kbm.KeyDown(Keys.T))
{
colorFilter.Saturation = MathHelper.Min(colorFilter.Saturation + .001f, 1);
}
if (kbm.KeyDown(Keys.G))
{
colorFilter.Saturation = MathHelper.Max(colorFilter.Saturation - .001f, 0);
}
if (kbm.KeyDown(Keys.Y))
{
colorFilter.Burn = MathHelper.Min(colorFilter.Burn + .001f, 1);
}
if (kbm.KeyDown(Keys.H))
{
colorFilter.Burn = MathHelper.Max(colorFilter.Burn - .001f, 0);
}
if (kbm.KeyDown(Keys.U))
{
colorFilter.Color = SetColor(colorFilter.Color.ToVector4() + new Vector4(.01f, 0, 0, 0));
}
if (kbm.KeyDown(Keys.J))
{
colorFilter.Color = SetColor(colorFilter.Color.ToVector4() - new Vector4(.01f, 0, 0, 0));
}
if (kbm.KeyDown(Keys.I))
{
colorFilter.Color = SetColor(colorFilter.Color.ToVector4() + new Vector4(0, .01f, 0, 0));
}
if (kbm.KeyDown(Keys.K))
{
colorFilter.Color = SetColor(colorFilter.Color.ToVector4() - new Vector4(0, .01f, 0, 0));
}
if (kbm.KeyDown(Keys.O))
{
colorFilter.Color = SetColor(colorFilter.Color.ToVector4() + new Vector4(0, 0, .01f, 0));
}
if (kbm.KeyDown(Keys.L))
{
colorFilter.Color = SetColor(colorFilter.Color.ToVector4() - new Vector4(0, 0, .01f, 0));
}
}
else if (selectedEffect == bleach)
{
if (kbm.KeyDown(Keys.R))
{
bleach.Opacity = MathHelper.Min(bleach.Opacity + .001f, 1);
}
if (kbm.KeyDown(Keys.F))
{
bleach.Opacity = MathHelper.Max(bleach.Opacity - .001f, 0);
}
}
else if (selectedEffect == scanLines)
{
if (kbm.KeyDown(Keys.R))
{
scanLines.NoiseIntensity = MathHelper.Min(scanLines.NoiseIntensity + .001f, 1);
}
if (kbm.KeyDown(Keys.F))
{
scanLines.NoiseIntensity = MathHelper.Max(scanLines.NoiseIntensity - .001f, 0);
}
if (kbm.KeyDown(Keys.T))
{
scanLines.LineIntensity = MathHelper.Min(scanLines.LineIntensity + .001f, 1);
}
if (kbm.KeyDown(Keys.G))
{
scanLines.LineIntensity = MathHelper.Max(scanLines.LineIntensity - .001f, 0);
}
if (kbm.KeyDown(Keys.Y))
{
scanLines.LineCount = MathHelper.Min(scanLines.LineCount + 1, 20000);
}
if (kbm.KeyDown(Keys.H))
{
scanLines.LineCount = MathHelper.Max(scanLines.LineCount - 1, 0);
}
}
else if (selectedEffect == deRezed)
{
if (kbm.KeyDown(Keys.R))
{
deRezed.NumberOfTiles = MathHelper.Min(deRezed.NumberOfTiles + 1, 1024);
}
if (kbm.KeyDown(Keys.F))
{
deRezed.NumberOfTiles = MathHelper.Max(deRezed.NumberOfTiles - 1, 1);
}
}
}
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
protected override void Update(GameTime gameTime)
{
msm.PreUpdate(gameTime);
kbm.PreUpdate(gameTime);
base.Update(gameTime);
if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed || kbm.KeyDown(Keys.Escape))
{
Exit();
}
// Camera controls..
float speedTran = .1f;
float speedRot = .01f;
if (kbm.KeyDown(Keys.W) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Left.Y > 0)
{
camera.Translate(Vector3.Forward * speedTran);
}
if (kbm.KeyDown(Keys.S) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Left.Y < 0)
{
camera.Translate(Vector3.Backward * speedTran);
}
if (kbm.KeyDown(Keys.A) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Left.X < 0)
{
camera.Translate(Vector3.Left * speedTran);
}
if (kbm.KeyDown(Keys.D) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Left.X > 0)
{
camera.Translate(Vector3.Right * speedTran);
}
if (kbm.KeyDown(Keys.Left) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Right.X < 0)
{
camera.Rotate(Vector3.Up, speedRot);
}
if (kbm.KeyDown(Keys.Right) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Right.X > 0)
{
camera.Rotate(Vector3.Up, -speedRot);
}
if (kbm.KeyDown(Keys.Up) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Right.Y > 0)
{
camera.Rotate(Vector3.Right, speedRot);
}
if (kbm.KeyDown(Keys.Down) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Right.Y < 0)
{
camera.Rotate(Vector3.Right, -speedRot);
}
// Do picking
if (msm.LeftClicked)
{
float minD = float.MaxValue;
foreach (Base3DObject obj in sceneObjects)
{
BoundingBox tbb = GameComponentHelper.TransformedBoundingBoxAA(obj.BoundingBox, obj.Position, obj.Scale);
float d = GameComponentHelper.RayPicking(msm.ScreenPoint, tbb, camera);
if (d < minD)
{
minD = d;
if (selected != null)
{
selected.DrawBoxBounds = false;
}
selected = obj;
selected.DrawBoxBounds = true;
}
}
if (minD == float.MaxValue)
{
if (selected != null)
{
selected.DrawBoxBounds = false;
}
selected = null;
}
}
}
