public override void Init()
        {
            Content.ContentPath = "Data";

            Instance = this;

            Scene = new Scene();
            Scene.View = this;
            Scene.Camera = new LookatCartesianCamera()
            {
                Position = new Vector3(10, 10, 10),
                Lookat = Vector3.Zero,
                ZFar = 100,
                AspectRatio = AspectRatio
            };
            sceneQuadtree = new Common.Quadtree<Entity>(0, 0, 100, 100, 10);
            sbau = new SceneBVHAutoSyncer(Scene, sceneQuadtree);

            StateManager = new Device9StateManager(Device9);

            Graphics.Renderer.IRenderer Renderer = new Graphics.Renderer.Renderer(Device9)
            {
                Scene = Scene,
                StateManager = StateManager,
                Settings = new Graphics.Renderer.Settings()
                {
                    FogDistance = 100,
                    WaterLevel = -55
                }
            };

            SRC = new SortedTestSceneRendererConnector
            {
                Scene = Scene,
                Renderer = Renderer,
            };

            Renderer.Initialize(Scene.View);
            SRC.Initialize();

            Scene.Add(exquemelin = new Entity
            {
                MainGraphic = new Graphics.Content.MetaModel
                {
                    SkinnedMesh = new Graphics.Content.SkinnedMeshFromFile("Models/Units/MainCharacter1.x"),
                    Texture = new Graphics.Content.TextureFromFile("Models/Units/MainCharacter1.png"),
                    World = Matrix.Scaling(0.5f, 0.5f, 0.5f) * Graphics.Content.SkinnedMesh.InitSkinnedMeshFromMaya * Matrix.Translation(0, 0, -4f),
                },
                VisibilityLocalBounding = new Common.Bounding.NonfittableBounding(Vector3.Zero, false, true)

            });

            InputHandler = new WalkaroundCameraInputHandler
            {
                Camera = (LookatCartesianCamera)Scene.Camera,
            };
        }
        public override void Init()
        {
            Content.ContentPath = "Data";

            Scene = new Scene();
            Scene.View = this;
            Scene.Camera = new LookatCartesianCamera()
            {
                Position = new Vector3(10, 10, 10),
                Lookat = Vector3.Zero,
                ZFar = 100,
                AspectRatio = AspectRatio
            };
            sceneQuadtree = new Common.Quadtree<Entity>(10);
            sbau = new SceneBVHAutoSyncer(Scene, sceneQuadtree);

            StateManager = new Device9StateManager(Device9);

            Renderer = new Graphics.Renderer.Renderer(Device9) { Scene = Scene, StateManager = StateManager, Settings = new Graphics.Renderer.Settings { ShadowQuality = Graphics.Renderer.Settings.ShadowQualities.NoShadows } };
            Renderer.Initialize(this);
            sceneRendererConnector = new SortedTestSceneRendererConnector
            {
                Scene = Scene,
                Renderer = Renderer
            };
            sceneRendererConnector.Initialize();

            Scene.Add(exquemelin = new Entity
            {
                MainGraphic = new Graphics.Content.MetaModel
                {
                    SkinnedMesh = new Graphics.Content.SkinnedMeshFromFile("Models/Units/Zombie1.x"),
                    Texture = new Graphics.Content.TextureFromFile("Models/Units/Zombie1.png"),
                    World = Graphics.Content.SkinnedMesh.InitSkinnedMeshFromMaya * Matrix.Scaling(0.5f, 0.5f, 0.5f),
                    HasAlpha = false,
                },
                VisibilityLocalBounding = new Common.Bounding.NonfittableBounding(Vector3.Zero, false, true)
            });

            Graphics.Renderer.Renderer.EntityAnimation ea = Scene.View.Content.Peek<Graphics.Renderer.Renderer.EntityAnimation>(exquemelin.MetaEntityAnimation);

            ea.PlayAnimation(new AnimationPlayParameters("Idle1", true));

            InputHandler = new WalkaroundCameraInputHandler
            {
                Camera = (LookatCartesianCamera)Scene.Camera,
            };
        }
        public override void Init()
        {
            Content.ContentPath = "Data";
            Instance = this;

            scene = new Scene();
            scene.DesignMode = true;
            scene.View = this;
            scene.Camera = new LookatCartesianCamera()
            {
                ZFar = 100,
                AspectRatio = AspectRatio
            };
            ((LookatCamera)scene.Camera).Lookat = new Vector3(SceneSize.Width / 2f, SceneSize.Height / 2f, 0);
            ((LookatCamera)scene.Camera).Position = ((LookatCamera)scene.Camera).Lookat + new Vector3(10, 10, 10);
            scene.EntityAdded += new Action<Entity>(scene_EntityAdded);
            scene.EntityRemoved += new Action<Entity>(scene_EntityRemoved);
            sceneQuadtree = new Common.Quadtree<Entity>(0, 0, SceneSize.Width, SceneSize.Height, 10);
            sbau = new SceneBVHAutoSyncer(scene, sceneQuadtree);

            renderer = new Graphics.Renderer.Renderer(Device9) { Scene = scene, StateManager = new Device9StateManager(Device9) };
            renderer.Initialize(this);
            sceneRendererConnector = new SortedTestSceneRendererConnector
            {
                Scene = scene,
                Renderer = renderer
            };
            sceneRendererConnector.Initialize();

            InputHandler = new WalkaroundCameraInputHandler
            {
                Camera = (LookatCartesianCamera)scene.Camera,
                InputHandler = new Graphics.InteractiveSceneManager { Scene = scene },
            };

            timer = new System.Windows.Forms.Timer();
            timer.Tick += new EventHandler(timer_Tick);
            timer.Interval = 1;
            timer.Enabled = true;

            RedGate.Profiler.UserEvents.ProfilerEvent.SignalEvent("Starting to add initial objects");
            for (int i = 0; i < nInitialEntities; i++)
                CreateRandomTestEntity();
            RedGate.Profiler.UserEvents.ProfilerEvent.SignalEvent("Starting CRUSHING!");
        }
        public override void Init()
        {
            Content.ContentPath = "Data";

            scene = new Scene();
            scene.View = this;
            scene.Camera = new LookatCartesianCamera
            {
                Position = new Vector3(-5, 5, 5),
            };

            foreach (var v in scene.AllEntities)
                v.VisibilityLocalBounding = Content.Acquire<Graphics.Content.StructBoxer<BoundingBox>>(v.MainGraphic).Value;

            var stateManager = new Device9StateManager(Device9);
            renderer = new Graphics.Renderer.Renderer(Device9) { Scene = scene, StateManager = stateManager };
            renderer.Initialize(this);

            sceneRendererConnector = new SortedTestSceneRendererConnector
            {
                Scene = scene,
                Renderer = renderer
            };
            sceneRendererConnector.Initialize();

            editor = new Graphics.Editors.SceneEditor { Scene = scene };
            editorRenderer = new Graphics.Editors.SceneEditor.Renderer9(editor)
            {
                BoundingVolumesRenderer = new BoundingVolumesRenderer
                {
                    StateManager = stateManager,
                    View = this
                }
            };

            InputHandler = editor;

            Entity e;
            scene.Add(e = new Entity
            {
                MainGraphic = new MetaModel
                {
                    XMesh = new MeshFromFile("Models/Props/Barrel1.x"),
                    Texture = new TextureFromFile("Models/Props/Barrel1.png"),
                    World = Matrix.Scaling(0.1f, 0.1f, 0.1f) * SkinnedMesh.InitSkinnedMeshFromMaya * Matrix.Translation(1, 0, 0)
                },
            });
            e.VisibilityLocalBounding = CreateBoundingBoxFromModel((MetaModel)e.MainGraphic);
            e.PickingLocalBounding = CreateBoundingMeshFromModel(e, (MetaModel)e.MainGraphic);

            scene.Add(e = new Entity
            {
                MainGraphic = new MetaModel
                {
                    SkinnedMesh = new SkinnedMeshFromFile("Models/Props/Bridge1.x"),
                    Texture = new TextureFromFile("Models/Props/Bridge1.png"),
                    World = Matrix.Scaling(0.1f, 0.1f, 0.1f) * SkinnedMesh.InitSkinnedMeshFromMaya *
                        Matrix.Translation(3, 0, 0)
                },
            });
            e.VisibilityLocalBounding = CreateBoundingBoxFromModel((MetaModel)e.MainGraphic);
            e.PickingLocalBounding = CreateBoundingMeshFromModel(e, (MetaModel)e.MainGraphic);
        }
        void Setup()
        {
            Scene = new Scene();
            GameState = GameState.Playing;
            InterfaceIngameScene = new Scene();
            Scene.View = InterfaceIngameScene.View = Program.Instance;
            Scene.Camera = InterfaceIngameScene.Camera = new LookatSphericalCamera()
            {
                Lookat = new Vector3(0, 0, 0),
                Position = new Vector3(10, 10, 10),
                FOV = Program.Settings.CameraFOV,
                ZFar = 20,
                ZNear = Program.Settings.CameraZNear,
                AspectRatio = Program.Instance.AspectRatio
            };
            CameraController = new CameraController { Camera = (LookatSphericalCamera)Scene.Camera };
            Scene.EntityAdded += scene_EntityAdded;

            Program.Instance.Interface.Layer1.AddChild(
                SceneControl = new GameSceneControl
                {
                    InnerScene = Scene,
                    Size = Program.Instance.Interface.Size
                });

            InterfaceIngameRenderer = new Graphics.Interface.InterfaceRenderer9(Program.Instance.Device9)
            {
                Scene = InterfaceIngameScene,
                StateManager = Program.Instance.StateManager,
            };
            InterfaceIngameRenderer.Initialize(Scene.View);

            if (Program.Settings.OutputPNGSequence)
                Directory.CreateDirectory(OutputPNGSequencePath);

            if (Program.Settings.UseDummyRenderer)
            {
                throw new NotSupportedException("Dummy renderer is no longer supported.");
            }
            else
            {
                Renderer = new Graphics.Renderer.Renderer(Program.Instance.Device9)
                {
                    Scene = Scene,
                    StateManager = Program.Instance.StateManager,
                    Settings = Program.Settings.RendererSettings,
                };
                SceneRendererConnector = new SortedTestSceneRendererConnector
                {
                    Scene = Scene,
                    Renderer = Renderer
                };
            }

            Graphics.Renderer.Results result = Renderer.Initialize(Scene.View);
            SceneRendererConnector.Initialize();
            if (result == Graphics.Renderer.Results.OutOfVideoMemory)
            {
                System.Windows.Forms.MessageBox.Show(Locale.Resource.ErrorOutOfVideoMemory);
                Application.Log("User ran out of video memory according to renderer. This is probably due to having too high shadow quality.");
                System.Windows.Forms.Application.Exit();
            }

            RendererSettingsController = new RendererSettingsController();

            var s = Program.Settings.GraphicsDeviceSettings.Resolution;
            Program.Instance.Interface.Layer1.AddChild(Interface = new Interface.Interface
            {
                Size = new Vector2(s.Width, s.Height),
                Visible = false
            });
        }
        public override void Init()
        {
            Content.ContentPath = "Data";

            scene = new Scene();
            scene.View = this;
            scene.Camera = new LookatCartesianCamera()
            {
                Position = new Vector3(-5, 5, 5),
                AspectRatio = AspectRatio
            };

            foreach (var v in scene.AllEntities)
                v.VisibilityLocalBounding = Vector3.Zero;

            Device9StateManager sm = new Device9StateManager(Device9);
            renderer = new Graphics.Renderer.Renderer(Device9) { Scene = scene, StateManager = sm };
            renderer.Initialize(this);
            sceneRendererConnector = new SortedTestSceneRendererConnector
            {
                Scene = scene,
                Renderer = renderer
            };
            sceneRendererConnector.Initialize();

            bvr = new BoundingVolumesRenderer
            {
                View = this,
                StateManager = sm
            };

            BVEntity t;
            scene.Add(t = new BVEntity
            {
                MainGraphic = new MetaModel
                {
                    XMesh = new MeshFromFile("Models/Props/Barrel1.x"),
                    Texture = new TextureFromFile("Models/Props/Barrel1.png"),
                    World = Matrix.Scaling(0.1f, 0.1f, 0.1f) * SkinnedMesh.InitSkinnedMeshFromMaya,
                },
                WorldMatrix = Matrix.Translation(1, 0, 0)
            });
            t.BoundingVolume = Graphics.Boundings.Transform(new Graphics.MetaBoundingBox { Mesh = ((MetaModel)t.MainGraphic).XMesh },
                ((MetaModel)t.MainGraphic).World);
            scene.Add(t = new BVEntity
            {
                MainGraphic = new MetaModel
                {
                    SkinnedMesh = new SkinnedMeshFromFile("Models/Props/Bridge1.x"),
                    Texture = new TextureFromFile("Models/Props/Bridge1.png"),
                    World = Matrix.Scaling(0.1f, 0.1f, 0.1f) * SkinnedMesh.InitSkinnedMeshFromMaya
                },
                WorldMatrix = Matrix.Translation(3, 0, 0)
            });
            scene.Add(t = new BVEntity
            {
                MainGraphic = new MetaModel
                {
                    SkinnedMesh = new SkinnedMeshFromFile("Models/Props/Bridge1.x"),
                    Texture = new TextureFromFile("Models/Props/Bridge1.png"),
                    World = Matrix.Scaling(0.1f, 0.1f, 0.1f) * SkinnedMesh.InitSkinnedMeshFromMaya
                },
                WorldMatrix = Matrix.Translation(-3, -3, 0)
            });
            t.BoundingVolume = Vector3.Zero;
        }