ClangFormat: apply to source, most of intern

Apply clang format as proposed in T53211.

For details on usage and instructions for migrating branches
without conflicts, see:

https://wiki.blender.org/wiki/Tools/ClangFormat

1 files changed, 1087 insertions, 1020 deletions

diff --git a/source/blender/blenkernel/intern/studiolight.c b/source/blender/blenkernel/intern/studiolight.c
index 38975f9a227..7a95ec3055e 100644
--- a/source/blender/blenkernel/intern/studiolight.c
+++ b/source/blender/blenkernel/intern/studiolight.c
@@ -46,7 +46,6 @@
 
 #include "MEM_guardedalloc.h"
 
-
 /* Statics */
 static ListBase studiolights;
 static int last_studiolight_id = 0;
@@ -94,133 +93,141 @@ static const char *STUDIOLIGHT_MATCAP_DEFAULT = "basic_1.exr";
  *   texel_size[2] : UV size of a pixel in this texture.
  *   pixel[] : pointer to the current pixel.
  */
-#define ITER_PIXELS(type, src, channels, width, height)                                \
-{                                                                                      \
-	float texel_size[2];                                                               \
-	texel_size[0] = 1.0f / width;                                                      \
-	texel_size[1] = 1.0f / height;                                                     \
-	type (*pixel_)[channels] = (type (*)[channels])src;                                \
-	for (float y = 0.5 * texel_size[1]; y < 1.0; y += texel_size[1]) {                 \
-		for (float x = 0.5 * texel_size[0]; x < 1.0; x += texel_size[0], pixel_++) {   \
-			type *pixel = *pixel_;
-
-#define ITER_PIXELS_END                                                              \
-		}                                                                            \
-	}                                                                                \
-} ((void)0)
+#define ITER_PIXELS(type, src, channels, width, height) \
+  { \
+    float texel_size[2]; \
+    texel_size[0] = 1.0f / width; \
+    texel_size[1] = 1.0f / height; \
+    type(*pixel_)[channels] = (type(*)[channels])src; \
+    for (float y = 0.5 * texel_size[1]; y < 1.0; y += texel_size[1]) { \
+      for (float x = 0.5 * texel_size[0]; x < 1.0; x += texel_size[0], pixel_++) { \
+        type *pixel = *pixel_;
+
+#define ITER_PIXELS_END \
+  } \
+  } \
+  } \
+  ((void)0)
 
 /* FUNCTIONS */
-#define IMB_SAFE_FREE(p) do { \
-if (p) {                      \
-	IMB_freeImBuf(p);         \
-	p = NULL;                 \
-}                             \
-} while (0)
-
-#define GPU_TEXTURE_SAFE_FREE(p) do { \
-if (p) {                              \
-	GPU_texture_free(p);              \
-	p = NULL;                         \
-}                                     \
-} while (0)
+#define IMB_SAFE_FREE(p) \
+  do { \
+    if (p) { \
+      IMB_freeImBuf(p); \
+      p = NULL; \
+    } \
+  } while (0)
+
+#define GPU_TEXTURE_SAFE_FREE(p) \
+  do { \
+    if (p) { \
+      GPU_texture_free(p); \
+      p = NULL; \
+    } \
+  } while (0)
 
 static void studiolight_free(struct StudioLight *sl)
 {
-#define STUDIOLIGHT_DELETE_ICON(s) {  \
-	if (s != 0) {                          \
-		BKE_icon_delete(s);           \
-		s = 0;                        \
-	}                                 \
-}
-	if (sl->free_function) {
-		sl->free_function(sl, sl->free_function_data);
-	}
-	STUDIOLIGHT_DELETE_ICON(sl->icon_id_radiance);
-	STUDIOLIGHT_DELETE_ICON(sl->icon_id_irradiance);
-	STUDIOLIGHT_DELETE_ICON(sl->icon_id_matcap);
-	STUDIOLIGHT_DELETE_ICON(sl->icon_id_matcap_flipped);
+#define STUDIOLIGHT_DELETE_ICON(s) \
+  { \
+    if (s != 0) { \
+      BKE_icon_delete(s); \
+      s = 0; \
+    } \
+  }
+  if (sl->free_function) {
+    sl->free_function(sl, sl->free_function_data);
+  }
+  STUDIOLIGHT_DELETE_ICON(sl->icon_id_radiance);
+  STUDIOLIGHT_DELETE_ICON(sl->icon_id_irradiance);
+  STUDIOLIGHT_DELETE_ICON(sl->icon_id_matcap);
+  STUDIOLIGHT_DELETE_ICON(sl->icon_id_matcap_flipped);
 #undef STUDIOLIGHT_DELETE_ICON
 
-	for (int index = 0; index < 6; index++) {
-		IMB_SAFE_FREE(sl->radiance_cubemap_buffers[index]);
-	}
-	GPU_TEXTURE_SAFE_FREE(sl->equirect_radiance_gputexture);
-	GPU_TEXTURE_SAFE_FREE(sl->equirect_irradiance_gputexture);
-	IMB_SAFE_FREE(sl->equirect_radiance_buffer);
-	IMB_SAFE_FREE(sl->equirect_irradiance_buffer);
-	MEM_SAFE_FREE(sl->path_irr_cache);
-	MEM_SAFE_FREE(sl->path_sh_cache);
-	MEM_SAFE_FREE(sl);
+  for (int index = 0; index < 6; index++) {
+    IMB_SAFE_FREE(sl->radiance_cubemap_buffers[index]);
+  }
+  GPU_TEXTURE_SAFE_FREE(sl->equirect_radiance_gputexture);
+  GPU_TEXTURE_SAFE_FREE(sl->equirect_irradiance_gputexture);
+  IMB_SAFE_FREE(sl->equirect_radiance_buffer);
+  IMB_SAFE_FREE(sl->equirect_irradiance_buffer);
+  MEM_SAFE_FREE(sl->path_irr_cache);
+  MEM_SAFE_FREE(sl->path_sh_cache);
+  MEM_SAFE_FREE(sl);
 }
 
 static struct StudioLight *studiolight_create(int flag)
 {
-	struct StudioLight *sl = MEM_callocN(sizeof(*sl), __func__);
-	sl->path[0] = 0x00;
-	sl->name[0] = 0x00;
-	sl->path_irr_cache = NULL;
-	sl->path_sh_cache = NULL;
-	sl->free_function = NULL;
-	sl->flag = flag;
-	sl->index = ++last_studiolight_id;
-	if (flag & STUDIOLIGHT_TYPE_STUDIO) {
-		sl->icon_id_irradiance = BKE_icon_ensure_studio_light(sl, STUDIOLIGHT_ICON_ID_TYPE_IRRADIANCE);
-	}
-	else if (flag & STUDIOLIGHT_TYPE_MATCAP) {
-		sl->icon_id_matcap = BKE_icon_ensure_studio_light(sl, STUDIOLIGHT_ICON_ID_TYPE_MATCAP);
-		sl->icon_id_matcap_flipped = BKE_icon_ensure_studio_light(sl, STUDIOLIGHT_ICON_ID_TYPE_MATCAP_FLIPPED);
-	}
-	else {
-		sl->icon_id_radiance = BKE_icon_ensure_studio_light(sl, STUDIOLIGHT_ICON_ID_TYPE_RADIANCE);
-	}
-
-	for (int index = 0; index < 6; index++) {
-		sl->radiance_cubemap_buffers[index] = NULL;
-	}
-
-	return sl;
+  struct StudioLight *sl = MEM_callocN(sizeof(*sl), __func__);
+  sl->path[0] = 0x00;
+  sl->name[0] = 0x00;
+  sl->path_irr_cache = NULL;
+  sl->path_sh_cache = NULL;
+  sl->free_function = NULL;
+  sl->flag = flag;
+  sl->index = ++last_studiolight_id;
+  if (flag & STUDIOLIGHT_TYPE_STUDIO) {
+    sl->icon_id_irradiance = BKE_icon_ensure_studio_light(sl, STUDIOLIGHT_ICON_ID_TYPE_IRRADIANCE);
+  }
+  else if (flag & STUDIOLIGHT_TYPE_MATCAP) {
+    sl->icon_id_matcap = BKE_icon_ensure_studio_light(sl, STUDIOLIGHT_ICON_ID_TYPE_MATCAP);
+    sl->icon_id_matcap_flipped = BKE_icon_ensure_studio_light(
+        sl, STUDIOLIGHT_ICON_ID_TYPE_MATCAP_FLIPPED);
+  }
+  else {
+    sl->icon_id_radiance = BKE_icon_ensure_studio_light(sl, STUDIOLIGHT_ICON_ID_TYPE_RADIANCE);
+  }
+
+  for (int index = 0; index < 6; index++) {
+    sl->radiance_cubemap_buffers[index] = NULL;
+  }
+
+  return sl;
 }
 
 #define STUDIOLIGHT_FILE_VERSION 1
 
-#define READ_VAL(type, parser, id, val, lines) do { \
-	for (LinkNode *line = lines; line; line = line->next) { \
-		char *val_str, *str = line->link; \
-		if ((val_str = strstr(str, id " "))) { \
-			val_str += sizeof(id); /* Skip id + spacer. */ \
-			val = parser(val_str); \
-		} \
-	} \
-} while (0)
+#define READ_VAL(type, parser, id, val, lines) \
+  do { \
+    for (LinkNode *line = lines; line; line = line->next) { \
+      char *val_str, *str = line->link; \
+      if ((val_str = strstr(str, id " "))) { \
+        val_str += sizeof(id); /* Skip id + spacer. */ \
+        val = parser(val_str); \
+      } \
+    } \
+  } while (0)
 
 #define READ_FVAL(id, val, lines) READ_VAL(float, atof, id, val, lines)
 #define READ_IVAL(id, val, lines) READ_VAL(int, atoi, id, val, lines)
 
-#define READ_VEC3(id, val, lines) do { \
-	READ_FVAL(id ".x", val[0], lines); \
-	READ_FVAL(id ".y", val[1], lines); \
-	READ_FVAL(id ".z", val[2], lines); \
-} while (0)
-
-#define READ_SOLIDLIGHT(sl, i, lines) do { \
-	READ_IVAL("light[" STRINGIFY(i) "].flag", sl[i].flag, lines); \
-	READ_FVAL("light[" STRINGIFY(i) "].smooth", sl[i].smooth, lines); \
-	READ_VEC3("light[" STRINGIFY(i) "].col", sl[i].col, lines); \
-	READ_VEC3("light[" STRINGIFY(i) "].spec", sl[i].spec, lines); \
-	READ_VEC3("light[" STRINGIFY(i) "].vec", sl[i].vec, lines); \
-} while (0)
+#define READ_VEC3(id, val, lines) \
+  do { \
+    READ_FVAL(id ".x", val[0], lines); \
+    READ_FVAL(id ".y", val[1], lines); \
+    READ_FVAL(id ".z", val[2], lines); \
+  } while (0)
+
+#define READ_SOLIDLIGHT(sl, i, lines) \
+  do { \
+    READ_IVAL("light[" STRINGIFY(i) "].flag", sl[i].flag, lines); \
+    READ_FVAL("light[" STRINGIFY(i) "].smooth", sl[i].smooth, lines); \
+    READ_VEC3("light[" STRINGIFY(i) "].col", sl[i].col, lines); \
+    READ_VEC3("light[" STRINGIFY(i) "].spec", sl[i].spec, lines); \
+    READ_VEC3("light[" STRINGIFY(i) "].vec", sl[i].vec, lines); \
+  } while (0)
 
 static void studiolight_load_solid_light(StudioLight *sl)
 {
-	LinkNode *lines = BLI_file_read_as_lines(sl->path);
-	if (lines) {
-		READ_VEC3("light_ambient", sl->light_ambient, lines);
-		READ_SOLIDLIGHT(sl->light, 0, lines);
-		READ_SOLIDLIGHT(sl->light, 1, lines);
-		READ_SOLIDLIGHT(sl->light, 2, lines);
-		READ_SOLIDLIGHT(sl->light, 3, lines);
-	}
-	BLI_file_free_lines(lines);
+  LinkNode *lines = BLI_file_read_as_lines(sl->path);
+  if (lines) {
+    READ_VEC3("light_ambient", sl->light_ambient, lines);
+    READ_SOLIDLIGHT(sl->light, 0, lines);
+    READ_SOLIDLIGHT(sl->light, 1, lines);
+    READ_SOLIDLIGHT(sl->light, 2, lines);
+    READ_SOLIDLIGHT(sl->light, 3, lines);
+  }
+  BLI_file_free_lines(lines);
 }
 
 #undef READ_SOLIDLIGHT
@@ -231,42 +238,44 @@ static void studiolight_load_solid_light(StudioLight *sl)
 #define WRITE_FVAL(str, id, val) (BLI_dynstr_appendf(str, id " %f\n", val))
 #define WRITE_IVAL(str, id, val) (BLI_dynstr_appendf(str, id " %d\n", val))
 
-#define WRITE_VEC3(str, id, val) do { \
-	WRITE_FVAL(str, id ".x", val[0]); \
-	WRITE_FVAL(str, id ".y", val[1]); \
-	WRITE_FVAL(str, id ".z", val[2]); \
-} while (0)
-
-#define WRITE_SOLIDLIGHT(str, sl, i) do { \
-	WRITE_IVAL(str, "light[" STRINGIFY(i) "].flag", sl[i].flag); \
-	WRITE_FVAL(str, "light[" STRINGIFY(i) "].smooth", sl[i].smooth); \
-	WRITE_VEC3(str, "light[" STRINGIFY(i) "].col", sl[i].col); \
-	WRITE_VEC3(str, "light[" STRINGIFY(i) "].spec", sl[i].spec); \
-	WRITE_VEC3(str, "light[" STRINGIFY(i) "].vec", sl[i].vec); \
-} while (0)
+#define WRITE_VEC3(str, id, val) \
+  do { \
+    WRITE_FVAL(str, id ".x", val[0]); \
+    WRITE_FVAL(str, id ".y", val[1]); \
+    WRITE_FVAL(str, id ".z", val[2]); \
+  } while (0)
+
+#define WRITE_SOLIDLIGHT(str, sl, i) \
+  do { \
+    WRITE_IVAL(str, "light[" STRINGIFY(i) "].flag", sl[i].flag); \
+    WRITE_FVAL(str, "light[" STRINGIFY(i) "].smooth", sl[i].smooth); \
+    WRITE_VEC3(str, "light[" STRINGIFY(i) "].col", sl[i].col); \
+    WRITE_VEC3(str, "light[" STRINGIFY(i) "].spec", sl[i].spec); \
+    WRITE_VEC3(str, "light[" STRINGIFY(i) "].vec", sl[i].vec); \
+  } while (0)
 
 static void studiolight_write_solid_light(StudioLight *sl)
 {
-	FILE *fp = BLI_fopen(sl->path, "wb");
-	if (fp) {
-		DynStr *str = BLI_dynstr_new();
-
-		/* Very dumb ascii format. One value per line separated by a space. */
-		WRITE_IVAL(str, "version", STUDIOLIGHT_FILE_VERSION);
-		WRITE_VEC3(str, "light_ambient", sl->light_ambient);
-		WRITE_SOLIDLIGHT(str, sl->light, 0);
-		WRITE_SOLIDLIGHT(str, sl->light, 1);
-		WRITE_SOLIDLIGHT(str, sl->light, 2);
-		WRITE_SOLIDLIGHT(str, sl->light, 3);
-
-		char *cstr = BLI_dynstr_get_cstring(str);
-
-		fwrite(cstr, BLI_dynstr_get_len(str), 1, fp);
-		fclose(fp);
-
-		MEM_freeN(cstr);
-		BLI_dynstr_free(str);
-	}
+  FILE *fp = BLI_fopen(sl->path, "wb");
+  if (fp) {
+    DynStr *str = BLI_dynstr_new();
+
+    /* Very dumb ascii format. One value per line separated by a space. */
+    WRITE_IVAL(str, "version", STUDIOLIGHT_FILE_VERSION);
+    WRITE_VEC3(str, "light_ambient", sl->light_ambient);
+    WRITE_SOLIDLIGHT(str, sl->light, 0);
+    WRITE_SOLIDLIGHT(str, sl->light, 1);
+    WRITE_SOLIDLIGHT(str, sl->light, 2);
+    WRITE_SOLIDLIGHT(str, sl->light, 3);
+
+    char *cstr = BLI_dynstr_get_cstring(str);
+
+    fwrite(cstr, BLI_dynstr_get_len(str), 1, fp);
+    fclose(fp);
+
+    MEM_freeN(cstr);
+    BLI_dynstr_free(str);
+  }
 }
 
 #undef WRITE_SOLIDLIGHT
