corentin/uui
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

EBO implementation + resize + keyboard

Browse source
This commit is contained in:
Corentin 2021-07-07 00:51:33 +09:00
commit 748644b220
8 changed files with 188 additions and 24 deletions
Download patch file Download diff file Expand all files Collapse all files

21
src/test/example_gl.cpp
View file

@ -10,12 +10,21 @@ int main()
try
{
uui::GlApplication app;
auto window_1 = app.add_window(800, 600, "OpenGl!");
window_1.lock()->add_box();
auto window_2 = app.add_window(600, 600, "OpenGL 2!");
window_2.lock()->add_box();
app.run();
{
uui::GlApplication app;
// uui::GlApplication app2; // exception : application already created
auto window_1 = app.add_window(800, 600, "OpenGl!");
window_1.lock()->add_box();
app.run();
}
{
uui::GlApplication app;
auto window_1 = app.add_window(800, 600, "OpenGl!");
window_1.lock()->add_box();
auto window_2 = app.add_window(600, 600, "OpenGL 2!");
window_2.lock()->add_box();
app.run();
}
}
catch(const std::exception& error)
{

3
src/uui/application.cpp Normal file
View file

@ -0,0 +1,3 @@
#include "uui/application.hpp"
bool uui::Application::application_created = false;

13
src/uui/opengl/application.cpp
View file

@ -5,13 +5,23 @@
uui::GlApplication::GlApplication()
{
std::cout << "Creating the GlApplication" << std::endl;
if(application_created)
throw std::runtime_error("GlApplication error: the application already created");
if constexpr(debug_mode)
std::cout << "Creating the GlApplication in debug mode" << std::endl;
else
std::cout << "Creating the GlApplication in release mode" << std::endl;
// Init GLFW
glfwInit();
// Set all the required options for GLFW
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 6);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
if constexpr(uui::GlApplication::debug_mode)
glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, true);
application_created = true;
}
uui::GlApplication::~GlApplication()
@ -19,6 +29,7 @@ uui::GlApplication::~GlApplication()
std::cout << "Destroying the GlApplication" << std::endl;
windows.clear();
glfwTerminate();
application_created = false;
}
void uui::GlApplication::run()

94
src/uui/opengl/box.cpp
View file

