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