Adding better instanced rendering support and buffer textures

.gitignore

@@ -45,3 +45,4 @@ compile_commands.json
 *.exe
 *.out
 *.app
+/.vs

include/polyscope/render/engine.h

@@ -36,7 +36,7 @@ enum class DrawMode {
   TriangleStripInstanced,
 };
 
-enum class TextureFormat { RGB8 = 0, RGBA8, RG16F, RGB16F, RGBA16F, RGBA32F, RGB32F, R32F, R16F, DEPTH24 };
+enum class TextureFormat { RGB8 = 0, RGBA8, RG16F, RGB16F, RGBA16F, RGBA32F, RGB32F, R32F, R16F, DEPTH24, R32UI, R32I };
 enum class RenderBufferType { Color, ColorAlpha, Depth, Float4 };
 enum class DepthMode { Less, LEqual, LEqualReadOnly, Greater, Disable, PassReadOnly };
 enum class BlendMode { AlphaOver, OverNoWrite, AlphaUnder, Zero, WeightedAdd, Add, Source, Disable };
@@ -291,12 +291,12 @@ struct ShaderSpecUniform {
   const RenderDataType type;
 };
 struct ShaderSpecAttribute {
-  ShaderSpecAttribute(std::string name_, RenderDataType type_) : name(name_), type(type_), arrayCount(1) {}
-  ShaderSpecAttribute(std::string name_, RenderDataType type_, int arrayCount_)
-      : name(name_), type(type_), arrayCount(arrayCount_) {}
+  ShaderSpecAttribute(std::string name_, RenderDataType type_, int arrayCount_ = 1, int attribDivisor = 0)
+      : name(name_), type(type_), arrayCount(arrayCount_), attribDivisor(attribDivisor) {}
   const std::string name;
   const RenderDataType type;
   const int arrayCount; // number of times this element is repeated in an array
+  const int attribDivisor;
 };
 struct ShaderSpecTexture {
   const std::string name;
@@ -401,6 +401,7 @@ class ShaderProgram {
 
   // Indices
   virtual void setInstanceCount(uint32_t instanceCount) = 0;
+  virtual void setInstanceVertexCount(uint32_t instanceVertexCount) = 0;
 
   // Call once to initialize GLSL code used by multiple shaders
   static void initCommonShaders(); // TODO
@@ -432,6 +433,7 @@ class ShaderProgram {
 
   // instancing
   uint32_t instanceCount = INVALID_IND_32;
+  uint32_t instanceVertexCount = INVALID_IND_32;
 };
 
 
@@ -549,6 +551,9 @@ class Engine {
                                                                unsigned int sizeY_, unsigned int sizeZ_,
                                                                const float* data) = 0; // 3d
 
+  // create buffer texture
+  virtual std::shared_ptr<TextureBuffer> generateStorageTextureBuffer(TextureFormat format, unsigned int size1D, void* data) = 0;
+
   // create render buffers
   virtual std::shared_ptr<RenderBuffer> generateRenderBuffer(RenderBufferType type, unsigned int sizeX_,
                                                              unsigned int sizeY_) = 0;

include/polyscope/render/mock_opengl/mock_gl_engine.h

@@ -139,6 +139,38 @@ class GLTextureBuffer : public TextureBuffer {
 protected:
 };
 
+class GLStorageTextureBuffer : public GLTextureBuffer {
+public:
+  ~GLStorageTextureBuffer() override;
+  void resize(unsigned newLen) override;
+  void resize(unsigned newX, unsigned newY) override;
+  void resize(unsigned newX, unsigned newY, unsigned newZ) override;
+  void setData(const std::vector<glm::vec2>& data) override;
+  void setData(const std::vector<glm::vec3>& data) override;
+  void setData(const std::vector<glm::vec4>& data) override;
+  void setData(const std::vector<float>& data) override;
+  void setData(const std::vector<double>& data) override;
+  void setData(const std::vector<int32_t>& data) override;
+  void setData(const std::vector<uint32_t>& data) override;
+  void setData(const std::vector<glm::uvec2>& data) override;
+  void setData(const std::vector<glm::uvec3>& data) override;
+  void setData(const std::vector<glm::uvec4>& data) override;
+  void setData(const std::vector<std::array<glm::vec3, 2>>& data) override;
+  void setData(const std::vector<std::array<glm::vec3, 3>>& data) override;
+  void setData(const std::vector<std::array<glm::vec3, 4>>& data) override;
+  void setFilterMode(FilterMode newMode) override;
+  void* getNativeHandle() override;
+  uint32_t getNativeBufferID() override;
+  std::vector<float> getDataScalar() override;
+  std::vector<glm::vec2> getDataVector2() override;
+  std::vector<glm::vec3> getDataVector3() override;
+
+  // Note: underlying buffer uses R32F as the internal format
+  // to support other formats here resizing, setData and getData need new logic
+  GLStorageTextureBuffer(TextureFormat format, unsigned int size1D, void* data);
+protected:
+};
+
 class GLRenderBuffer : public RenderBuffer {
 public:
   GLRenderBuffer(RenderBufferType type, unsigned int sizeX_, unsigned int sizeY_);
@@ -280,8 +312,9 @@ class GLShaderProgram : public ShaderProgram {
   void setIndex(std::shared_ptr<AttributeBuffer> externalBuffer) override;
   void setPrimitiveRestartIndex(unsigned int restartIndex) override;
 
-  // Indices
+  // Instancing
   void setInstanceCount(uint32_t instanceCount) override;
+  void setInstanceVertexCount(uint32_t instanceVertexCount) override;
 
   // Textures
   bool hasTexture(std::string name) override;
@@ -384,6 +417,9 @@ class MockGLEngine : public Engine {
                                                        unsigned int sizeZ_,
                                                        const float* data) override; // 3d
 
+  // create buffer texture
+  std::shared_ptr<TextureBuffer> generateStorageTextureBuffer(TextureFormat format, unsigned int size1D, void* data) override;
+
   // create render buffers
   std::shared_ptr<RenderBuffer> generateRenderBuffer(RenderBufferType type, unsigned int sizeX_,
                                                      unsigned int sizeY_) override;

include/polyscope/render/opengl/gl_engine.h

@@ -30,6 +30,7 @@ namespace backend_openGL3 {
 
 // Some very nice typdefs
 typedef GLuint TextureBufferHandle;
+typedef GLuint TextureStorageBufferHandle;
 typedef GLuint RenderBufferHandle;
 typedef GLuint FrameBufferHandle;
 typedef GLuint ShaderHandle;
@@ -167,12 +168,52 @@ class GLTextureBuffer : public TextureBuffer {
   std::vector<glm::vec3> getDataVector3() override;
 
   void bind();
-  GLenum textureType();
+  virtual GLenum textureType();
   TextureBufferHandle getHandle() const { return handle; }
 
 
 protected:
   TextureBufferHandle handle;
+
+  static GLTextureBuffer createUnintializedTextureBuffer(TextureFormat format, unsigned int size1D);
+
+private:
+  GLTextureBuffer(): TextureBuffer(1, TextureFormat::RGB8, 0), handle{0} {}
+};
+
+class GLStorageTextureBuffer : public GLTextureBuffer {
+public:
+  ~GLStorageTextureBuffer() override;
+  void resize(unsigned newLen) override;
+  void resize(unsigned newX, unsigned newY) override;
+  void resize(unsigned newX, unsigned newY, unsigned newZ) override;
+  void setData(const std::vector<glm::vec2>& data) override;
+  void setData(const std::vector<glm::vec3>& data) override;
+  void setData(const std::vector<glm::vec4>& data) override;
+  void setData(const std::vector<float>& data) override;
+  void setData(const std::vector<double>& data) override;
+  void setData(const std::vector<int32_t>& data) override;
+  void setData(const std::vector<uint32_t>& data) override;
+  void setData(const std::vector<glm::uvec2>& data) override;
+  void setData(const std::vector<glm::uvec3>& data) override;
+  void setData(const std::vector<glm::uvec4>& data) override;
+  void setData(const std::vector<std::array<glm::vec3, 2>>& data) override;
+  void setData(const std::vector<std::array<glm::vec3, 3>>& data) override;
+  void setData(const std::vector<std::array<glm::vec3, 4>>& data) override;
+  void setFilterMode(FilterMode newMode) override;
+  void* getNativeHandle() override;
+  uint32_t getNativeBufferID() override;
+  std::vector<float> getDataScalar() override;
+  std::vector<glm::vec2> getDataVector2() override;
+  std::vector<glm::vec3> getDataVector3() override;
+
+  GLenum textureType() override;
+
+  // Note: underlying buffer expects a type with 4 bytes and 1 dimension as the internal format
+  // to support other formats here resizing, setData and getData need new logic
+  GLStorageTextureBuffer(TextureFormat format, unsigned int size1D, void* data);
+protected:
+  TextureStorageBufferHandle bufferHandle;
 };
 
 class GLRenderBuffer : public RenderBuffer {
@@ -237,6 +278,7 @@ struct GLShaderAttribute {
   std::string name;
   RenderDataType type;
   int arrayCount;
+  int attribDivisor;
   AttributeLocation location;              // -1 means "no location", usually because it was optimized out
   std::shared_ptr<GLAttributeBuffer> buff; // the buffer that we will actually use
 };
@@ -326,6 +368,7 @@ class GLShaderProgram : public ShaderProgram {
 
   // Instancing
   void setInstanceCount(uint32_t instanceCount) override;
+  void setInstanceVertexCount(uint32_t instanceVertexCount) override;
 
   // Textures
   bool hasTexture(std::string name) override;
@@ -403,6 +446,9 @@ class GLEngine : public Engine {
                                                        unsigned int sizeZ_,
                                                        const float* data) override; // 3d
 
+  // create buffer texture
+  std::shared_ptr<TextureBuffer> generateStorageTextureBuffer(TextureFormat format, unsigned int size1D, void* data) override;
+
   // create render buffers
   std::shared_ptr<RenderBuffer> generateRenderBuffer(RenderBufferType type, unsigned int sizeX_,
                                                      unsigned int sizeY_) override;

src/render/engine.cpp

@@ -25,6 +25,8 @@ int dimension(const TextureFormat& x) {
     case TextureFormat::RGB32F:   return 3;
     case TextureFormat::RGBA32F:  return 4;
     case TextureFormat::DEPTH24:  return 1;
+    case TextureFormat::R32UI:    return 1;
+    case TextureFormat::R32I:     return 1;
   }
   // clang-format on
   exception("bad enum");
@@ -44,6 +46,8 @@ int sizeInBytes(const TextureFormat& f) {
     case TextureFormat::RGB32F:   return 3*4;
     case TextureFormat::RGBA32F:  return 4*4;
     case TextureFormat::DEPTH24:  return 1*3;
+    case TextureFormat::R32UI:    return 1*4;
+    case TextureFormat::R32I:     return 1*4;
   }
   // clang-format on
   return -1;

src/render/mock_opengl/mock_gl_engine.cpp

@@ -519,6 +519,116 @@ void GLTextureBuffer::bind() {
   checkGLError();
 }
 
+GLStorageTextureBuffer::~GLStorageTextureBuffer() {}
+
+void GLStorageTextureBuffer::resize(unsigned newLen) {
+  // intentionally skipping the logic of GLTextureBuffer::resize here
+  TextureBuffer::resize(newLen);  // NOLINT(bugprone-parent-virtual-call)
+
+  checkGLError();
+}
+
+void GLStorageTextureBuffer::resize(unsigned newX, unsigned newY) {
+  exception("buffer textures only support 1 dimension");
+}
+
+void GLStorageTextureBuffer::resize(unsigned newX, unsigned newY, unsigned newZ) {
+  exception("buffer textures only support 1 dimension");
+}
+
+void GLStorageTextureBuffer::setData(const std::vector<glm::vec2>& data) {
+  exception("not implemented"); 
+}
+
+void GLStorageTextureBuffer::setData(const std::vector<glm::vec3>& data) {
+  exception("not implemented"); 
+}
+
+void GLStorageTextureBuffer::setData(const std::vector<glm::vec4>& data) {
+  exception("not implemented"); 
+}
+
+void GLStorageTextureBuffer::setData(const std::vector<float>& data) {
+  if (data.size() != getTotalSize()) {
+    exception("OpenGL error: texture buffer data is not the right size.");
+  }
+
+  checkGLError();
+}
+
+void GLStorageTextureBuffer::setData(const std::vector<double>& data) {
+  exception("not implemented"); 
+}
+
+void GLStorageTextureBuffer::setData(const std::vector<int32_t>& data) {
+  exception("not implemented"); 
+}
+
+void GLStorageTextureBuffer::setData(const std::vector<uint32_t>& data) {
+  exception("not implemented"); 
+}
+
+void GLStorageTextureBuffer::setData(const std::vector<glm::uvec2>& data) {
+  exception("not implemented"); 
+}
+
+void GLStorageTextureBuffer::setData(const std::vector<glm::uvec3>& data) {
+  exception("not implemented"); 
+}
+
+void GLStorageTextureBuffer::setData(const std::vector<glm::uvec4>& data) {
+  exception("not implemented"); 
+}
+
+void GLStorageTextureBuffer::setData(const std::vector<std::array<glm::vec3, 2>>& data) {
+  exception("not implemented"); 
+}
+
+void GLStorageTextureBuffer::setData(const std::vector<std::array<glm::vec3, 3>>& data) {
+  exception("not implemented"); 
+}
+
+void GLStorageTextureBuffer::setData(const std::vector<std::array<glm::vec3, 4>>& data) {
+  exception("not implemented"); 
+}
+
+void GLStorageTextureBuffer::setFilterMode(FilterMode newMode) {
+  // no-op
+}
+
+void* GLStorageTextureBuffer::getNativeHandle() {
+  return GLTextureBuffer::getNativeHandle();
+}
+
+uint32_t GLStorageTextureBuffer::getNativeBufferID() {
+  return GLTextureBuffer::getNativeBufferID();
+}
+
+std::vector<float> GLStorageTextureBuffer::getDataScalar() {
+  std::vector<float> outData;
+  outData.resize(getTotalSize());
+
+  return outData;
+}
+
+std::vector<glm::vec2> GLStorageTextureBuffer::getDataVector2() {
+  std::vector<glm::vec2> outData;
+  outData.resize(getTotalSize());
+  exception("not implemented");
+  return outData;
+}
+
+std::vector<glm::vec3> GLStorageTextureBuffer::getDataVector3() {
+  std::vector<glm::vec3> outData;
+  outData.resize(getTotalSize());
+  exception("not implemented");
+  return outData;
+}
+
+GLStorageTextureBuffer::GLStorageTextureBuffer(TextureFormat format, unsigned int size1D, void* data): GLTextureBuffer{format, size1D} {
+  if (sizeInBytes(format) != 4 && dimension(format) != 1) exception("Unsupported format specified. Format with 1 dimesnion and 4 bytes expected.");
+}
+
 // =============================================================
 // ===================== Render buffer =========================
 // =============================================================
@@ -1481,6 +1591,9 @@ void GLShaderProgram::validateData() {
     if (instanceCount == INVALID_IND_32) {
       throw std::invalid_argument("Must set instance count to use instanced drawing");
     }
+    if (instanceVertexCount == INVALID_IND_32) {
+      throw std::invalid_argument("Must set instance vertex count to use instanced drawing");
+    }
   }
 }
 
@@ -1493,6 +1606,7 @@ void GLShaderProgram::setPrimitiveRestartIndex(unsigned int restartIndex_) {
 }
 
 void GLShaderProgram::setInstanceCount(uint32_t instanceCount_) { instanceCount = instanceCount_; }
+void GLShaderProgram::setInstanceVertexCount(uint32_t instanceVertexCount_) { instanceVertexCount = instanceVertexCount_; }
 
 void GLShaderProgram::activateTextures() {
   for (GLShaderTexture& t : textures) {
@@ -1742,6 +1856,11 @@ std::shared_ptr<TextureBuffer> MockGLEngine::generateTextureBuffer(TextureFormat
   return std::shared_ptr<TextureBuffer>(newT);
 }
 
+std::shared_ptr<TextureBuffer> MockGLEngine::generateStorageTextureBuffer(TextureFormat format, unsigned int size1D, void* data) {
+  GLStorageTextureBuffer* newT = new GLStorageTextureBuffer(format, size1D, data);
+  return std::shared_ptr<TextureBuffer>(newT);
+}
+
 
 std::shared_ptr<RenderBuffer> MockGLEngine::generateRenderBuffer(RenderBufferType type, unsigned int sizeX_,
                                                                  unsigned int sizeY_) {