make individual light path selection use opacity instead of soloing

Author: fu5ha

src/appleseed.studio/mainwindow/rendering/lightpathslayer.cpp

@@ -190,15 +190,15 @@ void LightPathsLayer::slot_synchronize_camera()
 
 void LightPathsLayer::load_light_paths_data()
 {
-    m_index_offsets.clear();
+    m_path_terminator_vertex_indices.clear();
     m_max_luminance = 0.0f;
     if (!m_light_paths.empty())
     {
-        m_index_offsets.push_back(0);
+        m_path_terminator_vertex_indices.push_back(0);
 
         const auto& light_path_recorder = m_project.get_light_path_recorder();
 
-        GLsizei total_index_count = 0;
+        m_total_triangle_count = 0;
 
         // Vertex count * 4 since we will be adding two vertices for each point along the line and will
         // be adding each point twice for the beginning and end parts of each segment
@@ -301,10 +301,10 @@ void LightPathsLayer::load_light_paths_data()
                     indices_scratch.begin(),
                     indices_scratch.end());
 
-                total_index_count += 6;
+                m_total_triangle_count += 6;
                 prev = vert;
             }
-            m_index_offsets.push_back(total_index_count);
+            m_path_terminator_vertex_indices.push_back(static_cast<GLsizei>(others_buffer.size()));
         }
 
         // Add an empty vertex at the end to serve as last 'next'
@@ -359,6 +359,8 @@ void LightPathsLayer::init_gl(QSurfaceFormat format)
     m_max_luminance_loc = m_gl->glGetUniformLocation(m_shader_program, "u_max_luminance");
     m_max_thickness_loc = m_gl->glGetUniformLocation(m_shader_program, "u_max_thickness");
     m_min_thickness_loc = m_gl->glGetUniformLocation(m_shader_program, "u_min_thickness");
+    m_first_selected_loc = m_gl->glGetUniformLocation(m_shader_program, "u_first_selected");
+    m_last_selected_loc = m_gl->glGetUniformLocation(m_shader_program, "u_last_selected");
 
     const float z_near = 0.01f;
     const float z_far = 1000.0f;
@@ -510,8 +512,22 @@ void LightPathsLayer::render_scene(const GLfloat* gl_view_matrix) const
     if (!m_gl_initialized)
         return;
 
-    if (m_index_offsets.size() > 1)
+    if (m_total_triangle_count > 1)
     {
+        GLint first_selected;
+        GLint last_selected;
+        assert(m_selected_light_path_index >= -1);
+        if (m_selected_light_path_index == -1)
+        {
+            first_selected = 0;
+            last_selected = static_cast<GLint>(m_path_terminator_vertex_indices[m_path_terminator_vertex_indices.size() - 1]);
+        }
+        else
+        {
+            first_selected = static_cast<GLint>(m_path_terminator_vertex_indices[m_selected_light_path_index + 1]);
+            last_selected = static_cast<GLint>(m_path_terminator_vertex_indices[m_selected_light_path_index + 2]);
+        }
+
         m_gl->glUseProgram(m_shader_program);
 
         m_gl->glUniformMatrix4fv(
@@ -537,24 +553,18 @@ void LightPathsLayer::render_scene(const GLfloat* gl_view_matrix) const
             m_res_loc,
             (GLfloat)m_width,
             (GLfloat)m_height);
+        m_gl->glUniform1i(
+            m_first_selected_loc,
+            first_selected);
+        m_gl->glUniform1i(
+            m_last_selected_loc,
+            last_selected);
 
         m_gl->glBindVertexArray(m_light_paths_vao);
 
-        GLint first;
-        GLsizei count;
-        assert(m_selected_light_path_index >= -1);
-        if (m_selected_light_path_index == -1)
-        {
-            first = 0;
-            count = m_index_offsets[m_index_offsets.size() - 1] / 3;
-        }
-        else
-        {
-            first = static_cast<GLint>(m_index_offsets[m_selected_light_path_index]);
-            count = m_index_offsets[m_selected_light_path_index + 1] - first;
-        }
+
         m_gl->glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indices_ebo);
