| private Initialize ( EGLDisplay dpy, int &major, int &minor ) : bool | ||
| dpy | EGLDisplay | |
| major | int | |
| minor | int | |
| Результат | bool | |
public GraphicsMode SelectGraphicsMode(ColorFormat color, int depth, int stencil,
int samples, ColorFormat accum, int buffers, bool stereo,
RenderableFlags renderable_flags)
{
IntPtr[] configs = new IntPtr[1];
int[] attribList = new int[]
{
//Egl.SURFACE_TYPE, Egl.WINDOW_BIT,
Egl.RENDERABLE_TYPE, (int)renderable_flags,
Egl.RED_SIZE, color.Red,
Egl.GREEN_SIZE, color.Green,
Egl.BLUE_SIZE, color.Blue,
Egl.ALPHA_SIZE, color.Alpha,
Egl.DEPTH_SIZE, depth > 0 ? depth : 0,
Egl.STENCIL_SIZE, stencil > 0 ? stencil : 0,
Egl.SAMPLE_BUFFERS, samples > 0 ? 1 : 0,
Egl.SAMPLES, samples > 0 ? samples : 0,
Egl.NONE,
};
// Todo: what if we don't wish to use the default display?
IntPtr display = Egl.GetDisplay(IntPtr.Zero);
int major, minor;
if (!Egl.Initialize(display, out major, out minor))
{
throw new GraphicsModeException(String.Format("Failed to initialize display connection, error {0}", Egl.GetError()));
}
int num_configs;
if (!Egl.ChooseConfig(display, attribList, configs, configs.Length, out num_configs) || num_configs == 0)
{
throw new GraphicsModeException(String.Format("Failed to retrieve GraphicsMode, error {0}", Egl.GetError()));
}
// See what we really got
IntPtr active_config = configs[0];
int r, g, b, a;
Egl.GetConfigAttrib(display, active_config, Egl.RED_SIZE, out r);
Egl.GetConfigAttrib(display, active_config, Egl.GREEN_SIZE, out g);
Egl.GetConfigAttrib(display, active_config, Egl.BLUE_SIZE, out b);
Egl.GetConfigAttrib(display, active_config, Egl.ALPHA_SIZE, out a);
int d, s;
Egl.GetConfigAttrib(display, active_config, Egl.DEPTH_SIZE, out d);
Egl.GetConfigAttrib(display, active_config, Egl.STENCIL_SIZE, out s);
int sample_buffers;
Egl.GetConfigAttrib(display, active_config, Egl.SAMPLES, out sample_buffers);
Egl.GetConfigAttrib(display, active_config, Egl.SAMPLES, out samples);
return(new GraphicsMode(active_config, new ColorFormat(r, g, b, a), d, s, sample_buffers > 0 ? samples : 0, 0, 2, false));
}
bool vsync = true; // Default vsync value is defined as 1 (true) in EGL.
public EglContext(GraphicsMode mode, EglWindowInfo window, IGraphicsContext sharedContext,
int major, int minor, GraphicsContextFlags flags)
{
if (mode == null)
{
throw new ArgumentNullException("mode");
}
if (window == null)
{
throw new ArgumentNullException("window");
}
//EglContext shared = (EglContext)sharedContext; //old version
EglContext shared = sharedContext as EglContext;
int dummy_major, dummy_minor;
if (!Egl.Initialize(window.Display, out dummy_major, out dummy_minor))
{
throw new GraphicsContextException(String.Format("Failed to initialize EGL, error {0}.", Egl.GetError()));
}
WindowInfo = window;
Egl.BindAPI(0x30A0); //bind EGL_OPENGL_ES_API
var eglGfxMode = new EglGraphicsMode();
eglGfxMode.window = window;
Mode = eglGfxMode.SelectGraphicsMode(mode.ColorFormat, mode.Depth, mode.Stencil, mode.Samples, mode.AccumulatorFormat, mode.Buffers, mode.Stereo);
if (!Mode.Index.HasValue)
{
throw new GraphicsModeException("Invalid or unsupported GraphicsMode.");
}
IntPtr config = Mode.Index.Value;
if (window.Surface == IntPtr.Zero)
{
window.CreateWindowSurface(config);
}
int[] attrib_list = new int[] {
//key,value
Egl.CONTEXT_CLIENT_VERSION, major,
Egl.NONE
};
HandleAsEGLContext = Egl.CreateContext(window.Display, config, shared != null ? shared.HandleAsEGLContext : IntPtr.Zero, attrib_list);
MakeCurrent(window);
}
int swap_interval = 1; // Default interval is defined as 1 in EGL.
#endregion
#region Constructors
public EglContext(GraphicsMode mode, EglWindowInfo window, IGraphicsContext sharedContext,
int major, int minor, GraphicsContextFlags flags)
{
if (mode == null)
{
throw new ArgumentNullException("mode");
}
if (window == null)
{
throw new ArgumentNullException("window");
}
EglContext shared = (EglContext)sharedContext;
int dummy_major, dummy_minor;
if (!Egl.Initialize(window.Display, out dummy_major, out dummy_minor))
{
throw new GraphicsContextException(String.Format("Failed to initialize EGL, error {0}.", Egl.GetError()));
}
WindowInfo = window;
// Select an EGLConfig that matches the desired mode. We cannot use the 'mode'
// parameter directly, since it may have originated on a different system (e.g. GLX)
// and it may not support the desired renderer.
Mode = new EglGraphicsMode().SelectGraphicsMode(mode.ColorFormat,
mode.Depth, mode.Stencil, mode.Samples, mode.AccumulatorFormat,
mode.Buffers, mode.Stereo,
major > 1 ? RenderableFlags.ES2 : RenderableFlags.ES);
if (!Mode.Index.HasValue)
{
throw new GraphicsModeException("Invalid or unsupported GraphicsMode.");
}
IntPtr config = Mode.Index.Value;
if (window.Surface == IntPtr.Zero)
{
window.CreateWindowSurface(config);
}
int[] attrib_list = new int[] { Egl.CONTEXT_CLIENT_VERSION, major, Egl.NONE };
HandleAsEGLContext = Egl.CreateContext(window.Display, config, shared != null ? shared.HandleAsEGLContext : IntPtr.Zero, attrib_list);
MakeCurrent(window);
}
public EglWindowInfo(IntPtr handle, IntPtr display, IntPtr surface)
{
Handle = handle;
Surface = surface;
if (display == IntPtr.Zero)
{
display = Egl.GetDisplay(IntPtr.Zero);
}
Display = display;
int dummyMajor, dummyMinor;
if (!Egl.Initialize(Display, out dummyMajor, out dummyMinor))
{
throw new GraphicsContextException(String.Format("Failed to initialize EGL, error {0}.", Egl.GetError()));
}
}
bool vsync = true; // Default vsync value is defined as 1 (true) in EGL.
#endregion
#region Constructors
public EglContext(GraphicsMode mode, EglWindowInfo window, IGraphicsContext sharedContext,
int major, int minor, GraphicsContextFlags flags)
{
if (mode == null)
{
throw new ArgumentNullException("mode");
}
if (window == null)
{
throw new ArgumentNullException("window");
}
EglContext shared = (EglContext)sharedContext;
int dummy_major, dummy_minor;
if (!Egl.Initialize(window.Display, out dummy_major, out dummy_minor))
{
throw new GraphicsContextException(String.Format("Failed to initialize EGL, error {0}.", Egl.GetError()));
}
WindowInfo = window;
Mode = new EglGraphicsMode().SelectGraphicsMode(mode.ColorFormat, mode.Depth, mode.Stencil, mode.Samples, mode.AccumulatorFormat, mode.Buffers, mode.Stereo);
if (!Mode.Index.HasValue)
{
throw new GraphicsModeException("Invalid or unsupported GraphicsMode.");
}
EGLConfig config = new EGLConfig(mode.Index.Value);
if (window.Surface.Handle == EGLSurface.None.Handle)
{
window.CreateWindowSurface(config);
}
int[] attrib_list = new int[] { Egl.CONTEXT_CLIENT_VERSION, major, Egl.NONE };
HandleAsEGLContext = Egl.CreateContext(window.Display, config, shared != null ? shared.HandleAsEGLContext : EGLContext.None, attrib_list);
MakeCurrent(window);
}
public EglContext(GraphicsMode mode, EglWindowInfo window, IGraphicsContext sharedContext, int major, int minor, GraphicsContextFlags flags)
{
if (mode == null)
{
throw new ArgumentNullException("mode");
}
if (window == null)
{
throw new ArgumentNullException("window");
}
EglContext eglContext = (EglContext)sharedContext;
int major1;
int minor1;
if (!Egl.Initialize(window.Display, out major1, out minor1))
{
throw new GraphicsContextException(string.Format("Failed to initialize EGL, error {0}.", (object)Egl.GetError()));
}
this.WindowInfo = window;
this.Mode = new EglGraphicsMode().SelectGraphicsMode(mode.ColorFormat, mode.Depth, mode.Stencil, mode.Samples, mode.AccumulatorFormat, mode.Buffers, mode.Stereo, major > 1 ? RenderableFlags.ES2 : RenderableFlags.ES);
if (!this.Mode.Index.HasValue)
{
throw new GraphicsModeException("Invalid or unsupported GraphicsMode.");
}
IntPtr config = this.Mode.Index.Value;
if (window.Surface == IntPtr.Zero)
{
window.CreateWindowSurface(config);
}
int[] attrib_list = new int[3]
{
12440,
major,
12344
};
this.HandleAsEGLContext = Egl.CreateContext(window.Display, config, eglContext != null ? eglContext.HandleAsEGLContext : IntPtr.Zero, attrib_list);
this.MakeCurrent((IWindowInfo)window);
}
public GraphicsMode SelectGraphicsMode(ColorFormat color, int depth, int stencil, int samples, ColorFormat accum, int buffers, bool stereo, RenderableFlags renderable_flags)
{
IntPtr[] configs = new IntPtr[1];
int[] attrib_list = new int[17]
{
12352,
(int)renderable_flags,
12324,
color.Red,
12323,
color.Green,
12322,
color.Blue,
12321,
color.Alpha,
12325,
depth > 0 ? depth : 0,
12326,
stencil > 0 ? stencil : 0,
12337,
samples > 0 ? samples : 0,
12344
};
IntPtr display = Egl.GetDisplay(IntPtr.Zero);
int major;
int minor;
if (!Egl.Initialize(display, out major, out minor))
{
throw new GraphicsModeException(string.Format("Failed to initialize display connection, error {0}", (object)Egl.GetError()));
}
int num_config;
if (!Egl.ChooseConfig(display, attrib_list, configs, configs.Length, out num_config) || num_config == 0)
{
throw new GraphicsModeException(string.Format("Failed to retrieve GraphicsMode, error {0}", (object)Egl.GetError()));
}
IntPtr config = configs[0];
int red;
Egl.GetConfigAttrib(display, config, 12324, out red);
int green;
Egl.GetConfigAttrib(display, config, 12323, out green);
int blue;
Egl.GetConfigAttrib(display, config, 12322, out blue);
int alpha;
Egl.GetConfigAttrib(display, config, 12321, out alpha);
int depth1;
Egl.GetConfigAttrib(display, config, 12325, out depth1);
int stencil1;
Egl.GetConfigAttrib(display, config, 12326, out stencil1);
int num;
Egl.GetConfigAttrib(display, config, 12337, out num);
Egl.GetConfigAttrib(display, config, 12337, out samples);
return(new GraphicsMode(new IntPtr?(config), new ColorFormat(red, green, blue, alpha), depth1, stencil1, num > 0 ? samples : 0, (ColorFormat)0, 2, false));
}
IntPtr TryInitEglDisplay(IWindowInfo window, ref int major, ref int minor, ref GraphicsContextFlags flags)
{
//see https://github.com/Microsoft/angle/wiki/Initializing-ANGLE-on-D3D11-Feature-Level-9
//IntPtr egl_display1 = Egl.GetPlatformDisplayEXT(Egl.PLATFORM_ANGLE_ANGLE, IntPtr.Zero, new int[]{
// Egl.PLATFORM_ANGLE_TYPE_ANGLE,
// Egl.PLATFORM_ANGLE_TYPE_D3D11_ANGLE,
// Egl.PLATFORM_ANGLE_MAX_VERSION_MAJOR_ANGLE, 9,
// Egl.PLATFORM_ANGLE_MAX_VERSION_MINOR_ANGLE, 3,
// Egl.NONE,
//});
//if (!Egl.Initialize(egl_display1, out int m1, out int m2))
//{
//}
//1. use default openTK default
WinWindowInfo win_win = (WinWindowInfo)window;
bool success = false;
int eglMajor, eglMinor;
IntPtr egl_display = IntPtr.Zero;
if (isFirstTimeEval)
{
isFirstTimeEval = false;
egl_display = GetDisplay(win_win.DeviceContext);
success = Egl.Initialize(egl_display, out eglMajor, out eglMinor);
//-------------------
//we found that some old machine can't init with D3D11
//so ... we use D3D9 instead
if (!success)
{
egl_display = Egl.GetPlatformDisplayEXT(Egl.PLATFORM_ANGLE_ANGLE, IntPtr.Zero, new int[] {
Egl.PLATFORM_ANGLE_TYPE_ANGLE,
Egl.PLATFORM_ANGLE_TYPE_D3D9_ANGLE,
Egl.NONE,
});
if (Egl.Initialize(egl_display, out eglMajor, out eglMinor))
{
useD3D9Only = true;
success = true;
//in this case
major = 2; //GLES2
minor = 1;
flags = flags & ~GraphicsContextFlags.AngleD3D11; //can't use D3D11
}
else
{
throw new GraphicsContextException(String.Format("Failed to initialize EGL, error {0}.", Egl.GetError()));
}
}
}
else
{
//not first time
if (useD3D9Only)
{
//no D3D11
egl_display = Egl.GetPlatformDisplayEXT(Egl.PLATFORM_ANGLE_ANGLE, IntPtr.Zero, new int[] {
Egl.PLATFORM_ANGLE_TYPE_ANGLE,
Egl.PLATFORM_ANGLE_TYPE_D3D9_ANGLE,
Egl.NONE,
});
if (Egl.Initialize(egl_display, out eglMajor, out eglMinor))
{
useD3D9Only = true;
success = true;
//in this case
major = 2; //GLES2
minor = 1;
flags = flags & ~GraphicsContextFlags.AngleD3D11; //can't use D3D11
}
else
{
throw new GraphicsContextException(String.Format("Failed to initialize EGL, error {0}.", Egl.GetError()));
}
}
else
{
//use D3D11
egl_display = GetDisplay(win_win.DeviceContext);
success = Egl.Initialize(egl_display, out eglMajor, out eglMinor);
//-------------------
//we found that some old machine can't init with D3D11
//so ... we use D3D9 instead
if (!success)
{
//???
throw new GraphicsContextException(String.Format("Failed to initialize EGL, error {0}.", Egl.GetError()));
}
}
}
return(egl_display);
}
