README.MD

@@ -1,10 +1,10 @@
-# VELAGE
+### VELAGE
-### the VEry LArge Game Engine
+# the VEry LArge Game Engine
 
 it's a game engine for big s#1t
 
 
-### building
+# building
 
 it's easy just type `make` to build and run ./build/main
 

engine/object.cpp

@@ -1,26 +1,7 @@
 #include "object.hpp"
 #include "shader.hpp"
-#include <string>
-#include <vector>
 
 void gameobject::render() {
-  GLint current;
-  // check if vbo is correct
-  glGetIntegerv(GL_VERTEX_ARRAY_BUFFER_BINDING, &current);
-  if (current != vbo)
-    glBindBuffer(GL_ARRAY_BUFFER, vbo);
-
-  // check if ebo is correct
-  glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &current);
-  if (current != ebo)
-    glBindBuffer(GL_ARRAY_BUFFER, ebo);
-
-  // check if vao is correct
-  glGetIntegerv(GL_VERTEX_ARRAY_BUFFER_BINDING, &current);
-  if (current != ebo)
-    glBindBuffer(GL_ARRAY_BUFFER, vao);
-
-  // draw
   glDrawElements(GL_TRIANGLES, element_number, GL_UNSIGNED_INT, elements);
 }
 
@@ -30,37 +11,19 @@ gameobject::gameobject(shader *render_shader) {
   glGenVertexArrays(1, &vao);
 }
 
-void gameobject::genEbo(GLuint elements[], GLuint size) {
+void gameobject::genEbo() {
-
-  this->elements = elements;
-  element_number = size;
-
   glGenBuffers(1, &ebo); // Generate 1 buffer
 
   glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
 
-  glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLuint) * element_number,
+  glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLuint)*element_number, elements,
-               elements, GL_STATIC_DRAW);
+               GL_STATIC_DRAW);
 }
 
 void gameobject::genVbo(GLfloat vertices[], GLuint size) {
-
-  this->vertices = vertices;
-  vertice_number = size;
-
   glGenBuffers(1, &vbo); // Generate 1 buffer
 
   glBindBuffer(GL_ARRAY_BUFFER, vbo);
 
-  glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * size, vertices,
+  glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * size, vertices, GL_STATIC_DRAW);
-               GL_STATIC_DRAW);
-}
-
-void gameobject::setVertexAtribPointer(std::string param, int size,
-                                       bool normalise, int stride,
-                                       const void *pointer) {
-  GLint posAttrib = rend_shader->getInputId(param);
-  glEnableVertexAttribArray(posAttrib);
-  glVertexAttribPointer(posAttrib, size, GL_FLOAT, GL_FALSE,
-                        stride * sizeof(GLfloat), pointer);
 }

engine/object.hpp

@@ -5,7 +5,6 @@
 #include <SDL2/SDL.h>
 #include <SDL2/SDL_opengl.h>
 #include <SDL2/SDL_video.h>
-#include <vector>
 #include "shader.hpp"
 
 /*
@@ -16,23 +15,17 @@ class gameobject{
 public:
   shader *rend_shader;
 
+  GLuint vbo;
   GLuint vao;
   
   GLuint element_number;
   GLuint ebo;
   GLuint *elements;
 
-  GLuint vertice_number;
-  GLuint vbo;
-  GLfloat *vertices;
-
   void render();
 
   void genVbo(GLfloat vertices[], GLuint size);
-
+  void genEbo();
-  void setVertexAtribPointer(std::string param, int size, bool normalise, int stride, const void * pointer);
-  //void genVbo(std::vector<GLfloat> vertices);
-  void genEbo(GLuint elements[], GLuint size);
 
   gameobject(shader *render_shader);
 private:

engine/rendering.cpp

@@ -172,6 +172,6 @@ bool rendering::Shaderinit() {
 
 void rendering::render(){
   for (int i=0; i<objects.size(); i++) {
-    objects.at(i).get().render();
+    objects.at(i).render();
   }
 }

engine/rendering.hpp

@@ -5,7 +5,6 @@
 #include <SDL2/SDL.h>
 #include <SDL2/SDL_opengl.h>
 #include <SDL2/SDL_video.h>
-#include <functional>
 #include <vector>
 #include <iostream>
 #include <fstream>
@@ -33,7 +32,7 @@ public:
   std::vector<GLuint> vertex_shaders;
   std::vector<GLuint> fragment_shaders;
   std::vector<shader> shaders;
-  std::vector< std::reference_wrapper<gameobject> > objects;
+  std::vector<gameobject> objects;
 
   //temporary
   void render();

test.cpp

@@ -2,7 +2,6 @@
 #include "engine/rendering.hpp"
 #include "engine/shader.hpp"
 #include <SDL2/SDL_video.h>
-#include <iostream>
 int main(int argc, char *argv[]) {
   rendering renderer;
 
@@ -22,29 +21,36 @@ int main(int argc, char *argv[]) {
 
   GLuint elements[] = {0, 2, 3, 1, 2, 3};
 
-  gameobject test(&renderer.shaders.at(0));
-  renderer.objects.push_back(test);
-  test.genVbo(vertices, 20);
-  test.genEbo(elements, 2);
-  glBindVertexArray(test.vao);
-  test.rend_shader->use();
-  test.setVertexAtribPointer("position",2, false, 5, 0);
-  test.setVertexAtribPointer("color",3, false, 5, (void *)(2 * sizeof(GLfloat)));
 
-  gameobject test2(&renderer.shaders.at(0));
+  gameobject test(&renderer.shaders.at(0));
-  renderer.objects.push_back(test2);
+  // renderer.objects.push_back(test);
-  test2.genVbo(vertices, 20);
+
-  test2.genEbo(elements, 2);
+  test.element_number = 6;
-  glBindVertexArray(test2.vao);
+  test.elements = elements;
-  test2.rend_shader->use();
+
-  test2.setVertexAtribPointer("position",2, false, 5, 0);
+  test.genVbo(vertices, 20);
-  test2.setVertexAtribPointer("color",2, false, 5, (void *)(2 * sizeof(GLfloat)));
+  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;
 
-  //std::cout<<renderer.objects.at(0).get().element_number;
-
-
   while (true) {
     if (SDL_PollEvent(&windowEvent)) {
       if (windowEvent.type == SDL_QUIT)
@@ -56,17 +62,17 @@ int main(int argc, char *argv[]) {
 
     GLenum err = glGetError();
   if (err != GL_NO_ERROR) {
-      //std::cout << err << "\n" << posAttrib;
+    std::cout << err<<"\n"<<posAttrib;
     return -1;
   }
-    renderer.render();
+    // renderer.render();
     // test.render();
-    //test2.render();
+    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, elements);
-    //glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, elements);
 
     SDL_GL_SwapWindow(window);
   }
 
+  
   SDL_GL_DeleteContext(renderer.context);
 
   SDL_Quit();