Esempio n. 1
0
        /// <summary>
        /// Initializes the BRaycastVehicle.
        /// </summary>
        private void Awake()
        {
            rigidBody = GetComponent <BRigidBody>();

            if (rigidBody == null)
            {
                Destroy(this);
                return;
            }

            RaycastRobot = new RaycastRobot(defaultVehicleTuning = new VehicleTuning
            {
                MaxSuspensionForce    = 1000f,
                MaxSuspensionTravelCm = SuspensionToleranceCm,
                SuspensionDamping     = 10f,
                SuspensionCompression = SuspensionCompressionRatio,
                SuspensionStiffness   = CalculateStiffness(DefaultNumWheels),
                FrictionSlip          = 2f
            },
                                            (RigidBody)rigidBody.GetCollisionObject(),
                                            new BRobotRaycaster((DynamicsWorld)BPhysicsWorld.Get().world));

            RaycastRobot.SetCoordinateSystem(0, 1, 2);

            BRobotManager.Instance.RegisterRaycastRobot(RaycastRobot);
        }
Esempio n. 2
0
        public RaycastRobot(VehicleTuning tuning, RigidBody chassis, IVehicleRaycaster raycaster)
        {
            chassisBody      = chassis;
            vehicleRaycaster = raycaster;

            SlidingFriction = 1.0f;
            EffectiveMass   = 1.0f / chassis.InvMass;
        }
Esempio n. 3
0
        /// <summary>
        /// Initializes the RaycastRobot with the given vehicle settings and parent chassis.
        /// </summary>
        /// <param name="tuning"></param>
        /// <param name="chassis"></param>
        /// <param name="raycaster"></param>
        public RaycastRobot(VehicleTuning tuning, RigidBody chassis, IVehicleRaycaster raycaster)
        {
            chassisBody      = chassis;
            RootRigidBody    = chassis;
            vehicleRaycaster = raycaster;

            MaxWheelAngularVelocity = 40f;
            OverrideMass            = 1.0f / chassis.InvMass;
        }
Esempio n. 4
0
 public RaycastVehicle(VehicleTuning tuning, RigidBody chassis, IVehicleRaycaster raycaster)
 {
     m_vehicleRaycaster = raycaster;
     m_pitchControl = 0f;
     m_chassisBody = chassis;
     m_indexRightAxis = 0;
     m_indexUpAxis = 1;
     m_indexForwardAxis = 2;
     DefaultInit(ref tuning);
 }
        public CustomVehicle(VehicleTuning tuning, RigidBody chassis, IVehicleRaycaster raycaster)
        {
            chassisBody      = chassis;
            vehicleRaycaster = raycaster;

            using (var ci = new RigidBodyConstructionInfo(0, null, null))
            {
                _fixedBody = new RigidBody(ci);
                _fixedBody.SetMassProps(0, Vector3.Zero);
            }
        }
Esempio n. 6
0
        /// <summary>
        /// Устанавливает настройки тюнинга
        /// </summary>
        internal static void SetVehicleTuning(Vehicle vehicle, VehicleTuning tuning)
        {
            ResetTuning(vehicle);
            API.shared.setVehiclePrimaryColor(vehicle, tuning.PrimaryColor);
            API.shared.setVehicleSecondaryColor(vehicle, tuning.SecondColor);
            API.shared.setVehicleEnginePowerMultiplier(vehicle, tuning.EnginePower);
            var neonColor = tuning.GetNeonColor();

            if (neonColor.Length > 0)
            {
                TurnNeonState(vehicle, true);
                API.shared.setVehicleNeonColor(vehicle, neonColor[0], neonColor[1], neonColor[2]);
            }
            foreach (var mod in tuning.GetMods())
            {
                API.shared.setVehicleMod(vehicle, mod.Key, mod.Value);
            }
        }