@@ -276,203 +285,217 @@ static void studiolight_write_solid_light(StudioLight *sl)
 
 static void direction_to_equirect(float r[2], const float dir[3])
 {
-	r[0] = (atan2f(dir[1], dir[0]) - M_PI) / -(M_PI * 2);
-	r[1] = (acosf(dir[2] / 1.0) - M_PI) / -M_PI;
+  r[0] = (atan2f(dir[1], dir[0]) - M_PI) / -(M_PI * 2);
+  r[1] = (acosf(dir[2] / 1.0) - M_PI) / -M_PI;
 }
 
 static void equirect_to_direction(float r[3], float u, float v)
 {
-	float phi = (-(M_PI * 2)) * u + M_PI;
-	float theta = -M_PI * v + M_PI;
-	float sin_theta = sinf(theta);
-	r[0] = sin_theta * cosf(phi);
-	r[1] = sin_theta * sinf(phi);
-	r[2] = cosf(theta);
+  float phi = (-(M_PI * 2)) * u + M_PI;
+  float theta = -M_PI * v + M_PI;
+  float sin_theta = sinf(theta);
+  r[0] = sin_theta * cosf(phi);
+  r[1] = sin_theta * sinf(phi);
+  r[2] = cosf(theta);
 }
 
-static void UNUSED_FUNCTION(direction_to_cube_face_uv)(float r_uv[2], int *r_face, const float dir[3])
+static void UNUSED_FUNCTION(direction_to_cube_face_uv)(float r_uv[2],
+                                                       int *r_face,
+                                                       const float dir[3])
 {
-	if (fabsf(dir[0]) > fabsf(dir[1]) && fabsf(dir[0]) > fabsf(dir[2])) {
-		bool is_pos = (dir[0] > 0.0f);
-		*r_face = is_pos ? STUDIOLIGHT_X_POS : STUDIOLIGHT_X_NEG;
-		r_uv[0] = dir[2] / fabsf(dir[0]) * (is_pos ?  1 : -1);
-		r_uv[1] = dir[1] / fabsf(dir[0]) * (is_pos ? -1 : -1);
-	}
-	else if (fabsf(dir[1]) > fabsf(dir[0]) && fabsf(dir[1]) > fabsf(dir[2])) {
-		bool is_pos = (dir[1] > 0.0f);
-		*r_face = is_pos ? STUDIOLIGHT_Y_POS : STUDIOLIGHT_Y_NEG;
-		r_uv[0] = dir[0] / fabsf(dir[1]) * (is_pos ?  1 :  1);
-		r_uv[1] = dir[2] / fabsf(dir[1]) * (is_pos ? -1 :  1);
-	}
-	else {
-		bool is_pos = (dir[2] > 0.0f);
-		*r_face = is_pos ? STUDIOLIGHT_Z_NEG : STUDIOLIGHT_Z_POS;
-		r_uv[0] = dir[0] / fabsf(dir[2]) * (is_pos ? -1 :  1);
-		r_uv[1] = dir[1] / fabsf(dir[2]) * (is_pos ? -1 : -1);
-	}
-	r_uv[0] = r_uv[0] * 0.5f + 0.5f;
-	r_uv[1] = r_uv[1] * 0.5f + 0.5f;
+  if (fabsf(dir[0]) > fabsf(dir[1]) && fabsf(dir[0]) > fabsf(dir[2])) {
+    bool is_pos = (dir[0] > 0.0f);
+    *r_face = is_pos ? STUDIOLIGHT_X_POS : STUDIOLIGHT_X_NEG;
+    r_uv[0] = dir[2] / fabsf(dir[0]) * (is_pos ? 1 : -1);
+    r_uv[1] = dir[1] / fabsf(dir[0]) * (is_pos ? -1 : -1);
+  }
+  else if (fabsf(dir[1]) > fabsf(dir[0]) && fabsf(dir[1]) > fabsf(dir[2])) {
+    bool is_pos = (dir[1] > 0.0f);
+    *r_face = is_pos ? STUDIOLIGHT_Y_POS : STUDIOLIGHT_Y_NEG;
+    r_uv[0] = dir[0] / fabsf(dir[1]) * (is_pos ? 1 : 1);
+    r_uv[1] = dir[2] / fabsf(dir[1]) * (is_pos ? -1 : 1);
+  }
+  else {
+    bool is_pos = (dir[2] > 0.0f);
+    *r_face = is_pos ? STUDIOLIGHT_Z_NEG : STUDIOLIGHT_Z_POS;
+    r_uv[0] = dir[0] / fabsf(dir[2]) * (is_pos ? -1 : 1);
+    r_uv[1] = dir[1] / fabsf(dir[2]) * (is_pos ? -1 : -1);
+  }
+  r_uv[0] = r_uv[0] * 0.5f + 0.5f;
+  r_uv[1] = r_uv[1] * 0.5f + 0.5f;
 }
 
 static void cube_face_uv_to_direction(float r_dir[3], float x, float y, int face)
 {
-	const float conversion_matrices[6][3][3] = {
-		{{ 0.0f, 0.0f,  1.0f}, {0.0f, -1.0f,  0.0f}, { 1.0f,  0.0f,  0.0f}},
-		{{ 0.0f, 0.0f, -1.0f}, {0.0f, -1.0f,  0.0f}, {-1.0f,  0.0f,  0.0f}},
-		{{ 1.0f, 0.0f,  0.0f}, {0.0f,  0.0f, -1.0f}, { 0.0f,  1.0f,  0.0f}},
-		{{ 1.0f, 0.0f,  0.0f}, {0.0f,  0.0f,  1.0f}, { 0.0f, -1.0f,  0.0f}},
-		{{ 1.0f, 0.0f,  0.0f}, {0.0f, -1.0f,  0.0f}, { 0.0f,  0.0f, -1.0f}},
-		{{-1.0f, 0.0f,  0.0f}, {0.0f, -1.0f,  0.0f}, { 0.0f,  0.0f,  1.0f}},
-	};
-
-	copy_v3_fl3(r_dir, x * 2.0f - 1.0f, y * 2.0f - 1.0f, 1.0f);
-	mul_m3_v3(conversion_matrices[face], r_dir);
-	normalize_v3(r_dir);
+  const float conversion_matrices[6][3][3] = {
+      {{0.0f, 0.0f, 1.0f}, {0.0f, -1.0f, 0.0f}, {1.0f, 0.0f, 0.0f}},
+      {{0.0f, 0.0f, -1.0f}, {0.0f, -1.0f, 0.0f}, {-1.0f, 0.0f, 0.0f}},
+      {{1.0f, 0.0f, 0.0f}, {0.0f, 0.0f, -1.0f}, {0.0f, 1.0f, 0.0f}},
+      {{1.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 1.0f}, {0.0f, -1.0f, 0.0f}},
+      {{1.0f, 0.0f, 0.0f}, {0.0f, -1.0f, 0.0f}, {0.0f, 0.0f, -1.0f}},
+      {{-1.0f, 0.0f, 0.0f}, {0.0f, -1.0f, 0.0f}, {0.0f, 0.0f, 1.0f}},
+  };
+
+  copy_v3_fl3(r_dir, x * 2.0f - 1.0f, y * 2.0f - 1.0f, 1.0f);
+  mul_m3_v3(conversion_matrices[face], r_dir);
+  normalize_v3(r_dir);
 }
 
 static void studiolight_load_equirect_image(StudioLight *sl)
 {
-	if (sl->flag & STUDIOLIGHT_EXTERNAL_FILE) {
-		ImBuf *ibuf = NULL;
-		ibuf = IMB_loadiffname(sl->path, 0, NULL);
-		if (ibuf == NULL) {
-			float *colbuf = MEM_mallocN(sizeof(float[4]), __func__);
-			copy_v4_fl4(colbuf, 1.0f, 0.0f, 1.0f, 1.0f);
-			ibuf = IMB_allocFromBuffer(NULL, colbuf, 1, 1);
-		}
-		IMB_float_from_rect(ibuf);
-		sl->equirect_radiance_buffer = ibuf;
-	}
-	sl->flag |= STUDIOLIGHT_EXTERNAL_IMAGE_LOADED;
+  if (sl->flag & STUDIOLIGHT_EXTERNAL_FILE) {
+    ImBuf *ibuf = NULL;
+    ibuf = IMB_loadiffname(sl->path, 0, NULL);
+    if (ibuf == NULL) {
+      float *colbuf = MEM_mallocN(sizeof(float[4]), __func__);
+      copy_v4_fl4(colbuf, 1.0f, 0.0f, 1.0f, 1.0f);
+      ibuf = IMB_allocFromBuffer(NULL, colbuf, 1, 1);
+    }
+    IMB_float_from_rect(ibuf);
+    sl->equirect_radiance_buffer = ibuf;
+  }
+  sl->flag |= STUDIOLIGHT_EXTERNAL_IMAGE_LOADED;
 }
 
 static void studiolight_create_equirect_radiance_gputexture(StudioLight *sl)
 {
-	if (sl->flag & STUDIOLIGHT_EXTERNAL_FILE) {
-		char error[256];
-		BKE_studiolight_ensure_flag(sl, STUDIOLIGHT_EXTERNAL_IMAGE_LOADED);
-		ImBuf *ibuf = sl->equirect_radiance_buffer;
-
-		if (sl->flag & STUDIOLIGHT_TYPE_MATCAP) {
-			float *gpu_matcap_3components = MEM_callocN(sizeof(float[3]) * ibuf->x * ibuf->y, __func__);
-
-			float (*offset4)[4] = (float (*)[4])ibuf->rect_float;
-			float (*offset3)[3] = (float (*)[3])gpu_matcap_3components;
-			for (int i = 0; i < ibuf->x * ibuf->y; i++, offset4++, offset3++) {
-				copy_v3_v3(*offset3, *offset4);
-			}
-
-			sl->equirect_radiance_gputexture = GPU_texture_create_nD(
-			        ibuf->x, ibuf->y, 0, 2, gpu_matcap_3components, GPU_R11F_G11F_B10F, GPU_DATA_FLOAT, 0, false, error);
-
-			MEM_SAFE_FREE(gpu_matcap_3components);
-		}
-		else {
-			sl->equirect_radiance_gputexture = GPU_texture_create_2d(
-			        ibuf->x, ibuf->y, GPU_RGBA16F, ibuf->rect_float, error);
-			GPUTexture *tex = sl->equirect_radiance_gputexture;
-			GPU_texture_bind(tex, 0);
-			GPU_texture_filter_mode(tex, true);
-			GPU_texture_wrap_mode(tex, true);
-			GPU_texture_unbind(tex);
-		}
-	}
-	sl->flag |= STUDIOLIGHT_EQUIRECT_RADIANCE_GPUTEXTURE;
+  if (sl->flag & STUDIOLIGHT_EXTERNAL_FILE) {
+    char error[256];
+    BKE_studiolight_ensure_flag(sl, STUDIOLIGHT_EXTERNAL_IMAGE_LOADED);
+    ImBuf *ibuf = sl->equirect_radiance_buffer;
+
+    if (sl->flag & STUDIOLIGHT_TYPE_MATCAP) {
+      float *gpu_matcap_3components = MEM_callocN(sizeof(float[3]) * ibuf->x * ibuf->y, __func__);
+
+      float(*offset4)[4] = (float(*)[4])ibuf->rect_float;
+      float(*offset3)[3] = (float(*)[3])gpu_matcap_3components;
+      for (int i = 0; i < ibuf->x * ibuf->y; i++, offset4++, offset3++) {
+        copy_v3_v3(*offset3, *offset4);
+      }
+
+      sl->equirect_radiance_gputexture = GPU_texture_create_nD(ibuf->x,
+                                                               ibuf->y,
+                                                               0,
+                                                               2,
+                                                               gpu_matcap_3components,
+                                                               GPU_R11F_G11F_B10F,
+                                                               GPU_DATA_FLOAT,
+                                                               0,
+                                                               false,
+                                                               error);
+
+      MEM_SAFE_FREE(gpu_matcap_3components);
+    }
+    else {
+      sl->equirect_radiance_gputexture = GPU_texture_create_2d(
+          ibuf->x, ibuf->y, GPU_RGBA16F, ibuf->rect_float, error);
+      GPUTexture *tex = sl->equirect_radiance_gputexture;
+      GPU_texture_bind(tex, 0);
+      GPU_texture_filter_mode(tex, true);
+      GPU_texture_wrap_mode(tex, true);
+      GPU_texture_unbind(tex);
+    }
+  }
+  sl->flag |= STUDIOLIGHT_EQUIRECT_RADIANCE_GPUTEXTURE;
 }
 
 static void studiolight_create_equirect_irradiance_gputexture(StudioLight *sl)
 {
-	if (sl->flag & STUDIOLIGHT_EXTERNAL_FILE) {
-		char error[256];
-		BKE_studiolight_ensure_flag(sl, STUDIOLIGHT_EQUIRECT_IRRADIANCE_IMAGE_CALCULATED);
-		ImBuf *ibuf = sl->equirect_irradiance_buffer;
-		sl->equirect_irradiance_gputexture = GPU_texture_create_2d(
-		        ibuf->x, ibuf->y, GPU_RGBA16F, ibuf->rect_float, error);
-		GPUTexture *tex = sl->equirect_irradiance_gputexture;
-		GPU_texture_bind(tex, 0);
-		GPU_texture_filter_mode(tex, true);
-		GPU_texture_wrap_mode(tex, true);
-		GPU_texture_unbind(tex);
-	}
-	sl->flag |= STUDIOLIGHT_EQUIRECT_IRRADIANCE_GPUTEXTURE;
+  if (sl->flag & STUDIOLIGHT_EXTERNAL_FILE) {
+    char error[256];
+    BKE_studiolight_ensure_flag(sl, STUDIOLIGHT_EQUIRECT_IRRADIANCE_IMAGE_CALCULATED);
+    ImBuf *ibuf = sl->equirect_irradiance_buffer;
+    sl->equirect_irradiance_gputexture = GPU_texture_create_2d(
+        ibuf->x, ibuf->y, GPU_RGBA16F, ibuf->rect_float, error);
+    GPUTexture *tex = sl->equirect_irradiance_gputexture;
+    GPU_texture_bind(tex, 0);
+    GPU_texture_filter_mode(tex, true);
+    GPU_texture_wrap_mode(tex, true);
+    GPU_texture_unbind(tex);
+  }
+  sl->flag |= STUDIOLIGHT_EQUIRECT_IRRADIANCE_GPUTEXTURE;
 }
 
 static void studiolight_calculate_radiance(ImBuf *ibuf, float color[4], const float direction[3])
 {
-	float uv[2];
-	direction_to_equirect(uv, direction);
-	nearest_interpolation_color_wrap(ibuf, NULL, color, uv[0] * ibuf->x, uv[1] * ibuf->y);
+  float uv[2];
+  direction_to_equirect(uv, direction);
+  nearest_interpolation_color_wrap(ibuf, NULL, color, uv[0] * ibuf->x, uv[1] * ibuf->y);
 }
 
