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();
}
bool gl_load(HDC deviceContext)
{
if (flextInit() == GL_FALSE)
return false;
if (wgl_LoadFunctions(deviceContext) == wgl_LOAD_FAILED)
return false;
return true;
}
bool CGlfwWindow::init(unsigned int width, unsigned int height, const std::string& name)
{
if (!glfwInit())
{
LOG_ERROR("Failed to initialize GLFW.");
return false;
}
glfwWindowHint(GLFW_SAMPLES, 4);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
// Create window from parameters
m_window = glfwCreateWindow(width, height, name.c_str(), NULL, NULL);
if (m_window == nullptr)
{
LOG_ERROR("Failed to create GLFW window.");
glfwTerminate();
return false;
}
int framebufferWidth;
int framebufferHeight;
glfwGetFramebufferSize(m_window, &framebufferWidth, &framebufferHeight);
m_width = framebufferWidth;
m_height = framebufferHeight;
glfwMakeContextCurrent(m_window);
glfwSetInputMode(m_window, GLFW_STICKY_KEYS, GL_TRUE);
// Load OpenGL extensions
#ifndef __APPLE__
if (flextInit(m_window) != GL_TRUE)
{
glfwTerminate();
LOG_ERROR("Failed to initialize flextGL.");
return false;
}
#endif
// Add mapping
s_windows[m_window] = this;
// Set window resize callback
glfwSetFramebufferSizeCallback(m_window, &CGlfwWindow::resizeCallback);
return true;
}
void initialize()
{
ChangeCurrentOpenGLContext ctx(opengl_context_ptr);
OpenGLBindings *b = new OpenGLBindings();
if (flextInit(opengl_context_ptr, b) == 0)
{
LOG_ERROR << "Failed to initialize flextGL.";
exit(-1);
}
gl(b);
input_data.allocate(352, 424 * 10);
for(int i = 0; i < 3; ++i)
stage1_data[i].allocate(512, 424);
if(do_debug) stage1_debug.allocate(512, 424);
stage1_infrared.allocate(512, 424);
for(int i = 0; i < 2; ++i)
filter1_data[i].allocate(512, 424);
filter1_max_edge_test.allocate(512, 424);
if(do_debug) filter1_debug.allocate(512, 424);
if(do_debug) stage2_debug.allocate(512, 424);
stage2_depth.allocate(512, 424);
stage2_depth_and_ir_sum.allocate(512, 424);
if(do_debug) filter2_debug.allocate(512, 424);
filter2_depth.allocate(512, 424);
stage1.setVertexShader(loadShaderSource(shader_folder + "default.vs"));
stage1.setFragmentShader(loadShaderSource(shader_folder + "stage1.fs"));
stage1.build();
filter1.setVertexShader(loadShaderSource(shader_folder + "default.vs"));
filter1.setFragmentShader(loadShaderSource(shader_folder + "filter1.fs"));
filter1.build();
stage2.setVertexShader(loadShaderSource(shader_folder + "default.vs"));
stage2.setFragmentShader(loadShaderSource(shader_folder + "stage2.fs"));
stage2.build();
filter2.setVertexShader(loadShaderSource(shader_folder + "default.vs"));
filter2.setFragmentShader(loadShaderSource(shader_folder + "filter2.fs"));
filter2.build();
if(do_debug)
{
debug.setVertexShader(loadShaderSource(shader_folder + "default.vs"));
debug.setFragmentShader(loadShaderSource(shader_folder + "debug.fs"));
debug.build();
}
GLenum debug_attachment = do_debug ? GL_COLOR_ATTACHMENT0 : GL_NONE;
gl()->glGenFramebuffers(1, &stage1_framebuffer);
gl()->glBindFramebuffer(GL_DRAW_FRAMEBUFFER, stage1_framebuffer);
const GLenum stage1_buffers[] = { debug_attachment, GL_COLOR_ATTACHMENT1, GL_COLOR_ATTACHMENT2, GL_COLOR_ATTACHMENT3, GL_COLOR_ATTACHMENT4 };
gl()->glDrawBuffers(5, stage1_buffers);
if(do_debug) gl()->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE, stage1_debug.texture, 0);
gl()->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_TEXTURE_RECTANGLE, stage1_data[0].texture, 0);
gl()->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT2, GL_TEXTURE_RECTANGLE, stage1_data[1].texture, 0);
gl()->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT3, GL_TEXTURE_RECTANGLE, stage1_data[2].texture, 0);
gl()->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT4, GL_TEXTURE_RECTANGLE, stage1_infrared.texture, 0);
gl()->glGenFramebuffers(1, &filter1_framebuffer);
gl()->glBindFramebuffer(GL_DRAW_FRAMEBUFFER, filter1_framebuffer);
const GLenum filter1_buffers[] = { debug_attachment, GL_COLOR_ATTACHMENT1, GL_COLOR_ATTACHMENT2, GL_COLOR_ATTACHMENT3 };
gl()->glDrawBuffers(4, filter1_buffers);
if(do_debug) gl()->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE, filter1_debug.texture, 0);
gl()->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_TEXTURE_RECTANGLE, filter1_data[0].texture, 0);
gl()->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT2, GL_TEXTURE_RECTANGLE, filter1_data[1].texture, 0);
gl()->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT3, GL_TEXTURE_RECTANGLE, filter1_max_edge_test.texture, 0);
gl()->glGenFramebuffers(1, &stage2_framebuffer);
gl()->glBindFramebuffer(GL_DRAW_FRAMEBUFFER, stage2_framebuffer);
const GLenum stage2_buffers[] = { debug_attachment, GL_COLOR_ATTACHMENT1, GL_COLOR_ATTACHMENT2 };
gl()->glDrawBuffers(3, stage2_buffers);
if(do_debug) gl()->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE, stage2_debug.texture, 0);
gl()->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_TEXTURE_RECTANGLE, stage2_depth.texture, 0);
gl()->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT2, GL_TEXTURE_RECTANGLE, stage2_depth_and_ir_sum.texture, 0);
gl()->glGenFramebuffers(1, &filter2_framebuffer);
gl()->glBindFramebuffer(GL_DRAW_FRAMEBUFFER, filter2_framebuffer);
const GLenum filter2_buffers[] = { debug_attachment, GL_COLOR_ATTACHMENT1 };
gl()->glDrawBuffers(2, filter2_buffers);
if(do_debug) gl()->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE, filter2_debug.texture, 0);
gl()->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_TEXTURE_RECTANGLE, filter2_depth.texture, 0);
Vertex bl = {-1.0f, -1.0f, 0.0f, 0.0f }, br = { 1.0f, -1.0f, 512.0f, 0.0f }, tl = {-1.0f, 1.0f, 0.0f, 424.0f }, tr = { 1.0f, 1.0f, 512.0f, 424.0f };
Vertex vertices[] = {
bl, tl, tr, tr, br, bl
};
gl()->glGenBuffers(1, &square_vbo);
gl()->glGenVertexArrays(1, &square_vao);
gl()->glBindVertexArray(square_vao);
gl()->glBindBuffer(GL_ARRAY_BUFFER, square_vbo);
gl()->glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
GLint position_attr = stage1.getAttributeLocation("Position");
gl()->glVertexAttribPointer(position_attr, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (GLvoid*)0);
gl()->glEnableVertexAttribArray(position_attr);
GLint texcoord_attr = stage1.getAttributeLocation("TexCoord");
gl()->glVertexAttribPointer(texcoord_attr, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (GLvoid*)(2 * sizeof(float)));
gl()->glEnableVertexAttribArray(texcoord_attr);
}
void Viewer::initialize()
{
// setup context
glfwDefaultWindowHints();
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
#ifdef __APPLE__
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
#endif
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
//glfwWindowHint(GLFW_VISIBLE, debug ? GL_TRUE : GL_FALSE);
window = glfwCreateWindow(1280, 800, "Viewer", 0, NULL);
glfwMakeContextCurrent(window);
OpenGLBindings *b = new OpenGLBindings();
flextInit(window, b);
gl(b);
std::string vertexshadersrc = ""
"#version 330\n"
"in vec2 Position;"
"in vec2 TexCoord;"
"out VertexData{"
"vec2 TexCoord;"
"} VertexOut;"
"void main(void)"
"{"
" gl_Position = vec4(Position, 0.0, 1.0);"
" VertexOut.TexCoord = TexCoord;"
"}";
std::string grayfragmentshader = ""
"#version 330\n"
"uniform sampler2DRect Data;"
"vec4 tempColor;"
"in VertexData{"
" vec2 TexCoord;"
"} FragmentIn;"
"layout(location = 0) out vec4 Color;"
"void main(void)"
"{"
"ivec2 uv = ivec2(FragmentIn.TexCoord.x, FragmentIn.TexCoord.y);"
"tempColor = texelFetch(Data, uv);"
"Color = vec4(tempColor.x/4500, tempColor.x/4500, tempColor.x/4500, 1);"
"}";
std::string fragmentshader = ""
"#version 330\n"
"uniform sampler2DRect Data;"
"in VertexData{"
" vec2 TexCoord;"
"} FragmentIn;"
"layout(location = 0) out vec4 Color;"
"void main(void)"
"{"
" ivec2 uv = ivec2(FragmentIn.TexCoord.x, FragmentIn.TexCoord.y);"
" Color = texelFetch(Data, uv);"
"}";
renderShader.setVertexShader(vertexshadersrc);
renderShader.setFragmentShader(fragmentshader);
renderShader.build();
renderGrayShader.setVertexShader(vertexshadersrc);
renderGrayShader.setFragmentShader(grayfragmentshader);
renderGrayShader.build();
glfwSetWindowUserPointer(window, this);
glfwSetKeyCallback(window, Viewer::key_callbackstatic);
shouldStop = false;
}
void Viewer::initialize()
{
glfwMakeContextCurrent(window);
OpenGLBindings *b = new OpenGLBindings();
flextInit(window, b);
gl(b);
std::string vertexshadersrc = ""
"#version 330\n"
"in vec2 Position;"
"in vec2 TexCoord;"
"out VertexData{"
"vec2 TexCoord;"
"} VertexOut;"
"void main(void)"
"{"
" gl_Position = vec4(Position, 0.0, 1.0);"
" VertexOut.TexCoord = TexCoord;"
"}";
std::string grayfragmentshader = ""
"#version 330\n"
"uniform sampler2DRect Data;"
"vec4 tempColor;"
"in VertexData{"
" vec2 TexCoord;"
"} FragmentIn;"
"layout(location = 0) out vec4 Color;"
"void main(void)"
"{"
"ivec2 uv = ivec2(FragmentIn.TexCoord.x, FragmentIn.TexCoord.y);"
"tempColor = texelFetch(Data, uv);"
"Color = vec4(tempColor.x/4500, tempColor.x/4500, tempColor.x/4500, 1);"
"}";
std::string fragmentshader = ""
"#version 330\n"
"uniform sampler2DRect Data;"
"in VertexData{"
" vec2 TexCoord;"
"} FragmentIn;"
"layout(location = 0) out vec4 Color;"
"void main(void)"
"{"
" ivec2 uv = ivec2(FragmentIn.TexCoord.x, FragmentIn.TexCoord.y);"
" Color = texelFetch(Data, uv);"
"}";
renderShader.setVertexShader(vertexshadersrc);
renderShader.setFragmentShader(fragmentshader);
renderShader.build();
renderGrayShader.setVertexShader(vertexshadersrc);
renderGrayShader.setFragmentShader(grayfragmentshader);
renderGrayShader.build();
glfwSetWindowUserPointer(window, this);
glfwSetKeyCallback(window, Viewer::key_callbackstatic);
shouldStop = false;
}
void InitWindow()
{
const int width = GetConfigInt("window.width", 640);
const int height = GetConfigInt("window.height", 480);
const char* title = GetConfigString("window.title", "Konstrukt");
const bool debug = GetConfigBool("opengl.debug", false);
const bool vsync = GetConfigBool("opengl.vsync", true);
LogInfo("Compiled with GLFW %d.%d.%d",
GLFW_VERSION_MAJOR,
GLFW_VERSION_MINOR,
GLFW_VERSION_REVISION);
LogInfo("Using GLFW %s", glfwGetVersionString());
assert(g_Window == NULL);
glfwSetErrorCallback(OnGLFWError);
if(!glfwInit())
FatalError("GLFW init failed.");
glfwDefaultWindowHints();
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_DEPTH_BITS, GetConfigInt("opengl.depth-bits", 24));
glfwWindowHint(GLFW_STENCIL_BITS, 0);
glfwWindowHint(GLFW_SAMPLES, GetConfigInt("opengl.samples", 0));
glfwWindowHint(GLFW_SRGB_CAPABLE, GL_TRUE);
glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, debug ? GL_TRUE : GL_FALSE);
g_Window = glfwCreateWindow(width, height, title, NULL, NULL);
if(!g_Window)
FatalError("Window creation failed.");
glfwGetWindowSize(g_Window, &g_WindowWidth, &g_WindowHeight);
glfwGetFramebufferSize(g_Window, &g_FramebufferWidth, &g_FramebufferHeight);
glfwMakeContextCurrent(g_Window);
if(!flextInit(g_Window))
FatalError("Failed to load OpenGL extensions.");
LogInfo("Using OpenGL %s\n"
"Vendor: %s\n"
"Renderer: %s\n"
"GLSL: %s",
glGetString(GL_VERSION),
glGetString(GL_VENDOR),
glGetString(GL_RENDERER),
glGetString(GL_SHADING_LANGUAGE_VERSION));
if(vsync)
{
if(glfwExtensionSupported("GLX_EXT_swap_control_tear") ||
glfwExtensionSupported("WGL_EXT_swap_control_tear"))
glfwSwapInterval(-1); // enable vsync (allow the driver to swap even if a frame arrives a little bit late)
else
glfwSwapInterval(1); // enable vsync
}
else
{
glfwSwapInterval(0); // disable vsync
}
glfwSetInputMode(g_Window, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
glfwSetInputMode(g_Window, GLFW_STICKY_KEYS, GL_FALSE);
glfwSetInputMode(g_Window, GLFW_STICKY_MOUSE_BUTTONS, GL_FALSE);
if(debug)
{
if(!FLEXT_ARB_debug_output)
FatalError("Debug output requested, but it's not supported!");
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB);
glDebugMessageCallbackARB(OnDebugEvent, NULL);
LogInfo("Debug output supported! You may receive debug messages from your OpenGL driver.");
}
glfwSetWindowSizeCallback(g_Window, OnWindowResize);
glfwSetFramebufferSizeCallback(g_Window, OnFramebufferResize);
glfwSetMouseButtonCallback(g_Window, OnMouseButtonAction);
glfwSetScrollCallback(g_Window, OnMouseScroll);
glfwSetCursorPosCallback(g_Window, OnCursorMove);
glfwSetKeyCallback(g_Window, OnKeyAction);
}