Esempio n. 7
0
        protected void AddWheels(Vector3 halfExtents, RaycastVehicle vehicle, VehicleTuning tuning, float wheelRadius)
        {
            //The direction of the raycast, the btRaycastVehicle uses raycasts instead of simiulating the wheels with rigid bodies
            Vector3 wheelDirectionCS0 = new Vector3(0, -1, 0);

            //The axis which the wheel rotates arround
            Vector3 wheelAxleCS = new Vector3(-1, 0, 0);

            //All the wheel configuration assumes the vehicle is centered at the origin and a right handed coordinate system is used
            Vector4 points = contactInfoByChassis(mesh.Name);

            points.Y += suspensionLength + meshAxisRadius.Y - (meshRealHeight / 2f);

            //Adds the rear wheels
            Vector3 wheelConnectionPoint = new Vector3(points.X, points.Y - rearWheelsHeight, points.Z);

            vehicle.AddWheel(wheelConnectionPoint, wheelDirectionCS0, wheelAxleCS, suspensionRestLength, wheelRadius, tuning, false);
            vehicle.AddWheel(wheelConnectionPoint * new Vector3(-1, 1, 1), wheelDirectionCS0, wheelAxleCS, suspensionRestLength, wheelRadius, tuning, false);

            //Adds the front wheels
            wheelConnectionPoint = new Vector3(points.X, points.Y - frontWheelsHeight, points.W);
            vehicle.AddWheel(wheelConnectionPoint * new Vector3(1, 1, -1), wheelDirectionCS0, wheelAxleCS, suspensionRestLength, wheelRadius, tuning, true);
            vehicle.AddWheel(wheelConnectionPoint * new Vector3(-1, 1, -1), wheelDirectionCS0, wheelAxleCS, suspensionRestLength, wheelRadius, tuning, true);

            //Configures each wheel of our vehicle, setting its friction, damping compression, etc.
            //For more details on what each parameter does, refer to the docs
            for (int i = 0; i < vehicle.NumWheels; i++)
            {
                WheelInfo wheel = vehicle.GetWheelInfo(i);
                wheel.MaxSuspensionForce = 700000;
                //wheel.MaxSuspensionTravelCm = 80;
                wheel.SuspensionStiffness      = suspensionStiffness;
                wheel.WheelsDampingCompression = dampingCompression * 2 * FastMath.Sqrt(wheel.SuspensionStiffness);
                wheel.WheelsDampingRelaxation  = dampingRelaxation * 2 * FastMath.Sqrt(wheel.SuspensionStiffness);
                wheel.FrictionSlip             = frictionSlip;
                wheel.RollInfluence            = rollInfluence;
            }
        }
Esempio n. 8
0
        public WheelInfo AddWheel(Vector3 connectionPointCS, Vector3 wheelDirectionCS0, Vector3 wheelAxleCS, float suspensionRestLength, float wheelRadius, VehicleTuning tuning, bool isFrontWheel)
        {
            WheelInfoConstructionInfo ci = new WheelInfoConstructionInfo();

            ci.ChassisConnectionCS      = connectionPointCS;
            ci.WheelDirectionCS         = wheelDirectionCS0;
            ci.WheelAxleCS              = wheelAxleCS;
            ci.SuspensionRestLength     = suspensionRestLength;
            ci.WheelRadius              = wheelRadius;
            ci.SuspensionStiffness      = tuning.SuspensionStiffness;
            ci.WheelsDampingCompression = tuning.SuspensionCompression;
            ci.WheelsDampingRelaxation  = tuning.SuspensionDamping;
            ci.FrictionSlip             = tuning.FrictionSlip;
            ci.IsFrontWheel             = isFrontWheel;
            ci.MaxSuspensionTravelCm    = tuning.MaxSuspensionTravelCm;
            ci.MaxSuspensionForce       = tuning.MaxSuspensionForce;

            WheelInfo wheel = new WheelInfo(ci);

            wheelInfo.Add(wheel);

            UpdateWheelTransformsWS(wheel, false);
            UpdateWheelTransform(NumWheels - 1, false);
            return(wheel);
        }
Esempio n. 9
0
 public CustomVehicle(VehicleTuning tuning, RigidBody chassis, IVehicleRaycaster raycaster)
 {
     chassisBody      = chassis;
     vehicleRaycaster = raycaster;
 }
