Formatting shaders

Author: MrDiver

.clang-format

@@ -0,0 +1 @@
+BasedOnStyle: Microsoft

manim/renderer/shaders/default/frag.glsl

@@ -3,6 +3,7 @@
 uniform vec4 u_color;
 out vec4 frag_color;
 
-void main() {
-  frag_color = u_color;
+void main()
+{
+    frag_color = u_color;
 }

manim/renderer/shaders/default/vert.glsl

@@ -5,6 +5,7 @@ uniform mat4 u_model_matrix;
 uniform mat4 u_view_matrix;
 uniform mat4 u_projection_matrix;
 
-void main() {
+void main()
+{
     gl_Position = u_projection_matrix * u_view_matrix * u_model_matrix * vec4(in_vert, 1.0);
 }

manim/renderer/shaders/include/camera_uniform_declarations.glsl

@@ -1,6 +1,7 @@
 #ifndef CAMERA_GLSL
 #define CAMERA_GLSL
-layout (std140) uniform ubo_camera {
+layout(std140) uniform ubo_camera
+{
     // mat4 u_projection_view_matrix; # TODO: convert to mat4 instead of the following...
     vec2 frame_shape;
     vec3 camera_center;

manim/renderer/shaders/include/finalize_color.glsl

@@ -1,29 +1,22 @@
 #ifndef FINALIZE_COLOR_GLSL
 #define FINALIZE_COLOR_GLSL
 
-vec3 float_to_color(float value, float min_val, float max_val, vec3[9] colormap_data){
+vec3 float_to_color(float value, float min_val, float max_val, vec3[9] colormap_data)
+{
     float alpha = clamp((value - min_val) / (max_val - min_val), 0.0, 1.0);
     int disc_alpha = min(int(alpha * 8), 7);
-    return mix(
-        colormap_data[disc_alpha],
-        colormap_data[disc_alpha + 1],
-        8.0 * alpha - disc_alpha
-    );
+    return mix(colormap_data[disc_alpha], colormap_data[disc_alpha + 1], 8.0 * alpha - disc_alpha);
 }
 
-
-vec4 add_light(vec4 color,
-               vec3 point,
-               vec3 unit_normal,
-               vec3 light_coords,
-               float gloss,
-               float shadow){
+vec4 add_light(vec4 color, vec3 point, vec3 unit_normal, vec3 light_coords, float gloss, float shadow)
+{
     if (gloss == 0.0 && shadow == 0.0 && reflectiveness == 0.0)
         return color;
 
     // TODO, do we actually want this?  It effectively treats surfaces as two-sided
-    if(unit_normal.z < 0){
-            unit_normal *= -1;
+    if (unit_normal.z < 0)
+    {
+        unit_normal *= -1;
     }
 
     // TODO, read this in as a uniform?
@@ -36,18 +29,11 @@ vec4 add_light(vec4 color,
     float shine = gloss * exp(-3 * pow(1 - dot_prod, 2));
     float dp2 = dot(normalize(to_light), unit_normal);
     float darkening = mix(1, max(dp2, 0), shadow);
-    return vec4(
-            darkening * mix(color.rgb, vec3(1.0), shine),
-            color.a
-    );
+    return vec4(darkening * mix(color.rgb, vec3(1.0), shine), color.a);
 }
 
-vec4 finalize_color(vec4 color,
-                    vec3 point,
-                    vec3 unit_normal,
-                    vec3 light_coords,
-                    float gloss,
-                    float shadow){
+vec4 finalize_color(vec4 color, vec3 point, vec3 unit_normal, vec3 light_coords, float gloss, float shadow)
+{
     ///// INSERT COLOR FUNCTION HERE /////
     // The line above may be replaced by arbitrary code snippets, as per
     // the method Mobject.set_color_by_code

manim/renderer/shaders/include/get_gl_Position.glsl

@@ -6,29 +6,35 @@
 
 const vec2 DEFAULT_FRAME_SHAPE = vec2(8.0 * 16.0 / 9.0, 8.0);
 
-float perspective_scale_factor(float z, float focal_distance) {
-  return max(0.0, focal_distance / (focal_distance - z));
+float perspective_scale_factor(float z, float focal_distance)
+{
+    return max(0.0, focal_distance / (focal_distance - z));
 }
 
-vec4 get_gl_Position(vec3 point) {
-  vec4 result = vec4(point, 1.0);
-  if (!bool(is_fixed_in_frame)) {
-    result.x *= 2.0 / frame_shape.x;
-    result.y *= 2.0 / frame_shape.y;
-    float psf = perspective_scale_factor(result.z, focal_distance);
-    if (psf > 0) {
-      result.xy *= psf;
-      // TODO, what's the better way to do this?
-      // This is to keep vertices too far out of frame from getting cut.
-      // TODO This will be done by the clipping plane in the future with the
-      // transformation matrix result.z += z_shift;
-      result.z *= (1.0 / 100.0);
+vec4 get_gl_Position(vec3 point)
+{
+    vec4 result = vec4(point, 1.0);
+    if (!bool(is_fixed_in_frame))
+    {
+        result.x *= 2.0 / frame_shape.x;
+        result.y *= 2.0 / frame_shape.y;
+        float psf = perspective_scale_factor(result.z, focal_distance);
+        if (psf > 0)
+        {
+            result.xy *= psf;
+            // TODO, what's the better way to do this?
+            // This is to keep vertices too far out of frame from getting cut.
+            // TODO This will be done by the clipping plane in the future with the
+            // transformation matrix result.z += z_shift;
+            result.z *= (1.0 / 100.0);
+        }
     }
-  } else {
-    result.x *= 2.0 / DEFAULT_FRAME_SHAPE.x;
-    result.y *= 2.0 / DEFAULT_FRAME_SHAPE.y;
-  }
-  result.z *= -1;
-  return result;
+    else
+    {
+        result.x *= 2.0 / DEFAULT_FRAME_SHAPE.x;
+        result.y *= 2.0 / DEFAULT_FRAME_SHAPE.y;
+    }
+    result.z *= -1;
+    return result;
 }
 #endif // GET_GL_POSITION_GLSL

manim/renderer/shaders/include/mobject_uniform_declarations.glsl

@@ -1,7 +1,8 @@
 #ifndef MOBJECT_GLSL
 #define MOBJECT_GLSL
 
-layout (std140) uniform ubo_mobject {
+layout(std140) uniform ubo_mobject
+{
     vec3 light_source_position;
     float gloss;
     float shadow;

manim/renderer/shaders/include/position_point_into_frame.glsl

@@ -4,19 +4,23 @@
 #include "./camera_uniform_declarations.glsl"
 #include "./mobject_uniform_declarations.glsl"
 
-vec3 rotate_point_into_frame(vec3 point){
-    if(bool(is_fixed_in_frame)){
+vec3 rotate_point_into_frame(vec3 point)
+{
+    if (bool(is_fixed_in_frame))
+    {
         return point;
     }
     return camera_rotation * point;
 }
 
-
-vec3 position_point_into_frame(vec3 point){
-    if(bool(is_fixed_in_frame)){
+vec3 position_point_into_frame(vec3 point)
+{
+    if (bool(is_fixed_in_frame))
+    {
         return point;
     }
-    if(bool(is_fixed_orientation)){
+    if (bool(is_fixed_orientation))
+    {
         vec3 new_center = rotate_point_into_frame(fixed_orientation_center);
         return point + (new_center - fixed_orientation_center);
     }

manim/renderer/shaders/quadratic_bezier_fill/frag.glsl

@@ -5,7 +5,7 @@ uniform vec2 pixel_shape;
 uniform float index;
 
 in vec4 color;
-in float fill_all;  // Either 0 or 1e
+in float fill_all; // Either 0 or 1e
 
 in float orientation;
 in vec2 uv_coords;
@@ -18,8 +18,10 @@ layout(location = 1) out vec4 stencil_value;
 
 #define ANTI_ALIASING
 
-float sdf(){
-    if(bezier_degree < 2){
+float sdf()
+{
+    if (bezier_degree < 2)
+    {
         return abs(uv_coords[1]);
     }
     vec2 p = uv_coords;
@@ -33,10 +35,11 @@ float sdf(){
 #endif
 }
 
-
-void main() {
+void main()
+{
     gl_FragDepth = gl_FragCoord.z;
-    if (color.a == 0) discard;
+    if (color.a == 0)
+        discard;
 
     float previous_index =
         texture2D(stencil_texture, vec2(gl_FragCoord.x / pixel_shape.x, gl_FragCoord.y / pixel_shape.y)).r;
@@ -55,7 +58,8 @@ void main() {
     stencil_value.rgb = vec3(index);
     stencil_value.a = 1.0;
     frag_color = color;
-    if (fill_all == 1.0) return;
+    if (fill_all == 1.0)
+        return;
 #ifdef ANTI_ALIASING
     float fac = max(0.0, min(1.0, 0.5 - sdf()));
     frag_color.a *= fac; // Anti-aliasing

manim/renderer/shaders/quadratic_bezier_fill/geom.glsl

@@ -1,7 +1,7 @@
 #version 330
 
-layout (triangles) in;
-layout (triangle_strip, max_vertices = 5) out;
+layout(triangles) in;
+layout(triangle_strip, max_vertices = 5) out;
 
 // Needed for get_gl_Position
 // uniform vec2 frame_shape;
@@ -20,12 +20,12 @@ out vec2 uv_coords;
 out float bezier_degree;
 
 // Analog of import for manim only
-#include "../include/mobject_uniform_declarations.glsl"
 #include "../include/camera_uniform_declarations.glsl"
-#include "../include/quadratic_bezier_geometry_functions.glsl"
+#include "../include/finalize_color.glsl"
 #include "../include/get_gl_Position.glsl"
 #include "../include/get_unit_normal.glsl"
-#include "../include/finalize_color.glsl"
+#include "../include/mobject_uniform_declarations.glsl"
+#include "../include/quadratic_bezier_geometry_functions.glsl"
 
 const vec2 uv_coords_arr[3] = vec2[3](vec2(0, 0), vec2(0.5, 0), vec2(1, 1));
 
@@ -39,21 +39,20 @@ void emit_vertex_wrapper(vec3 point, int index)
 
 void emit_simple_triangle()
 {
-    for(int i = 0; i < 3; i++)
+    for (int i = 0; i < 3; i++)
     {
         emit_vertex_wrapper(bp[i], i);
     }
     EndPrimitive();
 }
 
-void main(){
+void main()
+{
     // If vert indices are sequential, don't fill all
-    fill_all = float(
-        (v_vert_index[1] - v_vert_index[0]) != 1.0 ||
-        (v_vert_index[2] - v_vert_index[1]) != 1.0
-    );
+    fill_all = float((v_vert_index[1] - v_vert_index[0]) != 1.0 || (v_vert_index[2] - v_vert_index[1]) != 1.0);
 
-    if(fill_all == 1.0){
+    if (fill_all == 1.0)
+    {
         emit_simple_triangle();
         return;
     }
@@ -63,7 +62,8 @@ void main(){
     vec3 local_unit_normal = get_unit_normal(new_bp);
     orientation = sign(dot(v_global_unit_normal[0], local_unit_normal));
 
-    if(bezier_degree >= 1){
+    if (bezier_degree >= 1)
+    {
         emit_simple_triangle();
     }
     // Don't emit any vertices for bezier_degree 0

manim/renderer/shaders/quadratic_bezier_fill/vert.glsl

@@ -2,6 +2,7 @@
 
 #include "../include/camera_uniform_declarations.glsl"
 #include "../include/mobject_uniform_declarations.glsl"
+#include "../include/position_point_into_frame.glsl"
 
 in vec3 point;
 in vec3 unit_normal;
@@ -13,10 +14,8 @@ out vec4 v_color;
 out float v_vert_index;
 out vec3 v_global_unit_normal;
 
-// Analog of import for manim only
-#include "../include/position_point_into_frame.glsl"
-
-void main(){
+void main()
+{
     bp = position_point_into_frame(point.xyz);
     v_global_unit_normal = rotate_point_into_frame(unit_normal);
     v_color = color;