-static void studiolight_calculate_radiance_buffer(
-        ImBuf *ibuf, float *colbuf,
-        const int index_x, const int index_y, const int index_z,
-        const float xsign, const float ysign, const float zsign)
+static void studiolight_calculate_radiance_buffer(ImBuf *ibuf,
+                                                  float *colbuf,
+                                                  const int index_x,
+                                                  const int index_y,
+                                                  const int index_z,
+                                                  const float xsign,
+                                                  const float ysign,
+                                                  const float zsign)
 {
-	ITER_PIXELS(float, colbuf, 4,
-	            STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE,
-	            STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE)
-	{
-		float direction[3];
-		direction[index_x] = xsign * (x - 0.5f);
-		direction[index_y] = ysign * (y - 0.5f);
-		direction[index_z] = zsign * 0.5f;
-		normalize_v3(direction);
-		studiolight_calculate_radiance(ibuf, pixel, direction);
-	}
-	ITER_PIXELS_END;
+  ITER_PIXELS(
+      float, colbuf, 4, STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE, STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE)
+  {
+    float direction[3];
+    direction[index_x] = xsign * (x - 0.5f);
+    direction[index_y] = ysign * (y - 0.5f);
+    direction[index_z] = zsign * 0.5f;
+    normalize_v3(direction);
+    studiolight_calculate_radiance(ibuf, pixel, direction);
+  }
+  ITER_PIXELS_END;
 }
 
 static void studiolight_calculate_radiance_cubemap_buffers(StudioLight *sl)
 {
-	if (sl->flag & STUDIOLIGHT_EXTERNAL_FILE) {
-		BKE_studiolight_ensure_flag(sl, STUDIOLIGHT_EXTERNAL_IMAGE_LOADED);
-		ImBuf *ibuf = sl->equirect_radiance_buffer;
-		if (ibuf) {
-			float *colbuf = MEM_mallocN(SQUARE(STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE) * sizeof(float[4]), __func__);
-
-			/* front */
-			studiolight_calculate_radiance_buffer(ibuf, colbuf, 0, 2, 1,  1, -1,  1);
-			sl->radiance_cubemap_buffers[STUDIOLIGHT_Y_POS] = IMB_allocFromBuffer(
-			        NULL, colbuf, STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE, STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE);
-
-			/* back */
-			studiolight_calculate_radiance_buffer(ibuf, colbuf, 0, 2, 1,  1,  1, -1);
-			sl->radiance_cubemap_buffers[STUDIOLIGHT_Y_NEG] = IMB_allocFromBuffer(
-			        NULL, colbuf, STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE, STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE);
-
-			/* left */
-			studiolight_calculate_radiance_buffer(ibuf, colbuf, 2, 1, 0,  1, -1,  1);
-			sl->radiance_cubemap_buffers[STUDIOLIGHT_X_POS] = IMB_allocFromBuffer(
-			        NULL, colbuf, STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE, STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE);
-
-			/* right */
-			studiolight_calculate_radiance_buffer(ibuf, colbuf, 2, 1, 0, -1, -1, -1);
-			sl->radiance_cubemap_buffers[STUDIOLIGHT_X_NEG] = IMB_allocFromBuffer(
-			        NULL, colbuf, STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE, STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE);
-
-			/* top */
-			studiolight_calculate_radiance_buffer(ibuf, colbuf, 0, 1, 2, -1, -1,  1);
-			sl->radiance_cubemap_buffers[STUDIOLIGHT_Z_NEG] = IMB_allocFromBuffer(
-			        NULL, colbuf, STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE, STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE);
-
-			/* bottom */
-			studiolight_calculate_radiance_buffer(ibuf, colbuf, 0, 1, 2,  1, -1, -1);
-			sl->radiance_cubemap_buffers[STUDIOLIGHT_Z_POS] = IMB_allocFromBuffer(
-			        NULL, colbuf, STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE, STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE);
+  if (sl->flag & STUDIOLIGHT_EXTERNAL_FILE) {
+    BKE_studiolight_ensure_flag(sl, STUDIOLIGHT_EXTERNAL_IMAGE_LOADED);
+    ImBuf *ibuf = sl->equirect_radiance_buffer;
+    if (ibuf) {
+      float *colbuf = MEM_mallocN(SQUARE(STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE) * sizeof(float[4]),
+                                  __func__);
+
+      /* front */
+      studiolight_calculate_radiance_buffer(ibuf, colbuf, 0, 2, 1, 1, -1, 1);
+      sl->radiance_cubemap_buffers[STUDIOLIGHT_Y_POS] = IMB_allocFromBuffer(
+          NULL, colbuf, STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE, STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE);
+
+      /* back */
+      studiolight_calculate_radiance_buffer(ibuf, colbuf, 0, 2, 1, 1, 1, -1);
+      sl->radiance_cubemap_buffers[STUDIOLIGHT_Y_NEG] = IMB_allocFromBuffer(
+          NULL, colbuf, STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE, STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE);
+
+      /* left */
+      studiolight_calculate_radiance_buffer(ibuf, colbuf, 2, 1, 0, 1, -1, 1);
+      sl->radiance_cubemap_buffers[STUDIOLIGHT_X_POS] = IMB_allocFromBuffer(
+          NULL, colbuf, STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE, STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE);
+
+      /* right */
+      studiolight_calculate_radiance_buffer(ibuf, colbuf, 2, 1, 0, -1, -1, -1);
+      sl->radiance_cubemap_buffers[STUDIOLIGHT_X_NEG] = IMB_allocFromBuffer(
+          NULL, colbuf, STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE, STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE);
+
+      /* top */
+      studiolight_calculate_radiance_buffer(ibuf, colbuf, 0, 1, 2, -1, -1, 1);
+      sl->radiance_cubemap_buffers[STUDIOLIGHT_Z_NEG] = IMB_allocFromBuffer(
+          NULL, colbuf, STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE, STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE);
+
+      /* bottom */
+      studiolight_calculate_radiance_buffer(ibuf, colbuf, 0, 1, 2, 1, -1, -1);
+      sl->radiance_cubemap_buffers[STUDIOLIGHT_Z_POS] = IMB_allocFromBuffer(
+          NULL, colbuf, STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE, STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE);
 
 #if 0
-			IMB_saveiff(sl->radiance_cubemap_buffers[STUDIOLIGHT_X_POS], "/tmp/studiolight_radiance_left.png", IB_rectfloat);
-			IMB_saveiff(sl->radiance_cubemap_buffers[STUDIOLIGHT_X_NEG], "/tmp/studiolight_radiance_right.png", IB_rectfloat);
-			IMB_saveiff(sl->radiance_cubemap_buffers[STUDIOLIGHT_Y_POS], "/tmp/studiolight_radiance_front.png", IB_rectfloat);
-			IMB_saveiff(sl->radiance_cubemap_buffers[STUDIOLIGHT_Y_NEG], "/tmp/studiolight_radiance_back.png", IB_rectfloat);
-			IMB_saveiff(sl->radiance_cubemap_buffers[STUDIOLIGHT_Z_POS], "/tmp/studiolight_radiance_bottom.png", IB_rectfloat);
-			IMB_saveiff(sl->radiance_cubemap_buffers[STUDIOLIGHT_Z_NEG], "/tmp/studiolight_radiance_top.png", IB_rectfloat);
+      IMB_saveiff(sl->radiance_cubemap_buffers[STUDIOLIGHT_X_POS], "/tmp/studiolight_radiance_left.png", IB_rectfloat);
+      IMB_saveiff(sl->radiance_cubemap_buffers[STUDIOLIGHT_X_NEG], "/tmp/studiolight_radiance_right.png", IB_rectfloat);
+      IMB_saveiff(sl->radiance_cubemap_buffers[STUDIOLIGHT_Y_POS], "/tmp/studiolight_radiance_front.png", IB_rectfloat);
+      IMB_saveiff(sl->radiance_cubemap_buffers[STUDIOLIGHT_Y_NEG], "/tmp/studiolight_radiance_back.png", IB_rectfloat);
+      IMB_saveiff(sl->radiance_cubemap_buffers[STUDIOLIGHT_Z_POS], "/tmp/studiolight_radiance_bottom.png", IB_rectfloat);
+      IMB_saveiff(sl->radiance_cubemap_buffers[STUDIOLIGHT_Z_NEG], "/tmp/studiolight_radiance_top.png", IB_rectfloat);
 #endif
-			MEM_freeN(colbuf);
-		}
-	}
-	sl->flag |= STUDIOLIGHT_RADIANCE_BUFFERS_CALCULATED;
+      MEM_freeN(colbuf);
+    }
+  }
+  sl->flag |= STUDIOLIGHT_RADIANCE_BUFFERS_CALCULATED;
 }
 
 /*
@@ -480,236 +503,262 @@ static void studiolight_calculate_radiance_cubemap_buffers(StudioLight *sl)
  */
 BLI_INLINE float area_element(float x, float y)
 {
-	return atan2(x * y, sqrtf(x * x + y * y + 1));
+  return atan2(x * y, sqrtf(x * x + y * y + 1));
 }
 
 BLI_INLINE float texel_solid_angle(float x, float y, float halfpix)
 {
-	float v1x = (x - halfpix) * 2.0f - 1.0f;
-	float v1y = (y - halfpix) * 2.0f - 1.0f;
-	float v2x = (x + halfpix) * 2.0f - 1.0f;
-	float v2y = (y + halfpix) * 2.0f - 1.0f;
+  float v1x = (x - halfpix) * 2.0f - 1.0f;
+  float v1y = (y - halfpix) * 2.0f - 1.0f;
+  float v2x = (x + halfpix) * 2.0f - 1.0f;
+  float v2y = (y + halfpix) * 2.0f - 1.0f;
 
-	return area_element(v1x, v1y) - area_element(v1x, v2y) - area_element(v2x, v1y) + area_element(v2x, v2y);
+  return area_element(v1x, v1y) - area_element(v1x, v2y) - area_element(v2x, v1y) +
+         area_element(v2x, v2y);
 }
 
