Page MenuHome
Differential D16083 Diff 56395 source/blender/modifiers/intern/MOD_subsurf.cc

Changeset View

Standalone View

View Options

source/blender/modifiers/intern/MOD_subsurf.cc

  • This file was moved from source/blender/modifiers/intern/MOD_subsurf.c.
Show First 20 Lines • Show All 85 Lines • ▼ Show 20 Lines
{ {
#if 0 #if 0
const SubsurfModifierData *smd = (const SubsurfModifierData *)md; const SubsurfModifierData *smd = (const SubsurfModifierData *)md;
#endif #endif
SubsurfModifierData *tsmd = (SubsurfModifierData *)target; SubsurfModifierData *tsmd = (SubsurfModifierData *)target;
BKE_modifier_copydata_generic(md, target, flag); BKE_modifier_copydata_generic(md, target, flag);
tsmd->emCache = tsmd->mCache = NULL; tsmd->emCache = tsmd->mCache = nullptr;
} }
static void freeRuntimeData(void *runtime_data_v) static void freeRuntimeData(void *runtime_data_v)
{ {
if (runtime_data_v == NULL) { if (runtime_data_v == nullptr) {
return; return;
} }
SubsurfRuntimeData *runtime_data = (SubsurfRuntimeData *)runtime_data_v; SubsurfRuntimeData *runtime_data = (SubsurfRuntimeData *)runtime_data_v;
if (runtime_data->subdiv != NULL) { if (runtime_data->subdiv != nullptr) {
BKE_subdiv_free(runtime_data->subdiv); BKE_subdiv_free(runtime_data->subdiv);
} }
MEM_freeN(runtime_data); MEM_freeN(runtime_data);
} }
static void freeData(ModifierData *md) static void freeData(ModifierData *md)
{ {
SubsurfModifierData *smd = (SubsurfModifierData *)md; SubsurfModifierData *smd = (SubsurfModifierData *)md;
if (smd->mCache) { if (smd->mCache) {
ccgSubSurf_free(smd->mCache); ccgSubSurf_free(static_cast<CCGSubSurf *>(smd->mCache));
smd->mCache = NULL; smd->mCache = nullptr;
} }
if (smd->emCache) { if (smd->emCache) {
ccgSubSurf_free(smd->emCache); ccgSubSurf_free(static_cast<CCGSubSurf *>(smd->emCache));
smd->emCache = NULL; smd->emCache = nullptr;
} }
freeRuntimeData(smd->modifier.runtime); freeRuntimeData(smd->modifier.runtime);
} }
static bool isDisabled(const Scene *scene, ModifierData *md, bool useRenderParams) static bool isDisabled(const Scene *scene, ModifierData *md, bool useRenderParams)
{ {
SubsurfModifierData *smd = (SubsurfModifierData *)md; SubsurfModifierData *smd = (SubsurfModifierData *)md;
int levels = (useRenderParams) ? smd->renderLevels : smd->levels; int levels = (useRenderParams) ? smd->renderLevels : smd->levels;
▲ Show 20 Lines • Show All 102 Lines • ▼ Show 20 Lines#endif
/* Delay evaluation to the draw code if possible, provided we do not have to apply the modifier. /* Delay evaluation to the draw code if possible, provided we do not have to apply the modifier.
*/ */
if ((ctx->flag & MOD_APPLY_TO_BASE_MESH) == 0) { if ((ctx->flag & MOD_APPLY_TO_BASE_MESH) == 0) {
Scene *scene = DEG_get_evaluated_scene(ctx->depsgraph); Scene *scene = DEG_get_evaluated_scene(ctx->depsgraph);
const bool is_render_mode = (ctx->flag & MOD_APPLY_RENDER) != 0; const bool is_render_mode = (ctx->flag & MOD_APPLY_RENDER) != 0;
/* Same check as in `DRW_mesh_batch_cache_create_requested` to keep both code coherent. The /* Same check as in `DRW_mesh_batch_cache_create_requested` to keep both code coherent. The
* difference is that here we do not check for the final edit mesh pointer as it is not yet * difference is that here we do not check for the final edit mesh pointer as it is not yet
* assigned at this stage of modifier stack evaluation. */ * assigned at this stage of modifier stack evaluation. */
const bool is_editmode = (mesh->edit_mesh != NULL); const bool is_editmode = (mesh->edit_mesh != nullptr);
const int required_mode = BKE_subsurf_modifier_eval_required_mode(is_render_mode, is_editmode); const int required_mode = BKE_subsurf_modifier_eval_required_mode(is_render_mode, is_editmode);
if (BKE_subsurf_modifier_can_do_gpu_subdiv(scene, ctx->object, mesh, smd, required_mode)) { if (BKE_subsurf_modifier_can_do_gpu_subdiv(scene, ctx->object, mesh, smd, required_mode)) {
subdiv_cache_mesh_wrapper_settings(ctx, mesh, smd, runtime_data); subdiv_cache_mesh_wrapper_settings(ctx, mesh, smd, runtime_data);
return result; return result;
} }
} }
Subdiv *subdiv = BKE_subsurf_modifier_subdiv_descriptor_ensure(runtime_data, mesh, false); Subdiv *subdiv = BKE_subsurf_modifier_subdiv_descriptor_ensure(runtime_data, mesh, false);
if (subdiv == NULL) { if (subdiv == nullptr) {
/* Happens on bad topology, but also on empty input mesh. */ /* Happens on bad topology, but also on empty input mesh. */
return result; return result;
} }
const bool use_clnors = BKE_subsurf_modifier_use_custom_loop_normals(smd, mesh); const bool use_clnors = BKE_subsurf_modifier_use_custom_loop_normals(smd, mesh);
if (use_clnors) { if (use_clnors) {
/* If custom normals are present and the option is turned on calculate the split /* If custom normals are present and the option is turned on calculate the split
* normals and clear flag so the normals get interpolated to the result mesh. */ * normals and clear flag so the normals get interpolated to the result mesh. */
BKE_mesh_calc_normals_split(mesh); BKE_mesh_calc_normals_split(mesh);
CustomData_clear_layer_flag(&mesh->ldata, CD_NORMAL, CD_FLAG_TEMPORARY); CustomData_clear_layer_flag(&mesh->ldata, CD_NORMAL, CD_FLAG_TEMPORARY);
} }
/* TODO(sergey): Decide whether we ever want to use CCG for subsurf, /* TODO(sergey): Decide whether we ever want to use CCG for subsurf,
* maybe when it is a last modifier in the stack? */ * maybe when it is a last modifier in the stack? */
if (true) { if (true) {
result = subdiv_as_mesh(smd, ctx, mesh, subdiv); result = subdiv_as_mesh(smd, ctx, mesh, subdiv);
} }
else { else {
result = subdiv_as_ccg(smd, ctx, mesh, subdiv); result = subdiv_as_ccg(smd, ctx, mesh, subdiv);
} }
if (use_clnors) { if (use_clnors) {
float(*lnors)[3] = CustomData_get_layer(&result->ldata, CD_NORMAL); float(*lnors)[3] = static_cast<float(*)[3]>(CustomData_get_layer(&result->ldata, CD_NORMAL));
BLI_assert(lnors != NULL); BLI_assert(lnors != nullptr);
BKE_mesh_set_custom_normals(result, lnors); BKE_mesh_set_custom_normals(result, lnors);
CustomData_set_layer_flag(&mesh->ldata, CD_NORMAL, CD_FLAG_TEMPORARY); CustomData_set_layer_flag(&mesh->ldata, CD_NORMAL, CD_FLAG_TEMPORARY);
CustomData_set_layer_flag(&result->ldata, CD_NORMAL, CD_FLAG_TEMPORARY); CustomData_set_layer_flag(&result->ldata, CD_NORMAL, CD_FLAG_TEMPORARY);
} }
// BKE_subdiv_stats_print(&subdiv->stats); // BKE_subdiv_stats_print(&subdiv->stats);
if (subdiv != runtime_data->subdiv) { if (subdiv != runtime_data->subdiv) {
BKE_subdiv_free(subdiv); BKE_subdiv_free(subdiv);
} }
Show All 16 Lines#endif
(void)deform_matrices; (void)deform_matrices;
SubsurfModifierData *smd = (SubsurfModifierData *)md; SubsurfModifierData *smd = (SubsurfModifierData *)md;
if (!BKE_subsurf_modifier_runtime_init(smd, (ctx->flag & MOD_APPLY_RENDER) != 0)) { if (!BKE_subsurf_modifier_runtime_init(smd, (ctx->flag & MOD_APPLY_RENDER) != 0)) {
return; return;
} }
SubsurfRuntimeData *runtime_data = (SubsurfRuntimeData *)smd->modifier.runtime; SubsurfRuntimeData *runtime_data = (SubsurfRuntimeData *)smd->modifier.runtime;
Subdiv *subdiv = BKE_subsurf_modifier_subdiv_descriptor_ensure(runtime_data, mesh, false); Subdiv *subdiv = BKE_subsurf_modifier_subdiv_descriptor_ensure(runtime_data, mesh, false);
if (subdiv == NULL) { if (subdiv == nullptr) {
/* Happens on bad topology, but also on empty input mesh. */ /* Happens on bad topology, but also on empty input mesh. */
return; return;
} }
BKE_subdiv_deform_coarse_vertices(subdiv, mesh, vertex_cos, verts_num); BKE_subdiv_deform_coarse_vertices(subdiv, mesh, vertex_cos, verts_num);
if (subdiv != runtime_data->subdiv) { if (subdiv != runtime_data->subdiv) {
BKE_subdiv_free(subdiv); BKE_subdiv_free(subdiv);
} }
} }
#ifdef WITH_CYCLES #ifdef WITH_CYCLES
static bool get_show_adaptive_options(const bContext *C, Panel *panel) static bool get_show_adaptive_options(const bContext *C, Panel *panel)
{ {
/* Don't show adaptive options if cycles isn't the active engine. */ /* Don't show adaptive options if cycles isn't the active engine. */
const struct RenderEngineType *engine_type = CTX_data_engine_type(C); const struct RenderEngineType *engine_type = CTX_data_engine_type(C);
if (!STREQ(engine_type->idname, "CYCLES")) { if (!STREQ(engine_type->idname, "CYCLES")) {
return false; return false;
} }
/* Only show adaptive options if this is the last modifier. */ /* Only show adaptive options if this is the last modifier. */
PointerRNA *ptr = modifier_panel_get_property_pointers(panel, NULL); PointerRNA *ptr = modifier_panel_get_property_pointers(panel, nullptr);
ModifierData *md = ptr->data; ModifierData *md = static_cast<ModifierData *>(ptr->data);
if (md->next != NULL) { if (md->next != nullptr) {
return false; return false;
} }
/* Don't show adaptive options if regular subdivision used. */ /* Don't show adaptive options if regular subdivision used. */
if (!RNA_boolean_get(ptr, "use_limit_surface")) { if (!RNA_boolean_get(ptr, "use_limit_surface")) {
return false; return false;
} }
Show All 12 Linesstatic void panel_draw(const bContext *C, Panel *panel)
uiLayout *layout = panel->layout; uiLayout *layout = panel->layout;
PointerRNA ob_ptr; PointerRNA ob_ptr;
PointerRNA *ptr = modifier_panel_get_property_pointers(panel, &ob_ptr); PointerRNA *ptr = modifier_panel_get_property_pointers(panel, &ob_ptr);
/* Only test for adaptive subdivision if built with cycles. */ /* Only test for adaptive subdivision if built with cycles. */
bool show_adaptive_options = false; bool show_adaptive_options = false;
bool ob_use_adaptive_subdivision = false; bool ob_use_adaptive_subdivision = false;
PointerRNA cycles_ptr = {NULL}; PointerRNA cycles_ptr = {nullptr};
PointerRNA ob_cycles_ptr = {NULL}; PointerRNA ob_cycles_ptr = {nullptr};
#ifdef WITH_CYCLES #ifdef WITH_CYCLES
PointerRNA scene_ptr; PointerRNA scene_ptr;
Scene *scene = CTX_data_scene(C); Scene *scene = CTX_data_scene(C);
RNA_id_pointer_create(&scene->id, &scene_ptr); RNA_id_pointer_create(&scene->id, &scene_ptr);
if (BKE_scene_uses_cycles(scene)) { if (BKE_scene_uses_cycles(scene)) {
cycles_ptr = RNA_pointer_get(&scene_ptr, "cycles"); cycles_ptr = RNA_pointer_get(&scene_ptr, "cycles");
ob_cycles_ptr = RNA_pointer_get(&ob_ptr, "cycles"); ob_cycles_ptr = RNA_pointer_get(&ob_ptr, "cycles");
if (!RNA_pointer_is_null(&ob_cycles_ptr)) { if (!RNA_pointer_is_null(&ob_cycles_ptr)) {
ob_use_adaptive_subdivision = RNA_boolean_get(&ob_cycles_ptr, "use_adaptive_subdivision"); ob_use_adaptive_subdivision = RNA_boolean_get(&ob_cycles_ptr, "use_adaptive_subdivision");
show_adaptive_options = get_show_adaptive_options(C, panel); show_adaptive_options = get_show_adaptive_options(C, panel);
} }
} }
#else #else
UNUSED_VARS(C); UNUSED_VARS(C);
#endif #endif
uiItemR(layout, ptr, "subdivision_type", UI_ITEM_R_EXPAND, NULL, ICON_NONE); uiItemR(layout, ptr, "subdivision_type", UI_ITEM_R_EXPAND, nullptr, ICON_NONE);
uiLayoutSetPropSep(layout, true); uiLayoutSetPropSep(layout, true);
if (show_adaptive_options) { if (show_adaptive_options) {
uiItemR(layout, uiItemR(layout,
&ob_cycles_ptr, &ob_cycles_ptr,
"use_adaptive_subdivision", "use_adaptive_subdivision",
0, 0,
IFACE_("Adaptive Subdivision"), IFACE_("Adaptive Subdivision"),
ICON_NONE); ICON_NONE);
} }
if (ob_use_adaptive_subdivision && show_adaptive_options) { if (ob_use_adaptive_subdivision && show_adaptive_options) {
uiItemR(layout, &ob_cycles_ptr, "dicing_rate", 0, NULL, ICON_NONE); uiItemR(layout, &ob_cycles_ptr, "dicing_rate", 0, nullptr, ICON_NONE);
float render = MAX2(RNA_float_get(&cycles_ptr, "dicing_rate") * float render = MAX2(RNA_float_get(&cycles_ptr, "dicing_rate") *
RNA_float_get(&ob_cycles_ptr, "dicing_rate"), RNA_float_get(&ob_cycles_ptr, "dicing_rate"),
0.1f); 0.1f);
float preview = MAX2(RNA_float_get(&cycles_ptr, "preview_dicing_rate") * float preview = MAX2(RNA_float_get(&cycles_ptr, "preview_dicing_rate") *
RNA_float_get(&ob_cycles_ptr, "dicing_rate"), RNA_float_get(&ob_cycles_ptr, "dicing_rate"),
0.1f); 0.1f);
char output[256]; char output[256];
BLI_snprintf(output, BLI_snprintf(output,
sizeof(output), sizeof(output),
TIP_("Final Scale: Render %.2f px, Viewport %.2f px"), TIP_("Final Scale: Render %.2f px, Viewport %.2f px"),
render, render,
preview); preview);
uiItemL(layout, output, ICON_NONE); uiItemL(layout, output, ICON_NONE);
uiItemS(layout); uiItemS(layout);
uiItemR(layout, ptr, "levels", 0, IFACE_("Levels Viewport"), ICON_NONE); uiItemR(layout, ptr, "levels", 0, IFACE_("Levels Viewport"), ICON_NONE);
} }
else { else {
uiLayout *col = uiLayoutColumn(layout, true); uiLayout *col = uiLayoutColumn(layout, true);
uiItemR(col, ptr, "levels", 0, IFACE_("Levels Viewport"), ICON_NONE); uiItemR(col, ptr, "levels", 0, IFACE_("Levels Viewport"), ICON_NONE);
uiItemR(col, ptr, "render_levels", 0, IFACE_("Render"), ICON_NONE); uiItemR(col, ptr, "render_levels", 0, IFACE_("Render"), ICON_NONE);
} }
uiItemR(layout, ptr, "show_only_control_edges", 0, NULL, ICON_NONE); uiItemR(layout, ptr, "show_only_control_edges", 0, nullptr, ICON_NONE);
SubsurfModifierData *smd = ptr->data; SubsurfModifierData *smd = static_cast<SubsurfModifierData *>(ptr->data);
Object *ob = ob_ptr.data; const Object *ob = static_cast<const Object *>(ob_ptr.data);
Mesh *mesh = ob->data; const Mesh *mesh = static_cast<const Mesh *>(ob->data);
if (BKE_subsurf_modifier_force_disable_gpu_evaluation_for_mesh(smd, mesh)) { if (BKE_subsurf_modifier_force_disable_gpu_evaluation_for_mesh(smd, mesh)) {
uiItemL(layout, "Autosmooth or custom normals detected, disabling GPU subdivision", ICON_INFO); uiItemL(layout, "Autosmooth or custom normals detected, disabling GPU subdivision", ICON_INFO);
} }
modifier_panel_end(layout, ptr); modifier_panel_end(layout, ptr);
} }
static void advanced_panel_draw(const bContext *C, Panel *panel) static void advanced_panel_draw(const bContext *C, Panel *panel)
Show All 16 Lines#ifdef WITH_CYCLES
} }
#else #else
UNUSED_VARS(C); UNUSED_VARS(C);
#endif #endif
uiLayoutSetPropSep(layout, true); uiLayoutSetPropSep(layout, true);
uiLayoutSetActive(layout, !(show_adaptive_options && ob_use_adaptive_subdivision)); uiLayoutSetActive(layout, !(show_adaptive_options && ob_use_adaptive_subdivision));
uiItemR(layout, ptr, "use_limit_surface", 0, NULL, ICON_NONE); uiItemR(layout, ptr, "use_limit_surface", 0, nullptr, ICON_NONE);
uiLayout *col = uiLayoutColumn(layout, true); uiLayout *col = uiLayoutColumn(layout, true);
uiLayoutSetActive(col, RNA_boolean_get(ptr, "use_limit_surface")); uiLayoutSetActive(col, RNA_boolean_get(ptr, "use_limit_surface"));
uiItemR(col, ptr, "quality", 0, NULL, ICON_NONE); uiItemR(col, ptr, "quality", 0, nullptr, ICON_NONE);
uiItemR(layout, ptr, "uv_smooth", 0, NULL, ICON_NONE); uiItemR(layout, ptr, "uv_smooth", 0, nullptr, ICON_NONE);
uiItemR(layout, ptr, "boundary_smooth", 0, NULL, ICON_NONE); uiItemR(layout, ptr, "boundary_smooth", 0, nullptr, ICON_NONE);
uiItemR(layout, ptr, "use_creases", 0, NULL, ICON_NONE); uiItemR(layout, ptr, "use_creases", 0, nullptr, ICON_NONE);
uiItemR(layout, ptr, "use_custom_normals", 0, NULL, ICON_NONE); uiItemR(layout, ptr, "use_custom_normals", 0, nullptr, ICON_NONE);
} }
static void panelRegister(ARegionType *region_type) static void panelRegister(ARegionType *region_type)
{ {
PanelType *panel_type = modifier_panel_register(region_type, eModifierType_Subsurf, panel_draw); PanelType *panel_type = modifier_panel_register(region_type, eModifierType_Subsurf, panel_draw);
modifier_subpanel_register( modifier_subpanel_register(
region_type, "advanced", "Advanced", NULL, advanced_panel_draw, panel_type); region_type, "advanced", "Advanced", nullptr, advanced_panel_draw, panel_type);
} }
static void blendRead(BlendDataReader *UNUSED(reader), ModifierData *md) static void blendRead(BlendDataReader *UNUSED(reader), ModifierData *md)
{ {
SubsurfModifierData *smd = (SubsurfModifierData *)md; SubsurfModifierData *smd = (SubsurfModifierData *)md;
smd->emCache = smd->mCache = NULL; smd->emCache = smd->mCache = nullptr;
} }
ModifierTypeInfo modifierType_Subsurf = { ModifierTypeInfo modifierType_Subsurf = {
/* name */ N_("Subdivision"), /* name */ N_("Subdivision"),
/* structName */ "SubsurfModifierData", /* structName */ "SubsurfModifierData",
/* structSize */ sizeof(SubsurfModifierData), /* structSize */ sizeof(SubsurfModifierData),
/* srna */ &RNA_SubsurfModifier, /* srna */ &RNA_SubsurfModifier,
/* type */ eModifierTypeType_Constructive, /* type */ eModifierTypeType_Constructive,
/* flags */ eModifierTypeFlag_AcceptsMesh | eModifierTypeFlag_SupportsMapping | /* flags */ eModifierTypeFlag_AcceptsMesh | eModifierTypeFlag_SupportsMapping |
eModifierTypeFlag_SupportsEditmode | eModifierTypeFlag_EnableInEditmode | eModifierTypeFlag_SupportsEditmode | eModifierTypeFlag_EnableInEditmode |
eModifierTypeFlag_AcceptsCVs, eModifierTypeFlag_AcceptsCVs,
/* icon */ ICON_MOD_SUBSURF, /* icon */ ICON_MOD_SUBSURF,
/* copyData */ copyData, /* copyData */ copyData,
/* deformVerts */ NULL, /* deformVerts */ nullptr,
/* deformMatrices */ deformMatrices, /* deformMatrices */ deformMatrices,
/* deformVertsEM */ NULL, /* deformVertsEM */ nullptr,
/* deformMatricesEM */ NULL, /* deformMatricesEM */ nullptr,
/* modifyMesh */ modifyMesh, /* modifyMesh */ modifyMesh,
/* modifyGeometrySet */ NULL, /* modifyGeometrySet */ nullptr,
/* initData */ initData, /* initData */ initData,
/* requiredDataMask */ requiredDataMask, /* requiredDataMask */ requiredDataMask,
/* freeData */ freeData, /* freeData */ freeData,
/* isDisabled */ isDisabled, /* isDisabled */ isDisabled,
/* updateDepsgraph */ NULL, /* updateDepsgraph */ nullptr,
/* dependsOnTime */ NULL, /* dependsOnTime */ nullptr,
/* dependsOnNormals */ dependsOnNormals, /* dependsOnNormals */ dependsOnNormals,
/* foreachIDLink */ NULL, /* foreachIDLink */ nullptr,
/* foreachTexLink */ NULL, /* foreachTexLink */ nullptr,
/* freeRuntimeData */ freeRuntimeData, /* freeRuntimeData */ freeRuntimeData,
/* panelRegister */ panelRegister, /* panelRegister */ panelRegister,
/* blendWrite */ NULL, /* blendWrite */ nullptr,
/* blendRead */ blendRead, /* blendRead */ blendRead,
}; };