438 lines
19 KiB
ActionScript
438 lines
19 KiB
ActionScript
// Vehicle example.
|
|
// This sample demonstrates:
|
|
// - Creating a heightmap terrain with collision
|
|
// - Constructing a physical vehicle with rigid bodies for the hull and the wheels, joined with constraints
|
|
// - Saving and loading the variables of a script object, including node & component references
|
|
|
|
#include "Scripts/Utilities/Sample.as"
|
|
|
|
const int CTRL_FORWARD = 1;
|
|
const int CTRL_BACK = 2;
|
|
const int CTRL_LEFT = 4;
|
|
const int CTRL_RIGHT = 8;
|
|
const int CTRL_BRAKE = 16;
|
|
|
|
const float CAMERA_DISTANCE = 10.0f;
|
|
const float YAW_SENSITIVITY = 0.1f;
|
|
const float ENGINE_FORCE = 2500.0f;
|
|
const float DOWN_FORCE = 100.0f;
|
|
const float MAX_WHEEL_ANGLE = 22.5f;
|
|
const float CHASSIS_WIDTH = 2.6f;
|
|
|
|
Node@ vehicleNode;
|
|
|
|
void Start()
|
|
{
|
|
// Execute the common startup for samples
|
|
SampleStart();
|
|
// Create static scene content
|
|
CreateScene();
|
|
// Create the controllable vehicle
|
|
CreateVehicle();
|
|
// Create the UI content
|
|
CreateInstructions();
|
|
// Set the mouse mode to use in the sample
|
|
SampleInitMouseMode(MM_RELATIVE);
|
|
// Subscribe to necessary events
|
|
SubscribeToEvents();
|
|
}
|
|
|
|
void CreateScene()
|
|
{
|
|
scene_ = Scene();
|
|
// Create scene subsystem components
|
|
scene_.CreateComponent("Octree");
|
|
scene_.CreateComponent("PhysicsWorld");
|
|
// Create camera and define viewport. Camera does not necessarily have to belong to the scene
|
|
cameraNode = Node();
|
|
Camera@ camera = cameraNode.CreateComponent("Camera");
|
|
camera.farClip = 500.0f;
|
|
renderer.viewports[0] = Viewport(scene_, camera);
|
|
// Create static scene content. First create a zone for ambient lighting and fog control
|
|
Node@ zoneNode = scene_.CreateChild("Zone");
|
|
Zone@ zone = zoneNode.CreateComponent("Zone");
|
|
zone.ambientColor = Color(0.15f, 0.15f, 0.15f);
|
|
zone.fogColor = Color(0.5f, 0.5f, 0.7f);
|
|
zone.fogStart = 300.0f;
|
|
zone.fogEnd = 500.0f;
|
|
zone.boundingBox = BoundingBox(-2000.0f, 2000.0f);
|
|
// Create a directional light to the world. Enable cascaded shadows on it
|
|
Node@ lightNode = scene_.CreateChild("DirectionalLight");
|
|
lightNode.direction = Vector3(0.3f, -0.5f, 0.425f);
|
|
Light@ light = lightNode.CreateComponent("Light");
|
|
light.lightType = LIGHT_DIRECTIONAL;
|
|
light.castShadows = true;
|
|
light.shadowBias = BiasParameters(0.00025f, 0.5f);
|
|
light.shadowCascade = CascadeParameters(10.0f, 50.0f, 200.0f, 0.0f, 0.8f);
|
|
light.specularIntensity = 0.5f;
|
|
// Create heightmap terrain with collision
|
|
Node@ terrainNode = scene_.CreateChild("Terrain");
|
|
terrainNode.position = Vector3(0.0f, 0.0f, 0.0f);
|
|
Terrain@ terrain = terrainNode.CreateComponent("Terrain");
|
|
terrain.patchSize = 64;
|
|
terrain.spacing = Vector3(2.0f, 0.1f, 2.0f); // Spacing between vertices and vertical resolution of the height map
|
|
terrain.smoothing = true;
|
|
terrain.heightMap = cache.GetResource("Image", "Textures/HeightMap.png");
|
|
terrain.material = cache.GetResource("Material", "Materials/Terrain.xml");
|
|
// The terrain consists of large triangles, which fits well for occlusion rendering, as a hill can occlude all
|
|
// terrain patches and other objects behind it
|
|
terrain.occluder = true;
|
|
RigidBody@ body = terrainNode.CreateComponent("RigidBody");
|
|
body.collisionLayer = 2; // Use layer bitmask 2 for static geometry
|
|
CollisionShape@ shape = terrainNode.CreateComponent("CollisionShape");
|
|
shape.SetTerrain();
|
|
// Create 1000 mushrooms in the terrain. Always face outward along the terrain normal
|
|
const uint NUM_MUSHROOMS = 1000;
|
|
for (uint i = 0; i < NUM_MUSHROOMS; ++i)
|
|
{
|
|
Node@ objectNode = scene_.CreateChild("Mushroom");
|
|
Vector3 position(Random(2000.0f) - 1000.0f, 0.0f, Random(2000.0f) - 1000.0f);
|
|
position.y = terrain.GetHeight(position) - 0.1f;
|
|
objectNode.position = position;
|
|
// Create a rotation quaternion from up vector to terrain normal
|
|
objectNode.rotation = Quaternion(Vector3(0.0f, 1.0f, 0.0), terrain.GetNormal(position));
|
|
objectNode.SetScale(3.0f);
|
|
StaticModel@ object = objectNode.CreateComponent("StaticModel");
|
|
object.model = cache.GetResource("Model", "Models/Mushroom.mdl");
|
|
object.material = cache.GetResource("Material", "Materials/Mushroom.xml");
|
|
object.castShadows = true;
|
|
RigidBody@ mushroomBody = objectNode.CreateComponent("RigidBody");
|
|
mushroomBody.collisionLayer = 2;
|
|
CollisionShape@ mushroomShape = objectNode.CreateComponent("CollisionShape");
|
|
mushroomShape.SetTriangleMesh(object.model, 0);
|
|
}
|
|
}
|
|
|
|
void CreateVehicle()
|
|
{
|
|
vehicleNode = scene_.CreateChild("Vehicle");
|
|
vehicleNode.position = Vector3(0.0f, 5.0f, 0.0f);
|
|
// First createing player-controlled vehicle
|
|
// Create the vehicle logic script object
|
|
Vehicle@ vehicle = cast<Vehicle>(vehicleNode.CreateScriptObject(scriptFile, "Vehicle"));
|
|
// Initialize vehicle component
|
|
vehicle.Init();
|
|
vehicleNode.AddTag("vehicle");
|
|
// Set RigidBody physics parameters
|
|
// (The RigidBody was created by vehicle.Init()
|
|
RigidBody@ hullBody = vehicleNode.GetComponent("RigidBody");
|
|
hullBody.mass = 800.0f;
|
|
hullBody.linearDamping = 0.2f; // Some air resistance
|
|
hullBody.angularDamping = 0.5f;
|
|
hullBody.collisionLayer = 1;
|
|
}
|
|
|
|
void CreateInstructions()
|
|
{
|
|
// Construct new Text object, set string to display and font to use
|
|
Text@ instructionText = ui.root.CreateChild("Text");
|
|
instructionText.text =
|
|
"Use WASD keys to drive, F to brake, mouse/touch to rotate camera\n"
|
|
"F5 to save scene, F7 to load";
|
|
instructionText.
|
|
SetFont(cache.GetResource("Font", "Fonts/Anonymous Pro.ttf"), 15);
|
|
// The text has multiple rows. Center them in relation to each other
|
|
instructionText.textAlignment = HA_CENTER;
|
|
// Position the text relative to the screen center
|
|
instructionText.horizontalAlignment = HA_CENTER;
|
|
instructionText.verticalAlignment = VA_CENTER;
|
|
instructionText.SetPosition(0, ui.root.height / 4);
|
|
}
|
|
|
|
void SubscribeToEvents()
|
|
{
|
|
// Subscribe to Update event for setting the vehicle controls before physics simulation
|
|
SubscribeToEvent("Update", "HandleUpdate");
|
|
// Subscribe to PostUpdate event for updating the camera position after physics simulation
|
|
SubscribeToEvent("PostUpdate", "HandlePostUpdate");
|
|
// Unsubscribe the SceneUpdate event from base class as the camera node is being controlled in HandlePostUpdate() in this sample
|
|
UnsubscribeFromEvent("SceneUpdate");
|
|
}
|
|
|
|
void HandleUpdate(StringHash eventType, VariantMap& eventData)
|
|
{
|
|
if (vehicleNode is null)
|
|
return;
|
|
|
|
Vehicle@ vehicle = cast < Vehicle > (vehicleNode.scriptObject);
|
|
if (vehicle is null)
|
|
return;
|
|
// Get movement controls and assign them to the vehicle component. If UI has a focused element, clear controls
|
|
if (ui.focusElement is null)
|
|
{
|
|
vehicle.controls.Set(CTRL_FORWARD, input.keyDown[KEY_W]);
|
|
vehicle.controls.Set(CTRL_BACK, input.keyDown[KEY_S]);
|
|
vehicle.controls.Set(CTRL_LEFT, input.keyDown[KEY_A]);
|
|
vehicle.controls.Set(CTRL_RIGHT, input.keyDown[KEY_D]);
|
|
vehicle.controls.Set(CTRL_BRAKE, input.keyDown[KEY_F]);
|
|
// Add yaw & pitch from the mouse motion. Used only for the camera, does not affect motion
|
|
if (touchEnabled)
|
|
{
|
|
for (uint i = 0; i < input.numTouches; ++i)
|
|
{
|
|
TouchState@ state = input.touches[i];
|
|
if (state.touchedElement is null) // Touch on empty space
|
|
{
|
|
Camera@ camera = cameraNode.GetComponent("Camera");
|
|
if (camera is null)
|
|
return;
|
|
vehicle.controls.yaw += TOUCH_SENSITIVITY * camera.fov / graphics.height * state.delta.x;
|
|
vehicle.controls.pitch += TOUCH_SENSITIVITY * camera.fov / graphics.height * state.delta.y;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
vehicle.controls.yaw += input.mouseMoveX * YAW_SENSITIVITY;
|
|
vehicle.controls.pitch += input.mouseMoveY * YAW_SENSITIVITY;
|
|
}
|
|
// Limit pitch
|
|
vehicle.controls.pitch = Clamp(vehicle.controls.pitch, 0.0f, 80.0f);
|
|
// Check for loading / saving the scene
|
|
if (input.keyPress[KEY_F5])
|
|
{
|
|
File saveFile(fileSystem.programDir + "Data/Scenes/RaycastScriptVehicleDemo.xml", FILE_WRITE);
|
|
scene_.SaveXML(saveFile);
|
|
}
|
|
if (input.keyPress[KEY_F7])
|
|
{
|
|
File loadFile(fileSystem.programDir + "Data/Scenes/RaycastScriptVehicleDemo.xml", FILE_READ);
|
|
scene_.LoadXML(loadFile);
|
|
// After loading we have to reacquire the vehicle scene node, as it has been recreated
|
|
// Simply find by name as there's only one of them
|
|
Array<Node@>@ vehicles = scene_.GetChildrenWithTag("vehicle");
|
|
for (int i = 0; i < vehicles.length; i++)
|
|
{
|
|
Vehicle@ vehicleData = cast<Vehicle>(vehicles[i].scriptObject);
|
|
vehicleData.CreateEmitters();
|
|
}
|
|
vehicleNode = scene_.GetChild("Vehicle", true);
|
|
}
|
|
}
|
|
else
|
|
vehicle.controls.Set(CTRL_FORWARD | CTRL_BACK | CTRL_LEFT | CTRL_RIGHT | CTRL_BRAKE, false);
|
|
}
|
|
|
|
void HandlePostUpdate(StringHash eventType, VariantMap& eventData)
|
|
{
|
|
if (vehicleNode is null)
|
|
return;
|
|
Vehicle@ vehicle = cast < Vehicle > (vehicleNode.scriptObject);
|
|
if (vehicle is null)
|
|
return;
|
|
// Physics update has completed. Position camera behind vehicle
|
|
Quaternion dir(vehicleNode.rotation.yaw, Vector3(0.0f, 1.0f, 0.0f));
|
|
dir = dir * Quaternion(vehicle.controls.yaw, Vector3(0.0f, 1.0f, 0.0f));
|
|
dir = dir * Quaternion(vehicle.controls.pitch, Vector3(1.0f, 0.0f, 0.0f));
|
|
Vector3 cameraTargetPos = vehicleNode.position - dir * Vector3(0.0f, 0.0f, CAMERA_DISTANCE);
|
|
Vector3 cameraStartPos = vehicleNode.position;
|
|
// Raycast camera against static objects (physics collision mask 2)
|
|
// and move it closer to the vehicle if something in between
|
|
Ray cameraRay(cameraStartPos, (cameraTargetPos - cameraStartPos).Normalized());
|
|
float cameraRayLength = (cameraTargetPos - cameraStartPos).length;
|
|
PhysicsRaycastResult result = scene_.physicsWorld.RaycastSingle(cameraRay, cameraRayLength, 2);
|
|
if (result.body !is null)
|
|
cameraTargetPos = cameraStartPos + cameraRay.direction * (result.distance - 0.5f);
|
|
cameraNode.position = cameraTargetPos;
|
|
cameraNode.rotation = dir;
|
|
}
|
|
|
|
// Vehicle script object class
|
|
//
|
|
// When saving, the node and component handles are automatically converted into nodeID or componentID attributes
|
|
// and are acquired from the scene when loading. The steering member variable will likewise be saved automatically.
|
|
// The Controls object can not be automatically saved, so handle it manually in the Load() and Save() methods
|
|
|
|
class Vehicle:ScriptObject
|
|
{
|
|
|
|
RigidBody@ hullBody;
|
|
|
|
// Current left/right steering amount (-1 to 1.)
|
|
float steering = 0.0f;
|
|
|
|
// Vehicle controls.
|
|
Controls controls;
|
|
|
|
float suspensionRestLength = 0.6f;
|
|
float suspensionStiffness = 14.0f;
|
|
float suspensionDamping = 2.0f;
|
|
float suspensionCompression = 4.0f;
|
|
float wheelFriction = 1000.0f;
|
|
float rollInfluence = 0.12f;
|
|
float maxEngineForce = ENGINE_FORCE;
|
|
|
|
float wheelWidth = 0.4f;
|
|
float wheelRadius = 0.5f;
|
|
float brakingForce = 50.0f;
|
|
Array<Vector3> connectionPoints;
|
|
Array<Node@> particleEmitterNodeList;
|
|
protected Vector3 prevVelocity;
|
|
|
|
void Load(Deserializer& deserializer)
|
|
{
|
|
controls.yaw = deserializer.ReadFloat();
|
|
controls.pitch = deserializer.ReadFloat();
|
|
}
|
|
|
|
void Save(Serializer& serializer)
|
|
{
|
|
serializer.WriteFloat(controls.yaw);
|
|
serializer.WriteFloat(controls.pitch);
|
|
}
|
|
|
|
void Init()
|
|
{
|
|
// This function is called only from the main program when initially creating the vehicle, not on scene load
|
|
StaticModel@ hullObject = node.CreateComponent("StaticModel");
|
|
hullBody = node.CreateComponent("RigidBody");
|
|
CollisionShape@ hullShape = node.CreateComponent("CollisionShape");
|
|
node.scale = Vector3(2.3f, 1.0f, 4.0f);
|
|
hullObject.model = cache.GetResource("Model", "Models/Box.mdl");
|
|
hullObject.material = cache.GetResource("Material", "Materials/Stone.xml");
|
|
hullObject.castShadows = true;
|
|
hullShape.SetBox(Vector3(1.0f, 1.0f, 1.0f));
|
|
hullBody.mass = 800.0f;
|
|
hullBody.linearDamping = 0.2f; // Some air resistance
|
|
hullBody.angularDamping = 0.5f;
|
|
hullBody.collisionLayer = 1;
|
|
RaycastVehicle@ raycastVehicle = node.CreateComponent("RaycastVehicle");
|
|
raycastVehicle.Init();
|
|
connectionPoints.Reserve(4);
|
|
float connectionHeight = -0.4f; //1.2f;
|
|
bool isFrontWheel = true;
|
|
Vector3 wheelDirection(0, -1, 0);
|
|
Vector3 wheelAxle(-1, 0, 0);
|
|
float wheelX = CHASSIS_WIDTH / 2.0 - wheelWidth;
|
|
// Front left
|
|
connectionPoints.Push(Vector3(-wheelX, connectionHeight, 2.5f - wheelRadius * 2.0f));
|
|
// Front right
|
|
connectionPoints.Push(Vector3(wheelX, connectionHeight, 2.5f - wheelRadius * 2.0f));
|
|
// Back left
|
|
connectionPoints.Push(Vector3(-wheelX, connectionHeight, -2.5f + wheelRadius * 2.0f));
|
|
// Back right
|
|
connectionPoints.Push(Vector3(wheelX, connectionHeight, -2.5f + wheelRadius * 2.0f));
|
|
const Color LtBrown(0.972f, 0.780f, 0.412f);
|
|
for (int id = 0; id < connectionPoints.length; id++)
|
|
{
|
|
Node@ wheelNode = scene_.CreateChild();
|
|
Vector3 connectionPoint = connectionPoints[id];
|
|
// Front wheels are at front (z > 0)
|
|
// back wheels are at z < 0
|
|
// Setting rotation according to wheel position
|
|
bool isFrontWheel = connectionPoints[id].z > 0.0f;
|
|
wheelNode.rotation = (connectionPoint.x >= 0.0 ? Quaternion(0.0f, 0.0f, -90.0f) : Quaternion(0.0f, 0.0f, 90.0f));
|
|
wheelNode.worldPosition = (node.worldPosition + node.worldRotation * connectionPoints[id]);
|
|
wheelNode.scale = Vector3(1.0f, 0.65f, 1.0f);
|
|
raycastVehicle.AddWheel(wheelNode, wheelDirection, wheelAxle, suspensionRestLength, wheelRadius, isFrontWheel);
|
|
raycastVehicle.SetWheelSuspensionStiffness(id, suspensionStiffness);
|
|
raycastVehicle.SetWheelDampingRelaxation(id, suspensionDamping);
|
|
raycastVehicle.SetWheelDampingCompression(id, suspensionCompression);
|
|
raycastVehicle.SetWheelFrictionSlip(id, wheelFriction);
|
|
raycastVehicle.SetWheelRollInfluence(id, rollInfluence);
|
|
StaticModel@ pWheel = wheelNode.CreateComponent("StaticModel");
|
|
pWheel.model = cache.GetResource("Model", "Models/Cylinder.mdl");
|
|
pWheel.material = cache.GetResource("Material", "Materials/Stone.xml");
|
|
pWheel.castShadows = true;
|
|
}
|
|
CreateEmitters();
|
|
raycastVehicle.ResetWheels();
|
|
}
|
|
|
|
void CreateEmitter(Vector3 place)
|
|
{
|
|
Node@ emitter = scene_.CreateChild();
|
|
emitter.worldPosition = node.worldPosition + node.worldRotation * place + Vector3(0, -wheelRadius, 0);
|
|
ParticleEmitter@ particleEmitter = emitter.CreateComponent("ParticleEmitter");
|
|
particleEmitter.effect = cache.GetResource("ParticleEffect", "Particle/Dust.xml");
|
|
particleEmitter.emitting = false;
|
|
particleEmitterNodeList.Push(emitter);
|
|
emitter.temporary = true;
|
|
}
|
|
|
|
void CreateEmitters()
|
|
{
|
|
particleEmitterNodeList.Clear();
|
|
RaycastVehicle@ raycastVehicle = node.GetComponent("RaycastVehicle");
|
|
for (int id = 0; id < raycastVehicle.numWheels; id++)
|
|
{
|
|
Vector3 connectionPoint = raycastVehicle.GetWheelConnectionPoint(id);
|
|
CreateEmitter(connectionPoint);
|
|
}
|
|
}
|
|
|
|
void FixedUpdate(float timeStep)
|
|
{
|
|
float newSteering = 0.0f;
|
|
float accelerator = 0.0f;
|
|
bool brake = false;
|
|
RaycastVehicle@ raycastVehicle = node.GetComponent("RaycastVehicle");
|
|
if (controls.IsDown(CTRL_LEFT))
|
|
newSteering = -1.0f;
|
|
if (controls.IsDown(CTRL_RIGHT))
|
|
newSteering = 1.0f;
|
|
if (controls.IsDown(CTRL_FORWARD))
|
|
accelerator = 1.0f;
|
|
if (controls.IsDown(CTRL_BACK))
|
|
accelerator = -0.5f;
|
|
if (controls.IsDown(CTRL_BRAKE))
|
|
brake = true;
|
|
// When steering, wake up the wheel rigidbodies so that their orientation is updated
|
|
if (newSteering != 0.0f)
|
|
{
|
|
steering = steering * 0.95f + newSteering * 0.05f;
|
|
}
|
|
else
|
|
steering = steering * 0.8f + newSteering * 0.2f;
|
|
Quaternion steeringRot(0.0f, steering * MAX_WHEEL_ANGLE, 0.0f);
|
|
raycastVehicle.SetSteeringValue(0, steering);
|
|
raycastVehicle.SetSteeringValue(1, steering);
|
|
raycastVehicle.SetEngineForce(2, maxEngineForce * accelerator);
|
|
raycastVehicle.SetEngineForce(3, maxEngineForce * accelerator);
|
|
for (int i = 0; i < raycastVehicle.numWheels; i++)
|
|
{
|
|
if (brake)
|
|
{
|
|
raycastVehicle.SetBrake(i, brakingForce);
|
|
}
|
|
else
|
|
{
|
|
raycastVehicle.SetBrake(i, 0.0f);
|
|
}
|
|
}
|
|
// Apply downforce proportional to velocity
|
|
Vector3 localVelocity = hullBody.rotation.Inverse() * hullBody.linearVelocity;
|
|
hullBody.ApplyForce(hullBody.rotation * Vector3(0.0f, -1.0f, 0.0f) * Abs(localVelocity.z) * DOWN_FORCE);
|
|
}
|
|
|
|
void PostUpdate(float timeStep)
|
|
{
|
|
if (particleEmitterNodeList.length == 0)
|
|
return;
|
|
RaycastVehicle@ raycastVehicle = node.GetComponent("RaycastVehicle");
|
|
RigidBody@ vehicleBody = node.GetComponent("RigidBody");
|
|
Vector3 velocity = hullBody.linearVelocity;
|
|
Vector3 accel = (velocity - prevVelocity) / timeStep;
|
|
float planeAccel = Vector3(accel.x, 0.0f, accel.z).length;
|
|
for (int i = 0; i < raycastVehicle.numWheels; i++)
|
|
{
|
|
Node@ emitter = particleEmitterNodeList[i];
|
|
ParticleEmitter@ particleEmitter = emitter.GetComponent("ParticleEmitter");
|
|
if (raycastVehicle.WheelIsGrounded(i) && (raycastVehicle.GetWheelSkidInfoCumulative(i) < 0.9f || raycastVehicle.GetBrake(i) > 2.0f ||
|
|
planeAccel > 15.0f))
|
|
{
|
|
emitter.worldPosition = raycastVehicle.GetContactPosition(i);
|
|
if (!particleEmitter.emitting)
|
|
particleEmitter.emitting = true;
|
|
}
|
|
else if (particleEmitter.emitting)
|
|
particleEmitter.emitting = false;
|
|
}
|
|
prevVelocity = velocity;
|
|
}
|
|
}
|
|
|
|
// Create XML patch instructions for screen joystick layout specific to this sample app
|
|
String patchInstructions = "";
|
|
|