-static void studiolight_calculate_cubemap_vector_weight(float normal[3], float *weight, int face, float x, float y)
+static void studiolight_calculate_cubemap_vector_weight(
+    float normal[3], float *weight, int face, float x, float y)
 {
-	const float halfpix = 0.5f / STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE;
-	cube_face_uv_to_direction(normal, x, y, face);
-	*weight = texel_solid_angle(x, y, halfpix);
+  const float halfpix = 0.5f / STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE;
+  cube_face_uv_to_direction(normal, x, y, face);
+  *weight = texel_solid_angle(x, y, halfpix);
 }
 
 static void studiolight_spherical_harmonics_calculate_coefficients(StudioLight *sl, float (*sh)[3])
 {
-	float weight_accum = 0.0f;
-	memset(sh, 0, sizeof(float) * 3 * STUDIOLIGHT_SH_COEFS_LEN);
-
-	for (int face = 0; face < 6; face++) {
-		ITER_PIXELS(float, sl->radiance_cubemap_buffers[face]->rect_float, 4,
-		            STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE,
-		            STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE)
-		{
-			float color[3], cubevec[3], weight;
-			studiolight_calculate_cubemap_vector_weight(cubevec, &weight, face, x, y);
-			mul_v3_v3fl(color, pixel, weight);
-			weight_accum += weight;
-
-			int i = 0;
-			/* L0 */
-			madd_v3_v3fl(sh[i++], color, 0.2822095f);
+  float weight_accum = 0.0f;
+  memset(sh, 0, sizeof(float) * 3 * STUDIOLIGHT_SH_COEFS_LEN);
+
+  for (int face = 0; face < 6; face++) {
+    ITER_PIXELS(float,
+                sl->radiance_cubemap_buffers[face]->rect_float,
+                4,
+                STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE,
+                STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE)
+    {
+      float color[3], cubevec[3], weight;
+      studiolight_calculate_cubemap_vector_weight(cubevec, &weight, face, x, y);
+      mul_v3_v3fl(color, pixel, weight);
+      weight_accum += weight;
+
+      int i = 0;
+      /* L0 */
+      madd_v3_v3fl(sh[i++], color, 0.2822095f);
 #if STUDIOLIGHT_SH_BANDS > 1 /* L1 */
-			const float nx = cubevec[0];
-			const float ny = cubevec[1];
-			const float nz = cubevec[2];
-			madd_v3_v3fl(sh[i++], color, -0.488603f * nz);
-			madd_v3_v3fl(sh[i++], color, 0.488603f * ny);
-			madd_v3_v3fl(sh[i++], color, -0.488603f * nx);
+      const float nx = cubevec[0];
+      const float ny = cubevec[1];
+      const float nz = cubevec[2];
+      madd_v3_v3fl(sh[i++], color, -0.488603f * nz);
+      madd_v3_v3fl(sh[i++], color, 0.488603f * ny);
+      madd_v3_v3fl(sh[i++], color, -0.488603f * nx);
 #endif
 #if STUDIOLIGHT_SH_BANDS > 2 /* L2 */
-			const float nx2 = SQUARE(nx);
-			const float ny2 = SQUARE(ny);
-			const float nz2 = SQUARE(nz);
-			madd_v3_v3fl(sh[i++], color, 1.092548f * nx * nz);
-			madd_v3_v3fl(sh[i++], color, -1.092548f * nz * ny);
-			madd_v3_v3fl(sh[i++], color, 0.315392f * (3.0f * ny2 - 1.0f));
-			madd_v3_v3fl(sh[i++], color, 1.092548f * nx * ny);
-			madd_v3_v3fl(sh[i++], color, 0.546274f * (nx2 - nz2));
+      const float nx2 = SQUARE(nx);
+      const float ny2 = SQUARE(ny);
+      const float nz2 = SQUARE(nz);
+      madd_v3_v3fl(sh[i++], color, 1.092548f * nx * nz);
+      madd_v3_v3fl(sh[i++], color, -1.092548f * nz * ny);
+      madd_v3_v3fl(sh[i++], color, 0.315392f * (3.0f * ny2 - 1.0f));
+      madd_v3_v3fl(sh[i++], color, 1.092548f * nx * ny);
+      madd_v3_v3fl(sh[i++], color, 0.546274f * (nx2 - nz2));
 #endif
-			/* Bypass L3 Because final irradiance does not need it. */
+      /* Bypass L3 Because final irradiance does not need it. */
 #if STUDIOLIGHT_SH_BANDS > 4 /* L4 */
-			const float nx4 = SQUARE(nx2);
-			const float ny4 = SQUARE(ny2);
-			const float nz4 = SQUARE(nz2);
-			madd_v3_v3fl(sh[i++], color, 2.5033429417967046f * nx * nz * (nx2 - nz2));
-			madd_v3_v3fl(sh[i++], color, -1.7701307697799304f * nz * ny * (3.0f * nx2 - nz2));
-			madd_v3_v3fl(sh[i++], color, 0.9461746957575601f * nz * nx * (-1.0f + 7.0f * ny2));
-			madd_v3_v3fl(sh[i++], color, -0.6690465435572892f * nz * ny * (-3.0f + 7.0f * ny2));
-			madd_v3_v3fl(sh[i++], color, (105.0f * ny4 - 90.0f * ny2 + 9.0f) / 28.359261614f);
-			madd_v3_v3fl(sh[i++], color, -0.6690465435572892f * nx * ny * (-3.0f + 7.0f * ny2));
-			madd_v3_v3fl(sh[i++], color, 0.9461746957575601f * (nx2 - nz2) * (-1.0f + 7.0f * ny2));
-			madd_v3_v3fl(sh[i++], color, -1.7701307697799304f * nx * ny * (nx2 - 3.0f * nz2));
-			madd_v3_v3fl(sh[i++], color, 0.6258357354491761f * (nx4 - 6.0f * nz2 * nx2 + nz4));
+      const float nx4 = SQUARE(nx2);
+      const float ny4 = SQUARE(ny2);
+      const float nz4 = SQUARE(nz2);
+      madd_v3_v3fl(sh[i++], color, 2.5033429417967046f * nx * nz * (nx2 - nz2));
+      madd_v3_v3fl(sh[i++], color, -1.7701307697799304f * nz * ny * (3.0f * nx2 - nz2));
+      madd_v3_v3fl(sh[i++], color, 0.9461746957575601f * nz * nx * (-1.0f + 7.0f * ny2));
+      madd_v3_v3fl(sh[i++], color, -0.6690465435572892f * nz * ny * (-3.0f + 7.0f * ny2));
+      madd_v3_v3fl(sh[i++], color, (105.0f * ny4 - 90.0f * ny2 + 9.0f) / 28.359261614f);
+      madd_v3_v3fl(sh[i++], color, -0.6690465435572892f * nx * ny * (-3.0f + 7.0f * ny2));
+      madd_v3_v3fl(sh[i++], color, 0.9461746957575601f * (nx2 - nz2) * (-1.0f + 7.0f * ny2));
+      madd_v3_v3fl(sh[i++], color, -1.7701307697799304f * nx * ny * (nx2 - 3.0f * nz2));
+      madd_v3_v3fl(sh[i++], color, 0.6258357354491761f * (nx4 - 6.0f * nz2 * nx2 + nz4));
 #endif
-		}
-		ITER_PIXELS_END;
-	}
-
-	/* The sum of solid angle should be equal to the solid angle of the sphere (4 PI),
-	 * so normalize in order to make our weightAccum exactly match 4 PI. */
-	for (int i = 0; i < STUDIOLIGHT_SH_COEFS_LEN; ++i) {
-		mul_v3_fl(sh[i], M_PI * 4.0f / weight_accum);
-	}
+    }
+    ITER_PIXELS_END;
+  }
+
+  /* The sum of solid angle should be equal to the solid angle of the sphere (4 PI),
+   * so normalize in order to make our weightAccum exactly match 4 PI. */
+  for (int i = 0; i < STUDIOLIGHT_SH_COEFS_LEN; ++i) {
+    mul_v3_fl(sh[i], M_PI * 4.0f / weight_accum);
+  }
 }
 
 /* Take monochrome SH as input */
 static float studiolight_spherical_harmonics_lambda_get(float *sh, float max_laplacian)
 {
-	/* From Peter-Pike Sloan's Stupid SH Tricks http://www.ppsloan.org/publications/StupidSH36.pdf */
-	float table_l[STUDIOLIGHT_SH_BANDS];
-	float table_b[STUDIOLIGHT_SH_BANDS];
-
-	float lambda = 0.0f;
-
-	table_l[0] = 0.0f;
-	table_b[0] = 0.0f;
-	int index = 1;
-	for (int level = 1; level < STUDIOLIGHT_SH_BANDS; level++) {
-		table_l[level] = (float)(SQUARE(level) * SQUARE(level + 1));
-
-		float b = 0.0f;
-		for (int m = -1; m <= level; m++) {
-			b += SQUARE(sh[index++]);
-		}
-		table_b[level] = b;
-	}
-
-	float squared_lamplacian = 0.0f;
-	for (int level = 1; level < STUDIOLIGHT_SH_BANDS; level++) {
-		squared_lamplacian += table_l[level] * table_b[level];
-	}
-
-	const float target_squared_laplacian = max_laplacian * max_laplacian;
-	if (squared_lamplacian <= target_squared_laplacian) {
-		return lambda;
-	}
-
-	const int no_iterations = 10000000;
-	for (int i = 0; i < no_iterations; ++i) {
-		float f = 0.0f;
-		float fd = 0.0f;
-
-		for (int level = 1; level < STUDIOLIGHT_SH_BANDS; ++level) {
-			f += table_l[level] * table_b[level] / SQUARE(1.0f + lambda * table_l[level]);
-			fd += (2.0f * SQUARE(table_l[level]) * table_b[level]) / CUBE(1.0f + lambda * table_l[level]);
-		}
-
-		f = target_squared_laplacian - f;
-
-		float delta = -f / fd;
-		lambda += delta;
-
-		if (ABS(delta) < 1e-6f) {
-			break;
-		}
-	}
-
-	return lambda;
+  /* From Peter-Pike Sloan's Stupid SH Tricks http://www.ppsloan.org/publications/StupidSH36.pdf */
+  float table_l[STUDIOLIGHT_SH_BANDS];
+  float table_b[STUDIOLIGHT_SH_BANDS];
+
+  float lambda = 0.0f;
+
+  table_l[0] = 0.0f;
+  table_b[0] = 0.0f;
+  int index = 1;
+  for (int level = 1; level < STUDIOLIGHT_SH_BANDS; level++) {
+    table_l[level] = (float)(SQUARE(level) * SQUARE(level + 1));
+
+    float b = 0.0f;
+    for (int m = -1; m <= level; m++) {
+      b += SQUARE(sh[index++]);
+    }
+    table_b[level] = b;
+  }
+
+  float squared_lamplacian = 0.0f;
+  for (int level = 1; level < STUDIOLIGHT_SH_BANDS; level++) {
+    squared_lamplacian += table_l[level] * table_b[level];
+  }
+
+  const float target_squared_laplacian = max_laplacian * max_laplacian;
+  if (squared_lamplacian <= target_squared_laplacian) {
+    return lambda;
+  }
+
+  const int no_iterations = 10000000;
+  for (int i = 0; i < no_iterations; ++i) {
+    float f = 0.0f;
+    float fd = 0.0f;
+
+    for (int level = 1; level < STUDIOLIGHT_SH_BANDS; ++level) {
+      f += table_l[level] * table_b[level] / SQUARE(1.0f + lambda * table_l[level]);
+      fd += (2.0f * SQUARE(table_l[level]) * table_b[level]) /
+            CUBE(1.0f + lambda * table_l[level]);
+    }
+
+    f = target_squared_laplacian - f;
+
+    float delta = -f / fd;
+    lambda += delta;
+
+    if (ABS(delta) < 1e-6f) {
+      break;
+    }
+  }
+
+  return lambda;
 }
 
 static void studiolight_spherical_harmonics_apply_windowing(float (*sh)[3], float max_laplacian)
 {
-	if (max_laplacian <= 0.0f)
-		return;
-
-	float sh_r[STUDIOLIGHT_SH_COEFS_LEN];
-	float sh_g[STUDIOLIGHT_SH_COEFS_LEN];
-	float sh_b[STUDIOLIGHT_SH_COEFS_LEN];
-	for (int i = 0; i < STUDIOLIGHT_SH_COEFS_LEN; i++) {
-		sh_r[i] = sh[i][0];
-		sh_g[i] = sh[i][1];
-		sh_b[i] = sh[i][2];
-	}
-	float lambda_r = studiolight_spherical_harmonics_lambda_get(sh_r, max_laplacian);
-	float lambda_g = studiolight_spherical_harmonics_lambda_get(sh_g, max_laplacian);
-	float lambda_b = studiolight_spherical_harmonics_lambda_get(sh_b, max_laplacian);
-
-	/* Apply windowing lambda */
-	int index = 0;
-	for (int level = 0; level < STUDIOLIGHT_SH_BANDS; level++) {
-		float s[3];
-		s[0] = 1.0f / (1.0f + lambda_r * SQUARE(level) * SQUARE(level + 1.0f));
-		s[1] = 1.0f / (1.0f + lambda_g * SQUARE(level) * SQUARE(level + 1.0f));
-		s[2] = 1.0f / (1.0f + lambda_b * SQUARE(level) * SQUARE(level + 1.0f));
-
-		for (int m = -1; m <= level; m++) {
-			mul_v3_v3(sh[index++], s);
-		}
-	}
+  if (max_laplacian <= 0.0f)
+    return;
+
+  float sh_r[STUDIOLIGHT_SH_COEFS_LEN];
+  float sh_g[STUDIOLIGHT_SH_COEFS_LEN];
+  float sh_b[STUDIOLIGHT_SH_COEFS_LEN];
+  for (int i = 0; i < STUDIOLIGHT_SH_COEFS_LEN; i++) {
+    sh_r[i] = sh[i][0];
+    sh_g[i] = sh[i][1];
+    sh_b[i] = sh[i][2];
+  }
+  float lambda_r = studiolight_spherical_harmonics_lambda_get(sh_r, max_laplacian);
+  float lambda_g = studiolight_spherical_harmonics_lambda_get(sh_g, max_laplacian);
+  float lambda_b = studiolight_spherical_harmonics_lambda_get(sh_b, max_laplacian);
+
+  /* Apply windowing lambda */
+  int index = 0;
+  for (int level = 0; level < STUDIOLIGHT_SH_BANDS; level++) {
+    float s[3];
+    s[0] = 1.0f / (1.0f + lambda_r * SQUARE(level) * SQUARE(level + 1.0f));
+    s[1] = 1.0f / (1.0f + lambda_g * SQUARE(level) * SQUARE(level + 1.0f));
+    s[2] = 1.0f / (1.0f + lambda_b * SQUARE(level) * SQUARE(level + 1.0f));
+
+    for (int m = -1; m <= level; m++) {
+      mul_v3_v3(sh[index++], s);
+    }
+  }
 }
 
-static float studiolight_spherical_harmonics_geomerics_eval(const float normal[3], float sh0, float sh1, float sh2, float sh3)
+static float studiolight_spherical_harmonics_geomerics_eval(
+    const float normal[3], float sh0, float sh1, float sh2, float sh3)
 {
-	/* Use Geomerics non-linear SH. */
-	/* http://www.geomerics.com/wp-content/uploads/2015/08/CEDEC_Geomerics_ReconstructingDiffuseLighting1.pdf */
-	float R0 = sh0 * M_1_PI;
+  /* Use Geomerics non-linear SH. */
+  /* http://www.geomerics.com/wp-content/uploads/2015/08/CEDEC_Geomerics_ReconstructingDiffuseLighting1.pdf */
+  float R0 = sh0 * M_1_PI;
 
-	float R1[3] = {-sh3, sh2, -sh1};
-	mul_v3_fl(R1, 0.5f * M_1_PI * 1.5f); /* 1.5f is to improve the contrast a bit. */
-	float lenR1 = len_v3(R1);
-	mul_v3_fl(R1, 1.0f / lenR1);
-	float q = 0.5f * (1.0f + dot_v3v3(R1, normal));
+  float R1[3] = {-sh3, sh2, -sh1};
+  mul_v3_fl(R1, 0.5f * M_1_PI * 1.5f); /* 1.5f is to improve the contrast a bit. */
+  float lenR1 = len_v3(R1);
+  mul_v3_fl(R1, 1.0f / lenR1);
+  float q = 0.5f * (1.0f + dot_v3v3(R1, normal));
 
-	float p = 1.0f + 2.0f * lenR1 / R0;
-	float a = (1.0f - lenR1 / R0) / (1.0f + lenR1 / R0);
+  float p = 1.0f + 2.0f * lenR1 / R0;
+  float a = (1.0f - lenR1 / R0) / (1.0f + lenR1 / R0);
 
-	return R0 * (a + (1.0f - a) * (p + 1.0f) * powf(q, p));
+  return R0 * (a + (1.0f - a) * (p + 1.0f) * powf(q, p));
 }
 
