LÖVE

Code: Select all

local FFI = require( 'ffi' )
local OGL_LIBS = {
	OSX		= { x86 = "OpenGL.framework/OpenGL", x64 = "OpenGL.framework/OpenGL" },
	Windows	= { x86 = "OPENGL32.DLL", x64 = "OPENGL32.DLL" },
	Linux	= { x86 = "libGL.so", x64 = "libGL.so", arm = "libGL.so" },
}
local OGL_LIB = OGL_LIBS[ FFI.os ][ FFI.arch ]

FFI.cdef[[
	typedef char GLchar;
	typedef int GLsizei;
	typedef unsigned int GLuint;
	typedef unsigned int GLenum;

	void glPushDebugGroup( GLenum source, GLuint id, GLsizei length, const GLchar *message );
	void glPopDebugGroup( void );
]]

local OPENGL = {
	GL = FFI.load( OGL_LIB ),

	PushEvent = function( self, Message )
		self.GL.glPushDebugGroup(
			0,
			0,
			string.len( Message ),
			Message
		)
	end,
	
	PopEvent = function( self )
		self.GL.glPopDebugGroup()
	end
}

return OPENGL

Code: Select all

local GL = require( "ogl.lua" )

function love.load()
end

function love.update( dt )
end

function love.draw()
	GL:PushEvent( "ParentEvent" )
	
	love.graphics.rectangle( "fill", 10, 50, 60, 120 )
	
	GL:PushEvent( "ChildEvent" )

	love.graphics.rectangle( "fill", 40, 50, 60, 120 )

	GL:PopEvent()
	GL:PopEvent()
end

Code: Select all

Call = function( self, name, fun, ... )
	    self:PushEvent( name )
	    fn(...)
	    self:PopEvent()
	end


function love.draw()
	GL:Call( "gameplay", mygame.draw, mygame ) -- calls mygame:draw()
	GL:Call( "ui", draw_ui ) -- calls draw_ui()
end

Code: Select all

GL.Call = function(self, name, fun, ...) -- since it's explicit, you don't really need to call it self, only if you want to.
  self:PushEvent(name)
  fn(...)
  self:PopEvent()
end

--[[
function GL:Call(name, fun, ...) -- this works too, since it's functionally equivalent to the above.
  self:PushEvent(name)
  fn(...)
  self:PopEvent()
end
--]]

function love.draw()
	GL:Call("gameplay", mygame.draw, mygame ) -- calls mygame:draw() -> which is functionally equivalent to mygame.draw(mygame)
	GL:Call("ui", draw_ui ) -- calls draw_ui()
end

Code: Select all

function GL:Call(name, fun, ...) -- this works too, since it's functionally equivalent to the above.
    self:PushEvent(name)
    fn(...)
    self:PopEvent()
end

Code: Select all

local FFI = require( 'ffi' )
local OPENGL = {}
OPENGL.GL = {}
OPENGL.SDL = FFI.os == "Windows" and FFI.load("SDL2") or FFI.C

function OPENGL.Init()
	local Definitions = [[
		//---------------------
		// OpenGL
		//---------------------
		typedef char GLchar;
		typedef int GLsizei;
		typedef unsigned int GLuint;
		typedef unsigned int GLenum;

		// void glPushDebugGroup( GLenum source, GLuint id, GLsizei length, const GLchar *message );
		typedef void (APIENTRYP PFNGLPUSHDEBUGGROUPPROC) (GLenum source, GLuint id, GLsizei length, const GLchar *message);

		// void glPopDebugGroup( void );
		typedef void (APIENTRYP PFNGLPOPDEBUGGROUPPROC) (void);

		//---------------------
		// SDL
		//---------------------
		typedef bool SDL_bool;
		SDL_bool SDL_GL_ExtensionSupported( const char *extension );
		void* SDL_GL_GetProcAddress( const char *proc );
	]]

	if FFI.os == "Windows" then
		Definitions = Definitions:gsub( "APIENTRYP", "__stdcall *" )
	else
		Definitions = Definitions:gsub( "APIENTRYP", "*" )
	end

	FFI.cdef( Definitions )

	-- https://registry.khronos.org/OpenGL/api/GL/glext.h
	local Names = {
		{ "glPushDebugGroup", "PFNGLPUSHDEBUGGROUPPROC" },
		{ "glPopDebugGroup", "PFNGLPOPDEBUGGROUPPROC" }
	}
	local ProcName = ""
	local GLName = ""

	for i=1, #Names do
		GLName = Names[i][1]
		ProcName = Names[i][2]
		local Function = FFI.cast( ProcName, OPENGL.SDL.SDL_GL_GetProcAddress(GLName) )
		rawset( OPENGL.GL, GLName, Function)
	end
end

function OPENGL.IsExtensionSupported( Name )
	return OPENGL.SDL.SDL_GL_ExtensionSupported( Name )
end

function OPENGL.PushEvent( Message )
	OPENGL.GL.glPushDebugGroup(
		0,
		0,
		string.len( Message ),
		Message
	)
end

function OPENGL.PopEvent()
	OPENGL.GL.glPopDebugGroup()
end

OPENGL.Init()
return OPENGL