Mesh *BKE_mesh_create_derived_for_modifier(struct Depsgraph *depsgraph,
Scene *scene,
Object *ob_eval,
ModifierData *md_eval,
int build_shapekey_layers)
{
Mesh *me = ob_eval->runtime.mesh_orig ? ob_eval->runtime.mesh_orig : ob_eval->data;
const ModifierTypeInfo *mti = modifierType_getInfo(md_eval->type);
Mesh *result;
KeyBlock *kb;
ModifierEvalContext mectx = {depsgraph, ob_eval, 0};
if (!(md_eval->mode & eModifierMode_Realtime)) {
return NULL;
}
if (mti->isDisabled && mti->isDisabled(scene, md_eval, 0)) {
return NULL;
}
if (build_shapekey_layers && me->key &&
(kb = BLI_findlink(&me->key->block, ob_eval->shapenr - 1))) {
BKE_keyblock_convert_to_mesh(kb, me);
}
if (mti->type == eModifierTypeType_OnlyDeform) {
int numVerts;
float(*deformedVerts)[3] = BKE_mesh_vertexCos_get(me, &numVerts);
BKE_id_copy_ex(NULL, &me->id, (ID **)&result, LIB_ID_COPY_LOCALIZE);
mti->deformVerts(md_eval, &mectx, result, deformedVerts, numVerts);
BKE_mesh_apply_vert_coords(result, deformedVerts);
if (build_shapekey_layers) {
add_shapekey_layers(result, me);
}
MEM_freeN(deformedVerts);
}
else {
Mesh *mesh_temp;
BKE_id_copy_ex(NULL, &me->id, (ID **)&mesh_temp, LIB_ID_COPY_LOCALIZE);
if (build_shapekey_layers) {
add_shapekey_layers(mesh_temp, me);
}
result = mti->applyModifier(md_eval, &mectx, mesh_temp);
ASSERT_IS_VALID_MESH(result);
if (mesh_temp != result) {
BKE_id_free(NULL, mesh_temp);
}
}
return result;
}
/**
* Only copy internal data of Lattice ID from source
* to already allocated/initialized destination.
* You probably never want to use that directly,
* use #BKE_id_copy or #BKE_id_copy_ex for typical needs.
*
* WARNING! This function will not handle ID user count!
*
* \param flag: Copying options (see BKE_library.h's LIB_ID_COPY_... flags for more).
*/
void BKE_lattice_copy_data(Main *bmain, Lattice *lt_dst, const Lattice *lt_src, const int flag)
{
lt_dst->def = MEM_dupallocN(lt_src->def);
if (lt_src->key && (flag & LIB_ID_COPY_SHAPEKEY)) {
BKE_id_copy_ex(bmain, <_src->key->id, (ID **)<_dst->key, flag);
}
if (lt_src->dvert) {
int tot = lt_src->pntsu * lt_src->pntsv * lt_src->pntsw;
lt_dst->dvert = MEM_mallocN(sizeof(MDeformVert) * tot, "Lattice MDeformVert");
BKE_defvert_array_copy(lt_dst->dvert, lt_src->dvert, tot);
}
lt_dst->editlatt = NULL;
}
/**
* Only copy internal data of Light ID from source
* to already allocated/initialized destination.
* You probably never want to use that directly,
* use #BKE_id_copy or #BKE_id_copy_ex for typical needs.
*
* WARNING! This function will not handle ID user count!
*
* \param flag: Copying options (see BKE_library.h's LIB_ID_COPY_... flags for more).
*/
void BKE_light_copy_data(Main *bmain, Light *la_dst, const Light *la_src, const int flag)
{
la_dst->curfalloff = curvemapping_copy(la_src->curfalloff);
if (la_src->nodetree) {
/* Note: nodetree is *not* in bmain, however this specific case is handled at lower level
* (see BKE_libblock_copy_ex()). */
BKE_id_copy_ex(bmain, (ID *)la_src->nodetree, (ID **)&la_dst->nodetree, flag);
}
if ((flag & LIB_ID_COPY_NO_PREVIEW) == 0) {
BKE_previewimg_id_copy(&la_dst->id, &la_src->id);
}
else {
la_dst->preview = NULL;
}
}
/**
* Only copy internal data of Texture ID from source to already allocated/initialized destination.
* You probably nerver want to use that directly, use id_copy or BKE_id_copy_ex for typical needs.
*
* WARNING! This function will not handle ID user count!
*
* \param flag Copying options (see BKE_library.h's LIB_ID_COPY_... flags for more).
*/
void BKE_texture_copy_data(Main *bmain, Tex *tex_dst, const Tex *tex_src, const int flag)
{
/* We never handle usercount here for own data. */
const int flag_subdata = flag | LIB_ID_CREATE_NO_USER_REFCOUNT;
if (!BKE_texture_is_image_user(tex_src)) {
tex_dst->ima = NULL;
}
if (tex_dst->coba) {
tex_dst->coba = MEM_dupallocN(tex_dst->coba);
}
if (tex_dst->env) {
tex_dst->env = BKE_texture_envmap_copy(tex_dst->env, flag_subdata);
}
if (tex_dst->pd) {
tex_dst->pd = BKE_texture_pointdensity_copy(tex_dst->pd, flag_subdata);
}
if (tex_dst->vd) {
tex_dst->vd = MEM_dupallocN(tex_dst->vd);
}
if (tex_dst->ot) {
tex_dst->ot = BKE_texture_ocean_copy(tex_dst->ot, flag_subdata);
}
if (tex_src->nodetree) {
if (tex_src->nodetree->execdata) {
ntreeTexEndExecTree(tex_src->nodetree->execdata);
}
/* Note: nodetree is *not* in bmain, however this specific case is handled at lower level
* (see BKE_libblock_copy_ex()). */
BKE_id_copy_ex(bmain, (ID *)tex_src->nodetree, (ID **)&tex_dst->nodetree, flag, false);
}
if ((flag & LIB_ID_COPY_NO_PREVIEW) == 0) {
BKE_previewimg_id_copy(&tex_dst->id, &tex_src->id);
}
else {
tex_dst->preview = NULL;
}
}
Brush *BKE_brush_copy(Main *bmain, const Brush *brush)
{
Brush *brush_copy;
BKE_id_copy_ex(bmain, &brush->id, (ID **)&brush_copy, 0, false);
return brush_copy;
}
CacheFile *BKE_cachefile_copy(Main *bmain, const CacheFile *cache_file)
{
CacheFile *cache_file_copy;
BKE_id_copy_ex(bmain, &cache_file->id, (ID **)&cache_file_copy, 0, false);
return cache_file_copy;
}
/* settings: 1 - preview, 2 - render
*
* The convention goes as following:
*
* - Passing original object with apply_modifiers=false will give a
* non-modified non-deformed mesh.
* The result mesh will point to datablocks from the original "domain". For
* example, materials will be original.
*
* - Passing original object with apply_modifiers=true will give a mesh which
* has all modifiers applied.
* The result mesh will point to datablocks from the original "domain". For
* example, materials will be original.
*
* - Passing evaluated object will ignore apply_modifiers argument, and the
* result always contains all modifiers applied.
* The result mesh will point to an evaluated datablocks. For example,
* materials will be an evaluated IDs from the dependency graph.
*/
Mesh *BKE_mesh_new_from_object(Depsgraph *depsgraph,
Main *bmain,
Scene *sce,
Object *ob,
const bool apply_modifiers,
const bool calc_undeformed)
{
Mesh *tmpmesh;
Curve *tmpcu = NULL, *copycu;
int i;
const bool render = (DEG_get_mode(depsgraph) == DAG_EVAL_RENDER);
bool effective_apply_modifiers = apply_modifiers;
bool do_mat_id_data_us = true;
Object *object_input = ob;
Object *object_eval = DEG_get_evaluated_object(depsgraph, object_input);
Object object_for_eval;
if (object_eval == object_input) {
/* Evaluated mesh contains all modifiers applied already.
* The other types of object has them applied, but are stored in other
* data structures than a mesh. So need to apply modifiers again on a
* temporary copy before converting result to mesh. */
if (object_input->type == OB_MESH) {
effective_apply_modifiers = false;
}
else {
effective_apply_modifiers = true;
}
object_for_eval = *object_eval;
}
else {
if (apply_modifiers) {
object_for_eval = *object_eval;
if (object_for_eval.runtime.mesh_orig != NULL) {
object_for_eval.data = object_for_eval.runtime.mesh_orig;
}
}
else {
object_for_eval = *object_input;
}
}
const bool cage = !effective_apply_modifiers;
/* perform the mesh extraction based on type */
switch (object_for_eval.type) {
case OB_FONT:
case OB_CURVE:
case OB_SURF: {
ListBase dispbase = {NULL, NULL};
Mesh *me_eval_final = NULL;
int uv_from_orco;
/* copies object and modifiers (but not the data) */
Object *tmpobj;
BKE_id_copy_ex(NULL, &object_for_eval.id, (ID **)&tmpobj, LIB_ID_COPY_LOCALIZE);
tmpcu = (Curve *)tmpobj->data;
/* Copy cached display list, it might be needed by the stack evaluation.
* Ideally stack should be able to use render-time display list, but doing
* so is quite tricky and not safe so close to the release.
*
* TODO(sergey): Look into more proper solution.
*/
if (object_for_eval.runtime.curve_cache != NULL) {
if (tmpobj->runtime.curve_cache == NULL) {
tmpobj->runtime.curve_cache = MEM_callocN(sizeof(CurveCache),
"CurveCache for curve types");
}
BKE_displist_copy(&tmpobj->runtime.curve_cache->disp,
&object_for_eval.runtime.curve_cache->disp);
}
/* if getting the original caged mesh, delete object modifiers */
if (cage) {
BKE_object_free_modifiers(tmpobj, LIB_ID_CREATE_NO_USER_REFCOUNT);
}
/* copies the data, but *not* the shapekeys. */
BKE_id_copy_ex(NULL, object_for_eval.data, (ID **)©cu, LIB_ID_COPY_LOCALIZE);
tmpobj->data = copycu;
/* make sure texture space is calculated for a copy of curve,
* it will be used for the final result.
*/
BKE_curve_texspace_calc(copycu);
/* temporarily set edit so we get updates from edit mode, but
* also because for text datablocks copying it while in edit
* mode gives invalid data structures */
copycu->editfont = tmpcu->editfont;
copycu->editnurb = tmpcu->editnurb;
/* get updated display list, and convert to a mesh */
BKE_displist_make_curveTypes_forRender(
depsgraph, sce, tmpobj, &dispbase, &me_eval_final, false, NULL);
copycu->editfont = NULL;
copycu->editnurb = NULL;
tmpobj->runtime.mesh_eval = me_eval_final;
/* convert object type to mesh */
uv_from_orco = (tmpcu->flag & CU_UV_ORCO) != 0;
BKE_mesh_from_nurbs_displist(
bmain, tmpobj, &dispbase, uv_from_orco, tmpcu->id.name + 2, true);
/* Function above also frees copycu (aka tmpobj->data), make this obvious here. */
copycu = NULL;
tmpmesh = tmpobj->data;
id_us_min(
&tmpmesh->id); /* Gets one user from its creation in BKE_mesh_from_nurbs_displist(). */
BKE_displist_free(&dispbase);
/* BKE_mesh_from_nurbs changes the type to a mesh, check it worked.
* if it didn't the curve did not have any segments or otherwise
* would have generated an empty mesh */
if (tmpobj->type != OB_MESH) {
BKE_id_free(NULL, tmpobj);
return NULL;
}
BKE_id_free(NULL, tmpobj);
/* XXX The curve to mesh conversion is convoluted...
* But essentially, BKE_mesh_from_nurbs_displist()
* already transfers the ownership of materials from the temp copy of the Curve ID to the
* new Mesh ID, so we do not want to increase materials' usercount later. */
do_mat_id_data_us = false;
break;
}
case OB_MBALL: {
/* metaballs don't have modifiers, so just convert to mesh */
Object *basis_ob = BKE_mball_basis_find(sce, object_input);
/* todo, re-generatre for render-res */
/* metaball_polygonize(scene, ob) */
if (basis_ob != object_input) {
/* Only do basis metaball. */
return NULL;
}
tmpmesh = BKE_mesh_add(bmain, ((ID *)object_for_eval.data)->name + 2);
/* BKE_mesh_add gives us a user count we don't need */
id_us_min(&tmpmesh->id);
if (render) {
ListBase disp = {NULL, NULL};
BKE_displist_make_mball_forRender(depsgraph, sce, &object_for_eval, &disp);
BKE_mesh_from_metaball(&disp, tmpmesh);
BKE_displist_free(&disp);
}
else {
ListBase disp = {NULL, NULL};
if (object_for_eval.runtime.curve_cache) {
disp = object_for_eval.runtime.curve_cache->disp;
}
BKE_mesh_from_metaball(&disp, tmpmesh);
}
BKE_mesh_texspace_copy_from_object(tmpmesh, &object_for_eval);
break;
}
case OB_MESH:
/* copies object and modifiers (but not the data) */
if (cage) {
/* copies the data (but *not* the shapekeys). */
Mesh *mesh = object_for_eval.data;
BKE_id_copy_ex(bmain, &mesh->id, (ID **)&tmpmesh, 0);
/* XXX BKE_mesh_copy() already handles materials usercount. */
do_mat_id_data_us = false;
}
/* if not getting the original caged mesh, get final derived mesh */
else {
/* Make a dummy mesh, saves copying */
Mesh *me_eval;
CustomData_MeshMasks mask = CD_MASK_MESH; /* this seems more suitable, exporter,
* for example, needs CD_MASK_MDEFORMVERT */
if (calc_undeformed) {
mask.vmask |= CD_MASK_ORCO;
}
if (render) {
me_eval = mesh_create_eval_final_render(depsgraph, sce, &object_for_eval, &mask);
}
else {
me_eval = mesh_create_eval_final_view(depsgraph, sce, &object_for_eval, &mask);
}
tmpmesh = BKE_mesh_add(bmain, ((ID *)object_for_eval.data)->name + 2);
BKE_mesh_nomain_to_mesh(me_eval, tmpmesh, &object_for_eval, &mask, true);
/* Copy autosmooth settings from original mesh. */
Mesh *me = (Mesh *)object_for_eval.data;
tmpmesh->flag |= (me->flag & ME_AUTOSMOOTH);
tmpmesh->smoothresh = me->smoothresh;
}
/* BKE_mesh_add/copy gives us a user count we don't need */
id_us_min(&tmpmesh->id);
break;
default:
/* "Object does not have geometry data") */
return NULL;
}
/* Copy materials to new mesh */
switch (object_for_eval.type) {
case OB_SURF:
case OB_FONT:
case OB_CURVE:
tmpmesh->totcol = tmpcu->totcol;
/* free old material list (if it exists) and adjust user counts */
if (tmpcu->mat) {
for (i = tmpcu->totcol; i-- > 0;) {
/* are we an object material or data based? */
tmpmesh->mat[i] = give_current_material(object_input, i + 1);
if (((object_for_eval.matbits && object_for_eval.matbits[i]) || do_mat_id_data_us) &&
tmpmesh->mat[i]) {
id_us_plus(&tmpmesh->mat[i]->id);
}
}
}
break;
case OB_MBALL: {
MetaBall *tmpmb = (MetaBall *)object_for_eval.data;
tmpmesh->mat = MEM_dupallocN(tmpmb->mat);
tmpmesh->totcol = tmpmb->totcol;
/* free old material list (if it exists) and adjust user counts */
if (tmpmb->mat) {
for (i = tmpmb->totcol; i-- > 0;) {
/* are we an object material or data based? */
tmpmesh->mat[i] = give_current_material(object_input, i + 1);
if (((object_for_eval.matbits && object_for_eval.matbits[i]) || do_mat_id_data_us) &&
tmpmesh->mat[i]) {
id_us_plus(&tmpmesh->mat[i]->id);
}
}
}
break;
}
case OB_MESH:
if (!cage) {
Mesh *origmesh = object_for_eval.data;
tmpmesh->flag = origmesh->flag;
tmpmesh->mat = MEM_dupallocN(origmesh->mat);
tmpmesh->totcol = origmesh->totcol;
tmpmesh->smoothresh = origmesh->smoothresh;
if (origmesh->mat) {
for (i = origmesh->totcol; i-- > 0;) {
/* are we an object material or data based? */
tmpmesh->mat[i] = give_current_material(object_input, i + 1);
if (((object_for_eval.matbits && object_for_eval.matbits[i]) || do_mat_id_data_us) &&
tmpmesh->mat[i]) {
id_us_plus(&tmpmesh->mat[i]->id);
}
}
}
}
break;
} /* end copy materials */
return tmpmesh;
}
Tex *BKE_texture_copy(Main *bmain, const Tex *tex)
{
Tex *tex_copy;
BKE_id_copy_ex(bmain, &tex->id, (ID **)&tex_copy, 0, false);
return tex_copy;
}
Camera *BKE_camera_copy(Main *bmain, const Camera *cam)
{
Camera *cam_copy;
BKE_id_copy_ex(bmain, &cam->id, (ID **)&cam_copy, 0, false);
return cam_copy;
}