-BLI_INLINE void studiolight_spherical_harmonics_eval(StudioLight *sl, float color[3], const float normal[3])
+BLI_INLINE void studiolight_spherical_harmonics_eval(StudioLight *sl,
+                                                     float color[3],
+                                                     const float normal[3])
 {
 #if STUDIOLIGHT_SH_BANDS == 2
-	float (*sh)[3] = (float (*)[3])sl->spherical_harmonics_coefs;
-	for (int i = 0; i < 3; ++i) {
-		color[i] = studiolight_spherical_harmonics_geomerics_eval(normal, sh[0][i], sh[1][i], sh[2][i], sh[3][i]);
-	}
-	return;
+  float(*sh)[3] = (float(*)[3])sl->spherical_harmonics_coefs;
+  for (int i = 0; i < 3; ++i) {
+    color[i] = studiolight_spherical_harmonics_geomerics_eval(
+        normal, sh[0][i], sh[1][i], sh[2][i], sh[3][i]);
+  }
+  return;
 #else
 
-	/* L0 */
-	mul_v3_v3fl(color, sl->spherical_harmonics_coefs[0], 0.282095f);
+  /* L0 */
+  mul_v3_v3fl(color, sl->spherical_harmonics_coefs[0], 0.282095f);
 #  if STUDIOLIGHT_SH_BANDS > 1 /* L1 */
-	const float nx = normal[0];
-	const float ny = normal[1];
-	const float nz = normal[2];
-	madd_v3_v3fl(color, sl->spherical_harmonics_coefs[1], -0.488603f * nz);
-	madd_v3_v3fl(color, sl->spherical_harmonics_coefs[2],  0.488603f * ny);
-	madd_v3_v3fl(color, sl->spherical_harmonics_coefs[3], -0.488603f * nx);
+  const float nx = normal[0];
+  const float ny = normal[1];
+  const float nz = normal[2];
+  madd_v3_v3fl(color, sl->spherical_harmonics_coefs[1], -0.488603f * nz);
+  madd_v3_v3fl(color, sl->spherical_harmonics_coefs[2], 0.488603f * ny);
+  madd_v3_v3fl(color, sl->spherical_harmonics_coefs[3], -0.488603f * nx);
 #  endif
 #  if STUDIOLIGHT_SH_BANDS > 2 /* L2 */
-	const float nx2 = SQUARE(nx);
-	const float ny2 = SQUARE(ny);
-	const float nz2 = SQUARE(nz);
-	madd_v3_v3fl(color, sl->spherical_harmonics_coefs[4], 1.092548f * nx * nz);
-	madd_v3_v3fl(color, sl->spherical_harmonics_coefs[5], -1.092548f * nz * ny);
-	madd_v3_v3fl(color, sl->spherical_harmonics_coefs[6], 0.315392f * (3.0f * ny2 - 1.0f));
-	madd_v3_v3fl(color, sl->spherical_harmonics_coefs[7], -1.092548 * nx * ny);
-	madd_v3_v3fl(color, sl->spherical_harmonics_coefs[8], 0.546274 * (nx2 - nz2));
+  const float nx2 = SQUARE(nx);
+  const float ny2 = SQUARE(ny);
+  const float nz2 = SQUARE(nz);
+  madd_v3_v3fl(color, sl->spherical_harmonics_coefs[4], 1.092548f * nx * nz);
+  madd_v3_v3fl(color, sl->spherical_harmonics_coefs[5], -1.092548f * nz * ny);
+  madd_v3_v3fl(color, sl->spherical_harmonics_coefs[6], 0.315392f * (3.0f * ny2 - 1.0f));
+  madd_v3_v3fl(color, sl->spherical_harmonics_coefs[7], -1.092548 * nx * ny);
+  madd_v3_v3fl(color, sl->spherical_harmonics_coefs[8], 0.546274 * (nx2 - nz2));
 #  endif
-	/* L3 coefs are 0 */
+  /* L3 coefs are 0 */
 #  if STUDIOLIGHT_SH_BANDS > 4 /* L4 */
-	const float nx4 = SQUARE(nx2);
-	const float ny4 = SQUARE(ny2);
-	const float nz4 = SQUARE(nz2);
-	madd_v3_v3fl(color, sl->spherical_harmonics_coefs[9],   2.5033429417967046f * nx * nz * (nx2 - nz2));
-	madd_v3_v3fl(color, sl->spherical_harmonics_coefs[10], -1.7701307697799304f * nz * ny * (3.0f * nx2 - nz2));
-	madd_v3_v3fl(color, sl->spherical_harmonics_coefs[11],  0.9461746957575601f * nz * nx * (-1.0f + 7.0f * ny2));
-	madd_v3_v3fl(color, sl->spherical_harmonics_coefs[12], -0.6690465435572892f * nz * ny * (-3.0f + 7.0f * ny2));
-	madd_v3_v3fl(color, sl->spherical_harmonics_coefs[13],  (105.0f * ny4 - 90.0f * ny2 + 9.0f) / 28.359261614f);
-	madd_v3_v3fl(color, sl->spherical_harmonics_coefs[14], -0.6690465435572892f * nx * ny * (-3.0f + 7.0f * ny2));
-	madd_v3_v3fl(color, sl->spherical_harmonics_coefs[15],  0.9461746957575601f * (nx2 - nz2) * (-1.0f + 7.0f * ny2));
-	madd_v3_v3fl(color, sl->spherical_harmonics_coefs[16], -1.7701307697799304f * nx * ny * (nx2 - 3.0f * nz2));
-	madd_v3_v3fl(color, sl->spherical_harmonics_coefs[17],  0.6258357354491761f * (nx4 - 6.0f * nz2 * nx2 + nz4));
+  const float nx4 = SQUARE(nx2);
+  const float ny4 = SQUARE(ny2);
+  const float nz4 = SQUARE(nz2);
+  madd_v3_v3fl(
+      color, sl->spherical_harmonics_coefs[9], 2.5033429417967046f * nx * nz * (nx2 - nz2));
+  madd_v3_v3fl(color,
+               sl->spherical_harmonics_coefs[10],
+               -1.7701307697799304f * nz * ny * (3.0f * nx2 - nz2));
+  madd_v3_v3fl(color,
+               sl->spherical_harmonics_coefs[11],
+               0.9461746957575601f * nz * nx * (-1.0f + 7.0f * ny2));
+  madd_v3_v3fl(color,
+               sl->spherical_harmonics_coefs[12],
+               -0.6690465435572892f * nz * ny * (-3.0f + 7.0f * ny2));
+  madd_v3_v3fl(color,
+               sl->spherical_harmonics_coefs[13],
+               (105.0f * ny4 - 90.0f * ny2 + 9.0f) / 28.359261614f);
+  madd_v3_v3fl(color,
+               sl->spherical_harmonics_coefs[14],
+               -0.6690465435572892f * nx * ny * (-3.0f + 7.0f * ny2));
+  madd_v3_v3fl(color,
+               sl->spherical_harmonics_coefs[15],
+               0.9461746957575601f * (nx2 - nz2) * (-1.0f + 7.0f * ny2));
+  madd_v3_v3fl(color,
+               sl->spherical_harmonics_coefs[16],
+               -1.7701307697799304f * nx * ny * (nx2 - 3.0f * nz2));
+  madd_v3_v3fl(color,
+               sl->spherical_harmonics_coefs[17],
+               0.6258357354491761f * (nx4 - 6.0f * nz2 * nx2 + nz4));
 #  endif
 #endif
 }
