protected override void OnOpenGlDeinit(GlInterface gl, int fb)
{
game?.DisposeGame();
engine.Dispose();
engine = null !;
base.OnOpenGlDeinit(gl, fb);
}
public GlPlatformFeature(IAvnGlDisplay display)
{
_display = display;
var immediate = display.CreateContext(null);
var deferred = display.CreateContext(immediate);
int major, minor;
GlInterface glInterface;
using (immediate.MakeCurrent())
{
var basic = new GlBasicInfoInterface(display.GetProcAddress);
basic.GetIntegerv(GlConsts.GL_MAJOR_VERSION, out major);
basic.GetIntegerv(GlConsts.GL_MINOR_VERSION, out minor);
_version = new GlVersion(GlProfileType.OpenGL, major, minor);
glInterface = new GlInterface(_version, (name) =>
{
var rv = _display.GetProcAddress(name);
return(rv);
});
}
GlDisplay = new GlDisplay(display, glInterface, immediate.SampleCount, immediate.StencilSize);
ImmediateContext = new GlContext(GlDisplay, immediate, _version);
DeferredContext = new GlContext(GlDisplay, deferred, _version);
}
private LayerFbo(EAGLContext context, GlInterface gl, CAEAGLLayer layer, int framebuffer, int renderbuffer, int depthBuffer)
{
_context = context;
_gl = gl;
_layer = layer;
_framebuffer = framebuffer;
_renderbuffer = renderbuffer;
_depthBuffer = depthBuffer;
}
protected override void OnOpenGlRender(GlInterface gl, int fb)
{
if (engine == null || delayedDispose)
{
return;
}
engine.statsManager.PixelSize = new Vector2(PixelSize.Item1, PixelSize.Item2);
engine.statsManager.Counters.PresentTime.Add(PresentTime);
renderStopwatch.Restart();
try
{
engine.Device.device.CheckError("start OnOpenGlRender");
engine.Device.device.Begin();
engine.inputManager.Update();
engine.renderManager.BeginFrame();
var delta = (float)sw.Elapsed.TotalMilliseconds;
Tick(delta);
engine.statsManager.Counters.FrameTime.Add(delta);
sw.Restart();
Dispatcher.UIThread.Post(() => RaisePropertyChanged(FrameRateProperty, Optional <float> .Empty, FrameRate), DispatcherPriority.Render);
Update(delta);
// render pass
engine.renderManager.PrepareRendering(fb);
engine.renderManager.RenderWorld(fb);
Render(delta);
engine.renderManager.FinalizeRendering(fb);
if (engine.inputManager.Keyboard.JustPressed(Key.R))
{
if (engine.Device.device is DebugDevice debug)
{
var file = new FileInfo("render_debug.txt");
File.WriteAllLines(file.FullName, debug.commands);
Console.WriteLine("Log written to " + file.FullName);
}
}
engine.inputManager.PostUpdate();
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
finally
{
// important! we need to restore Avalonia status
engine.Device.device.ActiveTextureUnit(0);
engine.Device.device.CheckError("post render");
}
renderStopwatch.Stop();
engine.statsManager.Counters.TotalRender.Add(renderStopwatch.Elapsed.Milliseconds);
frame++;
}
protected override void OnOpenGlDeinit(GlInterface gl, int fb)
{
DisposeRenderer();
m_gl.BindVertexArray(0);
m_gl.DeleteVertexArrays(1, m_vao);
m_vao = null;
m_gl = null;
}
public GlDisplay(IAvnGlDisplay display)
{
_display = display;
GlInterface = new GlInterface((name, optional) =>
{
var rv = _display.GetProcAddress(name);
if (rv == IntPtr.Zero && !optional)
{
throw new OpenGlException($"{name} not found in system OpenGL");
}
return(rv);
});
}
public GlDisplay(IAvnGlDisplay display, int sampleCount, int stencilSize)
{
_display = display;
SampleCount = sampleCount;
StencilSize = stencilSize;
GlInterface = new GlInterface((name, optional) =>
{
var rv = _display.GetProcAddress(name);
if (rv == IntPtr.Zero && !optional)
{
throw new OpenGlException($"{name} not found in system OpenGL");
}
return(rv);
});
}
private bool CheckFramebufferStatus(GlInterface gl)
{
var status = gl.CheckFramebufferStatus(GL_FRAMEBUFFER);
if (status != GL_FRAMEBUFFER_COMPLETE)
{
int code;
while ((code = gl.GetError()) != 0)
{
Logger.TryGet(LogEventLevel.Error, "OpenGL")?.Log("OpenGlControlBase",
"Unable to initialize OpenGL FBO: {code}", code);
}
return(false);
}
return(true);
}
public static LayerFbo TryCreate(EAGLContext context, GlInterface gl, CAEAGLLayer layer)
{
if (context != EAGLContext.CurrentContext)
{
return(null);
}
var fb = new int[2];
var rb = new int[2];
var db = new int[2];
gl.GenRenderbuffers(1, rb);
gl.BindRenderbuffer(GlConsts.GL_RENDERBUFFER, rb[0]);
context.RenderBufferStorage(GlConsts.GL_RENDERBUFFER, layer);
gl.GenFramebuffers(1, fb);
gl.BindFramebuffer(GlConsts.GL_FRAMEBUFFER, fb[0]);
gl.FramebufferRenderbuffer(GlConsts.GL_FRAMEBUFFER, GlConsts.GL_COLOR_ATTACHMENT0, GlConsts.GL_RENDERBUFFER, rb[0]);
int[] w = new int[1];
int[] h = new int[1];
gl.GetRenderbufferParameteriv(GlConsts.GL_RENDERBUFFER, GlConsts.GL_RENDERBUFFER_WIDTH, w);
gl.GetRenderbufferParameteriv(GlConsts.GL_RENDERBUFFER, GlConsts.GL_RENDERBUFFER_HEIGHT, h);
gl.GenRenderbuffers(1, db);
//GL.BindRenderbuffer(RenderbufferTarget.Renderbuffer, depthBuffer);
//GL.RenderbufferStorage(RenderbufferTarget.Renderbuffer, RenderbufferInternalFormat.DepthComponent16, w, h);
gl.FramebufferRenderbuffer(GlConsts.GL_FRAMEBUFFER, GlConsts.GL_DEPTH_ATTACHMENT, GlConsts.GL_RENDERBUFFER, db[0]);
var frameBufferError = gl.CheckFramebufferStatus(GlConsts.GL_FRAMEBUFFER);
if (frameBufferError != GlConsts.GL_FRAMEBUFFER_COMPLETE)
{
gl.DeleteFramebuffers(1, fb);
gl.DeleteRenderbuffers(1, db);
gl.DeleteRenderbuffers(1, rb);
return(null);
}
return(new LayerFbo(context, gl, layer, fb, rb, db)
{
Width = w[0],
Height = h[0]
});
}
public GlxContext(GlxInterface glx, IntPtr handle, GlxDisplay display,
GlVersion version, int sampleCount, int stencilSize,
X11Info x11, IntPtr defaultXid,
bool ownsPBuffer)
{
Handle = handle;
Glx = glx;
_x11 = x11;
_defaultXid = defaultXid;
_ownsPBuffer = ownsPBuffer;
Display = display;
Version = version;
SampleCount = sampleCount;
StencilSize = stencilSize;
using (MakeCurrent())
GlInterface = new GlInterface(version, GlxInterface.SafeGetProcAddress);
}
protected unsafe override void OnOpenGlInit(GlInterface gl, int fb)
{
m_gl = new GlInterfaceEx(gl);
// hook up debug handler
//m_debugProc = OnGlDebugMessage;
//gl.Enable(GL_DEBUG_OUTPUT);
//m_gl.DebugMessageCallback(m_debugProc, null);
// allocate vertex array object (VAO)
m_vao = new int[1];
m_gl.GenVertexArrays(1, m_vao);
m_gl.BindVertexArray(m_vao[0]);
// initialize Cubism renderer
TryUpdateRenderer();
m_time.Restart();
}
protected override void OnOpenGlRender(GlInterface gl, int fb)
{
if (m_asset == null)
{
return;
}
if ((m_lastmotion == null) || (m_lastmotion.Finished == true))
{
var motion_group = m_asset.MotionGroups[""];
int number = new Random().Next() % motion_group.Length;
var motion = (CubismMotion)motion_group[number];
m_lastmotion = m_asset.StartMotion(MotionType.Base, motion, false);
}
m_asset.Update(m_time.ElapsedMilliseconds / 1000.0);
m_time.Restart();
double controlScaling = VisualRoot.RenderScaling;
int w = (int)(Bounds.Width * controlScaling);
int h = (int)(Bounds.Height * controlScaling);
double r = Math.Sqrt(((float)w) / h);
gl.Viewport(0, 0, w, h);
gl.Clear(GL_COLOR_BUFFER_BIT);
Matrix4x4 mvp_matrix = Matrix4x4.Identity;
if (h >= w)
{
mvp_matrix.M11 = 1.5f;
mvp_matrix.M22 = -1.5f * w / h;
}
else
{
mvp_matrix.M11 = 1.5f * h / w;
mvp_matrix.M22 = -1.5f;
}
m_rendermgr.Draw(mvp_matrix);
Dispatcher.UIThread.Post(InvalidateVisual, DispatcherPriority.Background);
}
public WglContext(WglContext sharedWith, GlVersion version, IntPtr context, IntPtr hWnd, IntPtr dc, int pixelFormat,
PixelFormatDescriptor formatDescriptor)
{
Version = version;
_sharedWith = sharedWith;
_context = context;
_hWnd = hWnd;
_dc = dc;
_pixelFormat = pixelFormat;
_formatDescriptor = formatDescriptor;
StencilSize = formatDescriptor.StencilBits;
using (MakeCurrent())
GlInterface = new GlInterface(version, proc =>
{
var ext = wglGetProcAddress(proc);
if (ext != IntPtr.Zero)
{
return(ext);
}
return(GetProcAddress(WglDisplay.OpenGl32Handle, proc));
});
}
protected override void OnOpenGlInit(GlInterface gl, int fb)
{
try
{
#if USE_OPENTK
engine = new Engine(new OpenTKDevice(), new Configuration(), this);
#else
IDevice device;
var real = new RealDevice(gl);
#if DEBUG && DEBUG_OPENGL
device = new DebugDevice(real);
#else
device = new RealDeviceWrapper(real);
#endif
engine = new Engine(device, new Configuration(), this);
#endif
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
