protected override bool ExampleApp_FrameStarted(FrameEvent evt)
{
if(base.ExampleApp_FrameStarted(evt) == false )
return false;
if( inputKeyboard.IsKeyDown( MOIS.KeyCode.KC_N ) )
{
pThrusters.SetDefaultDimensions( fDefDim + 0.25f, fDefDim + 0.25f );
fDefDim += 0.25f;
}
if( inputKeyboard.IsKeyDown( MOIS.KeyCode.KC_M ) )
{
pThrusters.SetDefaultDimensions( fDefDim - 0.25f, fDefDim - 0.25f );
fDefDim -= 0.25f;
}
if( inputKeyboard.IsKeyDown( MOIS.KeyCode.KC_H ) )
{
pThrusters.GetEmitter( 0 ).ParticleVelocity = fDefVel + 1;
pThrusters.GetEmitter( 1 ).ParticleVelocity = fDefVel + 1;
fDefVel += 1;
}
if( inputKeyboard.IsKeyDown( MOIS.KeyCode.KC_J ) && !( fDefVel < 0.0f ) )
{
pThrusters.GetEmitter( 0 ).ParticleVelocity = fDefVel - 1;
pThrusters.GetEmitter( 1 ).ParticleVelocity = fDefVel - 1;
fDefVel -= 1;
}
return true;
}
public override void Update(FrameEvent evt)
{
Animate(evt);
//Here goes the collision detection with the player
// (ignore until week 8) ...
base.Update(evt);
}
/// <summary>
/// We can't use constraints because otherwise we wouldn't be able to do loops.
/// </summary>
void PreSimulate(DiscreteDynamicsWorld world, FrameEvent evt)
{
// if the kart's gone, then we can get rid of this handler too
if (kart == null || kart.Vehicle.IsDisposed) {
Detach();
return;
}
// don't self-right if we're paused
else if (Pauser.IsPaused)
return;
// so first we get the kart's orientation
// then we basically get its local Y axis and average it with the global Y axis to make more of a smooth transition
Vector3 locY = kart.ActualOrientation.YAxis;
// first of all, if we're self righted enough, we can get rid of this handler
if (locY.DirectionEquals(Vector3.UNIT_Y, closeEnoughToUp)) { // 3 degrees
//Detach();
return;
}
// stop it spinning
kart.Body.AngularVelocity = Vector3.ZERO;
// update its rotation to point upwards
var quat = kart.ActualOrientation;
// make the x and z factors smaller, so that all that's left at the end is the Y pointing upwards
quat.x *= 0.92f;
quat.z *= 0.92f;
quat.Normalise();
// then update the body's transform
kart.Body.SetOrientation(quat);
}
protected override bool ExampleApp_FrameStarted(FrameEvent evt)
{
// Rotate fountains
mFountainNode.Yaw(evt.timeSinceLastFrame * 30);
// Call default
return base.ExampleApp_FrameStarted(evt);
}
bool FrameStarted(FrameEvent evt)
{
if (PhysicsMain.DrawLines) {
MogreDebugDrawer.Singleton.Build();
}
return true;
}
bool Skeletal_FrameStarted(FrameEvent evt)
{
for (int i = 0; i < NUM_ROBOTS; ++i)
{
_animState[i].AddTime(evt.timeSinceLastFrame * _animationSpeed[i]);
}
return true;
}
public virtual void Update(FrameEvent frameEvent)
{
//if (State.MainWindow.RenderWindowFocused == false) return;
State.InputManger.Capture();
Rotate(YawAngle(), PitchAngle());
Translate(GetTranslation() * frameEvent.timeSinceLastFrame);
}
public virtual void Update(FrameEvent evt)
{
// Projectile collision detection goes here
// (ignore until week 8) ...
if (!remove && time.Milliseconds > maxTime)
{
Dispose();
remove = true;
}
}
protected override bool UpdateCamera(FrameEvent evt)
{
base.UpdateCamera(evt);
Vector3 displacement = CameraNode._getDerivedPosition() - TargetNode.Position;
TargetNode.Orientation = CameraNode.Orientation;
TargetNode.Translate(displacement * _cameraTightness * evt.timeSinceLastFrame);
return true;
}
protected override bool ExampleApp_FrameStarted(FrameEvent evt)
{
if(base.ExampleApp_FrameStarted(evt) == false )
return false;
// Rotate fountains
mFountainNode.Yaw(new Degree(evt.timeSinceLastFrame * 30));
// Call default
return true;
}
protected override bool ExampleApp_FrameStarted(FrameEvent evt)
{
if(base.ExampleApp_FrameStarted(evt) == false )
return false;
foreach (AnimationState ani in this.mAnimStateList)
{
ani.AddTime(evt.timeSinceLastFrame);
}
return true;
}
public override void Update(FrameEvent frameEvent)
{
if (!State.MainWindow.IsRenderWindowFocused) return;
State.InputManger.Capture();
bool leftButtonDown = State.InputManger.MouseState.ButtonDown(MouseButtonID.MB_Left);
bool rightButtonDown = State.InputManger.MouseState.ButtonDown(MouseButtonID.MB_Right);
bool ctrl = State.InputManger.InputKeyboard.IsKeyDown(KeyCode.KC_LCONTROL);
bool shift = State.InputManger.InputKeyboard.IsKeyDown(KeyCode.KC_LSHIFT);
bool alt = State.InputManger.InputKeyboard.IsKeyDown(KeyCode.KC_LMENU);
Vector3 amount = GetTranslation()*frameEvent.timeSinceLastFrame;
if (ctrl && shift)
{
State.SelectedNode.Rotate(amount.x/5.0f, amount.z/5.0f);
State.SelectedNode.Rotate(5.0f*YawAngle(), 5.0f*PitchAngle());
//State.SelectedNode.MoveForward(amount);
}
else if (ctrl)
{
State.SelectedNode.Translate(amount);
State.SelectedNode.Translate(10.0f*new Vector3(-YawAngle().ValueRadians, 0, PitchAngle().ValueRadians));
}
else if (shift)
{
State.SelectedNode.Translate(new Vector3(amount.x, amount.z, amount.y));
State.SelectedNode.Translate(10.0f*new Vector3(-YawAngle().ValueRadians, -PitchAngle().ValueRadians, 0));
}
else if (alt)
{
State.SelectedNode.Scale = 1 + amount.z/2;
State.SelectedNode.Scale = 1 + 2*PitchAngle().ValueRadians;
}
else if (leftButtonDown)
{
Translate(amount);
Rotate(YawAngle(), PitchAngle());
}
else
{
Translate(amount);
}
//Joystick rotation
if (State.InputManger.InputJoyStick != null)
Rotate(RotateJoystickAxis(3, true), RotateJoystickAxis(2, true));
//base.Update(frameEvent);
State.MainWindow.UpdatePropertyTreeGrid();
}
/// <summary>
/// Apply a force every frame (can probably reduce this) to the player
/// </summary>
bool FrameStarted(FrameEvent evt)
{
// if someone is typing something into a text box, we don't want to move around!
if (LKernel.Get<InputSwallowerManager>().IsSwallowed())
return true;
var player = LKernel.Get<PlayerManager>().MainPlayer;
if (player != null) {
player.Actor.AddForceAtLocalPos(keyboardHandler.MovementVector * player.Kart.MoveSpeed, Vector3.ZERO);
}
return true;
}
/// <summary>
/// update all of our animations, but only if we aren't paused
/// </summary>
bool FrameStarted(FrameEvent evt)
{
if (!Pauser.IsPaused) {
foreach (AnimationBlender b in blenders) {
if (!b.Source.HasEnded)
b.AddTime(evt.timeSinceLastFrame);
}
foreach (AnimationState state in states) {
if (!state.HasEnded)
state.AddTime(evt.timeSinceLastFrame);
}
}
return true;
}
protected override bool ExampleApp_FrameStarted(FrameEvent evt)
{
// Change curvature / tiling
// Delay timer to stop too quick updates of curvature
float timeDelay = 0;
bool updateSky;
updateSky = false;
if(!base.ExampleApp_FrameStarted(evt))
return false;
if (inputKeyboard.IsKeyDown(MOIS.KeyCode.KC_H) && timeDelay <= 0)
{
mCurvature += 1;
timeDelay = 0.1f;
updateSky = true;
}
if (inputKeyboard.IsKeyDown(MOIS.KeyCode.KC_G) && timeDelay <= 0)
{
mCurvature -= 1;
timeDelay = 0.1f;
updateSky = true;
}
if (inputKeyboard.IsKeyDown(MOIS.KeyCode.KC_U) && timeDelay <= 0)
{
mTiling += 1;
timeDelay = 0.1f;
updateSky = true;
}
if (inputKeyboard.IsKeyDown(MOIS.KeyCode.KC_Y) && timeDelay <= 0)
{
mTiling -= 1;
timeDelay = 0.1f;
updateSky = true;
}
if (timeDelay > 0)
timeDelay -= evt.timeSinceLastFrame;
if (updateSky)
{
sceneMgr.SetSkyDome(true, "Examples/CloudySky", mCurvature, mTiling);
}
return true;
}
bool FrameStarted(FrameEvent evt)
{
if (elapsed >= 0.1f) {
elapsed = 0;
var mainPlayer = LKernel.GetG<PlayerManager>().MainPlayer;
if (label.Visible && LKernel.GetG<LevelManager>().IsValidLevel && mainPlayer != null && mainPlayer.Kart != null && !mainPlayer.Kart.Body.IsDisposed) {
Kart kart = mainPlayer.Kart;
Mogre.Vector3 axisA = new Mogre.Vector3(0,1,0);
Quaternion quat1;
quat1 = kart.ActualOrientation.XAxis.GetRotationTo(axisA);
label.Text = string.Format(
@"Speed: {0}
Turn angle: {1}, {2}, {3}, {4}
Linear velocity: {5}, {6}
Wheel friction: {7}, {8}
Skid info: {9}, {10}
Brake? {11}
AccelMultiplier: {12}
IntOr: {13}
Gravity: {14}
KartDriftState: {15} , WheelDriftState: {16}
Player Pos: {17} X, {18} Y, {19} Z
Quat: {20}
Quat W: {21}",
kart.VehicleSpeed,
Math.RadiansToDegrees(kart.Vehicle.GetSteeringValue(0)), Math.RadiansToDegrees(kart.Vehicle.GetSteeringValue(1)),
Math.RadiansToDegrees(kart.Vehicle.GetSteeringValue(2)), Math.RadiansToDegrees(kart.Vehicle.GetSteeringValue(3)),
kart.Body.LinearVelocity.Length, kart.Body.LinearVelocity,
kart.Vehicle.GetWheelInfo(0).FrictionSlip, kart.Vehicle.GetWheelInfo(2).FrictionSlip,
kart.Vehicle.GetWheelInfo(0).SkidInfo, kart.Vehicle.GetWheelInfo(2).SkidInfo,
kart.WheelFL.IsBrakeOn,
kart.Acceleration,
kart.InterpolatedOrientation,
kart.Body.Gravity,
kart.DriftState, kart.WheelFL.DriftState,
mainPlayer.NodePosition.x, mainPlayer.NodePosition.y, mainPlayer.NodePosition.z,
quat1,
quat1.w*180/Math.PI);
}
}
elapsed += evt.timeSinceLastFrame;
return true;
}
/// <summary>
/// After every frame, adjust the volumes appropriately
/// </summary>
bool FrameEnded(FrameEvent evt)
{
if (Pauser.IsPaused)
return true;
progress += evt.timeSinceLastFrame;
// if the progress is over the duration, or sounds don't exist, we've finished
if (progress > duration || soundToFadeOut == null || soundToFadeIn == null) {
Detach();
return true;
}
// adjust volumes relatively
float relProgress = progress / duration;
soundToFadeOut.Volume = 1f - (relProgress * initialFadeOutVolume);
soundToFadeIn.Volume = relProgress * targetFadeInVolume;
return true;
}
/// <summary>
/// Count down!
/// </summary>
private bool FrameStarted(FrameEvent evt) {
if (!Pauser.IsPaused) {
if (!three && elapsed >= INITIAL_DELAY) {
Invoke(RaceCountdownState.Three);
three = true;
elapsed = INITIAL_DELAY;
}
else if (!two && elapsed >= INITIAL_DELAY + 1) {
Invoke(RaceCountdownState.Two);
two = true;
elapsed = INITIAL_DELAY + 1;
}
else if (!one && elapsed >= INITIAL_DELAY + 2) {
Invoke(RaceCountdownState.One);
one = true;
elapsed = INITIAL_DELAY + 2;
}
else if (!go && elapsed >= INITIAL_DELAY + 3) {
#if ENABLE_COUNTDOWN
foreach (var player in LKernel.Get<PlayerManager>().Players) {
// first make sure all of the karts can't be controlled
player.IsControlEnabled = true;
}
LKernel.GetG<ItemManager>().spawning = true;
#endif
Invoke(RaceCountdownState.Go);
go = true;
elapsed = INITIAL_DELAY + 3;
}
else if (!oneSecondAfterGo && elapsed >= INITIAL_DELAY + 4) {
Invoke(RaceCountdownState.OneSecondAfterGo);
oneSecondAfterGo = true;
// don't need to keep checking the time any more
Detach();
}
elapsed += evt.timeSinceLastFrame;
}
return true;
}
/// <summary>
/// Change the width of the jet engine based on our current speed
/// </summary>
bool FrameStarted(FrameEvent evt)
{
// crop it to be between 0 and 1
float relSpeed = _vehicle.CurrentSpeedKmHour / topSpeedKmHour;
if (relSpeed < 0.5f && !idleState)
{
new SoundCrossfader(fullSound, idleSound, 1.65f, 2.0f);
idleState = true;
}
if (relSpeed > 0.5f && idleState)
{
new SoundCrossfader(idleSound, fullSound, 1.45f, 2.0f);
idleState = false;
}
return true;
}
protected override void HandleInput(FrameEvent evt)
{
base.HandleInput(evt);
// Show/Hide information
if (inputKeyboard.IsKeyDown(MOIS.KeyCode.KC_F1))
{
showInformation = !showInformation;
}
if (inputKeyboard.IsKeyDown(MOIS.KeyCode.KC_1) && !(inputKeyboard.IsKeyDown(MOIS.KeyCode.KC_LSHIFT) || inputKeyboard.IsKeyDown(MOIS.KeyCode.KC_RSHIFT)))
{
manager.TimeMultiplier = 1.0f;
}
if (inputKeyboard.IsKeyDown(MOIS.KeyCode.KC_1) && (inputKeyboard.IsKeyDown(MOIS.KeyCode.KC_LSHIFT) || inputKeyboard.IsKeyDown(MOIS.KeyCode.KC_RSHIFT)))
{
manager.TimeMultiplier = -1.0f;
}
}
/// <summary>
/// This method set the reaction to each key stroke
/// </summary>
/// <param name="evt">Can be used to tune the reaction timings</param>
/// <returns></returns>
public bool ProcessInput(FrameEvent evt)
{
Vector3 displacements = Vector3.ZERO;
Vector3 angles = Vector3.ZERO;
mKeyboard.Capture();
mMouse.Capture();
if (mKeyboard.IsKeyDown(MOIS.KeyCode.KC_A))
displacements += new Vector3(-0.1f, 0, 0);
if (mKeyboard.IsKeyDown(MOIS.KeyCode.KC_D))
displacements += new Vector3(0.1f, 0, 0);
if (mKeyboard.IsKeyDown(MOIS.KeyCode.KC_W))
displacements += new Vector3(0, 0, -0.1f);
if (mKeyboard.IsKeyDown(MOIS.KeyCode.KC_S))
displacements += new Vector3(0, 0, 0.1f);
if (mKeyboard.IsKeyDown(MOIS.KeyCode.KC_Q))
angles += .1f;
if (mKeyboard.IsKeyDown(MOIS.KeyCode.KC_E))
angles -= .1f;
//character.Move(displacements);
//character.xRotate(angles);
if (mMouse.MouseState.ButtonDown(MOIS.MouseButtonID.MB_Left))
{
angles.z = -mMouse.MouseState.X.rel;
}
if (mMouse.MouseState.ButtonDown(MOIS.MouseButtonID.MB_Right))
{
angles.x = -mMouse.MouseState.Y.rel;
}
//playerController.Rotate(angles);
return true;
}
public bool OnRenderFrame(FrameEvent evt)
{
_clipmap.MoveBy(0.0f, 0.4f);
RecalcHeight();
var angle = Mogre.Math.DegreesToRadians((DateTime.Now.Millisecond / 1000.0f + DateTime.Now.Second) * 6);
angle *= 4;
var z = 1.0f + (float)Math.Sin(angle);
if (z < _z)
z = _z;
var cam = new Vector3(0.0f, 0.0f, z);
var look = new Vector3((float)Math.Sin(angle), (float)Math.Cos(angle), 0.1f);
var up = new Vector3(0.0f, 0.0f, 1.0f);
_camera.Position = cam;
_camera.LookAt(look);
_camera.SetFixedYawAxis(true, up);
return !_window.IsClosed;
}
/// <summary>
/// It's just a linear function
/// </summary>
void PreSimulate(DiscreteDynamicsWorld world, FrameEvent evt)
{
if (kart == null || Pauser.IsPaused)
return;
progress += evt.timeSinceLastFrame;
if (progress > duration) {
// get rid of the skidder
Detach();
return;
}
float fraction = progress / duration;
// update friction
kart.ForEachWheel(w => {
w.Friction = w.DefaultFrictionSlip * fraction;
});
// limit angular velocity
Vector3 vec = new Vector3(kart.Body.AngularVelocity.x, kart.Body.AngularVelocity.y, kart.Body.AngularVelocity.z);
if (kart.Body.AngularVelocity.x > 1)
vec.x = 1;
else if (kart.Body.AngularVelocity.x < -1)
vec.x = -1;
if (kart.Body.AngularVelocity.y > 2)
vec.y = 2;
else if (kart.Body.AngularVelocity.y < -2)
vec.y = -2;
if (kart.Body.AngularVelocity.z > 1)
vec.z = 1;
else if (kart.Body.AngularVelocity.z < -1)
vec.z = -1;
kart.Body.AngularVelocity = vec;
}
protected override bool OnFrameRenderingQueued(FrameEvent evt)
{
base.OnFrameRenderingQueued(evt);
mEnvKeyboard.Capture();
Vector3 spotlightMove = Vector3.ZERO;
if (mEnvKeyboard.IsKeyDown(MOIS.KeyCode.KC_I))
spotlightMove.z -= 200;
if (mEnvKeyboard.IsKeyDown(MOIS.KeyCode.KC_K))
spotlightMove.z += 200;
if (mEnvKeyboard.IsKeyDown(MOIS.KeyCode.KC_J))
spotlightMove.x -= 200;
if (mEnvKeyboard.IsKeyDown(MOIS.KeyCode.KC_L))
spotlightMove.x += 200;
if (spotlightMove != Vector3.ZERO)
env.spotLight.Translate(spotlightMove * evt.timeSinceLastFrame);
return true;
}
public void AddKeyFrame(int frame, FrameEvent frameEvent)
{
_sequences.Add(new Sequence(frameEvent, frame, 1));
_frameCount = Math.Max(_frameCount, frame + 1);
}
bool mRoot_FrameStarted(FrameEvent evt)
{
return(true);
}
public MainMenu()
{
m_bQuit = false;
frameEvent = new FrameEvent();
}
public override bool frameEnded(FrameEvent evt)
{
Game.frameEnded(evt);
return(base.frameStarted(evt));
}
public void AddSequence(int start, int duration, FrameEvent frameEvent)
{
this._sequences.Add(new Film.Sequence(frameEvent, start, duration));
this._nextSequenceAppendTime = Math.Max(this._nextSequenceAppendTime, start + duration);
this._frameCount = Math.Max(this._frameCount, start + duration);
}
public void AppendSequence(int duration, FrameEvent frameEvent)
{
this.AddSequence(this._nextSequenceAppendTime, duration, frameEvent);
}
public void AppendKeyFrame(FrameEvent frameEvent)
{
this.AddKeyFrame(this._nextSequenceAppendTime, frameEvent);
}
/// <summary>
/// Handler zdarzenia FrameStarted: animacja
/// </summary>
/// <param name="evt"></param>
/// <returns></returns>
protected override bool FrameStarted(FrameEvent evt)
{
time += evt.timeSinceLastFrame;
// japanFlagState.AddTime(evt.timeSinceLastFrame);
/*
* p47Animation.updateTimeAll(evt.timeSinceLastFrame);
* p47Animation.animateAll();
*
*
*
* p47Animation.switchTo(PlaneAnimationManager.AnimationType.INNERTURN);
* if (p47Animation.CurrentAnimation.Ended)
* {
* p47Animation.rewindAll(true);
* p47Animation[PlaneAnimationManager.AnimationType.IDLE].Enabled = false;
* }
*/
//////////////////////////////////////////////////////////
// enemyAirscrewNode.Rotate(Vector3.NEGATIVE_UNIT_Z, evt.timeSinceLastFrame * 50.0f, Node.TransformSpace.TS_LOCAL);
float ySpeed, xSpeed;
/* if (time > 10)
* {
*
* if (p47AnimationState.AnimationName == "manual")
* {
* p47AnimationState = p47.GetAnimationState("die");
* p47AnimationState.Loop = false;
* p47AnimationState.Enabled = true;
*
* }
* p47AnimationState.AddTime(evt.timeSinceLastFrame); // animacja stanowa
* ySpeed = -2.0f; xSpeed = -2.0f;
* bladeNode.Rotate(Vector3.NEGATIVE_UNIT_Z, evt.timeSinceLastFrame * 1.0f, Node.TransformSpace.TS_LOCAL);
*
* }
*
* else*/
{
ySpeed = 0.0f;
xSpeed = -40;
bladeNode.Rotate(Vector3.NEGATIVE_UNIT_Z, evt.timeSinceLastFrame * 50.0f, Node.TransformSpace.TS_LOCAL);
}
playerNode.Translate(xSpeed * evt.timeSinceLastFrame, ySpeed * evt.timeSinceLastFrame, 0,
Node.TransformSpace.TS_LOCAL);
// a6mNode.Translate(0, ySpeed * evt.timeSinceLastFrame, xSpeed * evt.timeSinceLastFrame, Node.TransformSpace.TS_LOCAL);
carrierAerial1Node.Rotate(Vector3.NEGATIVE_UNIT_Y, evt.timeSinceLastFrame * 1.0f, Node.TransformSpace.TS_LOCAL);
/*
* Vector3 distance = gunEmplacementNode._getDerivedPosition() - playerNode._getDerivedPosition();
*
* //&& flakBarrelNode.Orientation.
* if (Mogre.Math.Abs(distance.Length) < 50 )
* {
* if (flakBarrelState == null || flakBarrelState.Enabled == false )
* {
* flakBarrelState = flakBarrel.GetAnimationState("fire");
* flakBarrelState.Loop = true;
* flakBarrelState.Enabled = true;
* }
*
* flakBarrelState.AddTime(evt.timeSinceLastFrame);
* flakBarrelNode.LookAt(playerNode.Position, Node.TransformSpace.TS_WORLD);
*
* }
* else
* {
* // if(flakBarrelState != null) flakBarrelState.Enabled = false;
* }
*/
for (int i = 0; i < soldiersState.Length; i++)
{
soldiersState[i].AddTime(evt.timeSinceLastFrame);
}
if (window.IsClosed)
{
return(false);
}
OnUpdateModel(evt);
return(!shutDown);
}
/// <summary>
/// This method is to update the character state
/// </summary>
/// <param name="evt">A frame event which can be used to tune the character update</param>
virtual public void Update(FrameEvent evt)
{
}
/// <summary>
/// Animates the model by spinning.
/// </summary>
/// <param name="evt"></param>
public override void Animate(FrameEvent evt)
{
angle += (Radian)evt.timeSinceLastFrame;
direction = radius * new Vector3(Mogre.Math.Cos(angle), 0, Mogre.Math.Sin(angle));
redGemModel.GameNode.Yaw(-evt.timeSinceLastFrame);
}
private bool FrameRenderingQueued(FrameEvent evt)
{
GameMapManager.Instance.Update(evt.timeSinceLastFrame);
TimerManager.Instance.Update();
return(true);
}
public override void Animate(FrameEvent evt)
{
gameNode.Yaw(Mogre.Math.AngleUnitsToRadians(20) * evt.timeSinceLastFrame);
// Console.Write(evt);
}
/// <summary>
/// Called at the end of a rendering frame.
/// </summary>
/// <param name="timesincelastframe"></param>
/// <param name="timesincelastevent"></param>
/// <returns></returns>
protected virtual bool FrameEnded(FrameEvent e)
{
return(true);
}
///// <summary>
// Updates time the projectile has been instantiated
///// </summary>
virtual public void Update(FrameEvent evt)
{
timeElapsed += evt.timeSinceLastFrame;
}
/// <summary>
/// This method set the reaction to each key stroke
/// </summary>
/// <param name="evt">Can be used to tune the reaction timings</param>
/// <returns></returns>
public bool ProcessInput(FrameEvent evt)
{
//Vector3 displacements = Vector3.ZERO;
Vector3 angles = Vector3.ZERO;
mKeyboard.Capture();
mMouse.Capture();
if (mKeyboard.IsKeyDown(MOIS.KeyCode.KC_A))
{
playerController.Left = true;
}
else
{
playerController.Left = false;
}
if (mKeyboard.IsKeyDown(MOIS.KeyCode.KC_D))
{
playerController.Right = true;
}
else
{
playerController.Right = false;
}
if (mKeyboard.IsKeyDown(MOIS.KeyCode.KC_W))
{
playerController.Forward = true;
}
else
{
playerController.Forward = false;
}
if (mKeyboard.IsKeyDown(MOIS.KeyCode.KC_S))
{
playerController.Backward = true;
}
else
{
playerController.Backward = false;
}
if (mKeyboard.IsKeyDown(MOIS.KeyCode.KC_SPACE))
{
playerController.Up = true;
}
else
{
playerController.Up = false;
}
//Console.WriteLine(mKeyboard.IsKeyDown(MOIS.KeyCode.KC_A));
// player.Move(displacements);
// if (mMouse.MouseState.ButtonDown(MOIS.MouseButtonID.MB_Left))
// {
angles += -mMouse.MouseState.X.rel;
playerController.Character.Model.GameNode.Yaw(angles.y * 0.005f);
//Console.WriteLine(angles.y);
// }
// if (mMouse.MouseState.ButtonDown(MOIS.MouseButtonID.MB_Right))
// {
// angles.x = -mMouse.MouseState.Y.rel;
//}
//player.Rotate(angles/10);
//playerController.Update(evt);
return(true);
}
public VideoComponent()
{
MediaPlayer.VideoFrameAvailable += (s, e) => FrameEvent.Set();
}
protected override void ModelFrameStarted(FrameEvent evt)
{
}
public void AddSequence(int start, int duration, FrameEvent frameEvent)
{
_sequences.Add(new Sequence(frameEvent, start, duration));
_nextSequenceAppendTime = Math.Max(_nextSequenceAppendTime, start + duration);
_frameCount = Math.Max(_frameCount, start + duration);
}
/// <summary>
/// This method updates the overlay
/// </summary>
/// <param name="evt">A frame event</param>
virtual public void Update(FrameEvent evt)
{
Animate(evt);
}
protected virtual void UpdateScene(FrameEvent evt)
{
}
public void AppendKeyFrame(FrameEvent frameEvent)
{
AddKeyFrame(_nextSequenceAppendTime, frameEvent);
}
public void AddKeyFrame(int frame, FrameEvent frameEvent)
{
this._sequences.Add(new Film.Sequence(frameEvent, frame, 1));
this._frameCount = Math.Max(this._frameCount, frame + 1);
}
public Sequence(FrameEvent frameEvent, int start, int duration)
{
_frameEvent = frameEvent;
_start = start;
_duration = duration;
}
public Sequence(FrameEvent frameEvent, int start, int duration)
{
this._frameEvent = frameEvent;
this._start = start;
this._duration = duration;
}
protected virtual void HandleInput(FrameEvent evt)
{
}
public override bool frameRenderingQueued(FrameEvent evt)
{
Game.frameRenderingQueued(evt);
return(base.frameStarted(evt));
}
protected virtual void HandleInput(FrameEvent evt)
{
// Move about 100 units per second,
float moveScale = camSpeed * evt.timeSinceLastFrame;
// Take about 10 seconds for full rotation
Degree rotScale = rotateSpeed * evt.timeSinceLastFrame;
Vector3 translateVector = Vector3.ZERO;
// set the scaling of camera motion
Degree scaleRotate = rotateSpeed * evt.timeSinceLastFrame;
Vector3 camVelocity = Vector3.ZERO;
inputKeyboard.Capture();
if (inputKeyboard.IsKeyDown(MOIS.KeyCode.KC_ESCAPE))
{
// stop rendering loop
shutDown = true;
}
if (inputKeyboard.IsKeyDown(MOIS.KeyCode.KC_A))
{
translateVector.x = -moveScale;
}
if (inputKeyboard.IsKeyDown(MOIS.KeyCode.KC_D))
{
translateVector.x = moveScale;
}
if (inputKeyboard.IsKeyDown(MOIS.KeyCode.KC_W))
{
translateVector.z = -moveScale;
}
if (inputKeyboard.IsKeyDown(MOIS.KeyCode.KC_S))
{
translateVector.z = moveScale;
}
if (inputKeyboard.IsKeyDown(MOIS.KeyCode.KC_LEFT))
{
camera.Yaw(scaleRotate);
}
if (inputKeyboard.IsKeyDown(MOIS.KeyCode.KC_RIGHT))
{
camera.Yaw(-scaleRotate);
}
if (inputKeyboard.IsKeyDown(MOIS.KeyCode.KC_UP))
{
camera.Pitch(scaleRotate);
}
if (inputKeyboard.IsKeyDown(MOIS.KeyCode.KC_DOWN))
{
camera.Pitch(-scaleRotate);
}
// subtract the time since last frame to delay specific key presses
toggleDelay -= evt.timeSinceLastFrame;
// toggle rendering mode
if (inputKeyboard.IsKeyDown(MOIS.KeyCode.KC_R) && toggleDelay < 0)
{
if (camera.PolygonMode == PolygonMode.PM_POINTS)
{
camera.PolygonMode = PolygonMode.PM_SOLID;
}
else if (camera.PolygonMode == PolygonMode.PM_SOLID)
{
camera.PolygonMode = PolygonMode.PM_WIREFRAME;
}
else
{
camera.PolygonMode = PolygonMode.PM_POINTS;
}
Console.WriteLine("Rendering mode changed to '{0}'.", camera.PolygonMode);
toggleDelay = 1;
}
if (inputKeyboard.IsKeyDown(MOIS.KeyCode.KC_T) && toggleDelay < 0)
{
// toggle the texture settings
switch (filtering)
{
case TextureFilterOptions.TFO_BILINEAR:
filtering = TextureFilterOptions.TFO_TRILINEAR;
aniso = 1;
break;
case TextureFilterOptions.TFO_TRILINEAR:
filtering = TextureFilterOptions.TFO_ANISOTROPIC;
aniso = 8;
break;
case TextureFilterOptions.TFO_ANISOTROPIC:
filtering = TextureFilterOptions.TFO_BILINEAR;
aniso = 1;
break;
}
Console.WriteLine("Texture Filtering changed to '{0}'.", filtering);
// set the new default
MaterialManager.Singleton.SetDefaultTextureFiltering(filtering);
MaterialManager.Singleton.DefaultAnisotropy = aniso;
toggleDelay = 1;
}
if (inputKeyboard.IsKeyDown(MOIS.KeyCode.KC_SYSRQ))
{
string[] temp = System.IO.Directory.GetFiles(Environment.CurrentDirectory, "screenshot*.jpg");
string fileName = string.Format("screenshot{0}.jpg", temp.Length + 1);
TakeScreenshot(fileName);
// show briefly on the screen
mDebugText = string.Format("Wrote screenshot '{0}'.", fileName);
// show for 2 seconds
debugTextDelay = 2.0f;
}
if (inputKeyboard.IsKeyDown(MOIS.KeyCode.KC_B))
{
sceneMgr.ShowBoundingBoxes = !sceneMgr.ShowBoundingBoxes;
}
if (inputKeyboard.IsKeyDown(MOIS.KeyCode.KC_F))
{
// hide all overlays, includes ones besides the debug overlay
viewport.OverlaysEnabled = !viewport.OverlaysEnabled;
}
inputMouse.Capture();
MOIS.MouseState_NativePtr mouseState = inputMouse.MouseState;
if (!mouseState.ButtonDown(MOIS.MouseButtonID.MB_Left))
{
Degree cameraYaw = -mouseState.X.rel * .13f;
Degree cameraPitch = -mouseState.Y.rel * .13f;
camera.Yaw(cameraYaw);
camera.Pitch(cameraPitch);
}
else
{
translateVector.x += mouseState.X.rel * 0.13f;
}
// move the camera based on the accumulated movement vector
camera.MoveRelative(translateVector);
// update performance stats once per second
if (statDelay < 0.0f && showDebugOverlay)
{
UpdateStats();
statDelay = 1.0f;
}
else
{
statDelay -= evt.timeSinceLastFrame;
}
// turn off debug text when delay ends
if (debugTextDelay < 0.0f)
{
debugTextDelay = 0.0f;
mDebugText = "";
}
else if (debugTextDelay > 0.0f)
{
debugTextDelay -= evt.timeSinceLastFrame;
}
}
protected virtual bool OnFrameRenderingQueued(FrameEvent evt)
{
if (mWindow.IsClosed)
return false;
if (mShutDown)
return false;
try {
ProcessInput();
UpdateScene(evt);
mCameraMan.UpdateCamera(evt.timeSinceLastFrame);
return true;
} catch (ShutdownException e) {
Console.WriteLine(e.Message);
mShutDown = true;
return false;
}
}
public override void Update(FrameEvent evt)
{
// Collision detection with the player goes here
// (ignore until week 8) ...
}
public bool FrameRenderingQueued(FrameEvent evt)
{
// let character update animations and camera
m_pChara.addTime(evt.timeSinceLastFrame);
return(true);
}
public bool FrameStarted(FrameEvent evt)
{
if (mWiimote1SceneNode.NumChildren() == 0)
return true;
float move = mWalkSpeed * evt.timeSinceLastFrame;
mWiimote1SceneNode.Translate(mDirection * move);
mWiimote2SceneNode.Translate(mDirection * move);
SceneNode l_CheckNode = (SceneNode)mWiimote1SceneNode.GetChild(0);
if ((l_CheckNode.Orientation.Pitch.ValueDegrees >= (InitialShoePitchAngle + MaxRotation) && ShoeRotationAngle > 0) ||
(l_CheckNode.Orientation.Pitch.ValueDegrees < (InitialShoePitchAngle - MaxRotation) && ShoeRotationAngle < 0))
{
ShoeRotationAngle = ShoeRotationAngle * -1;
}
// Console.Out.WriteLine("Initial Angle = " + InitialShoeRollAngle + " : Orientation = " + l_CheckNode.Orientation.Roll.ValueDegrees + " mShoeRotationAngle = " + ShoeRotationAngle);
Console.Out.WriteLine("Roll = " + l_CheckNode.Orientation.Roll.ValueDegrees + " : Pitch = " + l_CheckNode.Orientation.Pitch.ValueDegrees + " : Yaw = " + l_CheckNode.Orientation.Yaw.ValueDegrees + " : ShoeRotationAngle = " + ShoeRotationAngle);
Mogre.Degree l_DegreeAngle = new Mogre.Degree(5);
Node.ChildNodeIterator l_Iterator1 = mWiimote1SceneNode.GetChildIterator();
foreach (SceneNode l_Node in l_Iterator1)
{
// l_Node.Pitch(l_DegreeAngle.ValueRadians, Node.TransformSpace.TS_PARENT);
l_Node.Pitch(l_DegreeAngle.ValueRadians);
}
Node.ChildNodeIterator l_Iterator2 = mWiimote2SceneNode.GetChildIterator();
foreach (SceneNode l_Node in l_Iterator2)
{
// l_Node.Pitch(l_DegreeAngle.ValueRadians, Node.TransformSpace.TS_PARENT);
l_Node.Pitch(l_DegreeAngle.ValueRadians);
}
Mogre.Degree l_VideoAngle = new Mogre.Degree(Angle360Rotation);
if (mCubeSceneNode != null)
mCubeSceneNode.Yaw(l_VideoAngle.ValueRadians);
return true;
}
public void Animate(FrameEvent evt)
{
CircularMotion(evt);
AnimateMesh(evt);
}
bool ExampleApp_FrameStarted(FrameEvent evt)
{
if (window.IsClosed)
return false;
HandleInput(evt);
return !shutDown;
}
public override void Animate(FrameEvent evt)
{
blueGemElement.GameNode.Yaw(Mogre.Math.AngleUnitsToRadians(30) * evt.timeSinceLastFrame);
}
protected virtual void UpdateScene(FrameEvent evt)
{
}
/// <summary>
/// This method animates overlay elements
/// </summary>
/// <param name="evt">A frame event which can be used to tune the animation timing</param>
virtual protected void Animate(FrameEvent evt)
{
}