Esempio n. 10
0
        protected override void OnInitializePhysics()
        {
            CollisionShape groundShape = new BoxShape(50, 3, 50);

            CollisionShapes.Add(groundShape);

            CollisionConf = new DefaultCollisionConfiguration();
            Dispatcher    = new CollisionDispatcher(CollisionConf);
            Solver        = new SequentialImpulseConstraintSolver();

            Vector3 worldMin = new Vector3(-10000, -10000, -10000);
            Vector3 worldMax = new Vector3(10000, 10000, 10000);

            Broadphase = new AxisSweep3(worldMin, worldMax);
            //Broadphase = new DbvtBroadphase();

            World = new DiscreteDynamicsWorld(Dispatcher, Broadphase, Solver, CollisionConf);

            int    i;
            Matrix tr;
            Matrix vehicleTr;

            //if (UseTrimeshGround)
            {
                const float scale = 20.0f;

                //create a triangle-mesh ground
                const int NumVertsX  = 20;
                const int NumVertsY  = 20;
                const int totalVerts = NumVertsX * NumVertsY;

                const int totalTriangles = 2 * (NumVertsX - 1) * (NumVertsY - 1);

                TriangleIndexVertexArray vertexArray = new TriangleIndexVertexArray();
                IndexedMesh mesh = new IndexedMesh();
                mesh.Allocate(totalTriangles, totalVerts);
                mesh.NumTriangles        = totalTriangles;
                mesh.NumVertices         = totalVerts;
                mesh.TriangleIndexStride = 3 * sizeof(int);
                mesh.VertexStride        = Vector3.SizeInBytes;
                using (var indicesStream = mesh.GetTriangleStream())
                {
                    var indices = new BinaryWriter(indicesStream);
                    for (i = 0; i < NumVertsX - 1; i++)
                    {
                        for (int j = 0; j < NumVertsY - 1; j++)
                        {
                            indices.Write(j * NumVertsX + i);
                            indices.Write(j * NumVertsX + i + 1);
                            indices.Write((j + 1) * NumVertsX + i + 1);

                            indices.Write(j * NumVertsX + i);
                            indices.Write((j + 1) * NumVertsX + i + 1);
                            indices.Write((j + 1) * NumVertsX + i);
                        }
                    }
                    indices.Dispose();
                }

                using (var vertexStream = mesh.GetVertexStream())
                {
                    var vertices = new BinaryWriter(vertexStream);
                    for (i = 0; i < NumVertsX; i++)
                    {
                        for (int j = 0; j < NumVertsY; j++)
                        {
                            float wl     = .2f;
                            float height = 20.0f * (float)(Math.Sin(i * wl) * Math.Cos(j * wl));

                            vertices.Write((i - NumVertsX * 0.5f) * scale);
                            vertices.Write(height);
                            vertices.Write((j - NumVertsY * 0.5f) * scale);
                        }
                    }
                    vertices.Dispose();
                }

                vertexArray.AddIndexedMesh(mesh);
                groundShape = new BvhTriangleMeshShape(vertexArray, true);

                tr        = Matrix.Identity;
                vehicleTr = Matrix.Translation(0, -2, 0);
            }/*
              * else
              * {
              * // Use HeightfieldTerrainShape
              *
              * int width = 40, length = 40;
              * //int width = 128, length = 128; // Debugging is too slow for this
              * float maxHeight = 10.0f;
              * float heightScale = maxHeight / 256.0f;
              * Vector3 scale = new Vector3(20.0f, maxHeight, 20.0f);
              *
              * //PhyScalarType scalarType = PhyScalarType.PhyUChar;
              * //FileStream file = new FileStream(heightfieldFile, FileMode.Open, FileAccess.Read);
              *
              * // Use float data
              * PhyScalarType scalarType = PhyScalarType.PhyFloat;
              * byte[] terr = new byte[width * length * 4];
              * MemoryStream file = new MemoryStream(terr);
              * BinaryWriter writer = new BinaryWriter(file);
              * for (i = 0; i < width; i++)
              *     for (int j = 0; j < length; j++)
              *         writer.Write((float)((maxHeight / 2) + 4 * Math.Sin(j * 0.5f) * Math.Cos(i)));
              * writer.Flush();
              * file.Position = 0;
              *
              * HeightfieldTerrainShape heightterrainShape = new HeightfieldTerrainShape(width, length,
              *     file, heightScale, 0, maxHeight, upIndex, scalarType, false);
              * heightterrainShape.SetUseDiamondSubdivision(true);
              *
              * groundShape = heightterrainShape;
              * groundShape.LocalScaling = new Vector3(scale.X, 1, scale.Z);
              *
              * tr = Matrix.Translation(new Vector3(-scale.X / 2, scale.Y / 2, -scale.Z / 2));
              * vehicleTr = Matrix.Translation(new Vector3(20, 3, -3));
              *
              *
              * // Create graphics object
              *
              * file.Position = 0;
              * BinaryReader reader = new BinaryReader(file);
              *
              * int totalTriangles = (width - 1) * (length - 1) * 2;
              * int totalVerts = width * length;
              *
              * game.groundMesh = new Mesh(game.Device, totalTriangles, totalVerts,
              *     MeshFlags.SystemMemory | MeshFlags.Use32Bit, VertexFormat.Position | VertexFormat.Normal);
              * SlimDX.DataStream data = game.groundMesh.LockVertexBuffer(LockFlags.None);
              * for (i = 0; i < width; i++)
              * {
              *     for (int j = 0; j < length; j++)
              *     {
              *         float height;
              *         if (scalarType == PhyScalarType.PhyFloat)
              *         {
              *             // heightScale isn't applied internally for float data
              *             height = reader.ReadSingle();
              *         }
              *         else if (scalarType == PhyScalarType.PhyUChar)
              *         {
              *             height = file.ReadByte() * heightScale;
              *         }
              *         else
              *         {
              *             height = 0.0f;
              *         }
              *
              *         data.Write((j - length * 0.5f) * scale.X);
              *         data.Write(height);
              *         data.Write((i - width * 0.5f) * scale.Z);
              *
              *         // Normals will be calculated later
              *         data.Position += 12;
              *     }
              * }
              * game.groundMesh.UnlockVertexBuffer();
              * file.Close();
              *
              * data = game.groundMesh.LockIndexBuffer(LockFlags.None);
              * for (i = 0; i < width - 1; i++)
              * {
              *     for (int j = 0; j < length - 1; j++)
              *     {
              *         // Using diamond subdivision
              *         if ((j + i) % 2 == 0)
              *         {
              *             data.Write(j * width + i);
              *             data.Write((j + 1) * width + i + 1);
              *             data.Write(j * width + i + 1);
              *
              *             data.Write(j * width + i);
              *             data.Write((j + 1) * width + i);
              *             data.Write((j + 1) * width + i + 1);
              *         }
              *         else
              *         {
              *             data.Write(j * width + i);
              *             data.Write((j + 1) * width + i);
              *             data.Write(j * width + i + 1);
              *
              *             data.Write(j * width + i + 1);
              *             data.Write((j + 1) * width + i);
              *             data.Write((j + 1) * width + i + 1);
              *         }
              *
              *         / *
              *         // Not using diamond subdivision
              *         data.Write(j * width + i);
              *         data.Write((j + 1) * width + i);
              *         data.Write(j * width + i + 1);
              *
              *         data.Write(j * width + i + 1);
              *         data.Write((j + 1) * width + i);
              *         data.Write((j + 1) * width + i + 1);
              * /
              *     }
              * }
              * game.groundMesh.UnlockIndexBuffer();
              *
              * game.groundMesh.ComputeNormals();
              * }*/

            CollisionShapes.Add(groundShape);


            //create ground object
            RigidBody ground = LocalCreateRigidBody(0, tr, groundShape);

            ground.UserObject = "Ground";


            CollisionShape chassisShape = new BoxShape(1.0f, 0.5f, 2.0f);

            CollisionShapes.Add(chassisShape);

            CompoundShape compound = new CompoundShape();

            CollisionShapes.Add(compound);

            //localTrans effectively shifts the center of mass with respect to the chassis
            Matrix localTrans = Matrix.Translation(Vector3.UnitY);

            compound.AddChildShape(localTrans, chassisShape);
            RigidBody carChassis = LocalCreateRigidBody(800, Matrix.Identity, compound);

            carChassis.UserObject = "Chassis";
            //carChassis.SetDamping(0.2f, 0.2f);

            //CylinderShapeX wheelShape = new CylinderShapeX(wheelWidth, wheelRadius, wheelRadius);


            // clientResetScene();

            // create vehicle
            VehicleTuning     tuning           = new VehicleTuning();
            IVehicleRaycaster vehicleRayCaster = new DefaultVehicleRaycaster(World);

            //vehicle = new RaycastVehicle(tuning, carChassis, vehicleRayCaster);
            vehicle = new CustomVehicle(tuning, carChassis, vehicleRayCaster);

            carChassis.ActivationState = ActivationState.DisableDeactivation;
            World.AddAction(vehicle);


            const float connectionHeight = 1.2f;
            bool        isFrontWheel     = true;

            // choose coordinate system
            vehicle.SetCoordinateSystem(rightIndex, upIndex, forwardIndex);

            BulletSharp.Math.Vector3 connectionPointCS0 = new Vector3(CUBE_HALF_EXTENTS - (0.3f * wheelWidth), connectionHeight, 2 * CUBE_HALF_EXTENTS - wheelRadius);
            vehicle.AddWheel(connectionPointCS0, wheelDirectionCS0, wheelAxleCS, suspensionRestLength, wheelRadius, tuning, isFrontWheel);

            connectionPointCS0 = new Vector3(-CUBE_HALF_EXTENTS + (0.3f * wheelWidth), connectionHeight, 2 * CUBE_HALF_EXTENTS - wheelRadius);
            vehicle.AddWheel(connectionPointCS0, wheelDirectionCS0, wheelAxleCS, suspensionRestLength, wheelRadius, tuning, isFrontWheel);

            isFrontWheel       = false;
            connectionPointCS0 = new Vector3(-CUBE_HALF_EXTENTS + (0.3f * wheelWidth), connectionHeight, -2 * CUBE_HALF_EXTENTS + wheelRadius);
            vehicle.AddWheel(connectionPointCS0, wheelDirectionCS0, wheelAxleCS, suspensionRestLength, wheelRadius, tuning, isFrontWheel);

            connectionPointCS0 = new Vector3(CUBE_HALF_EXTENTS - (0.3f * wheelWidth), connectionHeight, -2 * CUBE_HALF_EXTENTS + wheelRadius);
            vehicle.AddWheel(connectionPointCS0, wheelDirectionCS0, wheelAxleCS, suspensionRestLength, wheelRadius, tuning, isFrontWheel);


            for (i = 0; i < vehicle.NumWheels; i++)
            {
                WheelInfo wheel = vehicle.GetWheelInfo(i);
                wheel.SuspensionStiffness      = suspensionStiffness;
                wheel.WheelsDampingRelaxation  = suspensionDamping;
                wheel.WheelsDampingCompression = suspensionCompression;
                wheel.FrictionSlip             = wheelFriction;
                wheel.RollInfluence            = rollInfluence;
            }

            vehicle.RigidBody.WorldTransform = vehicleTr;
        }
