Blender  V3.3
MOD_subsurf.c
Go to the documentation of this file.
1 /* SPDX-License-Identifier: GPL-2.0-or-later
2  * Copyright 2005 Blender Foundation. All rights reserved. */
3 
8 #include <stddef.h>
9 #include <stdio.h>
10 #include <string.h>
11 
12 #include "MEM_guardedalloc.h"
13 
14 #include "BLI_string.h"
15 #include "BLI_utildefines.h"
16 
17 #include "BLT_translation.h"
18 
19 #include "DNA_defaults.h"
20 #include "DNA_mesh_types.h"
21 #include "DNA_object_types.h"
22 #include "DNA_scene_types.h"
23 #include "DNA_screen_types.h"
24 
25 #include "BKE_context.h"
26 #include "BKE_editmesh.h"
27 #include "BKE_mesh.h"
28 #include "BKE_scene.h"
29 #include "BKE_screen.h"
30 #include "BKE_subdiv.h"
31 #include "BKE_subdiv_ccg.h"
32 #include "BKE_subdiv_deform.h"
33 #include "BKE_subdiv_mesh.h"
34 #include "BKE_subdiv_modifier.h"
35 #include "BKE_subsurf.h"
36 
37 #include "UI_interface.h"
38 #include "UI_resources.h"
39 
40 #include "RE_engine.h"
41 
42 #include "RNA_access.h"
43 #include "RNA_prototypes.h"
44 
45 #include "DEG_depsgraph.h"
46 #include "DEG_depsgraph_query.h"
47 
48 #include "MOD_modifiertypes.h"
49 #include "MOD_ui_common.h"
50 
51 #include "BLO_read_write.h"
52 
53 #include "intern/CCGSubSurf.h"
54 
55 static void initData(ModifierData *md)
56 {
58 
60 
62 }
63 
64 static void requiredDataMask(Object *UNUSED(ob),
65  ModifierData *md,
66  CustomData_MeshMasks *r_cddata_masks)
67 {
70  r_cddata_masks->lmask |= CD_MASK_NORMAL;
71  r_cddata_masks->lmask |= CD_MASK_CUSTOMLOOPNORMAL;
72  }
74  r_cddata_masks->vmask |= CD_MASK_CREASE;
75  }
76 }
77 
79 {
82  return true;
83  }
84  return false;
85 }
86 
87 static void copyData(const ModifierData *md, ModifierData *target, const int flag)
88 {
89 #if 0
90  const SubsurfModifierData *smd = (const SubsurfModifierData *)md;
91 #endif
92  SubsurfModifierData *tsmd = (SubsurfModifierData *)target;
93 
94  BKE_modifier_copydata_generic(md, target, flag);
95 
96  tsmd->emCache = tsmd->mCache = NULL;
97 }
98 
99 static void freeRuntimeData(void *runtime_data_v)
100 {
101  if (runtime_data_v == NULL) {
102  return;
103  }
104  SubsurfRuntimeData *runtime_data = (SubsurfRuntimeData *)runtime_data_v;
105  if (runtime_data->subdiv != NULL) {
106  BKE_subdiv_free(runtime_data->subdiv);
107  }
108  MEM_freeN(runtime_data);
109 }
110 
111 static void freeData(ModifierData *md)
112 {
114 
115  if (smd->mCache) {
116  ccgSubSurf_free(smd->mCache);
117  smd->mCache = NULL;
118  }
119  if (smd->emCache) {
120  ccgSubSurf_free(smd->emCache);
121  smd->emCache = NULL;
122  }
124 }
125 
126 static bool isDisabled(const Scene *scene, ModifierData *md, bool useRenderParams)
127 {
129  int levels = (useRenderParams) ? smd->renderLevels : smd->levels;
130 
131  return get_render_subsurf_level(&scene->r, levels, useRenderParams != 0) == 0;
132 }
133 
135  const ModifierEvalContext *ctx)
136 {
138  const bool use_render_params = (ctx->flag & MOD_APPLY_RENDER);
139  const int requested_levels = (use_render_params) ? smd->renderLevels : smd->levels;
140  return get_render_subsurf_level(&scene->r, requested_levels, use_render_params);
141 }
142 
143 /* Subdivide into fully qualified mesh. */
144 
146  const SubsurfModifierData *smd,
147  const ModifierEvalContext *ctx)
148 {
149  const int level = subdiv_levels_for_modifier_get(smd, ctx);
150  settings->resolution = (1 << level) + 1;
152  !(ctx->flag & MOD_APPLY_TO_BASE_MESH);
153 }
154 
156  const ModifierEvalContext *ctx,
157  Mesh *mesh,
158  Subdiv *subdiv)
159 {
160  Mesh *result = mesh;
161  SubdivToMeshSettings mesh_settings;
162  subdiv_mesh_settings_init(&mesh_settings, smd, ctx);
163  if (mesh_settings.resolution < 3) {
164  return result;
165  }
166  result = BKE_subdiv_to_mesh(subdiv, &mesh_settings, mesh);
167  return result;
168 }
169 
170 /* Subdivide into CCG. */
171 
173  const SubsurfModifierData *smd,
174  const ModifierEvalContext *ctx)
175 {
176  const int level = subdiv_levels_for_modifier_get(smd, ctx);
177  settings->resolution = (1 << level) + 1;
178  settings->need_normal = true;
179  settings->need_mask = false;
180 }
181 
183  const ModifierEvalContext *ctx,
184  Mesh *mesh,
185  Subdiv *subdiv)
186 {
187  Mesh *result = mesh;
188  SubdivToCCGSettings ccg_settings;
189  subdiv_ccg_settings_init(&ccg_settings, smd, ctx);
190  if (ccg_settings.resolution < 3) {
191  return result;
192  }
193  result = BKE_subdiv_to_ccg_mesh(subdiv, &ccg_settings, mesh);
194  return result;
195 }
196 
197 /* Cache settings for lazy CPU evaluation. */
198 
200  Mesh *mesh,
201  SubsurfModifierData *smd,
202  SubsurfRuntimeData *runtime_data)
203 {
204  SubdivToMeshSettings mesh_settings;
205  subdiv_mesh_settings_init(&mesh_settings, smd, ctx);
206 
207  runtime_data->has_gpu_subdiv = true;
208  runtime_data->resolution = mesh_settings.resolution;
209  runtime_data->use_optimal_display = mesh_settings.use_optimal_display;
210  runtime_data->calc_loop_normals = false; /* Set at the end of modifier stack evaluation. */
212 
213  mesh->runtime.subsurf_runtime_data = runtime_data;
214 }
215 
216 /* Modifier itself. */
217 
219 {
220  Mesh *result = mesh;
221 #if !defined(WITH_OPENSUBDIV)
222  BKE_modifier_set_error(ctx->object, md, "Disabled, built without OpenSubdiv");
223  return result;
224 #endif
226  if (!BKE_subsurf_modifier_runtime_init(smd, (ctx->flag & MOD_APPLY_RENDER) != 0)) {
227  return result;
228  }
229 
230  SubsurfRuntimeData *runtime_data = (SubsurfRuntimeData *)smd->modifier.runtime;
231 
232  /* Delay evaluation to the draw code if possible, provided we do not have to apply the modifier.
233  */
234  if ((ctx->flag & MOD_APPLY_TO_BASE_MESH) == 0) {
236  const bool is_render_mode = (ctx->flag & MOD_APPLY_RENDER) != 0;
237  /* Same check as in `DRW_mesh_batch_cache_create_requested` to keep both code coherent. The
238  * difference is that here we do not check for the final edit mesh pointer as it is not yet
239  * assigned at this stage of modifier stack evaluation. */
240  const bool is_editmode = (mesh->edit_mesh != NULL);
241  const int required_mode = BKE_subsurf_modifier_eval_required_mode(is_render_mode, is_editmode);
242  if (BKE_subsurf_modifier_can_do_gpu_subdiv(scene, ctx->object, mesh, smd, required_mode)) {
243  subdiv_cache_mesh_wrapper_settings(ctx, mesh, smd, runtime_data);
244  return result;
245  }
246  }
247 
248  Subdiv *subdiv = BKE_subsurf_modifier_subdiv_descriptor_ensure(runtime_data, mesh, false);
249  if (subdiv == NULL) {
250  /* Happens on bad topology, but also on empty input mesh. */
251  return result;
252  }
253  const bool use_clnors = BKE_subsurf_modifier_use_custom_loop_normals(smd, mesh);
254  if (use_clnors) {
255  /* If custom normals are present and the option is turned on calculate the split
256  * normals and clear flag so the normals get interpolated to the result mesh. */
259  }
260  /* TODO(sergey): Decide whether we ever want to use CCG for subsurf,
261  * maybe when it is a last modifier in the stack? */
262  if (true) {
263  result = subdiv_as_mesh(smd, ctx, mesh, subdiv);
264  }
265  else {
266  result = subdiv_as_ccg(smd, ctx, mesh, subdiv);
267  }
268 
269  if (use_clnors) {
270  float(*lnors)[3] = CustomData_get_layer(&result->ldata, CD_NORMAL);
271  BLI_assert(lnors != NULL);
275  }
276  // BKE_subdiv_stats_print(&subdiv->stats);
277  if (subdiv != runtime_data->subdiv) {
278  BKE_subdiv_free(subdiv);
279  }
280  return result;
281 }
282 
283 static void deformMatrices(ModifierData *md,
284  const ModifierEvalContext *ctx,
285  Mesh *mesh,
286  float (*vertex_cos)[3],
287  float (*deform_matrices)[3][3],
288  int verts_num)
289 {
290 #if !defined(WITH_OPENSUBDIV)
291  BKE_modifier_set_error(ctx->object, md, "Disabled, built without OpenSubdiv");
292  return;
293 #endif
294 
295  /* Subsurf does not require extra space mapping, keep matrices as is. */
296  (void)deform_matrices;
297 
299  if (!BKE_subsurf_modifier_runtime_init(smd, (ctx->flag & MOD_APPLY_RENDER) != 0)) {
300  return;
301  }
302  SubsurfRuntimeData *runtime_data = (SubsurfRuntimeData *)smd->modifier.runtime;
303  Subdiv *subdiv = BKE_subsurf_modifier_subdiv_descriptor_ensure(runtime_data, mesh, false);
304  if (subdiv == NULL) {
305  /* Happens on bad topology, but also on empty input mesh. */
306  return;
307  }
308  BKE_subdiv_deform_coarse_vertices(subdiv, mesh, vertex_cos, verts_num);
309  if (subdiv != runtime_data->subdiv) {
310  BKE_subdiv_free(subdiv);
311  }
312 }
313 
314 #ifdef WITH_CYCLES
315 static bool get_show_adaptive_options(const bContext *C, Panel *panel)
316 {
317  /* Don't show adaptive options if cycles isn't the active engine. */
318  const struct RenderEngineType *engine_type = CTX_data_engine_type(C);
319  if (!STREQ(engine_type->idname, "CYCLES")) {
320  return false;
321  }
322 
323  /* Only show adaptive options if this is the last modifier. */
325  ModifierData *md = ptr->data;
326  if (md->next != NULL) {
327  return false;
328  }
329 
330  /* Don't show adaptive options if regular subdivision used. */
331  if (!RNA_boolean_get(ptr, "use_limit_surface")) {
332  return false;
333  }
334 
335  /* Don't show adaptive options if the cycles experimental feature set is disabled. */
338  return false;
339  }
340 
341  return true;
342 }
343 #endif
344 
345 static void panel_draw(const bContext *C, Panel *panel)
346 {
347  uiLayout *layout = panel->layout;
348 
349  PointerRNA ob_ptr;
351 
352  /* Only test for adaptive subdivision if built with cycles. */
353  bool show_adaptive_options = false;
354  bool ob_use_adaptive_subdivision = false;
355  PointerRNA cycles_ptr = {NULL};
356  PointerRNA ob_cycles_ptr = {NULL};
357 #ifdef WITH_CYCLES
358  PointerRNA scene_ptr;
360  RNA_id_pointer_create(&scene->id, &scene_ptr);
362  cycles_ptr = RNA_pointer_get(&scene_ptr, "cycles");
363  ob_cycles_ptr = RNA_pointer_get(&ob_ptr, "cycles");
364  if (!RNA_pointer_is_null(&ob_cycles_ptr)) {
365  ob_use_adaptive_subdivision = RNA_boolean_get(&ob_cycles_ptr, "use_adaptive_subdivision");
366  show_adaptive_options = get_show_adaptive_options(C, panel);
367  }
368  }
369 #else
370  UNUSED_VARS(C);
371 #endif
372 
373  uiItemR(layout, ptr, "subdivision_type", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
374 
375  uiLayoutSetPropSep(layout, true);
376 
377  if (show_adaptive_options) {
378  uiItemR(layout,
379  &ob_cycles_ptr,
380  "use_adaptive_subdivision",
381  0,
382  IFACE_("Adaptive Subdivision"),
383  ICON_NONE);
384  }
385  if (ob_use_adaptive_subdivision && show_adaptive_options) {
386  uiItemR(layout, &ob_cycles_ptr, "dicing_rate", 0, NULL, ICON_NONE);
387  float render = MAX2(RNA_float_get(&cycles_ptr, "dicing_rate") *
388  RNA_float_get(&ob_cycles_ptr, "dicing_rate"),
389  0.1f);
390  float preview = MAX2(RNA_float_get(&cycles_ptr, "preview_dicing_rate") *
391  RNA_float_get(&ob_cycles_ptr, "dicing_rate"),
392  0.1f);
393  char output[256];
395  sizeof(output),
396  TIP_("Final Scale: Render %.2f px, Viewport %.2f px"),
397  render,
398  preview);
399  uiItemL(layout, output, ICON_NONE);
400 
401  uiItemS(layout);
402 
403  uiItemR(layout, ptr, "levels", 0, IFACE_("Levels Viewport"), ICON_NONE);
404  }
405  else {
406  uiLayout *col = uiLayoutColumn(layout, true);
407  uiItemR(col, ptr, "levels", 0, IFACE_("Levels Viewport"), ICON_NONE);
408  uiItemR(col, ptr, "render_levels", 0, IFACE_("Render"), ICON_NONE);
409  }
410 
411  uiItemR(layout, ptr, "show_only_control_edges", 0, NULL, ICON_NONE);
412 
413  SubsurfModifierData *smd = ptr->data;
414  Object *ob = ob_ptr.data;
415  Mesh *mesh = ob->data;
417  uiItemL(layout, "Autosmooth or custom normals detected, disabling GPU subdivision", ICON_INFO);
418  }
419 
420  modifier_panel_end(layout, ptr);
421 }
422 
423 static void advanced_panel_draw(const bContext *C, Panel *panel)
424 {
425  uiLayout *layout = panel->layout;
426 
427  PointerRNA ob_ptr;
429 
430  bool ob_use_adaptive_subdivision = false;
431  bool show_adaptive_options = false;
432 #ifdef WITH_CYCLES
435  PointerRNA ob_cycles_ptr = RNA_pointer_get(&ob_ptr, "cycles");
436  if (!RNA_pointer_is_null(&ob_cycles_ptr)) {
437  ob_use_adaptive_subdivision = RNA_boolean_get(&ob_cycles_ptr, "use_adaptive_subdivision");
438  show_adaptive_options = get_show_adaptive_options(C, panel);
439  }
440  }
441 #else
442  UNUSED_VARS(C);
443 #endif
444 
445  uiLayoutSetPropSep(layout, true);
446 
447  uiLayoutSetActive(layout, !(show_adaptive_options && ob_use_adaptive_subdivision));
448  uiItemR(layout, ptr, "use_limit_surface", 0, NULL, ICON_NONE);
449 
450  uiLayout *col = uiLayoutColumn(layout, true);
451  uiLayoutSetActive(col, RNA_boolean_get(ptr, "use_limit_surface"));
452  uiItemR(col, ptr, "quality", 0, NULL, ICON_NONE);
453 
454  uiItemR(layout, ptr, "uv_smooth", 0, NULL, ICON_NONE);
455  uiItemR(layout, ptr, "boundary_smooth", 0, NULL, ICON_NONE);
456  uiItemR(layout, ptr, "use_creases", 0, NULL, ICON_NONE);
457  uiItemR(layout, ptr, "use_custom_normals", 0, NULL, ICON_NONE);
458 }
459 
460 static void panelRegister(ARegionType *region_type)
461 {
464  region_type, "advanced", "Advanced", NULL, advanced_panel_draw, panel_type);
465 }
466 
467 static void blendRead(BlendDataReader *UNUSED(reader), ModifierData *md)
468 {
470 
471  smd->emCache = smd->mCache = NULL;
472 }
473 
475  /* name */ N_("Subdivision"),
476  /* structName */ "SubsurfModifierData",
477  /* structSize */ sizeof(SubsurfModifierData),
478  /* srna */ &RNA_SubsurfModifier,
483  /* icon */ ICON_MOD_SUBSURF,
484 
485  /* copyData */ copyData,
486 
487  /* deformVerts */ NULL,
488  /* deformMatrices */ deformMatrices,
489  /* deformVertsEM */ NULL,
490  /* deformMatricesEM */ NULL,
491  /* modifyMesh */ modifyMesh,
492  /* modifyGeometrySet */ NULL,
493 
494  /* initData */ initData,
495  /* requiredDataMask */ requiredDataMask,
496  /* freeData */ freeData,
497  /* isDisabled */ isDisabled,
498  /* updateDepsgraph */ NULL,
499  /* dependsOnTime */ NULL,
500  /* dependsOnNormals */ dependsOnNormals,
501  /* foreachIDLink */ NULL,
502  /* foreachTexLink */ NULL,
503  /* freeRuntimeData */ freeRuntimeData,
504  /* panelRegister */ panelRegister,
505  /* blendWrite */ NULL,
506  /* blendRead */ blendRead,
507 };
typedef float(TangentPoint)[2]
struct Scene * CTX_data_scene(const bContext *C)
Definition: context.c:1090
struct RenderEngineType * CTX_data_engine_type(const bContext *C)
Definition: context.c:1120
void CustomData_clear_layer_flag(struct CustomData *data, int type, int flag)
Definition: customdata.cc:2635
void * CustomData_get_layer(const struct CustomData *data, int type)
void CustomData_set_layer_flag(struct CustomData *data, int type, int flag)
Definition: customdata.cc:2626
void BKE_mesh_calc_normals_split(struct Mesh *mesh)
Definition: mesh.cc:1911
void BKE_mesh_set_custom_normals(struct Mesh *mesh, float(*r_custom_loopnors)[3])
@ eModifierTypeFlag_AcceptsCVs
Definition: BKE_modifier.h:67
@ eModifierTypeFlag_SupportsMapping
Definition: BKE_modifier.h:68
@ eModifierTypeFlag_EnableInEditmode
Definition: BKE_modifier.h:78
@ eModifierTypeFlag_SupportsEditmode
Definition: BKE_modifier.h:69
@ eModifierTypeFlag_AcceptsMesh
Definition: BKE_modifier.h:66
void BKE_modifier_copydata_generic(const struct ModifierData *md, struct ModifierData *md_dst, int flag)
@ eModifierTypeType_Constructive
Definition: BKE_modifier.h:47
void BKE_modifier_set_error(const struct Object *ob, struct ModifierData *md, const char *format,...) ATTR_PRINTF_FORMAT(3
@ MOD_APPLY_RENDER
Definition: BKE_modifier.h:115
@ MOD_APPLY_TO_BASE_MESH
Definition: BKE_modifier.h:128
bool BKE_scene_uses_cycles(const struct Scene *scene)
int get_render_subsurf_level(const struct RenderData *r, int lvl, bool for_render)
bool BKE_scene_uses_cycles_experimental_features(struct Scene *scene)
Definition: scene.cc:2871
void BKE_subdiv_free(Subdiv *subdiv)
Definition: subdiv.c:184
struct Mesh * BKE_subdiv_to_ccg_mesh(struct Subdiv *subdiv, const SubdivToCCGSettings *settings, const struct Mesh *coarse_mesh)
void BKE_subdiv_deform_coarse_vertices(struct Subdiv *subdiv, const struct Mesh *coarse_mesh, float(*vertex_cos)[3], int num_verts)
struct Mesh * BKE_subdiv_to_mesh(struct Subdiv *subdiv, const SubdivToMeshSettings *settings, const struct Mesh *coarse_mesh)
int BKE_subsurf_modifier_eval_required_mode(bool is_final_render, bool is_edit_mode)
bool BKE_subsurf_modifier_can_do_gpu_subdiv(const struct Scene *scene, const struct Object *ob, const struct Mesh *mesh, const struct SubsurfModifierData *smd, int required_mode)
bool BKE_subsurf_modifier_force_disable_gpu_evaluation_for_mesh(const struct SubsurfModifierData *smd, const struct Mesh *mesh)
struct Subdiv * BKE_subsurf_modifier_subdiv_descriptor_ensure(struct SubsurfRuntimeData *runtime_data, const struct Mesh *mesh, bool for_draw_code)
bool BKE_subsurf_modifier_use_custom_loop_normals(const struct SubsurfModifierData *smd, const struct Mesh *mesh)
bool BKE_subsurf_modifier_runtime_init(struct SubsurfModifierData *smd, bool use_render_params)
#define BLI_assert(a)
Definition: BLI_assert.h:46
size_t BLI_snprintf(char *__restrict dst, size_t maxncpy, const char *__restrict format,...) ATTR_NONNULL(1
#define UNUSED_VARS(...)
#define UNUSED(x)
#define MAX2(a, b)
#define MEMCMP_STRUCT_AFTER_IS_ZERO(struct_var, member)
#define MEMCPY_STRUCT_AFTER(struct_dst, struct_src, member)
#define STREQ(a, b)
#define TIP_(msgid)
#define IFACE_(msgid)
void ccgSubSurf_free(CCGSubSurf *ss)
Definition: CCGSubSurf.c:281
struct Scene * DEG_get_evaluated_scene(const struct Depsgraph *graph)
#define CD_MASK_NORMAL
@ CD_FLAG_TEMPORARY
#define CD_MASK_CUSTOMLOOPNORMAL
#define CD_MASK_CREASE
#define DNA_struct_default_get(struct_name)
Definition: DNA_defaults.h:29
@ eModifierType_Subsurf
struct SubsurfModifierData SubsurfModifierData
@ eSubsurfModifierFlag_UseCrease
@ eSubsurfModifierFlag_ControlEdges
@ eSubsurfModifierFlag_UseCustomNormals
Object is a sort of wrapper for general info.
Read Guarded memory(de)allocation.
static void blendRead(BlendDataReader *UNUSED(reader), ModifierData *md)
Definition: MOD_subsurf.c:467
static void copyData(const ModifierData *md, ModifierData *target, const int flag)
Definition: MOD_subsurf.c:87
static Mesh * modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *mesh)
Definition: MOD_subsurf.c:218
static void subdiv_mesh_settings_init(SubdivToMeshSettings *settings, const SubsurfModifierData *smd, const ModifierEvalContext *ctx)
Definition: MOD_subsurf.c:145
static bool dependsOnNormals(ModifierData *md)
Definition: MOD_subsurf.c:78
static void freeRuntimeData(void *runtime_data_v)
Definition: MOD_subsurf.c:99
static void subdiv_ccg_settings_init(SubdivToCCGSettings *settings, const SubsurfModifierData *smd, const ModifierEvalContext *ctx)
Definition: MOD_subsurf.c:172
static void deformMatrices(ModifierData *md, const ModifierEvalContext *ctx, Mesh *mesh, float(*vertex_cos)[3], float(*deform_matrices)[3][3], int verts_num)
Definition: MOD_subsurf.c:283
ModifierTypeInfo modifierType_Subsurf
Definition: MOD_subsurf.c:474
static void advanced_panel_draw(const bContext *C, Panel *panel)
Definition: MOD_subsurf.c:423
static Mesh * subdiv_as_ccg(SubsurfModifierData *smd, const ModifierEvalContext *ctx, Mesh *mesh, Subdiv *subdiv)
Definition: MOD_subsurf.c:182
static bool isDisabled(const Scene *scene, ModifierData *md, bool useRenderParams)
Definition: MOD_subsurf.c:126
static void initData(ModifierData *md)
Definition: MOD_subsurf.c:55
static void panelRegister(ARegionType *region_type)
Definition: MOD_subsurf.c:460
static int subdiv_levels_for_modifier_get(const SubsurfModifierData *smd, const ModifierEvalContext *ctx)
Definition: MOD_subsurf.c:134
static void freeData(ModifierData *md)
Definition: MOD_subsurf.c:111
static Mesh * subdiv_as_mesh(SubsurfModifierData *smd, const ModifierEvalContext *ctx, Mesh *mesh, Subdiv *subdiv)
Definition: MOD_subsurf.c:155
static void requiredDataMask(Object *UNUSED(ob), ModifierData *md, CustomData_MeshMasks *r_cddata_masks)
Definition: MOD_subsurf.c:64
static void panel_draw(const bContext *C, Panel *panel)
Definition: MOD_subsurf.c:345
static void subdiv_cache_mesh_wrapper_settings(const ModifierEvalContext *ctx, Mesh *mesh, SubsurfModifierData *smd, SubsurfRuntimeData *runtime_data)
Definition: MOD_subsurf.c:199
PointerRNA * modifier_panel_get_property_pointers(Panel *panel, PointerRNA *r_ob_ptr)
void modifier_panel_end(uiLayout *layout, PointerRNA *ptr)
Definition: MOD_ui_common.c:91
PanelType * modifier_panel_register(ARegionType *region_type, ModifierType type, PanelDrawFn draw)
PanelType * modifier_subpanel_register(ARegionType *region_type, const char *name, const char *label, PanelDrawFn draw_header, PanelDrawFn draw, PanelType *parent)
#define C
Definition: RandGen.cpp:25
void uiLayoutSetActive(uiLayout *layout, bool active)
uiLayout * uiLayoutColumn(uiLayout *layout, bool align)
void uiItemL(uiLayout *layout, const char *name, int icon)
void uiLayoutSetPropSep(uiLayout *layout, bool is_sep)
void uiItemS(uiLayout *layout)
@ UI_ITEM_R_EXPAND
void uiItemR(uiLayout *layout, struct PointerRNA *ptr, const char *propname, int flag, const char *name, int icon)
Scene scene
SyclQueue void void size_t num_bytes void
uint col
ccl_global KernelShaderEvalInput ccl_global float * output
void(* MEM_freeN)(void *vmemh)
Definition: mallocn.c:27
static const pxr::TfToken preview("preview", pxr::TfToken::Immortal)
PointerRNA RNA_pointer_get(PointerRNA *ptr, const char *name)
Definition: rna_access.c:5167
void RNA_id_pointer_create(ID *id, PointerRNA *r_ptr)
Definition: rna_access.c:112
float RNA_float_get(PointerRNA *ptr, const char *name)
Definition: rna_access.c:4957
bool RNA_pointer_is_null(const PointerRNA *ptr)
Definition: rna_access.c:164
bool RNA_boolean_get(PointerRNA *ptr, const char *name)
Definition: rna_access.c:4863
struct SubsurfRuntimeData * subsurf_runtime_data
struct BMEditMesh * edit_mesh
Mesh_Runtime runtime
CustomData ldata
struct ModifierData * next
struct Depsgraph * depsgraph
Definition: BKE_modifier.h:140
ModifierApplyFlag flag
Definition: BKE_modifier.h:142
struct Object * object
Definition: BKE_modifier.h:141
void * data
struct uiLayout * layout
void * data
Definition: RNA_types.h:38
void(* render)(struct RenderEngine *engine, struct Depsgraph *depsgraph)
Definition: RE_engine.h:78
char idname[64]
Definition: RE_engine.h:72
struct RenderData r
struct Subdiv * subdiv
#define N_(msgid)
PointerRNA * ptr
Definition: wm_files.c:3480