finaaaalllyyyy ∩w∩

.gitignore

@@ -1 +1,2 @@
 build/test
+build/main

README.MD

@@ -2,3 +2,12 @@
 # the VEry LArge Game Engine
 
 it's a game engine for big s#1t
+
+
+# building
+
+it's easy just type `make` to build and run ./build/main
+
+or run `make Test` to build the test
+
+"easy" he said. instant regret.

engine/object.cpp

@@ -0,0 +1,29 @@
+#include "object.hpp"
+#include "shader.hpp"
+
+void gameobject::render() {
+  glDrawElements(GL_TRIANGLES, element_number, GL_UNSIGNED_INT, elements);
+}
+
+gameobject::gameobject(shader *render_shader) {
+  rend_shader = render_shader;
+
+  glGenVertexArrays(1, &vao);
+}
+
+void gameobject::genEbo() {
+  glGenBuffers(1, &ebo); // Generate 1 buffer
+
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
+
+  glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLuint)*element_number, elements,
+               GL_STATIC_DRAW);
+}
+
+void gameobject::genVbo(GLfloat vertices[], GLuint size) {
+  glGenBuffers(1, &vbo); // Generate 1 buffer
+
+  glBindBuffer(GL_ARRAY_BUFFER, vbo);
+
+  glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * size, vertices, GL_STATIC_DRAW);
+}

engine/object.hpp

@@ -0,0 +1,34 @@
+#ifndef __GAMEOBJECT_H__
+#define __GAMEOBJECT_H__
+
+#include <GL/glew.h>
+#include <SDL2/SDL.h>
+#include <SDL2/SDL_opengl.h>
+#include <SDL2/SDL_video.h>
+#include "shader.hpp"
+
+/*
+ *  absolute bare minimum to get rendering to
+ *  sorta hacky work
+ */
+class gameobject{
+public:
+  shader *rend_shader;
+
+  GLuint vbo;
+  GLuint vao;
+  
+  GLuint element_number;
+  GLuint ebo;
+  GLuint *elements;
+
+  void render();
+
+  void genVbo(GLfloat vertices[], GLuint size);
+  void genEbo();
+
+  gameobject(shader *render_shader);
+private:
+};
+
+#endif

engine/rendering.cpp

@@ -39,7 +39,7 @@ bool rendering::Shaderinit() {
 
   // --get paths--
   for (int i = 0; i < manifest["vertex"].size(); i++) {
-    shaderpaths_vertex.push_back(manifest["vertex"][0].asString());
+    shaderpaths_vertex.push_back(manifest["vertex"][i]["path"].asString());
   }
 
   std::vector<std::string> shadercode_vertex;
@@ -88,7 +88,7 @@ bool rendering::Shaderinit() {
 
   // --get paths--
   for (int i = 0; i < manifest["fragment"].size(); i++) {
-    shaderpaths_fragment.push_back(manifest["fragment"][0].asString());
+    shaderpaths_fragment.push_back(manifest["fragment"][i]["path"].asString());
   }
 
   std::vector<std::string> shadercode_fragment;
@@ -144,14 +144,34 @@ bool rendering::Shaderinit() {
     }
     // fragment
     if (manifest["combos"][i]["fragment"].isInt()) {
-      shader.vertexShader =
-          vertex_shaders.at(manifest["combos"][i]["fragment"].asInt());
+      shader.fragmentShader =
+          fragment_shaders.at(manifest["combos"][i]["fragment"].asInt());
     } else {
       std::cerr
-          << "required argument \"fragment\" is nonexistant or not an int";
+          << "required argument \"fragment\" is nonexistant or not an int\n";
       return false;
     }
+
+    if(!manifest["fragment"][manifest["combos"][i]["fragment"].asInt()]["framebuff_output"].isArray()){
+      std::cerr<<"vertex["<<i<<"].framebuff_output is not an array.\n";
+      return false;
+    }
+
+    shader.attatchshader();
+    for(int j=0; j < manifest["fragment"][manifest["combos"][i]["fragment"].asInt()]["framebuff_output"].size();j++){
+      glBindFragDataLocation(shader.shaderProgram, j, manifest["fragment"][manifest["combos"][i]["fragment"].asInt()]["framebuff_output"][j].asCString());
+    }
+
+    shader.linkshader();
+
+    this->shaders.push_back(shader);
   }
 
   return true;
 }
