示例#1
0
        /// <summary>
        /// Runs the application.
        /// </summary>
        /// <param name="platform">Render system platform</param>
        /// <param name="pp">Parameters for backbuffer/window creation</param>
        public void Run(RenderSystemPlatform platform, PresentationParameters pp)
        {
            Init(platform, pp);

            //Create the timer for interpolation during Update() calls
            _timer = new GameTimer();
            //Set the timer to the engine's data value map, so we can access Time,TimePerFrame,and PerFrame engine values for our shaders
            Engine.ValueMap.Timer = _timer;
            _timer.Start();
            //Create and run the host
            _host.Idle += new Heartbeat(Loop);
            _host.Run();
        }
示例#2
0
        /// <summary>
        /// Creates a host to run our application in and executes the "game loop"
        /// </summary>
        public void Run(RenderSystemPlatform platform, PresentationParameters pp)
        {
            //Tesla's core functionality is serviced based. A service is a module that provides access
            //to concrete implementation of engine objects. Common services are the render system, windowing, and input. They are
            //managed by the static "Engine" class, which serves as the primary point in the codebase to bring together all services.
            //The only service that is actually is needed to "Initialize" the engine is a render system, all others are optional.
            //
            //Since service providers are interfaces, you effectively de-couple their implementations from other services or code
            //that relies on them. Other than allowing for code to be cleanly separated into modules, this allows for the developer to mix-and-match
            //services. For example, if you're developing a Windows application, then you can use the SWFWindowProvider, WindowsKeyboardProvider,
            //and WindowsMouseProvider (which we use below) for your windowing/input needs. Then, different render systems such as OpenGL, D3D10,
            //or XNA can be used without any modification.
            //
            //This modularity allows the engine to expand in the future, to include new implementations for new platforms or allow
            //the developer to create their own specific implementations. Additionally, new services can be created such as joystick or
            //gamepad support, either as a third-party addition or integrated directly into the engine core.


            //The render system is the central service for the graphics engine. Initializing
            //the engine will create default graphics content/objects (such as the standard render states)
            Engine.Initialize(new Tesla.Direct3D10.Graphics.D3D10RenderSystemProvider());

            //A window service provider allows us to setup native windows + the means to host them as an application.
            Engine.Services.AddService(typeof(IWindowProvider), new Tesla.Windows.Core.SWFWindowProvider());

            //Input providers should be obvious (in this case, by registering a service provider we can use the Keyboard/Mouse static classes)
            Engine.Services.AddService(typeof(IKeyboardProvider), new Tesla.Windows.Input.WindowsKeyboardProvider());
            Engine.Services.AddService(typeof(IMouseProvider), new Tesla.Windows.Input.WindowsMouseProvider());

            //Get the renderer so we don't have to keep querying the render system (there is only ever one renderer, similar
            //to how there's only ever one Device in Direct3D)
            _renderer = Engine.Services.GetService <IRenderSystemProvider>().Renderer;

            //Setup your game window. Since it's set to primary window, a form will be created. Non-primary creates
            //a control that can be added to a a windows form app (e.g. editor and such)
            _window = new Window(pp, true);
            _window.AllowUserResizing = true;
            _window.IsMouseVisible    = true;
            _window.Title             = "Minimal Sample";

            //Create a camera - if you resize the window, make sure you update your camera's viewport and projection!
            Camera camera = new Camera(new Viewport(0, 0, pp.BackBufferWidth, pp.BackBufferHeight));

            camera.Position = new Vector3(0, 0, 100f);
            camera.SetProjection(45.0f, 1.0f, 30000.0f);
            camera.Update();

            //Set the camera onto the renderer. This can be considered the "active" camera, which would
            //be used if you draw the scene graph (first there is a culling pass). Setting the current camera
            //also sets the viewport onto the device
            _renderer.CurrentCamera = camera;

            //To resize the camera we can add an event handler to the window. If we shrink/grow the window,
            //we need to reset the camera's viewport and projection too.
            _window.ClientSizeChanged += new EventHandler(delegate(Object sender, EventArgs args) {
                Rectangle rect  = _window.ClientBounds;
                camera.Viewport = new Viewport(0, 0, rect.Width, rect.Height);
                camera.SetProjection(45.0f, 1.0f, 30000.0f);
                camera.Update();

                //Set the viewport onto the renderer - if we set the renderer.CurrentCamera property, this would be taken care of too.
                _renderer.Viewport = camera.Viewport;
            });


            //Create a content manager - this allows us to load & cache assets. Very similar to XNA's way of doing content loading.
            //Every renderer has a manager for default content (currently the shader library), for platform-specific content.
            //Content managers only have the binary/material loaders registered, and all others (image, model loaders) must be registered.
            //You can also use content managers to divide up your assets into logical groups,
            _content = new ContentManager();

            //Load content
            LoadContent();

            //Create and start the timer we'll use for update calls
            _timer = new GameTimer();

            //Engine values are common properties such as the World-View-Projection matrices, the Camera, or the timer. You can
            //tell the material to query these values, which it will automatically every frame. The value map only needs 3 inputs:
            //
            // 1. World Matrix - Set your world matrix to it before calling properties that may require it (such as a World-View-Projection)
            // 2. Timer - Set your timer before calling timing properties (time per frame, fps, etc)
            // 3. Camera - Set your current camera before calling any camera related properties (such as World-View-Projection)
            //
            //When you set the camera to the renderer (renderer.CurrentCamera), #3 is automatically taken care of. The scenegraph takes
            //care of #1. When you setup your application, you have to set #2 yourself (as we do here). If you create your own mesh classes/scene graph,
            //be aware of #1.
            Engine.ValueMap.Timer = _timer;

            _timer.Start();

            //Create a host for the window (only for primary windows), if you're familiar with Application.Run(), our SWF host is effectively that!
            _host = Engine.Services.GetService <IWindowProvider>().CreateWindowHost(_window);
            //The "game loop", which is called when the application is idle
            _host.Idle += new Heartbeat(Loop);
            //Run the app
            _host.Run();

            //Ensure we dismiss the services and clean up the resources created, when we fall out of our loop.
            Engine.CleanUpResources();
        }