Esempio n. 11
0
        public Character(DiscreteDynamicsWorld world, Vehiculo vehiculo, TGCVector3 position, float rotation, GameModel gameModel)
        {
            //Cargar sonido
            turboSound = new TgcStaticSound();
            turboSound.loadSound(Game.Default.MediaDirectory + Game.Default.FXDirectory + "turbo.wav", gameModel.DirectSound.DsDevice);

            this.vehiculo = vehiculo;

            var loader = new TgcSceneLoader();

            this.mesh  = loader.loadSceneFromFile(vehiculo.ChassisXmlPath).Meshes[0];
            this.wheel = loader.loadSceneFromFile(vehiculo.WheelsXmlPath).Meshes[0];

            Vehiculo.ChangeTextureColor(this.mesh, vehiculo.Color);

            this.mesh.AutoTransform  = false;
            this.wheel.AutoTransform = false;

            maxHitPoints         = float.Parse(mesh.UserProperties["maxHitPoints"], CultureInfo.InvariantCulture);
            engineForce          = -float.Parse(mesh.UserProperties["engineForce"], CultureInfo.InvariantCulture);
            brakeForce           = float.Parse(mesh.UserProperties["brakeForce"], CultureInfo.InvariantCulture);
            steeringAngle        = -float.Parse(mesh.UserProperties["steeringAngle"], CultureInfo.InvariantCulture);
            turboImpulse         = float.Parse(mesh.UserProperties["turboImpulse"], CultureInfo.InvariantCulture);
            frictionSlip         = float.Parse(mesh.UserProperties["frictionSlip"], CultureInfo.InvariantCulture);
            rollInfluence        = float.Parse(mesh.UserProperties["rollInfluence"], CultureInfo.InvariantCulture);
            rearWheelsHeight     = float.Parse(mesh.UserProperties["rearWheelsHeight"], CultureInfo.InvariantCulture);
            frontWheelsHeight    = float.Parse(mesh.UserProperties["frontWheelsHeight"], CultureInfo.InvariantCulture);
            suspensionRestLength = float.Parse(mesh.UserProperties["suspensionRestLength"], CultureInfo.InvariantCulture);
            suspensionStiffness  = float.Parse(mesh.UserProperties["suspensionStiffness"], CultureInfo.InvariantCulture);
            dampingCompression   = float.Parse(mesh.UserProperties["dampingCompression"], CultureInfo.InvariantCulture);
            dampingRelaxation    = float.Parse(mesh.UserProperties["dampingRelaxation"], CultureInfo.InvariantCulture);

            meshAxisRadius = this.mesh.BoundingBox.calculateAxisRadius().ToBsVector;
            var wheelRadius = this.wheel.BoundingBox.calculateAxisRadius().Y;

            //The btBoxShape is centered at the origin
            CollisionShape chassisShape = new BoxShape(meshAxisRadius.X, meshRealHeight, meshAxisRadius.Z);

            //A compound shape is used so we can easily shift the center of gravity of our vehicle to its bottom
            //This is needed to make our vehicle more stable
            CompoundShape compound = new CompoundShape();

            //The center of gravity of the compound shape is the origin. When we add a rigidbody to the compound shape
            //it's center of gravity does not change. This way we can add the chassis rigidbody one unit above our center of gravity
            //keeping it under our chassis, and not in the middle of it
            var localTransform = Matrix.Translation(0, (meshAxisRadius.Y * 1.75f) - (meshRealHeight / 2f), 0);

            compound.AddChildShape(localTransform, chassisShape);
            //Creates a rigid body
            this.rigidBody = CreateChassisRigidBodyFromShape(compound, position, rotation);

            //Adds the vehicle chassis to the world
            world.AddRigidBody(this.rigidBody);
            worldID = world.CollisionObjectArray.IndexOf(this.rigidBody);

            //RaycastVehicle
            DefaultVehicleRaycaster vehicleRayCaster = new DefaultVehicleRaycaster(world);
            VehicleTuning           tuning           = new VehicleTuning();

            //Creates a new instance of the raycast vehicle
            vehicle = new RaycastVehicle(tuning, this.rigidBody, vehicleRayCaster);

            //Never deactivate the vehicle
            this.rigidBody.ActivationState = ActivationState.DisableDeactivation;

            //Adds the vehicle to the world
            world.AddAction(vehicle);

            //Adds the wheels to the vehicle
            AddWheels(meshAxisRadius, vehicle, tuning, wheelRadius);

            //Inicializo puntos
            hitPoints       = maxHitPoints;
            specialPoints   = maxSpecialPoints;
            timerMachineGun = 0f;
        }
