Cleanup: style, use braces for blenkernel
[blender.git] / source / blender / blenkernel / intern / studiolight.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2006-2007 Blender Foundation.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup bke
22  */
23
24 #include "BKE_studiolight.h"
25
26 #include "BKE_appdir.h"
27 #include "BKE_icons.h"
28
29 #include "BLI_dynstr.h"
30 #include "BLI_fileops.h"
31 #include "BLI_fileops_types.h"
32 #include "BLI_listbase.h"
33 #include "BLI_linklist.h"
34 #include "BLI_math.h"
35 #include "BLI_math_color.h"
36 #include "BLI_path_util.h"
37 #include "BLI_string.h"
38 #include "BLI_string_utils.h"
39
40 #include "DNA_listBase.h"
41
42 #include "IMB_imbuf.h"
43 #include "IMB_imbuf_types.h"
44
45 #include "GPU_texture.h"
46
47 #include "MEM_guardedalloc.h"
48
49 /* Statics */
50 static ListBase studiolights;
51 static int last_studiolight_id = 0;
52 #define STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE 96
53 #define STUDIOLIGHT_IRRADIANCE_EQUIRECT_HEIGHT 32
54 #define STUDIOLIGHT_IRRADIANCE_EQUIRECT_WIDTH (STUDIOLIGHT_IRRADIANCE_EQUIRECT_HEIGHT * 2)
55
56 /*
57  * The method to calculate the irradiance buffers
58  * The irradiance buffer is only shown in the background when in LookDev.
59  *
60  * STUDIOLIGHT_IRRADIANCE_METHOD_RADIANCE is very slow, but very accurate
61  * STUDIOLIGHT_IRRADIANCE_METHOD_SPHERICAL_HARMONICS is faster but has artifacts
62  * Cannot have both enabled at the same time!!!
63  */
64 // #define STUDIOLIGHT_IRRADIANCE_METHOD_RADIANCE
65 #define STUDIOLIGHT_IRRADIANCE_METHOD_SPHERICAL_HARMONICS
66
67 /* Temporarily disabled due to the creation of textures with -nan(ind)s */
68 #define STUDIOLIGHT_SH_WINDOWING 0.0f /* 0.0 is disabled */
69
70 /*
71  * Disable this option so caches are not loaded from disk
72  * Do not checkin with this commented out
73  */
74 #define STUDIOLIGHT_LOAD_CACHED_FILES
75
76 static const char *STUDIOLIGHT_LIGHTS_FOLDER = "studiolights/studio/";
77 static const char *STUDIOLIGHT_WORLD_FOLDER = "studiolights/world/";
78 static const char *STUDIOLIGHT_MATCAP_FOLDER = "studiolights/matcap/";
79
80 static const char *STUDIOLIGHT_WORLD_DEFAULT = "forest.exr";
81 static const char *STUDIOLIGHT_MATCAP_DEFAULT = "basic_1.exr";
82
83 /* ITER MACRO */
84
85 /** Iter on all pixel giving texel center position and pixel pointer.
86  * Arguments
87  *   type : type of src.
88  *   src : source buffer.
89  *   channels : number of channels per pixel.
90  *
91  * Others
92  *   x, y : normalized UV coordinate [0..1] of the current pixel center.
93  *   texel_size[2] : UV size of a pixel in this texture.
94  *   pixel[] : pointer to the current pixel.
95  */
96 #define ITER_PIXELS(type, src, channels, width, height) \
97   { \
98     float texel_size[2]; \
99     texel_size[0] = 1.0f / width; \
100     texel_size[1] = 1.0f / height; \
101     type(*pixel_)[channels] = (type(*)[channels])src; \
102     for (float y = 0.5 * texel_size[1]; y < 1.0; y += texel_size[1]) { \
103       for (float x = 0.5 * texel_size[0]; x < 1.0; x += texel_size[0], pixel_++) { \
104         type *pixel = *pixel_;
105
106 #define ITER_PIXELS_END \
107   } \
108   } \
109   } \
110   ((void)0)
111
112 /* FUNCTIONS */
113 #define IMB_SAFE_FREE(p) \
114   do { \
115     if (p) { \
116       IMB_freeImBuf(p); \
117       p = NULL; \
118     } \
119   } while (0)
120
121 #define GPU_TEXTURE_SAFE_FREE(p) \
122   do { \
123     if (p) { \
124       GPU_texture_free(p); \
125       p = NULL; \
126     } \
127   } while (0)
128
129 static void studiolight_free(struct StudioLight *sl)
130 {
131 #define STUDIOLIGHT_DELETE_ICON(s) \
132   do { \
133     if (s != 0) { \
134       BKE_icon_delete(s); \
135       s = 0; \
136     } \
137   } while (0)
138
139   if (sl->free_function) {
140     sl->free_function(sl, sl->free_function_data);
141   }
142   STUDIOLIGHT_DELETE_ICON(sl->icon_id_radiance);
143   STUDIOLIGHT_DELETE_ICON(sl->icon_id_irradiance);
144   STUDIOLIGHT_DELETE_ICON(sl->icon_id_matcap);
145   STUDIOLIGHT_DELETE_ICON(sl->icon_id_matcap_flipped);
146 #undef STUDIOLIGHT_DELETE_ICON
147
148   for (int index = 0; index < 6; index++) {
149     IMB_SAFE_FREE(sl->radiance_cubemap_buffers[index]);
150   }
151   GPU_TEXTURE_SAFE_FREE(sl->equirect_radiance_gputexture);
152   GPU_TEXTURE_SAFE_FREE(sl->equirect_irradiance_gputexture);
153   IMB_SAFE_FREE(sl->equirect_radiance_buffer);
154   IMB_SAFE_FREE(sl->equirect_irradiance_buffer);
155   MEM_SAFE_FREE(sl->path_irr_cache);
156   MEM_SAFE_FREE(sl->path_sh_cache);
157   MEM_SAFE_FREE(sl);
158 }
159
160 static struct StudioLight *studiolight_create(int flag)
161 {
162   struct StudioLight *sl = MEM_callocN(sizeof(*sl), __func__);
163   sl->path[0] = 0x00;
164   sl->name[0] = 0x00;
165   sl->path_irr_cache = NULL;
166   sl->path_sh_cache = NULL;
167   sl->free_function = NULL;
168   sl->flag = flag;
169   sl->index = ++last_studiolight_id;
170   if (flag & STUDIOLIGHT_TYPE_STUDIO) {
171     sl->icon_id_irradiance = BKE_icon_ensure_studio_light(sl, STUDIOLIGHT_ICON_ID_TYPE_IRRADIANCE);
172   }
173   else if (flag & STUDIOLIGHT_TYPE_MATCAP) {
174     sl->icon_id_matcap = BKE_icon_ensure_studio_light(sl, STUDIOLIGHT_ICON_ID_TYPE_MATCAP);
175     sl->icon_id_matcap_flipped = BKE_icon_ensure_studio_light(
176         sl, STUDIOLIGHT_ICON_ID_TYPE_MATCAP_FLIPPED);
177   }
178   else {
179     sl->icon_id_radiance = BKE_icon_ensure_studio_light(sl, STUDIOLIGHT_ICON_ID_TYPE_RADIANCE);
180   }
181
182   for (int index = 0; index < 6; index++) {
183     sl->radiance_cubemap_buffers[index] = NULL;
184   }
185
186   return sl;
187 }
188
189 #define STUDIOLIGHT_FILE_VERSION 1
190
191 #define READ_VAL(type, parser, id, val, lines) \
192   do { \
193     for (LinkNode *line = lines; line; line = line->next) { \
194       char *val_str, *str = line->link; \
195       if ((val_str = strstr(str, id " "))) { \
196         val_str += sizeof(id); /* Skip id + spacer. */ \
197         val = parser(val_str); \
198       } \
199     } \
200   } while (0)
201
202 #define READ_FVAL(id, val, lines) READ_VAL(float, atof, id, val, lines)
203 #define READ_IVAL(id, val, lines) READ_VAL(int, atoi, id, val, lines)
204
205 #define READ_VEC3(id, val, lines) \
206   do { \
207     READ_FVAL(id ".x", val[0], lines); \
208     READ_FVAL(id ".y", val[1], lines); \
209     READ_FVAL(id ".z", val[2], lines); \
210   } while (0)
211
212 #define READ_SOLIDLIGHT(sl, i, lines) \
213   do { \
214     READ_IVAL("light[" STRINGIFY(i) "].flag", sl[i].flag, lines); \
215     READ_FVAL("light[" STRINGIFY(i) "].smooth", sl[i].smooth, lines); \
216     READ_VEC3("light[" STRINGIFY(i) "].col", sl[i].col, lines); \
217     READ_VEC3("light[" STRINGIFY(i) "].spec", sl[i].spec, lines); \
218     READ_VEC3("light[" STRINGIFY(i) "].vec", sl[i].vec, lines); \
219   } while (0)
220
221 static void studiolight_load_solid_light(StudioLight *sl)
222 {
223   LinkNode *lines = BLI_file_read_as_lines(sl->path);
224   if (lines) {
225     READ_VEC3("light_ambient", sl->light_ambient, lines);
226     READ_SOLIDLIGHT(sl->light, 0, lines);
227     READ_SOLIDLIGHT(sl->light, 1, lines);
228     READ_SOLIDLIGHT(sl->light, 2, lines);
229     READ_SOLIDLIGHT(sl->light, 3, lines);
230   }
231   BLI_file_free_lines(lines);
232 }
233
234 #undef READ_SOLIDLIGHT
235 #undef READ_VEC3
236 #undef READ_IVAL
237 #undef READ_FVAL
238
239 #define WRITE_FVAL(str, id, val) (BLI_dynstr_appendf(str, id " %f\n", val))
240 #define WRITE_IVAL(str, id, val) (BLI_dynstr_appendf(str, id " %d\n", val))
241
242 #define WRITE_VEC3(str, id, val) \
243   do { \
244     WRITE_FVAL(str, id ".x", val[0]); \
245     WRITE_FVAL(str, id ".y", val[1]); \
246     WRITE_FVAL(str, id ".z", val[2]); \
247   } while (0)
248
249 #define WRITE_SOLIDLIGHT(str, sl, i) \
250   do { \
251     WRITE_IVAL(str, "light[" STRINGIFY(i) "].flag", sl[i].flag); \
252     WRITE_FVAL(str, "light[" STRINGIFY(i) "].smooth", sl[i].smooth); \
253     WRITE_VEC3(str, "light[" STRINGIFY(i) "].col", sl[i].col); \
254     WRITE_VEC3(str, "light[" STRINGIFY(i) "].spec", sl[i].spec); \
255     WRITE_VEC3(str, "light[" STRINGIFY(i) "].vec", sl[i].vec); \
256   } while (0)
257
258 static void studiolight_write_solid_light(StudioLight *sl)
259 {
260   FILE *fp = BLI_fopen(sl->path, "wb");
261   if (fp) {
262     DynStr *str = BLI_dynstr_new();
263
264     /* Very dumb ascii format. One value per line separated by a space. */
265     WRITE_IVAL(str, "version", STUDIOLIGHT_FILE_VERSION);
266     WRITE_VEC3(str, "light_ambient", sl->light_ambient);
267     WRITE_SOLIDLIGHT(str, sl->light, 0);
268     WRITE_SOLIDLIGHT(str, sl->light, 1);
269     WRITE_SOLIDLIGHT(str, sl->light, 2);
270     WRITE_SOLIDLIGHT(str, sl->light, 3);
271
272     char *cstr = BLI_dynstr_get_cstring(str);
273
274     fwrite(cstr, BLI_dynstr_get_len(str), 1, fp);
275     fclose(fp);
276
277     MEM_freeN(cstr);
278     BLI_dynstr_free(str);
279   }
280 }
281
282 #undef WRITE_SOLIDLIGHT
283 #undef WRITE_VEC3
284 #undef WRITE_IVAL
285 #undef WRITE_FVAL
286
287 static void direction_to_equirect(float r[2], const float dir[3])
288 {
289   r[0] = (atan2f(dir[1], dir[0]) - M_PI) / -(M_PI * 2);
290   r[1] = (acosf(dir[2] / 1.0) - M_PI) / -M_PI;
291 }
292
293 static void equirect_to_direction(float r[3], float u, float v)
294 {
295   float phi = (-(M_PI * 2)) * u + M_PI;
296   float theta = -M_PI * v + M_PI;
297   float sin_theta = sinf(theta);
298   r[0] = sin_theta * cosf(phi);
299   r[1] = sin_theta * sinf(phi);
300   r[2] = cosf(theta);
301 }
302
303 static void UNUSED_FUNCTION(direction_to_cube_face_uv)(float r_uv[2],
304                                                        int *r_face,
305                                                        const float dir[3])
306 {
307   if (fabsf(dir[0]) > fabsf(dir[1]) && fabsf(dir[0]) > fabsf(dir[2])) {
308     bool is_pos = (dir[0] > 0.0f);
309     *r_face = is_pos ? STUDIOLIGHT_X_POS : STUDIOLIGHT_X_NEG;
310     r_uv[0] = dir[2] / fabsf(dir[0]) * (is_pos ? 1 : -1);
311     r_uv[1] = dir[1] / fabsf(dir[0]) * (is_pos ? -1 : -1);
312   }
313   else if (fabsf(dir[1]) > fabsf(dir[0]) && fabsf(dir[1]) > fabsf(dir[2])) {
314     bool is_pos = (dir[1] > 0.0f);
315     *r_face = is_pos ? STUDIOLIGHT_Y_POS : STUDIOLIGHT_Y_NEG;
316     r_uv[0] = dir[0] / fabsf(dir[1]) * (is_pos ? 1 : 1);
317     r_uv[1] = dir[2] / fabsf(dir[1]) * (is_pos ? -1 : 1);
318   }
319   else {
320     bool is_pos = (dir[2] > 0.0f);
321     *r_face = is_pos ? STUDIOLIGHT_Z_NEG : STUDIOLIGHT_Z_POS;
322     r_uv[0] = dir[0] / fabsf(dir[2]) * (is_pos ? -1 : 1);
323     r_uv[1] = dir[1] / fabsf(dir[2]) * (is_pos ? -1 : -1);
324   }
325   r_uv[0] = r_uv[0] * 0.5f + 0.5f;
326   r_uv[1] = r_uv[1] * 0.5f + 0.5f;
327 }
328
329 static void cube_face_uv_to_direction(float r_dir[3], float x, float y, int face)
330 {
331   const float conversion_matrices[6][3][3] = {
332       {{0.0f, 0.0f, 1.0f}, {0.0f, -1.0f, 0.0f}, {1.0f, 0.0f, 0.0f}},
333       {{0.0f, 0.0f, -1.0f}, {0.0f, -1.0f, 0.0f}, {-1.0f, 0.0f, 0.0f}},
334       {{1.0f, 0.0f, 0.0f}, {0.0f, 0.0f, -1.0f}, {0.0f, 1.0f, 0.0f}},
335       {{1.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 1.0f}, {0.0f, -1.0f, 0.0f}},
336       {{1.0f, 0.0f, 0.0f}, {0.0f, -1.0f, 0.0f}, {0.0f, 0.0f, -1.0f}},
337       {{-1.0f, 0.0f, 0.0f}, {0.0f, -1.0f, 0.0f}, {0.0f, 0.0f, 1.0f}},
338   };
339
340   copy_v3_fl3(r_dir, x * 2.0f - 1.0f, y * 2.0f - 1.0f, 1.0f);
341   mul_m3_v3(conversion_matrices[face], r_dir);
342   normalize_v3(r_dir);
343 }
344
345 static void studiolight_load_equirect_image(StudioLight *sl)
346 {
347   if (sl->flag & STUDIOLIGHT_EXTERNAL_FILE) {
348     ImBuf *ibuf = NULL;
349     ibuf = IMB_loadiffname(sl->path, 0, NULL);
350     if (ibuf == NULL) {
351       float *colbuf = MEM_mallocN(sizeof(float[4]), __func__);
352       copy_v4_fl4(colbuf, 1.0f, 0.0f, 1.0f, 1.0f);
353       ibuf = IMB_allocFromBuffer(NULL, colbuf, 1, 1);
354     }
355     IMB_float_from_rect(ibuf);
356     sl->equirect_radiance_buffer = ibuf;
357   }
358   sl->flag |= STUDIOLIGHT_EXTERNAL_IMAGE_LOADED;
359 }
360
361 static void studiolight_create_equirect_radiance_gputexture(StudioLight *sl)
362 {
363   if (sl->flag & STUDIOLIGHT_EXTERNAL_FILE) {
364     char error[256];
365     BKE_studiolight_ensure_flag(sl, STUDIOLIGHT_EXTERNAL_IMAGE_LOADED);
366     ImBuf *ibuf = sl->equirect_radiance_buffer;
367
368     if (sl->flag & STUDIOLIGHT_TYPE_MATCAP) {
369       float *gpu_matcap_3components = MEM_callocN(sizeof(float[3]) * ibuf->x * ibuf->y, __func__);
370
371       float(*offset4)[4] = (float(*)[4])ibuf->rect_float;
372       float(*offset3)[3] = (float(*)[3])gpu_matcap_3components;
373       for (int i = 0; i < ibuf->x * ibuf->y; i++, offset4++, offset3++) {
374         copy_v3_v3(*offset3, *offset4);
375       }
376
377       sl->equirect_radiance_gputexture = GPU_texture_create_nD(ibuf->x,
378                                                                ibuf->y,
379                                                                0,
380                                                                2,
381                                                                gpu_matcap_3components,
382                                                                GPU_R11F_G11F_B10F,
383                                                                GPU_DATA_FLOAT,
384                                                                0,
385                                                                false,
386                                                                error);
387
388       MEM_SAFE_FREE(gpu_matcap_3components);
389     }
390     else {
391       sl->equirect_radiance_gputexture = GPU_texture_create_2d(
392           ibuf->x, ibuf->y, GPU_RGBA16F, ibuf->rect_float, error);
393       GPUTexture *tex = sl->equirect_radiance_gputexture;
394       GPU_texture_bind(tex, 0);
395       GPU_texture_filter_mode(tex, true);
396       GPU_texture_wrap_mode(tex, true);
397       GPU_texture_unbind(tex);
398     }
399   }
400   sl->flag |= STUDIOLIGHT_EQUIRECT_RADIANCE_GPUTEXTURE;
401 }
402
403 static void studiolight_create_equirect_irradiance_gputexture(StudioLight *sl)
404 {
405   if (sl->flag & STUDIOLIGHT_EXTERNAL_FILE) {
406     char error[256];
407     BKE_studiolight_ensure_flag(sl, STUDIOLIGHT_EQUIRECT_IRRADIANCE_IMAGE_CALCULATED);
408     ImBuf *ibuf = sl->equirect_irradiance_buffer;
409     sl->equirect_irradiance_gputexture = GPU_texture_create_2d(
410         ibuf->x, ibuf->y, GPU_RGBA16F, ibuf->rect_float, error);
411     GPUTexture *tex = sl->equirect_irradiance_gputexture;
412     GPU_texture_bind(tex, 0);
413     GPU_texture_filter_mode(tex, true);
414     GPU_texture_wrap_mode(tex, true);
415     GPU_texture_unbind(tex);
416   }
417   sl->flag |= STUDIOLIGHT_EQUIRECT_IRRADIANCE_GPUTEXTURE;
418 }
419
420 static void studiolight_calculate_radiance(ImBuf *ibuf, float color[4], const float direction[3])
421 {
422   float uv[2];
423   direction_to_equirect(uv, direction);
424   nearest_interpolation_color_wrap(ibuf, NULL, color, uv[0] * ibuf->x, uv[1] * ibuf->y);
425 }
426
427 static void studiolight_calculate_radiance_buffer(ImBuf *ibuf,
428                                                   float *colbuf,
429                                                   const int index_x,
430                                                   const int index_y,
431                                                   const int index_z,
432                                                   const float xsign,
433                                                   const float ysign,
434                                                   const float zsign)
435 {
436   ITER_PIXELS (
437       float, colbuf, 4, STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE, STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE) {
438     float direction[3];
439     direction[index_x] = xsign * (x - 0.5f);
440     direction[index_y] = ysign * (y - 0.5f);
441     direction[index_z] = zsign * 0.5f;
442     normalize_v3(direction);
443     studiolight_calculate_radiance(ibuf, pixel, direction);
444   }
445   ITER_PIXELS_END;
446 }
447
448 static void studiolight_calculate_radiance_cubemap_buffers(StudioLight *sl)
449 {
450   if (sl->flag & STUDIOLIGHT_EXTERNAL_FILE) {
451     BKE_studiolight_ensure_flag(sl, STUDIOLIGHT_EXTERNAL_IMAGE_LOADED);
452     ImBuf *ibuf = sl->equirect_radiance_buffer;
453     if (ibuf) {
454       float *colbuf = MEM_mallocN(SQUARE(STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE) * sizeof(float[4]),
455                                   __func__);
456
457       /* front */
458       studiolight_calculate_radiance_buffer(ibuf, colbuf, 0, 2, 1, 1, -1, 1);
459       sl->radiance_cubemap_buffers[STUDIOLIGHT_Y_POS] = IMB_allocFromBuffer(
460           NULL, colbuf, STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE, STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE);
461
462       /* back */
463       studiolight_calculate_radiance_buffer(ibuf, colbuf, 0, 2, 1, 1, 1, -1);
464       sl->radiance_cubemap_buffers[STUDIOLIGHT_Y_NEG] = IMB_allocFromBuffer(
465           NULL, colbuf, STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE, STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE);
466
467       /* left */
468       studiolight_calculate_radiance_buffer(ibuf, colbuf, 2, 1, 0, 1, -1, 1);
469       sl->radiance_cubemap_buffers[STUDIOLIGHT_X_POS] = IMB_allocFromBuffer(
470           NULL, colbuf, STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE, STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE);
471
472       /* right */
473       studiolight_calculate_radiance_buffer(ibuf, colbuf, 2, 1, 0, -1, -1, -1);
474       sl->radiance_cubemap_buffers[STUDIOLIGHT_X_NEG] = IMB_allocFromBuffer(
475           NULL, colbuf, STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE, STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE);
476
477       /* top */
478       studiolight_calculate_radiance_buffer(ibuf, colbuf, 0, 1, 2, -1, -1, 1);
479       sl->radiance_cubemap_buffers[STUDIOLIGHT_Z_NEG] = IMB_allocFromBuffer(
480           NULL, colbuf, STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE, STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE);
481
482       /* bottom */
483       studiolight_calculate_radiance_buffer(ibuf, colbuf, 0, 1, 2, 1, -1, -1);
484       sl->radiance_cubemap_buffers[STUDIOLIGHT_Z_POS] = IMB_allocFromBuffer(
485           NULL, colbuf, STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE, STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE);
486
487 #if 0
488       IMB_saveiff(sl->radiance_cubemap_buffers[STUDIOLIGHT_X_POS],
489                   "/tmp/studiolight_radiance_left.png",
490                   IB_rectfloat);
491       IMB_saveiff(sl->radiance_cubemap_buffers[STUDIOLIGHT_X_NEG],
492                   "/tmp/studiolight_radiance_right.png",
493                   IB_rectfloat);
494       IMB_saveiff(sl->radiance_cubemap_buffers[STUDIOLIGHT_Y_POS],
495                   "/tmp/studiolight_radiance_front.png",
496                   IB_rectfloat);
497       IMB_saveiff(sl->radiance_cubemap_buffers[STUDIOLIGHT_Y_NEG],
498                   "/tmp/studiolight_radiance_back.png",
499                   IB_rectfloat);
500       IMB_saveiff(sl->radiance_cubemap_buffers[STUDIOLIGHT_Z_POS],
501                   "/tmp/studiolight_radiance_bottom.png",
502                   IB_rectfloat);
503       IMB_saveiff(sl->radiance_cubemap_buffers[STUDIOLIGHT_Z_NEG],
504                   "/tmp/studiolight_radiance_top.png",
505                   IB_rectfloat);
506 #endif
507       MEM_freeN(colbuf);
508     }
509   }
510   sl->flag |= STUDIOLIGHT_RADIANCE_BUFFERS_CALCULATED;
511 }
512
513 /*
514  * Spherical Harmonics
515  */
516 BLI_INLINE float area_element(float x, float y)
517 {
518   return atan2(x * y, sqrtf(x * x + y * y + 1));
519 }
520
521 BLI_INLINE float texel_solid_angle(float x, float y, float halfpix)
522 {
523   float v1x = (x - halfpix) * 2.0f - 1.0f;
524   float v1y = (y - halfpix) * 2.0f - 1.0f;
525   float v2x = (x + halfpix) * 2.0f - 1.0f;
526   float v2y = (y + halfpix) * 2.0f - 1.0f;
527
528   return area_element(v1x, v1y) - area_element(v1x, v2y) - area_element(v2x, v1y) +
529          area_element(v2x, v2y);
530 }
531
532 static void studiolight_calculate_cubemap_vector_weight(
533     float normal[3], float *weight, int face, float x, float y)
534 {
535   const float halfpix = 0.5f / STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE;
536   cube_face_uv_to_direction(normal, x, y, face);
537   *weight = texel_solid_angle(x, y, halfpix);
538 }
539
540 static void studiolight_spherical_harmonics_calculate_coefficients(StudioLight *sl, float (*sh)[3])
541 {
542   float weight_accum = 0.0f;
543   memset(sh, 0, sizeof(float) * 3 * STUDIOLIGHT_SH_COEFS_LEN);
544
545   for (int face = 0; face < 6; face++) {
546     ITER_PIXELS (float,
547                  sl->radiance_cubemap_buffers[face]->rect_float,
548                  4,
549                  STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE,
550                  STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE) {
551       float color[3], cubevec[3], weight;
552       studiolight_calculate_cubemap_vector_weight(cubevec, &weight, face, x, y);
553       mul_v3_v3fl(color, pixel, weight);
554       weight_accum += weight;
555
556       int i = 0;
557       /* L0 */
558       madd_v3_v3fl(sh[i++], color, 0.2822095f);
559 #if STUDIOLIGHT_SH_BANDS > 1 /* L1 */
560       const float nx = cubevec[0];
561       const float ny = cubevec[1];
562       const float nz = cubevec[2];
563       madd_v3_v3fl(sh[i++], color, -0.488603f * nz);
564       madd_v3_v3fl(sh[i++], color, 0.488603f * ny);
565       madd_v3_v3fl(sh[i++], color, -0.488603f * nx);
566 #endif
567 #if STUDIOLIGHT_SH_BANDS > 2 /* L2 */
568       const float nx2 = SQUARE(nx);
569       const float ny2 = SQUARE(ny);
570       const float nz2 = SQUARE(nz);
571       madd_v3_v3fl(sh[i++], color, 1.092548f * nx * nz);
572       madd_v3_v3fl(sh[i++], color, -1.092548f * nz * ny);
573       madd_v3_v3fl(sh[i++], color, 0.315392f * (3.0f * ny2 - 1.0f));
574       madd_v3_v3fl(sh[i++], color, 1.092548f * nx * ny);
575       madd_v3_v3fl(sh[i++], color, 0.546274f * (nx2 - nz2));
576 #endif
577       /* Bypass L3 Because final irradiance does not need it. */
578 #if STUDIOLIGHT_SH_BANDS > 4 /* L4 */
579       const float nx4 = SQUARE(nx2);
580       const float ny4 = SQUARE(ny2);
581       const float nz4 = SQUARE(nz2);
582       madd_v3_v3fl(sh[i++], color, 2.5033429417967046f * nx * nz * (nx2 - nz2));
583       madd_v3_v3fl(sh[i++], color, -1.7701307697799304f * nz * ny * (3.0f * nx2 - nz2));
584       madd_v3_v3fl(sh[i++], color, 0.9461746957575601f * nz * nx * (-1.0f + 7.0f * ny2));
585       madd_v3_v3fl(sh[i++], color, -0.6690465435572892f * nz * ny * (-3.0f + 7.0f * ny2));
586       madd_v3_v3fl(sh[i++], color, (105.0f * ny4 - 90.0f * ny2 + 9.0f) / 28.359261614f);
587       madd_v3_v3fl(sh[i++], color, -0.6690465435572892f * nx * ny * (-3.0f + 7.0f * ny2));
588       madd_v3_v3fl(sh[i++], color, 0.9461746957575601f * (nx2 - nz2) * (-1.0f + 7.0f * ny2));
589       madd_v3_v3fl(sh[i++], color, -1.7701307697799304f * nx * ny * (nx2 - 3.0f * nz2));
590       madd_v3_v3fl(sh[i++], color, 0.6258357354491761f * (nx4 - 6.0f * nz2 * nx2 + nz4));
591 #endif
592     }
593     ITER_PIXELS_END;
594   }
595
596   /* The sum of solid angle should be equal to the solid angle of the sphere (4 PI),
597    * so normalize in order to make our weightAccum exactly match 4 PI. */
598   for (int i = 0; i < STUDIOLIGHT_SH_COEFS_LEN; ++i) {
599     mul_v3_fl(sh[i], M_PI * 4.0f / weight_accum);
600   }
601 }
602
603 /* Take monochrome SH as input */
604 static float studiolight_spherical_harmonics_lambda_get(float *sh, float max_laplacian)
605 {
606   /* From Peter-Pike Sloan's Stupid SH Tricks http://www.ppsloan.org/publications/StupidSH36.pdf */
607   float table_l[STUDIOLIGHT_SH_BANDS];
608   float table_b[STUDIOLIGHT_SH_BANDS];
609
610   float lambda = 0.0f;
611
612   table_l[0] = 0.0f;
613   table_b[0] = 0.0f;
614   int index = 1;
615   for (int level = 1; level < STUDIOLIGHT_SH_BANDS; level++) {
616     table_l[level] = (float)(SQUARE(level) * SQUARE(level + 1));
617
618     float b = 0.0f;
619     for (int m = -1; m <= level; m++) {
620       b += SQUARE(sh[index++]);
621     }
622     table_b[level] = b;
623   }
624
625   float squared_lamplacian = 0.0f;
626   for (int level = 1; level < STUDIOLIGHT_SH_BANDS; level++) {
627     squared_lamplacian += table_l[level] * table_b[level];
628   }
629
630   const float target_squared_laplacian = max_laplacian * max_laplacian;
631   if (squared_lamplacian <= target_squared_laplacian) {
632     return lambda;
633   }
634
635   const int no_iterations = 10000000;
636   for (int i = 0; i < no_iterations; ++i) {
637     float f = 0.0f;
638     float fd = 0.0f;
639
640     for (int level = 1; level < STUDIOLIGHT_SH_BANDS; ++level) {
641       f += table_l[level] * table_b[level] / SQUARE(1.0f + lambda * table_l[level]);
642       fd += (2.0f * SQUARE(table_l[level]) * table_b[level]) /
643             CUBE(1.0f + lambda * table_l[level]);
644     }
645
646     f = target_squared_laplacian - f;
647
648     float delta = -f / fd;
649     lambda += delta;
650
651     if (ABS(delta) < 1e-6f) {
652       break;
653     }
654   }
655
656   return lambda;
657 }
658
659 static void studiolight_spherical_harmonics_apply_windowing(float (*sh)[3], float max_laplacian)
660 {
661   if (max_laplacian <= 0.0f) {
662     return;
663   }
664
665   float sh_r[STUDIOLIGHT_SH_COEFS_LEN];
666   float sh_g[STUDIOLIGHT_SH_COEFS_LEN];
667   float sh_b[STUDIOLIGHT_SH_COEFS_LEN];
668   for (int i = 0; i < STUDIOLIGHT_SH_COEFS_LEN; i++) {
669     sh_r[i] = sh[i][0];
670     sh_g[i] = sh[i][1];
671     sh_b[i] = sh[i][2];
672   }
673   float lambda_r = studiolight_spherical_harmonics_lambda_get(sh_r, max_laplacian);
674   float lambda_g = studiolight_spherical_harmonics_lambda_get(sh_g, max_laplacian);
675   float lambda_b = studiolight_spherical_harmonics_lambda_get(sh_b, max_laplacian);
676
677   /* Apply windowing lambda */
678   int index = 0;
679   for (int level = 0; level < STUDIOLIGHT_SH_BANDS; level++) {
680     float s[3];
681     s[0] = 1.0f / (1.0f + lambda_r * SQUARE(level) * SQUARE(level + 1.0f));
682     s[1] = 1.0f / (1.0f + lambda_g * SQUARE(level) * SQUARE(level + 1.0f));
683     s[2] = 1.0f / (1.0f + lambda_b * SQUARE(level) * SQUARE(level + 1.0f));
684
685     for (int m = -1; m <= level; m++) {
686       mul_v3_v3(sh[index++], s);
687     }
688   }
689 }
690
691 static float studiolight_spherical_harmonics_geomerics_eval(
692     const float normal[3], float sh0, float sh1, float sh2, float sh3)
693 {
694   /* Use Geomerics non-linear SH. */
695   /* http://www.geomerics.com/wp-content/uploads/2015/08/CEDEC_Geomerics_ReconstructingDiffuseLighting1.pdf */
696   float R0 = sh0 * M_1_PI;
697
698   float R1[3] = {-sh3, sh2, -sh1};
699   mul_v3_fl(R1, 0.5f * M_1_PI * 1.5f); /* 1.5f is to improve the contrast a bit. */
700   float lenR1 = len_v3(R1);
701   mul_v3_fl(R1, 1.0f / lenR1);
702   float q = 0.5f * (1.0f + dot_v3v3(R1, normal));
703
704   float p = 1.0f + 2.0f * lenR1 / R0;
705   float a = (1.0f - lenR1 / R0) / (1.0f + lenR1 / R0);
706
707   return R0 * (a + (1.0f - a) * (p + 1.0f) * powf(q, p));
708 }
709
710 BLI_INLINE void studiolight_spherical_harmonics_eval(StudioLight *sl,
711                                                      float color[3],
712                                                      const float normal[3])
713 {
714 #if STUDIOLIGHT_SH_BANDS == 2
715   float(*sh)[3] = (float(*)[3])sl->spherical_harmonics_coefs;
716   for (int i = 0; i < 3; ++i) {
717     color[i] = studiolight_spherical_harmonics_geomerics_eval(
718         normal, sh[0][i], sh[1][i], sh[2][i], sh[3][i]);
719   }
720   return;
721 #else
722
723   /* L0 */
724   mul_v3_v3fl(color, sl->spherical_harmonics_coefs[0], 0.282095f);
725 #  if STUDIOLIGHT_SH_BANDS > 1 /* L1 */
726   const float nx = normal[0];
727   const float ny = normal[1];
728   const float nz = normal[2];
729   madd_v3_v3fl(color, sl->spherical_harmonics_coefs[1], -0.488603f * nz);
730   madd_v3_v3fl(color, sl->spherical_harmonics_coefs[2], 0.488603f * ny);
731   madd_v3_v3fl(color, sl->spherical_harmonics_coefs[3], -0.488603f * nx);
732 #  endif
733 #  if STUDIOLIGHT_SH_BANDS > 2 /* L2 */
734   const float nx2 = SQUARE(nx);
735   const float ny2 = SQUARE(ny);
736   const float nz2 = SQUARE(nz);
737   madd_v3_v3fl(color, sl->spherical_harmonics_coefs[4], 1.092548f * nx * nz);
738   madd_v3_v3fl(color, sl->spherical_harmonics_coefs[5], -1.092548f * nz * ny);
739   madd_v3_v3fl(color, sl->spherical_harmonics_coefs[6], 0.315392f * (3.0f * ny2 - 1.0f));
740   madd_v3_v3fl(color, sl->spherical_harmonics_coefs[7], -1.092548 * nx * ny);
741   madd_v3_v3fl(color, sl->spherical_harmonics_coefs[8], 0.546274 * (nx2 - nz2));
742 #  endif
743   /* L3 coefs are 0 */
744 #  if STUDIOLIGHT_SH_BANDS > 4 /* L4 */
745   const float nx4 = SQUARE(nx2);
746   const float ny4 = SQUARE(ny2);
747   const float nz4 = SQUARE(nz2);
748   madd_v3_v3fl(
749       color, sl->spherical_harmonics_coefs[9], 2.5033429417967046f * nx * nz * (nx2 - nz2));
750   madd_v3_v3fl(color,
751                sl->spherical_harmonics_coefs[10],
752                -1.7701307697799304f * nz * ny * (3.0f * nx2 - nz2));
753   madd_v3_v3fl(color,
754                sl->spherical_harmonics_coefs[11],
755                0.9461746957575601f * nz * nx * (-1.0f + 7.0f * ny2));
756   madd_v3_v3fl(color,
757                sl->spherical_harmonics_coefs[12],
758                -0.6690465435572892f * nz * ny * (-3.0f + 7.0f * ny2));
759   madd_v3_v3fl(color,
760                sl->spherical_harmonics_coefs[13],
761                (105.0f * ny4 - 90.0f * ny2 + 9.0f) / 28.359261614f);
762   madd_v3_v3fl(color,
763                sl->spherical_harmonics_coefs[14],
764                -0.6690465435572892f * nx * ny * (-3.0f + 7.0f * ny2));
765   madd_v3_v3fl(color,
766                sl->spherical_harmonics_coefs[15],
767                0.9461746957575601f * (nx2 - nz2) * (-1.0f + 7.0f * ny2));
768   madd_v3_v3fl(color,
769                sl->spherical_harmonics_coefs[16],
770                -1.7701307697799304f * nx * ny * (nx2 - 3.0f * nz2));
771   madd_v3_v3fl(color,
772                sl->spherical_harmonics_coefs[17],
773                0.6258357354491761f * (nx4 - 6.0f * nz2 * nx2 + nz4));
774 #  endif
775 #endif
776 }
777
778 /* This modify the radiance into irradiance. */
779 static void studiolight_spherical_harmonics_apply_band_factors(StudioLight *sl, float (*sh)[3])
780 {
781   static float sl_sh_band_factors[5] = {
782       1.0f,
783       2.0f / 3.0f,
784       1.0f / 4.0f,
785       0.0f,
786       -1.0f / 24.0f,
787   };
788
789   int index = 0, dst_idx = 0;
790   for (int band = 0; band < STUDIOLIGHT_SH_BANDS; band++) {
791     for (int m = 0; m < SQUARE(band + 1) - SQUARE(band); m++) {
792       /* Skip L3 */
793       if (band != 3) {
794         mul_v3_v3fl(sl->spherical_harmonics_coefs[dst_idx++], sh[index], sl_sh_band_factors[band]);
795       }
796       index++;
797     }
798   }
799 }
800
801 static void studiolight_calculate_diffuse_light(StudioLight *sl)
802 {
803   /* init light to black */
804   if (sl->flag & STUDIOLIGHT_EXTERNAL_FILE) {
805     BKE_studiolight_ensure_flag(sl, STUDIOLIGHT_RADIANCE_BUFFERS_CALCULATED);
806
807     float sh_coefs[STUDIOLIGHT_SH_COEFS_LEN][3];
808     studiolight_spherical_harmonics_calculate_coefficients(sl, sh_coefs);
809     studiolight_spherical_harmonics_apply_windowing(sh_coefs, STUDIOLIGHT_SH_WINDOWING);
810     studiolight_spherical_harmonics_apply_band_factors(sl, sh_coefs);
811
812     if (sl->flag & STUDIOLIGHT_USER_DEFINED) {
813       FILE *fp = BLI_fopen(sl->path_sh_cache, "wb");
814       if (fp) {
815         fwrite(sl->spherical_harmonics_coefs, sizeof(sl->spherical_harmonics_coefs), 1, fp);
816         fclose(fp);
817       }
818     }
819   }
820   sl->flag |= STUDIOLIGHT_SPHERICAL_HARMONICS_COEFFICIENTS_CALCULATED;
821 }
822
823 BLI_INLINE void studiolight_evaluate_specular_radiance_buffer(ImBuf *radiance_buffer,
824                                                               const float normal[3],
825                                                               float color[3],
826                                                               int xoffset,
827                                                               int yoffset,
828                                                               int zoffset,
829                                                               float zsign)
830 {
831   if (radiance_buffer == NULL) {
832     return;
833   }
834
835   float accum[3] = {0.0f, 0.0f, 0.0f};
836   float accum_weight = 0.00001f;
837   ITER_PIXELS (float,
838                radiance_buffer->rect_float,
839                4,
840                STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE,
841                STUDIOLIGHT_RADIANCE_CUBEMAP_SIZE) {
842     float direction[3];
843     direction[zoffset] = zsign * 0.5f;
844     direction[xoffset] = x - 0.5f;
845     direction[yoffset] = y - 0.5f;
846     normalize_v3(direction);
847     float weight = dot_v3v3(direction, normal) > 0.95f ? 1.0f : 0.0f;
848     // float solid_angle = texel_solid_angle(x, y, texel_size[0] * 0.5f);
849     madd_v3_v3fl(accum, pixel, weight);
850     accum_weight += weight;
851   }
852   ITER_PIXELS_END;
853
854   madd_v3_v3fl(color, accum, 1.0f / accum_weight);
855 }
856
857 #ifdef STUDIOLIGHT_IRRADIANCE_METHOD_RADIANCE
858 static void studiolight_irradiance_eval(StudioLight *sl, float color[3], const float normal[3])
859 {
860   copy_v3_fl(color, 0.0f);
861
862   /* XXX: This is madness, iterating over all cubemap pixels for each destination pixels
863    * even if their weight is 0.0f.
864    * It should use hemisphere, cosine sampling at least. */
865
866   /* back */
867   studiolight_evaluate_specular_radiance_buffer(
868       sl->radiance_cubemap_buffers[STUDIOLIGHT_Y_POS], normal, color, 0, 2, 1, 1);
869   /* front */
870   studiolight_evaluate_specular_radiance_buffer(
871       sl->radiance_cubemap_buffers[STUDIOLIGHT_Y_NEG], normal, color, 0, 2, 1, -1);
872
873   /* left */
874   studiolight_evaluate_specular_radiance_buffer(
875       sl->radiance_cubemap_buffers[STUDIOLIGHT_X_POS], normal, color, 1, 2, 0, 1);
876   /* right */
877   studiolight_evaluate_specular_radiance_buffer(
878       sl->radiance_cubemap_buffers[STUDIOLIGHT_X_NEG], normal, color, 1, 2, 0, -1);
879
880   /* top */
881   studiolight_evaluate_specular_radiance_buffer(
882       sl->radiance_cubemap_buffers[STUDIOLIGHT_Z_POS], normal, color, 0, 1, 2, 1);
883   /* bottom */
884   studiolight_evaluate_specular_radiance_buffer(
885       sl->radiance_cubemap_buffers[STUDIOLIGHT_Z_NEG], normal, color, 0, 1, 2, -1);
886
887   mul_v3_fl(color, 1.0 / M_PI);
888 }
889 #endif
890
891 static float brdf_approx(float spec_color, float roughness, float NV)
892 {
893   /* Very rough own approx. We don't need it to be correct, just fast.
894    * Just simulate fresnel effect with roughness attenuation. */
895   float fresnel = exp2(-8.35f * NV) * (1.0f - roughness);
896   return spec_color * (1.0f - fresnel) + fresnel;
897 }
898
899 /* NL need to be unclamped. w in [0..1] range. */
900 static float wrapped_lighting(float NL, float w)
901 {
902   float w_1 = w + 1.0f;
903   return max_ff((NL + w) / (w_1 * w_1), 0.0f);
904 }
905
906 static float blinn_specular(const float L[3],
907                             const float I[3],
908                             const float N[3],
909                             float R[3],
910                             float NL,
911                             float roughness,
912                             float wrap)
913 {
914   float half_dir[3];
915   float wrapped_NL = dot_v3v3(L, R);
916   add_v3_v3v3(half_dir, L, I);
917   normalize_v3(half_dir);
918   float spec_angle = max_ff(dot_v3v3(half_dir, N), 0.0f);
919
920   float gloss = 1.0f - roughness;
921   /* Reduce gloss for smooth light. (simulate bigger light) */
922   gloss *= 1.0f - wrap;
923   float shininess = exp2(10.0f * gloss + 1.0f);
924
925   /* Pi is already divided in the light power.
926    * normalization_factor = (shininess + 8.0) / (8.0 * M_PI) */
927   float normalization_factor = shininess * 0.125f + 1.0f;
928   float spec_light = powf(spec_angle, shininess) * max_ff(NL, 0.0f) * normalization_factor;
929
930   /* Simulate Env. light. */
931   float w = wrap * (1.0 - roughness) + roughness;
932   float spec_env = wrapped_lighting(wrapped_NL, w);
933
934   float w2 = wrap * wrap;
935
936   return spec_light * (1.0 - w2) + spec_env * w2;
937 }
938
939 /* Keep in sync with the glsl shader function get_world_lighting() */
940 static void studiolight_lights_eval(StudioLight *sl, float color[3], const float normal[3])
941 {
942   float R[3], I[3] = {0.0f, 0.0f, 1.0f}, N[3] = {normal[0], normal[2], -normal[1]};
943   const float roughness = 0.5f;
944   const float diffuse_color = 0.8f;
945   const float specular_color = brdf_approx(0.05f, roughness, N[2]);
946   float diff_light[3], spec_light[3];
947
948   /* Ambient lighting */
949   copy_v3_v3(diff_light, sl->light_ambient);
950   copy_v3_v3(spec_light, sl->light_ambient);
951
952   reflect_v3_v3v3(R, I, N);
953   for (int i = 0; i < 3; ++i) {
954     SolidLight *light = &sl->light[i];
955     if (light->flag) {
956       /* Diffuse lighting */
957       float NL = dot_v3v3(light->vec, N);
958       float diff = wrapped_lighting(NL, light->smooth);
959       madd_v3_v3fl(diff_light, light->col, diff);
960       /* Specular lighting */
961       float spec = blinn_specular(light->vec, I, N, R, NL, roughness, light->smooth);
962       madd_v3_v3fl(spec_light, light->spec, spec);
963     }
964   }
965
966   /* Multiply result by surface colors. */
967   mul_v3_fl(diff_light, diffuse_color * (1.0 - specular_color));
968   mul_v3_fl(spec_light, specular_color);
969
970   add_v3_v3v3(color, diff_light, spec_light);
971 }
972
973 static bool studiolight_load_irradiance_equirect_image(StudioLight *sl)
974 {
975 #ifdef STUDIOLIGHT_LOAD_CACHED_FILES
976   if (sl->flag & STUDIOLIGHT_EXTERNAL_FILE) {
977     ImBuf *ibuf = NULL;
978     ibuf = IMB_loadiffname(sl->path_irr_cache, 0, NULL);
979     if (ibuf) {
980       IMB_float_from_rect(ibuf);
981       sl->equirect_irradiance_buffer = ibuf;
982       sl->flag |= STUDIOLIGHT_EQUIRECT_IRRADIANCE_IMAGE_CALCULATED;
983       return true;
984     }
985   }
986 #else
987   UNUSED_VARS(sl);
988 #endif
989   return false;
990 }
991
992 static bool studiolight_load_spherical_harmonics_coefficients(StudioLight *sl)
993 {
994 #ifdef STUDIOLIGHT_LOAD_CACHED_FILES
995   if (sl->flag & STUDIOLIGHT_EXTERNAL_FILE) {
996     FILE *fp = BLI_fopen(sl->path_sh_cache, "rb");
997     if (fp) {
998       if (fread((void *)(sl->spherical_harmonics_coefs),
999                 sizeof(sl->spherical_harmonics_coefs),
1000                 1,
1001                 fp)) {
1002         sl->flag |= STUDIOLIGHT_SPHERICAL_HARMONICS_COEFFICIENTS_CALCULATED;
1003         fclose(fp);
1004         return true;
1005       }
1006       fclose(fp);
1007     }
1008   }
1009 #else
1010   UNUSED_VARS(sl);
1011 #endif
1012   return false;
1013 }
1014
1015 static void studiolight_calculate_irradiance_equirect_image(StudioLight *sl)
1016 {
1017   if (sl->flag & STUDIOLIGHT_EXTERNAL_FILE) {
1018 #ifdef STUDIOLIGHT_IRRADIANCE_METHOD_RADIANCE
1019     BKE_studiolight_ensure_flag(sl, STUDIOLIGHT_RADIANCE_BUFFERS_CALCULATED);
1020 #else
1021     BKE_studiolight_ensure_flag(sl, STUDIOLIGHT_SPHERICAL_HARMONICS_COEFFICIENTS_CALCULATED);
1022 #endif
1023
1024     float *colbuf = MEM_mallocN(STUDIOLIGHT_IRRADIANCE_EQUIRECT_WIDTH *
1025                                     STUDIOLIGHT_IRRADIANCE_EQUIRECT_HEIGHT * sizeof(float[4]),
1026                                 __func__);
1027
1028     ITER_PIXELS (float,
1029                  colbuf,
1030                  4,
1031                  STUDIOLIGHT_IRRADIANCE_EQUIRECT_WIDTH,
1032                  STUDIOLIGHT_IRRADIANCE_EQUIRECT_HEIGHT) {
1033       float dir[3];
1034       equirect_to_direction(dir, x, y);
1035 #ifdef STUDIOLIGHT_IRRADIANCE_METHOD_RADIANCE
1036       studiolight_irradiance_eval(sl, pixel, dir);
1037 #else
1038       studiolight_spherical_harmonics_eval(sl, pixel, dir);
1039 #endif
1040       pixel[3] = 1.0f;
1041     }
1042     ITER_PIXELS_END;
1043
1044     sl->equirect_irradiance_buffer = IMB_allocFromBuffer(NULL,
1045                                                          colbuf,
1046                                                          STUDIOLIGHT_IRRADIANCE_EQUIRECT_WIDTH,
1047                                                          STUDIOLIGHT_IRRADIANCE_EQUIRECT_HEIGHT);
1048     MEM_freeN(colbuf);
1049
1050 #ifdef STUDIOLIGHT_IRRADIANCE_METHOD_RADIANCE
1051     /*
1052      * Only store cached files when using STUDIOLIGHT_IRRADIANCE_METHOD_RADIANCE
1053      */
1054     if (sl->flag & STUDIOLIGHT_USER_DEFINED) {
1055       IMB_saveiff(sl->equirect_irradiance_buffer, sl->path_irr_cache, IB_rectfloat);
1056     }
1057 #endif
1058   }
1059   sl->flag |= STUDIOLIGHT_EQUIRECT_IRRADIANCE_IMAGE_CALCULATED;
1060 }
1061
1062 static StudioLight *studiolight_add_file(const char *path, int flag)
1063 {
1064   char filename[FILE_MAXFILE];
1065   BLI_split_file_part(path, filename, FILE_MAXFILE);
1066
1067   if ((((flag & STUDIOLIGHT_TYPE_STUDIO) != 0) && BLI_path_extension_check(filename, ".sl")) ||
1068       BLI_path_extension_check_array(filename, imb_ext_image)) {
1069     StudioLight *sl = studiolight_create(STUDIOLIGHT_EXTERNAL_FILE | flag);
1070     BLI_strncpy(sl->name, filename, FILE_MAXFILE);
1071     BLI_strncpy(sl->path, path, FILE_MAXFILE);
1072
1073     if ((flag & STUDIOLIGHT_TYPE_STUDIO) != 0) {
1074       studiolight_load_solid_light(sl);
1075     }
1076     else {
1077       sl->path_irr_cache = BLI_string_joinN(path, ".irr");
1078       sl->path_sh_cache = BLI_string_joinN(path, ".sh2");
1079     }
1080     BLI_addtail(&studiolights, sl);
1081     return sl;
1082   }
1083   return NULL;
1084 }
1085
1086 static void studiolight_add_files_from_datafolder(const int folder_id,
1087                                                   const char *subfolder,
1088                                                   int flag)
1089 {
1090   struct direntry *dir;
1091   const char *folder = BKE_appdir_folder_id(folder_id, subfolder);
1092   if (folder) {
1093     uint totfile = BLI_filelist_dir_contents(folder, &dir);
1094     int i;
1095     for (i = 0; i < totfile; i++) {
1096       if ((dir[i].type & S_IFREG)) {
1097         studiolight_add_file(dir[i].path, flag);
1098       }
1099     }
1100     BLI_filelist_free(dir, totfile);
1101     dir = NULL;
1102   }
1103 }
1104
1105 static int studiolight_flag_cmp_order(const StudioLight *sl)
1106 {
1107   /* Internal studiolights before external studio lights */
1108   if (sl->flag & STUDIOLIGHT_EXTERNAL_FILE) {
1109     return 1;
1110   }
1111   return 0;
1112 }
1113
1114 static int studiolight_cmp(const void *a, const void *b)
1115 {
1116   const StudioLight *sl1 = a;
1117   const StudioLight *sl2 = b;
1118
1119   const int flagorder1 = studiolight_flag_cmp_order(sl1);
1120   const int flagorder2 = studiolight_flag_cmp_order(sl2);
1121
1122   if (flagorder1 < flagorder2) {
1123     return -1;
1124   }
1125   else if (flagorder1 > flagorder2) {
1126     return 1;
1127   }
1128   else {
1129     return BLI_strcasecmp(sl1->name, sl2->name);
1130   }
1131 }
1132
1133 /* icons */
1134
1135 /* Takes normalized uvs as parameter (range from 0 to 1).
1136  * inner_edge and outer_edge are distances (from the center)
1137  * in uv space for the alpha mask falloff. */
1138 static uint alpha_circle_mask(float u, float v, float inner_edge, float outer_edge)
1139 {
1140   /* Coords from center. */
1141   float co[2] = {u - 0.5f, v - 0.5f};
1142   float dist = len_v2(co);
1143   float alpha = 1.0f + (inner_edge - dist) / (outer_edge - inner_edge);
1144   uint mask = (uint)floorf(255.0f * min_ff(max_ff(alpha, 0.0f), 1.0f));
1145   return mask << 24;
1146 }
1147
1148 /* Percentage of the icon that the preview sphere covers. */
1149 #define STUDIOLIGHT_DIAMETER 0.95f
1150 /* Rescale coord around (0.5, 0.5) by STUDIOLIGHT_DIAMETER. */
1151 #define RESCALE_COORD(x) (x / STUDIOLIGHT_DIAMETER - (1.0f - STUDIOLIGHT_DIAMETER) / 2.0f)
1152
1153 /* Remaps normalized UV [0..1] to a sphere normal around (0.5, 0.5) */
1154 static void sphere_normal_from_uv(float normal[3], float u, float v)
1155 {
1156   normal[0] = u * 2.0f - 1.0f;
1157   normal[1] = v * 2.0f - 1.0f;
1158   float dist = len_v2(normal);
1159   normal[2] = sqrtf(1.0f - SQUARE(dist));
1160 }
1161
1162 static void studiolight_radiance_preview(uint *icon_buffer, StudioLight *sl)
1163 {
1164   BKE_studiolight_ensure_flag(sl, STUDIOLIGHT_EXTERNAL_IMAGE_LOADED);
1165
1166   ITER_PIXELS (uint, icon_buffer, 1, STUDIOLIGHT_ICON_SIZE, STUDIOLIGHT_ICON_SIZE) {
1167     float dy = RESCALE_COORD(y);
1168     float dx = RESCALE_COORD(x);
1169
1170     uint alphamask = alpha_circle_mask(dx, dy, 0.5f - texel_size[0], 0.5f);
1171     if (alphamask != 0) {
1172       float normal[3], direction[3], color[4];
1173       float incoming[3] = {0.0f, 0.0f, -1.0f};
1174       sphere_normal_from_uv(normal, dx, dy);
1175       reflect_v3_v3v3(direction, incoming, normal);
1176       /* We want to see horizon not poles. */
1177       SWAP(float, direction[1], direction[2]);
1178       direction[1] = -direction[1];
1179
1180       studiolight_calculate_radiance(sl->equirect_radiance_buffer, color, direction);
1181
1182       *pixel = rgb_to_cpack(linearrgb_to_srgb(color[0]),
1183                             linearrgb_to_srgb(color[1]),
1184                             linearrgb_to_srgb(color[2])) |
1185                alphamask;
1186     }
1187     else {
1188       *pixel = 0x0;
1189     }
1190   }
1191   ITER_PIXELS_END;
1192 }
1193
1194 static void studiolight_matcap_preview(uint *icon_buffer, StudioLight *sl, bool flipped)
1195 {
1196   BKE_studiolight_ensure_flag(sl, STUDIOLIGHT_EXTERNAL_IMAGE_LOADED);
1197
1198   ImBuf *ibuf = sl->equirect_radiance_buffer;
1199
1200   ITER_PIXELS (uint, icon_buffer, 1, STUDIOLIGHT_ICON_SIZE, STUDIOLIGHT_ICON_SIZE) {
1201     float dy = RESCALE_COORD(y);
1202     float dx = RESCALE_COORD(x);
1203     if (flipped) {
1204       dx = 1.0f - dx;
1205     }
1206
1207     float color[4];
1208     nearest_interpolation_color(ibuf, NULL, color, dx * ibuf->x - 1.0f, dy * ibuf->y - 1.0f);
1209
1210     uint alphamask = alpha_circle_mask(dx, dy, 0.5f - texel_size[0], 0.5f);
1211
1212     *pixel = rgb_to_cpack(linearrgb_to_srgb(color[0]),
1213                           linearrgb_to_srgb(color[1]),
1214                           linearrgb_to_srgb(color[2])) |
1215              alphamask;
1216   }
1217   ITER_PIXELS_END;
1218 }
1219
1220 static void studiolight_irradiance_preview(uint *icon_buffer, StudioLight *sl)
1221 {
1222   ITER_PIXELS (uint, icon_buffer, 1, STUDIOLIGHT_ICON_SIZE, STUDIOLIGHT_ICON_SIZE) {
1223     float dy = RESCALE_COORD(y);
1224     float dx = RESCALE_COORD(x);
1225
1226     uint alphamask = alpha_circle_mask(dx, dy, 0.5f - texel_size[0], 0.5f);
1227     if (alphamask != 0) {
1228       float normal[3], color[3];
1229       sphere_normal_from_uv(normal, dx, dy);
1230       /* We want to see horizon not poles. */
1231       SWAP(float, normal[1], normal[2]);
1232       normal[1] = -normal[1];
1233
1234       studiolight_lights_eval(sl, color, normal);
1235
1236       *pixel = rgb_to_cpack(linearrgb_to_srgb(color[0]),
1237                             linearrgb_to_srgb(color[1]),
1238                             linearrgb_to_srgb(color[2])) |
1239                alphamask;
1240     }
1241     else {
1242       *pixel = 0x0;
1243     }
1244   }
1245   ITER_PIXELS_END;
1246 }
1247
1248 /* API */
1249 void BKE_studiolight_init(void)
1250 {
1251   /* Add default studio light */
1252   StudioLight *sl = studiolight_create(STUDIOLIGHT_INTERNAL |
1253                                        STUDIOLIGHT_SPHERICAL_HARMONICS_COEFFICIENTS_CALCULATED |
1254                                        STUDIOLIGHT_TYPE_STUDIO);
1255   BLI_strncpy(sl->name, "Default", FILE_MAXFILE);
1256
1257   copy_v3_fl3(sl->light_ambient, 0.025000, 0.025000, 0.025000);
1258
1259   copy_v4_fl4(sl->light[0].vec, -0.580952, 0.228571, 0.781185, 0.0);
1260   copy_v4_fl4(sl->light[0].col, 0.900000, 0.900000, 0.900000, 1.000000);
1261   copy_v4_fl4(sl->light[0].spec, 0.318547, 0.318547, 0.318547, 1.000000);
1262   sl->light[0].flag = 1;
1263   sl->light[0].smooth = 0.1;
1264
1265   copy_v4_fl4(sl->light[1].vec, 0.788218, 0.593482, -0.162765, 0.0);
1266   copy_v4_fl4(sl->light[1].col, 0.267115, 0.269928, 0.358840, 1.000000);
1267   copy_v4_fl4(sl->light[1].spec, 0.090838, 0.090838, 0.090838, 1.000000);
1268   sl->light[1].flag = 1;
1269   sl->light[1].smooth = 0.25;
1270
1271   copy_v4_fl4(sl->light[2].vec, 0.696472, -0.696472, -0.172785, 0.0);
1272   copy_v4_fl4(sl->light[2].col, 0.293216, 0.304662, 0.401968, 1.000000);
1273   copy_v4_fl4(sl->light[2].spec, 0.069399, 0.020331, 0.020331, 1.000000);
1274   sl->light[2].flag = 1;
1275   sl->light[2].smooth = 0.5;
1276
1277   copy_v4_fl4(sl->light[3].vec, 0.021053, -0.989474, 0.143173, 0.0);
1278   copy_v4_fl4(sl->light[3].col, 0.0, 0.0, 0.0, 1.0);
1279   copy_v4_fl4(sl->light[3].spec, 0.072234, 0.082253, 0.162642, 1.000000);
1280   sl->light[3].flag = 1;
1281   sl->light[3].smooth = 0.7;
1282
1283   BLI_addtail(&studiolights, sl);
1284
1285   /* go over the preset folder and add a studiolight for every image with its path */
1286   /* for portable installs (where USER and SYSTEM paths are the same), only go over LOCAL datafiles once */
1287   /* Also reserve icon space for it. */
1288   if (!BKE_appdir_app_is_portable_install()) {
1289     studiolight_add_files_from_datafolder(BLENDER_USER_DATAFILES,
1290                                           STUDIOLIGHT_LIGHTS_FOLDER,
1291                                           STUDIOLIGHT_TYPE_STUDIO | STUDIOLIGHT_USER_DEFINED);
1292     studiolight_add_files_from_datafolder(BLENDER_USER_DATAFILES,
1293                                           STUDIOLIGHT_WORLD_FOLDER,
1294                                           STUDIOLIGHT_TYPE_WORLD | STUDIOLIGHT_USER_DEFINED);
1295     studiolight_add_files_from_datafolder(BLENDER_USER_DATAFILES,
1296                                           STUDIOLIGHT_MATCAP_FOLDER,
1297                                           STUDIOLIGHT_TYPE_MATCAP | STUDIOLIGHT_USER_DEFINED);
1298   }
1299   studiolight_add_files_from_datafolder(
1300       BLENDER_SYSTEM_DATAFILES, STUDIOLIGHT_LIGHTS_FOLDER, STUDIOLIGHT_TYPE_STUDIO);
1301   studiolight_add_files_from_datafolder(
1302       BLENDER_SYSTEM_DATAFILES, STUDIOLIGHT_WORLD_FOLDER, STUDIOLIGHT_TYPE_WORLD);
1303   studiolight_add_files_from_datafolder(
1304       BLENDER_SYSTEM_DATAFILES, STUDIOLIGHT_MATCAP_FOLDER, STUDIOLIGHT_TYPE_MATCAP);
1305
1306   /* sort studio lights on filename. */
1307   BLI_listbase_sort(&studiolights, studiolight_cmp);
1308 }
1309
1310 void BKE_studiolight_free(void)
1311 {
1312   struct StudioLight *sl;
1313   while ((sl = BLI_pophead(&studiolights))) {
1314     studiolight_free(sl);
1315   }
1316 }
1317
1318 struct StudioLight *BKE_studiolight_find_default(int flag)
1319 {
1320   const char *default_name = "";
1321
1322   if (flag & STUDIOLIGHT_TYPE_WORLD) {
1323     default_name = STUDIOLIGHT_WORLD_DEFAULT;
1324   }
1325   else if (flag & STUDIOLIGHT_TYPE_MATCAP) {
1326     default_name = STUDIOLIGHT_MATCAP_DEFAULT;
1327   }
1328
1329   LISTBASE_FOREACH (StudioLight *, sl, &studiolights) {
1330     if ((sl->flag & flag) && STREQ(sl->name, default_name)) {
1331       return sl;
1332     }
1333   }
1334
1335   LISTBASE_FOREACH (StudioLight *, sl, &studiolights) {
1336     if ((sl->flag & flag)) {
1337       return sl;
1338     }
1339   }
1340   return NULL;
1341 }
1342
1343 struct StudioLight *BKE_studiolight_find(const char *name, int flag)
1344 {
1345   LISTBASE_FOREACH (StudioLight *, sl, &studiolights) {
1346     if (STREQLEN(sl->name, name, FILE_MAXFILE)) {
1347       if ((sl->flag & flag)) {
1348         return sl;
1349       }
1350       else {
1351         /* flags do not match, so use default */
1352         return BKE_studiolight_find_default(flag);
1353       }
1354     }
1355   }
1356   /* When not found, use the default studio light */
1357   return BKE_studiolight_find_default(flag);
1358 }
1359
1360 struct StudioLight *BKE_studiolight_findindex(int index, int flag)
1361 {
1362   LISTBASE_FOREACH (StudioLight *, sl, &studiolights) {
1363     if (sl->index == index) {
1364       return sl;
1365     }
1366   }
1367   /* When not found, use the default studio light */
1368   return BKE_studiolight_find_default(flag);
1369 }
1370
1371 struct ListBase *BKE_studiolight_listbase(void)
1372 {
1373   return &studiolights;
1374 }
1375
1376 void BKE_studiolight_preview(uint *icon_buffer, StudioLight *sl, int icon_id_type)
1377 {
1378   switch (icon_id_type) {
1379     case STUDIOLIGHT_ICON_ID_TYPE_RADIANCE:
1380     default: {
1381       studiolight_radiance_preview(icon_buffer, sl);
1382       break;
1383     }
1384     case STUDIOLIGHT_ICON_ID_TYPE_IRRADIANCE: {
1385       studiolight_irradiance_preview(icon_buffer, sl);
1386       break;
1387     }
1388     case STUDIOLIGHT_ICON_ID_TYPE_MATCAP: {
1389       studiolight_matcap_preview(icon_buffer, sl, false);
1390       break;
1391     }
1392     case STUDIOLIGHT_ICON_ID_TYPE_MATCAP_FLIPPED: {
1393       studiolight_matcap_preview(icon_buffer, sl, true);
1394       break;
1395     }
1396   }
1397 }
1398
1399 /* Ensure state of Studiolights */
1400 void BKE_studiolight_ensure_flag(StudioLight *sl, int flag)
1401 {
1402   if ((sl->flag & flag) == flag) {
1403     return;
1404   }
1405
1406   if ((flag & STUDIOLIGHT_EXTERNAL_IMAGE_LOADED)) {
1407     studiolight_load_equirect_image(sl);
1408   }
1409   if ((flag & STUDIOLIGHT_RADIANCE_BUFFERS_CALCULATED)) {
1410     studiolight_calculate_radiance_cubemap_buffers(sl);
1411   }
1412   if ((flag & STUDIOLIGHT_SPHERICAL_HARMONICS_COEFFICIENTS_CALCULATED)) {
1413     if (!studiolight_load_spherical_harmonics_coefficients(sl)) {
1414       studiolight_calculate_diffuse_light(sl);
1415     }
1416   }
1417   if ((flag & STUDIOLIGHT_EQUIRECT_RADIANCE_GPUTEXTURE)) {
1418     studiolight_create_equirect_radiance_gputexture(sl);
1419   }
1420   if ((flag & STUDIOLIGHT_EQUIRECT_IRRADIANCE_GPUTEXTURE)) {
1421     studiolight_create_equirect_irradiance_gputexture(sl);
1422   }
1423   if ((flag & STUDIOLIGHT_EQUIRECT_IRRADIANCE_IMAGE_CALCULATED)) {
1424     if (!studiolight_load_irradiance_equirect_image(sl)) {
1425       studiolight_calculate_irradiance_equirect_image(sl);
1426     }
1427   }
1428 }
1429
1430 /*
1431  * Python API Functions
1432  */
1433 void BKE_studiolight_remove(StudioLight *sl)
1434 {
1435   if (sl->flag & STUDIOLIGHT_USER_DEFINED) {
1436     BLI_remlink(&studiolights, sl);
1437     studiolight_free(sl);
1438   }
1439 }
1440
1441 StudioLight *BKE_studiolight_load(const char *path, int type)
1442 {
1443   StudioLight *sl = studiolight_add_file(path, type | STUDIOLIGHT_USER_DEFINED);
1444   return sl;
1445 }
1446
1447 StudioLight *BKE_studiolight_create(const char *path,
1448                                     const SolidLight light[4],
1449                                     const float light_ambient[3])
1450 {
1451   StudioLight *sl = studiolight_create(STUDIOLIGHT_EXTERNAL_FILE | STUDIOLIGHT_USER_DEFINED |
1452                                        STUDIOLIGHT_TYPE_STUDIO);
1453
1454   char filename[FILE_MAXFILE];
1455   BLI_split_file_part(path, filename, FILE_MAXFILE);
1456   STRNCPY(sl->path, path);
1457   STRNCPY(sl->name, filename);
1458
1459   memcpy(sl->light, light, sizeof(*light) * 4);
1460   memcpy(sl->light_ambient, light_ambient, sizeof(*light_ambient) * 3);
1461
1462   studiolight_write_solid_light(sl);
1463
1464   BLI_addtail(&studiolights, sl);
1465   return sl;
1466 }
1467
1468 /* Only useful for workbench while editing the userprefs. */
1469 StudioLight *BKE_studiolight_studio_edit_get(void)
1470 {
1471   static StudioLight sl = {0};
1472   sl.flag = STUDIOLIGHT_TYPE_STUDIO;
1473
1474   memcpy(sl.light, U.light_param, sizeof(*sl.light) * 4);
1475   memcpy(sl.light_ambient, U.light_ambient, sizeof(*sl.light_ambient) * 3);
1476
1477   return &sl;
1478 }
1479
1480 void BKE_studiolight_refresh(void)
1481 {
1482   BKE_studiolight_free();
1483   BKE_studiolight_init();
1484 }
1485
1486 void BKE_studiolight_set_free_function(StudioLight *sl,
1487                                        StudioLightFreeFunction *free_function,
1488                                        void *data)
1489 {
1490   sl->free_function = free_function;
1491   sl->free_function_data = data;
1492 }
1493
1494 void BKE_studiolight_unset_icon_id(StudioLight *sl, int icon_id)
1495 {
1496   BLI_assert(sl != NULL);
1497   if (sl->icon_id_radiance == icon_id) {
1498     sl->icon_id_radiance = 0;
1499   }
1500   if (sl->icon_id_irradiance == icon_id) {
1501     sl->icon_id_irradiance = 0;
1502   }
1503   if (sl->icon_id_matcap == icon_id) {
1504     sl->icon_id_matcap = 0;
1505   }
1506   if (sl->icon_id_matcap_flipped == icon_id) {
1507     sl->icon_id_matcap_flipped = 0;
1508   }
1509 }