public void Dispose()
{
if (_selfCreatedWindow)
{
OpenGLContext?.Dispose();
}
}
public virtual void SwapBuffers()
{
AssertValid();
AssertContext();
// basically SwapBuffers is the same as FlushBuffer on OSX
OpenGLContext.FlushBuffer();
}
public override void DrawRect(CGRect dirtyRect)
{
base.DrawRect(dirtyRect);
var size = ConvertSizeToBacking(Bounds.Size);
renderTarget.Width = (int)size.Width;
renderTarget.Height = (int)size.Height;
Gles.glClear(Gles.GL_STENCIL_BUFFER_BIT);
using (var surface = SKSurface.Create(context, renderTarget))
{
if (PaintSurface != null)
{
PaintSurface.Invoke(surface);
}
surface.Canvas.Flush();
}
// flush the SkiaSharp contents to GL
context.Flush();
OpenGLContext.FlushBuffer();
}
protected override void OnDraw()
{
OpenGLContext.CGLContext.Lock().ThrowIfFailed("CGLContext.Lock()");
try
{
OpenGLContext.MakeCurrentContext();
_perFrame.OnNext(_stopwatch.Elapsed.TotalSeconds);
_log.TrySomethingBlocking(Bootstrapper.OnUpdate);
if (_unoWindow.Size.HasZeroArea())
{
return;
}
if (Uno.Application.Current != null && Bootstrapper.DrawNextFrame)
{
_unoGraphics.ChangeBackbuffer((GLFramebufferHandle)_renderTarget.GetFramebufferHandle(_unoWindow.Size));
_log.TrySomethingBlocking(Bootstrapper.OnDraw);
_renderTarget.Flush(OpenGLContext);
}
}
finally
{
++_currentFrame;
OpenGLContext.CGLContext.Unlock().ThrowIfFailed("CGLContext.Unlock()");
}
}
private void GLRenderer_Initialized(object sender, EventArgs e)
{
// Release the GL exclusivity that SPB gave us as we aren't going to use it in GTK Thread.
OpenGLContext.MakeCurrent(null);
WaitEvent.Set();
}
public override void DrawRect(CGRect dirtyRect)
{
base.DrawRect(dirtyRect);
if (fsurface == null)
{
return;
}
var size = ConvertSizeToBacking(Bounds.Size);
renderTarget.Width = (int)size.Width;
renderTarget.Height = (int)size.Height;
Gles.glClear(Gles.GL_STENCIL_BUFFER_BIT);
using (var surface = SKSurface.Create(context, renderTarget))
{
fsurface.UpdateSurface(surface);
// draw on the surface
DrawInSurface(surface, renderTarget);
surface.Canvas.Flush();
}
// flush the SkiaSharp contents to GL
context.Flush();
OpenGLContext.FlushBuffer();
}
public void SetContext(IRenderContext context)
{
if (!(context is OpenGLContext))
{
throw new Exception("OpenGL: Invalid context!");
}
p_Context = (OpenGLContext)context;
}
internal OpenGLFont(OpenGLContext context,string fontname,float size)
{
font=new WGLBitmapFont(context,new Font(fontname,size));
font.InitRange((char)0,(char)255);
col=Color.FromArgb(unchecked((int)0xFFFFFFFF));
rot=0;
pos=new Point(0,0);
}
public override void DrawRect(CGRect dirtyRect)
{
base.DrawRect(dirtyRect);
Gles.glClear(Gles.GL_COLOR_BUFFER_BIT | Gles.GL_DEPTH_BUFFER_BIT | Gles.GL_STENCIL_BUFFER_BIT);
// create the render target
if (renderTarget == null || lastSize != newSize || !renderTarget.IsValid)
{
// create or update the dimensions
lastSize = newSize;
// read the info from the buffer
Gles.glGetIntegerv(Gles.GL_FRAMEBUFFER_BINDING, out var framebuffer);
Gles.glGetIntegerv(Gles.GL_STENCIL_BITS, out var stencil);
Gles.glGetIntegerv(Gles.GL_SAMPLES, out var samples);
var maxSamples = context.GetMaxSurfaceSampleCount(colorType);
if (samples > maxSamples)
{
samples = maxSamples;
}
glInfo = new GRGlFramebufferInfo((uint)framebuffer, colorType.ToGlSizedFormat());
// destroy the old surface
surface?.Dispose();
surface = null;
canvas = null;
// re-create the render target
renderTarget?.Dispose();
renderTarget = new GRBackendRenderTarget(newSize.Width, newSize.Height, samples, stencil, glInfo);
}
// create the surface
if (surface == null)
{
surface = SKSurface.Create(context, renderTarget, surfaceOrigin, colorType);
canvas = surface.Canvas;
}
using (new SKAutoCanvasRestore(canvas, true))
{
// start drawing
var e = new SKPaintGLSurfaceEventArgs(surface, renderTarget, surfaceOrigin, colorType, glInfo);
#pragma warning disable CS0618 // Type or member is obsolete
DrawInSurface(e.Surface, e.RenderTarget);
#pragma warning restore CS0618 // Type or member is obsolete
OnPaintSurface(e);
}
// flush the SkiaSharp contents to GL
canvas.Flush();
context.Flush();
OpenGLContext.FlushBuffer();
}
public void MakeNonCurrent()
{
Validate(true);
_threadLocalCurrent.Value = null;
OpenGLContext.MakeCurrent(null);
ThreadID = -1;
Validate(false);
}
public void MakeCurrent()
{
Validate(false);
_threadLocalCurrent.Value = this;
OpenGLContext.MakeCurrent(Window.WindowInfo);
ThreadID = Thread.CurrentThread.ManagedThreadId;
Validate(true);
}
public override void DrawRect(CGRect dirtyRect)
{
OpenGLContext.MakeCurrentContext();
GL.ClearColor(Color.Brown);
GL.ClearColor(0, 0, 0, 0);
GL.Clear(ClearBufferMask.ColorBufferBit);
DrawTriangle();
GL.Flush();
}
private void Intialize()
{
NativeWindow = RetrieveNativeWindow();
Window.EnsureNative();
OpenGLContext = PlatformHelper.CreateOpenGLContext(FramebufferFormat, GLVersionMajor, GLVersionMinor, ContextFlags, DirectRendering, SharedContext);
OpenGLContext.Initialize(NativeWindow);
OpenGLContext.MakeCurrent(NativeWindow);
_initialized = true;
Initialized?.Invoke(this, EventArgs.Empty);
}
public GraphicsDevice(IntPtr target)
{
context = OpenGLContext.GetContext();
context.Samples = 4;
// Create context using platform specific methods
context.CreateContext(target, IntPtr.Zero, null);
//GL.InitGeneral(context);
//foreach (var str in GL.GetSupportedExtensions())
//Console.WriteLine(str);
modelview_matrix = new MatrixState();
projection_matrix = new MatrixState();
texture_matrix = new MatrixState();
normal_matrix = new MatrixState();
var err = GL.glGetError();
GL.InitGL_1_2(context);
GL.InitGL_1_3(context);
GL.InitGL_1_4(context);
GL.InitGL_1_5(context);
GL.InitGL_2_0(context);
GL.InitGL_2_1(context);
GL.InitGL_3_0(context);
GL.InitGL_3_1(context);
GL.InitGL_3_2(context);
GL.InitFramebuffers(context);
GL.InitVertexArrayObjects(context);
var sp = GL.GetSupportedExtensions();
if (sp.Contains("GL_AMD_debug_output"))
{
GL.InitDebugOutputAMD(context);
GL.glDebugMessageCallbackAMD(new OpenGL.OpenGL.DebugProc(DebugProcecure), IntPtr.Zero);
GL.glDebugMessageEnableAMD(0, 0, 0, new int[] { }, GL.boolean.TRUE);
}
err = GL.glGetError();
GL.glEnable(GL.Const.GL_TEXTURE_2D);
state = new OpenGLState(this);
state.Blend = true;
state.BlendFunction(Blend.SrcAlpha, Blend.OneMinusSrcAlpha);
state.Culling = true;
state.DepthTest = true;
}
public override void DrawRect(CGRect dirtyRect)
{
base.DrawRect(dirtyRect);
Gles.glClear(Gles.GL_COLOR_BUFFER_BIT | Gles.GL_DEPTH_BUFFER_BIT | Gles.GL_STENCIL_BUFFER_BIT);
// manage the drawing surface
var size = ConvertSizeToBacking(Bounds.Size);
if (renderTarget == null || surface == null || renderTarget.Width != size.Width || renderTarget.Height != size.Height)
{
// create or update the dimensions
renderTarget?.Dispose();
Gles.glGetIntegerv(Gles.GL_FRAMEBUFFER_BINDING, out var framebuffer);
Gles.glGetIntegerv(Gles.GL_STENCIL_BITS, out var stencil);
Gles.glGetIntegerv(Gles.GL_SAMPLES, out var samples);
var maxSamples = context.GetMaxSurfaceSampleCount(colorType);
if (samples > maxSamples)
{
samples = maxSamples;
}
var glInfo = new GRGlFramebufferInfo((uint)framebuffer, colorType.ToGlSizedFormat());
renderTarget = new GRBackendRenderTarget((int)size.Width, (int)size.Height, samples, stencil, glInfo);
// create the surface
surface?.Dispose();
surface = SKSurface.Create(context, renderTarget, surfaceOrigin, colorType);
}
using (new SKAutoCanvasRestore(surface.Canvas, true))
{
// start drawing
var e = new SKPaintGLSurfaceEventArgs(surface, renderTarget, surfaceOrigin, colorType);
#pragma warning disable CS0618 // Type or member is obsolete
DrawInSurface(e.Surface, e.RenderTarget);
#pragma warning restore CS0618 // Type or member is obsolete
OnPaintSurface(e);
}
// flush the SkiaSharp contents to GL
surface.Canvas.Flush();
context.Flush();
OpenGLContext.FlushBuffer();
}
protected override void Dispose(bool disposing)
{
// Try to bind the OpenGL context before calling the shutdown event
try
{
OpenGLContext?.MakeCurrent(NativeWindow);
}
catch (Exception) { }
ShuttingDown?.Invoke(this, EventArgs.Empty);
// Unbind context and destroy everything
try
{
OpenGLContext?.MakeCurrent(null);
}
catch (Exception) { }
OpenGLContext.Dispose();
}
public void BeginFrame(IRenderContext context)
{
if (!(context is OpenGLContext))
{
throw new Exception("OpenGL: Invalid context!");
}
p_Context = context as OpenGLContext;
//swap to OpenGL context
if (!p_HasContext)
{
wglMakeCurrent(
p_Context.DeviceContext,
p_Context.RenderContext);
p_HasContext = true;
}
//resize?
if (p_Context.SizeChanged)
{
int width = p_Context.Width, height = p_Context.Height;
int centerX = width / 2, centerY = height / 2;
glViewport(0, 0, width, height);
glOrtho(-centerX, centerX, -centerY, centerY, -100, 100);
}
//reset tri count
p_CurrentVertCount = 0;
//setup orthoganol matrix so we are using screen coords instead
//of world coords
glLoadIdentity();
gluOrtho2D(0, p_Context.Width, p_Context.Height, 0);
glMatrixMode(MODELVIEW);
glPushMatrix();
glLoadIdentity();
}
public override void DrawRect(CGRect dirtyRect)
{
base.DrawRect(dirtyRect);
Gles.glClear(Gles.GL_COLOR_BUFFER_BIT | Gles.GL_DEPTH_BUFFER_BIT | Gles.GL_STENCIL_BUFFER_BIT);
// manage the drawing surface
var size = ConvertSizeToBacking(Bounds.Size);
if (renderTarget == null || surface == null || renderTarget.Width != size.Width || renderTarget.Height != size.Height)
{
// create or update the dimensions
renderTarget?.Dispose();
renderTarget = SKGLDrawable.CreateRenderTarget((int)size.Width, (int)size.Height);
// create the surface
surface?.Dispose();
surface = SKSurface.Create(context, renderTarget, GRSurfaceOrigin.BottomLeft, SKColorType.Rgba8888);
}
using (new SKAutoCanvasRestore(surface.Canvas, true))
{
// start drawing
var e = new SKPaintGLSurfaceEventArgs(surface, renderTarget, GRSurfaceOrigin.BottomLeft, SKColorType.Rgba8888);
#pragma warning disable CS0618 // Type or member is obsolete
DrawInSurface(e.Surface, e.RenderTarget);
#pragma warning restore CS0618 // Type or member is obsolete
OnPaintSurface(e);
}
// flush the SkiaSharp contents to GL
surface.Canvas.Flush();
context.Flush();
OpenGLContext.FlushBuffer();
}
public void DrawString(string text
, GePoint position, OpenGLContext context)
{
uint dbase = GL.glGenLists(256);
wglUseFontBitmaps(context.GetNativeGDI(), 0, 256, dbase);
GL.glRasterPos2f(position.X, position.Y);// Position The Text On The Screen
GL.glPushAttrib(GL.GL_LIST_BIT); // Pushes The Display List Bits
GL.glListBase(dbase); // Sets The Base Character to 32
GL.glCallLists(text.Length, GL.GL_UNSIGNED_SHORT, text); // Draws The Display List Text
GL.glPopAttrib();
}
public static void InitGL_3_0(OpenGLContext ctx)
{
glColorMaski = ctx.GetProc<ColorMaski>("glColorMaski");
glGetBooleani_v = ctx.GetProc<GetBooleani_v>("glGetBooleani_v");
glGetIntegeri_v = ctx.GetProc<GetIntegeri_v>("glGetIntegeri_v");
glEnablei = ctx.GetProc<Enablei>("glEnablei");
glDisablei = ctx.GetProc<Disablei>("glDisablei");
glIsEnabledi = ctx.GetProc<IsEnabledi>("glIsEnabledi");
glBeginTransformFeedback = ctx.GetProc<BeginTransformFeedback>("glBeginTransformFeedback");
glEndTransformFeedback = ctx.GetProc<EndTransformFeedback>("glEndTransformFeedback");
glBindBufferRange = ctx.GetProc<BindBufferRange>("glBindBufferRange");
glBindBufferBase = ctx.GetProc<BindBufferBase>("glBindBufferBase");
glTransformFeedbackVaryings = ctx.GetProc<TransformFeedbackVaryings>("glTransformFeedbackVaryings");
glGetTransformFeedbackVarying = ctx.GetProc<GetTransformFeedbackVarying>("glGetTransformFeedbackVarying");
glClampColor = ctx.GetProc<ClampColor>("glClampColor");
glBeginConditionalRender = ctx.GetProc<BeginConditionalRender>("glBeginConditionalRender");
glEndConditionalRender = ctx.GetProc<EndConditionalRender>("glEndConditionalRender");
glVertexAttribIPointer = ctx.GetProc<VertexAttribIPointer>("glVertexAttribIPointer");
glGetVertexAttribIiv = ctx.GetProc<GetVertexAttribIiv>("glGetVertexAttribIiv");
glGetVertexAttribIuiv = ctx.GetProc<GetVertexAttribIuiv>("glGetVertexAttribIuiv");
glVertexAttribI1i = ctx.GetProc<VertexAttribI1i>("glVertexAttribI1i");
glVertexAttribI2i = ctx.GetProc<VertexAttribI2i>("glVertexAttribI2i");
glVertexAttribI3i = ctx.GetProc<VertexAttribI3i>("glVertexAttribI3i");
glVertexAttribI4i = ctx.GetProc<VertexAttribI4i>("glVertexAttribI4i");
glVertexAttribI1ui = ctx.GetProc<VertexAttribI1ui>("glVertexAttribI1ui");
glVertexAttribI2ui = ctx.GetProc<VertexAttribI2ui>("glVertexAttribI2ui");
glVertexAttribI3ui = ctx.GetProc<VertexAttribI3ui>("glVertexAttribI3ui");
glVertexAttribI4ui = ctx.GetProc<VertexAttribI4ui>("glVertexAttribI4ui");
glVertexAttribI1iv = ctx.GetProc<VertexAttribI1iv>("glVertexAttribI1iv");
glVertexAttribI2iv = ctx.GetProc<VertexAttribI2iv>("glVertexAttribI2iv");
glVertexAttribI3iv = ctx.GetProc<VertexAttribI3iv>("glVertexAttribI3iv");
glVertexAttribI4iv = ctx.GetProc<VertexAttribI4iv>("glVertexAttribI4iv");
glVertexAttribI1uiv = ctx.GetProc<VertexAttribI1uiv>("glVertexAttribI1uiv");
glVertexAttribI2uiv = ctx.GetProc<VertexAttribI2uiv>("glVertexAttribI2uiv");
glVertexAttribI3uiv = ctx.GetProc<VertexAttribI3uiv>("glVertexAttribI3uiv");
glVertexAttribI4uiv = ctx.GetProc<VertexAttribI4uiv>("glVertexAttribI4uiv");
glVertexAttribI4bv = ctx.GetProc<VertexAttribI4bv>("glVertexAttribI4bv");
glVertexAttribI4sv = ctx.GetProc<VertexAttribI4sv>("glVertexAttribI4sv");
glVertexAttribI4ubv = ctx.GetProc<VertexAttribI4ubv>("glVertexAttribI4ubv");
glVertexAttribI4usv = ctx.GetProc<VertexAttribI4usv>("glVertexAttribI4usv");
glGetUniformuiv = ctx.GetProc<GetUniformuiv>("glGetUniformuiv");
glBindFragDataLocation = ctx.GetProc<BindFragDataLocation>("glBindFragDataLocation");
glGetFragDataLocation = ctx.GetProc<GetFragDataLocation>("glGetFragDataLocation");
glUniform1ui = ctx.GetProc<Uniform1ui>("glUniform1ui");
glUniform2ui = ctx.GetProc<Uniform2ui>("glUniform2ui");
glUniform3ui = ctx.GetProc<Uniform3ui>("glUniform3ui");
glUniform4ui = ctx.GetProc<Uniform4ui>("glUniform4ui");
glUniform1uiv = ctx.GetProc<Uniform1uiv>("glUniform1uiv");
glUniform2uiv = ctx.GetProc<Uniform2uiv>("glUniform2uiv");
glUniform3uiv = ctx.GetProc<Uniform3uiv>("glUniform3uiv");
glUniform4uiv = ctx.GetProc<Uniform4uiv>("glUniform4uiv");
glTexParameterIiv = ctx.GetProc<TexParameterIiv>("glTexParameterIiv");
glTexParameterIuiv = ctx.GetProc<TexParameterIuiv>("glTexParameterIuiv");
glGetTexParameterIiv = ctx.GetProc<GetTexParameterIiv>("glGetTexParameterIiv");
glGetTexParameterIuiv = ctx.GetProc<GetTexParameterIuiv>("glGetTexParameterIuiv");
glClearBufferiv = ctx.GetProc<ClearBufferiv>("glClearBufferiv");
glClearBufferuiv = ctx.GetProc<ClearBufferuiv>("glClearBufferuiv");
glClearBufferfv = ctx.GetProc<ClearBufferfv>("glClearBufferfv");
glClearBufferfi = ctx.GetProc<ClearBufferfi>("glClearBufferfi");
glGetStringi = ctx.GetProc<GetStringi>("glGetStringi");
}
public static void InitGL_2_1(OpenGLContext ctx)
{
glUniformMatrix2x3fv = ctx.GetProc<UniformMatrix2x3fv>("glUniformMatrix2x3fv");
glUniformMatrix3x2fv = ctx.GetProc<UniformMatrix3x2fv>("glUniformMatrix3x2fv");
glUniformMatrix2x4fv = ctx.GetProc<UniformMatrix2x4fv>("glUniformMatrix2x4fv");
glUniformMatrix4x2fv = ctx.GetProc<UniformMatrix4x2fv>("glUniformMatrix4x2fv");
glUniformMatrix3x4fv = ctx.GetProc<UniformMatrix3x4fv>("glUniformMatrix3x4fv");
glUniformMatrix4x3fv = ctx.GetProc<UniformMatrix4x3fv>("glUniformMatrix4x3fv");
}
public static void InitGL_2_0(OpenGLContext ctx)
{
glBlendEquationSeparate = ctx.GetProc<BlendEquationSeparate>("glBlendEquationSeparate");
glDrawBuffers = ctx.GetProc<DrawBuffers>("glDrawBuffers");
glStencilOpSeparate = ctx.GetProc<StencilOpSeparate>("glStencilOpSeparate");
glStencilFuncSeparate = ctx.GetProc<StencilFuncSeparate>("glStencilFuncSeparate");
glStencilMaskSeparate = ctx.GetProc<StencilMaskSeparate>("glStencilMaskSeparate");
glAttachShader = ctx.GetProc<AttachShader>("glAttachShader");
glBindAttribLocation = ctx.GetProc<BindAttribLocation>("glBindAttribLocation");
glCompileShader = ctx.GetProc<CompileShader>("glCompileShader");
glCreateProgram = ctx.GetProc<CreateProgram>("glCreateProgram");
glCreateShader = ctx.GetProc<CreateShader>("glCreateShader");
glDeleteProgram = ctx.GetProc<DeleteProgram>("glDeleteProgram");
glDeleteShader = ctx.GetProc<DeleteShader>("glDeleteShader");
glDetachShader = ctx.GetProc<DetachShader>("glDetachShader");
glDisableVertexAttribArray = ctx.GetProc<DisableVertexAttribArray>("glDisableVertexAttribArray");
glEnableVertexAttribArray = ctx.GetProc<EnableVertexAttribArray>("glEnableVertexAttribArray");
glGetActiveAttrib = ctx.GetProc<GetActiveAttrib>("glGetActiveAttrib");
glGetActiveUniform = ctx.GetProc<GetActiveUniform>("glGetActiveUniform");
glGetAttachedShaders = ctx.GetProc<GetAttachedShaders>("glGetAttachedShaders");
glGetAttribLocation = ctx.GetProc<GetAttribLocation>("glGetAttribLocation");
glGetProgramiv = ctx.GetProc<GetProgramiv>("glGetProgramiv");
glGetProgramInfoLog = ctx.GetProc<GetProgramInfoLog>("glGetProgramInfoLog");
glGetShaderiv = ctx.GetProc<GetShaderiv>("glGetShaderiv");
glGetShaderInfoLog = ctx.GetProc<GetShaderInfoLog>("glGetShaderInfoLog");
glGetShaderSource = ctx.GetProc<GetShaderSource>("glGetShaderSource");
glGetUniformLocation = ctx.GetProc<GetUniformLocation>("glGetUniformLocation");
glGetUniformfv = ctx.GetProc<GetUniformfv>("glGetUniformfv");
glGetUniformiv = ctx.GetProc<GetUniformiv>("glGetUniformiv");
glGetVertexAttribdv = ctx.GetProc<GetVertexAttribdv>("glGetVertexAttribdv");
glGetVertexAttribfv = ctx.GetProc<GetVertexAttribfv>("glGetVertexAttribfv");
glGetVertexAttribiv = ctx.GetProc<GetVertexAttribiv>("glGetVertexAttribiv");
glGetVertexAttribPointerv = ctx.GetProc<GetVertexAttribPointerv>("glGetVertexAttribPointerv");
glIsProgram = ctx.GetProc<IsProgram>("glIsProgram");
glIsShader = ctx.GetProc<IsShader>("glIsShader");
glLinkProgram = ctx.GetProc<LinkProgram>("glLinkProgram");
glShaderSource = ctx.GetProc<ShaderSource>("glShaderSource");
glUseProgram = ctx.GetProc<UseProgram>("glUseProgram");
glUniform1f = ctx.GetProc<Uniform1f>("glUniform1f");
glUniform2f = ctx.GetProc<Uniform2f>("glUniform2f");
glUniform3f = ctx.GetProc<Uniform3f>("glUniform3f");
glUniform4f = ctx.GetProc<Uniform4f>("glUniform4f");
glUniform1i = ctx.GetProc<Uniform1i>("glUniform1i");
glUniform2i = ctx.GetProc<Uniform2i>("glUniform2i");
glUniform3i = ctx.GetProc<Uniform3i>("glUniform3i");
glUniform4i = ctx.GetProc<Uniform4i>("glUniform4i");
glUniform1fv = ctx.GetProc<Uniform1fv>("glUniform1fv");
glUniform2fv = ctx.GetProc<Uniform2fv>("glUniform2fv");
glUniform3fv = ctx.GetProc<Uniform3fv>("glUniform3fv");
glUniform4fv = ctx.GetProc<Uniform4fv>("glUniform4fv");
glUniform1iv = ctx.GetProc<Uniform1iv>("glUniform1iv");
glUniform2iv = ctx.GetProc<Uniform2iv>("glUniform2iv");
glUniform3iv = ctx.GetProc<Uniform3iv>("glUniform3iv");
glUniform4iv = ctx.GetProc<Uniform4iv>("glUniform4iv");
glUniformMatrix2fv = ctx.GetProc<UniformMatrix2fv>("glUniformMatrix2fv");
glUniformMatrix3fv = ctx.GetProc<UniformMatrix3fv>("glUniformMatrix3fv");
glUniformMatrix4fv = ctx.GetProc<UniformMatrix4fv>("glUniformMatrix4fv");
glValidateProgram = ctx.GetProc<ValidateProgram>("glValidateProgram");
glVertexAttrib1d = ctx.GetProc<VertexAttrib1d>("glVertexAttrib1d");
glVertexAttrib1dv = ctx.GetProc<VertexAttrib1dv>("glVertexAttrib1dv");
glVertexAttrib1f = ctx.GetProc<VertexAttrib1f>("glVertexAttrib1f");
glVertexAttrib1fv = ctx.GetProc<VertexAttrib1fv>("glVertexAttrib1fv");
glVertexAttrib1s = ctx.GetProc<VertexAttrib1s>("glVertexAttrib1s");
glVertexAttrib1sv = ctx.GetProc<VertexAttrib1sv>("glVertexAttrib1sv");
glVertexAttrib2d = ctx.GetProc<VertexAttrib2d>("glVertexAttrib2d");
glVertexAttrib2dv = ctx.GetProc<VertexAttrib2dv>("glVertexAttrib2dv");
glVertexAttrib2f = ctx.GetProc<VertexAttrib2f>("glVertexAttrib2f");
glVertexAttrib2fv = ctx.GetProc<VertexAttrib2fv>("glVertexAttrib2fv");
glVertexAttrib2s = ctx.GetProc<VertexAttrib2s>("glVertexAttrib2s");
glVertexAttrib2sv = ctx.GetProc<VertexAttrib2sv>("glVertexAttrib2sv");
glVertexAttrib3d = ctx.GetProc<VertexAttrib3d>("glVertexAttrib3d");
glVertexAttrib3dv = ctx.GetProc<VertexAttrib3dv>("glVertexAttrib3dv");
glVertexAttrib3f = ctx.GetProc<VertexAttrib3f>("glVertexAttrib3f");
glVertexAttrib3fv = ctx.GetProc<VertexAttrib3fv>("glVertexAttrib3fv");
glVertexAttrib3s = ctx.GetProc<VertexAttrib3s>("glVertexAttrib3s");
glVertexAttrib3sv = ctx.GetProc<VertexAttrib3sv>("glVertexAttrib3sv");
glVertexAttrib4Nbv = ctx.GetProc<VertexAttrib4Nbv>("glVertexAttrib4Nbv");
glVertexAttrib4Niv = ctx.GetProc<VertexAttrib4Niv>("glVertexAttrib4Niv");
glVertexAttrib4Nsv = ctx.GetProc<VertexAttrib4Nsv>("glVertexAttrib4Nsv");
glVertexAttrib4Nub = ctx.GetProc<VertexAttrib4Nub>("glVertexAttrib4Nub");
glVertexAttrib4Nubv = ctx.GetProc<VertexAttrib4Nubv>("glVertexAttrib4Nubv");
glVertexAttrib4Nuiv = ctx.GetProc<VertexAttrib4Nuiv>("glVertexAttrib4Nuiv");
glVertexAttrib4Nusv = ctx.GetProc<VertexAttrib4Nusv>("glVertexAttrib4Nusv");
glVertexAttrib4bv = ctx.GetProc<VertexAttrib4bv>("glVertexAttrib4bv");
glVertexAttrib4d = ctx.GetProc<VertexAttrib4d>("glVertexAttrib4d");
glVertexAttrib4dv = ctx.GetProc<VertexAttrib4dv>("glVertexAttrib4dv");
glVertexAttrib4f = ctx.GetProc<VertexAttrib4f>("glVertexAttrib4f");
glVertexAttrib4fv = ctx.GetProc<VertexAttrib4fv>("glVertexAttrib4fv");
glVertexAttrib4iv = ctx.GetProc<VertexAttrib4iv>("glVertexAttrib4iv");
glVertexAttrib4s = ctx.GetProc<VertexAttrib4s>("glVertexAttrib4s");
glVertexAttrib4sv = ctx.GetProc<VertexAttrib4sv>("glVertexAttrib4sv");
glVertexAttrib4ubv = ctx.GetProc<VertexAttrib4ubv>("glVertexAttrib4ubv");
glVertexAttrib4uiv = ctx.GetProc<VertexAttrib4uiv>("glVertexAttrib4uiv");
glVertexAttrib4usv = ctx.GetProc<VertexAttrib4usv>("glVertexAttrib4usv");
glVertexAttribPointer = ctx.GetProc<VertexAttribPointer>("glVertexAttribPointer");
}
public static void InitGL_3_1(OpenGLContext ctx)
{
glDrawArraysInstanced = ctx.GetProc<DrawArraysInstanced>("glDrawArraysInstanced");
glDrawElementsInstanced = ctx.GetProc<DrawElementsInstanced>("glDrawElementsInstanced");
glTexBuffer = ctx.GetProc<TexBuffer>("glTexBuffer");
glPrimitiveRestartIndex = ctx.GetProc<PrimitiveRestartIndex>("glPrimitiveRestartIndex");
}
public static void InitGL_1_4(OpenGLContext ctx)
{
glBlendFuncSeparate = ctx.GetProc<BlendFuncSeparate>("glBlendFuncSeparate");
glMultiDrawArrays = ctx.GetProc<MultiDrawArrays>("glMultiDrawArrays");
glMultiDrawElements = ctx.GetProc<MultiDrawElements>("glMultiDrawElements");
glPointParameterf = ctx.GetProc<PointParameterf>("glPointParameterf");
glPointParameterfv = ctx.GetProc<PointParameterfv>("glPointParameterfv");
glPointParameteri = ctx.GetProc<PointParameteri>("glPointParameteri");
glPointParameteriv = ctx.GetProc<PointParameteriv>("glPointParameteriv");
}
private void lvFiles_SelectedIndexChanged(object sender, EventArgs e)
{
if (lvFiles.SelectedItems.Count <= 0)
{
pbPreview.Width = 0;
pbPreview.Visible = false;
rtbPreview.Width = 0;
rtbPreview.Visible = false;
splitContainer.SplitterDistance = this.Width;
lbSelection.Text = String.Empty;
return;
}
if (File.Exists(currentMeshFile))
{
File.Delete(currentMeshFile);
}
if (File.Exists(currentMeshFile + ".mtl"))
{
File.Delete(currentMeshFile + ".mtl");
}
if (glControl != null)
{
if (glControl.GLrender != null)
{
glControl.GLrender.ClearAllObjects();
glControl.GLrender.GLControlInstance.Dispose();
}
glControl.Dispose();
}
ListViewItem Item = lvFiles.SelectedItems[0];
lbSelection.Text = String.Format("Sel {0}", Item.Index + 1);
ImageListIndex indx = FileType.GetImageIndex(Path.GetExtension(Item.Text));
if (indx == ImageListIndex.Image)
{
pbPreview.Width = 399;
pbPreview.Visible = true;
rtbPreview.Width = 0;
rtbPreview.Visible = false;
pnlPreview.Visible = false;
ArchiveEntry ent = m_Archive.getByName(Path.GetFileNameWithoutExtension(Item.Text));
Image img = null;
using (MemoryStream ms = new MemoryStream(ent.getData()))
{
try
{
if (Path.GetExtension(Item.Text) == ".tga")
{
TargaImage tgaImg = new TargaImage(ms);
img = tgaImg.Image;
}
else
{
img = Image.FromStream(ms);
}
}
catch
{ }
}
if (img != null)
{
pbPreview.Image = img;
pbPreview.Width = img.Width;
pbPreview.Location = new Point(pbPreview.Location.X, (this.Height / 2) - (img.Height / 2) - 20);
splitContainer.SplitterDistance = Math.Max(this.Width - img.Width - 20, 200);
}
}
else if (indx == ImageListIndex.Text)
{
pbPreview.Width = 0;
pbPreview.Visible = false;
rtbPreview.Width = 500;
rtbPreview.Visible = true;
pnlPreview.Visible = false;
splitContainer.SplitterDistance = this.Width - 500;
rtbPreview.Text = "";
ArchiveEntry ent = m_Archive.getByName(Path.GetFileNameWithoutExtension(Item.Text));
if (ent != null)
{
rtbPreview.Text = Encoding.Default.GetString(ent.getData());
}
}
else if (indx == ImageListIndex.Mesh)
{
pnlPreview.Visible = true;
splitContainer.SplitterDistance = this.Width - 500;
glControl = new OGLControl();
glControl.Parent = pnlPreview;
glControl.Dock = DockStyle.Fill;
glContext = new OpenGLContext(glControl);
glControl.GLrender.PrimitiveTypes = OpenTK.Graphics.OpenGL.PrimitiveType.Triangles;
glControl.GLrender.Camera.ZNear = 0.01f;
glControl.GLrender.Camera.ZFar = float.MaxValue;
string tempFile = Path.GetTempFileName();
currentMeshFile = Path.ChangeExtension(Path.GetTempFileName(), "obj");
ArchiveEntry ent = m_Archive.getByName(Path.GetFileNameWithoutExtension(Item.Text));
ent.extractTo(tempFile, true);
using (AssimpContext context = new AssimpContext())
{
Scene mesh = context.ImportFile(tempFile);
context.ExportFile(mesh, currentMeshFile, "obj");
}
File.Delete(tempFile);
Model model = new Model(currentMeshFile);
glControl.GLrender.AddModel(model);
glControl.GLrender.SelectedModelIndex = 0;
}
else
{
pbPreview.Width = 0;
pbPreview.Visible = false;
rtbPreview.Width = 0;
rtbPreview.Visible = false;
pnlPreview.Visible = false;
}
}
public static void InitVertexArrayObjects(OpenGLContext ctx)
{
glBindVertexArray = ctx.GetProc<BindVertexArray>("glBindVertexArray");
glDeleteVertexArrays = ctx.GetProc<DeleteVertexArrays>("glDeleteVertexArrays");
glGenVertexArrays = ctx.GetProc<GenVertexArrays>("glGenVertexArrays");
glIsVertexArray = ctx.GetProc<IsVertexArray>("glIsVertexArray");
}
public GraphicsDevice(IntPtr target)
{
context = OpenGLContext.GetContext();
context.Samples = 4;
// Create context using platform specific methods
context.CreateContext(target, IntPtr.Zero, null);
//GL.InitGeneral(context);
//foreach (var str in GL.GetSupportedExtensions())
//Console.WriteLine(str);
modelview_matrix = new MatrixState();
projection_matrix = new MatrixState();
texture_matrix = new MatrixState();
normal_matrix = new MatrixState();
var err = GL.glGetError();
GL.InitGL_1_2(context);
GL.InitGL_1_3(context);
GL.InitGL_1_4(context);
GL.InitGL_1_5(context);
GL.InitGL_2_0(context);
GL.InitGL_2_1(context);
GL.InitGL_3_0(context);
GL.InitGL_3_1(context);
GL.InitGL_3_2(context);
GL.InitFramebuffers(context);
GL.InitVertexArrayObjects(context);
var sp = GL.GetSupportedExtensions();
if (sp.Contains("GL_AMD_debug_output"))
{
GL.InitDebugOutputAMD(context);
GL.glDebugMessageCallbackAMD(new OpenGL.OpenGL.DebugProc(DebugProcecure), IntPtr.Zero);
GL.glDebugMessageEnableAMD(0, 0, 0, new int[] { }, GL.boolean.TRUE);
}
err = GL.glGetError();
GL.glEnable(GL.Const.GL_TEXTURE_2D);
state = new OpenGLState(this);
state.Blend = true;
state.BlendFunction(Blend.SrcAlpha, Blend.OneMinusSrcAlpha);
state.Culling = true;
state.DepthTest = true;
}
public static void InitDebugOutputAMD(OpenGLContext ctx)
{
glDebugMessageCallbackAMD = ctx.GetProc<DebugMessageCallbackAMD>("glDebugMessageCallbackAMD");
glDebugMessageEnableAMD = ctx.GetProc<DebugMessageEnableAMD>("glDebugMessageEnableAMD");
glDebugMessageInsertAMD = ctx.GetProc<DebugMessageInsertAMD>("glDebugMessageInsertAMD");
glGetDebugMessageLogAMD = ctx.GetProc<GetDebugMessageLogAMD>("glGetDebugMessageLogAMD");
}
public static void InitFramebuffers(OpenGLContext ctx)
{
glIsRenderbuffer = ctx.GetProc<IsRenderbuffer>("glIsRenderbuffer");
glBindRenderbuffer = ctx.GetProc<BindRenderbuffer>("glBindRenderbuffer");
glDeleteRenderbuffers = ctx.GetProc<DeleteRenderbuffers>("glDeleteRenderbuffers");
glGenRenderbuffers = ctx.GetProc<GenRenderbuffers>("glGenRenderbuffers");
glRenderbufferStorage = ctx.GetProc<RenderbufferStorage>("glRenderbufferStorage");
glGetRenderbufferParameteriv = ctx.GetProc<GetRenderbufferParameteriv>("glGetRenderbufferParameteriv");
glIsFramebuffer = ctx.GetProc<IsFramebuffer>("glIsFramebuffer");
glBindFramebuffer = ctx.GetProc<BindFramebuffer>("glBindFramebuffer");
glDeleteFramebuffers = ctx.GetProc<DeleteFramebuffers>("glDeleteFramebuffers");
glGenFramebuffers = ctx.GetProc<GenFramebuffers>("glGenFramebuffers");
glCheckFramebufferStatus = ctx.GetProc<CheckFramebufferStatus>("glCheckFramebufferStatus");
glFramebufferTexture1D = ctx.GetProc<FramebufferTexture1D>("glFramebufferTexture1D");
glFramebufferTexture2D = ctx.GetProc<FramebufferTexture2D>("glFramebufferTexture2D");
glFramebufferTexture3D = ctx.GetProc<FramebufferTexture3D>("glFramebufferTexture3D");
glFramebufferRenderbuffer = ctx.GetProc<FramebufferRenderbuffer>("glFramebufferRenderbuffer");
glGetFramebufferAttachmentParameteriv = ctx.GetProc<GetFramebufferAttachmentParameteriv>("glGetFramebufferAttachmentParameteriv");
glGenerateMipmap = ctx.GetProc<GenerateMipmap>("glGenerateMipmap");
glBlitFramebuffer = ctx.GetProc<BlitFramebuffer>("glBlitFramebuffer");
glRenderbufferStorageMultisample = ctx.GetProc<RenderbufferStorageMultisample>("glRenderbufferStorageMultisample");
glFramebufferTextureLayer = ctx.GetProc<FramebufferTextureLayer>("glFramebufferTextureLayer");
}
public override void Update()
{
OpenGLContext.Update();
}
public GLxDisplayText(OpenGLContext context)
{
m_Context = context;
}
public void Render()
{
// First take exclusivity on the OpenGL context.
_renderer.InitializeBackgroundContext(SPBOpenGLContext.CreateBackgroundContext(OpenGLContext));
Gtk.Window parent = Toplevel as Gtk.Window;
parent.Present();
OpenGLContext.MakeCurrent(NativeWindow);
_device.Gpu.Renderer.Initialize(_glLogLevel);
// Make sure the first frame is not transparent.
GL.ClearColor(0, 0, 0, 1.0f);
GL.Clear(ClearBufferMask.ColorBufferBit);
SwapBuffers();
_device.Gpu.InitializeShaderCache();
Translator.IsReadyForTranslation.Set();
while (_isActive)
{
if (_isStopped)
{
return;
}
_ticks += _chrono.ElapsedTicks;
_chrono.Restart();
if (_device.WaitFifo())
{
_device.Statistics.RecordFifoStart();
_device.ProcessFrame();
_device.Statistics.RecordFifoEnd();
}
while (_device.ConsumeFrameAvailable())
{
_device.PresentFrame(SwapBuffers);
}
if (_ticks >= _ticksPerFrame)
{
string dockedMode = ConfigurationState.Instance.System.EnableDockedMode ? "Docked" : "Handheld";
float scale = Graphics.Gpu.GraphicsConfig.ResScale;
if (scale != 1)
{
dockedMode += $" ({scale}x)";
}
StatusUpdatedEvent?.Invoke(this, new StatusUpdatedEventArgs(
_device.EnableDeviceVsync,
dockedMode,
ConfigurationState.Instance.Graphics.AspectRatio.Value.ToText(),
$"Game: {_device.Statistics.GetGameFrameRate():00.00} FPS",
$"FIFO: {_device.Statistics.GetFifoPercent():0.00} %",
$"GPU: {_renderer.GpuVendor}"));
_ticks = Math.Min(_ticks - _ticksPerFrame, _ticksPerFrame);
}
}
}
public virtual void MakeCurrent()
{
AssertValid();
AssertContext();
OpenGLContext.MakeCurrentContext();
}
public static void InitGL_1_3(OpenGLContext ctx)
{
glActiveTexture = ctx.GetProc<ActiveTexture>("glActiveTexture");
glSampleCoverage = ctx.GetProc<SampleCoverage>("glSampleCoverage");
glCompressedTexImage3D = ctx.GetProc<CompressedTexImage3D>("glCompressedTexImage3D");
glCompressedTexImage2D = ctx.GetProc<CompressedTexImage2D>("glCompressedTexImage2D");
glCompressedTexImage1D = ctx.GetProc<CompressedTexImage1D>("glCompressedTexImage1D");
glCompressedTexSubImage3D = ctx.GetProc<CompressedTexSubImage3D>("glCompressedTexSubImage3D");
glCompressedTexSubImage2D = ctx.GetProc<CompressedTexSubImage2D>("glCompressedTexSubImage2D");
glCompressedTexSubImage1D = ctx.GetProc<CompressedTexSubImage1D>("glCompressedTexSubImage1D");
glGetCompressedTexImage = ctx.GetProc<GetCompressedTexImage>("glGetCompressedTexImage");
}
public static void InitGL_3_2(OpenGLContext ctx)
{
glGetInteger64i_v = ctx.GetProc<GetInteger64i_v>("glGetInteger64i_v");
glGetBufferParameteri64v = ctx.GetProc<GetBufferParameteri64v>("glGetBufferParameteri64v");
glProgramParameteri = ctx.GetProc<ProgramParameteri>("glProgramParameteri");
glFramebufferTexture = ctx.GetProc<FramebufferTexture>("glFramebufferTexture");
}
public static void InitGL_1_5(OpenGLContext ctx)
{
glDeleteQueries = ctx.GetProc<DeleteQueries>("glDeleteQueries");
glIsQuery = ctx.GetProc<IsQuery>("glIsQuery");
glBeginQuery = ctx.GetProc<BeginQuery>("glBeginQuery");
glEndQuery = ctx.GetProc<EndQuery>("glEndQuery");
glGetQueryiv = ctx.GetProc<GetQueryiv>("glGetQueryiv");
glGetQueryObjectiv = ctx.GetProc<GetQueryObjectiv>("glGetQueryObjectiv");
glGetQueryObjectuiv = ctx.GetProc<GetQueryObjectuiv>("glGetQueryObjectuiv");
glBindBuffer = ctx.GetProc<BindBuffer>("glBindBuffer");
glDeleteBuffers = ctx.GetProc<DeleteBuffers>("glDeleteBuffers");
glGenBuffers = ctx.GetProc<GenBuffers>("glGenBuffers");
glIsBuffer = ctx.GetProc<IsBuffer>("glIsBuffer");
glBufferData = ctx.GetProc<BufferData>("glBufferData");
glBufferSubData = ctx.GetProc<BufferSubData>("glBufferSubData");
glGetBufferSubData = ctx.GetProc<GetBufferSubData>("glGetBufferSubData");
glMapBuffer = ctx.GetProc<MapBuffer>("glMapBuffer");
glUnmapBuffer = ctx.GetProc<UnmapBuffer>("glUnmapBuffer");
glGetBufferParameteriv = ctx.GetProc<GetBufferParameteriv>("glGetBufferParameteriv");
glGetBufferPointerv = ctx.GetProc<GetBufferPointerv>("glGetBufferPointerv");
}
public OpenGLDevice(OpenGLGraphics gp, OpenGLContext context)
{
m_OpenGL = gp;
m_Context = context;
}
public static void InitGL_1_2(OpenGLContext ctx)
{
glBlendColor = ctx.GetProc<BlendColor>("glBlendColor");
glBlendEquation = ctx.GetProc<BlendEquation>("glBlendEquation");
glDrawRangeElements = ctx.GetProc<DrawRangeElements>("glDrawRangeElements");
glTexImage3D = ctx.GetProc<TexImage3D>("glTexImage3D");
glTexSubImage3D = ctx.GetProc<TexSubImage3D>("glTexSubImage3D");
glCopyTexSubImage3D = ctx.GetProc<CopyTexSubImage3D>("glCopyTexSubImage3D");
}
