Fixed BoundingBox rendering problems

.gitignore

 .DS_Store
+.VolumeIcon.icns
+.fseventsd
+Icon
+
 build*

include/BoundingBox.h

   private:
     std::array<glm::vec3, 8> corner;
 
-    static std::vector<glm::vec3> vertices, colorsLine, colorsPoint;
+    static std::vector<glm::vec4> vertices;
+    static std::vector<glm::vec3> colorsLine, colorsPoint;
     static std::vector<unsigned short> indicesLine;
 };
 

include/system/Shader.h

                        gl::GLenum mode = gl::GL_TRIANGLES, ShaderTexture* target = nullptr,
                        Shader& shader = colorShader);
 
+    static void drawGL(std::vector<glm::vec4>& vertices, std::vector<glm::vec3>& colors,
+                       gl::GLenum mode = gl::GL_TRIANGLES, ShaderTexture* target = nullptr,
+                       Shader& shader = transformedColorShader);
+    static void drawGL(std::vector<glm::vec4>& vertices, std::vector<glm::vec3>& colors,
+                       std::vector<unsigned short>& indices, gl::GLenum mode = gl::GL_TRIANGLES,
+                       ShaderTexture* target = nullptr, Shader& shader = transformedColorShader);
+
     static std::string getVersion(bool linked);
 
   private:
     static const char* colorShaderVertex;
     static const char* colorShaderFragment;
 
+    static Shader transformedColorShader;
+    static const char* transformedColorShaderVertex;
+    static const char* transformedColorShaderFragment;
+
     static unsigned int vertexArrayID;
     static bool lastBufferWasNotFramebuffer;
 };

src/BoundingBox.cpp

 
 #include <glbinding/gl/gl.h>
 
-std::vector<glm::vec3> BoundingBox::vertices, BoundingBox::colorsLine, BoundingBox::colorsPoint;
+std::vector<glm::vec4> BoundingBox::vertices;
+std::vector<glm::vec3> BoundingBox::colorsLine, BoundingBox::colorsPoint;
 std::vector<unsigned short> BoundingBox::indicesLine;
 
 BoundingBox::BoundingBox(glm::vec3 min, glm::vec3 max) {
     auto startSize = vertices.size();
 
     for (auto& c : corner) {
-        glm::vec4 t = VP * glm::vec4(c, 1.0f);
-        vertices.emplace_back(glm::vec3(t) / t.w);
+        vertices.emplace_back(VP * glm::vec4(c, 1.0f));
         colorsLine.emplace_back(colorLine);
         colorsPoint.emplace_back(colorDot);
     }
 
 void BoundingBox::display() {
     if (vertices.size() > 0) {
-        Shader::drawGL(vertices, colorsLine, indicesLine, glm::mat4(1.0f), gl::GL_LINES);
-        Shader::drawGL(vertices, colorsPoint, glm::mat4(1.0f), gl::GL_POINTS);
+        Shader::drawGL(vertices, colorsLine, indicesLine, gl::GL_LINES);
+        Shader::drawGL(vertices, colorsPoint, gl::GL_POINTS);
     }
 
     vertices.clear();

src/system/Shader.cpp

 
 Shader Shader::textureShader;
 Shader Shader::colorShader;
+Shader Shader::transformedColorShader;
 unsigned int Shader::vertexArrayID = 0;
 bool Shader::lastBufferWasNotFramebuffer = true;
 
     if (colorShader.addUniform("MVP") < 0)
         return -5;
 
+    if (transformedColorShader.compile(transformedColorShaderVertex, transformedColorShaderFragment) < 0)
+        return -6;
+
     return 0;
 }
 
     shader.otherBuffer.unbind(1);
 }
 
+void Shader::drawGL(std::vector<glm::vec4>& vertices, std::vector<glm::vec3>& colors,
+                    gl::GLenum mode, ShaderTexture* target, Shader& shader) {
+    bindProperBuffer(target);
+
+    shader.use();
+    shader.vertexBuffer.bufferData(vertices);
+    shader.otherBuffer.bufferData(colors);
+
+    shader.vertexBuffer.bindBuffer(0, 4);
+    shader.otherBuffer.bindBuffer(1, 3);
+
+    gl::glDrawArrays(mode, 0, shader.vertexBuffer.getSize());
+
+    shader.vertexBuffer.unbind(0);
+    shader.otherBuffer.unbind(0);
+}
+
+void Shader::drawGL(std::vector<glm::vec4>& vertices, std::vector<glm::vec3>& colors,
+                    std::vector<unsigned short>& indices, gl::GLenum mode,
+                    ShaderTexture* target, Shader& shader) {
+    bindProperBuffer(target);
+
+    shader.use();
+    shader.vertexBuffer.bufferData(vertices);
+    shader.otherBuffer.bufferData(colors);
+    shader.indexBuffer.bufferData(indices);
+
+    shader.vertexBuffer.bindBuffer(0, 4);
+    shader.otherBuffer.bindBuffer(1, 3);
+    shader.indexBuffer.bindBuffer();
+
+    gl::glDrawElements(mode, shader.indexBuffer.getSize(), gl::GL_UNSIGNED_SHORT, nullptr);
+
+    shader.vertexBuffer.unbind(0);
+    shader.otherBuffer.unbind(0);
+}
+
 // --------------------------------------
 // *INDENT-OFF*
 
 )!?!";
 
 // --------------------------------------
+
+const char* Shader::transformedColorShaderVertex = R"!?!(
+#version 330 core
+
+layout(location = 0) in vec4 vertexPosition;
+layout(location = 1) in vec3 vertexColor;
+
+out vec3 color;
+
+void main() {
+    gl_Position = vertexPosition;
+    color = vertexColor;
+}
+)!?!";
+
+const char* Shader::transformedColorShaderFragment = R"!?!(
+#version 330 core
+
+in vec3 color;
+
+layout(location = 0) out vec4 color_out;
+
+void main() {
+    color_out = vec4(color, 1);
+}
+)!?!";
+
+// --------------------------------------
 // *INDENT-ON*