void CreateRagdoll::CreateRagdollBone(const String& boneName, ShapeType type, const Vector3& size, const Vector3& position,
const Quaternion& rotation)
{
// Find the correct child scene node recursively
Node* boneNode = node_->GetChild(boneName, true);
if (!boneNode)
{
URHO3D_LOGWARNING("Could not find bone " + boneName + " for creating ragdoll physics components");
return;
}
RigidBody* body = boneNode->CreateComponent<RigidBody>();
// Set mass to make movable
body->SetMass(1.0f);
// Set damping parameters to smooth out the motion
body->SetLinearDamping(0.05f);
body->SetAngularDamping(0.85f);
// Set rest thresholds to ensure the ragdoll rigid bodies come to rest to not consume CPU endlessly
body->SetLinearRestThreshold(1.5f);
body->SetAngularRestThreshold(2.5f);
CollisionShape* shape = boneNode->CreateComponent<CollisionShape>();
// We use either a box or a capsule shape for all of the bones
if (type == SHAPE_BOX)
shape->SetBox(size, position, rotation);
else
shape->SetCapsule(size.x_, size.y_, position, rotation);
}
void PhysicsStressTest::SpawnObject()
{
ResourceCache* cache = GetSubsystem<ResourceCache>();
// Create a smaller box at camera position
Node* boxNode = scene_->CreateChild("SmallBox");
boxNode->SetPosition(cameraNode_->GetPosition());
boxNode->SetRotation(cameraNode_->GetRotation());
boxNode->SetScale(0.25f);
StaticModel* boxObject = boxNode->CreateComponent<StaticModel>();
boxObject->SetModel(cache->GetResource<Model>("Models/Box.mdl"));
boxObject->SetMaterial(cache->GetResource<Material>("Materials/StoneSmall.xml"));
boxObject->SetCastShadows(true);
// Create physics components, use a smaller mass also
RigidBody* body = boxNode->CreateComponent<RigidBody>();
body->SetMass(0.25f);
body->SetFriction(0.75f);
CollisionShape* shape = boxNode->CreateComponent<CollisionShape>();
shape->SetBox(Vector3::ONE);
const float OBJECT_VELOCITY = 10.0f;
// Set initial velocity for the RigidBody based on camera forward vector. Add also a slight up component
// to overcome gravity better
body->SetLinearVelocity(cameraNode_->GetRotation() * Vector3(0.0f, 0.25f, 1.0f) * OBJECT_VELOCITY);
}
void Ragdolls::SpawnObject()
{
ResourceCache* cache = GetContext()->m_ResourceCache.get();
Node* boxNode = scene_->CreateChild("Sphere");
boxNode->SetPosition(cameraNode_->GetPosition());
boxNode->SetRotation(cameraNode_->GetRotation());
boxNode->SetScale(0.25f);
StaticModel* boxObject = boxNode->CreateComponent<StaticModel>();
boxObject->SetModel(cache->GetResource<Model>("Models/Sphere.mdl"));
boxObject->SetMaterial(cache->GetResource<Material>("Materials/StoneSmall.xml"));
boxObject->SetCastShadows(true);
RigidBody* body = boxNode->CreateComponent<RigidBody>();
body->SetMass(1.0f);
body->SetRollingFriction(0.15f);
CollisionShape* shape = boxNode->CreateComponent<CollisionShape>();
shape->SetSphere(1.0f);
const float OBJECT_VELOCITY = 10.0f;
// Set initial velocity for the RigidBody based on camera forward vector. Add also a slight up component
// to overcome gravity better
body->SetLinearVelocity(cameraNode_->GetRotation() * Vector3(0.0f, 0.25f, 1.0f) * OBJECT_VELOCITY);
}
void RagDoll::Activate()
{
//turn the whole thing on
//pawn_->GetNode()->RemoveComponent<RigidBody>();
//pawn_->GetNode()->RemoveComponent<CollisionShape>();
//pawn_->GetNode()->RemoveComponent(pawn_->GetBody());//remove the main components
//pawn_->GetNode()->RemoveComponent(pawn_->GetShape());//remove the main components
//if(node_->HasComponent<RigidBody>())
//{
//GetSubsystem<DebugHud>()->SetAppStats("state:", name_ );
node_->RemoveComponent<RigidBody>();
node_->RemoveComponent<CollisionShape>();
//}
AnimatedModel* model = node_->GetComponent<AnimatedModel>();
Skeleton& skeleton = model->GetSkeleton();
for (unsigned i = 0; i < skeleton.GetNumBones(); ++i)
skeleton.GetBone(i)->animated_ = false;
for (unsigned i = 0; i < boneNode_.Size(); ++i)
{
//URHO3D_LOGINFO(String(i));
RigidBody* rb = boneNode_[i]->GetComponent<RigidBody>();
rb->SetTrigger(false);
rb->SetMass(1.0f);
}
}
Node* SceneReplication::CreateControllableObject()
{
ResourceCache* cache = GetSubsystem<ResourceCache>();
// Create the scene node & visual representation. This will be a replicated object
Node* ballNode = scene_->CreateChild("Ball");
ballNode->SetPosition(Vector3(Random(40.0f) - 20.0f, 5.0f, Random(40.0f) - 20.0f));
ballNode->SetScale(0.5f);
StaticModel* ballObject = ballNode->CreateComponent<StaticModel>();
ballObject->SetModel(cache->GetResource<Model>("Models/Sphere.mdl"));
ballObject->SetMaterial(cache->GetResource<Material>("Materials/StoneSmall.xml"));
// Create the physics components
RigidBody* body = ballNode->CreateComponent<RigidBody>();
body->SetMass(1.0f);
body->SetFriction(1.0f);
// In addition to friction, use motion damping so that the ball can not accelerate limitlessly
body->SetLinearDamping(0.5f);
body->SetAngularDamping(0.5f);
CollisionShape* shape = ballNode->CreateComponent<CollisionShape>();
shape->SetSphere(1.0f);
// Create a random colored point light at the ball so that can see better where is going
Light* light = ballNode->CreateComponent<Light>();
light->SetRange(3.0f);
light->SetColor(Color(0.5f + (Rand() & 1) * 0.5f, 0.5f + (Rand() & 1) * 0.5f, 0.5f + (Rand() & 1) * 0.5f));
return ballNode;
}
void CharacterDemo::CreateCharacter()
{
ResourceCache* cache = GetSubsystem<ResourceCache>();
Node* objectNode = scene_->CreateChild("Jack");
objectNode->SetPosition(Vector3(0.0f, 1.0f, 0.0f));
// spin node
Node* adjustNode = objectNode->CreateChild("AdjNode");
adjustNode->SetRotation( Quaternion(180, Vector3(0,1,0) ) );
// Create the rendering component + animation controller
AnimatedModel* object = adjustNode->CreateComponent<AnimatedModel>();
object->SetModel(cache->GetResource<Model>("Models/Mutant/Mutant.mdl"));
object->SetMaterial(cache->GetResource<Material>("Models/Mutant/Materials/mutant_M.xml"));
object->SetCastShadows(true);
adjustNode->CreateComponent<AnimationController>();
// Set the head bone for manual control
object->GetSkeleton().GetBone("Mutant:Head")->animated_ = false;
// Create rigidbody, and set non-zero mass so that the body becomes dynamic
RigidBody* body = objectNode->CreateComponent<RigidBody>();
body->SetCollisionLayer(1);
body->SetMass(1.0f);
// Set zero angular factor so that physics doesn't turn the character on its own.
// Instead we will control the character yaw manually
body->SetAngularFactor(Vector3::ZERO);
// Set the rigidbody to signal collision also when in rest, so that we get ground collisions properly
body->SetCollisionEventMode(COLLISION_ALWAYS);
// Set a capsule shape for collision
CollisionShape* shape = objectNode->CreateComponent<CollisionShape>();
shape->SetCapsule(0.7f, 1.8f, Vector3(0.0f, 0.9f, 0.0f));
// Create the character logic component, which takes care of steering the rigidbody
// Remember it so that we can set the controls. Use a WeakPtr because the scene hierarchy already owns it
// and keeps it alive as long as it's not removed from the hierarchy
character_ = objectNode->CreateComponent<Character>();
}
void Vehicle::InitWheel(const String& name, const Vector3& offset, WeakPtr<Node>& wheelNode, unsigned& wheelNodeID)
{
ResourceCache* cache = GetSubsystem<ResourceCache>();
// Note: do not parent the wheel to the hull scene node. Instead create it on the root level and let the physics
// constraint keep it together
wheelNode = GetScene()->CreateChild(name);
wheelNode->SetPosition(node_->LocalToWorld(offset));
wheelNode->SetRotation(node_->GetRotation() * (offset.x_ >= 0.0 ? Quaternion(0.0f, 0.0f, -90.0f) :
Quaternion(0.0f, 0.0f, 90.0f)));
wheelNode->SetScale(Vector3(0.8f, 0.5f, 0.8f));
// Remember the ID for serialization
wheelNodeID = wheelNode->GetID();
StaticModel* wheelObject = wheelNode->CreateComponent<StaticModel>();
RigidBody* wheelBody = wheelNode->CreateComponent<RigidBody>();
CollisionShape* wheelShape = wheelNode->CreateComponent<CollisionShape>();
Constraint* wheelConstraint = wheelNode->CreateComponent<Constraint>();
wheelObject->SetModel(cache->GetResource<Model>("Models/Cylinder.mdl"));
wheelObject->SetMaterial(cache->GetResource<Material>("Materials/Stone.xml"));
wheelObject->SetCastShadows(true);
wheelShape->SetSphere(1.0f);
wheelBody->SetFriction(1.0f);
wheelBody->SetMass(1.0f);
wheelBody->SetLinearDamping(0.2f); // Some air resistance
wheelBody->SetAngularDamping(0.75f); // Could also use rolling friction
wheelBody->SetCollisionLayer(1);
wheelConstraint->SetConstraintType(CONSTRAINT_HINGE);
wheelConstraint->SetOtherBody(GetComponent<RigidBody>()); // Connect to the hull body
wheelConstraint->SetWorldPosition(wheelNode->GetPosition()); // Set constraint's both ends at wheel's location
wheelConstraint->SetAxis(Vector3::UP); // Wheel rotates around its local Y-axis
wheelConstraint->SetOtherAxis(offset.x_ >= 0.0 ? Vector3::RIGHT : Vector3::LEFT); // Wheel's hull axis points either left or right
wheelConstraint->SetLowLimit(Vector2(-180.0f, 0.0f)); // Let the wheel rotate freely around the axis
wheelConstraint->SetHighLimit(Vector2(180.0f, 0.0f));
wheelConstraint->SetDisableCollision(true); // Let the wheel intersect the vehicle hull
}
void on_tick(const interface::TickEvent &event)
{
log_d(MODULE, "entitytest::on_tick");
static uint a = 0;
if(((a++) % 100) == 0){
main_context::access(m_server, [&](main_context::Interface *imc){
Scene *scene = imc->check_scene(m_main_scene);
Node *n = scene->GetChild("Box");
n->SetPosition(Vector3(0.0f, 6.0f, 0.0f));
n->SetRotation(Quaternion(30, 60, 90));
Node *n2 = scene->GetChild("Box2");
n2->SetPosition(Vector3(-0.4f, 8.0f, 0.0f));
n2->SetRotation(Quaternion(30, 60, 90));
m_slow_count++;
if(m_slow_count == 2){
Node *n = scene->CreateChild("Box");
n->SetPosition(Vector3(0.0f, 10.0f, 0.0f));
n->SetScale(Vector3(1.0f, 1.0f, 1.0f));
RigidBody *body = n->CreateComponent<RigidBody>();
CollisionShape *shape = n->CreateComponent<CollisionShape>();
shape->SetBox(Vector3::ONE);
body->SetMass(1.0);
body->SetFriction(0.75f);
// Model and material is set on client
}
});
return;
}
main_context::access(m_server, [&](main_context::Interface *imc){
Scene *scene = imc->check_scene(m_main_scene);
Node *n = scene->GetChild("Box");
//n->Translate(Vector3(0.1f, 0, 0));
Vector3 p = n->GetPosition();
log_v(MODULE, "Position: %s", p.ToString().CString());
});
}
void PhysicsStressTest::CreateScene()
{
ResourceCache* cache = GetSubsystem<ResourceCache>();
scene_ = new Scene(context_);
// Create octree, use default volume (-1000, -1000, -1000) to (1000, 1000, 1000)
// Create a physics simulation world with default parameters, which will update at 60fps. Like the Octree must
// exist before creating drawable components, the PhysicsWorld must exist before creating physics components.
// Finally, create a DebugRenderer component so that we can draw physics debug geometry
scene_->CreateComponent<Octree>();
scene_->CreateComponent<PhysicsWorld>();
scene_->CreateComponent<DebugRenderer>();
// Create a Zone component for ambient lighting & fog control
Node* zoneNode = scene_->CreateChild("Zone");
Zone* zone = zoneNode->CreateComponent<Zone>();
zone->SetBoundingBox(BoundingBox(-1000.0f, 1000.0f));
zone->SetAmbientColor(Color(0.15f, 0.15f, 0.15f));
zone->SetFogColor(Color(0.5f, 0.5f, 0.7f));
zone->SetFogStart(100.0f);
zone->SetFogEnd(300.0f);
// Create a directional light to the world. Enable cascaded shadows on it
Node* lightNode = scene_->CreateChild("DirectionalLight");
lightNode->SetDirection(Vector3(0.6f, -1.0f, 0.8f));
Light* light = lightNode->CreateComponent<Light>();
light->SetLightType(LIGHT_DIRECTIONAL);
light->SetCastShadows(true);
light->SetShadowBias(BiasParameters(0.00025f, 0.5f));
// Set cascade splits at 10, 50 and 200 world units, fade shadows out at 80% of maximum shadow distance
light->SetShadowCascade(CascadeParameters(10.0f, 50.0f, 200.0f, 0.0f, 0.8f));
{
// Create a floor object, 500 x 500 world units. Adjust position so that the ground is at zero Y
Node* floorNode = scene_->CreateChild("Floor");
floorNode->SetPosition(Vector3(0.0f, -0.5f, 0.0f));
floorNode->SetScale(Vector3(500.0f, 1.0f, 500.0f));
StaticModel* floorObject = floorNode->CreateComponent<StaticModel>();
floorObject->SetModel(cache->GetResource<Model>("Models/Box.mdl"));
floorObject->SetMaterial(cache->GetResource<Material>("Materials/StoneTiled.xml"));
// Make the floor physical by adding RigidBody and CollisionShape components
RigidBody* body = floorNode->CreateComponent<RigidBody>();
CollisionShape* shape = floorNode->CreateComponent<CollisionShape>();
shape->SetBox(Vector3::ONE);
}
{
// Create static mushrooms with triangle mesh collision
const unsigned NUM_MUSHROOMS = 50;
for (unsigned i = 0; i < NUM_MUSHROOMS; ++i)
{
Node* mushroomNode = scene_->CreateChild("Mushroom");
mushroomNode->SetPosition(Vector3(Random(400.0f) - 200.0f, 0.0f, Random(400.0f) - 200.0f));
mushroomNode->SetRotation(Quaternion(0.0f, Random(360.0f), 0.0f));
mushroomNode->SetScale(5.0f + Random(5.0f));
StaticModel* mushroomObject = mushroomNode->CreateComponent<StaticModel>();
mushroomObject->SetModel(cache->GetResource<Model>("Models/Mushroom.mdl"));
mushroomObject->SetMaterial(cache->GetResource<Material>("Materials/Mushroom.xml"));
mushroomObject->SetCastShadows(true);
RigidBody* body = mushroomNode->CreateComponent<RigidBody>();
CollisionShape* shape = mushroomNode->CreateComponent<CollisionShape>();
// By default the highest LOD level will be used, the LOD level can be passed as an optional parameter
shape->SetTriangleMesh(mushroomObject->GetModel());
}
}
{
// Create a large amount of falling physics objects
const unsigned NUM_OBJECTS = 1000;
for (unsigned i = 0; i < NUM_OBJECTS; ++i)
{
Node* boxNode = scene_->CreateChild("Box");
boxNode->SetPosition(Vector3(0.0f, i * 2.0f + 100.0f, 0.0f));
StaticModel* boxObject = boxNode->CreateComponent<StaticModel>();
boxObject->SetModel(cache->GetResource<Model>("Models/Box.mdl"));
boxObject->SetMaterial(cache->GetResource<Material>("Materials/StoneSmall.xml"));
boxObject->SetCastShadows(true);
// Give the RigidBody mass to make it movable and also adjust friction
RigidBody* body = boxNode->CreateComponent<RigidBody>();
body->SetMass(1.0f);
body->SetFriction(1.0f);
// Disable collision event signaling to reduce CPU load of the physics simulation
body->SetCollisionEventMode(COLLISION_NEVER);
CollisionShape* shape = boxNode->CreateComponent<CollisionShape>();
shape->SetBox(Vector3::ONE);
}
}
// Create the camera. Limit far clip distance to match the fog. Note: now we actually create the camera node outside
// the scene, because we want it to be unaffected by scene load / save
cameraNode_ = new Node(context_);
Camera* camera = cameraNode_->CreateComponent<Camera>();
camera->SetFarClip(300.0f);
// Set an initial position for the camera scene node above the floor
cameraNode_->SetPosition(Vector3(0.0f, 3.0f, -20.0f));
}
void CharacterDemo::CreateScene()
{
ResourceCache* cache = GetSubsystem<ResourceCache>();
scene_ = new Scene(context_);
// Create scene subsystem components
scene_->CreateComponent<Octree>();
scene_->CreateComponent<PhysicsWorld>();
// Create camera and define viewport. We will be doing load / save, so it's convenient to create the camera outside the scene,
// so that it won't be destroyed and recreated, and we don't have to redefine the viewport on load
cameraNode_ = new Node(context_);
Camera* camera = cameraNode_->CreateComponent<Camera>();
camera->SetFarClip(300.0f);
GetSubsystem<Renderer>()->SetViewport(0, new Viewport(context_, 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->SetAmbientColor(Color(0.15f, 0.15f, 0.15f));
zone->SetFogColor(Color(0.5f, 0.5f, 0.7f));
zone->SetFogStart(100.0f);
zone->SetFogEnd(300.0f);
zone->SetBoundingBox(BoundingBox(-1000.0f, 1000.0f));
// Create a directional light with cascaded shadow mapping
Node* lightNode = scene_->CreateChild("DirectionalLight");
lightNode->SetDirection(Vector3(0.3f, -0.5f, 0.425f));
Light* light = lightNode->CreateComponent<Light>();
light->SetLightType(LIGHT_DIRECTIONAL);
light->SetCastShadows(true);
light->SetShadowBias(BiasParameters(0.00025f, 0.5f));
light->SetShadowCascade(CascadeParameters(10.0f, 50.0f, 200.0f, 0.0f, 0.8f));
light->SetSpecularIntensity(0.5f);
// Create the floor object
Node* floorNode = scene_->CreateChild("Floor");
floorNode->SetPosition(Vector3(0.0f, -0.5f, 0.0f));
floorNode->SetScale(Vector3(200.0f, 1.0f, 200.0f));
StaticModel* object = floorNode->CreateComponent<StaticModel>();
object->SetModel(cache->GetResource<Model>("Models/Box.mdl"));
object->SetMaterial(cache->GetResource<Material>("Materials/Stone.xml"));
RigidBody* body = floorNode->CreateComponent<RigidBody>();
// Use collision layer bit 2 to mark world scenery. This is what we will raycast against to prevent camera from going
// inside geometry
body->SetCollisionLayer(2);
CollisionShape* shape = floorNode->CreateComponent<CollisionShape>();
shape->SetBox(Vector3::ONE);
// Create mushrooms of varying sizes
const unsigned NUM_MUSHROOMS = 60;
for (unsigned i = 0; i < NUM_MUSHROOMS; ++i)
{
Node* objectNode = scene_->CreateChild("Mushroom");
objectNode->SetPosition(Vector3(Random(180.0f) - 90.0f, 0.0f, Random(180.0f) - 90.0f));
objectNode->SetRotation(Quaternion(0.0f, Random(360.0f), 0.0f));
objectNode->SetScale(2.0f + Random(5.0f));
StaticModel* object = objectNode->CreateComponent<StaticModel>();
object->SetModel(cache->GetResource<Model>("Models/Mushroom.mdl"));
object->SetMaterial(cache->GetResource<Material>("Materials/Mushroom.xml"));
object->SetCastShadows(true);
RigidBody* body = objectNode->CreateComponent<RigidBody>();
body->SetCollisionLayer(2);
CollisionShape* shape = objectNode->CreateComponent<CollisionShape>();
shape->SetTriangleMesh(object->GetModel(), 0);
}
// Create movable boxes. Let them fall from the sky at first
const unsigned NUM_BOXES = 100;
for (unsigned i = 0; i < NUM_BOXES; ++i)
{
float scale = Random(2.0f) + 0.5f;
Node* objectNode = scene_->CreateChild("Box");
objectNode->SetPosition(Vector3(Random(180.0f) - 90.0f, Random(10.0f) + 10.0f, Random(180.0f) - 90.0f));
objectNode->SetRotation(Quaternion(Random(360.0f), Random(360.0f), Random(360.0f)));
objectNode->SetScale(scale);
StaticModel* object = objectNode->CreateComponent<StaticModel>();
object->SetModel(cache->GetResource<Model>("Models/Box.mdl"));
object->SetMaterial(cache->GetResource<Material>("Materials/Stone.xml"));
object->SetCastShadows(true);
RigidBody* body = objectNode->CreateComponent<RigidBody>();
body->SetCollisionLayer(2);
// Bigger boxes will be heavier and harder to move
body->SetMass(scale * 2.0f);
CollisionShape* shape = objectNode->CreateComponent<CollisionShape>();
shape->SetBox(Vector3::ONE);
}
}
void Physics::CreateScene()
{
ResourceCache* cache = GetSubsystem<ResourceCache>();
scene_ = new Scene(context_);
// Create octree, use default volume (-1000, -1000, -1000) to (1000, 1000, 1000)
// Create a physics simulation world with default parameters, which will update at 60fps. Like the Octree must
// exist before creating drawable components, the PhysicsWorld must exist before creating physics components.
// Finally, create a DebugRenderer component so that we can draw physics debug geometry
scene_->CreateComponent<Octree>();
scene_->CreateComponent<PhysicsWorld>();
scene_->CreateComponent<DebugRenderer>();
// Create a Zone component for ambient lighting & fog control
Node* zoneNode = scene_->CreateChild("Zone");
Zone* zone = zoneNode->CreateComponent<Zone>();
zone->SetBoundingBox(BoundingBox(-1000.0f, 1000.0f));
zone->SetAmbientColor(Color(0.15f, 0.15f, 0.15f));
zone->SetFogColor(Color(1.0f, 1.0f, 1.0f));
zone->SetFogStart(300.0f);
zone->SetFogEnd(500.0f);
// Create a directional light to the world. Enable cascaded shadows on it
Node* lightNode = scene_->CreateChild("DirectionalLight");
lightNode->SetDirection(Vector3(0.6f, -1.0f, 0.8f));
Light* light = lightNode->CreateComponent<Light>();
light->SetLightType(LIGHT_DIRECTIONAL);
light->SetCastShadows(true);
light->SetShadowBias(BiasParameters(0.00025f, 0.5f));
// Set cascade splits at 10, 50 and 200 world units, fade shadows out at 80% of maximum shadow distance
light->SetShadowCascade(CascadeParameters(10.0f, 50.0f, 200.0f, 0.0f, 0.8f));
// Create skybox. The Skybox component is used like StaticModel, but it will be always located at the camera, giving the
// illusion of the box planes being far away. Use just the ordinary Box model and a suitable material, whose shader will
// generate the necessary 3D texture coordinates for cube mapping
Node* skyNode = scene_->CreateChild("Sky");
skyNode->SetScale(500.0f); // The scale actually does not matter
Skybox* skybox = skyNode->CreateComponent<Skybox>();
skybox->SetModel(cache->GetResource<Model>("Models/Box.mdl"));
skybox->SetMaterial(cache->GetResource<Material>("Materials/Skybox.xml"));
{
// Create a floor object, 1000 x 1000 world units. Adjust position so that the ground is at zero Y
Node* floorNode = scene_->CreateChild("Floor");
floorNode->SetPosition(Vector3(0.0f, -0.5f, 0.0f));
floorNode->SetScale(Vector3(1000.0f, 1.0f, 1000.0f));
StaticModel* floorObject = floorNode->CreateComponent<StaticModel>();
floorObject->SetModel(cache->GetResource<Model>("Models/Box.mdl"));
floorObject->SetMaterial(cache->GetResource<Material>("Materials/StoneTiled.xml"));
// Make the floor physical by adding RigidBody and CollisionShape components. The RigidBody's default
// parameters make the object static (zero mass.) Note that a CollisionShape by itself will not participate
// in the physics simulation
/*RigidBody* body = */floorNode->CreateComponent<RigidBody>();
CollisionShape* shape = floorNode->CreateComponent<CollisionShape>();
// Set a box shape of size 1 x 1 x 1 for collision. The shape will be scaled with the scene node scale, so the
// rendering and physics representation sizes should match (the box model is also 1 x 1 x 1.)
shape->SetBox(Vector3::ONE);
}
{
// Create a pyramid of movable physics objects
for (int y = 0; y < 8; ++y)
{
for (int x = -y; x <= y; ++x)
{
Node* boxNode = scene_->CreateChild("Box");
boxNode->SetPosition(Vector3((float)x, -(float)y + 8.0f, 0.0f));
StaticModel* boxObject = boxNode->CreateComponent<StaticModel>();
boxObject->SetModel(cache->GetResource<Model>("Models/Box.mdl"));
boxObject->SetMaterial(cache->GetResource<Material>("Materials/StoneEnvMapSmall.xml"));
boxObject->SetCastShadows(true);
// Create RigidBody and CollisionShape components like above. Give the RigidBody mass to make it movable
// and also adjust friction. The actual mass is not important; only the mass ratios between colliding
// objects are significant
RigidBody* body = boxNode->CreateComponent<RigidBody>();
body->SetMass(1.0f);
body->SetFriction(0.75f);
CollisionShape* shape = boxNode->CreateComponent<CollisionShape>();
shape->SetBox(Vector3::ONE);
}
}
}
// Create the camera. Set far clip to match the fog. Note: now we actually create the camera node outside the scene, because
// we want it to be unaffected by scene load / save
cameraNode_ = new Node(context_);
Camera* camera = cameraNode_->CreateComponent<Camera>();
camera->SetFarClip(500.0f);
// Set an initial position for the camera scene node above the floor
cameraNode_->SetPosition(Vector3(0.0f, 5.0f, -20.0f));
}
//-------------------
//-------------------
void Stage2::Setup(SharedPtr<Scene> scene, SharedPtr<Node> cameraNode)
{
const String states_[50] =
{
String("state_1.001.mdl"),
String("state_2.001.mdl"),
String("state_3.001.mdl"),
String("state_4.001.mdl"),
String("state_5.001.mdl"),
String("state_6.001.mdl"),
String("state_7.001.mdl"),
String("state_8.001.mdl"),
String("state_9.001.mdl"),
String("state_10.001.mdl"),
String("state_11.001.mdl"),
String("state_12.001.mdl"),
String("state_13.001.mdl"),
String("state_14.001.mdl"),
String("state_15.001.mdl"),
String("state_16.001.mdl"),
String("state_17.001.mdl"),
String("state_18.001.mdl"),
String("state_19.001.mdl"),
String("state_20.001.mdl"),
String("state_21.001.mdl"),
String("state_22.001.mdl"),
String("state_23.001.mdl"),
String("state_24.001.mdl"),
String("state_25.001.mdl"),
String("state_26.001.mdl"),
String("state_27.001.mdl"),
String("state_28.001.mdl"),
String("state_29.001.mdl"),
String("state_30.001.mdl"),
String("state_31.001.mdl"),
String("state_32.001.mdl"),
String("state_33.001.mdl"),
String("state_34.001.mdl"),
String("state_35.001.mdl"),
String("state_36.001.mdl"),
String("state_37.001.mdl"),
String("state_38.001.mdl"),
String("state_39.001.mdl"),
String("state_40.001.mdl"),
String("state_41.001.mdl"),
String("state_42.001.mdl"),
String("state_43.001.mdl"),
String("state_44.001.mdl"),
String("state_45.001.mdl"),
String("state_46.001.mdl"),
String("state_47.001.mdl"),
String("state_48.001.mdl"),
String("state_49.001.mdl"),
String("state_50.001.mdl")
};
const Vector3 positions_[50] =
{
Vector3(0.21888011694f,0.0156500004232f,2.09723997116f),
Vector3(2.54229521751f,-0.00904999952763f,1.75292992592f),
Vector3(2.41885995865f,-0.00999999977648f,1.90676009655f),
Vector3(0.673485100269f,0.0166000016034f,2.30860519409f),
Vector3(0.369050145149f,0.0175500009209f,1.11237001419f),
Vector3(0.516425132751f,0.0185000002384f,0.181779891253f),
Vector3(0.423860132694f,0.0185000002384f,0.481095075607f),
Vector3(0.577625155449f,0.0185000002384f,1.04367494583f),
Vector3(0.837990105152f,0.0185000002384f,1.52935504913f),
Vector3(0.935640096664f,0.0185000002384f,1.02947998047f),
Vector3(0.837135195732f,0.0185000002384f,0.446817427874f),
Vector3(1.17873501778f,0.0185000002384f,0.342575073242f),
Vector3(1.26694011688f,0.0185000002384f,0.743340015411f),
Vector3(1.27813506126f,0.0185000002384f,1.56136512756f),
Vector3(1.73834013939f,0.0175500009209f,1.89084005356f),
Vector3(1.36196017265f,0.0185000002384f,1.13154006004f),
Vector3(1.85952007771f,0.0185000002384f,1.51079499722f),
Vector3(1.88827514648f,0.000450000166893f,1.21628499031f),
Vector3(1.77227497101f,0.0175500009209f,0.656964957714f),
Vector3(1.77993512154f,-0.00144999939948f,0.365104973316f),
Vector3(2.22174501419f,-0.0052499989979f,0.468360185623f),
Vector3(2.69981503487f,-0.0052499989979f,0.614735066891f),
Vector3(2.4618601799f,-0.0052499989979f,0.627650141716f),
Vector3(2.53034496307f,-0.00810000021011f,1.0825150013f),
Vector3(2.75453519821f,-0.00714999902993f,1.07339000702f),
Vector3(2.99251008034f,-0.00714999902993f,0.980669975281f),
Vector3(3.74992036819f,-0.00810000021011f,0.702120065689f),
Vector3(3.66952991486f,-0.00619999971241f,0.732804954052f),
Vector3(3.72557497025f,-0.00619999971241f,0.641584992409f),
Vector3(3.53317499161f,-0.00904999952763f,1.00545012951f),
Vector3(3.5650601387f,-0.00619999971241f,0.886059999466f),
Vector3(3.40220499039f,-0.00429999921471f,1.02564501762f),
Vector3(3.82462024689f,-0.00239999918267f,0.349364906549f),
Vector3(3.70352506638f,-0.0052499989979f,0.491724967957f),
Vector3(3.60558986664f,-0.0052499989979f,0.511260032654f),
Vector3(3.44979000092f,-0.00429999921471f,0.630430102348f),
Vector3(3.3455851078f,-0.0052499989979f,0.875915110111f),
Vector3(2.3500752449f,-0.0052499989979f,1.56273007393f),
Vector3(3.1991353035f,-0.00144999939948f,1.08977997303f),
Vector3(3.26395010948f,-0.00144999939948f,1.17536497116f),
Vector3(2.79603528976f,-0.00714999902993f,1.73529994488f),
Vector3(2.81455516815f,-0.00144999939948f,1.42764496803f),
Vector3(3.25786995888f,-0.00144999939948f,1.38491988182f),
Vector3(3.21765995026f,-0.00619999971241f,1.58336496353f),
Vector3(3.04369020462f,-0.00429999921471f,1.68953490257f),
Vector3(3.07175517082f,-0.00999999977648f,2.11033010483f),
Vector3(1.79783010483f,0.0185000002384f,0.926185011864f),
Vector3(2.24017524719f,-0.00619999971241f,0.882490038872f),
Vector3(2.32092523575f,-0.0052499989979f,1.23307991028f),
Vector3(2.81634521484f,-0.00429999921471f,1.25435996056f)
};
scene_ = scene;
cameraNode_ = cameraNode;
ResourceCache* cache = GetSubsystem<ResourceCache>();
// Create scene node & StaticModel component for showing a static plane
/*Node* planeNode = scene_->CreateChild("Plane");
planeNode->SetScale(Vector3(100.0f, 1.0f, 100.0f));
StaticModel* planeObject = planeNode->CreateComponent<StaticModel>();
planeObject->SetModel(cache->GetResource<Model>("Models/Plane.mdl"));
planeObject->SetMaterial(cache->GetResource<Material>("Materials/StoneTiled.xml"));*/
// Create a Zone component for ambient lighting & fog control
Node* zoneNode = scene_->CreateChild("Zone");
Zone* zone = zoneNode->CreateComponent<Zone>();
zone->SetBoundingBox(BoundingBox(-1000.0f, 1000.0f));
zone->SetAmbientColor(Color(0.15f, 0.15f, 0.15f));
zone->SetFogColor(Color(0.5f, 0.5f, 0.7f));
zone->SetFogStart(100.0f);
zone->SetFogEnd(300.0f);
// Create a directional light to the world. Enable cascaded shadows on it
Node* lightNode = scene_->CreateChild("DirectionalLight");
lightNode->SetDirection(Vector3(0.6f, -1.0f, 0.8f));
Light* light = lightNode->CreateComponent<Light>();
light->SetLightType(LIGHT_DIRECTIONAL);
light->SetCastShadows(true);
light->SetShadowBias(BiasParameters(0.00025f, 0.5f));
// Set cascade splits at 10, 50 and 200 world units, fade shadows out at 80% of maximum shadow distance
light->SetShadowCascade(CascadeParameters(10.0f, 50.0f, 200.0f, 0.0f, 0.8f));
// Create animated models
/*const unsigned NUM_MODELS = 100;
const float MODEL_MOVE_SPEED = 2.0f;
const float MODEL_ROTATE_SPEED = 100.0f;
const BoundingBox bounds(Vector3(-47.0f, 0.0f, -47.0f), Vector3(47.0f, 0.0f, 47.0f));
for (unsigned i = 0; i < NUM_MODELS; ++i)
{
Node* modelNode = scene_->CreateChild("Jack");
modelNode->SetPosition(Vector3(Random(90.0f) - 45.0f, 0.0f, Random(90.0f) - 45.0f));
modelNode->SetRotation(Quaternion(0.0f, Random(360.0f), 0.0f));
AnimatedModel* modelObject = modelNode->CreateComponent<AnimatedModel>();
modelObject->SetModel(cache->GetResource<Model>("Models/Jack.mdl"));
modelObject->SetMaterial(cache->GetResource<Material>("Materials/Jack.xml"));
modelObject->SetCastShadows(true);
// Create an AnimationState for a walk animation. Its time position will need to be manually updated to advance the
// animation, The alternative would be to use an AnimationController component which updates the animation automatically,
// but we need to update the model's position manually in any case
Animation* walkAnimation = cache->GetResource<Animation>("Models/Jack_Walk.ani");
AnimationState* state = modelObject->AddAnimationState(walkAnimation);
// The state would fail to create (return null) if the animation was not found
if (state)
{
// Enable full blending weight and looping
state->SetWeight(1.0f);
state->SetLooped(true);
}
// Create our custom Mover component that will move & animate the model during each frame's update
//Mover* mover = modelNode->CreateComponent<Mover>();
//mover->SetParameters(MODEL_MOVE_SPEED, MODEL_ROTATE_SPEED, bounds);
}*/
{
Node* floorNode = scene_->CreateChild("Floor");
floorNode->SetPosition(Vector3(0.0f, -1.0f, 0.0f));
floorNode->SetScale(Vector3(1000.0f, 1.0f, 1000.0f));
StaticModel* floorObject = floorNode->CreateComponent<StaticModel>();
floorObject->SetModel(cache->GetResource<Model>("Models/Box.mdl"));
floorObject->SetMaterial(cache->GetResource<Material>("Materials/StoneTiled.xml"));
// Make the floor physical by adding RigidBody and CollisionShape components. The RigidBody's default
// parameters make the object static (zero mass.) Note that a CollisionShape by itself will not participate
// in the physics simulation
/*RigidBody* body = */floorNode->CreateComponent<RigidBody>();
CollisionShape* shape = floorNode->CreateComponent<CollisionShape>();
// Set a box shape of size 1 x 1 x 1 for collision. The shape will be scaled with the scene node scale, so the
// rendering and physics representation sizes should match (the box model is also 1 x 1 x 1.)
shape->SetBox(Vector3::ONE);
}
for (unsigned j=0; j<50; ++j)
{
Node* stateNode = scene_->CreateChild("state");
Vector3 corrected = Vector3(positions_[j].z_,positions_[j].y_,positions_[j].x_)*10.0f;
stateNode->SetPosition(corrected);
StaticModel* stateModel = stateNode->CreateComponent<StaticModel>();
//stateModel->SetModel( cache->GetResource<Model>(String("Models/States/")+states_[j]) );
stateModel->SetModel( cache->GetResource<Model>(String("Models/States/state_"+String(j+1)+".001.mdl") ) );
RigidBody* body = stateNode->CreateComponent<RigidBody>();
body->SetMass(1.0f);
body->SetFriction(0.75f);
CollisionShape* sshape = stateNode->CreateComponent<CollisionShape>();
sshape->SetConvexHull(cache->GetResource<Model>(String("Models/States/state_convex_"+String(j+1)+".001.mdl") ));
//LOGINFO(positions_[j].ToString());
stateNode->SetPosition(stateNode->GetWorldPosition()+Vector3(0.0f,20.0f+float(j)*0.5,0.0f));
}
/*Node* stateNode = scene_->CreateChild("state");
stateNode->SetPosition(positions_[0]);
StaticModel* stateModel = stateNode->CreateComponent<StaticModel>();
stateModel->SetModel( cache->GetResource<Model>(String("Models/States/")+states_[0]) );*/
// Create the camera. Limit far clip distance to match the fog
//cameraNode_ = scene_->CreateChild("Camera");
//Camera* camera = cameraNode_->CreateComponent<Camera>();
//camera->SetFarClip(300.0f);
// Set an initial position for the camera scene node above the plane
cameraNode_->SetPosition(Vector3(0.0f, 5.0f, 0.0f));
//give the camera the logic I want
//CameraLogic* cameralogic = cameraNode_->CreateComponent<CameraLogic>();
}
