Cleanup: style, use braces for render
[blender.git] / source / blender / render / intern / source / multires_bake.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) 2012 by Blender Foundation
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup render
22  */
23
24 #include <string.h>
25
26 #include "MEM_guardedalloc.h"
27
28 #include "DNA_object_types.h"
29 #include "DNA_mesh_types.h"
30 #include "DNA_scene_types.h"
31
32 #include "BLI_math.h"
33 #include "BLI_listbase.h"
34 #include "BLI_threads.h"
35
36 #include "BKE_ccg.h"
37 #include "BKE_global.h"
38 #include "BKE_image.h"
39 #include "BKE_material.h"
40 #include "BKE_mesh.h"
41 #include "BKE_multires.h"
42 #include "BKE_modifier.h"
43 #include "BKE_subsurf.h"
44
45 #include "DEG_depsgraph.h"
46
47 #include "RE_multires_bake.h"
48 #include "RE_pipeline.h"
49 #include "RE_shader_ext.h"
50
51 #include "IMB_imbuf_types.h"
52 #include "IMB_imbuf.h"
53
54 typedef void (*MPassKnownData)(DerivedMesh *lores_dm,
55                                DerivedMesh *hires_dm,
56                                void *thread_data,
57                                void *bake_data,
58                                ImBuf *ibuf,
59                                const int face_index,
60                                const int lvl,
61                                const float st[2],
62                                float tangmat[3][3],
63                                const int x,
64                                const int y);
65
66 typedef void *(*MInitBakeData)(MultiresBakeRender *bkr, Image *ima);
67 typedef void (*MFreeBakeData)(void *bake_data);
68
69 typedef struct MultiresBakeResult {
70   float height_min, height_max;
71 } MultiresBakeResult;
72
73 typedef struct {
74   MVert *mvert;
75   MPoly *mpoly;
76   MLoop *mloop;
77   MLoopUV *mloopuv;
78   const MLoopTri *mlooptri;
79   float *pvtangent;
80   const float *precomputed_normals;
81   int w, h;
82   int tri_index;
83   DerivedMesh *lores_dm, *hires_dm;
84   int lvl;
85   void *thread_data;
86   void *bake_data;
87   ImBuf *ibuf;
88   MPassKnownData pass_data;
89   /* material aligned UV array */
90   Image **image_array;
91 } MResolvePixelData;
92
93 typedef void (*MFlushPixel)(const MResolvePixelData *data, const int x, const int y);
94
95 typedef struct {
96   int w, h;
97   char *texels;
98   const MResolvePixelData *data;
99   MFlushPixel flush_pixel;
100   short *do_update;
101 } MBakeRast;
102
103 typedef struct {
104   float *heights;
105   Image *ima;
106   DerivedMesh *ssdm;
107   const int *orig_index_mp_to_orig;
108 } MHeightBakeData;
109
110 typedef struct {
111   const int *orig_index_mp_to_orig;
112 } MNormalBakeData;
113
114 static void multiresbake_get_normal(const MResolvePixelData *data,
115                                     float norm[],
116                                     const int tri_num,
117                                     const int vert_index)
118 {
119   const int poly_index = data->mlooptri[tri_num].poly;
120   const MPoly *mp = &data->mpoly[poly_index];
121   const bool smoothnormal = (mp->flag & ME_SMOOTH) != 0;
122
123   if (!smoothnormal) { /* flat */
124     if (data->precomputed_normals) {
125       copy_v3_v3(norm, &data->precomputed_normals[poly_index]);
126     }
127     else {
128       BKE_mesh_calc_poly_normal(mp, &data->mloop[mp->loopstart], data->mvert, norm);
129     }
130   }
131   else {
132     const int vi = data->mloop[data->mlooptri[tri_num].tri[vert_index]].v;
133     const short *no = data->mvert[vi].no;
134
135     normal_short_to_float_v3(norm, no);
136     normalize_v3(norm);
137   }
138 }
139
140 static void init_bake_rast(MBakeRast *bake_rast,
141                            const ImBuf *ibuf,
142                            const MResolvePixelData *data,
143                            MFlushPixel flush_pixel,
144                            short *do_update)
145 {
146   BakeImBufuserData *userdata = (BakeImBufuserData *)ibuf->userdata;
147
148   memset(bake_rast, 0, sizeof(MBakeRast));
149
150   bake_rast->texels = userdata->mask_buffer;
151   bake_rast->w = ibuf->x;
152   bake_rast->h = ibuf->y;
153   bake_rast->data = data;
154   bake_rast->flush_pixel = flush_pixel;
155   bake_rast->do_update = do_update;
156 }
157
158 static void flush_pixel(const MResolvePixelData *data, const int x, const int y)
159 {
160   float st[2] = {(x + 0.5f) / data->w, (y + 0.5f) / data->h};
161   const float *st0, *st1, *st2;
162   const float *tang0, *tang1, *tang2;
163   float no0[3], no1[3], no2[3];
164   float fUV[2], from_tang[3][3], to_tang[3][3];
165   float u, v, w, sign;
166   int r;
167
168   st0 = data->mloopuv[data->mlooptri[data->tri_index].tri[0]].uv;
169   st1 = data->mloopuv[data->mlooptri[data->tri_index].tri[1]].uv;
170   st2 = data->mloopuv[data->mlooptri[data->tri_index].tri[2]].uv;
171
172   multiresbake_get_normal(data, no0, data->tri_index, 0); /* can optimize these 3 into one call */
173   multiresbake_get_normal(data, no1, data->tri_index, 1);
174   multiresbake_get_normal(data, no2, data->tri_index, 2);
175
176   resolve_tri_uv_v2(fUV, st, st0, st1, st2);
177
178   u = fUV[0];
179   v = fUV[1];
180   w = 1 - u - v;
181
182   if (data->pvtangent) {
183     tang0 = data->pvtangent + data->mlooptri[data->tri_index].tri[0] * 4;
184     tang1 = data->pvtangent + data->mlooptri[data->tri_index].tri[1] * 4;
185     tang2 = data->pvtangent + data->mlooptri[data->tri_index].tri[2] * 4;
186
187     /* the sign is the same at all face vertices for any non degenerate face.
188      * Just in case we clamp the interpolated value though. */
189     sign = (tang0[3] * u + tang1[3] * v + tang2[3] * w) < 0 ? (-1.0f) : 1.0f;
190
191     /* this sequence of math is designed specifically as is with great care
192      * to be compatible with our shader. Please don't change without good reason. */
193     for (r = 0; r < 3; r++) {
194       from_tang[0][r] = tang0[r] * u + tang1[r] * v + tang2[r] * w;
195       from_tang[2][r] = no0[r] * u + no1[r] * v + no2[r] * w;
196     }
197
198     cross_v3_v3v3(from_tang[1], from_tang[2], from_tang[0]); /* B = sign * cross(N, T)  */
199     mul_v3_fl(from_tang[1], sign);
200     invert_m3_m3(to_tang, from_tang);
201   }
202   else {
203     zero_m3(to_tang);
204   }
205
206   data->pass_data(data->lores_dm,
207                   data->hires_dm,
208                   data->thread_data,
209                   data->bake_data,
210                   data->ibuf,
211                   data->tri_index,
212                   data->lvl,
213                   st,
214                   to_tang,
215                   x,
216                   y);
217 }
218
219 static void set_rast_triangle(const MBakeRast *bake_rast, const int x, const int y)
220 {
221   const int w = bake_rast->w;
222   const int h = bake_rast->h;
223
224   if (x >= 0 && x < w && y >= 0 && y < h) {
225     if ((bake_rast->texels[y * w + x]) == 0) {
226       bake_rast->texels[y * w + x] = FILTER_MASK_USED;
227       flush_pixel(bake_rast->data, x, y);
228       if (bake_rast->do_update) {
229         *bake_rast->do_update = true;
230       }
231     }
232   }
233 }
234
235 static void rasterize_half(const MBakeRast *bake_rast,
236                            const float s0_s,
237                            const float t0_s,
238                            const float s1_s,
239                            const float t1_s,
240                            const float s0_l,
241                            const float t0_l,
242                            const float s1_l,
243                            const float t1_l,
244                            const int y0_in,
245                            const int y1_in,
246                            const int is_mid_right)
247 {
248   const int s_stable = fabsf(t1_s - t0_s) > FLT_EPSILON ? 1 : 0;
249   const int l_stable = fabsf(t1_l - t0_l) > FLT_EPSILON ? 1 : 0;
250   const int w = bake_rast->w;
251   const int h = bake_rast->h;
252   int y, y0, y1;
253
254   if (y1_in <= 0 || y0_in >= h) {
255     return;
256   }
257
258   y0 = y0_in < 0 ? 0 : y0_in;
259   y1 = y1_in >= h ? h : y1_in;
260
261   for (y = y0; y < y1; y++) {
262     /*-b(x-x0) + a(y-y0) = 0 */
263     int iXl, iXr, x;
264     float x_l = s_stable != 0 ? (s0_s + (((s1_s - s0_s) * (y - t0_s)) / (t1_s - t0_s))) : s0_s;
265     float x_r = l_stable != 0 ? (s0_l + (((s1_l - s0_l) * (y - t0_l)) / (t1_l - t0_l))) : s0_l;
266
267     if (is_mid_right != 0) {
268       SWAP(float, x_l, x_r);
269     }
270
271     iXl = (int)ceilf(x_l);
272     iXr = (int)ceilf(x_r);
273
274     if (iXr > 0 && iXl < w) {
275       iXl = iXl < 0 ? 0 : iXl;
276       iXr = iXr >= w ? w : iXr;
277
278       for (x = iXl; x < iXr; x++) {
279         set_rast_triangle(bake_rast, x, y);
280       }
281     }
282   }
283 }
284
285 static void bake_rasterize(const MBakeRast *bake_rast,
286                            const float st0_in[2],
287                            const float st1_in[2],
288                            const float st2_in[2])
289 {
290   const int w = bake_rast->w;
291   const int h = bake_rast->h;
292   float slo = st0_in[0] * w - 0.5f;
293   float tlo = st0_in[1] * h - 0.5f;
294   float smi = st1_in[0] * w - 0.5f;
295   float tmi = st1_in[1] * h - 0.5f;
296   float shi = st2_in[0] * w - 0.5f;
297   float thi = st2_in[1] * h - 0.5f;
298   int is_mid_right = 0, ylo, yhi, yhi_beg;
299
300   /* skip degenerates */
301   if ((slo == smi && tlo == tmi) || (slo == shi && tlo == thi) || (smi == shi && tmi == thi)) {
302     return;
303   }
304
305   /* sort by T */
306   if (tlo > tmi && tlo > thi) {
307     SWAP(float, shi, slo);
308     SWAP(float, thi, tlo);
309   }
310   else if (tmi > thi) {
311     SWAP(float, shi, smi);
312     SWAP(float, thi, tmi);
313   }
314
315   if (tlo > tmi) {
316     SWAP(float, slo, smi);
317     SWAP(float, tlo, tmi);
318   }
319
320   /* check if mid point is to the left or to the right of the lo-hi edge */
321   is_mid_right = (-(shi - slo) * (tmi - thi) + (thi - tlo) * (smi - shi)) > 0 ? 1 : 0;
322   ylo = (int)ceilf(tlo);
323   yhi_beg = (int)ceilf(tmi);
324   yhi = (int)ceilf(thi);
325
326   /*if (fTmi>ceilf(fTlo))*/
327   rasterize_half(bake_rast, slo, tlo, smi, tmi, slo, tlo, shi, thi, ylo, yhi_beg, is_mid_right);
328   rasterize_half(bake_rast, smi, tmi, shi, thi, slo, tlo, shi, thi, yhi_beg, yhi, is_mid_right);
329 }
330
331 static int multiresbake_test_break(MultiresBakeRender *bkr)
332 {
333   if (!bkr->stop) {
334     /* this means baker is executed outside from job system */
335     return 0;
336   }
337
338   return *bkr->stop || G.is_break;
339 }
340
341 /* **** Threading routines **** */
342
343 typedef struct MultiresBakeQueue {
344   int cur_tri;
345   int tot_tri;
346   SpinLock spin;
347 } MultiresBakeQueue;
348
349 typedef struct MultiresBakeThread {
350   /* this data is actually shared between all the threads */
351   MultiresBakeQueue *queue;
352   MultiresBakeRender *bkr;
353   Image *image;
354   void *bake_data;
355
356   /* thread-specific data */
357   MBakeRast bake_rast;
358   MResolvePixelData data;
359
360   /* displacement-specific data */
361   float height_min, height_max;
362 } MultiresBakeThread;
363
364 static int multires_bake_queue_next_tri(MultiresBakeQueue *queue)
365 {
366   int face = -1;
367
368   /* TODO: it could worth making it so thread will handle neighbor faces
369    *       for better memory cache utilization
370    */
371
372   BLI_spin_lock(&queue->spin);
373   if (queue->cur_tri < queue->tot_tri) {
374     face = queue->cur_tri;
375     queue->cur_tri++;
376   }
377   BLI_spin_unlock(&queue->spin);
378
379   return face;
380 }
381
382 static void *do_multires_bake_thread(void *data_v)
383 {
384   MultiresBakeThread *handle = (MultiresBakeThread *)data_v;
385   MResolvePixelData *data = &handle->data;
386   MBakeRast *bake_rast = &handle->bake_rast;
387   MultiresBakeRender *bkr = handle->bkr;
388   int tri_index;
389
390   while ((tri_index = multires_bake_queue_next_tri(handle->queue)) >= 0) {
391     const MLoopTri *lt = &data->mlooptri[tri_index];
392     const MPoly *mp = &data->mpoly[lt->poly];
393     const short mat_nr = mp->mat_nr;
394     const MLoopUV *mloopuv = data->mloopuv;
395
396     if (multiresbake_test_break(bkr)) {
397       break;
398     }
399
400     Image *tri_image = mat_nr < bkr->ob_image.len ? bkr->ob_image.array[mat_nr] : NULL;
401     if (tri_image != handle->image) {
402       continue;
403     }
404
405     data->tri_index = tri_index;
406
407     bake_rasterize(
408         bake_rast, mloopuv[lt->tri[0]].uv, mloopuv[lt->tri[1]].uv, mloopuv[lt->tri[2]].uv);
409
410     /* tag image buffer for refresh */
411     if (data->ibuf->rect_float) {
412       data->ibuf->userflags |= IB_RECT_INVALID;
413     }
414
415     data->ibuf->userflags |= IB_DISPLAY_BUFFER_INVALID;
416
417     /* update progress */
418     BLI_spin_lock(&handle->queue->spin);
419     bkr->baked_faces++;
420
421     if (bkr->do_update) {
422       *bkr->do_update = true;
423     }
424
425     if (bkr->progress) {
426       *bkr->progress = ((float)bkr->baked_objects +
427                         (float)bkr->baked_faces / handle->queue->tot_tri) /
428                        bkr->tot_obj;
429     }
430     BLI_spin_unlock(&handle->queue->spin);
431   }
432
433   return NULL;
434 }
435
436 /* some of arrays inside ccgdm are lazy-initialized, which will generally
437  * require lock around accessing such data
438  * this function will ensure all arrays are allocated before threading started
439  */
440 static void init_ccgdm_arrays(DerivedMesh *dm)
441 {
442   CCGElem **grid_data;
443   CCGKey key;
444   int grid_size;
445   const int *grid_offset;
446
447   grid_size = dm->getGridSize(dm);
448   grid_data = dm->getGridData(dm);
449   grid_offset = dm->getGridOffset(dm);
450   dm->getGridKey(dm, &key);
451
452   (void)grid_size;
453   (void)grid_data;
454   (void)grid_offset;
455 }
456
457 static void do_multires_bake(MultiresBakeRender *bkr,
458                              Image *ima,
459                              bool require_tangent,
460                              MPassKnownData passKnownData,
461                              MInitBakeData initBakeData,
462                              MFreeBakeData freeBakeData,
463                              MultiresBakeResult *result)
464 {
465   DerivedMesh *dm = bkr->lores_dm;
466   const MLoopTri *mlooptri = dm->getLoopTriArray(dm);
467   const int lvl = bkr->lvl;
468   int tot_tri = dm->getNumLoopTri(dm);
469
470   if (tot_tri > 0) {
471     MultiresBakeThread *handles;
472     MultiresBakeQueue queue;
473
474     ImBuf *ibuf = BKE_image_acquire_ibuf(ima, NULL, NULL);
475     MVert *mvert = dm->getVertArray(dm);
476     MPoly *mpoly = dm->getPolyArray(dm);
477     MLoop *mloop = dm->getLoopArray(dm);
478     MLoopUV *mloopuv = dm->getLoopDataArray(dm, CD_MLOOPUV);
479     const float *precomputed_normals = dm->getPolyDataArray(dm, CD_NORMAL);
480     float *pvtangent = NULL;
481
482     ListBase threads;
483     int i, tot_thread = bkr->threads > 0 ? bkr->threads : BLI_system_thread_count();
484
485     void *bake_data = NULL;
486
487     if (require_tangent) {
488       if (CustomData_get_layer_index(&dm->loopData, CD_TANGENT) == -1) {
489         DM_calc_loop_tangents(dm, true, NULL, 0);
490       }
491
492       pvtangent = DM_get_loop_data_layer(dm, CD_TANGENT);
493     }
494
495     /* all threads shares the same custom bake data */
496     if (initBakeData) {
497       bake_data = initBakeData(bkr, ima);
498     }
499
500     if (tot_thread > 1) {
501       BLI_threadpool_init(&threads, do_multires_bake_thread, tot_thread);
502     }
503
504     handles = MEM_callocN(tot_thread * sizeof(MultiresBakeThread), "do_multires_bake handles");
505
506     init_ccgdm_arrays(bkr->hires_dm);
507
508     /* faces queue */
509     queue.cur_tri = 0;
510     queue.tot_tri = tot_tri;
511     BLI_spin_init(&queue.spin);
512
513     /* fill in threads handles */
514     for (i = 0; i < tot_thread; i++) {
515       MultiresBakeThread *handle = &handles[i];
516
517       handle->bkr = bkr;
518       handle->image = ima;
519       handle->queue = &queue;
520
521       handle->data.mpoly = mpoly;
522       handle->data.mvert = mvert;
523       handle->data.mloopuv = mloopuv;
524       handle->data.mlooptri = mlooptri;
525       handle->data.mloop = mloop;
526       handle->data.pvtangent = pvtangent;
527       handle->data.precomputed_normals = precomputed_normals; /* don't strictly need this */
528       handle->data.w = ibuf->x;
529       handle->data.h = ibuf->y;
530       handle->data.lores_dm = dm;
531       handle->data.hires_dm = bkr->hires_dm;
532       handle->data.lvl = lvl;
533       handle->data.pass_data = passKnownData;
534       handle->data.thread_data = handle;
535       handle->data.bake_data = bake_data;
536       handle->data.ibuf = ibuf;
537
538       handle->height_min = FLT_MAX;
539       handle->height_max = -FLT_MAX;
540
541       init_bake_rast(&handle->bake_rast, ibuf, &handle->data, flush_pixel, bkr->do_update);
542
543       if (tot_thread > 1) {
544         BLI_threadpool_insert(&threads, handle);
545       }
546     }
547
548     /* run threads */
549     if (tot_thread > 1) {
550       BLI_threadpool_end(&threads);
551     }
552     else {
553       do_multires_bake_thread(&handles[0]);
554     }
555
556     /* construct bake result */
557     result->height_min = handles[0].height_min;
558     result->height_max = handles[0].height_max;
559
560     for (i = 1; i < tot_thread; i++) {
561       result->height_min = min_ff(result->height_min, handles[i].height_min);
562       result->height_max = max_ff(result->height_max, handles[i].height_max);
563     }
564
565     BLI_spin_end(&queue.spin);
566
567     /* finalize baking */
568     if (freeBakeData) {
569       freeBakeData(bake_data);
570     }
571
572     MEM_freeN(handles);
573
574     BKE_image_release_ibuf(ima, ibuf, NULL);
575   }
576 }
577
578 /* mode = 0: interpolate normals,
579  * mode = 1: interpolate coord */
580 static void interp_bilinear_grid(
581     CCGKey *key, CCGElem *grid, float crn_x, float crn_y, int mode, float res[3])
582 {
583   int x0, x1, y0, y1;
584   float u, v;
585   float data[4][3];
586
587   x0 = (int)crn_x;
588   x1 = x0 >= (key->grid_size - 1) ? (key->grid_size - 1) : (x0 + 1);
589
590   y0 = (int)crn_y;
591   y1 = y0 >= (key->grid_size - 1) ? (key->grid_size - 1) : (y0 + 1);
592
593   u = crn_x - x0;
594   v = crn_y - y0;
595
596   if (mode == 0) {
597     copy_v3_v3(data[0], CCG_grid_elem_no(key, grid, x0, y0));
598     copy_v3_v3(data[1], CCG_grid_elem_no(key, grid, x1, y0));
599     copy_v3_v3(data[2], CCG_grid_elem_no(key, grid, x1, y1));
600     copy_v3_v3(data[3], CCG_grid_elem_no(key, grid, x0, y1));
601   }
602   else {
603     copy_v3_v3(data[0], CCG_grid_elem_co(key, grid, x0, y0));
604     copy_v3_v3(data[1], CCG_grid_elem_co(key, grid, x1, y0));
605     copy_v3_v3(data[2], CCG_grid_elem_co(key, grid, x1, y1));
606     copy_v3_v3(data[3], CCG_grid_elem_co(key, grid, x0, y1));
607   }
608
609   interp_bilinear_quad_v3(data, u, v, res);
610 }
611
612 static void get_ccgdm_data(DerivedMesh *lodm,
613                            DerivedMesh *hidm,
614                            const int *index_mp_to_orig,
615                            const int lvl,
616                            const MLoopTri *lt,
617                            const float u,
618                            const float v,
619                            float co[3],
620                            float n[3])
621 {
622   CCGElem **grid_data;
623   CCGKey key;
624   float crn_x, crn_y;
625   int grid_size, S, face_side;
626   int *grid_offset, g_index;
627   int poly_index = lt->poly;
628
629   grid_size = hidm->getGridSize(hidm);
630   grid_data = hidm->getGridData(hidm);
631   grid_offset = hidm->getGridOffset(hidm);
632   hidm->getGridKey(hidm, &key);
633
634   if (lvl == 0) {
635     MPoly *mpoly;
636     face_side = (grid_size << 1) - 1;
637
638     mpoly = lodm->getPolyArray(lodm) + poly_index;
639     g_index = grid_offset[poly_index];
640     S = mdisp_rot_face_to_crn(lodm->getVertArray(lodm),
641                               mpoly,
642                               lodm->getLoopArray(lodm),
643                               lt,
644                               face_side,
645                               u * (face_side - 1),
646                               v * (face_side - 1),
647                               &crn_x,
648                               &crn_y);
649   }
650   else {
651     /* number of faces per grid side */
652     int polys_per_grid_side = (1 << (lvl - 1));
653     /* get the original cage face index */
654     int cage_face_index = index_mp_to_orig ? index_mp_to_orig[poly_index] : poly_index;
655     /* local offset in total cage face grids
656      * (1 << (2 * lvl)) is number of all polys for one cage face */
657     int loc_cage_poly_offs = poly_index % (1 << (2 * lvl));
658     /* local offset in the vertex grid itself */
659     int cell_index = loc_cage_poly_offs % (polys_per_grid_side * polys_per_grid_side);
660     int cell_side = (grid_size - 1) / polys_per_grid_side;
661     /* row and column based on grid side */
662     int row = cell_index / polys_per_grid_side;
663     int col = cell_index % polys_per_grid_side;
664
665     /* S is the vertex whose grid we are examining */
666     S = poly_index / (1 << (2 * (lvl - 1))) - grid_offset[cage_face_index];
667     /* get offset of grid data for original cage face */
668     g_index = grid_offset[cage_face_index];
669
670     crn_y = (row * cell_side) + u * cell_side;
671     crn_x = (col * cell_side) + v * cell_side;
672   }
673
674   CLAMP(crn_x, 0.0f, grid_size);
675   CLAMP(crn_y, 0.0f, grid_size);
676
677   if (n != NULL) {
678     interp_bilinear_grid(&key, grid_data[g_index + S], crn_x, crn_y, 0, n);
679   }
680
681   if (co != NULL) {
682     interp_bilinear_grid(&key, grid_data[g_index + S], crn_x, crn_y, 1, co);
683   }
684 }
685
686 /* mode = 0: interpolate normals,
687  * mode = 1: interpolate coord */
688
689 static void interp_bilinear_mpoly(DerivedMesh *dm,
690                                   MLoop *mloop,
691                                   MPoly *mpoly,
692                                   const float u,
693                                   const float v,
694                                   const int mode,
695                                   float res[3])
696 {
697   float data[4][3];
698
699   if (mode == 0) {
700     dm->getVertNo(dm, mloop[mpoly->loopstart].v, data[0]);
701     dm->getVertNo(dm, mloop[mpoly->loopstart + 1].v, data[1]);
702     dm->getVertNo(dm, mloop[mpoly->loopstart + 2].v, data[2]);
703     dm->getVertNo(dm, mloop[mpoly->loopstart + 3].v, data[3]);
704   }
705   else {
706     dm->getVertCo(dm, mloop[mpoly->loopstart].v, data[0]);
707     dm->getVertCo(dm, mloop[mpoly->loopstart + 1].v, data[1]);
708     dm->getVertCo(dm, mloop[mpoly->loopstart + 2].v, data[2]);
709     dm->getVertCo(dm, mloop[mpoly->loopstart + 3].v, data[3]);
710   }
711
712   interp_bilinear_quad_v3(data, u, v, res);
713 }
714
715 static void interp_barycentric_mlooptri(DerivedMesh *dm,
716                                         MLoop *mloop,
717                                         const MLoopTri *lt,
718                                         const float u,
719                                         const float v,
720                                         const int mode,
721                                         float res[3])
722 {
723   float data[3][3];
724
725   if (mode == 0) {
726     dm->getVertNo(dm, mloop[lt->tri[0]].v, data[0]);
727     dm->getVertNo(dm, mloop[lt->tri[1]].v, data[1]);
728     dm->getVertNo(dm, mloop[lt->tri[2]].v, data[2]);
729   }
730   else {
731     dm->getVertCo(dm, mloop[lt->tri[0]].v, data[0]);
732     dm->getVertCo(dm, mloop[lt->tri[1]].v, data[1]);
733     dm->getVertCo(dm, mloop[lt->tri[2]].v, data[2]);
734   }
735
736   interp_barycentric_tri_v3(data, u, v, res);
737 }
738
739 /* **************** Displacement Baker **************** */
740
741 static void *init_heights_data(MultiresBakeRender *bkr, Image *ima)
742 {
743   MHeightBakeData *height_data;
744   ImBuf *ibuf = BKE_image_acquire_ibuf(ima, NULL, NULL);
745   DerivedMesh *lodm = bkr->lores_dm;
746   BakeImBufuserData *userdata = ibuf->userdata;
747
748   if (userdata->displacement_buffer == NULL) {
749     userdata->displacement_buffer = MEM_callocN(sizeof(float) * ibuf->x * ibuf->y,
750                                                 "MultiresBake heights");
751   }
752
753   height_data = MEM_callocN(sizeof(MHeightBakeData), "MultiresBake heightData");
754
755   height_data->ima = ima;
756   height_data->heights = userdata->displacement_buffer;
757
758   if (!bkr->use_lores_mesh) {
759     SubsurfModifierData smd = {{NULL}};
760     int ss_lvl = bkr->tot_lvl - bkr->lvl;
761
762     CLAMP(ss_lvl, 0, 6);
763
764     if (ss_lvl > 0) {
765       smd.levels = smd.renderLevels = ss_lvl;
766       smd.uv_smooth = SUBSURF_UV_SMOOTH_PRESERVE_CORNERS;
767       smd.quality = 3;
768
769       if (bkr->simple) {
770         smd.subdivType = ME_SIMPLE_SUBSURF;
771       }
772
773       height_data->ssdm = subsurf_make_derived_from_derived(
774           bkr->lores_dm, &smd, bkr->scene, NULL, 0);
775       init_ccgdm_arrays(height_data->ssdm);
776     }
777   }
778
779   height_data->orig_index_mp_to_orig = lodm->getPolyDataArray(lodm, CD_ORIGINDEX);
780
781   BKE_image_release_ibuf(ima, ibuf, NULL);
782
783   return (void *)height_data;
784 }
785
786 static void free_heights_data(void *bake_data)
787 {
788   MHeightBakeData *height_data = (MHeightBakeData *)bake_data;
789
790   if (height_data->ssdm) {
791     height_data->ssdm->release(height_data->ssdm);
792   }
793
794   MEM_freeN(height_data);
795 }
796
797 /* MultiresBake callback for heights baking
798  * general idea:
799  *   - find coord of point with specified UV in hi-res mesh (let's call it p1)
800  *   - find coord of point and normal with specified UV in lo-res mesh (or subdivided lo-res
801  *     mesh to make texture smoother) let's call this point p0 and n.
802  *   - height wound be dot(n, p1-p0) */
803 static void apply_heights_callback(DerivedMesh *lores_dm,
804                                    DerivedMesh *hires_dm,
805                                    void *thread_data_v,
806                                    void *bake_data,
807                                    ImBuf *ibuf,
808                                    const int tri_index,
809                                    const int lvl,
810                                    const float st[2],
811                                    float UNUSED(tangmat[3][3]),
812                                    const int x,
813                                    const int y)
814 {
815   const MLoopTri *lt = lores_dm->getLoopTriArray(lores_dm) + tri_index;
816   MLoop *mloop = lores_dm->getLoopArray(lores_dm);
817   MPoly *mpoly = lores_dm->getPolyArray(lores_dm) + lt->poly;
818   MLoopUV *mloopuv = lores_dm->getLoopDataArray(lores_dm, CD_MLOOPUV);
819   MHeightBakeData *height_data = (MHeightBakeData *)bake_data;
820   MultiresBakeThread *thread_data = (MultiresBakeThread *)thread_data_v;
821   float uv[2], *st0, *st1, *st2, *st3;
822   int pixel = ibuf->x * y + x;
823   float vec[3], p0[3], p1[3], n[3], len;
824
825   /* ideally we would work on triangles only, however, we rely on quads to get orthogonal
826    * coordinates for use in grid space (triangle barycentric is not orthogonal) */
827   if (mpoly->totloop == 4) {
828     st0 = mloopuv[mpoly->loopstart].uv;
829     st1 = mloopuv[mpoly->loopstart + 1].uv;
830     st2 = mloopuv[mpoly->loopstart + 2].uv;
831     st3 = mloopuv[mpoly->loopstart + 3].uv;
832     resolve_quad_uv_v2(uv, st, st0, st1, st2, st3);
833   }
834   else {
835     st0 = mloopuv[lt->tri[0]].uv;
836     st1 = mloopuv[lt->tri[1]].uv;
837     st2 = mloopuv[lt->tri[2]].uv;
838     resolve_tri_uv_v2(uv, st, st0, st1, st2);
839   }
840
841   CLAMP(uv[0], 0.0f, 1.0f);
842   CLAMP(uv[1], 0.0f, 1.0f);
843
844   get_ccgdm_data(
845       lores_dm, hires_dm, height_data->orig_index_mp_to_orig, lvl, lt, uv[0], uv[1], p1, NULL);
846
847   if (height_data->ssdm) {
848     get_ccgdm_data(lores_dm,
849                    height_data->ssdm,
850                    height_data->orig_index_mp_to_orig,
851                    0,
852                    lt,
853                    uv[0],
854                    uv[1],
855                    p0,
856                    n);
857   }
858   else {
859     if (mpoly->totloop == 4) {
860       interp_bilinear_mpoly(lores_dm, mloop, mpoly, uv[0], uv[1], 1, p0);
861       interp_bilinear_mpoly(lores_dm, mloop, mpoly, uv[0], uv[1], 0, n);
862     }
863     else {
864       interp_barycentric_mlooptri(lores_dm, mloop, lt, uv[0], uv[1], 1, p0);
865       interp_barycentric_mlooptri(lores_dm, mloop, lt, uv[0], uv[1], 0, n);
866     }
867   }
868
869   sub_v3_v3v3(vec, p1, p0);
870   len = dot_v3v3(n, vec);
871
872   height_data->heights[pixel] = len;
873
874   thread_data->height_min = min_ff(thread_data->height_min, len);
875   thread_data->height_max = max_ff(thread_data->height_max, len);
876
877   if (ibuf->rect_float) {
878     float *rrgbf = ibuf->rect_float + pixel * 4;
879     rrgbf[0] = rrgbf[1] = rrgbf[2] = len;
880     rrgbf[3] = 1.0f;
881   }
882   else {
883     char *rrgb = (char *)ibuf->rect + pixel * 4;
884     rrgb[0] = rrgb[1] = rrgb[2] = unit_float_to_uchar_clamp(len);
885     rrgb[3] = 255;
886   }
887 }
888
889 /* **************** Normal Maps Baker **************** */
890
891 static void *init_normal_data(MultiresBakeRender *bkr, Image *UNUSED(ima))
892 {
893   MNormalBakeData *normal_data;
894   DerivedMesh *lodm = bkr->lores_dm;
895
896   normal_data = MEM_callocN(sizeof(MNormalBakeData), "MultiresBake normalData");
897
898   normal_data->orig_index_mp_to_orig = lodm->getPolyDataArray(lodm, CD_ORIGINDEX);
899
900   return (void *)normal_data;
901 }
902
903 static void free_normal_data(void *bake_data)
904 {
905   MNormalBakeData *normal_data = (MNormalBakeData *)bake_data;
906
907   MEM_freeN(normal_data);
908 }
909
910 /**
911  * MultiresBake callback for normals' baking.
912  *
913  * General idea:
914  * - Find coord and normal of point with specified UV in hi-res mesh.
915  * - Multiply it by tangmat.
916  * - Vector in color space would be `norm(vec) / 2 + (0.5, 0.5, 0.5)`.
917  */
918 static void apply_tangmat_callback(DerivedMesh *lores_dm,
919                                    DerivedMesh *hires_dm,
920                                    void *UNUSED(thread_data),
921                                    void *bake_data,
922                                    ImBuf *ibuf,
923                                    const int tri_index,
924                                    const int lvl,
925                                    const float st[2],
926                                    float tangmat[3][3],
927                                    const int x,
928                                    const int y)
929 {
930   const MLoopTri *lt = lores_dm->getLoopTriArray(lores_dm) + tri_index;
931   MPoly *mpoly = lores_dm->getPolyArray(lores_dm) + lt->poly;
932   MLoopUV *mloopuv = lores_dm->getLoopDataArray(lores_dm, CD_MLOOPUV);
933   MNormalBakeData *normal_data = (MNormalBakeData *)bake_data;
934   float uv[2], *st0, *st1, *st2, *st3;
935   int pixel = ibuf->x * y + x;
936   float n[3], vec[3], tmp[3] = {0.5, 0.5, 0.5};
937
938   /* ideally we would work on triangles only, however, we rely on quads to get orthogonal
939    * coordinates for use in grid space (triangle barycentric is not orthogonal) */
940   if (mpoly->totloop == 4) {
941     st0 = mloopuv[mpoly->loopstart].uv;
942     st1 = mloopuv[mpoly->loopstart + 1].uv;
943     st2 = mloopuv[mpoly->loopstart + 2].uv;
944     st3 = mloopuv[mpoly->loopstart + 3].uv;
945     resolve_quad_uv_v2(uv, st, st0, st1, st2, st3);
946   }
947   else {
948     st0 = mloopuv[lt->tri[0]].uv;
949     st1 = mloopuv[lt->tri[1]].uv;
950     st2 = mloopuv[lt->tri[2]].uv;
951     resolve_tri_uv_v2(uv, st, st0, st1, st2);
952   }
953
954   CLAMP(uv[0], 0.0f, 1.0f);
955   CLAMP(uv[1], 0.0f, 1.0f);
956
957   get_ccgdm_data(
958       lores_dm, hires_dm, normal_data->orig_index_mp_to_orig, lvl, lt, uv[0], uv[1], NULL, n);
959
960   mul_v3_m3v3(vec, tangmat, n);
961   normalize_v3_length(vec, 0.5);
962   add_v3_v3(vec, tmp);
963
964   if (ibuf->rect_float) {
965     float *rrgbf = ibuf->rect_float + pixel * 4;
966     rrgbf[0] = vec[0];
967     rrgbf[1] = vec[1];
968     rrgbf[2] = vec[2];
969     rrgbf[3] = 1.0f;
970   }
971   else {
972     unsigned char *rrgb = (unsigned char *)ibuf->rect + pixel * 4;
973     rgb_float_to_uchar(rrgb, vec);
974     rrgb[3] = 255;
975   }
976 }
977
978 /* TODO: restore ambient occlusion baking support, using BLI BVH? */
979 #if 0
980 /* **************** Ambient Occlusion Baker **************** */
981
982 // must be a power of two
983 #  define MAX_NUMBER_OF_AO_RAYS 1024
984
985 static unsigned short ao_random_table_1[MAX_NUMBER_OF_AO_RAYS];
986 static unsigned short ao_random_table_2[MAX_NUMBER_OF_AO_RAYS];
987
988 static void init_ao_random(void)
989 {
990   int i;
991
992   for (i = 0; i < MAX_NUMBER_OF_AO_RAYS; i++) {
993     ao_random_table_1[i] = rand() & 0xffff;
994     ao_random_table_2[i] = rand() & 0xffff;
995   }
996 }
997
998 static unsigned short get_ao_random1(const int i)
999 {
1000   return ao_random_table_1[i & (MAX_NUMBER_OF_AO_RAYS - 1)];
1001 }
1002
1003 static unsigned short get_ao_random2(const int i)
1004 {
1005   return ao_random_table_2[i & (MAX_NUMBER_OF_AO_RAYS - 1)];
1006 }
1007
1008 static void build_permutation_table(unsigned short permutation[],
1009                                     unsigned short temp_permutation[],
1010                                     const int number_of_rays,
1011                                     const int is_first_perm_table)
1012 {
1013   int i, k;
1014
1015   for (i = 0; i < number_of_rays; i++)
1016     temp_permutation[i] = i;
1017
1018   for (i = 0; i < number_of_rays; i++) {
1019     const unsigned int nr_entries_left = number_of_rays - i;
1020     unsigned short rnd = is_first_perm_table != false ? get_ao_random1(i) : get_ao_random2(i);
1021     const unsigned short entry = rnd % nr_entries_left;
1022
1023     /* pull entry */
1024     permutation[i] = temp_permutation[entry];
1025
1026     /* delete entry */
1027     for (k = entry; k < nr_entries_left - 1; k++) {
1028       temp_permutation[k] = temp_permutation[k + 1];
1029     }
1030   }
1031
1032   /* verify permutation table
1033    * every entry must appear exactly once
1034    */
1035 #  if 0
1036   for (i = 0; i < number_of_rays; i++) temp_permutation[i] = 0;
1037   for (i = 0; i < number_of_rays; i++) ++temp_permutation[permutation[i]];
1038   for (i = 0; i < number_of_rays; i++) BLI_assert(temp_permutation[i] == 1);
1039 #  endif
1040 }
1041
1042 static void create_ao_raytree(MultiresBakeRender *bkr, MAOBakeData *ao_data)
1043 {
1044   DerivedMesh *hidm = bkr->hires_dm;
1045   RayObject *raytree;
1046   RayFace *face;
1047   CCGElem **grid_data;
1048   CCGKey key;
1049   int num_grids, grid_size /*, face_side */, num_faces;
1050   int i;
1051
1052   num_grids = hidm->getNumGrids(hidm);
1053   grid_size = hidm->getGridSize(hidm);
1054   grid_data = hidm->getGridData(hidm);
1055   hidm->getGridKey(hidm, &key);
1056
1057   /* face_side = (grid_size << 1) - 1; */ /* UNUSED */
1058   num_faces = num_grids * (grid_size - 1) * (grid_size - 1);
1059
1060   raytree = ao_data->raytree = RE_rayobject_create(
1061       bkr->raytrace_structure, num_faces, bkr->octree_resolution);
1062   face = ao_data->rayfaces = (RayFace *)MEM_callocN(num_faces * sizeof(RayFace),
1063                                                     "ObjectRen faces");
1064
1065   for (i = 0; i < num_grids; i++) {
1066     int x, y;
1067     for (x = 0; x < grid_size - 1; x++) {
1068       for (y = 0; y < grid_size - 1; y++) {
1069         float co[4][3];
1070
1071         copy_v3_v3(co[0], CCG_grid_elem_co(&key, grid_data[i], x, y));
1072         copy_v3_v3(co[1], CCG_grid_elem_co(&key, grid_data[i], x, y + 1));
1073         copy_v3_v3(co[2], CCG_grid_elem_co(&key, grid_data[i], x + 1, y + 1));
1074         copy_v3_v3(co[3], CCG_grid_elem_co(&key, grid_data[i], x + 1, y));
1075
1076         RE_rayface_from_coords(face, ao_data, face, co[0], co[1], co[2], co[3]);
1077         RE_rayobject_add(raytree, RE_rayobject_unalignRayFace(face));
1078
1079         face++;
1080       }
1081     }
1082   }
1083
1084   RE_rayobject_done(raytree);
1085 }
1086
1087 static void *init_ao_data(MultiresBakeRender *bkr, Image *UNUSED(ima))
1088 {
1089   MAOBakeData *ao_data;
1090   DerivedMesh *lodm = bkr->lores_dm;
1091   unsigned short *temp_permutation_table;
1092   size_t permutation_size;
1093
1094   init_ao_random();
1095
1096   ao_data = MEM_callocN(sizeof(MAOBakeData), "MultiresBake aoData");
1097
1098   ao_data->number_of_rays = bkr->number_of_rays;
1099   ao_data->bias = bkr->bias;
1100
1101   ao_data->orig_index_mp_to_orig = lodm->getPolyDataArray(lodm, CD_ORIGINDEX);
1102
1103   create_ao_raytree(bkr, ao_data);
1104
1105   /* initialize permutation tables */
1106   permutation_size = sizeof(unsigned short) * bkr->number_of_rays;
1107   ao_data->permutation_table_1 = MEM_callocN(permutation_size, "multires AO baker perm1");
1108   ao_data->permutation_table_2 = MEM_callocN(permutation_size, "multires AO baker perm2");
1109   temp_permutation_table = MEM_callocN(permutation_size, "multires AO baker temp perm");
1110
1111   build_permutation_table(
1112       ao_data->permutation_table_1, temp_permutation_table, bkr->number_of_rays, 1);
1113   build_permutation_table(
1114       ao_data->permutation_table_2, temp_permutation_table, bkr->number_of_rays, 0);
1115
1116   MEM_freeN(temp_permutation_table);
1117
1118   return (void *)ao_data;
1119 }
1120
1121 static void free_ao_data(void *bake_data)
1122 {
1123   MAOBakeData *ao_data = (MAOBakeData *)bake_data;
1124
1125   RE_rayobject_free(ao_data->raytree);
1126   MEM_freeN(ao_data->rayfaces);
1127
1128   MEM_freeN(ao_data->permutation_table_1);
1129   MEM_freeN(ao_data->permutation_table_2);
1130
1131   MEM_freeN(ao_data);
1132 }
1133
1134 /* builds an X and a Y axis from the given Z axis */
1135 static void build_coordinate_frame(float axisX[3], float axisY[3], const float axisZ[3])
1136 {
1137   const float faX = fabsf(axisZ[0]);
1138   const float faY = fabsf(axisZ[1]);
1139   const float faZ = fabsf(axisZ[2]);
1140
1141   if (faX <= faY && faX <= faZ) {
1142     const float len = sqrtf(axisZ[1] * axisZ[1] + axisZ[2] * axisZ[2]);
1143     axisY[0] = 0;
1144     axisY[1] = axisZ[2] / len;
1145     axisY[2] = -axisZ[1] / len;
1146     cross_v3_v3v3(axisX, axisY, axisZ);
1147   }
1148   else if (faY <= faZ) {
1149     const float len = sqrtf(axisZ[0] * axisZ[0] + axisZ[2] * axisZ[2]);
1150     axisX[0] = axisZ[2] / len;
1151     axisX[1] = 0;
1152     axisX[2] = -axisZ[0] / len;
1153     cross_v3_v3v3(axisY, axisZ, axisX);
1154   }
1155   else {
1156     const float len = sqrtf(axisZ[0] * axisZ[0] + axisZ[1] * axisZ[1]);
1157     axisX[0] = axisZ[1] / len;
1158     axisX[1] = -axisZ[0] / len;
1159     axisX[2] = 0;
1160     cross_v3_v3v3(axisY, axisZ, axisX);
1161   }
1162 }
1163
1164 /* return false if nothing was hit and true otherwise */
1165 static int trace_ao_ray(MAOBakeData *ao_data, float ray_start[3], float ray_direction[3])
1166 {
1167   Isect isect = {{0}};
1168
1169   isect.dist = RE_RAYTRACE_MAXDIST;
1170   copy_v3_v3(isect.start, ray_start);
1171   copy_v3_v3(isect.dir, ray_direction);
1172   isect.lay = -1;
1173
1174   normalize_v3(isect.dir);
1175
1176   return RE_rayobject_raycast(ao_data->raytree, &isect);
1177 }
1178
1179 static void apply_ao_callback(DerivedMesh *lores_dm,
1180                               DerivedMesh *hires_dm,
1181                               void *UNUSED(thread_data),
1182                               void *bake_data,
1183                               ImBuf *ibuf,
1184                               const int tri_index,
1185                               const int lvl,
1186                               const float st[2],
1187                               float UNUSED(tangmat[3][3]),
1188                               const int x,
1189                               const int y)
1190 {
1191   const MLoopTri *lt = lores_dm->getLoopTriArray(lores_dm) + tri_index;
1192   MPoly *mpoly = lores_dm->getPolyArray(lores_dm) + lt->poly;
1193   MLoopUV *mloopuv = lores_dm->getLoopDataArray(lores_dm, CD_MLOOPUV);
1194   MAOBakeData *ao_data = (MAOBakeData *)bake_data;
1195
1196   int i, k, perm_offs;
1197   float pos[3], nrm[3];
1198   float cen[3];
1199   float axisX[3], axisY[3], axisZ[3];
1200   float shadow = 0;
1201   float value;
1202   int pixel = ibuf->x * y + x;
1203   float uv[2], *st0, *st1, *st2, *st3;
1204
1205   /* ideally we would work on triangles only, however, we rely on quads to get orthogonal
1206    * coordinates for use in grid space (triangle barycentric is not orthogonal) */
1207   if (mpoly->totloop == 4) {
1208     st0 = mloopuv[mpoly->loopstart].uv;
1209     st1 = mloopuv[mpoly->loopstart + 1].uv;
1210     st2 = mloopuv[mpoly->loopstart + 2].uv;
1211     st3 = mloopuv[mpoly->loopstart + 3].uv;
1212     resolve_quad_uv_v2(uv, st, st0, st1, st2, st3);
1213   }
1214   else {
1215     st0 = mloopuv[lt->tri[0]].uv;
1216     st1 = mloopuv[lt->tri[1]].uv;
1217     st2 = mloopuv[lt->tri[2]].uv;
1218     resolve_tri_uv_v2(uv, st, st0, st1, st2);
1219   }
1220
1221   CLAMP(uv[0], 0.0f, 1.0f);
1222   CLAMP(uv[1], 0.0f, 1.0f);
1223
1224   get_ccgdm_data(
1225       lores_dm, hires_dm, ao_data->orig_index_mp_to_orig, lvl, lt, uv[0], uv[1], pos, nrm);
1226
1227   /* offset ray origin by user bias along normal */
1228   for (i = 0; i < 3; i++)
1229     cen[i] = pos[i] + ao_data->bias * nrm[i];
1230
1231   /* build tangent frame */
1232   for (i = 0; i < 3; i++)
1233     axisZ[i] = nrm[i];
1234
1235   build_coordinate_frame(axisX, axisY, axisZ);
1236
1237   /* static noise */
1238   perm_offs = (get_ao_random2(get_ao_random1(x) + y)) & (MAX_NUMBER_OF_AO_RAYS - 1);
1239
1240   /* importance sample shadow rays (cosine weighted) */
1241   for (i = 0; i < ao_data->number_of_rays; i++) {
1242     int hit_something;
1243
1244     /* use N-Rooks to distribute our N ray samples across
1245      * a multi-dimensional domain (2D)
1246      */
1247     const unsigned short I =
1248         ao_data->permutation_table_1[(i + perm_offs) % ao_data->number_of_rays];
1249     const unsigned short J = ao_data->permutation_table_2[i];
1250
1251     const float JitPh = (get_ao_random2(I + perm_offs) & (MAX_NUMBER_OF_AO_RAYS - 1)) /
1252                         ((float)MAX_NUMBER_OF_AO_RAYS);
1253     const float JitTh = (get_ao_random1(J + perm_offs) & (MAX_NUMBER_OF_AO_RAYS - 1)) /
1254                         ((float)MAX_NUMBER_OF_AO_RAYS);
1255     const float SiSqPhi = (I + JitPh) / ao_data->number_of_rays;
1256     const float Theta = (float)(2 * M_PI) * ((J + JitTh) / ao_data->number_of_rays);
1257
1258     /* this gives results identical to the so-called cosine
1259      * weighted distribution relative to the north pole.
1260      */
1261     float SiPhi = sqrtf(SiSqPhi);
1262     float CoPhi = SiSqPhi < 1.0f ? sqrtf(1.0f - SiSqPhi) : 0;
1263     float CoThe = cosf(Theta);
1264     float SiThe = sinf(Theta);
1265
1266     const float dx = CoThe * CoPhi;
1267     const float dy = SiThe * CoPhi;
1268     const float dz = SiPhi;
1269
1270     /* transform ray direction out of tangent frame */
1271     float dv[3];
1272     for (k = 0; k < 3; k++)
1273       dv[k] = axisX[k] * dx + axisY[k] * dy + axisZ[k] * dz;
1274
1275     hit_something = trace_ao_ray(ao_data, cen, dv);
1276
1277     if (hit_something != 0)
1278       shadow += 1;
1279   }
1280
1281   value = 1.0f - (shadow / ao_data->number_of_rays);
1282
1283   if (ibuf->rect_float) {
1284     float *rrgbf = ibuf->rect_float + pixel * 4;
1285     rrgbf[0] = rrgbf[1] = rrgbf[2] = value;
1286     rrgbf[3] = 1.0f;
1287   }
1288   else {
1289     unsigned char *rrgb = (unsigned char *)ibuf->rect + pixel * 4;
1290     rrgb[0] = rrgb[1] = rrgb[2] = unit_float_to_uchar_clamp(value);
1291     rrgb[3] = 255;
1292   }
1293 }
1294 #endif
1295
1296 /* ******$***************** Post processing ************************* */
1297
1298 static void bake_ibuf_filter(ImBuf *ibuf, char *mask, const int filter)
1299 {
1300   /* must check before filtering */
1301   const bool is_new_alpha = (ibuf->planes != R_IMF_PLANES_RGBA) && BKE_imbuf_alpha_test(ibuf);
1302
1303   /* Margin */
1304   if (filter) {
1305     IMB_filter_extend(ibuf, mask, filter);
1306   }
1307
1308   /* if the bake results in new alpha then change the image setting */
1309   if (is_new_alpha) {
1310     ibuf->planes = R_IMF_PLANES_RGBA;
1311   }
1312   else {
1313     if (filter && ibuf->planes != R_IMF_PLANES_RGBA) {
1314       /* clear alpha added by filtering */
1315       IMB_rectfill_alpha(ibuf, 1.0f);
1316     }
1317   }
1318 }
1319
1320 static void bake_ibuf_normalize_displacement(
1321     ImBuf *ibuf, float *displacement, char *mask, float displacement_min, float displacement_max)
1322 {
1323   int i;
1324   const float *current_displacement = displacement;
1325   const char *current_mask = mask;
1326   float max_distance;
1327
1328   max_distance = max_ff(fabsf(displacement_min), fabsf(displacement_max));
1329
1330   for (i = 0; i < ibuf->x * ibuf->y; i++) {
1331     if (*current_mask == FILTER_MASK_USED) {
1332       float normalized_displacement;
1333
1334       if (max_distance > 1e-5f) {
1335         normalized_displacement = (*current_displacement + max_distance) / (max_distance * 2);
1336       }
1337       else {
1338         normalized_displacement = 0.5f;
1339       }
1340
1341       if (ibuf->rect_float) {
1342         /* currently baking happens to RGBA only */
1343         float *fp = ibuf->rect_float + i * 4;
1344         fp[0] = fp[1] = fp[2] = normalized_displacement;
1345         fp[3] = 1.0f;
1346       }
1347
1348       if (ibuf->rect) {
1349         unsigned char *cp = (unsigned char *)(ibuf->rect + i);
1350         cp[0] = cp[1] = cp[2] = unit_float_to_uchar_clamp(normalized_displacement);
1351         cp[3] = 255;
1352       }
1353     }
1354
1355     current_displacement++;
1356     current_mask++;
1357   }
1358 }
1359
1360 /* **************** Common functions public API relates on **************** */
1361
1362 static void count_images(MultiresBakeRender *bkr)
1363 {
1364   BLI_listbase_clear(&bkr->image);
1365   bkr->tot_image = 0;
1366
1367   for (int i = 0; i < bkr->ob_image.len; i++) {
1368     Image *ima = bkr->ob_image.array[i];
1369     if (ima) {
1370       ima->id.tag &= ~LIB_TAG_DOIT;
1371     }
1372   }
1373
1374   for (int i = 0; i < bkr->ob_image.len; i++) {
1375     Image *ima = bkr->ob_image.array[i];
1376     if (ima) {
1377       if ((ima->id.tag & LIB_TAG_DOIT) == 0) {
1378         LinkData *data = BLI_genericNodeN(ima);
1379         BLI_addtail(&bkr->image, data);
1380         bkr->tot_image++;
1381         ima->id.tag |= LIB_TAG_DOIT;
1382       }
1383     }
1384   }
1385
1386   for (int i = 0; i < bkr->ob_image.len; i++) {
1387     Image *ima = bkr->ob_image.array[i];
1388     if (ima) {
1389       ima->id.tag &= ~LIB_TAG_DOIT;
1390     }
1391   }
1392 }
1393
1394 static void bake_images(MultiresBakeRender *bkr, MultiresBakeResult *result)
1395 {
1396   LinkData *link;
1397
1398   for (link = bkr->image.first; link; link = link->next) {
1399     Image *ima = (Image *)link->data;
1400     ImBuf *ibuf = BKE_image_acquire_ibuf(ima, NULL, NULL);
1401
1402     if (ibuf->x > 0 && ibuf->y > 0) {
1403       BakeImBufuserData *userdata = MEM_callocN(sizeof(BakeImBufuserData),
1404                                                 "MultiresBake userdata");
1405       userdata->mask_buffer = MEM_callocN(ibuf->y * ibuf->x, "MultiresBake imbuf mask");
1406       ibuf->userdata = userdata;
1407
1408       switch (bkr->mode) {
1409         case RE_BAKE_NORMALS:
1410           do_multires_bake(
1411               bkr, ima, true, apply_tangmat_callback, init_normal_data, free_normal_data, result);
1412           break;
1413         case RE_BAKE_DISPLACEMENT:
1414           do_multires_bake(bkr,
1415                            ima,
1416                            false,
1417                            apply_heights_callback,
1418                            init_heights_data,
1419                            free_heights_data,
1420                            result);
1421           break;
1422 /* TODO: restore ambient occlusion baking support. */
1423 #if 0
1424         case RE_BAKE_AO:
1425           do_multires_bake(bkr, ima, false, apply_ao_callback, init_ao_data, free_ao_data, result);
1426           break;
1427 #endif
1428       }
1429     }
1430
1431     BKE_image_release_ibuf(ima, ibuf, NULL);
1432
1433     ima->id.tag |= LIB_TAG_DOIT;
1434   }
1435 }
1436
1437 static void finish_images(MultiresBakeRender *bkr, MultiresBakeResult *result)
1438 {
1439   LinkData *link;
1440   bool use_displacement_buffer = bkr->mode == RE_BAKE_DISPLACEMENT;
1441
1442   for (link = bkr->image.first; link; link = link->next) {
1443     Image *ima = (Image *)link->data;
1444     ImBuf *ibuf = BKE_image_acquire_ibuf(ima, NULL, NULL);
1445     BakeImBufuserData *userdata = (BakeImBufuserData *)ibuf->userdata;
1446
1447     if (ibuf->x <= 0 || ibuf->y <= 0) {
1448       continue;
1449     }
1450
1451     if (use_displacement_buffer) {
1452       bake_ibuf_normalize_displacement(ibuf,
1453                                        userdata->displacement_buffer,
1454                                        userdata->mask_buffer,
1455                                        result->height_min,
1456                                        result->height_max);
1457     }
1458
1459     bake_ibuf_filter(ibuf, userdata->mask_buffer, bkr->bake_filter);
1460
1461     ibuf->userflags |= IB_BITMAPDIRTY | IB_DISPLAY_BUFFER_INVALID;
1462
1463     if (ibuf->rect_float) {
1464       ibuf->userflags |= IB_RECT_INVALID;
1465     }
1466
1467     if (ibuf->mipmap[0]) {
1468       ibuf->userflags |= IB_MIPMAP_INVALID;
1469       imb_freemipmapImBuf(ibuf);
1470     }
1471
1472     if (ibuf->userdata) {
1473       if (userdata->displacement_buffer) {
1474         MEM_freeN(userdata->displacement_buffer);
1475       }
1476
1477       MEM_freeN(userdata->mask_buffer);
1478       MEM_freeN(userdata);
1479       ibuf->userdata = NULL;
1480     }
1481
1482     BKE_image_release_ibuf(ima, ibuf, NULL);
1483     DEG_id_tag_update(&ima->id, 0);
1484   }
1485 }
1486
1487 void RE_multires_bake_images(MultiresBakeRender *bkr)
1488 {
1489   MultiresBakeResult result;
1490
1491   count_images(bkr);
1492   bake_images(bkr, &result);
1493   finish_images(bkr, &result);
1494 }