Main simulation class of BEPUphysics. Contains various updating stages addition/removal methods for getting objects into the simulation.
コード例 #1
0
        public override void Initialize()
        {
            Children = new System.Collections.Generic.List<Aperture3D.Base.INode>();
            physicsSpace = new Space();

            Initialized = true;
        }
コード例 #2
0
ファイル: CollisionUtil.cs プロジェクト: Morphan1/Voxalia
 public CollisionUtil(Space world)
 {
     World = world;
     // NonSolid Vs. Solid,NonSolid,WorldSolid (All)
     CollisionGroup.DefineCollisionRule(NonSolid, WorldSolid, CollisionRule.NoBroadPhase);
     CollisionGroup.DefineCollisionRule(WorldSolid, NonSolid, CollisionRule.NoBroadPhase);
     CollisionGroup.DefineCollisionRule(NonSolid, NonSolid, CollisionRule.NoBroadPhase);
     CollisionGroup.DefineCollisionRule(NonSolid, Solid, CollisionRule.NoBroadPhase);
     CollisionGroup.DefineCollisionRule(Solid, NonSolid, CollisionRule.NoBroadPhase);
     // Player Vs. NonSolid,Player
     CollisionGroup.DefineCollisionRule(Player, NonSolid, CollisionRule.NoBroadPhase);
     CollisionGroup.DefineCollisionRule(NonSolid, Player, CollisionRule.NoBroadPhase);
     CollisionGroup.DefineCollisionRule(Player, Player, CollisionRule.NoBroadPhase);
     // Item Vs. NonSolid (All)
     CollisionGroup.DefineCollisionRule(Item, NonSolid, CollisionRule.NoBroadPhase);
     CollisionGroup.DefineCollisionRule(NonSolid, Item, CollisionRule.NoBroadPhase);
     // Water Vs. NonSolid,Solid,Player,Item (All)
     CollisionGroup.DefineCollisionRule(Water, NonSolid, CollisionRule.NoBroadPhase);
     CollisionGroup.DefineCollisionRule(NonSolid, Water, CollisionRule.NoBroadPhase);
     CollisionGroup.DefineCollisionRule(Water, Solid, CollisionRule.NoBroadPhase);
     CollisionGroup.DefineCollisionRule(Solid, Water, CollisionRule.NoBroadPhase);
     CollisionGroup.DefineCollisionRule(Water, Player, CollisionRule.NoBroadPhase);
     CollisionGroup.DefineCollisionRule(Player, Water, CollisionRule.NoBroadPhase);
     CollisionGroup.DefineCollisionRule(Water, Item, CollisionRule.NoBroadPhase);
     CollisionGroup.DefineCollisionRule(Item, Water, CollisionRule.NoBroadPhase);
     // Non-player Character Vs. NonSolid,Item,Water
     CollisionGroup.DefineCollisionRule(Character, NonSolid, CollisionRule.NoBroadPhase);
     CollisionGroup.DefineCollisionRule(NonSolid, Character, CollisionRule.NoBroadPhase);
     CollisionGroup.DefineCollisionRule(Character, Water, CollisionRule.NoBroadPhase);
     CollisionGroup.DefineCollisionRule(Water, Character, CollisionRule.NoBroadPhase);
     CollisionGroup.DefineCollisionRule(Character, Item, CollisionRule.NoBroadPhase);
     CollisionGroup.DefineCollisionRule(Item, Character, CollisionRule.NoBroadPhase);
 }
コード例 #3
0
        /// <summary>
        /// Constructs a new demo.
        /// </summary>
        /// <param name="game">Game owning this demo.</param>
        public ParallelSpaceTestDemo(DemosGame game)
            : base(game)
        {
            for (int i = 0; i < 32; i++)
            {
                var space = new Space(null);
                space.ForceUpdater.Gravity = new Vector3(0, -9.81f, 0);
                var box = new Box(new Vector3(20 * i, 0, 0), 100, 1, 100);
                space.Add(box);
                //game.ModelDrawer.Add(box);
                for (int j = 0; j < 30; j++)
                {
                    for (int k = 0; k < 10; k++)
                    {
                        box = new Box(new Vector3(20 * i, 2 + j * 1.1f, 0), 1, 1, 1, 1);
                        entities.Add(box);
                        space.Add(box);
                        //game.ModelDrawer.Add(box);
                    }
                }
                spaces.Add(space);
            }
            game.Camera.Position = new Vector3(20, 10, 70);

        }
