Support geometry shaders

cmake/macros/AutoScribeShader.cmake

@@ -44,6 +44,8 @@ function(AUTOSCRIBE_SHADER SHADER_FILE)
         set(SHADER_TARGET ${SHADER_TARGET}_vert.h)
     elseif(${SHADER_EXT} STREQUAL .slf) 
         set(SHADER_TARGET ${SHADER_TARGET}_frag.h)
+    elseif(${SHADER_EXT} STREQUAL .slg) 
+        set(SHADER_TARGET ${SHADER_TARGET}_geom.h)
     endif()
 
     set(SHADER_TARGET "${SHADERS_DIR}/${SHADER_TARGET}")
@@ -87,7 +89,7 @@ macro(AUTOSCRIBE_SHADER_LIB)
   #message(${HIFI_LIBRARIES_SHADER_INCLUDE_FILES})
 
   file(GLOB_RECURSE SHADER_INCLUDE_FILES src/*.slh)
-  file(GLOB_RECURSE SHADER_SOURCE_FILES src/*.slv src/*.slf)
+  file(GLOB_RECURSE SHADER_SOURCE_FILES src/*.slv src/*.slf src/*.slg)
 
   #make the shader folder
   set(SHADERS_DIR "${CMAKE_CURRENT_BINARY_DIR}/shaders/${TARGET_NAME}")

libraries/gpu-gl/src/gpu/gl/GLShader.cpp

@@ -25,40 +25,45 @@ GLShader::~GLShader() {
     }
 }
 
+// GLSL version
+static const std::string glslVersion {
+    "#version 410 core"
+};
+
+// Shader domain
+static const size_t NUM_SHADER_DOMAINS = 3;
+
+// GL Shader type enums
+// Must match the order of type specified in gpu::Shader::Type
+static const std::array<GLenum, NUM_SHADER_DOMAINS> SHADER_DOMAINS { {
+    GL_VERTEX_SHADER,
+    GL_FRAGMENT_SHADER,
+    GL_GEOMETRY_SHADER,
+} };
+
+// Domain specific defines
+// Must match the order of type specified in gpu::Shader::Type
+static const std::array<std::string, NUM_SHADER_DOMAINS> DOMAIN_DEFINES { {
+    "#define GPU_VERTEX_SHADER",
+    "#define GPU_PIXEL_SHADER",
+    "#define GPU_GEOMETRY_SHADER",
+} };
+
+// Versions specific of the shader
+static const std::array<std::string, GLShader::NumVersions> VERSION_DEFINES { {
+    ""
+} };
+
 GLShader* compileBackendShader(const Shader& shader) {
     // Any GLSLprogram ? normally yes...
     const std::string& shaderSource = shader.getSource().getCode();
-
-    // GLSL version
-    const std::string glslVersion = {
-        "#version 410 core"
-    };
-
-    // Shader domain
-    const int NUM_SHADER_DOMAINS = 2;
-    const GLenum SHADER_DOMAINS[NUM_SHADER_DOMAINS] = {
-        GL_VERTEX_SHADER,
-        GL_FRAGMENT_SHADER
-    };
     GLenum shaderDomain = SHADER_DOMAINS[shader.getType()];
-
-    // Domain specific defines
-    const std::string domainDefines[NUM_SHADER_DOMAINS] = {
-        "#define GPU_VERTEX_SHADER",
-        "#define GPU_PIXEL_SHADER"
-    };
-
-    // Versions specific of the shader
-    const std::string versionDefines[GLShader::NumVersions] = {
-        ""
-    };
-
     GLShader::ShaderObjects shaderObjects;
 
     for (int version = 0; version < GLShader::NumVersions; version++) {
         auto& shaderObject = shaderObjects[version];
 
-        std::string shaderDefines = glslVersion + "\n" + domainDefines[shader.getType()] + "\n" + versionDefines[version];
+        std::string shaderDefines = glslVersion + "\n" + DOMAIN_DEFINES[shader.getType()] + "\n" + VERSION_DEFINES[version];
 
         bool result = compileShader(shaderDomain, shaderSource, shaderDefines, shaderObject.glshader, shaderObject.glprogram);
         if (!result) {

libraries/gpu/src/gpu/Shader.cpp

@@ -31,6 +31,13 @@ Shader::Shader(Type type, const Pointer& vertex, const Pointer& pixel):
     _shaders[PIXEL] = pixel;
 }
 
+Shader::Shader(Type type, const Pointer& vertex, const Pointer& geometry, const Pointer& pixel) :
+_type(type) {
+    _shaders.resize(3);
+    _shaders[VERTEX] = vertex;
+    _shaders[GEOMETRY] = geometry;
+    _shaders[PIXEL] = pixel;
+}
 
 Shader::~Shader()
 {
@@ -44,6 +51,10 @@ Shader::Pointer Shader::createPixel(const Source& source) {
     return Pointer(new Shader(PIXEL, source));
 }
 
+Shader::Pointer Shader::createGeometry(const Source& source) {
+    return Pointer(new Shader(GEOMETRY, source));
+}
+
 Shader::Pointer Shader::createProgram(const Pointer& vertexShader, const Pointer& pixelShader) {
     if (vertexShader && vertexShader->getType() == VERTEX &&
         pixelShader && pixelShader->getType() == PIXEL) {
@@ -52,6 +63,15 @@ Shader::Pointer Shader::createProgram(const Pointer& vertexShader, const Pointer
     return Pointer();
 }
 
+Shader::Pointer Shader::createProgram(const Pointer& vertexShader, const Pointer& geometryShader, const Pointer& pixelShader) {
+    if (vertexShader && vertexShader->getType() == VERTEX &&
+        geometryShader && geometryShader->getType() == GEOMETRY &&
+        pixelShader && pixelShader->getType() == PIXEL) {
+        return Pointer(new Shader(PROGRAM, vertexShader, geometryShader, pixelShader));
+    }
+    return Pointer();
+}
+
 void Shader::defineSlots(const SlotSet& uniforms, const SlotSet& buffers, const SlotSet& textures, const SlotSet& samplers, const SlotSet& inputs, const SlotSet& outputs) {
     _uniforms = uniforms;
     _buffers = buffers;

libraries/gpu/src/gpu/Shader.h

@@ -110,8 +110,10 @@ public:
 
     static Pointer createVertex(const Source& source);
     static Pointer createPixel(const Source& source);
+    static Pointer createGeometry(const Source& source);
 
     static Pointer createProgram(const Pointer& vertexShader, const Pointer& pixelShader);
+    static Pointer createProgram(const Pointer& vertexShader, const Pointer& geometryShader, const Pointer& pixelShader);
 
 
     ~Shader();
@@ -163,6 +165,7 @@ public:
 protected:
     Shader(Type type, const Source& source);
     Shader(Type type, const Pointer& vertex, const Pointer& pixel);
+    Shader(Type type, const Pointer& vertex, const Pointer& geometry, const Pointer& pixel);
 
     Shader(const Shader& shader); // deep copy of the sysmem shader
     Shader& operator=(const Shader& shader); // deep copy of the sysmem texture