Fix rendering of ray-casted primitives in orthographic projection mode (#372)

* fix orthogonal issue.

* remove unused function

* move lazy properties to internal namespace

* manage perspective vs orthographic shader raycasts with a rule at build time

* add more tests for orthographic rendering

* fix unrelated but with ground plane and upDir in ortho view

* remove config file

* add ini to gitignore

---------

Co-authored-by: xTree <[email protected]>

Author: nmwsharp

.gitignore

@@ -5,6 +5,7 @@ misc/file2c/file2cpp
 
 # Editor and OS things
 imgui.ini
+.polyscope.ini
 .DS_Store
 .vscode
 *.swp

include/polyscope/camera_view.h

@@ -97,7 +97,6 @@ class CameraView : public QuantityStructure<CameraView> {
   // Rendering helpers used by quantities
   void setCameraViewUniforms(render::ShaderProgram& p);
   std::vector<std::string> addCameraViewRules(std::vector<std::string> initRules, bool withCameraView = true);
-  std::string getShaderNameForRenderMode();
 
   // Get info related to how the frame is drawn (billboard center vector, center-to-top vector, center-to-right vector)
   std::tuple<glm::vec3, glm::vec3, glm::vec3> getFrameBillboardGeometry();

include/polyscope/internal.h

@@ -5,6 +5,9 @@
 #include <cstdint>
 #include <string>
 
+#include "polyscope/scaled_value.h"
+#include "polyscope/types.h"
+
 
 namespace polyscope {
 
@@ -36,5 +39,20 @@ extern float lastRightSideFreeY;
 extern float leftWindowsWidth;
 extern float rightWindowsWidth;
 
+// Cached versions of lazy properties used for updates
+namespace lazy {
+extern TransparencyMode transparencyMode;
+extern ProjectionMode projectionMode;
+extern int transparencyRenderPasses;
+extern int ssaaFactor;
+extern float uiScale;
+extern bool groundPlaneEnabled;
+extern GroundPlaneMode groundPlaneMode;
+extern ScaledValue<float> groundPlaneHeightFactor;
+extern int shadowBlurIters;
+extern float shadowDarkness;
+} // namespace lazy
+
+
 } // namespace internal
 } // namespace polyscope

include/polyscope/render/opengl/shaders/rules.h

@@ -40,6 +40,8 @@ extern const ShaderReplacementRule PROJ_AND_INV_PROJ_MAT;
 extern const ShaderReplacementRule COMPUTE_SHADE_NORMAL_FROM_POSITION;
 extern const ShaderReplacementRule PREMULTIPLY_LIT_COLOR;
 extern const ShaderReplacementRule CULL_POS_FROM_VIEW;
+extern const ShaderReplacementRule BUILD_RAY_FOR_FRAGMENT_PERSPECTIVE;
+extern const ShaderReplacementRule BUILD_RAY_FOR_FRAGMENT_ORTHOGRAPHIC;
 
 ShaderReplacementRule generateSlicePlaneRule(std::string uniquePostfix);
 ShaderReplacementRule generateVolumeGridSlicePlaneRule(std::string uniquePostfix);

include/polyscope/vector_quantity.ipp

@@ -158,7 +158,8 @@ void VectorQuantity<QuantityT>::drawVectors() {
 template <typename QuantityT>
 void VectorQuantity<QuantityT>::createProgram() {
 
-  std::vector<std::string> rules = this->quantity.parent.addStructureRules({"SHADE_BASECOLOR"});
+  std::vector<std::string> rules =
+      this->quantity.parent.addStructureRules({view::getCurrentProjectionModeRaycastRule(), "SHADE_BASECOLOR"});
   if (this->quantity.parent.wantsCullPosition()) {
     rules.push_back("VECTOR_CULLPOS_FROM_TAIL");
   }

include/polyscope/view.h

@@ -85,6 +85,8 @@ CameraParameters getCameraParametersForCurrentView(); // contains all of this in
 // (these friendly helpers to get the same info as ^^^)
 glm::mat4 getCameraViewMatrix();
 void setCameraViewMatrix(glm::mat4 newMat);
+ProjectionMode getProjectionMode();
+void setProjectionMode(ProjectionMode newMode);
 glm::mat4 getCameraPerspectiveMatrix();
 glm::vec3 getCameraWorldPosition();
 void getCameraFrame(glm::vec3& lookDir, glm::vec3& upDir, glm::vec3& rightDir);
@@ -165,6 +167,7 @@ std::tuple<int, int> screenCoordsToBufferInds(glm::vec2 screenCoords);
 glm::ivec2 screenCoordsToBufferIndsVec(glm::vec2 screenCoords);
 glm::vec2 bufferIndsToScreenCoords(int xPos, int yPos);
 glm::vec2 bufferIndsToScreenCoords(glm::ivec2 bufferInds);
+std::string getCurrentProjectionModeRaycastRule();
 
 // == Internal helpers. Should probably not be called in user code.
 

src/camera_view.cpp

@@ -154,14 +154,16 @@ void CameraView::drawPickDelayed() {
 void CameraView::prepare() {
 
   {
-    std::vector<std::string> rules = addStructureRules({"SHADE_BASECOLOR"});
+    std::vector<std::string> rules =
+        addStructureRules({view::getCurrentProjectionModeRaycastRule(), "SHADE_BASECOLOR"});
     if (wantsCullPosition()) rules.push_back("SPHERE_CULLPOS_FROM_CENTER");
     rules = render::engine->addMaterialRules(material, rules);
     nodeProgram = render::engine->requestShader("RAYCAST_SPHERE", rules);
   }
 
   {
-    std::vector<std::string> rules = addStructureRules({"SHADE_BASECOLOR"});
+    std::vector<std::string> rules =
+        addStructureRules({view::getCurrentProjectionModeRaycastRule(), "SHADE_BASECOLOR"});
     if (wantsCullPosition()) rules.push_back("CYLINDER_CULLPOS_FROM_MID");
     rules = render::engine->addMaterialRules(material, rules);
     edgeProgram = render::engine->requestShader("RAYCAST_CYLINDER", rules);

src/curve_network.cpp

@@ -221,6 +221,8 @@ void CurveNetwork::drawPickDelayed() {
 
 std::vector<std::string> CurveNetwork::addCurveNetworkNodeRules(std::vector<std::string> initRules) {
   initRules = addStructureRules(initRules);
+  
+  initRules.push_back(view::getCurrentProjectionModeRaycastRule());
 
   if (nodeRadiusQuantityName != "" || edgeRadiusQuantityName != "") {
     initRules.push_back("SPHERE_VARIABLE_SIZE");
@@ -233,6 +235,8 @@ std::vector<std::string> CurveNetwork::addCurveNetworkNodeRules(std::vector<std:
 std::vector<std::string> CurveNetwork::addCurveNetworkEdgeRules(std::vector<std::string> initRules) {
   initRules = addStructureRules(initRules);
 
+  initRules.push_back(view::getCurrentProjectionModeRaycastRule());
+
   // use node radius to blend cylinder radius
   if (nodeRadiusQuantityName != "" || edgeRadiusQuantityName != "") {
     initRules.push_back("CYLINDER_VARIABLE_SIZE");
@@ -292,9 +296,10 @@ void CurveNetwork::preparePick() {
   size_t pickStart = pick::requestPickBufferRange(this, totalPickElements);
 
   { // Set up node picking program
-    nodePickProgram =
-        render::engine->requestShader("RAYCAST_SPHERE", addCurveNetworkNodeRules({"SPHERE_PROPAGATE_COLOR"}),
-                                      render::ShaderReplacementDefaults::Pick);
+    nodePickProgram = render::engine->requestShader(
+        "RAYCAST_SPHERE",
+        addCurveNetworkNodeRules({"SPHERE_PROPAGATE_COLOR"}),
+        render::ShaderReplacementDefaults::Pick);
 
     // Fill color buffer with packed point indices
     std::vector<glm::vec3> pickColors;

src/internal.cpp

@@ -22,5 +22,21 @@ float lastRightSideFreeY = 10;
 float leftWindowsWidth = -1.;
 float rightWindowsWidth = -1.;
 
+
+namespace lazy {
+
+TransparencyMode transparencyMode = TransparencyMode::None;
+ProjectionMode projectionMode = ProjectionMode::Perspective;
+int transparencyRenderPasses = 8;
+int ssaaFactor = 1;
+float uiScale = -1.;
+bool groundPlaneEnabled = true;
+GroundPlaneMode groundPlaneMode = GroundPlaneMode::TileReflection;
+ScaledValue<float> groundPlaneHeightFactor = 0;
+int shadowBlurIters = 2;
+float shadowDarkness = .4;
+
+} // namespace lazy
+
 } // namespace internal
 } // namespace polyscope

src/point_cloud.cpp

@@ -247,6 +247,9 @@ PointCloudPickResult PointCloud::interpretPickResult(const PickResult& rawResult
 std::vector<std::string> PointCloud::addPointCloudRules(std::vector<std::string> initRules, bool withPointCloud) {
   initRules = addStructureRules(initRules);
   if (withPointCloud) {
+
+    initRules.push_back(view::getCurrentProjectionModeRaycastRule());
+
     if (pointRadiusQuantityName != "") {
       initRules.push_back("SPHERE_VARIABLE_SIZE");
     }