+
+void rendering::render(){
+  for (int i=0; i<objects.size(); i++) {
+    objects.at(i).render();
+  }
+}

engine/rendering.hpp

@@ -12,6 +12,7 @@
 #include <json/value.h>
 #include <json/reader.h>
 #include "shader.hpp"
+#include "object.hpp"
 
 
 //contains the context for the window and stuff for setting up the renderer to render stuff
@@ -31,6 +32,10 @@ public:
   std::vector<GLuint> vertex_shaders;
   std::vector<GLuint> fragment_shaders;
   std::vector<shader> shaders;
+  std::vector<gameobject> objects;
+
+  //temporary
+  void render();
 
 private:
   SDL_Window *window;

engine/shader.cpp

@@ -1,8 +1,19 @@
 #include "shader.hpp"
 
-void shader::linkshader(){
-    shaderProgram = glCreateProgram();
-    glAttachShader(shaderProgram, vertexShader);
-    glAttachShader(shaderProgram, fragmentShader);  
-    glLinkProgram(shaderProgram);
+void shader::linkshader() { glLinkProgram(shaderProgram); }
+
+void shader::attatchshader() {
+  shaderProgram = glCreateProgram();
+  glAttachShader(shaderProgram, vertexShader);
+  glAttachShader(shaderProgram, fragmentShader);
+}
+
+void shader::use() { glUseProgram(shaderProgram); }
+
+GLint shader::getInputId(std::string name) {
+  return glGetProgramResourceIndex(shaderProgram, GL_PROGRAM_INPUT, name.c_str());
+}
+
+GLint shader::getOutputId(std::string name) {
+  return glGetProgramResourceIndex(shaderProgram, GL_PROGRAM_OUTPUT, name.c_str());
 }

engine/shader.hpp

@@ -5,6 +5,7 @@
 #include <SDL2/SDL.h>
 #include <SDL2/SDL_opengl.h>
 #include <SDL2/SDL_video.h>
+#include <string>
 
 class shader{
   public:
@@ -12,7 +13,13 @@ class shader{
     GLuint vertexShader;
     GLuint shaderProgram;
     //links the shader and creates the shaderprogram
+    GLint getInputId(std::string name);
+    GLint getOutputId(std::string name);
+    //void setAttribute(std::string name);
+    void setAttribute(GLuint name);
+    void attatchshader();
     void linkshader();
+    void use();
   private:
 };
 

main.cpp

@@ -71,6 +71,25 @@ int main(int argc, char *argv[])
     };
 
 
+    //shaders
+
+    GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
+    glShaderSource(vertexShader, 1, &vertcode, NULL);
+    glCompileShader(vertexShader);
+
+    GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
+    glShaderSource(fragmentShader, 1, &fragcode, NULL);
+    glCompileShader(fragmentShader);
+
+
+    GLuint shaderProgram = glCreateProgram();
+    glAttachShader(shaderProgram, vertexShader);
+    glAttachShader(shaderProgram, fragmentShader);  
+    glLinkProgram(shaderProgram);
+
+    GLuint vao;
+    glGenVertexArrays(1, &vao);
+
     //vbo
     GLuint vbo;
     glGenBuffers(1, &vbo); // Generate 1 buffer
@@ -88,26 +107,9 @@ int main(int argc, char *argv[])
 
     glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(elements), elements, GL_STATIC_DRAW);
 
-    //shaders
-
-    GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
-    glShaderSource(vertexShader, 1, &vertcode, NULL);
-    glCompileShader(vertexShader);
-
-    GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
-    glShaderSource(fragmentShader, 1, &fragcode, NULL);
-    glCompileShader(fragmentShader);
-
-
-    GLuint shaderProgram = glCreateProgram();
-    glAttachShader(shaderProgram, vertexShader);
-    glAttachShader(shaderProgram, fragmentShader);  
-    glLinkProgram(shaderProgram);
-
 
     //-----vao-----
