Cleanup: style, use braces for editors
[blender.git] / source / blender / editors / object / object_bake.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2004 by Blender Foundation
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup edobj
22  */
23
24 #include <string.h>
25
26 #include "MEM_guardedalloc.h"
27
28 #include "DNA_scene_types.h"
29 #include "DNA_screen_types.h"
30 #include "DNA_space_types.h"
31 #include "DNA_world_types.h"
32 #include "DNA_object_types.h"
33 #include "DNA_mesh_types.h"
34 #include "DNA_meshdata_types.h"
35
36 #include "BLI_blenlib.h"
37 #include "BLI_utildefines.h"
38
39 #include "BKE_blender.h"
40 #include "BKE_context.h"
41 #include "BKE_global.h"
42 #include "BKE_image.h"
43 #include "BKE_material.h"
44 #include "BKE_multires.h"
45 #include "BKE_report.h"
46 #include "BKE_cdderivedmesh.h"
47 #include "BKE_modifier.h"
48 #include "BKE_DerivedMesh.h"
49 #include "BKE_mesh.h"
50 #include "BKE_scene.h"
51
52 #include "DEG_depsgraph.h"
53
54 #include "RE_pipeline.h"
55 #include "RE_shader_ext.h"
56 #include "RE_multires_bake.h"
57
58 #include "PIL_time.h"
59
60 #include "IMB_imbuf_types.h"
61 #include "IMB_imbuf.h"
62
63 #include "GPU_draw.h" /* GPU_free_image */
64
65 #include "WM_api.h"
66 #include "WM_types.h"
67
68 #include "ED_object.h"
69 #include "ED_screen.h"
70 #include "ED_uvedit.h"
71
72 #include "object_intern.h"
73
74 static Image *bake_object_image_get(Object *ob, int mat_nr)
75 {
76   Image *image = NULL;
77   ED_object_get_active_image(ob, mat_nr + 1, &image, NULL, NULL, NULL);
78   return image;
79 }
80
81 static Image **bake_object_image_get_array(Object *ob)
82 {
83   Image **image_array = MEM_mallocN(sizeof(Material *) * ob->totcol, __func__);
84   for (int i = 0; i < ob->totcol; i++) {
85     image_array[i] = bake_object_image_get(ob, i);
86   }
87   return image_array;
88 }
89
90 /* ****************** multires BAKING ********************** */
91
92 /* holder of per-object data needed for bake job
93  * needed to make job totally thread-safe */
94 typedef struct MultiresBakerJobData {
95   struct MultiresBakerJobData *next, *prev;
96   /* material aligned image array (for per-face bake image) */
97   struct {
98     Image **array;
99     int len;
100   } ob_image;
101   DerivedMesh *lores_dm, *hires_dm;
102   bool simple;
103   int lvl, tot_lvl;
104   ListBase images;
105 } MultiresBakerJobData;
106
107 /* data passing to multires-baker job */
108 typedef struct {
109   Scene *scene;
110   ListBase data;
111   /** Clear the images before baking */
112   bool bake_clear;
113   /** Bake-filter, aka margin */
114   int bake_filter;
115   /** mode of baking (displacement, normals, AO) */
116   short mode;
117   /** Use low-resolution mesh when baking displacement maps */
118   bool use_lores_mesh;
119   /** Number of rays to be cast when doing AO baking */
120   int number_of_rays;
121   /** Bias between object and start ray point when doing AO baking */
122   float bias;
123   /** Number of threads to be used for baking */
124   int threads;
125   /** User scale used to scale displacement when baking derivative map. */
126   float user_scale;
127 } MultiresBakeJob;
128
129 static bool multiresbake_check(bContext *C, wmOperator *op)
130 {
131   Scene *scene = CTX_data_scene(C);
132   Object *ob;
133   Mesh *me;
134   MultiresModifierData *mmd;
135   bool ok = true;
136   int a;
137
138   CTX_DATA_BEGIN (C, Base *, base, selected_editable_bases) {
139     ob = base->object;
140
141     if (ob->type != OB_MESH) {
142       BKE_report(
143           op->reports, RPT_ERROR, "Baking of multires data only works with an active mesh object");
144
145       ok = false;
146       break;
147     }
148
149     me = (Mesh *)ob->data;
150     mmd = get_multires_modifier(scene, ob, 0);
151
152     /* Multi-resolution should be and be last in the stack */
153     if (ok && mmd) {
154       ModifierData *md;
155
156       ok = mmd->totlvl > 0;
157
158       for (md = (ModifierData *)mmd->modifier.next; md && ok; md = md->next) {
159         if (modifier_isEnabled(scene, md, eModifierMode_Realtime)) {
160           ok = false;
161         }
162       }
163     }
164     else {
165       ok = false;
166     }
167
168     if (!ok) {
169       BKE_report(op->reports, RPT_ERROR, "Multires data baking requires multi-resolution object");
170
171       break;
172     }
173
174     if (!me->mloopuv) {
175       BKE_report(op->reports, RPT_ERROR, "Mesh should be unwrapped before multires data baking");
176
177       ok = false;
178     }
179     else {
180       a = me->totpoly;
181       while (ok && a--) {
182         Image *ima = bake_object_image_get(ob, me->mpoly[a].mat_nr);
183
184         if (!ima) {
185           BKE_report(
186               op->reports, RPT_ERROR, "You should have active texture to use multires baker");
187
188           ok = false;
189         }
190         else {
191           ImBuf *ibuf = BKE_image_acquire_ibuf(ima, NULL, NULL);
192
193           if (!ibuf) {
194             BKE_report(op->reports, RPT_ERROR, "Baking should happen to image with image buffer");
195
196             ok = false;
197           }
198           else {
199             if (ibuf->rect == NULL && ibuf->rect_float == NULL) {
200               ok = false;
201             }
202
203             if (ibuf->rect_float && !(ibuf->channels == 0 || ibuf->channels == 4)) {
204               ok = false;
205             }
206
207             if (!ok) {
208               BKE_report(op->reports, RPT_ERROR, "Baking to unsupported image type");
209             }
210           }
211
212           BKE_image_release_ibuf(ima, ibuf, NULL);
213         }
214       }
215     }
216
217     if (!ok) {
218       break;
219     }
220   }
221   CTX_DATA_END;
222
223   return ok;
224 }
225
226 static DerivedMesh *multiresbake_create_loresdm(Scene *scene, Object *ob, int *lvl)
227 {
228   DerivedMesh *dm;
229   MultiresModifierData *mmd = get_multires_modifier(scene, ob, 0);
230   Mesh *me = (Mesh *)ob->data;
231   MultiresModifierData tmp_mmd = *mmd;
232   DerivedMesh *cddm = CDDM_from_mesh(me);
233
234   DM_set_only_copy(cddm, &CD_MASK_BAREMESH);
235
236   if (mmd->lvl == 0) {
237     dm = CDDM_copy(cddm);
238   }
239   else {
240     tmp_mmd.lvl = mmd->lvl;
241     tmp_mmd.sculptlvl = mmd->lvl;
242     dm = multires_make_derived_from_derived(cddm, &tmp_mmd, scene, ob, 0);
243   }
244
245   cddm->release(cddm);
246
247   *lvl = mmd->lvl;
248
249   return dm;
250 }
251
252 static DerivedMesh *multiresbake_create_hiresdm(Scene *scene, Object *ob, int *lvl, bool *simple)
253 {
254   Mesh *me = (Mesh *)ob->data;
255   MultiresModifierData *mmd = get_multires_modifier(scene, ob, 0);
256   MultiresModifierData tmp_mmd = *mmd;
257   DerivedMesh *cddm = CDDM_from_mesh(me);
258   DerivedMesh *dm;
259
260   DM_set_only_copy(cddm, &CD_MASK_BAREMESH);
261
262   /* TODO: DM_set_only_copy wouldn't set mask for loop and poly data,
263    *       but we really need BAREMESH only to save lots of memory
264    */
265   CustomData_set_only_copy(&cddm->loopData, CD_MASK_BAREMESH.lmask);
266   CustomData_set_only_copy(&cddm->polyData, CD_MASK_BAREMESH.pmask);
267
268   *lvl = mmd->totlvl;
269   *simple = mmd->simple != 0;
270
271   tmp_mmd.lvl = mmd->totlvl;
272   tmp_mmd.sculptlvl = mmd->totlvl;
273   dm = multires_make_derived_from_derived(cddm, &tmp_mmd, scene, ob, 0);
274   cddm->release(cddm);
275
276   return dm;
277 }
278
279 typedef enum ClearFlag {
280   CLEAR_TANGENT_NORMAL = 1,
281   CLEAR_DISPLACEMENT = 2,
282 } ClearFlag;
283
284 static void clear_single_image(Image *image, ClearFlag flag)
285 {
286   const float vec_alpha[4] = {0.0f, 0.0f, 0.0f, 0.0f};
287   const float vec_solid[4] = {0.0f, 0.0f, 0.0f, 1.0f};
288   const float nor_alpha[4] = {0.5f, 0.5f, 1.0f, 0.0f};
289   const float nor_solid[4] = {0.5f, 0.5f, 1.0f, 1.0f};
290   const float disp_alpha[4] = {0.5f, 0.5f, 0.5f, 0.0f};
291   const float disp_solid[4] = {0.5f, 0.5f, 0.5f, 1.0f};
292
293   if ((image->id.tag & LIB_TAG_DOIT) == 0) {
294     ImBuf *ibuf = BKE_image_acquire_ibuf(image, NULL, NULL);
295
296     if (flag == CLEAR_TANGENT_NORMAL) {
297       IMB_rectfill(ibuf, (ibuf->planes == R_IMF_PLANES_RGBA) ? nor_alpha : nor_solid);
298     }
299     else if (flag == CLEAR_DISPLACEMENT) {
300       IMB_rectfill(ibuf, (ibuf->planes == R_IMF_PLANES_RGBA) ? disp_alpha : disp_solid);
301     }
302     else {
303       IMB_rectfill(ibuf, (ibuf->planes == R_IMF_PLANES_RGBA) ? vec_alpha : vec_solid);
304     }
305
306     image->id.tag |= LIB_TAG_DOIT;
307
308     BKE_image_release_ibuf(image, ibuf, NULL);
309   }
310 }
311
312 static void clear_images_poly(Image **ob_image_array, int ob_image_array_len, ClearFlag flag)
313 {
314   for (int i = 0; i < ob_image_array_len; i++) {
315     Image *image = ob_image_array[i];
316     if (image) {
317       image->id.tag &= ~LIB_TAG_DOIT;
318     }
319   }
320
321   for (int i = 0; i < ob_image_array_len; i++) {
322     Image *image = ob_image_array[i];
323     if (image) {
324       clear_single_image(image, flag);
325     }
326   }
327
328   for (int i = 0; i < ob_image_array_len; i++) {
329     Image *image = ob_image_array[i];
330     if (image) {
331       image->id.tag &= ~LIB_TAG_DOIT;
332     }
333   }
334 }
335
336 static int multiresbake_image_exec_locked(bContext *C, wmOperator *op)
337 {
338   Object *ob;
339   Scene *scene = CTX_data_scene(C);
340   int objects_baked = 0;
341
342   if (!multiresbake_check(C, op)) {
343     return OPERATOR_CANCELLED;
344   }
345
346   if (scene->r.bake_flag & R_BAKE_CLEAR) { /* clear images */
347     CTX_DATA_BEGIN (C, Base *, base, selected_editable_bases) {
348       ClearFlag clear_flag = 0;
349
350       ob = base->object;
351       // me = (Mesh *)ob->data;
352
353       if (scene->r.bake_mode == RE_BAKE_NORMALS) {
354         clear_flag = CLEAR_TANGENT_NORMAL;
355       }
356       else if (scene->r.bake_mode == RE_BAKE_DISPLACEMENT) {
357         clear_flag = CLEAR_DISPLACEMENT;
358       }
359
360       {
361         Image **ob_image_array = bake_object_image_get_array(ob);
362         clear_images_poly(ob_image_array, ob->totcol, clear_flag);
363         MEM_freeN(ob_image_array);
364       }
365     }
366     CTX_DATA_END;
367   }
368
369   CTX_DATA_BEGIN (C, Base *, base, selected_editable_bases) {
370     MultiresBakeRender bkr = {NULL};
371
372     ob = base->object;
373
374     multires_force_update(ob);
375
376     /* copy data stored in job descriptor */
377     bkr.scene = scene;
378     bkr.bake_filter = scene->r.bake_filter;
379     bkr.mode = scene->r.bake_mode;
380     bkr.use_lores_mesh = scene->r.bake_flag & R_BAKE_LORES_MESH;
381     bkr.bias = scene->r.bake_biasdist;
382     bkr.number_of_rays = scene->r.bake_samples;
383     bkr.threads = BKE_scene_num_threads(scene);
384     bkr.user_scale = (scene->r.bake_flag & R_BAKE_USERSCALE) ? scene->r.bake_user_scale : -1.0f;
385     //bkr.reports= op->reports;
386
387     /* create low-resolution DM (to bake to) and hi-resolution DM (to bake from) */
388     bkr.ob_image.array = bake_object_image_get_array(ob);
389     bkr.ob_image.len = ob->totcol;
390
391     bkr.hires_dm = multiresbake_create_hiresdm(scene, ob, &bkr.tot_lvl, &bkr.simple);
392     bkr.lores_dm = multiresbake_create_loresdm(scene, ob, &bkr.lvl);
393
394     RE_multires_bake_images(&bkr);
395
396     MEM_freeN(bkr.ob_image.array);
397
398     BLI_freelistN(&bkr.image);
399
400     bkr.lores_dm->release(bkr.lores_dm);
401     bkr.hires_dm->release(bkr.hires_dm);
402
403     objects_baked++;
404   }
405   CTX_DATA_END;
406
407   if (!objects_baked) {
408     BKE_report(op->reports, RPT_ERROR, "No objects found to bake from");
409   }
410
411   return OPERATOR_FINISHED;
412 }
413
414 /* Multiresbake adopted for job-system executing */
415 static void init_multiresbake_job(bContext *C, MultiresBakeJob *bkj)
416 {
417   Scene *scene = CTX_data_scene(C);
418   Object *ob;
419
420   /* backup scene settings, so their changing in UI would take no effect on baker */
421   bkj->scene = scene;
422   bkj->bake_filter = scene->r.bake_filter;
423   bkj->mode = scene->r.bake_mode;
424   bkj->use_lores_mesh = scene->r.bake_flag & R_BAKE_LORES_MESH;
425   bkj->bake_clear = scene->r.bake_flag & R_BAKE_CLEAR;
426   bkj->bias = scene->r.bake_biasdist;
427   bkj->number_of_rays = scene->r.bake_samples;
428   bkj->threads = BKE_scene_num_threads(scene);
429   bkj->user_scale = (scene->r.bake_flag & R_BAKE_USERSCALE) ? scene->r.bake_user_scale : -1.0f;
430   //bkj->reports = op->reports;
431
432   CTX_DATA_BEGIN (C, Base *, base, selected_editable_bases) {
433     MultiresBakerJobData *data;
434     int lvl;
435
436     ob = base->object;
437
438     multires_force_update(ob);
439
440     data = MEM_callocN(sizeof(MultiresBakerJobData), "multiresBaker derivedMesh_data");
441
442     data->ob_image.array = bake_object_image_get_array(ob);
443     data->ob_image.len = ob->totcol;
444
445     /* create low-resolution DM (to bake to) and hi-resolution DM (to bake from) */
446     data->hires_dm = multiresbake_create_hiresdm(scene, ob, &data->tot_lvl, &data->simple);
447     data->lores_dm = multiresbake_create_loresdm(scene, ob, &lvl);
448     data->lvl = lvl;
449
450     BLI_addtail(&bkj->data, data);
451   }
452   CTX_DATA_END;
453 }
454
455 static void multiresbake_startjob(void *bkv, short *stop, short *do_update, float *progress)
456 {
457   MultiresBakerJobData *data;
458   MultiresBakeJob *bkj = bkv;
459   int baked_objects = 0, tot_obj;
460
461   tot_obj = BLI_listbase_count(&bkj->data);
462
463   if (bkj->bake_clear) { /* clear images */
464     for (data = bkj->data.first; data; data = data->next) {
465       ClearFlag clear_flag = 0;
466
467       if (bkj->mode == RE_BAKE_NORMALS) {
468         clear_flag = CLEAR_TANGENT_NORMAL;
469       }
470       else if (bkj->mode == RE_BAKE_DISPLACEMENT) {
471         clear_flag = CLEAR_DISPLACEMENT;
472       }
473
474       clear_images_poly(data->ob_image.array, data->ob_image.len, clear_flag);
475     }
476   }
477
478   for (data = bkj->data.first; data; data = data->next) {
479     MultiresBakeRender bkr = {NULL};
480
481     /* copy data stored in job descriptor */
482     bkr.scene = bkj->scene;
483     bkr.bake_filter = bkj->bake_filter;
484     bkr.mode = bkj->mode;
485     bkr.use_lores_mesh = bkj->use_lores_mesh;
486     bkr.user_scale = bkj->user_scale;
487     //bkr.reports = bkj->reports;
488     bkr.ob_image.array = data->ob_image.array;
489     bkr.ob_image.len = data->ob_image.len;
490
491     /* create low-resolution DM (to bake to) and hi-resolution DM (to bake from) */
492     bkr.lores_dm = data->lores_dm;
493     bkr.hires_dm = data->hires_dm;
494     bkr.tot_lvl = data->tot_lvl;
495     bkr.lvl = data->lvl;
496     bkr.simple = data->simple;
497
498     /* needed for proper progress bar */
499     bkr.tot_obj = tot_obj;
500     bkr.baked_objects = baked_objects;
501
502     bkr.stop = stop;
503     bkr.do_update = do_update;
504     bkr.progress = progress;
505
506     bkr.bias = bkj->bias;
507     bkr.number_of_rays = bkj->number_of_rays;
508     bkr.threads = bkj->threads;
509
510     RE_multires_bake_images(&bkr);
511
512     data->images = bkr.image;
513
514     baked_objects++;
515   }
516 }
517
518 static void multiresbake_freejob(void *bkv)
519 {
520   MultiresBakeJob *bkj = bkv;
521   MultiresBakerJobData *data, *next;
522   LinkData *link;
523
524   data = bkj->data.first;
525   while (data) {
526     next = data->next;
527     data->lores_dm->release(data->lores_dm);
528     data->hires_dm->release(data->hires_dm);
529
530     /* delete here, since this delete will be called from main thread */
531     for (link = data->images.first; link; link = link->next) {
532       Image *ima = (Image *)link->data;
533       GPU_free_image(ima);
534     }
535
536     MEM_freeN(data->ob_image.array);
537
538     BLI_freelistN(&data->images);
539
540     MEM_freeN(data);
541     data = next;
542   }
543
544   MEM_freeN(bkj);
545 }
546
547 static int multiresbake_image_exec(bContext *C, wmOperator *op)
548 {
549   Scene *scene = CTX_data_scene(C);
550   MultiresBakeJob *bkr;
551   wmJob *wm_job;
552
553   if (!multiresbake_check(C, op)) {
554     return OPERATOR_CANCELLED;
555   }
556
557   bkr = MEM_callocN(sizeof(MultiresBakeJob), "MultiresBakeJob data");
558   init_multiresbake_job(C, bkr);
559
560   if (!bkr->data.first) {
561     BKE_report(op->reports, RPT_ERROR, "No objects found to bake from");
562     return OPERATOR_CANCELLED;
563   }
564
565   /* setup job */
566   wm_job = WM_jobs_get(CTX_wm_manager(C),
567                        CTX_wm_window(C),
568                        scene,
569                        "Multires Bake",
570                        WM_JOB_EXCL_RENDER | WM_JOB_PRIORITY | WM_JOB_PROGRESS,
571                        WM_JOB_TYPE_OBJECT_BAKE_TEXTURE);
572   WM_jobs_customdata_set(wm_job, bkr, multiresbake_freejob);
573   WM_jobs_timer(wm_job, 0.5, NC_IMAGE, 0); /* TODO - only draw bake image, can we enforce this */
574   WM_jobs_callbacks(wm_job, multiresbake_startjob, NULL, NULL, NULL);
575
576   G.is_break = false;
577
578   WM_jobs_start(CTX_wm_manager(C), wm_job);
579   WM_cursor_wait(0);
580
581   /* add modal handler for ESC */
582   WM_event_add_modal_handler(C, op);
583
584   return OPERATOR_RUNNING_MODAL;
585 }
586
587 /* ****************** render BAKING ********************** */
588
589 /* catch esc */
590 static int objects_bake_render_modal(bContext *C, wmOperator *UNUSED(op), const wmEvent *event)
591 {
592   /* no running blender, remove handler and pass through */
593   if (0 == WM_jobs_test(CTX_wm_manager(C), CTX_data_scene(C), WM_JOB_TYPE_OBJECT_BAKE_TEXTURE)) {
594     return OPERATOR_FINISHED | OPERATOR_PASS_THROUGH;
595   }
596
597   /* running render */
598   switch (event->type) {
599     case ESCKEY:
600       return OPERATOR_RUNNING_MODAL;
601   }
602   return OPERATOR_PASS_THROUGH;
603 }
604
605 static bool is_multires_bake(Scene *scene)
606 {
607   if (ELEM(scene->r.bake_mode, RE_BAKE_NORMALS, RE_BAKE_DISPLACEMENT, RE_BAKE_AO)) {
608     return scene->r.bake_flag & R_BAKE_MULTIRES;
609   }
610
611   return 0;
612 }
613
614 static int objects_bake_render_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(_event))
615 {
616   Scene *scene = CTX_data_scene(C);
617   int result = OPERATOR_CANCELLED;
618
619   result = multiresbake_image_exec(C, op);
620
621   WM_event_add_notifier(C, NC_SCENE | ND_RENDER_RESULT, scene);
622
623   return result;
624 }
625
626 static int bake_image_exec(bContext *C, wmOperator *op)
627 {
628   Scene *scene = CTX_data_scene(C);
629   int result = OPERATOR_CANCELLED;
630
631   if (!is_multires_bake(scene)) {
632     BLI_assert(0);
633     return result;
634   }
635
636   result = multiresbake_image_exec_locked(C, op);
637
638   WM_event_add_notifier(C, NC_SCENE | ND_RENDER_RESULT, scene);
639
640   return result;
641 }
642
643 void OBJECT_OT_bake_image(wmOperatorType *ot)
644 {
645   /* identifiers */
646   ot->name = "Bake";
647   ot->description = "Bake image textures of selected objects";
648   ot->idname = "OBJECT_OT_bake_image";
649
650   /* api callbacks */
651   ot->exec = bake_image_exec;
652   ot->invoke = objects_bake_render_invoke;
653   ot->modal = objects_bake_render_modal;
654   ot->poll = ED_operator_object_active;
655 }