BKE_brush.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2023 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once

 
#include <optional>
 
#include "BLI_span.hh"
 
#include "DNA_brush_enums.h"
#include "DNA_color_types.h"
#include "DNA_object_enums.h"
#include "DNA_userdef_enums.h"
 
enum class PaintMode : int8_t;
struct Brush;
struct ImBuf;
struct ImagePool;
struct Main;
struct MTex;
struct Paint;
struct Scene;
struct UnifiedPaintSettings;
 
/* Globals for brush execution. */
 
void BKE_brush_system_init();
void BKE_brush_system_exit();
 
/* Data-block functions. */

Brush *BKE_brush_add(Main *bmain, const char *name, eObjectMode ob_mode);
bool BKE_brush_delete(Main *bmain, Brush *brush);

Brush *BKE_brush_duplicate(Main *bmain,
                           Brush *brush,
                           eDupli_ID_Flags dupflag,
                           /*eLibIDDuplicateFlags*/ uint duplicate_options);
void BKE_brush_init_gpencil_settings(Brush *brush);
 
void BKE_brush_init_curves_sculpt_settings(Brush *brush);

void BKE_brush_tag_unsaved_changes(Brush *brush);
 
Brush *BKE_brush_first_search(Main *bmain, eObjectMode ob_mode);
 
void BKE_brush_jitter_pos(const Scene &scene,
                          const Brush &brush,
                          const float pos[2],
                          float jitterpos[2]);
void BKE_brush_randomize_texture_coords(UnifiedPaintSettings *ups, bool mask);
 
/* Brush curve. */

void BKE_brush_curve_preset(Brush *b, eCurveMappingPreset preset);

void BKE_brush_calc_curve_factors(eBrushCurvePreset preset,
                                  const CurveMapping *cumap,
                                  blender::Span<float> distances,
                                  float brush_radius,
                                  blender::MutableSpan<float> factors);
float BKE_brush_curve_strength_clamped(const Brush *br, float p, float len);
float BKE_brush_curve_strength(eBrushCurvePreset preset,
                               const CurveMapping *cumap,
                               float distance,
                               float brush_radius);
float BKE_brush_curve_strength(const Brush *br, float p, float len);
 
/* Sampling. */

float BKE_brush_sample_tex_3d(const Scene *scene,
                              const Brush *br,
                              const MTex *mtex,
                              const float point[3],
                              float rgba[4],
                              int thread,
                              ImagePool *pool);
float BKE_brush_sample_masktex(
    const Scene *scene, Brush *br, const float point[2], int thread, ImagePool *pool);

const MTex *BKE_brush_mask_texture_get(const Brush *brush, eObjectMode object_mode);

const MTex *BKE_brush_color_texture_get(const Brush *brush, eObjectMode object_mode);

ImBuf *BKE_brush_gen_radial_control_imbuf(Brush *br, bool secondary, bool display_gradient);
 
/* Unified strength size and color. */
 
struct BrushColorJitterSettings {
  int flag;
  float hue;
  float saturation;
  float value;

  CurveMapping *curve_hue_jitter;
  CurveMapping *curve_sat_jitter;
  CurveMapping *curve_val_jitter;
};
 
const float *BKE_brush_color_get(const Scene *scene, const Paint *paint, const Brush *brush);
const std::optional<BrushColorJitterSettings> BKE_brush_color_jitter_get_settings(
    const Scene *scene, const Paint *paint, const Brush *brush);
const float *BKE_brush_secondary_color_get(const Scene *scene,
                                           const Paint *paint,
                                           const Brush *brush);
void BKE_brush_color_set(Scene *scene, const Paint *paint, Brush *brush, const float color[3]);
 
int BKE_brush_size_get(const Scene *scene, const Brush *brush);
void BKE_brush_size_set(Scene *scene, Brush *brush, int size);
 
float BKE_brush_unprojected_radius_get(const Scene *scene, const Brush *brush);
void BKE_brush_unprojected_radius_set(Scene *scene, Brush *brush, float unprojected_radius);
 
float BKE_brush_alpha_get(const Scene *scene, const Brush *brush);
void BKE_brush_alpha_set(Scene *scene, Brush *brush, float alpha);
float BKE_brush_weight_get(const Scene *scene, const Brush *brush);
void BKE_brush_weight_set(const Scene *scene, Brush *brush, float value);
 
int BKE_brush_input_samples_get(const Scene *scene, const Brush *brush);
void BKE_brush_input_samples_set(const Scene *scene, Brush *brush, int value);
 
bool BKE_brush_use_locked_size(const Scene *scene, const Brush *brush);
bool BKE_brush_use_alpha_pressure(const Brush *brush);
bool BKE_brush_use_size_pressure(const Brush *brush);

void BKE_brush_scale_unprojected_radius(float *unprojected_radius,
                                        int new_brush_size,
                                        int old_brush_size);

void BKE_brush_scale_size(int *r_brush_size,
                          float new_unprojected_radius,
                          float old_unprojected_radius);
 
/* Returns true if a brush requires a cube
 * (often presented to the user as a square) tip inside a specific paint mode.
 */
bool BKE_brush_has_cube_tip(const Brush *brush, PaintMode paint_mode);
 
/* debugging only */
void BKE_brush_debug_print_state(Brush *br);
 
/* -------------------------------------------------------------------- */
 
namespace blender::bke::brush {
bool supports_dyntopo(const Brush &brush);
bool supports_accumulate(const Brush &brush);
bool supports_topology_rake(const Brush &brush);
bool supports_auto_smooth(const Brush &brush);
bool supports_height(const Brush &brush);
bool supports_plane_height(const Brush &brush);
bool supports_plane_depth(const Brush &brush);
bool supports_jitter(const Brush &brush);
bool supports_normal_weight(const Brush &brush);
bool supports_rake_factor(const Brush &brush);
bool supports_persistence(const Brush &brush);
bool supports_pinch_factor(const Brush &brush);
bool supports_plane_offset(const Brush &brush);
bool supports_random_texture_angle(const Brush &brush);
bool supports_sculpt_plane(const Brush &brush);
bool supports_color(const Brush &brush);
bool supports_secondary_cursor_color(const Brush &brush);
bool supports_smooth_stroke(const Brush &brush);
bool supports_space_attenuation(const Brush &brush);
bool supports_strength_pressure(const Brush &brush);
bool supports_inverted_direction(const Brush &brush);
bool supports_gravity(const Brush &brush);
bool supports_tilt(const Brush &brush);
}  // namespace blender::bke::brush