@@ -717,339 +766,358 @@ BLI_INLINE void studiolight_spherical_harmonics_eval(StudioLight *sl, float colo
 /* This modify the radiance into irradiance. */
 static void studiolight_spherical_harmonics_apply_band_factors(StudioLight *sl, float (*sh)[3])
 {
-	static float sl_sh_band_factors[5] = {
-		1.0f,
-		2.0f / 3.0f,
-		1.0f / 4.0f,
-		0.0f,
-		-1.0f / 24.0f,
-	};
-
-	int index = 0, dst_idx = 0;
-	for (int band = 0; band < STUDIOLIGHT_SH_BANDS; band++) {
-		for (int m = 0; m < SQUARE(band + 1) - SQUARE(band); m++) {
-			/* Skip L3 */
-			if (band != 3) {
-				mul_v3_v3fl(sl->spherical_harmonics_coefs[dst_idx++], sh[index], sl_sh_band_factors[band]);
-			}
-			index++;
-		}
-	}
+  static float sl_sh_band_factors[5] = {
+      1.0f,
+      2.0f / 3.0f,
+      1.0f / 4.0f,
+      0.0f,
+      -1.0f / 24.0f,
+  };
+
+  int index = 0, dst_idx = 0;
+  for (int band = 0; band < STUDIOLIGHT_SH_BANDS; band++) {
+    for (int m = 0; m < SQUARE(band + 1) - SQUARE(band); m++) {
+      /* Skip L3 */
+      if (band != 3) {
+        mul_v3_v3fl(sl->spherical_harmonics_coefs[dst_idx++], sh[index], sl_sh_band_factors[band]);
+      }
+      index++;
+    }
+  }
 }
 
 static void studiolight_calculate_diffuse_light(StudioLight *sl)
 {
-	/* init light to black */
-	if (sl->flag & STUDIOLIGHT_EXTERNAL_FILE) {
-		BKE_studiolight_ensure_flag(sl, STUDIOLIGHT_RADIANCE_BUFFERS_CALCULATED);
-
-		float sh_coefs[STUDIOLIGHT_SH_COEFS_LEN][3];
-		studiolight_spherical_harmonics_calculate_coefficients(sl, sh_coefs);
-		studiolight_spherical_harmonics_apply_windowing(sh_coefs, STUDIOLIGHT_SH_WINDOWING);
-		studiolight_spherical_harmonics_apply_band_factors(sl, sh_coefs);
-
-		if (sl->flag & STUDIOLIGHT_USER_DEFINED) {
-			FILE *fp = BLI_fopen(sl->path_sh_cache, "wb");
-			if (fp) {
-				fwrite(sl->spherical_harmonics_coefs, sizeof(sl->spherical_harmonics_coefs), 1, fp);
-				fclose(fp);
-			}
-		}
-	}
-	sl->flag |= STUDIOLIGHT_SPHERICAL_HARMONICS_COEFFICIENTS_CALCULATED;
+  /* init light to black */
+  if (sl->flag & STUDIOLIGHT_EXTERNAL_FILE) {
+    BKE_studiolight_ensure_flag(sl, STUDIOLIGHT_RADIANCE_BUFFERS_CALCULATED);
+
+    float sh_coefs[STUDIOLIGHT_SH_COEFS_LEN][3];
+    studiolight_spherical_harmonics_calculate_coefficients(sl, sh_coefs);
+    studiolight_spherical_harmonics_apply_windowing(sh_coefs, STUDIOLIGHT_SH_WINDOWING);
+    studiolight_spherical_harmonics_apply_band_factors(sl, sh_coefs);
+
+    if (sl->flag & STUDIOLIGHT_USER_DEFINED) {
+      FILE *fp = BLI_fopen(sl->path_sh_cache, "wb");
+      if (fp) {
+        fwrite(sl->spherical_harmonics_coefs, sizeof(sl->spherical_harmonics_coefs), 1, fp);
+        fclose(fp);
+      }
+    }
+  }
+  sl->flag |= STUDIOLIGHT_SPHERICAL_HARMONICS_COEFFICIENTS_CALCULATED;
 }
 
-BLI_INLINE void studiolight_evaluate_specular_radiance_buffer(
-        ImBuf *radiance_buffer, const float normal[3], float color[3],
-        int xoffset, int yoffset, int zoffset, float zsign)
+BLI_INLINE void studiolight_evaluate_specular_radiance_buffer(ImBuf *radiance_buffer,
+                                                              const float normal[3],
+                                                              float color[3],
+                                                              int xoffset,
+                                                              int yoffset,
+                                                              int zoffset,
+                                                              float zsign)
 {
-	if (radiance_buffer == NULL) {
-		return;
-	}
-
-	float accum[3] = {0.0f, 0.0f, 0.0f};
-	float accum_weight = 0.00001f;
-	ITER_PIXELS(float, radiance_buffer->rect_float, 4,
-	            STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE,
-	            STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE)
-	{
-		float direction[3];
-		direction[zoffset] = zsign * 0.5f;
-		direction[xoffset] = x - 0.5f;
-		direction[yoffset] = y - 0.5f;
-		normalize_v3(direction);
-		float weight = dot_v3v3(direction, normal) > 0.95f ? 1.0f : 0.0f;
-		// float solid_angle = texel_solid_angle(x, y, texel_size[0] * 0.5f);
-		madd_v3_v3fl(accum, pixel, weight);
-		accum_weight += weight;
-	}
-	ITER_PIXELS_END;
-
-	madd_v3_v3fl(color, accum, 1.0f / accum_weight);
+  if (radiance_buffer == NULL) {
+    return;
+  }
+
+  float accum[3] = {0.0f, 0.0f, 0.0f};
+  float accum_weight = 0.00001f;
+  ITER_PIXELS(float,
+              radiance_buffer->rect_float,
+              4,
+              STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE,
+              STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE)
+  {
+    float direction[3];
+    direction[zoffset] = zsign * 0.5f;
+    direction[xoffset] = x - 0.5f;
+    direction[yoffset] = y - 0.5f;
+    normalize_v3(direction);
+    float weight = dot_v3v3(direction, normal) > 0.95f ? 1.0f : 0.0f;
+    // float solid_angle = texel_solid_angle(x, y, texel_size[0] * 0.5f);
+    madd_v3_v3fl(accum, pixel, weight);
+    accum_weight += weight;
+  }
+  ITER_PIXELS_END;
+
+  madd_v3_v3fl(color, accum, 1.0f / accum_weight);
 }
 
 #ifdef STUDIOLIGHT_IRRADIANCE_METHOD_RADIANCE
 static void studiolight_irradiance_eval(StudioLight *sl, float color[3], const float normal[3])
 {
-	copy_v3_fl(color, 0.0f);
-
-	/* XXX: This is madness, iterating over all cubemap pixels for each destination pixels
-	 * even if their weight is 0.0f.
-	 * It should use hemisphere, cosine sampling at least. */
-
-	/* back */
-	studiolight_evaluate_specular_radiance_buffer(
-	        sl->radiance_cubemap_buffers[STUDIOLIGHT_Y_POS], normal, color, 0, 2, 1, 1);
-	/* front */
-	studiolight_evaluate_specular_radiance_buffer(
-	        sl->radiance_cubemap_buffers[STUDIOLIGHT_Y_NEG], normal, color, 0, 2, 1, -1);
-
-	/* left */
-	studiolight_evaluate_specular_radiance_buffer(
-	        sl->radiance_cubemap_buffers[STUDIOLIGHT_X_POS], normal, color, 1, 2, 0, 1);
-	/* right */
-	studiolight_evaluate_specular_radiance_buffer(
-	        sl->radiance_cubemap_buffers[STUDIOLIGHT_X_NEG], normal, color, 1, 2, 0, -1);
-
-	/* top */
-	studiolight_evaluate_specular_radiance_buffer(
-	        sl->radiance_cubemap_buffers[STUDIOLIGHT_Z_POS], normal, color, 0, 1, 2, 1);
-	/* bottom */
-	studiolight_evaluate_specular_radiance_buffer(
-	        sl->radiance_cubemap_buffers[STUDIOLIGHT_Z_NEG], normal, color, 0, 1, 2, -1);
-
-	mul_v3_fl(color, 1.0 / M_PI);
+  copy_v3_fl(color, 0.0f);
+
+  /* XXX: This is madness, iterating over all cubemap pixels for each destination pixels
+   * even if their weight is 0.0f.
+   * It should use hemisphere, cosine sampling at least. */
+
+  /* back */
+  studiolight_evaluate_specular_radiance_buffer(
+      sl->radiance_cubemap_buffers[STUDIOLIGHT_Y_POS], normal, color, 0, 2, 1, 1);
+  /* front */
+  studiolight_evaluate_specular_radiance_buffer(
+      sl->radiance_cubemap_buffers[STUDIOLIGHT_Y_NEG], normal, color, 0, 2, 1, -1);
+
+  /* left */
+  studiolight_evaluate_specular_radiance_buffer(
+      sl->radiance_cubemap_buffers[STUDIOLIGHT_X_POS], normal, color, 1, 2, 0, 1);
+  /* right */
+  studiolight_evaluate_specular_radiance_buffer(
+      sl->radiance_cubemap_buffers[STUDIOLIGHT_X_NEG], normal, color, 1, 2, 0, -1);
+
+  /* top */
+  studiolight_evaluate_specular_radiance_buffer(
+      sl->radiance_cubemap_buffers[STUDIOLIGHT_Z_POS], normal, color, 0, 1, 2, 1);
+  /* bottom */
+  studiolight_evaluate_specular_radiance_buffer(
+      sl->radiance_cubemap_buffers[STUDIOLIGHT_Z_NEG], normal, color, 0, 1, 2, -1);
+
+  mul_v3_fl(color, 1.0 / M_PI);
 }
 #endif
 
 static float brdf_approx(float spec_color, float roughness, float NV)
 {
-	/* Very rough own approx. We don't need it to be correct, just fast.
-	 * Just simulate fresnel effect with roughness attenuation. */
-	float fresnel = exp2(-8.35f * NV) * (1.0f - roughness);
-	return spec_color * (1.0f - fresnel) + fresnel;
+  /* Very rough own approx. We don't need it to be correct, just fast.
+   * Just simulate fresnel effect with roughness attenuation. */
+  float fresnel = exp2(-8.35f * NV) * (1.0f - roughness);
+  return spec_color * (1.0f - fresnel) + fresnel;
 }
 
 /* NL need to be unclamped. w in [0..1] range. */
 static float wrapped_lighting(float NL, float w)
 {
-	float w_1 = w + 1.0f;
-	return max_ff((NL + w) / (w_1 * w_1), 0.0f);
+  float w_1 = w + 1.0f;
+  return max_ff((NL + w) / (w_1 * w_1), 0.0f);
 }
 
-static float blinn_specular(
-        const float L[3], const float I[3], const float N[3], float R[3], float NL, float roughness, float wrap)
+static float blinn_specular(const float L[3],
+                            const float I[3],
+                            const float N[3],
+                            float R[3],
+                            float NL,
+                            float roughness,
+                            float wrap)
 {
-	float half_dir[3];
-	float wrapped_NL = dot_v3v3(L, R);
-	add_v3_v3v3(half_dir, L, I);
-	normalize_v3(half_dir);
-	float spec_angle = max_ff(dot_v3v3(half_dir, N), 0.0f);
+  float half_dir[3];
+  float wrapped_NL = dot_v3v3(L, R);
+  add_v3_v3v3(half_dir, L, I);
+  normalize_v3(half_dir);
+  float spec_angle = max_ff(dot_v3v3(half_dir, N), 0.0f);
 
-	float gloss = 1.0f - roughness;
-	/* Reduce gloss for smooth light. (simulate bigger light) */
-	gloss *= 1.0f - wrap;
-	float shininess = exp2(10.0f * gloss + 1.0f);
+  float gloss = 1.0f - roughness;
+  /* Reduce gloss for smooth light. (simulate bigger light) */
+  gloss *= 1.0f - wrap;
+  float shininess = exp2(10.0f * gloss + 1.0f);
 
-	/* Pi is already divided in the light power.
-	 * normalization_factor = (shininess + 8.0) / (8.0 * M_PI) */
-	float normalization_factor = shininess * 0.125f + 1.0f;
-	float spec_light = powf(spec_angle, shininess) * max_ff(NL, 0.0f) * normalization_factor;
+  /* Pi is already divided in the light power.
+   * normalization_factor = (shininess + 8.0) / (8.0 * M_PI) */
+  float normalization_factor = shininess * 0.125f + 1.0f;
+  float spec_light = powf(spec_angle, shininess) * max_ff(NL, 0.0f) * normalization_factor;
 
-	/* Simulate Env. light. */
-	float w = wrap * (1.0 - roughness) + roughness;
-	float spec_env = wrapped_lighting(wrapped_NL, w);
+  /* Simulate Env. light. */
+  float w = wrap * (1.0 - roughness) + roughness;
+  float spec_env = wrapped_lighting(wrapped_NL, w);
 
-	float w2 = wrap * wrap;
+  float w2 = wrap * wrap;
 
-	return spec_light * (1.0 - w2) + spec_env * w2;
+  return spec_light * (1.0 - w2) + spec_env * w2;
 }
 
 /* Keep in sync with the glsl shader function get_world_lighting() */
 static void studiolight_lights_eval(StudioLight *sl, float color[3], const float normal[3])
 {
-	float R[3], I[3] = {0.0f, 0.0f, 1.0f}, N[3] = {normal[0], normal[2], -normal[1]};
-	const float roughness = 0.5f;
-	const float diffuse_color = 0.8f;
-	const float specular_color = brdf_approx(0.05f, roughness, N[2]);
-	float diff_light[3], spec_light[3];
-
-	/* Ambient lighting */
-	copy_v3_v3(diff_light, sl->light_ambient);
-	copy_v3_v3(spec_light, sl->light_ambient);
-
-	reflect_v3_v3v3(R, I, N);
-	for (int i = 0; i < 3; ++i) {
-		SolidLight *light = &sl->light[i];
-		if (light->flag) {
-			/* Diffuse lighting */
-			float NL = dot_v3v3(light->vec, N);
-			float diff = wrapped_lighting(NL, light->smooth);
-			madd_v3_v3fl(diff_light, light->col, diff);
-			/* Specular lighting */
-			float spec = blinn_specular(light->vec, I, N, R, NL, roughness, light->smooth);
-			madd_v3_v3fl(spec_light, light->spec, spec);
-		}
-	}
-
-	/* Multiply result by surface colors. */
-	mul_v3_fl(diff_light, diffuse_color * (1.0 - specular_color));
-	mul_v3_fl(spec_light, specular_color);
-
-	add_v3_v3v3(color, diff_light, spec_light);
+  float R[3], I[3] = {0.0f, 0.0f, 1.0f}, N[3] = {normal[0], normal[2], -normal[1]};
+  const float roughness = 0.5f;
+  const float diffuse_color = 0.8f;
+  const float specular_color = brdf_approx(0.05f, roughness, N[2]);
+  float diff_light[3], spec_light[3];
+
+  /* Ambient lighting */
+  copy_v3_v3(diff_light, sl->light_ambient);
+  copy_v3_v3(spec_light, sl->light_ambient);
+
+  reflect_v3_v3v3(R, I, N);
+  for (int i = 0; i < 3; ++i) {
+    SolidLight *light = &sl->light[i];
+    if (light->flag) {
+      /* Diffuse lighting */
+      float NL = dot_v3v3(light->vec, N);
+      float diff = wrapped_lighting(NL, light->smooth);
+      madd_v3_v3fl(diff_light, light->col, diff);
+      /* Specular lighting */
+      float spec = blinn_specular(light->vec, I, N, R, NL, roughness, light->smooth);
+      madd_v3_v3fl(spec_light, light->spec, spec);
+    }
+  }
+
+  /* Multiply result by surface colors. */
+  mul_v3_fl(diff_light, diffuse_color * (1.0 - specular_color));
+  mul_v3_fl(spec_light, specular_color);
+
+  add_v3_v3v3(color, diff_light, spec_light);
 }
 
 static bool studiolight_load_irradiance_equirect_image(StudioLight *sl)
 {
 #ifdef STUDIOLIGHT_LOAD_CACHED_FILES
-	if (sl->flag & STUDIOLIGHT_EXTERNAL_FILE) {
-		ImBuf *ibuf = NULL;
-		ibuf = IMB_loadiffname(sl->path_irr_cache, 0, NULL);
-		if (ibuf) {
-			IMB_float_from_rect(ibuf);
-			sl->equirect_irradiance_buffer = ibuf;
-			sl->flag |= STUDIOLIGHT_EQUIRECT_IRRADIANCE_IMAGE_CALCULATED;
-			return true;
-		}
-	}
+  if (sl->flag & STUDIOLIGHT_EXTERNAL_FILE) {
+    ImBuf *ibuf = NULL;
+    ibuf = IMB_loadiffname(sl->path_irr_cache, 0, NULL);
+    if (ibuf) {
+      IMB_float_from_rect(ibuf);
+      sl->equirect_irradiance_buffer = ibuf;
+      sl->flag |= STUDIOLIGHT_EQUIRECT_IRRADIANCE_IMAGE_CALCULATED;
+      return true;
+    }
+  }
 #else
-	UNUSED_VARS(sl);
+  UNUSED_VARS(sl);
 #endif
-	return false;
+  return false;
 }
 
 static bool studiolight_load_spherical_harmonics_coefficients(StudioLight *sl)
 {
 #ifdef STUDIOLIGHT_LOAD_CACHED_FILES
-	if (sl->flag & STUDIOLIGHT_EXTERNAL_FILE) {
-		FILE *fp = BLI_fopen(sl->path_sh_cache, "rb");
-		if (fp) {
-			if (fread((void *)(sl->spherical_harmonics_coefs), sizeof(sl->spherical_harmonics_coefs), 1, fp)) {
-				sl->flag |= STUDIOLIGHT_SPHERICAL_HARMONICS_COEFFICIENTS_CALCULATED;
-				fclose(fp);
-				return true;
-			}
-			fclose(fp);
-		}
-	}
+  if (sl->flag & STUDIOLIGHT_EXTERNAL_FILE) {
+    FILE *fp = BLI_fopen(sl->path_sh_cache, "rb");
+    if (fp) {
+      if (fread((void *)(sl->spherical_harmonics_coefs),
+                sizeof(sl->spherical_harmonics_coefs),
+                1,
+                fp)) {
+        sl->flag |= STUDIOLIGHT_SPHERICAL_HARMONICS_COEFFICIENTS_CALCULATED;
+        fclose(fp);
+        return true;
+      }
+      fclose(fp);
+    }
+  }
 #else
-	UNUSED_VARS(sl);
+  UNUSED_VARS(sl);
 #endif
-	return false;
+  return false;
 }
 
 static void studiolight_calculate_irradiance_equirect_image(StudioLight *sl)
 {
-	if (sl->flag & STUDIOLIGHT_EXTERNAL_FILE) {
+  if (sl->flag & STUDIOLIGHT_EXTERNAL_FILE) {
 #ifdef STUDIOLIGHT_IRRADIANCE_METHOD_RADIANCE
-		BKE_studiolight_ensure_flag(sl, STUDIOLIGHT_RADIANCE_BUFFERS_CALCULATED);
+    BKE_studiolight_ensure_flag(sl, STUDIOLIGHT_RADIANCE_BUFFERS_CALCULATED);
 #else
-		BKE_studiolight_ensure_flag(sl, STUDIOLIGHT_SPHERICAL_HARMONICS_COEFFICIENTS_CALCULATED);
+    BKE_studiolight_ensure_flag(sl, STUDIOLIGHT_SPHERICAL_HARMONICS_COEFFICIENTS_CALCULATED);
 #endif
 
-		float *colbuf = MEM_mallocN(STUDIOLIGHT_IRRADIANCE_EQUIRECT_WIDTH * STUDIOLIGHT_IRRADIANCE_EQUIRECT_HEIGHT * sizeof(float[4]), __func__);
-
-		ITER_PIXELS(float, colbuf, 4,
-		            STUDIOLIGHT_IRRADIANCE_EQUIRECT_WIDTH,
-		            STUDIOLIGHT_IRRADIANCE_EQUIRECT_HEIGHT)
-		{
-			float dir[3];
-			equirect_to_direction(dir, x, y);
+    float *colbuf = MEM_mallocN(STUDIOLIGHT_IRRADIANCE_EQUIRECT_WIDTH *
+                                    STUDIOLIGHT_IRRADIANCE_EQUIRECT_HEIGHT * sizeof(float[4]),
+                                __func__);
+
+    ITER_PIXELS(float,
+                colbuf,
+                4,
+                STUDIOLIGHT_IRRADIANCE_EQUIRECT_WIDTH,
+                STUDIOLIGHT_IRRADIANCE_EQUIRECT_HEIGHT)
+    {
+      float dir[3];
+      equirect_to_direction(dir, x, y);
 #ifdef STUDIOLIGHT_IRRADIANCE_METHOD_RADIANCE
-			studiolight_irradiance_eval(sl, pixel, dir);
+      studiolight_irradiance_eval(sl, pixel, dir);
 #else
-			studiolight_spherical_harmonics_eval(sl, pixel, dir);
+      studiolight_spherical_harmonics_eval(sl, pixel, dir);
 #endif
-			pixel[3] = 1.0f;
-		}
-		ITER_PIXELS_END;
+      pixel[3] = 1.0f;
+    }
+    ITER_PIXELS_END;
 
-		sl->equirect_irradiance_buffer = IMB_allocFromBuffer(
-		        NULL, colbuf,
-		        STUDIOLIGHT_IRRADIANCE_EQUIRECT_WIDTH,
-		        STUDIOLIGHT_IRRADIANCE_EQUIRECT_HEIGHT);
-		MEM_freeN(colbuf);
+    sl->equirect_irradiance_buffer = IMB_allocFromBuffer(NULL,
+                                                         colbuf,
+                                                         STUDIOLIGHT_IRRADIANCE_EQUIRECT_WIDTH,
+                                                         STUDIOLIGHT_IRRADIANCE_EQUIRECT_HEIGHT);
+    MEM_freeN(colbuf);
 
 #ifdef STUDIOLIGHT_IRRADIANCE_METHOD_RADIANCE
-		/*
-		 * Only store cached files when using STUDIOLIGHT_IRRADIANCE_METHOD_RADIANCE
-		 */
-		if (sl->flag & STUDIOLIGHT_USER_DEFINED) {
-			IMB_saveiff(sl->equirect_irradiance_buffer, sl->path_irr_cache, IB_rectfloat);
-		}
+    /*
+     * Only store cached files when using STUDIOLIGHT_IRRADIANCE_METHOD_RADIANCE
+     */
+    if (sl->flag & STUDIOLIGHT_USER_DEFINED) {
+      IMB_saveiff(sl->equirect_irradiance_buffer, sl->path_irr_cache, IB_rectfloat);
+    }
 #endif
-	}
-	sl->flag |= STUDIOLIGHT_EQUIRECT_IRRADIANCE_IMAGE_CALCULATED;
+  }
+  sl->flag |= STUDIOLIGHT_EQUIRECT_IRRADIANCE_IMAGE_CALCULATED;
 }
 
 static StudioLight *studiolight_add_file(const char *path, int flag)
 {
-	char filename[FILE_MAXFILE];
-	BLI_split_file_part(path, filename, FILE_MAXFILE);
-
-	if ((((flag & STUDIOLIGHT_TYPE_STUDIO) != 0) && BLI_path_extension_check(filename, ".sl")) ||
-	    BLI_path_extension_check_array(filename, imb_ext_image))
-	{
-		StudioLight *sl = studiolight_create(STUDIOLIGHT_EXTERNAL_FILE | flag);
-		BLI_strncpy(sl->name, filename, FILE_MAXFILE);
-		BLI_strncpy(sl->path, path, FILE_MAXFILE);
-
-		if ((flag & STUDIOLIGHT_TYPE_STUDIO) != 0) {
-			studiolight_load_solid_light(sl);
-		}
-		else {
-			sl->path_irr_cache = BLI_string_joinN(path, ".irr");
-			sl->path_sh_cache = BLI_string_joinN(path, ".sh2");
-		}
-		BLI_addtail(&studiolights, sl);
-		return sl;
-	}
-	return NULL;
+  char filename[FILE_MAXFILE];
+  BLI_split_file_part(path, filename, FILE_MAXFILE);
+
+  if ((((flag & STUDIOLIGHT_TYPE_STUDIO) != 0) && BLI_path_extension_check(filename, ".sl")) ||
+      BLI_path_extension_check_array(filename, imb_ext_image)) {
+    StudioLight *sl = studiolight_create(STUDIOLIGHT_EXTERNAL_FILE | flag);
+    BLI_strncpy(sl->name, filename, FILE_MAXFILE);
+    BLI_strncpy(sl->path, path, FILE_MAXFILE);
+
+    if ((flag & STUDIOLIGHT_TYPE_STUDIO) != 0) {
+      studiolight_load_solid_light(sl);
+    }
+    else {
+      sl->path_irr_cache = BLI_string_joinN(path, ".irr");
+      sl->path_sh_cache = BLI_string_joinN(path, ".sh2");
+    }
+    BLI_addtail(&studiolights, sl);
+    return sl;
+  }
+  return NULL;
 }
 
-static void studiolight_add_files_from_datafolder(const int folder_id, const char *subfolder, int flag)
+static void studiolight_add_files_from_datafolder(const int folder_id,
+                                                  const char *subfolder,
+                                                  int flag)
 {
-	struct direntry *dir;
-	const char *folder = BKE_appdir_folder_id(folder_id, subfolder);
-	if (folder) {
-		uint totfile = BLI_filelist_dir_contents(folder, &dir);
-		int i;
-		for (i = 0; i < totfile; i++) {
-			if ((dir[i].type & S_IFREG)) {
-				studiolight_add_file(dir[i].path, flag);
-			}
-		}
-		BLI_filelist_free(dir, totfile);
-		dir = NULL;
-	}
+  struct direntry *dir;
+  const char *folder = BKE_appdir_folder_id(folder_id, subfolder);
+  if (folder) {
+    uint totfile = BLI_filelist_dir_contents(folder, &dir);
+    int i;
+    for (i = 0; i < totfile; i++) {
+      if ((dir[i].type & S_IFREG)) {
+        studiolight_add_file(dir[i].path, flag);
+      }
+    }
+    BLI_filelist_free(dir, totfile);
+    dir = NULL;
+  }
 }
 
 static int studiolight_flag_cmp_order(const StudioLight *sl)
 {
-	/* Internal studiolights before external studio lights */
-	if (sl->flag & STUDIOLIGHT_EXTERNAL_FILE) {
-		return 1;
-	}
-	return 0;
+  /* Internal studiolights before external studio lights */
+  if (sl->flag & STUDIOLIGHT_EXTERNAL_FILE) {
+    return 1;
+  }
+  return 0;
 }
 
 static int studiolight_cmp(const void *a, const void *b)
 {
-	const StudioLight *sl1 = a;
-	const StudioLight *sl2 = b;
-
-	const int flagorder1 = studiolight_flag_cmp_order(sl1);
-	const int flagorder2 = studiolight_flag_cmp_order(sl2);
-
-	if (flagorder1 < flagorder2) {
-		return -1;
-	}
-	else if (flagorder1 > flagorder2) {
-		return 1;
-	}
-	else {
-		return BLI_strcasecmp(sl1->name, sl2->name);
-	}
+  const StudioLight *sl1 = a;
+  const StudioLight *sl2 = b;
+
+  const int flagorder1 = studiolight_flag_cmp_order(sl1);
+  const int flagorder2 = studiolight_flag_cmp_order(sl2);
+
+  if (flagorder1 < flagorder2) {
+    return -1;
+  }
+  else if (flagorder1 > flagorder2) {
+    return 1;
+  }
+  else {
+    return BLI_strcasecmp(sl1->name, sl2->name);
+  }
 }
 
 /* icons */
@@ -1059,12 +1127,12 @@ static int studiolight_cmp(const void *a, const void *b)
  * in uv space for the alpha mask falloff. */
 static uint alpha_circle_mask(float u, float v, float inner_edge, float outer_edge)
 {
-	/* Coords from center. */
-	float co[2] = {u - 0.5f, v - 0.5f};
-	float dist = len_v2(co);
-	float alpha = 1.0f + (inner_edge - dist) / (outer_edge - inner_edge);
-	uint mask = (uint)floorf(255.0f * min_ff(max_ff(alpha, 0.0f), 1.0f));
-	return mask << 24;
+  /* Coords from center. */
+  float co[2] = {u - 0.5f, v - 0.5f};
+  float dist = len_v2(co);
+  float alpha = 1.0f + (inner_edge - dist) / (outer_edge - inner_edge);
+  uint mask = (uint)floorf(255.0f * min_ff(max_ff(alpha, 0.0f), 1.0f));
+  return mask << 24;
 }
 
 /* Percentage of the icon that the preview sphere covers. */
@@ -1075,287 +1143,281 @@ static uint alpha_circle_mask(float u, float v, float inner_edge, float outer_ed
 /* Remaps normalized UV [0..1] to a sphere normal around (0.5, 0.5) */
 static void sphere_normal_from_uv(float normal[3], float u, float v)
 {
-	normal[0] = u * 2.0f - 1.0f;
-	normal[1] = v * 2.0f - 1.0f;
-	float dist = len_v2(normal);
-	normal[2] = sqrtf(1.0f - SQUARE(dist));
+  normal[0] = u * 2.0f - 1.0f;
+  normal[1] = v * 2.0f - 1.0f;
+  float dist = len_v2(normal);
+  normal[2] = sqrtf(1.0f - SQUARE(dist));
 }
 
 static void studiolight_radiance_preview(uint *icon_buffer, StudioLight *sl)
 {
-	BKE_studiolight_ensure_flag(sl, STUDIOLIGHT_EXTERNAL_IMAGE_LOADED);
-
-	ITER_PIXELS(uint, icon_buffer, 1,
-	            STUDIOLIGHT_ICON_SIZE,
-	            STUDIOLIGHT_ICON_SIZE)
-	{
-		float dy = RESCALE_COORD(y);
-		float dx = RESCALE_COORD(x);
-
-		uint alphamask = alpha_circle_mask(dx, dy, 0.5f - texel_size[0], 0.5f);
-		if (alphamask != 0) {
-			float normal[3], direction[3], color[4];
-			float incoming[3] = {0.0f, 0.0f, -1.0f};
-			sphere_normal_from_uv(normal, dx, dy);
-			reflect_v3_v3v3(direction, incoming, normal);
-			/* We want to see horizon not poles. */
-			SWAP(float, direction[1], direction[2]);
-			direction[1] = -direction[1];
-
-			studiolight_calculate_radiance(sl->equirect_radiance_buffer, color, direction);
-
-			*pixel = rgb_to_cpack(
-			        linearrgb_to_srgb(color[0]),
-			        linearrgb_to_srgb(color[1]),
-			        linearrgb_to_srgb(color[2])) | alphamask;
-		}
-		else {
-			*pixel = 0x0;
-		}
-	}
-	ITER_PIXELS_END;
+  BKE_studiolight_ensure_flag(sl, STUDIOLIGHT_EXTERNAL_IMAGE_LOADED);
+
+  ITER_PIXELS(uint, icon_buffer, 1, STUDIOLIGHT_ICON_SIZE, STUDIOLIGHT_ICON_SIZE)
+  {
+    float dy = RESCALE_COORD(y);
+    float dx = RESCALE_COORD(x);
+
+    uint alphamask = alpha_circle_mask(dx, dy, 0.5f - texel_size[0], 0.5f);
+    if (alphamask != 0) {
+      float normal[3], direction[3], color[4];
+      float incoming[3] = {0.0f, 0.0f, -1.0f};
+      sphere_normal_from_uv(normal, dx, dy);
+      reflect_v3_v3v3(direction, incoming, normal);
+      /* We want to see horizon not poles. */
+      SWAP(float, direction[1], direction[2]);
+      direction[1] = -direction[1];
+
+      studiolight_calculate_radiance(sl->equirect_radiance_buffer, color, direction);
+
+      *pixel = rgb_to_cpack(linearrgb_to_srgb(color[0]),
+                            linearrgb_to_srgb(color[1]),
+                            linearrgb_to_srgb(color[2])) |
+               alphamask;
+    }
+    else {
+      *pixel = 0x0;
+    }
+  }
+  ITER_PIXELS_END;
 }
 
 static void studiolight_matcap_preview(uint *icon_buffer, StudioLight *sl, bool flipped)
 {
-	BKE_studiolight_ensure_flag(sl, STUDIOLIGHT_EXTERNAL_IMAGE_LOADED);
-
-	ImBuf *ibuf = sl->equirect_radiance_buffer;
-
-	ITER_PIXELS(uint, icon_buffer, 1,
-	            STUDIOLIGHT_ICON_SIZE,
-	            STUDIOLIGHT_ICON_SIZE)
-	{
-		float dy = RESCALE_COORD(y);
-		float dx = RESCALE_COORD(x);
-		if (flipped) {
-			dx = 1.0f - dx;
-		}
-
-		float color[4];
-		nearest_interpolation_color(ibuf, NULL, color, dx * ibuf->x - 1.0f, dy * ibuf->y - 1.0f);
-
-		uint alphamask = alpha_circle_mask(dx, dy, 0.5f - texel_size[0], 0.5f);
-
-		*pixel = rgb_to_cpack(
-		        linearrgb_to_srgb(color[0]),
-		        linearrgb_to_srgb(color[1]),
-		        linearrgb_to_srgb(color[2])) | alphamask;
-	}
-	ITER_PIXELS_END;
+  BKE_studiolight_ensure_flag(sl, STUDIOLIGHT_EXTERNAL_IMAGE_LOADED);
+
+  ImBuf *ibuf = sl->equirect_radiance_buffer;
+
+  ITER_PIXELS(uint, icon_buffer, 1, STUDIOLIGHT_ICON_SIZE, STUDIOLIGHT_ICON_SIZE)
+  {
+    float dy = RESCALE_COORD(y);
+    float dx = RESCALE_COORD(x);
+    if (flipped) {
+      dx = 1.0f - dx;
+    }
+
+    float color[4];
+    nearest_interpolation_color(ibuf, NULL, color, dx * ibuf->x - 1.0f, dy * ibuf->y - 1.0f);
+
+    uint alphamask = alpha_circle_mask(dx, dy, 0.5f - texel_size[0], 0.5f);
+
+    *pixel = rgb_to_cpack(linearrgb_to_srgb(color[0]),
+                          linearrgb_to_srgb(color[1]),
+                          linearrgb_to_srgb(color[2])) |
+             alphamask;
+  }
+  ITER_PIXELS_END;
 }
 
 static void studiolight_irradiance_preview(uint *icon_buffer, StudioLight *sl)
 {
-	ITER_PIXELS(uint, icon_buffer, 1,
-	            STUDIOLIGHT_ICON_SIZE,
-	            STUDIOLIGHT_ICON_SIZE)
-	{
-		float dy = RESCALE_COORD(y);
-		float dx = RESCALE_COORD(x);
-
-		uint alphamask = alpha_circle_mask(dx, dy, 0.5f - texel_size[0], 0.5f);
-		if (alphamask != 0) {
-			float normal[3], color[3];
-			sphere_normal_from_uv(normal, dx, dy);
-			/* We want to see horizon not poles. */
-			SWAP(float, normal[1], normal[2]);
-			normal[1] = -normal[1];
-
-			studiolight_lights_eval(sl, color, normal);
-
-			*pixel = rgb_to_cpack(
-			        linearrgb_to_srgb(color[0]),
-			        linearrgb_to_srgb(color[1]),
-			        linearrgb_to_srgb(color[2])) | alphamask;
-		}
-		else {
-			*pixel = 0x0;
-		}
-	}
-	ITER_PIXELS_END;
+  ITER_PIXELS(uint, icon_buffer, 1, STUDIOLIGHT_ICON_SIZE, STUDIOLIGHT_ICON_SIZE)
+  {
+    float dy = RESCALE_COORD(y);
+    float dx = RESCALE_COORD(x);
+
+    uint alphamask = alpha_circle_mask(dx, dy, 0.5f - texel_size[0], 0.5f);
+    if (alphamask != 0) {
+      float normal[3], color[3];
+      sphere_normal_from_uv(normal, dx, dy);
+      /* We want to see horizon not poles. */
+      SWAP(float, normal[1], normal[2]);
+      normal[1] = -normal[1];
+
+      studiolight_lights_eval(sl, color, normal);
+
+      *pixel = rgb_to_cpack(linearrgb_to_srgb(color[0]),
+                            linearrgb_to_srgb(color[1]),
+                            linearrgb_to_srgb(color[2])) |
+               alphamask;
+    }
+    else {
+      *pixel = 0x0;
+    }
+  }
+  ITER_PIXELS_END;
 }
 
 /* API */
 void BKE_studiolight_init(void)
 {
-	/* Add default studio light */
-	StudioLight *sl = studiolight_create(
-	        STUDIOLIGHT_INTERNAL | STUDIOLIGHT_SPHERICAL_HARMONICS_COEFFICIENTS_CALCULATED | STUDIOLIGHT_TYPE_STUDIO);
-	BLI_strncpy(sl->name, "Default", FILE_MAXFILE);
-
-	copy_v3_fl3(sl->light_ambient, 0.025000, 0.025000, 0.025000);
-
-	copy_v4_fl4(sl->light[0].vec, -0.580952, 0.228571, 0.781185, 0.0);
-	copy_v4_fl4(sl->light[0].col, 0.900000, 0.900000, 0.900000, 1.000000);
-	copy_v4_fl4(sl->light[0].spec, 0.318547, 0.318547, 0.318547, 1.000000);
-	sl->light[0].flag = 1;
-	sl->light[0].smooth = 0.1;
-
-	copy_v4_fl4(sl->light[1].vec, 0.788218, 0.593482, -0.162765, 0.0);
-	copy_v4_fl4(sl->light[1].col, 0.267115, 0.269928, 0.358840, 1.000000);
-	copy_v4_fl4(sl->light[1].spec, 0.090838, 0.090838, 0.090838, 1.000000);
-	sl->light[1].flag = 1;
-	sl->light[1].smooth = 0.25;
-
-	copy_v4_fl4(sl->light[2].vec, 0.696472, -0.696472, -0.172785, 0.0);
-	copy_v4_fl4(sl->light[2].col, 0.293216, 0.304662, 0.401968, 1.000000);
-	copy_v4_fl4(sl->light[2].spec, 0.069399, 0.020331, 0.020331, 1.000000);
-	sl->light[2].flag = 1;
-	sl->light[2].smooth = 0.5;
-
-	copy_v4_fl4(sl->light[3].vec, 0.021053, -0.989474, 0.143173, 0.0);
-	copy_v4_fl4(sl->light[3].col, 0.0, 0.0, 0.0, 1.0);
-	copy_v4_fl4(sl->light[3].spec, 0.072234, 0.082253, 0.162642, 1.000000);
-	sl->light[3].flag = 1;
-	sl->light[3].smooth = 0.7;
-
-	BLI_addtail(&studiolights, sl);
-
-	/* go over the preset folder and add a studiolight for every image with its path */
-	/* for portable installs (where USER and SYSTEM paths are the same), only go over LOCAL datafiles once */
-	/* Also reserve icon space for it. */
-	if (!BKE_appdir_app_is_portable_install()) {
-		studiolight_add_files_from_datafolder(BLENDER_USER_DATAFILES,
-		                                      STUDIOLIGHT_LIGHTS_FOLDER,
-		                                      STUDIOLIGHT_TYPE_STUDIO | STUDIOLIGHT_USER_DEFINED);
-		studiolight_add_files_from_datafolder(BLENDER_USER_DATAFILES,
-		                                      STUDIOLIGHT_WORLD_FOLDER,
-		                                      STUDIOLIGHT_TYPE_WORLD | STUDIOLIGHT_USER_DEFINED);
-		studiolight_add_files_from_datafolder(BLENDER_USER_DATAFILES,
-		                                      STUDIOLIGHT_MATCAP_FOLDER,
-		                                      STUDIOLIGHT_TYPE_MATCAP | STUDIOLIGHT_USER_DEFINED);
-	}
-	studiolight_add_files_from_datafolder(BLENDER_SYSTEM_DATAFILES, STUDIOLIGHT_LIGHTS_FOLDER, STUDIOLIGHT_TYPE_STUDIO);
-	studiolight_add_files_from_datafolder(BLENDER_SYSTEM_DATAFILES, STUDIOLIGHT_WORLD_FOLDER,  STUDIOLIGHT_TYPE_WORLD);
-	studiolight_add_files_from_datafolder(BLENDER_SYSTEM_DATAFILES, STUDIOLIGHT_MATCAP_FOLDER, STUDIOLIGHT_TYPE_MATCAP);
-
-	/* sort studio lights on filename. */
-	BLI_listbase_sort(&studiolights, studiolight_cmp);
+  /* Add default studio light */
+  StudioLight *sl = studiolight_create(STUDIOLIGHT_INTERNAL |
+                                       STUDIOLIGHT_SPHERICAL_HARMONICS_COEFFICIENTS_CALCULATED |
+                                       STUDIOLIGHT_TYPE_STUDIO);
+  BLI_strncpy(sl->name, "Default", FILE_MAXFILE);
+
+  copy_v3_fl3(sl->light_ambient, 0.025000, 0.025000, 0.025000);
+
+  copy_v4_fl4(sl->light[0].vec, -0.580952, 0.228571, 0.781185, 0.0);
+  copy_v4_fl4(sl->light[0].col, 0.900000, 0.900000, 0.900000, 1.000000);
+  copy_v4_fl4(sl->light[0].spec, 0.318547, 0.318547, 0.318547, 1.000000);
+  sl->light[0].flag = 1;
+  sl->light[0].smooth = 0.1;
+
+  copy_v4_fl4(sl->light[1].vec, 0.788218, 0.593482, -0.162765, 0.0);
+  copy_v4_fl4(sl->light[1].col, 0.267115, 0.269928, 0.358840, 1.000000);
+  copy_v4_fl4(sl->light[1].spec, 0.090838, 0.090838, 0.090838, 1.000000);
+  sl->light[1].flag = 1;
+  sl->light[1].smooth = 0.25;
+
+  copy_v4_fl4(sl->light[2].vec, 0.696472, -0.696472, -0.172785, 0.0);
+  copy_v4_fl4(sl->light[2].col, 0.293216, 0.304662, 0.401968, 1.000000);
+  copy_v4_fl4(sl->light[2].spec, 0.069399, 0.020331, 0.020331, 1.000000);
+  sl->light[2].flag = 1;
+  sl->light[2].smooth = 0.5;
+
+  copy_v4_fl4(sl->light[3].vec, 0.021053, -0.989474, 0.143173, 0.0);
+  copy_v4_fl4(sl->light[3].col, 0.0, 0.0, 0.0, 1.0);
+  copy_v4_fl4(sl->light[3].spec, 0.072234, 0.082253, 0.162642, 1.000000);
+  sl->light[3].flag = 1;
+  sl->light[3].smooth = 0.7;
+
+  BLI_addtail(&studiolights, sl);
+
+  /* go over the preset folder and add a studiolight for every image with its path */
+  /* for portable installs (where USER and SYSTEM paths are the same), only go over LOCAL datafiles once */
+  /* Also reserve icon space for it. */
+  if (!BKE_appdir_app_is_portable_install()) {
+    studiolight_add_files_from_datafolder(BLENDER_USER_DATAFILES,
+                                          STUDIOLIGHT_LIGHTS_FOLDER,
+                                          STUDIOLIGHT_TYPE_STUDIO | STUDIOLIGHT_USER_DEFINED);
+    studiolight_add_files_from_datafolder(BLENDER_USER_DATAFILES,
+                                          STUDIOLIGHT_WORLD_FOLDER,
+                                          STUDIOLIGHT_TYPE_WORLD | STUDIOLIGHT_USER_DEFINED);
+    studiolight_add_files_from_datafolder(BLENDER_USER_DATAFILES,
+                                          STUDIOLIGHT_MATCAP_FOLDER,
+                                          STUDIOLIGHT_TYPE_MATCAP | STUDIOLIGHT_USER_DEFINED);
+  }
+  studiolight_add_files_from_datafolder(
+      BLENDER_SYSTEM_DATAFILES, STUDIOLIGHT_LIGHTS_FOLDER, STUDIOLIGHT_TYPE_STUDIO);
+  studiolight_add_files_from_datafolder(
+      BLENDER_SYSTEM_DATAFILES, STUDIOLIGHT_WORLD_FOLDER, STUDIOLIGHT_TYPE_WORLD);
+  studiolight_add_files_from_datafolder(
+      BLENDER_SYSTEM_DATAFILES, STUDIOLIGHT_MATCAP_FOLDER, STUDIOLIGHT_TYPE_MATCAP);
+
+  /* sort studio lights on filename. */
+  BLI_listbase_sort(&studiolights, studiolight_cmp);
 }
 
 void BKE_studiolight_free(void)
 {
-	struct StudioLight *sl;
-	while ((sl = BLI_pophead(&studiolights))) {
-		studiolight_free(sl);
-	}
+  struct StudioLight *sl;
+  while ((sl = BLI_pophead(&studiolights))) {
+    studiolight_free(sl);
+  }
 }
 
 struct StudioLight *BKE_studiolight_find_default(int flag)
 {
-	const char *default_name = "";
-
-	if (flag & STUDIOLIGHT_TYPE_WORLD) {
-		default_name = STUDIOLIGHT_WORLD_DEFAULT;
-	}
-	else if (flag & STUDIOLIGHT_TYPE_MATCAP) {
-		default_name = STUDIOLIGHT_MATCAP_DEFAULT;
-	}
-
-	LISTBASE_FOREACH(StudioLight *, sl, &studiolights) {
-		if ((sl->flag & flag) && STREQ(sl->name, default_name)) {
-			return sl;
-		}
-	}
-
-	LISTBASE_FOREACH(StudioLight *, sl, &studiolights) {
-		if ((sl->flag & flag)) {
-			return sl;
-		}
-	}
-	return NULL;
+  const char *default_name = "";
+
+  if (flag & STUDIOLIGHT_TYPE_WORLD) {
+    default_name = STUDIOLIGHT_WORLD_DEFAULT;
+  }
+  else if (flag & STUDIOLIGHT_TYPE_MATCAP) {
+    default_name = STUDIOLIGHT_MATCAP_DEFAULT;
+  }
+
+  LISTBASE_FOREACH (StudioLight *, sl, &studiolights) {
+    if ((sl->flag & flag) && STREQ(sl->name, default_name)) {
+      return sl;
+    }
+  }
+
+  LISTBASE_FOREACH (StudioLight *, sl, &studiolights) {
+    if ((sl->flag & flag)) {
+      return sl;
+    }
+  }
+  return NULL;
 }
 
 struct StudioLight *BKE_studiolight_find(const char *name, int flag)
 {
-	LISTBASE_FOREACH(StudioLight *, sl, &studiolights) {
-		if (STREQLEN(sl->name, name, FILE_MAXFILE)) {
-			if ((sl->flag & flag)) {
-				return sl;
-			}
-			else {
-				/* flags do not match, so use default */
-				return BKE_studiolight_find_default(flag);
-			}
-		}
-	}
-	/* When not found, use the default studio light */
-	return BKE_studiolight_find_default(flag);
+  LISTBASE_FOREACH (StudioLight *, sl, &studiolights) {
+    if (STREQLEN(sl->name, name, FILE_MAXFILE)) {
+      if ((sl->flag & flag)) {
+        return sl;
+      }
+      else {
+        /* flags do not match, so use default */
+        return BKE_studiolight_find_default(flag);
+      }
+    }
+  }
+  /* When not found, use the default studio light */
+  return BKE_studiolight_find_default(flag);
 }
 
 struct StudioLight *BKE_studiolight_findindex(int index, int flag)
 {
-	LISTBASE_FOREACH(StudioLight *, sl, &studiolights) {
-		if (sl->index == index) {
-			return sl;
-		}
-	}
-	/* When not found, use the default studio light */
-	return BKE_studiolight_find_default(flag);
+  LISTBASE_FOREACH (StudioLight *, sl, &studiolights) {
+    if (sl->index == index) {
+      return sl;
+    }
+  }
+  /* When not found, use the default studio light */
+  return BKE_studiolight_find_default(flag);
 }
 
 struct ListBase *BKE_studiolight_listbase(void)
 {
-	return &studiolights;
+  return &studiolights;
 }
 
 void BKE_studiolight_preview(uint *icon_buffer, StudioLight *sl, int icon_id_type)
 {
-	switch (icon_id_type) {
-		case STUDIOLIGHT_ICON_ID_TYPE_RADIANCE:
-		default:
-		{
-			studiolight_radiance_preview(icon_buffer, sl);
-			break;
-		}
-		case STUDIOLIGHT_ICON_ID_TYPE_IRRADIANCE:
-		{
-			studiolight_irradiance_preview(icon_buffer, sl);
-			break;
-		}
-		case STUDIOLIGHT_ICON_ID_TYPE_MATCAP:
-		{
-			studiolight_matcap_preview(icon_buffer, sl, false);
-			break;
-		}
-		case STUDIOLIGHT_ICON_ID_TYPE_MATCAP_FLIPPED:
-		{
-			studiolight_matcap_preview(icon_buffer, sl, true);
-			break;
-		}
-	}
+  switch (icon_id_type) {
+    case STUDIOLIGHT_ICON_ID_TYPE_RADIANCE:
+    default: {
+      studiolight_radiance_preview(icon_buffer, sl);
+      break;
+    }
+    case STUDIOLIGHT_ICON_ID_TYPE_IRRADIANCE: {
+      studiolight_irradiance_preview(icon_buffer, sl);
+      break;
+    }
+    case STUDIOLIGHT_ICON_ID_TYPE_MATCAP: {
+      studiolight_matcap_preview(icon_buffer, sl, false);
+      break;
+    }
+    case STUDIOLIGHT_ICON_ID_TYPE_MATCAP_FLIPPED: {
+      studiolight_matcap_preview(icon_buffer, sl, true);
+      break;
+    }
+  }
 }
 
 /* Ensure state of Studiolights */
 void BKE_studiolight_ensure_flag(StudioLight *sl, int flag)
 {
-	if ((sl->flag & flag) == flag) {
-		return;
-	}
-
-	if ((flag & STUDIOLIGHT_EXTERNAL_IMAGE_LOADED)) {
-		studiolight_load_equirect_image(sl);
-	}
-	if ((flag & STUDIOLIGHT_RADIANCE_BUFFERS_CALCULATED)) {
-		studiolight_calculate_radiance_cubemap_buffers(sl);
-	}
-	if ((flag & STUDIOLIGHT_SPHERICAL_HARMONICS_COEFFICIENTS_CALCULATED)) {
-		if (!studiolight_load_spherical_harmonics_coefficients(sl)) {
-			studiolight_calculate_diffuse_light(sl);
-		}
-	}
-	if ((flag & STUDIOLIGHT_EQUIRECT_RADIANCE_GPUTEXTURE)) {
-		studiolight_create_equirect_radiance_gputexture(sl);
-	}
-	if ((flag & STUDIOLIGHT_EQUIRECT_IRRADIANCE_GPUTEXTURE)) {
-		studiolight_create_equirect_irradiance_gputexture(sl);
-	}
-	if ((flag & STUDIOLIGHT_EQUIRECT_IRRADIANCE_IMAGE_CALCULATED)) {
-		if (!studiolight_load_irradiance_equirect_image(sl)) {
-			studiolight_calculate_irradiance_equirect_image(sl);
-		}
-	}
+  if ((sl->flag & flag) == flag) {
+    return;
+  }
+
+  if ((flag & STUDIOLIGHT_EXTERNAL_IMAGE_LOADED)) {
+    studiolight_load_equirect_image(sl);
+  }
+  if ((flag & STUDIOLIGHT_RADIANCE_BUFFERS_CALCULATED)) {
+    studiolight_calculate_radiance_cubemap_buffers(sl);
+  }
+  if ((flag & STUDIOLIGHT_SPHERICAL_HARMONICS_COEFFICIENTS_CALCULATED)) {
+    if (!studiolight_load_spherical_harmonics_coefficients(sl)) {
+      studiolight_calculate_diffuse_light(sl);
+    }
+  }
+  if ((flag & STUDIOLIGHT_EQUIRECT_RADIANCE_GPUTEXTURE)) {
+    studiolight_create_equirect_radiance_gputexture(sl);
+  }
+  if ((flag & STUDIOLIGHT_EQUIRECT_IRRADIANCE_GPUTEXTURE)) {
+    studiolight_create_equirect_irradiance_gputexture(sl);
+  }
+  if ((flag & STUDIOLIGHT_EQUIRECT_IRRADIANCE_IMAGE_CALCULATED)) {
+    if (!studiolight_load_irradiance_equirect_image(sl)) {
+      studiolight_calculate_irradiance_equirect_image(sl);
+    }
+  }
 }
 
 /*
@@ -1363,73 +1425,78 @@ void BKE_studiolight_ensure_flag(StudioLight *sl, int flag)
  */
 void BKE_studiolight_remove(StudioLight *sl)
 {
-	if (sl->flag & STUDIOLIGHT_USER_DEFINED) {
-		BLI_remlink(&studiolights, sl);
-		studiolight_free(sl);
-	}
+  if (sl->flag & STUDIOLIGHT_USER_DEFINED) {
+    BLI_remlink(&studiolights, sl);
+    studiolight_free(sl);
+  }
 }
 
 StudioLight *BKE_studiolight_load(const char *path, int type)
 {
-	StudioLight *sl = studiolight_add_file(path, type | STUDIOLIGHT_USER_DEFINED);
-	return sl;
+  StudioLight *sl = studiolight_add_file(path, type | STUDIOLIGHT_USER_DEFINED);
+  return sl;
 }
 
-StudioLight *BKE_studiolight_create(const char *path, const SolidLight light[4], const float light_ambient[3])
+StudioLight *BKE_studiolight_create(const char *path,
+                                    const SolidLight light[4],
+                                    const float light_ambient[3])
 {
-	StudioLight *sl = studiolight_create(STUDIOLIGHT_EXTERNAL_FILE | STUDIOLIGHT_USER_DEFINED | STUDIOLIGHT_TYPE_STUDIO);
+  StudioLight *sl = studiolight_create(STUDIOLIGHT_EXTERNAL_FILE | STUDIOLIGHT_USER_DEFINED |
+                                       STUDIOLIGHT_TYPE_STUDIO);
 
-	char filename[FILE_MAXFILE];
-	BLI_split_file_part(path, filename, FILE_MAXFILE);
-	STRNCPY(sl->path, path);
-	STRNCPY(sl->name, filename);
+  char filename[FILE_MAXFILE];
+  BLI_split_file_part(path, filename, FILE_MAXFILE);
+  STRNCPY(sl->path, path);
+  STRNCPY(sl->name, filename);
 
-	memcpy(sl->light, light, sizeof(*light) * 4);
-	memcpy(sl->light_ambient, light_ambient, sizeof(*light_ambient) * 3);
+  memcpy(sl->light, light, sizeof(*light) * 4);
+  memcpy(sl->light_ambient, light_ambient, sizeof(*light_ambient) * 3);
 
-	studiolight_write_solid_light(sl);
+  studiolight_write_solid_light(sl);
 
-	BLI_addtail(&studiolights, sl);
-	return sl;
+  BLI_addtail(&studiolights, sl);
+  return sl;
 }
 
 /* Only useful for workbench while editing the userprefs. */
 StudioLight *BKE_studiolight_studio_edit_get(void)
 {
-	static StudioLight sl = {0};
-	sl.flag = STUDIOLIGHT_TYPE_STUDIO;
+  static StudioLight sl = {0};
+  sl.flag = STUDIOLIGHT_TYPE_STUDIO;
 
-	memcpy(sl.light, U.light_param, sizeof(*sl.light) * 4);
-	memcpy(sl.light_ambient, U.light_ambient, sizeof(*sl.light_ambient) * 3);
+  memcpy(sl.light, U.light_param, sizeof(*sl.light) * 4);
+  memcpy(sl.light_ambient, U.light_ambient, sizeof(*sl.light_ambient) * 3);
 
-	return &sl;
+  return &sl;
 }
 
 void BKE_studiolight_refresh(void)
 {
-	BKE_studiolight_free();
-	BKE_studiolight_init();
+  BKE_studiolight_free();
+  BKE_studiolight_init();
 }
 
-void BKE_studiolight_set_free_function(StudioLight *sl, StudioLightFreeFunction *free_function, void *data)
+void BKE_studiolight_set_free_function(StudioLight *sl,
+                                       StudioLightFreeFunction *free_function,
+                                       void *data)
 {
-	sl->free_function = free_function;
-	sl->free_function_data = data;
+  sl->free_function = free_function;
+  sl->free_function_data = data;
 }
 
 void BKE_studiolight_unset_icon_id(StudioLight *sl, int icon_id)
 {
-	BLI_assert(sl != NULL);
-	if (sl->icon_id_radiance == icon_id) {
-		sl->icon_id_radiance = 0;
-	}
-	if (sl->icon_id_irradiance == icon_id) {
-		sl->icon_id_irradiance = 0;
-	}
-	if (sl->icon_id_matcap == icon_id) {
-		sl->icon_id_matcap = 0;
-	}
-	if (sl->icon_id_matcap_flipped == icon_id) {
-		sl->icon_id_matcap_flipped = 0;
-	}
+  BLI_assert(sl != NULL);
+  if (sl->icon_id_radiance == icon_id) {
+    sl->icon_id_radiance = 0;
+  }
+  if (sl->icon_id_irradiance == icon_id) {
+    sl->icon_id_irradiance = 0;
+  }
+  if (sl->icon_id_matcap == icon_id) {
+    sl->icon_id_matcap = 0;
+  }
+  if (sl->icon_id_matcap_flipped == icon_id) {
+    sl->icon_id_matcap_flipped = 0;
+  }
 }