fix memory leak when baking feedback loop detected.
[blender.git] / source / blender / editors / object / object_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) 2004 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/editors/object/object_bake.c
30  *  \ingroup edobj
31  */
32
33 #include <string.h>
34
35 #include "MEM_guardedalloc.h"
36
37 #include "DNA_scene_types.h"
38 #include "DNA_screen_types.h"
39 #include "DNA_space_types.h"
40 #include "DNA_world_types.h"
41 #include "DNA_object_types.h"
42 #include "DNA_mesh_types.h"
43 #include "DNA_meshdata_types.h"
44
45 #include "BLI_blenlib.h"
46 #include "BLI_threads.h"
47 #include "BLI_utildefines.h"
48 #include "BLI_math.h"
49 #include "BLI_math_geom.h"
50
51 #include "BKE_blender.h"
52 #include "BKE_ccg.h"
53 #include "BKE_screen.h"
54 #include "BKE_context.h"
55 #include "BKE_global.h"
56 #include "BKE_image.h"
57 #include "BKE_main.h"
58 #include "BKE_multires.h"
59 #include "BKE_report.h"
60 #include "BKE_cdderivedmesh.h"
61 #include "BKE_modifier.h"
62 #include "BKE_DerivedMesh.h"
63 #include "BKE_subsurf.h"
64
65 #include "RE_pipeline.h"
66 #include "RE_shader_ext.h"
67
68 #include "PIL_time.h"
69
70 #include "IMB_imbuf_types.h"
71 #include "IMB_imbuf.h"
72
73 #include "GPU_draw.h" /* GPU_free_image */
74
75 #include "WM_api.h"
76 #include "WM_types.h"
77
78 #include "ED_object.h"
79
80 #include "object_intern.h"
81
82 /* ****************** multires BAKING ********************** */
83
84 /* holder of per-object data needed for bake job
85  * needed to make job totally thread-safe */
86 typedef struct MultiresBakerJobData {
87         struct MultiresBakerJobData *next, *prev;
88         DerivedMesh *lores_dm, *hires_dm;
89         int simple, lvl, tot_lvl;
90 } MultiresBakerJobData;
91
92 /* data passing to multires-baker job */
93 typedef struct {
94         ListBase data;
95         int bake_clear, bake_filter;
96         short mode, use_lores_mesh;
97 } MultiresBakeJob;
98
99 /* data passing to multires baker */
100 typedef struct {
101         DerivedMesh *lores_dm, *hires_dm;
102         int simple, lvl, tot_lvl, bake_filter;
103         short mode, use_lores_mesh;
104
105         int tot_obj, tot_image;
106         ListBase image;
107
108         int baked_objects, baked_faces;
109
110         short *stop;
111         short *do_update;
112         float *progress;
113 } MultiresBakeRender;
114
115 typedef void (*MPassKnownData)(DerivedMesh *lores_dm, DerivedMesh *hires_dm, const void *bake_data,
116                                const int face_index, const int lvl, const float st[2],
117                                float tangmat[3][3], const int x, const int y);
118
119 typedef void * (*MInitBakeData)(MultiresBakeRender *bkr, Image *ima);
120 typedef void   (*MApplyBakeData)(void *bake_data);
121 typedef void   (*MFreeBakeData)(void *bake_data);
122
123 typedef struct {
124         MVert *mvert;
125         MFace *mface;
126         MTFace *mtface;
127         float *pvtangent;
128         float *precomputed_normals;
129         int w, h;
130         int face_index;
131         int i0, i1, i2;
132         DerivedMesh *lores_dm, *hires_dm;
133         int lvl;
134         void *bake_data;
135         MPassKnownData pass_data;
136 } MResolvePixelData;
137
138 typedef void (*MFlushPixel)(const MResolvePixelData *data, const int x, const int y);
139
140 typedef struct {
141         int w, h;
142         char *texels;
143         const MResolvePixelData *data;
144         MFlushPixel flush_pixel;
145 } MBakeRast;
146
147 typedef struct {
148         float *heights;
149         float height_min, height_max;
150         Image *ima;
151         DerivedMesh *ssdm;
152         const int *origindex;
153 } MHeightBakeData;
154
155 typedef struct {
156         const int *origindex;
157 } MNormalBakeData;
158
159 static void multiresbake_get_normal(const MResolvePixelData *data, float norm[], const int face_num, const int vert_index)
160 {
161         unsigned int indices[] = {data->mface[face_num].v1, data->mface[face_num].v2,
162                                   data->mface[face_num].v3, data->mface[face_num].v4};
163         const int smoothnormal = (data->mface[face_num].flag & ME_SMOOTH);
164
165         if (!smoothnormal) { /* flat */
166                 if (data->precomputed_normals) {
167                         copy_v3_v3(norm, &data->precomputed_normals[3 * face_num]);
168                 }
169                 else {
170                         float nor[3];
171                         float *p0, *p1, *p2;
172                         const int iGetNrVerts = data->mface[face_num].v4 != 0 ? 4 : 3;
173
174                         p0 = data->mvert[indices[0]].co;
175                         p1 = data->mvert[indices[1]].co;
176                         p2 = data->mvert[indices[2]].co;
177
178                         if (iGetNrVerts == 4) {
179                                 float *p3 = data->mvert[indices[3]].co;
180                                 normal_quad_v3(nor, p0, p1, p2, p3);
181                         }
182                         else {
183                                 normal_tri_v3(nor, p0, p1, p2);
184                         }
185
186                         copy_v3_v3(norm, nor);
187                 }
188         }
189         else {
190                 short *no = data->mvert[indices[vert_index]].no;
191
192                 normal_short_to_float_v3(norm, no);
193                 normalize_v3(norm);
194         }
195 }
196
197 static void init_bake_rast(MBakeRast *bake_rast, const ImBuf *ibuf, const MResolvePixelData *data, MFlushPixel flush_pixel)
198 {
199         memset(bake_rast, 0, sizeof(MBakeRast));
200
201         bake_rast->texels = ibuf->userdata;
202         bake_rast->w = ibuf->x;
203         bake_rast->h = ibuf->y;
204         bake_rast->data = data;
205         bake_rast->flush_pixel = flush_pixel;
206 }
207
208 static void flush_pixel(const MResolvePixelData *data, const int x, const int y)
209 {
210         float st[2] = {(x + 0.5f) / data->w, (y + 0.5f) / data->h};
211         float *st0, *st1, *st2;
212         float *tang0, *tang1, *tang2;
213         float no0[3], no1[3], no2[3];
214         float fUV[2], from_tang[3][3], to_tang[3][3];
215         float u, v, w, sign;
216         int r;
217
218         const int i0 = data->i0;
219         const int i1 = data->i1;
220         const int i2 = data->i2;
221
222         st0 = data->mtface[data->face_index].uv[i0];
223         st1 = data->mtface[data->face_index].uv[i1];
224         st2 = data->mtface[data->face_index].uv[i2];
225
226         tang0 = data->pvtangent + data->face_index * 16 + i0 * 4;
227         tang1 = data->pvtangent + data->face_index * 16 + i1 * 4;
228         tang2 = data->pvtangent + data->face_index * 16 + i2 * 4;
229
230         multiresbake_get_normal(data, no0, data->face_index, i0);   /* can optimize these 3 into one call */
231         multiresbake_get_normal(data, no1, data->face_index, i1);
232         multiresbake_get_normal(data, no2, data->face_index, i2);
233
234         resolve_tri_uv(fUV, st, st0, st1, st2);
235
236         u = fUV[0];
237         v = fUV[1];
238         w = 1 - u - v;
239
240         /* the sign is the same at all face vertices for any non degenerate face.
241          * Just in case we clamp the interpolated value though. */
242         sign = (tang0[3] * u + tang1[3] * v + tang2[3] * w) < 0 ? (-1.0f) : 1.0f;
243
244         /* this sequence of math is designed specifically as is with great care
245          * to be compatible with our shader. Please don't change without good reason. */
246         for (r = 0; r < 3; r++) {
247                 from_tang[0][r] = tang0[r] * u + tang1[r] * v + tang2[r] * w;
248                 from_tang[2][r] = no0[r] * u + no1[r] * v + no2[r] * w;
249         }
250
251         cross_v3_v3v3(from_tang[1], from_tang[2], from_tang[0]);  /* B = sign * cross(N, T)  */
252         mul_v3_fl(from_tang[1], sign);
253         invert_m3_m3(to_tang, from_tang);
254         /* sequence end */
255
256         data->pass_data(data->lores_dm, data->hires_dm, data->bake_data,
257                         data->face_index, data->lvl, st, to_tang, x, y);
258 }
259
260 static void set_rast_triangle(const MBakeRast *bake_rast, const int x, const int y)
261 {
262         const int w = bake_rast->w;
263         const int h = bake_rast->h;
264
265         if (x >= 0 && x < w && y >= 0 && y < h) {
266                 if ((bake_rast->texels[y * w + x]) == 0) {
267                         flush_pixel(bake_rast->data, x, y);
268                         bake_rast->texels[y * w + x] = FILTER_MASK_USED;
269                 }
270         }
271 }
272
273 static void rasterize_half(const MBakeRast *bake_rast,
274                            const float s0_s, const float t0_s, const float s1_s, const float t1_s,
275                            const float s0_l, const float t0_l, const float s1_l, const float t1_l,
276                            const int y0_in, const int y1_in, const int is_mid_right)
277 {
278         const int s_stable = fabsf(t1_s - t0_s) > FLT_EPSILON ? 1 : 0;
279         const int l_stable = fabsf(t1_l - t0_l) > FLT_EPSILON ? 1 : 0;
280         const int w = bake_rast->w;
281         const int h = bake_rast->h;
282         int y, y0, y1;
283
284         if (y1_in <= 0 || y0_in >= h)
285                 return;
286
287         y0 = y0_in < 0 ? 0 : y0_in;
288         y1 = y1_in >= h ? h : y1_in;
289
290         for (y = y0; y < y1; y++) {
291                 /*-b(x-x0) + a(y-y0) = 0 */
292                 int iXl, iXr, x;
293                 float x_l = s_stable != 0 ? (s0_s + (((s1_s - s0_s) * (y - t0_s)) / (t1_s - t0_s))) : s0_s;
294                 float x_r = l_stable != 0 ? (s0_l + (((s1_l - s0_l) * (y - t0_l)) / (t1_l - t0_l))) : s0_l;
295
296                 if (is_mid_right != 0)
297                         SWAP(float, x_l, x_r);
298
299                 iXl = (int)ceilf(x_l);
300                 iXr = (int)ceilf(x_r);
301
302                 if (iXr > 0 && iXl < w) {
303                         iXl = iXl < 0 ? 0 : iXl;
304                         iXr = iXr >= w ? w : iXr;
305
306                         for (x = iXl; x < iXr; x++)
307                                 set_rast_triangle(bake_rast, x, y);
308                 }
309         }
310 }
311
312 static void bake_rasterize(const MBakeRast *bake_rast, const float st0_in[2], const float st1_in[2], const float st2_in[2])
313 {
314         const int w = bake_rast->w;
315         const int h = bake_rast->h;
316         float slo = st0_in[0] * w - 0.5f;
317         float tlo = st0_in[1] * h - 0.5f;
318         float smi = st1_in[0] * w - 0.5f;
319         float tmi = st1_in[1] * h - 0.5f;
320         float shi = st2_in[0] * w - 0.5f;
321         float thi = st2_in[1] * h - 0.5f;
322         int is_mid_right = 0, ylo, yhi, yhi_beg;
323
324         /* skip degenerates */
325         if ((slo == smi && tlo == tmi) || (slo == shi && tlo == thi) || (smi == shi && tmi == thi))
326                 return;
327
328         /* sort by T */
329         if (tlo > tmi && tlo > thi) {
330                 SWAP(float, shi, slo);
331                 SWAP(float, thi, tlo);
332         }
333         else if (tmi > thi) {
334                 SWAP(float, shi, smi);
335                 SWAP(float, thi, tmi);
336         }
337
338         if (tlo > tmi) {
339                 SWAP(float, slo, smi);
340                 SWAP(float, tlo, tmi);
341         }
342
343         /* check if mid point is to the left or to the right of the lo-hi edge */
344         is_mid_right = (-(shi - slo) * (tmi - thi) + (thi - tlo) * (smi - shi)) > 0 ? 1 : 0;
345         ylo = (int) ceilf(tlo);
346         yhi_beg = (int) ceilf(tmi);
347         yhi = (int) ceilf(thi);
348
349         /*if (fTmi>ceilf(fTlo))*/
350         rasterize_half(bake_rast, slo, tlo, smi, tmi, slo, tlo, shi, thi, ylo, yhi_beg, is_mid_right);
351         rasterize_half(bake_rast, smi, tmi, shi, thi, slo, tlo, shi, thi, yhi_beg, yhi, is_mid_right);
352 }
353
354 static int multiresbake_test_break(MultiresBakeRender *bkr)
355 {
356         if (!bkr->stop) {
357                 /* this means baker is executed outside from job system */
358                 return 0;
359         }
360
361         return G.is_break;
362 }
363
364 static void do_multires_bake(MultiresBakeRender *bkr, Image *ima, MPassKnownData passKnownData,
365                              MInitBakeData initBakeData, MApplyBakeData applyBakeData, MFreeBakeData freeBakeData)
366 {
367         DerivedMesh *dm = bkr->lores_dm;
368         ImBuf *ibuf = BKE_image_get_ibuf(ima, NULL);
369         const int lvl = bkr->lvl;
370         const int tot_face = dm->getNumTessFaces(dm);
371         MVert *mvert = dm->getVertArray(dm);
372         MFace *mface = dm->getTessFaceArray(dm);
373         MTFace *mtface = dm->getTessFaceDataArray(dm, CD_MTFACE);
374         float *pvtangent = NULL;
375
376         if (CustomData_get_layer_index(&dm->faceData, CD_TANGENT) == -1)
377                 DM_add_tangent_layer(dm);
378
379         pvtangent = DM_get_tessface_data_layer(dm, CD_TANGENT);
380
381         if (tot_face > 0) {  /* sanity check */
382                 int f = 0;
383                 MBakeRast bake_rast;
384                 MResolvePixelData data = {NULL};
385
386                 data.mface = mface;
387                 data.mvert = mvert;
388                 data.mtface = mtface;
389                 data.pvtangent = pvtangent;
390                 data.precomputed_normals = dm->getTessFaceDataArray(dm, CD_NORMAL);  /* don't strictly need this */
391                 data.w = ibuf->x;
392                 data.h = ibuf->y;
393                 data.lores_dm = dm;
394                 data.hires_dm = bkr->hires_dm;
395                 data.lvl = lvl;
396                 data.pass_data = passKnownData;
397
398                 if (initBakeData)
399                         data.bake_data = initBakeData(bkr, ima);
400
401                 init_bake_rast(&bake_rast, ibuf, &data, flush_pixel);
402
403                 for (f = 0; f < tot_face; f++) {
404                         MTFace *mtfate = &mtface[f];
405                         int verts[3][2], nr_tris, t;
406
407                         if (multiresbake_test_break(bkr))
408                                 break;
409
410                         if (mtfate->tpage != ima)
411                                 continue;
412
413                         data.face_index = f;
414
415                         /* might support other forms of diagonal splits later on such as
416                          * split by shortest diagonal.*/
417                         verts[0][0] = 0;
418                         verts[1][0] = 1;
419                         verts[2][0] = 2;
420
421                         verts[0][1] = 0;
422                         verts[1][1] = 2;
423                         verts[2][1] = 3;
424
425                         nr_tris = mface[f].v4 != 0 ? 2 : 1;
426                         for (t = 0; t < nr_tris; t++) {
427                                 data.i0 = verts[0][t];
428                                 data.i1 = verts[1][t];
429                                 data.i2 = verts[2][t];
430
431                                 bake_rasterize(&bake_rast, mtfate->uv[data.i0], mtfate->uv[data.i1], mtfate->uv[data.i2]);
432                         }
433
434                         bkr->baked_faces++;
435
436                         if (bkr->do_update)
437                                 *bkr->do_update = TRUE;
438
439                         if (bkr->progress)
440                                 *bkr->progress = ((float)bkr->baked_objects + (float)bkr->baked_faces / tot_face) / bkr->tot_obj;
441                 }
442
443                 if (applyBakeData)
444                         applyBakeData(data.bake_data);
445
446                 if (freeBakeData)
447                         freeBakeData(data.bake_data);
448         }
449 }
450
451 static void interp_bilinear_quad_data(float data[4][3], float u, float v, float res[3])
452 {
453         float vec[3];
454
455         copy_v3_v3(res, data[0]);
456         mul_v3_fl(res, (1 - u) * (1 - v));
457         copy_v3_v3(vec, data[1]);
458         mul_v3_fl(vec, u * (1 - v)); add_v3_v3(res, vec);
459         copy_v3_v3(vec, data[2]);
460         mul_v3_fl(vec, u * v); add_v3_v3(res, vec);
461         copy_v3_v3(vec, data[3]);
462         mul_v3_fl(vec, (1 - u) * v); add_v3_v3(res, vec);
463 }
464
465 static void interp_barycentric_tri_data(float data[3][3], float u, float v, float res[3])
466 {
467         float vec[3];
468
469         copy_v3_v3(res, data[0]);
470         mul_v3_fl(res, u);
471         copy_v3_v3(vec, data[1]);
472         mul_v3_fl(vec, v); add_v3_v3(res, vec);
473         copy_v3_v3(vec, data[2]);
474         mul_v3_fl(vec, 1.0f - u - v); add_v3_v3(res, vec);
475 }
476
477 /* mode = 0: interpolate normals,
478  * mode = 1: interpolate coord */
479 static void interp_bilinear_grid(CCGKey *key, CCGElem *grid, float crn_x, float crn_y, int mode, float res[3])
480 {
481         int x0, x1, y0, y1;
482         float u, v;
483         float data[4][3];
484
485         x0 = (int) crn_x;
486         x1 = x0 >= (key->grid_size - 1) ? (key->grid_size - 1) : (x0 + 1);
487
488         y0 = (int) crn_y;
489         y1 = y0 >= (key->grid_size - 1) ? (key->grid_size - 1) : (y0 + 1);
490
491         u = crn_x - x0;
492         v = crn_y - y0;
493
494         if (mode == 0) {
495                 copy_v3_v3(data[0], CCG_grid_elem_no(key, grid, x0, y0));
496                 copy_v3_v3(data[1], CCG_grid_elem_no(key, grid, x1, y0));
497                 copy_v3_v3(data[2], CCG_grid_elem_no(key, grid, x1, y1));
498                 copy_v3_v3(data[3], CCG_grid_elem_no(key, grid, x0, y1));
499         }
500         else {
501                 copy_v3_v3(data[0], CCG_grid_elem_co(key, grid, x0, y0));
502                 copy_v3_v3(data[1], CCG_grid_elem_co(key, grid, x1, y0));
503                 copy_v3_v3(data[2], CCG_grid_elem_co(key, grid, x1, y1));
504                 copy_v3_v3(data[3], CCG_grid_elem_co(key, grid, x0, y1));
505         }
506
507         interp_bilinear_quad_data(data, u, v, res);
508 }
509
510 static void get_ccgdm_data(DerivedMesh *lodm, DerivedMesh *hidm, const int *origindex,  const int lvl, const int face_index, const float u, const float v, float co[3], float n[3])
511 {
512         MFace mface;
513         CCGElem **grid_data;
514         CCGKey key;
515         float crn_x, crn_y;
516         int grid_size, S, face_side;
517         int *grid_offset, g_index;
518
519         lodm->getTessFace(lodm, face_index, &mface);
520
521         grid_size = hidm->getGridSize(hidm);
522         grid_data = hidm->getGridData(hidm);
523         grid_offset = hidm->getGridOffset(hidm);
524         hidm->getGridKey(hidm, &key);
525
526         face_side = (grid_size << 1) - 1;
527
528         if (lvl == 0) {
529                 g_index = grid_offset[face_index];
530                 S = mdisp_rot_face_to_crn(mface.v4 ? 4 : 3, face_side, u * (face_side - 1), v * (face_side - 1), &crn_x, &crn_y);
531         }
532         else {
533                 int side = (1 << (lvl - 1)) + 1;
534                 int grid_index = origindex[face_index];
535                 int loc_offs = face_index % (1 << (2 * lvl));
536                 int cell_index = loc_offs % ((side - 1) * (side - 1));
537                 int cell_side = (grid_size - 1) / (side - 1);
538                 int row = cell_index / (side - 1);
539                 int col = cell_index % (side - 1);
540
541                 S = face_index / (1 << (2 * (lvl - 1))) - grid_offset[grid_index];
542                 g_index = grid_offset[grid_index];
543
544                 crn_y = (row * cell_side) + u * cell_side;
545                 crn_x = (col * cell_side) + v * cell_side;
546         }
547
548         CLAMP(crn_x, 0.0f, grid_size);
549         CLAMP(crn_y, 0.0f, grid_size);
550
551         if (n != NULL)
552                 interp_bilinear_grid(&key, grid_data[g_index + S], crn_x, crn_y, 0, n);
553
554         if (co != NULL)
555                 interp_bilinear_grid(&key, grid_data[g_index + S], crn_x, crn_y, 1, co);
556 }
557
558 /* mode = 0: interpolate normals,
559  * mode = 1: interpolate coord */
560 static void interp_bilinear_mface(DerivedMesh *dm, MFace *mface, const float u, const float v, const int mode, float res[3])
561 {
562         float data[4][3];
563
564         if (mode == 0) {
565                 dm->getVertNo(dm, mface->v1, data[0]);
566                 dm->getVertNo(dm, mface->v2, data[1]);
567                 dm->getVertNo(dm, mface->v3, data[2]);
568                 dm->getVertNo(dm, mface->v4, data[3]);
569         }
570         else {
571                 dm->getVertCo(dm, mface->v1, data[0]);
572                 dm->getVertCo(dm, mface->v2, data[1]);
573                 dm->getVertCo(dm, mface->v3, data[2]);
574                 dm->getVertCo(dm, mface->v4, data[3]);
575         }
576
577         interp_bilinear_quad_data(data, u, v, res);
578 }
579
580 /* mode = 0: interpolate normals,
581  * mode = 1: interpolate coord */
582 static void interp_barycentric_mface(DerivedMesh *dm, MFace *mface, const float u, const float v, const int mode, float res[3])
583 {
584         float data[3][3];
585
586         if (mode == 0) {
587                 dm->getVertNo(dm, mface->v1, data[0]);
588                 dm->getVertNo(dm, mface->v2, data[1]);
589                 dm->getVertNo(dm, mface->v3, data[2]);
590         }
591         else {
592                 dm->getVertCo(dm, mface->v1, data[0]);
593                 dm->getVertCo(dm, mface->v2, data[1]);
594                 dm->getVertCo(dm, mface->v3, data[2]);
595         }
596
597         interp_barycentric_tri_data(data, u, v, res);
598 }
599
600 static void *init_heights_data(MultiresBakeRender *bkr, Image *ima)
601 {
602         MHeightBakeData *height_data;
603         ImBuf *ibuf = BKE_image_get_ibuf(ima, NULL);
604         DerivedMesh *lodm = bkr->lores_dm;
605
606         height_data = MEM_callocN(sizeof(MHeightBakeData), "MultiresBake heightData");
607
608         height_data->ima = ima;
609         height_data->heights = MEM_callocN(sizeof(float) * ibuf->x * ibuf->y, "MultiresBake heights");
610         height_data->height_max = -FLT_MAX;
611         height_data->height_min = FLT_MAX;
612
613         if (!bkr->use_lores_mesh) {
614                 SubsurfModifierData smd = {{NULL}};
615                 int ss_lvl = bkr->tot_lvl - bkr->lvl;
616
617                 CLAMP(ss_lvl, 0, 6);
618
619                 if (ss_lvl > 0) {
620                         smd.levels = smd.renderLevels = ss_lvl;
621                         smd.flags |= eSubsurfModifierFlag_SubsurfUv;
622
623                         if (bkr->simple)
624                                 smd.subdivType = ME_SIMPLE_SUBSURF;
625
626                         height_data->ssdm = subsurf_make_derived_from_derived(bkr->lores_dm, &smd, NULL, 0);
627                 }
628         }
629
630         height_data->origindex = lodm->getTessFaceDataArray(lodm, CD_ORIGINDEX);
631
632         return (void *)height_data;
633 }
634
635 static void *init_normal_data(MultiresBakeRender *bkr, Image *UNUSED(ima))
636 {
637         MNormalBakeData *normal_data;
638         DerivedMesh *lodm = bkr->lores_dm;
639
640         normal_data = MEM_callocN(sizeof(MNormalBakeData), "MultiresBake normalData");
641
642         normal_data->origindex = lodm->getTessFaceDataArray(lodm, CD_ORIGINDEX);
643
644         return (void *)normal_data;
645 }
646
647 static void free_normal_data(void *bake_data)
648 {
649         MNormalBakeData *normal_data = (MNormalBakeData *)bake_data;
650
651         MEM_freeN(normal_data);
652 }
653
654 static void apply_heights_data(void *bake_data)
655 {
656         MHeightBakeData *height_data = (MHeightBakeData *)bake_data;
657         ImBuf *ibuf = BKE_image_get_ibuf(height_data->ima, NULL);
658         int x, y, i;
659         float height, *heights = height_data->heights;
660         float min = height_data->height_min, max = height_data->height_max;
661
662         for (x = 0; x < ibuf->x; x++) {
663                 for (y = 0; y < ibuf->y; y++) {
664                         i = ibuf->x * y + x;
665
666                         if (((char *)ibuf->userdata)[i] != FILTER_MASK_USED)
667                                 continue;
668
669                         if (ibuf->rect_float) {
670                                 float *rrgbf = ibuf->rect_float + i * 4;
671
672                                 if (max - min > 1e-5f) height = (heights[i] - min) / (max - min);
673                                 else height = 0;
674
675                                 rrgbf[0] = rrgbf[1] = rrgbf[2] = height;
676                         }
677                         else {
678                                 char *rrgb = (char *)ibuf->rect + i * 4;
679
680                                 if (max - min > 1e-5f) height = (heights[i] - min) / (max - min);
681                                 else height = 0;
682
683                                 rrgb[0] = rrgb[1] = rrgb[2] = FTOCHAR(height);
684                         }
685                 }
686         }
687
688         ibuf->userflags = IB_RECT_INVALID;
689 }
690
691 static void free_heights_data(void *bake_data)
692 {
693         MHeightBakeData *height_data = (MHeightBakeData *)bake_data;
694
695         if (height_data->ssdm)
696                 height_data->ssdm->release(height_data->ssdm);
697
698         MEM_freeN(height_data->heights);
699         MEM_freeN(height_data);
700 }
701
702 /* MultiresBake callback for heights baking
703  * general idea:
704  *   - find coord of point with specified UV in hi-res mesh (let's call it p1)
705  *   - find coord of point and normal with specified UV in lo-res mesh (or subdivided lo-res
706  *     mesh to make texture smoother) let's call this point p0 and n.
707  *   - height wound be dot(n, p1-p0) */
708 static void apply_heights_callback(DerivedMesh *lores_dm, DerivedMesh *hires_dm, const void *bake_data,
709                                    const int face_index, const int lvl, const float st[2],
710                                    float UNUSED(tangmat[3][3]), const int x, const int y)
711 {
712         MTFace *mtface = CustomData_get_layer(&lores_dm->faceData, CD_MTFACE);
713         MFace mface;
714         Image *ima = mtface[face_index].tpage;
715         ImBuf *ibuf = BKE_image_get_ibuf(ima, NULL);
716         MHeightBakeData *height_data = (MHeightBakeData *)bake_data;
717         float uv[2], *st0, *st1, *st2, *st3;
718         int pixel = ibuf->x * y + x;
719         float vec[3], p0[3], p1[3], n[3], len;
720
721         lores_dm->getTessFace(lores_dm, face_index, &mface);
722
723         st0 = mtface[face_index].uv[0];
724         st1 = mtface[face_index].uv[1];
725         st2 = mtface[face_index].uv[2];
726
727         if (mface.v4) {
728                 st3 = mtface[face_index].uv[3];
729                 resolve_quad_uv(uv, st, st0, st1, st2, st3);
730         }
731         else
732                 resolve_tri_uv(uv, st, st0, st1, st2);
733
734         CLAMP(uv[0], 0.0f, 1.0f);
735         CLAMP(uv[1], 0.0f, 1.0f);
736
737         get_ccgdm_data(lores_dm, hires_dm, height_data->origindex, lvl, face_index, uv[0], uv[1], p1, 0);
738
739         if (height_data->ssdm) {
740                 get_ccgdm_data(lores_dm, height_data->ssdm, height_data->origindex, 0, face_index, uv[0], uv[1], p0, n);
741         }
742         else {
743                 lores_dm->getTessFace(lores_dm, face_index, &mface);
744
745                 if (mface.v4) {
746                         interp_bilinear_mface(lores_dm, &mface, uv[0], uv[1], 1, p0);
747                         interp_bilinear_mface(lores_dm, &mface, uv[0], uv[1], 0, n);
748                 }
749                 else {
750                         interp_barycentric_mface(lores_dm, &mface, uv[0], uv[1], 1, p0);
751                         interp_barycentric_mface(lores_dm, &mface, uv[0], uv[1], 0, n);
752                 }
753         }
754
755         sub_v3_v3v3(vec, p1, p0);
756         len = dot_v3v3(n, vec);
757
758         height_data->heights[pixel] = len;
759         if (len < height_data->height_min) height_data->height_min = len;
760         if (len > height_data->height_max) height_data->height_max = len;
761
762         if (ibuf->rect_float) {
763                 float *rrgbf = ibuf->rect_float + pixel * 4;
764                 rrgbf[3] = 1.0f;
765
766                 ibuf->userflags = IB_RECT_INVALID;
767         }
768         else {
769                 char *rrgb = (char *)ibuf->rect + pixel * 4;
770                 rrgb[3] = 255;
771         }
772 }
773
774 /* MultiresBake callback for normals' baking
775  * general idea:
776  *   - find coord and normal of point with specified UV in hi-res mesh
777  *   - multiply it by tangmat
778  *   - vector in color space would be norm(vec) /2 + (0.5, 0.5, 0.5) */
779 static void apply_tangmat_callback(DerivedMesh *lores_dm, DerivedMesh *hires_dm, const void *bake_data,
780                                    const int face_index, const int lvl, const float st[2],
781                                    float tangmat[3][3], const int x, const int y)
782 {
783         MTFace *mtface = CustomData_get_layer(&lores_dm->faceData, CD_MTFACE);
784         MFace mface;
785         Image *ima = mtface[face_index].tpage;
786         ImBuf *ibuf = BKE_image_get_ibuf(ima, NULL);
787         MNormalBakeData *normal_data = (MNormalBakeData *)bake_data;
788         float uv[2], *st0, *st1, *st2, *st3;
789         int pixel = ibuf->x * y + x;
790         float n[3], vec[3], tmp[3] = {0.5, 0.5, 0.5};
791
792         lores_dm->getTessFace(lores_dm, face_index, &mface);
793
794         st0 = mtface[face_index].uv[0];
795         st1 = mtface[face_index].uv[1];
796         st2 = mtface[face_index].uv[2];
797
798         if (mface.v4) {
799                 st3 = mtface[face_index].uv[3];
800                 resolve_quad_uv(uv, st, st0, st1, st2, st3);
801         }
802         else
803                 resolve_tri_uv(uv, st, st0, st1, st2);
804
805         CLAMP(uv[0], 0.0f, 1.0f);
806         CLAMP(uv[1], 0.0f, 1.0f);
807
808         get_ccgdm_data(lores_dm, hires_dm, normal_data->origindex, lvl, face_index, uv[0], uv[1], NULL, n);
809
810         mul_v3_m3v3(vec, tangmat, n);
811         normalize_v3(vec);
812         mul_v3_fl(vec, 0.5);
813         add_v3_v3(vec, tmp);
814
815         if (ibuf->rect_float) {
816                 float *rrgbf = ibuf->rect_float + pixel * 4;
817                 rrgbf[0] = vec[0];
818                 rrgbf[1] = vec[1];
819                 rrgbf[2] = vec[2];
820                 rrgbf[3] = 1.0f;
821
822                 ibuf->userflags = IB_RECT_INVALID;
823         }
824         else {
825                 unsigned char *rrgb = (unsigned char *)ibuf->rect + pixel * 4;
826                 rgb_float_to_uchar(rrgb, vec);
827                 rrgb[3] = 255;
828         }
829 }
830
831 static void count_images(MultiresBakeRender *bkr)
832 {
833         int a, totface;
834         DerivedMesh *dm = bkr->lores_dm;
835         MTFace *mtface = CustomData_get_layer(&dm->faceData, CD_MTFACE);
836
837         bkr->image.first = bkr->image.last = NULL;
838         bkr->tot_image = 0;
839
840         totface = dm->getNumTessFaces(dm);
841
842         for (a = 0; a < totface; a++)
843                 mtface[a].tpage->id.flag &= ~LIB_DOIT;
844
845         for (a = 0; a < totface; a++) {
846                 Image *ima = mtface[a].tpage;
847                 if ((ima->id.flag & LIB_DOIT) == 0) {
848                         LinkData *data = BLI_genericNodeN(ima);
849                         BLI_addtail(&bkr->image, data);
850                         bkr->tot_image++;
851                         ima->id.flag |= LIB_DOIT;
852                 }
853         }
854
855         for (a = 0; a < totface; a++)
856                 mtface[a].tpage->id.flag &= ~LIB_DOIT;
857 }
858
859 static void bake_images(MultiresBakeRender *bkr)
860 {
861         LinkData *link;
862
863         for (link = bkr->image.first; link; link = link->next) {
864                 Image *ima = (Image *)link->data;
865                 ImBuf *ibuf = BKE_image_get_ibuf(ima, NULL);
866
867                 if (ibuf->x > 0 && ibuf->y > 0) {
868                         ibuf->userdata = MEM_callocN(ibuf->y * ibuf->x, "MultiresBake imbuf mask");
869
870                         switch (bkr->mode) {
871                                 case RE_BAKE_NORMALS:
872                                         do_multires_bake(bkr, ima, apply_tangmat_callback, init_normal_data, NULL, free_normal_data);
873                                         break;
874                                 case RE_BAKE_DISPLACEMENT:
875                                         do_multires_bake(bkr, ima, apply_heights_callback, init_heights_data,
876                                                          apply_heights_data, free_heights_data);
877                                         break;
878                         }
879                 }
880
881                 ima->id.flag |= LIB_DOIT;
882         }
883 }
884
885 static void finish_images(MultiresBakeRender *bkr)
886 {
887         LinkData *link;
888
889         for (link = bkr->image.first; link; link = link->next) {
890                 Image *ima = (Image *)link->data;
891                 ImBuf *ibuf = BKE_image_get_ibuf(ima, NULL);
892
893                 if (ibuf->x <= 0 || ibuf->y <= 0)
894                         continue;
895
896                 RE_bake_ibuf_filter(ibuf, (char *)ibuf->userdata, bkr->bake_filter);
897
898                 ibuf->userflags |= IB_BITMAPDIRTY;
899
900                 if (ibuf->rect_float)
901                         ibuf->userflags |= IB_RECT_INVALID;
902
903                 if (ibuf->mipmap[0]) {
904                         ibuf->userflags |= IB_MIPMAP_INVALID;
905                         imb_freemipmapImBuf(ibuf);
906                 }
907
908                 if (ibuf->userdata) {
909                         MEM_freeN(ibuf->userdata);
910                         ibuf->userdata = NULL;
911                 }
912         }
913 }
914
915 static void multiresbake_start(MultiresBakeRender *bkr)
916 {
917         count_images(bkr);
918         bake_images(bkr);
919         finish_images(bkr);
920 }
921
922 static int multiresbake_check(bContext *C, wmOperator *op)
923 {
924         Scene *scene = CTX_data_scene(C);
925         Object *ob;
926         Mesh *me;
927         MultiresModifierData *mmd;
928         int ok = 1, a;
929
930         CTX_DATA_BEGIN (C, Base *, base, selected_editable_bases)
931         {
932                 ob = base->object;
933
934                 if (ob->type != OB_MESH) {
935                         BKE_report(op->reports, RPT_ERROR, "Basking of multires data only works with active object which is a mesh");
936
937                         ok = 0;
938                         break;
939                 }
940
941                 me = (Mesh *)ob->data;
942                 mmd = get_multires_modifier(scene, ob, 0);
943
944                 /* Multi-resolution should be and be last in the stack */
945                 if (ok && mmd) {
946                         ModifierData *md;
947
948                         ok = mmd->totlvl > 0;
949
950                         for (md = (ModifierData *)mmd->modifier.next; md && ok; md = md->next) {
951                                 if (modifier_isEnabled(scene, md, eModifierMode_Realtime)) {
952                                         ok = 0;
953                                 }
954                         }
955                 }
956                 else ok = 0;
957
958                 if (!ok) {
959                         BKE_report(op->reports, RPT_ERROR, "Multires data baking requires multi-resolution object");
960
961                         break;
962                 }
963
964                 if (!me->mtpoly) {
965                         BKE_report(op->reports, RPT_ERROR, "Mesh should be unwrapped before multires data baking");
966
967                         ok = 0;
968                 }
969                 else {
970                         a = me->totpoly;
971                         while (ok && a--) {
972                                 Image *ima = me->mtpoly[a].tpage;
973
974                                 if (!ima) {
975                                         BKE_report(op->reports, RPT_ERROR, "You should have active texture to use multires baker");
976
977                                         ok = 0;
978                                 }
979                                 else {
980                                         ImBuf *ibuf = BKE_image_get_ibuf(ima, NULL);
981
982                                         if (!ibuf) {
983                                                 BKE_report(op->reports, RPT_ERROR, "Baking should happend to image with image buffer");
984
985                                                 ok = 0;
986                                         }
987                                         else {
988                                                 if (ibuf->rect == NULL && ibuf->rect_float == NULL)
989                                                         ok = 0;
990
991                                                 if (ibuf->rect_float && !(ibuf->channels == 0 || ibuf->channels == 4))
992                                                         ok = 0;
993
994                                                 if (!ok)
995                                                         BKE_report(op->reports, RPT_ERROR, "Baking to unsupported image type");
996                                         }
997                                 }
998                         }
999                 }
1000
1001                 if (!ok)
1002                         break;
1003         }
1004         CTX_DATA_END;
1005
1006         return ok;
1007 }
1008
1009 static DerivedMesh *multiresbake_create_loresdm(Scene *scene, Object *ob, int *lvl)
1010 {
1011         DerivedMesh *dm;
1012         MultiresModifierData *mmd = get_multires_modifier(scene, ob, 0);
1013         Mesh *me = (Mesh *)ob->data;
1014
1015         *lvl = mmd->lvl;
1016
1017         if (*lvl == 0) {
1018                 DerivedMesh *tmp_dm = CDDM_from_mesh(me, ob);
1019                 dm = CDDM_copy(tmp_dm);
1020                 tmp_dm->release(tmp_dm);
1021         }
1022         else {
1023                 MultiresModifierData tmp_mmd = *mmd;
1024                 DerivedMesh *cddm = CDDM_from_mesh(me, ob);
1025
1026                 tmp_mmd.lvl = *lvl;
1027                 tmp_mmd.sculptlvl = *lvl;
1028                 dm = multires_make_derived_from_derived(cddm, &tmp_mmd, ob,
1029                                                         MULTIRES_USE_LOCAL_MMD);
1030                 cddm->release(cddm);
1031         }
1032
1033         return dm;
1034 }
1035
1036 static DerivedMesh *multiresbake_create_hiresdm(Scene *scene, Object *ob, int *lvl, int *simple)
1037 {
1038         Mesh *me = (Mesh *)ob->data;
1039         MultiresModifierData *mmd = get_multires_modifier(scene, ob, 0);
1040         MultiresModifierData tmp_mmd = *mmd;
1041         DerivedMesh *cddm = CDDM_from_mesh(me, ob);
1042         DerivedMesh *dm;
1043
1044         *lvl = mmd->totlvl;
1045         *simple = mmd->simple;
1046
1047         tmp_mmd.lvl = mmd->totlvl;
1048         tmp_mmd.sculptlvl = mmd->totlvl;
1049         dm = multires_make_derived_from_derived(cddm, &tmp_mmd, ob,
1050                                                 MULTIRES_USE_LOCAL_MMD);
1051         cddm->release(cddm);
1052
1053         return dm;
1054 }
1055
1056 static void clear_images(MTFace *mtface, int totface)
1057 {
1058         int a;
1059         const float vec_alpha[4] = {0.0f, 0.0f, 0.0f, 0.0f};
1060         const float vec_solid[4] = {0.0f, 0.0f, 0.0f, 1.0f};
1061
1062         for (a = 0; a < totface; a++)
1063                 mtface[a].tpage->id.flag &= ~LIB_DOIT;
1064
1065         for (a = 0; a < totface; a++) {
1066                 Image *ima = mtface[a].tpage;
1067
1068                 if ((ima->id.flag & LIB_DOIT) == 0) {
1069                         ImBuf *ibuf = BKE_image_get_ibuf(ima, NULL);
1070
1071                         IMB_rectfill(ibuf, (ibuf->planes == R_IMF_PLANES_RGBA) ? vec_alpha : vec_solid);
1072                         ima->id.flag |= LIB_DOIT;
1073                 }
1074         }
1075
1076         for (a = 0; a < totface; a++)
1077                 mtface[a].tpage->id.flag &= ~LIB_DOIT;
1078 }
1079
1080 static int multiresbake_image_exec_locked(bContext *C, wmOperator *op)
1081 {
1082         Object *ob;
1083         Scene *scene = CTX_data_scene(C);
1084         int objects_baked = 0;
1085
1086         if (!multiresbake_check(C, op))
1087                 return OPERATOR_CANCELLED;
1088
1089         if (scene->r.bake_flag & R_BAKE_CLEAR) {  /* clear images */
1090                 CTX_DATA_BEGIN (C, Base *, base, selected_editable_bases)
1091                 {
1092                         Mesh *me;
1093
1094                         ob = base->object;
1095                         me = (Mesh *)ob->data;
1096
1097                         clear_images(me->mtface, me->totface);
1098                 }
1099                 CTX_DATA_END;
1100         }
1101
1102         CTX_DATA_BEGIN (C, Base *, base, selected_editable_bases)
1103         {
1104                 MultiresBakeRender bkr = {0};
1105
1106                 ob = base->object;
1107
1108                 multires_force_update(ob);
1109
1110                 /* copy data stored in job descriptor */
1111                 bkr.bake_filter = scene->r.bake_filter;
1112                 bkr.mode = scene->r.bake_mode;
1113                 bkr.use_lores_mesh = scene->r.bake_flag & R_BAKE_LORES_MESH;
1114
1115                 /* create low-resolution DM (to bake to) and hi-resolution DM (to bake from) */
1116                 bkr.lores_dm = multiresbake_create_loresdm(scene, ob, &bkr.lvl);
1117
1118                 if (!bkr.lores_dm)
1119                         continue;
1120
1121                 bkr.hires_dm = multiresbake_create_hiresdm(scene, ob, &bkr.tot_lvl, &bkr.simple);
1122
1123                 multiresbake_start(&bkr);
1124
1125                 BLI_freelistN(&bkr.image);
1126
1127                 bkr.lores_dm->release(bkr.lores_dm);
1128                 bkr.hires_dm->release(bkr.hires_dm);
1129
1130                 objects_baked++;
1131         }
1132         CTX_DATA_END;
1133
1134         if (!objects_baked)
1135                 BKE_report(op->reports, RPT_ERROR, "No objects found to bake from");
1136
1137         return OPERATOR_FINISHED;
1138 }
1139
1140 /* Multiresbake adopted for job-system executing */
1141 static void init_multiresbake_job(bContext *C, MultiresBakeJob *bkj)
1142 {
1143         Scene *scene = CTX_data_scene(C);
1144         Object *ob;
1145
1146         /* backup scene settings, so their changing in UI would take no effect on baker */
1147         bkj->bake_filter = scene->r.bake_filter;
1148         bkj->mode = scene->r.bake_mode;
1149         bkj->use_lores_mesh = scene->r.bake_flag & R_BAKE_LORES_MESH;
1150         bkj->bake_clear = scene->r.bake_flag & R_BAKE_CLEAR;
1151
1152         CTX_DATA_BEGIN (C, Base *, base, selected_editable_bases)
1153         {
1154                 MultiresBakerJobData *data;
1155                 DerivedMesh *lores_dm;
1156                 int lvl;
1157                 ob = base->object;
1158
1159                 multires_force_update(ob);
1160
1161                 lores_dm = multiresbake_create_loresdm(scene, ob, &lvl);
1162                 if (!lores_dm)
1163                         continue;
1164
1165                 data = MEM_callocN(sizeof(MultiresBakerJobData), "multiresBaker derivedMesh_data");
1166                 data->lores_dm = lores_dm;
1167                 data->lvl = lvl;
1168                 data->hires_dm = multiresbake_create_hiresdm(scene, ob, &data->tot_lvl, &data->simple);
1169
1170                 BLI_addtail(&bkj->data, data);
1171         }
1172         CTX_DATA_END;
1173 }
1174
1175 static void multiresbake_startjob(void *bkv, short *stop, short *do_update, float *progress)
1176 {
1177         MultiresBakerJobData *data;
1178         MultiresBakeJob *bkj = bkv;
1179         int baked_objects = 0, tot_obj;
1180
1181         tot_obj = BLI_countlist(&bkj->data);
1182
1183         if (bkj->bake_clear) {  /* clear images */
1184                 for (data = bkj->data.first; data; data = data->next) {
1185                         DerivedMesh *dm = data->lores_dm;
1186                         MTFace *mtface = CustomData_get_layer(&dm->faceData, CD_MTFACE);
1187
1188                         clear_images(mtface, dm->getNumTessFaces(dm));
1189                 }
1190         }
1191
1192         for (data = bkj->data.first; data; data = data->next) {
1193                 MultiresBakeRender bkr = {0};
1194
1195                 /* copy data stored in job descriptor */
1196                 bkr.bake_filter = bkj->bake_filter;
1197                 bkr.mode = bkj->mode;
1198                 bkr.use_lores_mesh = bkj->use_lores_mesh;
1199
1200                 /* create low-resolution DM (to bake to) and hi-resolution DM (to bake from) */
1201                 bkr.lores_dm = data->lores_dm;
1202                 bkr.hires_dm = data->hires_dm;
1203                 bkr.tot_lvl = data->tot_lvl;
1204                 bkr.lvl = data->lvl;
1205                 bkr.simple = data->simple;
1206
1207                 /* needed for proper progress bar */
1208                 bkr.tot_obj = tot_obj;
1209                 bkr.baked_objects = baked_objects;
1210
1211                 bkr.stop = stop;
1212                 bkr.do_update = do_update;
1213                 bkr.progress = progress;
1214
1215                 multiresbake_start(&bkr);
1216
1217                 BLI_freelistN(&bkr.image);
1218
1219                 baked_objects++;
1220         }
1221 }
1222
1223 static void multiresbake_freejob(void *bkv)
1224 {
1225         MultiresBakeJob *bkj = bkv;
1226         MultiresBakerJobData *data, *next;
1227
1228         data = bkj->data.first;
1229         while (data) {
1230                 next = data->next;
1231                 data->lores_dm->release(data->lores_dm);
1232                 data->hires_dm->release(data->hires_dm);
1233                 MEM_freeN(data);
1234                 data = next;
1235         }
1236
1237         MEM_freeN(bkj);
1238 }
1239
1240 static int multiresbake_image_exec(bContext *C, wmOperator *op)
1241 {
1242         Scene *scene = CTX_data_scene(C);
1243         MultiresBakeJob *bkr;
1244         wmJob *wm_job;
1245
1246         if (!multiresbake_check(C, op))
1247                 return OPERATOR_CANCELLED;
1248
1249         bkr = MEM_callocN(sizeof(MultiresBakeJob), "MultiresBakeJob data");
1250         init_multiresbake_job(C, bkr);
1251
1252         if (!bkr->data.first) {
1253                 BKE_report(op->reports, RPT_ERROR, "No objects found to bake from");
1254                 return OPERATOR_CANCELLED;
1255         }
1256
1257         /* setup job */
1258         wm_job = WM_jobs_get(CTX_wm_manager(C), CTX_wm_window(C), scene, "Multires Bake",
1259                              WM_JOB_EXCL_RENDER | WM_JOB_PRIORITY | WM_JOB_PROGRESS, WM_JOB_TYPE_OBJECT_BAKE_TEXTURE);
1260         WM_jobs_customdata_set(wm_job, bkr, multiresbake_freejob);
1261         WM_jobs_timer(wm_job, 0.2, NC_IMAGE, 0); /* TODO - only draw bake image, can we enforce this */
1262         WM_jobs_callbacks(wm_job, multiresbake_startjob, NULL, NULL, NULL);
1263
1264         G.is_break = FALSE;
1265
1266         WM_jobs_start(CTX_wm_manager(C), wm_job);
1267         WM_cursor_wait(0);
1268
1269         /* add modal handler for ESC */
1270         WM_event_add_modal_handler(C, op);
1271
1272         return OPERATOR_RUNNING_MODAL;
1273 }
1274
1275 /* ****************** render BAKING ********************** */
1276
1277 /* threaded break test */
1278 static int thread_break(void *UNUSED(arg))
1279 {
1280         return G.is_break;
1281 }
1282
1283 typedef struct BakeRender {
1284         Render *re;
1285         Main *main;
1286         Scene *scene;
1287         struct Object *actob;
1288         int result, ready;
1289
1290         ReportList *reports;
1291
1292         short *stop;
1293         short *do_update;
1294         float *progress;
1295         
1296         ListBase threads;
1297
1298         /* backup */
1299         short prev_wo_amb_occ;
1300         short prev_r_raytrace;
1301
1302         /* for redrawing */
1303         ScrArea *sa;
1304 } BakeRender;
1305
1306 /* use by exec and invoke */
1307 static int test_bake_internal(bContext *C, ReportList *reports)
1308 {
1309         Scene *scene = CTX_data_scene(C);
1310
1311         if ((scene->r.bake_flag & R_BAKE_TO_ACTIVE) && CTX_data_active_object(C) == NULL) {
1312                 BKE_report(reports, RPT_ERROR, "No active object");
1313         }
1314         else if (scene->r.bake_mode == RE_BAKE_AO && scene->world == NULL) {
1315                 BKE_report(reports, RPT_ERROR, "No world set up");
1316         }
1317         else {
1318                 return 1;
1319         }
1320
1321         return 0;
1322 }
1323
1324 static void init_bake_internal(BakeRender *bkr, bContext *C)
1325 {
1326         Scene *scene = CTX_data_scene(C);
1327
1328         /* get editmode results */
1329         ED_object_exit_editmode(C, 0);  /* 0 = does not exit editmode */
1330
1331         bkr->sa = BKE_screen_find_big_area(CTX_wm_screen(C), SPACE_IMAGE, 10); /* can be NULL */
1332         bkr->main = CTX_data_main(C);
1333         bkr->scene = scene;
1334         bkr->actob = (scene->r.bake_flag & R_BAKE_TO_ACTIVE) ? OBACT : NULL;
1335         bkr->re = RE_NewRender("_Bake View_");
1336
1337         if (scene->r.bake_mode == RE_BAKE_AO) {
1338                 /* If raytracing or AO is disabled, switch it on temporarily for baking. */
1339                 bkr->prev_wo_amb_occ = (scene->world->mode & WO_AMB_OCC) != 0;
1340                 scene->world->mode |= WO_AMB_OCC;
1341         }
1342         if (scene->r.bake_mode == RE_BAKE_AO || bkr->actob) {
1343                 bkr->prev_r_raytrace = (scene->r.mode & R_RAYTRACE) != 0;
1344                 scene->r.mode |= R_RAYTRACE;
1345         }
1346 }
1347
1348 static void finish_bake_internal(BakeRender *bkr)
1349 {
1350         Image *ima;
1351
1352         RE_Database_Free(bkr->re);
1353
1354         /* restore raytrace and AO */
1355         if (bkr->scene->r.bake_mode == RE_BAKE_AO)
1356                 if (bkr->prev_wo_amb_occ == 0)
1357                         bkr->scene->world->mode &= ~WO_AMB_OCC;
1358
1359         if (bkr->scene->r.bake_mode == RE_BAKE_AO || bkr->actob)
1360                 if (bkr->prev_r_raytrace == 0)
1361                         bkr->scene->r.mode &= ~R_RAYTRACE;
1362
1363
1364         /* force OpenGL reload and mipmap recalc */
1365         for (ima = G.main->image.first; ima; ima = ima->id.next) {
1366                 ImBuf *ibuf = BKE_image_get_ibuf(ima, NULL);
1367
1368                 if (bkr->result == BAKE_RESULT_OK) {
1369                         if (ima->ok == IMA_OK_LOADED) {
1370                                 if (ibuf) {
1371                                         if (ibuf->userflags & IB_BITMAPDIRTY) {
1372                                                 GPU_free_image(ima);
1373                                                 imb_freemipmapImBuf(ibuf);
1374                                         }
1375                                 }
1376                         }
1377                 }
1378
1379                 /* freed when baking is done, but if its canceled we need to free here */
1380                 if (ibuf->userdata) {
1381                         MEM_freeN(ibuf->userdata);
1382                         ibuf->userdata = NULL;
1383                 }
1384         }
1385 }
1386
1387 static void *do_bake_render(void *bake_v)
1388 {
1389         BakeRender *bkr = bake_v;
1390
1391         bkr->result = RE_bake_shade_all_selected(bkr->re, bkr->scene->r.bake_mode, bkr->actob, NULL, bkr->progress);
1392         bkr->ready = 1;
1393
1394         return NULL;
1395 }
1396
1397 static void bake_startjob(void *bkv, short *stop, short *do_update, float *progress)
1398 {
1399         BakeRender *bkr = bkv;
1400         Scene *scene = bkr->scene;
1401         Main *bmain = bkr->main;
1402
1403         bkr->stop = stop;
1404         bkr->do_update = do_update;
1405         bkr->progress = progress;
1406
1407         RE_test_break_cb(bkr->re, NULL, thread_break);
1408         G.is_break = FALSE;   /* blender_test_break uses this global */
1409
1410         RE_Database_Baking(bkr->re, bmain, scene, scene->lay, scene->r.bake_mode, bkr->actob);
1411
1412         /* baking itself is threaded, cannot use test_break in threads. we also update optional imagewindow */
1413         bkr->result = RE_bake_shade_all_selected(bkr->re, scene->r.bake_mode, bkr->actob, bkr->do_update, bkr->progress);
1414 }
1415
1416 static void bake_update(void *bkv)
1417 {
1418         BakeRender *bkr = bkv;
1419
1420         if (bkr->sa && bkr->sa->spacetype == SPACE_IMAGE) { /* in case the user changed while baking */
1421                 SpaceImage *sima = bkr->sa->spacedata.first;
1422                 if (sima)
1423                         sima->image = RE_bake_shade_get_image();
1424         }
1425 }
1426
1427 static void bake_freejob(void *bkv)
1428 {
1429         BakeRender *bkr = bkv;
1430         finish_bake_internal(bkr);
1431
1432         if (bkr->result == BAKE_RESULT_NO_OBJECTS)
1433                 BKE_report(bkr->reports, RPT_ERROR, "No objects or images found to bake to");
1434         else if (bkr->result == BAKE_RESULT_FEEDBACK_LOOP)
1435                 BKE_report(bkr->reports, RPT_WARNING, "Feedback loop detected");
1436
1437         MEM_freeN(bkr);
1438         G.is_rendering = FALSE;
1439 }
1440
1441 /* catch esc */
1442 static int objects_bake_render_modal(bContext *C, wmOperator *UNUSED(op), wmEvent *event)
1443 {
1444         /* no running blender, remove handler and pass through */
1445         if (0 == WM_jobs_test(CTX_wm_manager(C), CTX_data_scene(C), WM_JOB_TYPE_OBJECT_BAKE_TEXTURE))
1446                 return OPERATOR_FINISHED | OPERATOR_PASS_THROUGH;
1447
1448         /* running render */
1449         switch (event->type) {
1450                 case ESCKEY:
1451                         return OPERATOR_RUNNING_MODAL;
1452                         break;
1453         }
1454         return OPERATOR_PASS_THROUGH;
1455 }
1456
1457 static int is_multires_bake(Scene *scene)
1458 {
1459         if (ELEM(scene->r.bake_mode, RE_BAKE_NORMALS, RE_BAKE_DISPLACEMENT))
1460                 return scene->r.bake_flag & R_BAKE_MULTIRES;
1461
1462         return 0;
1463 }
1464
1465 static int objects_bake_render_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(_event))
1466 {
1467         Scene *scene = CTX_data_scene(C);
1468         int result = OPERATOR_CANCELLED;
1469
1470         if (is_multires_bake(scene)) {
1471                 result = multiresbake_image_exec(C, op);
1472         }
1473         else {
1474                 /* only one render job at a time */
1475                 if (WM_jobs_test(CTX_wm_manager(C), scene, WM_JOB_TYPE_OBJECT_BAKE_TEXTURE))
1476                         return OPERATOR_CANCELLED;
1477
1478                 if (test_bake_internal(C, op->reports) == 0) {
1479                         return OPERATOR_CANCELLED;
1480                 }
1481                 else {
1482                         BakeRender *bkr = MEM_callocN(sizeof(BakeRender), "render bake");
1483                         wmJob *wm_job;
1484
1485                         init_bake_internal(bkr, C);
1486                         bkr->reports = op->reports;
1487
1488                         /* setup job */
1489                         wm_job = WM_jobs_get(CTX_wm_manager(C), CTX_wm_window(C), scene, "Texture Bake",
1490                                              WM_JOB_EXCL_RENDER | WM_JOB_PRIORITY | WM_JOB_PROGRESS, WM_JOB_TYPE_OBJECT_BAKE_TEXTURE);
1491                         WM_jobs_customdata_set(wm_job, bkr, bake_freejob);
1492                         WM_jobs_timer(wm_job, 0.2, NC_IMAGE, 0); /* TODO - only draw bake image, can we enforce this */
1493                         WM_jobs_callbacks(wm_job, bake_startjob, NULL, bake_update, NULL);
1494
1495                         G.is_break = FALSE;
1496                         G.is_rendering = TRUE;
1497
1498                         WM_jobs_start(CTX_wm_manager(C), wm_job);
1499
1500                         WM_cursor_wait(0);
1501
1502                         /* add modal handler for ESC */
1503                         WM_event_add_modal_handler(C, op);
1504                 }
1505
1506                 result = OPERATOR_RUNNING_MODAL;
1507         }
1508
1509         WM_event_add_notifier(C, NC_SCENE | ND_RENDER_RESULT, scene);
1510
1511         return result;
1512 }
1513
1514
1515 static int bake_image_exec(bContext *C, wmOperator *op)
1516 {
1517         Main *bmain = CTX_data_main(C);
1518         Scene *scene = CTX_data_scene(C);
1519         int result = OPERATOR_CANCELLED;
1520
1521         if (is_multires_bake(scene)) {
1522                 result = multiresbake_image_exec_locked(C, op);
1523         }
1524         else {
1525                 if (test_bake_internal(C, op->reports) == 0) {
1526                         return OPERATOR_CANCELLED;
1527                 }
1528                 else {
1529                         ListBase threads;
1530                         BakeRender bkr = {NULL};
1531
1532                         init_bake_internal(&bkr, C);
1533                         bkr.reports = op->reports;
1534
1535                         RE_test_break_cb(bkr.re, NULL, thread_break);
1536                         G.is_break = FALSE;   /* blender_test_break uses this global */
1537
1538                         RE_Database_Baking(bkr.re, bmain, scene, scene->lay, scene->r.bake_mode, (scene->r.bake_flag & R_BAKE_TO_ACTIVE) ? OBACT : NULL);
1539
1540                         /* baking itself is threaded, cannot use test_break in threads  */
1541                         BLI_init_threads(&threads, do_bake_render, 1);
1542                         bkr.ready = 0;
1543                         BLI_insert_thread(&threads, &bkr);
1544
1545                         while (bkr.ready == 0) {
1546                                 PIL_sleep_ms(50);
1547                                 if (bkr.ready)
1548                                         break;
1549
1550                                 /* used to redraw in 2.4x but this is just for exec in 2.5 */
1551                                 if (!G.background)
1552                                         blender_test_break();
1553                         }
1554                         BLI_end_threads(&threads);
1555
1556                         if (bkr.result == BAKE_RESULT_NO_OBJECTS)
1557                                 BKE_report(op->reports, RPT_ERROR, "No valid images found to bake to");
1558                         else if (bkr.result == BAKE_RESULT_FEEDBACK_LOOP)
1559                                 BKE_report(op->reports, RPT_ERROR, "Feedback loop detected");
1560
1561                         finish_bake_internal(&bkr);
1562
1563                         result = OPERATOR_FINISHED;
1564                 }
1565         }
1566
1567         WM_event_add_notifier(C, NC_SCENE | ND_RENDER_RESULT, scene);
1568
1569         return result;
1570 }
1571
1572 void OBJECT_OT_bake_image(wmOperatorType *ot)
1573 {
1574         /* identifiers */
1575         ot->name = "Bake";
1576         ot->description = "Bake image textures of selected objects";
1577         ot->idname = "OBJECT_OT_bake_image";
1578
1579         /* api callbacks */
1580         ot->exec = bake_image_exec;
1581         ot->invoke = objects_bake_render_invoke;
1582         ot->modal = objects_bake_render_modal;
1583 }