-    GLuint vao;
-    glGenVertexArrays(1, &vao);
+    
     glBindVertexArray(vao);
     //-----vao-----
     
@@ -121,10 +123,10 @@ int main(int argc, char *argv[])
     glEnableVertexAttribArray(colAttrib);
     glVertexAttribPointer(colAttrib, 3, GL_FLOAT, GL_FALSE, 5*sizeof(GLfloat), (void*)(2*sizeof(GLfloat)));
 
-    glBindFragDataLocation(shaderProgram, 0, "outColor");
+    //glBindFragDataLocation(shaderProgram, 0, "outColor");
 
-    GLint uniColor = glGetUniformLocation(shaderProgram, "triangleColor");
-    glUniform3f(uniColor, 1.0f, 0.0f, 0.0f);
+    //GLint uniColor = glGetUniformLocation(shaderProgram, "triangleColor");
+    //glUniform3f(uniColor, 1.0f, 0.0f, 0.0f);
 
 
 

shaders.json

@@ -1,9 +1,12 @@
 {
     "vertex":[
-        "shaders/vertex/simple.glsl"
+        {"path":"shaders/vertex/simple.glsl"}
     ],
     "fragment":[
-        "shaders/fragment/simple.glsl"
+        {
+            "path":"shaders/fragment/simple.glsl",
+            "framebuff_output":["outColor"]
+        }
     ],
 
     "combos":[

test.cpp

@@ -1,15 +1,53 @@
+#include "engine/object.hpp"
 #include "engine/rendering.hpp"
+#include "engine/shader.hpp"
 #include <SDL2/SDL_video.h>
 int main(int argc, char *argv[]) {
   rendering renderer;
 
   renderer.SDLinit();
   SDL_Window *window =
-      SDL_CreateWindow("aaa", 20, 20, 500, 500, SDL_WINDOW_OPENGL);
+      SDL_CreateWindow("aaa", 20, 20, 800, 600, SDL_WINDOW_OPENGL);
   renderer.GLinit(window);
 
   renderer.Shaderinit();
 
+  GLfloat vertices[] = {
+      -0.5f, 0.5f,  1.0f, 0.0f, 0.0f, // Top-left
+      0.5f,  0.5f,  0.0f, 1.0f, 0.0f, // Top-right
+      0.5f,  -0.5f, 0.0f, 0.0f, 1.0f, // Bottom-right
+      -0.5f, -0.5f, 1.0f, 1.0f, 1.0f  // Bottom-left
+  };
+
+  GLuint elements[] = {0, 2, 3, 1, 2, 3};
+
+
+  gameobject test(&renderer.shaders.at(0));
+  // renderer.objects.push_back(test);
+
+  test.element_number = 6;
+  test.elements = elements;
+
+  test.genVbo(vertices, 20);
+  test.genEbo();
+
+  glBindVertexArray(test.vao);
+
+  test.rend_shader->use();
+
+  GLint posAttrib = test.rend_shader->getInputId("position");
+  glEnableVertexAttribArray(posAttrib);
+  glVertexAttribPointer(posAttrib, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat),
+                        0);
+
+  GLint colAttrib = test.rend_shader->getInputId("color");
+  glEnableVertexAttribArray(colAttrib);
+  glVertexAttribPointer(colAttrib, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat),
+                        (void *)(2 * sizeof(GLfloat)));
+
+  /*GLint uniColor =
+      glGetUniformLocation(test.rend_shader->shaderProgram, "triangleColor");
+  glUniform3f(uniColor, 1.0f, 0.0f, 0.0f);*/
 
   SDL_Event windowEvent;
 
@@ -21,8 +59,20 @@ int main(int argc, char *argv[]) {
           windowEvent.key.keysym.sym == SDLK_ESCAPE)
         break;
     }
+
+    GLenum err = glGetError();
+  if (err != GL_NO_ERROR) {
+    std::cout << err<<"\n"<<posAttrib;
+    return -1;
+  }
+    // renderer.render();
+    // test.render();
+    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, elements);
+
     SDL_GL_SwapWindow(window);
   }
+
+  
   SDL_GL_DeleteContext(renderer.context);
 
   SDL_Quit();