Cleanup: no need for plural for term 'collision'
[blender.git] / source / blender / gpencil_modifiers / intern / MOD_gpencilopacity.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2017, Blender Foundation
17  * This is a new part of Blender
18  */
19
20 /** \file
21  * \ingroup modifiers
22  */
23
24 #include <stdio.h>
25
26 #include "BLI_utildefines.h"
27
28 #include "BLI_blenlib.h"
29 #include "BLI_math_vector.h"
30
31 #include "BLT_translation.h"
32
33 #include "DNA_gpencil_modifier_types.h"
34 #include "DNA_gpencil_types.h"
35 #include "DNA_meshdata_types.h"
36 #include "DNA_object_types.h"
37 #include "DNA_scene_types.h"
38 #include "DNA_screen_types.h"
39
40 #include "BKE_colortools.h"
41 #include "BKE_context.h"
42 #include "BKE_deform.h"
43 #include "BKE_gpencil.h"
44 #include "BKE_gpencil_modifier.h"
45 #include "BKE_lib_query.h"
46 #include "BKE_main.h"
47 #include "BKE_material.h"
48 #include "BKE_modifier.h"
49 #include "BKE_screen.h"
50
51 #include "DEG_depsgraph.h"
52
53 #include "UI_interface.h"
54 #include "UI_resources.h"
55
56 #include "RNA_access.h"
57
58 #include "MOD_gpencil_modifiertypes.h"
59 #include "MOD_gpencil_ui_common.h"
60 #include "MOD_gpencil_util.h"
61
62 static void initData(GpencilModifierData *md)
63 {
64   OpacityGpencilModifierData *gpmd = (OpacityGpencilModifierData *)md;
65   gpmd->pass_index = 0;
66   gpmd->factor = 1.0f;
67   gpmd->hardeness = 1.0f;
68   gpmd->material = NULL;
69   gpmd->modify_color = GP_MODIFY_COLOR_BOTH;
70   gpmd->curve_intensity = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
71   if (gpmd->curve_intensity) {
72     CurveMapping *curve = gpmd->curve_intensity;
73     BKE_curvemapping_init(curve);
74   }
75 }
76
77 static void copyData(const GpencilModifierData *md, GpencilModifierData *target)
78 {
79   OpacityGpencilModifierData *gmd = (OpacityGpencilModifierData *)md;
80   OpacityGpencilModifierData *tgmd = (OpacityGpencilModifierData *)target;
81
82   if (tgmd->curve_intensity != NULL) {
83     BKE_curvemapping_free(tgmd->curve_intensity);
84     tgmd->curve_intensity = NULL;
85   }
86
87   BKE_gpencil_modifier_copydata_generic(md, target);
88
89   tgmd->curve_intensity = BKE_curvemapping_copy(gmd->curve_intensity);
90 }
91
92 /* opacity strokes */
93 static void deformStroke(GpencilModifierData *md,
94                          Depsgraph *UNUSED(depsgraph),
95                          Object *ob,
96                          bGPDlayer *gpl,
97                          bGPDframe *UNUSED(gpf),
98                          bGPDstroke *gps)
99 {
100   OpacityGpencilModifierData *mmd = (OpacityGpencilModifierData *)md;
101   const int def_nr = BKE_object_defgroup_name_index(ob, mmd->vgname);
102   const bool use_curve = (mmd->flag & GP_OPACITY_CUSTOM_CURVE) != 0 && mmd->curve_intensity;
103
104   if (!is_stroke_affected_by_modifier(ob,
105                                       mmd->layername,
106                                       mmd->material,
107                                       mmd->pass_index,
108                                       mmd->layer_pass,
109                                       1,
110                                       gpl,
111                                       gps,
112                                       mmd->flag & GP_OPACITY_INVERT_LAYER,
113                                       mmd->flag & GP_OPACITY_INVERT_PASS,
114                                       mmd->flag & GP_OPACITY_INVERT_LAYERPASS,
115                                       mmd->flag & GP_OPACITY_INVERT_MATERIAL)) {
116     return;
117   }
118
119   /* Hardness (at stroke level). */
120   if (mmd->modify_color == GP_MODIFY_COLOR_HARDNESS) {
121     gps->hardeness *= mmd->hardeness;
122     CLAMP(gps->hardeness, 0.0f, 1.0f);
123
124     return;
125   }
126
127   for (int i = 0; i < gps->totpoints; i++) {
128     bGPDspoint *pt = &gps->points[i];
129     MDeformVert *dvert = gps->dvert != NULL ? &gps->dvert[i] : NULL;
130
131     /* Stroke using strength. */
132     if (mmd->modify_color != GP_MODIFY_COLOR_FILL) {
133       /* verify vertex group */
134       float weight = get_modifier_point_weight(
135           dvert, (mmd->flag & GP_OPACITY_INVERT_VGROUP) != 0, def_nr);
136       if (weight < 0.0f) {
137         continue;
138       }
139       /* Custom curve to modulate value. */
140       float factor_curve = mmd->factor;
141       if (use_curve) {
142         float value = (float)i / (gps->totpoints - 1);
143         factor_curve *= BKE_curvemapping_evaluateF(mmd->curve_intensity, 0, value);
144       }
145
146       if (def_nr < 0) {
147         if (mmd->flag & GP_OPACITY_NORMALIZE) {
148           pt->strength = factor_curve;
149         }
150         else {
151           pt->strength += factor_curve - 1.0f;
152         }
153       }
154       else {
155         /* High factor values, change weight too. */
156         if ((factor_curve > 1.0f) && (weight < 1.0f)) {
157           weight += factor_curve - 1.0f;
158           CLAMP(weight, 0.0f, 1.0f);
159         }
160         if (mmd->flag & GP_OPACITY_NORMALIZE) {
161           pt->strength = factor_curve;
162         }
163         else {
164           pt->strength += (factor_curve - 1) * weight;
165         }
166       }
167
168       CLAMP(pt->strength, 0.0f, 1.0f);
169     }
170   }
171
172   /* Fill using opacity factor. */
173   if (mmd->modify_color != GP_MODIFY_COLOR_STROKE) {
174     gps->fill_opacity_fac = mmd->factor;
175     CLAMP(gps->fill_opacity_fac, 0.0f, 1.0f);
176   }
177 }
178
179 static void bakeModifier(Main *UNUSED(bmain),
180                          Depsgraph *depsgraph,
181                          GpencilModifierData *md,
182                          Object *ob)
183 {
184   bGPdata *gpd = ob->data;
185
186   LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
187     LISTBASE_FOREACH (bGPDframe *, gpf, &gpl->frames) {
188       LISTBASE_FOREACH (bGPDstroke *, gps, &gpf->strokes) {
189         deformStroke(md, depsgraph, ob, gpl, gpf, gps);
190       }
191     }
192   }
193 }
194
195 static void freeData(GpencilModifierData *md)
196 {
197   OpacityGpencilModifierData *gpmd = (OpacityGpencilModifierData *)md;
198
199   if (gpmd->curve_intensity) {
200     BKE_curvemapping_free(gpmd->curve_intensity);
201   }
202 }
203
204 static void foreachIDLink(GpencilModifierData *md, Object *ob, IDWalkFunc walk, void *userData)
205 {
206   OpacityGpencilModifierData *mmd = (OpacityGpencilModifierData *)md;
207
208   walk(userData, ob, (ID **)&mmd->material, IDWALK_CB_USER);
209 }
210
211 static void panel_draw(const bContext *C, Panel *panel)
212 {
213   uiLayout *layout = panel->layout;
214
215   PointerRNA ptr;
216   gpencil_modifier_panel_get_property_pointers(C, panel, NULL, &ptr);
217
218   uiLayoutSetPropSep(layout, true);
219
220   int modify_color = RNA_enum_get(&ptr, "modify_color");
221
222   uiItemR(layout, &ptr, "modify_color", 0, NULL, ICON_NONE);
223
224   if (modify_color == GP_MODIFY_COLOR_HARDNESS) {
225     uiItemR(layout, &ptr, "hardness", 0, NULL, ICON_NONE);
226   }
227   else {
228     uiItemR(layout, &ptr, "normalize_opacity", 0, NULL, ICON_NONE);
229     const char *text = (RNA_boolean_get(&ptr, "normalize_opacity")) ? IFACE_("Strength") :
230                                                                       IFACE_("Opacity Factor");
231     uiItemR(layout, &ptr, "hardness", 0, text, ICON_NONE);
232   }
233
234   gpencil_modifier_panel_end(layout, &ptr);
235 }
236
237 static void mask_panel_draw(const bContext *C, Panel *panel)
238 {
239   PointerRNA ptr;
240   gpencil_modifier_panel_get_property_pointers(C, panel, NULL, &ptr);
241
242   int modify_color = RNA_enum_get(&ptr, "modify_color");
243   bool show_vertex = (modify_color != GP_MODIFY_COLOR_HARDNESS);
244
245   gpencil_modifier_masking_panel_draw(C, panel, true, show_vertex);
246 }
247
248 static void curve_header_draw(const bContext *C, Panel *panel)
249 {
250   uiLayout *layout = panel->layout;
251
252   PointerRNA ptr;
253   gpencil_modifier_panel_get_property_pointers(C, panel, NULL, &ptr);
254
255   int modify_color = RNA_enum_get(&ptr, "modify_color");
256   uiLayoutSetActive(layout, modify_color != GP_MODIFY_COLOR_HARDNESS);
257
258   gpencil_modifier_curve_header_draw(C, panel);
259 }
260
261 static void curve_panel_draw(const bContext *C, Panel *panel)
262 {
263   uiLayout *layout = panel->layout;
264
265   PointerRNA ptr;
266   gpencil_modifier_panel_get_property_pointers(C, panel, NULL, &ptr);
267
268   int modify_color = RNA_enum_get(&ptr, "modify_color");
269   uiLayoutSetActive(layout, modify_color != GP_MODIFY_COLOR_HARDNESS);
270
271   gpencil_modifier_curve_panel_draw(C, panel);
272 }
273
274 static void panelRegister(ARegionType *region_type)
275 {
276   PanelType *panel_type = gpencil_modifier_panel_register(
277       region_type, eGpencilModifierType_Opacity, panel_draw);
278   PanelType *mask_panel_type = gpencil_modifier_subpanel_register(
279       region_type, "mask", "Influence", NULL, mask_panel_draw, panel_type);
280   gpencil_modifier_subpanel_register(
281       region_type, "curve", "", curve_header_draw, curve_panel_draw, mask_panel_type);
282 }
283
284 GpencilModifierTypeInfo modifierType_Gpencil_Opacity = {
285     /* name */ "Opacity",
286     /* structName */ "OpacityGpencilModifierData",
287     /* structSize */ sizeof(OpacityGpencilModifierData),
288     /* type */ eGpencilModifierTypeType_Gpencil,
289     /* flags */ eGpencilModifierTypeFlag_SupportsEditmode,
290
291     /* copyData */ copyData,
292
293     /* deformStroke */ deformStroke,
294     /* generateStrokes */ NULL,
295     /* bakeModifier */ bakeModifier,
296     /* remapTime */ NULL,
297
298     /* initData */ initData,
299     /* freeData */ freeData,
300     /* isDisabled */ NULL,
301     /* updateDepsgraph */ NULL,
302     /* dependsOnTime */ NULL,
303     /* foreachObjectLink */ NULL,
304     /* foreachIDLink */ foreachIDLink,
305     /* foreachTexLink */ NULL,
306     /* panelRegister */ panelRegister,
307 };