Adds wireframe mode

examples/CMakeLists.txt

@@ -247,6 +247,12 @@ if(NOT APPLE)
 
   add_executable(scatter_geodesic scatter_geodesic.cpp)
   target_link_libraries(scatter_geodesic OpenGL::GL glfw Freetype::Freetype)
+
+  # Instancing also not available on Apple (limited to OpenGL 4.1)
+  add_executable(scatter_instanced scatter_instanced.cpp)
+  target_link_libraries(scatter_instanced OpenGL::GL glfw Freetype::Freetype)
+  add_executable(breadcrumbs breadcrumbs.cpp)
+  target_link_libraries(breadcrumbs OpenGL::GL glfw Freetype::Freetype)
 endif()
 
 add_executable(scatter_dynamic scatter_dynamic.cpp)

examples/breadcrumbs.cpp

@@ -0,0 +1,128 @@
+/*
+ * Visualize a test surface
+ */
+#include <iostream>
+#include <fstream>
+#include <cmath>
+#include <array>
+
+#include <sm/scale>
+#include <sm/vec>
+#include <sm/vvec>
+
+#include <mplot/Visual.h>
+#include <mplot/ColourMap.h>
+#include <mplot/InstancedScatterVisual.h>
+#include <mplot/GeodesicVisual.h>
+
+// Instanced rendering requires OpenGL 4.3 or higher (for the SSBO)
+constexpr int glver = mplot::gl::version_4_3;
+
+constexpr float st = sm::mathconst<float>::two_pi / 360;
+constexpr float z = 0.0f;
+sm::vec<float, 3> f (int i, float _z = 0.0f)
+{
+    float phi = st * i;
+    float r = 1.0f + 0.1f * std::sin (phi * 10.0f);
+    sm::vec<float, 3> xyz = {
+        r * std::sin (phi),
+        r * std::cos (phi),
+        _z
+    };
+    return xyz;
+}
+
+int main()
+{
+    int rtn = -1;
+
+    mplot::Visual<glver> v(1024, 768, "mplot::InstancedScatterVisual");
+    v.lightingEffects();
+
+    // A normal, non instanced model. A sphere to orbit around.
+    auto gv1 = std::make_unique<mplot::GeodesicVisual<float,glver>> (sm::vec<>{}, 0.2f);
+    gv1->name = "geodesic";
+    v.bindmodel (gv1);
+    gv1->iterations = 3;
+    gv1->cm.setType (mplot::ColourMapType::Tofino);
+    gv1->finalize();
+    // re-colour after construction
+    auto gv1p = v.addVisualModel (gv1);
+    // sequential colouring:
+    size_t sz1 = gv1p->data.size();
+    gv1p->data.linspace (0.0f, 1.0f, sz1);
+    gv1p->reinitColours();
+
+    constexpr int dsz = 260;
+    sm::vvec<sm::vec<float, 3>> points(dsz);
+    sm::vvec<float> psz(dsz);
+
+    int i = 0;
+    sm::vec<float, 3> xyz = {};
+    for (i = 0; i < dsz; ++i) {
+        xyz = f (i);
+        points[i] = xyz;
+        psz[i] = xyz[2];
+    }
+
+    auto isv = std::make_unique<mplot::InstancedScatterVisual<glver>> (sm::vec<>{});
+    isv->name = "isv1";
+    v.bindmodel (isv);
+    isv->max_instances = dsz;
+    isv->radiusFixed = 0.03f;
+    isv->finalize();
+    auto isvp = v.addVisualModel (isv);
+
+    // Another one
+    isv = std::make_unique<mplot::InstancedScatterVisual<glver>> (sm::vec<>{0,0.1,0});
+    isv->name = "isv2";
+    v.bindmodel (isv);
+    isv->max_instances = dsz;
+    isv->radiusFixed = 0.03f;
+    isv->finalize();
+    auto isvp2 = v.addVisualModel (isv);
+
+    v.render();
+    isvp->set_instance_data (points); // colour, alpha, scale
+
+    isvp2->set_instance_data (points * 1.2f, mplot::colour::black, 0.7f, 1.0f);
+
+    sm::vvec<std::array<float, 3>> col = { mplot::colour::blue, mplot::colour::springgreen };
+    sm::vvec<float> alph = { 0.5f, 1.0f };
+    sm::vvec<float> scl = { 1.0f, 1.2f };
+
+    while (!v.readyToFinish()) {
+
+        xyz = f (i%360);
+        //std::cout << "i = " << i << ", i%dsz = " << (i%dsz) << ", i%360 = " << (i%360) << " f(i%360) = " << xyz << " -> points[" << (i%dsz)<< "]" <<  std::endl;
+
+        points[i%dsz] = xyz;
+        psz[i%dsz] = xyz[2];
+
+#if 1
+        // Update all points/psz
+        // Place data in SSBO. first call of set_data must occur after first call to v.render()
+        isvp->set_instance_data (points, col, alph, scl);
+
+        v.render();
+        v.waitevents (0.018);
+
+#else // I haven't mastered updating a subrange of data in an SSBO
+        // update circularly, change isvp->instance_start each time
+        std::cout << "updating data with points[i%dsz] = " << points[i%dsz] << std::endl;
+        isvp->update_instance_data (points, data, (i % dsz), (i % dsz));
+
+        std::cout << "Before render, isvp->instance_start is " << isvp->instance_start << std::endl;
+
+        v.render();
+        v.wait (0.4);
+
+        isvp->instance_start += 1;
+        if (isvp->instance_start >= isvp->instance_count) { isvp->instance_start = 0; }
+
+#endif
+        ++i;
+    }
+
+    return rtn;
+}

