Page MenuHome
Differential D6293 Diff 21982 source/blender/gpencil_modifiers/intern/MOD_gpencilvertexcolor.c

Changeset View

Standalone View

View Options

source/blender/gpencil_modifiers/intern/MOD_gpencilvertexcolor.c

  • This file was copied from source/blender/gpencil_modifiers/intern/MOD_gpencilhook.c.
Show All 20 Lines
* \ingroup modifiers * \ingroup modifiers
*/ */
#include <stdio.h> #include <stdio.h>
#include "BLI_utildefines.h" #include "BLI_utildefines.h"
#include "BLI_math.h" #include "BLI_math.h"
#include "BLI_listbase.h"
#include "DNA_meshdata_types.h" #include "DNA_meshdata_types.h"
#include "DNA_scene_types.h" #include "DNA_scene_types.h"
#include "DNA_object_types.h" #include "DNA_object_types.h"
#include "DNA_gpencil_types.h" #include "DNA_gpencil_types.h"
#include "DNA_gpencil_modifier_types.h" #include "DNA_gpencil_modifier_types.h"
#include "DNA_modifier_types.h" #include "DNA_modifier_types.h"
#include "BKE_action.h" #include "BKE_action.h"
#include "BKE_colorband.h"
#include "BKE_colortools.h" #include "BKE_colortools.h"
#include "BKE_deform.h" #include "BKE_deform.h"
#include "BKE_gpencil.h" #include "BKE_gpencil.h"
#include "BKE_gpencil_modifier.h" #include "BKE_gpencil_modifier.h"
#include "BKE_modifier.h" #include "BKE_modifier.h"
#include "BKE_lib_query.h" #include "BKE_lib_query.h"
#include "BKE_scene.h" #include "BKE_scene.h"
#include "BKE_main.h" #include "BKE_main.h"
#include "BKE_layer.h" #include "BKE_layer.h"
#include "MEM_guardedalloc.h" #include "MEM_guardedalloc.h"
#include "MOD_gpencil_util.h" #include "MOD_gpencil_util.h"
#include "MOD_gpencil_modifiertypes.h" #include "MOD_gpencil_modifiertypes.h"
#include "DEG_depsgraph.h" #include "DEG_depsgraph.h"
#include "DEG_depsgraph_build.h" #include "DEG_depsgraph_build.h"
#include "DEG_depsgraph_query.h" #include "DEG_depsgraph_query.h"
/* temp struct to hold data */
struct GPHookData_cb {
struct CurveMapping *curfalloff;
char falloff_type;
float falloff;
float falloff_sq;
float fac_orig;
uint use_falloff : 1;
uint use_uniform : 1;
float cent[3];
float mat_uniform[3][3];
float mat[4][4];
};
static void initData(GpencilModifierData *md) static void initData(GpencilModifierData *md)
{ {
HookGpencilModifierData *gpmd = (HookGpencilModifierData *)md; VertexcolorGpencilModifierData *gpmd = (VertexcolorGpencilModifierData *)md;
gpmd->pass_index = 0; gpmd->pass_index = 0;
gpmd->layername[0] = '\0'; gpmd->layername[0] = '\0';
gpmd->materialname[0] = '\0'; gpmd->materialname[0] = '\0';
gpmd->vgname[0] = '\0'; gpmd->vgname[0] = '\0';
gpmd->object = NULL; gpmd->object = NULL;
gpmd->force = 0.5f; gpmd->radius = 1.0f;
gpmd->falloff_type = eGPHook_Falloff_Smooth; gpmd->factor = 1.0f;
gpmd->curfalloff = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
if (gpmd->curfalloff) { /* Add default color ramp. */
BKE_curvemapping_initialize(gpmd->curfalloff); gpmd->colorband = BKE_colorband_add(false);
if (gpmd->colorband) {
BKE_colorband_init(gpmd->colorband, true);
CBData *ramp = gpmd->colorband->data;
ramp[0].r = ramp[0].g = ramp[0].b = ramp[0].a = 1.0f;
ramp[0].pos = 0.0f;
ramp[1].r = ramp[1].g = ramp[1].b = 0.0f;
ramp[1].a = 1.0f;
ramp[1].pos = 1.0f;
gpmd->colorband->tot = 2;
} }
} }
static void copyData(const GpencilModifierData *md, GpencilModifierData *target) static void copyData(const GpencilModifierData *md, GpencilModifierData *target)
{ {
HookGpencilModifierData *gmd = (HookGpencilModifierData *)md; VertexcolorGpencilModifierData *gmd = (VertexcolorGpencilModifierData *)md;
HookGpencilModifierData *tgmd = (HookGpencilModifierData *)target; VertexcolorGpencilModifierData *tgmd = (VertexcolorGpencilModifierData *)target;
if (tgmd->curfalloff != NULL) { MEM_SAFE_FREE(tgmd->colorband);
BKE_curvemapping_free(tgmd->curfalloff);
tgmd->curfalloff = NULL;
}
BKE_gpencil_modifier_copyData_generic(md, target); BKE_gpencil_modifier_copyData_generic(md, target);
if (gmd->colorband) {
tgmd->curfalloff = BKE_curvemapping_copy(gmd->curfalloff); tgmd->colorband = MEM_dupallocN(gmd->colorband);
}
/* calculate factor of fallof */
static float gp_hook_falloff(const struct GPHookData_cb *tData, const float len_sq)
{
BLI_assert(tData->falloff_sq);
if (len_sq > tData->falloff_sq) {
return 0.0f;
} }
else if (len_sq > 0.0f) {
float fac;
if (tData->falloff_type == eGPHook_Falloff_Const) {
fac = 1.0f;
goto finally;
}
else if (tData->falloff_type == eGPHook_Falloff_InvSquare) {
/* avoid sqrt below */
fac = 1.0f - (len_sq / tData->falloff_sq);
goto finally;
} }
fac = 1.0f - (sqrtf(len_sq) / tData->falloff); static void gpencil_parent_location(const Depsgraph *depsgraph,
Object *ob,
switch (tData->falloff_type) { bGPDlayer *gpl,
case eGPHook_Falloff_Curve: float diff_mat[4][4])
fac = BKE_curvemapping_evaluateF(tData->curfalloff, 0, fac); {
break; Object *ob_eval = depsgraph != NULL ? DEG_get_evaluated_object(depsgraph, ob) : ob;
case eGPHook_Falloff_Sharp: Object *obparent = gpl->parent;
fac = fac * fac; Object *obparent_eval = depsgraph != NULL ? DEG_get_evaluated_object(depsgraph, obparent) :
break; obparent;
case eGPHook_Falloff_Smooth:
fac = 3.0f * fac * fac - 2.0f * fac * fac * fac; /* if not layer parented, try with object parented */
break; if (obparent_eval == NULL) {
case eGPHook_Falloff_Root: if (ob_eval != NULL) {
fac = sqrtf(fac); copy_m4_m4(diff_mat, ob_eval->obmat);
break; return;
case eGPHook_Falloff_Linear:
/* pass */
break;
case eGPHook_Falloff_Sphere:
fac = sqrtf(2 * fac - fac * fac);
break;
default:
break;
} }
unit_m4(diff_mat);
finally: return;
return fac * tData->fac_orig;
} }
else { else {
return tData->fac_orig; if ((gpl->partype == PAROBJECT) || (gpl->partype == PARSKEL)) {
} mul_m4_m4m4(diff_mat, obparent_eval->obmat, gpl->inverse);
add_v3_v3(diff_mat[3], ob_eval->obmat[3]);
return;
} }
else if (gpl->partype == PARBONE) {
/* apply point deformation */ bPoseChannel *pchan = BKE_pose_channel_find_name(obparent_eval->pose, gpl->parsubstr);
static void gp_hook_co_apply(struct GPHookData_cb *tData, float weight, bGPDspoint *pt) if (pchan) {
{ float tmp_mat[4][4];
float fac; mul_m4_m4m4(tmp_mat, obparent_eval->obmat, pchan->pose_mat);
mul_m4_m4m4(diff_mat, tmp_mat, gpl->inverse);
if (tData->use_falloff) { add_v3_v3(diff_mat[3], ob_eval->obmat[3]);
float len_sq;
if (tData->use_uniform) {
float co_uniform[3];
mul_v3_m3v3(co_uniform, tData->mat_uniform, &pt->x);
len_sq = len_squared_v3v3(tData->cent, co_uniform);
} }
else { else {
len_sq = len_squared_v3v3(tData->cent, &pt->x); /* if bone not found use object (armature) */
mul_m4_m4m4(diff_mat, obparent_eval->obmat, gpl->inverse);
add_v3_v3(diff_mat[3], ob_eval->obmat[3]);
} }
return;
fac = gp_hook_falloff(tData, len_sq);
} }
else { else {
fac = tData->fac_orig; unit_m4(diff_mat); /* not defined type */
} }
if (fac) {
float co_tmp[3];
mul_v3_m4v3(co_tmp, tData->mat, &pt->x);
interp_v3_v3v3(&pt->x, &pt->x, co_tmp, fac * weight);
} }
} }
/* deform stroke */ /* deform stroke */
static void deformStroke(GpencilModifierData *md, static void deformStroke(GpencilModifierData *md,
Depsgraph *UNUSED(depsgraph), Depsgraph *depsgraph,
Object *ob, Object *ob,
bGPDlayer *gpl, bGPDlayer *gpl,
bGPDframe *UNUSED(gpf), bGPDframe *UNUSED(gpf),
bGPDstroke *gps) bGPDstroke *gps)
{ {
HookGpencilModifierData *mmd = (HookGpencilModifierData *)md; VertexcolorGpencilModifierData *mmd = (VertexcolorGpencilModifierData *)md;
if (!mmd->object) { if (!mmd->object) {
return; return;
} }
const int def_nr = defgroup_name_index(ob, mmd->vgname); const int def_nr = defgroup_name_index(ob, mmd->vgname);
bPoseChannel *pchan = BKE_pose_channel_find_name(mmd->object->pose, mmd->subtarget);
float dmat[4][4];
struct GPHookData_cb tData;
if (!is_stroke_affected_by_modifier(ob, if (!is_stroke_affected_by_modifier(ob,
mmd->layername, mmd->layername,
mmd->materialname, mmd->materialname,
mmd->pass_index, mmd->pass_index,
mmd->layer_pass, mmd->layer_pass,
1, 1,
gpl, gpl,
gps, gps,
mmd->flag & GP_HOOK_INVERT_LAYER, mmd->flag & GP_HOOK_INVERT_LAYER,
mmd->flag & GP_HOOK_INVERT_PASS, mmd->flag & GP_HOOK_INVERT_PASS,
mmd->flag & GP_HOOK_INVERT_LAYERPASS, mmd->flag & GP_HOOK_INVERT_LAYERPASS,
mmd->flag & GP_HOOK_INVERT_MATERIAL)) { mmd->flag & GP_HOOK_INVERT_MATERIAL)) {
return; return;
} }
/* init struct */ float target_scale = mat4_to_scale(mmd->object->obmat);
tData.curfalloff = mmd->curfalloff; float radius_sqr = (mmd->radius * mmd->radius) * target_scale;
tData.falloff_type = mmd->falloff_type; float coba_res[4];
tData.falloff = (mmd->falloff_type == eHook_Falloff_None) ? 0.0f : mmd->falloff; float mat[4][4];
tData.falloff_sq = SQUARE(tData.falloff);
tData.fac_orig = mmd->force;
tData.use_falloff = (tData.falloff_sq != 0.0f);
tData.use_uniform = (mmd->flag & GP_HOOK_UNIFORM_SPACE) != 0;
if (tData.use_uniform) {
copy_m3_m4(tData.mat_uniform, mmd->parentinv);
mul_v3_m3v3(tData.cent, tData.mat_uniform, mmd->cent);
}
else {
unit_m3(tData.mat_uniform);
copy_v3_v3(tData.cent, mmd->cent);
}
/* get world-space matrix of target, corrected for the space the verts are in */ gpencil_parent_location(depsgraph, ob, gpl, mat);
if (mmd->subtarget[0] && pchan) {
/* bone target if there's a matching pose-channel */
mul_m4_m4m4(dmat, mmd->object->obmat, pchan->pose_mat);
}
else {
/* just object target */
copy_m4_m4(dmat, mmd->object->obmat);
}
invert_m4_m4(ob->imat, ob->obmat);
mul_m4_series(tData.mat, ob->imat, dmat, mmd->parentinv);
/* loop points and apply deform */ /* loop points and apply deform */
bool doit = false;
for (int i = 0; i < gps->totpoints; i++) { for (int i = 0; i < gps->totpoints; i++) {
bGPDspoint *pt = &gps->points[i]; bGPDspoint *pt = &gps->points[i];
MDeformVert *dvert = gps->dvert != NULL ? &gps->dvert[i] : NULL; MDeformVert *dvert = gps->dvert != NULL ? &gps->dvert[i] : NULL;
/* verify vertex group */ /* Calc world position of point. */
float pt_loc[3];
mul_v3_m4v3(pt_loc, mat, &pt->x);
float dist_sqr = len_squared_v3v3(pt_loc, mmd->object->loc);
if (!doit) {
/* Apply to fill. */
if (mmd->mode != GPPAINT_MODE_STROKE) {
BKE_colorband_evaluate(mmd->colorband, 1.0f, coba_res);
interp_v3_v3v3(gps->vert_color_fill, gps->vert_color_fill, coba_res, mmd->factor);
gps->vert_color_fill[3] = mmd->factor;
/* If no stroke, cancel loop. */
if (mmd->mode != GPPAINT_MODE_BOTH) {
break;
}
}
doit = true;
}
/* Verify vertex group. */
if (mmd->mode != GPPAINT_MODE_FILL) {
const float weight = get_modifier_point_weight( const float weight = get_modifier_point_weight(
dvert, (mmd->flag & GP_HOOK_INVERT_VGROUP) != 0, def_nr); dvert, (mmd->flag & GP_HOOK_INVERT_VGROUP) != 0, def_nr);
if (weight < 0.0f) { if (weight < 0.0f) {
continue; continue;
} }
gp_hook_co_apply(&tData, weight, pt); /* Calc the factor using the distance and get mix color. */
float mix_factor = clamp_f(dist_sqr / radius_sqr, 0.0f, 1.0f);
BKE_colorband_evaluate(mmd->colorband, mix_factor, coba_res);
interp_v3_v3v3(pt->vert_color, pt->vert_color, coba_res, mmd->factor * weight * coba_res[3]);
}
} }
} }
/* FIXME: Ideally we be doing this on a copy of the main depsgraph /* FIXME: Ideally we be doing this on a copy of the main depsgraph
* (i.e. one where we don't have to worry about restoring state) * (i.e. one where we don't have to worry about restoring state)
*/ */
static void bakeModifier(Main *bmain, Depsgraph *depsgraph, GpencilModifierData *md, Object *ob) static void bakeModifier(Main *bmain, Depsgraph *depsgraph, GpencilModifierData *md, Object *ob)
{ {
HookGpencilModifierData *mmd = (HookGpencilModifierData *)md; VertexcolorGpencilModifierData *mmd = (VertexcolorGpencilModifierData *)md;
Scene *scene = DEG_get_evaluated_scene(depsgraph); Scene *scene = DEG_get_evaluated_scene(depsgraph);
bGPdata *gpd = ob->data; bGPdata *gpd = ob->data;
int oldframe = (int)DEG_get_ctime(depsgraph); int oldframe = (int)DEG_get_ctime(depsgraph);
if (mmd->object == NULL) { if (mmd->object == NULL) {
return; return;
} }
for (bGPDlayer *gpl = gpd->layers.first; gpl; gpl = gpl->next) { LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
for (bGPDframe *gpf = gpl->frames.first; gpf; gpf = gpf->next) { LISTBASE_FOREACH (bGPDframe *, gpf, &gpl->frames) {
/* apply hook effects on this frame /* apply effects on this frame
* NOTE: this assumes that we don't want hook animation on non-keyframed frames * NOTE: this assumes that we don't want animation on non-keyframed frames
*/ */
CFRA = gpf->framenum; CFRA = gpf->framenum;
BKE_scene_graph_update_for_newframe(depsgraph, bmain); BKE_scene_graph_update_for_newframe(depsgraph, bmain);
/* compute hook effects on this frame */ /* compute effects on this frame */
for (bGPDstroke *gps = gpf->strokes.first; gps; gps = gps->next) { LISTBASE_FOREACH (bGPDstroke *, gps, &gpf->strokes) {
deformStroke(md, depsgraph, ob, gpl, gpf, gps); deformStroke(md, depsgraph, ob, gpl, gpf, gps);
} }
} }
} }
/* return frame state and DB to original state */ /* return frame state and DB to original state */
CFRA = oldframe; CFRA = oldframe;
BKE_scene_graph_update_for_newframe(depsgraph, bmain); BKE_scene_graph_update_for_newframe(depsgraph, bmain);
} }
static void freeData(GpencilModifierData *md) static void freeData(GpencilModifierData *md)
{ {
HookGpencilModifierData *mmd = (HookGpencilModifierData *)md; VertexcolorGpencilModifierData *mmd = (VertexcolorGpencilModifierData *)md;
if (mmd->colorband) {
if (mmd->curfalloff) { MEM_freeN(mmd->colorband);
BKE_curvemapping_free(mmd->curfalloff); mmd->colorband = NULL;
} }
} }
static bool isDisabled(GpencilModifierData *md, int UNUSED(userRenderParams)) static bool isDisabled(GpencilModifierData *md, int UNUSED(userRenderParams))
{ {
HookGpencilModifierData *mmd = (HookGpencilModifierData *)md; VertexcolorGpencilModifierData *mmd = (VertexcolorGpencilModifierData *)md;
return !mmd->object; return !mmd->object;
} }
static void updateDepsgraph(GpencilModifierData *md, const ModifierUpdateDepsgraphContext *ctx) static void updateDepsgraph(GpencilModifierData *md, const ModifierUpdateDepsgraphContext *ctx)
{ {
HookGpencilModifierData *lmd = (HookGpencilModifierData *)md; VertexcolorGpencilModifierData *lmd = (VertexcolorGpencilModifierData *)md;
if (lmd->object != NULL) { if (lmd->object != NULL) {
DEG_add_object_relation(ctx->node, lmd->object, DEG_OB_COMP_GEOMETRY, "Hook Modifier"); DEG_add_object_relation(ctx->node, lmd->object, DEG_OB_COMP_GEOMETRY, "Vertexcolor Modifier");
DEG_add_object_relation(ctx->node, lmd->object, DEG_OB_COMP_TRANSFORM, "Hook Modifier"); DEG_add_object_relation(ctx->node, lmd->object, DEG_OB_COMP_TRANSFORM, "Vertexcolor Modifier");
} }
DEG_add_object_relation(ctx->node, ctx->object, DEG_OB_COMP_TRANSFORM, "Hook Modifier"); DEG_add_object_relation(ctx->node, ctx->object, DEG_OB_COMP_TRANSFORM, "Vertexcolor Modifier");
} }
static void foreachObjectLink(GpencilModifierData *md, static void foreachObjectLink(GpencilModifierData *md,
Object *ob, Object *ob,
ObjectWalkFunc walk, ObjectWalkFunc walk,
void *userData) void *userData)
{ {
HookGpencilModifierData *mmd = (HookGpencilModifierData *)md; VertexcolorGpencilModifierData *mmd = (VertexcolorGpencilModifierData *)md;
walk(userData, ob, &mmd->object, IDWALK_CB_NOP); walk(userData, ob, &mmd->object, IDWALK_CB_NOP);
} }
GpencilModifierTypeInfo modifierType_Gpencil_Hook = { GpencilModifierTypeInfo modifierType_Gpencil_Vertexcolor = {
/* name */ "Hook", /* name */ "Vertexcolor",
/* structName */ "HookGpencilModifierData", /* structName */ "VertexcolorGpencilModifierData",
/* structSize */ sizeof(HookGpencilModifierData), /* structSize */ sizeof(VertexcolorGpencilModifierData),
/* type */ eGpencilModifierTypeType_Gpencil, /* type */ eGpencilModifierTypeType_Gpencil,
/* flags */ eGpencilModifierTypeFlag_SupportsEditmode, /* flags */ eGpencilModifierTypeFlag_SupportsEditmode,
/* copyData */ copyData, /* copyData */ copyData,
/* deformStroke */ deformStroke, /* deformStroke */ deformStroke,
/* generateStrokes */ NULL, /* generateStrokes */ NULL,
/* bakeModifier */ bakeModifier, /* bakeModifier */ bakeModifier,
Show All 11 Lines