Fix GLSL 1.50 for Mesa

ogre_media/materials/glsl120/smooth_square.frag

@@ -7,19 +7,23 @@ uniform float alpha;
 
 void main()
 {
+  const float outer = 0.48;
+  const float inner = 0.45;
   float ax = gl_TexCoord[0].x-0.5;
   float ay = gl_TexCoord[0].y-0.5;
 
-  float blend = smoothstep(-0.48, -0.45, ay) * (1.0 - smoothstep(0.45, 0.48, ay)) *
-                smoothstep(-0.48, -0.45, ax) * (1.0 - smoothstep(0.45, 0.48, ax));
+  // blending factor, varying between 0.0 (at the border) and 1.0 (at the center of the square)
+  float blend = smoothstep(-outer, -inner, ay) * (1.0 - smoothstep(inner, outer, ay)) *
+                smoothstep(-outer, -inner, ax) * (1.0 - smoothstep(inner, outer, ax));
 
+#if 1 // high contrast edge (dark edge on light surface / light edge on dark surface)
   float inv_blend = 1.0 - blend;
-  vec3 col = blend * gl_Color.xyz + (sign(0.5 - length(vec3(gl_Color.xyz))) * vec3(0.2, 0.2, 0.2) + gl_Color.xyz) * inv_blend;
+  vec3 col = blend * gl_Color.rgb + (sign(0.5 - length(gl_Color.rgb)) * vec3(0.2, 0.2, 0.2) + gl_Color.rgb) * inv_blend;
+#else // alternatively: make color at edge darker
+  vec3 col = (0.5 + 0.5*blend) * gl_Color.rgb;
+#endif
 
-  //alternative version: make color at edge darker
-  //vec3 col = (0.5 + 0.5*blend) * gl_Color.xyz;
+  col = col + col * highlight.rgb;
 
-  col = col + col * highlight.xyz;
-
-  gl_FragColor = vec4(col.r, col.g, col.b, alpha * gl_Color.a );
+  gl_FragColor = vec4(col.rgb, alpha * gl_Color.a);
 }

ogre_media/materials/glsl150/billboard.geom

@@ -19,23 +19,24 @@ uniform mat4 worldviewproj_matrix;
 uniform vec4 size;
 uniform vec4 auto_size;
 
-in gl_PerVertex {
-	vec4 gl_Position;
-	vec4 gl_FrontColor;
-} gl_in[];
+in VertexData {
+	vec4 color;
+} vdata[];
 
-out vec4 gl_TexCoord[];
+// Use exactly these names to map onto gl_Color and gl_TexCoord used by fragment shaders
+out vec4 color;
+out vec2 TexCoord;
 
 layout(points) in;
 layout(triangle_strip, max_vertices=4) out;
 
 void emitVertex( vec3 pos_rel, vec3 tex )
 {
   pos_rel = mat3(inverse_worldview_matrix) * pos_rel;
-  vec4 pos = gl_in[0].gl_Position + vec4(pos_rel,0.0);
+  vec4 pos = gl_in[0].gl_Position + vec4(pos_rel, 0.0);
   gl_Position = worldviewproj_matrix * pos;
-  gl_TexCoord[0] = vec4( tex.xy, 0.0, 0.0 );
-  gl_FrontColor = vec4( gl_in[0].gl_FrontColor );
+  TexCoord = tex.xy;
+  color = vdata[0].color;
   EmitVertex();
 }
 

ogre_media/materials/glsl150/box.geom

@@ -19,13 +19,13 @@ uniform mat4 worldviewproj_matrix;
 uniform vec4 size;
 uniform vec4 auto_size;
 
-in gl_PerVertex {
-	vec4 gl_Position;
-	vec4 gl_FrontColor;
-} gl_in[];
+in VertexData {
+	vec4 color;
+} vdata[];
 
-
-out vec4 gl_TexCoord[];
+// Use exactly these names to map onto gl_Color and gl_TexCoord used by fragment shaders
+out vec4 color;
+out vec2 TexCoord;
 
 layout(points) in;
 layout(triangle_strip, max_vertices=24) out;
