GraphicsContext(OpenTK.Platform.External.ExternalGraphicsContext externalGraphicsContext)
{
implementation = externalGraphicsContext;
lock (SyncRoot)
{
// Angle needs an embedded context
//const GraphicsContextFlags useAngleFlag = GraphicsContextFlags.Angle
// | GraphicsContextFlags.AngleD3D9
// | GraphicsContextFlags.AngleD3D11
// | GraphicsContextFlags.AngleOpenGL;
bool useAngle = true;
try
{
IsExternal = true;
IPlatformFactory factory = Factory.Embedded;
// Note: this approach does not allow us to mix native and EGL contexts in the same process.
// This should not be a problem, as this use-case is not interesting for regular applications.
// Note 2: some platforms may not support a direct way of getting the current context
// (this happens e.g. with DummyGLContext). In that case, we use a slow fallback which
// iterates through all known contexts and checks if any is current (check GetCurrentContext
// declaration).
if (GetCurrentContext == null)
{
GetCurrentContext = externalGraphicsContext.CreateCurrentContextDel(); // factory.CreateGetCurrentGraphicsContext();
}
available_contexts.Add((implementation as IGraphicsContextInternal).Context, this);
(this as IGraphicsContextInternal).LoadAll();
handle_cached = ((IGraphicsContextInternal)implementation).Context;
factory.RegisterResource(this);
}
catch (Exception ex)
{
}
}
}
/// <summary>Constructs a new NativeWindow with the specified attributes.</summary>
/// <param name="x">Horizontal screen space coordinate of the NativeWindow's origin.</param>
/// <param name="y">Vertical screen space coordinate of the NativeWindow's origin.</param>
/// <param name="width">The width of the NativeWindow in pixels.</param>
/// <param name="height">The height of the NativeWindow in pixels.</param>
/// <param name="title">The title of the NativeWindow.</param>
/// <param name="options">GameWindow options specifying window appearance and behavior.</param>
/// <param name="mode">The OpenTK.Graphics.GraphicsMode of the NativeWindow.</param>
/// <param name="device">The OpenTK.Graphics.DisplayDevice to construct the NativeWindow in.</param>
/// <exception cref="System.ArgumentOutOfRangeException">If width or height is less than 1.</exception>
/// <exception cref="System.ArgumentNullException">If mode or device is null.</exception>
public NativeWindow(int x, int y, int width, int height, string title, GameWindowFlags options, GraphicsMode mode, DisplayDevice device)
{
// TODO: Should a constraint be added for the position?
if (width < 1)
{
throw new ArgumentOutOfRangeException("width", "Must be greater than zero.");
}
if (height < 1)
{
throw new ArgumentOutOfRangeException("height", "Must be greater than zero.");
}
if (mode == null)
{
throw new ArgumentNullException("mode");
}
this.options = options;
this.device = device;
this.thread_id = System.Threading.Thread.CurrentThread.ManagedThreadId;
IPlatformFactory factory = Factory.Default;
implementation = factory.CreateNativeWindow(x, y, width, height, title, mode, options, this.device);
factory.RegisterResource(this);
if ((options & GameWindowFlags.Fullscreen) != 0)
{
if (this.device != null)
{
this.device.ChangeResolution(width, height, mode.ColorFormat.BitsPerPixel, 0);
}
WindowState = WindowState.Fullscreen;
}
if ((options & GameWindowFlags.FixedWindow) != 0)
{
WindowBorder = WindowBorder.Fixed;
}
}
public void RegisterResource(IDisposable resource)
{
default_implementation.RegisterResource(resource);
}
/// <summary>
/// Constructs a new GraphicsContext with the specified GraphicsMode, version and flags, and attaches it to the specified window. A dummy context will be created if both
/// the handle and the window are null.
/// </summary>
/// <param name="mode">The OpenTK.Graphics.GraphicsMode of the GraphicsContext.</param>
/// <param name="window">The OpenTK.Platform.IWindowInfo to attach the GraphicsContext to.</param>
/// <param name="shareContext">The GraphicsContext to share resources with, or null for explicit non-sharing.</param>
/// <param name="major">The major version of the new GraphicsContext.</param>
/// <param name="minor">The minor version of the new GraphicsContext.</param>
/// <param name="flags">The GraphicsContextFlags for the GraphicsContext.</param>
/// <remarks>
/// Different hardware supports different flags, major and minor versions. Invalid parameters will be silently ignored.
/// </remarks>
public GraphicsContext(GraphicsMode mode, IWindowInfo window, IGraphicsContext shareContext, int major, int minor, GraphicsContextFlags flags)
{
lock (SyncRoot)
{
bool designMode = false;
if (mode == null && window == null)
{
designMode = true;
}
else if (mode == null)
{
throw new ArgumentNullException("mode", "Must be a valid GraphicsMode.");
}
else if (window == null)
{
throw new ArgumentNullException("window", "Must point to a valid window.");
}
// Silently ignore invalid major and minor versions.
if (major <= 0)
{
major = 1;
}
if (minor < 0)
{
minor = 0;
}
// Angle needs an embedded context
const GraphicsContextFlags useAngleFlag = GraphicsContextFlags.Angle
| GraphicsContextFlags.AngleD3D9
| GraphicsContextFlags.AngleD3D11
| GraphicsContextFlags.AngleOpenGL;
flags = useAngleFlag;
var useAngle = false;
if ((flags & useAngleFlag) != 0)
{
flags |= GraphicsContextFlags.Embedded;
useAngle = true;
}
Debug.WriteLine("Creating GraphicsContext.");
try
{
Debug.WriteLine("");
Debug.WriteLine($"GraphicsMode: {mode}");
Debug.WriteLine($"IWindowInfo: {window}");
Debug.WriteLine($"GraphicsContextFlags: {flags}");
Debug.WriteLine($"Requested version: {major}.{minor}");
// Todo: Add a DummyFactory implementing IPlatformFactory.
if (designMode)
{
implementation = new Platform.Dummy.DummyGLContext();
}
else
{
IPlatformFactory factory = null;
switch ((flags & GraphicsContextFlags.Embedded) == GraphicsContextFlags.Embedded)
{
case false:
factory = Factory.Default;
break;
case true:
factory = useAngle ? Factory.Angle : Factory.Embedded;
break;
}
// Note: this approach does not allow us to mix native and EGL contexts in the same process.
// This should not be a problem, as this use-case is not interesting for regular applications.
// Note 2: some platforms may not support a direct way of getting the current context
// (this happens e.g. with DummyGLContext). In that case, we use a slow fallback which
// iterates through all known contexts and checks if any is current (check GetCurrentContext
// declaration).
if (GetCurrentContext == null)
{
GetCurrentContext = factory.CreateGetCurrentGraphicsContext();
}
implementation = factory.CreateGLContext(mode, window, shareContext, DirectRendering, major, minor, flags);
handle_cached = ((IGraphicsContextInternal)implementation).Context;
factory.RegisterResource(this);
}
AddContext(this);
}
catch (Exception ex)
{
}
finally
{
}
}
}
/// <summary>
/// Constructs a new GraphicsContext with the specified GraphicsMode, version and flags, and attaches it to the specified window.
/// </summary>
/// <param name="mode">The OpenTK.Graphics.GraphicsMode of the GraphicsContext.</param>
/// <param name="window">The OpenTK.Platform.IWindowInfo to attach the GraphicsContext to.</param>
/// <param name="shareContext">The GraphicsContext to share resources with, or null for explicit non-sharing.</param>
/// <param name="major">The major version of the new GraphicsContext.</param>
/// <param name="minor">The minor version of the new GraphicsContext.</param>
/// <param name="flags">The GraphicsContextFlags for the GraphicsContext.</param>
/// <remarks>
/// Different hardware supports different flags, major and minor versions. Invalid parameters will be silently ignored.
/// </remarks>
public GraphicsContext(GraphicsMode mode, IWindowInfo window, IGraphicsContext shareContext, int major, int minor, GraphicsContextFlags flags)
{
lock (SyncRoot)
{
bool designMode = false;
if (mode == null && window == null)
{
designMode = true;
}
else if (mode == null)
{
throw new ArgumentNullException("mode", "Must be a valid GraphicsMode.");
}
else if (window == null)
{
throw new ArgumentNullException("window", "Must point to a valid window.");
}
// Silently ignore invalid major and minor versions.
if (major <= 0)
{
major = 1;
}
if (minor < 0)
{
minor = 0;
}
// Angle needs an embedded context
var use_angle_flag = GraphicsContextFlags.Angle
| GraphicsContextFlags.AngleD3D9
| GraphicsContextFlags.AngleD3D11
| GraphicsContextFlags.AngleOpenGL;
var use_angle = false;
if ((flags & use_angle_flag) != 0)
{
flags |= GraphicsContextFlags.Embedded;
use_angle = true;
}
Debug.Print("Creating GraphicsContext.");
try
{
Debug.Indent();
Debug.Print("GraphicsMode: {0}", mode);
Debug.Print("IWindowInfo: {0}", window);
Debug.Print("GraphicsContextFlags: {0}", flags);
Debug.Print("Requested version: {0}.{1}", major, minor);
// Todo: Add a DummyFactory implementing IPlatformFactory.
if (designMode)
{
implementation = new Platform.Dummy.DummyGLContext();
}
else
{
IPlatformFactory factory = null;
switch ((flags & GraphicsContextFlags.Embedded) == GraphicsContextFlags.Embedded)
{
case false:
factory = Factory.Default;
break;
case true:
factory = use_angle ? Factory.Angle : Factory.Embedded;
break;
}
GetCurrentContext = factory.CreateGetCurrentGraphicsContext();
implementation = factory.CreateGLContext(mode, window, shareContext, direct_rendering, major, minor, flags);
handle_cached = ((IGraphicsContextInternal)implementation).Context;
factory.RegisterResource(this);
}
AddContext(this);
}
finally
{
Debug.Unindent();
}
}
}
public static void Init()
{
ToolkitOptions optionsToolkit = new ToolkitOptions()
{
Backend = PlatformBackend.PreferNative //for eglSwapBuffers to SwapBuffers
};
Toolkit.Init(optionsToolkit);
GraphicsContextFlags flags = GraphicsContextFlags.Embedded;
int width = 854; //800;
int height = 480; //600;
GraphicsMode mode = GraphicsMode.Default;
string title = "PlayStation Suite Simulator"; //"Simple ES 2.0";
GameWindowFlags options = GameWindowFlags.FixedWindow; //GameWindowFlags.Default;
DisplayDevice device = DisplayDevice.Default;
int major = 2;
int minor = 0;
if (mode == null)
{
mode = GraphicsMode.Default;
}
if (device == null)
{
device = DisplayDevice.Default;
}
int x = (device != null ? device.Bounds.Left + (device.Bounds.Width - width) / 2 : 0);
int y = (device != null ? device.Bounds.Top + (device.Bounds.Height - height) / 2 : 0);
if (width < 1)
{
throw new ArgumentOutOfRangeException("width", "Must be greater than zero.");
}
if (height < 1)
{
throw new ArgumentOutOfRangeException("height", "Must be greater than zero.");
}
if (mode == null)
{
throw new ArgumentNullException("mode");
}
g_ctx.options = options;
g_ctx.device = device;
IPlatformFactory factory = Factory.Default;
g_ctx.implementation = factory.CreateNativeWindow(x, y, width, height, title, mode, options, g_ctx.device);
factory.RegisterResource(g_ctx);
if ((options & GameWindowFlags.Fullscreen) != 0)
{
if (g_ctx.device != null)
{
g_ctx.device.ChangeResolution(width, height, mode.ColorFormat.BitsPerPixel, 0);
}
setWindowState(WindowState.Fullscreen);
}
if ((options & GameWindowFlags.FixedWindow) != 0)
{
setWindowBorder(WindowBorder.Fixed);
}
try
{
g_ctx.glContext = new GraphicsContext(mode == null ? GraphicsMode.Default : mode, getWindowInfo(), major, minor, flags);
g_ctx.glContext.MakeCurrent(getWindowInfo());
(g_ctx.glContext as IGraphicsContextInternal).LoadAll();
setVSync(VSyncMode.On);
}
catch (Exception e)
{
Debug.Print(e.ToString());
baseDispose();
throw;
}
Run_1();
}