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());
}
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");
}
void Engine::initGLUT() {
int argc = 1;
char *argv[] = {"Bin", NULL};
glutInit(&argc, argv);
if(context->core) {
glutInitContextVersion(context->majorVersion, context->minorVersion);
glutInitContextProfile(GLUT_CORE_PROFILE);
} else {
glutInitContextProfile(GLUT_COMPATIBILITY_PROFILE);
}
glutInitDisplayMode(framebuffer->flags);
glutInitWindowPosition(window->positionX, window->positionY);
glutInitWindowSize(window->width, window->height);
// in case GL_DEBUG_OUTPUT doesn't work
// glutInitContextFlags(GLUT_DEBUG);
glutCreateWindow(window->name.c_str());
std::cout << "GLUT initialized\n";
glEnable(GL_DEBUG_OUTPUT);
glutSetWindowData(static_cast<void *>(this));
glutIdleFunc(idleCallback);
glutDisplayFunc(displayCallback);
glutReshapeFunc(reshapeCallback);
glutCloseFunc(closeCallback);
glutKeyboardFunc(handleKeyboardCallback);
glutKeyboardUpFunc(handleKeyboardUpCallback);
glutSpecialFunc(handleKeyboardSpecialCallback);
glutSpecialUpFunc(handleKeyboardSpecialUpCallback);
glutMotionFunc(handleMouseMovement);
glutPassiveMotionFunc(handleMouseMovement);
initGLEW();
glDebugMessageCallback(DebugOutput::printDebugOutput, NULL);
//GLenum severity = GL_DEBUG_SEVERITY_LOW | GL_DEBUG_SEVERITY_MEDIUM | GL_DEBUG_SEVERITY_HIGH | GL_DEBUG_SEVERITY_NOTIFICATION;
glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, NULL, GL_TRUE);
glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_NOTIFICATION, 0, NULL, GL_FALSE);
glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_GLUTMAINLOOP_RETURNS);
std::cout << "Info | Vendor: " << glGetString(GL_VENDOR) << " | Renderer: " << glGetString(GL_RENDERER) << " | OpenGl version: " << glGetString(GL_VERSION) << std::endl;
}
void RegisterErrorCallback()
{
glDebugMessageCallback(OpenGLErrorCallback, nullptr);
glDebugMessageControl(
GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, nullptr, GL_TRUE);
glEnable(GL_DEBUG_OUTPUT);
}
// 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);
}
// --------------------------------------------------------------------------------------------------------------------
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 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);
}
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 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();
}
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 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
}
/**
* Configures GL_ARB_debug_output to give us immediate callbacks when
* GL errors occur, so that we can log them.
*/
static void
glamor_setup_debug_output(ScreenPtr screen)
{
if (!epoxy_has_gl_extension("GL_ARB_debug_output"))
return;
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
/* Disable debugging messages other than GL API errors */
glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, NULL,
GL_FALSE);
glDebugMessageControl(GL_DEBUG_SOURCE_API,
GL_DEBUG_TYPE_ERROR,
GL_DONT_CARE,
0, NULL, GL_TRUE);
glDebugMessageCallback(glamor_debug_output_callback,
screen);
/* If KHR_debug is present, all debug output is disabled by
* default on non-debug contexts.
*/
if (epoxy_has_gl_extension("GL_KHR_debug"))
glEnable(GL_DEBUG_OUTPUT);
}
void initGL()
{
if (is_gl_init)
return;
is_gl_init = true;
// For Mesa extension reporting
#if !defined(USE_GLES2)
#ifndef WIN32
glewExperimental = GL_TRUE;
#endif
GLenum err = glewInit();
if (err == GLEW_ERROR_NO_GLX_DISPLAY)
{
Log::info("GLEW", "Glew couldn't open glx display.");
}
else if (err != GLEW_OK)
{
Log::fatal("GLEW", "Glew initialization failed with error %s", glewGetErrorString(err));
}
#else
#ifdef ARB_DEBUG_OUTPUT
glDebugMessageCallbackARB = (PFNGLDEBUGMESSAGECALLBACKKHRPROC)eglGetProcAddress("glDebugMessageCallbackKHR");
#endif
#endif
#ifdef ARB_DEBUG_OUTPUT
if (glDebugMessageCallbackARB)
glDebugMessageCallbackARB((GLDEBUGPROCARB)debugCallback, NULL);
#endif
#ifndef ANDROID
if (SP::sp_apitrace && hasGLExtension("GL_KHR_debug"))
{
#ifdef USE_GLES2
glDebugMessageControl = (void(GL_APIENTRY*)(GLenum, GLenum, GLenum, GLsizei,
const GLuint*, GLboolean))eglGetProcAddress("glDebugMessageControlKHR");
glDebugMessageInsert = (void(GL_APIENTRY*)(GLenum, GLenum, GLuint, GLenum,
GLsizei, const char*))eglGetProcAddress("glDebugMessageInsertKHR");
assert(glDebugMessageControl && glDebugMessageInsert);
#endif
glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, NULL, GL_TRUE);
}
else
{
SP::sp_apitrace = false;
}
#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;
}
bool Application::InitWindowAndOpenGL(const std::string & title)
{
int32_t width = GetContext().GetApplicationSettingsManager()->GetGroup("video").GetVar("window_width").ValueI(),
height = GetContext().GetApplicationSettingsManager()->GetGroup("video").GetVar("window_height").ValueI();
bool windowed = GetContext().GetApplicationSettingsManager()->GetGroup("video").GetVar("windowed").ValueB();
bool fullscreen = GetContext().GetApplicationSettingsManager()->GetGroup("video").GetVar("fullscreen").ValueB();
if (!GetContext().GetWindow()->Init(title, width, height, fullscreen, windowed))
{
GetContext().GetLogger()->log(LOG_LOG, "Could not initialize ApplicationWindow with dimensions %ix%i", width, height);
delete GetContext().p_window;
GetContext().p_window = nullptr;
return false;
}
GetContext().GetWindow()->SigWindowClosed().connect(sigc::mem_fun(this, &Application::OnWindowClose));
///REFACTOR: Opengl initialization should have it's own place, worst case: extract method.
GetContext().p_openGLExtensionLoader = new OpenGLExtensionLoader();
if (!GetContext().GetOpenGLExtensionLoader()->load_extensions())
{
delete GetContext().p_window;
return false;
}
if (0) {
std::cout << "Register OpenGL debug callback " << std::endl;
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
glDebugMessageCallback(openglCallbackFunction, nullptr);
GLuint unusedIds = 0;
glDebugMessageControl(GL_DONT_CARE,
GL_DONT_CARE,
GL_DONT_CARE,
0,
&unusedIds,
true);
}
else
std::cout << "glDebugMessageCallback not available" << std::endl;
GetContext().GetLogger()->log(LOG_CRITICAL, "Shading language: %s", (const char*)glGetString(GL_SHADING_LANGUAGE_VERSION));
return true;
}
int main(int argc, char* argv[])
{
const char* VERTEX_SHADER_SOURCE = ".\\..\\..\\..\\..\\source\\task4\\vertexshader.glsl";
const char* FRAGMENT_SHADER_SOURCE = ".\\..\\..\\..\\..\\source\\task4\\fragmentshader.glsl";
//const char* VERTEX_SHADER_SOURCE = "./source/task3/vertexshader.glsl";
//const char* FRAGMENT_SHADER_SOURCE = "./source/task3/fragmentshader.glsl";
try
{
GL::platform::Window window("Assignment 4 — Complex 3D object", 800, 600, 24, 8, false, 4, 3);
Renderer renderer(window);
glDebugMessageCallback(OpenGLDebugOutputCallback, nullptr);
glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, nullptr, GL_TRUE);
renderer.resize(800, 600);
InputHandler input_handler;
renderer.createShader(VERTEX_SHADER_SOURCE, FRAGMENT_SHADER_SOURCE);
renderer.createStructure();
window.attach(static_cast<GL::platform::KeyboardInputHandler*>(&input_handler));
window.attach(static_cast<GL::platform::MouseInputHandler*>(&input_handler));
GL::platform::run(renderer);
renderer.destroyStructure();
renderer.destroyShader();
}
catch (std::exception& e)
{
std::cout << "error: " << e.what() << std::endl;
getchar();
return -1;
}
catch (...)
{
std::cout << "unknown exception" << std::endl;
getchar();
return -128;
}
return 0;
}
void nsfw::Window::init(unsigned width, unsigned height)
{
if (glfwInit() == false) {
return;
}
glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, true);
window = glfwCreateWindow(width, height, "nsfwGL", nullptr, nullptr);
this->width = width;
this->height = height;
if (window == nullptr) {
glfwTerminate();
}
glfwMakeContextCurrent(window);
if (ogl_LoadFunctions() == ogl_LOAD_FAILED) {
glfwDestroyWindow(window);
glfwTerminate();
return;
}
#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
//TODO_D("Should create and set an active windowing context. ONLY GLFW! No GL!");
}
void initGLDebug(const OpenGL::Format &fmt, GLDEBUGPROC callback, void* userparam)
{
assert( fmt.versionMajor >= 3 );
if ( (fmt.versionMajor > 4) || (fmt.versionMajor == 4 && fmt.versionMinor >= 3) )
{
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
glDebugMessageCallback(callback, userparam);
glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, nullptr, true);
}
else if ( glewIsSupported("GL_ARB_debug_output") )
{
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB);
glDebugMessageCallbackARB(callback, userparam);
glDebugMessageControlARB(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, nullptr, true);
}
else
{
// Log(LogType::Warning, LogSource::Engine, LogSeverity::Medium, "OpenGL API debug output is not supported on this system.");
}
}
void nsfw::Window::init(unsigned a_width, unsigned a_height)
{
//TODO_D("Should create and set an active windowing context. ONLY GLFW! No GL!");
// initialize
glfwInit();
width = a_width;
height = a_height;
glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, true);
glfwWindowHint(GLFW_SAMPLES, 4);
window = glfwCreateWindow(width, height, "NSFWGL", NULL, NULL);
glfwMakeContextCurrent(window);
if (ogl_LoadFunctions() == ogl_LOAD_FAILED)
{
glfwDestroyWindow(window);
glfwTerminate();
}
// TODO: only do this on ogl4.3+
#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
auto major = ogl_GetMajorVersion();
auto minor = ogl_GetMinorVersion();
printf("GL: %i.%i\n", major, minor);
}
void Window::makeContextCurrent() {
glfwMakeContextCurrent(m_handle);
WindowData *wd = getWindowData(m_handle);
// init glaer
if (!wd->init_done) {
gecom::log("Window") << "GLAER initializing...";
//GLenum t_err = glGetError();
//gecom::log("Window") << "GLEW t_err: " << t_err;
if (!glaerInitCurrentContext()) {
gecom::log("Window").error() << "GLAER initialization failed:";
glfwTerminate();
std::abort();
}
// clear any GL errors from init
GLenum gl_err = glGetError();
while (gl_err) {
gecom::log("Window") << "GLAER initialization left GL error " << gl_err;
gl_err = glGetError();
}
//gecom::log("Window") << "GL Error: " << gluErrorString(gl_err);
gecom::log("Window") << "GL version string: " << glGetString(GL_VERSION);
gecom::log("Window").information(0) << "GLAER initialized";
wd->init_done = true;
// enable GL_ARB_debug_output if available
if (glfwExtensionSupported("GL_ARB_debug_output")) {
// this allows the error location to be determined from a stacktrace
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
// set the callback
glDebugMessageCallback(callbackDebugGL, this);
glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, nullptr, true);
log("Window") << "GL debug callback installed";
} else {
log("Window") << "GL_ARB_debug_output not available";
}
}
}
void get_error_log() {
glutInitContextFlags(GLUT_FORWARD_COMPATIBLE
#if _DEBUG
| GLUT_DEBUG
#endif
);
#if _DEBUG
if (glDebugMessageCallback) {
cout << "Register OpenGL debug callback " << endl;
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
glDebugMessageCallback(openglCallbackFunction, nullptr);
GLuint unusedIds = 0;
glDebugMessageControl(GL_DONT_CARE,
GL_DONT_CARE,
GL_DONT_CARE,
0,
&unusedIds,
true);
}
else
cout << "glDebugMessageCallback not available" << endl;
#endif
}
bool InitScene()
{
SetWindowText(hwnd, TITLE);
Quadron::qGLExtensions::QueryFeatures(hdc);
if( !Quadron::qGLExtensions::ARB_shader_storage_buffer_object )
return false;
#ifdef _DEBUG
if( Quadron::qGLExtensions::ARB_debug_output )
{
glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, 0, GL_TRUE);
glDebugMessageCallback(ReportGLError, 0);
}
#endif
glClearColor(0.0f, 0.125f, 0.3f, 1.0f);
//glClearColor(1, 1, 1, 1);
glClearDepth(1.0);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glDepthFunc(GL_LEQUAL);
glEnable(GL_DEPTH_TEST);
screenquad = new OpenGLScreenQuad();
// load objects
if( !GLCreateMeshFromQM("../media/meshes/cube.qm", &box) )
{
MYERROR("Could not load box");
return false;
}
if( !GLCreateMeshFromQM("../media/meshes/dragon.qm", &dragon) )
{
MYERROR("Could not load dragon");
return false;
}
if( !GLCreateMeshFromQM("../media/meshes/happy1.qm", &buddha) )
{
MYERROR("Could not load buddha");
return false;
}
// create texture
glGenTextures(1, &white);
glBindTexture(GL_TEXTURE_2D, white);
{
unsigned int wondercolor = 0xffffffff;
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, &wondercolor);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
}
// create buffers
size_t headsize = 16; // start, count, pad, pad
size_t nodesize = 16; // color, depth, next, pad
size_t numlists = screenwidth * screenheight;
glGenBuffers(1, &headbuffer);
glGenBuffers(1, &nodebuffer);
glGenBuffers(1, &counterbuffer);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, headbuffer);
glBufferData(GL_SHADER_STORAGE_BUFFER, numlists * headsize, 0, GL_STATIC_DRAW);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, nodebuffer);
glBufferData(GL_SHADER_STORAGE_BUFFER, numlists * 4 * nodesize, 0, GL_STATIC_DRAW); // 120 MB @ 1080p
glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, counterbuffer);
glBufferData(GL_ATOMIC_COUNTER_BUFFER, sizeof(GLuint), 0, GL_DYNAMIC_DRAW);
glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, 0);
// calculate scene bounding box
OpenGLAABox tmpbox;
float world[16];
float tmp[16];
GLMatrixIdentity(world);
for( int i = 0; i < numobjects; ++i )
{
const SceneObject& obj = objects[i];
// scaling * rotation * translation
GLMatrixScaling(tmp, obj.scale[0], obj.scale[1], obj.scale[2]);
GLMatrixRotationAxis(world, obj.angle, 0, 1, 0);
GLMatrixMultiply(world, tmp, world);
GLMatrixTranslation(tmp, obj.position[0], obj.position[1], obj.position[2]);
GLMatrixMultiply(world, world, tmp);
if( obj.type == 0 )
tmpbox = box->GetBoundingBox();
else if( obj.type == 1 )
tmpbox = dragon->GetBoundingBox();
else if( obj.type == 2 )
tmpbox = buddha->GetBoundingBox();
tmpbox.TransformAxisAligned(world);
scenebox.Add(tmpbox.Min);
scenebox.Add(tmpbox.Max);
}
// head pointer initializer
if( !GLCreateEffectFromFile("../media/shadersGL/basic2D.vert", 0, "../media/shadersGL/initheadpointers.frag", &init) )
{
MYERROR("Could not load initializer shader");
return false;
}
// renderer shader
if( !GLCreateEffectFromFile("../media/shadersGL/basic2D.vert", 0, "../media/shadersGL/renderfragments.frag", &render) )
{
MYERROR("Could not load rendering shader");
return false;
}
// fragment collector shader
if( !GLCreateEffectFromFile("../media/shadersGL/collectfragments.vert", 0, "../media/shadersGL/collectfragments.frag", &collect) )
{
MYERROR("Could not load collector shader");
return false;
}
float angles[2] = { 0.25f, -0.7f };
cameraangle = angles;
return true;
}
int main()
{
hmk::Logger::get_instance().initialize("engine.txt");
if (glfwInit() == GL_FALSE)
{
HMK_LOG_ERROR("failed glfwInit")
hmk::Logger::get_instance().shutdown();
return -1;
}
glfwSetErrorCallback(ErrorCallback);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
glfwWindowHint(GLFW_SAMPLES, 8);
GLFWwindow* window = glfwCreateWindow(800, 600, "HMK", nullptr, nullptr);
if (window == nullptr)
{
HMK_LOG_ERROR("failed glfwCreateWindow")
hmk::Logger::get_instance().shutdown();
glfwTerminate();
return -1;
}
glfwSetWindowPos(window, 500, 30);
glfwMakeContextCurrent(window);
if (gl3wInit() == -1) // 0 success
{
HMK_LOG_ERROR("failed gl3wInit")
hmk::Logger::get_instance().shutdown();
glfwTerminate();
return -1;
}
if (!gl3wIsSupported(3, 3))
{
HMK_LOG_ERROR("Upgrade your graphic card!")
hmk::Logger::get_instance().shutdown();
glfwTerminate();
return -1;
}
#if _DEBUG
if (glDebugMessageCallback)
{
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
glDebugMessageCallback(glErrorCallback, nullptr);
GLuint unused = 0;
glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, &unused, true);
}
#endif
ImGui_ImplGlfwGL3_Init(window, false);
Game *game = new Game();
game->initialize();
glfwSetKeyCallback(window, KeyCallback);
glfwSetCursorPosCallback(window, CursorPosCallback);
glfwSetMouseButtonCallback(window, MouseButtonCallback);
glfwSetDropCallback(window, DropCallback);
keyCallback = HMK_CALLBACK_4(Game::key_input, game);
cursorPosCallback = HMK_CALLBACK_2(Game::cursor_pos_input, game);
mouseButtonCallback = HMK_CALLBACK_3(Game::mouse_button_input, game);
dropCallback = HMK_CALLBACK_2(Game::drop_files_callback, game);
double lastTime = glfwGetTime();
glEnable(GL_DEPTH_TEST);
glDepthMask(GL_TRUE);
glDepthFunc(GL_LEQUAL);
glDepthRange(0.0f, 1.0f);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glFrontFace(GL_CW);
glEnable(GL_FRAMEBUFFER_SRGB);
glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS); // https://www.opengl.org/wiki/Cubemap_Texture#Seamless_cubemap
glEnable(GL_MULTISAMPLE);
glClearColor(0.2f, 0.3f, 0.2f, 1.0f);
double fps = 0.0;
double acc = 0.0;
while (!glfwWindowShouldClose(window))
{
glfwPollEvents();
ImGui_ImplGlfwGL3_NewFrame();
double now = glfwGetTime();
double delta = now - lastTime;
lastTime = now;
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
game->update((float)delta);
game->render();
fps++;
acc += delta;
if (acc > 1.0)
{
acc = 0.0;
fps = 0.0;
}
ImGui::Render();
glfwSwapBuffers(window);
}
delete game;
hmk::Logger::get_instance().shutdown();
glfwDestroyWindow(window);
ImGui_ImplGlfwGL3_Shutdown();
glfwTerminate();
return 0;
}
Window::Window(int width, int height, const std::string& title) :
width(width),
height(height),
title(title),
isCloseRequested(false)
{
SDL_Init(SDL_INIT_EVERYTHING);
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE,32);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE,16);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER,1);
// SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
// SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 4);
//SDL_GL_SetAttribute( SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE );
//SDL_GL_SetAttribute( SDL_GL_CONTEXT_MAJOR_VERSION, 4 );
//SDL_GL_SetAttribute( SDL_GL_CONTEXT_MINOR_VERSION, 2 );
bool DebugMode = true;
if(DebugMode)
{
SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_DEBUG_FLAG);
}
//Initialize SDL
SDL_Init(SDL_INIT_EVERYTHING);
SDL_ShowCursor(SDL_FALSE);
if (glDebugMessageCallbackARB != NULL && DebugMode)
{
float i;
glGetFloatv(GL_MAJOR_VERSION,&i);
if(i >= 4.0f)
{
glEnable(GL_DEBUG_OUTPUT);
glDebugMessageCallback(Core::DebugOutput::myCallback, NULL);
glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE,
GL_DONT_CARE, 0, NULL, GL_TRUE);
}
else
{
glEnable(GL_ARB_debug_output);
glDebugMessageCallback(Core::DebugOutput::myCallback, NULL);
glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE,
GL_DONT_CARE, 0, NULL, GL_TRUE);
};
}
window = SDL_CreateWindow(title.c_str(), SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, width, height, SDL_WINDOW_OPENGL);
if (window == nullptr)
{
fatalError("SDL Window could not be created!");
}
glContext = SDL_GL_CreateContext( window);
if (glContext == nullptr)
{
fatalError("SDL_GL context could not be created!");
}
SDL_SetHint(SDL_HINT_RENDER_VSYNC, "1");
SDL_GL_SetSwapInterval(1);
//Apparently this is necessary to build with Xcode
glewExperimental = GL_TRUE;
GLenum res = glewInit();
if(res != GLEW_OK)
{
fprintf(stderr, "Error: '%s'\n", glewGetErrorString(res));
}
SDL_GL_SwapWindow( window);
}
bool InitScene()
{
SetWindowText(hwnd, TITLE);
Quadron::qGLExtensions::QueryFeatures(hdc);
hascompute = (Quadron::qGLExtensions::ARB_compute_shader && Quadron::qGLExtensions::ARB_shader_storage_buffer_object);
#ifdef _DEBUG
if( Quadron::qGLExtensions::ARB_debug_output )
{
glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, 0, GL_TRUE);
glDebugMessageCallback(ReportGLError, 0);
}
#endif
glClearColor(0.0f, 0.125f, 0.3f, 1.0f);
glClearDepth(1.0);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glDepthFunc(GL_LEQUAL);
glEnable(GL_DEPTH_TEST);
// load objects
if( !GLCreateMeshFromQM("../media/meshes/teapot.qm", &teapot) )
{
MYERROR("Could not load teapot");
return false;
}
if( !GLCreateMeshFromQM("../media/meshes/cube.qm", &box) )
{
MYERROR("Could not load box");
return false;
}
// calculate scene bounding box
OpenGLAABox tmpbox;
float world[16];
float tmp[16];
GLMatrixIdentity(world);
for( int i = 0; i < numobjects; ++i )
{
const SceneObject& obj = objects[i];
// scaling * rotation * translation
GLMatrixScaling(tmp, obj.scale[0], obj.scale[1], obj.scale[2]);
GLMatrixRotationAxis(world, obj.angle, 0, 1, 0);
GLMatrixMultiply(world, tmp, world);
GLMatrixTranslation(tmp, obj.position[0], obj.position[1], obj.position[2]);
GLMatrixMultiply(world, world, tmp);
if( obj.type == 0 )
tmpbox = box->GetBoundingBox();
else if( obj.type == 1 )
tmpbox = teapot->GetBoundingBox();
tmpbox.TransformAxisAligned(world);
scenebox.Add(tmpbox.Min);
scenebox.Add(tmpbox.Max);
}
// create render targets
framebuffer = new OpenGLFramebuffer(screenwidth, screenheight);
framebuffer->AttachTexture(GL_COLOR_ATTACHMENT0, GLFMT_A16B16G16R16F);
framebuffer->AttachTexture(GL_DEPTH_ATTACHMENT, GLFMT_D32F);
if( !framebuffer->Validate() )
return false;
shadowmap = new OpenGLFramebuffer(SHADOWMAP_SIZE, SHADOWMAP_SIZE);
shadowmap->AttachTexture(GL_COLOR_ATTACHMENT0, GLFMT_G32R32F, GL_LINEAR);
shadowmap->AttachRenderbuffer(GL_DEPTH_ATTACHMENT, GLFMT_D24S8);
if( !shadowmap->Validate() )
return false;
blurredshadow = new OpenGLFramebuffer(SHADOWMAP_SIZE, SHADOWMAP_SIZE);
blurredshadow->AttachTexture(GL_COLOR_ATTACHMENT0, GLFMT_G32R32F, GL_LINEAR);
if( !blurredshadow->Validate() )
return false;
screenquad = new OpenGLScreenQuad();
// textures
if( !GLCreateTextureFromFile("../media/textures/wood2.jpg", true, &texture1) )
{
MYERROR("Could not load texture");
return false;
}
if( !GLCreateTextureFromFile("../media/textures/marble2.png", true, &texture2) )
{
MYERROR("Could not load texture");
return false;
}
if( !GLCreateTextureFromFile("../media/textures/static_sky.jpg", true, &texture3, GLTEX_FLIPX) )
{
MYERROR("Could not load texture");
return false;
}
// create buffers
workgroupsx = (screenwidth + (screenwidth % 16)) / 16;
workgroupsy = (screenheight + (screenheight % 16)) / 16;
size_t numtiles = workgroupsx * workgroupsy;
size_t headsize = 16; // start, count, pad, pad
size_t nodesize = 16; // light index, next, pad, pad
if( hascompute )
{
glGenBuffers(1, &headbuffer);
glGenBuffers(1, &nodebuffer);
glGenBuffers(1, &lightbuffer);
glGenBuffers(1, &counterbuffer);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, headbuffer);
glBufferData(GL_SHADER_STORAGE_BUFFER, numtiles * headsize, 0, GL_STATIC_DRAW);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, nodebuffer);
glBufferData(GL_SHADER_STORAGE_BUFFER, numtiles * nodesize * 1024, 0, GL_STATIC_DRAW); // 4 MB
glBindBuffer(GL_SHADER_STORAGE_BUFFER, lightbuffer);
glBufferData(GL_SHADER_STORAGE_BUFFER, NUM_LIGHTS * sizeof(LightParticle), 0, GL_DYNAMIC_DRAW);
UpdateParticles(0, true);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, counterbuffer);
glBufferData(GL_ATOMIC_COUNTER_BUFFER, sizeof(GLuint), 0, GL_DYNAMIC_DRAW);
glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, 0);
}
// load effects
if( !GLCreateEffectFromFile("../media/shadersGL/basic2D.vert", 0, "../media/shadersGL/basic2D.frag", &basic2D) )
{
MYERROR("Could not load basic 2D shader");
return false;
}
if( !GLCreateEffectFromFile("../media/shadersGL/basic2D.vert", 0, "../media/shadersGL/boxblur3x3.frag", &boxblur3x3) )
{
MYERROR("Could not load blur shader");
return false;
}
if( !GLCreateEffectFromFile("../media/shadersGL/basic2D.vert", 0, "../media/shadersGL/gammacorrect.frag", &gammacorrect) )
{
MYERROR("Could not load gamma correction shader");
return false;
}
if( !GLCreateEffectFromFile("../media/shadersGL/shadowmap_variance.vert", 0, "../media/shadersGL/shadowmap_variance.frag", &varianceshadow) )
{
MYERROR("Could not load shadowmap shader");
return false;
}
if( !GLCreateEffectFromFile("../media/shadersGL/blinnphong_variance.vert", 0, "../media/shadersGL/blinnphong_variance.frag", &shadowedlight) )
{
MYERROR("Could not load shadowed light shader");
return false;
}
if( !GLCreateEffectFromFile("../media/shadersGL/ambient.vert", 0, "../media/shadersGL/ambient.frag", &ambient) )
{
MYERROR("Could not load ambient shader");
return false;
}
if( hascompute )
{
// light accumulation shader
if( !GLCreateEffectFromFile("../media/shadersGL/lightaccum.vert", 0, "../media/shadersGL/lightaccum.frag", &lightaccum) )
{
MYERROR("Could not load light accumulation shader");
return false;
}
// light culling shader
if( !GLCreateComputeProgramFromFile("../media/shadersGL/lightcull.comp", &lightcull) )
{
MYERROR("Could not load light culling shader");
return false;
}
lightcull->SetInt("depthSampler", 0);
lightcull->SetInt("numLights", NUM_LIGHTS);
lightaccum->SetInt("sampler0", 0);
}
float white[] = { 1, 1, 1, 1 };
shadowedlight->SetVector("matSpecular", white);
shadowedlight->SetInt("sampler0", 0);
shadowedlight->SetInt("sampler1", 1);
boxblur3x3->SetInt("sampler0", 0);
basic2D->SetInt("sampler0", 0);
gammacorrect->SetInt("sampler0", 0);
float angles[2] = { 0.25f, -0.7f };
cameraangle = angles;
return true;
}
void set_debug_log_filters(GLenum source, GLenum type, const std::vector<GLuint>& ids, GLenum severity, bool enabled)
{
glDebugMessageControl(source, type, severity, static_cast<GLsizei>(ids.size()), ids.data(), enabled);
}
int main(int argc, char** argv)
{
int ch;
GLFWwindow* windows[2];
GLuint texture, program, vertex_buffer;
GLint mvp_location, vpos_location, color_location, texture_location;
srand((unsigned int) time(NULL));
glfwSetErrorCallback(error_callback);
if (!glfwInit())
exit(EXIT_FAILURE);
while ((ch = getopt(argc, argv, "d")) != -1)
{
switch (ch)
{
case 'd':
glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GLFW_TRUE);
break;
}
}
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
windows[0] = glfwCreateWindow(400, 400, "First", NULL, NULL);
if (!windows[0])
{
glfwTerminate();
exit(EXIT_FAILURE);
}
glfwSetKeyCallback(windows[0], key_callback);
glfwMakeContextCurrent(windows[0]);
// Only enable vsync for the first of the windows to be swapped to
// avoid waiting out the interval for each window
glfwSwapInterval(1);
// The contexts are created with the same APIs so the function
// pointers should be re-usable between them
gladLoadGLLoader((GLADloadproc) glfwGetProcAddress);
if (GLAD_GL_KHR_debug)
{
glDebugMessageCallback(debug_callback, NULL);
glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, NULL, GL_TRUE);
}
// Create the OpenGL objects inside the first context, created above
// All objects will be shared with the second context, created below
{
int x, y;
char pixels[16 * 16];
GLuint vertex_shader, fragment_shader;
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture);
for (y = 0; y < 16; y++)
{
for (x = 0; x < 16; x++)
pixels[y * 16 + x] = rand() % 256;
}
glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, 16, 16, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, pixels);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
vertex_shader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertex_shader, 1, &vertex_shader_text, NULL);
glCompileShader(vertex_shader);
fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragment_shader, 1, &fragment_shader_text, NULL);
glCompileShader(fragment_shader);
program = glCreateProgram();
glAttachShader(program, vertex_shader);
glAttachShader(program, fragment_shader);
glLinkProgram(program);
mvp_location = glGetUniformLocation(program, "MVP");
color_location = glGetUniformLocation(program, "color");
texture_location = glGetUniformLocation(program, "texture");
vpos_location = glGetAttribLocation(program, "vPos");
glGenBuffers(1, &vertex_buffer);
glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
}
glUseProgram(program);
glUniform1i(texture_location, 0);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, texture);
glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer);
glEnableVertexAttribArray(vpos_location);
glVertexAttribPointer(vpos_location, 2, GL_FLOAT, GL_FALSE,
sizeof(vertices[0]), (void*) 0);
windows[1] = glfwCreateWindow(400, 400, "Second", NULL, windows[0]);
if (!windows[1])
{
glfwTerminate();
exit(EXIT_FAILURE);
}
// Place the second window to the right of the first
{
int xpos, ypos, left, right, width;
glfwGetWindowSize(windows[0], &width, NULL);
glfwGetWindowFrameSize(windows[0], &left, NULL, &right, NULL);
glfwGetWindowPos(windows[0], &xpos, &ypos);
glfwSetWindowPos(windows[1], xpos + width + left + right, ypos);
}
glfwSetKeyCallback(windows[1], key_callback);
glfwMakeContextCurrent(windows[1]);
// While objects are shared, the global context state is not and will
// need to be set up for each context
glUseProgram(program);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, texture);
glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer);
glEnableVertexAttribArray(vpos_location);
glVertexAttribPointer(vpos_location, 2, GL_FLOAT, GL_FALSE,
sizeof(vertices[0]), (void*) 0);
while (!glfwWindowShouldClose(windows[0]) &&
!glfwWindowShouldClose(windows[1]))
{
int i;
const vec3 colors[2] =
{
{ 0.3f, 0.4f, 1.f },
{ 0.8f, 0.4f, 1.f }
};
for (i = 0; i < 2; i++)
{
int width, height;
mat4x4 mvp;
glfwGetFramebufferSize(windows[i], &width, &height);
glfwMakeContextCurrent(windows[i]);
glViewport(0, 0, width, height);
mat4x4_ortho(mvp, 0.f, 1.f, 0.f, 1.f, 0.f, 1.f);
glUniformMatrix4fv(mvp_location, 1, GL_FALSE, (const GLfloat*) mvp);
glUniform3fv(color_location, 1, colors[i]);
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
glfwSwapBuffers(windows[i]);
}
glfwWaitEvents();
}
glfwTerminate();
exit(EXIT_SUCCESS);
}
/* Initialise the double buffered display */
bool screenInitialise()
{
GLint glMaxTUs;
GLenum err;
glErrors();
err = glewInit();
if (GLEW_OK != err)
{
debug(LOG_FATAL, "Error: %s", glewGetErrorString(err));
exit(1);
}
/* Dump general information about OpenGL implementation to the console and the dump file */
ssprintf(opengl.vendor, "OpenGL Vendor: %s", glGetString(GL_VENDOR));
addDumpInfo(opengl.vendor);
debug(LOG_3D, "%s", opengl.vendor);
ssprintf(opengl.renderer, "OpenGL Renderer: %s", glGetString(GL_RENDERER));
addDumpInfo(opengl.renderer);
debug(LOG_3D, "%s", opengl.renderer);
ssprintf(opengl.version, "OpenGL Version: %s", glGetString(GL_VERSION));
addDumpInfo(opengl.version);
debug(LOG_3D, "%s", opengl.version);
ssprintf(opengl.GLEWversion, "GLEW Version: %s", glewGetString(GLEW_VERSION));
if (strncmp(opengl.GLEWversion, "1.9.", 4) == 0) // work around known bug with KHR_debug extension support in this release
{
debug(LOG_WARNING, "Your version of GLEW is old and buggy, please upgrade to at least version 1.10.");
khr_debug = false;
}
else
{
khr_debug = GLEW_KHR_debug;
}
addDumpInfo(opengl.GLEWversion);
debug(LOG_3D, "%s", opengl.GLEWversion);
GLubyte const *extensionsBegin = glGetString(GL_EXTENSIONS);
if (extensionsBegin == nullptr)
{
static GLubyte const emptyString[] = "";
extensionsBegin = emptyString;
}
GLubyte const *extensionsEnd = extensionsBegin + strlen((char const *)extensionsBegin);
std::vector<std::string> glExtensions;
for (GLubyte const *i = extensionsBegin; i < extensionsEnd;)
{
GLubyte const *j = std::find(i, extensionsEnd, ' ');
glExtensions.push_back(std::string(i, j));
i = j + 1;
}
/* Dump extended information about OpenGL implementation to the console */
std::string line;
for (unsigned n = 0; n < glExtensions.size(); ++n)
{
std::string word = " ";
word += glExtensions[n];
if (n + 1 != glExtensions.size())
{
word += ',';
}
if (line.size() + word.size() > 160)
{
debug(LOG_3D, "OpenGL Extensions:%s", line.c_str());
line.clear();
}
line += word;
}
debug(LOG_3D, "OpenGL Extensions:%s", line.c_str());
debug(LOG_3D, "Notable OpenGL features:");
debug(LOG_3D, " * OpenGL 1.2 %s supported!", GLEW_VERSION_1_2 ? "is" : "is NOT");
debug(LOG_3D, " * OpenGL 1.3 %s supported!", GLEW_VERSION_1_3 ? "is" : "is NOT");
debug(LOG_3D, " * OpenGL 1.4 %s supported!", GLEW_VERSION_1_4 ? "is" : "is NOT");
debug(LOG_3D, " * OpenGL 1.5 %s supported!", GLEW_VERSION_1_5 ? "is" : "is NOT");
debug(LOG_3D, " * OpenGL 2.0 %s supported!", GLEW_VERSION_2_0 ? "is" : "is NOT");
debug(LOG_3D, " * OpenGL 2.1 %s supported!", GLEW_VERSION_2_1 ? "is" : "is NOT");
debug(LOG_3D, " * OpenGL 3.0 %s supported!", GLEW_VERSION_3_0 ? "is" : "is NOT");
debug(LOG_3D, " * Texture compression %s supported.", GLEW_ARB_texture_compression ? "is" : "is NOT");
debug(LOG_3D, " * Two side stencil %s supported.", GLEW_EXT_stencil_two_side ? "is" : "is NOT");
debug(LOG_3D, " * ATI separate stencil is%s supported.", GLEW_ATI_separate_stencil ? "" : " NOT");
debug(LOG_3D, " * Stencil wrap %s supported.", GLEW_EXT_stencil_wrap ? "is" : "is NOT");
debug(LOG_3D, " * Anisotropic filtering %s supported.", GLEW_EXT_texture_filter_anisotropic ? "is" : "is NOT");
debug(LOG_3D, " * Rectangular texture %s supported.", GLEW_ARB_texture_rectangle ? "is" : "is NOT");
debug(LOG_3D, " * FrameBuffer Object (FBO) %s supported.", GLEW_EXT_framebuffer_object ? "is" : "is NOT");
debug(LOG_3D, " * ARB Vertex Buffer Object (VBO) %s supported.", GLEW_ARB_vertex_buffer_object ? "is" : "is NOT");
debug(LOG_3D, " * NPOT %s supported.", GLEW_ARB_texture_non_power_of_two ? "is" : "is NOT");
debug(LOG_3D, " * texture cube_map %s supported.", GLEW_ARB_texture_cube_map ? "is" : "is NOT");
glGetIntegerv(GL_MAX_TEXTURE_UNITS, &glMaxTUs);
debug(LOG_3D, " * Total number of Texture Units (TUs) supported is %d.", (int) glMaxTUs);
debug(LOG_3D, " * GL_ARB_timer_query %s supported!", GLEW_ARB_timer_query ? "is" : "is NOT");
debug(LOG_3D, " * KHR_DEBUG support %s detected", khr_debug ? "was" : "was NOT");
if (!GLEW_VERSION_2_0)
{
debug(LOG_FATAL, "OpenGL 2.0 not supported! Please upgrade your drivers.");
return false;
}
screenWidth = MAX(screenWidth, 640);
screenHeight = MAX(screenHeight, 480);
std::pair<int, int> glslVersion(0, 0);
sscanf((char const *)glGetString(GL_SHADING_LANGUAGE_VERSION), "%d.%d", &glslVersion.first, &glslVersion.second);
/* Dump information about OpenGL 2.0+ implementation to the console and the dump file */
GLint glMaxTIUs, glMaxTCs, glMaxTIUAs, glmaxSamples, glmaxSamplesbuf;
debug(LOG_3D, " * OpenGL GLSL Version : %s", glGetString(GL_SHADING_LANGUAGE_VERSION));
ssprintf(opengl.GLSLversion, "OpenGL GLSL Version : %s", glGetString(GL_SHADING_LANGUAGE_VERSION));
addDumpInfo(opengl.GLSLversion);
glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &glMaxTIUs);
debug(LOG_3D, " * Total number of Texture Image Units (TIUs) supported is %d.", (int) glMaxTIUs);
glGetIntegerv(GL_MAX_TEXTURE_COORDS, &glMaxTCs);
debug(LOG_3D, " * Total number of Texture Coords (TCs) supported is %d.", (int) glMaxTCs);
glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB, &glMaxTIUAs);
debug(LOG_3D, " * Total number of Texture Image Units ARB(TIUAs) supported is %d.", (int) glMaxTIUAs);
glGetIntegerv(GL_SAMPLE_BUFFERS, &glmaxSamplesbuf);
debug(LOG_3D, " * (current) Max Sample buffer is %d.", (int) glmaxSamplesbuf);
glGetIntegerv(GL_SAMPLES, &glmaxSamples);
debug(LOG_3D, " * (current) Max Sample level is %d.", (int) glmaxSamples);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
pie_Skybox_Init();
// Generate backdrop render
backdropGfx = new GFX(GFX_TEXTURE, GL_TRIANGLE_STRIP, 2);
if (GLEW_ARB_timer_query)
{
glGenQueries(PERF_COUNT, perfpos);
}
if (khr_debug)
{
glDebugMessageCallback((GLDEBUGPROC)khr_callback, NULL);
glEnable(GL_DEBUG_OUTPUT);
// Do not want to output notifications. Some drivers spam them too much.
glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_NOTIFICATION, 0, NULL, GL_FALSE);
debug(LOG_3D, "Enabling KHR_debug message callback");
}
glErrors();
return true;
}