Esempio n. 12
0
        private void CreateVehicle(Matrix transform)
        {
            var chassisShape = new BoxShape(1.0f, 0.5f, 2.0f);

            var compound = new CompoundShape();

            //localTrans effectively shifts the center of mass with respect to the chassis
            Matrix localTrans = Matrix.Translation(Vector3.UnitY);

            compound.AddChildShape(localTrans, chassisShape);
            RigidBody carChassis = PhysicsHelper.CreateBody(800, Matrix.Identity, compound, World);

            carChassis.UserObject = "Chassis";
            //carChassis.SetDamping(0.2f, 0.2f);

            var tuning           = new VehicleTuning();
            var vehicleRayCaster = new DefaultVehicleRaycaster(World);

            //vehicle = new RaycastVehicle(tuning, carChassis, vehicleRayCaster);
            _vehicle = new CustomVehicle(tuning, carChassis, vehicleRayCaster);

            carChassis.ActivationState = ActivationState.DisableDeactivation;
            World.AddAction(_vehicle);


            const float connectionHeight = 1.2f;

            // choose coordinate system
            _vehicle.SetCoordinateSystem(rightIndex, upIndex, forwardIndex);

            Vector3 wheelDirection = Vector3.Zero;
            Vector3 wheelAxle      = Vector3.Zero;

            wheelDirection[upIndex] = -1;
            wheelAxle[rightIndex]   = -1;

            bool isFrontWheel    = true;
            var  connectionPoint = new Vector3(CUBE_HALF_EXTENTS - (0.3f * wheelWidth), connectionHeight, 2 * CUBE_HALF_EXTENTS - wheelRadius);

            _vehicle.AddWheel(connectionPoint, wheelDirection, wheelAxle, suspensionRestLength, wheelRadius, tuning, isFrontWheel);

            connectionPoint = new Vector3(-CUBE_HALF_EXTENTS + (0.3f * wheelWidth), connectionHeight, 2 * CUBE_HALF_EXTENTS - wheelRadius);
            _vehicle.AddWheel(connectionPoint, wheelDirection, wheelAxle, suspensionRestLength, wheelRadius, tuning, isFrontWheel);

            isFrontWheel    = false;
            connectionPoint = new Vector3(-CUBE_HALF_EXTENTS + (0.3f * wheelWidth), connectionHeight, -2 * CUBE_HALF_EXTENTS + wheelRadius);
            _vehicle.AddWheel(connectionPoint, wheelDirection, wheelAxle, suspensionRestLength, wheelRadius, tuning, isFrontWheel);

            connectionPoint = new Vector3(CUBE_HALF_EXTENTS - (0.3f * wheelWidth), connectionHeight, -2 * CUBE_HALF_EXTENTS + wheelRadius);
            _vehicle.AddWheel(connectionPoint, wheelDirection, wheelAxle, suspensionRestLength, wheelRadius, tuning, isFrontWheel);


            for (int i = 0; i < _vehicle.NumWheels; i++)
            {
                WheelInfo wheel = _vehicle.GetWheelInfo(i);
                wheel.SuspensionStiffness      = suspensionStiffness;
                wheel.WheelsDampingRelaxation  = suspensionDamping;
                wheel.WheelsDampingCompression = suspensionCompression;
                wheel.FrictionSlip             = wheelFriction;
                wheel.RollInfluence            = rollInfluence;
            }

            _vehicle.RigidBody.WorldTransform = transform;
        }
        public WheelInfo AddWheel(Vector3 connectionPointCS, Vector3 wheelDirectionCS0, Vector3 wheelAxleCS, float suspensionRestLength, float wheelRadius, VehicleTuning tuning, bool isFrontWheel)
        {
            var ci = new WheelInfoConstructionInfo
            {
                ChassisConnectionCS      = connectionPointCS,
                WheelDirectionCS         = wheelDirectionCS0,
                WheelAxleCS              = wheelAxleCS,
                SuspensionRestLength     = suspensionRestLength,
                WheelRadius              = wheelRadius,
                SuspensionStiffness      = tuning.SuspensionStiffness,
                WheelsDampingCompression = tuning.SuspensionCompression,
                WheelsDampingRelaxation  = tuning.SuspensionDamping,
                FrictionSlip             = tuning.FrictionSlip,
                IsFrontWheel             = isFrontWheel,
                MaxSuspensionTravelCm    = tuning.MaxSuspensionTravelCm,
                MaxSuspensionForce       = tuning.MaxSuspensionForce,
            };

            var wheel = new WheelInfo(ci);

            _wheelInfo.Add(wheel);

            UpdateWheelTransformsWS(wheel, false);
            UpdateWheelTransform(NumWheels - 1, false);
            return(wheel);
        }
