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