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