Commit: c4e4924096d1dcfd971aafbbf82d848a774b57db Author: YimingWu Date: Tue Mar 29 22:46:30 2022 +0800 Branches: master https://developer.blender.org/rBc4e4924096d1dcfd971aafbbf82d848a774b57db
GPencil: Fading for build modifier. Adds fading support for build modifier so it's not a hard cut off Reviewed By: Antonio Vazquez (antoniov), Matias Mendiola (mendio) Differential Revision: https://developer.blender.org/D14309 =================================================================== M source/blender/gpencil_modifiers/intern/MOD_gpencilbuild.c M source/blender/makesdna/DNA_gpencil_modifier_types.h M source/blender/makesrna/intern/rna_gpencil_modifier.c =================================================================== diff --git a/source/blender/gpencil_modifiers/intern/MOD_gpencilbuild.c b/source/blender/gpencil_modifiers/intern/MOD_gpencilbuild.c index 1a69a6a8a38..18ce9a12f7b 100644 --- a/source/blender/gpencil_modifiers/intern/MOD_gpencilbuild.c +++ b/source/blender/gpencil_modifiers/intern/MOD_gpencilbuild.c @@ -6,6 +6,7 @@ */ #include <stdio.h> +#include <stdlib.h> #include "MEM_guardedalloc.h" @@ -13,6 +14,7 @@ #include "BLI_blenlib.h" #include "BLI_math.h" +#include "BLI_sort.h" #include "BLT_translation.h" @@ -25,9 +27,12 @@ #include "DNA_screen_types.h" #include "BKE_context.h" +#include "BKE_deform.h" #include "BKE_gpencil.h" #include "BKE_gpencil_geom.h" #include "BKE_gpencil_modifier.h" +#include "BKE_lib_query.h" +#include "BKE_modifier.h" #include "BKE_screen.h" #include "UI_interface.h" @@ -99,17 +104,22 @@ static void gpf_clear_all_strokes(bGPDframe *gpf) * NOTE: This won't be called if all points are present/removed */ static void reduce_stroke_points(bGPdata *gpd, + bGPDframe *gpf, bGPDstroke *gps, const int num_points, const eBuildGpencil_Transition transition) { + if (num_points == 0) { + clear_stroke(gpf, gps); + return; + } bGPDspoint *new_points = MEM_callocN(sizeof(bGPDspoint) * num_points, __func__); MDeformVert *new_dvert = NULL; if ((gps->dvert != NULL) && (num_points > 0)) { new_dvert = MEM_callocN(sizeof(MDeformVert) * num_points, __func__); } - /* Which end should points be removed from */ + /* Which end should points be removed from. */ switch (transition) { case GP_BUILD_TRANSITION_GROW: /* Show in forward order = * Remove ungrown-points from end of stroke. */ @@ -131,7 +141,7 @@ static void reduce_stroke_points(bGPdata *gpd, } /* Hide in forward order = Remove points from start of stroke */ - case GP_BUILD_TRANSITION_FADE: { + case GP_BUILD_TRANSITION_VANISH: { /* num_points is the number of points left after reducing. * We need to know how many to remove */ @@ -167,6 +177,57 @@ static void reduce_stroke_points(bGPdata *gpd, BKE_gpencil_stroke_geometry_update(gpd, gps); } +static void fade_stroke_points(bGPDstroke *gps, + const int starting_index, + const int ending_index, + const float starting_weight, + const float ending_weight, + const int target_def_nr, + const eBuildGpencil_Transition transition, + const float thickness_strength, + const float opacity_strength) +{ + MDeformVert *dvert; + + int range = ending_index - starting_index; + if (!range) { + range = 1; + } + + /* Which end should points be removed from */ + switch (transition) { + /* Because starting_weight and ending_weight are set in correct order before calling this + * function, those three modes can use the same interpolation code. */ + case GP_BUILD_TRANSITION_GROW: + case GP_BUILD_TRANSITION_SHRINK: + case GP_BUILD_TRANSITION_VANISH: { + for (int i = starting_index; i <= ending_index; i++) { + float weight = interpf( + ending_weight, starting_weight, (float)(i - starting_index) / range); + if (target_def_nr >= 0) { + dvert = &gps->dvert[i]; + MDeformWeight *dw = BKE_defvert_ensure_index(dvert, target_def_nr); + if (dw) { + dw->weight = weight; + CLAMP(dw->weight, 0.0f, 1.0f); + } + } + if (thickness_strength > 1e-5) { + gps->points[i].pressure *= interpf(weight, 1.0f, thickness_strength); + } + if (opacity_strength > 1e-5) { + gps->points[i].strength *= interpf(weight, 1.0f, opacity_strength); + } + } + break; + } + + default: + printf("ERROR: Unknown transition %d in %s()\n", (int)transition, __func__); + break; + } +} + /* --------------------------------------------- */ /* Stroke Data Table Entry - This represents one stroke being generated */ @@ -178,11 +239,26 @@ typedef struct tStrokeBuildDetails { /* Number of points - Cache for more convenient access */ int totpoints; + + /* Distance to control object, used to sort the strokes if set. */ + float distance; } tStrokeBuildDetails; +static int cmp_stroke_build_details(const void *ps1, const void *ps2) +{ + tStrokeBuildDetails *p1 = (tStrokeBuildDetails *)ps1; + tStrokeBuildDetails *p2 = (tStrokeBuildDetails *)ps2; + return p1->distance > p2->distance ? 1 : (p1->distance == p2->distance ? 0 : -1); +} + /* Sequential and additive - Show strokes one after the other. */ -static void build_sequential( - BuildGpencilModifierData *mmd, bGPdata *gpd, bGPDframe *gpf, float fac, bool additive) +static void build_sequential(Object *ob, + BuildGpencilModifierData *mmd, + bGPdata *gpd, + bGPDframe *gpf, + const int target_def_nr, + float fac, + bool additive) { size_t tot_strokes = BLI_listbase_count(&gpf->strokes); size_t start_stroke; @@ -222,6 +298,26 @@ static void build_sequential( cell->totpoints = gps->totpoints; totpoints += cell->totpoints; + + /* Compute distance to control object if set, and build according to that order. */ + if (mmd->object) { + float sv1[3], sv2[3]; + mul_v3_m4v3(sv1, ob->obmat, &gps->points[0].x); + mul_v3_m4v3(sv2, ob->obmat, &gps->points[gps->totpoints - 1].x); + float dist_l = len_v3v3(sv1, mmd->object->loc); + float dist_r = len_v3v3(sv2, mmd->object->loc); + if (dist_r < dist_l) { + BKE_gpencil_stroke_flip(gps); + cell->distance = dist_r; + } + else { + cell->distance = dist_l; + } + } + } + + if (mmd->object) { + qsort(table, tot_strokes, sizeof(tStrokeBuildDetails), cmp_stroke_build_details); } /* 2.2) Second pass - Compute the overall indices for points */ @@ -240,6 +336,17 @@ static void build_sequential( /* 3) Determine the global indices for points that should be visible */ size_t first_visible = 0; size_t last_visible = 0; + /* Need signed numbers because the representation of fading offset would exceed the beginning and + * the end of offsets. */ + int fade_start = 0; + int fade_end = 0; + + bool fading_enabled = (mmd->flag & GP_BUILD_USE_FADING); + + float set_fade_fac = fading_enabled ? mmd->fade_fac : 0.0f; + float use_fac = interpf(1 + set_fade_fac, 0, fac); + float use_fade_fac = use_fac - set_fade_fac; + CLAMP(use_fade_fac, 0.0f, 1.0f); switch (mmd->transition) { /* Show in forward order @@ -247,7 +354,9 @@ static void build_sequential( */ case GP_BUILD_TRANSITION_GROW: first_visible = 0; /* always visible */ - last_visible = (size_t)roundf(totpoints * fac); + last_visible = (size_t)roundf(totpoints * use_fac); + fade_start = (int)roundf(totpoints * use_fade_fac); + fade_end = last_visible; break; /* Hide in reverse order @@ -255,15 +364,19 @@ static void build_sequential( */ case GP_BUILD_TRANSITION_SHRINK: first_visible = 0; /* always visible (until last point removed) */ - last_visible = (size_t)(totpoints * (1.0f - fac)); + last_visible = (size_t)(totpoints * (1.0f + set_fade_fac - use_fac)); + fade_start = (int)roundf(totpoints * (1.0f - use_fade_fac - set_fade_fac)); + fade_end = last_visible; break; /* Hide in forward order * - As fac increases, the early points start getting hidden */ - case GP_BUILD_TRANSITION_FADE: - first_visible = (size_t)(totpoints * fac); + case GP_BUILD_TRANSITION_VANISH: + first_visible = (size_t)(totpoints * use_fade_fac); last_visible = totpoints; /* i.e. visible until the end, unless first overlaps this */ + fade_start = first_visible; + fade_end = (int)roundf(totpoints * use_fac); break; } @@ -277,6 +390,30 @@ static void build_sequential( clear_stroke(gpf, cell->gps); } else { + if (fade_start != fade_end && (int)cell->start_idx < fade_end && + (int)cell->end_idx > fade_start) { + int start_index = fade_start - cell->start_idx; + int end_index = cell->totpoints + fade_end - cell->end_idx - 1; + CLAMP(start_index, 0, cell->totpoints - 1); + CLAMP(end_index, 0, cell->totpoints - 1); + float start_weight = ratiof(fade_start, fade_end, cell->start_idx + start_index); + float end_weight = ratiof(fade_start, fade_end, cell->start_idx + end_index); + if (mmd->transition != GP_BUILD_TRANSITION_VANISH) { + start_weight = 1.0f - start_weight; + end_weight = 1.0f - end_weight; + } + fade_stroke_points(cell->gps, + start_index, + end_index, + start_weight, + end_weight, + target_def_nr, + mmd->transition, + mmd->fade_thickness_strength, + mmd->fade_opacity_strength); + /* Calc geometry data. */ + BKE_gpencil_stroke_geometry_update(gpd, cell->gps); + } /* Some proportion of stroke is visible */ if ((first_visible <= cell->start_idx) && (last_visible >= cell->end_idx)) { /* Do nothing - whole stroke is visible */ @@ -284,12 +421,12 @@ static void build_sequential( else if (first_visible > cell->start_idx) { /* Starts partway through this stroke */ int num_points = cell->end_idx - first_visible; - reduce_stroke_points(gpd, cell->gps, num_points, mmd->transition); + reduce_stroke_points(gpd, gpf, cell->gps, num_points, mmd->transition); @@ Diff output truncated at 10240 characters. @@ _______________________________________________ Bf-blender-cvs mailing list [email protected] List details, subscription details or unsubscribe: https://lists.blender.org/mailman/listinfo/bf-blender-cvs
