Bastien Montagne
de491abf99
Fix T58237: Exporters: Curve Modifier not applied when "apply modifiers" are selected. Fix T58856: Python: "to_mesh" broken in 2.8. ...And many other cases... ;) Thing is, we need target IDs to always be evaluated ones (at least I cannot see any case where having orig ones is desired effect here). Depsgraph/Cow system ensures us that when modifiers are evaluated by it, but they can also be called outside of this context, e.g. when doing binding, or object conversion... So we need to ensure in modifiers code that we actually are always working with eval data for those targets. Note that I did not touch to physics modifiers, those are a bit touchy and rather not 'fix' something there until proven broken!
365 lines
10 KiB
C
365 lines
10 KiB
C
/*
|
|
* ***** BEGIN GPL LICENSE BLOCK *****
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*
|
|
* The Original Code is Copyright (C) 2005 by the Blender Foundation.
|
|
* All rights reserved.
|
|
*
|
|
* Contributor(s): Daniel Dunbar
|
|
* Ton Roosendaal,
|
|
* Ben Batt,
|
|
* Brecht Van Lommel,
|
|
* Campbell Barton
|
|
*
|
|
* ***** END GPL LICENSE BLOCK *****
|
|
*
|
|
*/
|
|
|
|
/** \file blender/modifiers/intern/MOD_uvproject.c
|
|
* \ingroup modifiers
|
|
*/
|
|
|
|
|
|
/* UV Project modifier: Generates UVs projected from an object */
|
|
|
|
#include "DNA_mesh_types.h"
|
|
#include "DNA_meshdata_types.h"
|
|
#include "DNA_camera_types.h"
|
|
#include "DNA_object_types.h"
|
|
|
|
#include "BLI_math.h"
|
|
#include "BLI_uvproject.h"
|
|
#include "BLI_utildefines.h"
|
|
|
|
|
|
#include "BKE_camera.h"
|
|
#include "BKE_library.h"
|
|
#include "BKE_library_query.h"
|
|
#include "BKE_material.h"
|
|
#include "BKE_mesh.h"
|
|
|
|
#include "MOD_modifiertypes.h"
|
|
|
|
#include "MEM_guardedalloc.h"
|
|
|
|
#include "DEG_depsgraph.h"
|
|
#include "DEG_depsgraph_build.h"
|
|
#include "DEG_depsgraph_query.h"
|
|
|
|
static void initData(ModifierData *md)
|
|
{
|
|
UVProjectModifierData *umd = (UVProjectModifierData *) md;
|
|
|
|
|
|
umd->num_projectors = 1;
|
|
umd->aspectx = umd->aspecty = 1.0f;
|
|
umd->scalex = umd->scaley = 1.0f;
|
|
}
|
|
|
|
static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *UNUSED(md))
|
|
{
|
|
CustomDataMask dataMask = 0;
|
|
|
|
/* ask for UV coordinates */
|
|
dataMask |= CD_MLOOPUV;
|
|
|
|
return dataMask;
|
|
}
|
|
|
|
static void foreachObjectLink(
|
|
ModifierData *md, Object *ob,
|
|
ObjectWalkFunc walk, void *userData)
|
|
{
|
|
UVProjectModifierData *umd = (UVProjectModifierData *) md;
|
|
int i;
|
|
|
|
for (i = 0; i < MOD_UVPROJECT_MAXPROJECTORS; ++i)
|
|
walk(userData, ob, &umd->projectors[i], IDWALK_CB_NOP);
|
|
}
|
|
|
|
static void foreachIDLink(
|
|
ModifierData *md, Object *ob,
|
|
IDWalkFunc walk, void *userData)
|
|
{
|
|
#if 0
|
|
UVProjectModifierData *umd = (UVProjectModifierData *) md;
|
|
#endif
|
|
|
|
foreachObjectLink(md, ob, (ObjectWalkFunc)walk, userData);
|
|
}
|
|
|
|
static void updateDepsgraph(ModifierData *md, const ModifierUpdateDepsgraphContext *ctx)
|
|
{
|
|
UVProjectModifierData *umd = (UVProjectModifierData *)md;
|
|
bool do_add_own_transform = false;
|
|
for (int i = 0; i < umd->num_projectors; ++i) {
|
|
if (umd->projectors[i] != NULL) {
|
|
DEG_add_object_relation(ctx->node, umd->projectors[i], DEG_OB_COMP_TRANSFORM, "UV Project Modifier");
|
|
do_add_own_transform = true;
|
|
}
|
|
}
|
|
if (do_add_own_transform) {
|
|
DEG_add_object_relation(ctx->node, ctx->object, DEG_OB_COMP_TRANSFORM, "UV Project Modifier");
|
|
}
|
|
}
|
|
|
|
typedef struct Projector {
|
|
Object *ob; /* object this projector is derived from */
|
|
float projmat[4][4]; /* projection matrix */
|
|
float normal[3]; /* projector normal in world space */
|
|
void *uci; /* optional uv-project info (panorama projection) */
|
|
} Projector;
|
|
|
|
static Mesh *uvprojectModifier_do(
|
|
UVProjectModifierData *umd,
|
|
const ModifierEvalContext *ctx,
|
|
Object *ob, Mesh *mesh)
|
|
{
|
|
float (*coords)[3], (*co)[3];
|
|
MLoopUV *mloop_uv;
|
|
int i, numVerts, numPolys, numLoops;
|
|
MPoly *mpoly, *mp;
|
|
MLoop *mloop;
|
|
Projector projectors[MOD_UVPROJECT_MAXPROJECTORS];
|
|
int num_projectors = 0;
|
|
char uvname[MAX_CUSTOMDATA_LAYER_NAME];
|
|
float aspx = umd->aspectx ? umd->aspectx : 1.0f;
|
|
float aspy = umd->aspecty ? umd->aspecty : 1.0f;
|
|
float scax = umd->scalex ? umd->scalex : 1.0f;
|
|
float scay = umd->scaley ? umd->scaley : 1.0f;
|
|
int free_uci = 0;
|
|
|
|
for (i = 0; i < umd->num_projectors; ++i) {
|
|
if (umd->projectors[i] != NULL) {
|
|
projectors[num_projectors++].ob = DEG_get_evaluated_object(ctx->depsgraph, umd->projectors[i]);
|
|
}
|
|
}
|
|
|
|
if (num_projectors == 0)
|
|
return mesh;
|
|
|
|
/* make sure there are UV Maps available */
|
|
|
|
if (!CustomData_has_layer(&mesh->ldata, CD_MLOOPUV)) return mesh;
|
|
|
|
/* make sure we're using an existing layer */
|
|
CustomData_validate_layer_name(&mesh->ldata, CD_MLOOPUV, umd->uvlayer_name, uvname);
|
|
|
|
/* calculate a projection matrix and normal for each projector */
|
|
for (i = 0; i < num_projectors; ++i) {
|
|
float tmpmat[4][4];
|
|
float offsetmat[4][4];
|
|
Camera *cam = NULL;
|
|
/* calculate projection matrix */
|
|
invert_m4_m4(projectors[i].projmat, projectors[i].ob->obmat);
|
|
|
|
projectors[i].uci = NULL;
|
|
|
|
if (projectors[i].ob->type == OB_CAMERA) {
|
|
cam = (Camera *)projectors[i].ob->data;
|
|
if (cam->type == CAM_PANO) {
|
|
projectors[i].uci = BLI_uvproject_camera_info(projectors[i].ob, NULL, aspx, aspy);
|
|
BLI_uvproject_camera_info_scale(projectors[i].uci, scax, scay);
|
|
free_uci = 1;
|
|
}
|
|
else {
|
|
CameraParams params;
|
|
|
|
/* setup parameters */
|
|
BKE_camera_params_init(¶ms);
|
|
BKE_camera_params_from_object(¶ms, projectors[i].ob);
|
|
|
|
/* compute matrix, viewplane, .. */
|
|
BKE_camera_params_compute_viewplane(¶ms, 1, 1, aspx, aspy);
|
|
|
|
/* scale the view-plane */
|
|
params.viewplane.xmin *= scax;
|
|
params.viewplane.xmax *= scax;
|
|
params.viewplane.ymin *= scay;
|
|
params.viewplane.ymax *= scay;
|
|
|
|
BKE_camera_params_compute_matrix(¶ms);
|
|
mul_m4_m4m4(tmpmat, params.winmat, projectors[i].projmat);
|
|
}
|
|
}
|
|
else {
|
|
copy_m4_m4(tmpmat, projectors[i].projmat);
|
|
}
|
|
|
|
unit_m4(offsetmat);
|
|
mul_mat3_m4_fl(offsetmat, 0.5);
|
|
offsetmat[3][0] = offsetmat[3][1] = offsetmat[3][2] = 0.5;
|
|
|
|
mul_m4_m4m4(projectors[i].projmat, offsetmat, tmpmat);
|
|
|
|
/* calculate worldspace projector normal (for best projector test) */
|
|
projectors[i].normal[0] = 0;
|
|
projectors[i].normal[1] = 0;
|
|
projectors[i].normal[2] = 1;
|
|
mul_mat3_m4_v3(projectors[i].ob->obmat, projectors[i].normal);
|
|
}
|
|
|
|
numPolys = mesh->totpoly;
|
|
numLoops = mesh->totloop;
|
|
|
|
/* make sure we are not modifying the original UV map */
|
|
mloop_uv = CustomData_duplicate_referenced_layer_named(&mesh->ldata,
|
|
CD_MLOOPUV, uvname, numLoops);
|
|
|
|
coords = BKE_mesh_vertexCos_get(mesh, &numVerts);
|
|
|
|
/* convert coords to world space */
|
|
for (i = 0, co = coords; i < numVerts; ++i, ++co)
|
|
mul_m4_v3(ob->obmat, *co);
|
|
|
|
/* if only one projector, project coords to UVs */
|
|
if (num_projectors == 1 && projectors[0].uci == NULL)
|
|
for (i = 0, co = coords; i < numVerts; ++i, ++co)
|
|
mul_project_m4_v3(projectors[0].projmat, *co);
|
|
|
|
mpoly = mesh->mpoly;
|
|
mloop = mesh->mloop;
|
|
|
|
/* apply coords as UVs */
|
|
for (i = 0, mp = mpoly; i < numPolys; ++i, ++mp) {
|
|
if (num_projectors == 1) {
|
|
if (projectors[0].uci) {
|
|
unsigned int fidx = mp->totloop - 1;
|
|
do {
|
|
unsigned int lidx = mp->loopstart + fidx;
|
|
unsigned int vidx = mloop[lidx].v;
|
|
BLI_uvproject_from_camera(mloop_uv[lidx].uv, coords[vidx], projectors[0].uci);
|
|
} while (fidx--);
|
|
}
|
|
else {
|
|
/* apply transformed coords as UVs */
|
|
unsigned int fidx = mp->totloop - 1;
|
|
do {
|
|
unsigned int lidx = mp->loopstart + fidx;
|
|
unsigned int vidx = mloop[lidx].v;
|
|
copy_v2_v2(mloop_uv[lidx].uv, coords[vidx]);
|
|
} while (fidx--);
|
|
}
|
|
}
|
|
else {
|
|
/* multiple projectors, select the closest to face normal direction */
|
|
float face_no[3];
|
|
int j;
|
|
Projector *best_projector;
|
|
float best_dot;
|
|
|
|
/* get the untransformed face normal */
|
|
BKE_mesh_calc_poly_normal_coords(mp, mloop + mp->loopstart, (const float (*)[3])coords, face_no);
|
|
|
|
/* find the projector which the face points at most directly
|
|
* (projector normal with largest dot product is best)
|
|
*/
|
|
best_dot = dot_v3v3(projectors[0].normal, face_no);
|
|
best_projector = &projectors[0];
|
|
|
|
for (j = 1; j < num_projectors; ++j) {
|
|
float tmp_dot = dot_v3v3(projectors[j].normal, face_no);
|
|
if (tmp_dot > best_dot) {
|
|
best_dot = tmp_dot;
|
|
best_projector = &projectors[j];
|
|
}
|
|
}
|
|
|
|
if (best_projector->uci) {
|
|
unsigned int fidx = mp->totloop - 1;
|
|
do {
|
|
unsigned int lidx = mp->loopstart + fidx;
|
|
unsigned int vidx = mloop[lidx].v;
|
|
BLI_uvproject_from_camera(mloop_uv[lidx].uv, coords[vidx], best_projector->uci);
|
|
} while (fidx--);
|
|
}
|
|
else {
|
|
unsigned int fidx = mp->totloop - 1;
|
|
do {
|
|
unsigned int lidx = mp->loopstart + fidx;
|
|
unsigned int vidx = mloop[lidx].v;
|
|
mul_v2_project_m4_v3(mloop_uv[lidx].uv, best_projector->projmat, coords[vidx]);
|
|
} while (fidx--);
|
|
}
|
|
}
|
|
}
|
|
|
|
MEM_freeN(coords);
|
|
|
|
if (free_uci) {
|
|
int j;
|
|
for (j = 0; j < num_projectors; ++j) {
|
|
if (projectors[j].uci) {
|
|
MEM_freeN(projectors[j].uci);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Mark tessellated CD layers as dirty. */
|
|
mesh->runtime.cd_dirty_vert |= CD_MASK_TESSLOOPNORMAL;
|
|
|
|
return mesh;
|
|
}
|
|
|
|
static Mesh *applyModifier(
|
|
ModifierData *md, const ModifierEvalContext *ctx,
|
|
Mesh *mesh)
|
|
{
|
|
Mesh *result;
|
|
UVProjectModifierData *umd = (UVProjectModifierData *) md;
|
|
|
|
result = uvprojectModifier_do(umd, ctx, ctx->object, mesh);
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
ModifierTypeInfo modifierType_UVProject = {
|
|
/* name */ "UVProject",
|
|
/* structName */ "UVProjectModifierData",
|
|
/* structSize */ sizeof(UVProjectModifierData),
|
|
/* type */ eModifierTypeType_NonGeometrical,
|
|
/* flags */ eModifierTypeFlag_AcceptsMesh |
|
|
eModifierTypeFlag_SupportsMapping |
|
|
eModifierTypeFlag_SupportsEditmode |
|
|
eModifierTypeFlag_EnableInEditmode,
|
|
|
|
/* copyData */ modifier_copyData_generic,
|
|
|
|
/* deformVerts_DM */ NULL,
|
|
/* deformMatrices_DM */ NULL,
|
|
/* deformVertsEM_DM */ NULL,
|
|
/* deformMatricesEM_DM*/NULL,
|
|
/* applyModifier_DM */ NULL,
|
|
|
|
/* deformVerts */ NULL,
|
|
/* deformMatrices */ NULL,
|
|
/* deformVertsEM */ NULL,
|
|
/* deformMatricesEM */ NULL,
|
|
/* applyModifier */ applyModifier,
|
|
|
|
/* initData */ initData,
|
|
/* requiredDataMask */ requiredDataMask,
|
|
/* freeData */ NULL,
|
|
/* isDisabled */ NULL,
|
|
/* updateDepsgraph */ updateDepsgraph,
|
|
/* dependsOnTime */ NULL,
|
|
/* dependsOnNormals */ NULL,
|
|
/* foreachObjectLink */ foreachObjectLink,
|
|
/* foreachIDLink */ foreachIDLink,
|
|
/* foreachTexLink */ NULL,
|
|
};
|