2011-02-23 10:52:22 +00:00
|
|
|
/*
|
Brush Datablock:
- Added a new Brush datablock, only used by image paint, but intended
to be used in texture paint, vertex paint, weight paint and sculpt
mode also.
- Being a datablock, these brushes can be saved, appended and linked.
They have a fake user by default, to make sure they are saved even if
not selected.
Image Painting:
- Replaced the img module with C code in imagepaint.c
- Airbrush is no longer a separate tool, but rather an option that can
be used for soften, smear and clone also.
- Blend modes mix, add, subtract, multiply, darken and lighten have been
added, code taken directly from vertex paint.
Note to project files maintainers:
- The img module was removed from SCons and Makefiles, and this should
be done in other build systems also. I'll wait to remove the module
from cvs, to not break compilation.
2006-07-26 22:29:23 +00:00
|
|
|
* 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
|
2008-04-16 22:40:48 +00:00
|
|
|
* of the License, or (at your option) any later version.
|
Brush Datablock:
- Added a new Brush datablock, only used by image paint, but intended
to be used in texture paint, vertex paint, weight paint and sculpt
mode also.
- Being a datablock, these brushes can be saved, appended and linked.
They have a fake user by default, to make sure they are saved even if
not selected.
Image Painting:
- Replaced the img module with C code in imagepaint.c
- Airbrush is no longer a separate tool, but rather an option that can
be used for soften, smear and clone also.
- Blend modes mix, add, subtract, multiply, darken and lighten have been
added, code taken directly from vertex paint.
Note to project files maintainers:
- The img module was removed from SCons and Makefiles, and this should
be done in other build systems also. I'll wait to remove the module
from cvs, to not break compilation.
2006-07-26 22:29:23 +00:00
|
|
|
*
|
|
|
|
|
* 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,
|
2010-02-12 13:34:04 +00:00
|
|
|
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
Brush Datablock:
- Added a new Brush datablock, only used by image paint, but intended
to be used in texture paint, vertex paint, weight paint and sculpt
mode also.
- Being a datablock, these brushes can be saved, appended and linked.
They have a fake user by default, to make sure they are saved even if
not selected.
Image Painting:
- Replaced the img module with C code in imagepaint.c
- Airbrush is no longer a separate tool, but rather an option that can
be used for soften, smear and clone also.
- Blend modes mix, add, subtract, multiply, darken and lighten have been
added, code taken directly from vertex paint.
Note to project files maintainers:
- The img module was removed from SCons and Makefiles, and this should
be done in other build systems also. I'll wait to remove the module
from cvs, to not break compilation.
2006-07-26 22:29:23 +00:00
|
|
|
*/
|
|
|
|
|
|
2019-02-18 08:08:12 +11:00
|
|
|
/** \file
|
|
|
|
|
* \ingroup bke
|
2011-02-27 20:40:57 +00:00
|
|
|
*/
|
|
|
|
|
|
Brush Datablock:
- Added a new Brush datablock, only used by image paint, but intended
to be used in texture paint, vertex paint, weight paint and sculpt
mode also.
- Being a datablock, these brushes can be saved, appended and linked.
They have a fake user by default, to make sure they are saved even if
not selected.
Image Painting:
- Replaced the img module with C code in imagepaint.c
- Airbrush is no longer a separate tool, but rather an option that can
be used for soften, smear and clone also.
- Blend modes mix, add, subtract, multiply, darken and lighten have been
added, code taken directly from vertex paint.
Note to project files maintainers:
- The img module was removed from SCons and Makefiles, and this should
be done in other build systems also. I'll wait to remove the module
from cvs, to not break compilation.
2006-07-26 22:29:23 +00:00
|
|
|
#include "MEM_guardedalloc.h"
|
|
|
|
|
|
|
|
|
|
#include "DNA_brush_types.h"
|
2019-09-12 04:34:55 +10:00
|
|
|
#include "DNA_defaults.h"
|
2020-03-19 09:33:03 +01:00
|
|
|
#include "DNA_gpencil_types.h"
|
2020-12-15 10:47:58 +11:00
|
|
|
#include "DNA_material_types.h"
|
2020-03-19 09:33:03 +01:00
|
|
|
#include "DNA_object_types.h"
|
|
|
|
|
#include "DNA_scene_types.h"
|
Brush Datablock:
- Added a new Brush datablock, only used by image paint, but intended
to be used in texture paint, vertex paint, weight paint and sculpt
mode also.
- Being a datablock, these brushes can be saved, appended and linked.
They have a fake user by default, to make sure they are saved even if
not selected.
Image Painting:
- Replaced the img module with C code in imagepaint.c
- Airbrush is no longer a separate tool, but rather an option that can
be used for soften, smear and clone also.
- Blend modes mix, add, subtract, multiply, darken and lighten have been
added, code taken directly from vertex paint.
Note to project files maintainers:
- The img module was removed from SCons and Makefiles, and this should
be done in other build systems also. I'll wait to remove the module
from cvs, to not break compilation.
2006-07-26 22:29:23 +00:00
|
|
|
|
2019-09-27 16:52:08 +02:00
|
|
|
#include "BLI_listbase.h"
|
2009-11-10 20:43:45 +00:00
|
|
|
#include "BLI_math.h"
|
2009-09-18 11:25:52 +00:00
|
|
|
#include "BLI_rand.h"
|
Brush Datablock:
- Added a new Brush datablock, only used by image paint, but intended
to be used in texture paint, vertex paint, weight paint and sculpt
mode also.
- Being a datablock, these brushes can be saved, appended and linked.
They have a fake user by default, to make sure they are saved even if
not selected.
Image Painting:
- Replaced the img module with C code in imagepaint.c
- Airbrush is no longer a separate tool, but rather an option that can
be used for soften, smear and clone also.
- Blend modes mix, add, subtract, multiply, darken and lighten have been
added, code taken directly from vertex paint.
Note to project files maintainers:
- The img module was removed from SCons and Makefiles, and this should
be done in other build systems also. I'll wait to remove the module
from cvs, to not break compilation.
2006-07-26 22:29:23 +00:00
|
|
|
|
2020-03-06 12:47:26 +01:00
|
|
|
#include "BLT_translation.h"
|
|
|
|
|
|
Brush Datablock:
- Added a new Brush datablock, only used by image paint, but intended
to be used in texture paint, vertex paint, weight paint and sculpt
mode also.
- Being a datablock, these brushes can be saved, appended and linked.
They have a fake user by default, to make sure they are saved even if
not selected.
Image Painting:
- Replaced the img module with C code in imagepaint.c
- Airbrush is no longer a separate tool, but rather an option that can
be used for soften, smear and clone also.
- Blend modes mix, add, subtract, multiply, darken and lighten have been
added, code taken directly from vertex paint.
Note to project files maintainers:
- The img module was removed from SCons and Makefiles, and this should
be done in other build systems also. I'll wait to remove the module
from cvs, to not break compilation.
2006-07-26 22:29:23 +00:00
|
|
|
#include "BKE_brush.h"
|
2009-01-10 19:34:23 +00:00
|
|
|
#include "BKE_colortools.h"
|
2018-07-31 10:22:19 +02:00
|
|
|
#include "BKE_context.h"
|
2020-09-01 14:48:10 +10:00
|
|
|
#include "BKE_gpencil.h"
|
2020-03-19 09:33:03 +01:00
|
|
|
#include "BKE_icons.h"
|
2020-03-06 12:47:26 +01:00
|
|
|
#include "BKE_idtype.h"
|
2020-02-10 12:58:59 +01:00
|
|
|
#include "BKE_lib_id.h"
|
|
|
|
|
#include "BKE_lib_query.h"
|
|
|
|
|
#include "BKE_lib_remap.h"
|
Brush Datablock:
- Added a new Brush datablock, only used by image paint, but intended
to be used in texture paint, vertex paint, weight paint and sculpt
mode also.
- Being a datablock, these brushes can be saved, appended and linked.
They have a fake user by default, to make sure they are saved even if
not selected.
Image Painting:
- Replaced the img module with C code in imagepaint.c
- Airbrush is no longer a separate tool, but rather an option that can
be used for soften, smear and clone also.
- Blend modes mix, add, subtract, multiply, darken and lighten have been
added, code taken directly from vertex paint.
Note to project files maintainers:
- The img module was removed from SCons and Makefiles, and this should
be done in other build systems also. I'll wait to remove the module
from cvs, to not break compilation.
2006-07-26 22:29:23 +00:00
|
|
|
#include "BKE_main.h"
|
2019-09-27 16:52:08 +02:00
|
|
|
#include "BKE_material.h"
|
2009-08-17 04:40:59 +00:00
|
|
|
#include "BKE_paint.h"
|
2006-07-31 15:53:03 +00:00
|
|
|
#include "BKE_texture.h"
|
2009-12-24 16:10:26 +00:00
|
|
|
|
2013-12-03 22:13:15 +06:00
|
|
|
#include "IMB_colormanagement.h"
|
2006-07-31 15:53:03 +00:00
|
|
|
#include "IMB_imbuf.h"
|
|
|
|
|
#include "IMB_imbuf_types.h"
|
|
|
|
|
|
2020-11-09 15:42:38 +01:00
|
|
|
#include "RE_texture.h" /* RE_texture_evaluate */
|
2006-07-31 15:53:03 +00:00
|
|
|
|
2020-09-10 15:50:50 +02:00
|
|
|
#include "BLO_read_write.h"
|
|
|
|
|
|
2020-03-06 12:47:26 +01:00
|
|
|
static void brush_init_data(ID *id)
|
|
|
|
|
{
|
|
|
|
|
Brush *brush = (Brush *)id;
|
|
|
|
|
BLI_assert(MEMCMP_STRUCT_AFTER_IS_ZERO(brush, id));
|
|
|
|
|
|
|
|
|
|
MEMCPY_STRUCT_AFTER(brush, DNA_struct_default_get(Brush), id);
|
|
|
|
|
|
|
|
|
|
/* enable fake user by default */
|
|
|
|
|
id_fake_user_set(&brush->id);
|
|
|
|
|
|
|
|
|
|
/* the default alpha falloff curve */
|
|
|
|
|
BKE_brush_curve_preset(brush, CURVE_PRESET_SMOOTH);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void brush_copy_data(Main *UNUSED(bmain), ID *id_dst, const ID *id_src, const int flag)
|
|
|
|
|
{
|
|
|
|
|
Brush *brush_dst = (Brush *)id_dst;
|
|
|
|
|
const Brush *brush_src = (const Brush *)id_src;
|
|
|
|
|
if (brush_src->icon_imbuf) {
|
|
|
|
|
brush_dst->icon_imbuf = IMB_dupImBuf(brush_src->icon_imbuf);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if ((flag & LIB_ID_COPY_NO_PREVIEW) == 0) {
|
|
|
|
|
BKE_previewimg_id_copy(&brush_dst->id, &brush_src->id);
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
brush_dst->preview = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
brush_dst->curve = BKE_curvemapping_copy(brush_src->curve);
|
|
|
|
|
if (brush_src->gpencil_settings != NULL) {
|
|
|
|
|
brush_dst->gpencil_settings = MEM_dupallocN(brush_src->gpencil_settings);
|
|
|
|
|
brush_dst->gpencil_settings->curve_sensitivity = BKE_curvemapping_copy(
|
|
|
|
|
brush_src->gpencil_settings->curve_sensitivity);
|
|
|
|
|
brush_dst->gpencil_settings->curve_strength = BKE_curvemapping_copy(
|
|
|
|
|
brush_src->gpencil_settings->curve_strength);
|
|
|
|
|
brush_dst->gpencil_settings->curve_jitter = BKE_curvemapping_copy(
|
|
|
|
|
brush_src->gpencil_settings->curve_jitter);
|
2020-05-07 15:02:21 +02:00
|
|
|
|
|
|
|
|
brush_dst->gpencil_settings->curve_rand_pressure = BKE_curvemapping_copy(
|
|
|
|
|
brush_src->gpencil_settings->curve_rand_pressure);
|
|
|
|
|
brush_dst->gpencil_settings->curve_rand_strength = BKE_curvemapping_copy(
|
|
|
|
|
brush_src->gpencil_settings->curve_rand_strength);
|
|
|
|
|
brush_dst->gpencil_settings->curve_rand_uv = BKE_curvemapping_copy(
|
|
|
|
|
brush_src->gpencil_settings->curve_rand_uv);
|
|
|
|
|
brush_dst->gpencil_settings->curve_rand_hue = BKE_curvemapping_copy(
|
|
|
|
|
brush_src->gpencil_settings->curve_rand_hue);
|
|
|
|
|
brush_dst->gpencil_settings->curve_rand_saturation = BKE_curvemapping_copy(
|
|
|
|
|
brush_src->gpencil_settings->curve_rand_saturation);
|
|
|
|
|
brush_dst->gpencil_settings->curve_rand_value = BKE_curvemapping_copy(
|
|
|
|
|
brush_src->gpencil_settings->curve_rand_value);
|
2020-03-06 12:47:26 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* enable fake user by default */
|
|
|
|
|
id_fake_user_set(&brush_dst->id);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void brush_free_data(ID *id)
|
|
|
|
|
{
|
|
|
|
|
Brush *brush = (Brush *)id;
|
|
|
|
|
if (brush->icon_imbuf) {
|
|
|
|
|
IMB_freeImBuf(brush->icon_imbuf);
|
|
|
|
|
}
|
|
|
|
|
BKE_curvemapping_free(brush->curve);
|
|
|
|
|
|
|
|
|
|
if (brush->gpencil_settings != NULL) {
|
|
|
|
|
BKE_curvemapping_free(brush->gpencil_settings->curve_sensitivity);
|
|
|
|
|
BKE_curvemapping_free(brush->gpencil_settings->curve_strength);
|
|
|
|
|
BKE_curvemapping_free(brush->gpencil_settings->curve_jitter);
|
2020-05-07 15:02:21 +02:00
|
|
|
|
|
|
|
|
BKE_curvemapping_free(brush->gpencil_settings->curve_rand_pressure);
|
|
|
|
|
BKE_curvemapping_free(brush->gpencil_settings->curve_rand_strength);
|
|
|
|
|
BKE_curvemapping_free(brush->gpencil_settings->curve_rand_uv);
|
|
|
|
|
BKE_curvemapping_free(brush->gpencil_settings->curve_rand_hue);
|
|
|
|
|
BKE_curvemapping_free(brush->gpencil_settings->curve_rand_saturation);
|
|
|
|
|
BKE_curvemapping_free(brush->gpencil_settings->curve_rand_value);
|
|
|
|
|
|
2020-03-06 12:47:26 +01:00
|
|
|
MEM_SAFE_FREE(brush->gpencil_settings);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
MEM_SAFE_FREE(brush->gradient);
|
|
|
|
|
|
|
|
|
|
BKE_previewimg_free(&(brush->preview));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void brush_make_local(Main *bmain, ID *id, const int flags)
|
|
|
|
|
{
|
|
|
|
|
Brush *brush = (Brush *)id;
|
|
|
|
|
const bool lib_local = (flags & LIB_ID_MAKELOCAL_FULL_LIBRARY) != 0;
|
|
|
|
|
bool is_local = false, is_lib = false;
|
|
|
|
|
|
|
|
|
|
/* - only lib users: do nothing (unless force_local is set)
|
|
|
|
|
* - only local users: set flag
|
|
|
|
|
* - mixed: make copy
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
if (!ID_IS_LINKED(brush)) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (brush->clone.image) {
|
|
|
|
|
/* Special case: ima always local immediately. Clone image should only have one user anyway. */
|
|
|
|
|
BKE_lib_id_make_local(bmain, &brush->clone.image->id, false, 0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
BKE_library_ID_test_usages(bmain, brush, &is_local, &is_lib);
|
|
|
|
|
|
|
|
|
|
if (lib_local || is_local) {
|
|
|
|
|
if (!is_lib) {
|
|
|
|
|
BKE_lib_id_clear_library_data(bmain, &brush->id);
|
|
|
|
|
BKE_lib_id_expand_local(bmain, &brush->id);
|
|
|
|
|
|
|
|
|
|
/* enable fake user by default */
|
|
|
|
|
id_fake_user_set(&brush->id);
|
|
|
|
|
}
|
|
|
|
|
else {
|
2020-10-07 18:01:25 +02:00
|
|
|
Brush *brush_new = (Brush *)BKE_id_copy(bmain, &brush->id); /* Ensures FAKE_USER is set */
|
2020-03-06 12:47:26 +01:00
|
|
|
|
|
|
|
|
brush_new->id.us = 0;
|
|
|
|
|
|
|
|
|
|
/* setting newid is mandatory for complex make_lib_local logic... */
|
|
|
|
|
ID_NEW_SET(brush, brush_new);
|
|
|
|
|
|
|
|
|
|
if (!lib_local) {
|
|
|
|
|
BKE_libblock_remap(bmain, brush, brush_new, ID_REMAP_SKIP_INDIRECT_USAGE);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2020-05-13 19:52:19 +02:00
|
|
|
static void brush_foreach_id(ID *id, LibraryForeachIDData *data)
|
|
|
|
|
{
|
|
|
|
|
Brush *brush = (Brush *)id;
|
|
|
|
|
|
|
|
|
|
BKE_LIB_FOREACHID_PROCESS(data, brush->toggle_brush, IDWALK_CB_NOP);
|
|
|
|
|
BKE_LIB_FOREACHID_PROCESS(data, brush->clone.image, IDWALK_CB_NOP);
|
|
|
|
|
BKE_LIB_FOREACHID_PROCESS(data, brush->paint_curve, IDWALK_CB_USER);
|
|
|
|
|
if (brush->gpencil_settings) {
|
|
|
|
|
BKE_LIB_FOREACHID_PROCESS(data, brush->gpencil_settings->material, IDWALK_CB_USER);
|
|
|
|
|
}
|
|
|
|
|
BKE_texture_mtex_foreach_id(data, &brush->mtex);
|
|
|
|
|
BKE_texture_mtex_foreach_id(data, &brush->mask_mtex);
|
|
|
|
|
}
|
|
|
|
|
|
2020-09-10 15:50:50 +02:00
|
|
|
static void brush_blend_write(BlendWriter *writer, ID *id, const void *id_address)
|
|
|
|
|
{
|
|
|
|
|
Brush *brush = (Brush *)id;
|
|
|
|
|
if (brush->id.us > 0 || BLO_write_is_undo(writer)) {
|
|
|
|
|
BLO_write_id_struct(writer, Brush, id_address, &brush->id);
|
|
|
|
|
BKE_id_blend_write(writer, &brush->id);
|
|
|
|
|
|
|
|
|
|
if (brush->curve) {
|
|
|
|
|
BKE_curvemapping_blend_write(writer, brush->curve);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (brush->gpencil_settings) {
|
|
|
|
|
BLO_write_struct(writer, BrushGpencilSettings, brush->gpencil_settings);
|
|
|
|
|
|
|
|
|
|
if (brush->gpencil_settings->curve_sensitivity) {
|
|
|
|
|
BKE_curvemapping_blend_write(writer, brush->gpencil_settings->curve_sensitivity);
|
|
|
|
|
}
|
|
|
|
|
if (brush->gpencil_settings->curve_strength) {
|
|
|
|
|
BKE_curvemapping_blend_write(writer, brush->gpencil_settings->curve_strength);
|
|
|
|
|
}
|
|
|
|
|
if (brush->gpencil_settings->curve_jitter) {
|
|
|
|
|
BKE_curvemapping_blend_write(writer, brush->gpencil_settings->curve_jitter);
|
|
|
|
|
}
|
|
|
|
|
if (brush->gpencil_settings->curve_rand_pressure) {
|
|
|
|
|
BKE_curvemapping_blend_write(writer, brush->gpencil_settings->curve_rand_pressure);
|
|
|
|
|
}
|
|
|
|
|
if (brush->gpencil_settings->curve_rand_strength) {
|
|
|
|
|
BKE_curvemapping_blend_write(writer, brush->gpencil_settings->curve_rand_strength);
|
|
|
|
|
}
|
|
|
|
|
if (brush->gpencil_settings->curve_rand_uv) {
|
|
|
|
|
BKE_curvemapping_blend_write(writer, brush->gpencil_settings->curve_rand_uv);
|
|
|
|
|
}
|
|
|
|
|
if (brush->gpencil_settings->curve_rand_hue) {
|
|
|
|
|
BKE_curvemapping_blend_write(writer, brush->gpencil_settings->curve_rand_hue);
|
|
|
|
|
}
|
|
|
|
|
if (brush->gpencil_settings->curve_rand_saturation) {
|
|
|
|
|
BKE_curvemapping_blend_write(writer, brush->gpencil_settings->curve_rand_saturation);
|
|
|
|
|
}
|
|
|
|
|
if (brush->gpencil_settings->curve_rand_value) {
|
|
|
|
|
BKE_curvemapping_blend_write(writer, brush->gpencil_settings->curve_rand_value);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (brush->gradient) {
|
|
|
|
|
BLO_write_struct(writer, ColorBand, brush->gradient);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void brush_blend_read_data(BlendDataReader *reader, ID *id)
|
|
|
|
|
{
|
|
|
|
|
Brush *brush = (Brush *)id;
|
|
|
|
|
|
2020-09-21 15:17:41 +02:00
|
|
|
/* Falloff curve. */
|
2020-09-10 15:50:50 +02:00
|
|
|
BLO_read_data_address(reader, &brush->curve);
|
|
|
|
|
|
|
|
|
|
BLO_read_data_address(reader, &brush->gradient);
|
|
|
|
|
|
|
|
|
|
if (brush->curve) {
|
|
|
|
|
BKE_curvemapping_blend_read(reader, brush->curve);
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
BKE_brush_curve_preset(brush, CURVE_PRESET_SHARP);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* grease pencil */
|
|
|
|
|
BLO_read_data_address(reader, &brush->gpencil_settings);
|
|
|
|
|
if (brush->gpencil_settings != NULL) {
|
|
|
|
|
BLO_read_data_address(reader, &brush->gpencil_settings->curve_sensitivity);
|
|
|
|
|
BLO_read_data_address(reader, &brush->gpencil_settings->curve_strength);
|
|
|
|
|
BLO_read_data_address(reader, &brush->gpencil_settings->curve_jitter);
|
|
|
|
|
|
|
|
|
|
BLO_read_data_address(reader, &brush->gpencil_settings->curve_rand_pressure);
|
|
|
|
|
BLO_read_data_address(reader, &brush->gpencil_settings->curve_rand_strength);
|
|
|
|
|
BLO_read_data_address(reader, &brush->gpencil_settings->curve_rand_uv);
|
|
|
|
|
BLO_read_data_address(reader, &brush->gpencil_settings->curve_rand_hue);
|
|
|
|
|
BLO_read_data_address(reader, &brush->gpencil_settings->curve_rand_saturation);
|
|
|
|
|
BLO_read_data_address(reader, &brush->gpencil_settings->curve_rand_value);
|
|
|
|
|
|
|
|
|
|
if (brush->gpencil_settings->curve_sensitivity) {
|
|
|
|
|
BKE_curvemapping_blend_read(reader, brush->gpencil_settings->curve_sensitivity);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (brush->gpencil_settings->curve_strength) {
|
|
|
|
|
BKE_curvemapping_blend_read(reader, brush->gpencil_settings->curve_strength);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (brush->gpencil_settings->curve_jitter) {
|
|
|
|
|
BKE_curvemapping_blend_read(reader, brush->gpencil_settings->curve_jitter);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (brush->gpencil_settings->curve_rand_pressure) {
|
|
|
|
|
BKE_curvemapping_blend_read(reader, brush->gpencil_settings->curve_rand_pressure);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (brush->gpencil_settings->curve_rand_strength) {
|
|
|
|
|
BKE_curvemapping_blend_read(reader, brush->gpencil_settings->curve_rand_strength);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (brush->gpencil_settings->curve_rand_uv) {
|
|
|
|
|
BKE_curvemapping_blend_read(reader, brush->gpencil_settings->curve_rand_uv);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (brush->gpencil_settings->curve_rand_hue) {
|
|
|
|
|
BKE_curvemapping_blend_read(reader, brush->gpencil_settings->curve_rand_hue);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (brush->gpencil_settings->curve_rand_saturation) {
|
|
|
|
|
BKE_curvemapping_blend_read(reader, brush->gpencil_settings->curve_rand_saturation);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (brush->gpencil_settings->curve_rand_value) {
|
|
|
|
|
BKE_curvemapping_blend_read(reader, brush->gpencil_settings->curve_rand_value);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
brush->preview = NULL;
|
|
|
|
|
brush->icon_imbuf = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void brush_blend_read_lib(BlendLibReader *reader, ID *id)
|
|
|
|
|
{
|
|
|
|
|
Brush *brush = (Brush *)id;
|
|
|
|
|
|
|
|
|
|
/* brush->(mask_)mtex.obj is ignored on purpose? */
|
|
|
|
|
BLO_read_id_address(reader, brush->id.lib, &brush->mtex.tex);
|
|
|
|
|
BLO_read_id_address(reader, brush->id.lib, &brush->mask_mtex.tex);
|
|
|
|
|
BLO_read_id_address(reader, brush->id.lib, &brush->clone.image);
|
|
|
|
|
BLO_read_id_address(reader, brush->id.lib, &brush->toggle_brush);
|
|
|
|
|
BLO_read_id_address(reader, brush->id.lib, &brush->paint_curve);
|
|
|
|
|
|
|
|
|
|
/* link default grease pencil palette */
|
|
|
|
|
if (brush->gpencil_settings != NULL) {
|
|
|
|
|
if (brush->gpencil_settings->flag & GP_BRUSH_MATERIAL_PINNED) {
|
|
|
|
|
BLO_read_id_address(reader, brush->id.lib, &brush->gpencil_settings->material);
|
|
|
|
|
|
|
|
|
|
if (!brush->gpencil_settings->material) {
|
|
|
|
|
brush->gpencil_settings->flag &= ~GP_BRUSH_MATERIAL_PINNED;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
brush->gpencil_settings->material = NULL;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void brush_blend_read_expand(BlendExpander *expander, ID *id)
|
|
|
|
|
{
|
|
|
|
|
Brush *brush = (Brush *)id;
|
|
|
|
|
BLO_expand(expander, brush->mtex.tex);
|
|
|
|
|
BLO_expand(expander, brush->mask_mtex.tex);
|
|
|
|
|
BLO_expand(expander, brush->clone.image);
|
|
|
|
|
BLO_expand(expander, brush->paint_curve);
|
|
|
|
|
if (brush->gpencil_settings != NULL) {
|
|
|
|
|
BLO_expand(expander, brush->gpencil_settings->material);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2020-11-03 12:09:00 +01:00
|
|
|
static int brush_undo_preserve_cb(LibraryIDLinkCallbackData *cb_data)
|
|
|
|
|
{
|
|
|
|
|
BlendLibReader *reader = cb_data->user_data;
|
|
|
|
|
ID *id_old = *cb_data->id_pointer;
|
|
|
|
|
/* Old data has not been remapped to new values of the pointers, if we want to keep the old
|
|
|
|
|
* pointer here we need its new address. */
|
|
|
|
|
ID *id_old_new = id_old != NULL ? BLO_read_get_new_id_address(reader, id_old->lib, id_old) :
|
|
|
|
|
NULL;
|
|
|
|
|
BLI_assert(id_old_new == NULL || ELEM(id_old, id_old_new, id_old_new->orig_id));
|
|
|
|
|
if (cb_data->cb_flag & IDWALK_CB_USER) {
|
|
|
|
|
id_us_plus_no_lib(id_old_new);
|
|
|
|
|
id_us_min(id_old);
|
|
|
|
|
}
|
|
|
|
|
*cb_data->id_pointer = id_old_new;
|
|
|
|
|
return IDWALK_RET_NOP;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void brush_undo_preserve(BlendLibReader *reader, ID *id_new, ID *id_old)
|
|
|
|
|
{
|
|
|
|
|
/* Whole Brush is preserved accross undo's. */
|
|
|
|
|
BKE_lib_id_swap(NULL, id_new, id_old);
|
|
|
|
|
|
|
|
|
|
/* `id_new` now has content from `id_old`, we need to ensure those old ID pointers are valid.
|
|
|
|
|
* Note: Since we want to re-use all old pointers here, code is much simpler than for Scene. */
|
|
|
|
|
BKE_library_foreach_ID_link(NULL, id_new, brush_undo_preserve_cb, reader, IDWALK_NOP);
|
|
|
|
|
|
|
|
|
|
/* Note: We do not swap IDProperties, as dealing with potential ID pointers in those would be
|
|
|
|
|
* fairly delicate. */
|
|
|
|
|
SWAP(IDProperty *, id_new->properties, id_old->properties);
|
|
|
|
|
}
|
|
|
|
|
|
2020-03-06 12:47:26 +01:00
|
|
|
IDTypeInfo IDType_ID_BR = {
|
|
|
|
|
.id_code = ID_BR,
|
|
|
|
|
.id_filter = FILTER_ID_BR,
|
|
|
|
|
.main_listbase_index = INDEX_ID_BR,
|
|
|
|
|
.struct_size = sizeof(Brush),
|
|
|
|
|
.name = "Brush",
|
|
|
|
|
.name_plural = "brushes",
|
|
|
|
|
.translation_context = BLT_I18NCONTEXT_ID_BRUSH,
|
2020-10-07 12:35:58 +02:00
|
|
|
.flags = IDTYPE_FLAGS_NO_ANIMDATA,
|
2020-03-06 12:47:26 +01:00
|
|
|
|
|
|
|
|
.init_data = brush_init_data,
|
|
|
|
|
.copy_data = brush_copy_data,
|
|
|
|
|
.free_data = brush_free_data,
|
|
|
|
|
.make_local = brush_make_local,
|
2020-05-13 19:52:19 +02:00
|
|
|
.foreach_id = brush_foreach_id,
|
2020-08-28 13:05:48 +02:00
|
|
|
.foreach_cache = NULL,
|
|
|
|
|
|
2020-09-10 15:50:50 +02:00
|
|
|
.blend_write = brush_blend_write,
|
|
|
|
|
.blend_read_data = brush_blend_read_data,
|
|
|
|
|
.blend_read_lib = brush_blend_read_lib,
|
|
|
|
|
.blend_read_expand = brush_blend_read_expand,
|
2020-11-03 11:39:36 +01:00
|
|
|
|
2020-11-03 12:09:00 +01:00
|
|
|
.blend_read_undo_preserve = brush_undo_preserve,
|
2020-03-06 12:47:26 +01:00
|
|
|
};
|
|
|
|
|
|
2013-03-19 14:25:12 +00:00
|
|
|
static RNG *brush_rng;
|
|
|
|
|
|
2013-03-19 23:17:44 +00:00
|
|
|
void BKE_brush_system_init(void)
|
|
|
|
|
{
|
2013-03-19 14:25:12 +00:00
|
|
|
brush_rng = BLI_rng_new(0);
|
|
|
|
|
BLI_rng_srandom(brush_rng, 31415682);
|
|
|
|
|
}
|
|
|
|
|
|
2013-03-19 23:17:44 +00:00
|
|
|
void BKE_brush_system_exit(void)
|
|
|
|
|
{
|
2019-11-15 15:13:06 +01:00
|
|
|
if (brush_rng == NULL) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
2013-03-19 14:25:12 +00:00
|
|
|
BLI_rng_free(brush_rng);
|
2019-11-15 15:13:06 +01:00
|
|
|
brush_rng = NULL;
|
2013-03-19 14:25:12 +00:00
|
|
|
}
|
|
|
|
|
|
2012-05-05 00:58:22 +00:00
|
|
|
static void brush_defaults(Brush *brush)
|
Brush Datablock:
- Added a new Brush datablock, only used by image paint, but intended
to be used in texture paint, vertex paint, weight paint and sculpt
mode also.
- Being a datablock, these brushes can be saved, appended and linked.
They have a fake user by default, to make sure they are saved even if
not selected.
Image Painting:
- Replaced the img module with C code in imagepaint.c
- Airbrush is no longer a separate tool, but rather an option that can
be used for soften, smear and clone also.
- Blend modes mix, add, subtract, multiply, darken and lighten have been
added, code taken directly from vertex paint.
Note to project files maintainers:
- The img module was removed from SCons and Makefiles, and this should
be done in other build systems also. I'll wait to remove the module
from cvs, to not break compilation.
2006-07-26 22:29:23 +00:00
|
|
|
{
|
2019-09-12 04:34:55 +10:00
|
|
|
|
|
|
|
|
const Brush *brush_def = DNA_struct_default_get(Brush);
|
|
|
|
|
|
|
|
|
|
#define FROM_DEFAULT(member) memcpy(&brush->member, &brush_def->member, sizeof(brush->member))
|
|
|
|
|
#define FROM_DEFAULT_PTR(member) memcpy(brush->member, brush_def->member, sizeof(brush->member))
|
|
|
|
|
|
|
|
|
|
FROM_DEFAULT(blend);
|
|
|
|
|
FROM_DEFAULT(flag);
|
|
|
|
|
FROM_DEFAULT(weight);
|
|
|
|
|
FROM_DEFAULT(size);
|
|
|
|
|
FROM_DEFAULT(alpha);
|
2020-03-02 15:45:15 +01:00
|
|
|
FROM_DEFAULT(hardness);
|
2019-09-12 04:34:55 +10:00
|
|
|
FROM_DEFAULT(autosmooth_factor);
|
|
|
|
|
FROM_DEFAULT(topology_rake_factor);
|
|
|
|
|
FROM_DEFAULT(crease_pinch_factor);
|
|
|
|
|
FROM_DEFAULT(normal_radius_factor);
|
2020-11-17 22:33:09 +01:00
|
|
|
FROM_DEFAULT(wet_paint_radius_factor);
|
2019-12-16 23:16:21 +01:00
|
|
|
FROM_DEFAULT(area_radius_factor);
|
2020-06-23 16:10:47 +02:00
|
|
|
FROM_DEFAULT(disconnected_distance_max);
|
2019-09-12 04:34:55 +10:00
|
|
|
FROM_DEFAULT(sculpt_plane);
|
|
|
|
|
FROM_DEFAULT(plane_offset);
|
|
|
|
|
FROM_DEFAULT(clone.alpha);
|
|
|
|
|
FROM_DEFAULT(normal_weight);
|
|
|
|
|
FROM_DEFAULT(fill_threshold);
|
|
|
|
|
FROM_DEFAULT(flag);
|
2019-10-30 16:57:11 +01:00
|
|
|
FROM_DEFAULT(sampling_flag);
|
2019-09-12 04:34:55 +10:00
|
|
|
FROM_DEFAULT_PTR(rgb);
|
|
|
|
|
FROM_DEFAULT_PTR(secondary_rgb);
|
|
|
|
|
FROM_DEFAULT(spacing);
|
|
|
|
|
FROM_DEFAULT(smooth_stroke_radius);
|
|
|
|
|
FROM_DEFAULT(smooth_stroke_factor);
|
|
|
|
|
FROM_DEFAULT(rate);
|
|
|
|
|
FROM_DEFAULT(jitter);
|
|
|
|
|
FROM_DEFAULT(texture_sample_bias);
|
|
|
|
|
FROM_DEFAULT(texture_overlay_alpha);
|
|
|
|
|
FROM_DEFAULT(mask_overlay_alpha);
|
|
|
|
|
FROM_DEFAULT(cursor_overlay_alpha);
|
|
|
|
|
FROM_DEFAULT(overlay_flags);
|
|
|
|
|
FROM_DEFAULT_PTR(add_col);
|
|
|
|
|
FROM_DEFAULT_PTR(sub_col);
|
|
|
|
|
FROM_DEFAULT(stencil_pos);
|
|
|
|
|
FROM_DEFAULT(stencil_dimension);
|
|
|
|
|
FROM_DEFAULT(mtex);
|
|
|
|
|
FROM_DEFAULT(mask_mtex);
|
|
|
|
|
|
|
|
|
|
#undef FROM_DEFAULT
|
|
|
|
|
#undef FROM_DEFAULT_PTR
|
2010-07-27 16:09:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Datablock add/copy/free/make_local */
|
|
|
|
|
|
2018-01-10 19:34:34 +11:00
|
|
|
/**
|
2019-04-27 12:07:07 +10:00
|
|
|
* \note Resulting brush will have two users: one as a fake user,
|
|
|
|
|
* another is assumed to be used by the caller.
|
2018-01-10 19:57:02 +11:00
|
|
|
*/
|
2018-02-06 23:34:58 +11:00
|
|
|
Brush *BKE_brush_add(Main *bmain, const char *name, const eObjectMode ob_mode)
|
First step to handle missing libs/datablocks when reading a file.
Idea is, instead of ignoring completely missing linked datablocks, to
create void placeholders for them.
That way, you can work on your file, save it, and find again your missing data once
lib becomes available again. Or you can edit missing lib's path (in Outliner),
save and reload the file, and you are done.
Also, Outliner now shows broken libraries (and placeholders) with a 'broken lib' icon.
Future plans are also to be able to relocate missing libs and reload them at runtime.
Code notes:
- Placeholder ID is just a regular datablock of same type as expected linked one,
with 'default' data, and a LIB_MISSING bitflag set.
- To allow creation of such datablocks, creation of datablocks in BKE was split in two step:
+ Allocation of memory itself.
+ Setting of all internal data to default values.
See also the design task (T43351).
Reviewed by @campbellbarton, thanks a bunch!
Differential Revision: https://developer.blender.org/D1394
2015-10-20 14:44:57 +02:00
|
|
|
{
|
|
|
|
|
Brush *brush;
|
|
|
|
|
|
2020-10-08 12:50:04 +02:00
|
|
|
brush = BKE_id_new(bmain, ID_BR, name);
|
First step to handle missing libs/datablocks when reading a file.
Idea is, instead of ignoring completely missing linked datablocks, to
create void placeholders for them.
That way, you can work on your file, save it, and find again your missing data once
lib becomes available again. Or you can edit missing lib's path (in Outliner),
save and reload the file, and you are done.
Also, Outliner now shows broken libraries (and placeholders) with a 'broken lib' icon.
Future plans are also to be able to relocate missing libs and reload them at runtime.
Code notes:
- Placeholder ID is just a regular datablock of same type as expected linked one,
with 'default' data, and a LIB_MISSING bitflag set.
- To allow creation of such datablocks, creation of datablocks in BKE was split in two step:
+ Allocation of memory itself.
+ Setting of all internal data to default values.
See also the design task (T43351).
Reviewed by @campbellbarton, thanks a bunch!
Differential Revision: https://developer.blender.org/D1394
2015-10-20 14:44:57 +02:00
|
|
|
|
|
|
|
|
brush->ob_mode = ob_mode;
|
2010-07-14 14:11:03 +00:00
|
|
|
|
|
|
|
|
return brush;
|
Brush Datablock:
- Added a new Brush datablock, only used by image paint, but intended
to be used in texture paint, vertex paint, weight paint and sculpt
mode also.
- Being a datablock, these brushes can be saved, appended and linked.
They have a fake user by default, to make sure they are saved even if
not selected.
Image Painting:
- Replaced the img module with C code in imagepaint.c
- Airbrush is no longer a separate tool, but rather an option that can
be used for soften, smear and clone also.
- Blend modes mix, add, subtract, multiply, darken and lighten have been
added, code taken directly from vertex paint.
Note to project files maintainers:
- The img module was removed from SCons and Makefiles, and this should
be done in other build systems also. I'll wait to remove the module
from cvs, to not break compilation.
2006-07-26 22:29:23 +00:00
|
|
|
}
|
|
|
|
|
|
2018-10-29 16:42:47 +01:00
|
|
|
/* add grease pencil settings */
|
2018-08-05 16:19:24 +02:00
|
|
|
void BKE_brush_init_gpencil_settings(Brush *brush)
|
2018-07-31 10:22:19 +02:00
|
|
|
{
|
2018-08-05 16:19:24 +02:00
|
|
|
if (brush->gpencil_settings == NULL) {
|
|
|
|
|
brush->gpencil_settings = MEM_callocN(sizeof(BrushGpencilSettings), "BrushGpencilSettings");
|
|
|
|
|
}
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2018-07-31 10:22:19 +02:00
|
|
|
brush->gpencil_settings->draw_smoothlvl = 1;
|
|
|
|
|
brush->gpencil_settings->flag = 0;
|
|
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_PRESSURE;
|
|
|
|
|
brush->gpencil_settings->draw_strength = 1.0f;
|
|
|
|
|
brush->gpencil_settings->draw_jitter = 0.0f;
|
|
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_JITTER_PRESSURE;
|
|
|
|
|
brush->gpencil_settings->icon_id = GP_BRUSH_ICON_PEN;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2018-07-31 10:22:19 +02:00
|
|
|
/* curves */
|
2019-08-07 03:21:55 +10:00
|
|
|
brush->gpencil_settings->curve_sensitivity = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
|
|
|
|
|
brush->gpencil_settings->curve_strength = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
|
|
|
|
|
brush->gpencil_settings->curve_jitter = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
|
2020-05-07 15:02:21 +02:00
|
|
|
|
|
|
|
|
brush->gpencil_settings->curve_rand_pressure = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
|
|
|
|
|
brush->gpencil_settings->curve_rand_strength = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
|
|
|
|
|
brush->gpencil_settings->curve_rand_uv = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
|
|
|
|
|
brush->gpencil_settings->curve_rand_hue = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
|
|
|
|
|
brush->gpencil_settings->curve_rand_saturation = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
|
|
|
|
|
brush->gpencil_settings->curve_rand_value = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
|
2018-08-05 16:19:24 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* add a new gp-brush */
|
2020-03-09 16:27:24 +01:00
|
|
|
Brush *BKE_brush_add_gpencil(Main *bmain, ToolSettings *ts, const char *name, eObjectMode mode)
|
2018-08-05 16:19:24 +02:00
|
|
|
{
|
2020-03-09 16:27:24 +01:00
|
|
|
Paint *paint = NULL;
|
2018-08-05 16:19:24 +02:00
|
|
|
Brush *brush;
|
2020-03-09 16:27:24 +01:00
|
|
|
switch (mode) {
|
|
|
|
|
case OB_MODE_PAINT_GPENCIL: {
|
|
|
|
|
paint = &ts->gp_paint->paint;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case OB_MODE_SCULPT_GPENCIL: {
|
|
|
|
|
paint = &ts->gp_sculptpaint->paint;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case OB_MODE_WEIGHT_GPENCIL: {
|
|
|
|
|
paint = &ts->gp_weightpaint->paint;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case OB_MODE_VERTEX_GPENCIL: {
|
|
|
|
|
paint = &ts->gp_vertexpaint->paint;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
default:
|
|
|
|
|
paint = &ts->gp_paint->paint;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
brush = BKE_brush_add(bmain, name, mode);
|
2018-08-05 16:19:24 +02:00
|
|
|
|
|
|
|
|
BKE_paint_brush_set(paint, brush);
|
|
|
|
|
id_us_min(&brush->id);
|
|
|
|
|
|
|
|
|
|
brush->size = 3;
|
|
|
|
|
|
|
|
|
|
/* grease pencil basic settings */
|
|
|
|
|
BKE_brush_init_gpencil_settings(brush);
|
2018-07-31 10:22:19 +02:00
|
|
|
|
|
|
|
|
/* return brush */
|
|
|
|
|
return brush;
|
|
|
|
|
}
|
|
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
/* Delete a Brush. */
|
|
|
|
|
bool BKE_brush_delete(Main *bmain, Brush *brush)
|
|
|
|
|
{
|
|
|
|
|
if (brush->id.tag & LIB_TAG_INDIRECT) {
|
|
|
|
|
return false;
|
|
|
|
|
}
|
2020-07-03 18:04:40 +02:00
|
|
|
if (BKE_library_ID_is_indirectly_used(bmain, brush) && ID_REAL_USERS(brush) <= 1 &&
|
|
|
|
|
ID_EXTRA_USERS(brush) == 0) {
|
2020-03-09 16:27:24 +01:00
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
BKE_id_delete(bmain, brush);
|
|
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
2018-07-31 10:22:19 +02:00
|
|
|
/* grease pencil cumapping->preset */
|
|
|
|
|
typedef enum eGPCurveMappingPreset {
|
|
|
|
|
GPCURVE_PRESET_PENCIL = 0,
|
|
|
|
|
GPCURVE_PRESET_INK = 1,
|
|
|
|
|
GPCURVE_PRESET_INKNOISE = 2,
|
2019-04-16 16:40:47 +02:00
|
|
|
GPCURVE_PRESET_MARKER = 3,
|
2020-05-03 13:33:58 +02:00
|
|
|
GPCURVE_PRESET_CHISEL_SENSIVITY = 4,
|
|
|
|
|
GPCURVE_PRESET_CHISEL_STRENGTH = 5,
|
2018-07-31 10:22:19 +02:00
|
|
|
} eGPCurveMappingPreset;
|
|
|
|
|
|
2019-03-14 14:03:04 +01:00
|
|
|
static void brush_gpencil_curvemap_reset(CurveMap *cuma, int tot, int preset)
|
2018-07-31 10:22:19 +02:00
|
|
|
{
|
2019-04-22 09:39:35 +10:00
|
|
|
if (cuma->curve) {
|
2018-07-31 10:22:19 +02:00
|
|
|
MEM_freeN(cuma->curve);
|
2019-04-22 09:39:35 +10:00
|
|
|
}
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2019-03-14 14:03:04 +01:00
|
|
|
cuma->totpoint = tot;
|
2018-07-31 10:22:19 +02:00
|
|
|
cuma->curve = MEM_callocN(cuma->totpoint * sizeof(CurveMapPoint), __func__);
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2018-07-31 10:22:19 +02:00
|
|
|
switch (preset) {
|
|
|
|
|
case GPCURVE_PRESET_PENCIL:
|
|
|
|
|
cuma->curve[0].x = 0.0f;
|
|
|
|
|
cuma->curve[0].y = 0.0f;
|
|
|
|
|
cuma->curve[1].x = 0.75115f;
|
|
|
|
|
cuma->curve[1].y = 0.25f;
|
|
|
|
|
cuma->curve[2].x = 1.0f;
|
|
|
|
|
cuma->curve[2].y = 1.0f;
|
|
|
|
|
break;
|
|
|
|
|
case GPCURVE_PRESET_INK:
|
|
|
|
|
cuma->curve[0].x = 0.0f;
|
|
|
|
|
cuma->curve[0].y = 0.0f;
|
|
|
|
|
cuma->curve[1].x = 0.63448f;
|
|
|
|
|
cuma->curve[1].y = 0.375f;
|
|
|
|
|
cuma->curve[2].x = 1.0f;
|
|
|
|
|
cuma->curve[2].y = 1.0f;
|
|
|
|
|
break;
|
|
|
|
|
case GPCURVE_PRESET_INKNOISE:
|
|
|
|
|
cuma->curve[0].x = 0.0f;
|
|
|
|
|
cuma->curve[0].y = 0.0f;
|
2020-04-08 19:03:04 +02:00
|
|
|
cuma->curve[1].x = 0.55f;
|
|
|
|
|
cuma->curve[1].y = 0.45f;
|
|
|
|
|
cuma->curve[2].x = 0.85f;
|
2018-07-31 10:22:19 +02:00
|
|
|
cuma->curve[2].y = 1.0f;
|
|
|
|
|
break;
|
2019-03-14 14:03:04 +01:00
|
|
|
case GPCURVE_PRESET_MARKER:
|
|
|
|
|
cuma->curve[0].x = 0.0f;
|
|
|
|
|
cuma->curve[0].y = 0.0f;
|
|
|
|
|
cuma->curve[1].x = 0.38f;
|
|
|
|
|
cuma->curve[1].y = 0.22f;
|
|
|
|
|
cuma->curve[2].x = 0.65f;
|
|
|
|
|
cuma->curve[2].y = 0.68f;
|
|
|
|
|
cuma->curve[3].x = 1.0f;
|
|
|
|
|
cuma->curve[3].y = 1.0f;
|
|
|
|
|
break;
|
2020-05-03 13:33:58 +02:00
|
|
|
case GPCURVE_PRESET_CHISEL_SENSIVITY:
|
2020-04-08 19:03:04 +02:00
|
|
|
cuma->curve[0].x = 0.0f;
|
|
|
|
|
cuma->curve[0].y = 0.0f;
|
2020-05-03 13:33:58 +02:00
|
|
|
cuma->curve[1].x = 0.25f;
|
|
|
|
|
cuma->curve[1].y = 0.40f;
|
|
|
|
|
cuma->curve[2].x = 1.0f;
|
|
|
|
|
cuma->curve[2].y = 1.0f;
|
|
|
|
|
break;
|
|
|
|
|
case GPCURVE_PRESET_CHISEL_STRENGTH:
|
|
|
|
|
cuma->curve[0].x = 0.0f;
|
|
|
|
|
cuma->curve[0].y = 0.0f;
|
|
|
|
|
cuma->curve[1].x = 0.31f;
|
|
|
|
|
cuma->curve[1].y = 0.22f;
|
|
|
|
|
cuma->curve[2].x = 0.61f;
|
|
|
|
|
cuma->curve[2].y = 0.88f;
|
|
|
|
|
cuma->curve[3].x = 1.0f;
|
|
|
|
|
cuma->curve[3].y = 1.0f;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
2020-04-08 19:03:04 +02:00
|
|
|
break;
|
2018-07-31 10:22:19 +02:00
|
|
|
}
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2018-07-31 10:22:19 +02:00
|
|
|
if (cuma->table) {
|
|
|
|
|
MEM_freeN(cuma->table);
|
|
|
|
|
cuma->table = NULL;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
void BKE_gpencil_brush_preset_set(Main *bmain, Brush *brush, const short type)
|
2018-07-31 10:22:19 +02:00
|
|
|
{
|
|
|
|
|
#define SMOOTH_STROKE_RADIUS 40
|
|
|
|
|
#define SMOOTH_STROKE_FACTOR 0.9f
|
2020-03-09 16:27:24 +01:00
|
|
|
#define ACTIVE_SMOOTH 0.35f
|
2018-07-31 10:22:19 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
CurveMapping *custom_curve = NULL;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2020-09-01 14:48:10 +10:00
|
|
|
/* Optionally assign a material preset. */
|
|
|
|
|
enum {
|
|
|
|
|
PRESET_MATERIAL_NONE = 0,
|
|
|
|
|
PRESET_MATERIAL_DOT_STROKE,
|
|
|
|
|
} material_preset = PRESET_MATERIAL_NONE;
|
|
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
/* Set general defaults at brush level. */
|
|
|
|
|
brush->smooth_stroke_radius = SMOOTH_STROKE_RADIUS;
|
|
|
|
|
brush->smooth_stroke_factor = SMOOTH_STROKE_FACTOR;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->rgb[0] = 0.498f;
|
|
|
|
|
brush->rgb[1] = 1.0f;
|
|
|
|
|
brush->rgb[2] = 0.498f;
|
|
|
|
|
|
|
|
|
|
brush->secondary_rgb[0] = 1.0f;
|
|
|
|
|
brush->secondary_rgb[1] = 1.0f;
|
|
|
|
|
brush->secondary_rgb[2] = 1.0f;
|
|
|
|
|
|
|
|
|
|
brush->curve_preset = BRUSH_CURVE_SMOOTH;
|
|
|
|
|
|
|
|
|
|
if (brush->gpencil_settings == NULL) {
|
|
|
|
|
return;
|
2019-09-27 16:52:08 +02:00
|
|
|
}
|
|
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
/* Set preset type. */
|
|
|
|
|
brush->gpencil_settings->preset_type = type;
|
|
|
|
|
|
|
|
|
|
/* Set vertex mix factor. */
|
2020-06-17 22:49:59 +02:00
|
|
|
brush->gpencil_settings->vertex_mode = GPPAINT_MODE_BOTH;
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->gpencil_settings->vertex_factor = 1.0f;
|
|
|
|
|
|
|
|
|
|
switch (type) {
|
|
|
|
|
case GP_BRUSH_PRESET_AIRBRUSH: {
|
|
|
|
|
brush->size = 300.0f;
|
|
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_PRESSURE;
|
|
|
|
|
|
|
|
|
|
brush->gpencil_settings->draw_strength = 0.4f;
|
2020-08-04 13:26:21 +02:00
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_STRENGTH_PRESSURE;
|
2020-03-09 16:27:24 +01:00
|
|
|
|
|
|
|
|
brush->gpencil_settings->input_samples = 10;
|
|
|
|
|
brush->gpencil_settings->active_smooth = ACTIVE_SMOOTH;
|
|
|
|
|
brush->gpencil_settings->draw_angle = 0.0f;
|
|
|
|
|
brush->gpencil_settings->draw_angle_factor = 0.0f;
|
2020-03-11 18:01:25 +01:00
|
|
|
brush->gpencil_settings->hardeness = 0.9f;
|
2020-03-09 16:27:24 +01:00
|
|
|
copy_v2_fl(brush->gpencil_settings->aspect_ratio, 1.0f);
|
|
|
|
|
|
|
|
|
|
brush->gpencil_tool = GPAINT_TOOL_DRAW;
|
|
|
|
|
brush->gpencil_settings->icon_id = GP_BRUSH_ICON_AIRBRUSH;
|
|
|
|
|
|
|
|
|
|
zero_v3(brush->secondary_rgb);
|
2020-09-01 14:48:10 +10:00
|
|
|
|
|
|
|
|
material_preset = PRESET_MATERIAL_DOT_STROKE;
|
|
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case GP_BRUSH_PRESET_INK_PEN: {
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->size = 60.0f;
|
|
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_PRESSURE;
|
2019-09-27 16:52:08 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->gpencil_settings->draw_strength = 1.0f;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->gpencil_settings->input_samples = 10;
|
|
|
|
|
brush->gpencil_settings->active_smooth = ACTIVE_SMOOTH;
|
|
|
|
|
brush->gpencil_settings->draw_angle = 0.0f;
|
|
|
|
|
brush->gpencil_settings->draw_angle_factor = 0.0f;
|
|
|
|
|
brush->gpencil_settings->hardeness = 1.0f;
|
|
|
|
|
copy_v2_fl(brush->gpencil_settings->aspect_ratio, 1.0f);
|
2018-07-31 10:22:19 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_GROUP_SETTINGS;
|
|
|
|
|
brush->gpencil_settings->draw_smoothfac = 0.1f;
|
|
|
|
|
brush->gpencil_settings->draw_smoothlvl = 1;
|
|
|
|
|
brush->gpencil_settings->draw_subdivide = 0;
|
|
|
|
|
brush->gpencil_settings->simplify_f = 0.002f;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->gpencil_settings->draw_random_press = 0.0f;
|
|
|
|
|
brush->gpencil_settings->draw_jitter = 0.0f;
|
|
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_JITTER_PRESSURE;
|
2019-09-27 16:52:08 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
/* Curve. */
|
|
|
|
|
custom_curve = brush->gpencil_settings->curve_sensitivity;
|
|
|
|
|
BKE_curvemapping_set_defaults(custom_curve, 0, 0.0f, 0.0f, 1.0f, 1.0f);
|
2020-08-01 13:02:21 +10:00
|
|
|
BKE_curvemapping_init(custom_curve);
|
2020-03-09 16:27:24 +01:00
|
|
|
brush_gpencil_curvemap_reset(custom_curve->cm, 3, GPCURVE_PRESET_INK);
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->gpencil_settings->icon_id = GP_BRUSH_ICON_INK;
|
|
|
|
|
brush->gpencil_tool = GPAINT_TOOL_DRAW;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
zero_v3(brush->secondary_rgb);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case GP_BRUSH_PRESET_INK_PEN_ROUGH: {
|
|
|
|
|
brush->size = 60.0f;
|
|
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_PRESSURE;
|
|
|
|
|
|
|
|
|
|
brush->gpencil_settings->draw_strength = 1.0f;
|
|
|
|
|
|
|
|
|
|
brush->gpencil_settings->input_samples = 10;
|
|
|
|
|
brush->gpencil_settings->active_smooth = ACTIVE_SMOOTH;
|
|
|
|
|
brush->gpencil_settings->draw_angle = 0.0f;
|
|
|
|
|
brush->gpencil_settings->draw_angle_factor = 0.0f;
|
|
|
|
|
brush->gpencil_settings->hardeness = 1.0f;
|
|
|
|
|
copy_v2_fl(brush->gpencil_settings->aspect_ratio, 1.0f);
|
|
|
|
|
|
|
|
|
|
brush->gpencil_settings->flag &= ~GP_BRUSH_GROUP_SETTINGS;
|
|
|
|
|
brush->gpencil_settings->draw_smoothfac = 0.0f;
|
|
|
|
|
brush->gpencil_settings->draw_smoothlvl = 2;
|
|
|
|
|
brush->gpencil_settings->draw_subdivide = 0;
|
|
|
|
|
brush->gpencil_settings->simplify_f = 0.000f;
|
|
|
|
|
|
|
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_GROUP_RANDOM;
|
2020-04-08 19:03:04 +02:00
|
|
|
brush->gpencil_settings->draw_random_press = 0.6f;
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->gpencil_settings->draw_random_strength = 0.0f;
|
|
|
|
|
brush->gpencil_settings->draw_jitter = 0.0f;
|
|
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_JITTER_PRESSURE;
|
|
|
|
|
|
|
|
|
|
/* Curve. */
|
|
|
|
|
custom_curve = brush->gpencil_settings->curve_sensitivity;
|
|
|
|
|
BKE_curvemapping_set_defaults(custom_curve, 0, 0.0f, 0.0f, 1.0f, 1.0f);
|
2020-08-01 13:02:21 +10:00
|
|
|
BKE_curvemapping_init(custom_curve);
|
2020-03-09 16:27:24 +01:00
|
|
|
brush_gpencil_curvemap_reset(custom_curve->cm, 3, GPCURVE_PRESET_INKNOISE);
|
|
|
|
|
|
|
|
|
|
brush->gpencil_settings->icon_id = GP_BRUSH_ICON_INKNOISE;
|
|
|
|
|
brush->gpencil_tool = GPAINT_TOOL_DRAW;
|
|
|
|
|
|
|
|
|
|
zero_v3(brush->secondary_rgb);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case GP_BRUSH_PRESET_MARKER_BOLD: {
|
|
|
|
|
brush->size = 150.0f;
|
|
|
|
|
brush->gpencil_settings->flag &= ~GP_BRUSH_USE_PRESSURE;
|
|
|
|
|
|
|
|
|
|
brush->gpencil_settings->draw_strength = 0.3f;
|
|
|
|
|
|
|
|
|
|
brush->gpencil_settings->input_samples = 10;
|
|
|
|
|
brush->gpencil_settings->active_smooth = ACTIVE_SMOOTH;
|
|
|
|
|
brush->gpencil_settings->draw_angle = 0.0f;
|
|
|
|
|
brush->gpencil_settings->draw_angle_factor = 0.0f;
|
|
|
|
|
brush->gpencil_settings->hardeness = 1.0f;
|
|
|
|
|
copy_v2_fl(brush->gpencil_settings->aspect_ratio, 1.0f);
|
|
|
|
|
|
|
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_GROUP_SETTINGS;
|
|
|
|
|
brush->gpencil_settings->draw_smoothfac = 0.1f;
|
|
|
|
|
brush->gpencil_settings->draw_smoothlvl = 1;
|
|
|
|
|
brush->gpencil_settings->draw_subdivide = 0;
|
|
|
|
|
brush->gpencil_settings->simplify_f = 0.002f;
|
|
|
|
|
|
|
|
|
|
brush->gpencil_settings->flag &= ~GP_BRUSH_GROUP_RANDOM;
|
|
|
|
|
brush->gpencil_settings->draw_random_press = 0.0f;
|
|
|
|
|
brush->gpencil_settings->draw_random_strength = 0.0f;
|
|
|
|
|
brush->gpencil_settings->draw_jitter = 0.0f;
|
|
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_JITTER_PRESSURE;
|
|
|
|
|
|
|
|
|
|
/* Curve. */
|
|
|
|
|
custom_curve = brush->gpencil_settings->curve_sensitivity;
|
|
|
|
|
BKE_curvemapping_set_defaults(custom_curve, 0, 0.0f, 0.0f, 1.0f, 1.0f);
|
2020-08-01 13:02:21 +10:00
|
|
|
BKE_curvemapping_init(custom_curve);
|
2020-03-09 16:27:24 +01:00
|
|
|
brush_gpencil_curvemap_reset(custom_curve->cm, 4, GPCURVE_PRESET_MARKER);
|
|
|
|
|
|
|
|
|
|
brush->gpencil_settings->icon_id = GP_BRUSH_ICON_MARKER;
|
|
|
|
|
brush->gpencil_tool = GPAINT_TOOL_DRAW;
|
|
|
|
|
|
|
|
|
|
zero_v3(brush->secondary_rgb);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case GP_BRUSH_PRESET_MARKER_CHISEL: {
|
2020-04-18 13:15:51 +02:00
|
|
|
brush->size = 150.0f;
|
2020-05-04 08:23:27 +02:00
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_PRESSURE;
|
2020-03-09 16:27:24 +01:00
|
|
|
|
|
|
|
|
brush->gpencil_settings->draw_strength = 1.0f;
|
|
|
|
|
|
|
|
|
|
brush->gpencil_settings->input_samples = 10;
|
2020-05-03 13:33:58 +02:00
|
|
|
brush->gpencil_settings->active_smooth = 0.3f;
|
|
|
|
|
brush->gpencil_settings->draw_angle = DEG2RAD(35.0f);
|
|
|
|
|
brush->gpencil_settings->draw_angle_factor = 0.5f;
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->gpencil_settings->hardeness = 1.0f;
|
|
|
|
|
copy_v2_fl(brush->gpencil_settings->aspect_ratio, 1.0f);
|
|
|
|
|
|
|
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_GROUP_SETTINGS;
|
|
|
|
|
brush->gpencil_settings->draw_smoothfac = 0.0f;
|
|
|
|
|
brush->gpencil_settings->draw_smoothlvl = 1;
|
|
|
|
|
brush->gpencil_settings->draw_subdivide = 0;
|
|
|
|
|
brush->gpencil_settings->simplify_f = 0.002f;
|
|
|
|
|
|
|
|
|
|
brush->gpencil_settings->flag &= ~GP_BRUSH_GROUP_RANDOM;
|
|
|
|
|
brush->gpencil_settings->draw_random_press = 0.0f;
|
|
|
|
|
brush->gpencil_settings->draw_jitter = 0.0f;
|
|
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_JITTER_PRESSURE;
|
|
|
|
|
|
2020-04-08 19:03:04 +02:00
|
|
|
/* Curve. */
|
|
|
|
|
custom_curve = brush->gpencil_settings->curve_sensitivity;
|
|
|
|
|
BKE_curvemapping_set_defaults(custom_curve, 0, 0.0f, 0.0f, 1.0f, 1.0f);
|
2020-08-01 13:02:21 +10:00
|
|
|
BKE_curvemapping_init(custom_curve);
|
2020-05-03 13:33:58 +02:00
|
|
|
brush_gpencil_curvemap_reset(custom_curve->cm, 3, GPCURVE_PRESET_CHISEL_SENSIVITY);
|
|
|
|
|
|
|
|
|
|
custom_curve = brush->gpencil_settings->curve_strength;
|
|
|
|
|
BKE_curvemapping_set_defaults(custom_curve, 0, 0.0f, 0.0f, 1.0f, 1.0f);
|
2020-08-01 13:02:21 +10:00
|
|
|
BKE_curvemapping_init(custom_curve);
|
2020-05-03 13:33:58 +02:00
|
|
|
brush_gpencil_curvemap_reset(custom_curve->cm, 4, GPCURVE_PRESET_CHISEL_STRENGTH);
|
2020-04-08 19:03:04 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->gpencil_settings->icon_id = GP_BRUSH_ICON_CHISEL;
|
|
|
|
|
brush->gpencil_tool = GPAINT_TOOL_DRAW;
|
|
|
|
|
|
|
|
|
|
zero_v3(brush->secondary_rgb);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case GP_BRUSH_PRESET_PEN: {
|
2020-04-08 19:03:04 +02:00
|
|
|
brush->size = 25.0f;
|
2020-04-18 13:15:51 +02:00
|
|
|
brush->gpencil_settings->flag &= ~GP_BRUSH_USE_PRESSURE;
|
2020-03-09 16:27:24 +01:00
|
|
|
|
|
|
|
|
brush->gpencil_settings->draw_strength = 1.0f;
|
2020-08-04 13:26:21 +02:00
|
|
|
brush->gpencil_settings->flag &= ~GP_BRUSH_USE_STRENGTH_PRESSURE;
|
2020-03-09 16:27:24 +01:00
|
|
|
|
|
|
|
|
brush->gpencil_settings->input_samples = 10;
|
|
|
|
|
brush->gpencil_settings->active_smooth = ACTIVE_SMOOTH;
|
|
|
|
|
brush->gpencil_settings->draw_angle = 0.0f;
|
|
|
|
|
brush->gpencil_settings->draw_angle_factor = 0.0f;
|
|
|
|
|
brush->gpencil_settings->hardeness = 1.0f;
|
|
|
|
|
copy_v2_fl(brush->gpencil_settings->aspect_ratio, 1.0f);
|
|
|
|
|
|
|
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_GROUP_SETTINGS;
|
|
|
|
|
brush->gpencil_settings->draw_smoothfac = 0.0f;
|
|
|
|
|
brush->gpencil_settings->draw_smoothlvl = 1;
|
|
|
|
|
brush->gpencil_settings->draw_subdivide = 1;
|
|
|
|
|
brush->gpencil_settings->simplify_f = 0.002f;
|
|
|
|
|
|
|
|
|
|
brush->gpencil_settings->draw_random_press = 0.0f;
|
|
|
|
|
brush->gpencil_settings->draw_random_strength = 0.0f;
|
|
|
|
|
brush->gpencil_settings->draw_jitter = 0.0f;
|
|
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_JITTER_PRESSURE;
|
|
|
|
|
|
|
|
|
|
brush->gpencil_settings->icon_id = GP_BRUSH_ICON_PEN;
|
|
|
|
|
brush->gpencil_tool = GPAINT_TOOL_DRAW;
|
|
|
|
|
|
|
|
|
|
zero_v3(brush->secondary_rgb);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case GP_BRUSH_PRESET_PENCIL_SOFT: {
|
|
|
|
|
brush->size = 80.0f;
|
|
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_PRESSURE;
|
|
|
|
|
|
|
|
|
|
brush->gpencil_settings->draw_strength = 0.4f;
|
2020-08-04 13:26:21 +02:00
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_STRENGTH_PRESSURE;
|
2020-03-09 16:27:24 +01:00
|
|
|
|
|
|
|
|
brush->gpencil_settings->input_samples = 10;
|
|
|
|
|
brush->gpencil_settings->active_smooth = ACTIVE_SMOOTH;
|
|
|
|
|
brush->gpencil_settings->draw_angle = 0.0f;
|
|
|
|
|
brush->gpencil_settings->draw_angle_factor = 0.0f;
|
|
|
|
|
brush->gpencil_settings->hardeness = 0.8f;
|
|
|
|
|
copy_v2_fl(brush->gpencil_settings->aspect_ratio, 1.0f);
|
|
|
|
|
|
|
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_GROUP_SETTINGS;
|
|
|
|
|
brush->gpencil_settings->draw_smoothfac = 0.0f;
|
|
|
|
|
brush->gpencil_settings->draw_smoothlvl = 1;
|
|
|
|
|
brush->gpencil_settings->draw_subdivide = 0;
|
|
|
|
|
brush->gpencil_settings->simplify_f = 0.000f;
|
|
|
|
|
|
|
|
|
|
brush->gpencil_settings->draw_random_press = 0.0f;
|
|
|
|
|
brush->gpencil_settings->draw_random_strength = 0.0f;
|
|
|
|
|
brush->gpencil_settings->draw_jitter = 0.0f;
|
|
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_JITTER_PRESSURE;
|
|
|
|
|
|
|
|
|
|
brush->gpencil_settings->icon_id = GP_BRUSH_ICON_PENCIL;
|
|
|
|
|
brush->gpencil_tool = GPAINT_TOOL_DRAW;
|
|
|
|
|
|
|
|
|
|
zero_v3(brush->secondary_rgb);
|
2020-09-01 14:48:10 +10:00
|
|
|
|
|
|
|
|
material_preset = PRESET_MATERIAL_DOT_STROKE;
|
|
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case GP_BRUSH_PRESET_PENCIL: {
|
2020-04-08 19:03:04 +02:00
|
|
|
brush->size = 20.0f;
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_PRESSURE;
|
|
|
|
|
|
|
|
|
|
brush->gpencil_settings->draw_strength = 0.6f;
|
2020-08-04 13:26:21 +02:00
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_STRENGTH_PRESSURE;
|
2020-03-09 16:27:24 +01:00
|
|
|
|
|
|
|
|
brush->gpencil_settings->input_samples = 10;
|
|
|
|
|
brush->gpencil_settings->active_smooth = ACTIVE_SMOOTH;
|
|
|
|
|
brush->gpencil_settings->draw_angle = 0.0f;
|
|
|
|
|
brush->gpencil_settings->draw_angle_factor = 0.0f;
|
|
|
|
|
brush->gpencil_settings->hardeness = 1.0f;
|
|
|
|
|
copy_v2_fl(brush->gpencil_settings->aspect_ratio, 1.0f);
|
|
|
|
|
|
|
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_GROUP_SETTINGS;
|
|
|
|
|
brush->gpencil_settings->draw_smoothfac = 0.0f;
|
|
|
|
|
brush->gpencil_settings->draw_smoothlvl = 1;
|
|
|
|
|
brush->gpencil_settings->draw_subdivide = 0;
|
|
|
|
|
brush->gpencil_settings->simplify_f = 0.002f;
|
|
|
|
|
|
|
|
|
|
brush->gpencil_settings->draw_random_press = 0.0f;
|
|
|
|
|
brush->gpencil_settings->draw_jitter = 0.0f;
|
|
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_JITTER_PRESSURE;
|
|
|
|
|
|
|
|
|
|
brush->gpencil_settings->icon_id = GP_BRUSH_ICON_PENCIL;
|
|
|
|
|
brush->gpencil_tool = GPAINT_TOOL_DRAW;
|
|
|
|
|
|
|
|
|
|
zero_v3(brush->secondary_rgb);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case GP_BRUSH_PRESET_FILL_AREA: {
|
|
|
|
|
brush->size = 20.0f;
|
|
|
|
|
|
|
|
|
|
brush->gpencil_settings->fill_leak = 3;
|
|
|
|
|
brush->gpencil_settings->fill_threshold = 0.1f;
|
|
|
|
|
brush->gpencil_settings->fill_simplylvl = 1;
|
2021-01-14 12:54:02 +01:00
|
|
|
brush->gpencil_settings->fill_factor = 1.0f;
|
2020-03-09 16:27:24 +01:00
|
|
|
|
|
|
|
|
brush->gpencil_settings->draw_strength = 1.0f;
|
|
|
|
|
brush->gpencil_settings->hardeness = 1.0f;
|
|
|
|
|
copy_v2_fl(brush->gpencil_settings->aspect_ratio, 1.0f);
|
|
|
|
|
brush->gpencil_settings->draw_smoothfac = 0.1f;
|
|
|
|
|
brush->gpencil_settings->draw_smoothlvl = 1;
|
|
|
|
|
brush->gpencil_settings->draw_subdivide = 1;
|
|
|
|
|
|
|
|
|
|
brush->gpencil_settings->icon_id = GP_BRUSH_ICON_FILL;
|
|
|
|
|
brush->gpencil_tool = GPAINT_TOOL_FILL;
|
|
|
|
|
brush->gpencil_settings->vertex_mode = GPPAINT_MODE_FILL;
|
|
|
|
|
|
|
|
|
|
zero_v3(brush->secondary_rgb);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case GP_BRUSH_PRESET_ERASER_SOFT: {
|
|
|
|
|
brush->size = 30.0f;
|
|
|
|
|
brush->gpencil_settings->draw_strength = 0.5f;
|
|
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_DEFAULT_ERASER;
|
|
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_PRESSURE;
|
2020-08-04 13:26:21 +02:00
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_STRENGTH_PRESSURE;
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->gpencil_settings->icon_id = GP_BRUSH_ICON_ERASE_SOFT;
|
|
|
|
|
brush->gpencil_tool = GPAINT_TOOL_ERASE;
|
|
|
|
|
brush->gpencil_settings->eraser_mode = GP_BRUSH_ERASER_SOFT;
|
|
|
|
|
brush->gpencil_settings->era_strength_f = 100.0f;
|
|
|
|
|
brush->gpencil_settings->era_thickness_f = 10.0f;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case GP_BRUSH_PRESET_ERASER_HARD: {
|
|
|
|
|
brush->size = 30.0f;
|
|
|
|
|
brush->gpencil_settings->draw_strength = 1.0f;
|
|
|
|
|
brush->gpencil_settings->eraser_mode = GP_BRUSH_ERASER_SOFT;
|
|
|
|
|
brush->gpencil_settings->era_strength_f = 100.0f;
|
|
|
|
|
brush->gpencil_settings->era_thickness_f = 50.0f;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->gpencil_settings->icon_id = GP_BRUSH_ICON_ERASE_HARD;
|
|
|
|
|
brush->gpencil_tool = GPAINT_TOOL_ERASE;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case GP_BRUSH_PRESET_ERASER_POINT: {
|
|
|
|
|
brush->size = 30.0f;
|
|
|
|
|
brush->gpencil_settings->eraser_mode = GP_BRUSH_ERASER_HARD;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->gpencil_settings->icon_id = GP_BRUSH_ICON_ERASE_HARD;
|
|
|
|
|
brush->gpencil_tool = GPAINT_TOOL_ERASE;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case GP_BRUSH_PRESET_ERASER_STROKE: {
|
|
|
|
|
brush->size = 30.0f;
|
|
|
|
|
brush->gpencil_settings->eraser_mode = GP_BRUSH_ERASER_STROKE;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->gpencil_settings->icon_id = GP_BRUSH_ICON_ERASE_STROKE;
|
|
|
|
|
brush->gpencil_tool = GPAINT_TOOL_ERASE;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case GP_BRUSH_PRESET_TINT: {
|
|
|
|
|
brush->gpencil_settings->icon_id = GP_BRUSH_ICON_TINT;
|
|
|
|
|
brush->gpencil_tool = GPAINT_TOOL_TINT;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->size = 25.0f;
|
|
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_PRESSURE;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->gpencil_settings->draw_strength = 0.8f;
|
2020-08-04 13:26:21 +02:00
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_STRENGTH_PRESSURE;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
zero_v3(brush->secondary_rgb);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case GP_BRUSH_PRESET_VERTEX_DRAW: {
|
|
|
|
|
brush->gpencil_settings->icon_id = GP_BRUSH_ICON_VERTEX_DRAW;
|
|
|
|
|
brush->gpencil_vertex_tool = GPVERTEX_TOOL_DRAW;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->size = 25.0f;
|
|
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_PRESSURE;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->gpencil_settings->draw_strength = 0.8f;
|
2020-08-04 13:26:21 +02:00
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_STRENGTH_PRESSURE;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
zero_v3(brush->secondary_rgb);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case GP_BRUSH_PRESET_VERTEX_BLUR: {
|
|
|
|
|
brush->gpencil_settings->icon_id = GP_BRUSH_ICON_VERTEX_BLUR;
|
|
|
|
|
brush->gpencil_vertex_tool = GPVERTEX_TOOL_BLUR;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->size = 25.0f;
|
|
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_PRESSURE;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->gpencil_settings->draw_strength = 0.8f;
|
2020-08-04 13:26:21 +02:00
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_STRENGTH_PRESSURE;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
zero_v3(brush->secondary_rgb);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case GP_BRUSH_PRESET_VERTEX_AVERAGE: {
|
|
|
|
|
brush->gpencil_settings->icon_id = GP_BRUSH_ICON_VERTEX_AVERAGE;
|
|
|
|
|
brush->gpencil_vertex_tool = GPVERTEX_TOOL_AVERAGE;
|
2019-09-27 16:52:08 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->size = 25.0f;
|
|
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_PRESSURE;
|
2019-09-27 16:52:08 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->gpencil_settings->draw_strength = 0.8f;
|
2020-08-04 13:26:21 +02:00
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_STRENGTH_PRESSURE;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
zero_v3(brush->secondary_rgb);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case GP_BRUSH_PRESET_VERTEX_SMEAR: {
|
|
|
|
|
brush->gpencil_settings->icon_id = GP_BRUSH_ICON_VERTEX_SMEAR;
|
|
|
|
|
brush->gpencil_vertex_tool = GPVERTEX_TOOL_SMEAR;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->size = 25.0f;
|
|
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_PRESSURE;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->gpencil_settings->draw_strength = 0.8f;
|
2020-08-04 13:26:21 +02:00
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_STRENGTH_PRESSURE;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
zero_v3(brush->secondary_rgb);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case GP_BRUSH_PRESET_VERTEX_REPLACE: {
|
|
|
|
|
brush->gpencil_settings->icon_id = GP_BRUSH_ICON_VERTEX_REPLACE;
|
|
|
|
|
brush->gpencil_vertex_tool = GPVERTEX_TOOL_REPLACE;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->size = 25.0f;
|
|
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_PRESSURE;
|
2019-09-27 16:52:08 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->gpencil_settings->draw_strength = 0.8f;
|
2020-08-04 13:26:21 +02:00
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_STRENGTH_PRESSURE;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
zero_v3(brush->secondary_rgb);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case GP_BRUSH_PRESET_SMOOTH_STROKE: {
|
|
|
|
|
brush->gpencil_settings->icon_id = GP_BRUSH_ICON_GPBRUSH_SMOOTH;
|
|
|
|
|
brush->gpencil_sculpt_tool = GPSCULPT_TOOL_SMOOTH;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->size = 25.0f;
|
|
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_PRESSURE;
|
2019-09-27 16:52:08 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->gpencil_settings->draw_strength = 0.3f;
|
2020-08-04 13:26:21 +02:00
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_STRENGTH_PRESSURE;
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->gpencil_settings->sculpt_flag = GP_SCULPT_FLAG_SMOOTH_PRESSURE;
|
|
|
|
|
brush->gpencil_settings->sculpt_mode_flag |= GP_SCULPT_FLAGMODE_APPLY_POSITION;
|
2019-05-20 17:23:24 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case GP_BRUSH_PRESET_STRENGTH_STROKE: {
|
|
|
|
|
brush->gpencil_settings->icon_id = GP_BRUSH_ICON_GPBRUSH_STRENGTH;
|
|
|
|
|
brush->gpencil_sculpt_tool = GPSCULPT_TOOL_STRENGTH;
|
2019-09-27 16:52:08 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->size = 25.0f;
|
|
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_PRESSURE;
|
2019-09-27 16:52:08 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->gpencil_settings->draw_strength = 0.3f;
|
2020-08-04 13:26:21 +02:00
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_STRENGTH_PRESSURE;
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->gpencil_settings->sculpt_flag = GP_SCULPT_FLAG_SMOOTH_PRESSURE;
|
|
|
|
|
brush->gpencil_settings->sculpt_mode_flag |= GP_SCULPT_FLAGMODE_APPLY_POSITION;
|
2019-09-27 16:52:08 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case GP_BRUSH_PRESET_THICKNESS_STROKE: {
|
|
|
|
|
brush->gpencil_settings->icon_id = GP_BRUSH_ICON_GPBRUSH_THICKNESS;
|
|
|
|
|
brush->gpencil_sculpt_tool = GPSCULPT_TOOL_THICKNESS;
|
2019-09-27 16:52:08 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->size = 25.0f;
|
|
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_PRESSURE;
|
2019-05-20 17:23:24 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->gpencil_settings->draw_strength = 0.5f;
|
2020-08-04 13:26:21 +02:00
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_STRENGTH_PRESSURE;
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->gpencil_settings->sculpt_mode_flag |= GP_SCULPT_FLAGMODE_APPLY_POSITION;
|
2019-09-27 16:52:08 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case GP_BRUSH_PRESET_GRAB_STROKE: {
|
|
|
|
|
brush->gpencil_settings->icon_id = GP_BRUSH_ICON_GPBRUSH_GRAB;
|
|
|
|
|
brush->gpencil_sculpt_tool = GPSCULPT_TOOL_GRAB;
|
|
|
|
|
brush->gpencil_settings->flag &= ~GP_BRUSH_USE_PRESSURE;
|
2019-09-27 16:52:08 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->size = 25.0f;
|
2019-09-27 16:52:08 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->gpencil_settings->draw_strength = 0.3f;
|
2020-08-04 13:26:21 +02:00
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_STRENGTH_PRESSURE;
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->gpencil_settings->sculpt_mode_flag |= GP_SCULPT_FLAGMODE_APPLY_POSITION;
|
2019-09-27 16:52:08 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case GP_BRUSH_PRESET_PUSH_STROKE: {
|
|
|
|
|
brush->gpencil_settings->icon_id = GP_BRUSH_ICON_GPBRUSH_PUSH;
|
|
|
|
|
brush->gpencil_sculpt_tool = GPSCULPT_TOOL_PUSH;
|
2019-09-27 16:52:08 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->size = 25.0f;
|
|
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_PRESSURE;
|
2019-05-20 17:23:24 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->gpencil_settings->draw_strength = 0.3f;
|
2020-08-04 13:26:21 +02:00
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_STRENGTH_PRESSURE;
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->gpencil_settings->sculpt_mode_flag |= GP_SCULPT_FLAGMODE_APPLY_POSITION;
|
2019-09-27 16:52:08 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case GP_BRUSH_PRESET_TWIST_STROKE: {
|
|
|
|
|
brush->gpencil_settings->icon_id = GP_BRUSH_ICON_GPBRUSH_TWIST;
|
|
|
|
|
brush->gpencil_sculpt_tool = GPSCULPT_TOOL_TWIST;
|
2019-05-20 17:23:24 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->size = 50.0f;
|
|
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_PRESSURE;
|
2019-09-27 16:52:08 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->gpencil_settings->draw_strength = 0.3f;
|
2020-08-04 13:26:21 +02:00
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_STRENGTH_PRESSURE;
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->gpencil_settings->sculpt_mode_flag |= GP_SCULPT_FLAGMODE_APPLY_POSITION;
|
2019-09-27 16:52:08 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case GP_BRUSH_PRESET_PINCH_STROKE: {
|
|
|
|
|
brush->gpencil_settings->icon_id = GP_BRUSH_ICON_GPBRUSH_PINCH;
|
|
|
|
|
brush->gpencil_sculpt_tool = GPSCULPT_TOOL_PINCH;
|
2019-05-20 17:23:24 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->size = 50.0f;
|
|
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_PRESSURE;
|
2019-05-20 17:23:24 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->gpencil_settings->draw_strength = 0.5f;
|
2020-08-04 13:26:21 +02:00
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_STRENGTH_PRESSURE;
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->gpencil_settings->sculpt_mode_flag |= GP_SCULPT_FLAGMODE_APPLY_POSITION;
|
2019-09-27 16:52:08 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case GP_BRUSH_PRESET_RANDOMIZE_STROKE: {
|
|
|
|
|
brush->gpencil_settings->icon_id = GP_BRUSH_ICON_GPBRUSH_RANDOMIZE;
|
|
|
|
|
brush->gpencil_sculpt_tool = GPSCULPT_TOOL_RANDOMIZE;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->size = 25.0f;
|
|
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_PRESSURE;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->gpencil_settings->draw_strength = 0.5f;
|
2020-08-04 13:26:21 +02:00
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_STRENGTH_PRESSURE;
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->gpencil_settings->sculpt_mode_flag |= GP_SCULPT_FLAGMODE_APPLY_POSITION;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case GP_BRUSH_PRESET_CLONE_STROKE: {
|
|
|
|
|
brush->gpencil_settings->icon_id = GP_BRUSH_ICON_GPBRUSH_CLONE;
|
|
|
|
|
brush->gpencil_sculpt_tool = GPSCULPT_TOOL_CLONE;
|
|
|
|
|
brush->gpencil_settings->flag &= ~GP_BRUSH_USE_PRESSURE;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->size = 25.0f;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->gpencil_settings->draw_strength = 1.0f;
|
2020-08-04 13:26:21 +02:00
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_STRENGTH_PRESSURE;
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->gpencil_settings->sculpt_mode_flag |= GP_SCULPT_FLAGMODE_APPLY_POSITION;
|
|
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case GP_BRUSH_PRESET_DRAW_WEIGHT: {
|
|
|
|
|
brush->gpencil_settings->icon_id = GP_BRUSH_ICON_GPBRUSH_WEIGHT;
|
|
|
|
|
brush->gpencil_weight_tool = GPWEIGHT_TOOL_DRAW;
|
|
|
|
|
|
|
|
|
|
brush->size = 25.0f;
|
|
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_PRESSURE;
|
|
|
|
|
|
|
|
|
|
brush->gpencil_settings->draw_strength = 0.8f;
|
2020-08-04 13:26:21 +02:00
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_USE_STRENGTH_PRESSURE;
|
2020-03-09 16:27:24 +01:00
|
|
|
brush->gpencil_settings->sculpt_mode_flag |= GP_SCULPT_FLAGMODE_APPLY_POSITION;
|
|
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
default:
|
|
|
|
|
break;
|
2019-10-14 15:50:46 +02:00
|
|
|
}
|
2020-09-01 14:48:10 +10:00
|
|
|
|
|
|
|
|
switch (material_preset) {
|
|
|
|
|
case PRESET_MATERIAL_NONE:
|
|
|
|
|
break;
|
|
|
|
|
case PRESET_MATERIAL_DOT_STROKE: {
|
|
|
|
|
/* Create and link Black Dots material to brush.
|
|
|
|
|
* This material is required because the brush uses the material
|
|
|
|
|
* to define how the stroke is drawn. */
|
|
|
|
|
const char *ma_id = "Dots Stroke";
|
|
|
|
|
Material *ma = BLI_findstring(&bmain->materials, ma_id, offsetof(ID, name) + 2);
|
|
|
|
|
if (ma == NULL) {
|
|
|
|
|
ma = BKE_gpencil_material_add(bmain, ma_id);
|
|
|
|
|
ma->gp_style->mode = GP_MATERIAL_MODE_DOT;
|
|
|
|
|
BLI_assert(ma->id.us == 1);
|
|
|
|
|
id_us_min(&ma->id);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
BKE_gpencil_brush_material_set(brush, ma);
|
|
|
|
|
|
|
|
|
|
/* Pin the material to the brush. */
|
|
|
|
|
brush->gpencil_settings->flag |= GP_BRUSH_MATERIAL_PINNED;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
2020-03-09 16:27:24 +01:00
|
|
|
}
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2020-05-15 16:43:50 +02:00
|
|
|
static Brush *gpencil_brush_ensure(
|
|
|
|
|
Main *bmain, ToolSettings *ts, const char *brush_name, eObjectMode mode, bool *r_new)
|
2020-03-09 16:27:24 +01:00
|
|
|
{
|
2020-05-15 16:43:50 +02:00
|
|
|
*r_new = false;
|
2020-03-09 16:27:24 +01:00
|
|
|
Brush *brush = BLI_findstring(&bmain->brushes, brush_name, offsetof(ID, name) + 2);
|
2020-05-15 16:43:50 +02:00
|
|
|
|
|
|
|
|
/* If the brush exist, but the type is not GPencil or the mode is wrong, create a new one. */
|
|
|
|
|
if ((brush != NULL) && ((brush->gpencil_settings == NULL) || (brush->ob_mode != mode))) {
|
|
|
|
|
brush = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-14 15:50:46 +02:00
|
|
|
if (brush == NULL) {
|
2020-03-09 16:27:24 +01:00
|
|
|
brush = BKE_brush_add_gpencil(bmain, ts, brush_name, mode);
|
2020-05-15 16:43:50 +02:00
|
|
|
*r_new = true;
|
2019-10-14 15:50:46 +02:00
|
|
|
}
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
if (brush->gpencil_settings == NULL) {
|
|
|
|
|
BKE_brush_init_gpencil_settings(brush);
|
2019-10-14 15:50:46 +02:00
|
|
|
}
|
2019-09-27 16:52:08 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
return brush;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Create a set of grease pencil Drawing presets. */
|
2020-05-15 16:43:50 +02:00
|
|
|
void BKE_brush_gpencil_paint_presets(Main *bmain, ToolSettings *ts, const bool reset)
|
2020-03-09 16:27:24 +01:00
|
|
|
{
|
2020-05-15 16:43:50 +02:00
|
|
|
bool r_new = false;
|
2020-03-09 16:27:24 +01:00
|
|
|
|
|
|
|
|
Paint *paint = &ts->gp_paint->paint;
|
2020-05-18 17:04:00 +02:00
|
|
|
Brush *brush_prev = paint->brush;
|
2020-03-09 16:27:24 +01:00
|
|
|
Brush *brush, *deft_draw;
|
|
|
|
|
/* Airbrush brush. */
|
2020-05-15 16:43:50 +02:00
|
|
|
brush = gpencil_brush_ensure(bmain, ts, "Airbrush", OB_MODE_PAINT_GPENCIL, &r_new);
|
|
|
|
|
if ((reset) || (r_new)) {
|
|
|
|
|
BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_AIRBRUSH);
|
|
|
|
|
}
|
2020-03-09 16:27:24 +01:00
|
|
|
|
|
|
|
|
/* Ink Pen brush. */
|
2020-05-15 16:43:50 +02:00
|
|
|
brush = gpencil_brush_ensure(bmain, ts, "Ink Pen", OB_MODE_PAINT_GPENCIL, &r_new);
|
|
|
|
|
if ((reset) || (r_new)) {
|
|
|
|
|
BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_INK_PEN);
|
|
|
|
|
}
|
2020-03-09 16:27:24 +01:00
|
|
|
|
|
|
|
|
/* Ink Pen Rough brush. */
|
2020-05-15 16:43:50 +02:00
|
|
|
brush = gpencil_brush_ensure(bmain, ts, "Ink Pen Rough", OB_MODE_PAINT_GPENCIL, &r_new);
|
|
|
|
|
if ((reset) || (r_new)) {
|
|
|
|
|
BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_INK_PEN_ROUGH);
|
|
|
|
|
}
|
2020-03-09 16:27:24 +01:00
|
|
|
|
|
|
|
|
/* Marker Bold brush. */
|
2020-05-15 16:43:50 +02:00
|
|
|
brush = gpencil_brush_ensure(bmain, ts, "Marker Bold", OB_MODE_PAINT_GPENCIL, &r_new);
|
|
|
|
|
if ((reset) || (r_new)) {
|
|
|
|
|
BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_MARKER_BOLD);
|
|
|
|
|
}
|
2020-03-09 16:27:24 +01:00
|
|
|
|
|
|
|
|
/* Marker Chisel brush. */
|
2020-05-15 16:43:50 +02:00
|
|
|
brush = gpencil_brush_ensure(bmain, ts, "Marker Chisel", OB_MODE_PAINT_GPENCIL, &r_new);
|
|
|
|
|
if ((reset) || (r_new)) {
|
|
|
|
|
BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_MARKER_CHISEL);
|
|
|
|
|
}
|
2020-03-09 16:27:24 +01:00
|
|
|
|
|
|
|
|
/* Pen brush. */
|
2020-05-15 16:43:50 +02:00
|
|
|
brush = gpencil_brush_ensure(bmain, ts, "Pen", OB_MODE_PAINT_GPENCIL, &r_new);
|
|
|
|
|
if ((reset) || (r_new)) {
|
|
|
|
|
BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_PEN);
|
|
|
|
|
}
|
2020-03-09 16:27:24 +01:00
|
|
|
|
|
|
|
|
/* Pencil Soft brush. */
|
2020-05-15 16:43:50 +02:00
|
|
|
brush = gpencil_brush_ensure(bmain, ts, "Pencil Soft", OB_MODE_PAINT_GPENCIL, &r_new);
|
|
|
|
|
if ((reset) || (r_new)) {
|
|
|
|
|
BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_PENCIL_SOFT);
|
|
|
|
|
}
|
2020-03-09 16:27:24 +01:00
|
|
|
|
|
|
|
|
/* Pencil brush. */
|
2020-05-15 16:43:50 +02:00
|
|
|
brush = gpencil_brush_ensure(bmain, ts, "Pencil", OB_MODE_PAINT_GPENCIL, &r_new);
|
|
|
|
|
if ((reset) || (r_new)) {
|
|
|
|
|
BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_PENCIL);
|
|
|
|
|
}
|
2020-03-09 16:27:24 +01:00
|
|
|
deft_draw = brush; /* save default brush. */
|
|
|
|
|
|
|
|
|
|
/* Fill brush. */
|
2020-05-15 16:43:50 +02:00
|
|
|
brush = gpencil_brush_ensure(bmain, ts, "Fill Area", OB_MODE_PAINT_GPENCIL, &r_new);
|
|
|
|
|
if ((reset) || (r_new)) {
|
|
|
|
|
BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_FILL_AREA);
|
|
|
|
|
}
|
2020-03-09 16:27:24 +01:00
|
|
|
|
|
|
|
|
/* Soft Eraser brush. */
|
2020-05-15 16:43:50 +02:00
|
|
|
brush = gpencil_brush_ensure(bmain, ts, "Eraser Soft", OB_MODE_PAINT_GPENCIL, &r_new);
|
|
|
|
|
if ((reset) || (r_new)) {
|
|
|
|
|
BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_ERASER_SOFT);
|
|
|
|
|
}
|
2020-03-09 16:27:24 +01:00
|
|
|
|
|
|
|
|
/* Hard Eraser brush. */
|
2020-05-15 16:43:50 +02:00
|
|
|
brush = gpencil_brush_ensure(bmain, ts, "Eraser Hard", OB_MODE_PAINT_GPENCIL, &r_new);
|
|
|
|
|
if ((reset) || (r_new)) {
|
|
|
|
|
BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_ERASER_HARD);
|
|
|
|
|
}
|
2020-03-09 16:27:24 +01:00
|
|
|
|
|
|
|
|
/* Point Eraser brush. */
|
2020-05-15 16:43:50 +02:00
|
|
|
brush = gpencil_brush_ensure(bmain, ts, "Eraser Point", OB_MODE_PAINT_GPENCIL, &r_new);
|
|
|
|
|
if ((reset) || (r_new)) {
|
|
|
|
|
BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_ERASER_POINT);
|
|
|
|
|
}
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2019-09-27 16:52:08 +02:00
|
|
|
/* Stroke Eraser brush. */
|
2020-05-15 16:43:50 +02:00
|
|
|
brush = gpencil_brush_ensure(bmain, ts, "Eraser Stroke", OB_MODE_PAINT_GPENCIL, &r_new);
|
|
|
|
|
if ((reset) || (r_new)) {
|
|
|
|
|
BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_ERASER_STROKE);
|
|
|
|
|
}
|
2020-03-09 16:27:24 +01:00
|
|
|
|
|
|
|
|
/* Tint brush. */
|
2020-05-15 16:43:50 +02:00
|
|
|
brush = gpencil_brush_ensure(bmain, ts, "Tint", OB_MODE_PAINT_GPENCIL, &r_new);
|
|
|
|
|
if ((reset) || (r_new)) {
|
|
|
|
|
BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_TINT);
|
|
|
|
|
}
|
2020-03-09 16:27:24 +01:00
|
|
|
|
|
|
|
|
/* Set default Draw brush. */
|
2020-05-18 17:04:00 +02:00
|
|
|
if (reset || brush_prev == NULL) {
|
|
|
|
|
BKE_paint_brush_set(paint, deft_draw);
|
|
|
|
|
}
|
2020-06-25 17:13:21 +02:00
|
|
|
else {
|
|
|
|
|
if (brush_prev != NULL) {
|
|
|
|
|
BKE_paint_brush_set(paint, brush_prev);
|
|
|
|
|
}
|
|
|
|
|
}
|
2020-03-09 16:27:24 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Create a set of grease pencil Vertex Paint presets. */
|
2020-05-15 16:43:50 +02:00
|
|
|
void BKE_brush_gpencil_vertex_presets(Main *bmain, ToolSettings *ts, const bool reset)
|
2020-03-09 16:27:24 +01:00
|
|
|
{
|
2020-05-15 16:43:50 +02:00
|
|
|
bool r_new = false;
|
|
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
Paint *vertexpaint = &ts->gp_vertexpaint->paint;
|
2020-05-18 17:04:00 +02:00
|
|
|
Brush *brush_prev = vertexpaint->brush;
|
2020-03-09 16:27:24 +01:00
|
|
|
Brush *brush, *deft_vertex;
|
|
|
|
|
/* Vertex Draw brush. */
|
2020-05-15 16:43:50 +02:00
|
|
|
brush = gpencil_brush_ensure(bmain, ts, "Vertex Draw", OB_MODE_VERTEX_GPENCIL, &r_new);
|
|
|
|
|
if ((reset) || (r_new)) {
|
|
|
|
|
BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_VERTEX_DRAW);
|
|
|
|
|
}
|
2020-03-09 16:27:24 +01:00
|
|
|
deft_vertex = brush; /* save default brush. */
|
|
|
|
|
|
|
|
|
|
/* Vertex Blur brush. */
|
2020-05-15 16:43:50 +02:00
|
|
|
brush = gpencil_brush_ensure(bmain, ts, "Vertex Blur", OB_MODE_VERTEX_GPENCIL, &r_new);
|
|
|
|
|
if ((reset) || (r_new)) {
|
|
|
|
|
BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_VERTEX_BLUR);
|
|
|
|
|
}
|
2020-03-09 16:27:24 +01:00
|
|
|
/* Vertex Average brush. */
|
2020-05-15 16:43:50 +02:00
|
|
|
brush = gpencil_brush_ensure(bmain, ts, "Vertex Average", OB_MODE_VERTEX_GPENCIL, &r_new);
|
|
|
|
|
if ((reset) || (r_new)) {
|
|
|
|
|
BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_VERTEX_AVERAGE);
|
|
|
|
|
}
|
2020-03-09 16:27:24 +01:00
|
|
|
/* Vertex Smear brush. */
|
2020-05-15 16:43:50 +02:00
|
|
|
brush = gpencil_brush_ensure(bmain, ts, "Vertex Smear", OB_MODE_VERTEX_GPENCIL, &r_new);
|
|
|
|
|
if ((reset) || (r_new)) {
|
|
|
|
|
BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_VERTEX_SMEAR);
|
|
|
|
|
}
|
2020-03-09 16:27:24 +01:00
|
|
|
/* Vertex Replace brush. */
|
2020-05-15 16:43:50 +02:00
|
|
|
brush = gpencil_brush_ensure(bmain, ts, "Vertex Replace", OB_MODE_VERTEX_GPENCIL, &r_new);
|
|
|
|
|
if ((reset) || (r_new)) {
|
|
|
|
|
BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_VERTEX_REPLACE);
|
|
|
|
|
}
|
2020-03-09 16:27:24 +01:00
|
|
|
|
|
|
|
|
/* Set default Vertex brush. */
|
2020-05-18 17:04:00 +02:00
|
|
|
if (reset || brush_prev == NULL) {
|
|
|
|
|
BKE_paint_brush_set(vertexpaint, deft_vertex);
|
|
|
|
|
}
|
2020-06-25 17:13:21 +02:00
|
|
|
else {
|
|
|
|
|
if (brush_prev != NULL) {
|
|
|
|
|
BKE_paint_brush_set(vertexpaint, brush_prev);
|
|
|
|
|
}
|
|
|
|
|
}
|
2020-03-09 16:27:24 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Create a set of grease pencil Sculpt Paint presets. */
|
2020-05-15 16:43:50 +02:00
|
|
|
void BKE_brush_gpencil_sculpt_presets(Main *bmain, ToolSettings *ts, const bool reset)
|
2020-03-09 16:27:24 +01:00
|
|
|
{
|
2020-05-15 16:43:50 +02:00
|
|
|
bool r_new = false;
|
|
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
Paint *sculptpaint = &ts->gp_sculptpaint->paint;
|
2020-05-18 17:04:00 +02:00
|
|
|
Brush *brush_prev = sculptpaint->brush;
|
2020-03-09 16:27:24 +01:00
|
|
|
Brush *brush, *deft_sculpt;
|
|
|
|
|
|
|
|
|
|
/* Smooth brush. */
|
2020-05-15 16:43:50 +02:00
|
|
|
brush = gpencil_brush_ensure(bmain, ts, "Smooth Stroke", OB_MODE_SCULPT_GPENCIL, &r_new);
|
|
|
|
|
if ((reset) || (r_new)) {
|
|
|
|
|
BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_SMOOTH_STROKE);
|
|
|
|
|
}
|
2020-03-09 16:27:24 +01:00
|
|
|
deft_sculpt = brush;
|
|
|
|
|
|
|
|
|
|
/* Strength brush. */
|
2020-05-15 16:43:50 +02:00
|
|
|
brush = gpencil_brush_ensure(bmain, ts, "Strength Stroke", OB_MODE_SCULPT_GPENCIL, &r_new);
|
|
|
|
|
if ((reset) || (r_new)) {
|
|
|
|
|
BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_STRENGTH_STROKE);
|
|
|
|
|
}
|
2020-03-09 16:27:24 +01:00
|
|
|
|
|
|
|
|
/* Thickness brush. */
|
2020-05-15 16:43:50 +02:00
|
|
|
brush = gpencil_brush_ensure(bmain, ts, "Thickness Stroke", OB_MODE_SCULPT_GPENCIL, &r_new);
|
|
|
|
|
if ((reset) || (r_new)) {
|
|
|
|
|
BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_THICKNESS_STROKE);
|
|
|
|
|
}
|
2020-03-09 16:27:24 +01:00
|
|
|
|
|
|
|
|
/* Grab brush. */
|
2020-05-15 16:43:50 +02:00
|
|
|
brush = gpencil_brush_ensure(bmain, ts, "Grab Stroke", OB_MODE_SCULPT_GPENCIL, &r_new);
|
|
|
|
|
if ((reset) || (r_new)) {
|
|
|
|
|
BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_GRAB_STROKE);
|
|
|
|
|
}
|
2020-03-09 16:27:24 +01:00
|
|
|
|
|
|
|
|
/* Push brush. */
|
2020-05-15 16:43:50 +02:00
|
|
|
brush = gpencil_brush_ensure(bmain, ts, "Push Stroke", OB_MODE_SCULPT_GPENCIL, &r_new);
|
|
|
|
|
if ((reset) || (r_new)) {
|
|
|
|
|
BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_PUSH_STROKE);
|
|
|
|
|
}
|
2020-03-09 16:27:24 +01:00
|
|
|
|
|
|
|
|
/* Twist brush. */
|
2020-05-15 16:43:50 +02:00
|
|
|
brush = gpencil_brush_ensure(bmain, ts, "Twist Stroke", OB_MODE_SCULPT_GPENCIL, &r_new);
|
|
|
|
|
if ((reset) || (r_new)) {
|
|
|
|
|
BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_TWIST_STROKE);
|
|
|
|
|
}
|
2020-03-09 16:27:24 +01:00
|
|
|
|
|
|
|
|
/* Pinch brush. */
|
2020-05-15 16:43:50 +02:00
|
|
|
brush = gpencil_brush_ensure(bmain, ts, "Pinch Stroke", OB_MODE_SCULPT_GPENCIL, &r_new);
|
|
|
|
|
if ((reset) || (r_new)) {
|
|
|
|
|
BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_PINCH_STROKE);
|
|
|
|
|
}
|
2020-03-09 16:27:24 +01:00
|
|
|
|
|
|
|
|
/* Randomize brush. */
|
2020-05-15 16:43:50 +02:00
|
|
|
brush = gpencil_brush_ensure(bmain, ts, "Randomize Stroke", OB_MODE_SCULPT_GPENCIL, &r_new);
|
|
|
|
|
if ((reset) || (r_new)) {
|
|
|
|
|
BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_RANDOMIZE_STROKE);
|
|
|
|
|
}
|
2020-03-09 16:27:24 +01:00
|
|
|
|
|
|
|
|
/* Clone brush. */
|
2020-05-15 16:43:50 +02:00
|
|
|
brush = gpencil_brush_ensure(bmain, ts, "Clone Stroke", OB_MODE_SCULPT_GPENCIL, &r_new);
|
|
|
|
|
if ((reset) || (r_new)) {
|
|
|
|
|
BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_CLONE_STROKE);
|
|
|
|
|
}
|
2020-03-09 16:27:24 +01:00
|
|
|
|
|
|
|
|
/* Set default brush. */
|
2020-05-18 17:04:00 +02:00
|
|
|
if (reset || brush_prev == NULL) {
|
|
|
|
|
BKE_paint_brush_set(sculptpaint, deft_sculpt);
|
|
|
|
|
}
|
2020-06-25 17:13:21 +02:00
|
|
|
else {
|
|
|
|
|
if (brush_prev != NULL) {
|
|
|
|
|
BKE_paint_brush_set(sculptpaint, brush_prev);
|
|
|
|
|
}
|
|
|
|
|
}
|
2020-03-09 16:27:24 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Create a set of grease pencil Weight Paint presets. */
|
2020-05-15 16:43:50 +02:00
|
|
|
void BKE_brush_gpencil_weight_presets(Main *bmain, ToolSettings *ts, const bool reset)
|
2020-03-09 16:27:24 +01:00
|
|
|
{
|
2020-05-15 16:43:50 +02:00
|
|
|
bool r_new = false;
|
|
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
Paint *weightpaint = &ts->gp_weightpaint->paint;
|
2020-05-18 17:04:00 +02:00
|
|
|
Brush *brush_prev = weightpaint->brush;
|
2020-03-09 16:27:24 +01:00
|
|
|
Brush *brush, *deft_weight;
|
|
|
|
|
/* Vertex Draw brush. */
|
2020-05-15 16:43:50 +02:00
|
|
|
brush = gpencil_brush_ensure(bmain, ts, "Draw Weight", OB_MODE_WEIGHT_GPENCIL, &r_new);
|
|
|
|
|
if ((reset) || (r_new)) {
|
|
|
|
|
BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_DRAW_WEIGHT);
|
|
|
|
|
}
|
2020-03-09 16:27:24 +01:00
|
|
|
deft_weight = brush; /* save default brush. */
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2020-03-09 16:27:24 +01:00
|
|
|
/* Set default brush. */
|
2020-05-18 17:04:00 +02:00
|
|
|
if (reset || brush_prev == NULL) {
|
|
|
|
|
BKE_paint_brush_set(weightpaint, deft_weight);
|
|
|
|
|
}
|
2020-06-25 17:13:21 +02:00
|
|
|
else {
|
|
|
|
|
if (brush_prev != NULL) {
|
|
|
|
|
BKE_paint_brush_set(weightpaint, brush_prev);
|
|
|
|
|
}
|
|
|
|
|
}
|
2018-07-31 10:22:19 +02:00
|
|
|
}
|
|
|
|
|
|
2018-02-06 23:34:58 +11:00
|
|
|
struct Brush *BKE_brush_first_search(struct Main *bmain, const eObjectMode ob_mode)
|
2015-08-31 21:37:38 +03:00
|
|
|
{
|
|
|
|
|
Brush *brush;
|
|
|
|
|
|
2019-03-08 09:29:17 +11:00
|
|
|
for (brush = bmain->brushes.first; brush; brush = brush->id.next) {
|
2019-04-22 09:39:35 +10:00
|
|
|
if (brush->ob_mode & ob_mode) {
|
2015-08-31 21:37:38 +03:00
|
|
|
return brush;
|
2019-04-22 09:39:35 +10:00
|
|
|
}
|
2015-08-31 21:37:38 +03:00
|
|
|
}
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2012-05-05 00:58:22 +00:00
|
|
|
void BKE_brush_debug_print_state(Brush *br)
|
2010-07-27 16:09:02 +00:00
|
|
|
{
|
|
|
|
|
/* create a fake brush and set it to the defaults */
|
2012-05-06 15:15:33 +00:00
|
|
|
Brush def = {{NULL}};
|
2012-05-05 00:58:22 +00:00
|
|
|
brush_defaults(&def);
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2010-07-27 16:09:02 +00:00
|
|
|
#define BR_TEST(field, t) \
|
2020-09-19 16:01:32 +10:00
|
|
|
if (br->field != def.field) { \
|
|
|
|
|
printf("br->" #field " = %" #t ";\n", br->field); \
|
|
|
|
|
} \
|
|
|
|
|
((void)0)
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2012-05-06 15:15:33 +00:00
|
|
|
#define BR_TEST_FLAG(_f) \
|
2020-09-19 16:01:32 +10:00
|
|
|
if ((br->flag & _f) && !(def.flag & _f)) { \
|
2012-05-06 15:15:33 +00:00
|
|
|
printf("br->flag |= " #_f ";\n"); \
|
2020-09-19 16:01:32 +10:00
|
|
|
} \
|
|
|
|
|
else if (!(br->flag & _f) && (def.flag & _f)) { \
|
|
|
|
|
printf("br->flag &= ~" #_f ";\n"); \
|
|
|
|
|
} \
|
|
|
|
|
((void)0)
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2013-04-16 15:02:41 +00:00
|
|
|
#define BR_TEST_FLAG_OVERLAY(_f) \
|
2020-09-19 16:01:32 +10:00
|
|
|
if ((br->overlay_flags & _f) && !(def.overlay_flags & _f)) { \
|
2013-04-16 15:02:41 +00:00
|
|
|
printf("br->overlay_flags |= " #_f ";\n"); \
|
2020-09-19 16:01:32 +10:00
|
|
|
} \
|
|
|
|
|
else if (!(br->overlay_flags & _f) && (def.overlay_flags & _f)) { \
|
|
|
|
|
printf("br->overlay_flags &= ~" #_f ";\n"); \
|
|
|
|
|
} \
|
|
|
|
|
((void)0)
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2010-07-27 16:09:02 +00:00
|
|
|
/* print out any non-default brush state */
|
|
|
|
|
BR_TEST(normal_weight, f);
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2010-07-27 16:09:02 +00:00
|
|
|
BR_TEST(blend, d);
|
|
|
|
|
BR_TEST(size, d);
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2010-07-27 16:09:02 +00:00
|
|
|
/* br->flag */
|
|
|
|
|
BR_TEST_FLAG(BRUSH_AIRBRUSH);
|
|
|
|
|
BR_TEST_FLAG(BRUSH_ALPHA_PRESSURE);
|
|
|
|
|
BR_TEST_FLAG(BRUSH_SIZE_PRESSURE);
|
|
|
|
|
BR_TEST_FLAG(BRUSH_JITTER_PRESSURE);
|
|
|
|
|
BR_TEST_FLAG(BRUSH_SPACING_PRESSURE);
|
|
|
|
|
BR_TEST_FLAG(BRUSH_ANCHORED);
|
|
|
|
|
BR_TEST_FLAG(BRUSH_DIR_IN);
|
|
|
|
|
BR_TEST_FLAG(BRUSH_SPACE);
|
|
|
|
|
BR_TEST_FLAG(BRUSH_SMOOTH_STROKE);
|
|
|
|
|
BR_TEST_FLAG(BRUSH_PERSISTENT);
|
|
|
|
|
BR_TEST_FLAG(BRUSH_ACCUMULATE);
|
|
|
|
|
BR_TEST_FLAG(BRUSH_LOCK_ALPHA);
|
|
|
|
|
BR_TEST_FLAG(BRUSH_ORIGINAL_NORMAL);
|
|
|
|
|
BR_TEST_FLAG(BRUSH_OFFSET_PRESSURE);
|
|
|
|
|
BR_TEST_FLAG(BRUSH_SPACE_ATTEN);
|
|
|
|
|
BR_TEST_FLAG(BRUSH_ADAPTIVE_SPACE);
|
|
|
|
|
BR_TEST_FLAG(BRUSH_LOCK_SIZE);
|
|
|
|
|
BR_TEST_FLAG(BRUSH_EDGE_TO_EDGE);
|
2013-12-09 22:36:33 +02:00
|
|
|
BR_TEST_FLAG(BRUSH_DRAG_DOT);
|
2010-07-27 16:09:02 +00:00
|
|
|
BR_TEST_FLAG(BRUSH_INVERSE_SMOOTH_PRESSURE);
|
|
|
|
|
BR_TEST_FLAG(BRUSH_PLANE_TRIM);
|
|
|
|
|
BR_TEST_FLAG(BRUSH_FRONTFACE);
|
|
|
|
|
BR_TEST_FLAG(BRUSH_CUSTOM_ICON);
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2013-04-16 15:02:41 +00:00
|
|
|
BR_TEST_FLAG_OVERLAY(BRUSH_OVERLAY_CURSOR);
|
|
|
|
|
BR_TEST_FLAG_OVERLAY(BRUSH_OVERLAY_PRIMARY);
|
|
|
|
|
BR_TEST_FLAG_OVERLAY(BRUSH_OVERLAY_SECONDARY);
|
2013-04-23 00:32:51 +00:00
|
|
|
BR_TEST_FLAG_OVERLAY(BRUSH_OVERLAY_CURSOR_OVERRIDE_ON_STROKE);
|
|
|
|
|
BR_TEST_FLAG_OVERLAY(BRUSH_OVERLAY_PRIMARY_OVERRIDE_ON_STROKE);
|
|
|
|
|
BR_TEST_FLAG_OVERLAY(BRUSH_OVERLAY_SECONDARY_OVERRIDE_ON_STROKE);
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2010-07-27 16:09:02 +00:00
|
|
|
BR_TEST(jitter, f);
|
|
|
|
|
BR_TEST(spacing, d);
|
|
|
|
|
BR_TEST(smooth_stroke_radius, d);
|
|
|
|
|
BR_TEST(smooth_stroke_factor, f);
|
|
|
|
|
BR_TEST(rate, f);
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2010-07-27 16:09:02 +00:00
|
|
|
BR_TEST(alpha, f);
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2010-07-27 16:09:02 +00:00
|
|
|
BR_TEST(sculpt_plane, d);
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2010-07-27 16:09:02 +00:00
|
|
|
BR_TEST(plane_offset, f);
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2010-07-27 16:09:02 +00:00
|
|
|
BR_TEST(autosmooth_factor, f);
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2019-01-23 18:38:40 +01:00
|
|
|
BR_TEST(topology_rake_factor, f);
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2010-07-27 16:09:02 +00:00
|
|
|
BR_TEST(crease_pinch_factor, f);
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2010-07-27 16:09:02 +00:00
|
|
|
BR_TEST(plane_trim, f);
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2010-07-27 16:09:02 +00:00
|
|
|
BR_TEST(texture_sample_bias, f);
|
|
|
|
|
BR_TEST(texture_overlay_alpha, d);
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2010-07-27 16:09:02 +00:00
|
|
|
BR_TEST(add_col[0], f);
|
|
|
|
|
BR_TEST(add_col[1], f);
|
|
|
|
|
BR_TEST(add_col[2], f);
|
2019-12-30 16:41:20 +01:00
|
|
|
BR_TEST(add_col[3], f);
|
2010-07-27 16:09:02 +00:00
|
|
|
BR_TEST(sub_col[0], f);
|
|
|
|
|
BR_TEST(sub_col[1], f);
|
|
|
|
|
BR_TEST(sub_col[2], f);
|
2019-12-30 16:41:20 +01:00
|
|
|
BR_TEST(sub_col[3], f);
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2010-07-27 16:09:02 +00:00
|
|
|
printf("\n");
|
2018-06-17 17:05:51 +02:00
|
|
|
|
2010-07-27 16:09:02 +00:00
|
|
|
#undef BR_TEST
|
|
|
|
|
#undef BR_TEST_FLAG
|
|
|
|
|
}
|
|
|
|
|
|
2012-05-05 00:58:22 +00:00
|
|
|
void BKE_brush_sculpt_reset(Brush *br)
|
2010-07-27 16:09:02 +00:00
|
|
|
{
|
|
|
|
|
/* enable this to see any non-default
|
2012-03-03 20:19:11 +00:00
|
|
|
* settings used by a brush: */
|
2012-05-05 00:58:22 +00:00
|
|
|
// BKE_brush_debug_print_state(br);
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2012-05-05 00:58:22 +00:00
|
|
|
brush_defaults(br);
|
|
|
|
|
BKE_brush_curve_preset(br, CURVE_PRESET_SMOOTH);
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2019-09-06 21:55:32 +02:00
|
|
|
/* Use the curve presets by default */
|
|
|
|
|
br->curve_preset = BRUSH_CURVE_SMOOTH;
|
|
|
|
|
|
2019-10-02 03:32:51 +10:00
|
|
|
/* Note that sculpt defaults where set when 0.5 was the default (now it's 1.0)
|
|
|
|
|
* assign this so logic below can remain the same. */
|
|
|
|
|
br->alpha = 0.5f;
|
|
|
|
|
|
2019-09-26 16:14:02 +02:00
|
|
|
/* Brush settings */
|
2012-04-28 06:31:57 +00:00
|
|
|
switch (br->sculpt_tool) {
|
2019-09-26 16:14:02 +02:00
|
|
|
case SCULPT_TOOL_DRAW_SHARP:
|
|
|
|
|
br->flag |= BRUSH_DIR_IN;
|
|
|
|
|
br->curve_preset = BRUSH_CURVE_POW4;
|
|
|
|
|
br->spacing = 5;
|
2019-09-26 16:32:27 +02:00
|
|
|
break;
|
2020-08-12 16:57:36 +02:00
|
|
|
case SCULPT_TOOL_DISPLACEMENT_ERASER:
|
|
|
|
|
br->curve_preset = BRUSH_CURVE_SMOOTHER;
|
|
|
|
|
br->spacing = 10;
|
|
|
|
|
br->alpha = 1.0f;
|
|
|
|
|
break;
|
2020-01-15 15:54:11 +01:00
|
|
|
case SCULPT_TOOL_SLIDE_RELAX:
|
2019-11-21 18:57:26 +01:00
|
|
|
br->spacing = 10;
|
|
|
|
|
br->alpha = 1.0f;
|
2020-07-21 22:57:50 +02:00
|
|
|
br->slide_deform_type = BRUSH_SLIDE_DEFORM_DRAG;
|
2019-11-21 18:57:26 +01:00
|
|
|
break;
|
2012-05-06 15:15:33 +00:00
|
|
|
case SCULPT_TOOL_CLAY:
|
2019-11-24 21:20:27 +01:00
|
|
|
br->flag |= BRUSH_SIZE_PRESSURE;
|
|
|
|
|
br->spacing = 3;
|
|
|
|
|
br->autosmooth_factor = 0.25f;
|
2019-11-18 22:40:46 +01:00
|
|
|
br->normal_radius_factor = 0.75f;
|
2020-03-09 16:35:07 +01:00
|
|
|
br->hardness = 0.65f;
|
2012-05-06 15:15:33 +00:00
|
|
|
break;
|
2020-01-22 02:23:51 +01:00
|
|
|
case SCULPT_TOOL_CLAY_THUMB:
|
|
|
|
|
br->alpha = 0.5f;
|
|
|
|
|
br->normal_radius_factor = 1.0f;
|
|
|
|
|
br->spacing = 6;
|
2020-03-01 20:13:29 +01:00
|
|
|
br->hardness = 0.5f;
|
2020-01-22 02:23:51 +01:00
|
|
|
br->flag |= BRUSH_SIZE_PRESSURE;
|
|
|
|
|
br->flag &= ~BRUSH_SPACE_ATTEN;
|
|
|
|
|
break;
|
2019-10-03 23:46:29 +02:00
|
|
|
case SCULPT_TOOL_CLAY_STRIPS:
|
2019-11-14 19:12:11 +01:00
|
|
|
br->flag |= BRUSH_ACCUMULATE | BRUSH_SIZE_PRESSURE;
|
|
|
|
|
br->flag &= ~BRUSH_SPACE_ATTEN;
|
|
|
|
|
br->alpha = 0.6f;
|
2020-02-11 20:04:41 +01:00
|
|
|
br->spacing = 5;
|
2019-11-04 21:23:16 +01:00
|
|
|
br->normal_radius_factor = 1.55f;
|
2020-02-11 20:04:41 +01:00
|
|
|
br->tip_roundness = 0.18f;
|
|
|
|
|
br->curve_preset = BRUSH_CURVE_SMOOTHER;
|
2019-10-03 23:46:29 +02:00
|
|
|
break;
|
2019-11-06 19:39:34 +01:00
|
|
|
case SCULPT_TOOL_MULTIPLANE_SCRAPE:
|
|
|
|
|
br->flag2 |= BRUSH_MULTIPLANE_SCRAPE_DYNAMIC | BRUSH_MULTIPLANE_SCRAPE_PLANES_PREVIEW;
|
|
|
|
|
br->alpha = 0.7f;
|
|
|
|
|
br->normal_radius_factor = 0.70f;
|
|
|
|
|
br->multiplane_scrape_angle = 60;
|
|
|
|
|
br->curve_preset = BRUSH_CURVE_SMOOTH;
|
|
|
|
|
br->spacing = 5;
|
|
|
|
|
break;
|
2012-05-06 15:15:33 +00:00
|
|
|
case SCULPT_TOOL_CREASE:
|
|
|
|
|
br->flag |= BRUSH_DIR_IN;
|
|
|
|
|
br->alpha = 0.25;
|
|
|
|
|
break;
|
|
|
|
|
case SCULPT_TOOL_SCRAPE:
|
2019-10-08 18:10:02 +02:00
|
|
|
case SCULPT_TOOL_FILL:
|
2020-09-10 22:07:28 +02:00
|
|
|
br->alpha = 0.7f;
|
2020-10-20 22:59:12 +02:00
|
|
|
br->area_radius_factor = 0.5f;
|
2019-09-26 16:14:02 +02:00
|
|
|
br->spacing = 7;
|
2019-09-26 18:19:52 +02:00
|
|
|
br->flag |= BRUSH_ACCUMULATE;
|
2019-10-08 18:10:02 +02:00
|
|
|
br->flag |= BRUSH_INVERT_TO_SCRAPE_FILL;
|
2012-05-06 15:15:33 +00:00
|
|
|
break;
|
|
|
|
|
case SCULPT_TOOL_ROTATE:
|
|
|
|
|
br->alpha = 1.0;
|
|
|
|
|
break;
|
|
|
|
|
case SCULPT_TOOL_SMOOTH:
|
|
|
|
|
br->flag &= ~BRUSH_SPACE_ATTEN;
|
|
|
|
|
br->spacing = 5;
|
2019-09-26 16:14:02 +02:00
|
|
|
br->alpha = 0.7f;
|
2020-03-26 16:05:46 +01:00
|
|
|
br->surface_smooth_shape_preservation = 0.5f;
|
|
|
|
|
br->surface_smooth_current_vertex = 0.5f;
|
|
|
|
|
br->surface_smooth_iterations = 4;
|
2012-05-06 15:15:33 +00:00
|
|
|
break;
|
|
|
|
|
case SCULPT_TOOL_SNAKE_HOOK:
|
2019-09-27 16:00:57 +02:00
|
|
|
br->alpha = 1.0f;
|
2019-10-07 22:07:29 +02:00
|
|
|
br->rake_factor = 1.0f;
|
2019-09-27 16:00:57 +02:00
|
|
|
break;
|
2012-05-06 15:15:33 +00:00
|
|
|
case SCULPT_TOOL_THUMB:
|
|
|
|
|
br->size = 75;
|
|
|
|
|
br->flag &= ~BRUSH_ALPHA_PRESSURE;
|
|
|
|
|
br->flag &= ~BRUSH_SPACE;
|
|
|
|
|
br->flag &= ~BRUSH_SPACE_ATTEN;
|
2019-09-26 16:14:02 +02:00
|
|
|
break;
|
|
|
|
|
case SCULPT_TOOL_ELASTIC_DEFORM:
|
|
|
|
|
br->elastic_deform_volume_preservation = 0.4f;
|
|
|
|
|
br->elastic_deform_type = BRUSH_ELASTIC_DEFORM_GRAB_TRISCALE;
|
|
|
|
|
br->flag &= ~BRUSH_ALPHA_PRESSURE;
|
|
|
|
|
br->flag &= ~BRUSH_SPACE;
|
|
|
|
|
br->flag &= ~BRUSH_SPACE_ATTEN;
|
|
|
|
|
break;
|
|
|
|
|
case SCULPT_TOOL_POSE:
|
2019-11-17 01:09:08 +01:00
|
|
|
br->pose_smooth_iterations = 4;
|
2020-01-07 16:46:56 +01:00
|
|
|
br->pose_ik_segments = 1;
|
2020-06-23 16:10:47 +02:00
|
|
|
br->flag2 |= BRUSH_POSE_IK_ANCHORED | BRUSH_USE_CONNECTED_ONLY;
|
2019-09-26 16:14:02 +02:00
|
|
|
br->flag &= ~BRUSH_ALPHA_PRESSURE;
|
|
|
|
|
br->flag &= ~BRUSH_SPACE;
|
|
|
|
|
br->flag &= ~BRUSH_SPACE_ATTEN;
|
|
|
|
|
break;
|
Sculpt: Boundary Brush
This brush includes a set of deformation modes designed to deform and
control the shape of the mesh boundaries, which are really hard to do
with regular sculpt brushes (and even in edit mode). This is useful
for creating cloth assets and hard surface base meshes.
The brush detects the mesh boundary closest to the active vertex and
propagates the deformation using the brush falloff into the mesh.
It includes bend, expand, inflate, grab and twist deform modes.
The main use cases of this brush are the Bend and Expand deformation
modes, which depend on a grid topology to create the best results.
In order to do further adjustments and tweaks to the result of these
deformation modes, the brush also includes the Inflate, Grab and
Twist deformation modes, which do not depend that much on the topology.
Grab and Inflate are the same operation that is implemented in the
Grab and Inflate tools, they are also available in the boundary brush
as producing deformations with regular brushes in these areas is very
hard to control.
Even if this brush can produce deformations in triangle meshes and
meshes with a non-regular quad grid, the more regular and clean the
topology is, the better. Most of the assets this brush is intended to
deform are always created from a cylindrical or plane quad grid, so it
should be fine. Also, its algorithms can be improved in future versions
to handle more corner cases and topology patterns.
Reviewed By: sergey
Differential Revision: https://developer.blender.org/D8356
2020-08-10 17:57:01 +02:00
|
|
|
case SCULPT_TOOL_BOUNDARY:
|
|
|
|
|
br->flag &= ~BRUSH_ALPHA_PRESSURE;
|
|
|
|
|
br->flag &= ~BRUSH_SPACE;
|
|
|
|
|
br->flag &= ~BRUSH_SPACE_ATTEN;
|
|
|
|
|
br->curve_preset = BRUSH_CURVE_CONSTANT;
|
|
|
|
|
break;
|
2020-03-05 14:53:23 +01:00
|
|
|
case SCULPT_TOOL_DRAW_FACE_SETS:
|
|
|
|
|
br->alpha = 0.5f;
|
|
|
|
|
br->flag &= ~BRUSH_ALPHA_PRESSURE;
|
|
|
|
|
br->flag &= ~BRUSH_SPACE;
|
|
|
|
|
br->flag &= ~BRUSH_SPACE_ATTEN;
|
|
|
|
|
break;
|
2019-09-26 16:14:02 +02:00
|
|
|
case SCULPT_TOOL_GRAB:
|
|
|
|
|
br->alpha = 0.4f;
|
|
|
|
|
br->size = 75;
|
|
|
|
|
br->flag &= ~BRUSH_ALPHA_PRESSURE;
|
|
|
|
|
br->flag &= ~BRUSH_SPACE;
|
|
|
|
|
br->flag &= ~BRUSH_SPACE_ATTEN;
|
|
|
|
|
break;
|
2020-02-28 14:40:40 +01:00
|
|
|
case SCULPT_TOOL_CLOTH:
|
|
|
|
|
br->cloth_mass = 1.0f;
|
|
|
|
|
br->cloth_damping = 0.01f;
|
|
|
|
|
br->cloth_sim_limit = 2.5f;
|
|
|
|
|
br->cloth_sim_falloff = 0.75f;
|
|
|
|
|
br->cloth_deform_type = BRUSH_CLOTH_DEFORM_DRAG;
|
|
|
|
|
br->flag &= ~(BRUSH_ALPHA_PRESSURE | BRUSH_SIZE_PRESSURE);
|
|
|
|
|
break;
|
2020-04-14 21:06:49 +02:00
|
|
|
case SCULPT_TOOL_LAYER:
|
|
|
|
|
br->flag &= ~BRUSH_SPACE_ATTEN;
|
|
|
|
|
br->hardness = 0.35f;
|
|
|
|
|
br->alpha = 1.0f;
|
|
|
|
|
br->height = 0.05f;
|
|
|
|
|
break;
|
Sculpt Vertex Colors: Initial implementation
Sculpt Vertex Colors is a painting system that runs inside sculpt mode, reusing all its tools and optimizations. This provides much better performance, easier to maintain code and more advanced features (new brush engine, filters, symmetry options, masks and face sets compatibility...). This is also the initial step for future features like vertex painting in Multires and brushes that can sculpt and paint at the same time.
This commit includes:
- SCULPT_UNDO_COLOR for undo support in sculpt mode
- SCULPT_UPDATE_COLOR and PBVH flags and rendering
- Sculpt Color API functions
- Sculpt capability for sculpt tools (only enabled in the Paint Brush for now)
- Rendering support in workbench (default to Sculpt Vertex Colors except in Vertex Paint)
- Conversion operator between MPropCol (Sculpt Vertex Colors) and MLoopCol (Vertex Paint)
- Remesher reprojection in the Voxel Remehser
- Paint Brush and Smear Brush with color smoothing in alt-smooth mode
- Parameters for the new brush engine (density, opacity, flow, wet paint mixing, tip scale) implemented in Sculpt Vertex Colors
- Color Filter
- Color picker (uses S shortcut, replaces smooth)
- Color selector in the top bar
Reviewed By: brecht
Maniphest Tasks: T72866
Differential Revision: https://developer.blender.org/D5975
2020-06-22 20:05:28 +02:00
|
|
|
case SCULPT_TOOL_PAINT:
|
|
|
|
|
br->hardness = 0.4f;
|
|
|
|
|
br->spacing = 10;
|
|
|
|
|
br->alpha = 0.6f;
|
|
|
|
|
br->flow = 1.0f;
|
|
|
|
|
br->tip_scale_x = 1.0f;
|
|
|
|
|
br->tip_roundness = 1.0f;
|
|
|
|
|
br->density = 1.0f;
|
|
|
|
|
br->flag &= ~BRUSH_SPACE_ATTEN;
|
|
|
|
|
zero_v3(br->rgb);
|
|
|
|
|
break;
|
|
|
|
|
case SCULPT_TOOL_SMEAR:
|
|
|
|
|
br->alpha = 1.0f;
|
2020-06-26 19:58:33 +02:00
|
|
|
br->spacing = 5;
|
|
|
|
|
br->flag &= ~BRUSH_ALPHA_PRESSURE;
|
Sculpt Vertex Colors: Initial implementation
Sculpt Vertex Colors is a painting system that runs inside sculpt mode, reusing all its tools and optimizations. This provides much better performance, easier to maintain code and more advanced features (new brush engine, filters, symmetry options, masks and face sets compatibility...). This is also the initial step for future features like vertex painting in Multires and brushes that can sculpt and paint at the same time.
This commit includes:
- SCULPT_UNDO_COLOR for undo support in sculpt mode
- SCULPT_UPDATE_COLOR and PBVH flags and rendering
- Sculpt Color API functions
- Sculpt capability for sculpt tools (only enabled in the Paint Brush for now)
- Rendering support in workbench (default to Sculpt Vertex Colors except in Vertex Paint)
- Conversion operator between MPropCol (Sculpt Vertex Colors) and MLoopCol (Vertex Paint)
- Remesher reprojection in the Voxel Remehser
- Paint Brush and Smear Brush with color smoothing in alt-smooth mode
- Parameters for the new brush engine (density, opacity, flow, wet paint mixing, tip scale) implemented in Sculpt Vertex Colors
- Color Filter
- Color picker (uses S shortcut, replaces smooth)
- Color selector in the top bar
Reviewed By: brecht
Maniphest Tasks: T72866
Differential Revision: https://developer.blender.org/D5975
2020-06-22 20:05:28 +02:00
|
|
|
br->flag &= ~BRUSH_SPACE_ATTEN;
|
|
|
|
|
br->curve_preset = BRUSH_CURVE_SPHERE;
|
|
|
|
|
break;
|
2020-12-11 22:49:49 +01:00
|
|
|
case SCULPT_TOOL_DISPLACEMENT_SMEAR:
|
|
|
|
|
br->alpha = 1.0f;
|
|
|
|
|
br->spacing = 5;
|
|
|
|
|
br->hardness = 0.7f;
|
|
|
|
|
br->flag &= ~BRUSH_ALPHA_PRESSURE;
|
|
|
|
|
br->flag &= ~BRUSH_SPACE_ATTEN;
|
|
|
|
|
br->curve_preset = BRUSH_CURVE_SMOOTHER;
|
|
|
|
|
break;
|
2019-09-26 16:14:02 +02:00
|
|
|
default:
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Cursor colors */
|
2019-12-30 16:41:20 +01:00
|
|
|
|
|
|
|
|
/* Default Alpha */
|
|
|
|
|
br->add_col[3] = 0.90f;
|
|
|
|
|
br->sub_col[3] = 0.90f;
|
|
|
|
|
|
2019-09-26 16:14:02 +02:00
|
|
|
switch (br->sculpt_tool) {
|
|
|
|
|
case SCULPT_TOOL_DRAW:
|
|
|
|
|
case SCULPT_TOOL_DRAW_SHARP:
|
|
|
|
|
case SCULPT_TOOL_CLAY:
|
|
|
|
|
case SCULPT_TOOL_CLAY_STRIPS:
|
2020-01-22 02:23:51 +01:00
|
|
|
case SCULPT_TOOL_CLAY_THUMB:
|
2019-09-26 16:14:02 +02:00
|
|
|
case SCULPT_TOOL_LAYER:
|
|
|
|
|
case SCULPT_TOOL_INFLATE:
|
|
|
|
|
case SCULPT_TOOL_BLOB:
|
|
|
|
|
case SCULPT_TOOL_CREASE:
|
2019-11-05 16:49:16 +01:00
|
|
|
br->add_col[0] = 0.0f;
|
|
|
|
|
br->add_col[1] = 0.5f;
|
|
|
|
|
br->add_col[2] = 1.0f;
|
|
|
|
|
br->sub_col[0] = 0.0f;
|
|
|
|
|
br->sub_col[1] = 0.5f;
|
|
|
|
|
br->sub_col[2] = 1.0f;
|
2019-09-26 16:14:02 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case SCULPT_TOOL_SMOOTH:
|
|
|
|
|
case SCULPT_TOOL_FLATTEN:
|
|
|
|
|
case SCULPT_TOOL_FILL:
|
|
|
|
|
case SCULPT_TOOL_SCRAPE:
|
2019-11-06 19:39:34 +01:00
|
|
|
case SCULPT_TOOL_MULTIPLANE_SCRAPE:
|
2020-02-12 21:24:15 +01:00
|
|
|
br->add_col[0] = 0.877f;
|
|
|
|
|
br->add_col[1] = 0.142f;
|
|
|
|
|
br->add_col[2] = 0.117f;
|
|
|
|
|
br->sub_col[0] = 0.877f;
|
|
|
|
|
br->sub_col[1] = 0.142f;
|
|
|
|
|
br->sub_col[2] = 0.117f;
|
2019-09-26 16:14:02 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case SCULPT_TOOL_PINCH:
|
|
|
|
|
case SCULPT_TOOL_GRAB:
|
|
|
|
|
case SCULPT_TOOL_SNAKE_HOOK:
|
|
|
|
|
case SCULPT_TOOL_THUMB:
|
|
|
|
|
case SCULPT_TOOL_NUDGE:
|
|
|
|
|
case SCULPT_TOOL_ROTATE:
|
|
|
|
|
case SCULPT_TOOL_ELASTIC_DEFORM:
|
|
|
|
|
case SCULPT_TOOL_POSE:
|
Sculpt: Boundary Brush
This brush includes a set of deformation modes designed to deform and
control the shape of the mesh boundaries, which are really hard to do
with regular sculpt brushes (and even in edit mode). This is useful
for creating cloth assets and hard surface base meshes.
The brush detects the mesh boundary closest to the active vertex and
propagates the deformation using the brush falloff into the mesh.
It includes bend, expand, inflate, grab and twist deform modes.
The main use cases of this brush are the Bend and Expand deformation
modes, which depend on a grid topology to create the best results.
In order to do further adjustments and tweaks to the result of these
deformation modes, the brush also includes the Inflate, Grab and
Twist deformation modes, which do not depend that much on the topology.
Grab and Inflate are the same operation that is implemented in the
Grab and Inflate tools, they are also available in the boundary brush
as producing deformations with regular brushes in these areas is very
hard to control.
Even if this brush can produce deformations in triangle meshes and
meshes with a non-regular quad grid, the more regular and clean the
topology is, the better. Most of the assets this brush is intended to
deform are always created from a cylindrical or plane quad grid, so it
should be fine. Also, its algorithms can be improved in future versions
to handle more corner cases and topology patterns.
Reviewed By: sergey
Differential Revision: https://developer.blender.org/D8356
2020-08-10 17:57:01 +02:00
|
|
|
case SCULPT_TOOL_BOUNDARY:
|
2020-02-12 21:17:35 +01:00
|
|
|
case SCULPT_TOOL_SLIDE_RELAX:
|
2019-09-26 16:14:02 +02:00
|
|
|
br->add_col[0] = 1.0f;
|
2019-11-05 16:49:16 +01:00
|
|
|
br->add_col[1] = 0.95f;
|
|
|
|
|
br->add_col[2] = 0.005f;
|
2019-09-26 16:14:02 +02:00
|
|
|
br->sub_col[0] = 1.0f;
|
2019-11-05 16:49:16 +01:00
|
|
|
br->sub_col[1] = 0.95f;
|
|
|
|
|
br->sub_col[2] = 0.005f;
|
2019-09-26 16:14:02 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case SCULPT_TOOL_SIMPLIFY:
|
Sculpt Vertex Colors: Initial implementation
Sculpt Vertex Colors is a painting system that runs inside sculpt mode, reusing all its tools and optimizations. This provides much better performance, easier to maintain code and more advanced features (new brush engine, filters, symmetry options, masks and face sets compatibility...). This is also the initial step for future features like vertex painting in Multires and brushes that can sculpt and paint at the same time.
This commit includes:
- SCULPT_UNDO_COLOR for undo support in sculpt mode
- SCULPT_UPDATE_COLOR and PBVH flags and rendering
- Sculpt Color API functions
- Sculpt capability for sculpt tools (only enabled in the Paint Brush for now)
- Rendering support in workbench (default to Sculpt Vertex Colors except in Vertex Paint)
- Conversion operator between MPropCol (Sculpt Vertex Colors) and MLoopCol (Vertex Paint)
- Remesher reprojection in the Voxel Remehser
- Paint Brush and Smear Brush with color smoothing in alt-smooth mode
- Parameters for the new brush engine (density, opacity, flow, wet paint mixing, tip scale) implemented in Sculpt Vertex Colors
- Color Filter
- Color picker (uses S shortcut, replaces smooth)
- Color selector in the top bar
Reviewed By: brecht
Maniphest Tasks: T72866
Differential Revision: https://developer.blender.org/D5975
2020-06-22 20:05:28 +02:00
|
|
|
case SCULPT_TOOL_PAINT:
|
2019-09-26 16:14:02 +02:00
|
|
|
case SCULPT_TOOL_MASK:
|
2020-03-05 14:53:23 +01:00
|
|
|
case SCULPT_TOOL_DRAW_FACE_SETS:
|
2020-08-12 16:57:36 +02:00
|
|
|
case SCULPT_TOOL_DISPLACEMENT_ERASER:
|
2020-12-11 22:49:49 +01:00
|
|
|
case SCULPT_TOOL_DISPLACEMENT_SMEAR:
|
Sculpt Vertex Colors: Initial implementation
Sculpt Vertex Colors is a painting system that runs inside sculpt mode, reusing all its tools and optimizations. This provides much better performance, easier to maintain code and more advanced features (new brush engine, filters, symmetry options, masks and face sets compatibility...). This is also the initial step for future features like vertex painting in Multires and brushes that can sculpt and paint at the same time.
This commit includes:
- SCULPT_UNDO_COLOR for undo support in sculpt mode
- SCULPT_UPDATE_COLOR and PBVH flags and rendering
- Sculpt Color API functions
- Sculpt capability for sculpt tools (only enabled in the Paint Brush for now)
- Rendering support in workbench (default to Sculpt Vertex Colors except in Vertex Paint)
- Conversion operator between MPropCol (Sculpt Vertex Colors) and MLoopCol (Vertex Paint)
- Remesher reprojection in the Voxel Remehser
- Paint Brush and Smear Brush with color smoothing in alt-smooth mode
- Parameters for the new brush engine (density, opacity, flow, wet paint mixing, tip scale) implemented in Sculpt Vertex Colors
- Color Filter
- Color picker (uses S shortcut, replaces smooth)
- Color selector in the top bar
Reviewed By: brecht
Maniphest Tasks: T72866
Differential Revision: https://developer.blender.org/D5975
2020-06-22 20:05:28 +02:00
|
|
|
br->add_col[0] = 0.75f;
|
|
|
|
|
br->add_col[1] = 0.75f;
|
|
|
|
|
br->add_col[2] = 0.75f;
|
|
|
|
|
br->sub_col[0] = 0.75f;
|
|
|
|
|
br->sub_col[1] = 0.75f;
|
|
|
|
|
br->sub_col[2] = 0.75f;
|
2012-05-06 15:15:33 +00:00
|
|
|
break;
|
2020-02-28 14:40:40 +01:00
|
|
|
|
|
|
|
|
case SCULPT_TOOL_CLOTH:
|
|
|
|
|
br->add_col[0] = 1.0f;
|
|
|
|
|
br->add_col[1] = 0.5f;
|
|
|
|
|
br->add_col[2] = 0.1f;
|
|
|
|
|
br->sub_col[0] = 1.0f;
|
|
|
|
|
br->sub_col[1] = 0.5f;
|
|
|
|
|
br->sub_col[2] = 0.1f;
|
|
|
|
|
break;
|
2012-05-06 15:15:33 +00:00
|
|
|
default:
|
|
|
|
|
break;
|
2010-07-27 16:09:02 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2013-03-26 07:29:01 +00:00
|
|
|
/**
|
|
|
|
|
* Library Operations
|
|
|
|
|
*/
|
2017-10-17 13:43:10 +11:00
|
|
|
void BKE_brush_curve_preset(Brush *b, eCurveMappingPreset preset)
|
2009-01-07 04:38:30 +00:00
|
|
|
{
|
2019-11-01 12:09:55 +01:00
|
|
|
CurveMapping *cumap = NULL;
|
|
|
|
|
CurveMap *cuma = NULL;
|
2009-01-07 04:38:30 +00:00
|
|
|
|
2019-04-22 09:39:35 +10:00
|
|
|
if (!b->curve) {
|
2019-08-07 03:21:55 +10:00
|
|
|
b->curve = BKE_curvemapping_add(1, 0, 0, 1, 1);
|
2019-04-22 09:39:35 +10:00
|
|
|
}
|
2019-11-01 12:09:55 +01:00
|
|
|
cumap = b->curve;
|
|
|
|
|
cumap->flag &= ~CUMA_EXTEND_EXTRAPOLATE;
|
|
|
|
|
cumap->preset = preset;
|
2009-01-07 04:38:30 +00:00
|
|
|
|
2019-11-01 12:09:55 +01:00
|
|
|
cuma = b->curve->cm;
|
|
|
|
|
BKE_curvemap_reset(cuma, &cumap->clipr, cumap->preset, CURVEMAP_SLOPE_NEGATIVE);
|
|
|
|
|
BKE_curvemapping_changed(cumap, false);
|
2009-01-07 04:38:30 +00:00
|
|
|
}
|
|
|
|
|
|
2013-03-14 03:47:20 +00:00
|
|
|
/* Generic texture sampler for 3D painting systems. point has to be either in
|
2013-04-27 12:51:23 +00:00
|
|
|
* region space mouse coordinates, or 3d world coordinates for 3D mapping.
|
|
|
|
|
*
|
|
|
|
|
* rgba outputs straight alpha. */
|
2018-11-13 14:21:42 +11:00
|
|
|
float BKE_brush_sample_tex_3d(const Scene *scene,
|
|
|
|
|
const Brush *br,
|
2013-03-13 05:23:53 +00:00
|
|
|
const float point[3],
|
2013-03-14 05:59:34 +00:00
|
|
|
float rgba[4],
|
|
|
|
|
const int thread,
|
2013-03-13 05:23:53 +00:00
|
|
|
struct ImagePool *pool)
|
2013-03-13 03:46:22 +00:00
|
|
|
{
|
|
|
|
|
UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
|
2017-10-03 18:43:18 +11:00
|
|
|
const MTex *mtex = &br->mtex;
|
2013-03-13 03:46:22 +00:00
|
|
|
float intensity = 1.0;
|
|
|
|
|
bool hasrgb = false;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2013-03-13 03:46:22 +00:00
|
|
|
if (!mtex->tex) {
|
|
|
|
|
intensity = 1;
|
|
|
|
|
}
|
|
|
|
|
else if (mtex->brush_map_mode == MTEX_MAP_MODE_3D) {
|
|
|
|
|
/* Get strength by feeding the vertex
|
|
|
|
|
* location directly into a texture */
|
2020-05-01 14:03:12 +10:00
|
|
|
hasrgb = RE_texture_evaluate(mtex, point, thread, pool, false, false, &intensity, rgba);
|
2013-03-13 03:46:22 +00:00
|
|
|
}
|
2013-03-31 00:38:50 +00:00
|
|
|
else if (mtex->brush_map_mode == MTEX_MAP_MODE_STENCIL) {
|
|
|
|
|
float rotation = -mtex->rot;
|
2020-08-07 22:36:11 +10:00
|
|
|
const float point_2d[2] = {point[0], point[1]};
|
2013-07-13 16:25:47 +00:00
|
|
|
float x, y;
|
2013-03-31 00:38:50 +00:00
|
|
|
float co[3];
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2013-03-31 00:38:50 +00:00
|
|
|
x = point_2d[0] - br->stencil_pos[0];
|
|
|
|
|
y = point_2d[1] - br->stencil_pos[1];
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2013-03-31 00:38:50 +00:00
|
|
|
if (rotation > 0.001f || rotation < -0.001f) {
|
|
|
|
|
const float angle = atan2f(y, x) + rotation;
|
|
|
|
|
const float flen = sqrtf(x * x + y * y);
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2013-03-31 00:38:50 +00:00
|
|
|
x = flen * cosf(angle);
|
|
|
|
|
y = flen * sinf(angle);
|
|
|
|
|
}
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2013-04-05 15:45:10 +00:00
|
|
|
if (fabsf(x) > br->stencil_dimension[0] || fabsf(y) > br->stencil_dimension[1]) {
|
|
|
|
|
zero_v4(rgba);
|
|
|
|
|
return 0.0f;
|
2013-03-31 00:38:50 +00:00
|
|
|
}
|
|
|
|
|
x /= (br->stencil_dimension[0]);
|
|
|
|
|
y /= (br->stencil_dimension[1]);
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2014-03-02 19:40:39 +02:00
|
|
|
co[0] = x;
|
|
|
|
|
co[1] = y;
|
2013-03-31 00:38:50 +00:00
|
|
|
co[2] = 0.0f;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2020-05-01 14:03:12 +10:00
|
|
|
hasrgb = RE_texture_evaluate(mtex, co, thread, pool, false, false, &intensity, rgba);
|
2013-03-31 00:38:50 +00:00
|
|
|
}
|
2013-03-13 03:46:22 +00:00
|
|
|
else {
|
|
|
|
|
float rotation = -mtex->rot;
|
2020-08-07 22:36:11 +10:00
|
|
|
const float point_2d[2] = {point[0], point[1]};
|
2013-03-13 03:46:22 +00:00
|
|
|
float x = 0.0f, y = 0.0f; /* Quite warnings */
|
2013-03-31 00:38:50 +00:00
|
|
|
float invradius = 1.0f; /* Quite warnings */
|
2013-03-13 14:19:55 +00:00
|
|
|
float co[3];
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2013-03-26 22:45:06 +00:00
|
|
|
if (mtex->brush_map_mode == MTEX_MAP_MODE_VIEW) {
|
2013-03-13 03:46:22 +00:00
|
|
|
/* keep coordinates relative to mouse */
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2013-03-13 03:46:22 +00:00
|
|
|
rotation += ups->brush_rotation;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2013-03-26 21:34:39 +00:00
|
|
|
x = point_2d[0] - ups->tex_mouse[0];
|
|
|
|
|
y = point_2d[1] - ups->tex_mouse[1];
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2013-03-13 03:46:22 +00:00
|
|
|
/* use pressure adjusted size for fixed mode */
|
2013-03-31 03:28:46 +00:00
|
|
|
invradius = 1.0f / ups->pixel_radius;
|
2013-03-13 03:46:22 +00:00
|
|
|
}
|
|
|
|
|
else if (mtex->brush_map_mode == MTEX_MAP_MODE_TILED) {
|
|
|
|
|
/* leave the coordinates relative to the screen */
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2013-03-13 03:46:22 +00:00
|
|
|
/* use unadjusted size for tiled mode */
|
2013-03-31 03:28:46 +00:00
|
|
|
invradius = 1.0f / BKE_brush_size_get(scene, br);
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2013-03-13 03:46:22 +00:00
|
|
|
x = point_2d[0];
|
|
|
|
|
y = point_2d[1];
|
2013-03-26 22:45:06 +00:00
|
|
|
}
|
|
|
|
|
else if (mtex->brush_map_mode == MTEX_MAP_MODE_RANDOM) {
|
2013-03-26 21:34:39 +00:00
|
|
|
rotation += ups->brush_rotation;
|
|
|
|
|
/* these contain a random coordinate */
|
|
|
|
|
x = point_2d[0] - ups->tex_mouse[0];
|
|
|
|
|
y = point_2d[1] - ups->tex_mouse[1];
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2013-03-31 03:28:46 +00:00
|
|
|
invradius = 1.0f / ups->pixel_radius;
|
2013-03-13 03:46:22 +00:00
|
|
|
}
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2013-03-31 00:38:50 +00:00
|
|
|
x *= invradius;
|
|
|
|
|
y *= invradius;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2013-03-13 03:46:22 +00:00
|
|
|
/* it is probably worth optimizing for those cases where
|
|
|
|
|
* the texture is not rotated by skipping the calls to
|
|
|
|
|
* atan2, sqrtf, sin, and cos. */
|
|
|
|
|
if (rotation > 0.001f || rotation < -0.001f) {
|
|
|
|
|
const float angle = atan2f(y, x) + rotation;
|
|
|
|
|
const float flen = sqrtf(x * x + y * y);
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2013-03-13 03:46:22 +00:00
|
|
|
x = flen * cosf(angle);
|
|
|
|
|
y = flen * sinf(angle);
|
|
|
|
|
}
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2014-03-02 19:40:39 +02:00
|
|
|
co[0] = x;
|
|
|
|
|
co[1] = y;
|
2013-03-13 03:46:22 +00:00
|
|
|
co[2] = 0.0f;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2020-05-01 14:03:12 +10:00
|
|
|
hasrgb = RE_texture_evaluate(mtex, co, thread, pool, false, false, &intensity, rgba);
|
2013-03-13 03:46:22 +00:00
|
|
|
}
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2013-03-13 03:46:22 +00:00
|
|
|
intensity += br->texture_sample_bias;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2013-03-13 03:46:22 +00:00
|
|
|
if (!hasrgb) {
|
|
|
|
|
rgba[0] = intensity;
|
|
|
|
|
rgba[1] = intensity;
|
|
|
|
|
rgba[2] = intensity;
|
|
|
|
|
rgba[3] = 1.0f;
|
|
|
|
|
}
|
2014-04-13 19:03:14 +03:00
|
|
|
/* For consistency, sampling always returns color in linear space */
|
|
|
|
|
else if (ups->do_linear_conversion) {
|
|
|
|
|
IMB_colormanagement_colorspace_to_scene_linear_v3(rgba, ups->colorspace);
|
2013-12-03 22:13:15 +06:00
|
|
|
}
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2013-03-13 03:46:22 +00:00
|
|
|
return intensity;
|
|
|
|
|
}
|
|
|
|
|
|
2013-03-25 02:41:30 +00:00
|
|
|
float BKE_brush_sample_masktex(
|
|
|
|
|
const Scene *scene, Brush *br, const float point[2], const int thread, struct ImagePool *pool)
|
|
|
|
|
{
|
2013-03-25 01:00:16 +00:00
|
|
|
UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
|
|
|
|
|
MTex *mtex = &br->mask_mtex;
|
2013-04-22 10:46:01 +00:00
|
|
|
float rgba[4], intensity;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2013-04-22 10:46:01 +00:00
|
|
|
if (!mtex->tex) {
|
|
|
|
|
return 1.0f;
|
|
|
|
|
}
|
|
|
|
|
if (mtex->brush_map_mode == MTEX_MAP_MODE_STENCIL) {
|
2013-03-25 01:00:16 +00:00
|
|
|
float rotation = -mtex->rot;
|
2020-08-07 22:36:11 +10:00
|
|
|
const float point_2d[2] = {point[0], point[1]};
|
2013-07-13 16:25:47 +00:00
|
|
|
float x, y;
|
2013-03-25 01:00:16 +00:00
|
|
|
float co[3];
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2013-04-23 00:06:22 +00:00
|
|
|
x = point_2d[0] - br->mask_stencil_pos[0];
|
|
|
|
|
y = point_2d[1] - br->mask_stencil_pos[1];
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2013-04-22 10:46:01 +00:00
|
|
|
if (rotation > 0.001f || rotation < -0.001f) {
|
|
|
|
|
const float angle = atan2f(y, x) + rotation;
|
|
|
|
|
const float flen = sqrtf(x * x + y * y);
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2013-04-22 10:46:01 +00:00
|
|
|
x = flen * cosf(angle);
|
|
|
|
|
y = flen * sinf(angle);
|
|
|
|
|
}
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2013-04-23 00:06:22 +00:00
|
|
|
if (fabsf(x) > br->mask_stencil_dimension[0] || fabsf(y) > br->mask_stencil_dimension[1]) {
|
2013-04-22 10:46:01 +00:00
|
|
|
zero_v4(rgba);
|
|
|
|
|
return 0.0f;
|
|
|
|
|
}
|
2013-04-23 00:06:22 +00:00
|
|
|
x /= (br->mask_stencil_dimension[0]);
|
|
|
|
|
y /= (br->mask_stencil_dimension[1]);
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2014-03-04 20:35:39 +02:00
|
|
|
co[0] = x;
|
|
|
|
|
co[1] = y;
|
2013-04-22 10:46:01 +00:00
|
|
|
co[2] = 0.0f;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2020-05-01 14:03:12 +10:00
|
|
|
RE_texture_evaluate(mtex, co, thread, pool, false, false, &intensity, rgba);
|
2013-04-22 10:46:01 +00:00
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
float rotation = -mtex->rot;
|
2020-08-07 22:36:11 +10:00
|
|
|
const float point_2d[2] = {point[0], point[1]};
|
2013-04-22 10:46:01 +00:00
|
|
|
float x = 0.0f, y = 0.0f; /* Quite warnings */
|
|
|
|
|
float invradius = 1.0f; /* Quite warnings */
|
|
|
|
|
float co[3];
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2013-04-22 10:46:01 +00:00
|
|
|
if (mtex->brush_map_mode == MTEX_MAP_MODE_VIEW) {
|
|
|
|
|
/* keep coordinates relative to mouse */
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2014-12-26 23:51:27 +01:00
|
|
|
rotation += ups->brush_rotation_sec;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2013-04-22 10:46:01 +00:00
|
|
|
x = point_2d[0] - ups->mask_tex_mouse[0];
|
|
|
|
|
y = point_2d[1] - ups->mask_tex_mouse[1];
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2013-04-22 10:46:01 +00:00
|
|
|
/* use pressure adjusted size for fixed mode */
|
|
|
|
|
invradius = 1.0f / ups->pixel_radius;
|
|
|
|
|
}
|
|
|
|
|
else if (mtex->brush_map_mode == MTEX_MAP_MODE_TILED) {
|
|
|
|
|
/* leave the coordinates relative to the screen */
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2013-04-22 10:46:01 +00:00
|
|
|
/* use unadjusted size for tiled mode */
|
|
|
|
|
invradius = 1.0f / BKE_brush_size_get(scene, br);
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2013-04-22 10:46:01 +00:00
|
|
|
x = point_2d[0];
|
|
|
|
|
y = point_2d[1];
|
|
|
|
|
}
|
|
|
|
|
else if (mtex->brush_map_mode == MTEX_MAP_MODE_RANDOM) {
|
2014-12-26 23:51:27 +01:00
|
|
|
rotation += ups->brush_rotation_sec;
|
2013-04-22 10:46:01 +00:00
|
|
|
/* these contain a random coordinate */
|
|
|
|
|
x = point_2d[0] - ups->mask_tex_mouse[0];
|
|
|
|
|
y = point_2d[1] - ups->mask_tex_mouse[1];
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2013-04-22 10:46:01 +00:00
|
|
|
invradius = 1.0f / ups->pixel_radius;
|
|
|
|
|
}
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2013-04-22 10:46:01 +00:00
|
|
|
x *= invradius;
|
|
|
|
|
y *= invradius;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2013-03-25 01:00:16 +00:00
|
|
|
/* it is probably worth optimizing for those cases where
|
|
|
|
|
* the texture is not rotated by skipping the calls to
|
|
|
|
|
* atan2, sqrtf, sin, and cos. */
|
|
|
|
|
if (rotation > 0.001f || rotation < -0.001f) {
|
|
|
|
|
const float angle = atan2f(y, x) + rotation;
|
|
|
|
|
const float flen = sqrtf(x * x + y * y);
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2013-03-25 01:00:16 +00:00
|
|
|
x = flen * cosf(angle);
|
|
|
|
|
y = flen * sinf(angle);
|
|
|
|
|
}
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2014-03-04 20:35:39 +02:00
|
|
|
co[0] = x;
|
|
|
|
|
co[1] = y;
|
2013-03-25 01:00:16 +00:00
|
|
|
co[2] = 0.0f;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2020-05-01 14:03:12 +10:00
|
|
|
RE_texture_evaluate(mtex, co, thread, pool, false, false, &intensity, rgba);
|
2013-03-25 01:00:16 +00:00
|
|
|
}
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2014-07-21 12:02:05 +02:00
|
|
|
CLAMP(intensity, 0.0f, 1.0f);
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2014-07-21 12:02:05 +02:00
|
|
|
switch (br->mask_pressure) {
|
|
|
|
|
case BRUSH_MASK_PRESSURE_CUTOFF:
|
|
|
|
|
intensity = ((1.0f - intensity) < ups->size_pressure_value) ? 1.0f : 0.0f;
|
|
|
|
|
break;
|
|
|
|
|
case BRUSH_MASK_PRESSURE_RAMP:
|
|
|
|
|
intensity = ups->size_pressure_value + intensity * (1.0f - ups->size_pressure_value);
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
break;
|
|
|
|
|
}
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2013-04-22 10:46:01 +00:00
|
|
|
return intensity;
|
2013-03-25 01:00:16 +00:00
|
|
|
}
|
2013-03-13 03:46:22 +00:00
|
|
|
|
2014-07-21 12:02:05 +02:00
|
|
|
/* Unified Size / Strength / Color */
|
2012-01-14 23:54:51 +00:00
|
|
|
|
2012-10-20 20:20:02 +00:00
|
|
|
/* XXX: be careful about setting size and unprojected radius
|
|
|
|
|
* because they depend on one another
|
|
|
|
|
* these functions do not set the other corresponding value
|
|
|
|
|
* this can lead to odd behavior if size and unprojected
|
|
|
|
|
* radius become inconsistent.
|
|
|
|
|
* the biggest problem is that it isn't possible to change
|
|
|
|
|
* unprojected radius because a view context is not
|
2013-10-31 14:10:01 +00:00
|
|
|
* available. my usual solution to this is to use the
|
2012-10-20 20:20:02 +00:00
|
|
|
* ratio of change of the size to change the unprojected
|
|
|
|
|
* radius. Not completely convinced that is correct.
|
2013-02-06 14:02:19 +00:00
|
|
|
* In any case, a better solution is needed to prevent
|
2012-10-20 20:20:02 +00:00
|
|
|
* inconsistency. */
|
2012-01-14 23:54:51 +00:00
|
|
|
|
2015-04-17 03:10:57 +10:00
|
|
|
const float *BKE_brush_color_get(const struct Scene *scene, const struct Brush *brush)
|
2014-07-21 12:02:05 +02:00
|
|
|
{
|
|
|
|
|
UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
|
|
|
|
|
return (ups->flag & UNIFIED_PAINT_COLOR) ? ups->rgb : brush->rgb;
|
|
|
|
|
}
|
|
|
|
|
|
2015-04-17 03:10:57 +10:00
|
|
|
const float *BKE_brush_secondary_color_get(const struct Scene *scene, const struct Brush *brush)
|
2014-07-21 12:02:05 +02:00
|
|
|
{
|
|
|
|
|
UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
|
|
|
|
|
return (ups->flag & UNIFIED_PAINT_COLOR) ? ups->secondary_rgb : brush->secondary_rgb;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void BKE_brush_color_set(struct Scene *scene, struct Brush *brush, const float color[3])
|
|
|
|
|
{
|
|
|
|
|
UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
|
|
|
|
|
|
2019-04-22 09:39:35 +10:00
|
|
|
if (ups->flag & UNIFIED_PAINT_COLOR) {
|
2014-07-21 12:02:05 +02:00
|
|
|
copy_v3_v3(ups->rgb, color);
|
2019-04-22 09:39:35 +10:00
|
|
|
}
|
|
|
|
|
else {
|
2014-07-21 12:02:05 +02:00
|
|
|
copy_v3_v3(brush->rgb, color);
|
2019-04-22 09:39:35 +10:00
|
|
|
}
|
2014-07-21 12:02:05 +02:00
|
|
|
}
|
|
|
|
|
|
2012-05-05 00:58:22 +00:00
|
|
|
void BKE_brush_size_set(Scene *scene, Brush *brush, int size)
|
2012-01-14 23:54:51 +00:00
|
|
|
{
|
|
|
|
|
UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
|
2016-07-08 14:51:12 +10:00
|
|
|
|
2015-02-05 19:11:00 +01:00
|
|
|
/* make sure range is sane */
|
|
|
|
|
CLAMP(size, 1, MAX_BRUSH_PIXEL_RADIUS);
|
|
|
|
|
|
2019-04-22 09:39:35 +10:00
|
|
|
if (ups->flag & UNIFIED_PAINT_SIZE) {
|
2012-05-06 15:15:33 +00:00
|
|
|
ups->size = size;
|
2019-04-22 09:39:35 +10:00
|
|
|
}
|
|
|
|
|
else {
|
2012-05-06 15:15:33 +00:00
|
|
|
brush->size = size;
|
2019-04-22 09:39:35 +10:00
|
|
|
}
|
2012-01-14 23:54:51 +00:00
|
|
|
}
|
|
|
|
|
|
2015-04-17 03:10:57 +10:00
|
|
|
int BKE_brush_size_get(const Scene *scene, const Brush *brush)
|
2012-01-14 23:54:51 +00:00
|
|
|
{
|
|
|
|
|
UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
|
2012-12-14 15:09:59 +00:00
|
|
|
int size = (ups->flag & UNIFIED_PAINT_SIZE) ? ups->size : brush->size;
|
2018-06-17 17:05:51 +02:00
|
|
|
|
2016-06-03 01:07:29 +10:00
|
|
|
return size;
|
2012-01-14 23:54:51 +00:00
|
|
|
}
|
|
|
|
|
|
2017-10-05 12:51:36 +11:00
|
|
|
bool BKE_brush_use_locked_size(const Scene *scene, const Brush *brush)
|
2012-01-14 23:54:51 +00:00
|
|
|
{
|
|
|
|
|
const short us_flag = scene->toolsettings->unified_paint_settings.flag;
|
|
|
|
|
|
2012-05-06 15:15:33 +00:00
|
|
|
return (us_flag & UNIFIED_PAINT_SIZE) ? (us_flag & UNIFIED_PAINT_BRUSH_LOCK_SIZE) :
|
|
|
|
|
(brush->flag & BRUSH_LOCK_SIZE);
|
2012-01-14 23:54:51 +00:00
|
|
|
}
|
|
|
|
|
|
2019-11-27 02:02:18 +01:00
|
|
|
bool BKE_brush_use_size_pressure(const Brush *brush)
|
2012-01-14 23:54:51 +00:00
|
|
|
{
|
2019-11-27 02:02:18 +01:00
|
|
|
return brush->flag & BRUSH_SIZE_PRESSURE;
|
2012-01-14 23:54:51 +00:00
|
|
|
}
|
|
|
|
|
|
2019-11-27 02:02:18 +01:00
|
|
|
bool BKE_brush_use_alpha_pressure(const Brush *brush)
|
2012-01-14 23:54:51 +00:00
|
|
|
{
|
2019-11-27 02:02:18 +01:00
|
|
|
return brush->flag & BRUSH_ALPHA_PRESSURE;
|
2012-01-14 23:54:51 +00:00
|
|
|
}
|
|
|
|
|
|
2017-10-05 12:57:24 +11:00
|
|
|
bool BKE_brush_sculpt_has_secondary_color(const Brush *brush)
|
|
|
|
|
{
|
|
|
|
|
return ELEM(brush->sculpt_tool,
|
|
|
|
|
SCULPT_TOOL_BLOB,
|
|
|
|
|
SCULPT_TOOL_DRAW,
|
2019-09-06 21:55:32 +02:00
|
|
|
SCULPT_TOOL_DRAW_SHARP,
|
2017-10-05 12:57:24 +11:00
|
|
|
SCULPT_TOOL_INFLATE,
|
|
|
|
|
SCULPT_TOOL_CLAY,
|
|
|
|
|
SCULPT_TOOL_CLAY_STRIPS,
|
2020-01-22 02:23:51 +01:00
|
|
|
SCULPT_TOOL_CLAY_THUMB,
|
2017-10-05 12:57:24 +11:00
|
|
|
SCULPT_TOOL_PINCH,
|
|
|
|
|
SCULPT_TOOL_CREASE,
|
|
|
|
|
SCULPT_TOOL_LAYER,
|
|
|
|
|
SCULPT_TOOL_FLATTEN,
|
|
|
|
|
SCULPT_TOOL_FILL,
|
|
|
|
|
SCULPT_TOOL_SCRAPE,
|
|
|
|
|
SCULPT_TOOL_MASK);
|
|
|
|
|
}
|
|
|
|
|
|
2012-05-05 00:58:22 +00:00
|
|
|
void BKE_brush_unprojected_radius_set(Scene *scene, Brush *brush, float unprojected_radius)
|
2012-01-14 23:54:51 +00:00
|
|
|
{
|
|
|
|
|
UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
|
|
|
|
|
|
2019-04-22 09:39:35 +10:00
|
|
|
if (ups->flag & UNIFIED_PAINT_SIZE) {
|
2012-05-06 15:15:33 +00:00
|
|
|
ups->unprojected_radius = unprojected_radius;
|
2019-04-22 09:39:35 +10:00
|
|
|
}
|
|
|
|
|
else {
|
2012-05-06 15:15:33 +00:00
|
|
|
brush->unprojected_radius = unprojected_radius;
|
2019-04-22 09:39:35 +10:00
|
|
|
}
|
2012-01-14 23:54:51 +00:00
|
|
|
}
|
|
|
|
|
|
2015-04-17 03:10:57 +10:00
|
|
|
float BKE_brush_unprojected_radius_get(const Scene *scene, const Brush *brush)
|
2012-01-14 23:54:51 +00:00
|
|
|
{
|
|
|
|
|
UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
|
|
|
|
|
|
|
|
|
|
return (ups->flag & UNIFIED_PAINT_SIZE) ? ups->unprojected_radius : brush->unprojected_radius;
|
|
|
|
|
}
|
|
|
|
|
|
2013-01-01 21:23:12 +00:00
|
|
|
void BKE_brush_alpha_set(Scene *scene, Brush *brush, float alpha)
|
2012-01-14 23:54:51 +00:00
|
|
|
{
|
|
|
|
|
UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
|
|
|
|
|
|
2019-04-22 09:39:35 +10:00
|
|
|
if (ups->flag & UNIFIED_PAINT_ALPHA) {
|
2012-05-06 15:15:33 +00:00
|
|
|
ups->alpha = alpha;
|
2019-04-22 09:39:35 +10:00
|
|
|
}
|
|
|
|
|
else {
|
2012-05-06 15:15:33 +00:00
|
|
|
brush->alpha = alpha;
|
2019-04-22 09:39:35 +10:00
|
|
|
}
|
2012-01-14 23:54:51 +00:00
|
|
|
}
|
|
|
|
|
|
2015-04-17 03:10:57 +10:00
|
|
|
float BKE_brush_alpha_get(const Scene *scene, const Brush *brush)
|
2012-01-14 23:54:51 +00:00
|
|
|
{
|
|
|
|
|
UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
|
|
|
|
|
|
|
|
|
|
return (ups->flag & UNIFIED_PAINT_ALPHA) ? ups->alpha : brush->alpha;
|
|
|
|
|
}
|
|
|
|
|
|
2015-04-17 03:10:57 +10:00
|
|
|
float BKE_brush_weight_get(const Scene *scene, const Brush *brush)
|
2012-04-29 20:04:25 +00:00
|
|
|
{
|
|
|
|
|
UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
|
|
|
|
|
|
|
|
|
|
return (ups->flag & UNIFIED_PAINT_WEIGHT) ? ups->weight : brush->weight;
|
|
|
|
|
}
|
|
|
|
|
|
2012-05-05 00:58:22 +00:00
|
|
|
void BKE_brush_weight_set(const Scene *scene, Brush *brush, float value)
|
2012-05-02 16:05:25 +00:00
|
|
|
{
|
|
|
|
|
UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
|
|
|
|
|
|
2019-04-22 09:39:35 +10:00
|
|
|
if (ups->flag & UNIFIED_PAINT_WEIGHT) {
|
2012-05-02 16:05:25 +00:00
|
|
|
ups->weight = value;
|
2019-04-22 09:39:35 +10:00
|
|
|
}
|
|
|
|
|
else {
|
2012-05-02 16:05:25 +00:00
|
|
|
brush->weight = value;
|
2019-04-22 09:39:35 +10:00
|
|
|
}
|
2012-05-02 16:05:25 +00:00
|
|
|
}
|
|
|
|
|
|
2012-01-14 23:54:51 +00:00
|
|
|
/* scale unprojected radius to reflect a change in the brush's 2D size */
|
2012-05-05 00:58:22 +00:00
|
|
|
void BKE_brush_scale_unprojected_radius(float *unprojected_radius,
|
|
|
|
|
int new_brush_size,
|
|
|
|
|
int old_brush_size)
|
2012-01-14 23:54:51 +00:00
|
|
|
{
|
|
|
|
|
float scale = new_brush_size;
|
|
|
|
|
/* avoid division by zero */
|
2019-04-22 09:39:35 +10:00
|
|
|
if (old_brush_size != 0) {
|
2012-01-14 23:54:51 +00:00
|
|
|
scale /= (float)old_brush_size;
|
2019-04-22 09:39:35 +10:00
|
|
|
}
|
2012-01-14 23:54:51 +00:00
|
|
|
(*unprojected_radius) *= scale;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* scale brush size to reflect a change in the brush's unprojected radius */
|
2015-04-17 03:10:57 +10:00
|
|
|
void BKE_brush_scale_size(int *r_brush_size,
|
|
|
|
|
float new_unprojected_radius,
|
|
|
|
|
float old_unprojected_radius)
|
2012-01-14 23:54:51 +00:00
|
|
|
{
|
|
|
|
|
float scale = new_unprojected_radius;
|
|
|
|
|
/* avoid division by zero */
|
2019-04-22 09:39:35 +10:00
|
|
|
if (old_unprojected_radius != 0) {
|
2012-01-14 23:54:51 +00:00
|
|
|
scale /= new_unprojected_radius;
|
2019-04-22 09:39:35 +10:00
|
|
|
}
|
2012-10-12 14:35:10 +00:00
|
|
|
(*r_brush_size) = (int)((float)(*r_brush_size) * scale);
|
2012-01-14 23:54:51 +00:00
|
|
|
}
|
|
|
|
|
|
2012-05-05 00:58:22 +00:00
|
|
|
void BKE_brush_jitter_pos(const Scene *scene, Brush *brush, const float pos[2], float jitterpos[2])
|
2009-09-18 11:25:52 +00:00
|
|
|
{
|
2014-09-01 21:10:17 +02:00
|
|
|
float rand_pos[2];
|
|
|
|
|
float spread;
|
|
|
|
|
int diameter;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2014-09-01 21:10:17 +02:00
|
|
|
do {
|
|
|
|
|
rand_pos[0] = BLI_rng_get_float(brush_rng) - 0.5f;
|
|
|
|
|
rand_pos[1] = BLI_rng_get_float(brush_rng) - 0.5f;
|
2020-03-06 17:18:10 +01:00
|
|
|
} while (len_squared_v2(rand_pos) > square_f(0.5f));
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2014-09-01 21:10:17 +02:00
|
|
|
if (brush->flag & BRUSH_ABSOLUTE_JITTER) {
|
|
|
|
|
diameter = 2 * brush->jitter_absolute;
|
|
|
|
|
spread = 1.0;
|
2009-09-18 11:25:52 +00:00
|
|
|
}
|
|
|
|
|
else {
|
2014-09-01 21:10:17 +02:00
|
|
|
diameter = 2 * BKE_brush_size_get(scene, brush);
|
|
|
|
|
spread = brush->jitter;
|
2009-09-18 11:25:52 +00:00
|
|
|
}
|
2014-09-01 21:10:17 +02:00
|
|
|
/* find random position within a circle of diameter 1 */
|
|
|
|
|
jitterpos[0] = pos[0] + 2 * rand_pos[0] * diameter * spread;
|
|
|
|
|
jitterpos[1] = pos[1] + 2 * rand_pos[1] * diameter * spread;
|
2009-09-18 11:25:52 +00:00
|
|
|
}
|
|
|
|
|
|
2015-01-04 14:20:31 +11:00
|
|
|
void BKE_brush_randomize_texture_coords(UnifiedPaintSettings *ups, bool mask)
|
2013-03-26 22:45:06 +00:00
|
|
|
{
|
2013-03-26 21:34:39 +00:00
|
|
|
/* we multiply with brush radius as an optimization for the brush
|
|
|
|
|
* texture sampling functions */
|
2013-04-22 10:46:01 +00:00
|
|
|
if (mask) {
|
|
|
|
|
ups->mask_tex_mouse[0] = BLI_rng_get_float(brush_rng) * ups->pixel_radius;
|
|
|
|
|
ups->mask_tex_mouse[1] = BLI_rng_get_float(brush_rng) * ups->pixel_radius;
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
ups->tex_mouse[0] = BLI_rng_get_float(brush_rng) * ups->pixel_radius;
|
|
|
|
|
ups->tex_mouse[1] = BLI_rng_get_float(brush_rng) * ups->pixel_radius;
|
|
|
|
|
}
|
2013-03-26 21:34:39 +00:00
|
|
|
}
|
|
|
|
|
|
2015-06-10 13:32:11 +02:00
|
|
|
/* Uses the brush curve control to find a strength value */
|
2017-10-02 21:07:25 +11:00
|
|
|
float BKE_brush_curve_strength(const Brush *br, float p, const float len)
|
2009-09-24 01:32:23 +00:00
|
|
|
{
|
2019-07-31 12:58:50 +02:00
|
|
|
float strength = 1.0f;
|
2013-05-01 19:50:37 +00:00
|
|
|
|
2019-04-22 09:39:35 +10:00
|
|
|
if (p >= len) {
|
2012-05-06 15:15:33 +00:00
|
|
|
return 0;
|
2019-04-22 09:39:35 +10:00
|
|
|
}
|
2020-07-03 18:04:40 +02:00
|
|
|
|
|
|
|
|
p = p / len;
|
|
|
|
|
p = 1.0f - p;
|
2009-09-24 01:32:23 +00:00
|
|
|
|
2019-07-31 12:58:50 +02:00
|
|
|
switch (br->curve_preset) {
|
|
|
|
|
case BRUSH_CURVE_CUSTOM:
|
2019-08-07 03:21:55 +10:00
|
|
|
strength = BKE_curvemapping_evaluateF(br->curve, 0, 1.0f - p);
|
2019-07-31 12:58:50 +02:00
|
|
|
break;
|
|
|
|
|
case BRUSH_CURVE_SHARP:
|
|
|
|
|
strength = p * p;
|
|
|
|
|
break;
|
|
|
|
|
case BRUSH_CURVE_SMOOTH:
|
|
|
|
|
strength = 3.0f * p * p - 2.0f * p * p * p;
|
|
|
|
|
break;
|
2019-11-22 18:21:03 +01:00
|
|
|
case BRUSH_CURVE_SMOOTHER:
|
|
|
|
|
strength = pow3f(p) * (p * (p * 6.0f - 15.0f) + 10.0f);
|
|
|
|
|
break;
|
2019-07-31 12:58:50 +02:00
|
|
|
case BRUSH_CURVE_ROOT:
|
|
|
|
|
strength = sqrtf(p);
|
|
|
|
|
break;
|
|
|
|
|
case BRUSH_CURVE_LIN:
|
|
|
|
|
strength = p;
|
|
|
|
|
break;
|
|
|
|
|
case BRUSH_CURVE_CONSTANT:
|
|
|
|
|
strength = 1.0f;
|
|
|
|
|
break;
|
|
|
|
|
case BRUSH_CURVE_SPHERE:
|
|
|
|
|
strength = sqrtf(2 * p - p * p);
|
|
|
|
|
break;
|
|
|
|
|
case BRUSH_CURVE_POW4:
|
|
|
|
|
strength = p * p * p * p;
|
|
|
|
|
break;
|
|
|
|
|
case BRUSH_CURVE_INVSQUARE:
|
|
|
|
|
strength = p * (2.0f - p);
|
|
|
|
|
break;
|
|
|
|
|
}
|
2013-05-01 19:50:37 +00:00
|
|
|
|
2015-06-10 13:32:11 +02:00
|
|
|
return strength;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Uses the brush curve control to find a strength value between 0 and 1 */
|
|
|
|
|
float BKE_brush_curve_strength_clamped(Brush *br, float p, const float len)
|
|
|
|
|
{
|
|
|
|
|
float strength = BKE_brush_curve_strength(br, p, len);
|
|
|
|
|
|
2013-05-01 19:50:37 +00:00
|
|
|
CLAMP(strength, 0.0f, 1.0f);
|
2012-08-21 14:43:51 +00:00
|
|
|
|
2013-05-01 19:50:37 +00:00
|
|
|
return strength;
|
2009-09-24 01:32:23 +00:00
|
|
|
}
|
2009-01-25 07:28:11 +00:00
|
|
|
|
2013-03-07 12:11:38 +00:00
|
|
|
/* TODO: should probably be unified with BrushPainter stuff? */
|
2013-09-05 14:02:59 +00:00
|
|
|
unsigned int *BKE_brush_gen_texture_cache(Brush *br, int half_side, bool use_secondary)
|
2013-03-07 12:11:38 +00:00
|
|
|
{
|
|
|
|
|
unsigned int *texcache = NULL;
|
2013-09-05 14:02:59 +00:00
|
|
|
MTex *mtex = (use_secondary) ? &br->mask_mtex : &br->mtex;
|
2014-03-02 19:40:39 +02:00
|
|
|
float intensity;
|
2020-05-01 14:58:58 +10:00
|
|
|
float rgba_dummy[4];
|
2014-03-02 19:40:39 +02:00
|
|
|
int ix, iy;
|
2013-03-07 12:11:38 +00:00
|
|
|
int side = half_side * 2;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2013-03-07 12:11:38 +00:00
|
|
|
if (mtex->tex) {
|
|
|
|
|
float x, y, step = 2.0 / side, co[3];
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2013-03-07 12:11:38 +00:00
|
|
|
texcache = MEM_callocN(sizeof(int) * side * side, "Brush texture cache");
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2018-09-24 17:27:41 +02:00
|
|
|
/* do normalized canonical view coords for texture */
|
2013-03-07 12:11:38 +00:00
|
|
|
for (y = -1.0, iy = 0; iy < side; iy++, y += step) {
|
|
|
|
|
for (x = -1.0, ix = 0; ix < side; ix++, x += step) {
|
|
|
|
|
co[0] = x;
|
|
|
|
|
co[1] = y;
|
|
|
|
|
co[2] = 0.0f;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2013-03-07 12:11:38 +00:00
|
|
|
/* This is copied from displace modifier code */
|
2018-09-24 17:27:41 +02:00
|
|
|
/* TODO(sergey): brush are always caching with CM enabled for now. */
|
2020-05-01 14:58:58 +10:00
|
|
|
RE_texture_evaluate(mtex, co, 0, NULL, false, false, &intensity, rgba_dummy);
|
|
|
|
|
copy_v4_uchar((uchar *)&texcache[iy * side + ix], (char)(intensity * 255.0f));
|
2013-03-07 12:11:38 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2013-03-07 12:11:38 +00:00
|
|
|
return texcache;
|
|
|
|
|
}
|
|
|
|
|
|
2009-01-25 07:28:11 +00:00
|
|
|
/**** Radial Control ****/
|
2019-09-26 17:51:21 +02:00
|
|
|
struct ImBuf *BKE_brush_gen_radial_control_imbuf(Brush *br, bool secondary, bool display_gradient)
|
2009-01-25 07:28:11 +00:00
|
|
|
{
|
|
|
|
|
ImBuf *im = MEM_callocN(sizeof(ImBuf), "radial control texture");
|
|
|
|
|
unsigned int *texcache;
|
2019-09-26 17:51:21 +02:00
|
|
|
int side = 512;
|
2009-01-25 07:28:11 +00:00
|
|
|
int half = side / 2;
|
|
|
|
|
int i, j;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2020-08-01 13:02:21 +10:00
|
|
|
BKE_curvemapping_init(br->curve);
|
2013-09-05 14:02:59 +00:00
|
|
|
texcache = BKE_brush_gen_texture_cache(br, half, secondary);
|
2009-01-25 07:28:11 +00:00
|
|
|
im->rect_float = MEM_callocN(sizeof(float) * side * side, "radial control rect");
|
|
|
|
|
im->x = im->y = side;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2019-09-26 17:51:21 +02:00
|
|
|
if (display_gradient || texcache) {
|
|
|
|
|
for (i = 0; i < side; i++) {
|
|
|
|
|
for (j = 0; j < side; j++) {
|
|
|
|
|
float magn = sqrtf(pow2f(i - half) + pow2f(j - half));
|
|
|
|
|
im->rect_float[i * side + j] = BKE_brush_curve_strength_clamped(br, magn, half);
|
|
|
|
|
}
|
2009-01-25 07:28:11 +00:00
|
|
|
}
|
|
|
|
|
}
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2012-03-24 06:18:31 +00:00
|
|
|
if (texcache) {
|
2019-09-26 17:51:21 +02:00
|
|
|
/* Modulate curve with texture */
|
2019-09-08 00:12:26 +10:00
|
|
|
for (i = 0; i < side; i++) {
|
|
|
|
|
for (j = 0; j < side; j++) {
|
2012-05-06 15:15:33 +00:00
|
|
|
const int col = texcache[i * side + j];
|
2018-01-10 19:57:02 +11:00
|
|
|
im->rect_float[i * side + j] *= (((char *)&col)[0] + ((char *)&col)[1] +
|
|
|
|
|
((char *)&col)[2]) /
|
|
|
|
|
3.0f / 255.0f;
|
2009-01-25 07:28:11 +00:00
|
|
|
}
|
2009-01-29 03:50:46 +00:00
|
|
|
}
|
|
|
|
|
MEM_freeN(texcache);
|
|
|
|
|
}
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2009-01-25 07:28:11 +00:00
|
|
|
return im;
|
|
|
|
|
}
|