From 80109c976cf1f43e1f1730cb827130aa270abaaa Mon Sep 17 00:00:00 2001 From: Campbell Barton Date: Tue, 6 Nov 2018 18:06:33 +1100 Subject: [PATCH] Brush: split out vertex paint tool & blend mode - Vertex & weight paint now use the 'blend' setting. - Weight paint now has it's own tool setting, since weight paint doesn't deal with color - we'll likely support different tools eventually. --- .../startup/bl_ui/space_toolsystem_common.py | 2 +- .../startup/bl_ui/space_toolsystem_toolbar.py | 2 +- release/scripts/startup/bl_ui/space_view3d.py | 4 +- .../startup/bl_ui/space_view3d_toolbar.py | 6 +- source/blender/blenkernel/BKE_paint.h | 6 +- source/blender/blenkernel/intern/paint.c | 29 ++++- .../blenloader/intern/versioning_280.c | 103 ++++++++++++++++++ .../editors/interface/interface_icons.c | 45 ++++---- .../interface/interface_region_tooltip.c | 2 +- .../blender/editors/sculpt_paint/paint_ops.c | 7 +- .../editors/sculpt_paint/paint_vertex.c | 93 +++++++++------- .../sculpt_paint/paint_vertex_color_utils.c | 42 ++++--- .../sculpt_paint/paint_vertex_weight_ops.c | 2 +- .../sculpt_paint/paint_vertex_weight_utils.c | 42 ++++--- source/blender/makesdna/DNA_brush_types.h | 42 +++---- source/blender/makesrna/RNA_enum_types.h | 1 + source/blender/makesrna/intern/rna_brush.c | 69 +++++------- .../makesrna/intern/rna_sculpt_paint.c | 4 +- 18 files changed, 302 insertions(+), 199 deletions(-) diff --git a/release/scripts/startup/bl_ui/space_toolsystem_common.py b/release/scripts/startup/bl_ui/space_toolsystem_common.py index b034b99d8b3..138f69860a6 100644 --- a/release/scripts/startup/bl_ui/space_toolsystem_common.py +++ b/release/scripts/startup/bl_ui/space_toolsystem_common.py @@ -816,7 +816,7 @@ def keymap_from_context(context, space_type): mode = context.active_object.mode attr_op, attr_brush = { 'SCULPT': ("sculpt_tool", "sculpt_tool"), - 'WEIGHT_PAINT': ("weight_paint_tool", "vertex_tool"), + 'WEIGHT_PAINT': ("weight_paint_tool", "weight_tool"), 'VERTEX_PAINT': ("vertex_paint_tool", "vertex_tool"), 'TEXTURE_PAINT': ("texture_paint_tool", "image_tool"), }.get(mode, (None, None)) diff --git a/release/scripts/startup/bl_ui/space_toolsystem_toolbar.py b/release/scripts/startup/bl_ui/space_toolsystem_toolbar.py index bd64e7e3834..8ea25a99d6c 100644 --- a/release/scripts/startup/bl_ui/space_toolsystem_toolbar.py +++ b/release/scripts/startup/bl_ui/space_toolsystem_toolbar.py @@ -1040,7 +1040,7 @@ class _defs_weight_paint: context, icon_prefix="brush.paint_weight.", type=bpy.types.Brush, - attr="vertex_tool", + attr="weight_tool", ) @ToolDef.from_fn diff --git a/release/scripts/startup/bl_ui/space_view3d.py b/release/scripts/startup/bl_ui/space_view3d.py index 49c0c2c7834..81eeb567696 100644 --- a/release/scripts/startup/bl_ui/space_view3d.py +++ b/release/scripts/startup/bl_ui/space_view3d.py @@ -2107,8 +2107,10 @@ class VIEW3D_MT_brush(Menu): layout.prop_menu_enum(brush, "sculpt_tool") elif context.image_paint_object: layout.prop_menu_enum(brush, "image_tool") - elif context.vertex_paint_object or context.weight_paint_object: + elif context.vertex_paint_object: layout.prop_menu_enum(brush, "vertex_tool") + elif context.weight_paint_object: + layout.prop_menu_enum(brush, "weight_tool") # TODO: still missing a lot of brush options here diff --git a/release/scripts/startup/bl_ui/space_view3d_toolbar.py b/release/scripts/startup/bl_ui/space_view3d_toolbar.py index 1abfb92917b..07ebfb36f7d 100644 --- a/release/scripts/startup/bl_ui/space_view3d_toolbar.py +++ b/release/scripts/startup/bl_ui/space_view3d_toolbar.py @@ -399,9 +399,9 @@ class VIEW3D_PT_tools_brush(Panel, View3DPaintPanel): self.prop_unified_strength(row, context, brush, "use_pressure_strength") col.separator() - col.prop(brush, "vertex_tool", text="Blend") + col.prop(brush, "blend", text="Blend") - if brush.vertex_tool != 'SMEAR': + if brush.weight_tool != 'SMEAR': col.prop(brush, "use_accumulate") col.separator() @@ -440,7 +440,7 @@ class VIEW3D_PT_tools_brush(Panel, View3DPaintPanel): self.prop_unified_strength(row, context, brush, "use_pressure_strength") col.separator() - col.prop(brush, "vertex_tool", text="Blend") + col.prop(brush, "blend", text="Blend") col.prop(brush, "use_alpha") if brush.vertex_tool != 'SMEAR': diff --git a/source/blender/blenkernel/BKE_paint.h b/source/blender/blenkernel/BKE_paint.h index dc05642fb69..27f85d754cd 100644 --- a/source/blender/blenkernel/BKE_paint.h +++ b/source/blender/blenkernel/BKE_paint.h @@ -81,8 +81,9 @@ typedef enum ePaintMode { ePaintTextureProjective = 3, ePaintTexture2D = 4, ePaintSculptUV = 5, - ePaintInvalid = 6, - ePaintGpencil = 7 + ePaintGpencil = 6, + + ePaintInvalid = 7, } ePaintMode; /* overlay invalidation */ @@ -139,6 +140,7 @@ void BKE_paint_cavity_curve_preset(struct Paint *p, int preset); eObjectMode BKE_paint_object_mode_from_paint_mode(ePaintMode mode); struct Paint *BKE_paint_get_active_from_paintmode(struct Scene *sce, ePaintMode mode); const struct EnumPropertyItem *BKE_paint_get_tool_enum_from_paintmode(ePaintMode mode); +uint BKE_paint_get_brush_tool_offset_from_paint_mode(const ePaintMode mode); struct Paint *BKE_paint_get_active(struct Scene *sce, struct ViewLayer *view_layer); struct Paint *BKE_paint_get_active_from_context(const struct bContext *C); ePaintMode BKE_paintmode_get_active_from_context(const struct bContext *C); diff --git a/source/blender/blenkernel/intern/paint.c b/source/blender/blenkernel/intern/paint.c index 6bc86f75d71..55f6100c7be 100644 --- a/source/blender/blenkernel/intern/paint.c +++ b/source/blender/blenkernel/intern/paint.c @@ -182,9 +182,9 @@ const EnumPropertyItem *BKE_paint_get_tool_enum_from_paintmode(ePaintMode mode) case ePaintVertex: return rna_enum_brush_vertex_tool_items; case ePaintWeight: - return rna_enum_brush_vertex_tool_items; - case ePaintTextureProjective: + return rna_enum_brush_weight_tool_items; case ePaintTexture2D: + case ePaintTextureProjective: return rna_enum_brush_image_tool_items; case ePaintSculptUV: return NULL; @@ -369,7 +369,7 @@ void BKE_paint_runtime_init(const ToolSettings *ts, Paint *paint) paint->runtime.ob_mode = OB_MODE_VERTEX_PAINT; } else if (paint == &ts->wpaint->paint) { - paint->runtime.tool_offset = offsetof(Brush, vertexpaint_tool); + paint->runtime.tool_offset = offsetof(Brush, weightpaint_tool); paint->runtime.ob_mode = OB_MODE_WEIGHT_PAINT; } else if (paint == &ts->gp_paint->paint) { @@ -386,6 +386,26 @@ void BKE_paint_runtime_init(const ToolSettings *ts, Paint *paint) } } +uint BKE_paint_get_brush_tool_offset_from_paint_mode(const ePaintMode mode) +{ + switch (mode) { + case ePaintTexture2D: + case ePaintTextureProjective: + return offsetof(Brush, imagepaint_tool); + case ePaintSculpt: + return offsetof(Brush, sculpt_tool); + case ePaintVertex: + return offsetof(Brush, vertexpaint_tool); + case ePaintWeight: + return offsetof(Brush, weightpaint_tool); + case ePaintGpencil: + return offsetof(Brush, gpencil_tool); + case ePaintSculptUV: + case ePaintInvalid: + break; /* We don't use these yet. */ + } + return 0; +} /** Free (or release) any data used by this paint curve (does not free the pcurve itself). */ void BKE_paint_curve_free(PaintCurve *pc) @@ -591,9 +611,8 @@ eObjectMode BKE_paint_object_mode_from_paint_mode(ePaintMode mode) return OB_MODE_VERTEX_PAINT; case ePaintWeight: return OB_MODE_WEIGHT_PAINT; - case ePaintTextureProjective: - return OB_MODE_TEXTURE_PAINT; case ePaintTexture2D: + case ePaintTextureProjective: return OB_MODE_TEXTURE_PAINT; case ePaintSculptUV: return OB_MODE_EDIT; diff --git a/source/blender/blenloader/intern/versioning_280.c b/source/blender/blenloader/intern/versioning_280.c index fc009f6c876..040c08eb63f 100644 --- a/source/blender/blenloader/intern/versioning_280.c +++ b/source/blender/blenloader/intern/versioning_280.c @@ -89,6 +89,9 @@ #include "BKE_key.h" #include "BKE_unit.h" +/* Only for IMB_BlendMode */ +#include "IMB_imbuf.h" + #include "DEG_depsgraph.h" #include "BLT_translation.h" @@ -2253,6 +2256,106 @@ void blo_do_versions_280(FileData *fd, Library *UNUSED(lib), Main *bmain) scene->eevee.overscan = 3.0f; } } + + if (!DNA_struct_elem_find(fd->filesdna, "Brush", "char", "weightpaint_tool")) { + /* Magic defines from old files (2.7x) */ + +#define PAINT_BLEND_MIX 0 +#define PAINT_BLEND_ADD 1 +#define PAINT_BLEND_SUB 2 +#define PAINT_BLEND_MUL 3 +#define PAINT_BLEND_BLUR 4 +#define PAINT_BLEND_LIGHTEN 5 +#define PAINT_BLEND_DARKEN 6 +#define PAINT_BLEND_AVERAGE 7 +#define PAINT_BLEND_SMEAR 8 +#define PAINT_BLEND_COLORDODGE 9 +#define PAINT_BLEND_DIFFERENCE 10 +#define PAINT_BLEND_SCREEN 11 +#define PAINT_BLEND_HARDLIGHT 12 +#define PAINT_BLEND_OVERLAY 13 +#define PAINT_BLEND_SOFTLIGHT 14 +#define PAINT_BLEND_EXCLUSION 15 +#define PAINT_BLEND_LUMINOSITY 16 +#define PAINT_BLEND_SATURATION 17 +#define PAINT_BLEND_HUE 18 +#define PAINT_BLEND_ALPHA_SUB 19 +#define PAINT_BLEND_ALPHA_ADD 20 + + for (Brush *brush = bmain->brush.first; brush; brush = brush->id.next) { + if (brush->ob_mode & (OB_MODE_VERTEX_PAINT | OB_MODE_WEIGHT_PAINT)) { + const char tool_init = brush->vertexpaint_tool; + bool is_blend = false; + + { + char tool = tool_init; + switch (tool_init) { + case PAINT_BLEND_MIX: tool = VPAINT_TOOL_DRAW; break; + case PAINT_BLEND_BLUR: tool = VPAINT_TOOL_BLUR; break; + case PAINT_BLEND_AVERAGE: tool = VPAINT_TOOL_AVERAGE; break; + case PAINT_BLEND_SMEAR: tool = VPAINT_TOOL_SMEAR; break; + default: + tool = VPAINT_TOOL_DRAW; + is_blend = true; + break; + } + brush->vertexpaint_tool = tool; + } + + if (is_blend == false) { + brush->blend = IMB_BLEND_MIX; + } + else { + short blend = IMB_BLEND_MIX; + switch (tool_init) { + case PAINT_BLEND_ADD: blend = IMB_BLEND_ADD; break; + case PAINT_BLEND_SUB: blend = IMB_BLEND_SUB; break; + case PAINT_BLEND_MUL: blend = IMB_BLEND_MUL; break; + case PAINT_BLEND_LIGHTEN: blend = IMB_BLEND_LIGHTEN; break; + case PAINT_BLEND_DARKEN: blend = IMB_BLEND_DARKEN; break; + case PAINT_BLEND_COLORDODGE: blend = IMB_BLEND_COLORDODGE; break; + case PAINT_BLEND_DIFFERENCE: blend = IMB_BLEND_DIFFERENCE; break; + case PAINT_BLEND_SCREEN: blend = IMB_BLEND_SCREEN; break; + case PAINT_BLEND_HARDLIGHT: blend = IMB_BLEND_HARDLIGHT; break; + case PAINT_BLEND_OVERLAY: blend = IMB_BLEND_OVERLAY; break; + case PAINT_BLEND_SOFTLIGHT: blend = IMB_BLEND_SOFTLIGHT; break; + case PAINT_BLEND_EXCLUSION: blend = IMB_BLEND_EXCLUSION; break; + case PAINT_BLEND_LUMINOSITY: blend = IMB_BLEND_LUMINOSITY; break; + case PAINT_BLEND_SATURATION: blend = IMB_BLEND_SATURATION; break; + case PAINT_BLEND_HUE: blend = IMB_BLEND_HUE; break; + case PAINT_BLEND_ALPHA_SUB: blend = IMB_BLEND_ERASE_ALPHA; break; + case PAINT_BLEND_ALPHA_ADD: blend = IMB_BLEND_ADD_ALPHA; break; + } + brush->blend = blend; + } + } + /* For now these match, in the future new items may not. */ + brush->weightpaint_tool = brush->vertexpaint_tool; + } + +#undef PAINT_BLEND_MIX +#undef PAINT_BLEND_ADD +#undef PAINT_BLEND_SUB +#undef PAINT_BLEND_MUL +#undef PAINT_BLEND_BLUR +#undef PAINT_BLEND_LIGHTEN +#undef PAINT_BLEND_DARKEN +#undef PAINT_BLEND_AVERAGE +#undef PAINT_BLEND_SMEAR +#undef PAINT_BLEND_COLORDODGE +#undef PAINT_BLEND_DIFFERENCE +#undef PAINT_BLEND_SCREEN +#undef PAINT_BLEND_HARDLIGHT +#undef PAINT_BLEND_OVERLAY +#undef PAINT_BLEND_SOFTLIGHT +#undef PAINT_BLEND_EXCLUSION +#undef PAINT_BLEND_LUMINOSITY +#undef PAINT_BLEND_SATURATION +#undef PAINT_BLEND_HUE +#undef PAINT_BLEND_ALPHA_SUB +#undef PAINT_BLEND_ALPHA_ADD + + } } } diff --git a/source/blender/editors/interface/interface_icons.c b/source/blender/editors/interface/interface_icons.c index 09e16b806f3..80c62a3eda7 100644 --- a/source/blender/editors/interface/interface_icons.c +++ b/source/blender/editors/interface/interface_icons.c @@ -58,6 +58,7 @@ #include "BKE_context.h" #include "BKE_global.h" +#include "BKE_paint.h" #include "BKE_icons.h" #include "BKE_appdir.h" #include "BKE_studiolight.h" @@ -1679,7 +1680,7 @@ static int ui_id_brush_get_icon(const bContext *C, ID *id) WorkSpace *workspace = CTX_wm_workspace(C); Object *ob = CTX_data_active_object(C); const EnumPropertyItem *items = NULL; - int tool = PAINT_TOOL_DRAW, mode = 0; + ePaintMode paint_mode = ePaintInvalid; ScrArea *sa = CTX_wm_area(C); char space_type = sa->spacetype; /* When in an unsupported space. */ @@ -1692,12 +1693,18 @@ static int ui_id_brush_get_icon(const bContext *C, ID *id) * checking various context stuff here */ if ((space_type == SPACE_VIEW3D) && ob) { - if (ob->mode & OB_MODE_SCULPT) - mode = OB_MODE_SCULPT; - else if (ob->mode & (OB_MODE_VERTEX_PAINT | OB_MODE_WEIGHT_PAINT)) - mode = OB_MODE_VERTEX_PAINT; - else if (ob->mode & OB_MODE_TEXTURE_PAINT) - mode = OB_MODE_TEXTURE_PAINT; + if (ob->mode & OB_MODE_SCULPT) { + paint_mode = ePaintSculpt; + } + else if (ob->mode & OB_MODE_VERTEX_PAINT) { + paint_mode = ePaintVertex; + } + else if (ob->mode & OB_MODE_WEIGHT_PAINT) { + paint_mode = ePaintWeight; + } + else if (ob->mode & OB_MODE_TEXTURE_PAINT) { + paint_mode = ePaintTextureProjective; + } } else if (space_type == SPACE_IMAGE) { int sima_mode; @@ -1710,7 +1717,7 @@ static int ui_id_brush_get_icon(const bContext *C, ID *id) } if (sima_mode == SI_MODE_PAINT) { - mode = OB_MODE_TEXTURE_PAINT; + paint_mode = ePaintTexture2D; } } @@ -1756,21 +1763,17 @@ static int ui_id_brush_get_icon(const bContext *C, ID *id) } return id->icon_id; } - else if (mode == OB_MODE_SCULPT) { - items = rna_enum_brush_sculpt_tool_items; - tool = br->sculpt_tool; + else if (paint_mode != ePaintInvalid) { + items = BKE_paint_get_tool_enum_from_paintmode(paint_mode); + const uint tool_offset = BKE_paint_get_brush_tool_offset_from_paint_mode(paint_mode); + const int tool_type = *(char *)POINTER_OFFSET(br, tool_offset); + if (!items || !RNA_enum_icon_from_value(items, tool_type, &id->icon_id)) { + id->icon_id = 0; + } } - else if (mode == OB_MODE_VERTEX_PAINT) { - items = rna_enum_brush_vertex_tool_items; - tool = br->vertexpaint_tool; - } - else if (mode == OB_MODE_TEXTURE_PAINT) { - items = rna_enum_brush_image_tool_items; - tool = br->imagepaint_tool; - } - - if (!items || !RNA_enum_icon_from_value(items, tool, &id->icon_id)) + else { id->icon_id = 0; + } } return id->icon_id; diff --git a/source/blender/editors/interface/interface_region_tooltip.c b/source/blender/editors/interface/interface_region_tooltip.c index e410421479c..4e1218c3b2f 100644 --- a/source/blender/editors/interface/interface_region_tooltip.c +++ b/source/blender/editors/interface/interface_region_tooltip.c @@ -472,7 +472,7 @@ static uiTooltipData *ui_tooltip_data_from_tool(bContext *C, uiBut *but, bool is break; case CTX_MODE_PAINT_WEIGHT: tool_attr = "weight_paint_tool"; - tool_offset = offsetof(Brush, vertexpaint_tool); + tool_offset = offsetof(Brush, weightpaint_tool); break; case CTX_MODE_PAINT_TEXTURE: tool_attr = "texture_paint_tool"; diff --git a/source/blender/editors/sculpt_paint/paint_ops.c b/source/blender/editors/sculpt_paint/paint_ops.c index f15f727ed2c..cb78ecd511d 100644 --- a/source/blender/editors/sculpt_paint/paint_ops.c +++ b/source/blender/editors/sculpt_paint/paint_ops.c @@ -483,10 +483,9 @@ static int brush_select_exec(bContext *C, wmOperator *op) RNA_enum_name_from_value(rna_enum_brush_vertex_tool_items, tool, &tool_name); break; case OB_MODE_WEIGHT_PAINT: - /* vertexpaint_tool is used for weight paint mode */ - tool_offset = offsetof(Brush, vertexpaint_tool); + tool_offset = offsetof(Brush, weightpaint_tool); tool = RNA_enum_get(op->ptr, "weight_paint_tool"); - RNA_enum_name_from_value(rna_enum_brush_vertex_tool_items, tool, &tool_name); + RNA_enum_name_from_value(rna_enum_brush_weight_tool_items, tool, &tool_name); break; case OB_MODE_TEXTURE_PAINT: tool_offset = offsetof(Brush, imagepaint_tool); @@ -567,7 +566,7 @@ static void PAINT_OT_brush_select(wmOperatorType *ot) RNA_def_property_flag(prop, PROP_HIDDEN); prop = RNA_def_enum(ot->srna, "vertex_paint_tool", rna_enum_brush_vertex_tool_items, 0, "Vertex Paint Tool", ""); RNA_def_property_flag(prop, PROP_HIDDEN); - prop = RNA_def_enum(ot->srna, "weight_paint_tool", rna_enum_brush_vertex_tool_items, 0, "Weight Paint Tool", ""); + prop = RNA_def_enum(ot->srna, "weight_paint_tool", rna_enum_brush_weight_tool_items, 0, "Weight Paint Tool", ""); RNA_def_property_flag(prop, PROP_HIDDEN); prop = RNA_def_enum(ot->srna, "texture_paint_tool", rna_enum_brush_image_tool_items, 0, "Texture Paint Tool", ""); RNA_def_property_flag(prop, PROP_HIDDEN); diff --git a/source/blender/editors/sculpt_paint/paint_vertex.c b/source/blender/editors/sculpt_paint/paint_vertex.c index 103cb6b5f2f..bf20146f195 100644 --- a/source/blender/editors/sculpt_paint/paint_vertex.c +++ b/source/blender/editors/sculpt_paint/paint_vertex.c @@ -76,6 +76,9 @@ #include "ED_screen.h" #include "ED_view3d.h" +/* For IMB_BlendMode only. */ +#include "IMB_imbuf.h" + #include "bmesh.h" #include "BKE_ccg.h" @@ -153,9 +156,17 @@ static bool vwpaint_use_normal(const VPaint *vp) ((vp->paint.brush->flag & BRUSH_FRONTFACE_FALLOFF) != 0); } -static bool brush_use_accumulate(const Brush *brush) +static bool brush_use_accumulate_ex(const Brush *brush, const int ob_mode) { - return (brush->flag & BRUSH_ACCUMULATE) != 0 || brush->vertexpaint_tool == PAINT_BLEND_SMEAR; + return ((brush->flag & BRUSH_ACCUMULATE) != 0 || + (ob_mode == OB_MODE_VERTEX_PAINT ? + (brush->vertexpaint_tool == VPAINT_TOOL_SMEAR) : + (brush->weightpaint_tool == WPAINT_TOOL_SMEAR))); +} + +static bool brush_use_accumulate(const VPaint *vp) +{ + return brush_use_accumulate_ex(vp->paint.brush, vp->paint.runtime.ob_mode); } static MDeformVert *defweight_prev_init(MDeformVert *dvert_prev, MDeformVert *dvert_curr, int index) @@ -291,16 +302,16 @@ static uint vpaint_blend( const int brush_alpha_value_i) { const Brush *brush = vp->paint.brush; - const int tool = brush->vertexpaint_tool; + const IMB_BlendMode blend = brush->blend; - uint color_blend = ED_vpaint_blend_tool(tool, color_curr, color_paint, alpha_i); + uint color_blend = ED_vpaint_blend_tool(blend, color_curr, color_paint, alpha_i); /* if no accumulate, clip color adding with colorig & orig alpha */ - if (!brush_use_accumulate(brush)) { + if (!brush_use_accumulate(vp)) { uint color_test, a; char *cp, *ct, *co; - color_test = ED_vpaint_blend_tool(tool, color_orig, color_paint, brush_alpha_value_i); + color_test = ED_vpaint_blend_tool(blend, color_orig, color_paint, brush_alpha_value_i); cp = (char *)&color_blend; ct = (char *)&color_test; @@ -319,7 +330,7 @@ static uint vpaint_blend( } if ((brush->flag & BRUSH_LOCK_ALPHA) && - !ELEM(tool, PAINT_BLEND_ALPHA_SUB, PAINT_BLEND_ALPHA_ADD)) + !ELEM(blend, IMB_BLEND_ERASE_ALPHA, IMB_BLEND_ADD_ALPHA)) { char *cp, *cc; cp = (char *)&color_blend; @@ -363,24 +374,25 @@ static float wpaint_blend( const short do_flip) { const Brush *brush = wp->paint.brush; - int tool = brush->vertexpaint_tool; + IMB_BlendMode blend = brush->blend; if (do_flip) { - switch (tool) { - case PAINT_BLEND_MIX: + switch (blend) { + case IMB_BLEND_MIX: paintval = 1.f - paintval; break; - case PAINT_BLEND_ADD: - tool = PAINT_BLEND_SUB; break; - case PAINT_BLEND_SUB: - tool = PAINT_BLEND_ADD; break; - case PAINT_BLEND_LIGHTEN: - tool = PAINT_BLEND_DARKEN; break; - case PAINT_BLEND_DARKEN: - tool = PAINT_BLEND_LIGHTEN; break; + case IMB_BLEND_ADD: + blend = IMB_BLEND_SUB; break; + case IMB_BLEND_SUB: + blend = IMB_BLEND_ADD; break; + case IMB_BLEND_LIGHTEN: + blend = IMB_BLEND_DARKEN; break; + case IMB_BLEND_DARKEN: + blend = IMB_BLEND_LIGHTEN; break; + default: break; } } - weight = ED_wpaint_blend_tool(tool, weight, paintval, alpha); + weight = ED_wpaint_blend_tool(blend, weight, paintval, alpha); CLAMP(weight, 0.0f, 1.0f); @@ -759,7 +771,7 @@ static void do_weight_paint_vertex_single( dw_mirr = NULL; } - if (!brush_use_accumulate(wp->paint.brush)) { + if (!brush_use_accumulate(wp)) { MDeformVert *dvert_prev = ob->sculpt->mode.wpaint.dvert_prev; MDeformVert *dv_prev = defweight_prev_init(dvert_prev, me->dvert, index); if (index_mirr != -1) { @@ -875,7 +887,7 @@ static void do_weight_paint_vertex_multi( return; } - if (!brush_use_accumulate(wp->paint.brush)) { + if (!brush_use_accumulate(wp)) { MDeformVert *dvert_prev = ob->sculpt->mode.wpaint.dvert_prev; MDeformVert *dv_prev = defweight_prev_init(dvert_prev, me->dvert, index); if (index_mirr != -1) { @@ -978,15 +990,12 @@ static void vertex_paint_init_session_data(const ToolSettings *ts, Object *ob) { /* Create maps */ struct SculptVertexPaintGeomMap *gmap = NULL; - const Brush *brush = NULL; if (ob->mode == OB_MODE_VERTEX_PAINT) { gmap = &ob->sculpt->mode.vpaint.gmap; - brush = BKE_paint_brush(&ts->vpaint->paint); BLI_assert(ob->sculpt->mode_type == OB_MODE_VERTEX_PAINT); } else if (ob->mode == OB_MODE_WEIGHT_PAINT) { gmap = &ob->sculpt->mode.wpaint.gmap; - brush = BKE_paint_brush(&ts->wpaint->paint); BLI_assert(ob->sculpt->mode_type == OB_MODE_WEIGHT_PAINT); } else { @@ -1014,7 +1023,7 @@ static void vertex_paint_init_session_data(const ToolSettings *ts, Object *ob) /* Create average brush arrays */ if (ob->mode == OB_MODE_VERTEX_PAINT) { - if (!brush_use_accumulate(brush)) { + if (!brush_use_accumulate(ts->vpaint)) { if (ob->sculpt->mode.vpaint.previous_color == NULL) { ob->sculpt->mode.vpaint.previous_color = MEM_callocN(me->totloop * sizeof(uint), __func__); @@ -1025,7 +1034,7 @@ static void vertex_paint_init_session_data(const ToolSettings *ts, Object *ob) } } else if (ob->mode == OB_MODE_WEIGHT_PAINT) { - if (!brush_use_accumulate(brush)) { + if (!brush_use_accumulate(ts->wpaint)) { if (ob->sculpt->mode.wpaint.alpha_weight == NULL) { ob->sculpt->mode.wpaint.alpha_weight = MEM_callocN(me->totvert * sizeof(float), __func__); @@ -1544,7 +1553,7 @@ static bool wpaint_stroke_test_start(bContext *C, wmOperator *op, const float mo wpd->mirror.lock = tmpflags; } - if (ELEM(vp->paint.brush->vertexpaint_tool, PAINT_BLEND_SMEAR, PAINT_BLEND_BLUR)) { + if (ELEM(vp->paint.brush->weightpaint_tool, WPAINT_TOOL_SMEAR, WPAINT_TOOL_BLUR)) { wpd->precomputed_weight = MEM_mallocN(sizeof(float) * me->totvert, __func__); } @@ -1612,7 +1621,7 @@ static void do_wpaint_precompute_weight_cb_ex( static void precompute_weight_values( bContext *C, Object *ob, Brush *brush, struct WPaintData *wpd, WeightPaintInfo *wpi, Mesh *me) { - if (wpd->precomputed_weight_ready && !brush_use_accumulate(brush)) + if (wpd->precomputed_weight_ready && !brush_use_accumulate_ex(brush, ob->mode)) return; /* threaded loop over vertices */ @@ -2006,8 +2015,8 @@ static void wpaint_paint_leaves( /* NOTE: current mirroring code cannot be run in parallel */ settings.use_threading = !(me->editflag & ME_EDIT_MIRROR_X); - switch (brush->vertexpaint_tool) { - case PAINT_BLEND_AVERAGE: + switch ((eBrushWeightPaintTool)brush->weightpaint_tool) { + case WPAINT_TOOL_AVERAGE: calculate_average_weight(&data, nodes, totnode); BLI_task_parallel_range( 0, totnode, @@ -2015,21 +2024,21 @@ static void wpaint_paint_leaves( do_wpaint_brush_draw_task_cb_ex, &settings); break; - case PAINT_BLEND_SMEAR: + case WPAINT_TOOL_SMEAR: BLI_task_parallel_range( 0, totnode, &data, do_wpaint_brush_smear_task_cb_ex, &settings); break; - case PAINT_BLEND_BLUR: + case WPAINT_TOOL_BLUR: BLI_task_parallel_range( 0, totnode, &data, do_wpaint_brush_blur_task_cb_ex, &settings); break; - default: + case WPAINT_TOOL_DRAW: BLI_task_parallel_range( 0, totnode, &data, @@ -2512,7 +2521,7 @@ static bool vpaint_stroke_test_start(bContext *C, struct wmOperator *op, const f vpd->paintcol = vpaint_get_current_col(scene, vp, (RNA_enum_get(op->ptr, "mode") == BRUSH_STROKE_INVERT)); - vpd->is_texbrush = !(brush->vertexpaint_tool == PAINT_BLEND_BLUR) && brush->mtex.tex; + vpd->is_texbrush = !(brush->vertexpaint_tool == VPAINT_TOOL_BLUR) && brush->mtex.tex; /* are we painting onto a modified mesh?, * if not we can skip face map trickiness */ @@ -2526,11 +2535,11 @@ static bool vpaint_stroke_test_start(bContext *C, struct wmOperator *op, const f } /* to keep tracked of modified loops for shared vertex color blending */ - if (brush->vertexpaint_tool == PAINT_BLEND_BLUR) { + if (brush->vertexpaint_tool == VPAINT_TOOL_BLUR) { vpd->mlooptag = MEM_mallocN(sizeof(bool) * me->totloop, "VPaintData mlooptag"); } - if (brush->vertexpaint_tool == PAINT_BLEND_SMEAR) { + if (brush->vertexpaint_tool == VPAINT_TOOL_SMEAR) { vpd->smear.color_prev = MEM_mallocN(sizeof(uint) * me->totloop, __func__); memcpy(vpd->smear.color_prev, me->mloopcol, sizeof(uint) * me->totloop); vpd->smear.color_curr = MEM_dupallocN(vpd->smear.color_prev); @@ -3009,8 +3018,8 @@ static void vpaint_paint_leaves( }; ParallelRangeSettings settings; BLI_parallel_range_settings_defaults(&settings); - switch (brush->vertexpaint_tool) { - case PAINT_BLEND_AVERAGE: + switch ((eBrushVertexPaintTool)brush->vertexpaint_tool) { + case VPAINT_TOOL_AVERAGE: calculate_average_color(&data, nodes, totnode); BLI_task_parallel_range( 0, totnode, @@ -3018,21 +3027,21 @@ static void vpaint_paint_leaves( do_vpaint_brush_draw_task_cb_ex, &settings); break; - case PAINT_BLEND_BLUR: + case VPAINT_TOOL_BLUR: BLI_task_parallel_range( 0, totnode, &data, do_vpaint_brush_blur_task_cb_ex, &settings); break; - case PAINT_BLEND_SMEAR: + case VPAINT_TOOL_SMEAR: BLI_task_parallel_range( 0, totnode, &data, do_vpaint_brush_smear_task_cb_ex, &settings); break; - default: + case VPAINT_TOOL_DRAW: BLI_task_parallel_range( 0, totnode, &data, @@ -3144,7 +3153,7 @@ static void vpaint_stroke_update_step(bContext *C, struct PaintStroke *stroke, P BKE_mesh_batch_cache_dirty_tag(ob->data, BKE_MESH_BATCH_DIRTY_ALL); - if (vp->paint.brush->vertexpaint_tool == PAINT_BLEND_SMEAR) { + if (vp->paint.brush->vertexpaint_tool == PAINT_TOOL_SMEAR) { memcpy(vpd->smear.color_prev, vpd->smear.color_curr, sizeof(uint) * ((Mesh *)ob->data)->totloop); } diff --git a/source/blender/editors/sculpt_paint/paint_vertex_color_utils.c b/source/blender/editors/sculpt_paint/paint_vertex_color_utils.c index 481d5e7d5ea..f78588df0fa 100644 --- a/source/blender/editors/sculpt_paint/paint_vertex_color_utils.c +++ b/source/blender/editors/sculpt_paint/paint_vertex_color_utils.c @@ -36,6 +36,7 @@ #include "BLI_math_color.h" #include "IMB_colormanagement.h" +#include "IMB_imbuf.h" #include "BKE_context.h" #include "BKE_mesh.h" @@ -617,29 +618,26 @@ uint ED_vpaint_blend_tool( const int tool, const uint col, const uint paintcol, const int alpha_i) { - switch (tool) { - case PAINT_BLEND_MIX: - case PAINT_BLEND_BLUR: return mcol_blend(col, paintcol, alpha_i); - case PAINT_BLEND_AVERAGE: return mcol_blend(col, paintcol, alpha_i); - case PAINT_BLEND_SMEAR: return mcol_blend(col, paintcol, alpha_i); - case PAINT_BLEND_ADD: return mcol_add(col, paintcol, alpha_i); - case PAINT_BLEND_SUB: return mcol_sub(col, paintcol, alpha_i); - case PAINT_BLEND_MUL: return mcol_mul(col, paintcol, alpha_i); - case PAINT_BLEND_LIGHTEN: return mcol_lighten(col, paintcol, alpha_i); - case PAINT_BLEND_DARKEN: return mcol_darken(col, paintcol, alpha_i); - case PAINT_BLEND_COLORDODGE: return mcol_colordodge(col, paintcol, alpha_i); - case PAINT_BLEND_DIFFERENCE: return mcol_difference(col, paintcol, alpha_i); - case PAINT_BLEND_SCREEN: return mcol_screen(col, paintcol, alpha_i); - case PAINT_BLEND_HARDLIGHT: return mcol_hardlight(col, paintcol, alpha_i); - case PAINT_BLEND_OVERLAY: return mcol_overlay(col, paintcol, alpha_i); - case PAINT_BLEND_SOFTLIGHT: return mcol_softlight(col, paintcol, alpha_i); - case PAINT_BLEND_EXCLUSION: return mcol_exclusion(col, paintcol, alpha_i); - case PAINT_BLEND_LUMINOCITY: return mcol_luminosity(col, paintcol, alpha_i); - case PAINT_BLEND_SATURATION: return mcol_saturation(col, paintcol, alpha_i); - case PAINT_BLEND_HUE: return mcol_hue(col, paintcol, alpha_i); + switch ((IMB_BlendMode)tool) { + case IMB_BLEND_MIX: return mcol_blend(col, paintcol, alpha_i); + case IMB_BLEND_ADD: return mcol_add(col, paintcol, alpha_i); + case IMB_BLEND_SUB: return mcol_sub(col, paintcol, alpha_i); + case IMB_BLEND_MUL: return mcol_mul(col, paintcol, alpha_i); + case IMB_BLEND_LIGHTEN: return mcol_lighten(col, paintcol, alpha_i); + case IMB_BLEND_DARKEN: return mcol_darken(col, paintcol, alpha_i); + case IMB_BLEND_COLORDODGE: return mcol_colordodge(col, paintcol, alpha_i); + case IMB_BLEND_DIFFERENCE: return mcol_difference(col, paintcol, alpha_i); + case IMB_BLEND_SCREEN: return mcol_screen(col, paintcol, alpha_i); + case IMB_BLEND_HARDLIGHT: return mcol_hardlight(col, paintcol, alpha_i); + case IMB_BLEND_OVERLAY: return mcol_overlay(col, paintcol, alpha_i); + case IMB_BLEND_SOFTLIGHT: return mcol_softlight(col, paintcol, alpha_i); + case IMB_BLEND_EXCLUSION: return mcol_exclusion(col, paintcol, alpha_i); + case IMB_BLEND_LUMINOSITY: return mcol_luminosity(col, paintcol, alpha_i); + case IMB_BLEND_SATURATION: return mcol_saturation(col, paintcol, alpha_i); + case IMB_BLEND_HUE: return mcol_hue(col, paintcol, alpha_i); /* non-color */ - case PAINT_BLEND_ALPHA_SUB: return mcol_alpha_sub(col, alpha_i); - case PAINT_BLEND_ALPHA_ADD: return mcol_alpha_add(col, alpha_i); + case IMB_BLEND_ERASE_ALPHA: return mcol_alpha_sub(col, alpha_i); + case IMB_BLEND_ADD_ALPHA: return mcol_alpha_add(col, alpha_i); default: BLI_assert(0); return 0; diff --git a/source/blender/editors/sculpt_paint/paint_vertex_weight_ops.c b/source/blender/editors/sculpt_paint/paint_vertex_weight_ops.c index d15fd41a510..46eb3995ea3 100644 --- a/source/blender/editors/sculpt_paint/paint_vertex_weight_ops.c +++ b/source/blender/editors/sculpt_paint/paint_vertex_weight_ops.c @@ -591,7 +591,7 @@ static void gradientVert_update(WPGradient_userData *grad_data, int index) MDeformVert *dv = &me->dvert[index]; MDeformWeight *dw = defvert_verify_index(dv, grad_data->def_nr); // dw->weight = alpha; // testing - int tool = grad_data->brush->vertexpaint_tool; + int tool = grad_data->brush->blend; float testw; /* init if we just added */ diff --git a/source/blender/editors/sculpt_paint/paint_vertex_weight_utils.c b/source/blender/editors/sculpt_paint/paint_vertex_weight_utils.c index 51cd759b260..0a1fc7c0b4e 100644 --- a/source/blender/editors/sculpt_paint/paint_vertex_weight_utils.c +++ b/source/blender/editors/sculpt_paint/paint_vertex_weight_utils.c @@ -45,6 +45,9 @@ #include "BKE_report.h" #include "BKE_object.h" +/* Only for blend modes. */ +#include "IMB_imbuf.h" + #include "WM_api.h" #include "WM_types.h" @@ -280,31 +283,24 @@ float ED_wpaint_blend_tool( const float weight, const float paintval, const float alpha) { - switch (tool) { - case PAINT_BLEND_MIX: - case PAINT_BLEND_AVERAGE: - case PAINT_BLEND_SMEAR: - case PAINT_BLEND_BLUR: return wval_blend(weight, paintval, alpha); - case PAINT_BLEND_ADD: return wval_add(weight, paintval, alpha); - case PAINT_BLEND_SUB: return wval_sub(weight, paintval, alpha); - case PAINT_BLEND_MUL: return wval_mul(weight, paintval, alpha); - case PAINT_BLEND_LIGHTEN: return wval_lighten(weight, paintval, alpha); - case PAINT_BLEND_DARKEN: return wval_darken(weight, paintval, alpha); + switch ((IMB_BlendMode)tool) { + case IMB_BLEND_MIX: return wval_blend(weight, paintval, alpha); + case IMB_BLEND_ADD: return wval_add(weight, paintval, alpha); + case IMB_BLEND_SUB: return wval_sub(weight, paintval, alpha); + case IMB_BLEND_MUL: return wval_mul(weight, paintval, alpha); + case IMB_BLEND_LIGHTEN: return wval_lighten(weight, paintval, alpha); + case IMB_BLEND_DARKEN: return wval_darken(weight, paintval, alpha); /* Mostly make sense for color: support anyway. */ - case PAINT_BLEND_COLORDODGE: return wval_colordodge(weight, paintval, alpha); - case PAINT_BLEND_DIFFERENCE: return wval_difference(weight, paintval, alpha); - case PAINT_BLEND_SCREEN: return wval_screen(weight, paintval, alpha); - case PAINT_BLEND_HARDLIGHT: return wval_hardlight(weight, paintval, alpha); - case PAINT_BLEND_OVERLAY: return wval_overlay(weight, paintval, alpha); - case PAINT_BLEND_SOFTLIGHT: return wval_softlight(weight, paintval, alpha); - case PAINT_BLEND_EXCLUSION: return wval_exclusion(weight, paintval, alpha); + case IMB_BLEND_COLORDODGE: return wval_colordodge(weight, paintval, alpha); + case IMB_BLEND_DIFFERENCE: return wval_difference(weight, paintval, alpha); + case IMB_BLEND_SCREEN: return wval_screen(weight, paintval, alpha); + case IMB_BLEND_HARDLIGHT: return wval_hardlight(weight, paintval, alpha); + case IMB_BLEND_OVERLAY: return wval_overlay(weight, paintval, alpha); + case IMB_BLEND_SOFTLIGHT: return wval_softlight(weight, paintval, alpha); + case IMB_BLEND_EXCLUSION: return wval_exclusion(weight, paintval, alpha); /* Only for color: just use blend. */ - case PAINT_BLEND_LUMINOCITY: - case PAINT_BLEND_SATURATION: - case PAINT_BLEND_HUE: - case PAINT_BLEND_ALPHA_SUB: - case PAINT_BLEND_ALPHA_ADD: - default: return wval_blend(weight, paintval, alpha); + default: + return wval_blend(weight, paintval, alpha); } } diff --git a/source/blender/makesdna/DNA_brush_types.h b/source/blender/makesdna/DNA_brush_types.h index 9cf23f30287..d51c94fb536 100644 --- a/source/blender/makesdna/DNA_brush_types.h +++ b/source/blender/makesdna/DNA_brush_types.h @@ -205,11 +205,12 @@ typedef struct Brush { float falloff_angle; char sculpt_tool; /* active sculpt tool */ - char vertexpaint_tool; /* active vertex/weight paint blend mode (poorly named) */ + char vertexpaint_tool; /* active vertex paint */ + char weightpaint_tool; /* active weight paint */ char imagepaint_tool; /* active image paint tool */ char mask_tool; /* enum eBrushMaskTool, only used if sculpt_tool is SCULPT_TOOL_MASK */ char gpencil_tool; /* Active grease pencil tool. */ - char _pad0[7]; + char _pad0[6]; float autosmooth_factor; @@ -410,6 +411,19 @@ typedef enum eBrushImagePaintTool { PAINT_TOOL_MASK = 5 } eBrushImagePaintTool; +typedef enum eBrushVertexPaintTool { + VPAINT_TOOL_DRAW = 0, + VPAINT_TOOL_BLUR = 1, + VPAINT_TOOL_AVERAGE = 2, + VPAINT_TOOL_SMEAR = 3, +} eBrushVertexPaintTool; + +typedef enum eBrushWeightPaintTool { + WPAINT_TOOL_DRAW = 0, + WPAINT_TOOL_BLUR = 1, + WPAINT_TOOL_AVERAGE = 2, + WPAINT_TOOL_SMEAR = 3, +} eBrushWeightPaintTool; /* BrushGpencilSettings->brush type */ typedef enum eBrushGPaintTool { @@ -428,30 +442,6 @@ enum { SCULPT_DISP_DIR_Z = 4 }; -enum { - PAINT_BLEND_MIX = 0, - PAINT_BLEND_ADD = 1, - PAINT_BLEND_SUB = 2, - PAINT_BLEND_MUL = 3, - PAINT_BLEND_BLUR = 4, - PAINT_BLEND_LIGHTEN = 5, - PAINT_BLEND_DARKEN = 6, - PAINT_BLEND_AVERAGE = 7, - PAINT_BLEND_SMEAR = 8, - PAINT_BLEND_COLORDODGE = 9, - PAINT_BLEND_DIFFERENCE = 10, - PAINT_BLEND_SCREEN = 11, - PAINT_BLEND_HARDLIGHT = 12, - PAINT_BLEND_OVERLAY = 13, - PAINT_BLEND_SOFTLIGHT = 14, - PAINT_BLEND_EXCLUSION = 15, - PAINT_BLEND_LUMINOCITY = 16, - PAINT_BLEND_SATURATION = 17, - PAINT_BLEND_HUE = 18, - PAINT_BLEND_ALPHA_SUB = 19, - PAINT_BLEND_ALPHA_ADD = 20, -}; - typedef enum { BRUSH_MASK_DRAW = 0, BRUSH_MASK_SMOOTH = 1 diff --git a/source/blender/makesrna/RNA_enum_types.h b/source/blender/makesrna/RNA_enum_types.h index 8376bdefbc4..10c08464c8c 100644 --- a/source/blender/makesrna/RNA_enum_types.h +++ b/source/blender/makesrna/RNA_enum_types.h @@ -120,6 +120,7 @@ extern const EnumPropertyItem rna_enum_operator_property_tags[]; extern const EnumPropertyItem rna_enum_brush_sculpt_tool_items[]; extern const EnumPropertyItem rna_enum_brush_vertex_tool_items[]; +extern const EnumPropertyItem rna_enum_brush_weight_tool_items[]; extern const EnumPropertyItem rna_enum_brush_gpencil_types_items[]; extern const EnumPropertyItem rna_enum_brush_image_tool_items[]; diff --git a/source/blender/makesrna/intern/rna_brush.c b/source/blender/makesrna/intern/rna_brush.c index ac41666a79f..4506519e7f5 100644 --- a/source/blender/makesrna/intern/rna_brush.c +++ b/source/blender/makesrna/intern/rna_brush.c @@ -87,30 +87,19 @@ const EnumPropertyItem rna_enum_brush_sculpt_tool_items[] = { {0, NULL, 0, NULL, NULL} }; - const EnumPropertyItem rna_enum_brush_vertex_tool_items[] = { - {PAINT_BLEND_MIX, "MIX", ICON_BRUSH_MIX, "Mix", "Use mix blending mode while painting"}, - {PAINT_BLEND_ADD, "ADD", ICON_BRUSH_ADD, "Add", "Use add blending mode while painting"}, - {PAINT_BLEND_SUB, "SUB", ICON_BRUSH_SUBTRACT, "Subtract", "Use subtract blending mode while painting"}, - {PAINT_BLEND_MUL, "MUL", ICON_BRUSH_MULTIPLY, "Multiply", "Use multiply blending mode while painting"}, - {PAINT_BLEND_BLUR, "BLUR", ICON_BRUSH_BLUR, "Blur", "Blur the color with surrounding values"}, - {PAINT_BLEND_LIGHTEN, "LIGHTEN", ICON_BRUSH_LIGHTEN, "Lighten", "Use lighten blending mode while painting"}, - {PAINT_BLEND_DARKEN, "DARKEN", ICON_BRUSH_DARKEN, "Darken", "Use darken blending mode while painting"}, - {PAINT_BLEND_AVERAGE, "AVERAGE", ICON_BRUSH_BLUR, "Average", "Use average blending mode while painting"}, - {PAINT_BLEND_SMEAR, "SMEAR", ICON_BRUSH_BLUR, "Smear", "Use smear blending mode while painting"}, - {PAINT_BLEND_COLORDODGE, "COLORDODGE", ICON_BRUSH_BLUR, "Color Dodge", "Use color dodge blending mode while painting" }, - {PAINT_BLEND_DIFFERENCE, "DIFFERENCE", ICON_BRUSH_BLUR, "Difference", "Use difference blending mode while painting"}, - {PAINT_BLEND_SCREEN, "SCREEN", ICON_BRUSH_BLUR, "Screen", "Use screen blending mode while painting"}, - {PAINT_BLEND_HARDLIGHT, "HARDLIGHT", ICON_BRUSH_BLUR, "Hardlight", "Use hardlight blending mode while painting"}, - {PAINT_BLEND_OVERLAY, "OVERLAY", ICON_BRUSH_BLUR, "Overlay", "Use overlay blending mode while painting"}, - {PAINT_BLEND_SOFTLIGHT, "SOFTLIGHT", ICON_BRUSH_BLUR, "Softlight", "Use softlight blending mode while painting"}, - {PAINT_BLEND_EXCLUSION, "EXCLUSION", ICON_BRUSH_BLUR, "Exclusion", "Use exclusion blending mode while painting"}, - {PAINT_BLEND_LUMINOCITY, "LUMINOCITY", ICON_BRUSH_BLUR, "Luminocity", "Use luminocity blending mode while painting"}, - {PAINT_BLEND_SATURATION, "SATURATION", ICON_BRUSH_BLUR, "Saturation", "Use saturation blending mode while painting"}, - {PAINT_BLEND_HUE, "HUE", ICON_BRUSH_BLUR, "Hue", "Use hue blending mode while painting"}, - {PAINT_BLEND_ALPHA_SUB, "ERASE_ALPHA", 0, "Erase Alpha", "Erase alpha while painting"}, - {PAINT_BLEND_ALPHA_ADD, "ADD_ALPHA", 0, "Add Alpha", "Add alpha while painting"}, + {VPAINT_TOOL_DRAW, "DRAW", ICON_BRUSH_MIX, "Draw", ""}, + {VPAINT_TOOL_BLUR, "BLUR", ICON_BRUSH_BLUR, "Blur", ""}, + {VPAINT_TOOL_AVERAGE, "AVERAGE", ICON_BRUSH_BLUR, "Average", ""}, + {VPAINT_TOOL_SMEAR, "SMEAR", ICON_BRUSH_BLUR, "Smear", ""}, + {0, NULL, 0, NULL, NULL} +}; +const EnumPropertyItem rna_enum_brush_weight_tool_items[] = { + {WPAINT_TOOL_DRAW, "DRAW", ICON_BRUSH_MIX, "Draw", ""}, + {WPAINT_TOOL_BLUR, "BLUR", ICON_BRUSH_BLUR, "Blur", ""}, + {WPAINT_TOOL_AVERAGE, "AVERAGE", ICON_BRUSH_BLUR, "Average", ""}, + {WPAINT_TOOL_SMEAR, "SMEAR", ICON_BRUSH_BLUR, "Smear", ""}, {0, NULL, 0, NULL, NULL} }; @@ -390,7 +379,7 @@ static PointerRNA rna_Brush_capabilities_get(PointerRNA *ptr) return rna_pointer_inherit_refine(ptr, &RNA_BrushCapabilities, ptr->id.data); } -static void rna_Brush_reset_icon(Brush *br, const char *UNUSED(type)) +static void rna_Brush_reset_icon(Brush *br) { ID *id = &br->id; @@ -463,24 +452,10 @@ static void rna_Brush_size_update(Main *bmain, Scene *scene, PointerRNA *ptr) rna_Brush_update(bmain, scene, ptr); } -static void rna_Brush_sculpt_tool_update(Main *bmain, Scene *scene, PointerRNA *ptr) +static void rna_Brush_update_and_reset_icon(Main *bmain, Scene *scene, PointerRNA *ptr) { - Brush *br = (Brush *)ptr->data; - rna_Brush_reset_icon(br, "sculpt"); - rna_Brush_update(bmain, scene, ptr); -} - -static void rna_Brush_vertex_tool_update(Main *bmain, Scene *scene, PointerRNA *ptr) -{ - Brush *br = (Brush *)ptr->data; - rna_Brush_reset_icon(br, "vertex_paint"); - rna_Brush_update(bmain, scene, ptr); -} - -static void rna_Brush_imagepaint_tool_update(Main *bmain, Scene *scene, PointerRNA *ptr) -{ - Brush *br = (Brush *)ptr->data; - rna_Brush_reset_icon(br, "image_paint"); + Brush *br = ptr->data; + rna_Brush_reset_icon(br); rna_Brush_update(bmain, scene, ptr); } @@ -1344,19 +1319,25 @@ static void rna_def_brush(BlenderRNA *brna) prop = RNA_def_property(srna, "sculpt_tool", PROP_ENUM, PROP_NONE); RNA_def_property_enum_items(prop, rna_enum_brush_sculpt_tool_items); RNA_def_property_ui_text(prop, "Sculpt Tool", ""); - RNA_def_property_update(prop, 0, "rna_Brush_sculpt_tool_update"); + RNA_def_property_update(prop, 0, "rna_Brush_update_and_reset_icon"); prop = RNA_def_property(srna, "vertex_tool", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "vertexpaint_tool"); RNA_def_property_enum_items(prop, rna_enum_brush_vertex_tool_items); - RNA_def_property_ui_text(prop, "Blending mode", "Brush blending mode"); - RNA_def_property_update(prop, 0, "rna_Brush_vertex_tool_update"); + RNA_def_property_ui_text(prop, "Vertex Paint Tool", ""); + RNA_def_property_update(prop, 0, "rna_Brush_update_and_reset_icon"); + + prop = RNA_def_property(srna, "weight_tool", PROP_ENUM, PROP_NONE); + RNA_def_property_enum_sdna(prop, NULL, "weightpaint_tool"); + RNA_def_property_enum_items(prop, rna_enum_brush_weight_tool_items); + RNA_def_property_ui_text(prop, "Weight Paint Tool", ""); + RNA_def_property_update(prop, 0, "rna_Brush_update_and_reset_icon"); prop = RNA_def_property(srna, "image_tool", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "imagepaint_tool"); RNA_def_property_enum_items(prop, rna_enum_brush_image_tool_items); RNA_def_property_ui_text(prop, "Image Paint Tool", ""); - RNA_def_property_update(prop, NC_SPACE | ND_SPACE_IMAGE, "rna_Brush_imagepaint_tool_update"); + RNA_def_property_update(prop, NC_SPACE | ND_SPACE_IMAGE, "rna_Brush_update_and_reset_icon"); prop = RNA_def_property(srna, "gpencil_tool", PROP_ENUM, PROP_NONE); RNA_def_property_enum_sdna(prop, NULL, "gpencil_tool"); diff --git a/source/blender/makesrna/intern/rna_sculpt_paint.c b/source/blender/makesrna/intern/rna_sculpt_paint.c index a90ab01fc07..a97c971e2d3 100644 --- a/source/blender/makesrna/intern/rna_sculpt_paint.c +++ b/source/blender/makesrna/intern/rna_sculpt_paint.c @@ -333,7 +333,7 @@ static bool rna_Brush_mode_with_tool_poll(PointerRNA *ptr, PointerRNA value) mode = OB_MODE_VERTEX_PAINT; } else if (paint_contains_brush_slot(&ts->wpaint->paint, tslot, &slot_index)) { - if (slot_index != brush->vertexpaint_tool) { + if (slot_index != brush->weightpaint_tool) { return false; } mode = OB_MODE_WEIGHT_PAINT; @@ -453,7 +453,7 @@ static void rna_ImaPaint_viewport_update(Main *UNUSED(bmain), Scene *UNUSED(scen static void rna_ImaPaint_mode_update(bContext *C, PointerRNA *UNUSED(ptr)) { - Scene *scene = CTX_data_scene(C);\ + Scene *scene = CTX_data_scene(C); ViewLayer *view_layer = CTX_data_view_layer(C); Object *ob = OBACT(view_layer);