@ -5,6 +5,42 @@
#include "uui/opengl/application.hpp"
#include "uui/shader.hpp"
GLenum glCheckError_(const char* file, int line)
{
GLenum errorCode;
while((errorCode = glGetError()) != GL_NO_ERROR)
{
std::string error;
switch(errorCode)
{
case GL_INVALID_ENUM:
error = "INVALID_ENUM";
break;
case GL_INVALID_VALUE:
error = "INVALID_VALUE";
break;
case GL_INVALID_OPERATION:
error = "INVALID_OPERATION";
break;
case GL_STACK_OVERFLOW:
error = "STACK_OVERFLOW";
break;
case GL_STACK_UNDERFLOW:
error = "STACK_UNDERFLOW";
break;
case GL_OUT_OF_MEMORY:
error = "OUT_OF_MEMORY";
break;
case GL_INVALID_FRAMEBUFFER_OPERATION:
error = "INVALID_FRAMEBUFFER_OPERATION";
break;
}
std::cout << error << " | " << file << " (" << line << ")" << std::endl;
}
return errorCode;
}
#define glCheckError() glCheckError_(__FILE__, __LINE__)
uui::GlBox::GlBox()
{
std::cout << "Creating a GlBox" << std::endl;
@ -13,7 +49,8 @@ uui::GlBox::GlBox()
GLuint vertex_shader = glCreateShader(GL_VERTEX_SHADER);
{
auto vertex_src = readFile("bin/uui/opengl/shaders/main.vert");
auto vertex_code = vertex_src.data();
auto vertex_str = std::string(vertex_src.begin(), vertex_src.end());
auto vertex_code = vertex_str.c_str();
glShaderSource(vertex_shader, 1, &vertex_code, NULL);
glCompileShader(vertex_shader);
if constexpr(uui::GlApplication::debug_mode)
@ -24,7 +61,7 @@ uui::GlBox::GlBox()
if(!success)
{
glGetShaderInfoLog(vertex_shader, 512, NULL, info);
std::cout << "GlBox error : " << info << std::endl;
std::cout << "GlBox vertex shader creation error : " << info << std::endl;
}
}
}
@ -33,7 +70,8 @@ uui::GlBox::GlBox()
GLuint fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
{
auto fragment_src = readFile("bin/uui/opengl/shaders/main.frag");
auto fragment_code = fragment_src.data();
auto fragment_str = std::string(fragment_src.begin(), fragment_src.end());
auto fragment_code = fragment_str.c_str();
glShaderSource(fragment_shader, 1, &fragment_code, NULL);
glCompileShader(fragment_shader);
if constexpr(uui::GlApplication::debug_mode)
@ -44,7 +82,7 @@ uui::GlBox::GlBox()
if(!success)
{
glGetShaderInfoLog(fragment_shader, 512, NULL, info);
std::cout << "GlBox error : " << info << std::endl;
std::cout << "GlBox fragment shader creation error : " << info << std::endl;
}
}
}
@ -52,7 +90,11 @@ uui::GlBox::GlBox()
// Creating shader program
gl_program = glCreateProgram();
glAttachShader(gl_program, vertex_shader);
if constexpr(uui::GlApplication::debug_mode)
glCheckError();
glAttachShader(gl_program, fragment_shader);
if constexpr(uui::GlApplication::debug_mode)
glCheckError();
glLinkProgram(gl_program);
if constexpr(uui::GlApplication::debug_mode)
{
@ -68,20 +110,28 @@ uui::GlBox::GlBox()
glDeleteShader(vertex_shader);
glDeleteShader(fragment_shader);
// clang-format off
float vertices[] = {
-0.5f, -0.5f, 0.0f,
0.5f, -0.5f, 0.0f,
0.0f, 0.5f, 0.0f
};
// clang-format on
glGenVertexArrays(1, &gl_vao);
glGenBuffers(1, &gl_vbo);
glGenBuffers(1, &gl_ebo);
// bind the Vertex Array Object first, then bind and set vertex buffer(s), and then configure vertex attributes(s).
glBindVertexArray(gl_vao);
if constexpr(uui::GlApplication::debug_mode)
glCheckError();
// clang-format off
float vertices[] = {
0.5f, 0.5f, 0.0f, // top right
0.5f, -0.5f, 0.0f, // bottom right
-0.5f, -0.5f, 0.0f, // bottom left
-0.5f, 0.5f, 0.0f // top left
};
// clang-format on
glBindBuffer(GL_ARRAY_BUFFER, gl_vbo);
if constexpr(uui::GlApplication::debug_mode)
glCheckError();
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
if constexpr(uui::GlApplication::debug_mode)
glCheckError();
glVertexAttribPointer(
0, // index
@ -89,10 +139,21 @@ uui::GlBox::GlBox()
GL_FLOAT, // type
GL_FALSE, // enable normalization,
3 * sizeof(float), // stride
nullptr // offset
(void*)0 // offset
);
glEnableVertexAttribArray(0);
unsigned int indices[] = {
0, 1, 3, // first triangle
1, 2, 3 // second triangle
};
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, gl_ebo);
if constexpr(uui::GlApplication::debug_mode)
glCheckError();
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
if constexpr(uui::GlApplication::debug_mode)
glCheckError();
// unbinding VBO/VAO
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindVertexArray(0);
@ -102,13 +163,16 @@ uui::GlBox::~GlBox()
{
std::cout << "Closing a GlBox" << std::endl;
glDeleteVertexArrays(1, &gl_vao);
glDeleteProgram(gl_program);
glDeleteBuffers(1, &gl_vbo);
glDeleteBuffers(1, &gl_ebo);
glDeleteProgram(gl_program);
}
void uui::GlBox::render()
{
glBindVertexArray(gl_vao);
glDrawArrays(GL_TRIANGLES, 0, 3);
glUseProgram(gl_program);
glBindVertexArray(gl_vao);
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, (void*)0);
if constexpr(uui::GlApplication::debug_mode)
glCheckError();
}

