main.c 6.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <stdarg.h>
  4. #include <stdbool.h>
  5. #include <string.h>
  6. #include <errno.h>
  7. #define GLEW_STATIC
  8. #include <GL/glew.h>
  9. #define GL_GLEXT_PROTOTYPES
  10. #include <GLFW/glfw3.h>
  11. #define SCREEN_WIDTH 1024
  12. #define SCREEN_HEIGHT 768
  13. void panic_errno(const char *fmt, ...)
  14. {
  15. fprintf(stderr, "ERROR: ");
  16. va_list args;
  17. va_start(args, fmt);
  18. vfprintf(stderr, fmt, args);
  19. va_end(args);
  20. fprintf(stderr, ": %s\n", strerror(errno));
  21. exit(1);
  22. }
  23. char *slurp_file(const char *file_path)
  24. {
  25. #define SLURP_FILE_PANIC panic_errno("Could not read file `%s`", file_path)
  26. FILE *f = fopen(file_path, "r");
  27. if (f == NULL) SLURP_FILE_PANIC;
  28. if (fseek(f, 0, SEEK_END) < 0) SLURP_FILE_PANIC;
  29. long size = ftell(f);
  30. if (size < 0) SLURP_FILE_PANIC;
  31. char *buffer = malloc(size + 1);
  32. if (buffer == NULL) SLURP_FILE_PANIC;
  33. if (fseek(f, 0, SEEK_SET) < 0) SLURP_FILE_PANIC;
  34. fread(buffer, 1, size, f);
  35. if (ferror(f) < 0) SLURP_FILE_PANIC;
  36. buffer[size] = '\0';
  37. if (fclose(f) < 0) SLURP_FILE_PANIC;
  38. return buffer;
  39. #undef SLURP_FILE_PANIC
  40. }
  41. bool compile_shader_source(const GLchar *source, GLenum shader_type, GLuint *shader)
  42. {
  43. *shader = glCreateShader(shader_type);
  44. glShaderSource(*shader, 1, &source, NULL);
  45. glCompileShader(*shader);
  46. GLint compiled = 0;
  47. glGetShaderiv(*shader, GL_COMPILE_STATUS, &compiled);
  48. if (!compiled) {
  49. GLchar message[1024];
  50. GLsizei message_size = 0;
  51. glGetShaderInfoLog(*shader, sizeof(message), &message_size, message);
  52. fprintf(stderr, "%.*s\n", message_size, message);
  53. return false;
  54. }
  55. return true;
  56. }
  57. bool compile_shader_file(const char *file_path, GLenum shader_type, GLuint *shader)
  58. {
  59. char *source = slurp_file(file_path);
  60. bool err = compile_shader_source(source, shader_type, shader);
  61. free(source);
  62. return err;
  63. }
  64. bool link_program(GLuint vert_shader, GLuint frag_shader, GLuint *program)
  65. {
  66. *program = glCreateProgram();
  67. glAttachShader(*program, vert_shader);
  68. glAttachShader(*program, frag_shader);
  69. glLinkProgram(*program);
  70. GLint linked = 0;
  71. glGetProgramiv(*program, GL_LINK_STATUS, &linked);
  72. if (!linked) {
  73. GLsizei message_size = 0;
  74. GLchar message[1024];
  75. glGetProgramInfoLog(*program, sizeof(message), &message_size, message);
  76. fprintf(stderr, "Program Linking: %.*s\n", message_size, message);
  77. }
  78. glDeleteShader(vert_shader);
  79. glDeleteShader(frag_shader);
  80. return program;
  81. }
  82. // Global variables (fragile people with CS degree look away)
  83. bool program_failed = false;
  84. GLuint program = 0;
  85. GLint resolution_location = 0;
  86. GLint time_location = 0;
  87. bool pause = false;
  88. void reload_shaders(void)
  89. {
  90. glDeleteProgram(program);
  91. program_failed = false;
  92. glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
  93. GLuint vert = 0;
  94. if (!compile_shader_file("./main.vert", GL_VERTEX_SHADER, &vert)) {
  95. glClearColor(1.0f, 0.0f, 0.0f, 1.0f);
  96. program_failed = true;
  97. return;
  98. }
  99. GLuint frag = 0;
  100. if (!compile_shader_file("./main.frag", GL_FRAGMENT_SHADER, &frag)) {
  101. glClearColor(1.0f, 0.0f, 0.0f, 1.0f);
  102. program_failed = true;
  103. return;
  104. }
  105. if (!link_program(vert, frag, &program)) {
  106. glClearColor(1.0f, 0.0f, 0.0f, 1.0f);
  107. program_failed = true;
  108. return;
  109. }
  110. glUseProgram(program);
  111. resolution_location = glGetUniformLocation(program, "resolution");
  112. time_location = glGetUniformLocation(program, "time");
  113. printf("Successfully Reload the Shaders\n");
  114. }
  115. void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
  116. {
  117. (void) window;
  118. (void) scancode;
  119. (void) action;
  120. (void) mods;
  121. if (action == GLFW_PRESS) {
  122. if (key == GLFW_KEY_F5) {
  123. reload_shaders();
  124. } else if (key == GLFW_KEY_SPACE) {
  125. pause = !pause;
  126. }
  127. }
  128. }
  129. void window_size_callback(GLFWwindow* window, int width, int height)
  130. {
  131. (void) window;
  132. glViewport(
  133. width / 2 - SCREEN_WIDTH / 2,
  134. height / 2 - SCREEN_HEIGHT / 2,
  135. SCREEN_WIDTH,
  136. SCREEN_HEIGHT);
  137. }
  138. void MessageCallback(GLenum source,
  139. GLenum type,
  140. GLuint id,
  141. GLenum severity,
  142. GLsizei length,
  143. const GLchar* message,
  144. const void* userParam)
  145. {
  146. (void) source;
  147. (void) id;
  148. (void) length;
  149. (void) userParam;
  150. fprintf(stderr, "GL CALLBACK: %s type = 0x%x, severity = 0x%x, message = %s\n",
  151. (type == GL_DEBUG_TYPE_ERROR ? "** GL ERROR **" : ""),
  152. type, severity, message);
  153. }
  154. int main()
  155. {
  156. if (!glfwInit()) {
  157. fprintf(stderr, "ERROR: could not initialize GLFW\n");
  158. exit(1);
  159. }
  160. GLFWwindow * const window = glfwCreateWindow(
  161. SCREEN_WIDTH,
  162. SCREEN_HEIGHT,
  163. "OpenGL Template",
  164. NULL,
  165. NULL);
  166. if (window == NULL) {
  167. fprintf(stderr, "ERROR: could not create a window.\n");
  168. glfwTerminate();
  169. exit(1);
  170. }
  171. glfwMakeContextCurrent(window);
  172. if (GLEW_OK != glewInit()) {
  173. fprintf(stderr, "Could not initialize GLEW!\n");
  174. exit(1);
  175. }
  176. glEnable(GL_DEBUG_OUTPUT);
  177. glDebugMessageCallback(MessageCallback, 0);
  178. reload_shaders();
  179. glfwSetKeyCallback(window, key_callback);
  180. glfwSetFramebufferSizeCallback(window, window_size_callback);
  181. double time = glfwGetTime();
  182. double prev_time;
  183. while (!glfwWindowShouldClose(window)) {
  184. glClear(GL_COLOR_BUFFER_BIT);
  185. if (!program_failed) {
  186. glUniform2f(resolution_location,
  187. SCREEN_WIDTH,
  188. SCREEN_HEIGHT);
  189. glUniform1f(time_location, time);
  190. glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
  191. }
  192. glfwSwapBuffers(window);
  193. glfwPollEvents();
  194. double cur_time = glfwGetTime();
  195. if (!pause) {
  196. time += cur_time - prev_time;
  197. }
  198. prev_time = cur_time;
  199. }
  200. return 0;
  201. }