コード例 #4
0
ファイル: ObstacleDetector.cs プロジェクト: thormme/Chimera
        /// <summary>
        /// Determines whether there is a cliff nearby.
        /// </summary>
        /// <param name="position">Position to look from.</param>
        /// <param name="facingDirection">Direction to check in.</param>
        /// <param name="filter">Anonymous function to filter out unwanted objects.</param>
        /// <param name="space">The space to check for a cliff in.</param>
        /// <param name="distance">The distance to check at.</param>
        /// <returns>True if a cliff was detected, false otherwise.</returns>
        public static bool FindCliff(Vector3 position, Vector3 facingDirection, Func<BroadPhaseEntry, bool> filter, Space space, float distance)
        {
            // If there is a wall before the requested distance assume there is no cliff.
            Ray forwardRay = new Ray(position, new Vector3(facingDirection.X, 0, facingDirection.Z));
            RayCastResult forwardResult = new RayCastResult();
            space.RayCast(forwardRay, filter, out forwardResult);
            if ((forwardResult.HitData.Location - position).Length() < distance)
            {
                return false;
            }

            facingDirection.Normalize();
            Ray futureDownRay = new Ray(position + new Vector3(facingDirection.X * distance, 0, facingDirection.Z * distance), Vector3.Down);
            RayCastResult result = new RayCastResult();
            space.RayCast(futureDownRay, filter, out result);

            Vector3 drop = result.HitData.Location - futureDownRay.Position;
            if (drop.Y < -6.0f)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
コード例 #5
0
        /// <summary>
        /// Scales the configuration settings for collision detection and response to handle
        /// a different scale interpretation.  For example, if you want to increase your gravity to -100 from -10 and consider a 5 unit wide box to be tiny,
        /// apply a scale of 10 to get the collision response and detection systems to match expectations.
        /// </summary>
        /// <param name="space">Space to configure.</param>
        /// <param name="scale">Scale to apply to relevant configuration settings.</param>
        public static void ApplyScale(BEPUphysics.Space space, float scale)
        {
            //Set all values to default values * scale.
            space.DeactivationManager.VelocityLowerLimit = 0.26f * scale;
            CollisionResponseSettings.MaximumPenetrationRecoverySpeed   = 2 * scale;
            CollisionResponseSettings.BouncinessVelocityThreshold       = 1 * scale;
            CollisionResponseSettings.StaticFrictionVelocityThreshold   = .2f * scale;
            CollisionDetectionSettings.ContactInvalidationLength        = .1f * scale;
            CollisionDetectionSettings.ContactMinimumSeparationDistance = .03f * scale;
            CollisionDetectionSettings.MaximumContactDistance           = .1f * scale;
            CollisionDetectionSettings.DefaultMargin      = .04f * scale;
            CollisionDetectionSettings.AllowedPenetration = .01f * scale;

            //Adjust epsilons, too.
            Toolbox.Epsilon    = 1e-7f * scale;
            Toolbox.BigEpsilon = 1e-5f * scale;
            MPRToolbox.DepthRefinementEpsilon      = 1e-4f * scale;
            MPRToolbox.RayCastSurfaceEpsilon       = 1e-9f * scale;
            MPRToolbox.SurfaceEpsilon              = 1e-7f * scale;
            PairSimplex.DistanceConvergenceEpsilon = 1e-7f * scale;
            PairSimplex.ProgressionEpsilon         = 1e-8f * scale;

            //While not fully a size-related parameter, you may find that adjusting the SolverSettings.DefaultMinimumImpulse can help the simulation quality.
            //It is related to 'mass scale' instead of 'size scale.'
            //Heavy or effectively heavy objects will produce higher impulses and early out slower, taking more time than needed.
            //Light or effectively light objects will produce smaller impulses and early out faster, producing a lower quality result.
        }
コード例 #6
0
        /// <summary>
        /// Applies the default settings to the space.
        /// These values are what the engine starts with; they don't have to be applied unless you just want to get back to the defaults.
        /// This doesn't cover every single tunable field in the entire engine, just the main ones that this helper class is messing with.
        /// </summary>
        /// <param name="space">Space to configure.</param>
        public static void ApplyDefaultSettings(BEPUphysics.Space space)
        {
            MotionSettings.DefaultPositionUpdateMode    = PositionUpdateMode.Discrete;
            SolverSettings.DefaultMinimumIterationCount = 1;
            space.Solver.IterationLimit = 10;
            GeneralConvexPairTester.UseSimplexCaching = false;
            MotionSettings.UseExtraExpansionForContinuousBoundingBoxes = false;

            //Set all the scaling settings back to their defaults.
            space.DeactivationManager.VelocityLowerLimit = 0.26f;
            CollisionResponseSettings.MaximumPenetrationRecoverySpeed   = 2;
            CollisionResponseSettings.BouncinessVelocityThreshold       = 1;
            CollisionResponseSettings.StaticFrictionVelocityThreshold   = .2f;
            CollisionDetectionSettings.ContactInvalidationLength        = .1f;
            CollisionDetectionSettings.ContactMinimumSeparationDistance = .03f;
            CollisionDetectionSettings.MaximumContactDistance           = .1f;
            CollisionDetectionSettings.DefaultMargin      = .04f;
            CollisionDetectionSettings.AllowedPenetration = .01f;
            SolverSettings.DefaultMinimumImpulse          = 0.001f;

            //Adjust epsilons back to defaults.
            Toolbox.Epsilon    = 1e-7f;
            Toolbox.BigEpsilon = 1e-5f;
            MPRToolbox.DepthRefinementEpsilon      = 1e-4f;
            MPRToolbox.RayCastSurfaceEpsilon       = 1e-9f;
            MPRToolbox.SurfaceEpsilon              = 1e-7f;
            PairSimplex.DistanceConvergenceEpsilon = 1e-7f;
            PairSimplex.ProgressionEpsilon         = 1e-8f;
        }
コード例 #7
0
 /// <summary>
 /// Applies some high quality, low performance settings.
 /// By using universal continuous collision detection, missed collisions
 /// will be much, much rarer.  This actually doesn't have a huge performance cost.
 /// However, increasing the iteration limit and the minimum iterations to 5x the default
 /// will incur a pretty hefty overhead.
 /// On the upside, pretty much every simulation will be rock-solid.
 /// </summary>
 /// <param name="space">Space to configure.</param>
 public static void ApplyHighStabilitySettings(BEPUphysics.Space space)
 {
     MotionSettings.DefaultPositionUpdateMode = PositionUpdateMode.Continuous;
     MotionSettings.UseExtraExpansionForContinuousBoundingBoxes = true;
     SolverSettings.DefaultMinimumIterationCount = 5;
     space.Solver.IterationLimit = 50;
 }
コード例 #8
0
 public PhysicsSimulationComponent(Entity parent)
     : base(parent, "PhysicsSimulationComponent")
 {
     space = new Space();
     space.ForceUpdater.Gravity = GRAVITY;
     space.TimeStepSettings.TimeStepDuration = TIME_STEP_DURATION;
 }
コード例 #9
0
        public void Draw(Effect effect, Space space)
        {
            contactLines.Clear();
            int contactCount = 0;
            foreach (var pair in space.NarrowPhase.Pairs)
            {
                var pairHandler = pair as CollidablePairHandler;
                if (pairHandler != null)
                {
                    foreach (ContactInformation information in pairHandler.Contacts)
                    {
                        contactCount++;
                        contactLines.Add(new VertexPositionColor(information.Contact.Position, Color.White));
                        contactLines.Add(new VertexPositionColor(information.Contact.Position + information.Contact.Normal * information.Contact.PenetrationDepth, Color.Red));
                        contactLines.Add(new VertexPositionColor(information.Contact.Position + information.Contact.Normal * information.Contact.PenetrationDepth, Color.White));
                        contactLines.Add(new VertexPositionColor(information.Contact.Position + information.Contact.Normal * (information.Contact.PenetrationDepth + .3f), Color.White));
                    }
                }
            }

            if (contactCount > 0)
            {
                foreach (var pass in effect.CurrentTechnique.Passes)
                {
                    pass.Apply();

                    game.GraphicsDevice.DrawUserPrimitives(PrimitiveType.LineList, contactLines.Elements, 0, contactLines.Count / 2);
                }
            }

        }
コード例 #10
0
        protected Demo(DemosGame game)
        {
            Game = game;
            parallelLooper = new ParallelLooper();
            //This section lets the engine know that it can make use of multithreaded systems
            //by adding threads to its thread pool.
            #if XBOX360
            parallelLooper.AddThread(delegate { Thread.CurrentThread.SetProcessorAffinity(new[] { 1 }); });
            parallelLooper.AddThread(delegate { Thread.CurrentThread.SetProcessorAffinity(new[] { 3 }); });
            parallelLooper.AddThread(delegate { Thread.CurrentThread.SetProcessorAffinity(new[] { 4 }); });
            parallelLooper.AddThread(delegate { Thread.CurrentThread.SetProcessorAffinity(new[] { 5 }); });

            #else
            if (Environment.ProcessorCount > 1)
            {
                for (int i = 0; i < Environment.ProcessorCount; i++)
                {
                    parallelLooper.AddThread();
                }
            }
            #endif

            Space = new Space(parallelLooper);

            game.Camera.LockedUp = Vector3.Up;
            game.Camera.ViewDirection = new Vector3(0, 0, -1);
        }
コード例 #11
0
ファイル: Explosion.cs プロジェクト: Raverenx/GameEngine
 /// <summary>
 /// Constructs an explosion.
 /// </summary>
 /// <param name="pos">Initial position of the explosion.</param>
 /// <param name="explosionMagnitude">Base strength of the blast as applied in units of impulse.</param>
 /// <param name="maxDist">Maximum radius of effect.</param>
 /// <param name="containingSpace">Space in which the explosion resides.</param>
 public Explosion(Vector3 pos, float explosionMagnitude, float maxDist, Space containingSpace)
 {
     Position = pos;
     Magnitude = explosionMagnitude;
     MaxDistance = maxDist;
     Space = containingSpace;
 }
コード例 #12
0
        // _divisions is the divisions in one direction / 2
        public CollisionManager(int _width, int _height, int _depth, int _divisions)
        {
            width = _width;
            height = _height;
            depth = _depth;
            divisions = _divisions * _divisions * _divisions;

            toAdd = new LinkedList<CollisionBase>();
            toRemove = new LinkedList<CollisionBase>();

            /*#if DEBUG
            drawList = new List<SceneObject>();
            #endif*/

            space = new Space();
            space.Solver.AllowMultithreading = true;
            space.Solver.IterationLimit = 1;

            Vector3 offset = new Vector3(-_width / 2, -_height / 2, -_depth / 2);

            sectors = new CollisionSector[divisions]; // Though we use _divisions for calculating
            for (int i = 0; i < _divisions; i++)
            {
                for (int j = 0; j < _divisions; j++)
                {
                    for (int l = 0; l < _divisions; l++)
                    {
                        int x = ((i * width) / (2 * _divisions)) + (width / _divisions);
                        int y = ((j * height) / (2 * _divisions)) + (height / _divisions);
                        int z = ((l * depth) / (2 * _divisions)) + (depth / _divisions);
                        sectors[i*_divisions*_divisions + j*_divisions + l] = new CollisionSector(offset + new Vector3(x, y, z), width / _divisions, height / _divisions, depth / _divisions);
                    }
                }
            }
        }
コード例 #13
0
        public PhysicsQB()
        {
            if (threadManager == null)
            {
                threadManager = new BEPUphysics.Threading.SpecializedThreadManager();
                //This section lets the engine know that it can make use of multithreaded systems
                //by adding threads to its thread pool.
            #if XBOX360
            threadManager.AddThread(delegate { Thread.CurrentThread.SetProcessorAffinity(new[] { 1 }); }, null);
            threadManager.AddThread(delegate { Thread.CurrentThread.SetProcessorAffinity(new[] { 3 }); }, null);
            threadManager.AddThread(delegate { Thread.CurrentThread.SetProcessorAffinity(new[] { 4 }); }, null);
            //threadManager.AddThread(delegate { Thread.CurrentThread.SetProcessorAffinity(new[] { 5 }); }, null);

            #else
                if (Environment.ProcessorCount > 1)
                {
                    for (int i = 0; i < Environment.ProcessorCount; i++)
                    {
                        threadManager.AddThread();
                    }
                }
            #endif
            }

            space = new Space(threadManager);
        }
コード例 #14
0
 /// <summary>
 /// Applies some high quality, low performance settings.
 /// By using universal continuous collision detection, missed collisions
 /// will be much, much rarer.  This actually doesn't have a huge performance cost.
 /// However, increasing the iteration limit and the minimum iterations to 5x the default
 /// will incur a pretty hefty overhead.
 /// On the upside, pretty much every simulation will be rock-solid.
 /// </summary>
 /// <param name="space">Space to configure.</param>
 public static void ApplyHighStabilitySettings(Space space)
 {
     MotionSettings.DefaultPositionUpdateMode = PositionUpdateMode.Continuous;
     MotionSettings.UseExtraExpansionForContinuousBoundingBoxes = true;
     SolverSettings.DefaultMinimumIterations = 5;
     space.Solver.IterationLimit = 50;
 }
コード例 #15
0
 public void AddToSpace(Space space)
 {
     LeftTread.AddToSpace(space);
     RightTread.AddToSpace(space);
     Turret.AddToSpace(space);
     space.Add(Body);
 }
コード例 #16
0
 public void RemoveFromSpace(Space space)
 {
     LeftTread.RemoveFromSpace(space);
     RightTread.RemoveFromSpace(space);
     Turret.RemoveFromSpace(space);
     space.Remove(Body);
 }
コード例 #17
0
ファイル: Physics.cs プロジェクト: d3x0r/Voxelarium
		public void Dispose()
		{
			foreach( Sector sector in active_sectors )
				world.Remove( sector.grid );
			active_sectors = null;
			world = null;
		}
コード例 #18
0
        /// <summary>
        /// Applies the default settings to the space.
        /// These values are what the engine starts with; they don't have to be applied unless you just want to get back to the defaults.
        /// This doesn't cover every single tunable field in the entire engine, just the main ones that this helper class is messing with.
        /// </summary>
        /// <param name="space">Space to configure.</param>
        public static void ApplyDefaultSettings(Space space)
        {
            MotionSettings.DefaultPositionUpdateMode = PositionUpdateMode.Discrete;
            SolverSettings.DefaultMinimumIterationCount = 1;
            space.Solver.IterationLimit = 10;
            GeneralConvexPairTester.UseSimplexCaching = false;
            MotionSettings.UseExtraExpansionForContinuousBoundingBoxes = false;

            //Set all the scaling settings back to their defaults.
            space.DeactivationManager.VelocityLowerLimit = 0.26f;
            CollisionResponseSettings.MaximumPenetrationRecoverySpeed = 2;
            CollisionResponseSettings.BouncinessVelocityThreshold = 1;
            CollisionResponseSettings.StaticFrictionVelocityThreshold = .2f;
            CollisionDetectionSettings.ContactInvalidationLength = .1f;
            CollisionDetectionSettings.ContactMinimumSeparationDistance = .03f;
            CollisionDetectionSettings.MaximumContactDistance = .1f;
            CollisionDetectionSettings.DefaultMargin = .04f;
            CollisionDetectionSettings.AllowedPenetration = .01f;
            SolverSettings.DefaultMinimumImpulse = 0.001f;

            //Adjust epsilons back to defaults.
            Toolbox.Epsilon = 1e-7f;
            Toolbox.BigEpsilon = 1e-5f;
            MPRToolbox.DepthRefinementEpsilon = 1e-4f;
            MPRToolbox.RayCastSurfaceEpsilon = 1e-9f;
            MPRToolbox.SurfaceEpsilon = 1e-7f;
            PairSimplex.DistanceConvergenceEpsilon = 1e-7f;
            PairSimplex.ProgressionEpsilon = 1e-8f;

        }
コード例 #19
0
        internal PhysicsManager()
        {
            instance = this;

            parallelLooper = new ParallelLooper();
            //This section lets the engine know that it can make use of multithreaded systems
            //by adding threads to its thread pool.
#if XBOX360
            parallelLooper.AddThread(delegate { Thread.CurrentThread.SetProcessorAffinity(new[] { 1 }); });
            parallelLooper.AddThread(delegate { Thread.CurrentThread.SetProcessorAffinity(new[] { 3 }); });
            parallelLooper.AddThread(delegate { Thread.CurrentThread.SetProcessorAffinity(new[] { 4 }); });
            parallelLooper.AddThread(delegate { Thread.CurrentThread.SetProcessorAffinity(new[] { 5 }); });
#else
            if (Environment.ProcessorCount > 1)
            {
                for (int i = 0; i < Environment.ProcessorCount; i++)
                {
                    parallelLooper.AddThread();
                }
            }
#endif

            Space = new BEPUphysics.Space(parallelLooper);
            Space.ForceUpdater.Gravity = new Vector3(0, -9.81f, 0f);

            Space.TimeStepSettings.MaximumTimeStepsPerFrame = 100;


            //Set up two stacks which go through each other
            firstStackGroup  = new CollisionGroup();
            secondStackGroup = new CollisionGroup();
            //Adding this rule to the space's collision group rules will prevent entities belong to these two groups from generating collision pairs with each other.
            var groupPair = new CollisionGroupPair(firstStackGroup, secondStackGroup);
            //CollisionRules.CollisionGroupRules.Add(groupPair, CollisionRule.NoBroadPhase);
        }
コード例 #20
0
        /// <summary>
        /// Constructs the character and internal physics character controller.
        /// </summary>
        /// <param name="owningSpace">Space to add the character to.</param>
        /// <param name="camera">Camera to attach to the character.</param>
        /// <param name="game">The running game.</param>
        public CharacterControllerInput(Space owningSpace, Camera camera, DemosGame game)
        {
            CharacterController = new CharacterController();
            Camera = camera;
            CameraControlScheme = new CharacterCameraControlScheme(CharacterController, camera, game);

            Space = owningSpace;
        }
コード例 #21
0
        /// <summary>
        /// Constructs the character and internal physics character controller.
        /// </summary>
        /// <param name="owningSpace">Space to add the character to.</param>
        /// <param name="camera">Camera to attach to the character.</param>
        /// <param name="game">The running game.</param>
        public SphereCharacterControllerInput(Space owningSpace, Camera camera, DemosGame game)
        {
            CharacterController = new SphereCharacterController();
            Camera = camera;
            CameraControlScheme = new FixedOffsetCameraControlScheme(CharacterController.Body, camera, game);

            Space = owningSpace;
        }
コード例 #22
0
ファイル: Sector.cs プロジェクト: Aryn/Mobile-Fortress
 public void Initialize()
 {
     Space = new Space();
     Space.ForceUpdater.Gravity = new Vector3(0, -9.8f, 0);
     Terrain = new TerrainManager();
     ClientObjects = new EffectManager();
     Ships = new ShipManager();
     Objects = new MobileObjectManager();
 }
コード例 #23
0
ファイル: ModifiableLevel.cs プロジェクト: thormme/Chimera
 public ModifiableLevel(Level level, Space space)
     : base(level.Name)
 {
     mSpace = space;
     foreach (Vector3 block in level.Blocks.Keys)
     {
         AddNewBlock(block);
     }
 }
コード例 #24
0
        /// <summary>
        /// Constructs the character and internal physics character controller.
        /// </summary>
        /// <param name="owningSpace">Space to add the character to.</param>
        /// <param name="cameraToUse">Camera to attach to the character.</param>
        public CharacterControllerInput(Space owningSpace, Camera cameraToUse)
        {
            CharacterController = new CharacterController();

            Space = owningSpace;
            Space.Add(CharacterController);

            Camera = cameraToUse;
            Deactivate();
        }
コード例 #25
0
ファイル: PhysicsManager.cs プロジェクト: clashbyte/openvice
		/// <summary>
		/// Inititalize physics engine<para/>
		/// Инициализация физического движка
		/// </summary>
		public static void Init() {

			// Create simulation
			// Создание симуляции
			World = new Space();
			World.ForceUpdater.Gravity = new BEPUutilities.Vector3(0, -9.81f, 0);
			BEPUphysics.Settings.CollisionDetectionSettings.DefaultMargin = 0f;
			BEPUphysics.Settings.CollisionDetectionSettings.AllowedPenetration = 0f;
			//BEPUphysics.Settings.CollisionResponseSettings.PenetrationRecoveryStiffness = 0.005f;
		}
コード例 #26
0
 public BepuPhysicsSystem(Game game)
     : base(game)
 {
     this.looper = new BEPUutilities.Threading.ParallelLooper();
     for (int g = 0; g < Environment.ProcessorCount - 1; g++)
     {
         this.looper.AddThread();
     }
     this.space = new Space(this.looper);
 }
コード例 #27
0
        /// <summary>
        /// Constructs the character and internal physics character controller.
        /// </summary>
        /// <param name="owningSpace">Space to add the character to.</param>
        /// <param name="CameraToUse">Camera to attach to the character.</param>
        public CharacterControllerInputOld(Space owningSpace, Camera CameraToUse)
        {
            CharacterController = new CharacterControllerOld(Vector3.Zero, 2, .4f, 30f, 1.1f);

            Space = owningSpace;
            Space.Add(CharacterController);

            Camera = CameraToUse;
            Deactivate();
        }
コード例 #28
0
        /// <summary>
        /// Constructs the character and internal physics character controller.
        /// </summary>
        /// <param name="owningSpace">Space to add the character to.</param>
        /// <param name="CameraToUse">Camera to attach to the character.</param>
        public SimpleCharacterControllerInput(Space owningSpace, Camera CameraToUse)
        {
            CharacterController = new SimpleCharacterController(Vector3.Zero, 2, .8f, 1f, 20);

            Space = owningSpace;
            Space.Add(CharacterController);

            Camera = CameraToUse;
            Deactivate();
        }
コード例 #29
0
    public override void XStart()
    {
        nonMonoPhysics   = new List <NonMonoBehaviorPhysics> ();
        dynamicColliders = new List <PhysicsBehaviourX>();
        staticColliders  = new List <PhysicsBehaviourX>();

        _physicsSpace = new BEPUphysics.Space();
        _physicsSpace.ForceUpdater.Gravity              = Gravity.ToBEPU();
        _physicsSpace.BufferedStates.Enabled            = BufferedStates;
        _physicsSpace.Solver.IterationLimit             = IterationLimit; //Don't need many iterations, there's not really any stacking going on in this game.
        _physicsSpace.TimeStepSettings.TimeStepDuration = TimeStep;       //A slower timestep gives the Xbox a little breathing
    }
コード例 #30
0
        public void Draw(Effect effect, Space space)
        {
            if (space.Entities.Count > 0)
            {

                foreach (var e in space.Entities)
                {
                    Vector3[] boundingBoxCorners = MathConverter.Convert(e.CollisionInformation.BoundingBox.GetCorners());
                    var color = e.ActivityInformation.IsActive ? Color.DarkRed : new Color(150, 100, 100);
                    boundingBoxLines.Add(new VertexPositionColor(boundingBoxCorners[0], color));
                    boundingBoxLines.Add(new VertexPositionColor(boundingBoxCorners[1], color));

                    boundingBoxLines.Add(new VertexPositionColor(boundingBoxCorners[0], color));
                    boundingBoxLines.Add(new VertexPositionColor(boundingBoxCorners[3], color));

                    boundingBoxLines.Add(new VertexPositionColor(boundingBoxCorners[0], color));
                    boundingBoxLines.Add(new VertexPositionColor(boundingBoxCorners[4], color));

                    boundingBoxLines.Add(new VertexPositionColor(boundingBoxCorners[1], color));
                    boundingBoxLines.Add(new VertexPositionColor(boundingBoxCorners[2], color));

                    boundingBoxLines.Add(new VertexPositionColor(boundingBoxCorners[1], color));
                    boundingBoxLines.Add(new VertexPositionColor(boundingBoxCorners[5], color));

                    boundingBoxLines.Add(new VertexPositionColor(boundingBoxCorners[2], color));
                    boundingBoxLines.Add(new VertexPositionColor(boundingBoxCorners[3], color));

                    boundingBoxLines.Add(new VertexPositionColor(boundingBoxCorners[2], color));
                    boundingBoxLines.Add(new VertexPositionColor(boundingBoxCorners[6], color));

                    boundingBoxLines.Add(new VertexPositionColor(boundingBoxCorners[3], color));
                    boundingBoxLines.Add(new VertexPositionColor(boundingBoxCorners[7], color));

                    boundingBoxLines.Add(new VertexPositionColor(boundingBoxCorners[4], color));
                    boundingBoxLines.Add(new VertexPositionColor(boundingBoxCorners[5], color));

                    boundingBoxLines.Add(new VertexPositionColor(boundingBoxCorners[4], color));
                    boundingBoxLines.Add(new VertexPositionColor(boundingBoxCorners[7], color));

                    boundingBoxLines.Add(new VertexPositionColor(boundingBoxCorners[5], color));
                    boundingBoxLines.Add(new VertexPositionColor(boundingBoxCorners[6], color));

                    boundingBoxLines.Add(new VertexPositionColor(boundingBoxCorners[6], color));
                    boundingBoxLines.Add(new VertexPositionColor(boundingBoxCorners[7], color));
                }
                foreach (var pass in effect.CurrentTechnique.Passes)
                {
                    pass.Apply();
                    game.GraphicsDevice.DrawUserPrimitives(PrimitiveType.LineList, boundingBoxLines.Elements, 0, space.Entities.Count * 12);
                }
                boundingBoxLines.Clear();
            }
        }
コード例 #31
0
ファイル: Explosion.cs プロジェクト: ravduke/Tank-Wars
        /// <summary>
        /// Constructs an explosion.
        /// </summary>
        /// <param name="pos">Initial position of the explosion.</param>
        /// <param name="explosionMagnitude">Base strength of the blast as applied in units of impulse.</param>
        /// <param name="maxDist">Maximum radius of effect.</param>
        /// <param name="containingSpace">Space in which the explosion resides.</param>
        public Explosion(Entity entity, float explosionMagnitude, float maxDist, Space containingSpace, Game game)
            : base(game)
        {
            this.entity = entity;
            Position = entity.WorldTransform.Translation;
            Magnitude = explosionMagnitude;
            MaxDistance = maxDist;
            Space = containingSpace;

            explosionParticles = Game.Services.GetService(typeof(ExplosionParticleSystem)) as ExplosionParticleSystem;
            explosionSmokeParticles = Game.Services.GetService(typeof(ExplosionSmokeParticleSystem)) as ExplosionSmokeParticleSystem;
        }
コード例 #32
0
ファイル: ActorContainer.cs プロジェクト: slicedpan/demo
 public ActorContainer(Space space, ModelDrawer modelDrawer, LineDrawer constraintDrawer, LightDrawer lightDrawer)
 {
     _space = space;
     _meshes = new List<LPPMesh>();
     _deleteList = new List<Actor>();
     _actors = new List<Actor>();
     _components = new List<Component>();
     _modelDrawer = modelDrawer;
     _constraintDrawer = constraintDrawer;
     _lightDrawer = lightDrawer;
     _actorDictionary = new Dictionary<string, Actor>();
     Content = Game1.thegame.Content;
 }
コード例 #33
0
        protected override void Initialize()
        {
            Space = new Physics.Space(new Physics.PersistentUniformGrid(10));
            Space.simulationSettings.gravity = new Vector3(0, -9.81f, 0);

            FMOD.Factory.System_Create(ref SoundSystem);
            SoundSystem.init(32, FMOD.INITFLAG.NORMAL, (IntPtr)null);

            InitializeModules();
            InitializeBehaviors();

            base.Initialize();
        }
コード例 #34
0
        protected override void Initialize()
        {
            Space = new Physics.Space(new Physics.PersistentUniformGrid(10));
            Space.simulationSettings.gravity = new Vector3(0, -9.81f, 0);

            FMOD.Factory.System_Create(ref SoundSystem);
            SoundSystem.init(32, FMOD.INITFLAG.NORMAL, (IntPtr)null);

            InitializeModules();
            InitializeBehaviors();

            base.Initialize();
        }
コード例 #35
0
ファイル: Characters.cs プロジェクト: demiurghg/ShooterDemo
		/// <summary>
		/// 
		/// </summary>
		/// <param name="game"></param>
		/// <param name="space"></param>
		public Characters ( Entity entity, World world,
 			float height = 1.7f, 
			float crouchingHeight = 1.19f, 
			float radius = 0.6f, 
			float margin = 0.1f, 
			float mass = 10f, 
			float maximumTractionSlope = 0.8f, 
			float maximumSupportSlope = 1.3f, 
			float standingSpeed = 8f, 
			float crouchingSpeed = 3f, 
			float tractionForce = 1000f, 
			float slidingSpeed = 6f, 
			float slidingForce = 50f, 
			float airSpeed = 1f, 
			float airForce = 250f, 
			float jumpSpeed = 6f, 
			float slidingJumpSpeed = 3f, 
			float maximumGlueForce = 5000f ) : base(entity,world)
		{
			this.space	=	((MPWorld)world).PhysSpace;

			var pos = MathConverter.Convert( entity.Position );

			controller = new CharacterController( pos, 
					height					, 
					crouchingHeight			, 
					radius					, 
					margin					, 
					mass					,
					maximumTractionSlope	, 
					maximumSupportSlope		, 
					standingSpeed			,
					crouchingSpeed			,
					tractionForce			, 
					slidingSpeed			,
					slidingForce			,
					airSpeed				,
					airForce				, 
					jumpSpeed				, 
					slidingJumpSpeed		,
					maximumGlueForce		);


			controller.StepManager.MaximumStepHeight	=	0.5f;
			controller.Body.Tag	=	entity;
			controller.Tag		=	entity;

			space.Add( controller );
		}
コード例 #36
0
ファイル: Physics.cs プロジェクト: ravduke/Tank-Wars
        public Physics(Game game, Player player, ContentManager Content, TanksOnAHeightmap.GameBase.Shapes.Terrain terrain, Space space)
        {
            Cannon = new Cannon(game, player.tank);
            CannonBallManager = new CannonBallManager(game);
            EnemyCannon.playerTank = player.tank;

            healthManager = new HealthManager(game, space);
            this.Content = Content;
            this.Components = game.Components;
            this.game = game;
            this.player = player;
            this.tank = player.tank;
            this.terrain = terrain;
            this.space = space;
        }
コード例 #37
0
        /// <summary>
        /// Creates the physics scene and sets the defaults parameters.
        /// </summary>
        internal static void Initialize()
        {
            Scene = new Space();

            //  NOTE:PERFORMANCE
            //  BEPUphysics uses an iterative system to solve constraints.  You can tell it to do more or less iterations.
            //  Less iterations is faster; more iterations makes the result more accurate.
            //
            //  The amount of iterations needed for a simulation varies.  The "Wall" and "Pyramid" simulations are each fairly
            //  solver intensive, but as few as 4 iterations can be used with acceptable results.
            //  The "Jenga" simulation usually needs a few more iterations for stability; 7-9 is a good minimum.
            //
            //  The Dogbot demo shows how accuracy can smoothly increase with more iterations.
            //  With very few iterations (1-3), it has slightly jaggier movement, as if the parts used to construct it were a little cheap.
            //  As you give it a few more iterations, the motors and constraints get more and more robust.
            //
            //  Many simulations can work perfectly fine with very few iterations,
            //  and using a low number of iterations can substantially improve performance.
            //
            //  To change the number of iterations used, uncomment and change the following line (10 iterations is the default):
            Scene.Solver.IterationLimit = 10;

            // Setup multithreading
            #if XBOX360
            Scene.ThreadManager.AddThread(delegate(object information) { Thread.CurrentThread.SetProcessorAffinity(new int[] { 1 }); }, null);
            Scene.ThreadManager.AddThread(delegate(object information) { Thread.CurrentThread.SetProcessorAffinity(new int[] { 3 }); }, null);
            Scene.ThreadManager.AddThread(delegate(object information) { Thread.CurrentThread.SetProcessorAffinity(new int[] { 4 }); }, null);
            Scene.ThreadManager.AddThread(delegate(object information) { Thread.CurrentThread.SetProcessorAffinity(new int[] { 5 }); }, null);
            #else
            if (ProcessorsInformation.AvailableProcessors > 0)
            {
                // On windows, just throw a thread at every processor.
                // The thread scheduler will take care of where to put them.
                for (int i = 0; i < ProcessorsInformation.AvailableProcessors + 1; i++)
                {
                    Scene.ThreadManager.AddThread();
                }
            }
            #endif
        } // Initialize
コード例 #38
0
 /// <summary>
 /// Applies some higher quality settings.
 /// By using universal continuous collision detection, missed collisions
 /// will be much, much rarer.  This actually doesn't have a huge performance cost.
 /// The increased iterations put this as a midpoint between the normal and high stability settings.
 /// </summary>
 /// <param name="space">Space to configure.</param>
 public static void ApplyMediumHighStabilitySettings(BEPUphysics.Space space)
 {
     MotionSettings.DefaultPositionUpdateMode    = PositionUpdateMode.Continuous;
     SolverSettings.DefaultMinimumIterationCount = 2;
     space.Solver.IterationLimit = 15;
 }
コード例 #39
0
 /// <summary>
 /// Applies some low quality, high speed settings.
 /// The main benefit comes from the very low iteration cap.
 /// By enabling simplex caching, general convex collision detection
 /// gets a nice chunk faster, but some curved shapes lose collision detection robustness.
 /// </summary>
 /// <param name="space">Space to configure.</param>
 public static void ApplySuperSpeedySettings(BEPUphysics.Space space)
 {
     SolverSettings.DefaultMinimumIterationCount = 0;
     space.Solver.IterationLimit = 5;
     GeneralConvexPairTester.UseSimplexCaching = true;
 }