polyscope 2.2.0__tar.gz → 2.3.0__tar.gz

{polyscope-2.2.0/src/polyscope.egg-info → polyscope-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: polyscope
-Version: 2.2.0
+Version: 2.3.0
 Summary: Polyscope: A viewer and user interface for 3D data.
 Home-page: https://polyscope.run
 Author: Nicholas Sharp

{polyscope-2.2.0 → polyscope-2.3.0}/README.md

@@ -30,14 +30,16 @@ polyscope-py should work out-of-the-box on any combination of Python 3.5-3.12 an
 This repo is configured with CI on github actions. 
 
 - By default, all commits to the main branch build & run tests. Use `[ci skip]` to skip this.
-- Tagging a commit with `[ci build]` causes it to also build all precompiled wheels and upload them as artifacts.
-- Creating a tagged version like `v1.2.3` will build wheels as above, and ALSO automatically upload them to pypi as described below.
+- Tagging a commit with `[ci build]` causes it to also build all precompiled wheels on a matrix of platforms to ensure the build scripts succeed.
+- Tagging a commit with `[ci publish]` causes it to build all precompiled wheels on a matrix of platforms AND upload them to pypi index
 
 ### Deploy a new version
 
-- Commit the desired version to the `master` branch, be sure the version string in `setup.py` corresponds to the new version number. Use the `[ci build]` tag in the commit message to trigger builds, which should take about an hour.
+- Commit the desired version to the `master` branch. Use the `[ci build]` string in the commit message to trigger builds, which should take about an hour.
 - Watch the github actions builds to ensure all wheels build successfully. The resulting binaries will be saved as artifacts if you want try test with them.
 - While you're waiting, update the docs, including the changelog.
-- Tag the commit with a tag like `v1.2.3`, matching the version in `setup.py`. This will kick off a new github actions build which deploys the wheels to PyPI after compilation.
-- If we are still doing builds with multiple rounds of actions, it may be necessary to manually upload some of the generated wheels. Download from the github actions `Summary/Artifacs` pane, then upload with `twine upload * --skip-existing`
+- Update the version string in `setup.py` to the new version number. When you commit, include the string `[ci publish]`, which will kick of a publish job to build wheels again AND upload them to PyPI.
+- If something goes wrong with the build & publish, you can manually retry by pushing any new commit with "[ci publish]" in the message.
+- Create a github release. Tag the release commit with a tag like `v1.2.3`, matching the version in `setup.py`
+
 - Update the conda builds by committing to the [feedstock repository](https://github.com/conda-forge/polyscope-feedstock). This generally just requires bumping the version number and updating the hash in `meta.yml`. Since `meta.yml` is configured to pull source from PyPi, you can't do this until after the source build has been uploaded from the github action.

{polyscope-2.2.0 → polyscope-2.3.0}/deps/polyscope/include/polyscope/options.h

@@ -64,8 +64,10 @@ extern bool hideWindowAfterShow;
 
 // Behavior of the ground plane
 extern GroundPlaneMode groundPlaneMode;
+extern GroundPlaneHeightMode groundPlaneHeightMode;
 extern bool groundPlaneEnabled; // deprecated, but kept and respected for compatability. use groundPlaneMode.
 extern ScaledValue<float> groundPlaneHeightFactor;
+extern float groundPlaneHeight;
 extern int shadowBlurIters;
 extern float shadowDarkness;
 

{polyscope-2.2.0 → polyscope-2.3.0}/deps/polyscope/include/polyscope/point_cloud.h

@@ -102,6 +102,13 @@ public:
   void setPointRadiusQuantity(std::string name, bool autoScale = true);
   void clearPointRadiusQuantity();
 
+  // === Set transparency alpha from a scalar quantity
+  // effect is multiplicative with other transparency values
+  // values are clamped to [0,1]
+  void setTransparencyQuantity(PointCloudScalarQuantity* quantity);
+  void setTransparencyQuantity(std::string name);
+  void clearTransparencyQuantity();
+
   // The points that make up this point cloud
   // Normally, the values are stored here. But if the render buffer
   // is being manually updated, they will live only in the render buffer
@@ -174,9 +181,16 @@ private:
 
   // Manage varying point size
   // which (scalar) quantity to set point size from
+  // TODO make these PersistentValue<>?
   std::string pointRadiusQuantityName = ""; // empty string means none
   bool pointRadiusQuantityAutoscale = true;
   PointCloudScalarQuantity& resolvePointRadiusQuantity(); // helper
+
+  // Manage per-element transparency
+  // which (scalar) quantity to set point size from
+  // TODO make these PersistentValue<>?
+  std::string transparencyQuantityName = "";               // empty string means none
+  PointCloudScalarQuantity& resolveTransparencyQuantity(); // helper
 };
 
 

{polyscope-2.2.0 → polyscope-2.3.0}/deps/polyscope/include/polyscope/quantity.ipp

@@ -43,9 +43,7 @@ QuantityS<S>* QuantityS<S>::setEnabled(bool newEnabled) {
     }
   }
 
