void SpawnObject() { var cache = GetSubsystem <ResourceCache>(); // Create a smaller box at camera position Node boxNode = scene.CreateChild("SmallBox"); boxNode.Position = CameraNode.Position; boxNode.Rotation = CameraNode.Rotation; boxNode.SetScale(0.25f); StaticModel boxObject = boxNode.CreateComponent <StaticModel>(); boxObject.Model = (cache.Get <Model>("Models/Box.mdl")); boxObject.SetMaterial(cache.Get <Material>("Materials/StoneSmall.xml")); boxObject.CastShadows = true; // Create physics components, use a smaller mass also RigidBody body = boxNode.CreateComponent <RigidBody>(); body.Mass = 0.25f; body.Friction = 0.75f; CollisionShape shape = boxNode.CreateComponent <CollisionShape>(); shape.SetBox(Vector3.One, Vector3.Zero, Quaternion.Identity); const float objectVelocity = 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.Rotation * new Vector3(0.0f, 0.25f, 1.0f) * objectVelocity); }
void CreateRagdollBone(string boneName, ShapeType type, Vector3 size, Vector3 position, Quaternion rotation) { // Find the correct child scene node recursively Node boneNode = Node.GetChild(boneName, true); if (boneNode == null) { Log.Warn($"Could not find bone {boneName} for creating ragdoll physics components"); return; } RigidBody body = boneNode.CreateComponent <RigidBody>(); // Set mass to make movable body.Mass = 1.0f; // Set damping parameters to smooth out the motion body.LinearDamping = 0.05f; body.AngularDamping = 0.85f; // Set rest thresholds to ensure the ragdoll rigid bodies come to rest to not consume CPU endlessly body.LinearRestThreshold = 1.5f; body.AngularRestThreshold = 2.5f; CollisionShape shape = boneNode.CreateComponent <CollisionShape>(); // We use either a box or a capsule shape for all of the bones if (type == ShapeType.SHAPE_BOX) { shape.SetBox(size, position, rotation); } else { shape.SetCapsule(size.X, size.Y, position, rotation); } }
public void Init() { var cache = GetSubsystem <ResourceCache>(); // This function is called only from the main program when initially creating the vehicle, not on scene load var node = Node; StaticModel hullObject = node.CreateComponent <StaticModel>(); hullBody = node.CreateComponent <RigidBody>(); CollisionShape hullShape = node.CreateComponent <CollisionShape>(); node.Scale = new Vector3(1.5f, 1.0f, 3.0f); hullObject.Model = cache.Get <Model>("Models/Box.mdl"); hullObject.SetMaterial(cache.Get <Material>("Materials/Stone.xml")); hullObject.CastShadows = true; hullShape.SetBox(Vector3.One, Vector3.Zero, Quaternion.Identity); hullBody.Mass = 4.0f; hullBody.LinearDamping = 0.2f; // Some air resistance hullBody.AngularDamping = 0.5f; hullBody.CollisionLayer = 1; InitWheel("FrontLeft", new Vector3(-0.6f, -0.4f, 0.3f), out frontLeft, out frontLeftId); InitWheel("FrontRight", new Vector3(0.6f, -0.4f, 0.3f), out frontRight, out frontRightId); InitWheel("RearLeft", new Vector3(-0.6f, -0.4f, -0.3f), out rearLeft, out rearLeftId); InitWheel("RearRight", new Vector3(0.6f, -0.4f, -0.3f), out rearRight, out rearRightId); GetWheelComponents(); }
void UpdateAnchor(Node node, ARAnchor anchor) { var planeAnchor = anchor as ARPlaneAnchor; if (planeAnchor == null) { return; } Material tileMaterial = null; Node planeNode = null; if (node == null) { var id = planeAnchor.Identifier.ToString(); node = anchorsNode.CreateChild(id); planeNode = node.CreateChild("SubPlane"); var plane = planeNode.CreateComponent <StaticModel>(); planeNode.Position = new Vector3(); plane.Model = CoreAssets.Models.Plane; tileMaterial = new Material(); tileMaterial.SetTexture(TextureUnit.Diffuse, ResourceCache.GetTexture2D("Textures/PlaneTile.png")); var tech = new Technique(); var pass = tech.CreatePass("alpha"); pass.DepthWrite = false; pass.BlendMode = BlendMode.Alpha; pass.PixelShader = "PlaneTile"; pass.VertexShader = "PlaneTile"; tileMaterial.SetTechnique(0, tech); tileMaterial.SetShaderParameter("MeshColor", new Color(Randoms.Next(), 1, Randoms.Next())); tileMaterial.SetShaderParameter("MeshAlpha", 0.75f); // set 0.0f if you want to hide them tileMaterial.SetShaderParameter("MeshScale", 32.0f); var planeRb = planeNode.CreateComponent <RigidBody>(); planeRb.Friction = 1.5f; CollisionShape shape = planeNode.CreateComponent <CollisionShape>(); shape.SetBox(Vector3.One, Vector3.Zero, Quaternion.Identity); plane.Material = tileMaterial; } else { planeNode = node.GetChild("SubPlane"); tileMaterial = planeNode.GetComponent <StaticModel>().Material; } arkitComponent.ApplyOpenTkTransform(node, planeAnchor.Transform, true); planeNode.Scale = new Vector3(planeAnchor.Extent.X, 0.1f, planeAnchor.Extent.Z); planeNode.Position = new Vector3(planeAnchor.Center.X, planeAnchor.Center.Y, -planeAnchor.Center.Z); //var animation = new ValueAnimation(); //animation.SetKeyFrame(0.0f, 0.3f); //animation.SetKeyFrame(0.5f, 0.0f); //tileMaterial.SetShaderParameterAnimation("MeshAlpha", animation, WrapMode.Once, 1.0f); //Debug.WriteLine($"ARPlaneAnchor Extent({planeAnchor.Extent}), Center({planeAnchor.Center}), Position({planeAnchor.Transform.Row3}"); }
public void CreateEntity() { _baseEntity.CreateEntity(); _node.Scale = _scale; if (!InDesign) { RigidBody rigidBody = _node.CreateComponent <RigidBody>(); rigidBody.Mass = 1.0f; rigidBody.SetAngularFactor(Vector3.Zero); CollisionShape boxShape = _node.CreateComponent <CollisionShape>(CreateMode.Local); boxShape.SetBox(_scale, _baseEntity.Position, Quaternion.Identity); rigidBody.DrawDebugGeometry(GetDebugRenderer(), false); } }
protected Node CreateRigidBullet(bool byPlayer, Vector3 collisionBox) { var carrier = Node; var bullet = carrier.Scene.CreateChild(nameof(Weapon) + GetType().Name); var carrierPos = carrier.Position; bullet.Position = carrierPos; var body = bullet.CreateComponent <RigidBody>(); CollisionShape shape = bullet.CreateComponent <CollisionShape>(); shape.SetBox(collisionBox, Vector3.Zero, Quaternion.Identity); body.Kinematic = true; body.CollisionLayer = byPlayer ? (uint)CollisionLayers.Enemy : (uint)CollisionLayers.Player; bullet.AddComponent(new WeaponReferenceComponent(this)); return(bullet); }
protected Node CreatePhysicsFloor() { var floorNode = CreateFloor(); // Make the floor physical by adding RigidBody and CollisionShape components RigidBody body = floorNode.CreateComponent <RigidBody>(); // We will be spawning spherical objects in this sample. The ground also needs non-zero rolling friction so that // the spheres will eventually come to rest body.RollingFriction = 0.15f; 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, Vector3.Zero, Quaternion.Identity); body.Restitution = 0.3f; return(floorNode); }
// l'aereo attende fino a quando non รจ esploso public Task Play() { liveTask = new TaskCompletionSource <bool>(); Health = MaxHealth; var node = Node; // gestione delle collisioni var body = node.CreateComponent <RigidBody>(); body.Mass = 1; body.Kinematic = true; body.CollisionMask = (uint)CollisionLayer; CollisionShape shape = node.CreateComponent <CollisionShape>(); shape.SetBox(CollisionShapeSize, Vector3.Zero, Quaternion.Identity); Init(); node.SubscribeToNodeCollisionStart(OnCollided); return(liveTask.Task); }
/// <summary> /// Spawn the aircraft and wait until it's exploded /// </summary> public Task Play() { _liveTask = new TaskCompletionSource <bool>(); Health = MaxHealth; var node = Node; // Define physics for handling collisions var body = node.CreateComponent <RigidBody>(); body.Mass = 1; body.Kinematic = true; body.CollisionMask = (uint)CollisionLayer; CollisionShape shape = node.CreateComponent <CollisionShape>(); shape.SetBox(CollisionShapeSize, Vector3.Zero, Quaternion.Identity); Application.InvokeOnMain(Init); node.NodeCollisionStart += OnCollided; return(_liveTask.Task); }
void CreateScene() { var cache = GetSubsystem <ResourceCache>(); scene = new Scene(); // 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(new BoundingBox(-1000.0f, 1000.0f)); zone.AmbientColor = new Color(0.15f, 0.15f, 0.15f); zone.FogColor = new Color(0.5f, 0.5f, 0.7f); zone.FogStart = 100.0f; zone.FogEnd = 300.0f; // Create a directional light to the world. Enable cascaded shadows on it Node lightNode = scene.CreateChild("DirectionalLight"); lightNode.SetDirection(new Vector3(0.6f, -1.0f, 0.8f)); Light light = lightNode.CreateComponent <Light>(); light.LightType = LightType.LIGHT_DIRECTIONAL; light.CastShadows = true; light.ShadowBias = new 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.ShadowCascade = new 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.Position = new Vector3(0.0f, -0.5f, 0.0f); floorNode.Scale = new Vector3(500.0f, 1.0f, 500.0f); StaticModel floorObject = floorNode.CreateComponent <StaticModel>(); floorObject.Model = cache.Get <Model>("Models/Box.mdl"); floorObject.SetMaterial(cache.Get <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, Vector3.Zero, Quaternion.Identity); } { // Create static mushrooms with triangle mesh collision const uint numMushrooms = 50; for (uint i = 0; i < numMushrooms; ++i) { Node mushroomNode = scene.CreateChild("Mushroom"); mushroomNode.Position = new Vector3(NextRandom(400.0f) - 200.0f, 0.0f, NextRandom(400.0f) - 200.0f); mushroomNode.Rotation = new Quaternion(0.0f, NextRandom(360.0f), 0.0f); mushroomNode.SetScale(5.0f + NextRandom(5.0f)); StaticModel mushroomObject = mushroomNode.CreateComponent <StaticModel>(); mushroomObject.Model = (cache.Get <Model>("Models/Mushroom.mdl")); mushroomObject.SetMaterial(cache.Get <Material>("Materials/Mushroom.xml")); mushroomObject.CastShadows = true; 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.Model, 0, Vector3.One, Vector3.Zero, Quaternion.Identity); } } { // Create a large amount of falling physics objects const uint numObjects = 1000; for (uint i = 0; i < numObjects; ++i) { Node boxNode = scene.CreateChild("Box"); boxNode.Position = new Vector3(0.0f, i * 2.0f + 100.0f, 0.0f); StaticModel boxObject = boxNode.CreateComponent <StaticModel>(); boxObject.Model = cache.Get <Model>("Models/Box.mdl"); boxObject.SetMaterial(cache.Get <Material>("Materials/StoneSmall.xml")); boxObject.CastShadows = true; // Give the RigidBody mass to make it movable and also adjust friction RigidBody body = boxNode.CreateComponent <RigidBody>(); body.Mass = 1.0f; body.Friction = 1.0f; // Disable collision event signaling to reduce CPU load of the physics simulation body.CollisionEventMode = CollisionEventMode.COLLISION_NEVER; CollisionShape shape = boxNode.CreateComponent <CollisionShape>(); shape.SetBox(Vector3.One, Vector3.Zero, Quaternion.Identity); } } // 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(); Camera camera = CameraNode.CreateComponent <Camera>(); camera.FarClip = 300.0f; // Set an initial position for the camera scene node above the floor CameraNode.Position = new Vector3(0.0f, 3.0f, -20.0f); }
void CreateScene() { var cache = GetSubsystem <ResourceCache>(); scene = new Scene(); // 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(new BoundingBox(-1000.0f, 1000.0f)); zone.AmbientColor = (new Color(0.15f, 0.15f, 0.15f)); zone.FogColor = new Color(0.5f, 0.5f, 0.7f); zone.FogStart = 100.0f; zone.FogEnd = 300.0f; // Create a directional light to the world. Enable cascaded shadows on it Node lightNode = scene.CreateChild("DirectionalLight"); lightNode.SetDirection(new Vector3(0.6f, -1.0f, 0.8f)); Light light = lightNode.CreateComponent <Light>(); light.LightType = LightType.LIGHT_DIRECTIONAL; light.CastShadows = true; light.ShadowBias = new 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.ShadowCascade = new 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.Position = new Vector3(0.0f, -0.5f, 0.0f); floorNode.Scale = new Vector3(500.0f, 1.0f, 500.0f); StaticModel floorObject = floorNode.CreateComponent <StaticModel>(); floorObject.Model = cache.Get <Model>("Models/Box.mdl"); floorObject.SetMaterial(cache.Get <Material>("Materials/StoneTiled.xml")); // Make the floor physical by adding RigidBody and CollisionShape components RigidBody body = floorNode.CreateComponent <RigidBody>(); // We will be spawning spherical objects in this sample. The ground also needs non-zero rolling friction so that // the spheres will eventually come to rest body.RollingFriction = 0.15f; 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, Vector3.Zero, Quaternion.Identity); } // Create the camera. Limit far clip distance to match the fog CameraNode = new Node(); CameraNode.SetName("Camera"); camera = CameraNode.CreateComponent <Camera>(); camera.FarClip = 300.0f; // Set an initial position for the camera scene node above the plane CameraNode.Position = new Vector3(0.0f, 3.0f, -20.0f); }
public override void SetTo(CollisionShape shapeComponent) { shapeComponent.SetBox(size, position, rotation); }
void CreateScene() { var cache = GetSubsystem <ResourceCache>(); scene = new Scene(); // 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(new BoundingBox(-1000.0f, 1000.0f)); zone.AmbientColor = (new Color(0.15f, 0.15f, 0.15f)); zone.FogColor = new Color(0.5f, 0.5f, 0.7f); zone.FogStart = 100.0f; zone.FogEnd = 300.0f; // Create a directional light to the world. Enable cascaded shadows on it Node lightNode = scene.CreateChild("DirectionalLight"); lightNode.SetDirection(new Vector3(0.6f, -1.0f, 0.8f)); Light light = lightNode.CreateComponent <Light>(); light.LightType = LightType.LIGHT_DIRECTIONAL; light.CastShadows = true; light.ShadowBias = new 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.ShadowCascade = new 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.Position = new Vector3(0.0f, -0.5f, 0.0f); floorNode.Scale = new Vector3(500.0f, 1.0f, 500.0f); StaticModel floorObject = floorNode.CreateComponent <StaticModel>(); floorObject.Model = cache.Get <Model>("Models/Box.mdl"); floorObject.SetMaterial(cache.Get <Material>("Materials/StoneTiled.xml")); // Make the floor physical by adding RigidBody and CollisionShape components RigidBody body = floorNode.CreateComponent <RigidBody>(); // We will be spawning spherical objects in this sample. The ground also needs non-zero rolling friction so that // the spheres will eventually come to rest body.RollingFriction = 0.15f; 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, Vector3.Zero, Quaternion.Identity); } // Create animated models for (int z = -1; z <= 1; ++z) { for (int x = -4; x <= 4; ++x) { Node modelNode = scene.CreateChild("Jack"); modelNode.Position = new Vector3(x * 5.0f, 0.0f, z * 5.0f); modelNode.Rotation = new Quaternion(0.0f, 180.0f, 0.0f); AnimatedModel modelObject = modelNode.CreateComponent <AnimatedModel>(); modelObject.Model = cache.Get <Model>("Models/Jack.mdl"); modelObject.SetMaterial(cache.Get <Material>("Materials/Jack.xml")); modelObject.CastShadows = true; // Set the model to also update when invisible to avoid staying invisible when the model should come into // view, but does not as the bounding box is not updated modelObject.UpdateInvisible = true; // Create a rigid body and a collision shape. These will act as a trigger for transforming the // model into a ragdoll when hit by a moving object RigidBody body = modelNode.CreateComponent <RigidBody>(); // The Trigger mode makes the rigid body only detect collisions, but impart no forces on the // colliding objects body.Trigger = true; CollisionShape shape = modelNode.CreateComponent <CollisionShape>(); // Create the capsule shape with an offset so that it is correctly aligned with the model, which // has its origin at the feet shape.SetCapsule(0.7f, 2.0f, new Vector3(0.0f, 1.0f, 0.0f), Quaternion.Identity); // Create a custom component that reacts to collisions and creates the ragdoll modelNode.AddComponent(new Ragdoll()); } } // Create the camera. Limit far clip distance to match the fog CameraNode = new Node(); camera = CameraNode.CreateComponent <Camera>(); camera.FarClip = 300.0f; // Set an initial position for the camera scene node above the plane CameraNode.Position = new Vector3(0.0f, 3.0f, -20.0f); }
void CreateScene() { var cache = ResourceCache; scene = new Scene(); // 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(new BoundingBox(-1000.0f, 1000.0f)); zone.AmbientColor = new Color(0.15f, 0.15f, 0.15f); zone.FogColor = new Color(1.0f, 1.0f, 1.0f); zone.FogStart = 300.0f; zone.FogEnd = 500.0f; // Create a directional light to the world. Enable cascaded shadows on it Node lightNode = scene.CreateChild("DirectionalLight"); lightNode.SetDirection(new Vector3(0.6f, -1.0f, 0.8f)); Light light = lightNode.CreateComponent <Light>(); light.LightType = LightType.Directional; light.CastShadows = true; light.ShadowBias = new 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.ShadowCascade = new 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.Model = cache.GetModel("Models/Box.mdl"); skybox.SetMaterial(cache.GetMaterial("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.Position = new Vector3(0.0f, -0.5f, 0.0f); floorNode.Scale = new Vector3(1000.0f, 1.0f, 1000.0f); StaticModel floorObject = floorNode.CreateComponent <StaticModel>(); floorObject.Model = cache.GetModel("Models/Box.mdl"); floorObject.SetMaterial(cache.GetMaterial("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 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, Vector3.Zero, Quaternion.Identity); } { // 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.Position = new Vector3((float)x, -(float)y + 8.0f, 0.0f); StaticModel boxObject = boxNode.CreateComponent <StaticModel>(); boxObject.Model = cache.GetModel("Models/Box.mdl"); boxObject.SetMaterial(cache.GetMaterial("Materials/StoneEnvMapSmall.xml")); boxObject.CastShadows = 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.Mass = 1.0f; body.Friction = 0.75f; CollisionShape shape = boxNode.CreateComponent <CollisionShape>(); shape.SetBox(Vector3.One, Vector3.Zero, Quaternion.Identity); } } } // 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(); Camera camera = CameraNode.CreateComponent <Camera>(); camera.FarClip = 500.0f; // Set an initial position for the camera scene node above the floor CameraNode.Position = (new Vector3(0.0f, 5.0f, -20.0f)); }
void CreateScene() { var cache = ResourceCache; scene = new Scene(); // Create scene subsystem components scene.CreateComponent <Octree>(); physicsWorld = 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(); Camera camera = CameraNode.CreateComponent <Camera>(); camera.FarClip = 300.0f; Renderer.SetViewport(0, new Viewport(Context, scene, camera, null)); // 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 = new Color(0.15f, 0.15f, 0.15f); zone.FogColor = new Color(0.5f, 0.5f, 0.7f); zone.FogStart = 100.0f; zone.FogEnd = 300.0f; zone.SetBoundingBox(new BoundingBox(-1000.0f, 1000.0f)); // Create a directional light with cascaded shadow mapping Node lightNode = scene.CreateChild("DirectionalLight"); lightNode.SetDirection(new Vector3(0.3f, -0.5f, 0.425f)); Light light = lightNode.CreateComponent <Light>(); light.LightType = LightType.Directional; light.CastShadows = true; light.ShadowBias = new BiasParameters(0.00025f, 0.5f); light.ShadowCascade = new CascadeParameters(10.0f, 50.0f, 200.0f, 0.0f, 0.8f); light.SpecularIntensity = 0.5f; // Create the floor object Node floorNode = scene.CreateChild("Floor"); floorNode.Position = new Vector3(0.0f, -0.5f, 0.0f); floorNode.Scale = new Vector3(200.0f, 1.0f, 200.0f); StaticModel sm = floorNode.CreateComponent <StaticModel>(); sm.Model = cache.GetModel("Models/Box.mdl"); sm.SetMaterial(cache.GetMaterial("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.CollisionLayer = 2; CollisionShape shape = floorNode.CreateComponent <CollisionShape>(); shape.SetBox(Vector3.One, Vector3.Zero, Quaternion.Identity); // Create mushrooms of varying sizes const uint numMushrooms = 60; for (uint i = 0; i < numMushrooms; ++i) { Node objectNode = scene.CreateChild("Mushroom"); objectNode.Position = new Vector3(NextRandom(180.0f) - 90.0f, 0.0f, NextRandom(180.0f) - 90.0f); objectNode.Rotation = new Quaternion(0.0f, NextRandom(360.0f), 0.0f); objectNode.SetScale(2.0f + NextRandom(5.0f)); StaticModel o = objectNode.CreateComponent <StaticModel>(); o.Model = cache.GetModel("Models/Mushroom.mdl"); o.SetMaterial(cache.GetMaterial("Materials/Mushroom.xml")); o.CastShadows = true; body = objectNode.CreateComponent <RigidBody>(); body.CollisionLayer = 2; shape = objectNode.CreateComponent <CollisionShape>(); shape.SetTriangleMesh(o.Model, 0, Vector3.One, Vector3.Zero, Quaternion.Identity); } // Create movable boxes. Let them fall from the sky at first const uint numBoxes = 100; for (uint i = 0; i < numBoxes; ++i) { float scale = NextRandom(2.0f) + 0.5f; Node objectNode = scene.CreateChild("Box"); objectNode.Position = new Vector3(NextRandom(180.0f) - 90.0f, NextRandom(10.0f) + 10.0f, NextRandom(180.0f) - 90.0f); objectNode.Rotation = new Quaternion(NextRandom(360.0f), NextRandom(360.0f), NextRandom(360.0f)); objectNode.SetScale(scale); StaticModel o = objectNode.CreateComponent <StaticModel>(); o.Model = cache.GetModel("Models/Box.mdl"); o.SetMaterial(cache.GetMaterial("Materials/Stone.xml")); o.CastShadows = true; body = objectNode.CreateComponent <RigidBody>(); body.CollisionLayer = 2; // Bigger boxes will be heavier and harder to move body.Mass = scale * 2.0f; shape = objectNode.CreateComponent <CollisionShape>(); shape.SetBox(Vector3.One, Vector3.Zero, Quaternion.Identity); } }