Esempio n. 1
0
        void CreateScene()
        {
            var cache = ResourceCache;

            Input.TouchEnd += OnTouched;


            switch (Device.RuntimePlatform)
            {
            case Device.iOS:
                Debug.WriteLine("DEVICE : iOS");
                break;

            case Device.Android:
                Debug.WriteLine("DEVICE : Android");
                break;

            case Device.UWP:
            default:
                Debug.WriteLine("DEVICE : UWP");
                break;
            }



            scene  = new Scene();
            octree = scene.CreateComponent <Octree>();

            plotNode = scene.CreateChild();
            var baseNode = plotNode.CreateChild().CreateChild();
            var plane    = baseNode.CreateComponent <StaticModel>();

            plane.Model = CoreAssets.Models.Plane;


            // Create a Zone component for ambient lighting & fog control
            var zoneNode = scene.CreateChild("Zone");
            var zone     = zoneNode.CreateComponent <Zone>();

            // Set same volume as the Octree, set a close bluish fog and some ambient light
            zone.SetBoundingBox(new BoundingBox(-1000.0f, 1000.0f));
            zone.AmbientColor = new Urho.Color(0.15f, 0.15f, 0.15f);
            zone.FogColor     = new Urho.Color(0.5f, 0.5f, 0.9f);
            zone.FogStart     = 50;
            zone.FogEnd       = 300;

            // 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("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, -2.0f, 0.0f);
             * floorNode.Scale = new Vector3(100.0f, 1.0f, 100.0f);
             * StaticModel floorObject = floorNode.CreateComponent<StaticModel>();
             * floorObject.Model = cache.GetModel("Models/Box.mdl");
             * floorObject.SetMaterial(cache.GetMaterial("Materials/StoneTiled.xml"));
             */


            // Create a FLOOR object, 1000 x 1000 world units. Adjust position so that the ground is at zero Y
            Node floorNode = scene.CreateChild();

            floorNode.Position = new Vector3(0.0f, -2.0f, 0.0f);
            floorNode.Scale    = new Vector3(100.0f, 0.001f, 100.0f);
            var floor = floorNode.CreateComponent <Box>();

            floor.Color = new Urho.Color(0.2f, 0.2f, 0.2f, 1.0f);
            var ii = cache.GetImage("grass.jpg");
            var mm = Material.FromImage(ii);

            floor.SetMaterial(mm);



            // Create a directional LIGHT to the world. Enable cascaded shadows on it
            var DirlightNode = scene.CreateChild("DirectionalLight");

            DirlightNode.SetDirection(new Vector3(0.6f, -1.0f, 0.8f));
            var Dirlight = DirlightNode.CreateComponent <Light>();

            Dirlight.LightType   = LightType.Directional;
            Dirlight.CastShadows = true;
            Dirlight.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
            Dirlight.ShadowCascade = new CascadeParameters(10.0f, 50.0f, 200.0f, 0.0f, 0.8f);


            cameraNode          = scene.CreateChild();
            camera              = cameraNode.CreateComponent <Camera>();
            cameraNode.Position = new Vector3(0, 3, -13) / 1.75f;

            cameraNode.SetDirection(new Vector3(0, -3, 10));             // looking towards what point (x,y,z)

            Node lightNode = cameraNode.CreateChild();
            var  light     = lightNode.CreateComponent <Light>();

            light.LightType  = LightType.Point;
            light.Range      = 100;
            light.Brightness = 1.3f;


            // Draw a 3d reference
            New3Dtext(1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, "x...", plotNode, "3DlabeelX");
            New3Dtext(0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 90.0f, "y...", plotNode, "3DlabeelY");
            New3Dtext(0.0f, 0.0f, 1.0f, 0.0f, -90.0f, 0.0f, "z...", plotNode, "3DlabeelZ");

            // Write a text on a static place

            var staticObject = baseNode.CreateComponent <StaticModel>();

            plane.Model = CoreAssets.Models.Plane;


            // defining static cube
            staticNode = scene.CreateChild();
            New3Dtext(-2.0f, 2.0f, -2.0f, 0.0f, 0.0f, 0.0f, "*", staticNode, "ful");
            New3Dtext(2.0f, 2.0f, -2.0f, 0.0f, 0.0f, 0.0f, "*", staticNode, "fur");
            New3Dtext(-2.0f, -2.0f, -2.0f, 0.0f, 0.0f, 0.0f, "*", staticNode, "fll");
            New3Dtext(2.0f, -2.0f, -2.0f, 0.0f, 0.0f, 0.0f, "*", staticNode, "flr");
            New3Dtext(-2.0f, 2.0f, 2.0f, 0.0f, 0.0f, 0.0f, "*", staticNode, "bul");
            New3Dtext(2.0f, 2.0f, 2.0f, 0.0f, 0.0f, 0.0f, "*", staticNode, "bur");
            New3Dtext(-2.0f, -2.0f, 2.0f, 0.0f, 0.0f, 0.0f, "*", staticNode, "bll");
            New3Dtext(2.0f, -2.0f, 2.0f, 0.0f, 0.0f, 0.0f, "*", staticNode, "blr");

            var sphere = plotNode.CreateComponent <Sphere>();
            var i      = cache.GetImage("world.png");
            var m      = Material.FromImage(i);

            sphere.SetMaterial(m);

            var boxNode = staticNode.CreateChild();

            boxNode.Position = new Vector3(2.0f, 2.0f, -2.0f);
            var box = new Button("bigger", new Urho.Color(0.0f, 0.0f, 1.0f, 1.0f));

            boxNode.AddComponent(box);

            boxNode          = staticNode.CreateChild();
            boxNode.Position = new Vector3(-2.0f, 2.0f, -2.0f);
            box = new Button("smaller", new Urho.Color(1.0f, 0.0f, 0.0f, 1.0f));
            boxNode.AddComponent(box);

            boxNode          = staticNode.CreateChild();
            boxNode.Position = new Vector3(-2.0f, 2.0f, 2.0f);
            box = new Button("turn", new Urho.Color(0.0f, 1.0f, 0.0f, 1.0f));
            boxNode.AddComponent(box);

            New3Dtext(2.0f, 0.5f, -2.0f, 0.0f, 0.0f, 0.0f, "NumTouches= *\nDevice.Android= \nInput.MouseVisible=", staticNode, "displTouches");
            New3Dtext(0.0f, 0.5f, -2.0f, 0.0f, 0.0f, 0.0f, "Activated:", staticNode, "displActivated");

            var room  = new Room(new Vector3(4.0f, 0.0f, 0.0f), new Vector3(4.0f, 3.0f, 2.0f), new Vector3(0.0f, 0.0f, 0.0f), "Room1", staticNode);
            var room2 = new Room(new Vector3(-3.0f, -3.0f, -3.0f), new Vector3(6.0f, 6.0f, 6.0f), new Vector3(0.0f, 0.0f, 0.0f), "Room2", plotNode);
            var room3 = new Room(new Vector3(-2.0f, -2.0f, -2.0f), new Vector3(4.0f, 4.0f, 4.0f), new Vector3(0.0f, 45.0f, 0.0f), "Room3", plotNode);

            movementsEnabled = true;
        }
Esempio n. 2
0
        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));
        }