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