void Run(CollisionMethodArgs args)
{
PhysicsScene scene = demo.Engine.Factory.PhysicsSceneManager.Get(args.OwnerSceneIndex);
PhysicsObject objectBase = scene.Factory.PhysicsObjectManager.Get(args.OwnerIndex);
float time = args.Time;
if ((constraint1 == null) || (panel == null) || constraint1.IsBroken || panel.IsBrokenRigidGroup)
{
return;
}
PhysicsObject physicsObjectWithActiveCamera = scene.GetPhysicsObjectWithActiveCamera(0);
if ((physicsObjectWithActiveCamera == null) || !physicsObjectWithActiveCamera.RigidGroupOwner.IsColliding(objectBase))
{
return;
}
if (!enableRun)
{
enableRun = true;
if ((constraint2 != null) && (constraint2.ControlDegAngleY >= 180.0f))
{
flipRotation = true;
}
else
{
flipRotation = false;
}
}
}
void Run(CollisionMethodArgs args)
{
PhysicsScene scene = demo.Engine.Factory.PhysicsSceneManager.Get(args.OwnerSceneIndex);
PhysicsObject objectBase = scene.Factory.PhysicsObjectManager.Get(args.OwnerIndex);
float time = args.Time;
if ((cabinFrontButtonConstraint == null) || (body == null) || cabinFrontButtonConstraint.IsBroken || body.IsBrokenRigidGroup)
{
return;
}
PhysicsObject physicsObjectWithActiveCamera = scene.GetPhysicsObjectWithActiveCamera(0);
if ((physicsObjectWithActiveCamera == null) || !physicsObjectWithActiveCamera.RigidGroupOwner.IsColliding(objectBase))
{
return;
}
if (!enableFly)
{
enableFly = true;
cabinFrontButtonConstraint.ControlDistanceX = 0.4f;
}
}
public void DrawLine(DrawMethodArgs args)
{
PhysicsScene scene = demo.Engine.Factory.PhysicsSceneManager.Get(args.OwnerSceneIndex);
PhysicsObject objectBase = scene.Factory.PhysicsObjectManager.Get(args.OwnerIndex);
if (!objectBase.EnableDrawing)
{
return;
}
PhysicsObject physicsObjectWithActiveCamera = scene.GetPhysicsObjectWithActiveCamera(0);
if (physicsObjectWithActiveCamera == null)
{
return;
}
PhysicsCamera activeCamera = physicsObjectWithActiveCamera.Camera;
if (activeCamera == null)
{
return;
}
GL.Disable(EnableCap.DepthTest);
GL.DepthMask(false);
float time = args.Time;
CursorController cursorController = physicsObjectWithActiveCamera.InternalControllers.CursorController;
if ((cursorController != null) && cursorController.IsDragging)
{
activeCamera.View.GetViewMatrix(ref view);
activeCamera.Projection.GetProjectionMatrix(ref projection);
world = matrixIdentity;
cursorController.GetAnchor1(ref startPosition);
cursorController.GetAnchor2(ref endPosition);
render.SetWorld(ref world);
render.SetView(ref view);
render.SetProjection(ref projection);
render.Apply();
GL.Begin(PrimitiveType.Lines);
GL.Color3(0.0f, 1.0f, 0.6f);
GL.Vertex3(startPosition);
GL.Color3(1.0f, 1.0f, 1.0f);
GL.Vertex3(endPosition);
GL.End();
}
GL.DepthMask(true);
GL.Enable(EnableCap.DepthTest);
}
public void Draw(DrawMethodArgs args)
{
PhysicsScene scene = demo.Engine.Factory.PhysicsSceneManager.Get(args.OwnerSceneIndex);
PhysicsObject objectBase = scene.Factory.PhysicsObjectManager.Get(args.OwnerIndex);
if (!objectBase.EnableDrawing)
{
return;
}
PhysicsObject physicsObjectWithActiveCamera = scene.GetPhysicsObjectWithActiveCamera(0);
if (physicsObjectWithActiveCamera == null)
{
return;
}
PhysicsCamera activeCamera = physicsObjectWithActiveCamera.Camera;
if (activeCamera == null)
{
return;
}
float time = args.Time;
activeCamera.GetTransposeRotation(ref world);
Vector3.TransformVector(ref demo.CursorLightDirection, ref world, out localLightDirection);
activeCamera.View.GetViewMatrix(ref view);
activeCamera.Projection.GetProjectionMatrix(ref projection);
objectBase.MainWorldTransform.GetTransformMatrix(ref world);
if (objectBase.UserDataStr != null)
{
GL.Disable(EnableCap.DepthTest);
GL.DepthMask(false);
DemoMesh mesh = demo.Meshes[objectBase.UserDataStr];
PhysicsLight sceneLight = scene.Light;
sceneLight.GetDirection(ref lightDirection);
sceneLight.SetDirection(ref localLightDirection);
mesh.Draw(ref world, ref view, ref projection, sceneLight, objectBase.Material, activeCamera, false, demo.EnableWireframe);
sceneLight.SetDirection(ref lightDirection);
GL.DepthMask(true);
GL.Enable(EnableCap.DepthTest);
}
}
void Draw(DrawMethodArgs args)
{
PhysicsScene scene = demo.Engine.Factory.PhysicsSceneManager.Get(args.OwnerSceneIndex);
PhysicsObject objectBase = scene.Factory.PhysicsObjectManager.Get(args.OwnerIndex);
PhysicsObject physicsObjectWithActiveCamera = scene.GetPhysicsObjectWithActiveCamera(0);
if (physicsObjectWithActiveCamera == null)
{
return;
}
PhysicsCamera activeCamera = physicsObjectWithActiveCamera.Camera;
if (activeCamera == null)
{
return;
}
DemoMesh mesh = demo.Meshes[objectBase.UserDataStr];
if ((mesh == null) || (mesh.Vertices == null))
{
return;
}
if (mesh.Dynamic && objectBase.Shape.ShapePrimitive.DynamicUpdate)
{
objectBase.Shape.GetMeshVertices(1.0f, 1.0f, false, true, mesh.Vertices);
mesh.SetVertices(mesh.Vertices);
}
float time = args.Time;
objectBase.MainWorldTransform.GetTransformMatrix(ref world);
activeCamera.View.GetViewMatrix(ref view);
activeCamera.Projection.GetProjectionMatrix(ref projection);
PhysicsLight sceneLight = scene.Light;
if (objectBase.Shape.ShapePrimitive.DynamicUpdateState)
{
mesh.Draw(ref world, ref view, ref projection, sceneLight, objectBase.Material, activeCamera, false, demo.EnableWireframe);
}
else
{
mesh = demo.Meshes[lakeInstanceName];
mesh.Draw(ref world, ref view, ref projection, sceneLight, objectBase.Material, activeCamera, false, demo.EnableWireframe);
}
}
public void DrawSky(DrawMethodArgs args)
{
PhysicsScene scene = demo.Engine.Factory.PhysicsSceneManager.Get(args.OwnerSceneIndex);
PhysicsObject objectBase = scene.Factory.PhysicsObjectManager.Get(args.OwnerIndex);
DemoKeyboardState keyboardState = demo.GetKeyboardState();
if (keyboardState[Key.J])
{
scene.Light.RotationDegAngleX += 0.5f;
render.SunRotationDegAngleX = scene.Light.RotationDegAngleX;
render.UpdateSunParameters();
}
if (keyboardState[Key.K])
{
scene.Light.RotationDegAngleX -= 0.5f;
render.SunRotationDegAngleX = scene.Light.RotationDegAngleX;
render.UpdateSunParameters();
}
curTime = DateTime.Now.Hour * 60 + DateTime.Now.Minute;
if (curTime != oldTime)
{
oldTime = curTime;
// Sun position update based on the current time
//scene.Light.RotationDegAngleX = curTime * 0.25f - 90.0f;
//render.SunRotationDegAngleX = scene.Light.RotationDegAngleX;
//render.UpdateSunParameters();
}
render.GetLightDirection(ref direction);
render.GetSunColor(ref diffuse);
Vector3.Multiply(ref diffuse, 0.5f, out diffuse);
Vector3.Multiply(ref diffuse, 0.4f, out specular);
scene.Light.SetDirection(ref direction);
scene.Light.SetDiffuse(ref diffuse);
scene.Light.SetSpecular(ref specular);
PhysicsObject physicsObjectWithActiveCamera = scene.GetPhysicsObjectWithActiveCamera(0);
if (physicsObjectWithActiveCamera == null)
{
return;
}
PhysicsCamera activeCamera = physicsObjectWithActiveCamera.Camera;
if (activeCamera == null)
{
return;
}
if (demo.EnableWireframe)
{
return;
}
float time = args.Time;
activeCamera.View.GetViewMatrix(ref view);
activeCamera.Projection.GetProjectionMatrix(ref projection);
if (objectBase.UserDataStr != null)
{
DemoMesh mesh = demo.Meshes[objectBase.UserDataStr];
targets[0] = DrawBuffersEnum.ColorAttachment0;
targets[1] = DrawBuffersEnum.None;
targets[2] = DrawBuffersEnum.None;
targets[3] = DrawBuffersEnum.None;
GL.DrawBuffers(4, targets);
GL.CullFace(mesh.CullMode);
GL.Disable(EnableCap.Texture2D);
GL.DepthMask(false);
physicsObjectWithActiveCamera.MainWorldTransform.GetPosition(ref position);
Matrix4.CreateTranslation(ref position, out translation);
objectBase.MainWorldTransform.GetTransformMatrix(ref transform);
Matrix4.Mult(ref transform, ref translation, out world);
//Matrix4.Mult(ref world, ref view, out transform);
//Matrix4.Mult(ref transform, ref projection, out world);
//render.SetWorldViewProjection(ref world);
//render.Texture = mesh.DemoTexture.Handle;
render.SetWorld(ref world);
render.SetView(ref view);
render.SetProjection(ref projection);
mesh.Draw(render);
GL.DepthMask(true);
GL.Enable(EnableCap.Texture2D);
targets[0] = DrawBuffersEnum.ColorAttachment0;
targets[1] = DrawBuffersEnum.ColorAttachment1;
targets[2] = DrawBuffersEnum.ColorAttachment2;
targets[3] = DrawBuffersEnum.ColorAttachment3;
GL.DrawBuffers(4, targets);
}
}
void Move(SimulateMethodArgs args)
{
PhysicsScene scene = demo.Engine.Factory.PhysicsSceneManager.Get(args.OwnerSceneIndex);
PhysicsObject objectBase = scene.Factory.PhysicsObjectManager.Get(args.OwnerIndex);
float time = args.Time;
PhysicsObject physicsObjectWithActiveCamera = scene.GetPhysicsObjectWithActiveCamera(0);
if (physicsObjectWithActiveCamera == null)
{
return;
}
PhysicsObject cameraBody = physicsObjectWithActiveCamera.RigidGroupOwner.FindChildPhysicsObject(cameraBodyName, true, true);
PhysicsObject cameraDown = physicsObjectWithActiveCamera.RigidGroupOwner.FindChildPhysicsObject(cameraDownName, true, true);
if ((bodyBox0 == null) || (engineSwitch == null) || (cameraBody == null) || (cameraDown == null))
{
return;
}
Constraint CameraConstraint = objectBase.Scene.Factory.ConstraintManager.Find(cameraConstraintName);
bool rotorWorking = true;
if (constraint2 != null)
{
if (constraint2.PhysicsObject1 != null)
{
if (constraint2.PhysicsObject1.IsBrokenRigidGroup || constraint2.IsBroken)
{
rotorWorking = false;
}
}
if (constraint2.PhysicsObject2 != null)
{
if (constraint2.PhysicsObject2.IsBrokenRigidGroup || constraint2.IsBroken)
{
rotorWorking = false;
}
}
}
else
{
rotorWorking = false;
}
if (objectBase.IsBrokenRigidGroup || !rotorWorking)
{
if (constraint1 != null)
{
constraint1.EnableControlAngleY = false;
}
if ((CameraConstraint != null) && (CameraConstraint.PhysicsObject1 == cameraDown))
{
objectBase.Scene.Factory.ConstraintManager.Remove(CameraConstraint);
physicsObjectWithActiveCamera.Camera.EnableControl = false;
cameraDown.RigidGroupOwner.MaxPreUpdateAngularVelocity = 0.0f;
cameraDown.RigidGroupOwner.MaxPostUpdateAngularVelocity = 0.0f;
Vector3 euler = vectorZero;
Vector3 cameraEuler = vectorZero;
Vector3 objectEuler = vectorZero;
physicsObjectWithActiveCamera.Camera.GetEuler(ref cameraEuler);
physicsObjectWithActiveCamera.MainWorldTransform.GetTransposeRotation(ref objectRotation);
physicsObjectWithActiveCamera.InitLocalTransform.GetRotation(ref objectInitRotation);
Matrix4.Mult(ref objectRotation, ref objectInitRotation, out rotation);
physicsObjectWithActiveCamera.Camera.SetEuler(ref rotation);
physicsObjectWithActiveCamera.Camera.GetEuler(ref objectEuler);
Vector3.Add(ref objectEuler, ref cameraEuler, out euler);
Matrix4 rotationX, rotationY;
Matrix4.CreateRotationX(-euler.X, out rotationX);
Matrix4.CreateRotationY(-euler.Y, out rotationY);
Matrix4.Mult(ref rotationY, ref rotationX, out rotation);
physicsObjectWithActiveCamera.Camera.SetEuler(ref euler);
physicsObjectWithActiveCamera.Camera.SetRotation(ref rotation);
Matrix4.CreateRotationY(euler.Y, out rotation);
physicsObjectWithActiveCamera.RigidGroupOwner.MainWorldTransform.SetRotation(ref rotation);
physicsObjectWithActiveCamera.RigidGroupOwner.RecalculateMainTransform();
}
return;
}
DemoKeyboardState keyboardState = demo.GetKeyboardState();
if (physicsObjectWithActiveCamera.Camera.EnableControl && (CameraConstraint != null) && (CameraConstraint.PhysicsObject1 == cameraDown))
{
if (keyboardState[Key.Space] && !oldKeyboardState[Key.Space])
{
if (constraint1 != null)
{
constraint1.EnableControlAngleY = false;
}
objectBase.Scene.Factory.ConstraintManager.Remove(CameraConstraint);
physicsObjectWithActiveCamera.Camera.EnableControl = false;
cameraDown.RigidGroupOwner.MaxPreUpdateAngularVelocity = 0.0f;
cameraDown.RigidGroupOwner.MaxPostUpdateAngularVelocity = 0.0f;
Vector3 euler = vectorZero;
Vector3 cameraEuler = vectorZero;
Vector3 objectEuler = vectorZero;
physicsObjectWithActiveCamera.Camera.GetEuler(ref cameraEuler);
physicsObjectWithActiveCamera.MainWorldTransform.GetTransposeRotation(ref objectRotation);
physicsObjectWithActiveCamera.InitLocalTransform.GetRotation(ref objectInitRotation);
Matrix4.Mult(ref objectRotation, ref objectInitRotation, out rotation);
physicsObjectWithActiveCamera.Camera.SetEuler(ref rotation);
physicsObjectWithActiveCamera.Camera.GetEuler(ref objectEuler);
Vector3.Add(ref objectEuler, ref cameraEuler, out euler);
euler.Z = 0.0f;
Matrix4 rotationX, rotationY;
Matrix4.CreateRotationX(-euler.X, out rotationX);
Matrix4.CreateRotationY(-euler.Y, out rotationY);
Matrix4.Mult(ref rotationY, ref rotationX, out rotation);
physicsObjectWithActiveCamera.Camera.SetEuler(ref euler);
physicsObjectWithActiveCamera.Camera.SetRotation(ref rotation);
Matrix4.CreateRotationY(euler.Y, out rotation);
physicsObjectWithActiveCamera.RigidGroupOwner.MainWorldTransform.SetRotation(ref rotation);
physicsObjectWithActiveCamera.RigidGroupOwner.RecalculateMainTransform();
oldKeyboardState = keyboardState;
return;
}
if (keyboardState[Key.W])
{
if ((engine != null) && (engineRotor != null))
{
Vector3.Multiply(ref unitZ, -10.0f, out velocity);
engineRotor.MainWorldTransform.SetLocalAngularVelocity(ref velocity);
if (engineRotor.IsUnderFluidSurface)
{
Vector3.Multiply(ref unitZ, 5.0f, out velocity);
engine.MainWorldTransform.AddLocalLinearVelocity(ref velocity);
}
}
}
if (keyboardState[Key.S])
{
if ((engine != null) && (engineRotor != null))
{
Vector3.Multiply(ref unitZ, 10.0f, out velocity);
engineRotor.MainWorldTransform.SetLocalAngularVelocity(ref velocity);
if (engineRotor.IsUnderFluidSurface)
{
Vector3.Multiply(ref unitZ, -5.0f, out velocity);
engine.MainWorldTransform.AddLocalLinearVelocity(ref velocity);
}
}
}
if (keyboardState[Key.D])
{
if (constraint1 != null)
{
constraint1.ControlDegAngleY += 0.5f;
}
}
if (keyboardState[Key.A])
{
if (constraint1 != null)
{
constraint1.ControlDegAngleY -= 0.5f;
}
}
}
else
{
if (constraint1 != null)
{
constraint1.EnableControlAngleY = false;
}
if (engineSwitch.IsColliding(cameraBody))
{
if (keyboardState[Key.Space] && !oldKeyboardState[Key.Space])
{
physicsObjectWithActiveCamera.Camera.EnableControl = true;
if (constraint1 != null)
{
constraint1.EnableControlAngleY = true;
}
constraint1.ControlDegAngleY = 0.0f;
cameraDown.RigidGroupOwner.MaxPreUpdateAngularVelocity = 1000.0f;
cameraDown.RigidGroupOwner.MaxPostUpdateAngularVelocity = 1000.0f;
Quaternion cameraOrientationX = quaternionIdentity;
Quaternion cameraOrientationY = quaternionIdentity;
Quaternion cameraOrientationZ = quaternionIdentity;
Quaternion cameraOrientationXY = quaternionIdentity;
Quaternion cameraOrientation = quaternionIdentity;
Quaternion.Multiply(ref cameraOrientationX, ref cameraOrientationY, out cameraOrientationXY);
Quaternion.Multiply(ref cameraOrientationXY, ref cameraOrientationZ, out cameraOrientation);
rotation = Matrix4.CreateFromQuaternion(cameraOrientation);
physicsObjectWithActiveCamera.Camera.SetOrientation(ref cameraOrientation);
physicsObjectWithActiveCamera.Camera.SetRotation(ref rotation);
physicsObjectWithActiveCamera.Camera.SetEuler(ref rotation);
objectOrientation = quaternionIdentity;
objectRotation = Matrix4.CreateFromQuaternion(objectOrientation);
Vector3 boatDeckPosition = vectorZero;
Matrix4 boatDeckRotation = matrixIdentity;
bodyBox0.MainWorldTransform.GetPosition(ref boatDeckPosition);
bodyBox0.MainWorldTransform.GetRotation(ref boatDeckRotation);
Matrix4.Mult(ref objectRotation, ref boatDeckRotation, out rotation);
Vector3.TransformVector(ref driverLocalPosition, ref boatDeckRotation, out position);
Vector3.Add(ref boatDeckPosition, ref position, out position);
physicsObjectWithActiveCamera.RigidGroupOwner.MainWorldTransform.SetRotation(ref rotation);
physicsObjectWithActiveCamera.RigidGroupOwner.MainWorldTransform.SetPosition(ref position);
physicsObjectWithActiveCamera.RigidGroupOwner.RecalculateMainTransform();
if (CameraConstraint == null)
{
CameraConstraint = scene.Factory.ConstraintManager.Create(cameraConstraintName);
CameraConstraint.PhysicsObject1 = cameraDown;
CameraConstraint.PhysicsObject2 = bodyBox0;
CameraConstraint.PhysicsObject1.MainWorldTransform.GetPosition(ref position1);
CameraConstraint.PhysicsObject1.MainWorldTransform.GetOrientation(ref orientation1);
CameraConstraint.PhysicsObject2.MainWorldTransform.GetOrientation(ref orientation2);
boatDeckPosition.X = boatDeckPosition.Z = 0.0f;
boatDeckPosition.Y = 2.0f;
Vector3.Subtract(ref position1, ref boatDeckPosition, out position1);
CameraConstraint.SetAnchor1(ref position1);
CameraConstraint.SetAnchor2(ref position1);
CameraConstraint.SetInitWorldOrientation1(ref orientation1);
CameraConstraint.SetInitWorldOrientation2(ref orientation2);
CameraConstraint.EnableLimitAngleX = true;
CameraConstraint.EnableLimitAngleY = true;
CameraConstraint.EnableLimitAngleZ = true;
CameraConstraint.LimitAngleForce = 0.6f;
CameraConstraint.Update();
}
}
}
if (enableExternalMoving)
{
if (keyboardState[Key.Up])
{
if (constraint1 != null)
{
constraint1.EnableControlAngleY = true;
}
if ((engine != null) && (engineRotor != null))
{
Vector3.Multiply(ref unitZ, -10.0f, out velocity);
engineRotor.MainWorldTransform.SetLocalAngularVelocity(ref velocity);
if (engineRotor.IsUnderFluidSurface)
{
Vector3.Multiply(ref unitZ, 5.0f, out velocity);
engine.MainWorldTransform.AddLocalLinearVelocity(ref velocity);
}
}
}
if (keyboardState[Key.Down])
{
if (constraint1 != null)
{
constraint1.EnableControlAngleY = true;
}
if ((engine != null) && (engineRotor != null))
{
Vector3.Multiply(ref unitZ, 10.0f, out velocity);
engineRotor.MainWorldTransform.SetLocalAngularVelocity(ref velocity);
if (engineRotor.IsUnderFluidSurface)
{
Vector3.Multiply(ref unitZ, -5.0f, out velocity);
engine.MainWorldTransform.AddLocalLinearVelocity(ref velocity);
}
}
}
if (keyboardState[Key.Right])
{
if (constraint1 != null)
{
constraint1.EnableControlAngleY = true;
}
if (constraint1 != null)
{
constraint1.ControlDegAngleY += 0.5f;
}
}
if (keyboardState[Key.Left])
{
if (constraint1 != null)
{
constraint1.EnableControlAngleY = true;
}
if (constraint1 != null)
{
constraint1.ControlDegAngleY -= 0.5f;
}
}
}
}
oldKeyboardState = keyboardState;
}
void SwitchLeft(SimulateMethodArgs args)
{
PhysicsScene scene = demo.Engine.Factory.PhysicsSceneManager.Get(args.OwnerSceneIndex);
PhysicsObject objectBase = scene.Factory.PhysicsObjectManager.Get(args.OwnerIndex);
float time = args.Time;
if (leftDoorConstraint.IsBroken || leftDoorConstraint.PhysicsObject1.IsBrokenRigidGroup || leftDoorConstraint.PhysicsObject2.IsBrokenRigidGroup)
{
leftDoorConstraint.EnableControlAngleY = false;
cabinBodyLeft1.DisableCollision(leftDoorRight, false);
cabinBodyLeft2.DisableCollision(leftDoorUp, false);
cabinBodyLeft2.DisableCollision(leftDoorDown, false);
cabinBodyLeft2.DisableCollision(leftDoorLeft, false);
cabinBodyUp1.DisableCollision(leftDoorUp, false);
cabinBodyUp2.DisableCollision(leftDoorUp, false);
cabinBodyUp2.DisableCollision(leftDoorRight, false);
cabinBodyFrontLeft.DisableCollision(leftDoorUp, false);
cabinBodyFrontLeft.DisableCollision(leftDoorRight, false);
cabinBodyFrontLeft.DisableCollision(leftDoorDown, false);
cabinBodyDown1.DisableCollision(leftDoorDown, false);
cabinBodyDown2.DisableCollision(leftDoorDown, false);
return;
}
PhysicsObject cameraBody = scene.GetPhysicsObjectWithActiveCamera(0).RigidGroupOwner.FindChildPhysicsObject(cameraBodyName, true, true);
if (cameraBody == null)
{
leftDoorConstraint.EnableControlAngleY = true;
return;
}
bool switchColliding = objectBase.IsColliding(cameraBody);
bool doorColliding = objectBase.RigidGroupOwner.IsColliding(cameraBody);
if (switchColliding)
{
totalSwitchLeftTime = 0.0;
leftDoorConstraint.EnableControlAngleY = false;
}
if (totalSwitchLeftTime < maxSwitchLeftTime)
{
Vector3.Multiply(ref unitY, -2000.0f, out torque);
objectBase.RigidGroupOwner.WorldAccumulator.SetLocalTorque(ref torque);
}
else
if (totalSwitchLeftTime < 2.0f * maxSwitchLeftTime)
{
if (!doorColliding)
{
Vector3.Multiply(ref unitY, 2000.0f, out torque);
objectBase.RigidGroupOwner.WorldAccumulator.SetLocalTorque(ref torque);
}
else
{
totalSwitchLeftTime = 0.0;
}
}
else
if (!doorColliding)
{
leftDoorConstraint.EnableControlAngleY = true;
}
else
{
totalSwitchLeftTime = 0.0;
}
totalSwitchLeftTime += time;
if (totalSwitchLeftTime > 2.0f * maxSwitchLeftTime)
{
totalSwitchLeftTime = 2.0f * maxSwitchLeftTime;
}
}
public void Move(SimulateMethodArgs args)
{
PhysicsScene scene = demo.Engine.Factory.PhysicsSceneManager.Get(args.OwnerSceneIndex);
PhysicsObject objectBase = scene.Factory.PhysicsObjectManager.Get(args.OwnerIndex);
float time = args.Time;
PhysicsObject physicsObjectWithActiveCamera = scene.GetPhysicsObjectWithActiveCamera(0);
if (physicsObjectWithActiveCamera == null)
{
return;
}
PhysicsObject cameraBody = physicsObjectWithActiveCamera.RigidGroupOwner.FindChildPhysicsObject(cameraBodyName, true, true);
PhysicsObject cameraDown = physicsObjectWithActiveCamera.RigidGroupOwner.FindChildPhysicsObject(cameraDownName, true, true);
if ((chassisMiddleDown == null) || (steeringGearSwitch == null))
{
return;
}
Constraint CameraConstraint = objectBase.Scene.Factory.ConstraintManager.Find(cameraConstraintName);
bool steeringGearWorking = true;
if (steeringGearConstraint != null)
{
if (steeringGearConstraint.PhysicsObject1 != null)
{
if (steeringGearConstraint.PhysicsObject1.IsBrokenRigidGroup || steeringGearConstraint.IsBroken)
{
steeringGearWorking = false;
}
}
if (steeringGearConstraint.PhysicsObject2 != null)
{
if (steeringGearConstraint.PhysicsObject2.IsBrokenRigidGroup || steeringGearConstraint.IsBroken)
{
steeringGearWorking = false;
}
}
}
else
{
steeringGearWorking = false;
}
if (!steeringGearWorking)
{
steeringGearDown.DisableCollision(chassisUpPanel, false);
steeringGearDown.DisableCollision(chassisDownPanel, false);
steeringGearDown.DisableCollision(upBodyFront, false);
steeringGearDown.DisableCollision(upBodyDownBack, false);
}
if (objectBase.IsBrokenRigidGroup || !steeringGearWorking)
{
if ((CameraConstraint != null) && (CameraConstraint.PhysicsObject1 == cameraDown))
{
objectBase.Scene.Factory.ConstraintManager.Remove(CameraConstraint);
physicsObjectWithActiveCamera.Camera.EnableControl = false;
cameraDown.RigidGroupOwner.MaxPreUpdateAngularVelocity = 0.0f;
cameraDown.RigidGroupOwner.MaxPostUpdateAngularVelocity = 0.0f;
cameraDown.DisableCollision(steeringWheel, false);
cameraDown.DisableCollision(chassisBack, false);
cameraDown.DisableCollision(chassisMiddleBack, false);
cameraDown.DisableCollision(upBodyFront, false);
cameraDown.DisableCollision(upBodyDownBack, false);
cameraBody.DisableCollision(steeringGearDown, false);
cameraBody.DisableCollision(steeringWheel, false);
cameraBody.DisableCollision(chassisBack, false);
cameraBody.DisableCollision(chassisMiddleBack, false);
cameraBody.DisableCollision(upBodyFront, false);
cameraBody.DisableCollision(upBodyDownBack, false);
Vector3 euler = vectorZero;
Vector3 cameraEuler = vectorZero;
Vector3 objectEuler = vectorZero;
physicsObjectWithActiveCamera.Camera.GetEuler(ref cameraEuler);
physicsObjectWithActiveCamera.MainWorldTransform.GetTransposeRotation(ref objectRotation);
physicsObjectWithActiveCamera.InitLocalTransform.GetRotation(ref objectInitRotation);
Matrix4.Mult(ref objectRotation, ref objectInitRotation, out rotation);
physicsObjectWithActiveCamera.Camera.SetEuler(ref rotation);
physicsObjectWithActiveCamera.Camera.GetEuler(ref objectEuler);
Vector3.Add(ref objectEuler, ref cameraEuler, out euler);
Matrix4 rotationX, rotationY;
Matrix4.CreateRotationX(-euler.X, out rotationX);
Matrix4.CreateRotationY(-euler.Y, out rotationY);
Matrix4.Mult(ref rotationY, ref rotationX, out rotation);
physicsObjectWithActiveCamera.Camera.SetEuler(ref euler);
physicsObjectWithActiveCamera.Camera.SetRotation(ref rotation);
Matrix4.CreateRotationY(euler.Y, out rotation);
physicsObjectWithActiveCamera.RigidGroupOwner.MainWorldTransform.SetRotation(ref rotation);
physicsObjectWithActiveCamera.RigidGroupOwner.RecalculateMainTransform();
}
return;
}
DemoKeyboardState keyboardState = demo.GetKeyboardState();
if (physicsObjectWithActiveCamera.Camera.EnableControl && (CameraConstraint != null) && (CameraConstraint.PhysicsObject1 == cameraDown))
{
if (keyboardState[Key.Space] && !oldKeyboardState[Key.Space])
{
objectBase.Scene.Factory.ConstraintManager.Remove(CameraConstraint);
physicsObjectWithActiveCamera.Camera.EnableControl = false;
cameraDown.RigidGroupOwner.MaxPreUpdateAngularVelocity = 0.0f;
cameraDown.RigidGroupOwner.MaxPostUpdateAngularVelocity = 0.0f;
cameraDown.DisableCollision(steeringWheel, false);
cameraDown.DisableCollision(chassisBack, false);
cameraDown.DisableCollision(chassisMiddleBack, false);
cameraDown.DisableCollision(upBodyFront, false);
cameraDown.DisableCollision(upBodyDownBack, false);
cameraBody.DisableCollision(steeringGearDown, false);
cameraBody.DisableCollision(steeringWheel, false);
cameraBody.DisableCollision(chassisBack, false);
cameraBody.DisableCollision(chassisMiddleBack, false);
cameraBody.DisableCollision(upBodyFront, false);
cameraBody.DisableCollision(upBodyDownBack, false);
Vector3 euler = vectorZero;
Vector3 cameraEuler = vectorZero;
Vector3 objectEuler = vectorZero;
physicsObjectWithActiveCamera.Camera.GetEuler(ref cameraEuler);
physicsObjectWithActiveCamera.MainWorldTransform.GetTransposeRotation(ref objectRotation);
physicsObjectWithActiveCamera.InitLocalTransform.GetRotation(ref objectInitRotation);
Matrix4.Mult(ref objectRotation, ref objectInitRotation, out rotation);
physicsObjectWithActiveCamera.Camera.SetEuler(ref rotation);
physicsObjectWithActiveCamera.Camera.GetEuler(ref objectEuler);
Vector3.Add(ref objectEuler, ref cameraEuler, out euler);
euler.Z = 0.0f;
Matrix4 rotationX, rotationY;
Matrix4.CreateRotationX(-euler.X, out rotationX);
Matrix4.CreateRotationY(-euler.Y, out rotationY);
Matrix4.Mult(ref rotationY, ref rotationX, out rotation);
physicsObjectWithActiveCamera.Camera.SetEuler(ref euler);
physicsObjectWithActiveCamera.Camera.SetRotation(ref rotation);
Matrix4.CreateRotationY(euler.Y, out rotation);
physicsObjectWithActiveCamera.RigidGroupOwner.MainWorldTransform.SetRotation(ref rotation);
physicsObjectWithActiveCamera.RigidGroupOwner.RecalculateMainTransform();
oldKeyboardState = keyboardState;
return;
}
if (keyboardState[Key.W])
{
if (wheel1 != null)
{
Vector3.Multiply(ref unitY, 5.0f, out velocity);
wheel1.MainWorldTransform.AddLocalAngularVelocity(ref velocity);
}
if (wheel2 != null)
{
Vector3.Multiply(ref unitY, 5.0f, out velocity);
wheel2.MainWorldTransform.AddLocalAngularVelocity(ref velocity);
}
}
if (keyboardState[Key.S])
{
if (wheel1 != null)
{
Vector3.Multiply(ref unitY, -5.0f, out velocity);
wheel1.MainWorldTransform.AddLocalAngularVelocity(ref velocity);
}
if (wheel2 != null)
{
Vector3.Multiply(ref unitY, -5.0f, out velocity);
wheel2.MainWorldTransform.AddLocalAngularVelocity(ref velocity);
}
}
if (keyboardState[Key.D])
{
if (steeringGearConstraint != null)
{
steeringGearConstraint.ControlDegAngleY -= 2.0f;
}
if (constraint1 != null)
{
constraint1.ControlDegAngleY += 1.0f;
}
if (constraint4 != null)
{
constraint4.ControlDegAngleY += 1.0f;
}
}
if (keyboardState[Key.A])
{
if (steeringGearConstraint != null)
{
steeringGearConstraint.ControlDegAngleY += 2.0f;
}
if (constraint1 != null)
{
constraint1.ControlDegAngleY -= 1.0f;
}
if (constraint4 != null)
{
constraint4.ControlDegAngleY -= 1.0f;
}
}
}
else
{
if ((cameraBody != null) && steeringGearSwitch.IsColliding(cameraBody))
{
if (keyboardState[Key.Space] && !oldKeyboardState[Key.Space])
{
physicsObjectWithActiveCamera.Camera.EnableControl = true;
cameraDown.RigidGroupOwner.MaxPreUpdateAngularVelocity = 1000.0f;
cameraDown.RigidGroupOwner.MaxPostUpdateAngularVelocity = 1000.0f;
cameraDown.DisableCollision(steeringWheel, true);
cameraDown.DisableCollision(chassisBack, true);
cameraDown.DisableCollision(chassisMiddleBack, true);
cameraDown.DisableCollision(upBodyFront, true);
cameraDown.DisableCollision(upBodyDownBack, true);
cameraBody.DisableCollision(steeringGearDown, true);
cameraBody.DisableCollision(steeringWheel, true);
cameraBody.DisableCollision(chassisBack, true);
cameraBody.DisableCollision(chassisMiddleBack, true);
cameraBody.DisableCollision(upBodyFront, true);
cameraBody.DisableCollision(upBodyDownBack, true);
Quaternion cameraOrientationX = quaternionIdentity;
Quaternion cameraOrientationY = quaternionIdentity;
Quaternion cameraOrientationZ = quaternionIdentity;
Quaternion cameraOrientationXY = quaternionIdentity;
Quaternion cameraOrientation = quaternionIdentity;
Quaternion.Multiply(ref cameraOrientationX, ref cameraOrientationY, out cameraOrientationXY);
Quaternion.Multiply(ref cameraOrientationXY, ref cameraOrientationZ, out cameraOrientation);
rotation = Matrix4.CreateFromQuaternion(cameraOrientation);
physicsObjectWithActiveCamera.Camera.SetOrientation(ref cameraOrientation);
physicsObjectWithActiveCamera.Camera.SetRotation(ref rotation);
physicsObjectWithActiveCamera.Camera.SetEuler(ref rotation);
objectOrientation = Quaternion.FromAxisAngle(unitY, MathHelper.DegreesToRadians(180.0f));
objectRotation = Matrix4.CreateFromQuaternion(objectOrientation);
Vector3 carChassisPosition = vectorZero;
Matrix4 carChassisRotation = matrixIdentity;
chassisMiddleDown.MainWorldTransform.GetPosition(ref carChassisPosition);
chassisMiddleDown.MainWorldTransform.GetRotation(ref carChassisRotation);
Matrix4.Mult(ref objectRotation, ref carChassisRotation, out rotation);
Vector3.TransformVector(ref driverLocalPosition, ref carChassisRotation, out position);
Vector3.Add(ref carChassisPosition, ref position, out position);
physicsObjectWithActiveCamera.RigidGroupOwner.MainWorldTransform.SetRotation(ref rotation);
physicsObjectWithActiveCamera.RigidGroupOwner.MainWorldTransform.SetPosition(ref position);
physicsObjectWithActiveCamera.RigidGroupOwner.RecalculateMainTransform();
if (CameraConstraint == null)
{
CameraConstraint = scene.Factory.ConstraintManager.Create(cameraConstraintName);
CameraConstraint.PhysicsObject1 = cameraDown;
CameraConstraint.PhysicsObject2 = chassisMiddleDown;
CameraConstraint.PhysicsObject1.MainWorldTransform.GetPosition(ref position1);
CameraConstraint.PhysicsObject1.MainWorldTransform.GetOrientation(ref orientation1);
CameraConstraint.PhysicsObject2.MainWorldTransform.GetOrientation(ref orientation2);
carChassisPosition.X = carChassisPosition.Z = 0.0f;
carChassisPosition.Y = 2.0f;
Vector3.Subtract(ref position1, ref carChassisPosition, out position1);
CameraConstraint.SetAnchor1(ref position1);
CameraConstraint.SetAnchor2(ref position1);
CameraConstraint.SetInitWorldOrientation1(ref orientation1);
CameraConstraint.SetInitWorldOrientation2(ref orientation2);
CameraConstraint.EnableLimitAngleX = true;
CameraConstraint.EnableLimitAngleY = true;
CameraConstraint.EnableLimitAngleZ = true;
CameraConstraint.LimitAngleForce = 0.4f;
CameraConstraint.MinResponseLinearVelocity = 0.005f;
CameraConstraint.MinResponseAngularVelocity = 0.005f;
CameraConstraint.Update();
}
}
}
if (enableExternalMoving)
{
if (keyboardState[Key.Up])
{
if (wheel1 != null)
{
Vector3.Multiply(ref unitY, 5.0f, out velocity);
wheel1.MainWorldTransform.AddLocalAngularVelocity(ref velocity);
}
if (wheel2 != null)
{
Vector3.Multiply(ref unitY, 5.0f, out velocity);
wheel2.MainWorldTransform.AddLocalAngularVelocity(ref velocity);
}
}
if (keyboardState[Key.Down])
{
if (wheel1 != null)
{
Vector3.Multiply(ref unitY, -5.0f, out velocity);
wheel1.MainWorldTransform.AddLocalAngularVelocity(ref velocity);
}
if (wheel2 != null)
{
Vector3.Multiply(ref unitY, -5.0f, out velocity);
wheel2.MainWorldTransform.AddLocalAngularVelocity(ref velocity);
}
}
if (keyboardState[Key.Right])
{
if (steeringGearConstraint != null)
{
steeringGearConstraint.ControlDegAngleY -= 2.0f;
}
if (constraint1 != null)
{
constraint1.ControlDegAngleY += 1.0f;
}
if (constraint4 != null)
{
constraint4.ControlDegAngleY += 1.0f;
}
}
if (keyboardState[Key.Left])
{
if (steeringGearConstraint != null)
{
steeringGearConstraint.ControlDegAngleY += 2.0f;
}
if (constraint1 != null)
{
constraint1.ControlDegAngleY -= 1.0f;
}
if (constraint4 != null)
{
constraint4.ControlDegAngleY -= 1.0f;
}
}
}
}
oldKeyboardState = keyboardState;
}
void SwitchLeft(SimulateMethodArgs args)
{
PhysicsScene scene = demo.Engine.Factory.PhysicsSceneManager.Get(args.OwnerSceneIndex);
PhysicsObject objectBase = scene.Factory.PhysicsObjectManager.Get(args.OwnerIndex);
float time = args.Time;
MenuData userData = (MenuData)args.UserDataObj;
string switchSliderConstraintName = userData.SwitchSliderConstraintName;
int sceneIndex = userData.SceneIndex;
int switchIndex = userData.SwitchIndex;
if (baseSceneIndex > 0)
{
objectBase.Material.SetAmbient(0.4f, 0.4f, 0.25f);
}
else
{
objectBase.Material.SetAmbient(0.4f, 0.4f, 0.4f);
}
PhysicsObject physicsObjectWithActiveCamera = scene.GetPhysicsObjectWithActiveCamera(0);
if (physicsObjectWithActiveCamera == null)
{
return;
}
PhysicsCamera activeCamera = physicsObjectWithActiveCamera.Camera;
if (activeCamera == null)
{
return;
}
Vector3 switchVelocity;
ScreenToRayController screenToRayController = physicsObjectWithActiveCamera.InternalControllers.ScreenToRayController;
Constraint switchSliderConstraint = scene.Factory.ConstraintManager.Find(switchSliderConstraintName);
string sceneName = demo.Scenes[sceneIndex].SceneName;
DemoMouseState mouseState = demo.GetMouseState();
DemoMouseState oldMouseState = userData.OldMouseState;
int deltaX = mouseState.X - oldMouseState.X;
int deltaY = mouseState.Y - oldMouseState.Y;
if (switchSliderConstraint != null)
{
if (screenToRayController.IsHitPhysicsObject && (screenToRayController.HitPhysicsObject == objectBase))
{
if (((switchPhysicsObject != objectBase) && !mouseState[MouseButton.Left] && !mouseState[MouseButton.Middle] && !mouseState[MouseButton.Right] && (Math.Abs(deltaX) + Math.Abs(deltaY) != 0)) || ((switchPhysicsObject == objectBase) && (switchSliderConstraint.ControlDistanceZ < -4.95f)) || ((switchPhysicsObject == objectBase) && (Math.Abs(deltaX) + Math.Abs(deltaY) != 0)))
{
enableStartInfo = false;
if (infoScreen != null)
{
infoScreen.EnableDrawing = false;
}
if (infoDescription != null)
{
infoDescription.EnableDrawing = false;
}
switchPhysicsObject = objectBase;
Vector3.Multiply(ref unitZ, -10.0f, out switchVelocity);
objectBase.MainWorldTransform.SetLinearVelocity(ref switchVelocity);
objectBase.MainWorldTransform.SetAngularVelocity(ref vectorZero);
}
if ((switchPhysicsObject == objectBase) && mouseState[MouseButton.Left] && !oldMouseState[MouseButton.Left] && (switchSliderConstraint.ControlDistanceZ <= -0.5f))
{
baseSceneIndex = Math.Max(baseSceneIndex - 1, 0);
}
}
else
{
if ((switchPhysicsObject == objectBase) && (switchSliderConstraint.ControlDistanceZ >= -0.05))
{
if (infoScreen != null)
{
infoScreen.EnableDrawing = false;
}
if (infoDescription != null)
{
infoDescription.EnableDrawing = false;
}
switchPhysicsObject = null;
}
}
}
userData.OldMouseState = mouseState;
args.UserDataObj = userData;
}