View difference between Paste ID: Wsu3ZTSB and fxLTLDhV

 // gl_loop.c
 
 #include "gl_draw.h"
 #include "gl_loop.h"
 #include "gl_screen.h"
 #include "i_err.h"
 #include "i_salloc.h"
 #include "i_types.h"
 
 // gl_screen variables, extern'd thru gl-screen to rest of program
 unsigned short globsperscreenW;
 unsigned short globsperscreenH;
 
 void initglscreen() {
   globsperscreenW = GLOBS_PER_TILE_WIDTH * TILES_PER_SCREEN_WIDTH;
   globsperscreenH = GLOBS_PER_TILE_HEIGHT * TILES_PER_SCREEN_HEIGHT;
 
   // make sure the total size isn't over USHRT_MAX
   int totalsize = globsperscreenW * globsperscreenH;
   if (totalsize > USHRT_MAX) error("Total size of glscreen is greater than the maximum USHRT value",false);
 
   // also sets up some variables that aren't important
 }
 
 #include "g_tick.h"
 #include "gl_shaders.h"
 
 // opengl headers
 #include <stdio.h>
 #include <stdlib.h>
 
 #include <GL/glew.h>
 #include <GLFW/glfw3.h>
 
 int beginGLLoop() {
   // firstly, create the window
   puts("Creating window...");
 
   // initialize GLFW
   glewExperimental = true;
   if (!glfwInit()) error("Failed to initialize GLFW",true);
 
   // set window hints
   glfwWindowHint(GLFW_SAMPLES, 4);
   glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
   glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
   glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
   glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
 
   // actually create the window
   GLFWwindow *window;
   window = glfwCreateWindow(720,720,"Test Program",NULL,NULL);
   if (window == NULL) error("Unable to initialize window",true);
   glfwMakeContextCurrent(window);
   glewExperimental = true;
   if (glewInit() != GLEW_OK) error("Failed to initialize GLEW",true);
 
   puts("Window successfully initialized, initializing screen buffer...");
 
   // while we're here, initialize the screen
   initglscreen(); // sets up some (currently useless) variables
 
   puts("Screen buffer initialized, initializing vertex diagram...");
 
   // secondly, calculate the vertices that we need to render
   // (more complex calculations are run by the vertex shader)
   size_t verticesSize;
   GLuint vertexbuffer;
   vertexbuffer = initvertexdiagram(&verticesSize);
   GLuint colorbuffer = initcolordiagram();
 
   puts("Vertex diagram initialized, loading shaders...");
 
   // thirdly, load and compile the shaders
   GLuint program = loadshaders("./src/shaders/vertex.glsl","./src/shaders/fragment.glsl"); // TODO: find a more reliable way of storing the shader paths
 
   puts("Shaders are loaded, running final initialization procedures...");
 
   // fourthly, initialize some things that have to be done before rendering
   initdraw();
 
   puts("Initialization completed, begininng rendering loop...");
 
   // fifthly, begin rendering loop
   bool continueRendering = true; // TODO: create a more sophisticated way of doing this
   glfwSetInputMode(window, GLFW_STICKY_KEYS, GL_TRUE);
   int windowwidth, windowheight;
   //glUseProgram(program);
   do {
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
     glUseProgram(program);
 
     // TODO: poll game to update screen variables
 
     glfwGetWindowSize(window,&windowwidth,&windowheight);
     drawscreen(window,windowwidth,windowheight,vertexbuffer,colorbuffer);
 
     // swap buffers
     glfwSwapBuffers(window);
     glfwPollEvents();
 
     // event polling
     continueRendering = (glfwGetKey(window, GLFW_KEY_ESCAPE) != GLFW_PRESS) && gametick();
   } while (glfwWindowShouldClose(window) == 0 && continueRendering);
 
 
   puts("Freeing memory before exit...");
   // finally, release any memory held by the program
   glDeleteBuffers(1,&vertexbuffer);
   glDeleteBuffers(1,&colorbuffer);
   puts("Memory freed, exiting program.");
 
   // return
   return 0;
 }
 
 // gl_draw.c
 #include "i_salloc.h"
 #include "i_types.h"
 
 #include "gl_draw.h"
 #include "gl_screen.h"
 
 #include <stdio.h>
 #include <stdlib.h>
 
 // initialize collection of vertices used to draw stuff
 GLuint initvertexdiagram(size_t *size) {
   // initialize memory
   const byte numsPerVertice = 3;
   *size = sizeof(GLfloat) * (globsperscreenW * globsperscreenH * ((numsPerVertice * 4)));
   GLfloat *verticies = checkalloc(*size);
 
   // initialize recurring variables
   const GLfloat zVal = 0.0f;
   GLfloat xVal = -1.0f;
   GLfloat yVal = -1.0f;
 
   GLfloat xIncrement = 2.0f / globsperscreenW;
   GLfloat yIncrement = 2.0f / globsperscreenH;
 
   // begin loop to fill diagram
   unsigned short currentIndex = 0;
   for (unsigned short i = 0; i < globsperscreenH; i++) {
     for (unsigned short j = 0; j < globsperscreenH; j++) {
       // assign x y and z values
       verticies[currentIndex] = xVal;
       verticies[currentIndex + 1] = yVal + yIncrement;
       verticies[currentIndex + 2] = zVal;
 
       verticies[currentIndex + 3] = xVal;
       verticies[currentIndex + 4] = yVal;
       verticies[currentIndex + 5] = zVal;
 
       verticies[currentIndex + 6] = xVal + xIncrement;
       verticies[currentIndex + 7] = yVal;
       verticies[currentIndex + 8] = zVal;
 
       verticies[currentIndex + 9] = xVal + xIncrement;
       verticies[currentIndex + 10] = yVal + yIncrement;
       verticies[currentIndex + 11] = zVal;
 
 
       // increment index
       currentIndex += 12;
 
       // change values
       xVal += xIncrement;
     }
     yVal += yIncrement;
   }
 
   // setup opengl-style buffer
   GLuint buffer;
   glGenBuffers(1,&buffer);
   glBindBuffer(GL_ARRAY_BUFFER,buffer);
   glBufferData(GL_ARRAY_BUFFER,*size,verticies,GL_STATIC_DRAW);
 
   free(verticies);
 
   // return the pointer
   return buffer;
 }
 
 // initialize a buffer of colors
 GLuint initcolordiagram() {
   size_t size = sizeof(GLfloat) * globsperscreenW * globsperscreenH * 3 * 4;
   GLfloat *colors = checkalloc(size);
 
   // loop through it
   int currentIndex = 0;
   for (int i = 0; i < globsperscreenW * globsperscreenH * 4; i++) {
     colors[currentIndex] = 0.0f;
     colors[currentIndex + 1] = 0.0f;
     colors[currentIndex + 2] = 1.0f;
     currentIndex += 3;
   }
 
 
   // bind buffers
   GLuint buffer;
   glGenBuffers(1,&buffer);
   glBindBuffer(GL_ARRAY_BUFFER,buffer);
   glBufferData(GL_ARRAY_BUFFER,size,colors,GL_STATIC_DRAW);
 
   free(colors);
 
   return buffer;
 }
 
 void initdraw() {
   glClearColor(0.0f, 0.4f, 0.4f, 0.0f);
 }
 
 void drawscreen(GLFWwindow *window, int width, int height, GLuint vertexbuffer, GLuint colorbuffer) {
   glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);
   glEnableVertexAttribArray(0);
   glVertexAttribPointer(0,3,GL_FLOAT,GL_FALSE,0,(void *)0);
   glBindBuffer(GL_ARRAY_BUFFER, colorbuffer);
   glEnableVertexAttribArray(1);
   glVertexAttribPointer(1,3,GL_FLOAT,GL_FALSE,0,(void *)0);
 
   // draw the squares
   static const GLubyte indicies[] = {0,1,2,0,2,3};
 
   glDrawElements(GL_TRIANGLES,6,GL_UNSIGNED_BYTE,indicies);
 
   glDisableVertexAttribArray(1);
   glDisableVertexAttribArray(0);
 }
 
 // vertex shader
 #version 330 core
 
 layout (location = 0) in vec3 vertexPos;
 layout (location = 1) in vec3 fColor;
 
 out vec3 vertexColor;
 
 void main() {
   gl_Position.xyz = vertexPos;
   gl_Position.w = 1.0;
 
   vertexColor = fColor;
 }
 
 // fragment shader
 #version 330 core
 
-// this file is a part of Avaritia, made by John Nunley and licensed under GPL 3.0
+
 
 in vec3 vertexColor;
 
 void main() {
   fragmentColor.xyz = vertexColor;
   fragmentColor.a = 1.0f;
 }