support for geometry shaders

wrapper/Shader.cpp

@@ -4,13 +4,22 @@
 #include "wrapper/GL.h"
 #include "wrapper/Shader.h"
 
-Shader::Shader(const char* vertexPath, const char* fragmentPath) : vertexShader(0), fragmentShader(0), program(0) {
+Shader::Shader(const char* vertexPath, const char* fragmentPath,
+               const char* geometryPath)
+    : vertexShader(0), geometryShader(0), fragmentShader(0), program(0) {
     if(readFileAndCompile(vertexPath, vertexShader, GL_VERTEX_SHADER) ||
        readFileAndCompile(fragmentPath, fragmentShader, GL_FRAGMENT_SHADER)) {
         return;
     }
+    if(geometryPath != nullptr &&
+       readFileAndCompile(geometryPath, geometryShader, GL_GEOMETRY_SHADER)) {
+        return;
+    }
     program = glCreateProgram();
     glAttachShader(program, vertexShader);
+    if(geometryPath != nullptr) {
+        glAttachShader(program, geometryShader);
+    }
     glAttachShader(program, fragmentShader);
     glLinkProgram(program);
     if(GL::checkAndPrintError("cannot link")) {
@@ -22,17 +31,25 @@ Shader::Shader(const char* vertexPath, const char* fragmentPath) : vertexShader(
         ErrorLog log;
         glGetProgramInfoLog(program, log.getLength(), nullptr, log.begin());
         std::cout << "linker log: " << log.begin() << "\n";
+        clean();
         return;
     }
 }
 
 Shader::~Shader() {
+    clean();
+}
+
+void Shader::clean() {
     glDeleteShader(vertexShader);
+    glDeleteShader(geometryShader);
     glDeleteShader(fragmentShader);
     glDeleteProgram(program);
+    program = 0;
 }
 
-bool Shader::readFileAndCompile(const char* path, GLuint& shader, GLenum shaderType) {
+bool Shader::readFileAndCompile(const char* path, GLuint& shader,
+                                GLenum shaderType) {
     std::cout << "shader: " << path << '\n';
     Code code;
     if(readFile(code, path)) {

wrapper/Shader.h

@@ -8,11 +8,13 @@
 
 class Shader final {
     GLuint vertexShader;
+    GLuint geometryShader;
     GLuint fragmentShader;
     GLuint program;
 
 public:
-    Shader(const char* vertexPath, const char* fragmentPath);
+    Shader(const char* vertexPath, const char* fragmentPath,
+           const char* geometryPath = nullptr);
     ~Shader();
     Shader(const Shader& other) = delete;
     Shader(Shader&& other) = delete;
@@ -31,9 +33,11 @@ public:
     void setVector(const GLchar* name, const Vector4& v);
 
 private:
+    void clean();
     typedef Array<GLchar, 1024 * 128> Code;
     typedef Array<GLchar, 1024> ErrorLog;
-    bool readFileAndCompile(const char* path, GLuint& shader, GLenum shaderType);
+    bool readFileAndCompile(const char* path, GLuint& shader,
+                            GLenum shaderType);
     bool readFile(Code& code, const char* path) const;
     bool compile(GLuint& shader, const Code& code, GLenum shaderType);
 };

wrapper/VertexBuffer.cpp

@@ -46,15 +46,19 @@ void VertexBuffer::updateData(int offset, int size, const void* data) {
     glBufferSubData(GL_ARRAY_BUFFER, offset, size, data);
 }
 
-void VertexBuffer::draw(int vertices, int mode, int offset) {
+void VertexBuffer::drawMode(int vertices, int mode, int offset) {
     bindArray();
     glDrawArrays(mode, offset, vertices);
 }
 
 void VertexBuffer::draw(int vertices, int offset) {
-    draw(vertices, GL_TRIANGLES, offset);
+    drawMode(vertices, GL_TRIANGLES, offset);
 }
 
 void VertexBuffer::drawStrip(int vertices, int offset) {
-    draw(vertices, GL_TRIANGLE_STRIP, offset);
+    drawMode(vertices, GL_TRIANGLE_STRIP, offset);
+}
+
+void VertexBuffer::drawPoints(int vertices, int offset) {
+    drawMode(vertices, GL_POINTS, offset);
 }

wrapper/VertexBuffer.h

@@ -25,9 +25,10 @@ public:
 
     void draw(int vertices, int offset = 0);
     void drawStrip(int vertices, int offset = 0);
+    void drawPoints(int vertices, int offset = 0);
 
 private:
-    void draw(int vertices, int mode, int offset = 0);
+    void drawMode(int vertices, int mode, int offset = 0);
     void setData(int size, const void* data, int flag);
     void bindArray() const;
     void bindBuffer() const;