dimitri/ShaderTool
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Reset frame count and time when reloading shaders

Browse source 
Define a struct to hold the renderer state.
This commit is contained in:
Dimitri Lozeve 2021-02-25 21:09:40 +01:00
parent 685e2e62ce
commit 6f21d1e0ec
3 changed files with 81 additions and 69 deletions
Download patch file Download diff file Expand all files Collapse all files

99
src/main.c
View file

@ -14,81 +14,78 @@ int main(int argc, char *argv[]) {
log_error("Usage: %s <screen shader> [<buffer shader>]", argv[0]); log_error("Usage: %s <screen shader> [<buffer shader>]", argv[0]);
return EXIT_FAILURE; return EXIT_FAILURE;
} }
const char *screen_shader_file = argv[1];
log_debug("Screen shader file: %s", screen_shader_file); struct renderer_state state = {0};
const char *buffer_shader_file = NULL;
state.screen_shader_file = argv[1];
log_debug("Screen shader file: %s", state.screen_shader_file);
if (argc >= 3) { if (argc >= 3) {
buffer_shader_file = argv[2]; state.buffer_shader_file = argv[2];
log_debug("Buffer shader file: %s", buffer_shader_file); log_debug("Buffer shader file: %s", state.buffer_shader_file);
} }
GLFWwindow *window = initialize_window(WINDOW_WIDTH, WINDOW_HEIGHT); state.window = initialize_window(WINDOW_WIDTH, WINDOW_HEIGHT);
if (window == NULL) { if (state.window == NULL) {
glfwTerminate(); glfwTerminate();
return EXIT_FAILURE; return EXIT_FAILURE;
} }
unsigned int VAO = initialize_vertices(); unsigned int VAO = initialize_vertices();
unsigned int screen_shader = glCreateProgram(); state.screen_shader = glCreateProgram();
if (!screen_shader) { if (!state.screen_shader) {
log_error("Could not create screen shader program"); log_error("Could not create screen shader program");
glfwDestroyWindow(window); glfwDestroyWindow(state.window);
glfwTerminate(); glfwTerminate();
return EXIT_FAILURE; return EXIT_FAILURE;
} }
compile_shaders(&screen_shader, screen_shader_file); compile_shaders(&state.screen_shader, state.screen_shader_file);
glUseProgram(screen_shader); glUseProgram(state.screen_shader);
glUniform1i(glGetUniformLocation(screen_shader, "u_texture"), 0); glUniform1i(glGetUniformLocation(state.screen_shader, "u_texture"), 0);
unsigned int buffer_shader = 0;
unsigned int framebuffer = 0; unsigned int framebuffer = 0;
unsigned int texture_color_buffer = 0; unsigned int texture_color_buffer = 0;
if (buffer_shader_file) { if (state.buffer_shader_file) {
buffer_shader = glCreateProgram(); state.buffer_shader = glCreateProgram();
if (!buffer_shader) { if (!state.buffer_shader) {
log_error("Could not create buffer shader program"); log_error("Could not create buffer shader program");
glfwDestroyWindow(window); glfwDestroyWindow(state.window);
glfwTerminate(); glfwTerminate();
return EXIT_FAILURE; return EXIT_FAILURE;
} }
compile_shaders(&buffer_shader, buffer_shader_file); compile_shaders(&state.buffer_shader, state.buffer_shader_file);
glUseProgram(buffer_shader); glUseProgram(state.buffer_shader);
glUniform1i(glGetUniformLocation(buffer_shader, "u_texture"), 0); glUniform1i(glGetUniformLocation(state.buffer_shader, "u_texture"), 0);
if (initialize_framebuffer(&framebuffer, &texture_color_buffer, if (initialize_framebuffer(&framebuffer, &texture_color_buffer,
WINDOW_WIDTH, WINDOW_HEIGHT)) { WINDOW_WIDTH, WINDOW_HEIGHT)) {
glfwDestroyWindow(window); glfwDestroyWindow(state.window);
glfwTerminate(); glfwTerminate();
return EXIT_FAILURE; return EXIT_FAILURE;
} }
} }
/* Drawing loop */ /* Drawing loop */
size_t frame_count = 0; glfwSetTime(0.0);
size_t prev_frame_count = 0; while (!glfwWindowShouldClose(state.window)) {
double time = 0; process_input(&state);
double prev_time = 0;
while (!glfwWindowShouldClose(window)) {
process_input(window, &screen_shader, screen_shader_file, &buffer_shader,
buffer_shader_file);
/* data required for uniforms */ /* data required for uniforms */
time = glfwGetTime(); state.time = glfwGetTime();
int viewport[4] = {0}; int viewport[4] = {0};
glGetIntegerv(GL_VIEWPORT, viewport); glGetIntegerv(GL_VIEWPORT, viewport);
double mouse_x = 0, mouse_y = 0; double mouse_x = 0, mouse_y = 0;
glfwGetCursorPos(window, &mouse_x, &mouse_y); glfwGetCursorPos(state.window, &mouse_x, &mouse_y);
if (time - prev_time >= 1.0) { if (state.time - state.prev_time >= 1.0) {
double fps = (frame_count - prev_frame_count) / (time - prev_time); double fps = (state.frame_count - state.prev_frame_count) / (state.time - state.prev_time);
log_debug("frame = %zu, time = %.2f, fps = %.2f, viewport = (%d, %d)", frame_count, log_debug("frame = %zu, time = %.2f, fps = %.2f, viewport = (%d, %d)",
time, fps, viewport[2], viewport[3]); state.frame_count, state.time, fps, viewport[2], viewport[3]);
prev_frame_count = frame_count; state.prev_frame_count = state.frame_count;
prev_time = time; state.prev_time = state.time;
} }
if (buffer_shader_file) { if (state.buffer_shader_file) {
/* bind the framebuffer and draw to it */ /* bind the framebuffer and draw to it */
glBindFramebuffer(GL_FRAMEBUFFER, framebuffer); glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
@ -97,12 +94,12 @@ int main(int argc, char *argv[]) {
glClear(GL_COLOR_BUFFER_BIT); glClear(GL_COLOR_BUFFER_BIT);
/* Setup uniforms */ /* Setup uniforms */
glUseProgram(buffer_shader); glUseProgram(state.buffer_shader);
glUniform1ui(glGetUniformLocation(buffer_shader, "u_frame"), frame_count); glUniform1ui(glGetUniformLocation(state.buffer_shader, "u_frame"), state.frame_count);
glUniform1f(glGetUniformLocation(buffer_shader, "u_time"), time); glUniform1f(glGetUniformLocation(state.buffer_shader, "u_time"), state.time);
glUniform2f(glGetUniformLocation(buffer_shader, "u_resolution"), glUniform2f(glGetUniformLocation(state.buffer_shader, "u_resolution"),
viewport[2], viewport[3]); viewport[2], viewport[3]);
glUniform2f(glGetUniformLocation(buffer_shader, "u_mouse"), mouse_x, glUniform2f(glGetUniformLocation(state.buffer_shader, "u_mouse"), mouse_x,
mouse_y); mouse_y);
/* Draw the vertices */ /* Draw the vertices */
@ -119,12 +116,12 @@ int main(int argc, char *argv[]) {
glClear(GL_COLOR_BUFFER_BIT); glClear(GL_COLOR_BUFFER_BIT);
/* Setup uniforms */ /* Setup uniforms */
glUseProgram(screen_shader); glUseProgram(state.screen_shader);
glUniform1ui(glGetUniformLocation(screen_shader, "u_frame"), frame_count); glUniform1ui(glGetUniformLocation(state.screen_shader, "u_frame"), state.frame_count);
glUniform1f(glGetUniformLocation(screen_shader, "u_time"), time); glUniform1f(glGetUniformLocation(state.screen_shader, "u_time"), state.time);
glUniform2f(glGetUniformLocation(screen_shader, "u_resolution"), glUniform2f(glGetUniformLocation(state.screen_shader, "u_resolution"),
viewport[2], viewport[3]); viewport[2], viewport[3]);
glUniform2f(glGetUniformLocation(screen_shader, "u_mouse"), mouse_x, glUniform2f(glGetUniformLocation(state.screen_shader, "u_mouse"), mouse_x,
mouse_y); mouse_y);
/* Draw the vertices */ /* Draw the vertices */
@ -133,12 +130,12 @@ int main(int argc, char *argv[]) {
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0); glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
glBindVertexArray(0); glBindVertexArray(0);
glfwSwapBuffers(window); glfwSwapBuffers(state.window);
glfwPollEvents(); glfwPollEvents();
frame_count++; state.frame_count++;
} }
glfwDestroyWindow(window); glfwDestroyWindow(state.window);
glfwTerminate(); glfwTerminate();
return EXIT_SUCCESS; return EXIT_SUCCESS;
} }

30
src/renderer.c
View file

@ -186,23 +186,25 @@ void capture_screenshot() {
* @brief Ensure the window is closed when the user presses the escape * @brief Ensure the window is closed when the user presses the escape
* key. * key.
* *
* @param window The current window. * @param state The current state of the renderer.
* @param shader_program Pointer to the shader program to update if needed.
* @param fragment_shader_file The shader file to reload if needed.
*/ */
void process_input(GLFWwindow *window, unsigned int *screen_shader, void process_input(struct renderer_state *state) {
const char *const screen_shader_file, if (glfwGetKey(state->window, GLFW_KEY_ESCAPE) == GLFW_PRESS) {
unsigned int *buffer_shader,
const char *const buffer_shader_file) {
if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS) {
log_debug("Quitting"); log_debug("Quitting");
glfwSetWindowShouldClose(window, true); glfwSetWindowShouldClose(state->window, true);
} else if (glfwGetKey(window, GLFW_KEY_R) == GLFW_PRESS) { } else if (glfwGetKey(state->window, GLFW_KEY_R) == GLFW_PRESS) {
compile_shaders(screen_shader, screen_shader_file); // reinitialize time and frame count
if (buffer_shader_file) { state->frame_count = 0;
compile_shaders(buffer_shader, buffer_shader_file); state->prev_frame_count = 0;
glfwSetTime(0.0);
state->time = 0.0;
state->prev_time = 0.0;
// recompile shaders
compile_shaders(&state->screen_shader, state->screen_shader_file);
if (state->buffer_shader_file) {
compile_shaders(&state->buffer_shader, state->buffer_shader_file);
} }
} else if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS) { } else if (glfwGetKey(state->window, GLFW_KEY_S) == GLFW_PRESS) {
capture_screenshot(); capture_screenshot();
} }
} }

21
src/renderer.h
View file

@ -3,6 +3,22 @@
#include <GLFW/glfw3.h> #include <GLFW/glfw3.h>
/**
* Structure representing the state of the renderer and associated
* shaders.
*/
struct renderer_state {
GLFWwindow *window; /**< GLFW window where the shaders are rendered. */
unsigned int screen_shader; /**< Shader for the main screen. */
const char *screen_shader_file; /**< Screen shader file name. */
unsigned int buffer_shader; /**< Shader for the background framebuffer. */
const char *buffer_shader_file; /**< Buffer shader file name. */
size_t frame_count; /**< Frame count since the beginning of the render loop. */
size_t prev_frame_count; /**< Frame count at the last log. */
double time; /**< Time in seconds since the beginning of the render loop. */
double prev_time; /**< Time in seconds at the last log. */
};
GLFWwindow *initialize_window(int width, int height); GLFWwindow *initialize_window(int width, int height);
unsigned int initialize_vertices(); unsigned int initialize_vertices();
unsigned int initialize_framebuffer(unsigned int *framebuffer, unsigned int initialize_framebuffer(unsigned int *framebuffer,
@ -11,9 +27,6 @@ unsigned int initialize_framebuffer(unsigned int *framebuffer,
unsigned int texture_height); unsigned int texture_height);
void framebuffer_size_callback(GLFWwindow *window, int width, int height); void framebuffer_size_callback(GLFWwindow *window, int width, int height);
void capture_screenshot(); void capture_screenshot();
void process_input(GLFWwindow *window, unsigned int *screen_shader, void process_input(struct renderer_state *state);
const char *const screen_shader_file,
unsigned int *buffer_shader,
const char *const buffer_shader_file);
#endif /* RENDERER_H */ #endif /* RENDERER_H */