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