2007-07-23 00:15:18 +00: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-26 22:56:55 +00:00
using System.Diagnostics ;
2007-07-23 00:15:18 +00:00
using OpenTK.Platform ;
2007-08-06 09:22:04 +00:00
using OpenTK.Input ;
using System.Threading ;
2007-09-02 22:52:00 +00:00
using OpenTK.OpenGL ;
2007-11-04 15:41:10 +00:00
using OpenTK.OpenGL.Enums ;
2007-07-23 00:15:18 +00:00
namespace OpenTK
{
2007-09-26 11:50:44 +00:00
/// <summary>
2007-11-04 15:41:10 +00:00
/// The GameWindow class contains cross-platform methods to create and render on an OpenGL
2007-11-01 23:28:31 +00:00
/// window, handle input and load resources.
2007-09-26 11:50:44 +00:00
/// </summary>
/// <remarks>
/// GameWindow contains several events you can hook or override to add your custom logic:
/// <list>
2007-11-04 15:41:10 +00:00
/// <item>
/// OnLoad: Occurs after creating the OpenGL context, but before entering the main loop.
/// Override to load resources.
2007-11-01 23:28:31 +00:00
/// </item>
2007-11-04 15:41:10 +00:00
/// <item>
/// OnUnload: Occurs after exiting the main loop, but before deleting the OpenGL context.
/// Override to unload resources.
2007-11-01 23:28:31 +00:00
/// </item>
2007-11-04 15:41:10 +00:00
/// <item>
/// OnResize: Occurs whenever GameWindow is resized. You should update the OpenGL Viewport
/// and Projection Matrix here.
2007-11-01 23:28:31 +00:00
/// </item>
2007-11-04 15:41:10 +00:00
/// <item>
/// OnUpdateFrame: Occurs at the specified logic update rate. Override to add your game
/// logic.
2007-11-01 23:28:31 +00:00
/// </item>
2007-11-04 15:41:10 +00:00
/// <item>
/// OnRenderFrame: Occurs at the specified frame render rate. Override to add your
/// rendering code.
2007-11-01 23:28:31 +00:00
/// </item>
2007-09-26 11:50:44 +00:00
/// </list>
2007-11-04 15:41:10 +00:00
/// Call the Run() method to start the application's main loop. Run(double, double) takes two
2007-11-01 23:28:31 +00:00
/// parameters that
2007-09-26 11:50:44 +00:00
/// specify the logic update rate, and the render update rate.
/// </remarks>
2007-09-30 12:44:42 +00:00
public class GameWindow : INativeGLWindow
2007-07-23 00:15:18 +00:00
{
2007-08-05 13:42:31 +00:00
#region - - - Fields - - -
2007-09-26 11:50:44 +00:00
INativeGLWindow glWindow ;
DisplayMode mode ;
2007-07-23 00:15:18 +00:00
2007-09-26 11:50:44 +00:00
ResizeEventArgs resizeEventArgs = new ResizeEventArgs ( ) ;
2007-08-05 13:42:31 +00:00
2007-09-26 11:50:44 +00:00
bool isExiting ;
bool disposed ;
2007-08-06 09:22:04 +00:00
2007-09-30 12:44:42 +00: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 11:12:56 +00:00
//bool allow_sleep = true; // If true, GameWindow will call Timer.Sleep() if there is enough time.
2007-09-26 11:50:44 +00:00
int width , height ;
2007-09-30 12:44:42 +00:00
VSyncMode vsync ;
2007-10-19 20:03:53 +00:00
InputDriver input_driver ;
2007-09-26 11:50:44 +00:00
#endregion
2007-09-30 12:44:42 +00:00
#region - - - Internal Properties - - -
2007-09-26 11:50:44 +00:00
bool MustResize
{
get { return glWindow . Width ! = this . Width | | glWindow . Height ! = this . Height ; }
}
2007-09-23 12:09:42 +00:00
2007-08-05 13:42:31 +00:00
#endregion
2007-08-03 00:14:31 +00:00
2007-07-23 00:15:18 +00:00
#region - - - Contructors - - -
/// <summary>
2007-10-19 20:03:53 +00:00
/// Constructs a new GameWindow using a safe DisplayMode.
/// </summary>
2007-11-04 15:41:10 +00:00
public GameWindow ( ) : this ( new DisplayMode ( 640 , 480 , 0 , 16 , false ) , "OpenTK game window" )
2007-11-01 23:28:31 +00:00
{ }
2007-10-19 20:03:53 +00:00
/// <summary>
/// Constructs a new GameWindow, and opens a render window with the specified DisplayMode.
2007-07-23 00:15:18 +00:00
/// </summary>
2007-10-19 20:03:53 +00:00
/// <param name="mode">The DisplayMode of the GameWindow.</param>
public GameWindow ( DisplayMode mode ) : this ( mode , "OpenTK game window" ) { }
/// <summary>
2007-11-04 15:41:10 +00:00
/// Constructs a new GameWindow with the specified title, and opens a render window with the
2007-11-01 23:28:31 +00:00
/// specified DisplayMode.
2007-10-19 20:03:53 +00: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 00:15:18 +00:00
{
2007-09-09 16:07:39 +00:00
switch ( Environment . OSVersion . Platform )
2007-07-23 00:15:18 +00:00
{
2007-09-09 16:07:39 +00:00
case PlatformID . Win32NT :
case PlatformID . Win32S :
case PlatformID . Win32Windows :
case PlatformID . WinCE :
glWindow = new OpenTK . Platform . Windows . WinGLNative ( ) ;
break ;
2007-10-19 20:03:53 +00:00
2007-09-09 16:07:39 +00:00
case PlatformID . Unix :
case ( PlatformID ) 128 :
glWindow = new OpenTK . Platform . X11 . X11GLNative ( ) ;
break ;
2007-10-19 20:03:53 +00:00
2007-09-09 16:07:39 +00:00
default :
throw new PlatformNotSupportedException ( "Your platform is not supported currently. Please, refer to http://opentk.sourceforge.net for more information." ) ;
2007-07-23 00:15:18 +00:00
}
2007-08-10 16:55:24 +00:00
glWindow . Destroy + = new DestroyEvent ( glWindow_Destroy ) ;
2007-10-19 20:03:53 +00:00
2007-09-26 11:50:44 +00:00
CreateWindow ( mode , title ) ;
2007-10-20 14:22:39 +00:00
this . vsync = VSyncMode . Adaptive ;
2007-09-26 11:50:44 +00:00
}
2007-08-06 11:22:18 +00:00
void glWindow_Destroy ( object sender , EventArgs e )
{
2007-08-06 12:13:50 +00:00
glWindow . Destroy - = glWindow_Destroy ;
2007-07-23 00:15:18 +00:00
2007-10-19 20:03:53 +00:00
Debug . Print ( "GameWindow destruction imminent." ) ;
this . isExiting = true ;
//this.OnDestroy(EventArgs.Empty);
2007-07-23 00:15:18 +00:00
}
#endregion
2007-08-05 13:42:31 +00:00
#region - - - INativeGLWindow Members - - -
2007-08-04 12:09:58 +00:00
#region public void Exit ( )
/// <summary>
/// Gracefully exits the current GameWindow.
2007-08-06 09:22:04 +00:00
/// Override if you want to provide yor own exit sequence.
/// If you override this method, place a call to base.Exit(), to ensure
/// proper OpenTK shutdown.
2007-08-04 12:09:58 +00:00
/// </summary>
2007-08-06 09:22:04 +00:00
public virtual void Exit ( )
2007-08-04 12:09:58 +00:00
{
2007-08-06 09:22:04 +00:00
isExiting = true ;
2007-10-26 15:54:35 +00:00
//throw new GameWindowExitException();
2007-08-06 09:22:04 +00:00
//glWindow.Exit();
//this.Dispose();
2007-08-04 12:09:58 +00:00
}
#endregion
2007-07-23 00:15:18 +00:00
#region public bool IsIdle
2007-08-04 12:09:58 +00: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 00:15:18 +00:00
public bool IsIdle
{
get { return glWindow . IsIdle ; }
}
#endregion
#region public bool Fullscreen
2007-09-26 15:43:28 +00: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 00:15:18 +00:00
public bool Fullscreen
{
2007-10-15 11:12:56 +00:00
get { return false ; /* return glWindow.Fullscreen; */ }
set { /* glWindow.Fullscreen = value; */ }
2007-07-23 00:15:18 +00:00
}
#endregion
2007-08-04 12:09:58 +00:00
#region public IGLContext Context
2007-07-23 00:15:18 +00:00
2007-08-04 12:09:58 +00:00
/// <summary>
/// Returns the opengl IGLontext associated with the current GameWindow.
/// Forces window creation.
/// </summary>
public IGLContext Context
2007-07-23 00:15:18 +00:00
{
2007-08-04 12:09:58 +00:00
get
{
2007-08-10 16:55:24 +00: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 ) ;
}
return glWindow . Context ;
}
2007-07-23 00:15:18 +00:00
}
#endregion
2007-08-06 09:22:04 +00:00
#region public bool Exists
2007-07-23 00:15:18 +00:00
2007-08-04 12:09:58 +00:00
/// <summary>
2007-09-26 11:50:44 +00:00
/// Gets a value indicating whether a render window exists.
2007-08-04 12:09:58 +00:00
/// </summary>
2007-08-06 09:22:04 +00:00
public bool Exists
2007-07-23 00:15:18 +00:00
{
2007-08-10 16:55:24 +00:00
get { return glWindow = = null ? false : glWindow . Exists ; }
2007-07-23 00:15:18 +00:00
}
#endregion
2007-09-26 11:50:44 +00: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 15:43:28 +00:00
/// TODO: This property is not implemented
2007-09-26 11:50:44 +00:00
/// Gets or sets a value indicating whether the GameWindow is visible.
/// </summary>
public bool Visible
{
get
{
2007-09-26 15:43:28 +00:00
throw new NotImplementedException ( ) ;
2007-11-06 13:37:19 +00:00
//return glWindow.Visible;
2007-09-26 11:50:44 +00:00
}
set
{
2007-09-26 15:43:28 +00:00
throw new NotImplementedException ( ) ;
2007-11-06 13:37:19 +00:00
//glWindow.Visible = value;
2007-09-26 11:50:44 +00:00
}
}
#endregion
2007-08-05 13:42:31 +00:00
#region public IWindowInfo WindowInfo
public IWindowInfo WindowInfo
{
get { return glWindow . WindowInfo ; }
}
#endregion
2007-10-19 20:03:53 +00:00
#if false
2007-08-05 13:42:31 +00:00
2007-09-26 11:50:44 +00: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 20:03:53 +00:00
return null ;
2007-09-26 11:50:44 +00:00
}
}
#endregion
2007-10-19 20:03:53 +00:00
#endif
2007-08-06 11:22:18 +00:00
#region public void CreateWindow ( DisplayMode mode )
/// <summary>
2007-09-26 11:50:44 +00:00
/// Creates a render window for the calling GameWindow.
2007-08-06 11:22:18 +00:00
/// </summary>
/// <param name="mode">The DisplayMode of the render window.</param>
2007-09-26 11:50:44 +00: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 11:22:18 +00:00
/// <exception cref="ApplicationException">Occurs when a render window already exists.</exception>
public void CreateWindow ( DisplayMode mode )
{
if ( ! Exists )
{
2007-08-20 13:47:14 +00:00
try
{
glWindow . CreateWindow ( mode ) ;
}
catch ( ApplicationException expt )
{
Debug . Print ( expt . ToString ( ) ) ;
throw ;
}
2007-08-06 11:22:18 +00:00
}
else
{
2007-09-26 11:50:44 +00:00
throw new ApplicationException ( "A render window already exists for this GameWindow." ) ;
2007-08-06 11:22:18 +00:00
}
}
#endregion
#region OnCreate
2007-09-02 00:13:52 +00:00
[Obsolete("The Create event is obsolete and will be removed on later versions. Use the Load event instead.")]
2007-08-06 11:22:18 +00:00
public event CreateEvent Create ;
2007-08-10 16:55:24 +00:00
/// <summary>
/// Raises the Create event. Override in derived classes to initialize resources.
/// </summary>
/// <param name="e"></param>
2007-09-02 00:13:52 +00:00
[Obsolete("The OnCreate method is obsolete and will be removed on later versions. Use the OnLoad method instead.")]
2007-08-06 11:22:18 +00:00
public virtual void OnCreate ( EventArgs e )
{
2007-08-20 10:46:37 +00:00
Debug . WriteLine ( "Firing GameWindow.Create event" ) ;
2007-08-06 11:22:18 +00:00
if ( this . Create ! = null )
{
this . Create ( this , e ) ;
}
}
#endregion
#region public void DestroyWindow ( )
2007-08-10 16:55:24 +00: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 11:22:18 +00:00
public void DestroyWindow ( )
{
if ( Exists )
{
glWindow . DestroyWindow ( ) ;
}
else
{
throw new ApplicationException ( "Tried to destroy inexistent window." ) ;
}
}
#endregion
#region OnDestroy
2007-08-10 16:55:24 +00:00
/// <summary>
/// Raises the Destroy event. Override in derived classes, to modify the shutdown
/// sequence (e.g. to release resources before shutdown).
/// </summary>
/// <param name="e"></param>
2007-08-06 11:22:18 +00:00
public virtual void OnDestroy ( EventArgs e )
{
2007-08-20 10:46:37 +00:00
Debug . WriteLine ( "Firing GameWindow.Destroy event" ) ;
2007-08-06 11:22:18 +00:00
if ( this . Destroy ! = null )
{
this . Destroy ( this , e ) ;
}
}
public event DestroyEvent Destroy ;
#endregion
2007-07-23 00:15:18 +00:00
#endregion
2007-09-30 12:44:42 +00:00
#region - - - GameWindow Methods - - -
2007-07-23 00:15:18 +00:00
2007-10-26 15:54:35 +00: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 )
{
try
{
glWindow . CreateWindow ( mode ) ;
this . Title = title ;
input_driver = new InputDriver ( this ) ;
}
catch ( ApplicationException expt )
{
Debug . Print ( expt . ToString ( ) ) ;
throw ;
}
}
else
{
throw new InvalidOperationException ( "A render window already exists for this GameWindow." ) ;
}
}
#endregion
2007-09-26 23:13:57 +00:00
#region void Run ( )
2007-08-04 12:09:58 +00:00
2007-07-23 00:15:18 +00:00
/// <summary>
2007-10-15 11:12:56 +00:00
/// Enters the game loop of the GameWindow updating and rendering at the maximum possible frequency.
2007-07-23 00:15:18 +00:00
/// </summary>
2007-10-15 11:12:56 +00:00
/// <see cref="public virtual void Run(double update_frequency, double render_frequency)"/>
2007-09-23 12:37:07 +00:00
public void Run ( )
{
Run ( 0.0 , 0.0 ) ;
}
/// <summary>
2007-10-15 11:12:56 +00:00
/// Enters the game loop of the GameWindow updating the specified update frequency, while maintaining the
2007-09-23 12:37:07 +00: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 11:12:56 +00:00
/// Enters the game loop of the GameWindow updating and rendering at the specified frequency.
2007-09-23 12:37:07 +00:00
/// </summary>
2007-10-15 11:12:56 +00: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 12:44:42 +00:00
public void Run ( double updates_per_second , double frames_per_second )
{
2007-10-20 14:22:39 +00:00
try
2007-09-30 12:44:42 +00:00
{
2007-10-20 14:22:39 +00: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 12:44:42 +00:00
2007-10-20 14:22:39 +00:00
TargetUpdateFrequency = updates_per_second ;
TargetRenderFrequency = frames_per_second ;
2007-09-30 12:44:42 +00:00
2007-10-20 14:22:39 +00: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 12:44:42 +00:00
2007-10-26 15:54:35 +00:00
//double sleep_granularity; // In seconds.
2007-09-30 12:44:42 +00:00
2007-10-20 14:22:39 +00:00
//GC.Collect(2);
//GC.WaitForPendingFinalizers();
//GC.Collect(2);
2007-09-30 12:44:42 +00:00
2007-10-20 14:22:39 +00: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 11:12:56 +00:00
2007-10-20 14:22:39 +00:00
OnLoadInternal ( EventArgs . Empty ) ;
2007-09-30 12:44:42 +00:00
2007-10-20 14:22:39 +00:00
Thread . CurrentThread . Priority = ThreadPriority . AboveNormal ;
2007-09-30 12:44:42 +00:00
2007-10-20 14:22:39 +00:00
while ( ! isExiting )
2007-09-30 12:44:42 +00:00
{
2007-10-20 14:22:39 +00:00
// Process events
ProcessEvents ( ) ;
2007-09-30 12:44:42 +00:00
2007-10-20 14:22:39 +00: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 15:54:35 +00:00
if ( next_update < - 1.0 ) // Cap the maximum time drift, to avoid lengthy catch-up games.
next_update = - 1.0 ;
2007-10-20 14:22:39 +00:00
update_time_counter + = time ;
+ + num_updates ;
update_watch . Reset ( ) ;
update_watch . Start ( ) ;
update_args . Time = time ;
OnUpdateFrameInternal ( update_args ) ;
2007-10-26 15:54:35 +00:00
update_time = update_watch . Elapsed . TotalSeconds ;
2007-10-20 14:22:39 +00:00
if ( TargetUpdateFrequency = = 0.0 )
break ;
time = update_watch . Elapsed . TotalSeconds ;
next_update - = time ;
update_time_counter + = time ;
2007-10-26 15:54:35 +00:00
// Allow up to 10 frames to be dropped. Prevents the application from hanging
// with very high update frequencies.
2007-10-20 14:22:39 +00: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 ;
}
2007-10-26 15:54:35 +00:00
if ( isExiting )
break ;
2007-10-20 14:22:39 +00:00
// 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 15:54:35 +00:00
if ( RenderTime > 2.0 * TargetRenderPeriod )
2007-10-20 14:22:39 +00:00
Context . VSync = false ;
else
Context . VSync = true ;
}
if ( time_left < = 0.0 )
{
next_render = time_left + TargetRenderPeriod ;
2007-10-26 15:54:35 +00:00
if ( next_render < - 1.0 ) // Cap the maximum time drift, to avoid lengthy catch-up games.
next_render = - 1.0 ;
2007-10-20 14:22:39 +00:00
render_watch . Reset ( ) ;
render_watch . Start ( ) ;
render_period = render_args . Time = time ;
render_args . ScaleFactor = RenderPeriod / UpdatePeriod ;
OnRenderFrameInternal ( render_args ) ;
2007-10-26 15:54:35 +00:00
render_time = render_watch . Elapsed . TotalSeconds ;
2007-10-20 14:22:39 +00: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 11:22:18 +00:00
}
2007-07-23 00:15:18 +00:00
}
2007-10-26 15:54:35 +00:00
//catch (GameWindowExitException e)
//{
2007-08-06 09:22:04 +00:00
2007-10-26 15:54:35 +00:00
//}
2007-10-20 14:22:39 +00:00
finally
{
Thread . CurrentThread . Priority = ThreadPriority . Normal ;
2007-10-15 11:12:56 +00:00
2007-10-20 14:22:39 +00:00
OnUnloadInternal ( EventArgs . Empty ) ;
2007-09-26 23:13:57 +00:00
2007-10-20 14:22:39 +00:00
if ( this . Exists )
2007-08-06 11:22:18 +00:00
{
2007-10-20 14:22:39 +00:00
glWindow . DestroyWindow ( ) ;
while ( this . Exists )
{
this . ProcessEvents ( ) ;
}
2007-08-06 11:22:18 +00:00
}
2007-08-06 09:22:04 +00:00
}
2007-07-23 00:15:18 +00:00
}
2007-08-04 12:09:58 +00: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 00:15:18 +00:00
public void ProcessEvents ( )
{
2007-09-30 12:44:42 +00:00
//if (!isExiting)
// InputDriver.Poll();
2007-07-23 00:15:18 +00:00
glWindow . ProcessEvents ( ) ;
2007-10-20 10:28:02 +00:00
if ( MustResize )
{
resizeEventArgs . Width = glWindow . Width ;
resizeEventArgs . Height = glWindow . Height ;
OnResizeInternal ( resizeEventArgs ) ;
}
2007-07-23 00:15:18 +00:00
}
2007-08-04 12:09:58 +00:00
#endregion
2007-09-26 11:50:44 +00:00
#region OnRenderFrame ( RenderFrameEventArgs e )
2007-08-04 12:09:58 +00:00
/// <summary>
2007-09-26 11:50:44 +00:00
/// Raises the RenderFrame event, and calls the public function.
2007-08-04 12:09:58 +00:00
/// </summary>
2007-09-26 11:50:44 +00:00
/// <param name="e"></param>
private void OnRenderFrameInternal ( RenderFrameEventArgs e )
2007-07-23 00:15:18 +00:00
{
2007-08-10 16:55:24 +00:00
if ( ! this . Exists & & ! this . IsExiting )
2007-08-04 12:09:58 +00: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 11:22:18 +00:00
RenderFrame ( this , e ) ;
2007-09-26 11:50:44 +00: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 00:15:18 +00:00
}
2007-08-06 11:22:18 +00:00
/// <summary>
/// Occurs when it is time to render the next frame.
/// </summary>
public event RenderFrameEvent RenderFrame ;
2007-08-04 12:09:58 +00:00
#endregion
2007-09-26 11:50:44 +00:00
#region OnUpdateFrame ( UpdateFrameEventArgs e )
2007-08-04 12:09:58 +00:00
2007-09-26 11:50:44 +00:00
private void OnUpdateFrameInternal ( UpdateFrameEventArgs e )
2007-07-23 00:15:18 +00:00
{
2007-08-10 16:55:24 +00:00
if ( ! this . Exists & & ! this . IsExiting )
2007-08-04 12:09:58 +00:00
{
2007-10-20 10:28:02 +00: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 11:50:44 +00:00
}
2007-08-04 12:09:58 +00:00
if ( UpdateFrame ! = null )
2007-09-26 11:50:44 +00:00
{
2007-08-06 11:22:18 +00:00
UpdateFrame ( this , e ) ;
2007-09-26 11:50:44 +00: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 00:15:18 +00:00
}
2007-08-04 12:09:58 +00:00
/// <summary>
/// Occurs when it is time to update the next frame.
/// </summary>
public event UpdateFrameEvent UpdateFrame ;
2007-08-06 11:22:18 +00:00
#endregion
2007-09-26 11:50:44 +00:00
#region OnLoad ( EventArgs e )
2007-08-06 11:22:18 +00:00
2007-08-04 12:09:58 +00:00
/// <summary>
2007-09-26 11:50:44 +00:00
/// Occurs after establishing an OpenGL context, but before entering the main loop.
2007-08-04 12:09:58 +00:00
/// </summary>
2007-09-26 11:50:44 +00: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 11:22:18 +00:00
{
2007-10-20 10:28:02 +00:00
if ( MustResize )
{
resizeEventArgs . Width = glWindow . Width ;
resizeEventArgs . Height = glWindow . Height ;
OnResizeInternal ( resizeEventArgs ) ;
}
2007-09-26 23:13:57 +00:00
Debug . WriteLine ( String . Format ( "OpenGL driver information: {0}, {1}, {2}" ,
2007-11-04 15:41:10 +00:00
GL . GetString ( StringName . Renderer ) ,
GL . GetString ( StringName . Vendor ) ,
GL . GetString ( StringName . Version ) ) ) ;
2007-09-26 23:13:57 +00:00
2007-08-06 11:22:18 +00:00
if ( this . Load ! = null )
{
this . Load ( this , e ) ;
}
2007-09-26 11:50:44 +00:00
OnLoad ( e ) ;
2007-08-06 11:22:18 +00:00
}
/// <summary>
2007-09-26 11:50:44 +00: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 11:22:18 +00:00
/// </summary>
2007-09-26 11:50:44 +00:00
/// <param name="e">Not used.</param>
public virtual void OnLoad ( EventArgs e )
{
}
2007-08-06 11:22:18 +00:00
#endregion
2007-07-23 00:15:18 +00:00
2007-09-26 23:13:57 +00: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 09:22:04 +00: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 11:50:44 +00:00
#region public Keyboard Keyboard
/// <summary>
/// Gets the primary Keyboard device, or null if no Keyboard exists.
/// </summary>
public KeyboardDevice Keyboard
{
get
{
2007-10-19 20:03:53 +00:00
if ( input_driver . Keyboard . Count > 0 )
return input_driver . Keyboard [ 0 ] ;
2007-09-26 11:50:44 +00:00
else
return null ;
}
}
#endregion
#region public Mouse Mouse
2007-08-06 09:22:04 +00:00
/// <summary>
2007-09-26 11:50:44 +00:00
/// Gets the primary Mouse device, or null if no Mouse exists.
2007-08-06 09:22:04 +00:00
/// </summary>
2007-09-26 11:50:44 +00:00
public MouseDevice Mouse
2007-08-06 09:22:04 +00:00
{
get
{
2007-10-19 20:03:53 +00:00
if ( input_driver . Mouse . Count > 0 )
return input_driver . Mouse [ 0 ] ;
2007-09-26 11:50:44 +00:00
else
return null ;
2007-08-06 09:22:04 +00:00
}
}
#endregion
2007-09-30 12:44:42 +00: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 ;
else if ( value = = VSyncMode . On )
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 11:12:56 +00: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 12:44:42 +00:00
#region public double TargetRenderPeriod
/// <summary>
2007-10-26 15:54:35 +00:00
/// Gets or sets a double representing the target render period, in seconds.
2007-09-30 12:44:42 +00: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 15:54:35 +00:00
/// Gets or sets a double representing the target render frequency, in Herz.
2007-09-30 12:44:42 +00: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 11:12:56 +00:00
if ( value < 1.0 )
2007-09-30 12:44:42 +00: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 15:54:35 +00:00
/// Gets or sets a double representing the target update period, in seconds.
2007-09-30 12:44:42 +00: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 15:54:35 +00:00
/// Gets or sets a double representing the target update frequency, in Herz.
2007-09-30 12:44:42 +00: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 11:12:56 +00:00
if ( value < 1.0 )
2007-09-30 12:44:42 +00: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 15:54:35 +00:00
/// Gets a double representing the actual frequency of RenderFrame events, in Herz (i.e. FPS or Frames Per Second).
2007-09-30 12:44:42 +00: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 15:54:35 +00:00
/// Gets a double representing the period of RenderFrame events, in seconds.
2007-09-30 12:44:42 +00:00
/// </summary>
public double RenderPeriod
{
get
{
return render_period ;
}
}
#endregion
#region public double UpdateFrequency
/// <summary>
2007-10-26 15:54:35 +00:00
/// Gets a double representing the frequency of UpdateFrame events, in Herz.
2007-09-30 12:44:42 +00: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 15:54:35 +00:00
/// Gets a double representing the period of UpdateFrame events, in seconds.
2007-09-30 12:44:42 +00:00
/// </summary>
public double UpdatePeriod
{
get
{
return update_period ;
}
}
#endregion
2007-10-26 15:54:35 +00: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 00:15:18 +00:00
#endregion
#region - - - IResizable Members - - -
#region public int Width , Height
2007-08-21 12:04:01 +00:00
/// <summary>
/// Gets or sets the Width of the GameWindow's rendering area, in pixels.
/// </summary>
2007-07-23 00:15:18 +00:00
public int Width
{
2007-09-26 11:50:44 +00:00
get { return width ; }
2007-07-23 00:15:18 +00: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 12:04:01 +00:00
/// <summary>
/// Gets or sets the Height of the GameWindow's rendering area, in pixels.
/// </summary>
2007-07-23 00:15:18 +00:00
public int Height
{
2007-09-26 11:50:44 +00:00
get { return height ; }
2007-07-23 00:15:18 +00: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 11:50:44 +00:00
/// <summary>
/// Occurs when the GameWindow is resized. Derived classes should override the OnResize method for better performance.
/// </summary>
2007-07-23 00:15:18 +00:00
public event ResizeEvent Resize ;
/// <summary>
/// Raises the Resize event.
/// </summary>
2007-09-26 11:50:44 +00:00
/// <param name="e">Contains information about the Resize event.</param>
private void OnResizeInternal ( ResizeEventArgs e )
2007-07-23 00:15:18 +00:00
{
2007-08-06 11:22:18 +00:00
Debug . Print ( "Firing GameWindow.Resize event: {0}." , e . ToString ( ) ) ;
2007-09-26 11:50:44 +00:00
this . width = e . Width ;
this . height = e . Height ;
2007-07-23 00:15:18 +00:00
if ( this . Resize ! = null )
this . Resize ( this , e ) ;
2007-09-26 11:50:44 +00: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 00:15:18 +00:00
}
#endregion
2007-08-21 12:04:01 +00: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 00:15:18 +00:00
2007-08-21 12:04:01 +00: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 00:15:18 +00:00
#endregion
#region - - - IDisposable Members - - -
2007-09-26 23:13:57 +00:00
/// <summary>
/// Not used yet.
/// </summary>
private void DisposeInternal ( )
{
Dispose ( ) ; // User overridable Dispose method.
}
2007-09-25 16:45:12 +00:00
/// <summary>
/// Disposes of the GameWindow, releasing all resources consumed by it.
/// </summary>
public virtual void Dispose ( )
2007-07-23 00:15:18 +00:00
{
2007-10-26 15:54:35 +00:00
Dispose ( true ) ;
2007-09-25 16:45:12 +00:00
GC . SuppressFinalize ( this ) ;
2007-08-06 09:22:04 +00:00
}
private void Dispose ( bool manual )
{
if ( ! disposed )
{
if ( manual )
{
if ( glWindow ! = null )
{
glWindow . Dispose ( ) ;
glWindow = null ;
}
}
disposed = true ;
}
}
2007-09-25 16:45:12 +00:00
~ GameWindow ( )
{
2007-10-26 15:54:35 +00:00
Dispose ( false ) ;
2007-09-25 16:45:12 +00:00
}
2007-07-23 00:15:18 +00:00
#endregion
}
2007-09-22 22:01:43 +00:00
2007-09-30 12:44:42 +00:00
#region public enum VSyncMode
/// <summary>
2007-10-15 11:12:56 +00:00
/// Enumerates the available VSync modes.
2007-09-30 12:44:42 +00: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 11:12:56 +00:00
Adaptive ,
2007-09-30 12:44:42 +00: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-22 22:01:43 +00:00
public class UpdateFrameEventArgs : EventArgs
{
2007-09-23 12:09:42 +00: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 12:44:42 +00:00
private double scale_factor ;
2007-09-22 22:01:43 +00:00
/// <summary>
/// Gets the Time elapsed between frame updates, in seconds.
/// </summary>
2007-09-23 12:09:42 +00:00
public double Time
2007-09-22 22:01:43 +00:00
{
get { return time ; }
internal set { time = value ; }
}
2007-09-30 12:44:42 +00: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-22 22:01:43 +00:00
}
2007-09-30 12:44:42 +00:00
#endregion
2007-10-15 11:12:56 +00:00
#region - - - GameWindow Exceptions - - -
public class GameWindowExitException : ApplicationException
{
}
#endregion
2007-07-23 00:15:18 +00:00
}