Esempio n. 14
0
        private void DefaultInit(ref VehicleTuning tuning)
        {
            //(void)tuning;
	        m_currentVehicleSpeedKmHour = 0f;
	        m_steeringValue = 0f;

        }
Esempio n. 15
0
        public WheelInfo AddWheel(ref Vector3 connectionPointCS0, ref Vector3 wheelDirectionCS0, ref Vector3 wheelAxleCS, float suspensionRestLength, float wheelRadius, VehicleTuning tuning, bool isFrontWheel)
        {
            WheelInfoConstructionInfo ci = new WheelInfoConstructionInfo();

            ci.m_chassisConnectionCS = connectionPointCS0;
            ci.m_wheelDirectionCS = wheelDirectionCS0;
            ci.m_wheelAxleCS = wheelAxleCS;
            ci.m_suspensionRestLength = suspensionRestLength;
            ci.m_wheelRadius = wheelRadius;
            ci.m_suspensionStiffness = tuning.m_suspensionStiffness;
            ci.m_wheelsDampingCompression = tuning.m_suspensionCompression;
            ci.m_wheelsDampingRelaxation = tuning.m_suspensionDamping;
            ci.m_frictionSlip = tuning.m_frictionSlip;
            ci.m_bIsFrontWheel = isFrontWheel;
            ci.m_maxSuspensionTravelCm = tuning.m_maxSuspensionTravelCm;
            ci.m_maxSuspensionForce = tuning.m_maxSuspensionForce;

            WheelInfo wheel = new WheelInfo(ref ci);
            m_wheelInfo.Add(wheel);

            UpdateWheelTransformsWS(wheel, false);
            UpdateWheelTransform(GetNumWheels() - 1, false);
            return wheel;
        }