73
src/uui/opengl/window.cpp
View file

@ -4,6 +4,63 @@
#include "uui/opengl/box.hpp"
static void APIENTRY
glDebugOutput(GLenum source, GLenum type, unsigned int id, GLenum severity, GLsizei length, const char* message, const void* userParam)
{
// ignore non-significant error/warning codes
if(id == 131169 || id == 131185 || id == 131218 || id == 131204)
return;
std::cout << "---------------" << std::endl;
std::cout << "Debug message (" << id << "): " << message << std::endl;
// clang-format off
switch (source)
{
case GL_DEBUG_SOURCE_API: std::cout << "Source: API"; break;
case GL_DEBUG_SOURCE_WINDOW_SYSTEM: std::cout << "Source: Window System"; break;
case GL_DEBUG_SOURCE_SHADER_COMPILER: std::cout << "Source: Shader Compiler"; break;
case GL_DEBUG_SOURCE_THIRD_PARTY: std::cout << "Source: Third Party"; break;
case GL_DEBUG_SOURCE_APPLICATION: std::cout << "Source: Application"; break;
case GL_DEBUG_SOURCE_OTHER: std::cout << "Source: Other"; break;
} std::cout << std::endl;
switch (type)
{
case GL_DEBUG_TYPE_ERROR: std::cout << "Type: Error"; break;
case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR: std::cout << "Type: Deprecated Behaviour"; break;
case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR: std::cout << "Type: Undefined Behaviour"; break;
case GL_DEBUG_TYPE_PORTABILITY: std::cout << "Type: Portability"; break;
case GL_DEBUG_TYPE_PERFORMANCE: std::cout << "Type: Performance"; break;
case GL_DEBUG_TYPE_MARKER: std::cout << "Type: Marker"; break;
case GL_DEBUG_TYPE_PUSH_GROUP: std::cout << "Type: Push Group"; break;
case GL_DEBUG_TYPE_POP_GROUP: std::cout << "Type: Pop Group"; break;
case GL_DEBUG_TYPE_OTHER: std::cout << "Type: Other"; break;
} std::cout << std::endl;
switch (severity)
{
case GL_DEBUG_SEVERITY_HIGH: std::cout << "Severity: high"; break;
case GL_DEBUG_SEVERITY_MEDIUM: std::cout << "Severity: medium"; break;
case GL_DEBUG_SEVERITY_LOW: std::cout << "Severity: low"; break;
case GL_DEBUG_SEVERITY_NOTIFICATION: std::cout << "Severity: notification"; break;
} std::cout << std::endl;
// clang-format on
std::cout << std::endl;
}
static void glfw_resize_callback(GLFWwindow* window, int width, int height)
{
glfwMakeContextCurrent(window);
glViewport(0, 0, width, height);
}
static void glfw_key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
{
if(key == GLFW_KEY_ESCAPE && action == GLFW_PRESS)
glfwSetWindowShouldClose(window, true);
}
uui::GlWindow::GlWindow(const uui::GlApplication& app, int width, int height, const std::string& title): app(app)
{
std::cout << "Creating a GlWindow" << std::endl;
@ -14,8 +71,24 @@ uui::GlWindow::GlWindow(const uui::GlApplication& app, int width, int height, co
throw std::runtime_error("GLWindow : failed to create GLFW window");
glfwMakeContextCurrent(glfw_window);
glfwSetFramebufferSizeCallback(glfw_window, glfw_resize_callback);
glfwSetKeyCallback(glfw_window, glfw_key_callback);
if(!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
throw std::runtime_error("GLWindow : Failed to initialize OpenGL context");
if constexpr(uui::GlApplication::debug_mode)
{
GLint flags;
glGetIntegerv(GL_CONTEXT_FLAGS, &flags);
if(flags & GL_CONTEXT_FLAG_DEBUG_BIT)
{
glEnable(GL_DEBUG_OUTPUT);
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
glDebugMessageCallback(glDebugOutput, nullptr);
glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, nullptr, GL_TRUE);
}
}
}
uui::GlWindow::~GlWindow()