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