-  if (isEnabled()) {
-    requestRedraw();
-  }
+  requestRedraw();
 
   return this;
 }

{polyscope-2.2.0 → polyscope-2.3.0}/deps/polyscope/include/polyscope/render/opengl/shaders/sphere_shaders.h

@@ -19,6 +19,7 @@ extern const ShaderStageSpecification FLEX_POINTQUAD_FRAG_SHADER;
 
 // Rules specific to spheres
 extern const ShaderReplacementRule SPHERE_PROPAGATE_VALUE;
+extern const ShaderReplacementRule SPHERE_PROPAGATE_VALUEALPHA;
 extern const ShaderReplacementRule SPHERE_PROPAGATE_VALUE2;
 extern const ShaderReplacementRule SPHERE_PROPAGATE_COLOR;
 extern const ShaderReplacementRule SPHERE_VARIABLE_SIZE;

{polyscope-2.2.0 → polyscope-2.3.0}/deps/polyscope/include/polyscope/render/opengl/shaders/surface_mesh_shaders.h

@@ -24,6 +24,7 @@ extern const ShaderReplacementRule MESH_BACKFACE_NORMAL_FLIP;
 extern const ShaderReplacementRule MESH_BACKFACE_DIFFERENT;
 extern const ShaderReplacementRule MESH_BACKFACE_DARKEN;
 extern const ShaderReplacementRule MESH_PROPAGATE_VALUE;
+extern const ShaderReplacementRule MESH_PROPAGATE_VALUEALPHA;
 extern const ShaderReplacementRule MESH_PROPAGATE_FLAT_VALUE;
 extern const ShaderReplacementRule MESH_PROPAGATE_INT;
 extern const ShaderReplacementRule MESH_PROPAGATE_VALUE2;

{polyscope-2.2.0 → polyscope-2.3.0}/deps/polyscope/include/polyscope/surface_mesh.h

@@ -29,6 +29,7 @@ namespace polyscope {
 class SurfaceVertexColorQuantity;
 class SurfaceFaceColorQuantity;
 class SurfaceTextureColorQuantity;
+class SurfaceScalarQuantity;
 class SurfaceVertexScalarQuantity;
 class SurfaceFaceScalarQuantity;
 class SurfaceEdgeScalarQuantity;
@@ -176,6 +177,13 @@ public:
   template <class V>
   void updateVertexPositions2D(const V& newPositions2D);
 
+  // === Set transparency alpha from a scalar quantity
+  // effect is multiplicative with other transparency values
+  // values are clamped to [0,1]
+  void setTransparencyQuantity(SurfaceScalarQuantity* quantity);
+  void setTransparencyQuantity(std::string name);
+  void clearTransparencyQuantity();
+
 
   // === Indexing conventions
 
@@ -376,6 +384,13 @@ private:
   void buildHalfedgeInfoGui(size_t heInd);
   void buildCornerInfoGui(size_t cInd);
 
+  // Manage per-element transparency
+  // which (scalar) quantity to set point size from
+  // TODO make these PersistentValue<>?
+  std::string transparencyQuantityName = "";            // empty string means none
+  SurfaceScalarQuantity& resolveTransparencyQuantity(); // helper
+
+
   // ==== Gui implementation details
 
   std::shared_ptr<render::ShaderProgram> program;

{polyscope-2.2.0 → polyscope-2.3.0}/deps/polyscope/include/polyscope/surface_scalar_quantity.h

@@ -28,8 +28,11 @@ public:
   virtual std::string niceName() override;
   virtual void refresh() override;
 
-protected:
+  virtual std::shared_ptr<render::AttributeBuffer> getAttributeBuffer() = 0;
+
   const std::string definedOn;
+
+protected:
   std::shared_ptr<render::ShaderProgram> program;
 
   // Helpers
@@ -47,6 +50,8 @@ public:
 
   virtual void createProgram() override;
 
+  virtual std::shared_ptr<render::AttributeBuffer> getAttributeBuffer() override;
+
   void buildVertexInfoGUI(size_t vInd) override;
 };
 
