void initialize() {
if(!isEnabled()) {
return;
}
bool have_debug = ARX_HAVE_GL_VER(4, 3) || ARX_HAVE_GL_EXT(KHR_debug);
#if ARX_HAVE_EPOXY
have_debug = have_debug || (epoxy_is_desktop_gl() && ARX_HAVE_GL_EXT(ARB_debug_output));
#endif
if(!have_debug) {
LogWarning << "OpenGL debug output not available";
return;
}
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
// GLEW versions before 1.11.0 define GLDEBUGPROC with a non-const user pointer
#if !ARX_HAVE_GLEW || defined(GLEW_VERSION_4_5)
glDebugMessageCallback(gldebug::callback, NULL);
#else
glDebugMessageCallback((GLDEBUGPROC)gldebug::callback, NULL);
#endif
// Forward messages with high severity level
glDebugMessageControl(GL_DONT_CARE,
GL_DONT_CARE,
GL_DEBUG_SEVERITY_HIGH,
0,
NULL,
GL_TRUE);
// Forward messages with medium severity level
glDebugMessageControl(GL_DONT_CARE,
GL_DONT_CARE,
GL_DEBUG_SEVERITY_MEDIUM,
0,
NULL,
GL_TRUE);
// Forward messages from the application
glDebugMessageControl(GL_DEBUG_SOURCE_APPLICATION,
GL_DONT_CARE,
GL_DONT_CARE,
0,
NULL,
GL_TRUE);
std::string strInitialized("OpenGL debug output enabled");
glDebugMessageInsert(GL_DEBUG_SOURCE_APPLICATION,
GL_DEBUG_TYPE_OTHER,
1,
GL_DEBUG_SEVERITY_LOW,
GLsizei(strInitialized.size()), strInitialized.c_str());
}
void dumpCurrentContext(std::ostream &os)
{
JSONWriter json(os);
#ifndef NDEBUG
GLint old_bindings[NUM_BINDINGS];
for (unsigned i = 0; i < NUM_BINDINGS; ++i) {
old_bindings[i] = 0;
glGetIntegerv(bindings[i], &old_bindings[i]);
}
#endif
Context context;
/* Temporarily disable messages, as dumpParameters blindlessly tries to
* get state, regardless the respective extension is supported or not.
*/
GLDEBUGPROC prevDebugCallbackFunction = 0;
void *prevDebugCallbackUserParam = 0;
if (context.KHR_debug) {
glGetPointerv(GL_DEBUG_CALLBACK_FUNCTION, (GLvoid **) &prevDebugCallbackFunction);
glGetPointerv(GL_DEBUG_CALLBACK_USER_PARAM, &prevDebugCallbackUserParam);
glDebugMessageCallback(NULL, NULL);
}
dumpParameters(json, context);
// Use our own debug-message callback.
if (context.KHR_debug) {
glDebugMessageCallback(debugMessageCallback, NULL);
}
dumpShadersUniforms(json, context);
dumpTextures(json, context);
dumpFramebuffer(json, context);
#ifndef NDEBUG
for (unsigned i = 0; i < NUM_BINDINGS; ++i) {
GLint new_binding = 0;
glGetIntegerv(bindings[i], &new_binding);
if (new_binding != old_bindings[i]) {
std::cerr << "warning: " << enumToString(bindings[i]) << " was clobbered\n";
}
}
#endif
// Restore debug message callback
if (context.KHR_debug) {
glDebugMessageCallback(prevDebugCallbackFunction, prevDebugCallbackUserParam);
}
}
static void APIENTRY video_gl_debug_enable(void) {
GLuint unused = 0;
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
glDebugMessageCallback(video_gl_debug, NULL);
glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, &unused, true);
log_info("Enabled OpenGL debugging");
}
Window::Window()
:
window_handle(nullptr)
{
this->window_handle = glfwCreateWindow(640, 480, "Hello World", nullptr, nullptr);
if (!this->window_handle)
throw "Cannot create window";
glfwSetWindowUserPointer(this->window_handle, this);
glfwMakeContextCurrent(this->window_handle);
GLenum err = glewInit();
if (GLEW_OK != err)
{
std::cerr << glewGetErrorString(err) << std::endl;
throw "Cannot initialize GLEW";
}
std::cout << "OpenGL version supported by this platform: " << glGetString(GL_VERSION) << std::endl;
#ifndef NDEBUG
glEnable(GL_DEBUG_OUTPUT);
glDebugMessageCallback(MessageCallback, nullptr);
#endif
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengles_GLES32_nglDebugMessageCallback(JNIEnv *__env, jclass clazz, jlong callbackAddress, jlong userParamAddress) {
glDebugMessageCallbackPROC glDebugMessageCallback = (glDebugMessageCallbackPROC)tlsGetFunction(318);
intptr_t callback = (intptr_t)callbackAddress;
intptr_t userParam = (intptr_t)userParamAddress;
UNUSED_PARAM(clazz)
glDebugMessageCallback(callback, userParam);
}
static void
realize(GtkWidget *widget, gpointer user_data)
{
gtk_gl_area_make_current(GTK_GL_AREA(widget));
glDebugMessageCallback(debug, NULL);
char *str = pk_io_read_file("data/vs.glsl");
programs[0] = glCreateShaderProgramv(GL_VERTEX_SHADER, 1, &str);
free(str);
str = pk_io_read_file("data/fs.glsl");
programs[1] = glCreateShaderProgramv(GL_FRAGMENT_SHADER, 1, &str);
free(str);
/* set up pipeline for rendering fullscreen quad */
glCreateProgramPipelines(1, &pipeline);
glUseProgramStages(pipeline, GL_VERTEX_SHADER_BIT, programs[0]);
glUseProgramStages(pipeline, GL_FRAGMENT_SHADER_BIT, programs[1]);
glBindProgramPipeline(pipeline);
glCreateVertexArrays(1, &vao);
glBindVertexArray(vao);
}
void enable_debugging()
{
#ifdef WIN32
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
glDebugMessageCallback(static_cast<GLDEBUGPROC>(dbgFunc), nullptr);
#endif
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL43_nglDebugMessageCallback(JNIEnv *__env, jclass clazz, jlong callbackAddress, jlong userParamAddress, jlong __functionAddress) {
GLDEBUGPROC callback = (GLDEBUGPROC)(intptr_t)callbackAddress;
void *userParam = (void *)(intptr_t)userParamAddress;
glDebugMessageCallbackPROC glDebugMessageCallback = (glDebugMessageCallbackPROC)(intptr_t)__functionAddress;
UNUSED_PARAMS(__env, clazz)
glDebugMessageCallback(callback, userParam);
}
void init(Data*data){
if(data->args.size()<2){
std::cerr<<"expected name of video"<<std::endl;
std::exit(0);
}
data->video = std::make_shared<Video>(data->args[1]);
data->window->setSize(data->video->getWidth(),data->video->getHeight());
glEnable(GL_DEBUG_OUTPUT);
glDebugMessageCallback((GLDEBUGPROC)defaultDebugMessage,NULL);
glViewport(0,0,data->video->getWidth(),data->video->getHeight());
data->frame = std::make_shared<TextureObject>();
data->program = std::make_shared<ProgramObject>(createProgram(
compileShader(GL_VERTEX_SHADER ,
"#version 450\n",
loadFile("shaders/video_gray.vp")),
compileShader(GL_FRAGMENT_SHADER,
"#version 450\n",
loadFile("shaders/noiseFunctions.vp"),
loadFile("shaders/gradients.vp"),
loadFile("shaders/video_gray.fp"))));
glGenVertexArrays(1,&data->vao);
glClearColor(0,0,0,1);
}
/**
* Initialize the renderer
* @param width Width of the window
* @param height Height of the window
* @return True if the renderer successfully init
*/
bool Renderer::Init(unsigned int pWidth, unsigned int pHeight, UiFunction* pUiFunctionPtr)
{
_uiFunctionPtr = pUiFunctionPtr;
_width = pWidth;
_height = pHeight;
glbinding::Binding::initialize();
//Get context info
Log("GL Info : ");
Log(ToString(glGetString(GL_VENDOR)));
Log(ToString(glGetString(GL_RENDERER)));
Log(ToString(glGetString(GL_VERSION)));
Log(ToString(glGetString(GL_SHADING_LANGUAGE_VERSION)));
debugProc = GLDEBUGPROC(&DebugProc);
glDebugMessageCallback(debugProc, nullptr);
glCullFace(GL_BACK);
glFrontFace(GL_CCW);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glClearColor(0, 0, 0, 1);
glClearDepthf(1.0);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS);
glGenVertexArrays(1, &_baseVAO);
SetupPrograms();
SetupBuffers();
///TODO : Check for ATI memory info
std::set<GLextension> extensions = ContextInfo::extensions();
if (extensions.find(GLextension::GL_NVX_gpu_memory_info) != extensions.end())
{
GLint memory = 0;
glGetIntegerv(GL_GPU_MEMORY_INFO_DEDICATED_VIDMEM_NVX, &memory);
Log("Dedicated video memory, total size(in kb) of the GPU memory : " + ToString(memory));
glGetIntegerv(GL_GPU_MEMORY_INFO_TOTAL_AVAILABLE_MEMORY_NVX, &memory);
Log("Total available memory, total size(in Kb) of the memory available for allocations : " + ToString(memory));
glGetIntegerv(GL_GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX, &memory);
Log("Current available dedicated video memory(in kb), currently unused GPU memory : " + ToString(memory));
glGetIntegerv(GL_GPU_MEMORY_INFO_EVICTION_COUNT_NVX, &memory);
Log("Count of total evictions seen by system : " + ToString(memory));
glGetIntegerv(GL_GPU_MEMORY_INFO_EVICTED_MEMORY_NVX, &memory);
Log("Size of total video memory evicted(in kb) : " + ToString(memory));
}
CheckGLError();
_uiPtr = nullptr;
_menuPtr = nullptr;
return true;
}
// Debug context logger registration
void registerGlDebugLogger(unsigned int logLevel) {
glDebugLogLevel = logLevel;
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
glDebugMessageControl = (PFNGLDEBUGMESSAGECONTROLARBPROC) wglGetProcAddress("glDebugMessageControlARB");
glDebugMessageCallback = (PFNGLDEBUGMESSAGECALLBACKARBPROC) wglGetProcAddress("glDebugMessageCallbackARB");
glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, NULL, GL_TRUE);
glDebugMessageCallback(&debugCallback, NULL);
}
void RegisterErrorCallback()
{
glDebugMessageCallback(OpenGLErrorCallback, nullptr);
glDebugMessageControl(
GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, nullptr, GL_TRUE);
glEnable(GL_DEBUG_OUTPUT);
}
void GlfwApp::onCreate() {
windowAspect = glm::aspect(windowSize);
windowAspectInverse = 1.0f / windowAspect;
glfwSetWindowUserPointer(window, this);
glfwSetKeyCallback(window, glfwKeyCallback);
glfwSetMouseButtonCallback(window, glfwMouseButtonCallback);
glfwMakeContextCurrent(window);
glfwSwapInterval(1);
// Initialize the OpenGL bindings
// For some reason we have to set this experminetal flag to properly
// init GLEW if we use a core context.
glewExperimental = GL_TRUE;
if (0 != glewInit()) {
FAIL("Failed to initialize GL3W");
}
glGetError();
#ifdef RIFT_DEBUG
GL_CHECK_ERROR;
glEnable (GL_DEBUG_OUTPUT_SYNCHRONOUS);
GL_CHECK_ERROR;
GLuint unusedIds = 0;
if (glDebugMessageCallback) {
glDebugMessageCallback(debugCallback, this);
GL_CHECK_ERROR;
glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE,
0, &unusedIds, true);
GL_CHECK_ERROR;
} else if (glDebugMessageCallbackARB) {
glDebugMessageCallbackARB(debugCallback, this);
GL_CHECK_ERROR;
glDebugMessageControlARB(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE,
0, &unusedIds, true);
GL_CHECK_ERROR;
}
#endif
GL_CHECK_ERROR;
/*
if (glNamedStringARB) {
for (int i = 0;
Resources::LIB_SHADERS[i] != Resource::NO_SHADER; ++i) {
std::string shaderFile = getShaderPath(
Resources::LIB_SHADERS[i]);
std::string shaderSrc = Files::read(shaderFile);
size_t lastSlash = shaderFile.rfind('/');
std::string name = shaderFile.substr(lastSlash);
glNamedStringARB(GL_SHADER_INCLUDE_ARB,
name.length(), name.c_str(),
shaderSrc.length(), shaderSrc.c_str());
GL_CHECK_ERROR;
}
}
*/
compileAllShaders(Resources::VERTEX_SHADERS, GL_VERTEX_SHADER);
compileAllShaders(Resources::FRAGMENT_SHADERS, GL_FRAGMENT_SHADER);
}
/*--------------------------------GLFW3 and GLEW------------------------------*/
bool start_gl () {
gl_log ("starting GLFW %s\n", glfwGetVersionString ());
glfwSetErrorCallback (glfw_error_callback);
if (!glfwInit ()) {
fprintf (stderr, "ERROR: could not start GLFW3\n");
return false;
}
// uncomment these lines if on Apple OS X
glfwWindowHint (GLFW_CONTEXT_VERSION_MAJOR, 4);
glfwWindowHint (GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint (GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
glfwWindowHint (GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
// glfwWindowHint (GLFW_SAMPLES, 32);
/*GLFWmonitor* mon = glfwGetPrimaryMonitor ();
const GLFWvidmode* vmode = glfwGetVideoMode (mon);
g_window = glfwCreateWindow (
vmode->width, vmode->height, "Extended GL Init", mon, NULL
);*/
g_window = glfwCreateWindow (
g_gl_width, g_gl_height, "Extended Init.", NULL, NULL
);
if (!g_window) {
fprintf (stderr, "ERROR: could not open window with GLFW3\n");
glfwTerminate();
return false;
}
glfwSetWindowSizeCallback (g_window, glfw_window_size_callback);
glfwMakeContextCurrent (g_window);
// start GLEW extension handler
glewExperimental = GL_TRUE;
glewInit ();
if (GLEW_KHR_debug) {
int param = -1;
printf ("KHR_debug extension found\n");
glDebugMessageCallback ((GLDEBUGPROC)debug_gl_callback, ¶m);
glEnable (GL_DEBUG_OUTPUT_SYNCHRONOUS);
printf ("debug callback engaged\n");
} else {
printf ("KHR_debug extension NOT found\n");
}
// get version info
const GLubyte* renderer = glGetString (GL_RENDERER); // get renderer string
const GLubyte* version = glGetString (GL_VERSION); // version as a string
printf ("Renderer: %s\n", renderer);
printf ("OpenGL version supported %s\n", version);
gl_log ("renderer: %s\nversion: %s\n", renderer, version);
//vysnch
// glfwSwapInterval (1);
return true;
}
// --------------------------------------------------------------------------------------------------------------------
bool GfxApiOpenGLBase::Init(const std::string& _title, int _x, int _y, int _width, int _height)
{
#if defined(_DEBUG)
//glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, 1);
#endif
mWnd = CreateGLWindow(_title.c_str(), _x, _y, _width, _height);
if (!mWnd) {
console::warn("Unable to create SDL Window, which is required for GL.");
return false;
}
if (!GfxBaseApi::Init(_title, _x, _y, _width, _height)) {
return false;
}
glfwMakeContextCurrent(mWnd);
if (g_bInitOpenGL)
{
g_bInitOpenGL = false;
GLenum err = glewInit();
if (GLEW_OK != err)
{
console::error("Unable to initialize GLEW; err: %s -- required -- so exiting.", glewGetErrorString(err));
return false;
}
}
console::log("GL created successfully! Info follows.");
console::log("Vendor: %s", glGetString(GL_VENDOR));
console::log("Renderer: %s", glGetString(GL_RENDERER));
console::log("Version: %s", glGetString(GL_VERSION));
console::log("Shading Language Version: %s", glGetString(GL_SHADING_LANGUAGE_VERSION));
glfwSwapInterval(0);
// Default GL State
glCullFace(GL_FRONT);
glEnable(GL_CULL_FACE);
glDisable(GL_SCISSOR_TEST);
glEnable(GL_DEPTH_TEST);
glDepthMask(1);
glDepthFunc(GL_LESS);
glDisable(GL_BLEND);
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
#if defined(_DEBUG)
if (glDebugMessageControl != NULL && glDebugMessageCallback != NULL) {
glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, NULL, GL_TRUE);
// glDebugMessageControl(GL_DEBUG_SOURCE_API, GL_DEBUG_TYPE_OTHER, GL_DEBUG_SEVERITY_LOW, 0, nullptr, GL_FALSE);
glDebugMessageCallback(ErrorCallback, nullptr);
glEnable(GL_DEBUG_OUTPUT);
}
#endif
return true;
}
void initializeGL() {
glDebugMessageCallback(GLUtils::debugCallback, NULL);
glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, NULL, GL_TRUE);
glDebugMessageInsert(GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_MARKER, 0,
GL_DEBUG_SEVERITY_NOTIFICATION, -1 , "Start debugging");
glClearColor(0.5f,0.5f,0.5f,1.0f);
scene->initScene();
}
void gl_log_enable() {
#if !defined(USING_GLES2)
#if 0
glEnable(DEBUG_OUTPUT_SYNCHRONOUS_ARB); // TODO: Look into disabling, for more perf
glDebugMessageCallback(&log_callback, 0);
glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, 0, GL_TRUE);
#endif
#endif
}
void set_debug_log_callback(const std::function<void(const debug_log&)>& callback, void* user_data)
{
std::function<void(GLenum, GLenum, GLuint, GLenum, GLsizei, const char*, const void*)> function =
[&](GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const char* message, const void* data)
{
callback(debug_log({source, type, id, severity, std::string(message), data}));
};
glDebugMessageCallback((GLDEBUGPROC)function.target<void(GLenum, GLenum, GLuint, GLenum, GLsizei, const char*, const void*)>(), user_data);
}
void DebugImplementation_DebugKHR::registerCallback()
{
if (m_isRegistered)
return;
glDebugMessageCallback(reinterpret_cast<GLDEBUGPROC>(debugMessageCallback), reinterpret_cast<void*>(this));
m_isRegistered = true;
}
void api::setup_debugging( void )
{
#ifndef __APPLE__
GLint flags;
glGetIntegerv( GL_CONTEXT_FLAGS, &flags );
if ( flags & GL_CONTEXT_FLAG_DEBUG_BIT)
glDebugMessageCallback( &gldebugging, nullptr );
#endif
}
void Window::initializeGL() {
if (!glfwInit()) {
std::cout << "Failed to initialize GLFW." << std::endl;
return;
}
glfwWindowHint(GLFW_SAMPLES, 4);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, FLEXT_MAJOR_VERSION);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, FLEXT_MINOR_VERSION);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
// Create window from parameters
std::cout << "Creating GLFW window for OpenGL version " << FLEXT_MAJOR_VERSION
<< ", " << FLEXT_MINOR_VERSION << std::endl;
auto window = glfwCreateWindow(1024, 768, "JungleIN", NULL, NULL);
if (window == nullptr) {
std::cout << "Failed to create GLFW window." << std::endl;
glfwTerminate();
return;
}
glfwMakeContextCurrent(window);
glfwSetInputMode(window, GLFW_STICKY_KEYS, GL_FALSE);
// Load OpenGL extensions
if (flextInit() != GL_TRUE) {
glfwTerminate();
std::cout << "Failed to initialize flextGL." << std::endl;
return;
}
PRINT_GL_ERROR();
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
PRINT_GL_ERROR();
glDebugMessageCallback(&errorCallback, nullptr);
PRINT_GL_ERROR();
Utils::window = window;
glfwShowWindow(window);
//
// if (!strstr((char *)glGetString(GL_EXTENSIONS),
// "GL_EXT_texture_filter_anisotropic")) {
Utils::USE_ANISO = false;
Utils::MAX_ANISO = 0x0000;
// } else {
// Utils::USE_ANISO = true;
// float maxAniso;
// glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &maxAniso);
// Utils::MAX_ANISO = maxAniso;
// }
initializeObjects();
PRINT_GL_ERROR();
}
graphics_system::graphics_system(core::engine& engine)
: engine_{engine}, window_{nullptr, [](SDL_Window*){}}, context_{nullptr}, width_{800}, height_{600},
fullscreen_{false}, clear_color_{glm::vec4{0.4f, 0.6f, 0.9f, 1.f}},
shader_manager_{std::make_unique<graphics::shader_manager>(engine_)},
texture_manager_{std::make_unique<graphics::texture_manager>(engine_)} {
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS,1);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES,8);
auto window_mask = SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN | (fullscreen_ ? SDL_WINDOW_FULLSCREEN_DESKTOP : 0);
name_ = "Behaviour Trees";
window_ = std::unique_ptr<SDL_Window, void(*)(SDL_Window*)>(
SDL_CreateWindow(name_.c_str(), SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, width_, height_, window_mask),
SDL_DestroyWindow);
if (!window_) {
throw std::runtime_error{"could not create window"};
}
auto width = 0;
auto height = 0;
SDL_GetWindowSize(window_.get(), &width, &height);
width_ = width;
height_ = height;
try {
context_ = SDL_GL_CreateContext(window_.get());
} catch (const std::runtime_error& ex) {
throw std::runtime_error{std::string{"could not create opengl context with version 4.3. "} + ex.what()};
}
SDL_GL_SetSwapInterval(1);
glewExperimental = GL_TRUE;
if (glewInit() != GLEW_OK) {
throw std::runtime_error("requested opengl 4.3 features are not available");
}
utils::log << "OpenGL version " << std::string{reinterpret_cast<const char*>(glGetString(GL_VERSION))} << std::endl;
if(GLEW_KHR_debug){
glDebugMessageCallback(
+[](GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar* message, const void*) {
std::cerr << std::string(message,length) << " (source: " << source << ", type: " <<type<< ", id: "
<< id <<", severity: " << severity << ")" <<std::endl;
}, nullptr);
}
else{
utils::log(utils::LOG_WARNING) << "no opengL debug log available." << std::endl;
}
clear_color(clear_color_);
}
bool initDebug()
{
bool Validated(true);
glEnable(GL_DEBUG_OUTPUT);
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, NULL, GL_TRUE);
glDebugMessageCallback(&glf::debugOutput, NULL);
return Validated;
}
void InitDebugProc()
{
GLint flag(0);
glGetIntegerv(GL_CONTEXT_FLAGS,&flag);
if (!(flag&GL_CONTEXT_FLAG_DEBUG_BIT))
{
std::cerr<<"InitDebugProc requires a debug context!\n";
return;
}
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
glDebugMessageCallback(CallBack,nullptr);
}
static void gl_enable_debug()
{
if (GLAD_GL_VERSION_4_3) {
glDebugMessageCallback(gl_debug_proc, NULL);
gl_enable(GL_DEBUG_OUTPUT);
} else if (GLAD_GL_ARB_debug_output) {
glDebugMessageCallbackARB(gl_debug_proc, NULL);
} else {
blog(LOG_DEBUG, "Failed to set GL debug callback as it is "
"not supported.");
}
}
static void gl_enable_debug()
{
/* Perhaps we should create GLEW contexts? */
if (ogl_IsVersionGEQ(4, 3)) {
glDebugMessageCallback(gl_debug_proc, NULL);
gl_enable(GL_DEBUG_OUTPUT);
} else if (ogl_ext_ARB_debug_output) {
glDebugMessageCallbackARB(gl_debug_proc, NULL);
} else {
blog(LOG_DEBUG, "Failed to set GL debug callback as it is "
"not supported.");
}
}
void nsfw::Window::init(unsigned width, unsigned height)
{
//TODO_D("Should create and set an active windowing context. ONLY GLFW! No GL!");
//set width and height for later use
this->width = width;
this->height = height;
//Initialize glfw
glfwInit();
//tell glfw to use debug stuff
glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, true);
//create title of the window
const char* title = "nsfwgl Test";
//create the window
window = glfwCreateWindow(width, height, title, nullptr, nullptr);
//check to make sure window is created and functioning
//if window isn't creating properly then let the console know
if (window == nullptr)
std::cout << "\n\n\n\n ERROR: WINDOW CREATION UNSUCCESSFUL \n\n\n\n" << std::endl;
//set window to current context
glfwMakeContextCurrent(window);
//load functions
if (ogl_LoadFunctions() == ogl_LOAD_FAILED)
{
glfwDestroyWindow(window);
glfwTerminate();
}
//this is for glfw debug
#ifdef _DEBUG
if (glDebugMessageCallback)
{
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
glDebugMessageCallback(oglErrorDefaultCallback, nullptr);
GLuint unusedIDs = 0;
glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, &unusedIDs, true);
}
else
{
std::cerr << "Failed to subscribe to glDebugMessageCallback." << std::endl;
}
#endif
}
//--------------------------------------------------------------
void ofxOpenVR::exit()
{
if (vr::VRCompositor()->IsMirrorWindowVisible()) {
hideMirrorWindow();
}
if (_pHMD)
{
vr::VR_Shutdown();
_pHMD = NULL;
}
for (std::vector< CGLRenderModel * >::iterator i = _vecRenderModels.begin(); i != _vecRenderModels.end(); i++)
{
delete (*i);
}
_vecRenderModels.clear();
if (_bIsGLInit)
{
glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, nullptr, GL_FALSE);
glDebugMessageCallback(nullptr, nullptr);
glDeleteBuffers(1, &_glIDVertBuffer);
glDeleteBuffers(1, &_glIDIndexBuffer);
glDeleteRenderbuffers(1, &leftEyeDesc._nDepthBufferId);
glDeleteTextures(1, &leftEyeDesc._nRenderTextureId);
glDeleteFramebuffers(1, &leftEyeDesc._nRenderFramebufferId);
glDeleteTextures(1, &leftEyeDesc._nResolveTextureId);
glDeleteFramebuffers(1, &leftEyeDesc._nResolveFramebufferId);
glDeleteRenderbuffers(1, &rightEyeDesc._nDepthBufferId);
glDeleteTextures(1, &rightEyeDesc._nRenderTextureId);
glDeleteFramebuffers(1, &rightEyeDesc._nRenderFramebufferId);
glDeleteTextures(1, &rightEyeDesc._nResolveTextureId);
glDeleteFramebuffers(1, &rightEyeDesc._nResolveFramebufferId);
if (_unLensVAO != 0)
{
glDeleteVertexArrays(1, &_unLensVAO);
}
_lensShader.unload();
_controllersTransformShader.unload();
_renderModelsShader.unload();
}
}
void BaseApplication::InitDependency(vec3 a_vCamPos)
{
if (ogl_LoadFunctions() == ogl_LOAD_FAILED)
{
glfwTerminate();
printf("<ERROR>: ogl_LoadFunctions has fail initialization. \n");
exit(EXIT_FAILURE);
}
else
{
printf("--------------------------------------------------------------------------------");
printf("-- OGL LOADED SUCCESSFULLY. \n");
if (this->m_oApp->APPINFO.Flags.m_uiDebug)
{
glDebugMessageCallback(debug_callback, NULL);
if (glDebugMessageCallback != NULL)
{
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
}
glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, NULL, GL_TRUE);
glDebugMessageInsert(GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_MARKER, 0, GL_DEBUG_SEVERITY_NOTIFICATION, -1, "START DEBUGGING\n");
}
//this->DATA.m_oTweeking = new Bar();
//this->DATA.m_oTweeking->InitTweek();
printf("-- GL DEBUG MESSAGE ENABLED. \n");
glfwSetCharModsCallback(this->m_oApp->DATA.m_oWin, on_char_callback);
printf("-- CHAR_CALLBACK ENABLED. \n");
glfwSetKeyCallback(this->m_oApp->DATA.m_oWin, key_callback);
printf("-- KEY_CALLBACK ENABLED. \n");
glfwSetMouseButtonCallback(this->m_oApp->DATA.m_oWin, mouse_button_callback);
glfwSetCursorPosCallback(this->m_oApp->DATA.m_oWin, mouse_callback);
glfwSetCursorPos(this->m_oApp->DATA.m_oWin, (double)this->m_oApp->APPINFO.m_viWinSize.x / 2.0, (double)this->m_oApp->APPINFO.m_viWinSize.y / 2.0);
printf("-- MOUSE_CALLBACK ENABLED. \n");
glfwSetScrollCallback(this->m_oApp->DATA.m_oWin, scroll_callback);
printf("-- SCROLL_CALLBACK ENABLED. \n");
glfwSetFramebufferSizeCallback(this->m_oApp->DATA.m_oWin, framebuffer_size_callback);
printf("-- WINDOW_BUFFER_CALLBACK ENABLED. \n");
//
this->m_oApp->DATA.m_oCurrCamera = new Camera(vec2(this->m_oApp->APPINFO.m_viWinSize.x,
this->m_oApp->APPINFO.m_viWinSize.y));
this->m_oApp->DATA.m_oCurrCamera->BuildCamera(a_vCamPos);
this->m_oApp->DATA.m_oTotalCameras[0] = this->m_oApp->DATA.m_oCurrCamera;
printf("-- CAMERA BUILT SUCCESSFULLY. \n");
//Note: I should consider moving this function call into the appropriate application.
//m_oTweek.InitTweek();
printf("--------------------------------------------------------------------------------");
}
}
bool Renderer_OpenGL::Initialize(const RenderInitParameter& init_param)
{
MLOG("## Initialize OpenGL\n");
// initialize parent member variable
Renderer::Initialize(init_param);
// create OpenGL context
#if MG_PLATFORM_WINDOWS
bool result = Initialize_Windows(init_param);
if (!result)
{
MASSERT_MSG(0, "Failed initialize opengl context");
return false;
}
#else
#endif
// retrieve hardware and opengl information
const GLubyte *renderer = glGetString(GL_RENDERER);
const GLubyte *vendor = glGetString(GL_VENDOR);
const GLubyte *version = glGetString(GL_VERSION);
const GLubyte *glslVersion = glGetString(GL_SHADING_LANGUAGE_VERSION);
GLint major, minor;
glGetIntegerv(GL_MAJOR_VERSION, &major);
glGetIntegerv(GL_MINOR_VERSION, &minor);
MLOG("## GL Vendor : %s\n", vendor);
MLOG("## GL Renderer : %s\n", renderer);
MLOG("## GL Version (string) : %s\n", version);
MLOG("## GL Version (integer) : %d.%d\n", major, minor);
MLOG("## GLSL Version : %s\n", glslVersion);
#if MUGGLE_DEBUG
// if gl version >= 4.3, enable debug callback
GLint gl_version = major * 100 + minor;
if (gl_version >= 403)
{
glEnable(GL_DEBUG_OUTPUT);
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
glDebugMessageCallback(GLDebugCallback, nullptr);
glDebugMessageControl(
GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, NULL, true
);
}
#endif
return true;
}