examples/gl_compute/shader_naive_scan.cpp

@@ -11,7 +11,7 @@
 
 #include <mplot/gl/compute_manager.h>
 #include <mplot/gl/texture.h>
-#include <mplot/gl/ssbo.h>
+#include <mplot/gl/ssbo_nomx.h>
 #include <mplot/gl/shaders.h>
 #include <mplot/loadpng.h>
 

examples/gl_compute/shader_naive_scan_cli.cpp

@@ -17,7 +17,7 @@
 
 #include <mplot/gl/compute_manager_cli.h>
 #include <mplot/gl/texture.h>
-#include <mplot/gl/ssbo.h>
+#include <mplot/gl/ssbo_nomx.h>
 #include <mplot/loadpng.h>
 
 namespace my {

examples/gl_compute/shader_ssbo.cpp

@@ -4,7 +4,7 @@
  */
 
 // You have to include the GL headers manually so that you will be sure you have the
-// right ones. THis is because for OpenGL version 4.3, you would include GL3/gl3.h and
+// right ones. This is because for OpenGL version 4.3, you would include GL3/gl3.h and
 // GL/glext.h whereas if you are targeting OpenGL 3.1 ES, you want to include
 // GLES3/gl3[12].h (and maybe GLES3/gl3ext.h).
 #include <GLES3/gl31.h>
@@ -13,13 +13,15 @@
 #include <mplot/gl/compute_manager.h>
 #include <mplot/gl/util_nomx.h>
 #include <mplot/gl/texture.h>
-#include <mplot/gl/ssbo.h>
+#include <mplot/gl/ssbo_nomx.h>
 #include <mplot/loadpng.h>
 
 namespace my {
 
+    static constexpr int glver = mplot::gl::version_3_1_es;
+
     // Use OpenGL 3.1 ES here
-    struct compute_manager : public mplot::gl::compute_manager<mplot::gl::version_3_1_es>
+    struct compute_manager : public mplot::gl::compute_manager<glver>
     {
         static constexpr int dwidth = 256;
         static constexpr int dheight = 65;
@@ -86,9 +88,12 @@ namespace my {
             sm::vec<unsigned int, 2> _dims = mplot::loadpng ("../examples/gl_compute/bike.png", inputvv);
             if ((_dims - dims) > 0) { throw std::runtime_error ("Loaded image is not expected size"); }
 
+            this->input_ssbo.init (); // could take the image data as arg
+
             // Set that data into the SSBO object (where it is stored in a vec<>)
-            std::copy (inputvv.begin(), inputvv.end(), this->input_ssbo.data.begin());
-            this->input_ssbo.init();
+            sm::vec<float, dsz> data;
+            std::copy (inputvv.begin(), inputvv.end(), data.begin());
+            this->input_ssbo.copy_to_gpu (data);
         }
 
         ~compute_manager()
@@ -119,8 +124,9 @@ namespace my {
             this->compute_program.load_shaders (shaders);
 
             // We'll reuse the vertex/fragment shaders from the shadercompute example
+            std::string defVtxShdr = mplot::getDefaultVtxShader (glver);
             std::vector<mplot::gl::ShaderInfo> vtxshaders = {
-                {GL_VERTEX_SHADER, "../examples/gl_compute/shader_ssbo.vert.glsl", mplot::defaultVtxShader, 0 },
+                {GL_VERTEX_SHADER, "../examples/gl_compute/shader_ssbo.vert.glsl", defVtxShdr.c_str(), 0 },
                 {GL_FRAGMENT_SHADER, "../examples/gl_compute/shader_ssbo.frag.glsl", mplot::defaultFragShader, 0 }
             };
             this->vtxprog = mplot::gl::LoadShaders (vtxshaders);
@@ -130,10 +136,12 @@ namespace my {
         // Override your one time/non-rendering compute function
         void compute() final
         {
-            // To copy updated data:
-            this->input_ssbo.data[0] = std::abs (std::sin (compstep)); // Make a pixel pulse
+            // To copy updated data. Would be nice to give a data subrange to update.
+            sm::vec<float, 2> data_update;
+            data_update[0] = std::abs (std::sin (compstep)); // Make a pixel pulse
+            data_update[1] = std::abs (std::cos (compstep));
             compstep += 0.0001;
-            this->input_ssbo.copy_to_gpu();
+            this->input_ssbo.copy_to_gpu (data_update, 2);
 
             this->measure_compute(); // optional
             this->compute_program.use();
@@ -142,8 +150,14 @@ namespace my {
             // To retreive data from the SSBO:
             // sm::range<float> ssbo_range = this->input_ssbo.get_range();
             // or
-            this->input_ssbo.copy_from_gpu();
-            // and access input_ssbo.data.
+#if 0
+            sm::vec<float, 6> data_rtn;
+            this->input_ssbo.copy_from_gpu (data_rtn, 0);
+            std::cout << "data_rtn[0-5] = "
+                      << data_rtn[0] << ", " << data_rtn[1] << ", "
+                      << data_rtn[2] << ", " << data_rtn[3] << ", "
+                      << data_rtn[4] << ", " << data_rtn[5] << std::endl;
+#endif
         }
 
         // Override the render method to do whatever visualization you want
@@ -194,7 +208,7 @@ namespace my {
         // CPU side input data. This will be SSBO index 1.
         mplot::gl::ssbo<1, float, dsz> input_ssbo;
         // You will need at least one gl::compute_shaderprog
-        mplot::gl::compute_shaderprog<mplot::gl::version_3_1_es> compute_program;
+        mplot::gl::compute_shaderprog<glver> compute_program;
     };
 } // namespace my
 

examples/gl_compute/shadercompute.cpp

@@ -12,7 +12,6 @@
  * https://learnopengl.com/Guest-Articles/2022/Compute-Shaders/Introduction
  */
 
-
 // You have to include the GL headers manually so that you will be sure you have the
 // right ones. This is because for OpenGL version 4.3, you would include GL3/gl3.h and
 // GL/glext.h whereas if you are targeting OpenGL 3.1 ES, you want to include
@@ -25,8 +24,10 @@
 
 namespace my {
 
+    static constexpr int glver = mplot::gl::version_4_5;
+
     // Specify OpenGL version 4.5 (4.3 is min for compute)
-    struct compute_manager : public mplot::gl::compute_manager<mplot::gl::version_4_5>
+    struct compute_manager : public mplot::gl::compute_manager<glver>
     {
         // Call init in your constructor, ensuring *your* version of load_shaders() is called.
         compute_manager()
@@ -80,8 +81,9 @@ namespace my {
             };
             this->compute_program.load_shaders (shaders);
 
+            std::string defVtxShdr = mplot::getDefaultVtxShader (glver);
             std::vector<mplot::gl::ShaderInfo> vtxshaders = {
-                {GL_VERTEX_SHADER, "../examples/gl_compute/shadercompute.vert.glsl", mplot::defaultVtxShader, 0 },
+                {GL_VERTEX_SHADER, "../examples/gl_compute/shadercompute.vert.glsl", defVtxShdr.c_str(), 0 },
                 {GL_FRAGMENT_SHADER, "../examples/gl_compute/shadercompute.frag.glsl", mplot::defaultFragShader, 0 }
             };
             this->vtxprog = mplot::gl::LoadShaders (vtxshaders);
@@ -137,7 +139,7 @@ namespace my {
         unsigned int vao = 0;
         unsigned int vbo = 0;
         // You will need at least one gl::compute_shaderprog
-        mplot::gl::compute_shaderprog<mplot::gl::version_4_5> compute_program;
+        mplot::gl::compute_shaderprog<glver> compute_program;
     };
 } // namespace my
 

examples/hexgrid.cpp

@@ -41,14 +41,15 @@ int main()
 
     // Make some dummy data (a sine wave) to make an interesting surface
     std::vector<float> data(hg.num(), 0.0f);
-    for (unsigned int ri=0; ri<hg.num(); ++ri) {
-        data[ri] = 0.05f + 0.05f*std::sin(20.0f*hg.d_x[ri]) * std::sin(10.0f*hg.d_y[ri]) ; // Range 0->1
+    for (unsigned int ri = 0; ri < hg.num(); ++ri) {
+        data[ri] = 0.05f + 0.05f * std::sin (20.0f * hg.d_x[ri]) * std::sin (10.0f * hg.d_y[ri]) ; // Range 0->1
     }
 
     // Add a HexGridVisual to display the HexGrid within the sm::Visual scene
     sm::vec<float, 3> offset = { 0.0f, -0.05f, 0.0f };
     auto hgv = std::make_unique<mplot::HexGridVisual<float, mplot::gl::version_4_1>>(&hg, offset);
     v.bindmodel (hgv);
+    hgv->wireframe (true);
     hgv->cm.setType (mplot::ColourMapType::Ice);
     hgv->setScalarData (&data);
     hgv->hexVisMode = mplot::HexVisMode::HexInterp; // Or sm::HexVisMode::Triangles for a smoother surface plot

examples/scatter_instanced.cpp

@@ -0,0 +1,60 @@
+/*
+ * Visualize a test surface
+ */
+#include <iostream>
+#include <fstream>
+#include <cmath>
+#include <array>
+
+#include <sm/scale>
+#include <sm/vec>
+#include <sm/vvec>
+
+#include <mplot/Visual.h>
+#include <mplot/ColourMap.h>
+#include <mplot/InstancedScatterVisual.h>
+
+// Instanced rendering requires OpenGL 4.3 or higher (for the SSBO)
+constexpr int glver = mplot::gl::version_4_3;
+
+int main()
+{
+    int rtn = -1;
+
+    mplot::Visual<glver> v(1024, 768, "mplot::InstancedScatterVisual");
+    v.lightingEffects();
+
+    sm::vvec<sm::vec<float, 3>> points(20*20);
+    sm::vvec<float> alpha(20*20, 1.0f);
+    sm::vvec<float> scale(20*20);
+    sm::vvec<std::array<float, 3>> clrs(20*20);
+    size_t k = 0;
+
+    mplot::ColourMap<float> cm (mplot::ColourMapType::Plasma);
+    for (int i = -10; i < 10; ++i) {
+        for (int j = -10; j < 10; ++j) {
+            float x = 0.1*i;
+            float y = 0.1*j;
+            // z is some function of x, y
+            float z = x * std::exp(-(x*x) - (y*y));
+            points[k] = {x, y, z};
+            scale[k] = 1.0f + z;
+            clrs[k] = cm.convert (z);
+            k++;
+        }
+    }
+
+    auto isv = std::make_unique<mplot::InstancedScatterVisual<glver>> (sm::vec<>{});
+    v.bindmodel (isv);
+    isv->radiusFixed = 0.03f;
+    isv->finalize();
+    auto isvp = v.addVisualModel (isv);
+
+    v.render();
+    // We set the instance data, which adds points, colours, alpha and scale
+    isvp->set_instance_data (points, clrs, alpha, scale);
+
+    v.keepOpen();
+
+    return rtn;
+}

mplot/CMakeLists.txt

@@ -76,6 +76,7 @@ install(
   HexGridVisual.h
   HSVWheelVisual.h
   IcosaVisual.h
+  InstancedScatterVisual.h
   LengthscaleVisual.h
   NormalsVisual.h
   PointRowsMeshVisual.h