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); }
/// <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) { }