@@ -61,7 +66,7 @@ public:
                             DataType dataType_ = DataType::STANDARD);
 
   virtual void createProgram() override;
-
+  virtual std::shared_ptr<render::AttributeBuffer> getAttributeBuffer() override;
   void buildFaceInfoGUI(size_t fInd) override;
 };
 
@@ -76,7 +81,7 @@ public:
                             DataType dataType_ = DataType::STANDARD);
 
   virtual void createProgram() override;
-
+  virtual std::shared_ptr<render::AttributeBuffer> getAttributeBuffer() override;
   void buildEdgeInfoGUI(size_t edgeInd) override;
 };
 
@@ -90,7 +95,7 @@ public:
                                 DataType dataType_ = DataType::STANDARD);
 
   virtual void createProgram() override;
-
+  virtual std::shared_ptr<render::AttributeBuffer> getAttributeBuffer() override;
   void buildHalfedgeInfoGUI(size_t heInd) override;
 };
 
@@ -104,7 +109,7 @@ public:
                               DataType dataType_ = DataType::STANDARD);
 
   virtual void createProgram() override;
-
+  virtual std::shared_ptr<render::AttributeBuffer> getAttributeBuffer() override;
   void buildCornerInfoGUI(size_t heInd) override;
 };
 
@@ -119,6 +124,8 @@ public:
                                DataType dataType_ = DataType::STANDARD);
 
   virtual void createProgram() override;
+  virtual std::shared_ptr<render::AttributeBuffer> getAttributeBuffer() override;
+
 
 protected:
   SurfaceParameterizationQuantity& param;

{polyscope-2.2.0 → polyscope-2.3.0}/deps/polyscope/include/polyscope/types.h

@@ -13,6 +13,7 @@ enum class BackgroundView { None = 0 };
 enum class ProjectionMode { Perspective = 0, Orthographic };
 enum class TransparencyMode { None = 0, Simple, Pretty };
 enum class GroundPlaneMode { None, Tile, TileReflection, ShadowOnly };
+enum class GroundPlaneHeightMode { Automatic = 0, Manual };
 enum class BackFacePolicy { Identical, Different, Custom, Cull };
 
 enum class PointRenderMode { Sphere = 0, Quad };

{polyscope-2.2.0 → polyscope-2.3.0}/deps/polyscope/src/file_helpers.cpp

@@ -40,9 +40,10 @@ std::string promptForFilename(std::string initName) {
   using namespace std::placeholders;
 
   // Register the callback which creates the UI and does the hard work
-  char* textBuff = new char[2048];
-  snprintf(textBuff, sizeof(textBuff), "%s", initName.c_str());
-  auto func = std::bind(filenamePromptCallback, textBuff, 2048);
+  const size_t BUFF_LEN = 2048;
+  char* textBuff = new char[BUFF_LEN];
+  snprintf(textBuff, BUFF_LEN, "%s", initName.c_str());
+  auto func = std::bind(filenamePromptCallback, textBuff, BUFF_LEN);
   pushContext(func);
 
   std::string stringOut(textBuff);

{polyscope-2.2.0 → polyscope-2.3.0}/deps/polyscope/src/options.cpp

@@ -31,7 +31,9 @@ std::string screenshotExtension = ".png";
 // Ground plane / shadows
 bool groundPlaneEnabled = true;
 GroundPlaneMode groundPlaneMode = GroundPlaneMode::TileReflection;
+GroundPlaneHeightMode groundPlaneHeightMode = GroundPlaneHeightMode::Automatic;
 ScaledValue<float> groundPlaneHeightFactor = 0;
+float groundPlaneHeight = 0.;
 int shadowBlurIters = 2;
 float shadowDarkness = 0.25;
 

{polyscope-2.2.0 → polyscope-2.3.0}/deps/polyscope/src/point_cloud.cpp

@@ -185,6 +185,10 @@ void PointCloud::setPointProgramGeometryAttributes(render::ShaderProgram& p) {
     PointCloudScalarQuantity& radQ = resolvePointRadiusQuantity();
     p.setAttribute("a_pointRadius", radQ.values.getRenderAttributeBuffer());
   }
+  if (transparencyQuantityName != "") {
+    PointCloudScalarQuantity& transparencyQ = resolveTransparencyQuantity();
+    p.setAttribute("a_valueAlpha", transparencyQ.values.getRenderAttributeBuffer());
+  }
 }
 
 std::string PointCloud::getShaderNameForRenderMode() {
@@ -212,6 +216,9 @@ std::vector<std::string> PointCloud::addPointCloudRules(std::vector<std::string>
       else if (getPointRenderMode() == PointRenderMode::Quad)
         initRules.push_back("SPHERE_CULLPOS_FROM_CENTER_QUAD");
     }
+    if (transparencyQuantityName != "") {
+      initRules.push_back("SPHERE_PROPAGATE_VALUEALPHA");
+    }
   }
   return initRules;
 }
