Blender V5.3
object_bake.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2004 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include <cstring>
10
11#include "MEM_guardedalloc.h"
12
13#include "DNA_layer_types.h"
14#include "DNA_mesh_types.h"
15#include "DNA_object_types.h"
16#include "DNA_scene_types.h"
17#include "DNA_screen_types.h"
18
19#include "BLI_listbase.hh"
20#include "BLI_span.hh"
21#include "BLI_utildefines.hh"
22#include "BLI_vector.hh"
23
24#include "BKE_attribute.hh"
25#include "BKE_context.hh"
26#include "BKE_customdata.hh"
27#include "BKE_global.hh"
28#include "BKE_image.hh"
29#include "BKE_modifier.hh"
30#include "BKE_multires.hh"
31#include "BKE_report.hh"
32#include "BKE_scene.hh"
33
34#include "RE_multires_bake.h"
35#include "RE_pipeline.h"
36
37#include "IMB_imbuf.hh"
38#include "IMB_imbuf_types.hh"
39
40#include "WM_api.hh"
41#include "WM_types.hh"
42
43#include "ED_screen.hh"
44#include "ED_uvedit.hh"
45
46#include "object_intern.hh"
47
48namespace blender::ed::object {
49
50static Image *bake_object_image_get(Object &object, const int mat_nr)
51{
52 Image *image = nullptr;
53 ED_object_get_active_image(&object, mat_nr + 1, &image, nullptr, nullptr, nullptr);
54 return image;
55}
56
58{
59 Vector<Image *> images;
60 images.reserve(object.totcol);
61 for (int i = 0; i < object.totcol; i++) {
62 images.append(bake_object_image_get(object, i));
63 }
64 return images;
65}
66
67/* ****************** multires BAKING ********************** */
68
69/* holder of per-object data needed for bake job
70 * needed to make job totally thread-safe */
72 MultiresBakerJobData *next = nullptr, *prev = nullptr;
73
74 /* Material aligned image array (for per-face bake image). */
76
77 /* Base mesh at the input of the multiresolution modifier. */
78 Mesh *base_mesh = nullptr;
79
80 /* Multi-resolution modifier which is being baked. */
82
84};
85
86/* data passing to multires-baker job */
102
104{
105 Scene *scene = CTX_data_scene(C);
106 Object *ob;
107 Mesh *mesh;
109 bool ok = true;
110 int a;
111
112 CTX_DATA_BEGIN (C, Base *, base, selected_editable_bases) {
113 ob = base->object;
114
115 if (ob->type != OB_MESH) {
117 op->reports, RPT_ERROR, "Baking of multires data only works with an active mesh object");
118
119 ok = false;
120 break;
121 }
122
123 mesh = id_cast<Mesh *>(ob->data);
124 mmd = get_multires_modifier(scene, ob, false);
125
126 /* Multi-resolution should be and be last in the stack */
127 if (ok && mmd) {
128 ModifierData *md;
129
130 ok = mmd->totlvl > 0;
131
132 for (md = static_cast<ModifierData *>(mmd->modifier.next); md && ok; md = md->next) {
134 ok = false;
135 }
136 }
137 }
138 else {
139 ok = false;
140 }
141
142 if (!ok) {
143 BKE_report(op->reports, RPT_ERROR, "Multires data baking requires multi-resolution object");
144
145 break;
146 }
147
148 if (mesh->uv_map_names().is_empty()) {
149 BKE_report(op->reports, RPT_ERROR, "Mesh should be unwrapped before multires data baking");
150
151 ok = false;
152 }
153 else {
154 const bke::AttributeAccessor attributes = mesh->attributes();
155 const VArraySpan material_indices = *attributes.lookup<int>("material_index",
157 a = mesh->faces_num;
158 while (ok && a--) {
159 Image *ima = bake_object_image_get(*ob,
160 material_indices.is_empty() ? 0 : material_indices[a]);
161
162 if (!ima) {
164 op->reports, RPT_ERROR, "You should have active texture to use multires baker");
165
166 ok = false;
167 }
168 else {
169 for (ImageTile &tile : ima->tiles) {
170 ImageUser iuser;
171 BKE_imageuser_default(&iuser);
172 iuser.tile = tile.tile_number;
173
174 ImBuf *ibuf = BKE_image_acquire_ibuf(ima, &iuser, nullptr);
175
176 if (!ibuf) {
178 op->reports, RPT_ERROR, "Baking should happen to image with image buffer");
179
180 ok = false;
181 }
182 else {
183 if (ibuf->byte_data() == nullptr && ibuf->float_data() == nullptr) {
184 ok = false;
185 }
186
187 if (ibuf->float_data() && !ELEM(ibuf->channels, 0, 4)) {
188 ok = false;
189 }
190
191 if (!ok) {
192 BKE_report(op->reports, RPT_ERROR, "Baking to unsupported image type");
193 }
194 }
195
196 BKE_image_release_ibuf(ima, ibuf, nullptr);
197 }
198 }
199 }
200 }
201
202 if (!ok) {
203 break;
204 }
205 }
207
208 return ok;
209}
210
215
217{
218 const float vec_alpha[4] = {0.0f, 0.0f, 0.0f, 0.0f};
219 const float vec_solid[4] = {0.0f, 0.0f, 0.0f, 1.0f};
220 const float nor_alpha[4] = {0.5f, 0.5f, 1.0f, 0.0f};
221 const float nor_solid[4] = {0.5f, 0.5f, 1.0f, 1.0f};
222 const float disp_alpha[4] = {0.5f, 0.5f, 0.5f, 0.0f};
223 const float disp_solid[4] = {0.5f, 0.5f, 0.5f, 1.0f};
224
225 if ((image->id.tag & ID_TAG_DOIT) == 0) {
226 for (ImageTile &tile : image->tiles) {
227 ImageUser iuser;
228 BKE_imageuser_default(&iuser);
229 iuser.tile = tile.tile_number;
230
231 ImBuf *ibuf = BKE_image_acquire_ibuf(image, &iuser, nullptr);
232
233 if (flag == CLEAR_TANGENT_NORMAL) {
234 IMB_rectfill(ibuf, ibuf->can_contain_alpha() ? nor_alpha : nor_solid);
235 }
236 else if (flag == CLEAR_DISPLACEMENT) {
237 IMB_rectfill(ibuf, ibuf->can_contain_alpha() ? disp_alpha : disp_solid);
238 }
239 else {
240 IMB_rectfill(ibuf, ibuf->can_contain_alpha() ? vec_alpha : vec_solid);
241 }
242
243 image->id.tag |= ID_TAG_DOIT;
244
245 BKE_image_release_ibuf(image, ibuf, nullptr);
246 }
247 }
248}
249
250static void clear_images_poly(const Span<Image *> ob_image_array, const ClearFlag flag)
251{
252 for (Image *image : ob_image_array) {
253 if (image) {
254 image->id.tag &= ~ID_TAG_DOIT;
255 }
256 }
257
258 for (Image *image : ob_image_array) {
259 if (image) {
261 }
262 }
263
264 for (Image *image : ob_image_array) {
265 if (image) {
266 image->id.tag &= ~ID_TAG_DOIT;
267 }
268 }
269}
270
272{
273 Scene *scene = CTX_data_scene(C);
274 int objects_baked = 0;
275
276 if (!multiresbake_check(C, op)) {
277 return OPERATOR_CANCELLED;
278 }
279
280 if (scene->r.bake.flag & R_BAKE_CLEAR) { /* clear images */
281 CTX_DATA_BEGIN (C, Base *, base, selected_editable_bases) {
282 Object &object = *base->object;
283 BLI_assert(object.type == OB_MESH);
284
285 ClearFlag clear_flag = ClearFlag(0);
286
287 if (scene->r.bake.type == R_BAKE_NORMALS) {
288 clear_flag = CLEAR_TANGENT_NORMAL;
289 }
290 else if (scene->r.bake.type == R_BAKE_DISPLACEMENT) {
291 clear_flag = CLEAR_DISPLACEMENT;
292 }
293
294 {
295 const Vector<Image *> ob_image_array = bake_object_image_get_array(object);
296 clear_images_poly(ob_image_array, clear_flag);
297 }
298 }
300 }
301
302 CTX_DATA_BEGIN (C, Base *, base, selected_editable_bases) {
303 Object &object = *base->object;
304 BLI_assert(object.type == OB_MESH);
305
307
309
310 /* Copy data stored in job descriptor. */
311 bake.bake_margin = scene->r.bake.margin;
312 if (scene->r.bake.type == R_BAKE_NORMALS) {
313 bake.bake_margin_type = R_BAKE_EXTEND;
314 }
315 else {
316 bake.bake_margin_type = eBakeMarginType(scene->r.bake.margin_type);
317 }
318 bake.type = eBakeType(scene->r.bake.type);
319 bake.displacement_space = eBakeSpace(scene->r.bake.displacement_space);
320 bake.use_low_resolution_mesh = scene->r.bake.flag & R_BAKE_LORES_MESH;
321
322 bake.ob_image = bake_object_image_get_array(object);
323
324 bake.base_mesh = id_cast<Mesh *>(object.data);
325 bake.multires_modifier = get_multires_modifier(scene, &object, false);
326
328
329 objects_baked++;
330 }
332
333 if (!objects_baked) {
334 BKE_report(op->reports, RPT_ERROR, "No objects found to bake from");
335 }
336
337 return OPERATOR_FINISHED;
338}
339
344{
345 Scene *scene = CTX_data_scene(C);
346
347 /* backup scene settings, so their changing in UI would take no effect on baker */
348 bkj->scene = scene;
349 bkj->bake_margin = scene->r.bake.margin;
350 if (scene->r.bake.type == R_BAKE_NORMALS) {
352 }
353 else {
355 }
356 bkj->type = eBakeType(scene->r.bake.type);
359 bkj->bake_clear = scene->r.bake.flag & R_BAKE_CLEAR;
360
361 CTX_DATA_BEGIN (C, Base *, base, selected_editable_bases) {
362 Object &object = *base->object;
363 BLI_assert(object.type == OB_MESH);
364
366
367 MultiresBakerJobData *data = MEM_new<MultiresBakerJobData>(__func__);
368
369 data->ob_image = bake_object_image_get_array(object);
370
371 data->base_mesh = id_cast<Mesh *>(object.data);
372 data->multires_modifier = get_multires_modifier(scene, &object, false);
373
374 BLI_addtail(&bkj->data, data);
375 }
377}
378
379static void multiresbake_startjob(void *bkv, wmJobWorkerStatus *worker_status)
380{
381 MultiresBakeJob *bkj = static_cast<MultiresBakeJob *>(bkv);
382 int baked_objects = 0, tot_obj;
383
384 tot_obj = bkj->data.count();
385
386 if (bkj->bake_clear) { /* clear images */
387 for (MultiresBakerJobData &data : bkj->data) {
388 ClearFlag clear_flag = ClearFlag(0);
389
390 if (bkj->type == R_BAKE_NORMALS) {
391 clear_flag = CLEAR_TANGENT_NORMAL;
392 }
393 else if (bkj->type == R_BAKE_DISPLACEMENT) {
394 clear_flag = CLEAR_DISPLACEMENT;
395 }
396
397 clear_images_poly(data.ob_image, clear_flag);
398 }
399 }
400
401 for (MultiresBakerJobData &data : bkj->data) {
403
404 /* copy data stored in job descriptor */
405 bake.bake_margin = bkj->bake_margin;
406 bake.bake_margin_type = eBakeMarginType(bkj->bake_margin_type);
407 bake.type = bkj->type;
408 bake.displacement_space = bkj->displacement_space;
409 bake.use_low_resolution_mesh = bkj->use_low_resolution_mesh;
410 bake.ob_image = data.ob_image;
411
412 bake.base_mesh = data.base_mesh;
413 bake.multires_modifier = data.multires_modifier;
414
415 /* needed for proper progress bar */
416 bake.num_total_objects = tot_obj;
417 bake.num_baked_objects = baked_objects;
418
419 bake.stop = &worker_status->stop;
420 bake.do_update = &worker_status->do_update;
421 bake.progress = &worker_status->progress;
422
424
425 data.images = bake.images;
426
427 baked_objects++;
428 }
429}
430
431static void multiresbake_freejob(void *bkv)
432{
433 MultiresBakeJob *bkj = static_cast<MultiresBakeJob *>(bkv);
435
436 data = bkj->data.first();
437 while (data) {
438 next = data->next;
439 /* delete here, since this delete will be called from main thread */
440 MEM_delete(data);
441 data = next;
442 }
443
444 MEM_delete(bkj);
445}
446
448{
449 Scene *scene = CTX_data_scene(C);
450
451 if (!multiresbake_check(C, op)) {
452 return OPERATOR_CANCELLED;
453 }
454
457
458 if (!bkr->data.first_) {
459 BKE_report(op->reports, RPT_ERROR, "No objects found to bake from");
460 MEM_delete(bkr);
461 return OPERATOR_CANCELLED;
462 }
463
464 /* setup job */
467 scene,
468 "Baking Multires...",
472 WM_jobs_timer(wm_job, 0.5, NC_IMAGE, 0); /* TODO: only draw bake image, can we enforce this. */
473 WM_jobs_callbacks(wm_job, multiresbake_startjob, nullptr, nullptr, nullptr);
474
475 G.is_break = false;
476
478 WM_cursor_wait(false);
479
480 /* add modal handler for ESC */
482
484}
485
486/* ****************** render BAKING ********************** */
487
490 wmOperator * /*op*/,
491 const wmEvent *event)
492{
493 /* no running blender, remove handler and pass through */
495 {
497 }
498
499 /* running render */
500 switch (event->type) {
501 case EVT_ESCKEY:
503 default: {
504 break;
505 }
506 }
508}
509
510static bool is_multires_bake(Scene *scene)
511{
512 if (ELEM(scene->r.bake.type,
516 R_BAKE_AO))
517 {
518 return scene->r.bake.flag & R_BAKE_MULTIRES;
519 }
520
521 return false;
522}
523
525 wmOperator *op,
526 const wmEvent * /*event*/)
527{
528 Scene *scene = CTX_data_scene(C);
530
532
534
535 return result;
536}
537
539{
540 Scene *scene = CTX_data_scene(C);
542
543 if (!is_multires_bake(scene)) {
544 BLI_assert(0);
545 return result;
546 }
547
549
551
552 return result;
553}
554
556{
557 /* identifiers */
558 ot->name = "Bake";
559 ot->description = "Bake image textures of selected objects";
560 ot->idname = "OBJECT_OT_bake_image";
561
562 /* API callbacks. */
563 ot->exec = bake_image_exec;
567}
568
569} // namespace blender::ed::object
#define CTX_DATA_BEGIN(C, Type, instance, member)
#define CTX_DATA_END
CustomData interface, see also DNA_customdata_types.h.
Object is a sort of wrapper for general info.
Read Blender memory allocation and freeing.
#define C
Definition RandGen.cpp:29
#define ND_RENDER_RESULT
Definition WM_types.hh:465
#define NC_SCENE
Definition WM_types.hh:391
#define NC_IMAGE
Definition WM_types.hh:397
#define ELEM(...)
void append(const T &value)
void reserve(const int64_t min_capacity)
GAttributeReader lookup(const StringRef name) const
constexpr bool is_empty() const
const ccl_global KernelWorkTile * tile
static wmOperatorStatus objects_bake_render_invoke(bContext *C, wmOperator *op, const wmEvent *)
static wmOperatorStatus multiresbake_image_exec(bContext *C, wmOperator *op)
static Image * bake_object_image_get(Object &object, const int mat_nr)
static wmOperatorStatus multiresbake_image_exec_locked(bContext *C, wmOperator *op)
void OBJECT_OT_bake_image(wmOperatorType *ot)
static void multiresbake_startjob(void *bkv, wmJobWorkerStatus *worker_status)
static Vector< Image * > bake_object_image_get_array(Object &object)
static void init_multiresbake_job(bContext *C, MultiresBakeJob *bkj)
static void clear_images_poly(const Span< Image * > ob_image_array, const ClearFlag flag)
static bool is_multires_bake(Scene *scene)
static void multiresbake_freejob(void *bkv)
static void clear_single_image(Image *image, ClearFlag flag)
static wmOperatorStatus bake_image_exec(bContext *C, wmOperator *op)
static bool multiresbake_check(bContext *C, wmOperator *op)
static wmOperatorStatus objects_bake_render_modal(bContext *C, wmOperator *, const wmEvent *event)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
void WM_jobs_callbacks(wmJob *wm_job, wm_jobs_start_callback startjob, void(*initjob)(void *), void(*update)(void *), void(*endjob)(void *))
Definition wm_jobs.cc:407
void RE_multires_bake_images(MultiresBakeRender &bake)
@ WM_JOB_TYPE_OBJECT_BAKE_TEXTURE
Definition WM_api.hh:2017
void IMB_rectfill(ImBuf *drect, const float col[4])
Definition rectop.cc:1165
wmWindow * CTX_wm_window(const bContext *C)
void WM_jobs_customdata_set(wmJob *wm_job, void *customdata, void(*free)(void *customdata))
Definition wm_jobs.cc:377
@ WM_JOB_PRIORITY
Definition WM_api.hh:1990
@ WM_JOB_EXCL_RENDER
Definition WM_api.hh:1995
@ WM_JOB_PROGRESS
Definition WM_api.hh:1997
void multires_flush_sculpt_updates(Object *object)
Definition multires.cc:277
void WM_jobs_start(wmWindowManager *wm, wmJob *wm_job)
Definition wm_jobs.cc:498
Global G
Definition blender.cc:57
void * MEM_new_zeroed(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
MultiresModifierData * get_multires_modifier(Scene *scene, Object *ob, bool use_first)
Definition multires.cc:185
void BKE_report(ReportList *reports, eReportType type, const char *message)
Definition report.cc:162
BMesh const char void * data
bool WM_jobs_has_running(const wmWindowManager *window_manager, const void *owner, const eWM_JobType type, const eWM_JobFlag exclude_flags)
Definition wm_jobs.cc:809
wmWindowManager * CTX_wm_manager(const bContext *C)
bool ED_operator_object_active(bContext *C)
void WM_event_add_notifier(const bContext *C, uint type, void *reference)
ImBuf * BKE_image_acquire_ibuf(Image *ima, ImageUser *iuser, void **r_lock)
@ R_BAKE_VECTOR_DISPLACEMENT
wmEventHandler_Op * WM_event_add_modal_handler(bContext *C, wmOperator *op)
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:118
wmJob * WM_jobs_get(wmWindowManager *wm, wmWindow *win, const void *owner, const char *name, const eWM_JobFlag flag, const eWM_JobType job_type)
Definition wm_jobs.cc:228
@ ID_TAG_DOIT
Definition DNA_ID.h:1029
Scene * CTX_data_scene(const bContext *C)
void BKE_imageuser_default(ImageUser *iuser)
bool BKE_modifier_is_enabled(const Scene *scene, ModifierData *md, int required_mode)
void WM_cursor_wait(bool val)
void WM_jobs_timer(wmJob *wm_job, double time_step, uint note, uint endnote, void(*timer_step)(void *))
Definition wm_jobs.cc:393
void BKE_image_release_ibuf(Image *ima, ImBuf *ibuf, void *lock)
bool ED_object_get_active_image(Object *ob, int mat_nr, Image **r_ima, ImageUser **r_iuser, const bNode **r_node, const bNodeTree **r_ntree)
Definition uvedit_ops.cc:98
eBakeMarginType margin_type
eBakeSpace displacement_space
const uint8_t * byte_data() const
const float * float_data() const
bool can_contain_alpha() const
struct ModifierData * next
struct RenderData r
ListBaseT< MultiresBakerJobData > data
wmEventType type
Definition WM_types.hh:817
wmOperatorStatus(*) exec(bContext *C, wmOperator *op) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1125
const char * description
Definition WM_types.hh:1115
bool(*) poll(bContext *C) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1165
wmOperatorStatus(*) invoke(bContext *C, wmOperator *op, const wmEvent *event) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1141
wmOperatorStatus(*) modal(bContext *C, wmOperator *op, const wmEvent *event) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1157
struct ReportList * reports