public static void Init(int width, int height)
        {
            m_Game = new Game();
            m_Content = m_Game.Content;
            m_Content.RootDirectory = "Content";

            m_Graphics = new GraphicsDeviceManager(m_Game);
            m_Graphics.PreferredBackBufferFormat = SurfaceFormat.Color;
            m_Graphics.PreferredDepthStencilFormat = DepthFormat.Depth24Stencil8;
            m_Graphics.PreferredBackBufferWidth = width;
            m_Graphics.PreferredBackBufferHeight = height;
            m_Graphics.SynchronizeWithVerticalRetrace = false;
            m_Graphics.PreferMultiSampling = false;
            m_Graphics.PreparingDeviceSettings += new EventHandler<PreparingDeviceSettingsEventArgs>(PreparingDeviceSettings);

            m_Graphics.ApplyChanges();

            if (!m_Graphics.SynchronizeWithVerticalRetrace)
                m_Game.IsFixedTimeStep = false;

            m_DeviceService = (IGraphicsDeviceService)m_Game.Services.GetService(typeof(IGraphicsDeviceService));

            // just to preload the asset. m_Content will return a cached copy later on
            Effect domeFX = m_Content.Load<Effect>("Dome");
            Texture2D texture = m_Content.Load<Texture2D>("Sprite");

            domeFX.Parameters["ParticleSize"].SetValue(2.5f);
            domeFX.Parameters["Texture"].SetValue(texture);
        }

 public override void Initialize()
 {
     // Gets the graphics device service
     graphicsDeviceService = (IGraphicsDeviceService)base.Services.GetService(typeof(IGraphicsDeviceService));
     this.Visible = true;
     base.Initialize();
 }

        internal WindowManager(IGraphicsDeviceService graphicsDeviceService)
        {
            if (graphicsDeviceService == null)
                throw new ArgumentNullException("graphicsDeviceService");

            GraphicsDeviceService = graphicsDeviceService;
        }

        public override void Initialize()
        {
            base.Initialize();

            isInitialized = true;

            // Get graphics device service
            graphicsDeviceService = Services.GetSafeServiceAs<IGraphicsDeviceService>();

#if SILICONSTUDIO_PLATFORM_WINDOWS_DESKTOP
            Enabled = true;
            directoryWatcher = new DirectoryWatcher("*.xksl");
            directoryWatcher.Modified += FileModifiedEvent;
            // TODO: xkfx too
#endif

            // Setup shader compiler settings from a compilation mode. 
            // TODO: We might want to provide overrides on the GameSettings to specify debug and/or optim level specifically.
            if (Game != null && (((Game)Game).Settings != null))
            {
                effectCompilerParameters.ApplyCompilationMode(((Game)Game).Settings.CompilationMode);
            }

            // Make sure default compiler is created (local if possible otherwise none) if nothing else was explicitely set/requested (i.e. by GameSettings)
            if (Compiler == null)
                Compiler = CreateEffectCompiler();
        }

        public override void Initialize()
        {
            // A reference to the graphics service is mandatory since we need to get the graphics device after it's destroyed
            graphicsService = Game.Services.GetService(typeof(IGraphicsDeviceService)) as IGraphicsDeviceService;
            graphicsDevice = graphicsService.GraphicsDevice;

            // Those three events are necessary to keep a "fresh" state, see individual methods
            graphicsService.DeviceCreated += delegate { OnDeviceCreated(); };
            graphicsService.DeviceResetting += delegate { OnDeviceResetting(); };
            graphicsService.DeviceReset += delegate { OnDeviceReset(); };

            // Here's the trick... We know it's a form, so let's cast it as a form!
            // No need to say that this won't work on the Xbox 360...
            windowsGameForm = Control.FromHandle(Game.Window.Handle) as Form;

            // After, we add up our own components to it
            InitializeComponent();
            Game.Window.Title = "nu";

            // We can then map events to the components like in a normal Windows Forms context
            //someButton.Click += new EventHandler(someButton_Click);
            //quitMenuItem.Click += delegate { Game.Exit(); };

            // And force a reset so that we set the right target to begin with
            graphicsDevice.Reset();

            base.Initialize();
        }

 protected GameComponent( IGraphicsDeviceService graphicsDeviceService, IEventAggregator eventAggregator )
 {
     this._eventAggregator = eventAggregator;
     this._graphicsDeviceService = graphicsDeviceService.NotNull();
     this._graphicsDeviceService.DeviceCreated += this.DeviceCreated;
     this._graphicsDeviceService.DeviceDisposing += this.DeviceDisposing;
 }

        internal OpenTKWindowManager(IGraphicsDeviceService graphicsDeviceService, GameWindow gameWindow)
            : base(graphicsDeviceService)
        {
            if (gameWindow == null)
                throw new ArgumentNullException("gameWindow");

            _gameWindow = gameWindow;
        }

 public Core(Game game)
     : base(game)
 {
     svc = (IGraphicsDeviceService)game.Services.GetService(typeof(IGraphicsDeviceService));
     graphics =  (GraphicsDeviceManager)svc;
     //remember wich level we are playing
     this.game = game;
 }

 public ScreenManager( Game game )
     : base(game)
 {
     graphicsDeviceService = (IGraphicsDeviceService)game.Services.GetService(
                                                 typeof( IGraphicsDeviceService ) );
     content = new ContentManager( game.Services );
     content.RootDirectory = "Content";
     current_game = game;
 }

        public VertexPositionTextureDrawer( Camera3D camera3D, IGraphicsDeviceService graphicsDeviceService )
        {
            this._graphicsDeviceService = graphicsDeviceService;
            this._camera = camera3D.NotNull();
            this._camera.Changed += this.UpdateBasicEffect;

            this._graphicsDeviceService.DeviceCreated += this.RecreateBassicEffect;
            this.CreateBasicEffect();
        }

        /// <summary>
        /// Constructs a render coordinator. A render manager and synchronous draw methods are automatically provided for you.
        /// </summary>
        /// <param name="deviceService"></param>
        public RenderCoordinator(IGraphicsDeviceService deviceService)
        {
            Manager = new RenderManager(deviceService.GraphicsDevice);

            _SyncBeginDraw = DefaultBeginDraw;
            _SyncEndDraw = DefaultEndDraw;

            CoreInitialize();
        }

        public VertexPositionColorDrawer( IGraphicsDeviceService deviceService, Camera3D camera3D )
        {
            this._camera = camera3D.NotNull();
            this._camera.Changed += this.UpdateBasicEffect;
            this._graphicsDeviceService = deviceService;
            this._graphicsDeviceService.DeviceCreated += this.RecreateBassicEffect;
            this.CreateBasicEffect();

            this.CreateBasicEffect();
        }

        public DXControlLite(IGraphicsDeviceService deviceService)
        {
            InitializeComponent();

            this.deviceService = deviceService;
            this.Loaded += DXControlLite_Loaded;

            this.deviceService.DeviceCreated += deviceService_DeviceCreated;
            this.deviceService.DeviceLost += deviceService_DeviceLost;
            this.deviceService.DeviceDisposing += deviceService_DeviceDisposing;
        }

        /// <summary>
        /// Constructs a new screen manager component.
        /// </summary>
        public ScreenManager(Game game)
            : base(game)
        {
            content = new ContentManager(game.Services, "Content");

            graphicsDeviceService = (IGraphicsDeviceService)game.Services.GetService(
                                                        typeof(IGraphicsDeviceService));

            if (graphicsDeviceService == null)
                throw new InvalidOperationException("No graphics device service.");
        }

        /// <summary>
        /// Constructs a new screen manager component.
        /// </summary>
        /// <exception cref="InvalidOperationException">No graphics device service.</exception>
        public ScreenManager(Game game)
            : base(game)
        {
            ContentManager = new ContentManager(game.Services);
            _graphicsDeviceService = (IGraphicsDeviceService) game.Services.GetService(
                                                                  typeof (IGraphicsDeviceService));
            game.Exiting += Game_Exiting;

            if (_graphicsDeviceService == null)
                throw new InvalidOperationException("No graphics device service.");
        }

        /// <summary>Initializes a new frame rate tracking component</summary>
        /// <param name="graphicsDeviceService">
        ///   Graphics device service the counter uses for rendering
        /// </param>
        public FpsComponent(
          IGraphicsDeviceService graphicsDeviceService, string contentRootDirectory
        )
            : base(null)
        {
            this.graphicsDeviceService = graphicsDeviceService;
            this.contentRoot = contentRootDirectory;

            this.frameTimes = new Queue<long>();
            Visible = true;
        }

        public static WindowManager Create(IGraphicsDeviceService graphicsDeviceService, IntPtr windowHandle)
        {
            if (graphicsDeviceService is GraphicsDeviceManager)
                throw new NotImplementedException("This is not implemented. You need to use the Game instead of the GameWindow.Handle.");

            //Get a Windows.Form
            var window = Control.FromHandle(windowHandle) as Form;
            if (window == null)
                throw new ArgumentException("The windowHandle is not a valid Windows.Form handle.");

            return new FormWindowManager(graphicsDeviceService, window);
        }

        /// <summary>
        /// Create an instance of an UI element renderer.
        /// </summary>
        /// <param name="services">The list of registered services</param>
        public ElementRenderer(IServiceRegistry services)
        {
            Content = services.GetSafeServiceAs<IContentManager>();
            GraphicsDeviceService = services.GetSafeServiceAs<IGraphicsDeviceService>();

            UI = services.GetServiceAs<UISystem>();
            if (UI == null)
            {
                UI = new UISystem(services);
                var gameSystems = services.GetServiceAs<IGameSystemCollection>();
                gameSystems?.Add(UI);
            }
        }

        public GraphicsContext(IGraphicsDeviceService service, Device d3dDevice, DeviceContext d3dContext)
        {
            this.RenderContext = new RenderContext();

            this.GraphicsService = service;
            this.Device = service.GraphicsDevice;
            this.D3D11Device = d3dDevice;
            this.D3D11Context = d3dContext;

            this.SpriteBatch = new SpriteBatch(service.GraphicsDevice);

            this.GBuffer = new GeometryBuffer(this);
            this.CurrentCamera = new PlanetCamera(6359.99);
        }

    /// <summary>Initializes a new particle system manager</summary>
    /// <param name="graphicsDeviceService">
    ///   Graphics device service being used to render the particle systems
    /// </param>
    public ParticleSystemManager(IGraphicsDeviceService graphicsDeviceService) :
      base(graphicsDeviceService) {

      this.particleSystems = new Dictionary<object, IParticleSystemHolder>();
      this.primitiveBatches = new Dictionary<Type, PrimitiveBatchHolder>();

      this.pruneAsyncResult = new PruneAsyncResult(this);
      this.updateAsyncResult = new UpdateAsyncResult(this);

      this.particleSystemHolders = new IParticleSystemHolder[16];
      this.primitiveBatchHolders = new PrimitiveBatchHolder[4];

      this.holderArraysDirty = true;
    }