@@ -268,6 +275,11 @@ void PointCloud::buildCustomUI() {
 }
 
 void PointCloud::buildCustomOptionsUI() {
+  if (render::buildMaterialOptionsGui(material.get())) {
+    material.manuallyChanged();
+    setMaterial(material.get()); // trigger the other updates that happen on set()
+  }
+
   if (ImGui::BeginMenu("Point Render Mode")) {
 
     for (const PointRenderMode& m : {PointRenderMode::Sphere, PointRenderMode::Quad}) {
@@ -305,9 +317,21 @@ void PointCloud::buildCustomOptionsUI() {
     ImGui::EndMenu();
   }
 
-  if (render::buildMaterialOptionsGui(material.get())) {
-    material.manuallyChanged();
-    setMaterial(material.get()); // trigger the other updates that happen on set()
+  // transparency quantity
+  if (ImGui::BeginMenu("Per-Point Transparency")) {
+
+    if (ImGui::MenuItem("none", nullptr, transparencyQuantityName == "")) clearTransparencyQuantity();
+    ImGui::Separator();
+
+    for (auto& q : quantities) {
+      PointCloudScalarQuantity* scalarQ = dynamic_cast<PointCloudScalarQuantity*>(q.second.get());
+      if (scalarQ != nullptr) {
+        if (ImGui::MenuItem(scalarQ->name.c_str(), nullptr, transparencyQuantityName == scalarQ->name))
+          setTransparencyQuantity(scalarQ);
+      }
+    }
+
+    ImGui::EndMenu();
   }
 }
 
@@ -362,6 +386,42 @@ void PointCloud::clearPointRadiusQuantity() {
   refresh();
 }
 
+void PointCloud::setTransparencyQuantity(PointCloudScalarQuantity* quantity) {
+  setTransparencyQuantity(quantity->name);
+}
+
+void PointCloud::setTransparencyQuantity(std::string name) {
+  transparencyQuantityName = name;
+  resolveTransparencyQuantity(); // do it once, just so we fail fast if it doesn't exist
+
+  // if transparency is disabled, enable it
+  if (options::transparencyMode == TransparencyMode::None) {
+    options::transparencyMode = TransparencyMode::Pretty;
+  }
+
+  refresh();
+}
+
+void PointCloud::clearTransparencyQuantity() {
+  transparencyQuantityName = "";
+  refresh();
+}
+
+PointCloudScalarQuantity& PointCloud::resolveTransparencyQuantity() {
+  PointCloudScalarQuantity* transparencyScalarQ = nullptr;
+  PointCloudQuantity* anyQ = getQuantity(transparencyQuantityName);
+  if (anyQ != nullptr) {
+    transparencyScalarQ = dynamic_cast<PointCloudScalarQuantity*>(anyQ);
+    if (transparencyScalarQ == nullptr) {
+      exception("Cannot populate per-element transparency from quantity [" + name + "], it is not a scalar quantity");
+    }
+  } else {
+    exception("Cannot populate per-element transparency from quantity [" + name + "], it does not exist");
+  }
+
+  return *transparencyScalarQ;
+}
+
 // === Quantities
 
 // Quantity default methods

{polyscope-2.2.0 → polyscope-2.3.0}/deps/polyscope/src/render/ground_plane.cpp

@@ -196,7 +196,18 @@ void GroundPlane::draw(bool isRedraw) {
   double bboxBottom = sign == 1.0 ? std::get<0>(state::boundingBox)[iP] : std::get<1>(state::boundingBox)[iP];
   double bboxHeight = std::get<1>(state::boundingBox)[iP] - std::get<0>(state::boundingBox)[iP];
   double heightEPS = state::lengthScale * 1e-4;
-  double groundHeight = bboxBottom - sign * (options::groundPlaneHeightFactor.asAbsolute() + heightEPS);
+
+  double groundHeight = -777;
+  switch (options::groundPlaneHeightMode) {
+  case GroundPlaneHeightMode::Automatic: {
+    groundHeight = bboxBottom - sign * (options::groundPlaneHeightFactor.asAbsolute() + heightEPS);
+    break;
+  }
+  case GroundPlaneHeightMode::Manual: {
+    groundHeight = options::groundPlaneHeight;
+    break;
+  }
+  }
 
   // Viewport
   glm::vec4 viewport = render::engine->getCurrentViewport();
@@ -387,6 +398,16 @@ void GroundPlane::buildGui() {
     return "";
   };
 
+  auto heightModeName = [](const GroundPlaneHeightMode& m) -> std::string {
+    switch (m) {
+    case GroundPlaneHeightMode::Automatic:
+      return "Automatic";
+    case GroundPlaneHeightMode::Manual:
+      return "Manual";
+    }
+    return "";
+  };
+
   ImGui::SetNextItemOpen(false, ImGuiCond_FirstUseEver);
   if (ImGui::TreeNode("Ground Plane")) {
 
@@ -404,7 +425,39 @@ void GroundPlane::buildGui() {
     }
     ImGui::PopItemWidth();
 
-    if (ImGui::SliderFloat("Height", options::groundPlaneHeightFactor.getValuePtr(), -1.0, 1.0)) requestRedraw();
+    // Height
+    ImGui::PushItemWidth(80);
+    switch (options::groundPlaneHeightMode) {
+    case GroundPlaneHeightMode::Automatic:
+      if (ImGui::SliderFloat("##HeightValue", options::groundPlaneHeightFactor.getValuePtr(), -1.0, 1.0))
+        requestRedraw();
+      break;
+    case GroundPlaneHeightMode::Manual:
+      int iP;
+      float sign;
+      std::tie(iP, sign) = getGroundPlaneAxisAndSign();
+      double bboxBottom = sign == 1.0 ? std::get<0>(state::boundingBox)[iP] : std::get<1>(state::boundingBox)[iP];
+      double bboxHeight = std::get<1>(state::boundingBox)[iP] - std::get<0>(state::boundingBox)[iP];
+      if (ImGui::SliderFloat("##HeightValue", &options::groundPlaneHeight, bboxBottom - 0.5 * bboxHeight,
+                             bboxBottom + bboxHeight)) {
+        requestRedraw();
+      }
+      break;
+    }
+    ImGui::PopItemWidth();
+    ImGui::SameLine();
+    ImGui::PushItemWidth(100);
+    if (ImGui::BeginCombo("Height##Mode", heightModeName(options::groundPlaneHeightMode).c_str())) {
+      for (GroundPlaneHeightMode m : {GroundPlaneHeightMode::Automatic, GroundPlaneHeightMode::Manual}) {
+        std::string mName = heightModeName(m);
+        if (ImGui::Selectable(mName.c_str(), options::groundPlaneHeightMode == m)) {
+          options::groundPlaneHeightMode = m;
+          requestRedraw();
+        }
+      }
+      ImGui::EndCombo();
+    }
+    ImGui::PopItemWidth();
 
     switch (options::groundPlaneMode) {
     case GroundPlaneMode::None:

{polyscope-2.2.0 → polyscope-2.3.0}/deps/polyscope/src/render/initialize_backend.cpp

@@ -49,7 +49,7 @@ void initializeRenderEngine(std::string backend) {
 
 #ifdef POLYSCOPE_BACKEND_OPENGL3_GLFW_ENABLED
     // First try GLFW, if available
-    backend = "openGL3_glfw";
+    engineBackendName = "openGL3_glfw";
     try {
       backend_openGL3::initializeRenderEngine_glfw();
       initSucces = true;
@@ -64,7 +64,7 @@ void initializeRenderEngine(std::string backend) {
 
 #ifdef POLYSCOPE_BACKEND_OPENGL3_EGL_ENABLED
     // Then, try EGL if available
-    backend = "openGL3_egl";
+    engineBackendName = "openGL3_egl";
     try {
       backend_openGL3::initializeRenderEngine_egl();
       initSucces = true;

{polyscope-2.2.0 → polyscope-2.3.0}/deps/polyscope/src/render/mock_opengl/mock_gl_engine.cpp

@@ -1981,6 +1981,7 @@ void MockGLEngine::populateDefaultShadersAndRules() {
   registerShaderRule("MESH_BACKFACE_DIFFERENT", MESH_BACKFACE_DIFFERENT);
   registerShaderRule("MESH_BACKFACE_DARKEN", MESH_BACKFACE_DARKEN);
   registerShaderRule("MESH_PROPAGATE_VALUE", MESH_PROPAGATE_VALUE);
+  registerShaderRule("MESH_PROPAGATE_VALUEALPHA", MESH_PROPAGATE_VALUEALPHA);
   registerShaderRule("MESH_PROPAGATE_FLAT_VALUE", MESH_PROPAGATE_FLAT_VALUE);
   registerShaderRule("MESH_PROPAGATE_VALUE2", MESH_PROPAGATE_VALUE2);
   registerShaderRule("MESH_PROPAGATE_TCOORD", MESH_PROPAGATE_TCOORD);
@@ -2000,6 +2001,7 @@ void MockGLEngine::populateDefaultShadersAndRules() {
 
   // sphere things
   registerShaderRule("SPHERE_PROPAGATE_VALUE", SPHERE_PROPAGATE_VALUE);
+  registerShaderRule("SPHERE_PROPAGATE_VALUEALPHA", SPHERE_PROPAGATE_VALUEALPHA);
   registerShaderRule("SPHERE_PROPAGATE_VALUE2", SPHERE_PROPAGATE_VALUE2);
   registerShaderRule("SPHERE_PROPAGATE_COLOR", SPHERE_PROPAGATE_COLOR);
   registerShaderRule("SPHERE_CULLPOS_FROM_CENTER", SPHERE_CULLPOS_FROM_CENTER);

{polyscope-2.2.0 → polyscope-2.3.0}/deps/polyscope/src/render/opengl/gl_engine.cpp

@@ -2540,6 +2540,7 @@ void GLEngine::populateDefaultShadersAndRules() {
   registerShaderRule("MESH_BACKFACE_DIFFERENT", MESH_BACKFACE_DIFFERENT);
   registerShaderRule("MESH_BACKFACE_DARKEN", MESH_BACKFACE_DARKEN);
   registerShaderRule("MESH_PROPAGATE_VALUE", MESH_PROPAGATE_VALUE);
+  registerShaderRule("MESH_PROPAGATE_VALUEALPHA", MESH_PROPAGATE_VALUEALPHA);
   registerShaderRule("MESH_PROPAGATE_FLAT_VALUE", MESH_PROPAGATE_FLAT_VALUE);
   registerShaderRule("MESH_PROPAGATE_VALUE2", MESH_PROPAGATE_VALUE2);
   registerShaderRule("MESH_PROPAGATE_TCOORD", MESH_PROPAGATE_TCOORD);
@@ -2559,6 +2560,7 @@ void GLEngine::populateDefaultShadersAndRules() {
 
   // sphere things
   registerShaderRule("SPHERE_PROPAGATE_VALUE", SPHERE_PROPAGATE_VALUE);
+  registerShaderRule("SPHERE_PROPAGATE_VALUEALPHA", SPHERE_PROPAGATE_VALUEALPHA);
   registerShaderRule("SPHERE_PROPAGATE_VALUE2", SPHERE_PROPAGATE_VALUE2);
   registerShaderRule("SPHERE_PROPAGATE_COLOR", SPHERE_PROPAGATE_COLOR);
   registerShaderRule("SPHERE_CULLPOS_FROM_CENTER", SPHERE_CULLPOS_FROM_CENTER);

{polyscope-2.2.0 → polyscope-2.3.0}/deps/polyscope/src/render/opengl/shaders/lighting_shaders.cpp

@@ -238,7 +238,7 @@ const ShaderReplacementRule TRANSPARENCY_STRUCTURE (
           uniform float u_transparency;
         )"},
       {"GENERATE_ALPHA", R"(
-          alphaOut = u_transparency;
+          alphaOut *= u_transparency;
         )"},
     },
     /* uniforms */ {
@@ -257,7 +257,7 @@ const ShaderReplacementRule TRANSPARENCY_PEEL_STRUCTURE (
           uniform vec2 u_viewportDim;
         )"},
       {"GENERATE_ALPHA", R"(
-          alphaOut = u_transparency;
+          alphaOut *= u_transparency;
         )"},
       {"GLOBAL_FRAGMENT_FILTER", R"(
           // assumption: "float depth" must be already set 

{polyscope-2.2.0 → polyscope-2.3.0}/deps/polyscope/src/render/opengl/shaders/sphere_shaders.cpp

@@ -386,6 +386,37 @@ const ShaderReplacementRule SPHERE_PROPAGATE_VALUE (
     /* textures */ {}
 );
 
+const ShaderReplacementRule SPHERE_PROPAGATE_VALUEALPHA (
+    /* rule name */ "SPHERE_PROPAGATE_VALUEALPHA",
+    { /* replacement sources */
+      {"VERT_DECLARATIONS", R"(
+          in float a_valueAlpha;
+          out float a_valueAlphaToGeom;
+        )"},
+      {"VERT_ASSIGNMENTS", R"(
+          a_valueAlphaToGeom = a_valueAlpha;
+        )"},
+      {"GEOM_DECLARATIONS", R"(
+          in float a_valueAlphaToGeom[];
+          out float a_valueAlphaToFrag;
+        )"},
+      {"GEOM_PER_EMIT", R"(
+          a_valueAlphaToFrag = a_valueAlphaToGeom[0]; 
+        )"},
+      {"FRAG_DECLARATIONS", R"(
+          in float a_valueAlphaToFrag;
+        )"},
+      {"GENERATE_ALPHA", R"(
+          alphaOut *= clamp(a_valueAlphaToFrag, 0.f, 1.f);
+        )"},
+    },
+    /* uniforms */ {},
+    /* attributes */ {
+      {"a_valueAlpha", RenderDataType::Float},
+    },
+    /* textures */ {}
+);
+
 const ShaderReplacementRule SPHERE_PROPAGATE_VALUE2 (
     /* rule name */ "SPHERE_PROPAGATE_VALUE2",
     { /* replacement sources */

{polyscope-2.2.0 → polyscope-2.3.0}/deps/polyscope/src/render/opengl/shaders/surface_mesh_shaders.cpp

@@ -256,6 +256,30 @@ const ShaderReplacementRule MESH_PROPAGATE_VALUE (
     /* textures */ {}
 );
 
+const ShaderReplacementRule MESH_PROPAGATE_VALUEALPHA (
+    /* rule name */ "MESH_PROPAGATE_VALUEALPHA",
+    { /* replacement sources */
+      {"VERT_DECLARATIONS", R"(
+          in float a_valueAlpha;
+          out float a_valueAlphaToFrag;
+        )"},
+      {"VERT_ASSIGNMENTS", R"(
+          a_valueAlphaToFrag = a_valueAlpha;
+        )"},
+      {"FRAG_DECLARATIONS", R"(
+          in float a_valueAlphaToFrag;
+        )"},
+      {"GENERATE_ALPHA", R"(
+          alphaOut *= clamp(a_valueAlphaToFrag, 0.f, 1.f);
+        )"},
+    },
+    /* uniforms */ {},
+    /* attributes */ {
+      {"a_valueAlpha", RenderDataType::Float},
+    },
+    /* textures */ {}
+);
+
 const ShaderReplacementRule MESH_PROPAGATE_FLAT_VALUE (
     /* rule name */ "MESH_PROPAGATE_FLAT_VALUE",
     { /* replacement sources */

{polyscope-2.2.0 → polyscope-2.3.0}/deps/polyscope/src/surface_mesh.cpp

@@ -826,6 +826,11 @@ void SurfaceMesh::setMeshGeometryAttributes(render::ShaderProgram& p) {
   if (wantsCullPosition()) {
     p.setAttribute("a_cullPos", faceCenters.getIndexedRenderAttributeBuffer(triangleFaceInds));
   }
+
+  if (transparencyQuantityName != "") {
+    SurfaceScalarQuantity& transparencyQ = resolveTransparencyQuantity();
+    p.setAttribute("a_valueAlpha", transparencyQ.getAttributeBuffer());
+  }
 }
 
 void SurfaceMesh::setMeshPickAttributes(render::ShaderProgram& p) {
@@ -1023,6 +1028,10 @@ std::vector<std::string> SurfaceMesh::addSurfaceMeshRules(std::vector<std::strin
     if (wantsCullPosition()) {
       initRules.push_back("MESH_PROPAGATE_CULLPOS");
     }
+
+    if (transparencyQuantityName != "") {
+      initRules.push_back("MESH_PROPAGATE_VALUEALPHA");
+    }
   }
   return initRules;
 }
@@ -1300,6 +1309,26 @@ void SurfaceMesh::buildCustomOptionsUI() {
       setBackFacePolicy(BackFacePolicy::Cull);
     ImGui::EndMenu();
   }
+
+  // transparency quantity
+  if (ImGui::BeginMenu("Per-Element Transparency")) {
+
+    if (ImGui::MenuItem("none", nullptr, transparencyQuantityName == "")) clearTransparencyQuantity();
+    ImGui::Separator();
+
+    for (auto& q : quantities) {
+      SurfaceScalarQuantity* scalarQ = dynamic_cast<SurfaceScalarQuantity*>(q.second.get());
+      if (scalarQ != nullptr) {
+        if (scalarQ->definedOn == "vertex" || scalarQ->definedOn == "face" || scalarQ->definedOn == "corner") {
+
+          if (ImGui::MenuItem(scalarQ->name.c_str(), nullptr, transparencyQuantityName == scalarQ->name))
+            setTransparencyQuantity(scalarQ);
+        }
+      }
+    }
+
+    ImGui::EndMenu();
+  }
 }
 
 void SurfaceMesh::recomputeGeometryIfPopulated() {
@@ -1412,6 +1441,46 @@ long long int SurfaceMesh::selectVertex() {
   return returnVertInd;
 }
 
+void SurfaceMesh::setTransparencyQuantity(SurfaceScalarQuantity* quantity) { setTransparencyQuantity(quantity->name); }
+
+void SurfaceMesh::setTransparencyQuantity(std::string name) {
+  transparencyQuantityName = name;
+  resolveTransparencyQuantity(); // do it once, just so we fail fast if it doesn't exist
+
+  // if transparency is disabled, enable it
+  if (options::transparencyMode == TransparencyMode::None) {
+    options::transparencyMode = TransparencyMode::Pretty;
+  }
+
+  refresh();
+}
+
+void SurfaceMesh::clearTransparencyQuantity() {
+  transparencyQuantityName = "";
+  refresh();
+}
+
+SurfaceScalarQuantity& SurfaceMesh::resolveTransparencyQuantity() {
+  SurfaceScalarQuantity* transparencyScalarQ = nullptr;
+  SurfaceMeshQuantity* anyQ = getQuantity(transparencyQuantityName);
+  if (anyQ != nullptr) {
+    transparencyScalarQ = dynamic_cast<SurfaceScalarQuantity*>(anyQ);
+    if (transparencyScalarQ == nullptr) {
+      exception("Cannot populate per-element transparency from quantity [" + name + "], it is not a scalar quantity");
+    }
+
+    if (!(transparencyScalarQ->definedOn == "vertex" || transparencyScalarQ->definedOn == "face" ||
+          transparencyScalarQ->definedOn == "corner")) {
+      exception("Cannot populate per-element transparency from quantity [" + name +
+                "], only vertex, face, and corner quantities are supported");
+    }
+
+  } else {
+    exception("Cannot populate per-element transparency from quantity [" + name + "], it does not exist");
+  }
+
+  return *transparencyScalarQ;
+}
 
 void SurfaceMesh::markEdgesAsUsed() {
   if (edgesHaveBeenUsed) return;