C# Vector3.AsPhysX方法代码示例

        public PhysxPhysicWorld(Vector3 gravity, bool connectToRemoteDebugger = false)
        {
            physix = new PhysX.Physics(new ErrorCallbackImp(), true);            
            
            var sceneDesc = new SceneDesc()
            {
                Gravity = gravity.AsPhysX()                
            };
                        
            scene = physix.CreateScene(sceneDesc);
                                    
            this.scene.SetVisualizationParameter(VisualizationParameter.Scale, 1.0f);
            this.scene.SetVisualizationParameter(VisualizationParameter.CollisionShapes, true);
            this.scene.SetVisualizationParameter(VisualizationParameter.JointLocalFrames, true);
            this.scene.SetVisualizationParameter(VisualizationParameter.JointLimits, true);
            this.scene.SetVisualizationParameter(VisualizationParameter.ParticleSystemPosition, true);
            this.scene.SetVisualizationParameter(VisualizationParameter.ActorAxes, true);            

            // Connect to the remote debugger if it's there            
            if (connectToRemoteDebugger)
            {
                physix.ConnectToRemoteDebugger("localhost");
            }
            
            objs = new List<IPhysicObject>();
            ctns = new List<IPhysicConstraint>();

            cooking = physix.CreateCooking();

        }

 public PhysxCapsuleCharacterObject(CapsuleControllerDescription CapsuleControllerDescription,Vector3 position, Matrix rotation,Vector3 scale)
 {
     this.scale = scale;
     this.CapsuleControllerDescription = CapsuleControllerDescription;
     this.CapsuleControllerDescription.Position = position.AsPhysX();
     CapsuleControllerDescription.Height *= scale.Y;
     CapsuleControllerDescription.Radius *= scale.X;
     this.rotation = rotation;
 }

 public PhysxBoxCharacterObject(BoxControllerDescription BoxControllerDescription, Vector3 position, Matrix rotation, Vector3 scale)
 {
     this.scale = scale;
     this.BoxControllerDescription = BoxControllerDescription;
     this.BoxControllerDescription.Position = position.AsPhysX();
     StillDesign.PhysX.MathPrimitives.Vector3 vec = BoxControllerDescription.Size;
     vec.X *= scale.X;
     vec.Y *= scale.Y;
     vec.Z *= scale.Z;
     BoxControllerDescription.Size = vec;
     this.rotation = rotation;
 }

        protected override void LoadContent(GraphicInfo GraphicInfo, GraphicFactory factory ,IContentManager contentManager)
        {
            PhysxPhysicWorld PhysxPhysicWorld = World.PhysicWorld as PhysxPhysicWorld;

            base.LoadContent(GraphicInfo, factory, contentManager);            

            int w = 25;
            int h = 25;

            float hw = w / 2.0f;
            float hh = h / 2.0f;

            Vector3 p = new Vector3(0, 20, 0);
            

            var grid = VertexGrid.CreateGrid(w, h);
            
            ClothModel ClothModel = new PloobsEngine.Modelo.ClothModel(factory, PhysxPhysicWorld,
                new ClothMeshDescription(), grid.Points,grid.TextCoords,grid.Indices, "Textures//meiofio");

            var clothDesc = new ClothDescription()
            {
                Friction = 0.5f,
                ClothMesh = ClothModel.ClothMesh,
                Flags = ClothFlag.Gravity | ClothFlag.Bending | ClothFlag.CollisionTwoway | ClothFlag.Visualization ,
                Thickness = 0.2f,                
            };            
            
            clothDesc.MeshData.AllocatePositions<Vector3>(grid.Points.Length );
            clothDesc.MeshData.AllocateIndices<int>(grid.Indices.Length );
            clothDesc.MeshData.AllocateNormals<Vector3>(grid.Points.Length );

            clothDesc.MeshData.MaximumVertices = grid.Points.Length ;
            clothDesc.MeshData.MaximumIndices = grid.Indices.Length ;

            clothDesc.MeshData.NumberOfVertices = grid.Points.Length ;
            clothDesc.MeshData.NumberOfIndices = grid.Indices.Length ;            
            
            PhysxClothObject PhysxClothObject = new PloobsEngine.Physics.PhysxClothObject(clothDesc,
                                                Matrix.CreateTranslation(-hw, 0, -hh) * Matrix.CreateTranslation(p));
            ForwardXNABasicShader ForwardXNABasicShader = new PloobsEngine.Material.ForwardXNABasicShader();
            ClothMaterial ClothMaterial = new ClothMaterial(ForwardXNABasicShader);
            IObject IObject = new PloobsEngine.SceneControl.IObject(ClothMaterial, ClothModel, PhysxClothObject);
            
            World.AddObject(IObject);



            // Four corner boxes to hold it in place
            var positions = new[]
			{
				new StillDesign.PhysX.MathPrimitives.Vector3(0, 0, -hh), // Back
				new StillDesign.PhysX.MathPrimitives.Vector3(0, 0, hh), // Front
				new StillDesign.PhysX.MathPrimitives.Vector3(-hw, 0, 0), // Left
				new StillDesign.PhysX.MathPrimitives.Vector3(hw, 0, 0), // Right
			};

            var sizes = new[]
			{
				new StillDesign.PhysX.MathPrimitives.Vector3(w, 1, 1), // Back
				new StillDesign.PhysX.MathPrimitives.Vector3(w, 1, 1), // Front
				new StillDesign.PhysX.MathPrimitives.Vector3(1, 1, h), // Left
				new StillDesign.PhysX.MathPrimitives.Vector3(1, 1, h), //Right
			};

            ///pra preender
            for (int i = 0; i < 2; i++)
            {
                var actorDesc = new ActorDescription()
                {
                    GlobalPose = StillDesign.PhysX.MathPrimitives.Matrix.Translation(positions[i] + p.AsPhysX()),
                    Shapes = { new BoxShapeDescription(sizes[i]) }
                };

                var actor = PhysxPhysicWorld.Scene.CreateActor(actorDesc);


                PhysxClothObject.Cloth.AttachToShape(actor.Shapes.First(), (ClothAttachmentFlag)0);                
            }
                        
            BallThrowPhysx28 BallThrowBullet = new BallThrowPhysx28(this.World, GraphicFactory);
            this.AttachCleanUpAble(BallThrowBullet);
            this.World.CameraManager.AddCamera(new CameraFirstPerson(GraphicInfo));
        }

 public override void GetPhysicsObjectsInRange(Vector3 position, float distance, CullerConditionAvaliator<IPhysicObject, SceneControl.IObject> CullerAvaliator, List<IPhysicObject> resp)
 {
     SphereGeometry SphereGeometry = new PhysX.SphereGeometry(distance);
     foreach (var item in scene.OverlapMultiple(SphereGeometry, PhysX.Math.Matrix.Translation(position.AsPhysX())))
     {
         if (item.UserData is IPhysicObject)
         {
             IPhysicObject IPhysicObject = item.UserData as IPhysicObject;
             if (CullerAvaliator(IPhysicObject, IPhysicObject.ObjectOwner))
             {
                 resp.Add(IPhysicObject);
             }
         }
     }
 }

 public override void ApplyImpulse(Vector3 position, Vector3 force)
 {
     Actor.AddForceAtLocalPosition(force.AsPhysX(), position.AsPhysX());
 }