diff options
Diffstat (limited to 'source/blender/render/intern')
| -rw-r--r-- | source/blender/render/intern/bake.c | 42 | ||||
| -rw-r--r-- | source/blender/render/intern/engine.cc (renamed from source/blender/render/intern/engine.c) | 329 | ||||
| -rw-r--r-- | source/blender/render/intern/initrender.cc (renamed from source/blender/render/intern/initrender.c) | 8 | ||||
| -rw-r--r-- | source/blender/render/intern/multires_bake.c | 22 | ||||
| -rw-r--r-- | source/blender/render/intern/pipeline.cc (renamed from source/blender/render/intern/pipeline.c) | 420 | ||||
| -rw-r--r-- | source/blender/render/intern/render_result.cc (renamed from source/blender/render/intern/render_result.c) | 291 | ||||
| -rw-r--r-- | source/blender/render/intern/render_result.h | 3 | ||||
| -rw-r--r-- | source/blender/render/intern/render_types.h | 7 | ||||
| -rw-r--r-- | source/blender/render/intern/texture_common.h | 4 | ||||
| -rw-r--r-- | source/blender/render/intern/texture_image.c | 318 | ||||
| -rw-r--r-- | source/blender/render/intern/texture_margin.cc | 14 | ||||
| -rw-r--r-- | source/blender/render/intern/texture_pointdensity.c | 8 | ||||
| -rw-r--r-- | source/blender/render/intern/texture_procedural.c | 415 |
13 files changed, 680 insertions, 1201 deletions
diff --git a/source/blender/render/intern/bake.c b/source/blender/render/intern/bake.c index 9ffe2879779..c383d13e4e1 100644 --- a/source/blender/render/intern/bake.c +++ b/source/blender/render/intern/bake.c @@ -72,7 +72,6 @@ #include "RE_texture_margin.h" /* local include */ -#include "render_types.h" #include "zbuf.h" typedef struct BakeDataZSpan { @@ -460,7 +459,10 @@ static TriTessFace *mesh_calc_tri_tessface(Mesh *me, bool tangent, Mesh *me_eval unsigned int mpoly_prev = UINT_MAX; float no[3]; - const MVert *mvert = CustomData_get_layer(&me->vdata, CD_MVERT); + const MVert *verts = BKE_mesh_verts(me); + const MPoly *polys = BKE_mesh_polys(me); + const MLoop *loops = BKE_mesh_loops(me); + looptri = MEM_mallocN(sizeof(*looptri) * tottri, __func__); triangles = MEM_callocN(sizeof(TriTessFace) * tottri, __func__); @@ -471,10 +473,10 @@ static TriTessFace *mesh_calc_tri_tessface(Mesh *me, bool tangent, Mesh *me_eval if (precomputed_normals != NULL) { BKE_mesh_recalc_looptri_with_normals( - me->mloop, me->mpoly, me->mvert, me->totloop, me->totpoly, looptri, precomputed_normals); + loops, polys, verts, me->totloop, me->totpoly, looptri, precomputed_normals); } else { - BKE_mesh_recalc_looptri(me->mloop, me->mpoly, me->mvert, me->totloop, me->totpoly, looptri); + BKE_mesh_recalc_looptri(loops, polys, verts, me->totloop, me->totpoly, looptri); } const TSpace *tspace = NULL; @@ -493,14 +495,14 @@ static TriTessFace *mesh_calc_tri_tessface(Mesh *me, bool tangent, Mesh *me_eval const float(*vert_normals)[3] = BKE_mesh_vertex_normals_ensure(me); for (i = 0; i < tottri; i++) { const MLoopTri *lt = &looptri[i]; - const MPoly *mp = &me->mpoly[lt->poly]; - - triangles[i].mverts[0] = &mvert[me->mloop[lt->tri[0]].v]; - triangles[i].mverts[1] = &mvert[me->mloop[lt->tri[1]].v]; - triangles[i].mverts[2] = &mvert[me->mloop[lt->tri[2]].v]; - triangles[i].vert_normals[0] = vert_normals[me->mloop[lt->tri[0]].v]; - triangles[i].vert_normals[1] = vert_normals[me->mloop[lt->tri[1]].v]; - triangles[i].vert_normals[2] = vert_normals[me->mloop[lt->tri[2]].v]; + const MPoly *mp = &polys[lt->poly]; + + triangles[i].mverts[0] = &verts[loops[lt->tri[0]].v]; + triangles[i].mverts[1] = &verts[loops[lt->tri[1]].v]; + triangles[i].mverts[2] = &verts[loops[lt->tri[2]].v]; + triangles[i].vert_normals[0] = vert_normals[loops[lt->tri[0]].v]; + triangles[i].vert_normals[1] = vert_normals[loops[lt->tri[1]].v]; + triangles[i].vert_normals[2] = vert_normals[loops[lt->tri[2]].v]; triangles[i].is_smooth = (mp->flag & ME_SMOOTH) != 0; if (tangent) { @@ -517,7 +519,7 @@ static TriTessFace *mesh_calc_tri_tessface(Mesh *me, bool tangent, Mesh *me_eval if (calculate_normal) { if (lt->poly != mpoly_prev) { - BKE_mesh_calc_poly_normal(mp, &me->mloop[mp->loopstart], me->mvert, no); + BKE_mesh_calc_poly_normal(mp, &loops[mp->loopstart], verts, no); mpoly_prev = lt->poly; } copy_v3_v3(triangles[i].normal, no); @@ -739,16 +741,20 @@ void RE_bake_pixels_populate(Mesh *me, const int tottri = poly_to_tri_count(me->totpoly, me->totloop); MLoopTri *looptri = MEM_mallocN(sizeof(*looptri) * tottri, __func__); - BKE_mesh_recalc_looptri(me->mloop, me->mpoly, me->mvert, me->totloop, me->totpoly, looptri); + const MVert *verts = BKE_mesh_verts(me); + const MPoly *polys = BKE_mesh_polys(me); + const MLoop *loops = BKE_mesh_loops(me); + BKE_mesh_recalc_looptri(loops, polys, verts, me->totloop, me->totpoly, looptri); + + const int *material_indices = BKE_mesh_material_indices(me); for (int i = 0; i < tottri; i++) { const MLoopTri *lt = &looptri[i]; - const MPoly *mp = &me->mpoly[lt->poly]; bd.primitive_id = i; /* Find images matching this material. */ - Image *image = targets->material_to_image[mp->mat_nr]; + Image *image = targets->material_to_image[material_indices ? material_indices[lt->poly] : 0]; for (int image_id = 0; image_id < targets->images_num; image_id++) { BakeImage *bk_image = &targets->images[image_id]; if (bk_image->image != image) { @@ -760,8 +766,8 @@ void RE_bake_pixels_populate(Mesh *me, for (int a = 0; a < 3; a++) { const float *uv = mloopuv[lt->tri[a]].uv; - /* NOTE(campbell): workaround for pixel aligned UVs which are common and can screw up our - * intersection tests where a pixel gets in between 2 faces or the middle of a quad, + /* NOTE(@campbellbarton): workaround for pixel aligned UVs which are common and can screw + * up our intersection tests where a pixel gets in between 2 faces or the middle of a quad, * camera aligned quads also have this problem but they are less common. * Add a small offset to the UVs, fixes bug T18685. */ vec[a][0] = (uv[0] - bk_image->uv_offset[0]) * (float)bk_image->width - (0.5f + 0.001f); diff --git a/source/blender/render/intern/engine.c b/source/blender/render/intern/engine.cc index 8a4b4c2a70d..a440b34af78 100644 --- a/source/blender/render/intern/engine.c +++ b/source/blender/render/intern/engine.cc @@ -5,9 +5,9 @@ * \ingroup render */ -#include <stddef.h> -#include <stdlib.h> -#include <string.h> +#include <cstddef> +#include <cstdlib> +#include <cstring> #include "MEM_guardedalloc.h" @@ -46,13 +46,16 @@ #include "DRW_engine.h" +#include "GPU_context.h" +#include "WM_api.h" + #include "pipeline.h" #include "render_result.h" #include "render_types.h" /* Render Engine Types */ -ListBase R_engines = {NULL, NULL}; +ListBase R_engines = {nullptr, nullptr}; void RE_engines_init(void) { @@ -70,7 +73,7 @@ void RE_engines_exit(void) DRW_engines_free(); - for (type = R_engines.first; type; type = next) { + for (type = static_cast<RenderEngineType *>(R_engines.first); type; type = next) { next = type->next; BLI_remlink(&R_engines, type); @@ -95,11 +98,11 @@ void RE_engines_register(RenderEngineType *render_type) RenderEngineType *RE_engines_find(const char *idname) { - RenderEngineType *type; - - type = BLI_findstring(&R_engines, idname, offsetof(RenderEngineType, idname)); + RenderEngineType *type = static_cast<RenderEngineType *>( + BLI_findstring(&R_engines, idname, offsetof(RenderEngineType, idname))); if (!type) { - type = BLI_findstring(&R_engines, "BLENDER_EEVEE", offsetof(RenderEngineType, idname)); + type = static_cast<RenderEngineType *>( + BLI_findstring(&R_engines, "BLENDER_EEVEE", offsetof(RenderEngineType, idname))); } return type; @@ -113,7 +116,8 @@ bool RE_engine_is_external(const Render *re) bool RE_engine_is_opengl(RenderEngineType *render_type) { /* TODO: refine? Can we have ogl render engine without ogl render pipeline? */ - return (render_type->draw_engine != NULL) && DRW_engine_render_support(render_type->draw_engine); + return (render_type->draw_engine != nullptr) && + DRW_engine_render_support(render_type->draw_engine); } bool RE_engine_supports_alembic_procedural(const RenderEngineType *render_type, Scene *scene) @@ -133,10 +137,11 @@ bool RE_engine_supports_alembic_procedural(const RenderEngineType *render_type, RenderEngine *RE_engine_create(RenderEngineType *type) { - RenderEngine *engine = MEM_callocN(sizeof(RenderEngine), "RenderEngine"); + RenderEngine *engine = MEM_cnew<RenderEngine>("RenderEngine"); engine->type = type; BLI_mutex_init(&engine->update_render_passes_mutex); + BLI_mutex_init(&engine->gpu_context_mutex); return engine; } @@ -151,7 +156,7 @@ static void engine_depsgraph_free(RenderEngine *engine) } DEG_graph_free(engine->depsgraph); - engine->depsgraph = NULL; + engine->depsgraph = nullptr; if (use_gpu_context) { DRW_render_context_disable(engine->re); @@ -169,6 +174,7 @@ void RE_engine_free(RenderEngine *engine) engine_depsgraph_free(engine); + BLI_mutex_end(&engine->gpu_context_mutex); BLI_mutex_end(&engine->update_render_passes_mutex); MEM_freeN(engine); @@ -176,10 +182,20 @@ void RE_engine_free(RenderEngine *engine) /* Bake Render Results */ -static RenderResult *render_result_from_bake(RenderEngine *engine, int x, int y, int w, int h) +static RenderResult *render_result_from_bake( + RenderEngine *engine, int x, int y, int w, int h, const char *layername) { + BakeImage *image = &engine->bake.targets->images[engine->bake.image_id]; + const BakePixel *pixels = engine->bake.pixels + image->offset; + const size_t channels_num = engine->bake.targets->channels_num; + + /* Remember layer name for to match images in render_frame_finish. */ + if (image->render_layer_name[0] == '\0') { + STRNCPY(image->render_layer_name, layername); + } + /* Create render result with specified size. */ - RenderResult *rr = MEM_callocN(sizeof(RenderResult), __func__); + RenderResult *rr = MEM_cnew<RenderResult>(__func__); rr->rectx = w; rr->recty = h; @@ -189,13 +205,14 @@ static RenderResult *render_result_from_bake(RenderEngine *engine, int x, int y, rr->tilerect.ymax = y + h; /* Add single baking render layer. */ - RenderLayer *rl = MEM_callocN(sizeof(RenderLayer), "bake render layer"); + RenderLayer *rl = MEM_cnew<RenderLayer>("bake render layer"); + STRNCPY(rl->name, layername); rl->rectx = w; rl->recty = h; BLI_addtail(&rr->layers, rl); /* Add render passes. */ - render_layer_add_pass(rr, rl, engine->bake.depth, RE_PASSNAME_COMBINED, "", "RGBA", true); + render_layer_add_pass(rr, rl, channels_num, RE_PASSNAME_COMBINED, "", "RGBA", true); RenderPass *primitive_pass = render_layer_add_pass(rr, rl, 4, "BakePrimitive", "", "RGBA", true); RenderPass *differential_pass = render_layer_add_pass( @@ -207,8 +224,8 @@ static RenderResult *render_result_from_bake(RenderEngine *engine, int x, int y, float *primitive = primitive_pass->rect + offset; float *differential = differential_pass->rect + offset; - size_t bake_offset = (y + ty) * engine->bake.width + x; - const BakePixel *bake_pixel = engine->bake.pixels + bake_offset; + size_t bake_offset = (y + ty) * image->width + x; + const BakePixel *bake_pixel = pixels + bake_offset; for (int tx = 0; tx < w; tx++) { if (bake_pixel->object_id != engine->bake.object_id) { @@ -238,35 +255,50 @@ static RenderResult *render_result_from_bake(RenderEngine *engine, int x, int y, static void render_result_to_bake(RenderEngine *engine, RenderResult *rr) { - RenderPass *rpass = RE_pass_find_by_name(rr->layers.first, RE_PASSNAME_COMBINED, ""); - + RenderLayer *rl = static_cast<RenderLayer *>(rr->layers.first); + RenderPass *rpass = RE_pass_find_by_name(rl, RE_PASSNAME_COMBINED, ""); if (!rpass) { return; } + /* Find bake image corresponding to layer. */ + int image_id = 0; + for (; image_id < engine->bake.targets->images_num; image_id++) { + if (STREQ(engine->bake.targets->images[image_id].render_layer_name, rl->name)) { + break; + } + } + if (image_id == engine->bake.targets->images_num) { + return; + } + + const BakeImage *image = &engine->bake.targets->images[image_id]; + const BakePixel *pixels = engine->bake.pixels + image->offset; + const size_t channels_num = engine->bake.targets->channels_num; + const size_t channels_size = channels_num * sizeof(float); + float *result = engine->bake.result + image->offset * channels_num; + /* Copy from tile render result to full image bake result. Just the pixels for the * object currently being baked, to preserve other objects when baking multiple. */ const int x = rr->tilerect.xmin; const int y = rr->tilerect.ymin; const int w = rr->tilerect.xmax - rr->tilerect.xmin; const int h = rr->tilerect.ymax - rr->tilerect.ymin; - const size_t pixel_depth = engine->bake.depth; - const size_t pixel_size = pixel_depth * sizeof(float); for (int ty = 0; ty < h; ty++) { const size_t offset = ty * w; - const size_t bake_offset = (y + ty) * engine->bake.width + x; + const size_t bake_offset = (y + ty) * image->width + x; - const float *pass_rect = rpass->rect + offset * pixel_depth; - const BakePixel *bake_pixel = engine->bake.pixels + bake_offset; - float *bake_result = engine->bake.result + bake_offset * pixel_depth; + const float *pass_rect = rpass->rect + offset * channels_num; + const BakePixel *bake_pixel = pixels + bake_offset; + float *bake_result = result + bake_offset * channels_num; for (int tx = 0; tx < w; tx++) { if (bake_pixel->object_id == engine->bake.object_id) { - memcpy(bake_result, pass_rect, pixel_size); + memcpy(bake_result, pass_rect, channels_size); } - pass_rect += pixel_depth; - bake_result += pixel_depth; + pass_rect += channels_num; + bake_result += channels_num; bake_pixel++; } } @@ -294,7 +326,7 @@ static void engine_tile_highlight_set(RenderEngine *engine, BLI_mutex_lock(&re->highlighted_tiles_mutex); - if (re->highlighted_tiles == NULL) { + if (re->highlighted_tiles == nullptr) { re->highlighted_tiles = BLI_gset_new( BLI_ghashutil_inthash_v4_p, BLI_ghashutil_inthash_v4_cmp, "highlighted tiles"); } @@ -302,7 +334,7 @@ static void engine_tile_highlight_set(RenderEngine *engine, if (highlight) { HighlightedTile **tile_in_set; if (!BLI_gset_ensure_p_ex(re->highlighted_tiles, tile, (void ***)&tile_in_set)) { - *tile_in_set = MEM_mallocN(sizeof(HighlightedTile), __func__); + *tile_in_set = MEM_cnew<HighlightedTile>(__func__); **tile_in_set = *tile; } } @@ -316,8 +348,8 @@ static void engine_tile_highlight_set(RenderEngine *engine, RenderResult *RE_engine_begin_result( RenderEngine *engine, int x, int y, int w, int h, const char *layername, const char *viewname) { - if (engine->bake.pixels) { - RenderResult *result = render_result_from_bake(engine, x, y, w, h); + if (engine->bake.targets) { + RenderResult *result = render_result_from_bake(engine, x, y, w, h, layername); BLI_addtail(&engine->fullresult, result); return result; } @@ -349,7 +381,7 @@ RenderResult *RE_engine_begin_result( /* TODO: make this thread safe. */ - /* can be NULL if we CLAMP the width or height to 0 */ + /* can be nullptr if we CLAMP the width or height to 0 */ if (result) { render_result_clone_passes(re, result, viewname); render_result_passes_allocated_ensure(result); @@ -378,7 +410,7 @@ static void re_ensure_passes_allocated_thread_safe(Render *re) void RE_engine_update_result(RenderEngine *engine, RenderResult *result) { - if (engine->bake.pixels) { + if (engine->bake.targets) { /* No interactive baking updates for now. */ return; } @@ -388,8 +420,9 @@ void RE_engine_update_result(RenderEngine *engine, RenderResult *result) if (result) { re_ensure_passes_allocated_thread_safe(re); render_result_merge(re->result, result); - result->renlay = result->layers.first; /* weak, draws first layer always */ - re->display_update(re->duh, result, NULL); + result->renlay = static_cast<RenderLayer *>( + result->layers.first); /* weak, draws first layer always */ + re->display_update(re->duh, result, nullptr); } } @@ -405,7 +438,7 @@ void RE_engine_add_pass(RenderEngine *engine, return; } - RE_create_render_pass(re->result, name, channels, chan_id, layername, NULL, false); + RE_create_render_pass(re->result, name, channels, chan_id, layername, nullptr, false); } void RE_engine_end_result( @@ -417,8 +450,10 @@ void RE_engine_end_result( return; } - if (engine->bake.pixels) { - render_result_to_bake(engine, result); + if (engine->bake.targets) { + if (!cancel || merge_results) { + render_result_to_bake(engine, result); + } BLI_remlink(&engine->fullresult, result); render_result_free(result); return; @@ -438,8 +473,9 @@ void RE_engine_end_result( /* draw */ if (!re->test_break(re->tbh)) { - result->renlay = result->layers.first; /* weak, draws first layer always */ - re->display_update(re->duh, result, NULL); + result->renlay = static_cast<RenderLayer *>( + result->layers.first); /* weak, draws first layer always */ + re->display_update(re->duh, result, nullptr); } } @@ -463,7 +499,7 @@ bool RE_engine_test_break(RenderEngine *engine) return re->test_break(re->tbh); } - return 0; + return false; } /* Statistics */ @@ -477,8 +513,8 @@ void RE_engine_update_stats(RenderEngine *engine, const char *stats, const char re->i.statstr = stats; re->i.infostr = info; re->stats_draw(re->sdh, &re->i); - re->i.infostr = NULL; - re->i.statstr = NULL; + re->i.infostr = nullptr; + re->i.statstr = nullptr; } /* set engine text */ @@ -520,20 +556,20 @@ void RE_engine_report(RenderEngine *engine, int type, const char *msg) Render *re = engine->re; if (re) { - BKE_report(engine->re->reports, type, msg); + BKE_report(engine->re->reports, (eReportType)type, msg); } else if (engine->reports) { - BKE_report(engine->reports, type, msg); + BKE_report(engine->reports, (eReportType)type, msg); } } void RE_engine_set_error_message(RenderEngine *engine, const char *msg) { Render *re = engine->re; - if (re != NULL) { + if (re != nullptr) { RenderResult *rr = RE_AcquireResultRead(re); if (rr) { - if (rr->error != NULL) { + if (rr->error != nullptr) { MEM_freeN(rr->error); } rr->error = BLI_strdup(msg); @@ -545,17 +581,17 @@ void RE_engine_set_error_message(RenderEngine *engine, const char *msg) RenderPass *RE_engine_pass_by_index_get(RenderEngine *engine, const char *layer_name, int index) { Render *re = engine->re; - if (re == NULL) { - return NULL; + if (re == nullptr) { + return nullptr; } - RenderPass *pass = NULL; + RenderPass *pass = nullptr; RenderResult *rr = RE_AcquireResultRead(re); - if (rr != NULL) { + if (rr != nullptr) { const RenderLayer *layer = RE_GetRenderLayer(rr, layer_name); - if (layer != NULL) { - pass = BLI_findlink(&layer->passes, index); + if (layer != nullptr) { + pass = static_cast<RenderPass *>(BLI_findlink(&layer->passes, index)); } } RE_ReleaseResult(re); @@ -580,8 +616,8 @@ float RE_engine_get_camera_shift_x(RenderEngine *engine, Object *camera, bool us /* When using spherical stereo, get camera shift without multiview, * leaving stereo to be handled by the engine. */ Render *re = engine->re; - if (use_spherical_stereo || re == NULL) { - return BKE_camera_multiview_shift_x(NULL, camera, NULL); + if (use_spherical_stereo || re == nullptr) { + return BKE_camera_multiview_shift_x(nullptr, camera, nullptr); } return BKE_camera_multiview_shift_x(&re->r, camera, re->viewname); @@ -595,8 +631,8 @@ void RE_engine_get_camera_model_matrix(RenderEngine *engine, /* When using spherical stereo, get model matrix without multiview, * leaving stereo to be handled by the engine. */ Render *re = engine->re; - if (use_spherical_stereo || re == NULL) { - BKE_camera_multiview_model_matrix(NULL, camera, NULL, (float(*)[4])r_modelmat); + if (use_spherical_stereo || re == nullptr) { + BKE_camera_multiview_model_matrix(nullptr, camera, nullptr, (float(*)[4])r_modelmat); } else { BKE_camera_multiview_model_matrix(&re->r, camera, re->viewname, (float(*)[4])r_modelmat); @@ -606,7 +642,7 @@ void RE_engine_get_camera_model_matrix(RenderEngine *engine, bool RE_engine_get_spherical_stereo(RenderEngine *engine, Object *camera) { Render *re = engine->re; - return BKE_camera_multiview_spherical_stereo(re ? &re->r : NULL, camera) ? 1 : 0; + return BKE_camera_multiview_spherical_stereo(re ? &re->r : nullptr, camera) ? true : false; } rcti *RE_engine_get_current_tiles(Render *re, int *r_total_tiles, bool *r_needs_free) @@ -621,10 +657,10 @@ rcti *RE_engine_get_current_tiles(Render *re, int *r_total_tiles, bool *r_needs_ *r_needs_free = false; - if (re->highlighted_tiles == NULL) { + if (re->highlighted_tiles == nullptr) { *r_total_tiles = 0; BLI_mutex_unlock(&re->highlighted_tiles_mutex); - return NULL; + return nullptr; } GSET_FOREACH_BEGIN (HighlightedTile *, tile, re->highlighted_tiles) { @@ -637,10 +673,10 @@ rcti *RE_engine_get_current_tiles(Render *re, int *r_total_tiles, bool *r_needs_ /* Can not realloc yet, tiles are pointing to a * stack memory. */ - tiles = MEM_mallocN(allocation_size * sizeof(rcti), "current engine tiles"); + tiles = MEM_cnew_array<rcti>(allocation_size, "current engine tiles"); } else { - tiles = MEM_reallocN(tiles, allocation_size * sizeof(rcti)); + tiles = static_cast<rcti *>(MEM_reallocN(tiles, allocation_size * sizeof(rcti))); } *r_needs_free = true; } @@ -705,7 +741,7 @@ static void engine_depsgraph_init(RenderEngine *engine, ViewLayer *view_layer) if (!engine->depsgraph) { /* Ensure we only use persistent data for one scene / view layer at a time, * to avoid excessive memory usage. */ - RE_FreePersistentData(NULL); + RE_FreePersistentData(nullptr); /* Create new depsgraph if not cached with persistent data. */ engine->depsgraph = DEG_graph_new(bmain, scene, view_layer, DAG_EVAL_RENDER); @@ -783,7 +819,7 @@ void RE_bake_engine_set_engine_parameters(Render *re, Main *bmain, Scene *scene) bool RE_bake_has_engine(const Render *re) { const RenderEngineType *type = RE_engines_find(re->r.engine); - return (type->bake != NULL); + return (type->bake != nullptr); } bool RE_bake_engine(Render *re, @@ -827,23 +863,29 @@ bool RE_bake_engine(Render *re, type->update(engine, re->main, engine->depsgraph); } - for (int i = 0; i < targets->images_num; i++) { - const BakeImage *image = targets->images + i; + /* Bake all images. */ + engine->bake.targets = targets; + engine->bake.pixels = pixel_array; + engine->bake.result = result; + engine->bake.object_id = object_id; - engine->bake.pixels = pixel_array + image->offset; - engine->bake.result = result + image->offset * targets->channels_num; - engine->bake.width = image->width; - engine->bake.height = image->height; - engine->bake.depth = targets->channels_num; - engine->bake.object_id = object_id; + for (int i = 0; i < targets->images_num; i++) { + const BakeImage *image = &targets->images[i]; + engine->bake.image_id = i; type->bake( engine, engine->depsgraph, object, pass_type, pass_filter, image->width, image->height); + } - memset(&engine->bake, 0, sizeof(engine->bake)); + /* Optionally let render images read bake images from disk delayed. */ + if (type->render_frame_finish) { + engine->bake.image_id = 0; + type->render_frame_finish(engine); } - engine->depsgraph = NULL; + memset(&engine->bake, 0, sizeof(engine->bake)); + + engine->depsgraph = nullptr; } engine->flag &= ~RE_ENGINE_RENDERING; @@ -851,7 +893,7 @@ bool RE_bake_engine(Render *re, engine_depsgraph_free(engine); RE_engine_free(engine); - re->engine = NULL; + re->engine = nullptr; if (BKE_reports_contain(re->reports, RPT_ERROR)) { G.is_break = true; @@ -874,8 +916,8 @@ static void engine_render_view_layer(Render *re, } /* Create depsgraph with scene evaluated at render resolution. */ - ViewLayer *view_layer = BLI_findstring( - &re->scene->view_layers, view_layer_iter->name, offsetof(ViewLayer, name)); + ViewLayer *view_layer = static_cast<ViewLayer *>( + BLI_findstring(&re->scene->view_layers, view_layer_iter->name, offsetof(ViewLayer, name))); engine_depsgraph_init(engine, view_layer); /* Sync data to engine, within draw lock so scene data can be accessed safely. */ @@ -918,7 +960,7 @@ static void engine_render_view_layer(Render *re, /* NOTE: External engine might have been requested to free its * dependency graph, which is only allowed if there is no grease * pencil (pipeline is taking care of that). */ - if (!RE_engine_test_break(engine) && engine->depsgraph != NULL) { + if (!RE_engine_test_break(engine) && engine->depsgraph != nullptr) { DRW_render_gpencil(engine, engine->depsgraph); } } @@ -950,6 +992,16 @@ bool RE_engine_render(Render *re, bool do_all) re->draw_lock(re->dlh, true); } + if ((type->flag & RE_USE_GPU_CONTEXT) && !GPU_backend_supported()) { + /* Clear UI drawing locks. */ + if (re->draw_lock) { + re->draw_lock(re->dlh, false); + } + BKE_report(re->reports, RPT_ERROR, "Can not initialize the GPU"); + G.is_break = true; + return true; + } + /* update animation here so any render layer animation is applied before * creating the render result */ if ((re->r.scemode & (R_NO_FRAME_UPDATE | R_BUTS_PREVIEW)) == 0) { @@ -958,7 +1010,7 @@ bool RE_engine_render(Render *re, bool do_all) /* create render result */ BLI_rw_mutex_lock(&re->resultmutex, THREAD_LOCK_WRITE); - if (re->result == NULL || !(re->r.scemode & R_BUTS_PREVIEW)) { + if (re->result == nullptr || !(re->r.scemode & R_BUTS_PREVIEW)) { if (re->result) { render_result_free(re->result); } @@ -967,7 +1019,7 @@ bool RE_engine_render(Render *re, bool do_all) } BLI_rw_mutex_unlock(&re->resultmutex); - if (re->result == NULL) { + if (re->result == nullptr) { /* Clear UI drawing locks. */ if (re->draw_lock) { re->draw_lock(re->dlh, false); @@ -1050,14 +1102,15 @@ bool RE_engine_render(Render *re, bool do_all) /* Clear tile data */ engine->flag &= ~RE_ENGINE_RENDERING; - render_result_free_list(&engine->fullresult, engine->fullresult.first); + render_result_free_list(&engine->fullresult, + static_cast<RenderResult *>(engine->fullresult.first)); /* re->engine becomes zero if user changed active render engine during render */ if (!engine_keep_depsgraph(engine) || !re->engine) { engine_depsgraph_free(engine); RE_engine_free(engine); - re->engine = NULL; + re->engine = nullptr; } if (re->r.scemode & R_EXR_CACHE_FILE) { @@ -1094,8 +1147,8 @@ void RE_engine_update_render_passes(struct RenderEngine *engine, engine->update_render_passes_cb = callback; engine->update_render_passes_data = callback_data; engine->type->update_render_passes(engine, scene, view_layer); - engine->update_render_passes_cb = NULL; - engine->update_render_passes_data = NULL; + engine->update_render_passes_cb = nullptr; + engine->update_render_passes_data = nullptr; BLI_mutex_unlock(&engine->update_render_passes_mutex); } @@ -1139,7 +1192,8 @@ bool RE_engine_draw_acquire(Render *re) RenderEngine *engine = re->engine; - if (engine == NULL || engine->type->draw == NULL || (engine->flag & RE_ENGINE_CAN_DRAW) == 0) { + if (engine == nullptr || engine->type->draw == nullptr || + (engine->flag & RE_ENGINE_CAN_DRAW) == 0) { BLI_mutex_unlock(&re->engine_draw_mutex); return false; } @@ -1171,7 +1225,7 @@ void RE_engine_tile_highlight_clear_all(RenderEngine *engine) BLI_mutex_lock(&re->highlighted_tiles_mutex); - if (re->highlighted_tiles != NULL) { + if (re->highlighted_tiles != nullptr) { BLI_gset_clear(re->highlighted_tiles, MEM_freeN); } @@ -1181,27 +1235,106 @@ void RE_engine_tile_highlight_clear_all(RenderEngine *engine) /* -------------------------------------------------------------------- */ /** \name OpenGL context manipulation. * - * NOTE: Only used for Cycles's BLenderGPUDisplay integration with the draw manager. A subject - * for re-consideration. Do not use this functionality. + * GPU context for engine to create and update GPU resources in its own thread, + * without blocking the main thread. Used by Cycles' display driver to create + * display textures. + * * \{ */ -bool RE_engine_has_render_context(RenderEngine *engine) +bool RE_engine_gpu_context_create(RenderEngine *engine) { - if (engine->re == NULL) { - return false; + /* If the there already is a draw manager render context available, reuse it. */ + engine->use_drw_render_context = (engine->re && RE_gl_context_get(engine->re)); + if (engine->use_drw_render_context) { + return true; + } + + /* Viewport render case where no render context is available. We are expected to be on + * the main thread here to safely create a context. */ + BLI_assert(BLI_thread_is_main()); + + const bool drw_state = DRW_opengl_context_release(); + engine->gpu_context = WM_opengl_context_create(); + + /* On Windows an old context is restored after creation, and subsequent release of context + * generates a Win32 error. Harmless for users, but annoying to have possible misleading + * error prints in the console. */ +#ifndef _WIN32 + if (engine->gpu_context) { + WM_opengl_context_release(engine->gpu_context); } +#endif - return RE_gl_context_get(engine->re) != NULL; + DRW_opengl_context_activate(drw_state); + + return engine->gpu_context != nullptr; +} + +void RE_engine_gpu_context_destroy(RenderEngine *engine) +{ + if (!engine->gpu_context) { + return; + } + + BLI_assert(BLI_thread_is_main()); + + const bool drw_state = DRW_opengl_context_release(); + + WM_opengl_context_activate(engine->gpu_context); + WM_opengl_context_dispose(engine->gpu_context); + + DRW_opengl_context_activate(drw_state); +} + +bool RE_engine_gpu_context_enable(RenderEngine *engine) +{ + if (engine->use_drw_render_context) { + DRW_render_context_enable(engine->re); + return true; + } + if (engine->gpu_context) { + BLI_mutex_lock(&engine->gpu_context_mutex); + WM_opengl_context_activate(engine->gpu_context); + return true; + } + return false; +} + +void RE_engine_gpu_context_disable(RenderEngine *engine) +{ + if (engine->use_drw_render_context) { + DRW_render_context_disable(engine->re); + } + else { + if (engine->gpu_context) { + WM_opengl_context_release(engine->gpu_context); + BLI_mutex_unlock(&engine->gpu_context_mutex); + } + } } -void RE_engine_render_context_enable(RenderEngine *engine) +void RE_engine_gpu_context_lock(RenderEngine *engine) { - DRW_render_context_enable(engine->re); + if (engine->use_drw_render_context) { + /* Locking already handled by the draw manager. */ + } + else { + if (engine->gpu_context) { + BLI_mutex_lock(&engine->gpu_context_mutex); + } + } } -void RE_engine_render_context_disable(RenderEngine *engine) +void RE_engine_gpu_context_unlock(RenderEngine *engine) { - DRW_render_context_disable(engine->re); + if (engine->use_drw_render_context) { + /* Locking already handled by the draw manager. */ + } + else { + if (engine->gpu_context) { + BLI_mutex_unlock(&engine->gpu_context_mutex); + } + } } /** \} */ diff --git a/source/blender/render/intern/initrender.c b/source/blender/render/intern/initrender.cc index a2a6a5815a0..cc05aa8621e 100644 --- a/source/blender/render/intern/initrender.c +++ b/source/blender/render/intern/initrender.cc @@ -7,10 +7,10 @@ /* Global includes */ -#include <math.h> -#include <stdio.h> -#include <stdlib.h> -#include <string.h> +#include <cmath> +#include <cstdio> +#include <cstdlib> +#include <cstring> #include "MEM_guardedalloc.h" diff --git a/source/blender/render/intern/multires_bake.c b/source/blender/render/intern/multires_bake.c index e3229e20595..79eddd20bdf 100644 --- a/source/blender/render/intern/multires_bake.c +++ b/source/blender/render/intern/multires_bake.c @@ -63,6 +63,7 @@ typedef struct { MVert *mvert; const float (*vert_normals)[3]; MPoly *mpoly; + const int *material_indices; MLoop *mloop; MLoopUV *mloopuv; float uv_offset[2]; @@ -382,8 +383,7 @@ static void *do_multires_bake_thread(void *data_v) while ((tri_index = multires_bake_queue_next_tri(handle->queue)) >= 0) { const MLoopTri *lt = &data->mlooptri[tri_index]; - const MPoly *mp = &data->mpoly[lt->poly]; - const short mat_nr = mp->mat_nr; + const short mat_nr = data->material_indices == NULL ? 0 : data->material_indices[lt->poly]; const MLoopUV *mloopuv = data->mloopuv; if (multiresbake_test_break(bkr)) { @@ -485,10 +485,18 @@ static void do_multires_bake(MultiresBakeRender *bkr, Mesh *temp_mesh = BKE_mesh_new_nomain( dm->getNumVerts(dm), dm->getNumEdges(dm), 0, dm->getNumLoops(dm), dm->getNumPolys(dm)); - memcpy(temp_mesh->mvert, dm->getVertArray(dm), temp_mesh->totvert * sizeof(*temp_mesh->mvert)); - memcpy(temp_mesh->medge, dm->getEdgeArray(dm), temp_mesh->totedge * sizeof(*temp_mesh->medge)); - memcpy(temp_mesh->mpoly, dm->getPolyArray(dm), temp_mesh->totpoly * sizeof(*temp_mesh->mpoly)); - memcpy(temp_mesh->mloop, dm->getLoopArray(dm), temp_mesh->totloop * sizeof(*temp_mesh->mloop)); + memcpy(BKE_mesh_verts_for_write(temp_mesh), + dm->getVertArray(dm), + temp_mesh->totvert * sizeof(MVert)); + memcpy(BKE_mesh_edges_for_write(temp_mesh), + dm->getEdgeArray(dm), + temp_mesh->totedge * sizeof(MEdge)); + memcpy(BKE_mesh_polys_for_write(temp_mesh), + dm->getPolyArray(dm), + temp_mesh->totpoly * sizeof(MPoly)); + memcpy(BKE_mesh_loops_for_write(temp_mesh), + dm->getLoopArray(dm), + temp_mesh->totloop * sizeof(MLoop)); const float(*vert_normals)[3] = BKE_mesh_vertex_normals_ensure(temp_mesh); const float(*poly_normals)[3] = BKE_mesh_poly_normals_ensure(temp_mesh); @@ -545,6 +553,8 @@ static void do_multires_bake(MultiresBakeRender *bkr, handle->queue = &queue; handle->data.mpoly = mpoly; + handle->data.material_indices = CustomData_get_layer_named( + &dm->polyData, CD_PROP_INT32, "material_index"); handle->data.mvert = mvert; handle->data.vert_normals = vert_normals; handle->data.mloopuv = mloopuv; diff --git a/source/blender/render/intern/pipeline.c b/source/blender/render/intern/pipeline.cc index 075f1ece647..d9ffb09c5a4 100644 --- a/source/blender/render/intern/pipeline.c +++ b/source/blender/render/intern/pipeline.cc @@ -5,12 +5,12 @@ * \ingroup render */ -#include <errno.h> -#include <limits.h> -#include <math.h> -#include <stddef.h> -#include <stdlib.h> -#include <string.h> +#include <cerrno> +#include <climits> +#include <cmath> +#include <cstddef> +#include <cstdlib> +#include <cstring> #include "DNA_anim_types.h" #include "DNA_collection_types.h" @@ -33,6 +33,7 @@ #include "BLI_string.h" #include "BLI_threads.h" #include "BLI_timecode.h" +#include "BLI_vector.hh" #include "BLT_translation.h" @@ -41,7 +42,6 @@ #include "BKE_callbacks.h" #include "BKE_camera.h" #include "BKE_colortools.h" -#include "BKE_context.h" /* XXX needed by wm_window.h */ #include "BKE_global.h" #include "BKE_image.h" #include "BKE_image_format.h" @@ -49,6 +49,7 @@ #include "BKE_layer.h" #include "BKE_lib_id.h" #include "BKE_lib_remap.h" +#include "BKE_main.h" #include "BKE_mask.h" #include "BKE_modifier.h" #include "BKE_node.h" @@ -79,9 +80,9 @@ #include "SEQ_relations.h" #include "SEQ_render.h" -#include "../../windowmanager/WM_api.h" /* XXX */ -#include "../../windowmanager/wm_window.h" /* XXX */ #include "GPU_context.h" +#include "WM_api.h" +#include "wm_window.h" #ifdef WITH_FREESTYLE # include "FRS_freestyle.h" @@ -123,7 +124,7 @@ /* here we store all renders */ static struct { ListBase renderlist; -} RenderGlobal = {{NULL, NULL}}; +} RenderGlobal = {{nullptr, nullptr}}; /** \} */ @@ -185,7 +186,7 @@ static int default_break(void *UNUSED(arg)) static void stats_background(void *UNUSED(arg), RenderStats *rs) { - if (rs->infostr == NULL) { + if (rs->infostr == nullptr) { return; } @@ -199,14 +200,20 @@ static void stats_background(void *UNUSED(arg), RenderStats *rs) megs_used_memory = (mem_in_use) / (1024.0 * 1024.0); megs_peak_memory = (peak_memory) / (1024.0 * 1024.0); + BLI_timecode_string_from_time_simple( + info_time_str, sizeof(info_time_str), PIL_check_seconds_timer() - rs->starttime); + + /* Compositor calls this from multiple threads, mutex lock to ensure we don't + * get garbled output. */ + static ThreadMutex mutex = BLI_MUTEX_INITIALIZER; + BLI_mutex_lock(&mutex); + fprintf(stdout, TIP_("Fra:%d Mem:%.2fM (Peak %.2fM) "), rs->cfra, megs_used_memory, megs_peak_memory); - BLI_timecode_string_from_time_simple( - info_time_str, sizeof(info_time_str), PIL_check_seconds_timer() - rs->starttime); fprintf(stdout, TIP_("| Time:%s | "), info_time_str); fprintf(stdout, "%s", rs->infostr); @@ -215,11 +222,13 @@ static void stats_background(void *UNUSED(arg), RenderStats *rs) fflush(stdout); /* NOTE: using G_MAIN seems valid here??? - * Not sure it's actually even used anyway, we could as well pass NULL? */ + * Not sure it's actually even used anyway, we could as well pass nullptr? */ BKE_callback_exec_null(G_MAIN, BKE_CB_EVT_RENDER_STATS); fputc('\n', stdout); fflush(stdout); + + BLI_mutex_unlock(&mutex); } void RE_FreeRenderResult(RenderResult *rr) @@ -230,16 +239,17 @@ void RE_FreeRenderResult(RenderResult *rr) float *RE_RenderLayerGetPass(RenderLayer *rl, const char *name, const char *viewname) { RenderPass *rpass = RE_pass_find_by_name(rl, name, viewname); - return rpass ? rpass->rect : NULL; + return rpass ? rpass->rect : nullptr; } RenderLayer *RE_GetRenderLayer(RenderResult *rr, const char *name) { - if (rr == NULL) { - return NULL; + if (rr == nullptr) { + return nullptr; } - return BLI_findstring(&rr->layers, name, offsetof(RenderLayer, name)); + return static_cast<RenderLayer *>( + BLI_findstring(&rr->layers, name, offsetof(RenderLayer, name))); } bool RE_HasSingleLayer(Render *re) @@ -255,17 +265,18 @@ RenderResult *RE_MultilayerConvert( RenderLayer *render_get_active_layer(Render *re, RenderResult *rr) { - ViewLayer *view_layer = BLI_findlink(&re->view_layers, re->active_view_layer); + ViewLayer *view_layer = static_cast<ViewLayer *>( + BLI_findlink(&re->view_layers, re->active_view_layer)); if (view_layer) { - RenderLayer *rl = BLI_findstring(&rr->layers, view_layer->name, offsetof(RenderLayer, name)); + RenderLayer *rl = RE_GetRenderLayer(rr, view_layer->name); if (rl) { return rl; } } - return rr->layers.first; + return static_cast<RenderLayer *>(rr->layers.first); } static bool render_scene_has_layers_to_render(Scene *scene, ViewLayer *single_layer) @@ -274,8 +285,7 @@ static bool render_scene_has_layers_to_render(Scene *scene, ViewLayer *single_la return true; } - ViewLayer *view_layer; - for (view_layer = scene->view_layers.first; view_layer; view_layer = view_layer->next) { + LISTBASE_FOREACH (ViewLayer *, view_layer, &scene->view_layers) { if (view_layer->flag & VIEW_LAYER_RENDER) { return true; } @@ -291,16 +301,14 @@ static bool render_scene_has_layers_to_render(Scene *scene, ViewLayer *single_la Render *RE_GetRender(const char *name) { - Render *re; - /* search for existing renders */ - for (re = RenderGlobal.renderlist.first; re; re = re->next) { + LISTBASE_FOREACH (Render *, re, &RenderGlobal.renderlist) { if (STREQLEN(re->name, name, RE_MAXNAME)) { - break; + return re; } } - return re; + return nullptr; } RenderResult *RE_AcquireResultRead(Render *re) @@ -310,7 +318,7 @@ RenderResult *RE_AcquireResultRead(Render *re) return re->result; } - return NULL; + return nullptr; } RenderResult *RE_AcquireResultWrite(Render *re) @@ -321,14 +329,14 @@ RenderResult *RE_AcquireResultWrite(Render *re) return re->result; } - return NULL; + return nullptr; } void RE_ClearResult(Render *re) { if (re) { render_result_free(re->result); - re->result = NULL; + re->result = nullptr; } } @@ -352,7 +360,7 @@ Scene *RE_GetScene(Render *re) if (re) { return re->scene; } - return NULL; + return nullptr; } void RE_SetScene(Render *re, Scene *sce) @@ -370,30 +378,27 @@ void RE_AcquireResultImageViews(Render *re, RenderResult *rr) BLI_rw_mutex_lock(&re->resultmutex, THREAD_LOCK_READ); if (re->result) { - RenderLayer *rl; - RenderView *rv, *rview; - rr->rectx = re->result->rectx; rr->recty = re->result->recty; /* creates a temporary duplication of views */ render_result_views_shallowcopy(rr, re->result); - rv = rr->views.first; - rr->have_combined = (rv->rectf != NULL); + RenderView *rv = static_cast<RenderView *>(rr->views.first); + rr->have_combined = (rv->rectf != nullptr); /* active layer */ - rl = render_get_active_layer(re, re->result); + RenderLayer *rl = render_get_active_layer(re, re->result); if (rl) { - if (rv->rectf == NULL) { - for (rview = (RenderView *)rr->views.first; rview; rview = rview->next) { + if (rv->rectf == nullptr) { + LISTBASE_FOREACH (RenderView *, rview, &rr->views) { rview->rectf = RE_RenderLayerGetPass(rl, RE_PASSNAME_COMBINED, rview->name); } } - if (rv->rectz == NULL) { - for (rview = (RenderView *)rr->views.first; rview; rview = rview->next) { + if (rv->rectz == nullptr) { + LISTBASE_FOREACH (RenderView *, rview, &rr->views) { rview->rectz = RE_RenderLayerGetPass(rl, RE_PASSNAME_Z, rview->name); } } @@ -431,9 +436,9 @@ void RE_AcquireResultImage(Render *re, RenderResult *rr, const int view_id) rr->rectx = re->result->rectx; rr->recty = re->result->recty; - /* actview view */ + /* `scene.rd.actview` view. */ rv = RE_RenderViewGetById(re->result, view_id); - rr->have_combined = (rv->rectf != NULL); + rr->have_combined = (rv->rectf != nullptr); rr->rectf = rv->rectf; rr->rectz = rv->rectz; @@ -443,11 +448,11 @@ void RE_AcquireResultImage(Render *re, RenderResult *rr, const int view_id) rl = render_get_active_layer(re, re->result); if (rl) { - if (rv->rectf == NULL) { + if (rv->rectf == nullptr) { rr->rectf = RE_RenderLayerGetPass(rl, RE_PASSNAME_COMBINED, rv->name); } - if (rv->rectz == NULL) { + if (rv->rectz == nullptr) { rr->rectz = RE_RenderLayerGetPass(rl, RE_PASSNAME_Z, rv->name); } } @@ -511,10 +516,10 @@ Render *RE_NewRender(const char *name) /* only one render per name exists */ re = RE_GetRender(name); - if (re == NULL) { + if (re == nullptr) { /* new render data struct */ - re = MEM_callocN(sizeof(Render), "new render"); + re = MEM_cnew<Render>("new render"); BLI_addtail(&RenderGlobal.renderlist, re); BLI_strncpy(re->name, name, RE_MAXNAME); BLI_rw_mutex_init(&re->resultmutex); @@ -570,7 +575,7 @@ void RE_InitRenderCB(Render *re) re->stats_draw = stats_nothing; } /* clear callback handles */ - re->dih = re->dch = re->duh = re->sdh = re->prh = re->tbh = NULL; + re->dih = re->dch = re->duh = re->sdh = re->prh = re->tbh = nullptr; } void RE_FreeRender(Render *re) @@ -588,13 +593,13 @@ void RE_FreeRender(Render *re) BKE_curvemapping_free_data(&re->r.mblur_shutter_curve); - if (re->highlighted_tiles != NULL) { + if (re->highlighted_tiles != nullptr) { BLI_gset_free(re->highlighted_tiles, MEM_freeN); } /* main dbase can already be invalid now, some database-free code checks it */ - re->main = NULL; - re->scene = NULL; + re->main = nullptr; + re->scene = nullptr; render_result_free(re->result); render_result_free(re->pushedresult); @@ -606,7 +611,7 @@ void RE_FreeRender(Render *re) void RE_FreeAllRender(void) { while (RenderGlobal.renderlist.first) { - RE_FreeRender(RenderGlobal.renderlist.first); + RE_FreeRender(static_cast<Render *>(RenderGlobal.renderlist.first)); } #ifdef WITH_FREESTYLE @@ -617,25 +622,22 @@ void RE_FreeAllRender(void) void RE_FreeAllRenderResults(void) { - Render *re; - - for (re = RenderGlobal.renderlist.first; re; re = re->next) { + LISTBASE_FOREACH (Render *, re, &RenderGlobal.renderlist) { render_result_free(re->result); render_result_free(re->pushedresult); - re->result = NULL; - re->pushedresult = NULL; + re->result = nullptr; + re->pushedresult = nullptr; } } void RE_FreeAllPersistentData(void) { - Render *re; - for (re = RenderGlobal.renderlist.first; re != NULL; re = re->next) { - if (re->engine != NULL) { + LISTBASE_FOREACH (Render *, re, &RenderGlobal.renderlist) { + if (re->engine != nullptr) { BLI_assert(!(re->engine->flag & RE_ENGINE_RENDERING)); RE_engine_free(re->engine); - re->engine = NULL; + re->engine = nullptr; } } } @@ -645,7 +647,7 @@ static void re_free_persistent_data(Render *re) /* If engine is currently rendering, just wait for it to be freed when it finishes rendering. */ if (re->engine && !(re->engine->flag & RE_ENGINE_RENDERING)) { RE_engine_free(re->engine); - re->engine = NULL; + re->engine = nullptr; } } @@ -659,7 +661,7 @@ void RE_FreePersistentData(const Scene *scene) } } else { - for (Render *re = RenderGlobal.renderlist.first; re; re = re->next) { + LISTBASE_FOREACH (Render *, re, &RenderGlobal.renderlist) { re_free_persistent_data(re); } } @@ -711,7 +713,7 @@ void render_copy_renderdata(RenderData *to, RenderData *from) BLI_freelistN(&to->views); BKE_curvemapping_free_data(&to->mblur_shutter_curve); - *to = *from; + memcpy(to, from, sizeof(*to)); BLI_duplicatelist(&to->views, &from->views); BKE_curvemapping_copy_data(&to->mblur_shutter_curve, &from->mblur_shutter_curve); @@ -779,14 +781,14 @@ void RE_InitState(Render *re, if (had_freestyle || (re->r.mode & R_EDGE_FRS)) { /* freestyle manipulates render layers so always have to free */ render_result_free(re->result); - re->result = NULL; + re->result = nullptr; } else if (re->result) { - ViewLayer *active_render_layer = BLI_findlink(&re->view_layers, re->active_view_layer); - RenderLayer *rl; + ViewLayer *active_render_layer = static_cast<ViewLayer *>( + BLI_findlink(&re->view_layers, re->active_view_layer)); bool have_layer = false; - for (rl = re->result->layers.first; rl; rl = rl->next) { + LISTBASE_FOREACH (RenderLayer *, rl, &re->result->layers) { if (STREQ(rl->name, active_render_layer->name)) { have_layer = true; } @@ -799,7 +801,7 @@ void RE_InitState(Render *re, else { /* free because resolution changed */ render_result_free(re->result); - re->result = NULL; + re->result = nullptr; } } } @@ -807,7 +809,7 @@ void RE_InitState(Render *re, /* make empty render result, so display callbacks can initialize */ render_result_free(re->result); - re->result = MEM_callocN(sizeof(RenderResult), "new render result"); + re->result = MEM_cnew<RenderResult>("new render result"); re->result->rectx = re->rectx; re->result->recty = re->recty; render_result_view_new(re->result, ""); @@ -906,13 +908,13 @@ void RE_gl_context_destroy(Render *re) if (re->gl_context) { if (re->gpu_context) { WM_opengl_context_activate(re->gl_context); - GPU_context_active_set(re->gpu_context); - GPU_context_discard(re->gpu_context); - re->gpu_context = NULL; + GPU_context_active_set(static_cast<GPUContext *>(re->gpu_context)); + GPU_context_discard(static_cast<GPUContext *>(re->gpu_context)); + re->gpu_context = nullptr; } WM_opengl_context_dispose(re->gl_context); - re->gl_context = NULL; + re->gl_context = nullptr; } } @@ -923,8 +925,8 @@ void *RE_gl_context_get(Render *re) void *RE_gpu_context_get(Render *re) { - if (re->gpu_context == NULL) { - re->gpu_context = GPU_context_create(NULL); + if (re->gpu_context == nullptr) { + re->gpu_context = GPU_context_create(nullptr); } return re->gpu_context; } @@ -974,7 +976,7 @@ static void render_result_uncrop(Render *re) rres = render_result_new(re, &re->disprect, RR_ALL_LAYERS, RR_ALL_VIEWS); rres->stamp_data = BKE_stamp_data_copy(re->result->stamp_data); - render_result_clone_passes(re, rres, NULL); + render_result_clone_passes(re, rres, nullptr); render_result_passes_allocated_ensure(rres); render_result_merge(rres, re->result); @@ -987,7 +989,7 @@ static void render_result_uncrop(Render *re) BLI_rw_mutex_unlock(&re->resultmutex); re->display_init(re->dih, re->result); - re->display_update(re->duh, re->result, NULL); + re->display_update(re->duh, re->result, nullptr); /* restore the disprect from border */ re->disprect = orig_disprect; @@ -1007,7 +1009,7 @@ static void do_render_engine(Render *re) { Object *camera = RE_GetCamera(re); /* also check for camera here */ - if (camera == NULL) { + if (camera == nullptr) { BKE_report(re->reports, RPT_ERROR, "Cannot render, no camera"); G.is_break = true; return; @@ -1035,13 +1037,12 @@ static void do_render_compositor_scene(Render *re, Scene *sce, int cfra) BKE_scene_camera_switch_update(sce); /* exception: scene uses own size (unfinished code) */ - if (0) { - winx = (sce->r.size * sce->r.xsch) / 100; - winy = (sce->r.size * sce->r.ysch) / 100; + if (false) { + BKE_render_resolution(&sce->r, false, &winx, &winy); } /* initial setup */ - RE_InitState(resc, re, &sce->r, &sce->view_layers, NULL, winx, winy, &re->disprect); + RE_InitState(resc, re, &sce->r, &sce->view_layers, nullptr, winx, winy, &re->disprect); /* We still want to use 'rendercache' setting from org (main) scene... */ resc->r.scemode = (resc->r.scemode & ~R_EXR_CACHE_FILE) | (re->r.scemode & R_EXR_CACHE_FILE); @@ -1068,9 +1069,8 @@ static void do_render_compositor_scene(Render *re, Scene *sce, int cfra) static int compositor_needs_render(Scene *sce, int this_scene) { bNodeTree *ntree = sce->nodetree; - bNode *node; - if (ntree == NULL) { + if (ntree == nullptr) { return 1; } if (sce->use_nodes == false) { @@ -1080,9 +1080,9 @@ static int compositor_needs_render(Scene *sce, int this_scene) return 1; } - for (node = ntree->nodes.first; node; node = node->next) { + LISTBASE_FOREACH (bNode *, node, &ntree->nodes) { if (node->type == CMP_NODE_R_LAYERS && (node->flag & NODE_MUTED) == 0) { - if (this_scene == 0 || node->id == NULL || node->id == &sce->id) { + if (this_scene == 0 || node->id == nullptr || node->id == &sce->id) { return 1; } } @@ -1093,11 +1093,10 @@ static int compositor_needs_render(Scene *sce, int this_scene) /* Render all scenes within a compositor node tree. */ static void do_render_compositor_scenes(Render *re) { - bNode *node; int cfra = re->scene->r.cfra; Scene *restore_scene = re->scene; - if (re->scene->nodetree == NULL) { + if (re->scene->nodetree == nullptr) { return; } @@ -1106,12 +1105,12 @@ static void do_render_compositor_scenes(Render *re) /* now foreach render-result node we do a full render */ /* results are stored in a way compositor will find it */ GSet *scenes_rendered = BLI_gset_ptr_new(__func__); - for (node = re->scene->nodetree->nodes.first; node; node = node->next) { + LISTBASE_FOREACH (bNode *, node, &re->scene->nodetree->nodes) { if (node->type == CMP_NODE_R_LAYERS && (node->flag & NODE_MUTED) == 0) { if (node->id && node->id != (ID *)re->scene) { Scene *scene = (Scene *)node->id; if (!BLI_gset_haskey(scenes_rendered, scene) && - render_scene_has_layers_to_render(scene, false)) { + render_scene_has_layers_to_render(scene, nullptr)) { do_render_compositor_scene(re, scene, cfra); BLI_gset_add(scenes_rendered, scene); node->typeinfo->updatefunc(restore_scene->nodetree, node); @@ -1123,7 +1122,7 @@ static void do_render_compositor_scenes(Render *re) } } } - BLI_gset_free(scenes_rendered, NULL); + BLI_gset_free(scenes_rendered, nullptr); if (changed_scene) { /* If rendered another scene, switch back to the current scene with compositing nodes. */ @@ -1208,64 +1207,59 @@ static void do_render_compositor(Render *re) /* If we have consistent depsgraph now would be a time to update them. */ } - RenderView *rv; - for (rv = re->result->views.first; rv; rv = rv->next) { + LISTBASE_FOREACH (RenderView *, rv, &re->result->views) { ntreeCompositExecTree( re->pipeline_scene_eval, ntree, &re->r, true, G.background == 0, rv->name); } - ntree->stats_draw = NULL; - ntree->test_break = NULL; - ntree->progress = NULL; - ntree->tbh = ntree->sdh = ntree->prh = NULL; + ntree->stats_draw = nullptr; + ntree->test_break = nullptr; + ntree->progress = nullptr; + ntree->tbh = ntree->sdh = ntree->prh = nullptr; } } } - /* weak... the display callback wants an active renderlayer pointer... */ - if (re->result != NULL) { + /* Weak: the display callback wants an active render-layer pointer. */ + if (re->result != nullptr) { re->result->renlay = render_get_active_layer(re, re->result); - re->display_update(re->duh, re->result, NULL); + re->display_update(re->duh, re->result, nullptr); } } static void renderresult_stampinfo(Render *re) { RenderResult rres; - RenderView *rv; - int nr; + int nr = 0; /* this is the basic trick to get the displayed float or char rect from render result */ - nr = 0; - for (rv = re->result->views.first; rv; rv = rv->next, nr++) { + LISTBASE_FOREACH (RenderView *, rv, &re->result->views) { RE_SetActiveRenderView(re, rv->name); RE_AcquireResultImage(re, &rres, nr); Object *ob_camera_eval = DEG_get_evaluated_object(re->pipeline_depsgraph, RE_GetCamera(re)); BKE_image_stamp_buf(re->scene, ob_camera_eval, - (re->r.stamp & R_STAMP_STRIPMETA) ? rres.stamp_data : NULL, + (re->r.stamp & R_STAMP_STRIPMETA) ? rres.stamp_data : nullptr, (unsigned char *)rres.rect32, rres.rectf, rres.rectx, rres.recty, 4); RE_ReleaseResultImage(re); + nr++; } } int RE_seq_render_active(Scene *scene, RenderData *rd) { - Editing *ed; - Sequence *seq; - - ed = scene->ed; + Editing *ed = scene->ed; if (!(rd->scemode & R_DOSEQ) || !ed || !ed->seqbase.first) { return 0; } - for (seq = ed->seqbase.first; seq; seq = seq->next) { + LISTBASE_FOREACH (Sequence *, seq, &ed->seqbase) { if (seq->type != SEQ_TYPE_SOUND_RAM) { return 1; } @@ -1283,7 +1277,6 @@ static void do_render_sequencer(Render *re) int cfra = re->r.cfra; SeqRenderData context; int view_id, tot_views; - struct ImBuf **ibuf_arr; int re_x, re_y; re->i.cfra = cfra; @@ -1302,7 +1295,7 @@ static void do_render_sequencer(Render *re) } tot_views = BKE_scene_multiview_num_views_get(&re->r); - ibuf_arr = MEM_mallocN(sizeof(ImBuf *) * tot_views, "Sequencer Views ImBufs"); + blender::Vector<ImBuf *> ibuf_arr(tot_views); SEQ_render_new_render_data(re->main, re->pipeline_depsgraph, @@ -1327,7 +1320,7 @@ static void do_render_sequencer(Render *re) SEQ_render_imbuf_from_sequencer_space(re->pipeline_scene_eval, ibuf_arr[view_id]); } else { - ibuf_arr[view_id] = NULL; + ibuf_arr[view_id] = nullptr; } } @@ -1347,7 +1340,7 @@ static void do_render_sequencer(Render *re) if (ibuf_arr[view_id]->metadata && (re->r.stamp & R_STAMP_STRIPMETA)) { /* ensure render stamp info first */ - BKE_render_result_stamp_info(NULL, NULL, rr, true); + BKE_render_result_stamp_info(nullptr, nullptr, rr, true); BKE_stamp_info_from_imbuf(rr, ibuf_arr[view_id]); } @@ -1368,11 +1361,9 @@ static void do_render_sequencer(Render *re) /* would mark display buffers as invalid */ RE_SetActiveRenderView(re, rv->name); - re->display_update(re->duh, re->result, NULL); + re->display_update(re->duh, re->result, nullptr); } - MEM_freeN(ibuf_arr); - recurs_depth--; /* just in case this flag went missing at some point */ @@ -1415,7 +1406,7 @@ static void do_render_full_pipeline(Render *re) } re->stats_draw(re->sdh, &re->i); - re->display_update(re->duh, re->result, NULL); + re->display_update(re->duh, re->result, nullptr); } else { do_render_compositor(re); @@ -1426,7 +1417,7 @@ static void do_render_full_pipeline(Render *re) re->stats_draw(re->sdh, &re->i); /* save render result stamp if needed */ - if (re->result != NULL) { + if (re->result != nullptr) { /* sequence rendering should have taken care of that already */ if (!(render_seq && (re->r.stamp & R_STAMP_STRIPMETA))) { Object *ob_camera_eval = DEG_get_evaluated_object(re->pipeline_depsgraph, RE_GetCamera(re)); @@ -1436,7 +1427,7 @@ static void do_render_full_pipeline(Render *re) /* stamp image info here */ if ((re->r.stamp & R_STAMP_ALL) && (re->r.stamp & R_STAMP_DRAW)) { renderresult_stampinfo(re); - re->display_update(re->duh, re->result, NULL); + re->display_update(re->duh, re->result, nullptr); } } } @@ -1444,38 +1435,34 @@ static void do_render_full_pipeline(Render *re) static bool check_valid_compositing_camera(Scene *scene, Object *camera_override) { if (scene->r.scemode & R_DOCOMP && scene->use_nodes) { - bNode *node = scene->nodetree->nodes.first; - - while (node) { + LISTBASE_FOREACH (bNode *, node, &scene->nodetree->nodes) { if (node->type == CMP_NODE_R_LAYERS && (node->flag & NODE_MUTED) == 0) { Scene *sce = node->id ? (Scene *)node->id : scene; - if (sce->camera == NULL) { + if (sce->camera == nullptr) { sce->camera = BKE_view_layer_camera_find(BKE_view_layer_default_render(sce)); } - if (sce->camera == NULL) { + if (sce->camera == nullptr) { /* all render layers nodes need camera */ return false; } } - node = node->next; } return true; } - return (camera_override != NULL || scene->camera != NULL); + return (camera_override != nullptr || scene->camera != nullptr); } static bool check_valid_camera_multiview(Scene *scene, Object *camera, ReportList *reports) { - SceneRenderView *srv; bool active_view = false; - if (camera == NULL || (scene->r.scemode & R_MULTIVIEW) == 0) { + if (camera == nullptr || (scene->r.scemode & R_MULTIVIEW) == 0) { return true; } - for (srv = scene->r.views.first; srv; srv = srv->next) { + LISTBASE_FOREACH (SceneRenderView *, srv, &scene->r.views) { if (BKE_scene_multiview_is_render_view_active(&scene->r, srv)) { active_view = true; @@ -1509,7 +1496,7 @@ static int check_valid_camera(Scene *scene, Object *camera_override, ReportList { const char *err_msg = "No camera found in scene \"%s\""; - if (camera_override == NULL && scene->camera == NULL) { + if (camera_override == nullptr && scene->camera == nullptr) { scene->camera = BKE_view_layer_camera_find(BKE_view_layer_default_render(scene)); } @@ -1519,16 +1506,14 @@ static int check_valid_camera(Scene *scene, Object *camera_override, ReportList if (RE_seq_render_active(scene, &scene->r)) { if (scene->ed) { - Sequence *seq = scene->ed->seqbase.first; - - while (seq) { + LISTBASE_FOREACH (Sequence *, seq, &scene->ed->seqbase) { if ((seq->type == SEQ_TYPE_SCENE) && ((seq->flag & SEQ_SCENE_STRIPS) == 0) && - (seq->scene != NULL)) { + (seq->scene != nullptr)) { if (!seq->scene_camera) { if (!seq->scene->camera && !BKE_view_layer_camera_find(BKE_view_layer_default_render(seq->scene))) { /* camera could be unneeded due to composite nodes */ - Object *override = (seq->scene == scene) ? camera_override : NULL; + Object *override = (seq->scene == scene) ? camera_override : nullptr; if (!check_valid_compositing_camera(seq->scene, override)) { BKE_reportf(reports, RPT_ERROR, err_msg, seq->scene->id.name + 2); @@ -1540,8 +1525,6 @@ static int check_valid_camera(Scene *scene, Object *camera_override, ReportList return false; } } - - seq = seq->next; } } } @@ -1555,9 +1538,7 @@ static int check_valid_camera(Scene *scene, Object *camera_override, ReportList static bool node_tree_has_compositor_output(bNodeTree *ntree) { - bNode *node; - - for (node = ntree->nodes.first; node; node = node->next) { + LISTBASE_FOREACH (bNode *, node, &ntree->nodes) { if (ELEM(node->type, CMP_NODE_COMPOSITE, CMP_NODE_OUTPUT_FILE)) { return true; } @@ -1589,7 +1570,7 @@ bool RE_is_rendering_allowed(Scene *scene, if (scene->r.border.xmax <= scene->r.border.xmin || scene->r.border.ymax <= scene->r.border.ymin) { BKE_report(reports, RPT_ERROR, "No border area selected"); - return 0; + return false; } } @@ -1604,28 +1585,28 @@ bool RE_is_rendering_allowed(Scene *scene, /* Compositor */ if (!scene->nodetree) { BKE_report(reports, RPT_ERROR, "No node tree in scene"); - return 0; + return false; } if (!check_compositor_output(scene)) { BKE_report(reports, RPT_ERROR, "No render output node in scene"); - return 0; + return false; } } else { /* Regular Render */ if (!render_scene_has_layers_to_render(scene, single_layer)) { BKE_report(reports, RPT_ERROR, "All render layers are disabled"); - return 0; + return false; } } /* check valid camera, without camera render is OK (compo, seq) */ if (!check_valid_camera(scene, camera_override, reports)) { - return 0; + return false; } - return 1; + return true; } static void update_physics_cache(Render *re, @@ -1675,8 +1656,7 @@ static int render_init_from_main(Render *re, * r.border is the clipping rect */ /* calculate actual render result and display size */ - winx = (rd->size * rd->xsch) / 100; - winy = (rd->size * rd->ysch) / 100; + BKE_render_resolution(rd, false, &winx, &winy); /* We always render smaller part, inserting it in larger image is compositor business, * it uses 'disprect' for it. */ @@ -1710,7 +1690,7 @@ static int render_init_from_main(Render *re, * can be later set as render profile option * and default for background render. */ - if (0) { + if (false) { /* make sure dynamics are up to date */ ViewLayer *view_layer = BKE_view_layer_context_active_PLACEHOLDER(scene); update_physics_cache(re, scene, view_layer, anim_init); @@ -1722,7 +1702,7 @@ static int render_init_from_main(Render *re, BLI_rw_mutex_unlock(&re->resultmutex); } - RE_InitState(re, NULL, &scene->r, &scene->view_layers, single_layer, winx, winy, &disprect); + RE_InitState(re, nullptr, &scene->r, &scene->view_layers, single_layer, winx, winy, &disprect); if (!re->ok) { /* if an error was printed, abort */ return 0; } @@ -1770,19 +1750,19 @@ static void render_pipeline_free(Render *re) { if (re->engine && !RE_engine_use_persistent_data(re->engine)) { RE_engine_free(re->engine); - re->engine = NULL; + re->engine = nullptr; } - if (re->pipeline_depsgraph != NULL) { + if (re->pipeline_depsgraph != nullptr) { DEG_graph_free(re->pipeline_depsgraph); - re->pipeline_depsgraph = NULL; - re->pipeline_scene_eval = NULL; + re->pipeline_depsgraph = nullptr; + re->pipeline_scene_eval = nullptr; } /* Destroy the opengl context in the correct thread. */ RE_gl_context_destroy(re); /* In the case the engine did not mark tiles as finished (un-highlight, which could happen in the * case of cancelled render) ensure the storage is empty. */ - if (re->highlighted_tiles != NULL) { + if (re->highlighted_tiles != nullptr) { BLI_mutex_lock(&re->highlighted_tiles_mutex); /* Rendering is supposed to be finished here, so no new tiles are expected to be written. @@ -1790,7 +1770,7 @@ static void render_pipeline_free(Render *re) BLI_assert(re->highlighted_tiles); BLI_gset_free(re->highlighted_tiles, MEM_freeN); - re->highlighted_tiles = NULL; + re->highlighted_tiles = nullptr; BLI_mutex_unlock(&re->highlighted_tiles_mutex); } @@ -1815,7 +1795,8 @@ void RE_RenderFrame(Render *re, scene->r.subframe = subframe; if (render_init_from_main(re, &scene->r, bmain, scene, single_layer, camera_override, 0, 0)) { - const RenderData rd = scene->r; + RenderData rd; + memcpy(&rd, &scene->r, sizeof(rd)); MEM_reset_peak_memory(); render_callback_exec_id(re, re->main, &scene->id, BKE_CB_EVT_RENDER_PRE); @@ -1838,10 +1819,10 @@ void RE_RenderFrame(Render *re, &rd.im_format, (rd.scemode & R_EXTENSION) != 0, false, - NULL); + nullptr); /* reports only used for Movie */ - do_write_image_or_movie(re, bmain, scene, NULL, 0, name); + do_write_image_or_movie(re, bmain, scene, nullptr, 0, name); } } @@ -1871,7 +1852,7 @@ static void change_renderdata_engine(Render *re, const char *new_engine) if (!STREQ(re->r.engine, new_engine)) { if (re->engine) { RE_engine_free(re->engine); - re->engine = NULL; + re->engine = nullptr; } BLI_strncpy(re->r.engine, new_engine, sizeof(re->r.engine)); } @@ -1886,7 +1867,7 @@ static bool use_eevee_for_freestyle_render(Render *re) void RE_RenderFreestyleStrokes(Render *re, Main *bmain, Scene *scene, int render) { re->result_ok = 0; - if (render_init_from_main(re, &scene->r, bmain, scene, NULL, NULL, 0, 0)) { + if (render_init_from_main(re, &scene->r, bmain, scene, nullptr, nullptr, 0, 0)) { if (render) { char scene_engine[32]; BLI_strncpy(scene_engine, re->r.engine, sizeof(scene_engine)); @@ -1913,7 +1894,8 @@ void RE_RenderFreestyleExternal(Render *re) LISTBASE_FOREACH (RenderView *, rv, &re->result->views) { RE_SetActiveRenderView(re, rv->name); - ViewLayer *active_view_layer = BLI_findlink(&re->view_layers, re->active_view_layer); + ViewLayer *active_view_layer = static_cast<ViewLayer *>( + BLI_findlink(&re->view_layers, re->active_view_layer)); FRS_begin_stroke_rendering(re); LISTBASE_FOREACH (ViewLayer *, view_layer, &re->view_layers) { @@ -1953,7 +1935,7 @@ bool RE_WriteRenderViewsMovie(ReportList *reports, } ImageFormatData image_format; - BKE_image_format_init_for_write(&image_format, scene, NULL); + BKE_image_format_init_for_write(&image_format, scene, nullptr); const bool is_mono = BLI_listbase_count_at_most(&rr->views, 2) < 2; const float dither = scene->r.dither_intensity; @@ -1966,15 +1948,17 @@ bool RE_WriteRenderViewsMovie(ReportList *reports, IMB_colormanagement_imbuf_for_write(ibuf, true, false, &image_format); - ok &= mh->append_movie(movie_ctx_arr[view_id], - rd, - preview ? scene->r.psfra : scene->r.sfra, - scene->r.cfra, - (int *)ibuf->rect, - ibuf->x, - ibuf->y, - suffix, - reports); + if (!mh->append_movie(movie_ctx_arr[view_id], + rd, + preview ? scene->r.psfra : scene->r.sfra, + scene->r.cfra, + (int *)ibuf->rect, + ibuf->x, + ibuf->y, + suffix, + reports)) { + ok = false; + } /* imbuf knows which rects are not part of ibuf */ IMB_freeImBuf(ibuf); @@ -1983,7 +1967,7 @@ bool RE_WriteRenderViewsMovie(ReportList *reports, } else { /* R_IMF_VIEWS_STEREO_3D */ const char *names[2] = {STEREO_LEFT_NAME, STEREO_RIGHT_NAME}; - ImBuf *ibuf_arr[3] = {NULL}; + ImBuf *ibuf_arr[3] = {nullptr}; int i; BLI_assert((totvideos == 1) && (image_format.views_format == R_IMF_VIEWS_STEREO_3D)); @@ -1997,7 +1981,7 @@ bool RE_WriteRenderViewsMovie(ReportList *reports, ibuf_arr[2] = IMB_stereo3d_ImBuf(&image_format, ibuf_arr[0], ibuf_arr[1]); - ok = mh->append_movie(movie_ctx_arr[0], + if (!mh->append_movie(movie_ctx_arr[0], rd, preview ? scene->r.psfra : scene->r.sfra, scene->r.cfra, @@ -2005,7 +1989,9 @@ bool RE_WriteRenderViewsMovie(ReportList *reports, ibuf_arr[2]->x, ibuf_arr[2]->y, "", - reports); + reports)) { + ok = false; + } for (i = 0; i < 3; i++) { /* imbuf knows which rects are not part of ibuf */ @@ -2055,7 +2041,7 @@ static bool do_write_image_or_movie(Render *re, &scene->r.im_format, (scene->r.scemode & R_EXTENSION) != 0, true, - NULL); + nullptr); } /* write images as individual images or stereo */ @@ -2075,7 +2061,7 @@ static bool do_write_image_or_movie(Render *re, fflush(stdout); /* NOTE: using G_MAIN seems valid here??? - * Not sure it's actually even used anyway, we could as well pass NULL? */ + * Not sure it's actually even used anyway, we could as well pass nullptr? */ render_callback_exec_null(re, G_MAIN, BKE_CB_EVT_RENDER_STATS); if (do_write_file) { @@ -2138,8 +2124,9 @@ void RE_RenderAnim(Render *re, * copying (e.g. alter the output path). */ render_callback_exec_id(re, re->main, &scene->id, BKE_CB_EVT_RENDER_INIT); - const RenderData rd = scene->r; - bMovieHandle *mh = NULL; + RenderData rd; + memcpy(&rd, &scene->r, sizeof(rd)); + bMovieHandle *mh = nullptr; const int cfra_old = rd.cfra; const float subframe_old = rd.subframe; int nfra, totrendered = 0, totskipped = 0; @@ -2169,12 +2156,12 @@ void RE_RenderAnim(Render *re, get_videos_dimensions(re, &rd, &width, &height); mh = BKE_movie_handle_get(rd.im_format.imtype); - if (mh == NULL) { + if (mh == nullptr) { BKE_report(re->reports, RPT_ERROR, "Movie format unsupported"); return; } - re->movie_ctx_arr = MEM_mallocN(sizeof(void *) * totvideos, "Movies' Context"); + re->movie_ctx_arr = MEM_cnew_array<void *>(totvideos, "Movies' Context"); for (i = 0; i < totvideos; i++) { const char *suffix = BKE_scene_multiview_view_id_suffix_get(&re->r, i); @@ -2254,7 +2241,7 @@ void RE_RenderAnim(Render *re, &rd.im_format, (rd.scemode & R_EXTENSION) != 0, true, - NULL); + nullptr); } if (rd.mode & R_NO_OVERWRITE) { @@ -2266,11 +2253,10 @@ void RE_RenderAnim(Render *re, } } else { - SceneRenderView *srv; bool is_skip = false; char filepath[FILE_MAX]; - for (srv = scene->r.views.first; srv; srv = srv->next) { + LISTBASE_FOREACH (SceneRenderView *, srv, &scene->r.views) { if (!BKE_scene_multiview_is_render_view_active(&scene->r, srv)) { continue; } @@ -2298,10 +2284,9 @@ void RE_RenderAnim(Render *re, } } else { - SceneRenderView *srv; char filepath[FILE_MAX]; - for (srv = scene->r.views.first; srv; srv = srv->next) { + LISTBASE_FOREACH (SceneRenderView *, srv, &scene->r.views) { if (!BKE_scene_multiview_is_render_view_active(&scene->r, srv)) { continue; } @@ -2328,7 +2313,7 @@ void RE_RenderAnim(Render *re, if (re->test_break(re->tbh) == 0) { if (!G.is_break) { - if (!do_write_image_or_movie(re, bmain, scene, mh, totvideos, NULL)) { + if (!do_write_image_or_movie(re, bmain, scene, mh, totvideos, nullptr)) { G.is_break = true; } } @@ -2348,10 +2333,9 @@ void RE_RenderAnim(Render *re, } } else { - SceneRenderView *srv; char filepath[FILE_MAX]; - for (srv = scene->r.views.first; srv; srv = srv->next) { + LISTBASE_FOREACH (SceneRenderView *, srv, &scene->r.views) { if (!BKE_scene_multiview_is_render_view_active(&scene->r, srv)) { continue; } @@ -2409,10 +2393,9 @@ void RE_PreviewRender(Render *re, Main *bmain, Scene *sce) Object *camera; int winx, winy; - winx = (sce->r.size * sce->r.xsch) / 100; - winy = (sce->r.size * sce->r.ysch) / 100; + BKE_render_resolution(&sce->r, false, &winx, &winy); - RE_InitState(re, NULL, &sce->r, &sce->view_layers, NULL, winx, winy, NULL); + RE_InitState(re, nullptr, &sce->r, &sce->view_layers, nullptr, winx, winy, nullptr); re->main = bmain; re->scene = sce; @@ -2425,7 +2408,7 @@ void RE_PreviewRender(Render *re, Main *bmain, Scene *sce) /* No persistent data for preview render. */ if (re->engine) { RE_engine_free(re->engine); - re->engine = NULL; + re->engine = nullptr; } } @@ -2439,8 +2422,7 @@ bool RE_ReadRenderResult(Scene *scene, Scene *scenode) rcti disprect; /* calculate actual render result and display size */ - winx = (scene->r.size * scene->r.xsch) / 100; - winy = (scene->r.size * scene->r.ysch) / 100; + BKE_render_resolution(&scene->r, false, &winx, &winy); /* only in movie case we render smaller part */ if (scene->r.mode & R_BORDER) { @@ -2462,10 +2444,10 @@ bool RE_ReadRenderResult(Scene *scene, Scene *scenode) /* get render: it can be called from UI with draw callbacks */ re = RE_GetSceneRender(scene); - if (re == NULL) { + if (re == nullptr) { re = RE_NewSceneRender(scene); } - RE_InitState(re, NULL, &scene->r, &scene->view_layers, NULL, winx, winy, &disprect); + RE_InitState(re, nullptr, &scene->r, &scene->view_layers, nullptr, winx, winy, &disprect); re->scene = scene; BLI_rw_mutex_lock(&re->resultmutex, THREAD_LOCK_WRITE); @@ -2481,17 +2463,17 @@ void RE_layer_load_from_file( RenderLayer *layer, ReportList *reports, const char *filepath, int x, int y) { /* OCIO_TODO: assume layer was saved in default color space */ - ImBuf *ibuf = IMB_loadiffname(filepath, IB_rect, NULL); - RenderPass *rpass = NULL; + ImBuf *ibuf = IMB_loadiffname(filepath, IB_rect, nullptr); + RenderPass *rpass = nullptr; /* multiview: since the API takes no 'view', we use the first combined pass found */ - for (rpass = layer->passes.first; rpass; rpass = rpass->next) { + for (rpass = static_cast<RenderPass *>(layer->passes.first); rpass; rpass = rpass->next) { if (STREQ(rpass->name, RE_PASSNAME_COMBINED)) { break; } } - if (rpass == NULL) { + if (rpass == nullptr) { BKE_reportf(reports, RPT_ERROR, "%s: no Combined pass found in the render layer '%s'", @@ -2501,7 +2483,7 @@ void RE_layer_load_from_file( if (ibuf && (ibuf->rect || ibuf->rect_float)) { if (ibuf->x == layer->rectx && ibuf->y == layer->recty) { - if (ibuf->rect_float == NULL) { + if (ibuf->rect_float == nullptr) { IMB_float_from_rect(ibuf); } @@ -2511,7 +2493,7 @@ void RE_layer_load_from_file( if ((ibuf->x - x >= layer->rectx) && (ibuf->y - y >= layer->recty)) { ImBuf *ibuf_clip; - if (ibuf->rect_float == NULL) { + if (ibuf->rect_float == nullptr) { IMB_float_from_rect(ibuf); } @@ -2546,19 +2528,19 @@ void RE_layer_load_from_file( void RE_result_load_from_file(RenderResult *result, ReportList *reports, const char *filepath) { - if (!render_result_exr_file_read_path(result, NULL, filepath)) { + if (!render_result_exr_file_read_path(result, nullptr, filepath)) { BKE_reportf(reports, RPT_ERROR, "%s: failed to load '%s'", __func__, filepath); return; } } -bool RE_layers_have_name(struct RenderResult *rr) +bool RE_layers_have_name(struct RenderResult *result) { - switch (BLI_listbase_count_at_most(&rr->layers, 2)) { + switch (BLI_listbase_count_at_most(&result->layers, 2)) { case 0: return false; case 1: - return (((RenderLayer *)rr->layers.first)->name[0] != '\0'); + return (((RenderLayer *)result->layers.first)->name[0] != '\0'); default: return true; } @@ -2578,19 +2560,17 @@ bool RE_passes_have_name(struct RenderLayer *rl) RenderPass *RE_pass_find_by_name(RenderLayer *rl, const char *name, const char *viewname) { - RenderPass *rp = NULL; - - for (rp = rl->passes.last; rp; rp = rp->prev) { + LISTBASE_FOREACH_BACKWARD (RenderPass *, rp, &rl->passes) { if (STREQ(rp->name, name)) { - if (viewname == NULL || viewname[0] == '\0') { - break; + if (viewname == nullptr || viewname[0] == '\0') { + return rp; } if (STREQ(rp->view, viewname)) { - break; + return rp; } } } - return rp; + return nullptr; } RenderPass *RE_pass_find_by_type(RenderLayer *rl, int passtype, const char *viewname) @@ -2628,15 +2608,15 @@ RenderPass *RE_pass_find_by_type(RenderLayer *rl, int passtype, const char *view #undef CHECK_PASS - return NULL; + return nullptr; } RenderPass *RE_create_gp_pass(RenderResult *rr, const char *layername, const char *viewname) { - RenderLayer *rl = BLI_findstring(&rr->layers, layername, offsetof(RenderLayer, name)); + RenderLayer *rl = RE_GetRenderLayer(rr, layername); /* only create render layer if not exist */ if (!rl) { - rl = MEM_callocN(sizeof(RenderLayer), layername); + rl = MEM_cnew<RenderLayer>(layername); BLI_addtail(&rr->layers, rl); BLI_strncpy(rl->name, layername, sizeof(rl->name)); rl->layflag = SCE_LAY_SOLID; diff --git a/source/blender/render/intern/render_result.c b/source/blender/render/intern/render_result.cc index 9992d1a507f..86ee9ad779a 100644 --- a/source/blender/render/intern/render_result.c +++ b/source/blender/render/intern/render_result.cc @@ -5,10 +5,10 @@ * \ingroup render */ -#include <errno.h> -#include <stdio.h> -#include <stdlib.h> -#include <string.h> +#include <cerrno> +#include <cstdio> +#include <cstdlib> +#include <cstring> #include "MEM_guardedalloc.h" @@ -28,6 +28,7 @@ #include "BKE_image.h" #include "BKE_image_format.h" #include "BKE_image_save.h" +#include "BKE_main.h" #include "BKE_report.h" #include "BKE_scene.h" @@ -46,7 +47,7 @@ static void render_result_views_free(RenderResult *rr) { while (rr->views.first) { - RenderView *rv = rr->views.first; + RenderView *rv = static_cast<RenderView *>(rr->views.first); BLI_remlink(&rr->views, rv); if (rv->rect32) { @@ -69,15 +70,15 @@ static void render_result_views_free(RenderResult *rr) void render_result_free(RenderResult *rr) { - if (rr == NULL) { + if (rr == nullptr) { return; } while (rr->layers.first) { - RenderLayer *rl = rr->layers.first; + RenderLayer *rl = static_cast<RenderLayer *>(rr->layers.first); while (rl->passes.first) { - RenderPass *rpass = rl->passes.first; + RenderPass *rpass = static_cast<RenderPass *>(rl->passes.first); if (rpass->rect) { MEM_freeN(rpass->rect); } @@ -130,16 +131,14 @@ void render_result_free_list(ListBase *lb, RenderResult *rr) void render_result_views_shallowcopy(RenderResult *dst, RenderResult *src) { - RenderView *rview; - - if (dst == NULL || src == NULL) { + if (dst == nullptr || src == nullptr) { return; } - for (rview = src->views.first; rview; rview = rview->next) { + LISTBASE_FOREACH (RenderView *, rview, &src->views) { RenderView *rv; - rv = MEM_mallocN(sizeof(RenderView), "new render view"); + rv = MEM_cnew<RenderView>("new render view"); BLI_addtail(&dst->views, rv); BLI_strncpy(rv->name, rview->name, sizeof(rv->name)); @@ -151,12 +150,12 @@ void render_result_views_shallowcopy(RenderResult *dst, RenderResult *src) void render_result_views_shallowdelete(RenderResult *rr) { - if (rr == NULL) { + if (rr == nullptr) { return; } while (rr->views.first) { - RenderView *rv = rr->views.first; + RenderView *rv = static_cast<RenderView *>(rr->views.first); BLI_remlink(&rr->views, rv); MEM_freeN(rv); } @@ -166,12 +165,12 @@ void render_result_views_shallowdelete(RenderResult *rr) static void render_layer_allocate_pass(RenderResult *rr, RenderPass *rp) { - if (rp->rect != NULL) { + if (rp->rect != nullptr) { return; } const size_t rectsize = ((size_t)rr->rectx) * rr->recty * rp->channels; - rp->rect = MEM_callocN(sizeof(float) * rectsize, rp->name); + rp->rect = MEM_cnew_array<float>(rectsize, rp->name); if (STREQ(rp->name, RE_PASSNAME_VECTOR)) { /* initialize to max speed */ @@ -197,7 +196,7 @@ RenderPass *render_layer_add_pass(RenderResult *rr, const bool allocate) { const int view_id = BLI_findstringindex(&rr->views, viewname, offsetof(RenderView, name)); - RenderPass *rpass = MEM_callocN(sizeof(RenderPass), name); + RenderPass *rpass = MEM_cnew<RenderPass>(name); rpass->channels = channels; rpass->rectx = rl->rectx; @@ -208,14 +207,15 @@ RenderPass *render_layer_add_pass(RenderResult *rr, BLI_strncpy(rpass->chan_id, chan_id, sizeof(rpass->chan_id)); BLI_strncpy(rpass->view, viewname, sizeof(rpass->view)); RE_render_result_full_channel_name( - rpass->fullname, NULL, rpass->name, rpass->view, rpass->chan_id, -1); + rpass->fullname, nullptr, rpass->name, rpass->view, rpass->chan_id, -1); if (rl->exrhandle) { int a; for (a = 0; a < channels; a++) { char passname[EXR_PASS_MAXNAME]; - RE_render_result_full_channel_name(passname, NULL, rpass->name, NULL, rpass->chan_id, a); - IMB_exr_add_channel(rl->exrhandle, rl->name, passname, viewname, 0, 0, NULL, false); + RE_render_result_full_channel_name( + passname, nullptr, rpass->name, nullptr, rpass->chan_id, a); + IMB_exr_add_channel(rl->exrhandle, rl->name, passname, viewname, 0, 0, nullptr, false); } } @@ -239,17 +239,16 @@ RenderResult *render_result_new(Render *re, { RenderResult *rr; RenderLayer *rl; - RenderView *rv; int rectx, recty; rectx = BLI_rcti_size_x(partrct); recty = BLI_rcti_size_y(partrct); if (rectx <= 0 || recty <= 0) { - return NULL; + return nullptr; } - rr = MEM_callocN(sizeof(RenderResult), "new render result"); + rr = MEM_cnew<RenderResult>("new render result"); rr->rectx = rectx; rr->recty = recty; rr->renrect.xmin = 0; @@ -273,7 +272,7 @@ RenderResult *render_result_new(Render *re, } } - rl = MEM_callocN(sizeof(RenderLayer), "new render layer"); + rl = MEM_cnew<RenderLayer>("new render layer"); BLI_addtail(&rr->layers, rl); BLI_strncpy(rl->name, view_layer->name, sizeof(rl->name)); @@ -284,7 +283,7 @@ RenderResult *render_result_new(Render *re, rl->rectx = rectx; rl->recty = recty; - for (rv = rr->views.first; rv; rv = rv->next) { + LISTBASE_FOREACH (RenderView *, rv, &rr->views) { const char *view = rv->name; if (viewname && viewname[0]) { @@ -295,13 +294,13 @@ RenderResult *render_result_new(Render *re, #define RENDER_LAYER_ADD_PASS_SAFE(rr, rl, channels, name, viewname, chan_id) \ do { \ - if (render_layer_add_pass(rr, rl, channels, name, viewname, chan_id, false) == NULL) { \ + if (render_layer_add_pass(rr, rl, channels, name, viewname, chan_id, false) == nullptr) { \ render_result_free(rr); \ - return NULL; \ + return nullptr; \ } \ } while (false) - /* A renderlayer should always have a Combined pass. */ + /* A render-layer should always have a "Combined" pass. */ render_layer_add_pass(rr, rl, 4, "Combined", view, "RGBA", false); if (view_layer->passflag & SCE_PASS_Z) { @@ -383,13 +382,13 @@ RenderResult *render_result_new(Render *re, /* Preview-render doesn't do layers, so we make a default one. */ if (BLI_listbase_is_empty(&rr->layers) && !(layername && layername[0])) { - rl = MEM_callocN(sizeof(RenderLayer), "new render layer"); + rl = MEM_cnew<RenderLayer>("new render layer"); BLI_addtail(&rr->layers, rl); rl->rectx = rectx; rl->recty = recty; - for (rv = rr->views.first; rv; rv = rv->next) { + LISTBASE_FOREACH (RenderView *, rv, &rr->views) { const char *view = rv->name; if (viewname && viewname[0]) { @@ -398,7 +397,7 @@ RenderResult *render_result_new(Render *re, } } - /* a renderlayer should always have a Combined pass */ + /* A render-layer should always have a "Combined" pass. */ render_layer_add_pass(rr, rl, 4, RE_PASSNAME_COMBINED, view, "RGBA", false); } @@ -424,7 +423,7 @@ RenderResult *render_result_new(Render *re, void render_result_passes_allocated_ensure(RenderResult *rr) { - if (rr == NULL) { + if (rr == nullptr) { /* Happens when the result was not yet allocated for the current scene or slot configuration. */ return; @@ -432,7 +431,7 @@ void render_result_passes_allocated_ensure(RenderResult *rr) LISTBASE_FOREACH (RenderLayer *, rl, &rr->layers) { LISTBASE_FOREACH (RenderPass *, rp, &rl->passes) { - if (rl->exrhandle != NULL && !STREQ(rp->name, RE_PASSNAME_COMBINED)) { + if (rl->exrhandle != nullptr && !STREQ(rp->name, RE_PASSNAME_COMBINED)) { continue; } @@ -445,24 +444,20 @@ void render_result_passes_allocated_ensure(RenderResult *rr) void render_result_clone_passes(Render *re, RenderResult *rr, const char *viewname) { - RenderLayer *rl; - RenderPass *main_rp; - - for (rl = rr->layers.first; rl; rl = rl->next) { - RenderLayer *main_rl = BLI_findstring( - &re->result->layers, rl->name, offsetof(RenderLayer, name)); + LISTBASE_FOREACH (RenderLayer *, rl, &rr->layers) { + RenderLayer *main_rl = RE_GetRenderLayer(re->result, rl->name); if (!main_rl) { continue; } - for (main_rp = main_rl->passes.first; main_rp; main_rp = main_rp->next) { + LISTBASE_FOREACH (RenderPass *, main_rp, &main_rl->passes) { if (viewname && viewname[0] && !STREQ(main_rp->view, viewname)) { continue; } /* Compare fullname to make sure that the view also is equal. */ - RenderPass *rp = BLI_findstring( - &rl->passes, main_rp->fullname, offsetof(RenderPass, fullname)); + RenderPass *rp = static_cast<RenderPass *>( + BLI_findstring(&rl->passes, main_rp->fullname, offsetof(RenderPass, fullname))); if (!rp) { render_layer_add_pass( rr, rl, main_rp->channels, main_rp->name, main_rp->view, main_rp->chan_id, false); @@ -479,16 +474,12 @@ void RE_create_render_pass(RenderResult *rr, const char *viewname, const bool allocate) { - RenderLayer *rl; - RenderPass *rp; - RenderView *rv; - - for (rl = rr->layers.first; rl; rl = rl->next) { + LISTBASE_FOREACH (RenderLayer *, rl, &rr->layers) { if (layername && layername[0] && !STREQ(rl->name, layername)) { continue; } - for (rv = rr->views.first; rv; rv = rv->next) { + LISTBASE_FOREACH (RenderView *, rv, &rr->views) { const char *view = rv->name; if (viewname && viewname[0] && !STREQ(view, viewname)) { @@ -496,17 +487,15 @@ void RE_create_render_pass(RenderResult *rr, } /* Ensure that the pass doesn't exist yet. */ - for (rp = rl->passes.first; rp; rp = rp->next) { - if (!STREQ(rp->name, name)) { - continue; + bool pass_exists = false; + LISTBASE_FOREACH (RenderPass *, rp, &rl->passes) { + if (STREQ(rp->name, name) && STREQ(rp->view, view)) { + pass_exists = true; + break; } - if (!STREQ(rp->view, view)) { - continue; - } - break; } - if (!rp) { + if (!pass_exists) { render_layer_add_pass(rr, rl, channels, name, view, chan_id, allocate); } } @@ -587,10 +576,9 @@ static int passtype_from_name(const char *name) /* callbacks for render_result_new_from_exr */ static void *ml_addlayer_cb(void *base, const char *str) { - RenderResult *rr = base; - RenderLayer *rl; + RenderResult *rr = static_cast<RenderResult *>(base); - rl = MEM_callocN(sizeof(RenderLayer), "new render layer"); + RenderLayer *rl = MEM_cnew<RenderLayer>("new render layer"); BLI_addtail(&rr->layers, rl); BLI_strncpy(rl->name, str, EXR_LAY_MAXNAME); @@ -605,9 +593,9 @@ static void ml_addpass_cb(void *base, const char *chan_id, const char *view) { - RenderResult *rr = base; - RenderLayer *rl = lay; - RenderPass *rpass = MEM_callocN(sizeof(RenderPass), "loaded pass"); + RenderResult *rr = static_cast<RenderResult *>(base); + RenderLayer *rl = static_cast<RenderLayer *>(lay); + RenderPass *rpass = MEM_cnew<RenderPass>("loaded pass"); BLI_addtail(&rl->passes, rpass); rpass->channels = totchan; @@ -619,7 +607,7 @@ static void ml_addpass_cb(void *base, rpass->rect = rect; BLI_strncpy(rpass->name, name, EXR_PASS_MAXNAME); BLI_strncpy(rpass->view, view, sizeof(rpass->view)); - RE_render_result_full_channel_name(rpass->fullname, NULL, name, view, rpass->chan_id, -1); + RE_render_result_full_channel_name(rpass->fullname, nullptr, name, view, rpass->chan_id, -1); if (view[0] != '\0') { rpass->view_id = BLI_findstringindex(&rr->views, view, offsetof(RenderView, name)); @@ -631,10 +619,9 @@ static void ml_addpass_cb(void *base, static void *ml_addview_cb(void *base, const char *str) { - RenderResult *rr = base; - RenderView *rv; + RenderResult *rr = static_cast<RenderResult *>(base); - rv = MEM_callocN(sizeof(RenderView), "new render view"); + RenderView *rv = MEM_cnew<RenderView>("new render view"); BLI_strncpy(rv->name, str, EXR_VIEW_MAXNAME); /* For stereo drawing we need to ensure: @@ -645,9 +632,10 @@ static void *ml_addview_cb(void *base, const char *str) BLI_addhead(&rr->views, rv); } else if (STREQ(str, STEREO_RIGHT_NAME)) { - RenderView *left_rv = BLI_findstring(&rr->views, STEREO_LEFT_NAME, offsetof(RenderView, name)); + RenderView *left_rv = static_cast<RenderView *>( + BLI_findstring(&rr->views, STEREO_LEFT_NAME, offsetof(RenderView, name))); - if (left_rv == NULL) { + if (left_rv == nullptr) { BLI_addhead(&rr->views, rv); } else { @@ -719,9 +707,7 @@ static int order_render_passes(const void *a, const void *b) RenderResult *render_result_new_from_exr( void *exrhandle, const char *colorspace, bool predivide, int rectx, int recty) { - RenderResult *rr = MEM_callocN(sizeof(RenderResult), __func__); - RenderLayer *rl; - RenderPass *rpass; + RenderResult *rr = MEM_cnew<RenderResult>(__func__); const char *to_colorspace = IMB_colormanagement_role_colorspace_name_get( COLOR_ROLE_SCENE_LINEAR); @@ -730,13 +716,13 @@ RenderResult *render_result_new_from_exr( IMB_exr_multilayer_convert(exrhandle, rr, ml_addview_cb, ml_addlayer_cb, ml_addpass_cb); - for (rl = rr->layers.first; rl; rl = rl->next) { + LISTBASE_FOREACH (RenderLayer *, rl, &rr->layers) { rl->rectx = rectx; rl->recty = recty; BLI_listbase_sort(&rl->passes, order_render_passes); - for (rpass = rl->passes.first; rpass; rpass = rpass->next) { + LISTBASE_FOREACH (RenderPass *, rpass, &rl->passes) { rpass->rectx = rectx; rpass->recty = recty; @@ -757,21 +743,19 @@ RenderResult *render_result_new_from_exr( void render_result_view_new(RenderResult *rr, const char *viewname) { - RenderView *rv = MEM_callocN(sizeof(RenderView), "new render view"); + RenderView *rv = MEM_cnew<RenderView>("new render view"); BLI_addtail(&rr->views, rv); BLI_strncpy(rv->name, viewname, sizeof(rv->name)); } void render_result_views_new(RenderResult *rr, const RenderData *rd) { - SceneRenderView *srv; - /* clear previously existing views - for sequencer */ render_result_views_free(rr); /* check renderdata for amount of views */ if (rd->scemode & R_MULTIVIEW) { - for (srv = rd->views.first; srv; srv = srv->next) { + LISTBASE_FOREACH (SceneRenderView *, srv, &rd->views) { if (BKE_scene_multiview_is_render_view_active(rd, srv) == false) { continue; } @@ -812,17 +796,17 @@ static void do_merge_tile( void render_result_merge(RenderResult *rr, RenderResult *rrpart) { - RenderLayer *rl, *rlp; - RenderPass *rpass, *rpassp; + LISTBASE_FOREACH (RenderLayer *, rl, &rr->layers) { + RenderLayer *rlp = RE_GetRenderLayer(rrpart, rl->name); - for (rl = rr->layers.first; rl; rl = rl->next) { - rlp = RE_GetRenderLayer(rrpart, rl->name); if (rlp) { /* Passes are allocated in sync. */ - for (rpass = rl->passes.first, rpassp = rlp->passes.first; rpass && rpassp; + for (RenderPass *rpass = static_cast<RenderPass *>(rl->passes.first), + *rpassp = static_cast<RenderPass *>(rlp->passes.first); + rpass && rpassp; rpass = rpass->next) { /* For save buffers, skip any passes that are only saved to disk. */ - if (rpass->rect == NULL || rpassp->rect == NULL) { + if (rpass->rect == nullptr || rpassp->rect == nullptr) { continue; } /* Render-result have all passes, render-part only the active view's passes. */ @@ -845,21 +829,16 @@ void render_result_single_layer_begin(Render *re) { /* all layers except the active one get temporally pushed away */ - /* officially pushed result should be NULL... error can happen with do_seq */ + /* officially pushed result should be nullptr... error can happen with do_seq */ RE_FreeRenderResult(re->pushedresult); re->pushedresult = re->result; - re->result = NULL; + re->result = nullptr; } void render_result_single_layer_end(Render *re) { - ViewLayer *view_layer; - RenderLayer *rlpush; - RenderLayer *rl; - int nr; - - if (re->result == NULL) { + if (re->result == nullptr) { printf("pop render result error; no current result!\n"); return; } @@ -871,37 +850,36 @@ void render_result_single_layer_end(Render *re) if (re->pushedresult->rectx == re->result->rectx && re->pushedresult->recty == re->result->recty) { /* find which layer in re->pushedresult should be replaced */ - rl = re->result->layers.first; + RenderLayer *rl = static_cast<RenderLayer *>(re->result->layers.first); /* render result should be empty after this */ BLI_remlink(&re->result->layers, rl); /* reconstruct render result layers */ - for (nr = 0, view_layer = re->view_layers.first; view_layer; - view_layer = view_layer->next, nr++) { + int nr = 0; + LISTBASE_FOREACH (ViewLayer *, view_layer, &re->view_layers) { if (nr == re->active_view_layer) { BLI_addtail(&re->result->layers, rl); } else { - rlpush = RE_GetRenderLayer(re->pushedresult, view_layer->name); + RenderLayer *rlpush = RE_GetRenderLayer(re->pushedresult, view_layer->name); if (rlpush) { BLI_remlink(&re->pushedresult->layers, rlpush); BLI_addtail(&re->result->layers, rlpush); } } + nr++; } } RE_FreeRenderResult(re->pushedresult); - re->pushedresult = NULL; + re->pushedresult = nullptr; } int render_result_exr_file_read_path(RenderResult *rr, RenderLayer *rl_single, const char *filepath) { - RenderLayer *rl; - RenderPass *rpass; void *exrhandle = IMB_exr_get_handle(); int rectx, recty; @@ -911,37 +889,37 @@ int render_result_exr_file_read_path(RenderResult *rr, return 0; } - if (rr == NULL || rectx != rr->rectx || recty != rr->recty) { + if (rr == nullptr || rectx != rr->rectx || recty != rr->recty) { if (rr) { printf("error in reading render result: dimensions don't match\n"); } else { - printf("error in reading render result: NULL result pointer\n"); + printf("error in reading render result: nullptr result pointer\n"); } IMB_exr_close(exrhandle); return 0; } - for (rl = rr->layers.first; rl; rl = rl->next) { + LISTBASE_FOREACH (RenderLayer *, rl, &rr->layers) { if (rl_single && rl_single != rl) { continue; } /* passes are allocated in sync */ - for (rpass = rl->passes.first; rpass; rpass = rpass->next) { + LISTBASE_FOREACH (RenderPass *, rpass, &rl->passes) { const int xstride = rpass->channels; int a; char fullname[EXR_PASS_MAXNAME]; for (a = 0; a < xstride; a++) { RE_render_result_full_channel_name( - fullname, NULL, rpass->name, rpass->view, rpass->chan_id, a); + fullname, nullptr, rpass->name, rpass->view, rpass->chan_id, a); IMB_exr_set_channel( exrhandle, rl->name, fullname, xstride, xstride * rectx, rpass->rect + a); } RE_render_result_full_channel_name( - rpass->fullname, NULL, rpass->name, rpass->view, rpass->chan_id, -1); + rpass->fullname, nullptr, rpass->name, rpass->view, rpass->chan_id, -1); } } @@ -990,10 +968,12 @@ void render_result_exr_file_cache_write(Render *re) char str[FILE_MAXFILE + FILE_MAXFILE + MAX_ID_NAME + 100]; char *root = U.render_cachedir; + render_result_passes_allocated_ensure(rr); + render_result_exr_file_cache_path(re->scene, root, str); printf("Caching exr file, %dx%d, %s\n", rr->rectx, rr->recty, str); - BKE_image_render_write_exr(NULL, rr, str, NULL, true, NULL, -1); + BKE_image_render_write_exr(nullptr, rr, str, nullptr, true, nullptr, -1); } bool render_result_exr_file_cache_read(Render *re) @@ -1053,7 +1033,7 @@ ImBuf *RE_render_result_rect_to_ibuf(RenderResult *rr, (R_IMF_CHAN_DEPTH_12 | R_IMF_CHAN_DEPTH_16 | R_IMF_CHAN_DEPTH_24 | R_IMF_CHAN_DEPTH_32)) { if (imf->depth == R_IMF_CHAN_DEPTH_8) { /* Higher depth bits are supported but not needed for current file output. */ - ibuf->rect_float = NULL; + ibuf->rect_float = nullptr; } else { IMB_float_from_rect(ibuf); @@ -1061,7 +1041,7 @@ ImBuf *RE_render_result_rect_to_ibuf(RenderResult *rr, } else { /* ensure no float buffer remained from previous frame */ - ibuf->rect_float = NULL; + ibuf->rect_float = nullptr; } } @@ -1085,7 +1065,7 @@ void RE_render_result_rect_from_ibuf(RenderResult *rr, const ImBuf *ibuf, const rr->have_combined = true; if (!rv->rectf) { - rv->rectf = MEM_mallocN(sizeof(float[4]) * rr->rectx * rr->recty, "render_seq rectf"); + rv->rectf = MEM_cnew_array<float>(4 * rr->rectx * rr->recty, "render_seq rectf"); } memcpy(rv->rectf, ibuf->rect_float, sizeof(float[4]) * rr->rectx * rr->recty); @@ -1098,10 +1078,10 @@ void RE_render_result_rect_from_ibuf(RenderResult *rr, const ImBuf *ibuf, const rr->have_combined = true; if (!rv->rect32) { - rv->rect32 = MEM_mallocN(sizeof(int) * rr->rectx * rr->recty, "render_seq rect"); + rv->rect32 = MEM_cnew_array<int>(rr->rectx * rr->recty, "render_seq rect"); } - memcpy(rv->rect32, ibuf->rect, 4 * rr->rectx * rr->recty); + memcpy(rv->rect32, ibuf->rect, sizeof(int) * rr->rectx * rr->recty); /* Same things as above, old rectf can hang around from previous render. */ MEM_SAFE_FREE(rv->rectf); @@ -1119,7 +1099,7 @@ void render_result_rect_fill_zero(RenderResult *rr, const int view_id) memset(rv->rect32, 0, 4 * rr->rectx * rr->recty); } else { - rv->rect32 = MEM_callocN(sizeof(int) * rr->rectx * rr->recty, "render_seq rect"); + rv->rect32 = MEM_cnew_array<int>(rr->rectx * rr->recty, "render_seq rect"); } } @@ -1154,23 +1134,23 @@ void render_result_rect_get_pixels(RenderResult *rr, /*************************** multiview functions *****************************/ -bool RE_HasCombinedLayer(const RenderResult *rr) +bool RE_HasCombinedLayer(const RenderResult *result) { - if (rr == NULL) { + if (result == nullptr) { return false; } - const RenderView *rv = rr->views.first; - if (rv == NULL) { + const RenderView *rv = static_cast<RenderView *>(result->views.first); + if (rv == nullptr) { return false; } return (rv->rect32 || rv->rectf); } -bool RE_HasFloatPixels(const RenderResult *rr) +bool RE_HasFloatPixels(const RenderResult *result) { - for (const RenderView *rview = rr->views.first; rview; rview = rview->next) { + LISTBASE_FOREACH (const RenderView *, rview, &result->views) { if (rview->rect32 && !rview->rectf) { return false; } @@ -1179,13 +1159,13 @@ bool RE_HasFloatPixels(const RenderResult *rr) return true; } -bool RE_RenderResult_is_stereo(const RenderResult *rr) +bool RE_RenderResult_is_stereo(const RenderResult *result) { - if (!BLI_findstring(&rr->views, STEREO_LEFT_NAME, offsetof(RenderView, name))) { + if (!BLI_findstring(&result->views, STEREO_LEFT_NAME, offsetof(RenderView, name))) { return false; } - if (!BLI_findstring(&rr->views, STEREO_RIGHT_NAME, offsetof(RenderView, name))) { + if (!BLI_findstring(&result->views, STEREO_RIGHT_NAME, offsetof(RenderView, name))) { return false; } @@ -1194,37 +1174,36 @@ bool RE_RenderResult_is_stereo(const RenderResult *rr) RenderView *RE_RenderViewGetById(RenderResult *rr, const int view_id) { - RenderView *rv = BLI_findlink(&rr->views, view_id); + RenderView *rv = static_cast<RenderView *>(BLI_findlink(&rr->views, view_id)); BLI_assert(rr->views.first); - return rv ? rv : rr->views.first; + return rv ? rv : static_cast<RenderView *>(rr->views.first); } RenderView *RE_RenderViewGetByName(RenderResult *rr, const char *viewname) { - RenderView *rv = BLI_findstring(&rr->views, viewname, offsetof(RenderView, name)); + RenderView *rv = static_cast<RenderView *>( + BLI_findstring(&rr->views, viewname, offsetof(RenderView, name))); BLI_assert(rr->views.first); - return rv ? rv : rr->views.first; + return rv ? rv : static_cast<RenderView *>(rr->views.first); } static RenderPass *duplicate_render_pass(RenderPass *rpass) { - RenderPass *new_rpass = MEM_mallocN(sizeof(RenderPass), "new render pass"); - *new_rpass = *rpass; - new_rpass->next = new_rpass->prev = NULL; - if (new_rpass->rect != NULL) { - new_rpass->rect = MEM_dupallocN(new_rpass->rect); + RenderPass *new_rpass = MEM_cnew("new render pass", *rpass); + new_rpass->next = new_rpass->prev = nullptr; + if (new_rpass->rect != nullptr) { + new_rpass->rect = static_cast<float *>(MEM_dupallocN(new_rpass->rect)); } return new_rpass; } static RenderLayer *duplicate_render_layer(RenderLayer *rl) { - RenderLayer *new_rl = MEM_mallocN(sizeof(RenderLayer), "new render layer"); - *new_rl = *rl; - new_rl->next = new_rl->prev = NULL; - new_rl->passes.first = new_rl->passes.last = NULL; - new_rl->exrhandle = NULL; - for (RenderPass *rpass = rl->passes.first; rpass != NULL; rpass = rpass->next) { + RenderLayer *new_rl = MEM_cnew("new render layer", *rl); + new_rl->next = new_rl->prev = nullptr; + new_rl->passes.first = new_rl->passes.last = nullptr; + new_rl->exrhandle = nullptr; + LISTBASE_FOREACH (RenderPass *, rpass, &rl->passes) { RenderPass *new_rpass = duplicate_render_pass(rpass); BLI_addtail(&new_rl->passes, new_rpass); } @@ -1233,43 +1212,41 @@ static RenderLayer *duplicate_render_layer(RenderLayer *rl) static RenderView *duplicate_render_view(RenderView *rview) { - RenderView *new_rview = MEM_mallocN(sizeof(RenderView), "new render view"); - *new_rview = *rview; - if (new_rview->rectf != NULL) { - new_rview->rectf = MEM_dupallocN(new_rview->rectf); + RenderView *new_rview = MEM_cnew("new render view", *rview); + if (new_rview->rectf != nullptr) { + new_rview->rectf = static_cast<float *>(MEM_dupallocN(new_rview->rectf)); } - if (new_rview->rectz != NULL) { - new_rview->rectz = MEM_dupallocN(new_rview->rectz); + if (new_rview->rectz != nullptr) { + new_rview->rectz = static_cast<float *>(MEM_dupallocN(new_rview->rectz)); } - if (new_rview->rect32 != NULL) { - new_rview->rect32 = MEM_dupallocN(new_rview->rect32); + if (new_rview->rect32 != nullptr) { + new_rview->rect32 = static_cast<int *>(MEM_dupallocN(new_rview->rect32)); } return new_rview; } RenderResult *RE_DuplicateRenderResult(RenderResult *rr) { - RenderResult *new_rr = MEM_mallocN(sizeof(RenderResult), "new duplicated render result"); - *new_rr = *rr; - new_rr->next = new_rr->prev = NULL; - new_rr->layers.first = new_rr->layers.last = NULL; - new_rr->views.first = new_rr->views.last = NULL; - for (RenderLayer *rl = rr->layers.first; rl != NULL; rl = rl->next) { + RenderResult *new_rr = MEM_cnew("new duplicated render result", *rr); + new_rr->next = new_rr->prev = nullptr; + new_rr->layers.first = new_rr->layers.last = nullptr; + new_rr->views.first = new_rr->views.last = nullptr; + LISTBASE_FOREACH (RenderLayer *, rl, &rr->layers) { RenderLayer *new_rl = duplicate_render_layer(rl); BLI_addtail(&new_rr->layers, new_rl); } - for (RenderView *rview = rr->views.first; rview != NULL; rview = rview->next) { + LISTBASE_FOREACH (RenderView *, rview, &rr->views) { RenderView *new_rview = duplicate_render_view(rview); BLI_addtail(&new_rr->views, new_rview); } - if (new_rr->rect32 != NULL) { - new_rr->rect32 = MEM_dupallocN(new_rr->rect32); + if (new_rr->rectf != nullptr) { + new_rr->rectf = static_cast<float *>(MEM_dupallocN(new_rr->rectf)); } - if (new_rr->rectf != NULL) { - new_rr->rectf = MEM_dupallocN(new_rr->rectf); + if (new_rr->rectz != nullptr) { + new_rr->rectz = static_cast<float *>(MEM_dupallocN(new_rr->rectz)); } - if (new_rr->rectz != NULL) { - new_rr->rectz = MEM_dupallocN(new_rr->rectz); + if (new_rr->rect32 != nullptr) { + new_rr->rect32 = static_cast<int *>(MEM_dupallocN(new_rr->rect32)); } new_rr->stamp_data = BKE_stamp_data_copy(new_rr->stamp_data); return new_rr; diff --git a/source/blender/render/intern/render_result.h b/source/blender/render/intern/render_result.h index c84e0a04018..2e76efba8a3 100644 --- a/source/blender/render/intern/render_result.h +++ b/source/blender/render/intern/render_result.h @@ -136,7 +136,8 @@ void render_result_views_shallowdelete(struct RenderResult *rr); { \ int nr_; \ ViewLayer *iter_; \ - for (nr_ = 0, iter_ = (re_)->view_layers.first; iter_ != NULL; iter_ = iter_->next, nr_++) { \ + for (nr_ = 0, iter_ = static_cast<ViewLayer *>((re_)->view_layers.first); iter_ != NULL; \ + iter_ = iter_->next, nr_++) { \ if (!G.background && (re_)->r.scemode & R_SINGLE_LAYER) { \ if (nr_ != re->active_view_layer) { \ continue; \ diff --git a/source/blender/render/intern/render_types.h b/source/blender/render/intern/render_types.h index 58a15e3f013..29bac6e2766 100644 --- a/source/blender/render/intern/render_types.h +++ b/source/blender/render/intern/render_types.h @@ -11,16 +11,13 @@ /* exposed internal in render module only! */ /* ------------------------------------------------------------------------- */ -#include "DNA_object_types.h" #include "DNA_scene_types.h" #include "BLI_threads.h" -#include "BKE_main.h" - #include "RE_pipeline.h" -struct GHash; +struct Depsgraph; struct GSet; struct Main; struct Object; @@ -91,7 +88,7 @@ struct Render { /* NOTE: This is a minimal dependency graph and evaluated scene which is enough to access view * layer visibility and use for postprocessing (compositor and sequencer). */ - Depsgraph *pipeline_depsgraph; + struct Depsgraph *pipeline_depsgraph; Scene *pipeline_scene_eval; /* callbacks */ diff --git a/source/blender/render/intern/texture_common.h b/source/blender/render/intern/texture_common.h index 0057779bda6..028b3d22f01 100644 --- a/source/blender/render/intern/texture_common.h +++ b/source/blender/render/intern/texture_common.h @@ -73,8 +73,8 @@ int imagewraposa(struct Tex *tex, struct Image *ima, struct ImBuf *ibuf, const float texvec[3], - const float dxt[2], - const float dyt[2], + const float DXT[2], + const float DYT[2], struct TexResult *texres, struct ImagePool *pool, bool skip_load_image); diff --git a/source/blender/render/intern/texture_image.c b/source/blender/render/intern/texture_image.c index 3b1eb293a3a..38a569877c0 100644 --- a/source/blender/render/intern/texture_image.c +++ b/source/blender/render/intern/texture_image.c @@ -32,7 +32,6 @@ #include "RE_texture.h" -#include "render_types.h" #include "texture_common.h" static void boxsample(ImBuf *ibuf, @@ -88,14 +87,13 @@ int imagewrap(Tex *tex, struct ImagePool *pool, const bool skip_load_image) { - float fx, fy, val1, val2, val3; + float fx, fy; int x, y, retval; int xi, yi; /* original values */ texres->tin = texres->trgba[3] = texres->trgba[0] = texres->trgba[1] = texres->trgba[2] = 0.0f; - /* we need to set retval OK, otherwise texture code generates normals itself... */ - retval = texres->nor ? (TEX_RGB | TEX_NOR) : TEX_RGB; + retval = TEX_RGB; /* quick tests */ if (ima == NULL) { @@ -256,47 +254,6 @@ int imagewrap(Tex *tex, ibuf_get_color(texres->trgba, ibuf, x, y); } - if (texres->nor) { - if (tex->imaflag & TEX_NORMALMAP) { - /* Normal from color: - * The invert of the red channel is to make - * the normal map compliant with the outside world. - * It needs to be done because in Blender - * the normal used in the renderer points inward. It is generated - * this way in calc_vertexnormals(). Should this ever change - * this negate must be removed. */ - texres->nor[0] = -2.0f * (texres->trgba[0] - 0.5f); - texres->nor[1] = 2.0f * (texres->trgba[1] - 0.5f); - texres->nor[2] = 2.0f * (texres->trgba[2] - 0.5f); - } - else { - /* bump: take three samples */ - val1 = texres->trgba[0] + texres->trgba[1] + texres->trgba[2]; - - if (x < ibuf->x - 1) { - float col[4]; - ibuf_get_color(col, ibuf, x + 1, y); - val2 = (col[0] + col[1] + col[2]); - } - else { - val2 = val1; - } - - if (y < ibuf->y - 1) { - float col[4]; - ibuf_get_color(col, ibuf, x, y + 1); - val3 = (col[0] + col[1] + col[2]); - } - else { - val3 = val1; - } - - /* do not mix up x and y here! */ - texres->nor[0] = (val1 - val2); - texres->nor[1] = (val1 - val3); - } - } - if (texres->talpha) { texres->tin = texres->trgba[3]; } @@ -989,7 +946,7 @@ static int imagewraposa_aniso(Tex *tex, { TexResult texr; float fx, fy, minx, maxx, miny, maxy; - float maxd, val1, val2, val3; + float maxd; int curmap, retval, intpol, extflag = 0; afdata_t AFD; @@ -1008,8 +965,7 @@ static int imagewraposa_aniso(Tex *tex, texres->tin = texres->trgba[3] = texres->trgba[0] = texres->trgba[1] = texres->trgba[2] = 0.0f; - /* we need to set retval OK, otherwise texture code generates normals itself... */ - retval = texres->nor ? (TEX_RGB | TEX_NOR) : TEX_RGB; + retval = TEX_RGB; /* quick tests */ if (ibuf == NULL && ima == NULL) { @@ -1040,7 +996,7 @@ static int imagewraposa_aniso(Tex *tex, if (ima) { if ((tex->imaflag & TEX_USEALPHA) && (ima->alpha_mode != IMA_ALPHA_IGNORE)) { if ((tex->imaflag & TEX_CALCALPHA) == 0) { - texres->talpha = 1; + texres->talpha = true; } } } @@ -1301,48 +1257,17 @@ static int imagewraposa_aniso(Tex *tex, } /* filter functions take care of interpolation themselves, no need to modify dxt/dyt here */ - - if (texres->nor && ((tex->imaflag & TEX_NORMALMAP) == 0)) { - /* color & normal */ - filterfunc(texres, curibuf, fx, fy, &AFD); - val1 = texres->trgba[0] + texres->trgba[1] + texres->trgba[2]; - filterfunc(&texr, curibuf, fx + dxt[0], fy + dxt[1], &AFD); - val2 = texr.trgba[0] + texr.trgba[1] + texr.trgba[2]; - filterfunc(&texr, curibuf, fx + dyt[0], fy + dyt[1], &AFD); - val3 = texr.trgba[0] + texr.trgba[1] + texr.trgba[2]; - /* don't switch x or y! */ - texres->nor[0] = val1 - val2; - texres->nor[1] = val1 - val3; - if (previbuf != curibuf) { /* interpolate */ - filterfunc(&texr, previbuf, fx, fy, &AFD); - /* rgb */ - texres->trgba[0] += levf * (texr.trgba[0] - texres->trgba[0]); - texres->trgba[1] += levf * (texr.trgba[1] - texres->trgba[1]); - texres->trgba[2] += levf * (texr.trgba[2] - texres->trgba[2]); - texres->trgba[3] += levf * (texr.trgba[3] - texres->trgba[3]); - /* normal */ - val1 += levf * ((texr.trgba[0] + texr.trgba[1] + texr.trgba[2]) - val1); - filterfunc(&texr, previbuf, fx + dxt[0], fy + dxt[1], &AFD); - val2 += levf * ((texr.trgba[0] + texr.trgba[1] + texr.trgba[2]) - val2); - filterfunc(&texr, previbuf, fx + dyt[0], fy + dyt[1], &AFD); - val3 += levf * ((texr.trgba[0] + texr.trgba[1] + texr.trgba[2]) - val3); - texres->nor[0] = val1 - val2; /* vals have been interpolated above! */ - texres->nor[1] = val1 - val3; - } + filterfunc(texres, curibuf, fx, fy, &AFD); + if (previbuf != curibuf) { /* interpolate */ + filterfunc(&texr, previbuf, fx, fy, &AFD); + texres->trgba[0] += levf * (texr.trgba[0] - texres->trgba[0]); + texres->trgba[1] += levf * (texr.trgba[1] - texres->trgba[1]); + texres->trgba[2] += levf * (texr.trgba[2] - texres->trgba[2]); + texres->trgba[3] += levf * (texr.trgba[3] - texres->trgba[3]); } - else { /* color */ - filterfunc(texres, curibuf, fx, fy, &AFD); - if (previbuf != curibuf) { /* interpolate */ - filterfunc(&texr, previbuf, fx, fy, &AFD); - texres->trgba[0] += levf * (texr.trgba[0] - texres->trgba[0]); - texres->trgba[1] += levf * (texr.trgba[1] - texres->trgba[1]); - texres->trgba[2] += levf * (texr.trgba[2] - texres->trgba[2]); - texres->trgba[3] += levf * (texr.trgba[3] - texres->trgba[3]); - } - if (tex->texfilter != TXF_EWA) { - alpha_clip_aniso(ibuf, fx - minx, fy - miny, fx + minx, fy + miny, extflag, texres); - } + if (tex->texfilter != TXF_EWA) { + alpha_clip_aniso(ibuf, fx - minx, fy - miny, fx + minx, fy + miny, extflag, texres); } } else { /* no mipmap */ @@ -1372,23 +1297,9 @@ static int imagewraposa_aniso(Tex *tex, AFD.dusc = 1.0f / ff; AFD.dvsc = ff / (float)ibuf->y; } - if (texres->nor && ((tex->imaflag & TEX_NORMALMAP) == 0)) { - /* color & normal */ - filterfunc(texres, ibuf, fx, fy, &AFD); - val1 = texres->trgba[0] + texres->trgba[1] + texres->trgba[2]; - filterfunc(&texr, ibuf, fx + dxt[0], fy + dxt[1], &AFD); - val2 = texr.trgba[0] + texr.trgba[1] + texr.trgba[2]; - filterfunc(&texr, ibuf, fx + dyt[0], fy + dyt[1], &AFD); - val3 = texr.trgba[0] + texr.trgba[1] + texr.trgba[2]; - /* don't switch x or y! */ - texres->nor[0] = val1 - val2; - texres->nor[1] = val1 - val3; - } - else { - filterfunc(texres, ibuf, fx, fy, &AFD); - if (tex->texfilter != TXF_EWA) { - alpha_clip_aniso(ibuf, fx - minx, fy - miny, fx + minx, fy + miny, extflag, texres); - } + filterfunc(texres, ibuf, fx, fy, &AFD); + if (tex->texfilter != TXF_EWA) { + alpha_clip_aniso(ibuf, fx - minx, fy - miny, fx + minx, fy + miny, extflag, texres); } } @@ -1403,18 +1314,6 @@ static int imagewraposa_aniso(Tex *tex, texres->trgba[3] = 1.0f - texres->trgba[3]; } - if (texres->nor && (tex->imaflag & TEX_NORMALMAP)) { /* normal from color */ - /* The invert of the red channel is to make - * the normal map compliant with the outside world. - * It needs to be done because in Blender - * the normal used in the renderer points inward. It is generated - * this way in calc_vertexnormals(). Should this ever change - * this negate must be removed. */ - texres->nor[0] = -2.0f * (texres->trgba[0] - 0.5f); - texres->nor[1] = 2.0f * (texres->trgba[1] - 0.5f); - texres->nor[2] = 2.0f * (texres->trgba[2] - 0.5f); - } - /* de-premul, this is being pre-multiplied in shade_input_do_shade() * TXF: this currently does not (yet?) work properly, destroys edge AA in clip/checker mode, * so for now commented out also disabled in imagewraposa() @@ -1451,7 +1350,7 @@ int imagewraposa(Tex *tex, { TexResult texr; float fx, fy, minx, maxx, miny, maxy, dx, dy, dxt[2], dyt[2]; - float maxd, pixsize, val1, val2, val3; + float maxd, pixsize; int curmap, retval, imaprepeat, imapextend; /* TXF: since dxt/dyt might be modified here and since they might be needed after imagewraposa() @@ -1466,8 +1365,7 @@ int imagewraposa(Tex *tex, texres->tin = texres->trgba[3] = texres->trgba[0] = texres->trgba[1] = texres->trgba[2] = 0.0f; - /* we need to set retval OK, otherwise texture code generates normals itself... */ - retval = texres->nor ? (TEX_RGB | TEX_NOR) : TEX_RGB; + retval = TEX_RGB; /* quick tests */ if (ibuf == NULL && ima == NULL) { @@ -1721,7 +1619,6 @@ int imagewraposa(Tex *tex, /* Choice: */ if (tex->imaflag & TEX_MIPMAP) { ImBuf *previbuf, *curibuf; - float bumpscale; dx = minx; dy = miny; @@ -1732,14 +1629,6 @@ int imagewraposa(Tex *tex, pixsize = 1.0f / (float)MIN2(ibuf->x, ibuf->y); - bumpscale = pixsize / maxd; - if (bumpscale > 1.0f) { - bumpscale = 1.0f; - } - else { - bumpscale *= bumpscale; - } - curmap = 0; previbuf = curibuf = ibuf; while (curmap < IMB_MIPMAP_LEVELS && ibuf->mipmap[curmap]) { @@ -1762,118 +1651,30 @@ int imagewraposa(Tex *tex, } } - if (texres->nor && (tex->imaflag & TEX_NORMALMAP) == 0) { - /* a bit extra filter */ - // minx*= 1.35f; - // miny*= 1.35f; - - boxsample( - curibuf, fx - minx, fy - miny, fx + minx, fy + miny, texres, imaprepeat, imapextend); - val1 = texres->trgba[0] + texres->trgba[1] + texres->trgba[2]; - boxsample(curibuf, - fx - minx + dxt[0], - fy - miny + dxt[1], - fx + minx + dxt[0], - fy + miny + dxt[1], - &texr, - imaprepeat, - imapextend); - val2 = texr.trgba[0] + texr.trgba[1] + texr.trgba[2]; - boxsample(curibuf, - fx - minx + dyt[0], - fy - miny + dyt[1], - fx + minx + dyt[0], - fy + miny + dyt[1], - &texr, - imaprepeat, - imapextend); - val3 = texr.trgba[0] + texr.trgba[1] + texr.trgba[2]; - - /* don't switch x or y! */ - texres->nor[0] = (val1 - val2); - texres->nor[1] = (val1 - val3); - - if (previbuf != curibuf) { /* interpolate */ - - boxsample( - previbuf, fx - minx, fy - miny, fx + minx, fy + miny, &texr, imaprepeat, imapextend); - - /* calc rgb */ - dx = 2.0f * (pixsize - maxd) / pixsize; - if (dx >= 1.0f) { - texres->trgba[3] = texr.trgba[3]; - texres->trgba[2] = texr.trgba[2]; - texres->trgba[1] = texr.trgba[1]; - texres->trgba[0] = texr.trgba[0]; - } - else { - dy = 1.0f - dx; - texres->trgba[2] = dy * texres->trgba[2] + dx * texr.trgba[2]; - texres->trgba[1] = dy * texres->trgba[1] + dx * texr.trgba[1]; - texres->trgba[0] = dy * texres->trgba[0] + dx * texr.trgba[0]; - texres->trgba[3] = dy * texres->trgba[3] + dx * texr.trgba[3]; - } - - val1 = dy * val1 + dx * (texr.trgba[0] + texr.trgba[1] + texr.trgba[2]); - boxsample(previbuf, - fx - minx + dxt[0], - fy - miny + dxt[1], - fx + minx + dxt[0], - fy + miny + dxt[1], - &texr, - imaprepeat, - imapextend); - val2 = dy * val2 + dx * (texr.trgba[0] + texr.trgba[1] + texr.trgba[2]); - boxsample(previbuf, - fx - minx + dyt[0], - fy - miny + dyt[1], - fx + minx + dyt[0], - fy + miny + dyt[1], - &texr, - imaprepeat, - imapextend); - val3 = dy * val3 + dx * (texr.trgba[0] + texr.trgba[1] + texr.trgba[2]); - - texres->nor[0] = (val1 - val2); /* vals have been interpolated above! */ - texres->nor[1] = (val1 - val3); - - if (dx < 1.0f) { - dy = 1.0f - dx; - texres->trgba[2] = dy * texres->trgba[2] + dx * texr.trgba[2]; - texres->trgba[1] = dy * texres->trgba[1] + dx * texr.trgba[1]; - texres->trgba[0] = dy * texres->trgba[0] + dx * texr.trgba[0]; - texres->trgba[3] = dy * texres->trgba[3] + dx * texr.trgba[3]; - } - } - texres->nor[0] *= bumpscale; - texres->nor[1] *= bumpscale; - } - else { - maxx = fx + minx; - minx = fx - minx; - maxy = fy + miny; - miny = fy - miny; + maxx = fx + minx; + minx = fx - minx; + maxy = fy + miny; + miny = fy - miny; - boxsample(curibuf, minx, miny, maxx, maxy, texres, imaprepeat, imapextend); + boxsample(curibuf, minx, miny, maxx, maxy, texres, imaprepeat, imapextend); - if (previbuf != curibuf) { /* interpolate */ - boxsample(previbuf, minx, miny, maxx, maxy, &texr, imaprepeat, imapextend); + if (previbuf != curibuf) { /* interpolate */ + boxsample(previbuf, minx, miny, maxx, maxy, &texr, imaprepeat, imapextend); - fx = 2.0f * (pixsize - maxd) / pixsize; + fx = 2.0f * (pixsize - maxd) / pixsize; - if (fx >= 1.0f) { - texres->trgba[3] = texr.trgba[3]; - texres->trgba[2] = texr.trgba[2]; - texres->trgba[1] = texr.trgba[1]; - texres->trgba[0] = texr.trgba[0]; - } - else { - fy = 1.0f - fx; - texres->trgba[2] = fy * texres->trgba[2] + fx * texr.trgba[2]; - texres->trgba[1] = fy * texres->trgba[1] + fx * texr.trgba[1]; - texres->trgba[0] = fy * texres->trgba[0] + fx * texr.trgba[0]; - texres->trgba[3] = fy * texres->trgba[3] + fx * texr.trgba[3]; - } + if (fx >= 1.0f) { + texres->trgba[3] = texr.trgba[3]; + texres->trgba[2] = texr.trgba[2]; + texres->trgba[1] = texr.trgba[1]; + texres->trgba[0] = texr.trgba[0]; + } + else { + fy = 1.0f - fx; + texres->trgba[2] = fy * texres->trgba[2] + fx * texr.trgba[2]; + texres->trgba[1] = fy * texres->trgba[1] + fx * texr.trgba[1]; + texres->trgba[0] = fy * texres->trgba[0] + fx * texr.trgba[0]; + texres->trgba[3] = fy * texres->trgba[3] + fx * texr.trgba[3]; } } } @@ -1889,35 +1690,7 @@ int imagewraposa(Tex *tex, } } - if (texres->nor && (tex->imaflag & TEX_NORMALMAP) == 0) { - boxsample(ibuf, fx - minx, fy - miny, fx + minx, fy + miny, texres, imaprepeat, imapextend); - val1 = texres->trgba[0] + texres->trgba[1] + texres->trgba[2]; - boxsample(ibuf, - fx - minx + dxt[0], - fy - miny + dxt[1], - fx + minx + dxt[0], - fy + miny + dxt[1], - &texr, - imaprepeat, - imapextend); - val2 = texr.trgba[0] + texr.trgba[1] + texr.trgba[2]; - boxsample(ibuf, - fx - minx + dyt[0], - fy - miny + dyt[1], - fx + minx + dyt[0], - fy + miny + dyt[1], - &texr, - imaprepeat, - imapextend); - val3 = texr.trgba[0] + texr.trgba[1] + texr.trgba[2]; - - /* don't switch x or y! */ - texres->nor[0] = (val1 - val2); - texres->nor[1] = (val1 - val3); - } - else { - boxsample(ibuf, fx - minx, fy - miny, fx + minx, fy + miny, texres, imaprepeat, imapextend); - } + boxsample(ibuf, fx - minx, fy - miny, fx + minx, fy + miny, texres, imaprepeat, imapextend); } if (tex->imaflag & TEX_CALCALPHA) { @@ -1932,17 +1705,6 @@ int imagewraposa(Tex *tex, texres->trgba[3] = 1.0f - texres->trgba[3]; } - if (texres->nor && (tex->imaflag & TEX_NORMALMAP)) { - /* Normal from color: - * The invert of the red channel is to make the normal map compliant with the outside world. - * It needs to be done because in Blender the normal used in the renderer points inward. - * It is generated this way in #calc_vertexnormals(). - * Should this ever change this negate must be removed. */ - texres->nor[0] = -2.0f * (texres->trgba[0] - 0.5f); - texres->nor[1] = 2.0f * (texres->trgba[1] - 0.5f); - texres->nor[2] = 2.0f * (texres->trgba[2] - 0.5f); - } - /* de-premul, this is being pre-multiplied in shade_input_do_shade() */ /* do not de-premul for generated alpha, it is already in straight */ if (texres->trgba[3] != 1.0f && texres->trgba[3] > 1e-4f && !(tex->imaflag & TEX_CALCALPHA)) { diff --git a/source/blender/render/intern/texture_margin.cc b/source/blender/render/intern/texture_margin.cc index 37ef9213615..66ab7ba6e2e 100644 --- a/source/blender/render/intern/texture_margin.cc +++ b/source/blender/render/intern/texture_margin.cc @@ -491,8 +491,8 @@ static void generate_margin(ImBuf *ibuf, const float uv_offset[2]) { - MPoly *mpoly; - MLoop *mloop; + const MPoly *mpoly; + const MLoop *mloop; const MLoopUV *mloopuv; int totpoly, totloop, totedge; @@ -505,8 +505,8 @@ static void generate_margin(ImBuf *ibuf, totpoly = me->totpoly; totloop = me->totloop; totedge = me->totedge; - mpoly = me->mpoly; - mloop = me->mloop; + mpoly = me->polys().data(); + mloop = me->loops().data(); if ((uv_layer == nullptr) || (uv_layer[0] == '\0')) { mloopuv = static_cast<const MLoopUV *>(CustomData_get_layer(&me->ldata, CD_MLOOPUV)); @@ -520,7 +520,7 @@ static void generate_margin(ImBuf *ibuf, tottri = poly_to_tri_count(me->totpoly, me->totloop); looptri_mem = static_cast<MLoopTri *>(MEM_mallocN(sizeof(*looptri) * tottri, __func__)); BKE_mesh_recalc_looptri( - me->mloop, me->mpoly, me->mvert, me->totloop, me->totpoly, looptri_mem); + mloop, mpoly, me->verts().data(), me->totloop, me->totpoly, looptri_mem); looptri = looptri_mem; } else { @@ -558,8 +558,8 @@ static void generate_margin(ImBuf *ibuf, for (int a = 0; a < 3; a++) { const float *uv = mloopuv[lt->tri[a]].uv; - /* NOTE(campbell): workaround for pixel aligned UVs which are common and can screw up our - * intersection tests where a pixel gets in between 2 faces or the middle of a quad, + /* NOTE(@campbellbarton): workaround for pixel aligned UVs which are common and can screw up + * our intersection tests where a pixel gets in between 2 faces or the middle of a quad, * camera aligned quads also have this problem but they are less common. * Add a small offset to the UVs, fixes bug T18685. */ vec[a][0] = (uv[0] - uv_offset[0]) * (float)ibuf->x - (0.5f + 0.001f); diff --git a/source/blender/render/intern/texture_pointdensity.c b/source/blender/render/intern/texture_pointdensity.c index 6e0bae700dc..2a2b62be1f0 100644 --- a/source/blender/render/intern/texture_pointdensity.c +++ b/source/blender/render/intern/texture_pointdensity.c @@ -24,6 +24,7 @@ #include "DNA_meshdata_types.h" #include "DNA_object_types.h" #include "DNA_particle_types.h" +#include "DNA_scene_types.h" #include "DNA_texture_types.h" #include "BKE_colorband.h" @@ -39,7 +40,6 @@ #include "DEG_depsgraph.h" #include "DEG_depsgraph_query.h" -#include "render_types.h" #include "texture_common.h" #include "RE_texture.h" @@ -269,7 +269,7 @@ static void pointdensity_cache_vertex_color(PointDensity *pd, Mesh *mesh, float *data_color) { - const MLoop *mloop = mesh->mloop; + const MLoop *mloop = BKE_mesh_loops(mesh); const int totloop = mesh->totloop; char layername[MAX_CUSTOMDATA_LAYER_NAME]; int i; @@ -364,7 +364,7 @@ static void pointdensity_cache_object(PointDensity *pd, Object *ob) { float *data_color; int i; - MVert *mvert = NULL, *mv; + const MVert *mvert = NULL, *mv; Mesh *mesh = ob->data; #if 0 /* UNUSED */ @@ -380,7 +380,7 @@ static void pointdensity_cache_object(PointDensity *pd, Object *ob) } #endif - mvert = mesh->mvert; /* local object space */ + mvert = BKE_mesh_verts(mesh); /* local object space */ pd->totpoints = mesh->totvert; if (pd->totpoints == 0) { return; diff --git a/source/blender/render/intern/texture_procedural.c b/source/blender/render/intern/texture_procedural.c index ce58993b7cf..13207543fd7 100644 --- a/source/blender/render/intern/texture_procedural.c +++ b/source/blender/render/intern/texture_procedural.c @@ -38,7 +38,6 @@ #include "MEM_guardedalloc.h" -#include "render_types.h" #include "texture_common.h" #include "RE_texture.h" @@ -61,34 +60,6 @@ void RE_texture_rng_exit(void) /* ------------------------------------------------------------------------- */ -/* This allows color-banded textures to control normals as well. */ -static void tex_normal_derivate(const Tex *tex, TexResult *texres) -{ - if (tex->flag & TEX_COLORBAND) { - float col[4]; - if (BKE_colorband_evaluate(tex->coba, texres->tin, col)) { - float fac0, fac1, fac2, fac3; - - fac0 = (col[0] + col[1] + col[2]); - BKE_colorband_evaluate(tex->coba, texres->nor[0], col); - fac1 = (col[0] + col[1] + col[2]); - BKE_colorband_evaluate(tex->coba, texres->nor[1], col); - fac2 = (col[0] + col[1] + col[2]); - BKE_colorband_evaluate(tex->coba, texres->nor[2], col); - fac3 = (col[0] + col[1] + col[2]); - - texres->nor[0] = (fac0 - fac1) / 3.0f; - texres->nor[1] = (fac0 - fac2) / 3.0f; - texres->nor[2] = (fac0 - fac3) / 3.0f; - - return; - } - } - texres->nor[0] = texres->tin - texres->nor[0]; - texres->nor[1] = texres->tin - texres->nor[1]; - texres->nor[2] = texres->tin - texres->nor[2]; -} - static int blend(const Tex *tex, const float texvec[3], TexResult *texres) { float x, y, t; @@ -165,37 +136,7 @@ static int clouds(const Tex *tex, const float texvec[3], TexResult *texres) (tex->noisetype != TEX_NOISESOFT), tex->noisebasis); - if (texres->nor != NULL) { - /* calculate bumpnormal */ - texres->nor[0] = BLI_noise_generic_turbulence(tex->noisesize, - texvec[0] + tex->nabla, - texvec[1], - texvec[2], - tex->noisedepth, - (tex->noisetype != TEX_NOISESOFT), - tex->noisebasis); - texres->nor[1] = BLI_noise_generic_turbulence(tex->noisesize, - texvec[0], - texvec[1] + tex->nabla, - texvec[2], - tex->noisedepth, - (tex->noisetype != TEX_NOISESOFT), - tex->noisebasis); - texres->nor[2] = BLI_noise_generic_turbulence(tex->noisesize, - texvec[0], - texvec[1], - texvec[2] + tex->nabla, - tex->noisedepth, - (tex->noisetype != TEX_NOISESOFT), - tex->noisebasis); - - tex_normal_derivate(tex, texres); - rv |= TEX_NOR; - } - if (tex->stype == TEX_COLOR) { - /* in this case, int. value should really be computed from color, - * and bumpnormal from that, would be too slow, looks ok as is */ texres->trgba[0] = texres->tin; texres->trgba[1] = BLI_noise_generic_turbulence(tex->noisesize, texvec[1], @@ -298,15 +239,6 @@ static int wood(const Tex *tex, const float texvec[3], TexResult *texres) int rv = TEX_INT; texres->tin = wood_int(tex, texvec[0], texvec[1], texvec[2]); - if (texres->nor != NULL) { - /* calculate bumpnormal */ - texres->nor[0] = wood_int(tex, texvec[0] + tex->nabla, texvec[1], texvec[2]); - texres->nor[1] = wood_int(tex, texvec[0], texvec[1] + tex->nabla, texvec[2]); - texres->nor[2] = wood_int(tex, texvec[0], texvec[1], texvec[2] + tex->nabla); - - tex_normal_derivate(tex, texres); - rv |= TEX_NOR; - } BRICONT; @@ -358,17 +290,6 @@ static int marble(const Tex *tex, const float texvec[3], TexResult *texres) texres->tin = marble_int(tex, texvec[0], texvec[1], texvec[2]); - if (texres->nor != NULL) { - /* calculate bumpnormal */ - texres->nor[0] = marble_int(tex, texvec[0] + tex->nabla, texvec[1], texvec[2]); - texres->nor[1] = marble_int(tex, texvec[0], texvec[1] + tex->nabla, texvec[2]); - texres->nor[2] = marble_int(tex, texvec[0], texvec[1], texvec[2] + tex->nabla); - - tex_normal_derivate(tex, texres); - - rv |= TEX_NOR; - } - BRICONT; return rv; @@ -454,7 +375,7 @@ static int magic(const Tex *tex, const float texvec[3], TexResult *texres) /* newnoise: stucci also modified to use different noisebasis */ static int stucci(const Tex *tex, const float texvec[3], TexResult *texres) { - float nor[3], b2, ofs; + float b2, ofs; int retval = TEX_INT; b2 = BLI_noise_generic_noise(tex->noisesize, @@ -469,40 +390,13 @@ static int stucci(const Tex *tex, const float texvec[3], TexResult *texres) if (tex->stype) { ofs *= (b2 * b2); } - nor[0] = BLI_noise_generic_noise(tex->noisesize, - texvec[0] + ofs, - texvec[1], - texvec[2], - (tex->noisetype != TEX_NOISESOFT), - tex->noisebasis); - nor[1] = BLI_noise_generic_noise(tex->noisesize, - texvec[0], - texvec[1] + ofs, - texvec[2], - (tex->noisetype != TEX_NOISESOFT), - tex->noisebasis); - nor[2] = BLI_noise_generic_noise(tex->noisesize, - texvec[0], - texvec[1], - texvec[2] + ofs, - (tex->noisetype != TEX_NOISESOFT), - tex->noisebasis); - - texres->tin = nor[2]; - - if (texres->nor) { - - copy_v3_v3(texres->nor, nor); - tex_normal_derivate(tex, texres); - - if (tex->stype == TEX_WALLOUT) { - texres->nor[0] = -texres->nor[0]; - texres->nor[1] = -texres->nor[1]; - texres->nor[2] = -texres->nor[2]; - } - retval |= TEX_NOR; - } + texres->tin = BLI_noise_generic_noise(tex->noisesize, + texvec[0], + texvec[1], + texvec[2] + ofs, + (tex->noisetype != TEX_NOISESOFT), + tex->noisebasis); if (tex->stype == TEX_WALLOUT) { texres->tin = 1.0f - texres->tin; @@ -538,36 +432,6 @@ static int mg_mFractalOrfBmTex(const Tex *tex, const float texvec[3], TexResult tex->mg_octaves, tex->noisebasis); - if (texres->nor != NULL) { - float ofs = tex->nabla / tex->noisesize; /* also scaling of texvec */ - - /* calculate bumpnormal */ - texres->nor[0] = tex->ns_outscale * mgravefunc(texvec[0] + ofs, - texvec[1], - texvec[2], - tex->mg_H, - tex->mg_lacunarity, - tex->mg_octaves, - tex->noisebasis); - texres->nor[1] = tex->ns_outscale * mgravefunc(texvec[0], - texvec[1] + ofs, - texvec[2], - tex->mg_H, - tex->mg_lacunarity, - tex->mg_octaves, - tex->noisebasis); - texres->nor[2] = tex->ns_outscale * mgravefunc(texvec[0], - texvec[1], - texvec[2] + ofs, - tex->mg_H, - tex->mg_lacunarity, - tex->mg_octaves, - tex->noisebasis); - - tex_normal_derivate(tex, texres); - rv |= TEX_NOR; - } - BRICONT; return rv; @@ -595,42 +459,6 @@ static int mg_ridgedOrHybridMFTex(const Tex *tex, const float texvec[3], TexResu tex->mg_gain, tex->noisebasis); - if (texres->nor != NULL) { - float ofs = tex->nabla / tex->noisesize; /* also scaling of texvec */ - - /* calculate bumpnormal */ - texres->nor[0] = tex->ns_outscale * mgravefunc(texvec[0] + ofs, - texvec[1], - texvec[2], - tex->mg_H, - tex->mg_lacunarity, - tex->mg_octaves, - tex->mg_offset, - tex->mg_gain, - tex->noisebasis); - texres->nor[1] = tex->ns_outscale * mgravefunc(texvec[0], - texvec[1] + ofs, - texvec[2], - tex->mg_H, - tex->mg_lacunarity, - tex->mg_octaves, - tex->mg_offset, - tex->mg_gain, - tex->noisebasis); - texres->nor[2] = tex->ns_outscale * mgravefunc(texvec[0], - texvec[1], - texvec[2] + ofs, - tex->mg_H, - tex->mg_lacunarity, - tex->mg_octaves, - tex->mg_offset, - tex->mg_gain, - tex->noisebasis); - - tex_normal_derivate(tex, texres); - rv |= TEX_NOR; - } - BRICONT; return rv; @@ -649,39 +477,6 @@ static int mg_HTerrainTex(const Tex *tex, const float texvec[3], TexResult *texr tex->mg_offset, tex->noisebasis); - if (texres->nor != NULL) { - float ofs = tex->nabla / tex->noisesize; /* also scaling of texvec */ - - /* calculate bumpnormal */ - texres->nor[0] = tex->ns_outscale * BLI_noise_mg_hetero_terrain(texvec[0] + ofs, - texvec[1], - texvec[2], - tex->mg_H, - tex->mg_lacunarity, - tex->mg_octaves, - tex->mg_offset, - tex->noisebasis); - texres->nor[1] = tex->ns_outscale * BLI_noise_mg_hetero_terrain(texvec[0], - texvec[1] + ofs, - texvec[2], - tex->mg_H, - tex->mg_lacunarity, - tex->mg_octaves, - tex->mg_offset, - tex->noisebasis); - texres->nor[2] = tex->ns_outscale * BLI_noise_mg_hetero_terrain(texvec[0], - texvec[1], - texvec[2] + ofs, - tex->mg_H, - tex->mg_lacunarity, - tex->mg_octaves, - tex->mg_offset, - tex->noisebasis); - - tex_normal_derivate(tex, texres); - rv |= TEX_NOR; - } - BRICONT; return rv; @@ -694,33 +489,6 @@ static int mg_distNoiseTex(const Tex *tex, const float texvec[3], TexResult *tex texres->tin = BLI_noise_mg_variable_lacunarity( texvec[0], texvec[1], texvec[2], tex->dist_amount, tex->noisebasis, tex->noisebasis2); - if (texres->nor != NULL) { - float ofs = tex->nabla / tex->noisesize; /* also scaling of texvec */ - - /* calculate bumpnormal */ - texres->nor[0] = BLI_noise_mg_variable_lacunarity(texvec[0] + ofs, - texvec[1], - texvec[2], - tex->dist_amount, - tex->noisebasis, - tex->noisebasis2); - texres->nor[1] = BLI_noise_mg_variable_lacunarity(texvec[0], - texvec[1] + ofs, - texvec[2], - tex->dist_amount, - tex->noisebasis, - tex->noisebasis2); - texres->nor[2] = BLI_noise_mg_variable_lacunarity(texvec[0], - texvec[1], - texvec[2] + ofs, - tex->dist_amount, - tex->noisebasis, - tex->noisebasis2); - - tex_normal_derivate(tex, texres); - rv |= TEX_NOR; - } - BRICONT; return rv; @@ -788,21 +556,6 @@ static int voronoiTex(const Tex *tex, const float texvec[3], TexResult *texres) } } - if (texres->nor != NULL) { - float ofs = tex->nabla / tex->noisesize; /* also scaling of texvec */ - - /* calculate bumpnormal */ - BLI_noise_voronoi(texvec[0] + ofs, texvec[1], texvec[2], da, pa, tex->vn_mexp, tex->vn_distm); - texres->nor[0] = sc * fabsf(dot_v4v4(&tex->vn_w1, da)); - BLI_noise_voronoi(texvec[0], texvec[1] + ofs, texvec[2], da, pa, tex->vn_mexp, tex->vn_distm); - texres->nor[1] = sc * fabsf(dot_v4v4(&tex->vn_w1, da)); - BLI_noise_voronoi(texvec[0], texvec[1], texvec[2] + ofs, da, pa, tex->vn_mexp, tex->vn_distm); - texres->nor[2] = sc * fabsf(dot_v4v4(&tex->vn_w1, da)); - - tex_normal_derivate(tex, texres); - rv |= TEX_NOR; - } - if (tex->vn_coltype) { BRICONTRGB; texres->trgba[3] = 1.0; @@ -1148,7 +901,7 @@ static int multitex(Tex *tex, const bool use_nodes) { float tmpvec[3]; - int retval = 0; /* return value, int:0, col:1, nor:2, everything:3 */ + int retval = 0; /* return value, TEX_INT or TEX_RGB. */ texres->talpha = false; /* is set when image texture returns alpha (considered premul) */ @@ -1283,14 +1036,14 @@ static int multitex_nodes_intern(Tex *tex, } if (tex->type == TEX_IMAGE) { - int rgbnor; + int retval; if (mtex) { float texvec_l[3]; copy_v3_v3(texvec_l, texvec); /* we have mtex, use it for 2d mapping images only */ do_2d_mapping(mtex, texvec_l, NULL, dxt, dyt); - rgbnor = multitex(tex, + retval = multitex(tex, texvec_l, dxt, dyt, @@ -1307,7 +1060,7 @@ static int multitex_nodes_intern(Tex *tex, ImBuf *ibuf = BKE_image_pool_acquire_ibuf(tex->ima, &tex->iuser, pool); /* don't linearize float buffers, assumed to be linear */ - if (ibuf != NULL && ibuf->rect_float == NULL && (rgbnor & TEX_RGB) && scene_color_manage) { + if (ibuf != NULL && ibuf->rect_float == NULL && (retval & TEX_RGB) && scene_color_manage) { IMB_colormanagement_colorspace_to_scene_linear_v3(texres->trgba, ibuf->rect_colorspace); } @@ -1335,7 +1088,7 @@ static int multitex_nodes_intern(Tex *tex, } do_2d_mapping(&localmtex, texvec_l, NULL, dxt_l, dyt_l); - rgbnor = multitex(tex, + retval = multitex(tex, texvec_l, dxt_l, dyt_l, @@ -1352,7 +1105,7 @@ static int multitex_nodes_intern(Tex *tex, ImBuf *ibuf = BKE_image_pool_acquire_ibuf(tex->ima, &tex->iuser, pool); /* don't linearize float buffers, assumed to be linear */ - if (ibuf != NULL && ibuf->rect_float == NULL && (rgbnor & TEX_RGB) && scene_color_manage) { + if (ibuf != NULL && ibuf->rect_float == NULL && (retval & TEX_RGB) && scene_color_manage) { IMB_colormanagement_colorspace_to_scene_linear_v3(texres->trgba, ibuf->rect_colorspace); } @@ -1360,7 +1113,7 @@ static int multitex_nodes_intern(Tex *tex, } } - return rgbnor; + return retval; } return multitex(tex, @@ -1456,145 +1209,6 @@ int multitex_ext_safe(Tex *tex, /* ------------------------------------------------------------------------- */ -void texture_rgb_blend( - float in[3], const float tex[3], const float out[3], float fact, float facg, int blendtype) -{ - float facm; - - switch (blendtype) { - case MTEX_BLEND: - fact *= facg; - facm = 1.0f - fact; - - in[0] = (fact * tex[0] + facm * out[0]); - in[1] = (fact * tex[1] + facm * out[1]); - in[2] = (fact * tex[2] + facm * out[2]); - break; - - case MTEX_MUL: - fact *= facg; - facm = 1.0f - fact; - in[0] = (facm + fact * tex[0]) * out[0]; - in[1] = (facm + fact * tex[1]) * out[1]; - in[2] = (facm + fact * tex[2]) * out[2]; - break; - - case MTEX_SCREEN: - fact *= facg; - facm = 1.0f - fact; - in[0] = 1.0f - (facm + fact * (1.0f - tex[0])) * (1.0f - out[0]); - in[1] = 1.0f - (facm + fact * (1.0f - tex[1])) * (1.0f - out[1]); - in[2] = 1.0f - (facm + fact * (1.0f - tex[2])) * (1.0f - out[2]); - break; - - case MTEX_OVERLAY: - fact *= facg; - facm = 1.0f - fact; - - if (out[0] < 0.5f) { - in[0] = out[0] * (facm + 2.0f * fact * tex[0]); - } - else { - in[0] = 1.0f - (facm + 2.0f * fact * (1.0f - tex[0])) * (1.0f - out[0]); - } - if (out[1] < 0.5f) { - in[1] = out[1] * (facm + 2.0f * fact * tex[1]); - } - else { - in[1] = 1.0f - (facm + 2.0f * fact * (1.0f - tex[1])) * (1.0f - out[1]); - } - if (out[2] < 0.5f) { - in[2] = out[2] * (facm + 2.0f * fact * tex[2]); - } - else { - in[2] = 1.0f - (facm + 2.0f * fact * (1.0f - tex[2])) * (1.0f - out[2]); - } - break; - - case MTEX_SUB: - fact = -fact; - ATTR_FALLTHROUGH; - case MTEX_ADD: - fact *= facg; - in[0] = (fact * tex[0] + out[0]); - in[1] = (fact * tex[1] + out[1]); - in[2] = (fact * tex[2] + out[2]); - break; - - case MTEX_DIV: - fact *= facg; - facm = 1.0f - fact; - - if (tex[0] != 0.0f) { - in[0] = facm * out[0] + fact * out[0] / tex[0]; - } - if (tex[1] != 0.0f) { - in[1] = facm * out[1] + fact * out[1] / tex[1]; - } - if (tex[2] != 0.0f) { - in[2] = facm * out[2] + fact * out[2] / tex[2]; - } - - break; - - case MTEX_DIFF: - fact *= facg; - facm = 1.0f - fact; - in[0] = facm * out[0] + fact * fabsf(tex[0] - out[0]); - in[1] = facm * out[1] + fact * fabsf(tex[1] - out[1]); - in[2] = facm * out[2] + fact * fabsf(tex[2] - out[2]); - break; - - case MTEX_DARK: - fact *= facg; - facm = 1.0f - fact; - - in[0] = min_ff(out[0], tex[0]) * fact + out[0] * facm; - in[1] = min_ff(out[1], tex[1]) * fact + out[1] * facm; - in[2] = min_ff(out[2], tex[2]) * fact + out[2] * facm; - break; - - case MTEX_LIGHT: - fact *= facg; - - in[0] = max_ff(fact * tex[0], out[0]); - in[1] = max_ff(fact * tex[1], out[1]); - in[2] = max_ff(fact * tex[2], out[2]); - break; - - case MTEX_BLEND_HUE: - fact *= facg; - copy_v3_v3(in, out); - ramp_blend(MA_RAMP_HUE, in, fact, tex); - break; - case MTEX_BLEND_SAT: - fact *= facg; - copy_v3_v3(in, out); - ramp_blend(MA_RAMP_SAT, in, fact, tex); - break; - case MTEX_BLEND_VAL: - fact *= facg; - copy_v3_v3(in, out); - ramp_blend(MA_RAMP_VAL, in, fact, tex); - break; - case MTEX_BLEND_COLOR: - fact *= facg; - copy_v3_v3(in, out); - ramp_blend(MA_RAMP_COLOR, in, fact, tex); - break; - case MTEX_SOFT_LIGHT: - fact *= facg; - copy_v3_v3(in, out); - ramp_blend(MA_RAMP_SOFT, in, fact, tex); - break; - case MTEX_LIN_LIGHT: - fact *= facg; - copy_v3_v3(in, out); - ramp_blend(MA_RAMP_LINEAR, in, fact, tex); - break; - } -} - float texture_value_blend(float tex, float out, float fact, float facg, int blendtype) { float in = 0.0, facm, col, scf; @@ -1703,7 +1317,6 @@ bool RE_texture_evaluate(const MTex *mtex, if (tex == NULL) { return 0; } - texr.nor = NULL; /* placement */ if (mtex->projx) { |