2007-07-23 02:15:18 +02:00
#region - - - License - - -
/ * Copyright ( c ) 2006 , 2007 Stefanos Apostolopoulos
* See license . txt for license info
* /
#endregion
using System ;
using System.Collections.Generic ;
using System.Text ;
2007-07-27 00:56:55 +02:00
using System.Diagnostics ;
2007-07-23 02:15:18 +02:00
using OpenTK.Platform ;
2007-08-06 11:22:04 +02:00
using OpenTK.Input ;
using System.Threading ;
2007-09-03 00:52:00 +02:00
using OpenTK.OpenGL ;
2007-11-04 16:41:10 +01:00
using OpenTK.OpenGL.Enums ;
2007-07-23 02:15:18 +02:00
namespace OpenTK
{
2007-09-26 13:50:44 +02:00
/// <summary>
2007-11-04 16:41:10 +01:00
/// The GameWindow class contains cross-platform methods to create and render on an OpenGL
2007-11-02 00:28:31 +01:00
/// window, handle input and load resources.
2007-09-26 13:50:44 +02:00
/// </summary>
/// <remarks>
/// GameWindow contains several events you can hook or override to add your custom logic:
/// <list>
2007-11-04 16:41:10 +01:00
/// <item>
/// OnLoad: Occurs after creating the OpenGL context, but before entering the main loop.
/// Override to load resources.
2007-11-02 00:28:31 +01:00
/// </item>
2007-11-04 16:41:10 +01:00
/// <item>
/// OnUnload: Occurs after exiting the main loop, but before deleting the OpenGL context.
/// Override to unload resources.
2007-11-02 00:28:31 +01:00
/// </item>
2007-11-04 16:41:10 +01:00
/// <item>
/// OnResize: Occurs whenever GameWindow is resized. You should update the OpenGL Viewport
/// and Projection Matrix here.
2007-11-02 00:28:31 +01:00
/// </item>
2007-11-04 16:41:10 +01:00
/// <item>
/// OnUpdateFrame: Occurs at the specified logic update rate. Override to add your game
/// logic.
2007-11-02 00:28:31 +01:00
/// </item>
2007-11-04 16:41:10 +01:00
/// <item>
/// OnRenderFrame: Occurs at the specified frame render rate. Override to add your
/// rendering code.
2007-11-02 00:28:31 +01:00
/// </item>
2007-09-26 13:50:44 +02:00
/// </list>
2007-11-04 16:41:10 +01:00
/// Call the Run() method to start the application's main loop. Run(double, double) takes two
2007-11-02 00:28:31 +01:00
/// parameters that
2007-09-26 13:50:44 +02:00
/// specify the logic update rate, and the render update rate.
/// </remarks>
2007-11-10 19:26:05 +01:00
public class GameWindow : IDisposable /* : IGameWindow*/
2007-07-23 02:15:18 +02:00
{
2007-08-05 15:42:31 +02:00
#region - - - Fields - - -
2007-09-26 13:50:44 +02:00
INativeGLWindow glWindow ;
DisplayMode mode ;
2007-07-23 02:15:18 +02:00
2007-09-26 13:50:44 +02:00
ResizeEventArgs resizeEventArgs = new ResizeEventArgs ( ) ;
2007-08-05 15:42:31 +02:00
2007-09-26 13:50:44 +02:00
bool isExiting ;
bool disposed ;
2007-08-06 11:22:04 +02:00
2007-09-30 14:44:42 +02:00
double update_period , render_period ;
double target_update_period , target_render_period , target_render_period_doubled ;
// TODO: Implement these:
double update_time , render_time , event_time ;
2007-10-15 13:12:56 +02:00
//bool allow_sleep = true; // If true, GameWindow will call Timer.Sleep() if there is enough time.
2007-09-26 13:50:44 +02:00
int width , height ;
2007-09-30 14:44:42 +02:00
VSyncMode vsync ;
2007-11-10 19:26:05 +01:00
//InputDriver input_driver;
2007-10-19 22:03:53 +02:00
2007-12-09 19:15:51 +01:00
GLContext glContext ;
2007-09-26 13:50:44 +02:00
#endregion
2007-09-30 14:44:42 +02:00
#region - - - Internal Properties - - -
2007-09-26 13:50:44 +02:00
bool MustResize
{
get { return glWindow . Width ! = this . Width | | glWindow . Height ! = this . Height ; }
}
2007-09-23 14:09:42 +02:00
2007-08-05 15:42:31 +02:00
#endregion
2007-08-03 02:14:31 +02:00
2007-07-23 02:15:18 +02:00
#region - - - Contructors - - -
/// <summary>
2007-10-19 22:03:53 +02:00
/// Constructs a new GameWindow using a safe DisplayMode.
/// </summary>
2007-11-04 16:41:10 +01:00
public GameWindow ( ) : this ( new DisplayMode ( 640 , 480 , 0 , 16 , false ) , "OpenTK game window" )
2007-11-02 00:28:31 +01:00
{ }
2007-10-19 22:03:53 +02:00
/// <summary>
/// Constructs a new GameWindow, and opens a render window with the specified DisplayMode.
2007-07-23 02:15:18 +02:00
/// </summary>
2007-10-19 22:03:53 +02:00
/// <param name="mode">The DisplayMode of the GameWindow.</param>
public GameWindow ( DisplayMode mode ) : this ( mode , "OpenTK game window" ) { }
/// <summary>
2007-11-04 16:41:10 +01:00
/// Constructs a new GameWindow with the specified title, and opens a render window with the
2007-11-02 00:28:31 +01:00
/// specified DisplayMode.
2007-10-19 22:03:53 +02:00
/// </summary>
/// <param name="mode">The DisplayMode of the GameWindow.</param>
/// <param name="title">The Title of the GameWindow.</param>
public GameWindow ( DisplayMode mode , string title )
2007-07-23 02:15:18 +02:00
{
2007-09-09 18:07:39 +02:00
switch ( Environment . OSVersion . Platform )
2007-07-23 02:15:18 +02:00
{
2007-09-09 18:07:39 +02:00
case PlatformID . Win32NT :
case PlatformID . Win32S :
case PlatformID . Win32Windows :
case PlatformID . WinCE :
glWindow = new OpenTK . Platform . Windows . WinGLNative ( ) ;
break ;
2007-10-19 22:03:53 +02:00
2007-09-09 18:07:39 +02:00
case PlatformID . Unix :
case ( PlatformID ) 128 :
glWindow = new OpenTK . Platform . X11 . X11GLNative ( ) ;
break ;
2007-10-19 22:03:53 +02:00
2007-09-09 18:07:39 +02:00
default :
2007-11-10 19:26:05 +01:00
throw new PlatformNotSupportedException (
"Your platform is not supported currently. Please, refer to http://opentk.sourceforge.net for more information." ) ;
2007-07-23 02:15:18 +02:00
}
2007-08-10 18:55:24 +02:00
glWindow . Destroy + = new DestroyEvent ( glWindow_Destroy ) ;
2007-10-19 22:03:53 +02:00
2007-09-26 13:50:44 +02:00
CreateWindow ( mode , title ) ;
2007-12-09 19:15:51 +01:00
2007-11-08 16:57:10 +01:00
//this.vsync = VSyncMode.Adaptive;
this . VSync = VSyncMode . On ;
2007-09-26 13:50:44 +02:00
}
2007-08-06 13:22:18 +02:00
void glWindow_Destroy ( object sender , EventArgs e )
{
2007-08-06 14:13:50 +02:00
glWindow . Destroy - = glWindow_Destroy ;
2007-11-11 21:10:08 +01:00
this . Exit ( ) ;
2007-07-23 02:15:18 +02:00
}
#endregion
2007-08-05 15:42:31 +02:00
#region - - - INativeGLWindow Members - - -
2007-08-04 14:09:58 +02:00
2008-01-06 03:29:54 +01:00
#region public virtual void Exit ( )
2007-08-04 14:09:58 +02:00
/// <summary>
2008-01-06 03:29:54 +01:00
/// Gracefully exits the GameWindow. May be called from any thread.
2007-08-04 14:09:58 +02:00
/// </summary>
2008-01-06 03:29:54 +01:00
/// <remarks>
/// <para>Override if you want to provide yor own exit sequence.</para>
/// <para>If you override this method, place a call to base.Exit(), to ensure
/// proper OpenTK shutdown.</para>
/// </remarks>
2007-08-06 11:22:04 +02:00
public virtual void Exit ( )
2007-08-04 14:09:58 +02:00
{
2007-08-06 11:22:04 +02:00
isExiting = true ;
2008-01-06 03:29:54 +01:00
UpdateFrame + = GameWindow_UpdateFrame ;
}
#endregion
#region void ExitInternal ( )
/// <summary>
/// Stops the main loop.
/// </summary>
void ExitInternal ( )
{
2007-11-11 20:28:13 +01:00
throw new GameWindowExitException ( ) ;
2007-08-04 14:09:58 +02:00
}
2008-01-06 03:29:54 +01:00
void GameWindow_UpdateFrame ( GameWindow sender , UpdateFrameEventArgs e )
{
UpdateFrame - = GameWindow_UpdateFrame ;
sender . ExitInternal ( ) ;
}
2007-08-04 14:09:58 +02:00
#endregion
2007-07-23 02:15:18 +02:00
#region public bool IsIdle
2007-08-04 14:09:58 +02:00
/// <summary>
/// Gets a value indicating whether the current GameWindow is idle.
/// If true, the OnUpdateFrame and OnRenderFrame functions should be called.
/// </summary>
2007-07-23 02:15:18 +02:00
public bool IsIdle
{
get { return glWindow . IsIdle ; }
}
#endregion
#region public bool Fullscreen
2007-09-26 17:43:28 +02:00
/// <summary>
/// TODO: This property is not implemented.
/// Gets or sets a value indicating whether the GameWindow is in fullscrren mode.
/// </summary>
2007-07-23 02:15:18 +02:00
public bool Fullscreen
{
2007-10-15 13:12:56 +02:00
get { return false ; /* return glWindow.Fullscreen; */ }
set { /* glWindow.Fullscreen = value; */ }
2007-07-23 02:15:18 +02:00
}
#endregion
2007-08-04 14:09:58 +02:00
#region public IGLContext Context
2007-07-23 02:15:18 +02:00
2007-08-04 14:09:58 +02:00
/// <summary>
/// Returns the opengl IGLontext associated with the current GameWindow.
/// Forces window creation.
/// </summary>
2008-01-11 21:37:09 +01:00
public GLContext Context
2007-07-23 02:15:18 +02:00
{
2007-08-04 14:09:58 +02:00
get
{
2007-08-10 18:55:24 +02:00
if ( ! this . Exists & & ! this . IsExiting )
{
Debug . WriteLine ( "WARNING: OpenGL Context accessed before creating a render window. This may indicate a programming error. Force-creating a render window." ) ;
mode = new DisplayMode ( 640 , 480 ) ;
this . CreateWindow ( mode ) ;
}
2007-12-09 19:15:51 +01:00
//return glWindow.Context;
return glContext ;
2007-08-10 18:55:24 +02:00
}
2007-07-23 02:15:18 +02:00
}
#endregion
2007-08-06 11:22:04 +02:00
#region public bool Exists
2007-07-23 02:15:18 +02:00
2007-08-04 14:09:58 +02:00
/// <summary>
2007-09-26 13:50:44 +02:00
/// Gets a value indicating whether a render window exists.
2007-08-04 14:09:58 +02:00
/// </summary>
2007-08-06 11:22:04 +02:00
public bool Exists
2007-07-23 02:15:18 +02:00
{
2007-08-10 18:55:24 +02:00
get { return glWindow = = null ? false : glWindow . Exists ; }
2007-07-23 02:15:18 +02:00
}
#endregion
2007-09-26 13:50:44 +02:00
#region public string Text
/// <summary>
/// Gets or sets the GameWindow title.
/// </summary>
public string Title
{
get
{
return glWindow . Title ;
}
set
{
glWindow . Title = value ;
}
}
#endregion
#region public bool Visible
/// <summary>
2007-09-26 17:43:28 +02:00
/// TODO: This property is not implemented
2007-09-26 13:50:44 +02:00
/// Gets or sets a value indicating whether the GameWindow is visible.
/// </summary>
public bool Visible
{
get
{
2007-09-26 17:43:28 +02:00
throw new NotImplementedException ( ) ;
2007-11-06 14:37:19 +01:00
//return glWindow.Visible;
2007-09-26 13:50:44 +02:00
}
set
{
2007-09-26 17:43:28 +02:00
throw new NotImplementedException ( ) ;
2007-11-06 14:37:19 +01:00
//glWindow.Visible = value;
2007-09-26 13:50:44 +02:00
}
}
#endregion
2007-08-05 15:42:31 +02:00
#region public IWindowInfo WindowInfo
public IWindowInfo WindowInfo
{
get { return glWindow . WindowInfo ; }
}
#endregion
2007-10-19 22:03:53 +02:00
#if false
2007-08-05 15:42:31 +02:00
2007-09-26 13:50:44 +02:00
#region public IInputDriver InputDriver
/// <summary>
/// Gets an interface to the InputDriver used to obtain Keyboard, Mouse and Joystick input.
/// </summary>
public IInputDriver InputDriver
{
get
{
2007-10-19 22:03:53 +02:00
return null ;
2007-09-26 13:50:44 +02:00
}
}
#endregion
2007-10-19 22:03:53 +02:00
#endif
2007-08-06 13:22:18 +02:00
#region public void CreateWindow ( DisplayMode mode )
/// <summary>
2007-09-26 13:50:44 +02:00
/// Creates a render window for the calling GameWindow.
2007-08-06 13:22:18 +02:00
/// </summary>
/// <param name="mode">The DisplayMode of the render window.</param>
2007-09-26 13:50:44 +02:00
/// <remarks>
/// It is an error to call this function when a render window already exists.
/// <para>Call DestroyWindow to close the render window.</para>
/// </remarks>
2007-08-06 13:22:18 +02:00
/// <exception cref="ApplicationException">Occurs when a render window already exists.</exception>
public void CreateWindow ( DisplayMode mode )
{
if ( ! Exists )
{
2007-08-20 15:47:14 +02:00
try
{
2008-01-11 21:37:09 +01:00
glWindow . CreateWindow ( mode , Context ) ;
2007-08-20 15:47:14 +02:00
}
catch ( ApplicationException expt )
{
Debug . Print ( expt . ToString ( ) ) ;
throw ;
}
2007-08-06 13:22:18 +02:00
}
else
{
2007-09-26 13:50:44 +02:00
throw new ApplicationException ( "A render window already exists for this GameWindow." ) ;
2007-08-06 13:22:18 +02:00
}
}
#endregion
#region public void DestroyWindow ( )
2007-08-10 18:55:24 +02:00
/// <summary>
/// Destroys the GameWindow. The Destroy event is raised before destruction commences
/// (while the opengl context still exists), to allow resource cleanup.
/// </summary>
2007-08-06 13:22:18 +02:00
public void DestroyWindow ( )
{
if ( Exists )
glWindow . DestroyWindow ( ) ;
else
2007-11-11 21:10:08 +01:00
throw new ApplicationException ( "Tried to destroy non-existent window." ) ;
2007-08-06 13:22:18 +02:00
}
#endregion
2007-07-23 02:15:18 +02:00
#endregion
2007-09-30 14:44:42 +02:00
#region - - - GameWindow Methods - - -
2007-07-23 02:15:18 +02:00
2007-10-26 17:54:35 +02:00
#region public void CreateWindow ( DisplayMode mode , string title )
/// <summary>
/// Creates a render window for the calling GameWindow, with the specified DisplayMode and Title.
/// </summary>
/// <param name="mode">The DisplayMode of the render window.</param>
/// <param name="title">The Title of the render window.</param>
/// <remarks>
/// It is an error to call this function when a render window already exists.
/// <para>Call DestroyWindow to close the render window.</para>
/// </remarks>
/// <exception cref="ApplicationException">Occurs when a render window already exists.</exception>
private void CreateWindow ( DisplayMode mode , string title )
{
if ( ! Exists )
{
2008-01-11 21:37:09 +01:00
glWindow . CreateWindow ( mode , glContext ) ;
glContext = new GLContext ( mode , glWindow . WindowInfo ) ;
( glContext as IGLContextCreationHack ) . SetWindowHandle ( glWindow . WindowInfo . Handle ) ;
( glContext as IGLContextCreationHack ) . SelectDisplayMode ( mode , glWindow . WindowInfo ) ;
glContext . CreateContext ( ) ;
2007-12-09 19:15:51 +01:00
this . Title = title ;
2007-10-26 17:54:35 +02:00
}
else
throw new InvalidOperationException ( "A render window already exists for this GameWindow." ) ;
}
#endregion
2007-09-27 01:13:57 +02:00
#region void Run ( )
2007-08-04 14:09:58 +02:00
2007-07-23 02:15:18 +02:00
/// <summary>
2007-10-15 13:12:56 +02:00
/// Enters the game loop of the GameWindow updating and rendering at the maximum possible frequency.
2007-07-23 02:15:18 +02:00
/// </summary>
2007-10-15 13:12:56 +02:00
/// <see cref="public virtual void Run(double update_frequency, double render_frequency)"/>
2007-09-23 14:37:07 +02:00
public void Run ( )
{
Run ( 0.0 , 0.0 ) ;
}
/// <summary>
2007-10-15 13:12:56 +02:00
/// Enters the game loop of the GameWindow updating the specified update frequency, while maintaining the
2007-09-23 14:37:07 +02:00
/// maximum possible render frequency.
/// </summary>
/// <see cref="public virtual void Run(double updateFrequency, double renderFrequency)"/>
public void Run ( double updateFrequency )
{
Run ( updateFrequency , 0.0 ) ;
}
/// <summary>
2007-10-15 13:12:56 +02:00
/// Enters the game loop of the GameWindow updating and rendering at the specified frequency.
2007-09-23 14:37:07 +02:00
/// </summary>
2007-10-15 13:12:56 +02:00
/// <param name="updates_per_second">The frequency of UpdateFrame events.</param>
/// <param name="frames_per_second">The frequency of RenderFrame events.</param>
2007-09-30 14:44:42 +02:00
public void Run ( double updates_per_second , double frames_per_second )
{
2007-10-20 16:22:39 +02:00
try
2007-09-30 14:44:42 +02:00
{
2007-10-20 16:22:39 +02:00
if ( updates_per_second < 0.0 | | updates_per_second > 200.0 )
throw new ArgumentOutOfRangeException ( "updates_per_second" , updates_per_second , "Parameter should be inside the range [0.0, 200.0]" ) ;
if ( frames_per_second < 0.0 | | frames_per_second > 200.0 )
throw new ArgumentOutOfRangeException ( "frames_per_second" , frames_per_second , "Parameter should be inside the range [0.0, 200.0]" ) ;
2007-09-30 14:44:42 +02:00
2007-10-20 16:22:39 +02:00
TargetUpdateFrequency = updates_per_second ;
TargetRenderFrequency = frames_per_second ;
2007-09-30 14:44:42 +02:00
2007-10-20 16:22:39 +02:00
Stopwatch update_watch = new Stopwatch ( ) , render_watch = new Stopwatch ( ) ;
double time , next_render = 0.0 , next_update = 0.0 , update_time_counter = 0.0 ;
int num_updates = 0 ;
UpdateFrameEventArgs update_args = new UpdateFrameEventArgs ( ) ;
RenderFrameEventArgs render_args = new RenderFrameEventArgs ( ) ;
2007-09-30 14:44:42 +02:00
2007-11-12 00:32:58 +01:00
update_watch . Reset ( ) ;
render_watch . Reset ( ) ;
2007-10-26 17:54:35 +02:00
//double sleep_granularity; // In seconds.
2007-09-30 14:44:42 +02:00
2007-10-20 16:22:39 +02:00
//GC.Collect(2);
//GC.WaitForPendingFinalizers();
//GC.Collect(2);
2007-09-30 14:44:42 +02:00
2007-10-20 16:22:39 +02:00
// Find the minimum granularity of the Thread.Sleep() function.
// TODO: Disabled - see comment on Thread.Sleep() problems below.
//update_watch.Start();
//const int test_times = 5;
//for (int i = test_times; --i > 0; )
// Thread.Sleep(1);
//update_watch.Stop();
//sleep_granularity = System.Math.Round(1000.0 * update_watch.Elapsed.TotalSeconds / test_times, MidpointRounding.AwayFromZero) / 1000.0;
//update_watch.Reset(); // We don't want to affect the first UpdateFrame!
2007-10-15 13:12:56 +02:00
2008-01-06 03:29:54 +01:00
//try
//{
2007-11-08 16:57:10 +01:00
OnLoadInternal ( EventArgs . Empty ) ;
2008-01-06 03:29:54 +01:00
//}
//catch (Exception e)
//{
// Trace.WriteLine(String.Format("OnLoad failed: {0}", e.ToString()));
// return;
//}
2007-09-30 14:44:42 +02:00
2007-11-08 16:57:10 +01:00
Debug . Print ( "Elevating priority." ) ;
2007-10-20 16:22:39 +02:00
Thread . CurrentThread . Priority = ThreadPriority . AboveNormal ;
2007-11-12 08:45:34 +01:00
//ProcessEvents();
//OnUpdateFrameInternal(update_args);
//OnRenderFrameInternal(render_args);
2007-11-08 16:57:10 +01:00
Debug . Print ( "Entering main loop." ) ;
2007-10-20 16:22:39 +02:00
while ( ! isExiting )
2007-09-30 14:44:42 +02:00
{
2007-10-20 16:22:39 +02:00
// Process events
ProcessEvents ( ) ;
2007-09-30 14:44:42 +02:00
2007-10-20 16:22:39 +02:00
// Raise UpdateFrame events
time = update_watch . Elapsed . TotalSeconds ;
if ( time > 1.0 )
time = 1.0 ;
while ( next_update - time < = 0.0 )
{
next_update = next_update - time + TargetUpdatePeriod ;
2007-10-26 17:54:35 +02:00
if ( next_update < - 1.0 ) // Cap the maximum time drift, to avoid lengthy catch-up games.
next_update = - 1.0 ;
2007-10-20 16:22:39 +02:00
update_time_counter + = time ;
+ + num_updates ;
update_watch . Reset ( ) ;
update_watch . Start ( ) ;
update_args . Time = time ;
OnUpdateFrameInternal ( update_args ) ;
2007-10-26 17:54:35 +02:00
update_time = update_watch . Elapsed . TotalSeconds ;
2007-10-20 16:22:39 +02:00
if ( TargetUpdateFrequency = = 0.0 )
break ;
time = update_watch . Elapsed . TotalSeconds ;
next_update - = time ;
update_time_counter + = time ;
2007-10-26 17:54:35 +02:00
// Allow up to 10 frames to be dropped. Prevents the application from hanging
// with very high update frequencies.
2007-10-20 16:22:39 +02:00
if ( num_updates > = 10 )
break ;
}
if ( num_updates > 0 )
{
update_period = update_time_counter / ( double ) num_updates ;
num_updates = 0 ;
update_time_counter = 0.0 ;
}
// Raise RenderFrame event
time = render_watch . Elapsed . TotalSeconds ;
if ( time > 1.0 )
time = 1.0 ;
double time_left = next_render - time ;
if ( VSync = = VSyncMode . Adaptive )
{
// Check if we have enough time for a vsync
2007-10-26 17:54:35 +02:00
if ( RenderTime > 2.0 * TargetRenderPeriod )
2007-10-20 16:22:39 +02:00
Context . VSync = false ;
else
Context . VSync = true ;
}
if ( time_left < = 0.0 )
{
next_render = time_left + TargetRenderPeriod ;
2007-10-26 17:54:35 +02:00
if ( next_render < - 1.0 ) // Cap the maximum time drift, to avoid lengthy catch-up games.
next_render = - 1.0 ;
2007-10-20 16:22:39 +02:00
render_watch . Reset ( ) ;
render_watch . Start ( ) ;
render_period = render_args . Time = time ;
render_args . ScaleFactor = RenderPeriod / UpdatePeriod ;
OnRenderFrameInternal ( render_args ) ;
2007-10-26 17:54:35 +02:00
render_time = render_watch . Elapsed . TotalSeconds ;
2007-10-20 16:22:39 +02:00
}
// Yield CPU time, if the Thread.Sleep() granularity allows it.
// TODO: Disabled because it does not work reliably enough on all systems.
// Enable vsync as a workaround.
//if (AllowSleep && next_render > sleep_granularity && next_update > sleep_granularity)
//{
// Thread.Sleep((int)(1000.0 * System.Math.Min(next_render - sleep_granularity, next_update - sleep_granularity)));
//}
2007-08-06 13:22:18 +02:00
}
2007-07-23 02:15:18 +02:00
}
2007-11-11 20:28:13 +01:00
catch ( GameWindowExitException )
{
2007-11-11 21:10:08 +01:00
Trace . WriteLine ( "Exiting main loop." ) ;
2007-11-11 20:28:13 +01:00
}
2007-10-20 16:22:39 +02:00
finally
{
2007-11-11 21:10:08 +01:00
Debug . Print ( "Restoring priority." ) ;
2007-10-20 16:22:39 +02:00
Thread . CurrentThread . Priority = ThreadPriority . Normal ;
2007-10-15 13:12:56 +02:00
2007-10-20 16:22:39 +02:00
OnUnloadInternal ( EventArgs . Empty ) ;
2007-09-27 01:13:57 +02:00
2007-10-20 16:22:39 +02:00
if ( this . Exists )
2007-08-06 13:22:18 +02:00
{
2007-11-11 21:10:08 +01:00
if ( Exists )
glWindow . DestroyWindow ( ) ;
2007-10-20 16:22:39 +02:00
while ( this . Exists )
this . ProcessEvents ( ) ;
2007-08-06 13:22:18 +02:00
}
2007-08-06 11:22:04 +02:00
}
2007-07-23 02:15:18 +02:00
}
2007-08-04 14:09:58 +02:00
#endregion
#region public void ProcessEvents ( )
/// <summary>
/// Processes operating system events until the GameWindow becomes idle.
/// </summary>
/// <remarks>
/// When overriding the default GameWindow game loop (provided by the Run() function)
/// you should call ProcessEvents() to ensure that your GameWindow responds to
/// operating system events.
/// <para>
/// Once ProcessEvents() returns, it is time to call update and render the next frame.
/// </para>
/// </remarks>
2007-07-23 02:15:18 +02:00
public void ProcessEvents ( )
{
2007-09-30 14:44:42 +02:00
//if (!isExiting)
// InputDriver.Poll();
2007-07-23 02:15:18 +02:00
glWindow . ProcessEvents ( ) ;
2007-10-20 12:28:02 +02:00
if ( MustResize )
{
resizeEventArgs . Width = glWindow . Width ;
resizeEventArgs . Height = glWindow . Height ;
OnResizeInternal ( resizeEventArgs ) ;
}
2007-07-23 02:15:18 +02:00
}
2007-08-04 14:09:58 +02:00
#endregion
2007-09-26 13:50:44 +02:00
#region OnRenderFrame ( RenderFrameEventArgs e )
2007-08-04 14:09:58 +02:00
/// <summary>
2007-09-26 13:50:44 +02:00
/// Raises the RenderFrame event, and calls the public function.
2007-08-04 14:09:58 +02:00
/// </summary>
2007-09-26 13:50:44 +02:00
/// <param name="e"></param>
private void OnRenderFrameInternal ( RenderFrameEventArgs e )
2007-07-23 02:15:18 +02:00
{
2007-08-10 18:55:24 +02:00
if ( ! this . Exists & & ! this . IsExiting )
2007-08-04 14:09:58 +02:00
{
Debug . Print ( "WARNING: RenderFrame event raised, without a valid render window. This may indicate a programming error. Creating render window." ) ;
mode = new DisplayMode ( 640 , 480 ) ;
this . CreateWindow ( mode ) ;
}
if ( RenderFrame ! = null )
2007-08-06 13:22:18 +02:00
RenderFrame ( this , e ) ;
2007-09-26 13:50:44 +02:00
// Call the user's override.
OnRenderFrame ( e ) ;
}
/// <summary>
/// Override in derived classes to render a frame.
/// </summary>
/// <param name="e">Contains information necessary for frame rendering.</param>
/// <remarks>
/// The base implementation (base.OnRenderFrame) is empty, there is no need to call it.
/// </remarks>
public virtual void OnRenderFrame ( RenderFrameEventArgs e )
{
2007-07-23 02:15:18 +02:00
}
2007-08-06 13:22:18 +02:00
/// <summary>
/// Occurs when it is time to render the next frame.
/// </summary>
public event RenderFrameEvent RenderFrame ;
2007-08-04 14:09:58 +02:00
#endregion
2007-09-26 13:50:44 +02:00
#region OnUpdateFrame ( UpdateFrameEventArgs e )
2007-08-04 14:09:58 +02:00
2007-09-26 13:50:44 +02:00
private void OnUpdateFrameInternal ( UpdateFrameEventArgs e )
2007-07-23 02:15:18 +02:00
{
2007-08-10 18:55:24 +02:00
if ( ! this . Exists & & ! this . IsExiting )
2007-08-04 14:09:58 +02:00
{
2007-10-20 12:28:02 +02:00
//Debug.Print("WARNING: UpdateFrame event raised without a valid render window. This may indicate a programming error. Creating render window.");
//mode = new DisplayMode(640, 480);
//this.CreateWindow(mode);
throw new InvalidOperationException ( "Cannot enter game loop without a render window" ) ;
2007-09-26 13:50:44 +02:00
}
2007-08-04 14:09:58 +02:00
if ( UpdateFrame ! = null )
2007-09-26 13:50:44 +02:00
{
2007-08-06 13:22:18 +02:00
UpdateFrame ( this , e ) ;
2007-09-26 13:50:44 +02:00
}
OnUpdateFrame ( e ) ;
}
/// <summary>
/// Override in derived classes to update a frame.
/// </summary>
/// <param name="e">Contains information necessary for frame updating.</param>
/// <remarks>
/// The base implementation (base.OnUpdateFrame) is empty, there is no need to call it.
/// </remarks>
public virtual void OnUpdateFrame ( UpdateFrameEventArgs e )
{
2007-07-23 02:15:18 +02:00
}
2007-08-04 14:09:58 +02:00
/// <summary>
/// Occurs when it is time to update the next frame.
/// </summary>
public event UpdateFrameEvent UpdateFrame ;
2007-08-06 13:22:18 +02:00
#endregion
2007-09-26 13:50:44 +02:00
#region OnLoad ( EventArgs e )
2007-08-06 13:22:18 +02:00
2007-08-04 14:09:58 +02:00
/// <summary>
2007-09-26 13:50:44 +02:00
/// Occurs after establishing an OpenGL context, but before entering the main loop.
2007-08-04 14:09:58 +02:00
/// </summary>
2007-09-26 13:50:44 +02:00
public event LoadEvent Load ;
/// <summary>
/// Raises the Load event, and calls the user's OnLoad override.
/// </summary>
/// <param name="e"></param>
private void OnLoadInternal ( EventArgs e )
2007-08-06 13:22:18 +02:00
{
2007-10-20 12:28:02 +02:00
if ( MustResize )
{
resizeEventArgs . Width = glWindow . Width ;
resizeEventArgs . Height = glWindow . Height ;
OnResizeInternal ( resizeEventArgs ) ;
}
2007-09-27 01:13:57 +02:00
Debug . WriteLine ( String . Format ( "OpenGL driver information: {0}, {1}, {2}" ,
2007-11-04 16:41:10 +01:00
GL . GetString ( StringName . Renderer ) ,
GL . GetString ( StringName . Vendor ) ,
GL . GetString ( StringName . Version ) ) ) ;
2007-09-27 01:13:57 +02:00
2007-08-06 13:22:18 +02:00
if ( this . Load ! = null )
{
this . Load ( this , e ) ;
}
2007-09-26 13:50:44 +02:00
OnLoad ( e ) ;
2007-08-06 13:22:18 +02:00
}
/// <summary>
2007-09-26 13:50:44 +02:00
/// Occurs after establishing an OpenGL context, but before entering the main loop.
/// Override to load resources that should be maintained for the lifetime of the application.
2007-08-06 13:22:18 +02:00
/// </summary>
2007-09-26 13:50:44 +02:00
/// <param name="e">Not used.</param>
public virtual void OnLoad ( EventArgs e )
{
}
2007-08-06 13:22:18 +02:00
#endregion
2007-07-23 02:15:18 +02:00
2007-09-27 01:13:57 +02:00
#region OnUnload ( EventArgs e )
/// <summary>
/// Occurs after after calling GameWindow.Exit, but before destroying the OpenGL context.
/// </summary>
public event UnloadEvent Unload ;
/// <summary>
/// Raises the Unload event, and calls the user's OnUnload override.
/// </summary>
/// <param name="e"></param>
private void OnUnloadInternal ( EventArgs e )
{
if ( this . Unload ! = null )
{
this . Unload ( this , e ) ;
}
OnUnload ( e ) ;
}
/// <summary>
/// Occurs after after calling GameWindow.Exit, but before destroying the OpenGL context.
/// Override to unload application resources.
/// </summary>
/// <param name="e">Not used.</param>
public virtual void OnUnload ( EventArgs e )
{
}
#endregion
2007-08-06 11:22:04 +02:00
#region public bool IsExiting
/// <summary>
/// Gets a value indicating whether the shutdown sequence has been initiated
/// for this window, by calling GameWindow.Exit() or hitting the 'close' button.
/// If this property is true, it is no longer safe to use any OpenTK.Input or
/// OpenTK.OpenGL functions or properties.
/// </summary>
public bool IsExiting
{
get { return isExiting ; }
}
#endregion
2007-09-26 13:50:44 +02:00
#region public Keyboard Keyboard
/// <summary>
/// Gets the primary Keyboard device, or null if no Keyboard exists.
/// </summary>
public KeyboardDevice Keyboard
{
get
{
2007-11-10 19:26:05 +01:00
//if (input_driver.Keyboard.Count > 0)
// return input_driver.Keyboard[0];
//else
// return null;
if ( glWindow . InputDriver . Keyboard . Count > 0 )
return glWindow . InputDriver . Keyboard [ 0 ] ;
2007-09-26 13:50:44 +02:00
else
return null ;
}
}
#endregion
#region public Mouse Mouse
2007-08-06 11:22:04 +02:00
/// <summary>
2007-09-26 13:50:44 +02:00
/// Gets the primary Mouse device, or null if no Mouse exists.
2007-08-06 11:22:04 +02:00
/// </summary>
2007-09-26 13:50:44 +02:00
public MouseDevice Mouse
2007-08-06 11:22:04 +02:00
{
get
{
2007-11-10 19:26:05 +01:00
//if (input_driver.Mouse.Count > 0)
// return input_driver.Mouse[0];
//else
// return null;
if ( glWindow . InputDriver . Mouse . Count > 0 )
return glWindow . InputDriver . Mouse [ 0 ] ;
2007-09-26 13:50:44 +02:00
else
return null ;
2007-08-06 11:22:04 +02:00
}
}
#endregion
2007-09-30 14:44:42 +02:00
#region public VSyncMode VSync
/// <summary>
/// Gets or sets the VSyncMode.
/// </summary>
public VSyncMode VSync
{
get
{
return vsync ;
}
set
{
if ( value = = VSyncMode . Off )
Context . VSync = false ;
2007-11-08 16:57:10 +01:00
else
2007-09-30 14:44:42 +02:00
Context . VSync = true ;
vsync = value ;
}
}
#endregion
#region public void SwapBuffers ( )
/// <summary>
/// Swaps the front and back buffer, presenting the rendered scene to the user.
/// Only useful in double- or triple-buffered formats.
/// </summary>
/// <remarks>Calling this function is equivalent to calling Context.SwapBuffers()</remarks>
public void SwapBuffers ( )
{
Context . SwapBuffers ( ) ;
}
#endregion
#endregion
#region - - - GameWindow Timing - - -
2007-10-15 13:12:56 +02:00
// TODO: Disabled because it is not reliable enough. Use vsync as a workaround.
//#region public bool AllowSleep
//public bool AllowSleep
//{
// get { return allow_sleep; }
// set { allow_sleep = value; }
//}
//#endregion
2007-09-30 14:44:42 +02:00
#region public double TargetRenderPeriod
/// <summary>
2007-10-26 17:54:35 +02:00
/// Gets or sets a double representing the target render period, in seconds.
2007-09-30 14:44:42 +02:00
/// </summary>
/// <para>A value of 0.0 indicates that RenderFrame events are generated at the maximum possible frequency (i.e. only limited by the hardware's capabilities).</para>
/// <para>Values lower than 0.005 seconds (200Hz) are clamped to 0.0. Values higher than 1.0 seconds (1Hz) are clamped to 1.0.</para>
/// </remarks>
public double TargetRenderPeriod
{
get
{
return target_render_period ;
}
set
{
if ( value < = 0.005 )
{
target_render_period = target_render_period_doubled = 0.0 ;
}
else if ( value < = 1.0 )
{
target_render_period = value ;
target_render_period_doubled = 2.0 * target_render_period ;
}
else Debug . Print ( "Target render period clamped to 1.0 seconds." ) ;
}
}
#endregion
#region public double TargetRenderFrequency
/// <summary>
2007-10-26 17:54:35 +02:00
/// Gets or sets a double representing the target render frequency, in Herz.
2007-09-30 14:44:42 +02:00
/// </summary>
/// <remarks>
/// <para>A value of 0.0 indicates that RenderFrame events are generated at the maximum possible frequency (i.e. only limited by the hardware's capabilities).</para>
/// <para>Values lower than 1.0Hz are clamped to 1.0Hz. Values higher than 200.0Hz are clamped to 200.0Hz.</para>
/// </remarks>
public double TargetRenderFrequency
{
get
{
if ( TargetRenderPeriod = = 0.0 )
return 0.0 ;
return 1.0 / TargetRenderPeriod ;
}
set
{
2007-10-15 13:12:56 +02:00
if ( value < 1.0 )
2007-09-30 14:44:42 +02:00
{
TargetRenderPeriod = 0.0 ;
}
else if ( value < = 200.0 )
{
TargetRenderPeriod = 1.0 / value ;
}
else Debug . Print ( "Target render frequency clamped to 200.0Hz." ) ;
}
}
#endregion
#region public double TargetUpdatePeriod
/// <summary>
2007-10-26 17:54:35 +02:00
/// Gets or sets a double representing the target update period, in seconds.
2007-09-30 14:44:42 +02:00
/// </summary>
/// <remarks>
/// <para>A value of 0.0 indicates that UpdateFrame events are generated at the maximum possible frequency (i.e. only limited by the hardware's capabilities).</para>
/// <para>Values lower than 0.005 seconds (200Hz) are clamped to 0.0. Values higher than 1.0 seconds (1Hz) are clamped to 1.0.</para>
/// </remarks>
public double TargetUpdatePeriod
{
get
{
return target_update_period ;
}
set
{
if ( value < = 0.005 )
{
target_update_period = 0.0 ;
}
else if ( value < = 1.0 )
{
target_update_period = value ;
}
else Debug . Print ( "Target update period clamped to 1.0 seconds." ) ;
}
}
#endregion
#region public double TargetUpdateFrequency
/// <summary>
2007-10-26 17:54:35 +02:00
/// Gets or sets a double representing the target update frequency, in Herz.
2007-09-30 14:44:42 +02:00
/// </summary>
/// <remarks>
/// <para>A value of 0.0 indicates that UpdateFrame events are generated at the maximum possible frequency (i.e. only limited by the hardware's capabilities).</para>
/// <para>Values lower than 1.0Hz are clamped to 1.0Hz. Values higher than 200.0Hz are clamped to 200.0Hz.</para>
/// </remarks>
public double TargetUpdateFrequency
{
get
{
if ( TargetUpdatePeriod = = 0.0 )
return 0.0 ;
return 1.0 / TargetUpdatePeriod ;
}
set
{
2007-10-15 13:12:56 +02:00
if ( value < 1.0 )
2007-09-30 14:44:42 +02:00
{
TargetUpdatePeriod = 0.0 ;
}
else if ( value < = 200.0 )
{
TargetUpdatePeriod = 1.0 / value ;
}
else Debug . Print ( "Target update frequency clamped to 200.0Hz." ) ;
}
}
#endregion
#region public double RenderFrequency
/// <summary>
2007-10-26 17:54:35 +02:00
/// Gets a double representing the actual frequency of RenderFrame events, in Herz (i.e. FPS or Frames Per Second).
2007-09-30 14:44:42 +02:00
/// </summary>
public double RenderFrequency
{
get
{
if ( render_period = = 0.0 )
return 1.0 ;
return 1.0 / render_period ;
}
}
#endregion
#region public double RenderPeriod
/// <summary>
2007-10-26 17:54:35 +02:00
/// Gets a double representing the period of RenderFrame events, in seconds.
2007-09-30 14:44:42 +02:00
/// </summary>
public double RenderPeriod
{
get
{
return render_period ;
}
}
#endregion
#region public double UpdateFrequency
/// <summary>
2007-10-26 17:54:35 +02:00
/// Gets a double representing the frequency of UpdateFrame events, in Herz.
2007-09-30 14:44:42 +02:00
/// </summary>
public double UpdateFrequency
{
get
{
if ( update_period = = 0.0 )
return 1.0 ;
return 1.0 / update_period ;
}
}
#endregion
#region public double UpdatePeriod
/// <summary>
2007-10-26 17:54:35 +02:00
/// Gets a double representing the period of UpdateFrame events, in seconds.
2007-09-30 14:44:42 +02:00
/// </summary>
public double UpdatePeriod
{
get
{
return update_period ;
}
}
#endregion
2007-10-26 17:54:35 +02:00
#region public double RenderTime
/// <summary>
/// Gets a double representing the time spent in the RenderFrame function, in seconds.
/// </summary>
public double RenderTime
{
get { return render_time ; }
protected set { render_time = value ; }
}
#endregion
#region public double RenderTime
/// <summary>
/// Gets a double representing the time spent in the UpdateFrame function, in seconds.
/// </summary>
public double UpdateTime
{
get { return update_time ; }
}
#endregion
2007-07-23 02:15:18 +02:00
#endregion
#region - - - IResizable Members - - -
#region public int Width , Height
2007-08-21 14:04:01 +02:00
/// <summary>
/// Gets or sets the Width of the GameWindow's rendering area, in pixels.
/// </summary>
2007-07-23 02:15:18 +02:00
public int Width
{
2007-09-26 13:50:44 +02:00
get { return width ; }
2007-07-23 02:15:18 +02:00
set
{
if ( value = = this . Width )
{
return ;
}
else if ( value > 0 )
{
glWindow . Width = value ;
}
else
{
throw new ArgumentOutOfRangeException (
"Width" ,
value ,
"Width must be greater than 0"
) ;
}
}
}
2007-08-21 14:04:01 +02:00
/// <summary>
/// Gets or sets the Height of the GameWindow's rendering area, in pixels.
/// </summary>
2007-07-23 02:15:18 +02:00
public int Height
{
2007-09-26 13:50:44 +02:00
get { return height ; }
2007-07-23 02:15:18 +02:00
set
{
if ( value = = this . Height )
{
return ;
}
else if ( value > 0 )
{
glWindow . Height = value ;
}
else
{
throw new ArgumentOutOfRangeException (
"Height" ,
value ,
"Height must be greater than 0"
) ;
}
}
}
#endregion
#region public event ResizeEvent Resize ;
2007-09-26 13:50:44 +02:00
/// <summary>
/// Occurs when the GameWindow is resized. Derived classes should override the OnResize method for better performance.
/// </summary>
2007-07-23 02:15:18 +02:00
public event ResizeEvent Resize ;
/// <summary>
/// Raises the Resize event.
/// </summary>
2007-09-26 13:50:44 +02:00
/// <param name="e">Contains information about the Resize event.</param>
private void OnResizeInternal ( ResizeEventArgs e )
2007-07-23 02:15:18 +02:00
{
2007-08-06 13:22:18 +02:00
Debug . Print ( "Firing GameWindow.Resize event: {0}." , e . ToString ( ) ) ;
2007-09-26 13:50:44 +02:00
this . width = e . Width ;
this . height = e . Height ;
2007-07-23 02:15:18 +02:00
if ( this . Resize ! = null )
this . Resize ( this , e ) ;
2007-09-26 13:50:44 +02:00
OnResize ( e ) ;
}
/// <summary>
/// Override in derived classes to respond to the Resize events.
/// </summary>
/// <param name="e">Contains information about the Resize event.</param>
protected virtual void OnResize ( ResizeEventArgs e )
{
2007-07-23 02:15:18 +02:00
}
#endregion
2007-08-21 14:04:01 +02:00
/ *
/// <summary>
/// Gets the Top coordinate of the GameWindow's rendering area, in pixel coordinates relative to the GameWindow's top left point.
/// </summary>
public int Top
{
get { return glWindow . Top ; }
}
/// <summary>
/// /// Gets the Bottom coordinate of the GameWindow's rendering area, in pixel coordinates relative to the GameWindow's top left point.
/// </summary>
public int Bottom
{
get { return glWindow . Bottom ; }
}
2007-07-23 02:15:18 +02:00
2007-08-21 14:04:01 +02:00
/// <summary>
/// Gets the Left coordinate of the GameWindow's rendering area, in pixel coordinates relative to the GameWindow's top left point.
/// </summary>
public int Left
{
get { return glWindow . Left ; }
}
/// <summary>
/// Gets the Right coordinate of the GameWindow's rendering area, in pixel coordinates relative to the GameWindow's top left point.
/// </summary>
public int Right
{
get { return glWindow . Right ; }
}
* /
2007-07-23 02:15:18 +02:00
#endregion
2008-01-06 03:29:54 +01:00
#region PointToClient
/// <summary>
/// Converts the screen coordinates of a specified point on the screen to client-area coordinates.
/// </summary>
/// <param name="p">A System.Drawing.Point structure that specifies the screen coordinates to be converted</param>
/// <returns>The client-area coordinates of the point. The new coordinates are relative to the upper-left corner of the GameWindow's client area.</returns>
public System . Drawing . Point PointToClient ( System . Drawing . Point p )
{
glWindow . PointToClient ( ref p ) ;
return p ;
}
#endregion
#region PointToScreen
/// <summary>
/// Converts the client-area coordinates of a specified point to screen coordinates.
/// </summary>
/// <param name="p">A System.Drawing.Point structure that specifies the client-area coordinates to be converted</param>
/// <returns>The screen coordinates of the point, relative to the upper-left corner of the screen. Note, a screen-coordinate point that is above the window's client area has a negative y-coordinate. Similarly, a screen coordinate to the left of a client area has a negative x-coordinate.</returns>
public System . Drawing . Point PointToScreen ( System . Drawing . Point p )
{
glWindow . PointToScreen ( ref p ) ;
return p ;
}
#endregion
2007-07-23 02:15:18 +02:00
#region - - - IDisposable Members - - -
2007-09-27 01:13:57 +02:00
/// <summary>
/// Not used yet.
/// </summary>
private void DisposeInternal ( )
{
Dispose ( ) ; // User overridable Dispose method.
}
2007-09-25 18:45:12 +02:00
/// <summary>
/// Disposes of the GameWindow, releasing all resources consumed by it.
/// </summary>
public virtual void Dispose ( )
2007-07-23 02:15:18 +02:00
{
2007-10-26 17:54:35 +02:00
Dispose ( true ) ;
2007-09-25 18:45:12 +02:00
GC . SuppressFinalize ( this ) ;
2007-08-06 11:22:04 +02:00
}
private void Dispose ( bool manual )
{
if ( ! disposed )
{
if ( manual )
{
if ( glWindow ! = null )
{
2008-01-11 21:37:09 +01:00
glContext . Dispose ( ) ;
2007-08-06 11:22:04 +02:00
glWindow . Dispose ( ) ;
glWindow = null ;
}
}
disposed = true ;
}
}
2007-09-25 18:45:12 +02:00
~ GameWindow ( )
{
2007-10-26 17:54:35 +02:00
Dispose ( false ) ;
2007-09-25 18:45:12 +02:00
}
2007-07-23 02:15:18 +02:00
#endregion
}
2007-09-23 00:01:43 +02:00
2007-09-30 14:44:42 +02:00
#region public enum VSyncMode
/// <summary>
2008-01-06 03:29:54 +01:00
/// Enumerates available VSync modes.
2007-09-30 14:44:42 +02:00
/// </summary>
public enum VSyncMode
{
/// <summary>
/// Vsync disabled.
/// </summary>
Off = 0 ,
/// <summary>
/// VSync enabled.
/// </summary>
On ,
/// <summary>
/// VSync enabled, but automatically disabled if framerate falls below a specified limit.
/// </summary>
2007-10-15 13:12:56 +02:00
Adaptive ,
2007-09-30 14:44:42 +02:00
}
#endregion
#region - - - GameWindow Events - - -
public delegate void UpdateFrameEvent ( GameWindow sender , UpdateFrameEventArgs e ) ;
public delegate void RenderFrameEvent ( GameWindow sender , RenderFrameEventArgs e ) ;
public delegate void LoadEvent ( GameWindow sender , EventArgs e ) ;
public delegate void UnloadEvent ( GameWindow sender , EventArgs e ) ;
2007-09-23 00:01:43 +02:00
public class UpdateFrameEventArgs : EventArgs
{
2007-09-23 14:09:42 +02:00
private double time ;
/// <summary>
/// Gets the Time elapsed between frame updates, in seconds.
/// </summary>
public double Time
{
get { return time ; }
internal set { time = value ; }
}
}
public class RenderFrameEventArgs : EventArgs
{
private double time ;
2007-09-30 14:44:42 +02:00
private double scale_factor ;
2007-09-23 00:01:43 +02:00
/// <summary>
/// Gets the Time elapsed between frame updates, in seconds.
/// </summary>
2007-09-23 14:09:42 +02:00
public double Time
2007-09-23 00:01:43 +02:00
{
get { return time ; }
internal set { time = value ; }
}
2007-09-30 14:44:42 +02:00
public double ScaleFactor
{
get
{
return scale_factor ;
}
internal set
{
if ( value ! = 0.0 & & ! Double . IsNaN ( value ) )
scale_factor = value ;
else
scale_factor = 1.0 ;
}
}
2007-09-23 00:01:43 +02:00
}
2007-09-30 14:44:42 +02:00
#endregion
2007-10-15 13:12:56 +02:00
#region - - - GameWindow Exceptions - - -
2007-11-12 20:21:45 +01:00
[DebuggerNonUserCode]
2007-11-10 19:26:05 +01:00
class GameWindowExitException : ApplicationException
2007-10-15 13:12:56 +02:00
{
2007-11-11 21:23:25 +01:00
public override string Message
{
get
{
2007-11-12 20:21:45 +01:00
return
@ "This exception is a normal part of the GameWindow shutdown process and is completely harmless. While this warning will never be seen by end-users, Visual Studio reminds you that an exception is leaving your code unhandled, which can sometimes be a security breach.
You can disable this warning for this specific exception : select Debug - > Exceptions from the menu bar and click "" Add "" . Choose "" Common Language Runtime Exceptions "" , type "" OpenTK . GameWindowExitException "" in the box below and click "" Ok "" . Deselecting the "" User - unhandled "" checkbox from the newly created exception will disable this warning .
Alternatively , you can disable the "" Just my code "" debugging mode ( "" Tools - > Options - > Debugging - > General "" and untick "" Enable Just my code ( Managed only ) "" . This has the sideffect that it will allow you to step into OpenTK code if an error happens . Please , do this only if you are confident in your debugging skills . ";
2007-11-11 21:23:25 +01:00
}
}
2007-10-15 13:12:56 +02:00
}
#endregion
2007-07-23 02:15:18 +02:00
}