@@ -39,22 +39,17 @@ const vec4 axes[3] = vec4[] (
 const float lightness[6] = float[] (
     0.9, 0.5, 0.6, 0.6, 1.0, 0.4 );
 
-
-void emitVertex( int side, vec4 x, vec4 y, vec4 z, vec3 tex )
+void emitVertex( int side, vec4 x, vec4 y, vec4 z, vec3 tex, vec4 size_factor )
 {
-  // if auto_size == 1, then size_factor == size*gl_Vertex.z
-  // if auto_size == 0, then size_factor == size
-  vec4 size_factor = (1-auto_size.x+(auto_size.x*gl_in[0].gl_Position.z))*size;
-
   vec4 pos_rel = tex.x*x + tex.y*y + tex.z*z;
-  vec4 pos = gl_in[0].gl_Position + vec4( pos_rel * size_factor * 0.5 );
+  vec4 pos = gl_in[0].gl_Position + vec4( pos_rel * size_factor );
   gl_Position = worldviewproj_matrix * pos;
-  gl_TexCoord[0] = vec4( tex.x*0.5+0.5, tex.y*0.5+0.5, 0.0, 0.0 );
+  TexCoord = vec2(tex.x*0.5+0.5, tex.y*0.5+0.5);
 
 #ifdef WITH_LIGHTING
-    gl_FrontColor = vec4( gl_in[0].gl_FrontColor.xyz * lightness[side], gl_in[0].gl_FrontColor.a );
+    color = vec4( vdata[0].color.rgb * lightness[side], vdata[0].color.a );
 #else
-    gl_FrontColor = vec4( gl_in[0].gl_FrontColor.xyz, gl_in[0].gl_FrontColor.a );
+    color = vdata[0].color;
 #endif
 
 #ifdef WITH_DEPTH
@@ -67,26 +62,28 @@ void emitVertex( int side, vec4 x, vec4 y, vec4 z, vec3 tex )
 
 void main()
 {
+  // if auto_size == 1, then size_factor == size*gl_Vertex.z
+  // if auto_size == 0, then size_factor == size
+  vec4 size_factor = (0.5*(1-auto_size.x+(auto_size.x*gl_in[0].gl_Position.z)))*size;
+
   for( int side=0; side<3; side++ )
   {
-    int side2 = (side+1)%3;
-    int side3 = (side+2)%3;
     vec4 x=axes[ side ];
-    vec4 y=axes[ side2 ];
-    vec4 z=axes[ side3 ];
+    vec4 y=axes[ (side+1)%3 ];
+    vec4 z=axes[ (side+2)%3 ];
 
     // face for +z
-    emitVertex( side, x, y, z, vec3(-1, -1, +1) );
-    emitVertex( side, x, y, z, vec3(+1, -1, +1) );
-    emitVertex( side, x, y, z, vec3(-1, +1, +1) );
-    emitVertex( side, x, y, z, vec3(+1, +1, +1) );
+    emitVertex( side, x, y, z, vec3(-1, -1, +1), size_factor );
+    emitVertex( side, x, y, z, vec3(+1, -1, +1), size_factor );
+    emitVertex( side, x, y, z, vec3(-1, +1, +1), size_factor );
+    emitVertex( side, x, y, z, vec3(+1, +1, +1), size_factor );
     EndPrimitive();
 
     // face for -z
-    emitVertex( side+3, x, y, z, vec3(-1, -1, -1) );
-    emitVertex( side+3, x, y, z, vec3(-1, +1, -1) );
-    emitVertex( side+3, x, y, z, vec3(+1, -1, -1) );
-    emitVertex( side+3, x, y, z, vec3(+1, +1, -1) );
+    emitVertex( side+3, x, y, z, vec3(-1, -1, -1), size_factor );
+    emitVertex( side+3, x, y, z, vec3(-1, +1, -1), size_factor );
+    emitVertex( side+3, x, y, z, vec3(+1, -1, -1), size_factor );
+    emitVertex( side+3, x, y, z, vec3(+1, +1, -1), size_factor );
     EndPrimitive();
   }
 }

ogre_media/materials/glsl150/flat_color.frag

@@ -0,0 +1,15 @@
+#version 150
+
+// Passes the fragment color, multiplying a with the alpha param
+
+uniform vec4 highlight;
+uniform float alpha;
+
+in vec4 color;
+out vec4 FragColor;
+
+void main()
+{
+  vec3 col = color.xyz + color.xyz * highlight.xyz;
+  FragColor = vec4(col, color.a * alpha);
+}

ogre_media/materials/glsl150/glsl150.program

@@ -78,3 +78,33 @@ vertex_program rviz/glsl150/pass_pos_color.vert glsl
 {
   source pass_pos_color.vert
 }
+
+fragment_program rviz/glsl150/flat_color.frag glsl
+{
+  source flat_color.frag
+  default_params
+  {
+    param_named_auto highlight custom 5
+    param_named_auto alpha custom 1
+  }
+}
+
+fragment_program rviz/glsl150/shaded_circle.frag glsl
+{
+  source shaded_circle.frag
+  default_params
+  {
+    param_named_auto highlight custom 5
+    param_named_auto alpha custom 1
+  }
+}
+
+fragment_program rviz/glsl150/smooth_square.frag glsl
+{
+  source smooth_square.frag
+  default_params
+  {
+    param_named_auto highlight custom 5
+    param_named_auto alpha custom 1
+  }
+}

ogre_media/materials/glsl150/pass_pos_color.vert

@@ -1,14 +1,17 @@
-#version 150 compatibility
+#version 150
 
-// this merely passes over position and color,
-// as needed by box.geom
+// need to use exactly these names to have OGRE bind the unpacked values:
+// https://ogrecave.github.io/ogre/api/latest/_high-level-_programs.html#Binding-vertex-attributes
+in vec4 vertex;
+in vec4 colour;
 
-out gl_PerVertex {
-	vec4 gl_Position;
-	vec4 gl_FrontColor;
-};
+// this merely passes over position and color as needed by box.geom
+
+out VertexData {
+    vec4 color;
+} vdata;
 
 void main() {
-    gl_Position = gl_Vertex;
-    gl_FrontColor = gl_Color;
+    gl_Position = vertex;
+    vdata.color = colour;
 }

ogre_media/materials/glsl150/shaded_circle.frag

@@ -0,0 +1,26 @@
+#version 150
+
+// rasterizes a circle that is darker at the borders than in the center
+
+uniform vec4 highlight;
+uniform float alpha;
+
+in vec4 color;
+in vec2 TexCoord;
+
+out vec4 FragColor;
+
+void main()
+{
+  float ax = TexCoord.x-0.5;
+  float ay = TexCoord.y-0.5;
+
+  float rsquared = ax*ax+ay*ay;
+  float a = (0.25 - rsquared) * 4.0;
+
+  vec3 col = mix(vec3(0.8, 0.8, 0.8) * color.xyz, color.xyz, a);
+
+  col = col + col * highlight.xyz;
+
+  FragColor = vec4(col, alpha * ceil(a) * color.a);
+}

ogre_media/materials/glsl150/smooth_square.frag

@@ -0,0 +1,34 @@
+#version 150
+
+// rasterizes a smooth square with ax,ay in [-0.5..0.5]
+
+uniform vec4 highlight;
+uniform float alpha;
+
+in vec4 color;
+in vec2 TexCoord;
+
+out vec4 FragColor;
+
+void main()
+{
+  const float outer = 0.48;
+  const float inner = 0.45;
+  float ax = TexCoord.x-0.5;
+  float ay = TexCoord.y-0.5;
+
+  // blending factor, varying between 0.0 (at the border) and 1.0 (at the center of the square)
+  float blend = smoothstep(-outer, -inner, ay) * (1.0 - smoothstep(inner, outer, ay)) *
+                smoothstep(-outer, -inner, ax) * (1.0 - smoothstep(inner, outer, ax));
+
+#if 1 // high contrast edge (dark edge on light surface / light edge on dark surface)
+  float inv_blend = 1.0 - blend;
+  vec3 col = blend * color.rgb + (sign(0.5 - length(vec3(color.rgb))) * vec3(0.2, 0.2, 0.2) + color.rgb) * inv_blend;
+#else // alternatively: make color at edge darker
+  vec3 col = (0.5 + 0.5*blend) * color.rgb;
+#endif
+
+  col = col + col * highlight.rgb;
+
+  FragColor = vec4(col.rgb, alpha * color.a);
+}

ogre_media/materials/scripts150/point_cloud_box.material

@@ -1,6 +1,6 @@
 material rviz/PointCloudBox
 {
-  /* This material should only be used with glsl < 1.50 */
+  /* This material should only be used with glsl >= 1.50 */
 
   // the 'gp' techniques need one input vertex per box
   // and use geometry shaders to create the geometry
@@ -11,7 +11,7 @@ material rviz/PointCloudBox
     {
       vertex_program_ref   rviz/glsl150/pass_pos_color.vert {}
       geometry_program_ref rviz/glsl150/box.geom(with_lighting) {}
-      fragment_program_ref rviz/glsl120/smooth_square.frag {}
+      fragment_program_ref rviz/glsl150/smooth_square.frag {}
     }
   }
 

ogre_media/materials/scripts150/point_cloud_flat_square.material

@@ -7,7 +7,7 @@ material rviz/PointCloudFlatSquare {
       alpha_rejection greater_equal 1
       vertex_program_ref   rviz/glsl150/pass_pos_color.vert {}
       geometry_program_ref rviz/glsl150/billboard.geom {}
-      fragment_program_ref rviz/glsl120/flat_color.frag {}
+      fragment_program_ref rviz/glsl150/flat_color.frag {}
     }
   }
 

ogre_media/materials/scripts150/point_cloud_sphere.material

@@ -7,7 +7,7 @@ material rviz/PointCloudSphere {
       alpha_rejection greater_equal 1
       vertex_program_ref   rviz/glsl150/pass_pos_color.vert {}
       geometry_program_ref rviz/glsl150/billboard.geom {}
-      fragment_program_ref rviz/glsl120/shaded_circle.frag {}
+      fragment_program_ref rviz/glsl150/shaded_circle.frag {}
     }
   }
 

