Blender V5.3
MOD_meshcache.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include "BLI_utildefines.hh"
10
11#include "BLI_math_matrix_c.hh"
13#include "BLI_math_vector_c.hh"
14#include "BLI_path_utils.hh"
15#include "BLI_string.hh"
16
17#include "BLT_translation.hh"
18
19#include "DNA_mesh_types.h"
20#include "DNA_meshdata_types.h"
21#include "DNA_object_types.h"
22#include "DNA_scene_types.h"
23#include "DNA_screen_types.h"
24
25#include "BKE_deform.hh"
26#include "BKE_library.hh"
27#include "BKE_main.hh"
28#include "BKE_mesh.hh"
29#include "BKE_scene.hh"
30
32#include "UI_resources.hh"
33
34#include "RNA_access.hh"
35#include "RNA_prototypes.hh"
36
38
39#include "MEM_guardedalloc.h"
40
41#include "MOD_meshcache_util.hh" /* utility functions */
42#include "MOD_modifiertypes.hh"
43#include "MOD_ui_common.hh"
44#include "MOD_util.hh"
45
46namespace blender {
47
48static void init_data(ModifierData *md)
49{
50 MeshCacheModifierData *mcmd = reinterpret_cast<MeshCacheModifierData *>(md);
52}
53
54static bool depends_on_time(Scene * /*scene*/, ModifierData *md)
55{
56 MeshCacheModifierData *mcmd = reinterpret_cast<MeshCacheModifierData *>(md);
57 return (mcmd->play_mode == MOD_MESHCACHE_PLAY_CFEA);
58}
59
60static bool is_disabled(const Scene * /*scene*/, ModifierData *md, bool /*use_render_params*/)
61{
62 MeshCacheModifierData *mcmd = reinterpret_cast<MeshCacheModifierData *>(md);
63
64 /* leave it up to the modifier to check the file is valid on calculation */
65 return (mcmd->factor <= 0.0f) || (mcmd->filepath[0] == '\0');
66}
67
69 Scene *scene,
70 Object *ob,
71 Mesh *mesh,
72 float (*vertexCos_Real)[3],
73 int verts_num)
74{
75 const bool use_factor = mcmd->factor < 1.0f;
76 int influence_group_index;
77 const MDeformVert *dvert;
78 MOD_get_vgroup(ob, mesh, mcmd->defgrp_name, &dvert, &influence_group_index);
79
80 float (*vertexCos_Store)[3] = (use_factor || influence_group_index != -1 ||
82 MEM_new_array_uninitialized<float[3]>(size_t(verts_num),
83 __func__) :
84 nullptr;
85 float (*vertexCos)[3] = vertexCos_Store ? vertexCos_Store : vertexCos_Real;
86
87 const float fps = scene->frames_per_second();
88
89 char filepath[FILE_MAX];
90 const char *err_str = nullptr;
91 bool ok;
92
93 float time;
94
95 /* -------------------------------------------------------------------- */
96 /* Interpret Time (the reading functions also do some of this). */
98 const float ctime = BKE_scene_ctime_get(scene);
99
100 switch (mcmd->time_mode) {
102 time = ctime;
103 break;
104 }
106 time = ctime / fps;
107 break;
108 }
110 default: {
111 time = ctime / fps;
112 break;
113 }
114 }
115
116 /* apply offset and scale */
117 time = (mcmd->frame_scale * time) - mcmd->frame_start;
118 }
119 else { /* `if (mcmd->play_mode == MOD_MESHCACHE_PLAY_EVAL) {`. */
120 switch (mcmd->time_mode) {
122 time = mcmd->eval_frame;
123 break;
124 }
126 time = mcmd->eval_time;
127 break;
128 }
130 default: {
131 time = mcmd->eval_factor;
132 break;
133 }
134 }
135 }
136
137 /* -------------------------------------------------------------------- */
138 /* Read the File (or error out when the file is bad) */
139
140 /* would be nice if we could avoid doing this _every_ frame */
141 STRNCPY(filepath, mcmd->filepath);
142 BLI_path_abs(filepath, ID_BLEND_PATH_FROM_GLOBAL((ID *)ob));
143
144 switch (mcmd->type) {
147 filepath, vertexCos, verts_num, mcmd->interp, time, fps, mcmd->time_mode, &err_str);
148 break;
151 filepath, vertexCos, verts_num, mcmd->interp, time, fps, mcmd->time_mode, &err_str);
152 break;
153 default:
154 ok = false;
155 break;
156 }
157
158 /* -------------------------------------------------------------------- */
159 /* tricky shape key integration (slow!) */
161 Mesh *mesh = id_cast<Mesh *>(ob->data);
162
163 /* we could support any object type */
164 if (ob->type != OB_MESH) [[unlikely]] {
165 BKE_modifier_set_error(ob, &mcmd->modifier, "'Integrate' only valid for Mesh objects");
166 }
167 else if (mesh->verts_num != verts_num) [[unlikely]] {
168 BKE_modifier_set_error(ob, &mcmd->modifier, "'Integrate' original mesh vertex mismatch");
169 }
170 else if (mesh->faces_num == 0) [[unlikely]] {
171 BKE_modifier_set_error(ob, &mcmd->modifier, "'Integrate' requires faces");
172 }
173 else {
174 float (*vertexCos_New)[3] = MEM_new_array_uninitialized<float[3]>(size_t(verts_num),
175 __func__);
176
178 mesh->face_offsets().data(),
179 mesh->faces_num,
180 mesh->corner_verts().data(),
181 mesh->verts_num,
182 /* From the original Mesh. */
183 reinterpret_cast<const float (*)[3]>(mesh->vert_positions().data()),
184 /* the input we've been given (shape keys!) */
185 const_cast<const float (*)[3]>(vertexCos_Real),
186 /* The result of this modifier. */
187 const_cast<const float (*)[3]>(vertexCos),
188 /* The result of this function. */
189 vertexCos_New);
190
191 /* write the corrected locations back into the result */
192 memcpy(vertexCos, vertexCos_New, sizeof(*vertexCos) * verts_num);
193
194 MEM_delete(vertexCos_New);
195 }
196 }
197
198 /* -------------------------------------------------------------------- */
199 /* Apply the transformation matrix (if needed) */
200 if (err_str) [[unlikely]] {
201 BKE_modifier_set_error(ob, &mcmd->modifier, "%s", err_str);
202 }
203 else if (ok) {
204 bool use_matrix = false;
205 float mat[3][3];
206 unit_m3(mat);
207
208 if (mat3_from_axis_conversion(mcmd->forward_axis, mcmd->up_axis, 1, 2, mat)) {
209 use_matrix = true;
210 }
211
212 if (mcmd->flip_axis) {
213 float tmat[3][3];
214 unit_m3(tmat);
216 tmat[0][0] = -1.0f;
217 }
219 tmat[1][1] = -1.0f;
220 }
222 tmat[2][2] = -1.0f;
223 }
224 mul_m3_m3m3(mat, tmat, mat);
225
226 use_matrix = true;
227 }
228
229 if (use_matrix) {
230 int i;
231 for (i = 0; i < verts_num; i++) {
232 mul_m3_v3(mat, vertexCos[i]);
233 }
234 }
235 }
236
237 if (vertexCos_Store) {
238 if (ok) {
239 if (influence_group_index != -1) {
240 const float global_factor = (mcmd->flag & MOD_MESHCACHE_INVERT_VERTEX_GROUP) ?
241 -mcmd->factor :
242 mcmd->factor;
243 const float global_offset = (mcmd->flag & MOD_MESHCACHE_INVERT_VERTEX_GROUP) ?
244 mcmd->factor :
245 0.0f;
246 if (!mesh->deform_verts().is_empty()) {
247 for (int i = 0; i < verts_num; i++) {
248 /* For each vertex, compute its blending factor between the mesh cache (for `fac = 0`)
249 * and the former position of the vertex (for `fac = 1`). */
250 const MDeformVert *currentIndexDVert = dvert + i;
251 const float local_vertex_fac = global_offset +
252 BKE_defvert_find_weight(currentIndexDVert,
253 influence_group_index) *
254 global_factor;
256 vertexCos_Real[i], vertexCos_Real[i], vertexCos_Store[i], local_vertex_fac);
257 }
258 }
259 }
260 else if (use_factor) {
261 /* Influence_group_index is -1. */
262 interp_vn_vn(*vertexCos_Real, *vertexCos_Store, mcmd->factor, verts_num * 3);
263 }
264 else {
265 memcpy(vertexCos_Real, vertexCos_Store, sizeof(*vertexCos_Store) * verts_num);
266 }
267 }
268
269 MEM_delete(vertexCos_Store);
270 }
271}
272
274 const ModifierEvalContext *ctx,
275 Mesh *mesh,
276 MutableSpan<float3> positions)
277{
278 MeshCacheModifierData *mcmd = reinterpret_cast<MeshCacheModifierData *>(md);
280
281 meshcache_do(mcmd,
282 scene,
283 ctx->object,
284 mesh,
285 reinterpret_cast<float (*)[3]>(positions.data()),
286 positions.size());
287}
288
289static void panel_draw(const bContext * /*C*/, Panel *panel)
290{
291 ui::Layout &layout = *panel->layout;
292
293 PointerRNA ob_ptr;
295
296 layout.use_property_split_set(true);
297
298 layout.prop(ptr, "cache_format", UI_ITEM_NONE, std::nullopt, ICON_NONE);
299 layout.prop(ptr, "filepath", UI_ITEM_NONE, std::nullopt, ICON_NONE);
300
301 layout.prop(ptr, "factor", ui::ITEM_R_SLIDER, std::nullopt, ICON_NONE);
302 layout.prop(ptr, "deform_mode", UI_ITEM_NONE, std::nullopt, ICON_NONE);
303 layout.prop(ptr, "interpolation", UI_ITEM_NONE, std::nullopt, ICON_NONE);
304 modifier_vgroup_ui(layout, ptr, &ob_ptr, "vertex_group", "invert_vertex_group", std::nullopt);
305
306 modifier_error_message_draw(layout, ptr);
307}
308
309static void time_remapping_panel_draw(const bContext * /*C*/, Panel *panel)
310{
311 ui::Layout &layout = *panel->layout;
312
314
315 layout.prop(ptr, "time_mode", ui::ITEM_R_EXPAND, std::nullopt, ICON_NONE);
316
317 layout.use_property_split_set(true);
318
319 layout.prop(ptr, "play_mode", ui::ITEM_R_EXPAND, std::nullopt, ICON_NONE);
320
321 if (RNA_enum_get(ptr, "play_mode") == MOD_MESHCACHE_PLAY_CFEA) {
322 layout.prop(ptr, "frame_start", UI_ITEM_NONE, std::nullopt, ICON_NONE);
323 layout.prop(ptr, "frame_scale", UI_ITEM_NONE, std::nullopt, ICON_NONE);
324 }
325 else { /* play_mode == MOD_MESHCACHE_PLAY_EVAL */
326 int time_mode = RNA_enum_get(ptr, "time_mode");
327 if (time_mode == MOD_MESHCACHE_TIME_FRAME) {
328 layout.prop(ptr, "eval_frame", UI_ITEM_NONE, std::nullopt, ICON_NONE);
329 }
330 else if (time_mode == MOD_MESHCACHE_TIME_SECONDS) {
331 layout.prop(ptr, "eval_time", UI_ITEM_NONE, std::nullopt, ICON_NONE);
332 }
333 else { /* time_mode == MOD_MESHCACHE_TIME_FACTOR */
334 layout.prop(ptr, "eval_factor", UI_ITEM_NONE, std::nullopt, ICON_NONE);
335 }
336 }
337}
338
339static void axis_mapping_panel_draw(const bContext * /*C*/, Panel *panel)
340{
341 ui::Layout &layout = *panel->layout;
342
344
345 layout.use_property_split_set(true);
346
347 ui::Layout &col = layout.column(true);
348 col.red_alert_set(RNA_enum_get(ptr, "forward_axis") == RNA_enum_get(ptr, "up_axis"));
349 col.prop(ptr, "forward_axis", UI_ITEM_NONE, std::nullopt, ICON_NONE);
350 col.prop(ptr, "up_axis", UI_ITEM_NONE, std::nullopt, ICON_NONE);
351
353 PropertyRNA *prop = RNA_struct_find_property(ptr, "flip_axis");
354 ui::Layout &row = col.row(true, IFACE_("Flip Axis"));
355 row.prop(ptr, prop, 0, 0, toggles_flag, IFACE_("X"), ICON_NONE);
356 row.prop(ptr, prop, 1, 0, toggles_flag, IFACE_("Y"), ICON_NONE);
357 row.prop(ptr, prop, 2, 0, toggles_flag, IFACE_("Z"), ICON_NONE);
358}
359
360static void panel_register(ARegionType *region_type)
361{
363 region_type, eModifierType_MeshCache, panel_draw);
364 modifier_subpanel_register(region_type,
365 "time_remapping",
366 "Time Remapping",
367 nullptr,
369 panel_type);
371 region_type, "axis_mapping", "Axis Mapping", nullptr, axis_mapping_panel_draw, panel_type);
372}
373
375 /*idname*/ "MeshCache",
376 /*name*/ N_("MeshCache"),
377 /*struct_name*/ "MeshCacheModifierData",
378 /*struct_size*/ sizeof(MeshCacheModifierData),
379 /*srna*/ &RNA_MeshCacheModifier,
383 /*icon*/ ICON_MOD_MESHDEFORM, /* TODO: Use correct icon. */
384
385 /*copy_data*/ BKE_modifier_copydata_generic,
386
387 /*deform_verts*/ deform_verts,
388 /*deform_matrices*/ nullptr,
389 /*deform_verts_EM*/ nullptr,
390 /*deform_matrices_EM*/ nullptr,
391 /*modify_mesh*/ nullptr,
392 /*modify_geometry_set*/ nullptr,
393
394 /*init_data*/ init_data,
395 /*required_data_mask*/ nullptr,
396 /*free_data*/ nullptr,
397 /*is_disabled*/ is_disabled,
398 /*update_depsgraph*/ nullptr,
399 /*depends_on_time*/ depends_on_time,
400 /*depends_on_normals*/ nullptr,
401 /*foreach_ID_link*/ nullptr,
402 /*foreach_tex_link*/ nullptr,
403 /*free_runtime_data*/ nullptr,
404 /*panel_register*/ panel_register,
405 /*blend_write*/ nullptr,
406 /*blend_read*/ nullptr,
407 /*foreach_cache*/ nullptr,
408 /*foreach_working_space_color*/ nullptr,
409};
410
411} // namespace blender
support for deformation groups and hooks.
#define FILE_MAX
#define IFACE_(msgid)
#define ID_BLEND_PATH_FROM_GLOBAL(_id)
Definition DNA_ID.h:691
Object is a sort of wrapper for general info.
Read Blender memory allocation and freeing.
#define UI_ITEM_NONE
#define INIT_DEFAULT_STRUCT_AFTER(struct_dst, member)
constexpr int64_t size() const
Definition BLI_span.hh:499
constexpr T * data() const
Definition BLI_span.hh:545
BMesh Iterators.
void mul_m3_v3(const float M[3][3], float r[3])
ModifierTypeInfo modifierType_MeshCache
char * STRNCPY(char(&dst)[N], const char *src)
int RNA_enum_get(PointerRNA *ptr, const char *name)
void BKE_modifier_set_error(const Object *ob, ModifierData *md, const char *format,...) ATTR_PRINTF_FORMAT(3
PointerRNA * modifier_panel_get_property_pointers(Panel *panel, PointerRNA *r_ob_ptr)
PropertyRNA * RNA_struct_find_property(PointerRNA *ptr, const char *identifier)
void * MEM_new_array_uninitialized(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
bool BLI_path_abs(char path[FILE_MAX], const char *basepath) ATTR_NONNULL(1
static bool depends_on_time(Scene *, ModifierData *)
Definition MOD_build.cc:46
static void meshcache_do(MeshCacheModifierData *mcmd, Scene *scene, Object *ob, Mesh *mesh, float(*vertexCos_Real)[3], int verts_num)
void MOD_get_vgroup(const Object *ob, const Mesh *mesh, const char *name, const MDeformVert **dvert, int *defgrp_index)
Definition MOD_util.cc:158
@ MOD_MESHCACHE_INVERT_VERTEX_GROUP
static void init_data(ModifierData *md)
static void axis_mapping_panel_draw(const bContext *, Panel *panel)
void interp_vn_vn(float *array_tar, const float *array_src, float t, int size)
bool MOD_meshcache_read_mdd_times(const char *filepath, float(*vertexCos)[3], const int verts_tot, const char interp, const float time, const float fps, const char time_mode, const char **r_err_str)
void modifier_error_message_draw(ui::Layout &layout, PointerRNA *ptr)
float BKE_defvert_find_weight(const MDeformVert *dvert, int defgroup)
Definition deform.cc:779
void modifier_vgroup_ui(ui::Layout &layout, PointerRNA *ptr, PointerRNA *ob_ptr, const StringRefNull vgroup_prop, const std::optional< StringRefNull > invert_vgroup_prop, const std::optional< StringRefNull > text)
static void panel_register(ARegionType *region_type)
bool mat3_from_axis_conversion(int src_forward, int src_up, int dst_forward, int dst_up, float r_mat[3][3])
void interp_v3_v3v3(float r[3], const float a[3], const float b[3], float t)
void BKE_mesh_calc_relative_deform(const int *face_offsets, int faces_num, const int *corner_verts, int totvert, const float(*vert_cos_src)[3], const float(*vert_cos_dst)[3], const float(*vert_cos_org)[3], float(*vert_cos_new)[3])
@ eModifierTypeFlag_AcceptsCVs
@ eModifierTypeFlag_SupportsEditmode
@ eModifierTypeFlag_AcceptsVertexCosOnly
@ MOD_MESHCACHE_DEFORM_INTEGRATE
void unit_m3(float m[3][3])
float BKE_scene_ctime_get(const Scene *scene)
Definition scene.cc:2581
PanelType * modifier_panel_register(ARegionType *region_type, ModifierType type, PanelDrawFn draw)
static void panel_draw(const bContext *, Panel *panel)
static void time_remapping_panel_draw(const bContext *, Panel *panel)
PanelType * modifier_subpanel_register(ARegionType *region_type, const char *name, const char *label, PanelDrawFn draw_header, PanelDrawFn draw, PanelType *parent)
static void deform_verts(ModifierData *md, const ModifierEvalContext *ctx, Mesh *mesh, MutableSpan< float3 > positions)
void mul_m3_m3m3(float R[3][3], const float A[3][3], const float B[3][3])
static bool is_disabled(const Scene *, ModifierData *md, bool)
Scene * DEG_get_evaluated_scene(const Depsgraph *graph)
bool MOD_meshcache_read_pc2_times(const char *filepath, float(*vertexCos)[3], const int verts_tot, const char interp, const float time, const float fps, const char time_mode, const char **r_err_str)
void BKE_modifier_copydata_generic(const ModifierData *md, ModifierData *md_dst, int flag)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
MeshCacheModifierInterpolation interp
MeshCacheModifierDeformMode deform_mode
MeshCacheModifierPlayMode play_mode
MeshCacheModifierFlipAxis flip_axis
MeshCacheModifierTimeMode time_mode
ui::Layout * layout
void use_property_split_set(bool is_sep)
void prop(PointerRNA *ptr, PropertyRNA *prop, int index, int value, eUI_Item_Flag flag, std::optional< StringRef > name_opt, int icon, std::optional< StringRef > placeholder=std::nullopt)
void red_alert_set(bool red_alert)
Layout & column(bool align)
Layout & row(bool align)
#define N_(msgid)