/// <summary> /// Creates an actor using shape info and information from the parent BaseEntity. /// </summary> /// <param name="PhysicsScene">Reference to the physics scene</param> protected override void CreateActor(IPhysicsScene PhysicsScene) { // Character physics have custom physics bodies that have gravity and other // forces manually applied, but they're still considered dynamic so they can // collide with other objects this.isDynamic = true; ActorDesc desc = new ActorDesc(); desc.Orientation = this.parentEntity.Rotation; desc.Mass = this.mass; desc.Dynamic = this.isDynamic; desc.AffectedByGravity = this.affectedByGravity; desc.Position = this.parentEntity.Position; desc.EntityID = this.parentEntity.UniqueID; desc.Game = this.parentEntity.Game; desc.Type = ActorType.Character; this.actor = PhysicsScene.CreateActor(desc); if (this.actor != null) { this.actor.EnableCollisionListening(); } }
/// <summary> /// Creates an actor using shape info and information from the parent BaseEntity. /// </summary> /// <param name="PhysicsScene">Reference to the physics scene</param> protected override void CreateActor(IPhysicsScene PhysicsScene) { ShapeDesc newShape = CreateShapeFromType(shapeType); // Phantoms cannot currently have dynamic physics this.isDynamic = false; var desc = new ActorDesc(); desc.Orientation = this.parentEntity.Rotation; desc.Mass = this.mass; desc.Dynamic = this.isDynamic; desc.AffectedByGravity = this.affectedByGravity; desc.Position = this.parentEntity.Position; desc.Shapes.Add(newShape); desc.EntityID = this.parentEntity.UniqueID; desc.Game = this.parentEntity.Game; desc.Type = ActorType.Static; this.actor = PhysicsScene.CreateActor(desc); if (this.actor != null) { this.actor.EnableCollisionListening(); } }
/// <summary> /// Creates an actor using shape info and information from the parent BaseEntity. /// </summary> /// <param name="PhysicsScene">Reference to the physics scene</param> protected virtual void CreateActor(IPhysicsScene PhysicsScene) { ShapeDesc newShape = CreateShapeFromType(shapeType); if (newShape == null) { throw new Exception("Shape did not load properly"); } ActorDesc desc = new ActorDesc(); desc.Orientation = this.parentEntity.Rotation; desc.Mass = this.mass; desc.Dynamic = this.isDynamic; desc.AffectedByGravity = this.affectedByGravity; desc.Position = this.parentEntity.Position; desc.Shapes.Add(newShape); desc.EntityID = this.parentEntity.UniqueID; desc.Game = this.parentEntity.Game; desc.Type = ActorType.Basic; if (newShape is TriangleMeshShapeDesc) { var triDesc = newShape as TriangleMeshShapeDesc; if (triDesc.Vertices.Count > 100) { desc.Type = ActorType.Static; } } this.actor = PhysicsScene.CreateActor(desc); }
/// <summary> /// Constructs a new static physics actor. /// </summary> /// <param name="desc">Descriptor for the actor.</param> public TerrainBEPUActor(ActorDesc desc) : base(desc) { if (desc.Shapes.Count != 1) { throw new Exception("Terrain actors can only consist of one shape"); } ShapeDesc shapeDesc = desc.Shapes[0]; if (shapeDesc is HeightFieldShapeDesc) { // For height fields, we need to copy the data into an Array2D. var heightFieldDesc = shapeDesc as HeightFieldShapeDesc; float spacing = heightFieldDesc.SizeX / heightFieldDesc.HeightField.GetLength(0); this.collidable = new Terrain(heightFieldDesc.HeightField, new AffineTransform( new Vector3(spacing, 1, spacing), Quaternion.Identity, Vector3.Zero)); } else { throw new Exception("Shape description for a Terrain actor must be HeightFieldShapeDesc."); } // Tag the physics with data needed by the engine var tag = new EntityTag(this.ownerEntityID); this.collidable.Tag = tag; this.spaceObject = this.collidable; }
private void AddCube() { double d = 0.1 + 0.2 * rnd.NextDouble(); Mogre.Vector3 pos = new Mogre.Vector3((float)(-10 * d), (float)d, 0);; for (int j = 0; j < 10; j++) { float tempy = pos.y; pos.x += 2 * (float)(d - physx.Parameters.SkinWidth); pos.z += 1f * (float)(d + physx.Parameters.SkinWidth); for (int i = 0; i < 1 + j; i++) { var ad = new ActorDesc(new BodyDesc(), 10, new BoxShapeDesc(new Mogre.Vector3((float)d, (float)d, (float)d))); ad.GlobalPosition = new Mogre.Vector3(pos.x, pos.y, pos.z); pos.y += 2 * (float)(d - physx.Parameters.SkinWidth); var a = scene.CreateActor(ad); cubeActors.Add(a); string id = "MaunalObject_" + Guid.NewGuid().ToString(); string cubeName = "CUSTOME_CUBE_" + Guid.NewGuid().ToString(); createCube(cubeName, ad.GlobalPosition, d); Entity mo = m_pSceneMgr.CreateEntity(id, cubeName); SceneNode moSceneNode = m_pSceneMgr.RootSceneNode.CreateChildSceneNode(); moSceneNode.AttachObject(mo); cubes.Add(mo); } pos.y = tempy; } return; }
/// <summary> /// Constructs a new physics actor. /// </summary> /// <param name="desc">Descriptor for the actor.</param> public CharacterBEPUActor(ActorDesc desc) : base(desc) { character = new CharacterController(desc.Position, 17f, 17f * 0.6f, 6.0f, 4500.0f); characterBody = character.Body; // Tag the physics with data needed by the engine var tag = new CharacterTag(this.ownerEntityID, characterBody); this.characterBody.Tag = tag; this.characterBody.CollisionInformation.Tag = tag; this.Position = desc.Position; this.Orientation = desc.Orientation; Debug.Assert(this.characterBody != null, "A physics entity was not properly created."); this.spaceObject = this.character; this.characterBody.IsAffectedByGravity = desc.AffectedByGravity; #if WINDOWS // We add the character's cylinder body to the physics viewer. var msgAddPhys = ObjectPool.Aquire <MsgAddPhysicsToModelViewer>(); msgAddPhys.SpaceObject = this.characterBody; this.game.SendInterfaceMessage(msgAddPhys, InterfaceType.Physics); #endif //WINDOW }
public override void Spawn(Vector3 position, Quaternion orientation) { // create scene node SceneNode sceneNode = this.CreateSceneNode(position, orientation); Entity entity = sceneNode.GetAttachedObject(0) as Entity; // physics BodyDesc bodyDesc = new BodyDesc(); bodyDesc.LinearVelocity = this.Velocity; ActorDesc actorDesc = Engine.Physics.CreateActorDesc(this, entity, position, orientation, this.Scale); actorDesc.Density = this.Density; actorDesc.Body = bodyDesc; actorDesc.GlobalPosition = position; actorDesc.GlobalOrientation = orientation.ToRotationMatrix(); if (this.EnableCCD) { foreach (ShapeDesc shapeDesc in actorDesc.Shapes) { shapeDesc.ShapeFlags = ShapeFlags.DynamicDynamicCCD; } } Actor actor = Engine.Physics.Scene.CreateActor(actorDesc); actor.UserData = this; ActorNode actorNode = new ActorNode(sceneNode, actor); Engine.World.ActorNodes.Add(actorNode); }
/// <summary> /// These can be specified in several different ways: /// ///1) actorDesc.density == 0, bodyDesc.mass > 0, bodyDesc.massSpaceInertia.magnitude() > 0 /// ///Here the mass properties are specified explicitly, there is nothing to compute. /// ///2) actorDesc.density > 0, actorDesc.shapes.size() > 0, bodyDesc.mass == 0, bodyDesc.massSpaceInertia.magnitude() == 0 /// ///Here a density and the shapes are given. From this both the mass and the inertia tensor is computed. /// ///3) actorDesc.density == 0, actorDesc.shapes.size() > 0, bodyDesc.mass > 0, bodyDesc.massSpaceInertia.magnitude() == 0 /// ///Here a mass and shapes are given. From this the inertia tensor is computed. /// ///Other combinations of settings are illegal. /// </summary> /// <param name="node"></param> /// <param name="dynamic"></param> /// <param name="shapeBuilder"></param> /// <param name="density"></param> /// <param name="mass"></param> /// <returns></returns> public Actor CreateActor(Physic physic, bool dynamic, Func <Frame, ActorShapeDesc> shapeBuilder, float density = 0, float mass = 0) { if (physic != null) { throw new NullReferenceException("Physics"); } ActorDesc actorDesc = _CreateActorDescription(dynamic, density, mass); if (shapeBuilder != null) { foreach (var child in EnumerateNodesPosOrden()) { var shapeDesc = shapeBuilder(child); if (shapeDesc != null) { actorDesc.Shapes.Add(shapeDesc); } } } var actor = physic.CreateActor(actorDesc); this.BindTo(actor); return(actor); }
private ActorDesc _CreateActorDescription(bool dynamic, float density = 0, float mass = 0) { if (Engine.Scene == null || Engine.Scene.Physics == null) { throw new InvalidOperationException("No Scene"); } ActorDesc actorDesc = new ActorDesc(); actorDesc.Name = Name; actorDesc.GlobalPose = _worldTransform; if (density > 0) { actorDesc.Density = density; mass = 0; } if (dynamic) { actorDesc.Body = new BodyDesc() { }; if (mass > 0) { actorDesc.Body.Mass = mass; } } return(actorDesc); }
public void ToNxActor(ref ActorDesc actorDesc) { actorDesc.ContactReportFlags = contactReportFlags; actorDesc.Density = density; actorDesc.DominanceGroup = dominanceGroup; actorDesc.ForceFieldMaterial = forceFieldMaterial; actorDesc.Group = group; actorDesc.Name = name; }
/// <summary> /// Constructs a new physics actor. /// </summary> /// <param name="desc">Descriptor for the actor.</param> internal BEPUActor(ActorDesc desc) { this.actorType = desc.Type; this.shapes = desc.Shapes; this.ownerEntityID = desc.EntityID; this.game = desc.Game; this.body = new QSBody(this); }
public void CreateStatic(Vector3 pose, RigidBodyDescription description, Scene scene, ShapeDesc shape) { ActorDesc actorDesc = new ActorDesc(); actorDesc.GlobalPosition = pose; actorDesc.Body = null; description.ToNxActor(ref actorDesc); actorDesc.Shapes.Add(shape); Actor = scene.CreateActor(actorDesc); }
public override void enter() { m_pSceneMgr = AdvancedMogreFramework.Singleton.m_pRoot.CreateSceneManager(SceneType.ST_GENERIC, "PhysxBasicCubeMgr"); ColourValue cvAmbineLight = new ColourValue(0.7f, 0.7f, 0.7f); m_pSceneMgr.AmbientLight = cvAmbineLight;//(Ogre::ColourValue(0.7f, 0.7f, 0.7f)); m_pCamera = m_pSceneMgr.CreateCamera("PhysxBasicCubeCamera"); Mogre.Vector3 vectCameraPostion = new Mogre.Vector3(-10, 40, 10); m_pCamera.Position = vectCameraPostion; Mogre.Vector3 vectorCameraLookAt = new Mogre.Vector3(5, 20, 0); m_pCamera.LookAt(vectorCameraLookAt); m_pCamera.NearClipDistance = 5; m_pCamera.AspectRatio = AdvancedMogreFramework.Singleton.m_pViewport.ActualWidth / AdvancedMogreFramework.Singleton.m_pViewport.ActualHeight; AdvancedMogreFramework.Singleton.m_pViewport.Camera = m_pCamera; createPanel(m_pSceneMgr); trayMgr.destroyAllWidgets(); for (int i = 0; i < 10; i++) { double d = 0.1 + 0.2 * rnd.NextDouble() * 10; var ad = new ActorDesc(new BodyDesc(), 10, new BoxShapeDesc(new Mogre.Vector3((float)d, (float)d, (float)d))); Mogre.Vector3 gpose = new Mogre.Vector3((float)(10 * (rnd.NextDouble() - rnd.NextDouble())), (float)(10 * rnd.NextDouble()), (float)(5 * rnd.NextDouble())); ad.GlobalPosition = gpose; var a = scene.CreateActor(ad); cubeActors.Add(a); a.AddTorque(new Mogre.Vector3(0, 0, (float)(15 * d * (rnd.NextDouble() - rnd.NextDouble()))), ForceModes.Impulse); string id = "MaunalObject_" + Guid.NewGuid().ToString(); string cubeName = "CUSTOME_CUBE_" + Guid.NewGuid().ToString(); createCube(cubeName, gpose, d); Entity mo = m_pSceneMgr.CreateEntity(id, cubeName); SceneNode moSceneNode = m_pSceneMgr.RootSceneNode.CreateChildSceneNode(); moSceneNode.AttachObject(mo); cubes.Add(mo); } scene.Simulate(0); AdvancedMogreFramework.Singleton.m_pMouse.MouseMoved += mouseMoved; AdvancedMogreFramework.Singleton.m_pMouse.MousePressed += mousePressed; AdvancedMogreFramework.Singleton.m_pMouse.MouseReleased += mouseReleased; AdvancedMogreFramework.Singleton.m_pKeyboard.KeyPressed += keyPressed; AdvancedMogreFramework.Singleton.m_pKeyboard.KeyReleased += keyReleased; }
protected override void create() { itemEnt = camera.SceneManager.CreateEntity(itemName, itemMeshName); itemNode = camera.SceneManager.RootSceneNode.CreateChildSceneNode(); itemNode.AttachObject(itemEnt); ActorDesc actorDesc = new ActorDesc(); actorDesc.Density = 4; actorDesc.Body = null; actorDesc.Shapes.Add(physics.CreateTriangleMesh(new StaticMeshData(itemEnt.GetMesh()))); itemActor = physicsScene.CreateActor(actorDesc); }
protected override void create() { renderable.Entity = renderable.SceneManager.CreateEntity(Guid.NewGuid().ToString(), itemData.MeshName); renderable.EntityNode = renderable.SceneManager.RootSceneNode.CreateChildSceneNode(); renderable.EntityNode.AttachObject(renderable.Entity); ActorDesc actorDesc = new ActorDesc(); actorDesc.Density = 4; actorDesc.Body = null; actorDesc.Shapes.Add(physics.CreateTriangleMesh(new StaticMeshData(renderable.Entity.GetMesh()))); itemActor = physicsScene.CreateActor(actorDesc); }
protected override void create(GameWorld world) { base.create(world); renderable.Entity = renderable.SceneManager.CreateEntity(itemName, itemMeshName); renderable.EntityNode = renderable.SceneManager.RootSceneNode.CreateChildSceneNode(); renderable.EntityNode.AttachObject(renderable.Entity); ActorDesc actorDesc = new ActorDesc(); actorDesc.Density = 4; actorDesc.Body = null; actorDesc.Shapes.Add(physics.CreateTriangleMesh(new StaticMeshData(renderable.Entity.GetMesh()))); itemActor = physicsScene.CreateActor(actorDesc); }
public void CreateDynamic( Vector3 pose, Matrix3 oritentaion, RigidBodyDescription description, Scene scene, ShapeDesc shape) { BodyDesc bodyDesc = new BodyDesc(); ActorDesc actorDesc = new ActorDesc(); description.ToNxActor(ref actorDesc, ref bodyDesc); actorDesc.Body = bodyDesc; actorDesc.GlobalPosition = pose; actorDesc.GlobalOrientation = oritentaion; actorDesc.Shapes.Add(shape); Actor = scene.CreateActor(actorDesc); }
public ActorDesc CreateActorDesc(EntityWorldEntity entityNode, Entity entity, Vector3 position, Quaternion orientation, Vector3 scale) { ActorDesc actorDesc = new ActorDesc(); actorDesc.GlobalPosition = position; actorDesc.GlobalOrientation = orientation.ToRotationMatrix(); if (entityNode.CollisionMode == CollisionMode.ConvexHull || entityNode.CollisionMode == CollisionMode.TriangleMesh) { StaticMeshData meshData = new StaticMeshData(entity.GetMesh(), scale); if (entityNode.CollisionMode == CollisionMode.TriangleMesh) { actorDesc.Shapes.Add(Engine.Physics.CreateTriangleMesh(meshData)); } else { actorDesc.Shapes.Add(Engine.Physics.CreateConvexHull(meshData)); } } else { switch (entityNode.CollisionMode) { case CollisionMode.BoundingBox: actorDesc.Shapes.Add(new BoxShapeDesc(entity.BoundingBox.HalfSize * scale, entity.BoundingBox.Center * scale)); break; case CollisionMode.BoundingSphere: actorDesc.Shapes.Add(new SphereShapeDesc(Engine.MaxAxis(entity.BoundingBox.HalfSize), entity.BoundingBox.Center * scale)); break; case CollisionMode.Shapes: foreach (ShapeDesc shapeDesc in entityNode.Shapes) { actorDesc.Shapes.Add(shapeDesc); } break; default: throw new Exception(entityNode.CollisionMode.ToString() + " not implemented"); } } return(actorDesc); }
private void createPanel(SceneManager scm) { MeshManager.Singleton.CreatePlane("floor", ResourceGroupManager.DEFAULT_RESOURCE_GROUP_NAME, new Plane(Mogre.Vector3.UNIT_Y, 0), 100, 100, 10, 10, true, 1, 10, 10, Mogre.Vector3.UNIT_Z); Entity floor = scm.CreateEntity("Floor", "floor"); floor.SetMaterialName("Examples/Rockwall"); floor.CastShadows = (false); scm.RootSceneNode.AttachObject(floor); ActorDesc actorDesc = new ActorDesc(); actorDesc.Density = 4; actorDesc.Body = null; actorDesc.Shapes.Add(physx.CreateTriangleMesh(new StaticMeshData(floor.GetMesh()))); Actor floorActor = scene.CreateActor(actorDesc); }
/// <summary> /// Creates a new physics actor. /// </summary> /// <param name="desc">The actor descriptor.</param> /// <returns>The new actor instance.</returns> public IPhysicsActor CreateActor(ActorDesc desc) { if (this.bFixedTimeMet) { // This should pause the physics frame ever so slightly so we can add the // actor to the physics scene. this.startFrame.Reset(); } IPhysicsActor actor; switch (desc.Type) { case ActorType.Basic: actor = new BasicBEPUActor(desc); break; case ActorType.Character: actor = new CharacterBEPUActor(desc); break; case ActorType.Terrain: actor = new TerrainBEPUActor(desc); break; case ActorType.Water: actor = new WaterVolumeBEPUActor(desc); break; case ActorType.Static: actor = new StaticBEPUActor(desc); break; default: throw new ArgumentException("Unknown actor type, new type was added and this switch wasn't updated to handle it."); } if (this.bFixedTimeMet) { // Unpause physics now that new actor is in the physics scene this.startFrame.Set(); } return(actor); }
public Actor CreateActor(Physic physic, bool dynamic, ActorShapeDesc[] shapes, float density = 0, float mass = 0) { if (physic != null) { throw new ArgumentNullException("physic"); } ActorDesc actorDesc = _CreateActorDescription(dynamic, density, mass); foreach (var item in shapes) { actorDesc.Shapes.Add(item); } var actor = physic.CreateActor(actorDesc); this.BindTo(actor); return(actor); }
public void ToNxActor(ref ActorDesc actorDesc, ref BodyDesc bodyDesc) { ToNxActor(ref actorDesc); bodyDesc.AngularDamping = angularDamping; bodyDesc.AngularVelocity = angularVelocity; bodyDesc.CCDMotionThreshold = ccdMotionThreshold; bodyDesc.LinearDamping = linearDamping; bodyDesc.LinearVelocity = linearVelocity; bodyDesc.Mass = mass; bodyDesc.MassLocalPose = massLocalPose; bodyDesc.MassSpaceInertia = massSpaceInertia; bodyDesc.MaxAngularVelocity = maxAngularVelocity; bodyDesc.SleepAngularVelocity = sleepAngularVelocity; bodyDesc.SleepDamping = sleepDamping; bodyDesc.SleepEnergyThreshold = sleepEnergyThreshold; bodyDesc.SleepLinearVelocity = sleepLinearVelocity; bodyDesc.SolverIterationCount = solverIterationCount; bodyDesc.WakeUpCounter = wakeUpCounter; }
protected override void create() { string name = Guid.NewGuid().ToString(); MeshManager.Singleton.CreatePlane(name, groupName, new Plane(rkNormal, fConstanst), width, height, xsegments, ysegments, normals, numTexCoordSets, uTile, vTile, upVector); entity = sceneManager.CreateEntity(Guid.NewGuid().ToString(), name); entity.SetMaterialName(materialName); entity.CastShadows = false; entNode = sceneManager.RootSceneNode.CreateChildSceneNode(); entNode.AttachObject(entity); entNode.Position = position; ActorDesc actorDesc = new ActorDesc(); actorDesc.Density = 4; actorDesc.Body = null; actorDesc.Shapes.Add(physics.CreateTriangleMesh(new StaticMeshData(entity.GetMesh()))); Actor entityActor = physicsScene.CreateActor(actorDesc); }
internal override void Initialize(ActorContext context, ActorDesc actorDesc) { base.Initialize(context, actorDesc); var desc = (PhysicsSceneDesc)actorDesc; // TODO: Enable custom initialization of physics world collisionConf = new DefaultCollisionConfiguration(); dispatcher = new CollisionDispatcher(collisionConf); broadphase = new DbvtBroadphase(); world = new DiscreteDynamicsWorld(dispatcher, broadphase, null, collisionConf); world.Gravity = desc.Gravity; if (desc.Colliders != null) { foreach (var collider in desc.Colliders) { AddCollider(collider); } } }
public override void Spawn(Vector3 position, Quaternion orientation) { // create entity Entity entity = this.CreateEntity(); // add it to the static geometry if (this.CastShadows) { Engine.World.StaticGeometryCaster.AddEntity(entity, position, orientation, scale); } else { Engine.World.StaticGeometryReceiver.AddEntity(entity, position, orientation, scale); } // create the physics mesh ActorDesc actorDesc = Engine.Physics.CreateActorDesc(this, entity, position, orientation, scale); Actor actor = Engine.Physics.Scene.CreateActor(actorDesc); actor.UserData = this; }
/// <summary> /// Creates an actor using shape info and information from the parent BaseEntity. /// </summary> /// <param name="PhysicsScene">Reference to the physics scene</param> /// <param name="density">Density of physics object</param> private void CreateHeightfieldActor(IPhysicsScene PhysicsScene, float[,] heightData, float scaleFactor) { HeightFieldShapeDesc heightfieldShape = CreateHeightfieldShape(heightData, scaleFactor); if (heightfieldShape == null) { throw new Exception("Shape did not load properly"); } var desc = new ActorDesc(); desc.Orientation = parentEntity.Rotation; desc.Mass = 1.0f; desc.Dynamic = false; desc.AffectedByGravity = false; desc.Position = parentEntity.Position; desc.EntityID = this.parentEntity.UniqueID; desc.Shapes.Add(heightfieldShape); desc.Type = ActorType.Terrain; actor = PhysicsScene.CreateActor(desc); }
internal override void Initialize(ActorContext context, ActorDesc actorDesc) { base.Initialize(context, actorDesc); var desc = (RigidBodyDesc)actorDesc; var snapshot = (RigidBodySnapshot)Snapshot; var localInertia = Vector3.Zero; if (!desc.IsKinematic) { desc.Shape.CalculateLocalInertia(desc.Mass, out localInertia); } var motionState = new DefaultMotionState(desc.StartTransform, desc.CenterOfMassOffset); using (var rbInfo = new RigidBodyConstructionInfo(desc.Mass, motionState, desc.Shape, localInertia)) { rbInfo.Friction = desc.Friction; rbInfo.RollingFriction = desc.RollingFriction; rbInfo.Restitution = desc.Restitution; rbInfo.LinearDamping = desc.LinearDamping; rbInfo.AngularDamping = desc.AngularDamping; rigidBody = new RigidBody(rbInfo); rigidBody.UserObject = this; if (desc.IsKinematic) { rigidBody.CollisionFlags |= CollisionFlags.KinematicObject; } Scene.World.AddRigidBody(rigidBody); logger.Debug("Create RigidBody for {0}: Mass: {1}, Shape: {2}, Friction: {3}, RollingFriction: {4}, Restitution: {5}, LinearDamping: {6}, AngularDamping: {7}" , this, 1 / rigidBody.InvMass, rigidBody.CollisionShape, rigidBody.Friction, rigidBody.RollingFriction, rigidBody.Restitution, rigidBody.LinearDamping, rigidBody.AngularDamping); } }
/// <summary> /// Creates an actor using shape info and information from the parent BaseEntity. /// </summary> /// <param name="PhysicsScene">Reference to the physics scene</param> protected override void CreateActor(IPhysicsScene PhysicsScene) { ShapeDesc newShape = CreateShapeFromType(shapeType); if (newShape == null) { throw new Exception("Shape did not load properly"); } ActorDesc desc = new ActorDesc(); desc.Orientation = this.parentEntity.Rotation; desc.Mass = this.mass; desc.Dynamic = false; desc.AffectedByGravity = false; desc.Position = this.parentEntity.Position; desc.Shapes.Add(newShape); desc.EntityID = this.parentEntity.UniqueID; desc.Game = this.parentEntity.Game; desc.Type = ActorType.Water; this.actor = PhysicsScene.CreateActor(desc); }
public ActorDesc CreateActorDesc(EntityWorldEntity entityNode, Entity entity, Vector3 position, Quaternion orientation, Vector3 scale) { ActorDesc actorDesc = new ActorDesc(); actorDesc.GlobalPosition = position; actorDesc.GlobalOrientation = orientation.ToRotationMatrix(); if (entityNode.CollisionMode == CollisionMode.ConvexHull || entityNode.CollisionMode == CollisionMode.TriangleMesh) { StaticMeshData meshData = new StaticMeshData(entity.GetMesh(), scale); if (entityNode.CollisionMode == CollisionMode.TriangleMesh) actorDesc.Shapes.Add(Engine.Physics.CreateTriangleMesh(meshData)); else actorDesc.Shapes.Add(Engine.Physics.CreateConvexHull(meshData)); } else { switch (entityNode.CollisionMode) { case CollisionMode.BoundingBox: actorDesc.Shapes.Add(new BoxShapeDesc(entity.BoundingBox.HalfSize * scale, entity.BoundingBox.Center * scale)); break; case CollisionMode.BoundingSphere: actorDesc.Shapes.Add(new SphereShapeDesc(Engine.MaxAxis(entity.BoundingBox.HalfSize), entity.BoundingBox.Center * scale)); break; case CollisionMode.Shapes: foreach (ShapeDesc shapeDesc in entityNode.Shapes) actorDesc.Shapes.Add(shapeDesc); break; default: throw new Exception(entityNode.CollisionMode.ToString() + " not implemented"); } } return actorDesc; }
public override void init() { #region ground MeshManager.Singleton.CreatePlane("ground", ResourceGroupManager.DEFAULT_RESOURCE_GROUP_NAME, new Plane(Mogre.Vector3.UNIT_Y, 0), 1500, 1500, 20, 20, true, 1, 5, 5, Mogre.Vector3.UNIT_Z); // Create a ground plane entities.Add(OgreWindow.Instance.mSceneMgr.CreateEntity("GroundEntity", "ground")); entities["GroundEntity"].CastShadows = false; entities["GroundEntity"].SetMaterialName("dirt"); nodes.Add(OgreWindow.Instance.mSceneMgr.RootSceneNode.CreateChildSceneNode("ground")); nodes["ground"].AttachObject(entities["GroundEntity"]); nodes["ground"].Position = new Mogre.Vector3(0f, 0f, 0f) + Location().toMogre; // the actor properties control the mass, position and orientation // if you leave the body set to null it will become a static actor and wont move ActorDesc actorDesc2 = new ActorDesc(); actorDesc2.Density = 4; actorDesc2.Body = null; actorDesc2.GlobalPosition = nodes["ground"].Position; actorDesc2.GlobalOrientation = nodes["ground"].Orientation.ToRotationMatrix(); PhysXHelpers.StaticMeshData meshdata = new PhysXHelpers.StaticMeshData(entities["GroundEntity"].GetMesh()); actorDesc2.Shapes.Add(PhysXHelpers.CreateTriangleMesh(meshdata)); Actor actor2 = null; try { actor2 = OgreWindow.Instance.scene.CreateActor(actorDesc2); } catch (System.AccessViolationException ex) { log(ex.ToString()); } if (actor2 != null) { // create our special actor node to tie together the scene node and actor that we can update its position later ActorNode actorNode2 = new ActorNode(nodes["ground"], actor2); actors.Add(actorNode2); } #endregion lights.Add(OgreWindow.Instance.mSceneMgr.CreateLight("playerLight")); lights["playerLight"].Type = Light.LightTypes.LT_POINT; lights["playerLight"].Position = Location().toMogre; lights["playerLight"].DiffuseColour = ColourValue.White; lights["playerLight"].SpecularColour = ColourValue.White; #region drone OgreWindow.Instance.skeletons["\\Drone.skeleton"].Load(); OgreWindow.Instance.meshes["\\Drone.mesh"].Load(); OgreWindow.Instance.meshes["\\Drone.mesh"].SkeletonName = "\\Drone.skeleton"; entities.Add(OgreWindow.Instance.mSceneMgr.CreateEntity("drone", "\\Drone.mesh")); entities["drone"].CastShadows = true; walkState = entities["drone"].GetAnimationState("walk"); walkState.Enabled = true; walkState.Loop = true; entities["drone"].SetMaterialName("metal"); nodes.Add(OgreWindow.Instance.mSceneMgr.RootSceneNode.CreateChildSceneNode("drone")); nodes["drone"].AttachObject(entities["drone"]); nodes["drone"].Position = new Mogre.Vector3(0f, 40f, 0f) + Location().toMogre; nodes["drone"].Scale(new Mogre.Vector3(.3f)); nodes.Add(nodes["drone"].CreateChildSceneNode("orbit0")); nodes.Add(nodes["orbit0"].CreateChildSceneNode("orbit")); nodes["orbit"].Position = Location().toMogre; nodes["orbit"].AttachObject(OgreWindow.Instance.mCamera); nodes["drone"].SetFixedYawAxis(true); #endregion //#region baseball //entities.Add(OgreWindow.Instance.mSceneMgr.CreateEntity("baseball", "\\baseball.mesh")); //entities["baseball"].SetMaterialName("baseball"); ////nodes.Add(OgreWindow.Instance.mSceneMgr.RootSceneNode.CreateChildSceneNode("baseball")); //nodes.Add(nodes["drone"].CreateChildSceneNode("baseball")); //nodes["baseball"].AttachObject(entities["baseball"]); //nodes["baseball"].SetScale(.5f, .5f, .5f); //nodes["baseball"].SetPosition(-3f, 7f, 3f); //// nodes["baseball"].SetScale(5f, 5f, 5f); //#endregion #region player physics bcd = new BoxControllerDesc(); control = OgreWindow.Instance.physics.ControllerManager.CreateController(OgreWindow.Instance.scene, bcd); //System.NullReferenceException #endregion nodes.Add(OgreWindow.Instance.mSceneMgr.RootSceneNode.CreateChildSceneNode("suspensionY")); OgreWindow.g_m.MouseMoved += new MouseListener.MouseMovedHandler(mouseMoved); middlemousetimer.reset(); middlemousetimer.start(); this.btnLimiter_F.reset(); this.btnLimiter_F.start(); ready = true; new Thread(new ThreadStart(controlThread)).Start(); new Thread(new ThreadStart(statusUpdaterThread)).Start(); localY = nodes["drone"]._getDerivedOrientation() * Mogre.Vector3.UNIT_Y; localZ = nodes["drone"]._getDerivedOrientation() * Mogre.Vector3.UNIT_Z; localX = nodes["drone"]._getDerivedOrientation() * Mogre.Vector3.UNIT_X; OgreWindow.Instance.tbTextToSend.GotFocus += new EventHandler(tbTextToSend_GotFocus); OgreWindow.Instance.tbTextToSend.LostFocus += new EventHandler(tbTextToSend_LostFocus); OgreWindow.Instance.tbConsole.GotFocus += new EventHandler(tbConsole_GotFocus); OgreWindow.Instance.tbConsole.LostFocus += new EventHandler(tbConsole_LostFocus); }
/// <summary> /// Constructs a new physics actor. /// </summary> /// <param name="desc">Descriptor for the actor.</param> public StaticBEPUActor(ActorDesc desc) : base(desc) { // Build all shapes that make up the actor. for (int i = 0; i < desc.Shapes.Count; ++i) { ShapeDesc shapeDesc = desc.Shapes[i]; var tag = new EntityTag(this.ownerEntityID); if (shapeDesc is BoxShapeDesc) { var boxDesc = shapeDesc as BoxShapeDesc; this.body.PhysicsEntity = new Box(desc.Position, boxDesc.Extents.X, boxDesc.Extents.Y, boxDesc.Extents.Z); } else if (shapeDesc is SphereShapeDesc) { var sphereDesc = shapeDesc as SphereShapeDesc; this.body.PhysicsEntity = new Sphere(desc.Position, sphereDesc.Radius); } else if (shapeDesc is CapsuleShapeDesc) { var capDesc = shapeDesc as CapsuleShapeDesc; this.body.PhysicsEntity = new Capsule(desc.Position, capDesc.Length, capDesc.Radius); } else if (shapeDesc is CylinderShapeDesc) { var cylDesc = shapeDesc as CylinderShapeDesc; this.body.PhysicsEntity = new Cylinder(desc.Position, cylDesc.Height, cylDesc.Radius); } else if (shapeDesc is TriangleMeshShapeDesc) { var triDesc = shapeDesc as TriangleMeshShapeDesc; this.collidable = new StaticMesh(triDesc.Vertices.ToArray(), triDesc.Indices.ToArray(), new AffineTransform(Quaternion.CreateFromRotationMatrix(desc.Orientation), desc.Position)); this.collidable.Tag = tag; this.spaceObject = this.collidable; } else if (shapeDesc is HeightFieldShapeDesc) { throw new Exception("To load terrain physics you must use a TerrainBEPUActor."); } else { throw new Exception("Bad shape."); } if (null != this.body.PhysicsEntity) { SetMovable(false); this.body.PhysicsEntity.Tag = tag; this.body.PhysicsEntity.CollisionInformation.Tag = tag; this.spaceObject = this.body.PhysicsEntity; } } if (this.body.PhysicsEntity != null) { this.spaceObject = this.body.PhysicsEntity; this.body.PhysicsEntity.BecomeKinematic(); this.body.PhysicsEntity.IsAffectedByGravity = desc.Dynamic; } Debug.Assert(this.spaceObject != null, "A physics entity was not properly created."); }