Blender  V3.3
object_bake.c
Go to the documentation of this file.
1 /* SPDX-License-Identifier: GPL-2.0-or-later
2  * Copyright 2004 Blender Foundation. All rights reserved. */
3 
8 #include <string.h>
9 
10 #include "MEM_guardedalloc.h"
11 
12 #include "DNA_material_types.h"
13 #include "DNA_mesh_types.h"
14 #include "DNA_meshdata_types.h"
15 #include "DNA_object_types.h"
16 #include "DNA_scene_types.h"
17 #include "DNA_screen_types.h"
18 #include "DNA_space_types.h"
19 #include "DNA_world_types.h"
20 
21 #include "BLI_blenlib.h"
22 #include "BLI_utildefines.h"
23 
24 #include "BKE_DerivedMesh.h"
25 #include "BKE_blender.h"
26 #include "BKE_cdderivedmesh.h"
27 #include "BKE_context.h"
28 #include "BKE_global.h"
29 #include "BKE_image.h"
30 #include "BKE_material.h"
31 #include "BKE_mesh.h"
32 #include "BKE_modifier.h"
33 #include "BKE_multires.h"
34 #include "BKE_report.h"
35 #include "BKE_scene.h"
36 
37 #include "DEG_depsgraph.h"
38 
39 #include "RE_multires_bake.h"
40 #include "RE_pipeline.h"
41 #include "RE_texture.h"
42 
43 #include "PIL_time.h"
44 
45 #include "IMB_imbuf.h"
46 #include "IMB_imbuf_types.h"
47 
48 #include "WM_api.h"
49 #include "WM_types.h"
50 
51 #include "ED_object.h"
52 #include "ED_screen.h"
53 #include "ED_uvedit.h"
54 
55 #include "object_intern.h"
56 
57 static Image *bake_object_image_get(Object *ob, int mat_nr)
58 {
59  Image *image = NULL;
60  ED_object_get_active_image(ob, mat_nr + 1, &image, NULL, NULL, NULL);
61  return image;
62 }
63 
65 {
66  Image **image_array = MEM_mallocN(sizeof(Material *) * ob->totcol, __func__);
67  for (int i = 0; i < ob->totcol; i++) {
68  image_array[i] = bake_object_image_get(ob, i);
69  }
70  return image_array;
71 }
72 
73 /* ****************** multires BAKING ********************** */
74 
75 /* holder of per-object data needed for bake job
76  * needed to make job totally thread-safe */
77 typedef struct MultiresBakerJobData {
79  /* material aligned image array (for per-face bake image) */
80  struct {
82  int len;
85  int lvl, tot_lvl;
88 
89 /* data passing to multires-baker job */
90 typedef struct {
94  bool bake_clear;
100  short mode;
106  float bias;
108  int threads;
110  float user_scale;
112 
114 {
116  Object *ob;
117  Mesh *me;
119  bool ok = true;
120  int a;
121 
122  CTX_DATA_BEGIN (C, Base *, base, selected_editable_bases) {
123  ob = base->object;
124 
125  if (ob->type != OB_MESH) {
126  BKE_report(
127  op->reports, RPT_ERROR, "Baking of multires data only works with an active mesh object");
128 
129  ok = false;
130  break;
131  }
132 
133  me = (Mesh *)ob->data;
134  mmd = get_multires_modifier(scene, ob, 0);
135 
136  /* Multi-resolution should be and be last in the stack */
137  if (ok && mmd) {
138  ModifierData *md;
139 
140  ok = mmd->totlvl > 0;
141 
142  for (md = (ModifierData *)mmd->modifier.next; md && ok; md = md->next) {
144  ok = false;
145  }
146  }
147  }
148  else {
149  ok = false;
150  }
151 
152  if (!ok) {
153  BKE_report(op->reports, RPT_ERROR, "Multires data baking requires multi-resolution object");
154 
155  break;
156  }
157 
158  if (!me->mloopuv) {
159  BKE_report(op->reports, RPT_ERROR, "Mesh should be unwrapped before multires data baking");
160 
161  ok = false;
162  }
163  else {
164  a = me->totpoly;
165  while (ok && a--) {
166  Image *ima = bake_object_image_get(ob, me->mpoly[a].mat_nr);
167 
168  if (!ima) {
169  BKE_report(
170  op->reports, RPT_ERROR, "You should have active texture to use multires baker");
171 
172  ok = false;
173  }
174  else {
175  LISTBASE_FOREACH (ImageTile *, tile, &ima->tiles) {
176  ImageUser iuser;
177  BKE_imageuser_default(&iuser);
178  iuser.tile = tile->tile_number;
179 
180  ImBuf *ibuf = BKE_image_acquire_ibuf(ima, &iuser, NULL);
181 
182  if (!ibuf) {
183  BKE_report(
184  op->reports, RPT_ERROR, "Baking should happen to image with image buffer");
185 
186  ok = false;
187  }
188  else {
189  if (ibuf->rect == NULL && ibuf->rect_float == NULL) {
190  ok = false;
191  }
192 
193  if (ibuf->rect_float && !(ELEM(ibuf->channels, 0, 4))) {
194  ok = false;
195  }
196 
197  if (!ok) {
198  BKE_report(op->reports, RPT_ERROR, "Baking to unsupported image type");
199  }
200  }
201 
202  BKE_image_release_ibuf(ima, ibuf, NULL);
203  }
204  }
205  }
206  }
207 
208  if (!ok) {
209  break;
210  }
211  }
212  CTX_DATA_END;
213 
214  return ok;
215 }
216 
218 {
219  DerivedMesh *dm;
221  Mesh *me = (Mesh *)ob->data;
222  MultiresModifierData tmp_mmd = *mmd;
223 
224  *lvl = mmd->lvl;
225 
226  if (mmd->lvl == 0) {
227  DerivedMesh *cddm = CDDM_from_mesh(me);
229  return cddm;
230  }
231 
232  DerivedMesh *cddm = CDDM_from_mesh(me);
234  tmp_mmd.lvl = mmd->lvl;
235  tmp_mmd.sculptlvl = mmd->lvl;
236  dm = multires_make_derived_from_derived(cddm, &tmp_mmd, scene, ob, 0);
237 
238  cddm->release(cddm);
239 
240  return dm;
241 }
242 
244 {
245  Mesh *me = (Mesh *)ob->data;
247  MultiresModifierData tmp_mmd = *mmd;
248  DerivedMesh *cddm = CDDM_from_mesh(me);
249  DerivedMesh *dm;
250 
252 
253  /* TODO: DM_set_only_copy wouldn't set mask for loop and poly data,
254  * but we really need BAREMESH only to save lots of memory
255  */
258 
259  *lvl = mmd->totlvl;
260 
261  tmp_mmd.lvl = mmd->totlvl;
262  tmp_mmd.sculptlvl = mmd->totlvl;
263  dm = multires_make_derived_from_derived(cddm, &tmp_mmd, scene, ob, 0);
264  cddm->release(cddm);
265 
266  return dm;
267 }
268 
269 typedef enum ClearFlag {
273 
275 {
276  const float vec_alpha[4] = {0.0f, 0.0f, 0.0f, 0.0f};
277  const float vec_solid[4] = {0.0f, 0.0f, 0.0f, 1.0f};
278  const float nor_alpha[4] = {0.5f, 0.5f, 1.0f, 0.0f};
279  const float nor_solid[4] = {0.5f, 0.5f, 1.0f, 1.0f};
280  const float disp_alpha[4] = {0.5f, 0.5f, 0.5f, 0.0f};
281  const float disp_solid[4] = {0.5f, 0.5f, 0.5f, 1.0f};
282 
283  if ((image->id.tag & LIB_TAG_DOIT) == 0) {
284  LISTBASE_FOREACH (ImageTile *, tile, &image->tiles) {
285  ImageUser iuser;
286  BKE_imageuser_default(&iuser);
287  iuser.tile = tile->tile_number;
288 
289  ImBuf *ibuf = BKE_image_acquire_ibuf(image, &iuser, NULL);
290 
291  if (flag == CLEAR_TANGENT_NORMAL) {
292  IMB_rectfill(ibuf, (ibuf->planes == R_IMF_PLANES_RGBA) ? nor_alpha : nor_solid);
293  }
294  else if (flag == CLEAR_DISPLACEMENT) {
295  IMB_rectfill(ibuf, (ibuf->planes == R_IMF_PLANES_RGBA) ? disp_alpha : disp_solid);
296  }
297  else {
298  IMB_rectfill(ibuf, (ibuf->planes == R_IMF_PLANES_RGBA) ? vec_alpha : vec_solid);
299  }
300 
301  image->id.tag |= LIB_TAG_DOIT;
302 
304  }
305  }
306 }
307 
308 static void clear_images_poly(Image **ob_image_array, int ob_image_array_len, ClearFlag flag)
309 {
310  for (int i = 0; i < ob_image_array_len; i++) {
311  Image *image = ob_image_array[i];
312  if (image) {
313  image->id.tag &= ~LIB_TAG_DOIT;
314  }
315  }
316 
317  for (int i = 0; i < ob_image_array_len; i++) {
318  Image *image = ob_image_array[i];
319  if (image) {
320  clear_single_image(image, flag);
321  }
322  }
323 
324  for (int i = 0; i < ob_image_array_len; i++) {
325  Image *image = ob_image_array[i];
326  if (image) {
327  image->id.tag &= ~LIB_TAG_DOIT;
328  }
329  }
330 }
331 
333 {
334  Object *ob;
336  int objects_baked = 0;
337 
338  if (!multiresbake_check(C, op)) {
339  return OPERATOR_CANCELLED;
340  }
341 
342  if (scene->r.bake_flag & R_BAKE_CLEAR) { /* clear images */
343  CTX_DATA_BEGIN (C, Base *, base, selected_editable_bases) {
344  ClearFlag clear_flag = 0;
345 
346  ob = base->object;
347  // me = (Mesh *)ob->data;
348 
349  if (scene->r.bake_mode == RE_BAKE_NORMALS) {
350  clear_flag = CLEAR_TANGENT_NORMAL;
351  }
352  else if (scene->r.bake_mode == RE_BAKE_DISPLACEMENT) {
353  clear_flag = CLEAR_DISPLACEMENT;
354  }
355 
356  {
357  Image **ob_image_array = bake_object_image_get_array(ob);
358  clear_images_poly(ob_image_array, ob->totcol, clear_flag);
359  MEM_freeN(ob_image_array);
360  }
361  }
362  CTX_DATA_END;
363  }
364 
365  CTX_DATA_BEGIN (C, Base *, base, selected_editable_bases) {
366  MultiresBakeRender bkr = {NULL};
367 
368  ob = base->object;
369 
371 
372  /* copy data stored in job descriptor */
373  bkr.scene = scene;
375  if (scene->r.bake_mode == RE_BAKE_NORMALS) {
377  }
378  else {
380  }
381  bkr.mode = scene->r.bake_mode;
383  bkr.bias = scene->r.bake_biasdist;
387  // bkr.reports= op->reports;
388 
389  /* create low-resolution DM (to bake to) and hi-resolution DM (to bake from) */
391  bkr.ob_image.len = ob->totcol;
392 
395 
397 
398  MEM_freeN(bkr.ob_image.array);
399 
400  BLI_freelistN(&bkr.image);
401 
402  bkr.lores_dm->release(bkr.lores_dm);
403  bkr.hires_dm->release(bkr.hires_dm);
404 
405  objects_baked++;
406  }
407  CTX_DATA_END;
408 
409  if (!objects_baked) {
410  BKE_report(op->reports, RPT_ERROR, "No objects found to bake from");
411  }
412 
413  return OPERATOR_FINISHED;
414 }
415 
416 /* Multiresbake adopted for job-system executing */
418 {
420  Object *ob;
421 
422  /* backup scene settings, so their changing in UI would take no effect on baker */
423  bkj->scene = scene;
424  bkj->bake_margin = scene->r.bake_margin;
425  if (scene->r.bake_mode == RE_BAKE_NORMALS) {
427  }
428  else {
430  }
431  bkj->mode = scene->r.bake_mode;
434  bkj->bias = scene->r.bake_biasdist;
438  // bkj->reports = op->reports;
439 
440  CTX_DATA_BEGIN (C, Base *, base, selected_editable_bases) {
442  int lvl;
443 
444  ob = base->object;
445 
447 
448  data = MEM_callocN(sizeof(MultiresBakerJobData), "multiresBaker derivedMesh_data");
449 
450  data->ob_image.array = bake_object_image_get_array(ob);
451  data->ob_image.len = ob->totcol;
452 
453  /* create low-resolution DM (to bake to) and hi-resolution DM (to bake from) */
454  data->hires_dm = multiresbake_create_hiresdm(scene, ob, &data->tot_lvl);
455  data->lores_dm = multiresbake_create_loresdm(scene, ob, &lvl);
456  data->lvl = lvl;
457 
458  BLI_addtail(&bkj->data, data);
459  }
460  CTX_DATA_END;
461 }
462 
463 static void multiresbake_startjob(void *bkv, short *stop, short *do_update, float *progress)
464 {
466  MultiresBakeJob *bkj = bkv;
467  int baked_objects = 0, tot_obj;
468 
469  tot_obj = BLI_listbase_count(&bkj->data);
470 
471  if (bkj->bake_clear) { /* clear images */
472  for (data = bkj->data.first; data; data = data->next) {
473  ClearFlag clear_flag = 0;
474 
475  if (bkj->mode == RE_BAKE_NORMALS) {
476  clear_flag = CLEAR_TANGENT_NORMAL;
477  }
478  else if (bkj->mode == RE_BAKE_DISPLACEMENT) {
479  clear_flag = CLEAR_DISPLACEMENT;
480  }
481 
482  clear_images_poly(data->ob_image.array, data->ob_image.len, clear_flag);
483  }
484  }
485 
486  for (data = bkj->data.first; data; data = data->next) {
487  MultiresBakeRender bkr = {NULL};
488 
489  /* copy data stored in job descriptor */
490  bkr.scene = bkj->scene;
491  bkr.bake_margin = bkj->bake_margin;
493  bkr.mode = bkj->mode;
494  bkr.use_lores_mesh = bkj->use_lores_mesh;
495  bkr.user_scale = bkj->user_scale;
496  // bkr.reports = bkj->reports;
497  bkr.ob_image.array = data->ob_image.array;
498  bkr.ob_image.len = data->ob_image.len;
499 
500  /* create low-resolution DM (to bake to) and hi-resolution DM (to bake from) */
501  bkr.lores_dm = data->lores_dm;
502  bkr.hires_dm = data->hires_dm;
503  bkr.tot_lvl = data->tot_lvl;
504  bkr.lvl = data->lvl;
505 
506  /* needed for proper progress bar */
507  bkr.tot_obj = tot_obj;
508  bkr.baked_objects = baked_objects;
509 
510  bkr.stop = stop;
511  bkr.do_update = do_update;
512  bkr.progress = progress;
513 
514  bkr.bias = bkj->bias;
515  bkr.number_of_rays = bkj->number_of_rays;
516  bkr.threads = bkj->threads;
517 
519 
520  data->images = bkr.image;
521 
522  baked_objects++;
523  }
524 }
525 
526 static void multiresbake_freejob(void *bkv)
527 {
528  MultiresBakeJob *bkj = bkv;
530  LinkData *link;
531 
532  data = bkj->data.first;
533  while (data) {
534  next = data->next;
535  data->lores_dm->release(data->lores_dm);
536  data->hires_dm->release(data->hires_dm);
537 
538  /* delete here, since this delete will be called from main thread */
539  for (link = data->images.first; link; link = link->next) {
540  Image *ima = (Image *)link->data;
542  }
543 
544  MEM_freeN(data->ob_image.array);
545 
546  BLI_freelistN(&data->images);
547 
548  MEM_freeN(data);
549  data = next;
550  }
551 
552  MEM_freeN(bkj);
553 }
554 
556 {
558  MultiresBakeJob *bkr;
559  wmJob *wm_job;
560 
561  if (!multiresbake_check(C, op)) {
562  return OPERATOR_CANCELLED;
563  }
564 
565  bkr = MEM_callocN(sizeof(MultiresBakeJob), "MultiresBakeJob data");
566  init_multiresbake_job(C, bkr);
567 
568  if (!bkr->data.first) {
569  BKE_report(op->reports, RPT_ERROR, "No objects found to bake from");
570  return OPERATOR_CANCELLED;
571  }
572 
573  /* setup job */
574  wm_job = WM_jobs_get(CTX_wm_manager(C),
575  CTX_wm_window(C),
576  scene,
577  "Multires Bake",
581  WM_jobs_timer(wm_job, 0.5, NC_IMAGE, 0); /* TODO: only draw bake image, can we enforce this. */
583 
584  G.is_break = false;
585 
586  WM_jobs_start(CTX_wm_manager(C), wm_job);
587  WM_cursor_wait(false);
588 
589  /* add modal handler for ESC */
591 
592  return OPERATOR_RUNNING_MODAL;
593 }
594 
595 /* ****************** render BAKING ********************** */
596 
599 {
600  /* no running blender, remove handler and pass through */
603  }
604 
605  /* running render */
606  switch (event->type) {
607  case EVT_ESCKEY:
608  return OPERATOR_RUNNING_MODAL;
609  }
610  return OPERATOR_PASS_THROUGH;
611 }
612 
614 {
616  return scene->r.bake_flag & R_BAKE_MULTIRES;
617  }
618 
619  return 0;
620 }
621 
623 {
626 
628 
630 
631  return result;
632 }
633 
635 {
638 
639  if (!is_multires_bake(scene)) {
640  BLI_assert(0);
641  return result;
642  }
643 
645 
647 
648  return result;
649 }
650 
652 {
653  /* identifiers */
654  ot->name = "Bake";
655  ot->description = "Bake image textures of selected objects";
656  ot->idname = "OBJECT_OT_bake_image";
657 
658  /* api callbacks */
663 }
void DM_set_only_copy(DerivedMesh *dm, const struct CustomData_MeshMasks *mask)
Blender util stuff.
struct DerivedMesh * CDDM_from_mesh(struct Mesh *mesh)
struct Scene * CTX_data_scene(const bContext *C)
Definition: context.c:1090
struct wmWindowManager * CTX_wm_manager(const bContext *C)
Definition: context.c:713
#define CTX_DATA_BEGIN(C, Type, instance, member)
Definition: BKE_context.h:269
#define CTX_DATA_END
Definition: BKE_context.h:278
struct wmWindow * CTX_wm_window(const bContext *C)
Definition: context.c:723
const CustomData_MeshMasks CD_MASK_BAREMESH
Definition: customdata.cc:2051
void CustomData_set_only_copy(const struct CustomData *data, eCustomDataMask mask)
void BKE_image_release_ibuf(struct Image *ima, struct ImBuf *ibuf, void *lock)
struct ImBuf * BKE_image_acquire_ibuf(struct Image *ima, struct ImageUser *iuser, void **r_lock)
void BKE_image_partial_update_mark_full_update(struct Image *image)
Mark the whole image to be updated.
void BKE_imageuser_default(struct ImageUser *iuser)
General operations, lookup, etc. for materials.
bool BKE_modifier_is_enabled(const struct Scene *scene, struct ModifierData *md, int required_mode)
struct MultiresModifierData * get_multires_modifier(struct Scene *scene, struct Object *ob, bool use_first)
Definition: multires.c:317
struct DerivedMesh * multires_make_derived_from_derived(struct DerivedMesh *dm, struct MultiresModifierData *mmd, struct Scene *scene, struct Object *ob, MultiresFlags flags)
Definition: multires.c:1205
void multires_flush_sculpt_updates(struct Object *object)
Definition: multires.c:408
void BKE_report(ReportList *reports, eReportType type, const char *message)
Definition: report.c:83
int BKE_scene_num_threads(const struct Scene *scene)
#define BLI_assert(a)
Definition: BLI_assert.h:46
#define LISTBASE_FOREACH(type, var, list)
Definition: BLI_listbase.h:336
void void BLI_freelistN(struct ListBase *listbase) ATTR_NONNULL(1)
Definition: listbase.c:466
void BLI_addtail(struct ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition: listbase.c:80
int BLI_listbase_count(const struct ListBase *listbase) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
#define UNUSED(x)
#define ELEM(...)
@ LIB_TAG_DOIT
Definition: DNA_ID.h:707
@ eModifierMode_Realtime
Object is a sort of wrapper for general info.
@ OB_MESH
#define R_BAKE_CLEAR
#define R_BAKE_USERSCALE
@ R_BAKE_EXTEND
#define R_IMF_PLANES_RGBA
#define R_BAKE_MULTIRES
#define R_BAKE_LORES_MESH
@ OPERATOR_CANCELLED
@ OPERATOR_FINISHED
@ OPERATOR_RUNNING_MODAL
@ OPERATOR_PASS_THROUGH
bool ED_operator_object_active(struct bContext *C)
Definition: screen_ops.c:370
bool ED_object_get_active_image(struct Object *ob, int mat_nr, struct Image **r_ima, struct ImageUser **r_iuser, struct bNode **r_node, struct bNodeTree **r_ntree)
Definition: uvedit_ops.c:109
void IMB_rectfill(struct ImBuf *drect, const float col[4])
Definition: rectop.c:1050
Contains defines and structs used throughout the imbuf module.
Read Guarded memory(de)allocation.
Platform independent time functions.
#define RE_BAKE_AO
Definition: RE_pipeline.h:441
#define RE_BAKE_NORMALS
Definition: RE_pipeline.h:439
#define RE_BAKE_DISPLACEMENT
Definition: RE_pipeline.h:440
#define C
Definition: RandGen.cpp:25
@ WM_JOB_EXCL_RENDER
Definition: WM_api.h:1338
@ WM_JOB_PROGRESS
Definition: WM_api.h:1339
@ WM_JOB_PRIORITY
Definition: WM_api.h:1337
@ WM_JOB_TYPE_OBJECT_BAKE_TEXTURE
Definition: WM_api.h:1355
#define ND_RENDER_RESULT
Definition: WM_types.h:394
#define NC_SCENE
Definition: WM_types.h:328
#define NC_IMAGE
Definition: WM_types.h:334
ListBase tiles
Scene scene
depth_tx normal_tx diffuse_light_tx specular_light_tx volume_light_tx environment_tx ambient_occlusion_tx aov_value_tx in_weight_img image(1, GPU_R32F, Qualifier::WRITE, ImageType::FLOAT_2D_ARRAY, "out_weight_img") .image(3
ccl_global const KernelWorkTile * tile
void(* MEM_freeN)(void *vmemh)
Definition: mallocn.c:27
void *(* MEM_callocN)(size_t len, const char *str)
Definition: mallocn.c:31
void *(* MEM_mallocN)(size_t len, const char *str)
Definition: mallocn.c:33
static ulong * next
#define G(x, y, z)
void RE_multires_bake_images(MultiresBakeRender *bkr)
static unsigned a[3]
Definition: RandGen.cpp:78
static void multiresbake_startjob(void *bkv, short *stop, short *do_update, float *progress)
Definition: object_bake.c:463
static int multiresbake_image_exec_locked(bContext *C, wmOperator *op)
Definition: object_bake.c:332
static DerivedMesh * multiresbake_create_hiresdm(Scene *scene, Object *ob, int *lvl)
Definition: object_bake.c:243
static int objects_bake_render_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(_event))
Definition: object_bake.c:622
static void multiresbake_freejob(void *bkv)
Definition: object_bake.c:526
static void init_multiresbake_job(bContext *C, MultiresBakeJob *bkj)
Definition: object_bake.c:417
static Image ** bake_object_image_get_array(Object *ob)
Definition: object_bake.c:64
void OBJECT_OT_bake_image(wmOperatorType *ot)
Definition: object_bake.c:651
static int objects_bake_render_modal(bContext *C, wmOperator *UNUSED(op), const wmEvent *event)
Definition: object_bake.c:598
ClearFlag
Definition: object_bake.c:269
@ CLEAR_DISPLACEMENT
Definition: object_bake.c:271
@ CLEAR_TANGENT_NORMAL
Definition: object_bake.c:270
static int multiresbake_image_exec(bContext *C, wmOperator *op)
Definition: object_bake.c:555
static void clear_images_poly(Image **ob_image_array, int ob_image_array_len, ClearFlag flag)
Definition: object_bake.c:308
static Image * bake_object_image_get(Object *ob, int mat_nr)
Definition: object_bake.c:57
static void clear_single_image(Image *image, ClearFlag flag)
Definition: object_bake.c:274
struct MultiresBakerJobData MultiresBakerJobData
static bool is_multires_bake(Scene *scene)
Definition: object_bake.c:613
static bool multiresbake_check(bContext *C, wmOperator *op)
Definition: object_bake.c:113
static DerivedMesh * multiresbake_create_loresdm(Scene *scene, Object *ob, int *lvl)
Definition: object_bake.c:217
static int bake_image_exec(bContext *C, wmOperator *op)
Definition: object_bake.c:634
CustomData polyData
CustomData loopData
void(* release)(DerivedMesh *dm)
int channels
unsigned char planes
unsigned int * rect
float * rect_float
void * data
Definition: DNA_listBase.h:26
struct LinkData * next
Definition: DNA_listBase.h:25
void * first
Definition: DNA_listBase.h:31
short mat_nr
struct MLoopUV * mloopuv
int totpoly
struct MPoly * mpoly
struct ModifierData * next
ListBase data
Definition: object_bake.c:92
char bake_margin_type
Definition: object_bake.c:98
DerivedMesh * hires_dm
DerivedMesh * lores_dm
struct MultiresBakeRender::@1173 ob_image
struct MultiresBakerJobData * prev
Definition: object_bake.c:78
struct MultiresBakerJobData * next
Definition: object_bake.c:78
DerivedMesh * hires_dm
Definition: object_bake.c:84
DerivedMesh * lores_dm
Definition: object_bake.c:84
struct MultiresBakerJobData::@487 ob_image
void * data
short bake_samples
float bake_biasdist
short bake_margin_type
float bake_user_scale
struct RenderData r
short type
Definition: WM_types.h:678
Definition: wm_jobs.c:57
int(* invoke)(struct bContext *, struct wmOperator *, const struct wmEvent *) ATTR_WARN_UNUSED_RESULT
Definition: WM_types.h:919
const char * name
Definition: WM_types.h:888
int(* modal)(struct bContext *, struct wmOperator *, const struct wmEvent *) ATTR_WARN_UNUSED_RESULT
Definition: WM_types.h:935
const char * idname
Definition: WM_types.h:890
bool(* poll)(struct bContext *) ATTR_WARN_UNUSED_RESULT
Definition: WM_types.h:943
const char * description
Definition: WM_types.h:893
int(* exec)(struct bContext *, struct wmOperator *) ATTR_WARN_UNUSED_RESULT
Definition: WM_types.h:903
struct ReportList * reports
void WM_cursor_wait(bool val)
Definition: wm_cursors.c:209
wmEventHandler_Op * WM_event_add_modal_handler(bContext *C, wmOperator *op)
void WM_event_add_notifier(const bContext *C, uint type, void *reference)
@ EVT_ESCKEY
wmOperatorType * ot
Definition: wm_files.c:3479
void WM_jobs_start(wmWindowManager *wm, wmJob *wm_job)
Definition: wm_jobs.c:437
void WM_jobs_callbacks(wmJob *wm_job, wm_jobs_start_callback startjob, void(*initjob)(void *), void(*update)(void *), void(*endjob)(void *))
Definition: wm_jobs.c:351
bool WM_jobs_test(const wmWindowManager *wm, const void *owner, int job_type)
Definition: wm_jobs.c:214
void WM_jobs_customdata_set(wmJob *wm_job, void *customdata, void(*free)(void *))
Definition: wm_jobs.c:323
void WM_jobs_timer(wmJob *wm_job, double timestep, unsigned int note, unsigned int endnote)
Definition: wm_jobs.c:339
wmJob * WM_jobs_get(wmWindowManager *wm, wmWindow *win, const void *owner, const char *name, int flag, int job_type)
Definition: wm_jobs.c:184