-        m_gl->glDrawElements(GL_TRIANGLES, count, GL_UNSIGNED_INT, reinterpret_cast<GLvoid*>(first * sizeof(unsigned int)));
+        m_gl->glDrawElements(GL_TRIANGLES, m_total_triangle_count, GL_UNSIGNED_INT, static_cast<const GLvoid*>(0));
         m_gl->glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
     }
 }

src/appleseed.studio/mainwindow/rendering/lightpathslayer.h

@@ -129,7 +129,8 @@ class LightPathsLayer: public QObject
     GLuint                                  m_positions_vbo;
     GLuint                                  m_others_vbo;
     GLuint                                  m_indices_ebo;
-    std::vector<GLsizei>                    m_index_offsets;
+    std::vector<GLsizei>                    m_path_terminator_vertex_indices;
+    GLsizei                                 m_total_triangle_count;
     GLuint                                  m_light_paths_vao;
     GLuint                                  m_shader_program;
     GLint                                   m_view_mat_loc;
@@ -138,6 +139,8 @@ class LightPathsLayer: public QObject
     GLint                                   m_max_luminance_loc;
     GLint                                   m_min_thickness_loc;
     GLint                                   m_max_thickness_loc;
+    GLint                                   m_first_selected_loc;
+    GLint                                   m_last_selected_loc;
     foundation::Matrix4f                    m_gl_render_view_matrix;
     foundation::Matrix4f                    m_gl_view_matrix;
     foundation::Matrix4f                    m_gl_proj_matrix;

src/appleseed.studio/resources/shaders/lightpaths.frag

@@ -28,7 +28,7 @@
 #version 410
 #extension GL_ARB_separate_shader_objects : enable
 
-flat in vec3 f_color;
+flat in vec4 f_color;
 in float f_aa_norm;
 flat in float f_thickness;
 flat in float f_total_thickness;
@@ -40,7 +40,7 @@ layout(location = 0) out vec4 accum_target;
 layout(location = 1) out float revealage_target;
 
 void write_pixel(vec4 premultiplied_col, vec3 transmit) { 
-    // premultiplied_col.a *= 1.0 - clamp((transmit.r + transmit.g + transmit.b) * (1.0 / 3.0), 0, 1);
+    premultiplied_col.a *= 1.0 - clamp((transmit.r + transmit.g + transmit.b) * (1.0 / 3.0), 0, 1);
 
     float a = min(1.0, premultiplied_col.a) * 8.0 + 0.01;
     float b = -gl_FragCoord.z * 0.95 + 1.0;
@@ -55,7 +55,8 @@ void main()
     float dist = abs(f_aa_norm) * f_total_thickness - 0.5 / f_aspect_expansion_len;
     float eps = fwidth(dist);
     float a = 1.0 - smoothstep(f_thickness - eps, f_thickness + eps, dist);
+    a *= f_color.a;
 
-    vec4 premult = vec4(f_color * a, a);
-    write_pixel(premult, vec3(1.0));
+    vec4 premult = vec4(f_color.rgb * a, a);
+    write_pixel(premult, vec3(0.0));
 }

src/appleseed.studio/resources/shaders/lightpaths.vert

@@ -44,7 +44,10 @@ uniform float u_max_luminance;
 uniform float u_max_thickness;
 uniform float u_min_thickness;
 
-flat out vec3 f_color;
+uniform int u_first_selected;
+uniform int u_last_selected;
+
+flat out vec4 f_color;
 out float f_aa_norm;
 flat out float f_thickness;
 flat out float f_total_thickness;
@@ -105,5 +108,8 @@ void main() {
 
     gl_Position = vec4((curr_screen + expansion) / aspect_vec, curr_proj.z / curr_proj.w, 1.0);
     f_aa_norm = orientation;
-    f_color = v_color;
+
+    bool is_selected = gl_VertexID >= u_first_selected && gl_VertexID < u_last_selected;
+    float a = is_selected ? 1.0 : 0.2;
+    f_color = vec4(v_color, a);
 }