ogre_media/materials/scripts150/point_cloud_square.material

@@ -7,7 +7,7 @@ material rviz/PointCloudSquare {
       alpha_rejection greater_equal 1
       vertex_program_ref   rviz/glsl150/pass_pos_color.vert {}
       geometry_program_ref rviz/glsl150/billboard.geom {}
-      fragment_program_ref rviz/glsl120/smooth_square.frag {}
+      fragment_program_ref rviz/glsl150/smooth_square.frag {}
     }
   }
 

src/rviz/ogre_helpers/point_cloud.cpp

@@ -219,32 +219,27 @@ void PointCloud::setHighlightColor(float r, float g, float b)
 void PointCloud::setRenderMode(RenderMode mode)
 {
   render_mode_ = mode;
-
-  if (mode == RM_POINTS)
-  {
-    current_material_ = Ogre::MaterialPtr(point_material_);
-  }
-  else if (mode == RM_SQUARES)
-  {
-    current_material_ = Ogre::MaterialPtr(square_material_);
-  }
-  else if (mode == RM_FLAT_SQUARES)
-  {
-    current_material_ = Ogre::MaterialPtr(flat_square_material_);
-  }
-  else if (mode == RM_SPHERES)
-  {
-    current_material_ = Ogre::MaterialPtr(sphere_material_);
-  }
-  else if (mode == RM_TILES)
-  {
-    current_material_ = Ogre::MaterialPtr(tile_material_);
+  switch (mode)
+  {
+  case RM_POINTS:
+    current_material_ = point_material_;
+    break;
+  case RM_SQUARES:
+    current_material_ = square_material_;
+    break;
+  case RM_FLAT_SQUARES:
+    current_material_ = flat_square_material_;
+    break;
+  case RM_SPHERES:
+    current_material_ = sphere_material_;
+    break;
+  case RM_TILES:
+    current_material_ = tile_material_;
+    break;
+  case RM_BOXES:
+    current_material_ = box_material_;
+    break;
   }
-  else if (mode == RM_BOXES)
-  {
-    current_material_ = Ogre::MaterialPtr(box_material_);
-  }
-
   current_material_->load();
 
   // ROS_INFO("Best technique [%s] [gp=%s]", current_material_->getBestTechnique()->getName().c_str(),
@@ -262,8 +257,6 @@ void PointCloud::setRenderMode(RenderMode mode)
       }
 
       current_mode_supports_geometry_shader_ = true;
-
-      // ROS_INFO("Using geometry shader");
     }
     else
     {