2022-02-10 23:07:11 +01:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
* Copyright 2009 by Nicholas Bishop. All rights reserved. */
|
2009-08-15 21:48:50 +02:00
|
|
|
|
2012-02-17 19:59:41 +01:00
|
|
|
#pragma once
|
2009-08-15 21:48:50 +02:00
|
|
|
|
2019-02-17 22:08:12 +01:00
|
|
|
/** \file
|
|
|
|
* \ingroup bke
|
2011-02-18 14:05:18 +01:00
|
|
|
*/
|
|
|
|
|
Fix T78747: Fix mesh boundary detection and automasking
This issue was produced by a hack in the sculpt mode code from 2.80
when the sculpt API for connectivity info was not available.
The smooth brush was the only brush that needed connectivity info,
so there were 3 different smooth functions with the connectivity
queries implemented for dyntopo, meshes and grids. The mesh version
of smoothing was checking the number of connected faces to a vertex
to mask the mesh boundaries, which was not covering all cases and
was hardcoded in the smooth function itself.
This patch removes all those legacy functions and unifies all
smooth functions into a single one using the new API and the
automasking system. In order to achieve this, there were needed
some extra changes:
- The smooth brush now does not automasks the boundaries by default,
so its default preset needs to be updated to enable automasking
- The mesh boundary info is extracted once and cached in a
bitmap, similar to the disconnected elements IDs. This makes
boundary detection work as expected in all cases, solving a lot
of known issues with the smooth brush. In multires, this info is
extracted and cached only at the base mesh level, so it is much
more memory efficient than the previous automasking system.
- In order to keep the brushes responsive as they were before,
the automasking system can now skip creating the cache when it
is not needed for the requested options. This means that for
high poly meshes and simple automasking options the brushes
won't lag on start.
Reviewed By: sergey
Maniphest Tasks: T78747
Differential Revision: https://developer.blender.org/D8260
2020-07-15 16:24:03 +02:00
|
|
|
#include "BLI_bitmap.h"
|
2022-09-16 21:20:28 +02:00
|
|
|
#include "BLI_compiler_compat.h"
|
2020-05-08 18:16:39 +02:00
|
|
|
#include "BLI_utildefines.h"
|
2022-09-16 21:20:28 +02:00
|
|
|
|
2020-12-11 11:48:58 +01:00
|
|
|
#include "DNA_brush_enums.h"
|
2020-05-08 18:16:39 +02:00
|
|
|
#include "DNA_object_enums.h"
|
|
|
|
|
2022-04-05 20:42:55 +02:00
|
|
|
#include "BKE_attribute.h"
|
2022-07-30 04:01:32 +02:00
|
|
|
#include "BKE_pbvh.h"
|
2022-04-05 20:42:55 +02:00
|
|
|
|
2020-03-02 15:07:49 +01:00
|
|
|
#ifdef __cplusplus
|
|
|
|
extern "C" {
|
|
|
|
#endif
|
|
|
|
|
2013-01-19 17:10:21 +01:00
|
|
|
struct BMFace;
|
2019-01-28 11:08:24 +01:00
|
|
|
struct BMesh;
|
2020-12-16 06:26:23 +01:00
|
|
|
struct BlendDataReader;
|
|
|
|
struct BlendLibReader;
|
|
|
|
struct BlendWriter;
|
2009-08-16 21:50:00 +02:00
|
|
|
struct Brush;
|
Paint refactoring commit, non-disruptive (in theory :p)
* Fix precision overflow issue with overlay previews,
* Expose alpha mask mapping to UI (still not functional but coming soon).
* More overlay refactoring:
Overlay now does minimal checking for texture refresh.
Instead, we now have invalidation flags to set an aspect of the brush
overlay as invalid. This is necessary because this way we will be able to
separate and preview different brush attributes on the overlays, using
different textures:
These attributes/aspects are:
Primary texture (main texture for sculpt, vertex, imapaint)
Secondary texture (mask/alpha texture for imapaint)
Cursor texture (cursor texture. It involves brush strength and curves)
Modified the relevant RNA property update functions and C update callback
functions to call the relevant cursor invalidation functions instead
of checking every frame for multiple properties.
Properties that affect this are:
Image changes, if image is used by current brush,
Texture slot changes, similarly
Curve changes,
Object mode change invalidates the cursor
Paint tool change invalidates the cursor.
These changes give slightly more invalidation cases than simply
comparing the relevant properties each frame, but these do not occur in
performance critical moments and it's a much more elegant system than
adding more variables to check per frame each time we add something on
the system.
2013-04-12 19:21:31 +02:00
|
|
|
struct CurveMapping;
|
2019-01-28 11:08:24 +01:00
|
|
|
struct Depsgraph;
|
2020-06-24 07:30:54 +02:00
|
|
|
struct EdgeSet;
|
2020-09-30 03:51:13 +02:00
|
|
|
struct EnumPropertyItem;
|
2020-03-09 16:27:24 +01:00
|
|
|
struct GHash;
|
2012-05-10 22:33:55 +02:00
|
|
|
struct GridPaintMask;
|
2022-04-15 16:39:50 +02:00
|
|
|
struct Image;
|
2019-01-28 11:08:24 +01:00
|
|
|
struct ImagePool;
|
2022-04-15 16:39:50 +02:00
|
|
|
struct ImageUser;
|
2020-07-29 17:39:08 +02:00
|
|
|
struct ListBase;
|
2015-07-16 19:36:03 +02:00
|
|
|
struct MLoopTri;
|
2019-01-28 11:08:24 +01:00
|
|
|
struct Main;
|
|
|
|
struct Mesh;
|
|
|
|
struct MeshElemMap;
|
2009-08-15 21:48:50 +02:00
|
|
|
struct Object;
|
2019-01-28 11:08:24 +01:00
|
|
|
struct PBVH;
|
2009-08-16 21:50:00 +02:00
|
|
|
struct Paint;
|
2014-07-21 12:02:05 +02:00
|
|
|
struct PaintCurve;
|
2022-04-13 14:27:19 +02:00
|
|
|
struct PaintModeSettings;
|
2014-07-21 12:02:05 +02:00
|
|
|
struct Palette;
|
|
|
|
struct PaletteColor;
|
2009-08-16 21:50:00 +02:00
|
|
|
struct Scene;
|
2009-08-28 23:47:11 +02:00
|
|
|
struct StrokeCache;
|
2022-09-29 01:22:34 +02:00
|
|
|
struct Sculpt;
|
2023-03-22 21:58:34 +01:00
|
|
|
struct SculptSession;
|
2018-09-14 10:56:54 +02:00
|
|
|
struct SubdivCCG;
|
Paint refactoring commit, non-disruptive (in theory :p)
* Fix precision overflow issue with overlay previews,
* Expose alpha mask mapping to UI (still not functional but coming soon).
* More overlay refactoring:
Overlay now does minimal checking for texture refresh.
Instead, we now have invalidation flags to set an aspect of the brush
overlay as invalid. This is necessary because this way we will be able to
separate and preview different brush attributes on the overlays, using
different textures:
These attributes/aspects are:
Primary texture (main texture for sculpt, vertex, imapaint)
Secondary texture (mask/alpha texture for imapaint)
Cursor texture (cursor texture. It involves brush strength and curves)
Modified the relevant RNA property update functions and C update callback
functions to call the relevant cursor invalidation functions instead
of checking every frame for multiple properties.
Properties that affect this are:
Image changes, if image is used by current brush,
Texture slot changes, similarly
Curve changes,
Object mode change invalidates the cursor
Paint tool change invalidates the cursor.
These changes give slightly more invalidation cases than simply
comparing the relevant properties each frame, but these do not occur in
performance critical moments and it's a much more elegant system than
adding more variables to check per frame each time we add something on
the system.
2013-04-12 19:21:31 +02:00
|
|
|
struct Tex;
|
2018-11-05 05:31:25 +01:00
|
|
|
struct ToolSettings;
|
2019-01-28 11:08:24 +01:00
|
|
|
struct UnifiedPaintSettings;
|
2019-05-31 14:04:16 +02:00
|
|
|
struct View3D;
|
2019-01-28 11:08:24 +01:00
|
|
|
struct ViewLayer;
|
|
|
|
struct bContext;
|
|
|
|
struct bToolRef;
|
2020-03-14 05:22:04 +01:00
|
|
|
struct tPaletteColorHSV;
|
2009-08-16 21:50:00 +02:00
|
|
|
|
2022-08-26 07:06:33 +02:00
|
|
|
extern const uchar PAINT_CURSOR_SCULPT[3];
|
|
|
|
extern const uchar PAINT_CURSOR_VERTEX_PAINT[3];
|
|
|
|
extern const uchar PAINT_CURSOR_WEIGHT_PAINT[3];
|
|
|
|
extern const uchar PAINT_CURSOR_TEXTURE_PAINT[3];
|
2022-10-03 12:22:30 +02:00
|
|
|
extern const uchar PAINT_CURSOR_SCULPT_CURVES[3];
|
2009-08-20 18:00:17 +02:00
|
|
|
|
2017-10-17 04:43:10 +02:00
|
|
|
typedef enum ePaintMode {
|
2018-11-14 01:20:08 +01:00
|
|
|
PAINT_MODE_SCULPT = 0,
|
2018-11-07 01:44:51 +01:00
|
|
|
/** Vertex color. */
|
2018-11-14 01:20:08 +01:00
|
|
|
PAINT_MODE_VERTEX = 1,
|
|
|
|
PAINT_MODE_WEIGHT = 2,
|
2018-11-07 01:44:51 +01:00
|
|
|
/** 3D view (projection painting). */
|
2018-11-14 01:20:08 +01:00
|
|
|
PAINT_MODE_TEXTURE_3D = 3,
|
2018-11-07 01:44:51 +01:00
|
|
|
/** Image space (2D painting). */
|
2018-11-14 01:20:08 +01:00
|
|
|
PAINT_MODE_TEXTURE_2D = 4,
|
|
|
|
PAINT_MODE_SCULPT_UV = 5,
|
2018-11-14 01:24:37 +01:00
|
|
|
PAINT_MODE_GPENCIL = 6,
|
2020-03-09 16:27:24 +01:00
|
|
|
/* Grease Pencil Vertex Paint */
|
|
|
|
PAINT_MODE_VERTEX_GPENCIL = 7,
|
|
|
|
PAINT_MODE_SCULPT_GPENCIL = 8,
|
|
|
|
PAINT_MODE_WEIGHT_GPENCIL = 9,
|
2022-02-18 09:12:41 +01:00
|
|
|
/** Curves. */
|
|
|
|
PAINT_MODE_SCULPT_CURVES = 10,
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2018-11-14 01:20:08 +01:00
|
|
|
/** Keep last. */
|
2022-02-18 09:12:41 +01:00
|
|
|
PAINT_MODE_INVALID = 11,
|
2017-10-17 04:43:10 +02:00
|
|
|
} ePaintMode;
|
2013-03-06 23:54:44 +01:00
|
|
|
|
2018-11-21 07:56:10 +01:00
|
|
|
#define PAINT_MODE_HAS_BRUSH(mode) !ELEM(mode, PAINT_MODE_SCULPT_UV)
|
|
|
|
|
Paint refactoring commit, non-disruptive (in theory :p)
* Fix precision overflow issue with overlay previews,
* Expose alpha mask mapping to UI (still not functional but coming soon).
* More overlay refactoring:
Overlay now does minimal checking for texture refresh.
Instead, we now have invalidation flags to set an aspect of the brush
overlay as invalid. This is necessary because this way we will be able to
separate and preview different brush attributes on the overlays, using
different textures:
These attributes/aspects are:
Primary texture (main texture for sculpt, vertex, imapaint)
Secondary texture (mask/alpha texture for imapaint)
Cursor texture (cursor texture. It involves brush strength and curves)
Modified the relevant RNA property update functions and C update callback
functions to call the relevant cursor invalidation functions instead
of checking every frame for multiple properties.
Properties that affect this are:
Image changes, if image is used by current brush,
Texture slot changes, similarly
Curve changes,
Object mode change invalidates the cursor
Paint tool change invalidates the cursor.
These changes give slightly more invalidation cases than simply
comparing the relevant properties each frame, but these do not occur in
performance critical moments and it's a much more elegant system than
adding more variables to check per frame each time we add something on
the system.
2013-04-12 19:21:31 +02:00
|
|
|
/* overlay invalidation */
|
2020-01-08 02:59:48 +01:00
|
|
|
typedef enum ePaintOverlayControlFlags {
|
2018-11-14 01:20:08 +01:00
|
|
|
PAINT_OVERLAY_INVALID_TEXTURE_PRIMARY = 1,
|
|
|
|
PAINT_OVERLAY_INVALID_TEXTURE_SECONDARY = (1 << 2),
|
|
|
|
PAINT_OVERLAY_INVALID_CURVE = (1 << 3),
|
2013-04-23 02:32:51 +02:00
|
|
|
PAINT_OVERLAY_OVERRIDE_CURSOR = (1 << 4),
|
|
|
|
PAINT_OVERLAY_OVERRIDE_PRIMARY = (1 << 5),
|
2019-01-15 13:57:49 +01:00
|
|
|
PAINT_OVERLAY_OVERRIDE_SECONDARY = (1 << 6),
|
2020-01-08 02:59:48 +01:00
|
|
|
} ePaintOverlayControlFlags;
|
2022-08-23 18:01:37 +02:00
|
|
|
ENUM_OPERATORS(ePaintOverlayControlFlags, PAINT_OVERLAY_OVERRIDE_SECONDARY);
|
Paint refactoring commit, non-disruptive (in theory :p)
* Fix precision overflow issue with overlay previews,
* Expose alpha mask mapping to UI (still not functional but coming soon).
* More overlay refactoring:
Overlay now does minimal checking for texture refresh.
Instead, we now have invalidation flags to set an aspect of the brush
overlay as invalid. This is necessary because this way we will be able to
separate and preview different brush attributes on the overlays, using
different textures:
These attributes/aspects are:
Primary texture (main texture for sculpt, vertex, imapaint)
Secondary texture (mask/alpha texture for imapaint)
Cursor texture (cursor texture. It involves brush strength and curves)
Modified the relevant RNA property update functions and C update callback
functions to call the relevant cursor invalidation functions instead
of checking every frame for multiple properties.
Properties that affect this are:
Image changes, if image is used by current brush,
Texture slot changes, similarly
Curve changes,
Object mode change invalidates the cursor
Paint tool change invalidates the cursor.
These changes give slightly more invalidation cases than simply
comparing the relevant properties each frame, but these do not occur in
performance critical moments and it's a much more elegant system than
adding more variables to check per frame each time we add something on
the system.
2013-04-12 19:21:31 +02:00
|
|
|
|
2018-11-14 01:20:08 +01:00
|
|
|
#define PAINT_OVERRIDE_MASK \
|
|
|
|
(PAINT_OVERLAY_OVERRIDE_SECONDARY | PAINT_OVERLAY_OVERRIDE_PRIMARY | \
|
|
|
|
PAINT_OVERLAY_OVERRIDE_CURSOR)
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2021-12-07 07:19:15 +01:00
|
|
|
/**
|
|
|
|
* Defines 8 areas resulting of splitting the object space by the XYZ axis planes. This is used to
|
2020-01-07 16:46:56 +01:00
|
|
|
* flip or mirror transform values depending on where the vertex is and where the transform
|
2021-12-07 07:19:15 +01:00
|
|
|
* operation started to support XYZ symmetry on those operations in a predictable way.
|
|
|
|
*/
|
2020-01-08 02:59:48 +01:00
|
|
|
#define PAINT_SYMM_AREA_DEFAULT 0
|
2020-01-07 16:46:56 +01:00
|
|
|
|
|
|
|
typedef enum ePaintSymmetryAreas {
|
2020-01-08 02:59:48 +01:00
|
|
|
PAINT_SYMM_AREA_X = (1 << 0),
|
|
|
|
PAINT_SYMM_AREA_Y = (1 << 1),
|
|
|
|
PAINT_SYMM_AREA_Z = (1 << 2),
|
2020-01-07 16:46:56 +01:00
|
|
|
} ePaintSymmetryAreas;
|
2022-11-10 02:27:41 +01:00
|
|
|
ENUM_OPERATORS(ePaintSymmetryAreas, PAINT_SYMM_AREA_Z);
|
2020-01-07 16:46:56 +01:00
|
|
|
|
|
|
|
#define PAINT_SYMM_AREAS 8
|
|
|
|
|
2018-04-05 18:20:27 +02:00
|
|
|
void BKE_paint_invalidate_overlay_tex(struct Scene *scene,
|
|
|
|
struct ViewLayer *view_layer,
|
|
|
|
const struct Tex *tex);
|
|
|
|
void BKE_paint_invalidate_cursor_overlay(struct Scene *scene,
|
|
|
|
struct ViewLayer *view_layer,
|
|
|
|
struct CurveMapping *curve);
|
Paint refactoring commit, non-disruptive (in theory :p)
* Fix precision overflow issue with overlay previews,
* Expose alpha mask mapping to UI (still not functional but coming soon).
* More overlay refactoring:
Overlay now does minimal checking for texture refresh.
Instead, we now have invalidation flags to set an aspect of the brush
overlay as invalid. This is necessary because this way we will be able to
separate and preview different brush attributes on the overlays, using
different textures:
These attributes/aspects are:
Primary texture (main texture for sculpt, vertex, imapaint)
Secondary texture (mask/alpha texture for imapaint)
Cursor texture (cursor texture. It involves brush strength and curves)
Modified the relevant RNA property update functions and C update callback
functions to call the relevant cursor invalidation functions instead
of checking every frame for multiple properties.
Properties that affect this are:
Image changes, if image is used by current brush,
Texture slot changes, similarly
Curve changes,
Object mode change invalidates the cursor
Paint tool change invalidates the cursor.
These changes give slightly more invalidation cases than simply
comparing the relevant properties each frame, but these do not occur in
performance critical moments and it's a much more elegant system than
adding more variables to check per frame each time we add something on
the system.
2013-04-12 19:21:31 +02:00
|
|
|
void BKE_paint_invalidate_overlay_all(void);
|
2020-01-08 02:59:48 +01:00
|
|
|
ePaintOverlayControlFlags BKE_paint_get_overlay_flags(void);
|
|
|
|
void BKE_paint_reset_overlay_invalid(ePaintOverlayControlFlags flag);
|
2017-10-17 04:43:10 +02:00
|
|
|
void BKE_paint_set_overlay_override(enum eOverlayFlags flag);
|
Paint refactoring commit, non-disruptive (in theory :p)
* Fix precision overflow issue with overlay previews,
* Expose alpha mask mapping to UI (still not functional but coming soon).
* More overlay refactoring:
Overlay now does minimal checking for texture refresh.
Instead, we now have invalidation flags to set an aspect of the brush
overlay as invalid. This is necessary because this way we will be able to
separate and preview different brush attributes on the overlays, using
different textures:
These attributes/aspects are:
Primary texture (main texture for sculpt, vertex, imapaint)
Secondary texture (mask/alpha texture for imapaint)
Cursor texture (cursor texture. It involves brush strength and curves)
Modified the relevant RNA property update functions and C update callback
functions to call the relevant cursor invalidation functions instead
of checking every frame for multiple properties.
Properties that affect this are:
Image changes, if image is used by current brush,
Texture slot changes, similarly
Curve changes,
Object mode change invalidates the cursor
Paint tool change invalidates the cursor.
These changes give slightly more invalidation cases than simply
comparing the relevant properties each frame, but these do not occur in
performance critical moments and it's a much more elegant system than
adding more variables to check per frame each time we add something on
the system.
2013-04-12 19:21:31 +02:00
|
|
|
|
2021-12-07 07:19:15 +01:00
|
|
|
/* Palettes. */
|
|
|
|
|
2014-07-21 12:02:05 +02:00
|
|
|
struct Palette *BKE_palette_add(struct Main *bmain, const char *name);
|
|
|
|
struct PaletteColor *BKE_palette_color_add(struct Palette *palette);
|
|
|
|
bool BKE_palette_is_empty(const struct Palette *palette);
|
2021-12-07 07:19:15 +01:00
|
|
|
/**
|
|
|
|
* Remove color from palette. Must be certain color is inside the palette!
|
|
|
|
*/
|
2014-07-21 12:02:05 +02:00
|
|
|
void BKE_palette_color_remove(struct Palette *palette, struct PaletteColor *color);
|
2015-03-18 05:09:04 +01:00
|
|
|
void BKE_palette_clear(struct Palette *palette);
|
2014-07-21 12:02:05 +02:00
|
|
|
|
2022-01-07 01:38:08 +01:00
|
|
|
void BKE_palette_sort_hsv(struct tPaletteColorHSV *color_array, int totcol);
|
|
|
|
void BKE_palette_sort_svh(struct tPaletteColorHSV *color_array, int totcol);
|
|
|
|
void BKE_palette_sort_vhs(struct tPaletteColorHSV *color_array, int totcol);
|
|
|
|
void BKE_palette_sort_luminance(struct tPaletteColorHSV *color_array, int totcol);
|
2020-03-09 16:27:24 +01:00
|
|
|
bool BKE_palette_from_hash(struct Main *bmain,
|
|
|
|
struct GHash *color_table,
|
|
|
|
const char *name,
|
2022-01-07 01:38:08 +01:00
|
|
|
bool linear);
|
2020-03-09 16:27:24 +01:00
|
|
|
|
2021-12-07 07:19:15 +01:00
|
|
|
/* Paint curves. */
|
|
|
|
|
2014-07-21 12:02:05 +02:00
|
|
|
struct PaintCurve *BKE_paint_curve_add(struct Main *bmain, const char *name);
|
|
|
|
|
2021-12-07 07:19:15 +01:00
|
|
|
/**
|
|
|
|
* Call when entering each respective paint mode.
|
|
|
|
*/
|
2019-12-10 15:45:55 +01:00
|
|
|
bool BKE_paint_ensure(struct ToolSettings *ts, struct Paint **r_paint);
|
2022-08-26 07:06:33 +02:00
|
|
|
void BKE_paint_init(struct Main *bmain, struct Scene *sce, ePaintMode mode, const uchar col[3]);
|
2012-07-26 00:37:52 +02:00
|
|
|
void BKE_paint_free(struct Paint *p);
|
2021-12-07 07:19:15 +01:00
|
|
|
/**
|
|
|
|
* Called when copying scene settings, so even if 'src' and 'tar' are the same still do a
|
|
|
|
* #id_us_plus(), rather than if we were copying between 2 existing scenes where a matching
|
|
|
|
* value should decrease the existing user count as with #paint_brush_set()
|
|
|
|
*/
|
2022-01-07 01:38:08 +01:00
|
|
|
void BKE_paint_copy(struct Paint *src, struct Paint *tar, int flag);
|
2009-08-16 21:50:00 +02:00
|
|
|
|
2018-11-05 06:18:43 +01:00
|
|
|
void BKE_paint_runtime_init(const struct ToolSettings *ts, struct Paint *paint);
|
|
|
|
|
2015-02-11 15:07:04 +01:00
|
|
|
void BKE_paint_cavity_curve_preset(struct Paint *p, int preset);
|
|
|
|
|
2018-11-06 23:43:07 +01:00
|
|
|
eObjectMode BKE_paint_object_mode_from_paintmode(ePaintMode mode);
|
2019-05-01 10:10:34 +02:00
|
|
|
bool BKE_paint_ensure_from_paintmode(struct Scene *sce, ePaintMode mode);
|
2017-10-17 04:43:10 +02:00
|
|
|
struct Paint *BKE_paint_get_active_from_paintmode(struct Scene *sce, ePaintMode mode);
|
2018-11-06 02:08:39 +01:00
|
|
|
const struct EnumPropertyItem *BKE_paint_get_tool_enum_from_paintmode(ePaintMode mode);
|
2018-11-07 01:38:10 +01:00
|
|
|
const char *BKE_paint_get_tool_prop_id_from_paintmode(ePaintMode mode);
|
2022-01-07 01:38:08 +01:00
|
|
|
uint BKE_paint_get_brush_tool_offset_from_paintmode(ePaintMode mode);
|
2018-04-05 18:20:27 +02:00
|
|
|
struct Paint *BKE_paint_get_active(struct Scene *sce, struct ViewLayer *view_layer);
|
Paint refactoring commit, non-disruptive (in theory :p)
* Fix precision overflow issue with overlay previews,
* Expose alpha mask mapping to UI (still not functional but coming soon).
* More overlay refactoring:
Overlay now does minimal checking for texture refresh.
Instead, we now have invalidation flags to set an aspect of the brush
overlay as invalid. This is necessary because this way we will be able to
separate and preview different brush attributes on the overlays, using
different textures:
These attributes/aspects are:
Primary texture (main texture for sculpt, vertex, imapaint)
Secondary texture (mask/alpha texture for imapaint)
Cursor texture (cursor texture. It involves brush strength and curves)
Modified the relevant RNA property update functions and C update callback
functions to call the relevant cursor invalidation functions instead
of checking every frame for multiple properties.
Properties that affect this are:
Image changes, if image is used by current brush,
Texture slot changes, similarly
Curve changes,
Object mode change invalidates the cursor
Paint tool change invalidates the cursor.
These changes give slightly more invalidation cases than simply
comparing the relevant properties each frame, but these do not occur in
performance critical moments and it's a much more elegant system than
adding more variables to check per frame each time we add something on
the system.
2013-04-12 19:21:31 +02:00
|
|
|
struct Paint *BKE_paint_get_active_from_context(const struct bContext *C);
|
2017-10-17 04:43:10 +02:00
|
|
|
ePaintMode BKE_paintmode_get_active_from_context(const struct bContext *C);
|
2018-11-06 02:08:39 +01:00
|
|
|
ePaintMode BKE_paintmode_get_from_tool(const struct bToolRef *tref);
|
Paint refactoring commit, non-disruptive (in theory :p)
* Fix precision overflow issue with overlay previews,
* Expose alpha mask mapping to UI (still not functional but coming soon).
* More overlay refactoring:
Overlay now does minimal checking for texture refresh.
Instead, we now have invalidation flags to set an aspect of the brush
overlay as invalid. This is necessary because this way we will be able to
separate and preview different brush attributes on the overlays, using
different textures:
These attributes/aspects are:
Primary texture (main texture for sculpt, vertex, imapaint)
Secondary texture (mask/alpha texture for imapaint)
Cursor texture (cursor texture. It involves brush strength and curves)
Modified the relevant RNA property update functions and C update callback
functions to call the relevant cursor invalidation functions instead
of checking every frame for multiple properties.
Properties that affect this are:
Image changes, if image is used by current brush,
Texture slot changes, similarly
Curve changes,
Object mode change invalidates the cursor
Paint tool change invalidates the cursor.
These changes give slightly more invalidation cases than simply
comparing the relevant properties each frame, but these do not occur in
performance critical moments and it's a much more elegant system than
adding more variables to check per frame each time we add something on
the system.
2013-04-12 19:21:31 +02:00
|
|
|
struct Brush *BKE_paint_brush(struct Paint *paint);
|
2022-05-17 13:06:14 +02:00
|
|
|
const struct Brush *BKE_paint_brush_for_read(const struct Paint *p);
|
Paint refactoring commit, non-disruptive (in theory :p)
* Fix precision overflow issue with overlay previews,
* Expose alpha mask mapping to UI (still not functional but coming soon).
* More overlay refactoring:
Overlay now does minimal checking for texture refresh.
Instead, we now have invalidation flags to set an aspect of the brush
overlay as invalid. This is necessary because this way we will be able to
separate and preview different brush attributes on the overlays, using
different textures:
These attributes/aspects are:
Primary texture (main texture for sculpt, vertex, imapaint)
Secondary texture (mask/alpha texture for imapaint)
Cursor texture (cursor texture. It involves brush strength and curves)
Modified the relevant RNA property update functions and C update callback
functions to call the relevant cursor invalidation functions instead
of checking every frame for multiple properties.
Properties that affect this are:
Image changes, if image is used by current brush,
Texture slot changes, similarly
Curve changes,
Object mode change invalidates the cursor
Paint tool change invalidates the cursor.
These changes give slightly more invalidation cases than simply
comparing the relevant properties each frame, but these do not occur in
performance critical moments and it's a much more elegant system than
adding more variables to check per frame each time we add something on
the system.
2013-04-12 19:21:31 +02:00
|
|
|
void BKE_paint_brush_set(struct Paint *paint, struct Brush *br);
|
2014-07-21 12:02:05 +02:00
|
|
|
struct Palette *BKE_paint_palette(struct Paint *paint);
|
|
|
|
void BKE_paint_palette_set(struct Paint *p, struct Palette *palette);
|
|
|
|
void BKE_paint_curve_set(struct Brush *br, struct PaintCurve *pc);
|
2022-01-07 01:38:08 +01:00
|
|
|
void BKE_paint_curve_clamp_endpoint_add_index(struct PaintCurve *pc, int add_index);
|
2009-08-15 21:48:50 +02:00
|
|
|
|
2021-12-07 07:19:15 +01:00
|
|
|
/**
|
|
|
|
* Return true when in vertex/weight/texture paint + face-select mode?
|
|
|
|
*/
|
2018-04-05 18:20:27 +02:00
|
|
|
bool BKE_paint_select_face_test(struct Object *ob);
|
2021-12-07 07:19:15 +01:00
|
|
|
/**
|
|
|
|
* Return true when in vertex/weight paint + vertex-select mode?
|
|
|
|
*/
|
2018-04-05 18:20:27 +02:00
|
|
|
bool BKE_paint_select_vert_test(struct Object *ob);
|
2021-12-07 07:19:15 +01:00
|
|
|
/**
|
|
|
|
* used to check if selection is possible
|
|
|
|
* (when we don't care if its face or vert)
|
|
|
|
*/
|
2018-04-05 18:20:27 +02:00
|
|
|
bool BKE_paint_select_elem_test(struct Object *ob);
|
2022-02-19 15:04:32 +01:00
|
|
|
/**
|
|
|
|
* Checks if face/vertex hiding is always applied in the current mode.
|
|
|
|
* Returns true in vertex/weight paint.
|
|
|
|
*/
|
|
|
|
bool BKE_paint_always_hide_test(struct Object *ob);
|
2009-08-15 21:48:50 +02:00
|
|
|
|
2021-12-07 07:19:15 +01:00
|
|
|
/* Partial visibility. */
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns non-zero if any of the face's vertices are hidden, zero otherwise.
|
|
|
|
*/
|
2022-09-12 19:48:35 +02:00
|
|
|
bool paint_is_face_hidden(const struct MLoopTri *lt, const bool *hide_poly);
|
2021-12-07 07:19:15 +01:00
|
|
|
/**
|
|
|
|
* Returns non-zero if any of the corners of the grid
|
|
|
|
* face whose inner corner is at (x, y) are hidden, zero otherwise.
|
|
|
|
*/
|
2014-01-21 16:48:11 +01:00
|
|
|
bool paint_is_grid_face_hidden(const unsigned int *grid_hidden, int gridsize, int x, int y);
|
2021-12-07 07:19:15 +01:00
|
|
|
/**
|
|
|
|
* Return true if all vertices in the face are visible, false otherwise.
|
|
|
|
*/
|
2014-01-21 16:48:11 +01:00
|
|
|
bool paint_is_bmesh_face_hidden(struct BMFace *f);
|
2012-03-14 07:31:38 +01:00
|
|
|
|
2021-12-07 07:19:15 +01:00
|
|
|
/* Paint masks. */
|
|
|
|
|
2020-02-07 15:02:18 +01:00
|
|
|
float paint_grid_paint_mask(const struct GridPaintMask *gpm, uint level, uint x, uint y);
|
2014-07-21 12:02:05 +02:00
|
|
|
|
2022-01-07 01:38:08 +01:00
|
|
|
void BKE_paint_face_set_overlay_color_get(int face_set, int seed, uchar r_color[4]);
|
2020-09-18 19:30:02 +02:00
|
|
|
|
2021-12-07 07:19:15 +01:00
|
|
|
/* Stroke related. */
|
|
|
|
|
2017-12-18 04:35:15 +01:00
|
|
|
bool paint_calculate_rake_rotation(struct UnifiedPaintSettings *ups,
|
|
|
|
struct Brush *brush,
|
|
|
|
const float mouse_pos[2]);
|
2015-05-07 18:10:34 +02:00
|
|
|
void paint_update_brush_rake_rotation(struct UnifiedPaintSettings *ups,
|
|
|
|
struct Brush *brush,
|
|
|
|
float rotation);
|
2014-07-21 12:02:05 +02:00
|
|
|
|
2014-12-29 11:35:22 +01:00
|
|
|
void BKE_paint_stroke_get_average(struct Scene *scene, struct Object *ob, float stroke[3]);
|
|
|
|
|
2018-11-01 23:10:23 +01:00
|
|
|
/* Tool slot API. */
|
2021-12-07 07:19:15 +01:00
|
|
|
|
2018-11-01 23:10:23 +01:00
|
|
|
void BKE_paint_toolslots_init_from_main(struct Main *bmain);
|
|
|
|
void BKE_paint_toolslots_len_ensure(struct Paint *paint, int len);
|
2018-11-05 06:18:43 +01:00
|
|
|
void BKE_paint_toolslots_brush_update_ex(struct Paint *paint, struct Brush *brush);
|
|
|
|
void BKE_paint_toolslots_brush_update(struct Paint *paint);
|
2021-12-07 07:19:15 +01:00
|
|
|
/**
|
|
|
|
* Run this to ensure brush types are set for each slot on entering modes
|
|
|
|
* (for new scenes for example).
|
|
|
|
*/
|
2018-11-05 06:18:43 +01:00
|
|
|
void BKE_paint_toolslots_brush_validate(struct Main *bmain, struct Paint *paint);
|
2018-11-06 02:08:39 +01:00
|
|
|
struct Brush *BKE_paint_toolslots_brush_get(struct Paint *paint, int slot_index);
|
2018-11-01 23:10:23 +01:00
|
|
|
|
2020-11-06 13:16:17 +01:00
|
|
|
/* .blend I/O */
|
2021-12-07 07:19:15 +01:00
|
|
|
|
2020-11-06 13:16:17 +01:00
|
|
|
void BKE_paint_blend_write(struct BlendWriter *writer, struct Paint *paint);
|
|
|
|
void BKE_paint_blend_read_data(struct BlendDataReader *reader,
|
|
|
|
const struct Scene *scene,
|
|
|
|
struct Paint *paint);
|
2020-11-06 14:09:58 +01:00
|
|
|
void BKE_paint_blend_read_lib(struct BlendLibReader *reader,
|
|
|
|
struct Scene *scene,
|
|
|
|
struct Paint *paint);
|
2020-11-06 13:16:17 +01:00
|
|
|
|
2020-03-05 14:53:23 +01:00
|
|
|
#define SCULPT_FACE_SET_NONE 0
|
|
|
|
|
2021-12-07 07:19:15 +01:00
|
|
|
/** Used for both vertex color and weight paint. */
|
2017-09-27 17:38:17 +02:00
|
|
|
struct SculptVertexPaintGeomMap {
|
|
|
|
int *vert_map_mem;
|
|
|
|
struct MeshElemMap *vert_to_loop;
|
|
|
|
int *poly_map_mem;
|
|
|
|
struct MeshElemMap *vert_to_poly;
|
|
|
|
};
|
|
|
|
|
2021-12-07 07:19:15 +01:00
|
|
|
/** Pose Brush IK Chain. */
|
2020-01-08 02:59:48 +01:00
|
|
|
typedef struct SculptPoseIKChainSegment {
|
2020-01-07 16:46:56 +01:00
|
|
|
float orig[3];
|
|
|
|
float head[3];
|
|
|
|
|
|
|
|
float initial_orig[3];
|
|
|
|
float initial_head[3];
|
|
|
|
float len;
|
2020-06-05 20:47:56 +02:00
|
|
|
float scale[3];
|
2020-01-07 16:46:56 +01:00
|
|
|
float rot[4];
|
|
|
|
float *weights;
|
|
|
|
|
|
|
|
/* Store a 4x4 transform matrix for each of the possible combinations of enabled XYZ symmetry
|
|
|
|
* axis. */
|
|
|
|
float trans_mat[PAINT_SYMM_AREAS][4][4];
|
|
|
|
float pivot_mat[PAINT_SYMM_AREAS][4][4];
|
|
|
|
float pivot_mat_inv[PAINT_SYMM_AREAS][4][4];
|
2020-01-08 02:59:48 +01:00
|
|
|
} SculptPoseIKChainSegment;
|
2020-01-07 16:46:56 +01:00
|
|
|
|
2020-01-08 02:59:48 +01:00
|
|
|
typedef struct SculptPoseIKChain {
|
|
|
|
SculptPoseIKChainSegment *segments;
|
2020-01-07 16:46:56 +01:00
|
|
|
int tot_segments;
|
2020-06-02 02:20:36 +02:00
|
|
|
float grab_delta_offset[3];
|
2020-01-08 02:59:48 +01:00
|
|
|
} SculptPoseIKChain;
|
2020-01-07 16:46:56 +01:00
|
|
|
|
2020-02-28 14:40:40 +01:00
|
|
|
/* Cloth Brush */
|
|
|
|
|
2020-10-01 18:50:52 +02:00
|
|
|
/* Cloth Simulation. */
|
|
|
|
typedef enum eSculptClothNodeSimState {
|
|
|
|
/* Constraints were not built for this node, so it can't be simulated. */
|
|
|
|
SCULPT_CLOTH_NODE_UNINITIALIZED,
|
|
|
|
|
|
|
|
/* There are constraints for the geometry in this node, but it should not be simulated. */
|
|
|
|
SCULPT_CLOTH_NODE_INACTIVE,
|
|
|
|
|
|
|
|
/* There are constraints for this node and they should be used by the solver. */
|
|
|
|
SCULPT_CLOTH_NODE_ACTIVE,
|
|
|
|
} eSculptClothNodeSimState;
|
|
|
|
|
2020-08-24 23:26:37 +02:00
|
|
|
typedef enum eSculptClothConstraintType {
|
|
|
|
/* Constraint that creates the structure of the cloth. */
|
|
|
|
SCULPT_CLOTH_CONSTRAINT_STRUCTURAL = 0,
|
|
|
|
/* Constraint that references the position of a vertex and a position in deformation_pos which
|
2020-10-14 05:43:54 +02:00
|
|
|
* can be deformed by the tools. */
|
2020-08-24 23:26:37 +02:00
|
|
|
SCULPT_CLOTH_CONSTRAINT_DEFORMATION = 1,
|
2020-10-14 05:43:54 +02:00
|
|
|
/* Constraint that references the vertex position and a editable soft-body position for
|
|
|
|
* plasticity. */
|
2020-08-24 23:26:37 +02:00
|
|
|
SCULPT_CLOTH_CONSTRAINT_SOFTBODY = 2,
|
2020-10-14 05:43:54 +02:00
|
|
|
/* Constraint that references the vertex position and its initial position. */
|
2020-10-12 23:24:45 +02:00
|
|
|
SCULPT_CLOTH_CONSTRAINT_PIN = 3,
|
2020-08-24 23:26:37 +02:00
|
|
|
} eSculptClothConstraintType;
|
|
|
|
|
2020-02-28 14:40:40 +01:00
|
|
|
typedef struct SculptClothLengthConstraint {
|
2020-07-29 19:12:35 +02:00
|
|
|
/* Elements that are affected by the constraint. */
|
|
|
|
/* Element a should always be a mesh vertex with the index stored in elem_index_a as it is always
|
2020-07-30 00:31:25 +02:00
|
|
|
* deformed. Element b could be another vertex of the same mesh or any other position (arbitrary
|
2020-07-29 19:12:35 +02:00
|
|
|
* point, position for a previous state). In that case, elem_index_a and elem_index_b should be
|
|
|
|
* the same to avoid affecting two different vertices when solving the constraints.
|
|
|
|
* *elem_position points to the position which is owned by the element. */
|
|
|
|
int elem_index_a;
|
|
|
|
float *elem_position_a;
|
|
|
|
|
|
|
|
int elem_index_b;
|
|
|
|
float *elem_position_b;
|
2020-02-28 14:40:40 +01:00
|
|
|
|
|
|
|
float length;
|
2020-07-29 19:12:35 +02:00
|
|
|
float strength;
|
2020-08-24 23:26:37 +02:00
|
|
|
|
2020-10-14 05:43:54 +02:00
|
|
|
/* Index in #SculptClothSimulation.node_state of the node from where this constraint was created.
|
2020-10-01 18:50:52 +02:00
|
|
|
* This constraints will only be used by the solver if the state is active. */
|
|
|
|
int node;
|
|
|
|
|
2020-08-24 23:26:37 +02:00
|
|
|
eSculptClothConstraintType type;
|
2020-02-28 14:40:40 +01:00
|
|
|
} SculptClothLengthConstraint;
|
|
|
|
|
|
|
|
typedef struct SculptClothSimulation {
|
|
|
|
SculptClothLengthConstraint *length_constraints;
|
|
|
|
int tot_length_constraints;
|
2020-06-24 07:30:54 +02:00
|
|
|
struct EdgeSet *created_length_constraints;
|
2020-02-28 14:40:40 +01:00
|
|
|
int capacity_length_constraints;
|
|
|
|
float *length_constraint_tweak;
|
|
|
|
|
2020-07-30 14:58:15 +02:00
|
|
|
/* Position anchors for deformation brushes. These positions are modified by the brush and the
|
|
|
|
* final positions of the simulated vertices are updated with constraints that use these points
|
|
|
|
* as targets. */
|
|
|
|
float (*deformation_pos)[3];
|
2020-08-24 23:26:37 +02:00
|
|
|
float *deformation_strength;
|
2020-07-30 14:58:15 +02:00
|
|
|
|
2020-02-28 14:40:40 +01:00
|
|
|
float mass;
|
|
|
|
float damping;
|
2020-10-12 23:24:45 +02:00
|
|
|
float softbody_strength;
|
2020-02-28 14:40:40 +01:00
|
|
|
|
|
|
|
float (*acceleration)[3];
|
|
|
|
float (*pos)[3];
|
|
|
|
float (*init_pos)[3];
|
2022-09-29 22:38:16 +02:00
|
|
|
float (*init_no)[3];
|
2020-10-12 23:24:45 +02:00
|
|
|
float (*softbody_pos)[3];
|
2020-02-28 14:40:40 +01:00
|
|
|
float (*prev_pos)[3];
|
2020-07-29 17:39:08 +02:00
|
|
|
float (*last_iteration_pos)[3];
|
2020-02-28 14:40:40 +01:00
|
|
|
|
2020-07-29 17:39:08 +02:00
|
|
|
struct ListBase *collider_list;
|
2020-10-01 18:50:52 +02:00
|
|
|
|
|
|
|
int totnode;
|
2020-10-14 05:43:54 +02:00
|
|
|
/** #PBVHNode pointer as a key, index in #SculptClothSimulation.node_state as value. */
|
2020-10-01 18:50:52 +02:00
|
|
|
struct GHash *node_state_index;
|
|
|
|
eSculptClothNodeSimState *node_state;
|
2020-02-28 14:40:40 +01:00
|
|
|
} SculptClothSimulation;
|
|
|
|
|
2020-06-11 20:15:57 +02:00
|
|
|
typedef struct SculptPersistentBase {
|
2020-04-14 21:06:49 +02:00
|
|
|
float co[3];
|
|
|
|
float no[3];
|
|
|
|
float disp;
|
2020-06-11 20:15:57 +02:00
|
|
|
} SculptPersistentBase;
|
2020-04-14 21:06:49 +02:00
|
|
|
|
2020-06-23 16:10:47 +02:00
|
|
|
typedef struct SculptVertexInfo {
|
Fix T78747: Fix mesh boundary detection and automasking
This issue was produced by a hack in the sculpt mode code from 2.80
when the sculpt API for connectivity info was not available.
The smooth brush was the only brush that needed connectivity info,
so there were 3 different smooth functions with the connectivity
queries implemented for dyntopo, meshes and grids. The mesh version
of smoothing was checking the number of connected faces to a vertex
to mask the mesh boundaries, which was not covering all cases and
was hardcoded in the smooth function itself.
This patch removes all those legacy functions and unifies all
smooth functions into a single one using the new API and the
automasking system. In order to achieve this, there were needed
some extra changes:
- The smooth brush now does not automasks the boundaries by default,
so its default preset needs to be updated to enable automasking
- The mesh boundary info is extracted once and cached in a
bitmap, similar to the disconnected elements IDs. This makes
boundary detection work as expected in all cases, solving a lot
of known issues with the smooth brush. In multires, this info is
extracted and cached only at the base mesh level, so it is much
more memory efficient than the previous automasking system.
- In order to keep the brushes responsive as they were before,
the automasking system can now skip creating the cache when it
is not needed for the requested options. This means that for
high poly meshes and simple automasking options the brushes
won't lag on start.
Reviewed By: sergey
Maniphest Tasks: T78747
Differential Revision: https://developer.blender.org/D8260
2020-07-15 16:24:03 +02:00
|
|
|
/* Indexed by base mesh vertex index, stores if that vertex is a boundary. */
|
|
|
|
BLI_bitmap *boundary;
|
2020-06-23 16:10:47 +02:00
|
|
|
} SculptVertexInfo;
|
|
|
|
|
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
|
|
|
typedef struct SculptBoundaryEditInfo {
|
|
|
|
/* Vertex index from where the topology propagation reached this vertex. */
|
2022-07-30 04:01:32 +02:00
|
|
|
int original_vertex_i;
|
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
|
|
|
|
|
|
|
/* How many steps were needed to reach this vertex from the boundary. */
|
2022-09-08 03:22:30 +02:00
|
|
|
int propagation_steps_num;
|
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
|
|
|
|
2021-02-05 06:23:34 +01:00
|
|
|
/* Strength that is used to deform this vertex. */
|
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
|
|
|
float strength_factor;
|
|
|
|
} SculptBoundaryEditInfo;
|
|
|
|
|
|
|
|
/* Edge for drawing the boundary preview in the cursor. */
|
|
|
|
typedef struct SculptBoundaryPreviewEdge {
|
2022-07-30 04:01:32 +02:00
|
|
|
PBVHVertRef v1;
|
|
|
|
PBVHVertRef v2;
|
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
|
|
|
} SculptBoundaryPreviewEdge;
|
|
|
|
|
|
|
|
typedef struct SculptBoundary {
|
|
|
|
/* Vertex indices of the active boundary. */
|
2022-09-08 03:22:30 +02:00
|
|
|
PBVHVertRef *verts;
|
|
|
|
int verts_capacity;
|
|
|
|
int verts_num;
|
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
|
|
|
|
2020-08-11 16:33:35 +02:00
|
|
|
/* Distance from a vertex in the boundary to initial vertex indexed by vertex index, taking into
|
2020-08-17 04:34:05 +02:00
|
|
|
* account the length of all edges between them. Any vertex that is not in the boundary will have
|
2020-08-11 16:33:35 +02:00
|
|
|
* a distance of 0. */
|
|
|
|
float *distance;
|
|
|
|
|
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
|
|
|
/* Data for drawing the preview. */
|
|
|
|
SculptBoundaryPreviewEdge *edges;
|
|
|
|
int edges_capacity;
|
2022-09-08 03:22:30 +02:00
|
|
|
int edges_num;
|
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
|
|
|
|
|
|
|
/* True if the boundary loops into itself. */
|
|
|
|
bool forms_loop;
|
|
|
|
|
|
|
|
/* Initial vertex in the boundary which is closest to the current sculpt active vertex. */
|
2022-07-30 04:01:32 +02:00
|
|
|
PBVHVertRef initial_vertex;
|
|
|
|
int initial_vertex_i;
|
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
|
|
|
|
|
|
|
/* Vertex that at max_propagation_steps from the boundary and closest to the original active
|
|
|
|
* vertex that was used to initialize the boundary. This is used as a reference to check how much
|
|
|
|
* the deformation will go into the mesh and to calculate the strength of the brushes. */
|
2022-07-30 04:01:32 +02:00
|
|
|
PBVHVertRef pivot_vertex;
|
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
|
|
|
|
|
|
|
/* Stores the initial positions of the pivot and boundary initial vertex as they may be deformed
|
|
|
|
* during the brush action. This allows to use them as a reference positions and vectors for some
|
|
|
|
* brush effects. */
|
|
|
|
float initial_vertex_position[3];
|
|
|
|
float initial_pivot_position[3];
|
|
|
|
|
|
|
|
/* Maximum number of topology steps that were calculated from the boundary. */
|
|
|
|
int max_propagation_steps;
|
|
|
|
|
|
|
|
/* Indexed by vertex index, contains the topology information needed for boundary deformations.
|
|
|
|
*/
|
|
|
|
struct SculptBoundaryEditInfo *edit_info;
|
|
|
|
|
|
|
|
/* Bend Deform type. */
|
|
|
|
struct {
|
|
|
|
float (*pivot_rotation_axis)[3];
|
|
|
|
float (*pivot_positions)[3];
|
|
|
|
} bend;
|
|
|
|
|
|
|
|
/* Slide Deform type. */
|
|
|
|
struct {
|
|
|
|
float (*directions)[3];
|
|
|
|
} slide;
|
|
|
|
|
|
|
|
/* Twist Deform type. */
|
|
|
|
struct {
|
|
|
|
float rotation_axis[3];
|
|
|
|
float pivot_position[3];
|
|
|
|
} twist;
|
|
|
|
} SculptBoundary;
|
|
|
|
|
2020-06-23 16:10:47 +02:00
|
|
|
typedef struct SculptFakeNeighbors {
|
|
|
|
bool use_fake_neighbors;
|
|
|
|
|
|
|
|
/* Max distance used to calculate neighborhood information. */
|
|
|
|
float current_max_distance;
|
|
|
|
|
2020-10-14 05:43:54 +02:00
|
|
|
/* Indexed by vertex, stores the vertex index of its fake neighbor if available. */
|
2020-06-23 16:10:47 +02:00
|
|
|
int *fake_neighbor_index;
|
|
|
|
|
|
|
|
} SculptFakeNeighbors;
|
|
|
|
|
2009-08-28 23:47:11 +02:00
|
|
|
/* Session data (mode-specific) */
|
|
|
|
|
2022-09-16 21:20:28 +02:00
|
|
|
/* Custom Temporary Attributes */
|
|
|
|
|
|
|
|
typedef struct SculptAttributeParams {
|
|
|
|
/* Allocate a flat array outside the CustomData system. Cannot be combined with permanent. */
|
|
|
|
int simple_array : 1;
|
|
|
|
|
|
|
|
/* Do not mark CustomData layer as temporary. Cannot be combined with simple_array. Doesn't
|
|
|
|
* work with PBVH_GRIDS.
|
|
|
|
*/
|
|
|
|
int permanent : 1; /* Cannot be combined with simple_array. */
|
|
|
|
int stroke_only : 1; /* Release layer at end of struct */
|
|
|
|
} SculptAttributeParams;
|
|
|
|
|
|
|
|
typedef struct SculptAttribute {
|
|
|
|
/* Domain, data type and name */
|
|
|
|
eAttrDomain domain;
|
|
|
|
eCustomDataType proptype;
|
|
|
|
char name[MAX_CUSTOMDATA_LAYER_NAME];
|
|
|
|
|
|
|
|
/* Source layer on mesh/bmesh, if any. */
|
|
|
|
struct CustomDataLayer *layer;
|
|
|
|
|
|
|
|
/* Data stored as flat array. */
|
|
|
|
void *data;
|
|
|
|
int elem_size, elem_num;
|
|
|
|
bool data_for_bmesh; /* Temporary data store as array outside of bmesh. */
|
|
|
|
|
2022-12-13 22:42:25 +01:00
|
|
|
/* Data is a flat array outside the CustomData system.
|
|
|
|
* This will be true if simple_array is requested in
|
|
|
|
* SculptAttributeParams, or the PBVH type is PBVH_GRIDS or PBVH_BMESH.
|
|
|
|
*/
|
2022-12-14 23:34:22 +01:00
|
|
|
bool simple_array;
|
2022-09-16 21:20:28 +02:00
|
|
|
/* Data stored per BMesh element. */
|
|
|
|
int bmesh_cd_offset;
|
|
|
|
|
|
|
|
/* Sculpt usage */
|
|
|
|
SculptAttributeParams params;
|
|
|
|
|
|
|
|
/* Used to keep track of which preallocated SculptAttribute instances
|
|
|
|
* inside of SculptSession.temp_attribute are used.
|
|
|
|
*/
|
|
|
|
bool used;
|
|
|
|
} SculptAttribute;
|
|
|
|
|
|
|
|
#define SCULPT_MAX_ATTRIBUTES 64
|
|
|
|
|
|
|
|
/* Get a standard attribute name. Key must match up with a member
|
|
|
|
* of SculptAttributePointers.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define SCULPT_ATTRIBUTE_NAME(key) \
|
|
|
|
(offsetof(SculptAttributePointers, key) >= 0 ? /* Spellcheck name. */ \
|
|
|
|
(".sculpt_" #key) /* Make name. */ \
|
|
|
|
: \
|
|
|
|
"You misspelled the layer name key")
|
|
|
|
|
2022-09-17 06:46:50 +02:00
|
|
|
/* Convenience pointers for standard sculpt attributes. */
|
2022-09-16 21:20:28 +02:00
|
|
|
|
|
|
|
typedef struct SculptAttributePointers {
|
|
|
|
/* Persistent base. */
|
|
|
|
SculptAttribute *persistent_co;
|
|
|
|
SculptAttribute *persistent_no;
|
|
|
|
SculptAttribute *persistent_disp;
|
|
|
|
|
|
|
|
/* Precomputed auto-mask factor indexed by vertex, owned by the auto-masking system and
|
|
|
|
* initialized in #SCULPT_automasking_cache_init when needed. */
|
|
|
|
SculptAttribute *automasking_factor;
|
2022-09-29 08:21:56 +02:00
|
|
|
SculptAttribute *automasking_occlusion; /* CD_PROP_INT8. */
|
|
|
|
SculptAttribute *automasking_stroke_id;
|
|
|
|
SculptAttribute *automasking_cavity;
|
2022-09-16 21:20:28 +02:00
|
|
|
|
2023-01-20 01:53:43 +01:00
|
|
|
SculptAttribute *topology_island_key; /* CD_PROP_INT8 */
|
|
|
|
|
2022-09-16 21:20:28 +02:00
|
|
|
/* BMesh */
|
|
|
|
SculptAttribute *dyntopo_node_id_vertex;
|
|
|
|
SculptAttribute *dyntopo_node_id_face;
|
|
|
|
} SculptAttributePointers;
|
|
|
|
|
2023-03-22 21:58:34 +01:00
|
|
|
#ifdef __cplusplus
|
|
|
|
|
2009-08-28 23:47:11 +02:00
|
|
|
typedef struct SculptSession {
|
|
|
|
/* Mesh data (not copied) can come either directly from a Mesh, or from a MultiresDM */
|
2020-04-02 10:10:13 +02:00
|
|
|
struct { /* Special handling for multires meshes */
|
|
|
|
bool active;
|
|
|
|
struct MultiresModifierData *modifier;
|
|
|
|
int level;
|
|
|
|
} multires;
|
2020-04-20 02:06:12 +02:00
|
|
|
|
2020-07-29 17:39:08 +02:00
|
|
|
/* Depsgraph for the Cloth Brush solver to get the colliders. */
|
|
|
|
struct Depsgraph *depsgraph;
|
|
|
|
|
2020-04-20 02:06:12 +02:00
|
|
|
/* These are always assigned to base mesh data when using PBVH_FACES and PBVH_GRIDS. */
|
Mesh: Move positions to a generic attribute
**Changes**
As described in T93602, this patch removes all use of the `MVert`
struct, replacing it with a generic named attribute with the name
`"position"`, consistent with other geometry types.
Variable names have been changed from `verts` to `positions`, to align
with the attribute name and the more generic design (positions are not
vertices, they are just an attribute stored on the point domain).
This change is made possible by previous commits that moved all other
data out of `MVert` to runtime data or other generic attributes. What
remains is mostly a simple type change. Though, the type still shows up
859 times, so the patch is quite large.
One compromise is that now `CD_MASK_BAREMESH` now contains
`CD_PROP_FLOAT3`. With the general move towards generic attributes
over custom data types, we are removing use of these type masks anyway.
**Benefits**
The most obvious benefit is reduced memory usage and the benefits
that brings in memory-bound situations. `float3` is only 3 bytes, in
comparison to `MVert` which was 4. When there are millions of vertices
this starts to matter more.
The other benefits come from using a more generic type. Instead of
writing algorithms specifically for `MVert`, code can just use arrays
of vectors. This will allow eliminating many temporary arrays or
wrappers used to extract positions.
Many possible improvements aren't implemented in this patch, though
I did switch simplify or remove the process of creating temporary
position arrays in a few places.
The design clarity that "positions are just another attribute" brings
allows removing explicit copying of vertices in some procedural
operations-- they are just processed like most other attributes.
**Performance**
This touches so many areas that it's hard to benchmark exhaustively,
but I observed some areas as examples.
* The mesh line node with 4 million count was 1.5x (8ms to 12ms) faster.
* The Spring splash screen went from ~4.3 to ~4.5 fps.
* The subdivision surface modifier/node was slightly faster
RNA access through Python may be slightly slower, since now we need
a name lookup instead of just a custom data type lookup for each index.
**Future Improvements**
* Remove uses of "vert_coords" functions:
* `BKE_mesh_vert_coords_alloc`
* `BKE_mesh_vert_coords_get`
* `BKE_mesh_vert_coords_apply{_with_mat4}`
* Remove more hidden copying of positions
* General simplification now possible in many areas
* Convert more code to C++ to use `float3` instead of `float[3]`
* Currently `reinterpret_cast` is used for those C-API functions
Differential Revision: https://developer.blender.org/D15982
2023-01-10 06:10:43 +01:00
|
|
|
float (*vert_positions)[3];
|
2023-03-22 21:58:34 +01:00
|
|
|
blender::Span<MPoly> polys;
|
|
|
|
blender::Span<int> corner_verts;
|
2020-04-20 02:06:12 +02:00
|
|
|
|
|
|
|
/* These contain the vertex and poly counts of the final mesh. */
|
2012-02-05 05:11:34 +01:00
|
|
|
int totvert, totpoly;
|
2020-04-20 02:06:12 +02:00
|
|
|
|
2019-10-07 17:27:56 +02:00
|
|
|
struct KeyBlock *shapekey_active;
|
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
|
|
|
struct MPropCol *vcol;
|
2022-04-05 20:42:55 +02:00
|
|
|
struct MLoopCol *mcol;
|
|
|
|
|
2022-06-01 06:38:06 +02:00
|
|
|
eAttrDomain vcol_domain;
|
|
|
|
eCustomDataType vcol_type;
|
2022-04-05 20:42:55 +02:00
|
|
|
|
2012-05-10 22:34:47 +02:00
|
|
|
float *vmask;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
Sculpt: Expand Operator
Expand is a new operator for Sculpt Mode which is intended to be the main
tool for masking, Face Set editing, interacting with the filters and pattern
creation.
The fundamentals of the tool are similar to the previous sculpt.mask_expand
operator. It shares the same default shortcuts and functionality, making
the previous operator obsolete.
The shortcuts to execute the operator are:
- Shift + A: Expand mask
- Shift + Alt + A: Expand mask by normals
- Shift + W: Expand Face Set
- Shift + Alt + W: Resize current Face Set
The main changes compared to the previous sculpt.mask_expand operator are:
- Modal keymap, all operator options can be changed in real time while the
operator is running.
- Supports creating Mask, Face Sets and Sculpt Vertex Colors.
- Much better code, new features can be easily integrated.
Limitations:
- All Mask operations are supported for Sculpt Vertex colors, but not exposed
by default as their support is still experimental.
- Dyntopo does not support any Face Set or Sculpt Vertex Colors. functionality
(they are not implemented in general for Dyntopo).
- Multires does not support any feature related to geodesic distances.
- Multires does not support vertex colors.
- Multires does not support recursions.
- In Multires, Face Sets snaping does not initialize all current enabled Face
Sets when toggling snapping.
- In Multires, Face Sets are created at base mesh level (works by this by
design, like any other tool).
- Unlike the previous mask_expand operator, this one does not blur the mask
by default after finishing Expand as that does not fit the new design.
The mask can still be blurred by using the mask filter manually.
Reviewed By: JacquesLucke
Differential Revision: https://developer.blender.org/D10455
2021-03-01 23:37:48 +01:00
|
|
|
/* Mesh connectivity maps. */
|
|
|
|
/* Vertices to adjacent polys. */
|
2018-06-08 17:04:54 +02:00
|
|
|
struct MeshElemMap *pmap;
|
|
|
|
int *pmap_mem;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
Sculpt: Expand Operator
Expand is a new operator for Sculpt Mode which is intended to be the main
tool for masking, Face Set editing, interacting with the filters and pattern
creation.
The fundamentals of the tool are similar to the previous sculpt.mask_expand
operator. It shares the same default shortcuts and functionality, making
the previous operator obsolete.
The shortcuts to execute the operator are:
- Shift + A: Expand mask
- Shift + Alt + A: Expand mask by normals
- Shift + W: Expand Face Set
- Shift + Alt + W: Resize current Face Set
The main changes compared to the previous sculpt.mask_expand operator are:
- Modal keymap, all operator options can be changed in real time while the
operator is running.
- Supports creating Mask, Face Sets and Sculpt Vertex Colors.
- Much better code, new features can be easily integrated.
Limitations:
- All Mask operations are supported for Sculpt Vertex colors, but not exposed
by default as their support is still experimental.
- Dyntopo does not support any Face Set or Sculpt Vertex Colors. functionality
(they are not implemented in general for Dyntopo).
- Multires does not support any feature related to geodesic distances.
- Multires does not support vertex colors.
- Multires does not support recursions.
- In Multires, Face Sets snaping does not initialize all current enabled Face
Sets when toggling snapping.
- In Multires, Face Sets are created at base mesh level (works by this by
design, like any other tool).
- Unlike the previous mask_expand operator, this one does not blur the mask
by default after finishing Expand as that does not fit the new design.
The mask can still be blurred by using the mask filter manually.
Reviewed By: JacquesLucke
Differential Revision: https://developer.blender.org/D10455
2021-03-01 23:37:48 +01:00
|
|
|
/* Edges to adjacent polys. */
|
|
|
|
struct MeshElemMap *epmap;
|
|
|
|
int *epmap_mem;
|
|
|
|
|
|
|
|
/* Vertices to adjacent edges. */
|
|
|
|
struct MeshElemMap *vemap;
|
|
|
|
int *vemap_mem;
|
|
|
|
|
2020-03-05 14:53:23 +01:00
|
|
|
/* Mesh Face Sets */
|
2020-04-20 02:06:12 +02:00
|
|
|
/* Total number of polys of the base mesh. */
|
2020-04-01 01:03:20 +02:00
|
|
|
int totfaces;
|
2022-09-16 21:20:28 +02:00
|
|
|
|
2022-09-14 21:33:55 +02:00
|
|
|
/* The 0 ID is not used by the tools or the visibility system, it is just used when creating new
|
2021-05-14 03:07:18 +02:00
|
|
|
* geometry (the trim tool, for example) to detect which geometry was just added, so it can be
|
|
|
|
* assigned a valid Face Set after creation. Tools are not intended to run with Face Sets IDs set
|
|
|
|
* to 0. */
|
2020-03-05 14:53:23 +01:00
|
|
|
int *face_sets;
|
2022-09-14 21:33:55 +02:00
|
|
|
/**
|
|
|
|
* A reference to the ".hide_poly" attribute, to store whether (base) polygons are hidden.
|
|
|
|
* May be null.
|
|
|
|
*/
|
|
|
|
bool *hide_poly;
|
2020-03-05 14:53:23 +01:00
|
|
|
|
2012-12-30 19:27:33 +01:00
|
|
|
/* BMesh for dynamic topology sculpting */
|
|
|
|
struct BMesh *bm;
|
2014-04-07 09:00:08 +02:00
|
|
|
bool bm_smooth_shading;
|
2012-12-30 19:27:33 +01:00
|
|
|
/* Undo/redo log for dynamic topology sculpting */
|
|
|
|
struct BMLog *bm_log;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2018-09-14 10:56:54 +02:00
|
|
|
/* Limit surface/grids. */
|
|
|
|
struct SubdivCCG *subdiv_ccg;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2010-03-22 12:59:36 +01:00
|
|
|
/* PBVH acceleration structure */
|
|
|
|
struct PBVH *pbvh;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2014-08-13 01:33:46 +02:00
|
|
|
/* Painting on deformed mesh */
|
2020-07-01 05:12:24 +02:00
|
|
|
bool deform_modifiers_active; /* Object is deformed with some modifiers. */
|
|
|
|
float (*orig_cos)[3]; /* Coords of un-deformed mesh. */
|
|
|
|
float (*deform_cos)[3]; /* Coords of deformed mesh but without stroke displacement. */
|
|
|
|
float (*deform_imats)[3][3]; /* Crazy-space deformation matrices. */
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2022-06-22 19:34:16 +02:00
|
|
|
/* Pool for texture evaluations. */
|
2013-01-21 09:49:42 +01:00
|
|
|
struct ImagePool *tex_pool;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2009-08-28 23:47:11 +02:00
|
|
|
struct StrokeCache *cache;
|
2019-09-09 15:42:51 +02:00
|
|
|
struct FilterCache *filter_cache;
|
Sculpt: Expand Operator
Expand is a new operator for Sculpt Mode which is intended to be the main
tool for masking, Face Set editing, interacting with the filters and pattern
creation.
The fundamentals of the tool are similar to the previous sculpt.mask_expand
operator. It shares the same default shortcuts and functionality, making
the previous operator obsolete.
The shortcuts to execute the operator are:
- Shift + A: Expand mask
- Shift + Alt + A: Expand mask by normals
- Shift + W: Expand Face Set
- Shift + Alt + W: Resize current Face Set
The main changes compared to the previous sculpt.mask_expand operator are:
- Modal keymap, all operator options can be changed in real time while the
operator is running.
- Supports creating Mask, Face Sets and Sculpt Vertex Colors.
- Much better code, new features can be easily integrated.
Limitations:
- All Mask operations are supported for Sculpt Vertex colors, but not exposed
by default as their support is still experimental.
- Dyntopo does not support any Face Set or Sculpt Vertex Colors. functionality
(they are not implemented in general for Dyntopo).
- Multires does not support any feature related to geodesic distances.
- Multires does not support vertex colors.
- Multires does not support recursions.
- In Multires, Face Sets snaping does not initialize all current enabled Face
Sets when toggling snapping.
- In Multires, Face Sets are created at base mesh level (works by this by
design, like any other tool).
- Unlike the previous mask_expand operator, this one does not blur the mask
by default after finishing Expand as that does not fit the new design.
The mask can still be blurred by using the mask filter manually.
Reviewed By: JacquesLucke
Differential Revision: https://developer.blender.org/D10455
2021-03-01 23:37:48 +01:00
|
|
|
struct ExpandCache *expand_cache;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2019-08-30 16:27:31 +02:00
|
|
|
/* Cursor data and active vertex for tools */
|
2022-07-30 04:01:32 +02:00
|
|
|
PBVHVertRef active_vertex;
|
2019-08-14 22:54:23 +02:00
|
|
|
|
2020-04-01 17:51:59 +02:00
|
|
|
int active_face_index;
|
|
|
|
int active_grid_index;
|
|
|
|
|
2022-09-16 21:20:28 +02:00
|
|
|
/* When active, the cursor draws with faded colors, indicating that there is an action
|
|
|
|
* enabled.
|
2020-10-29 22:32:22 +01:00
|
|
|
*/
|
|
|
|
bool draw_faded_cursor;
|
2019-08-30 16:27:31 +02:00
|
|
|
float cursor_radius;
|
|
|
|
float cursor_location[3];
|
|
|
|
float cursor_normal[3];
|
2020-02-28 14:40:40 +01:00
|
|
|
float cursor_sampled_normal[3];
|
2019-08-30 16:27:31 +02:00
|
|
|
float cursor_view_normal[3];
|
2019-12-10 15:18:16 +01:00
|
|
|
|
2022-09-16 21:20:28 +02:00
|
|
|
/* For Sculpt trimming gesture tools, initial ray-cast data from the position of the mouse
|
|
|
|
* when
|
|
|
|
* the gesture starts (intersection with the surface and if they ray hit the surface or not).
|
|
|
|
*/
|
2020-10-15 19:13:29 +02:00
|
|
|
float gesture_initial_location[3];
|
2020-10-30 01:16:14 +01:00
|
|
|
float gesture_initial_normal[3];
|
2020-10-15 19:13:29 +02:00
|
|
|
bool gesture_initial_hit;
|
|
|
|
|
2021-02-05 06:23:34 +01:00
|
|
|
/* TODO(jbakker): Replace rv3d and v3d with ViewContext */
|
2019-08-30 16:27:31 +02:00
|
|
|
struct RegionView3D *rv3d;
|
2019-12-10 15:18:16 +01:00
|
|
|
struct View3D *v3d;
|
2020-06-26 21:57:19 +02:00
|
|
|
struct Scene *scene;
|
2019-08-30 16:27:31 +02:00
|
|
|
|
2019-09-09 22:23:54 +02:00
|
|
|
/* Dynamic mesh preview */
|
2022-07-30 04:01:32 +02:00
|
|
|
PBVHVertRef *preview_vert_list;
|
|
|
|
int preview_vert_count;
|
2020-01-07 16:46:56 +01:00
|
|
|
|
|
|
|
/* Pose Brush Preview */
|
2019-09-13 16:18:22 +02:00
|
|
|
float pose_origin[3];
|
2020-01-08 02:59:48 +01:00
|
|
|
SculptPoseIKChain *pose_ik_chain_preview;
|
2019-09-09 22:23:54 +02:00
|
|
|
|
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
|
|
|
/* Boundary Brush Preview */
|
|
|
|
SculptBoundary *boundary_preview;
|
|
|
|
|
2020-06-23 16:10:47 +02:00
|
|
|
SculptVertexInfo vertex_info;
|
|
|
|
SculptFakeNeighbors fake_neighbors;
|
|
|
|
|
2019-09-10 19:55:15 +02:00
|
|
|
/* Transform operator */
|
|
|
|
float pivot_pos[3];
|
|
|
|
float pivot_rot[4];
|
|
|
|
float pivot_scale[3];
|
|
|
|
|
|
|
|
float init_pivot_pos[3];
|
|
|
|
float init_pivot_rot[4];
|
|
|
|
float init_pivot_scale[3];
|
|
|
|
|
2022-06-04 04:21:04 +02:00
|
|
|
float prev_pivot_pos[3];
|
|
|
|
float prev_pivot_rot[4];
|
|
|
|
float prev_pivot_scale[3];
|
|
|
|
|
2017-09-27 17:38:17 +02:00
|
|
|
union {
|
|
|
|
struct {
|
|
|
|
struct SculptVertexPaintGeomMap gmap;
|
|
|
|
} vpaint;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2017-09-27 17:38:17 +02:00
|
|
|
struct {
|
|
|
|
struct SculptVertexPaintGeomMap gmap;
|
|
|
|
/* Keep track of how much each vertex has been painted (non-airbrush only). */
|
|
|
|
float *alpha_weight;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2017-10-03 09:50:34 +02:00
|
|
|
/* Needed to continuously re-apply over the same weights (BRUSH_ACCUMULATE disabled).
|
2017-10-01 12:12:14 +02:00
|
|
|
* Lazy initialize as needed (flag is set to 1 to tag it as uninitialized). */
|
|
|
|
struct MDeformVert *dvert_prev;
|
2017-09-27 17:38:17 +02:00
|
|
|
} wpaint;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2018-04-16 17:08:27 +02:00
|
|
|
/* TODO: identify sculpt-only fields */
|
|
|
|
// struct { ... } sculpt;
|
2017-09-27 17:38:17 +02:00
|
|
|
} mode;
|
2020-05-12 13:59:16 +02:00
|
|
|
eObjectMode mode_type;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2017-09-27 17:38:17 +02:00
|
|
|
/* This flag prevents PBVH from being freed when creating the vp_handle for texture paint. */
|
|
|
|
bool building_vp_handle;
|
2019-11-07 06:52:03 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* ID data is older than sculpt-mode data.
|
|
|
|
* Set #Main.is_memfile_undo_flush_needed when enabling.
|
|
|
|
*/
|
|
|
|
char needs_flush_to_id;
|
|
|
|
|
2022-09-16 21:20:28 +02:00
|
|
|
/* This is a fixed-size array so we can pass pointers to its elements
|
|
|
|
* to client code. This is important to keep bmesh offsets up to date.
|
|
|
|
*/
|
|
|
|
struct SculptAttribute temp_attributes[SCULPT_MAX_ATTRIBUTES];
|
|
|
|
|
2022-09-17 06:46:50 +02:00
|
|
|
/* Convenience #SculptAttribute pointers. */
|
2022-09-16 21:20:28 +02:00
|
|
|
SculptAttributePointers attrs;
|
|
|
|
|
2022-04-08 16:37:35 +02:00
|
|
|
/**
|
|
|
|
* Some tools follows the shading chosen by the last used tool canvas.
|
|
|
|
* When not set the viewport shading color would be used.
|
|
|
|
*
|
|
|
|
* NOTE: This setting is temporarily until paint mode is added.
|
|
|
|
*/
|
|
|
|
bool sticky_shading_color;
|
|
|
|
|
2022-09-29 08:21:56 +02:00
|
|
|
uchar stroke_id;
|
|
|
|
|
2022-04-15 16:39:50 +02:00
|
|
|
/**
|
|
|
|
* Last used painting canvas key.
|
|
|
|
*/
|
|
|
|
char *last_paint_canvas_key;
|
2022-09-29 08:21:56 +02:00
|
|
|
float last_normal[3];
|
2022-04-15 16:39:50 +02:00
|
|
|
|
2022-09-29 01:22:34 +02:00
|
|
|
int last_automasking_settings_hash;
|
2022-09-29 08:21:56 +02:00
|
|
|
uchar last_automask_stroke_id;
|
2023-01-20 01:53:43 +01:00
|
|
|
bool islands_valid; /* Is attrs.topology_island_key valid? */
|
2009-08-28 23:47:11 +02:00
|
|
|
} SculptSession;
|
|
|
|
|
2023-03-22 21:58:34 +01:00
|
|
|
#endif
|
|
|
|
|
2015-04-04 06:15:50 +02:00
|
|
|
void BKE_sculptsession_free(struct Object *ob);
|
|
|
|
void BKE_sculptsession_free_deformMats(struct SculptSession *ss);
|
2017-09-27 17:38:17 +02:00
|
|
|
void BKE_sculptsession_free_vwpaint_data(struct SculptSession *ss);
|
2014-05-07 01:59:23 +02:00
|
|
|
void BKE_sculptsession_bm_to_me(struct Object *ob, bool reorder);
|
|
|
|
void BKE_sculptsession_bm_to_me_for_render(struct Object *object);
|
2023-03-22 21:58:34 +01:00
|
|
|
int BKE_sculptsession_vertex_count(const struct SculptSession *ss);
|
2022-09-16 21:20:28 +02:00
|
|
|
|
2022-09-17 06:46:50 +02:00
|
|
|
/* Ensure an attribute layer exists. */
|
2022-09-16 21:20:28 +02:00
|
|
|
SculptAttribute *BKE_sculpt_attribute_ensure(struct Object *ob,
|
|
|
|
eAttrDomain domain,
|
|
|
|
eCustomDataType proptype,
|
|
|
|
const char *name,
|
|
|
|
const SculptAttributeParams *params);
|
|
|
|
|
|
|
|
/* Returns nullptr if attribute does not exist. */
|
|
|
|
SculptAttribute *BKE_sculpt_attribute_get(struct Object *ob,
|
|
|
|
eAttrDomain domain,
|
|
|
|
eCustomDataType proptype,
|
|
|
|
const char *name);
|
|
|
|
|
|
|
|
bool BKE_sculpt_attribute_exists(struct Object *ob,
|
|
|
|
eAttrDomain domain,
|
|
|
|
eCustomDataType proptype,
|
|
|
|
const char *name);
|
|
|
|
|
|
|
|
bool BKE_sculpt_attribute_destroy(struct Object *ob, SculptAttribute *attr);
|
|
|
|
|
2022-09-17 06:46:50 +02:00
|
|
|
/* Destroy all attributes and pseudo-attributes created by sculpt mode. */
|
2022-09-16 21:20:28 +02:00
|
|
|
void BKE_sculpt_attribute_destroy_temporary_all(struct Object *ob);
|
|
|
|
|
|
|
|
/* Destroy attributes that were marked as stroke only in SculptAttributeParams. */
|
|
|
|
void BKE_sculpt_attributes_destroy_temporary_stroke(struct Object *ob);
|
|
|
|
|
|
|
|
BLI_INLINE void *BKE_sculpt_vertex_attr_get(const PBVHVertRef vertex, const SculptAttribute *attr)
|
|
|
|
{
|
|
|
|
if (attr->data) {
|
|
|
|
char *p = (char *)attr->data;
|
|
|
|
int idx = (int)vertex.i;
|
|
|
|
|
|
|
|
if (attr->data_for_bmesh) {
|
|
|
|
BMElem *v = (BMElem *)vertex.i;
|
|
|
|
idx = v->head.index;
|
|
|
|
}
|
|
|
|
|
|
|
|
return p + attr->elem_size * (int)idx;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
BMElem *v = (BMElem *)vertex.i;
|
|
|
|
return BM_ELEM_CD_GET_VOID_P(v, attr->bmesh_cd_offset);
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
BLI_INLINE void *BKE_sculpt_face_attr_get(const PBVHFaceRef vertex, const SculptAttribute *attr)
|
|
|
|
{
|
|
|
|
if (attr->data) {
|
|
|
|
char *p = (char *)attr->data;
|
|
|
|
int idx = (int)vertex.i;
|
|
|
|
|
|
|
|
if (attr->data_for_bmesh) {
|
|
|
|
BMElem *v = (BMElem *)vertex.i;
|
|
|
|
idx = v->head.index;
|
|
|
|
}
|
|
|
|
|
|
|
|
return p + attr->elem_size * (int)idx;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
BMElem *v = (BMElem *)vertex.i;
|
|
|
|
return BM_ELEM_CD_GET_VOID_P(v, attr->bmesh_cd_offset);
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
2019-05-31 12:50:15 +02:00
|
|
|
|
2021-12-07 07:19:15 +01:00
|
|
|
/**
|
|
|
|
* Create new color layer on object if it doesn't have one and if experimental feature set has
|
|
|
|
* sculpt vertex color enabled. Returns truth if new layer has been added, false otherwise.
|
|
|
|
*/
|
2020-07-17 18:07:47 +02:00
|
|
|
void BKE_sculpt_color_layer_create_if_needed(struct Object *object);
|
|
|
|
|
2021-12-07 07:19:15 +01:00
|
|
|
/**
|
|
|
|
* \warning Expects a fully evaluated depsgraph.
|
|
|
|
*/
|
2019-05-31 12:50:15 +02:00
|
|
|
void BKE_sculpt_update_object_for_edit(struct Depsgraph *depsgraph,
|
|
|
|
struct Object *ob_orig,
|
|
|
|
bool need_pmap,
|
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
|
|
|
bool need_mask,
|
2022-06-30 08:11:24 +02:00
|
|
|
bool is_paint_tool);
|
2022-09-12 19:48:35 +02:00
|
|
|
void BKE_sculpt_update_object_before_eval(struct Object *ob_eval);
|
2019-05-31 12:50:15 +02:00
|
|
|
void BKE_sculpt_update_object_after_eval(struct Depsgraph *depsgraph, struct Object *ob_eval);
|
|
|
|
|
2021-12-07 07:19:15 +01:00
|
|
|
/**
|
|
|
|
* Sculpt mode handles multi-res differently from regular meshes, but only if
|
|
|
|
* it's the last modifier on the stack and it is not on the first level.
|
|
|
|
*/
|
2022-02-14 19:05:54 +01:00
|
|
|
struct MultiresModifierData *BKE_sculpt_multires_active(const struct Scene *scene,
|
|
|
|
struct Object *ob);
|
2022-09-12 19:48:35 +02:00
|
|
|
int *BKE_sculpt_face_sets_ensure(struct Mesh *mesh);
|
2022-09-14 21:33:55 +02:00
|
|
|
/**
|
|
|
|
* Create the attribute used to store face visibility and retrieve its data.
|
|
|
|
* Note that changes to the face visibility have to be propagated to other domains
|
|
|
|
* (see #SCULPT_visibility_sync_all_from_faces).
|
|
|
|
*/
|
|
|
|
bool *BKE_sculpt_hide_poly_ensure(struct Mesh *mesh);
|
2022-10-16 22:24:26 +02:00
|
|
|
|
2022-10-17 02:16:39 +02:00
|
|
|
/**
|
|
|
|
* Ensures a mask layer exists. If depsgraph and bmain are non-null,
|
|
|
|
* a mask doesn't exist and the object has a multi-resolution modifier
|
2022-10-16 22:24:26 +02:00
|
|
|
* then the scene depsgraph will be evaluated to update the runtime
|
|
|
|
* subdivision data.
|
|
|
|
*
|
2022-10-17 02:16:39 +02:00
|
|
|
* \note always call *before* #BKE_sculpt_update_object_for_edit.
|
2022-10-16 22:24:26 +02:00
|
|
|
*/
|
|
|
|
int BKE_sculpt_mask_layers_ensure(struct Depsgraph *depsgraph,
|
|
|
|
struct Main *bmain,
|
|
|
|
struct Object *ob,
|
|
|
|
struct MultiresModifierData *mmd);
|
2018-01-30 10:33:20 +01:00
|
|
|
void BKE_sculpt_toolsettings_data_ensure(struct Scene *scene);
|
2014-05-06 22:30:51 +02:00
|
|
|
|
2018-09-06 17:06:17 +02:00
|
|
|
struct PBVH *BKE_sculpt_object_pbvh_ensure(struct Depsgraph *depsgraph, struct Object *ob);
|
2018-06-08 17:04:54 +02:00
|
|
|
|
2019-03-07 15:27:31 +01:00
|
|
|
void BKE_sculpt_bvh_update_from_ccg(struct PBVH *pbvh, struct SubdivCCG *subdiv_ccg);
|
|
|
|
|
2022-09-16 21:20:28 +02:00
|
|
|
void BKE_sculpt_ensure_orig_mesh_data(struct Scene *scene, struct Object *object);
|
2022-09-14 21:33:55 +02:00
|
|
|
void BKE_sculpt_sync_face_visibility_to_grids(struct Mesh *mesh, struct SubdivCCG *subdiv_ccg);
|
2020-12-29 14:43:12 +01:00
|
|
|
|
2021-12-07 07:19:15 +01:00
|
|
|
/**
|
|
|
|
* Test if PBVH can be used directly for drawing, which is faster than
|
|
|
|
* drawing the mesh and all updates that come with it.
|
|
|
|
*/
|
2022-10-26 18:01:45 +02:00
|
|
|
bool BKE_sculptsession_use_pbvh_draw(const struct Object *ob, const struct RegionView3D *rv3d);
|
2019-05-31 14:04:16 +02:00
|
|
|
|
2014-05-06 22:30:51 +02:00
|
|
|
enum {
|
2014-05-07 01:59:23 +02:00
|
|
|
SCULPT_MASK_LAYER_CALC_VERT = (1 << 0),
|
2019-01-15 13:57:49 +01:00
|
|
|
SCULPT_MASK_LAYER_CALC_LOOP = (1 << 1),
|
2014-05-06 22:30:51 +02:00
|
|
|
};
|
2020-03-02 15:07:49 +01:00
|
|
|
|
2022-05-02 12:18:04 +02:00
|
|
|
/* paint_vertex.cc */
|
|
|
|
|
|
|
|
/**
|
2022-05-03 07:11:27 +02:00
|
|
|
* Fills the object's active color attribute layer with the fill color.
|
2022-05-02 12:18:04 +02:00
|
|
|
*
|
|
|
|
* \param[in] ob: The object.
|
|
|
|
* \param[in] fill_color: The fill color.
|
|
|
|
* \param[in] only_selected: Limit the fill to selected faces or vertices.
|
|
|
|
*
|
|
|
|
* \return #true if successful.
|
|
|
|
*/
|
|
|
|
bool BKE_object_attributes_active_color_fill(struct Object *ob,
|
|
|
|
const float fill_color[4],
|
|
|
|
bool only_selected);
|
|
|
|
|
2023-03-22 21:58:34 +01:00
|
|
|
/** C accessor for #Object::sculpt::pbvh. */
|
|
|
|
struct PBVH *BKE_object_sculpt_pbvh_get(struct Object *object);
|
|
|
|
bool BKE_object_sculpt_use_dyntopo(const struct Object *object);
|
|
|
|
void BKE_object_sculpt_dyntopo_smooth_shading_set(struct Object *object, bool value);
|
|
|
|
|
2022-04-13 14:27:19 +02:00
|
|
|
/* paint_canvas.cc */
|
2022-04-24 05:33:14 +02:00
|
|
|
|
2022-04-15 16:39:50 +02:00
|
|
|
/**
|
|
|
|
* Create a key that can be used to compare with previous ones to identify changes.
|
|
|
|
* The resulting 'string' is owned by the caller.
|
|
|
|
*/
|
|
|
|
char *BKE_paint_canvas_key_get(struct PaintModeSettings *settings, struct Object *ob);
|
|
|
|
|
|
|
|
bool BKE_paint_canvas_image_get(struct PaintModeSettings *settings,
|
|
|
|
struct Object *ob,
|
|
|
|
struct Image **r_image,
|
|
|
|
struct ImageUser **r_image_user);
|
2022-04-13 14:27:19 +02:00
|
|
|
int BKE_paint_canvas_uvmap_layer_index_get(const struct PaintModeSettings *settings,
|
|
|
|
struct Object *ob);
|
2022-09-29 01:22:34 +02:00
|
|
|
void BKE_sculpt_check_cavity_curves(struct Sculpt *sd);
|
|
|
|
struct CurveMapping *BKE_sculpt_default_cavity_curve(void);
|
2022-04-13 14:27:19 +02:00
|
|
|
|
2020-03-02 15:07:49 +01:00
|
|
|
#ifdef __cplusplus
|
|
|
|
}
|
|
|
|
#endif
|