Cleanup: DRW: common_math_geom_lib.glsl: Fix variable name style

source/blender/draw/intern/shaders/common_math_geom_lib.glsl

@@ -5,63 +5,71 @@
 /** \name Math intersection & projection functions.
  * \{ */
 
-float point_plane_projection_dist(vec3 lineorigin, vec3 planeorigin, vec3 planenormal)
+float point_plane_projection_dist(vec3 line_origin, vec3 plane_origin, vec3 plane_normal)
 {
-  return dot(planenormal, planeorigin - lineorigin);
+  return dot(plane_normal, plane_origin - line_origin);
 }
 
-float line_plane_intersect_dist(vec3 lineorigin,
-                                vec3 linedirection,
-                                vec3 planeorigin,
-                                vec3 planenormal)
+float line_plane_intersect_dist(vec3 line_origin,
+                                vec3 line_direction,
+                                vec3 plane_origin,
+                                vec3 plane_normal)
 {
-  return dot(planenormal, planeorigin - lineorigin) / dot(planenormal, linedirection);
+  return dot(plane_normal, plane_origin - line_origin) / dot(plane_normal, line_direction);
 }
 
-float line_plane_intersect_dist(vec3 lineorigin, vec3 linedirection, vec4 plane)
+float line_plane_intersect_dist(vec3 line_origin, vec3 line_direction, vec4 plane)
 {
   vec3 plane_co = plane.xyz * (-plane.w / len_squared(plane.xyz));
-  vec3 h = lineorigin - plane_co;
-  return -dot(plane.xyz, h) / dot(plane.xyz, linedirection);
+  vec3 h = line_origin - plane_co;
+  return -dot(plane.xyz, h) / dot(plane.xyz, line_direction);
 }
 
-vec3 line_plane_intersect(vec3 lineorigin, vec3 linedirection, vec3 planeorigin, vec3 planenormal)
+vec3 line_plane_intersect(vec3 line_origin,
+                          vec3 line_direction,
+                          vec3 plane_origin,
+                          vec3 plane_normal)
 {
-  float dist = line_plane_intersect_dist(lineorigin, linedirection, planeorigin, planenormal);
-  return lineorigin + linedirection * dist;
+  float dist = line_plane_intersect_dist(line_origin, line_direction, plane_origin, plane_normal);
+  return line_origin + line_direction * dist;
 }
 
-vec3 line_plane_intersect(vec3 lineorigin, vec3 linedirection, vec4 plane)
+vec3 line_plane_intersect(vec3 line_origin, vec3 line_direction, vec4 plane)
 {
-  float dist = line_plane_intersect_dist(lineorigin, linedirection, plane);
-  return lineorigin + linedirection * dist;
+  float dist = line_plane_intersect_dist(line_origin, line_direction, plane);
+  return line_origin + line_direction * dist;
 }
 
-float line_aligned_plane_intersect_dist(vec3 lineorigin, vec3 linedirection, vec3 planeorigin)
+float line_aligned_plane_intersect_dist(vec3 line_origin, vec3 line_direction, vec3 plane_origin)
 {
   /* aligned plane normal */
-  vec3 L = planeorigin - lineorigin;
-  float diskdist = length(L);
-  vec3 planenormal = -normalize(L);
-  return -diskdist / dot(planenormal, linedirection);
+  vec3 L = plane_origin - line_origin;
+  float disk_dist = length(L);
+  vec3 plane_normal = -normalize(L);
+  return -disk_dist / dot(plane_normal, line_direction);
 }
 
-vec3 line_aligned_plane_intersect(vec3 lineorigin, vec3 linedirection, vec3 planeorigin)
+vec3 line_aligned_plane_intersect(vec3 line_origin, vec3 line_direction, vec3 plane_origin)
 {
-  float dist = line_aligned_plane_intersect_dist(lineorigin, linedirection, planeorigin);
+  float dist = line_aligned_plane_intersect_dist(line_origin, line_direction, plane_origin);
   if (dist < 0) {
     /* if intersection is behind we fake the intersection to be
      * really far and (hopefully) not inside the radius of interest */
     dist = 1e16;
   }
-  return lineorigin + linedirection * dist;
+  return line_origin + line_direction * dist;
 }
 
-float line_unit_sphere_intersect_dist(vec3 lineorigin, vec3 linedirection)
+/**
+ * Returns intersection distance between the unit sphere and the line
+ * with the assumption that \a line_origin is contained in the unit sphere.
+ * It will always returns the farthest intersection.
+ */
+float line_unit_sphere_intersect_dist(vec3 line_origin, vec3 line_direction)
 {
-  float a = dot(linedirection, linedirection);
-  float b = dot(linedirection, lineorigin);
-  float c = dot(lineorigin, lineorigin) - 1;
+  float a = dot(line_direction, line_direction);
+  float b = dot(line_direction, line_origin);
+  float c = dot(line_origin, line_origin) - 1;
 
   float dist = 1e15;
   float determinant = b * b - a * c;
@@ -72,22 +80,27 @@ float line_unit_sphere_intersect_dist(vec3 lineorigin, vec3 linedirection)
   return dist;
 }
 
-float line_unit_box_intersect_dist(vec3 lineorigin, vec3 linedirection)
+/**
+ * Returns minimum intersection distance between the unit box and the line
+ * with the assumption that \a line_origin is contained in the unit box.
+ * In other words, it will always returns the farthest intersection.
+ */
+float line_unit_box_intersect_dist(vec3 line_origin, vec3 line_direction)
 {
   /* https://seblagarde.wordpress.com/2012/09/29/image-based-lighting-approaches-and-parallax-corrected-cubemap/
    */
-  vec3 firstplane = (vec3(1.0) - lineorigin) / linedirection;
-  vec3 secondplane = (vec3(-1.0) - lineorigin) / linedirection;
-  vec3 furthestplane = max(firstplane, secondplane);
+  vec3 first_plane = (vec3(1.0) - line_origin) / line_direction;
+  vec3 second_plane = (vec3(-1.0) - line_origin) / line_direction;
+  vec3 farthest_plane = max(first_plane, second_plane);
 
-  return min_v3(furthestplane);
+  return min_v3(farthest_plane);
 }
 
-float line_unit_box_intersect_dist_safe(vec3 lineorigin, vec3 linedirection)
+float line_unit_box_intersect_dist_safe(vec3 line_origin, vec3 line_direction)
 {
-  vec3 safe_linedirection = max(vec3(1e-8), abs(linedirection)) *
-                            select(vec3(1.0), -vec3(1.0), lessThan(linedirection, vec3(0.0)));
-  return line_unit_box_intersect_dist(lineorigin, safe_linedirection);
+  vec3 safe_line_direction = max(vec3(1e-8), abs(line_direction)) *
+                             select(vec3(1.0), -vec3(1.0), lessThan(line_direction, vec3(0.0)));
+  return line_unit_box_intersect_dist(line_origin, safe_line_direction);
 }
 
 /**
@@ -115,8 +128,8 @@ float line_aabb_clipping_dist(vec3 line_origin, vec3 line_direction, vec3 aabb_m
 
 void make_orthonormal_basis(vec3 N, out vec3 T, out vec3 B)
 {
-  vec3 UpVector = abs(N.z) < 0.99999 ? vec3(0.0, 0.0, 1.0) : vec3(1.0, 0.0, 0.0);
-  T = normalize(cross(UpVector, N));
+  vec3 up_vector = abs(N.z) < 0.99999 ? vec3(0.0, 0.0, 1.0) : vec3(1.0, 0.0, 0.0);
+  T = normalize(cross(up_vector, N));
   B = cross(N, T);
 }