Drezil/imgui
1
0
Fork 0
mirror of https://github.com/Drezil/imgui.git synced 2025-03-28 15:02:44 +00:00
Code Issues Packages Projects Releases Wiki Activity

fixed indentation mix, removed some unused code, updated different callback using the example_opengl code.

Browse Source
This commit is contained in:
Olivier Chatry 2014-12-03 19:11:23 +01:00
parent a8d2bc69ed
commit 2f176033c6
1 changed files with 96 additions and 118 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

214
examples/opengl3_example/main.cpp
View File

@ -10,6 +10,9 @@
static GLFWwindow* window; static GLFWwindow* window;
static GLuint fontTex; static GLuint fontTex;
static bool mousePressed[2] = { false, false };
static ImVec2 mousePosScale(1.0f, 1.0f);
//Shader variables //Shader variables
static int shader_handle, vert_handle, frag_handle; static int shader_handle, vert_handle, frag_handle;
@ -19,34 +22,10 @@ static int position_location, uv_location, colour_location;
//we are going to use the same vertex buffer for all rendering of imgui //we are going to use the same vertex buffer for all rendering of imgui
//so we need to use a large enough buffer as default. //so we need to use a large enough buffer as default.
//the buffer will be resized if needed in the rendering code, but it is not a "free" operation. //the buffer will be resized if needed in the rendering code, but it is not a "free" operation.
static size_t vbo_max_size = 1000000; static size_t vbo_max_size = 1000000;
static unsigned int vbo_handle, vao_handle; static unsigned int vbo_handle, vao_handle;
template<typename T>
unsigned int stream(GLenum target, unsigned int vbo, unsigned int *vbo_cursor, unsigned int *vbo_size, T *start, int elementCount)
{
unsigned int bytes = sizeof(T) *elementCount;
unsigned int aligned = bytes + bytes % 64; //align memory
glBindBuffer(target, vbo);
//If there's not enough space left, orphan the buffer object, create a new one and start writing
if (vbo_cursor[0] + aligned > vbo_size[0])
{
assert(aligned < vbo_size[0]);
glBufferData(target, vbo_size[0], NULL, GL_DYNAMIC_DRAW);
vbo_cursor[0] = 0;
}
void* mapped = glMapBufferRange(target, vbo_cursor[0], aligned, GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT);
memcpy(mapped, start, bytes);
vbo_cursor[0] += aligned;
glUnmapBuffer(target);
return vbo_cursor[0] - aligned; //return the offset we use for glVertexAttribPointer call
}
// This is the main rendering function that you have to implement and provide to ImGui (via setting up 'RenderDrawListsFn' in the ImGuiIO structure) // This is the main rendering function that you have to implement and provide to ImGui (via setting up 'RenderDrawListsFn' in the ImGuiIO structure)
// If text or lines are blurry when integrating ImGui in your engine: // If text or lines are blurry when integrating ImGui in your engine:
// - try adjusting ImGui::GetIO().PixelCenterOffset to 0.0f or 0.5f // - try adjusting ImGui::GetIO().PixelCenterOffset to 0.0f or 0.5f
@ -58,9 +37,9 @@ static void ImImpl_RenderDrawLists(ImDrawList** const cmd_lists, int cmd_lists_c
// Setup render state: alpha-blending enabled, no face culling, no depth testing, scissor enabled // Setup render state: alpha-blending enabled, no face culling, no depth testing, scissor enabled
glEnable(GL_BLEND); glEnable(GL_BLEND);
glBlendEquation(GL_FUNC_ADD); glBlendEquation(GL_FUNC_ADD);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_CULL_FACE); glDisable(GL_CULL_FACE);
glDisable(GL_DEPTH_TEST); glDisable(GL_DEPTH_TEST);
glEnable(GL_SCISSOR_TEST); glEnable(GL_SCISSOR_TEST);
@ -71,46 +50,46 @@ static void ImImpl_RenderDrawLists(ImDrawList** const cmd_lists, int cmd_lists_c
// Setup orthographic projection matrix // Setup orthographic projection matrix
const float width = ImGui::GetIO().DisplaySize.x; const float width = ImGui::GetIO().DisplaySize.x;
const float height = ImGui::GetIO().DisplaySize.y; const float height = ImGui::GetIO().DisplaySize.y;
const float ortho_projection[4][4] = const float ortho_projection[4][4] =
{ {
{ 2.0f/width, 0.0f, 0.0f, 0.0f }, { 2.0f/width, 0.0f, 0.0f, 0.0f },
{ 0.0f, 2.0f/-height, 0.0f, 0.0f }, { 0.0f, 2.0f/-height, 0.0f, 0.0f },
{ 0.0f, 0.0f, -1.0f, 0.0f }, { 0.0f, 0.0f, -1.0f, 0.0f },
{ -1.0f, 1.0f, 0.0f, 1.0f }, { -1.0f, 1.0f, 0.0f, 1.0f },
}; };
glUseProgram(shader_handle); glUseProgram(shader_handle);
glUniform1i(texture_location, 0); glUniform1i(texture_location, 0);
glUniformMatrix4fv(ortho_location, 1, GL_FALSE, &ortho_projection[0][0]); glUniformMatrix4fv(ortho_location, 1, GL_FALSE, &ortho_projection[0][0]);
// we will update the buffer in full, so we need to compute the total size of the buffer. // we will update the buffer in full, so we need to compute the total size of the buffer.
size_t total_vtx_count = 0; size_t total_vtx_count = 0;
for (int n = 0; n < cmd_lists_count; n++) for (int n = 0; n < cmd_lists_count; n++)
total_vtx_count += cmd_lists[n]->vtx_buffer.size(); total_vtx_count += cmd_lists[n]->vtx_buffer.size();
glBindBuffer(GL_ARRAY_BUFFER, vbo_handle);
size_t neededBufferSize = total_vtx_count * sizeof(ImDrawVert);
if (neededBufferSize > vbo_max_size)
{
vbo_max_size = neededBufferSize;
glBufferData(GL_ARRAY_BUFFER, total_vtx_count * sizeof(ImDrawVert), NULL, GL_STREAM_DRAW);
}
unsigned char* buffer_data = (unsigned char*)glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY); glBindBuffer(GL_ARRAY_BUFFER, vbo_handle);
if (!buffer_data) size_t neededBufferSize = total_vtx_count * sizeof(ImDrawVert);
return; if (neededBufferSize > vbo_max_size)
for (int n = 0; n < cmd_lists_count; n++) {
{ vbo_max_size = neededBufferSize;
const ImDrawList* cmd_list = cmd_lists[n]; glBufferData(GL_ARRAY_BUFFER, total_vtx_count * sizeof(ImDrawVert), NULL, GL_STREAM_DRAW);
memcpy(buffer_data, &cmd_list->vtx_buffer[0], cmd_list->vtx_buffer.size() * sizeof(ImDrawVert)); }
buffer_data += cmd_list->vtx_buffer.size() * sizeof(ImDrawVert);
}
glUnmapBuffer(GL_ARRAY_BUFFER);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindVertexArray(vao_handle); unsigned char* buffer_data = (unsigned char*)glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY);
if (!buffer_data)
int cmd_offset = 0; return;
for (int n = 0; n < cmd_lists_count; n++) for (int n = 0; n < cmd_lists_count; n++)
{
const ImDrawList* cmd_list = cmd_lists[n];
memcpy(buffer_data, &cmd_list->vtx_buffer[0], cmd_list->vtx_buffer.size() * sizeof(ImDrawVert));
buffer_data += cmd_list->vtx_buffer.size() * sizeof(ImDrawVert);
}
glUnmapBuffer(GL_ARRAY_BUFFER);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindVertexArray(vao_handle);
int cmd_offset = 0;
for (int n = 0; n < cmd_lists_count; n++)
{ {
const ImDrawList* cmd_list = cmd_lists[n]; const ImDrawList* cmd_list = cmd_lists[n];
int vtx_offset = cmd_offset; int vtx_offset = cmd_offset;
@ -121,13 +100,13 @@ static void ImImpl_RenderDrawLists(ImDrawList** const cmd_lists, int cmd_lists_c
glDrawArrays(GL_TRIANGLES, vtx_offset, pcmd->vtx_count); glDrawArrays(GL_TRIANGLES, vtx_offset, pcmd->vtx_count);
vtx_offset += pcmd->vtx_count; vtx_offset += pcmd->vtx_count;
} }
cmd_offset = vtx_offset; cmd_offset = vtx_offset;
} }
glBindVertexArray(0); glBindVertexArray(0);
glUseProgram(0); glUseProgram(0);
glDisable(GL_SCISSOR_TEST); glDisable(GL_SCISSOR_TEST);
glBindTexture(GL_TEXTURE_2D, 0); glBindTexture(GL_TEXTURE_2D, 0);
} }
@ -147,10 +126,16 @@ static void glfw_error_callback(int error, const char* description)
fputs(description, stderr); fputs(description, stderr);
} }
static void glfw_mouse_button_callback(GLFWwindow* window, int button, int action, int mods)
{
if (action == GLFW_PRESS && button >= 0 && button < 2)
mousePressed[button] = true;
}
static void glfw_scroll_callback(GLFWwindow* window, double xoffset, double yoffset) static void glfw_scroll_callback(GLFWwindow* window, double xoffset, double yoffset)
{ {
ImGuiIO& io = ImGui::GetIO(); ImGuiIO& io = ImGui::GetIO();
io.MouseWheel = (yoffset != 0.0f) ? yoffset > 0.0f ? 1.0f : -1.0f : 0.0f; // Mouse wheel: -1,0,+1 io.MouseWheel += (float)yoffset; // Use fractional mouse wheel, 1.0 unit 5 lines.
} }
static void glfw_key_callback(GLFWwindow* window, int key, int scancode, int action, int mods) static void glfw_key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
@ -166,8 +151,8 @@ static void glfw_key_callback(GLFWwindow* window, int key, int scancode, int act
static void glfw_char_callback(GLFWwindow* window, unsigned int c) static void glfw_char_callback(GLFWwindow* window, unsigned int c)
{ {
if (c > 0 && c <= 255) if (c > 0 && c < 0x10000)
ImGui::GetIO().AddInputCharacter((char)c); ImGui::GetIO().AddInputCharacter((unsigned short)c);
} }
@ -182,7 +167,7 @@ void InitGL()
glfwWindowHint(GLFW_RESIZABLE, GL_FALSE); glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
window = glfwCreateWindow(1280, 720, "ImGui OpenGL example", NULL, NULL); window = glfwCreateWindow(1280, 720, "ImGui OpenGL example", NULL, NULL);
glfwMakeContextCurrent(window); glfwMakeContextCurrent(window);
@ -190,49 +175,42 @@ void InitGL()
glfwSetScrollCallback(window, glfw_scroll_callback); glfwSetScrollCallback(window, glfw_scroll_callback);
glfwSetCharCallback(window, glfw_char_callback); glfwSetCharCallback(window, glfw_char_callback);
glewExperimental = GL_TRUE; glewExperimental = GL_TRUE;
GLenum err = glewInit();
if (GLEW_OK != err)
{
fprintf(stderr, "Error: %s\n", glewGetErrorString(err));
}
const GLchar *vertex_shader = \ GLenum err = glewInit();
"#version 330\n" if (GLEW_OK != err)
"uniform mat4 ortho;\n" {
fprintf(stderr, "Error: %s\n", glewGetErrorString(err));
}
"in vec2 Position;\n" const GLchar *vertex_shader = \
"in vec2 UV;\n" "#version 330\n"
"in vec4 Colour;\n" "uniform mat4 ortho;\n"
"in vec2 Position;\n"
"in vec2 UV;\n"
"in vec4 Colour;\n"
"out vec2 Frag_UV;\n"
"out vec4 Frag_Colour;\n"
"void main()\n"
"{\n"
" Frag_UV = UV;\n"
" Frag_Colour = Colour;\n"
" gl_Position = ortho*vec4(Position.xy,0,1);\n"
"}\n";
"out vec2 Frag_UV;\n" const GLchar* fragment_shader = \
"out vec4 Frag_Colour;\n" "#version 330\n"
"uniform sampler2D Texture;\n"
"in vec2 Frag_UV;\n"
"in vec4 Frag_Colour;\n"
"out vec4 FragColor;\n"
"void main()\n"
"{\n"
" FragColor = Frag_Colour * texture( Texture, Frag_UV.st);\n"
"}\n";
"void main()\n" shader_handle = glCreateProgram();
"{\n" vert_handle = glCreateShader(GL_VERTEX_SHADER);
" Frag_UV = UV;\n"
" Frag_Colour = Colour;\n"
"\n"
" gl_Position = ortho*vec4(Position.xy,0,1);\n"
"}\n";
const GLchar* fragment_shader = \
"#version 330\n"
"uniform sampler2D Texture;\n"
"in vec2 Frag_UV;\n"
"in vec4 Frag_Colour;\n"
"out vec4 FragColor;\n"
"void main()\n"
"{\n"
" FragColor = Frag_Colour * texture( Texture, Frag_UV.st);\n"
"}\n";
shader_handle = glCreateProgram();
vert_handle = glCreateShader(GL_VERTEX_SHADER);
frag_handle = glCreateShader(GL_FRAGMENT_SHADER); frag_handle = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(vert_handle, 1, &vertex_shader, 0); glShaderSource(vert_handle, 1, &vertex_shader, 0);
glShaderSource(frag_handle, 1, &fragment_shader, 0); glShaderSource(frag_handle, 1, &fragment_shader, 0);
@ -252,19 +230,19 @@ void InitGL()
glBindBuffer(GL_ARRAY_BUFFER, vbo_handle); glBindBuffer(GL_ARRAY_BUFFER, vbo_handle);
glBufferData(GL_ARRAY_BUFFER, vbo_max_size, NULL, GL_DYNAMIC_DRAW); glBufferData(GL_ARRAY_BUFFER, vbo_max_size, NULL, GL_DYNAMIC_DRAW);
glGenVertexArrays(1, &vao_handle); glGenVertexArrays(1, &vao_handle);
glBindVertexArray(vao_handle); glBindVertexArray(vao_handle);
glBindBuffer(GL_ARRAY_BUFFER, vbo_handle); glBindBuffer(GL_ARRAY_BUFFER, vbo_handle);
glEnableVertexAttribArray(position_location); glEnableVertexAttribArray(position_location);
glEnableVertexAttribArray(uv_location); glEnableVertexAttribArray(uv_location);
glEnableVertexAttribArray(colour_location); glEnableVertexAttribArray(colour_location);
glVertexAttribPointer(position_location, 2, GL_FLOAT, GL_FALSE, sizeof(ImDrawVert), (GLvoid*) offsetof(ImDrawVert, pos)); glVertexAttribPointer(position_location, 2, GL_FLOAT, GL_FALSE, sizeof(ImDrawVert), (GLvoid*) offsetof(ImDrawVert, pos));
glVertexAttribPointer(uv_location, 2, GL_FLOAT, GL_FALSE, sizeof(ImDrawVert), (GLvoid*) offsetof(ImDrawVert, uv)); glVertexAttribPointer(uv_location, 2, GL_FLOAT, GL_FALSE, sizeof(ImDrawVert), (GLvoid*) offsetof(ImDrawVert, uv));
glVertexAttribPointer(colour_location, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(ImDrawVert), (GLvoid*) offsetof(ImDrawVert, col)); glVertexAttribPointer(colour_location, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(ImDrawVert), (GLvoid*) offsetof(ImDrawVert, col));
glBindVertexArray(0); glBindVertexArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ARRAY_BUFFER, 0);
} }
@ -392,7 +370,7 @@ int main(int argc, char** argv)
ImGui::Render(); ImGui::Render();
glfwSwapBuffers(window); glfwSwapBuffers(window);
} }
if (vao_handle) glDeleteVertexArrays(1, &vao_handle); if (vao_handle) glDeleteVertexArrays(1, &vao_handle);
if (vbo_handle) glDeleteBuffers(1, &vbo_handle); if (vbo_handle) glDeleteBuffers(1, &vbo_handle);
glDetachShader(shader_handle, vert_handle); glDetachShader(shader_handle, vert_handle);
glDetachShader(shader_handle, frag_handle); glDetachShader(shader_handle, frag_handle);