forked from bartvdbraak/blender
code cleanup: brush/camera naming
This commit is contained in:
parent
4c5502bfd6
commit
084fedd03a
@ -41,34 +41,34 @@ struct wmOperator;
|
||||
// enum CurveMappingPreset;
|
||||
|
||||
/* datablock functions */
|
||||
struct Brush *add_brush(const char *name);
|
||||
struct Brush *copy_brush(struct Brush *brush);
|
||||
void make_local_brush(struct Brush *brush);
|
||||
void free_brush(struct Brush *brush);
|
||||
struct Brush *BKE_brush_add(const char *name);
|
||||
struct Brush *BKE_brush_copy(struct Brush *brush);
|
||||
void BKE_brush_make_local(struct Brush *brush);
|
||||
void BKE_brush_free(struct Brush *brush);
|
||||
|
||||
void brush_reset_sculpt(struct Brush *brush);
|
||||
void BKE_brush_sculpt_reset(struct Brush *brush);
|
||||
|
||||
/* image icon function */
|
||||
struct ImBuf *get_brush_icon(struct Brush *brush);
|
||||
|
||||
/* brush library operations used by different paint panels */
|
||||
int brush_texture_set_nr(struct Brush *brush, int nr);
|
||||
int brush_texture_delete(struct Brush *brush);
|
||||
int brush_clone_image_set_nr(struct Brush *brush, int nr);
|
||||
int brush_clone_image_delete(struct Brush *brush);
|
||||
int BKE_brush_texture_set_nr(struct Brush *brush, int nr);
|
||||
int BKE_brush_texture_delete(struct Brush *brush);
|
||||
int BKE_brush_clone_image_set_nr(struct Brush *brush, int nr);
|
||||
int BKE_brush_clone_image_delete(struct Brush *brush);
|
||||
|
||||
/* jitter */
|
||||
void brush_jitter_pos(const struct Scene *scene, struct Brush *brush,
|
||||
void BKE_brush_jitter_pos(const struct Scene *scene, struct Brush *brush,
|
||||
const float pos[2], float jitterpos[2]);
|
||||
|
||||
/* brush curve */
|
||||
void brush_curve_preset(struct Brush *b, /*enum CurveMappingPreset*/int preset);
|
||||
float brush_curve_strength_clamp(struct Brush *br, float p, const float len);
|
||||
float brush_curve_strength(struct Brush *br, float p, const float len); /* used for sculpt */
|
||||
void BKE_brush_curve_preset(struct Brush *b, /*enum CurveMappingPreset*/int preset);
|
||||
float BKE_brush_curve_strength_clamp(struct Brush *br, float p, const float len);
|
||||
float BKE_brush_curve_strength(struct Brush *br, float p, const float len); /* used for sculpt */
|
||||
|
||||
/* sampling */
|
||||
void brush_sample_tex(const struct Scene *scene, struct Brush *brush, const float xy[2], float rgba[4], const int thread);
|
||||
void brush_imbuf_new(const struct Scene *scene, struct Brush *brush, short flt, short texfalloff, int size,
|
||||
void BKE_brush_sample_tex(const struct Scene *scene, struct Brush *brush, const float xy[2], float rgba[4], const int thread);
|
||||
void BKE_brush_imbuf_new(const struct Scene *scene, struct Brush *brush, short flt, short texfalloff, int size,
|
||||
struct ImBuf **imbuf, int use_color_correction);
|
||||
|
||||
/* painting */
|
||||
@ -76,48 +76,48 @@ struct BrushPainter;
|
||||
typedef struct BrushPainter BrushPainter;
|
||||
typedef int (*BrushFunc)(void *user, struct ImBuf *ibuf, const float lastpos[2], const float pos[2]);
|
||||
|
||||
BrushPainter *brush_painter_new(struct Scene *scene, struct Brush *brush);
|
||||
void brush_painter_require_imbuf(BrushPainter *painter, short flt,
|
||||
BrushPainter *BKE_brush_painter_new(struct Scene *scene, struct Brush *brush);
|
||||
void BKE_brush_painter_require_imbuf(BrushPainter *painter, short flt,
|
||||
short texonly, int size);
|
||||
int brush_painter_paint(BrushPainter *painter, BrushFunc func, const float pos[2],
|
||||
int BKE_brush_painter_paint(BrushPainter *painter, BrushFunc func, const float pos[2],
|
||||
double time, float pressure, void *user, int use_color_correction);
|
||||
void brush_painter_break_stroke(BrushPainter *painter);
|
||||
void brush_painter_free(BrushPainter *painter);
|
||||
void BKE_brush_painter_break_stroke(BrushPainter *painter);
|
||||
void BKE_brush_painter_free(BrushPainter *painter);
|
||||
|
||||
/* texture */
|
||||
unsigned int *brush_gen_texture_cache(struct Brush *br, int half_side);
|
||||
unsigned int *BKE_brush_gen_texture_cache(struct Brush *br, int half_side);
|
||||
|
||||
/* radial control */
|
||||
struct ImBuf *brush_gen_radial_control_imbuf(struct Brush *br);
|
||||
struct ImBuf *BKE_brush_gen_radial_control_imbuf(struct Brush *br);
|
||||
|
||||
/* unified strength and size */
|
||||
|
||||
int brush_size(const struct Scene *scene, struct Brush *brush);
|
||||
void brush_set_size(struct Scene *scene, struct Brush *brush, int value);
|
||||
int BKE_brush_size_get(const struct Scene *scene, struct Brush *brush);
|
||||
void BKE_brush_size_set(struct Scene *scene, struct Brush *brush, int value);
|
||||
|
||||
float brush_unprojected_radius(const struct Scene *scene, struct Brush *brush);
|
||||
void brush_set_unprojected_radius(struct Scene *scene, struct Brush *brush, float value);
|
||||
float BKE_brush_unprojected_radius_get(const struct Scene *scene, struct Brush *brush);
|
||||
void BKE_brush_unprojected_radius_set(struct Scene *scene, struct Brush *brush, float value);
|
||||
|
||||
float brush_alpha(const struct Scene *scene, struct Brush *brush);
|
||||
float brush_weight(const Scene *scene, struct Brush *brush);
|
||||
void brush_set_weight(const Scene *scene, struct Brush *brush, float value);
|
||||
float BKE_brush_alpha_get(const struct Scene *scene, struct Brush *brush);
|
||||
float BKE_brush_weight_get(const Scene *scene, struct Brush *brush);
|
||||
void BKE_brush_weight_set(const Scene *scene, struct Brush *brush, float value);
|
||||
|
||||
int brush_use_locked_size(const struct Scene *scene, struct Brush *brush);
|
||||
int brush_use_alpha_pressure(const struct Scene *scene, struct Brush *brush);
|
||||
int brush_use_size_pressure(const struct Scene *scene, struct Brush *brush);
|
||||
int BKE_brush_use_locked_size(const struct Scene *scene, struct Brush *brush);
|
||||
int BKE_brush_use_alpha_pressure(const struct Scene *scene, struct Brush *brush);
|
||||
int BKE_brush_use_size_pressure(const struct Scene *scene, struct Brush *brush);
|
||||
|
||||
/* scale unprojected radius to reflect a change in the brush's 2D size */
|
||||
void brush_scale_unprojected_radius(float *unprojected_radius,
|
||||
void BKE_brush_scale_unprojected_radius(float *unprojected_radius,
|
||||
int new_brush_size,
|
||||
int old_brush_size);
|
||||
|
||||
/* scale brush size to reflect a change in the brush's unprojected radius */
|
||||
void brush_scale_size(int *brush_size,
|
||||
void BKE_brush_scale_size(int *BKE_brush_size_get,
|
||||
float new_unprojected_radius,
|
||||
float old_unprojected_radius);
|
||||
|
||||
/* debugging only */
|
||||
void brush_debug_print_state(struct Brush *br);
|
||||
void BKE_brush_debug_print_state(struct Brush *br);
|
||||
|
||||
#endif
|
||||
|
||||
|
@ -48,18 +48,18 @@ struct View3D;
|
||||
|
||||
/* Camera Datablock */
|
||||
|
||||
void *add_camera(const char *name);
|
||||
struct Camera *copy_camera(struct Camera *cam);
|
||||
void make_local_camera(struct Camera *cam);
|
||||
void free_camera(struct Camera *ca);
|
||||
void *BKE_camera_add(const char *name);
|
||||
struct Camera *BKE_camera_copy(struct Camera *cam);
|
||||
void BKE_camera_make_local(struct Camera *cam);
|
||||
void BKE_camera_free(struct Camera *ca);
|
||||
|
||||
/* Camera Usage */
|
||||
|
||||
float object_camera_dof_distance(struct Object *ob);
|
||||
void object_camera_mode(struct RenderData *rd, struct Object *ob);
|
||||
float BKE_camera_object_dof_distance(struct Object *ob);
|
||||
void BKE_camera_object_mode(struct RenderData *rd, struct Object *ob);
|
||||
|
||||
int camera_sensor_fit(int sensor_fit, float sizex, float sizey);
|
||||
float camera_sensor_size(int sensor_fit, float sensor_x, float sensor_y);
|
||||
int BKE_camera_sensor_fit(int sensor_fit, float sizex, float sizey);
|
||||
float BKE_camera_sensor_size(int sensor_fit, float sensor_x, float sensor_y);
|
||||
|
||||
/* Camera Parameters:
|
||||
*
|
||||
@ -102,21 +102,21 @@ typedef struct CameraParams {
|
||||
float winmat[4][4];
|
||||
} CameraParams;
|
||||
|
||||
void camera_params_init(CameraParams *params);
|
||||
void camera_params_from_object(CameraParams *params, struct Object *camera);
|
||||
void camera_params_from_view3d(CameraParams *params, struct View3D *v3d, struct RegionView3D *rv3d);
|
||||
void BKE_camera_params_init(CameraParams *params);
|
||||
void BKE_camera_params_from_object(CameraParams *params, struct Object *camera);
|
||||
void BKE_camera_params_from_view3d(CameraParams *params, struct View3D *v3d, struct RegionView3D *rv3d);
|
||||
|
||||
void camera_params_compute_viewplane(CameraParams *params, int winx, int winy, float aspx, float aspy);
|
||||
void camera_params_compute_matrix(CameraParams *params);
|
||||
void BKE_camera_params_compute_viewplane(CameraParams *params, int winx, int winy, float aspx, float aspy);
|
||||
void BKE_camera_params_compute_matrix(CameraParams *params);
|
||||
|
||||
/* Camera View Frame */
|
||||
|
||||
void camera_view_frame_ex(struct Scene *scene, struct Camera *camera, float drawsize, const short do_clip, const float scale[3],
|
||||
void BKE_camera_view_frame_ex(struct Scene *scene, struct Camera *camera, float drawsize, const short do_clip, const float scale[3],
|
||||
float r_asp[2], float r_shift[2], float *r_drawsize, float r_vec[4][3]);
|
||||
|
||||
void camera_view_frame(struct Scene *scene, struct Camera *camera, float r_vec[4][3]);
|
||||
void BKE_camera_view_frame(struct Scene *scene, struct Camera *camera, float r_vec[4][3]);
|
||||
|
||||
int camera_view_frame_fit_to_scene(
|
||||
int BKE_camera_view_frame_fit_to_scene(
|
||||
struct Scene *scene, struct View3D *v3d, struct Object *camera_ob,
|
||||
float r_co[3]);
|
||||
|
||||
|
@ -67,7 +67,7 @@
|
||||
#include "RE_render_ext.h" /* externtex */
|
||||
#include "RE_shader_ext.h"
|
||||
|
||||
static void brush_set_defaults(Brush *brush)
|
||||
static void brush_defaults(Brush *brush)
|
||||
{
|
||||
brush->blend = 0;
|
||||
brush->flag = 0;
|
||||
@ -122,7 +122,7 @@ static void brush_set_defaults(Brush *brush)
|
||||
|
||||
/* Datablock add/copy/free/make_local */
|
||||
|
||||
Brush *add_brush(const char *name)
|
||||
Brush *BKE_brush_add(const char *name)
|
||||
{
|
||||
Brush *brush;
|
||||
|
||||
@ -131,17 +131,17 @@ Brush *add_brush(const char *name)
|
||||
/* enable fake user by default */
|
||||
brush->id.flag |= LIB_FAKEUSER;
|
||||
|
||||
brush_set_defaults(brush);
|
||||
brush_defaults(brush);
|
||||
|
||||
brush->sculpt_tool = SCULPT_TOOL_DRAW; /* sculpting defaults to the draw tool for new brushes */
|
||||
|
||||
/* the default alpha falloff curve */
|
||||
brush_curve_preset(brush, CURVE_PRESET_SMOOTH);
|
||||
BKE_brush_curve_preset(brush, CURVE_PRESET_SMOOTH);
|
||||
|
||||
return brush;
|
||||
}
|
||||
|
||||
Brush *copy_brush(Brush *brush)
|
||||
Brush *BKE_brush_copy(Brush *brush)
|
||||
{
|
||||
Brush *brushn;
|
||||
|
||||
@ -167,7 +167,7 @@ Brush *copy_brush(Brush *brush)
|
||||
}
|
||||
|
||||
/* not brush itself */
|
||||
void free_brush(Brush *brush)
|
||||
void BKE_brush_free(Brush *brush)
|
||||
{
|
||||
if (brush->mtex.tex)
|
||||
brush->mtex.tex->id.us--;
|
||||
@ -186,7 +186,7 @@ static void extern_local_brush(Brush *brush)
|
||||
id_lib_extern((ID *)brush->clone.image);
|
||||
}
|
||||
|
||||
void make_local_brush(Brush *brush)
|
||||
void BKE_brush_make_local(Brush *brush)
|
||||
{
|
||||
|
||||
/* - only lib users: do nothing
|
||||
@ -225,7 +225,7 @@ void make_local_brush(Brush *brush)
|
||||
}
|
||||
}
|
||||
else if (is_local && is_lib) {
|
||||
Brush *brush_new= copy_brush(brush);
|
||||
Brush *brush_new= BKE_brush_copy(brush);
|
||||
brush_new->id.us= 1; /* only keep fake user */
|
||||
brush_new->id.flag |= LIB_FAKEUSER;
|
||||
|
||||
@ -242,11 +242,11 @@ void make_local_brush(Brush *brush)
|
||||
}
|
||||
}
|
||||
|
||||
void brush_debug_print_state(Brush *br)
|
||||
void BKE_brush_debug_print_state(Brush *br)
|
||||
{
|
||||
/* create a fake brush and set it to the defaults */
|
||||
Brush def= {{NULL}};
|
||||
brush_set_defaults(&def);
|
||||
brush_defaults(&def);
|
||||
|
||||
#define BR_TEST(field, t) \
|
||||
if (br->field != def.field) \
|
||||
@ -329,14 +329,14 @@ void brush_debug_print_state(Brush *br)
|
||||
#undef BR_TEST_FLAG
|
||||
}
|
||||
|
||||
void brush_reset_sculpt(Brush *br)
|
||||
void BKE_brush_sculpt_reset(Brush *br)
|
||||
{
|
||||
/* enable this to see any non-default
|
||||
* settings used by a brush: */
|
||||
// brush_debug_print_state(br);
|
||||
// BKE_brush_debug_print_state(br);
|
||||
|
||||
brush_set_defaults(br);
|
||||
brush_curve_preset(br, CURVE_PRESET_SMOOTH);
|
||||
brush_defaults(br);
|
||||
BKE_brush_curve_preset(br, CURVE_PRESET_SMOOTH);
|
||||
|
||||
switch (br->sculpt_tool) {
|
||||
case SCULPT_TOOL_CLAY:
|
||||
@ -409,7 +409,7 @@ void brush_reset_sculpt(Brush *br)
|
||||
}
|
||||
|
||||
/* Library Operations */
|
||||
void brush_curve_preset(Brush *b, /*CurveMappingPreset*/int preset)
|
||||
void BKE_brush_curve_preset(Brush *b, /*CurveMappingPreset*/int preset)
|
||||
{
|
||||
CurveMap *cm = NULL;
|
||||
|
||||
@ -424,7 +424,7 @@ void brush_curve_preset(Brush *b, /*CurveMappingPreset*/int preset)
|
||||
curvemapping_changed(b->curve, 0);
|
||||
}
|
||||
|
||||
int brush_texture_set_nr(Brush *brush, int nr)
|
||||
int BKE_brush_texture_set_nr(Brush *brush, int nr)
|
||||
{
|
||||
ID *idtest, *id=NULL;
|
||||
|
||||
@ -437,7 +437,7 @@ int brush_texture_set_nr(Brush *brush, int nr)
|
||||
idtest->us--;
|
||||
}
|
||||
if (idtest!=id) {
|
||||
brush_texture_delete(brush);
|
||||
BKE_brush_texture_delete(brush);
|
||||
|
||||
brush->mtex.tex= (Tex*)idtest;
|
||||
id_us_plus(idtest);
|
||||
@ -448,7 +448,7 @@ int brush_texture_set_nr(Brush *brush, int nr)
|
||||
return 0;
|
||||
}
|
||||
|
||||
int brush_texture_delete(Brush *brush)
|
||||
int BKE_brush_texture_delete(Brush *brush)
|
||||
{
|
||||
if (brush->mtex.tex)
|
||||
brush->mtex.tex->id.us--;
|
||||
@ -456,13 +456,13 @@ int brush_texture_delete(Brush *brush)
|
||||
return 1;
|
||||
}
|
||||
|
||||
int brush_clone_image_set_nr(Brush *brush, int nr)
|
||||
int BKE_brush_clone_image_set_nr(Brush *brush, int nr)
|
||||
{
|
||||
if (brush && nr > 0) {
|
||||
Image *ima= (Image*)BLI_findlink(&G.main->image, nr-1);
|
||||
|
||||
if (ima) {
|
||||
brush_clone_image_delete(brush);
|
||||
BKE_brush_clone_image_delete(brush);
|
||||
brush->clone.image= ima;
|
||||
id_us_plus(&ima->id);
|
||||
brush->clone.offset[0]= brush->clone.offset[1]= 0.0f;
|
||||
@ -474,7 +474,7 @@ int brush_clone_image_set_nr(Brush *brush, int nr)
|
||||
return 0;
|
||||
}
|
||||
|
||||
int brush_clone_image_delete(Brush *brush)
|
||||
int BKE_brush_clone_image_delete(Brush *brush)
|
||||
{
|
||||
if (brush && brush->clone.image) {
|
||||
brush->clone.image->id.us--;
|
||||
@ -486,14 +486,14 @@ int brush_clone_image_delete(Brush *brush)
|
||||
}
|
||||
|
||||
/* Brush Sampling */
|
||||
void brush_sample_tex(const Scene *scene, Brush *brush, const float xy[2], float rgba[4], const int thread)
|
||||
void BKE_brush_sample_tex(const Scene *scene, Brush *brush, const float xy[2], float rgba[4], const int thread)
|
||||
{
|
||||
MTex *mtex= &brush->mtex;
|
||||
|
||||
if (mtex && mtex->tex) {
|
||||
float co[3], tin, tr, tg, tb, ta;
|
||||
int hasrgb;
|
||||
const int radius= brush_size(scene, brush);
|
||||
const int radius= BKE_brush_size_get(scene, brush);
|
||||
|
||||
co[0]= xy[0]/radius;
|
||||
co[1]= xy[1]/radius;
|
||||
@ -520,14 +520,14 @@ void brush_sample_tex(const Scene *scene, Brush *brush, const float xy[2], float
|
||||
}
|
||||
|
||||
/* TODO, use define for 'texfall' arg */
|
||||
void brush_imbuf_new(const Scene *scene, Brush *brush, short flt, short texfall, int bufsize, ImBuf **outbuf, int use_color_correction)
|
||||
void BKE_brush_imbuf_new(const Scene *scene, Brush *brush, short flt, short texfall, int bufsize, ImBuf **outbuf, int use_color_correction)
|
||||
{
|
||||
ImBuf *ibuf;
|
||||
float xy[2], rgba[4], *dstf;
|
||||
int x, y, rowbytes, xoff, yoff, imbflag;
|
||||
const int radius= brush_size(scene, brush);
|
||||
const int radius= BKE_brush_size_get(scene, brush);
|
||||
unsigned char *dst, crgb[3];
|
||||
const float alpha= brush_alpha(scene, brush);
|
||||
const float alpha= BKE_brush_alpha_get(scene, brush);
|
||||
float brush_rgb[3];
|
||||
|
||||
imbflag= (flt)? IB_rectfloat: IB_rect;
|
||||
@ -555,15 +555,15 @@ void brush_imbuf_new(const Scene *scene, Brush *brush, short flt, short texfall,
|
||||
|
||||
if (texfall == 0) {
|
||||
copy_v3_v3(dstf, brush_rgb);
|
||||
dstf[3]= alpha*brush_curve_strength_clamp(brush, len_v2(xy), radius);
|
||||
dstf[3]= alpha*BKE_brush_curve_strength_clamp(brush, len_v2(xy), radius);
|
||||
}
|
||||
else if (texfall == 1) {
|
||||
brush_sample_tex(scene, brush, xy, dstf, 0);
|
||||
BKE_brush_sample_tex(scene, brush, xy, dstf, 0);
|
||||
}
|
||||
else {
|
||||
brush_sample_tex(scene, brush, xy, rgba, 0);
|
||||
BKE_brush_sample_tex(scene, brush, xy, rgba, 0);
|
||||
mul_v3_v3v3(dstf, rgba, brush_rgb);
|
||||
dstf[3] = rgba[3]*alpha*brush_curve_strength_clamp(brush, len_v2(xy), radius);
|
||||
dstf[3] = rgba[3]*alpha*BKE_brush_curve_strength_clamp(brush, len_v2(xy), radius);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -580,7 +580,7 @@ void brush_imbuf_new(const Scene *scene, Brush *brush, short flt, short texfall,
|
||||
xy[1] = y + yoff;
|
||||
|
||||
if (texfall == 0) {
|
||||
alpha_f = alpha * brush_curve_strength(brush, len_v2(xy), radius);
|
||||
alpha_f = alpha * BKE_brush_curve_strength(brush, len_v2(xy), radius);
|
||||
|
||||
dst[0] = crgb[0];
|
||||
dst[1] = crgb[1];
|
||||
@ -588,21 +588,21 @@ void brush_imbuf_new(const Scene *scene, Brush *brush, short flt, short texfall,
|
||||
dst[3] = FTOCHAR(alpha_f);
|
||||
}
|
||||
else if (texfall == 1) {
|
||||
brush_sample_tex(scene, brush, xy, rgba, 0);
|
||||
BKE_brush_sample_tex(scene, brush, xy, rgba, 0);
|
||||
rgba_float_to_uchar(dst, rgba);
|
||||
}
|
||||
else if (texfall == 2) {
|
||||
brush_sample_tex(scene, brush, xy, rgba, 0);
|
||||
BKE_brush_sample_tex(scene, brush, xy, rgba, 0);
|
||||
mul_v3_v3(rgba, brush->rgb);
|
||||
alpha_f = rgba[3] * alpha * brush_curve_strength_clamp(brush, len_v2(xy), radius);
|
||||
alpha_f = rgba[3] * alpha * BKE_brush_curve_strength_clamp(brush, len_v2(xy), radius);
|
||||
|
||||
rgb_float_to_uchar(dst, rgba);
|
||||
|
||||
dst[3] = FTOCHAR(alpha_f);
|
||||
}
|
||||
else {
|
||||
brush_sample_tex(scene, brush, xy, rgba, 0);
|
||||
alpha_f = rgba[3] * alpha * brush_curve_strength_clamp(brush, len_v2(xy), radius);
|
||||
BKE_brush_sample_tex(scene, brush, xy, rgba, 0);
|
||||
alpha_f = rgba[3] * alpha * BKE_brush_curve_strength_clamp(brush, len_v2(xy), radius);
|
||||
|
||||
dst[0] = crgb[0];
|
||||
dst[1] = crgb[1];
|
||||
@ -631,7 +631,7 @@ void brush_imbuf_new(const Scene *scene, Brush *brush, short flt, short texfall,
|
||||
// In anycase, a better solution is needed to prevent
|
||||
// inconsistency.
|
||||
|
||||
void brush_set_size(Scene *scene, Brush *brush, int size)
|
||||
void BKE_brush_size_set(Scene *scene, Brush *brush, int size)
|
||||
{
|
||||
UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
|
||||
|
||||
@ -641,14 +641,14 @@ void brush_set_size(Scene *scene, Brush *brush, int size)
|
||||
brush->size= size;
|
||||
}
|
||||
|
||||
int brush_size(const Scene *scene, Brush *brush)
|
||||
int BKE_brush_size_get(const Scene *scene, Brush *brush)
|
||||
{
|
||||
UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
|
||||
|
||||
return (ups->flag & UNIFIED_PAINT_SIZE) ? ups->size : brush->size;
|
||||
}
|
||||
|
||||
int brush_use_locked_size(const Scene *scene, Brush *brush)
|
||||
int BKE_brush_use_locked_size(const Scene *scene, Brush *brush)
|
||||
{
|
||||
const short us_flag = scene->toolsettings->unified_paint_settings.flag;
|
||||
|
||||
@ -657,7 +657,7 @@ int brush_use_locked_size(const Scene *scene, Brush *brush)
|
||||
(brush->flag & BRUSH_LOCK_SIZE);
|
||||
}
|
||||
|
||||
int brush_use_size_pressure(const Scene *scene, Brush *brush)
|
||||
int BKE_brush_use_size_pressure(const Scene *scene, Brush *brush)
|
||||
{
|
||||
const short us_flag = scene->toolsettings->unified_paint_settings.flag;
|
||||
|
||||
@ -666,7 +666,7 @@ int brush_use_size_pressure(const Scene *scene, Brush *brush)
|
||||
(brush->flag & BRUSH_SIZE_PRESSURE);
|
||||
}
|
||||
|
||||
int brush_use_alpha_pressure(const Scene *scene, Brush *brush)
|
||||
int BKE_brush_use_alpha_pressure(const Scene *scene, Brush *brush)
|
||||
{
|
||||
const short us_flag = scene->toolsettings->unified_paint_settings.flag;
|
||||
|
||||
@ -675,7 +675,7 @@ int brush_use_alpha_pressure(const Scene *scene, Brush *brush)
|
||||
(brush->flag & BRUSH_ALPHA_PRESSURE);
|
||||
}
|
||||
|
||||
void brush_set_unprojected_radius(Scene *scene, Brush *brush, float unprojected_radius)
|
||||
void BKE_brush_unprojected_radius_set(Scene *scene, Brush *brush, float unprojected_radius)
|
||||
{
|
||||
UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
|
||||
|
||||
@ -685,7 +685,7 @@ void brush_set_unprojected_radius(Scene *scene, Brush *brush, float unprojected_
|
||||
brush->unprojected_radius= unprojected_radius;
|
||||
}
|
||||
|
||||
float brush_unprojected_radius(const Scene *scene, Brush *brush)
|
||||
float BKE_brush_unprojected_radius_get(const Scene *scene, Brush *brush)
|
||||
{
|
||||
UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
|
||||
|
||||
@ -694,7 +694,7 @@ float brush_unprojected_radius(const Scene *scene, Brush *brush)
|
||||
brush->unprojected_radius;
|
||||
}
|
||||
|
||||
static void brush_set_alpha(Scene *scene, Brush *brush, float alpha)
|
||||
static void brush_alpha_set(Scene *scene, Brush *brush, float alpha)
|
||||
{
|
||||
UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
|
||||
|
||||
@ -704,21 +704,21 @@ static void brush_set_alpha(Scene *scene, Brush *brush, float alpha)
|
||||
brush->alpha= alpha;
|
||||
}
|
||||
|
||||
float brush_alpha(const Scene *scene, Brush *brush)
|
||||
float BKE_brush_alpha_get(const Scene *scene, Brush *brush)
|
||||
{
|
||||
UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
|
||||
|
||||
return (ups->flag & UNIFIED_PAINT_ALPHA) ? ups->alpha : brush->alpha;
|
||||
}
|
||||
|
||||
float brush_weight(const Scene *scene, Brush *brush)
|
||||
float BKE_brush_weight_get(const Scene *scene, Brush *brush)
|
||||
{
|
||||
UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
|
||||
|
||||
return (ups->flag & UNIFIED_PAINT_WEIGHT) ? ups->weight : brush->weight;
|
||||
}
|
||||
|
||||
void brush_set_weight(const Scene *scene, Brush *brush, float value)
|
||||
void BKE_brush_weight_set(const Scene *scene, Brush *brush, float value)
|
||||
{
|
||||
UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
|
||||
|
||||
@ -729,9 +729,9 @@ void brush_set_weight(const Scene *scene, Brush *brush, float value)
|
||||
}
|
||||
|
||||
/* scale unprojected radius to reflect a change in the brush's 2D size */
|
||||
void brush_scale_unprojected_radius(float *unprojected_radius,
|
||||
int new_brush_size,
|
||||
int old_brush_size)
|
||||
void BKE_brush_scale_unprojected_radius(float *unprojected_radius,
|
||||
int new_brush_size,
|
||||
int old_brush_size)
|
||||
{
|
||||
float scale = new_brush_size;
|
||||
/* avoid division by zero */
|
||||
@ -741,15 +741,15 @@ void brush_scale_unprojected_radius(float *unprojected_radius,
|
||||
}
|
||||
|
||||
/* scale brush size to reflect a change in the brush's unprojected radius */
|
||||
void brush_scale_size(int *brush_size,
|
||||
float new_unprojected_radius,
|
||||
float old_unprojected_radius)
|
||||
void BKE_brush_scale_size(int *BKE_brush_size_get,
|
||||
float new_unprojected_radius,
|
||||
float old_unprojected_radius)
|
||||
{
|
||||
float scale = new_unprojected_radius;
|
||||
/* avoid division by zero */
|
||||
if (old_unprojected_radius != 0)
|
||||
scale /= new_unprojected_radius;
|
||||
(*brush_size)= (int)((float)(*brush_size) * scale);
|
||||
(*BKE_brush_size_get)= (int)((float)(*BKE_brush_size_get) * scale);
|
||||
}
|
||||
|
||||
/* Brush Painting */
|
||||
@ -757,7 +757,7 @@ void brush_scale_size(int *brush_size,
|
||||
typedef struct BrushPainterCache {
|
||||
short enabled;
|
||||
|
||||
int size; /* size override, if 0 uses 2*brush_size(brush) */
|
||||
int size; /* size override, if 0 uses 2*BKE_brush_size_get(brush) */
|
||||
short flt; /* need float imbuf? */
|
||||
short texonly; /* no alpha, color or fallof, only texture in imbuf */
|
||||
|
||||
@ -795,7 +795,7 @@ struct BrushPainter {
|
||||
BrushPainterCache cache;
|
||||
};
|
||||
|
||||
BrushPainter *brush_painter_new(Scene *scene, Brush *brush)
|
||||
BrushPainter *BKE_brush_painter_new(Scene *scene, Brush *brush)
|
||||
{
|
||||
BrushPainter *painter= MEM_callocN(sizeof(BrushPainter), "BrushPainter");
|
||||
|
||||
@ -804,15 +804,15 @@ BrushPainter *brush_painter_new(Scene *scene, Brush *brush)
|
||||
painter->firsttouch= 1;
|
||||
painter->cache.lastsize= -1; /* force ibuf create in refresh */
|
||||
|
||||
painter->startsize = brush_size(scene, brush);
|
||||
painter->startalpha = brush_alpha(scene, brush);
|
||||
painter->startsize = BKE_brush_size_get(scene, brush);
|
||||
painter->startalpha = BKE_brush_alpha_get(scene, brush);
|
||||
painter->startjitter = brush->jitter;
|
||||
painter->startspacing = brush->spacing;
|
||||
|
||||
return painter;
|
||||
}
|
||||
|
||||
void brush_painter_require_imbuf(BrushPainter *painter, short flt, short texonly, int size)
|
||||
void BKE_brush_painter_require_imbuf(BrushPainter *painter, short flt, short texonly, int size)
|
||||
{
|
||||
if ((painter->cache.flt != flt) || (painter->cache.size != size) ||
|
||||
((painter->cache.texonly != texonly) && texonly)) {
|
||||
@ -834,12 +834,12 @@ void brush_painter_require_imbuf(BrushPainter *painter, short flt, short texonly
|
||||
painter->cache.enabled= 1;
|
||||
}
|
||||
|
||||
void brush_painter_free(BrushPainter *painter)
|
||||
void BKE_brush_painter_free(BrushPainter *painter)
|
||||
{
|
||||
Brush *brush = painter->brush;
|
||||
|
||||
brush_set_size(painter->scene, brush, painter->startsize);
|
||||
brush_set_alpha(painter->scene, brush, painter->startalpha);
|
||||
BKE_brush_size_set(painter->scene, brush, painter->startsize);
|
||||
brush_alpha_set(painter->scene, brush, painter->startalpha);
|
||||
brush->jitter = painter->startjitter;
|
||||
brush->spacing = painter->startspacing;
|
||||
|
||||
@ -859,7 +859,7 @@ static void brush_painter_do_partial(BrushPainter *painter, ImBuf *oldtexibuf,
|
||||
float *bf, *mf, *tf, *otf=NULL, xoff, yoff, xy[2], rgba[4];
|
||||
unsigned char *b, *m, *t, *ot= NULL;
|
||||
int dotexold, origx= x, origy= y;
|
||||
const int radius= brush_size(painter->scene, brush);
|
||||
const int radius= BKE_brush_size_get(painter->scene, brush);
|
||||
|
||||
xoff = -radius + 0.5f;
|
||||
yoff = -radius + 0.5f;
|
||||
@ -897,7 +897,7 @@ static void brush_painter_do_partial(BrushPainter *painter, ImBuf *oldtexibuf,
|
||||
xy[0] = x + xoff;
|
||||
xy[1] = y + yoff;
|
||||
|
||||
brush_sample_tex(scene, brush, xy, tf, 0);
|
||||
BKE_brush_sample_tex(scene, brush, xy, tf, 0);
|
||||
}
|
||||
|
||||
bf[0] = tf[0]*mf[0];
|
||||
@ -928,7 +928,7 @@ static void brush_painter_do_partial(BrushPainter *painter, ImBuf *oldtexibuf,
|
||||
xy[0] = x + xoff;
|
||||
xy[1] = y + yoff;
|
||||
|
||||
brush_sample_tex(scene, brush, xy, rgba, 0);
|
||||
BKE_brush_sample_tex(scene, brush, xy, rgba, 0);
|
||||
rgba_float_to_uchar(t, rgba);
|
||||
}
|
||||
|
||||
@ -948,7 +948,7 @@ static void brush_painter_fixed_tex_partial_update(BrushPainter *painter, const
|
||||
BrushPainterCache *cache= &painter->cache;
|
||||
ImBuf *oldtexibuf, *ibuf;
|
||||
int imbflag, destx, desty, srcx, srcy, w, h, x1, y1, x2, y2;
|
||||
const int diameter= 2*brush_size(scene, brush);
|
||||
const int diameter= 2*BKE_brush_size_get(scene, brush);
|
||||
|
||||
imbflag= (cache->flt)? IB_rectfloat: IB_rect;
|
||||
if (!cache->ibuf)
|
||||
@ -1004,8 +1004,8 @@ static void brush_painter_refresh_cache(BrushPainter *painter, const float pos[2
|
||||
MTex *mtex= &brush->mtex;
|
||||
int size;
|
||||
short flt;
|
||||
const int diameter= 2*brush_size(scene, brush);
|
||||
const float alpha= brush_alpha(scene, brush);
|
||||
const int diameter= 2*BKE_brush_size_get(scene, brush);
|
||||
const float alpha= BKE_brush_alpha_get(scene, brush);
|
||||
|
||||
if (diameter != cache->lastsize ||
|
||||
alpha != cache->lastalpha ||
|
||||
@ -1024,11 +1024,11 @@ static void brush_painter_refresh_cache(BrushPainter *painter, const float pos[2
|
||||
size= (cache->size)? cache->size: diameter;
|
||||
|
||||
if (brush->flag & BRUSH_FIXED_TEX) {
|
||||
brush_imbuf_new(scene, brush, flt, 3, size, &cache->maskibuf, use_color_correction);
|
||||
BKE_brush_imbuf_new(scene, brush, flt, 3, size, &cache->maskibuf, use_color_correction);
|
||||
brush_painter_fixed_tex_partial_update(painter, pos);
|
||||
}
|
||||
else
|
||||
brush_imbuf_new(scene, brush, flt, 2, size, &cache->ibuf, use_color_correction);
|
||||
BKE_brush_imbuf_new(scene, brush, flt, 2, size, &cache->ibuf, use_color_correction);
|
||||
|
||||
cache->lastsize= diameter;
|
||||
cache->lastalpha= alpha;
|
||||
@ -1043,24 +1043,24 @@ static void brush_painter_refresh_cache(BrushPainter *painter, const float pos[2
|
||||
}
|
||||
}
|
||||
|
||||
void brush_painter_break_stroke(BrushPainter *painter)
|
||||
void BKE_brush_painter_break_stroke(BrushPainter *painter)
|
||||
{
|
||||
painter->firsttouch= 1;
|
||||
}
|
||||
|
||||
static void brush_apply_pressure(BrushPainter *painter, Brush *brush, float pressure)
|
||||
static void brush_pressure_apply(BrushPainter *painter, Brush *brush, float pressure)
|
||||
{
|
||||
if (brush_use_alpha_pressure(painter->scene, brush))
|
||||
brush_set_alpha(painter->scene, brush, MAX2(0.0f, painter->startalpha*pressure));
|
||||
if (brush_use_size_pressure(painter->scene, brush))
|
||||
brush_set_size(painter->scene, brush, MAX2(1.0f, painter->startsize*pressure));
|
||||
if (BKE_brush_use_alpha_pressure(painter->scene, brush))
|
||||
brush_alpha_set(painter->scene, brush, MAX2(0.0f, painter->startalpha*pressure));
|
||||
if (BKE_brush_use_size_pressure(painter->scene, brush))
|
||||
BKE_brush_size_set(painter->scene, brush, MAX2(1.0f, painter->startsize*pressure));
|
||||
if (brush->flag & BRUSH_JITTER_PRESSURE)
|
||||
brush->jitter = MAX2(0.0f, painter->startjitter*pressure);
|
||||
if (brush->flag & BRUSH_SPACING_PRESSURE)
|
||||
brush->spacing = MAX2(1.0f, painter->startspacing*(1.5f-pressure));
|
||||
}
|
||||
|
||||
void brush_jitter_pos(const Scene *scene, Brush *brush, const float pos[2], float jitterpos[2])
|
||||
void BKE_brush_jitter_pos(const Scene *scene, Brush *brush, const float pos[2], float jitterpos[2])
|
||||
{
|
||||
int use_jitter= brush->jitter != 0;
|
||||
|
||||
@ -1070,7 +1070,7 @@ void brush_jitter_pos(const Scene *scene, Brush *brush, const float pos[2], floa
|
||||
|
||||
if (use_jitter) {
|
||||
float rand_pos[2];
|
||||
const int radius= brush_size(scene, brush);
|
||||
const int radius= BKE_brush_size_get(scene, brush);
|
||||
const int diameter= 2*radius;
|
||||
|
||||
// find random position within a circle of diameter 1
|
||||
@ -1087,8 +1087,8 @@ void brush_jitter_pos(const Scene *scene, Brush *brush, const float pos[2], floa
|
||||
}
|
||||
}
|
||||
|
||||
int brush_painter_paint(BrushPainter *painter, BrushFunc func, const float pos[2], double time, float pressure,
|
||||
void *user, int use_color_correction)
|
||||
int BKE_brush_painter_paint(BrushPainter *painter, BrushFunc func, const float pos[2], double time, float pressure,
|
||||
void *user, int use_color_correction)
|
||||
{
|
||||
Scene *scene= painter->scene;
|
||||
Brush *brush= painter->brush;
|
||||
@ -1105,7 +1105,7 @@ int brush_painter_paint(BrushPainter *painter, BrushFunc func, const float pos[2
|
||||
painter->startpaintpos[0]= pos[0];
|
||||
painter->startpaintpos[1]= pos[1];
|
||||
|
||||
brush_apply_pressure(painter, brush, pressure);
|
||||
brush_pressure_apply(painter, brush, pressure);
|
||||
if (painter->cache.enabled)
|
||||
brush_painter_refresh_cache(painter, pos, use_color_correction);
|
||||
totpaintops += func(user, painter->cache.ibuf, pos, pos);
|
||||
@ -1152,11 +1152,11 @@ int brush_painter_paint(BrushPainter *painter, BrushFunc func, const float pos[2
|
||||
else {
|
||||
float startdistance, spacing, step, paintpos[2], dmousepos[2], finalpos[2];
|
||||
float t, len, press;
|
||||
const int radius= brush_size(scene, brush);
|
||||
const int radius= BKE_brush_size_get(scene, brush);
|
||||
|
||||
/* compute brush spacing adapted to brush radius, spacing may depend
|
||||
* on pressure, so update it */
|
||||
brush_apply_pressure(painter, brush, painter->lastpressure);
|
||||
brush_pressure_apply(painter, brush, painter->lastpressure);
|
||||
spacing= MAX2(1.0f, radius)*brush->spacing*0.01f;
|
||||
|
||||
/* setup starting distance, direction vector and accumulated distance */
|
||||
@ -1174,10 +1174,10 @@ int brush_painter_paint(BrushPainter *painter, BrushFunc func, const float pos[2
|
||||
|
||||
t = step/len;
|
||||
press= (1.0f-t)*painter->lastpressure + t*pressure;
|
||||
brush_apply_pressure(painter, brush, press);
|
||||
brush_pressure_apply(painter, brush, press);
|
||||
spacing= MAX2(1.0f, radius)*brush->spacing*0.01f;
|
||||
|
||||
brush_jitter_pos(scene, brush, paintpos, finalpos);
|
||||
BKE_brush_jitter_pos(scene, brush, paintpos, finalpos);
|
||||
|
||||
if (painter->cache.enabled)
|
||||
brush_painter_refresh_cache(painter, finalpos, use_color_correction);
|
||||
@ -1192,7 +1192,7 @@ int brush_painter_paint(BrushPainter *painter, BrushFunc func, const float pos[2
|
||||
}
|
||||
}
|
||||
else {
|
||||
brush_jitter_pos(scene, brush, pos, finalpos);
|
||||
BKE_brush_jitter_pos(scene, brush, pos, finalpos);
|
||||
|
||||
if (painter->cache.enabled)
|
||||
brush_painter_refresh_cache(painter, finalpos, use_color_correction);
|
||||
@ -1218,9 +1218,9 @@ int brush_painter_paint(BrushPainter *painter, BrushFunc func, const float pos[2
|
||||
painter->accumtime -= painttime;
|
||||
|
||||
while (painter->accumtime >= (double)brush->rate) {
|
||||
brush_apply_pressure(painter, brush, pressure);
|
||||
brush_pressure_apply(painter, brush, pressure);
|
||||
|
||||
brush_jitter_pos(scene, brush, pos, finalpos);
|
||||
BKE_brush_jitter_pos(scene, brush, pos, finalpos);
|
||||
|
||||
if (painter->cache.enabled)
|
||||
brush_painter_refresh_cache(painter, finalpos, use_color_correction);
|
||||
@ -1238,8 +1238,8 @@ int brush_painter_paint(BrushPainter *painter, BrushFunc func, const float pos[2
|
||||
painter->lastmousepos[1]= pos[1];
|
||||
painter->lastpressure= pressure;
|
||||
|
||||
brush_set_alpha(scene, brush, painter->startalpha);
|
||||
brush_set_size(scene, brush, painter->startsize);
|
||||
brush_alpha_set(scene, brush, painter->startalpha);
|
||||
BKE_brush_size_set(scene, brush, painter->startsize);
|
||||
brush->jitter = painter->startjitter;
|
||||
brush->spacing = painter->startspacing;
|
||||
|
||||
@ -1247,7 +1247,7 @@ int brush_painter_paint(BrushPainter *painter, BrushFunc func, const float pos[2
|
||||
}
|
||||
|
||||
/* Uses the brush curve control to find a strength value between 0 and 1 */
|
||||
float brush_curve_strength_clamp(Brush *br, float p, const float len)
|
||||
float BKE_brush_curve_strength_clamp(Brush *br, float p, const float len)
|
||||
{
|
||||
if (p >= len) return 0;
|
||||
else p= p/len;
|
||||
@ -1259,7 +1259,7 @@ float brush_curve_strength_clamp(Brush *br, float p, const float len)
|
||||
}
|
||||
/* same as above but can return negative values if the curve enables
|
||||
* used for sculpt only */
|
||||
float brush_curve_strength(Brush *br, float p, const float len)
|
||||
float BKE_brush_curve_strength(Brush *br, float p, const float len)
|
||||
{
|
||||
if (p >= len)
|
||||
p= 1.0f;
|
||||
@ -1270,7 +1270,7 @@ float brush_curve_strength(Brush *br, float p, const float len)
|
||||
}
|
||||
|
||||
/* TODO: should probably be unified with BrushPainter stuff? */
|
||||
unsigned int *brush_gen_texture_cache(Brush *br, int half_side)
|
||||
unsigned int *BKE_brush_gen_texture_cache(Brush *br, int half_side)
|
||||
{
|
||||
unsigned int *texcache = NULL;
|
||||
MTex *mtex = &br->mtex;
|
||||
@ -1316,7 +1316,7 @@ unsigned int *brush_gen_texture_cache(Brush *br, int half_side)
|
||||
}
|
||||
|
||||
/**** Radial Control ****/
|
||||
struct ImBuf *brush_gen_radial_control_imbuf(Brush *br)
|
||||
struct ImBuf *BKE_brush_gen_radial_control_imbuf(Brush *br)
|
||||
{
|
||||
ImBuf *im = MEM_callocN(sizeof(ImBuf), "radial control texture");
|
||||
unsigned int *texcache;
|
||||
@ -1324,14 +1324,14 @@ struct ImBuf *brush_gen_radial_control_imbuf(Brush *br)
|
||||
int half = side / 2;
|
||||
int i, j;
|
||||
|
||||
texcache = brush_gen_texture_cache(br, half);
|
||||
texcache = BKE_brush_gen_texture_cache(br, half);
|
||||
im->rect_float = MEM_callocN(sizeof(float) * side * side, "radial control rect");
|
||||
im->x = im->y = side;
|
||||
|
||||
for (i=0; i<side; ++i) {
|
||||
for (j=0; j<side; ++j) {
|
||||
float magn= sqrt(pow(i - half, 2) + pow(j - half, 2));
|
||||
im->rect_float[i*side + j]= brush_curve_strength_clamp(br, magn, half);
|
||||
im->rect_float[i*side + j]= BKE_brush_curve_strength_clamp(br, magn, half);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -50,7 +50,7 @@
|
||||
|
||||
/****************************** Camera Datablock *****************************/
|
||||
|
||||
void *add_camera(const char *name)
|
||||
void *BKE_camera_add(const char *name)
|
||||
{
|
||||
Camera *cam;
|
||||
|
||||
@ -69,7 +69,7 @@ void *add_camera(const char *name)
|
||||
return cam;
|
||||
}
|
||||
|
||||
Camera *copy_camera(Camera *cam)
|
||||
Camera *BKE_camera_copy(Camera *cam)
|
||||
{
|
||||
Camera *camn;
|
||||
|
||||
@ -80,7 +80,7 @@ Camera *copy_camera(Camera *cam)
|
||||
return camn;
|
||||
}
|
||||
|
||||
void make_local_camera(Camera *cam)
|
||||
void BKE_camera_make_local(Camera *cam)
|
||||
{
|
||||
Main *bmain= G.main;
|
||||
Object *ob;
|
||||
@ -108,7 +108,7 @@ void make_local_camera(Camera *cam)
|
||||
id_clear_lib_data(bmain, &cam->id);
|
||||
}
|
||||
else if (is_local && is_lib) {
|
||||
Camera *cam_new= copy_camera(cam);
|
||||
Camera *cam_new= BKE_camera_copy(cam);
|
||||
|
||||
cam_new->id.us= 0;
|
||||
|
||||
@ -127,14 +127,14 @@ void make_local_camera(Camera *cam)
|
||||
}
|
||||
}
|
||||
|
||||
void free_camera(Camera *ca)
|
||||
void BKE_camera_free(Camera *ca)
|
||||
{
|
||||
BKE_free_animdata((ID *)ca);
|
||||
}
|
||||
|
||||
/******************************** Camera Usage *******************************/
|
||||
|
||||
void object_camera_mode(RenderData *rd, Object *cam_ob)
|
||||
void BKE_camera_object_mode(RenderData *rd, Object *cam_ob)
|
||||
{
|
||||
rd->mode &= ~(R_ORTHO|R_PANORAMA);
|
||||
|
||||
@ -146,7 +146,7 @@ void object_camera_mode(RenderData *rd, Object *cam_ob)
|
||||
}
|
||||
|
||||
/* get the camera's dof value, takes the dof object into account */
|
||||
float object_camera_dof_distance(Object *ob)
|
||||
float BKE_camera_object_dof_distance(Object *ob)
|
||||
{
|
||||
Camera *cam = (Camera *)ob->data;
|
||||
if (ob->type != OB_CAMERA)
|
||||
@ -165,7 +165,7 @@ float object_camera_dof_distance(Object *ob)
|
||||
return cam->YF_dofdist;
|
||||
}
|
||||
|
||||
float camera_sensor_size(int sensor_fit, float sensor_x, float sensor_y)
|
||||
float BKE_camera_sensor_size(int sensor_fit, float sensor_x, float sensor_y)
|
||||
{
|
||||
/* sensor size used to fit to. for auto, sensor_x is both x and y. */
|
||||
if (sensor_fit == CAMERA_SENSOR_FIT_VERT)
|
||||
@ -174,7 +174,7 @@ float camera_sensor_size(int sensor_fit, float sensor_x, float sensor_y)
|
||||
return sensor_x;
|
||||
}
|
||||
|
||||
int camera_sensor_fit(int sensor_fit, float sizex, float sizey)
|
||||
int BKE_camera_sensor_fit(int sensor_fit, float sizex, float sizey)
|
||||
{
|
||||
if (sensor_fit == CAMERA_SENSOR_FIT_AUTO) {
|
||||
if (sizex >= sizey)
|
||||
@ -188,7 +188,7 @@ int camera_sensor_fit(int sensor_fit, float sizex, float sizey)
|
||||
|
||||
/******************************** Camera Params *******************************/
|
||||
|
||||
void camera_params_init(CameraParams *params)
|
||||
void BKE_camera_params_init(CameraParams *params)
|
||||
{
|
||||
memset(params, 0, sizeof(CameraParams));
|
||||
|
||||
@ -200,7 +200,7 @@ void camera_params_init(CameraParams *params)
|
||||
params->zoom= 1.0f;
|
||||
}
|
||||
|
||||
void camera_params_from_object(CameraParams *params, Object *ob)
|
||||
void BKE_camera_params_from_object(CameraParams *params, Object *ob)
|
||||
{
|
||||
if (!ob)
|
||||
return;
|
||||
@ -239,7 +239,7 @@ void camera_params_from_object(CameraParams *params, Object *ob)
|
||||
}
|
||||
}
|
||||
|
||||
void camera_params_from_view3d(CameraParams *params, View3D *v3d, RegionView3D *rv3d)
|
||||
void BKE_camera_params_from_view3d(CameraParams *params, View3D *v3d, RegionView3D *rv3d)
|
||||
{
|
||||
/* common */
|
||||
params->lens= v3d->lens;
|
||||
@ -248,7 +248,7 @@ void camera_params_from_view3d(CameraParams *params, View3D *v3d, RegionView3D *
|
||||
|
||||
if (rv3d->persp==RV3D_CAMOB) {
|
||||
/* camera view */
|
||||
camera_params_from_object(params, v3d->camera);
|
||||
BKE_camera_params_from_object(params, v3d->camera);
|
||||
|
||||
params->zoom= BKE_screen_view3d_zoom_to_fac((float)rv3d->camzoom);
|
||||
|
||||
@ -275,7 +275,7 @@ void camera_params_from_view3d(CameraParams *params, View3D *v3d, RegionView3D *
|
||||
}
|
||||
}
|
||||
|
||||
void camera_params_compute_viewplane(CameraParams *params, int winx, int winy, float xasp, float yasp)
|
||||
void BKE_camera_params_compute_viewplane(CameraParams *params, int winx, int winy, float xasp, float yasp)
|
||||
{
|
||||
rctf viewplane;
|
||||
float pixsize, viewfac, sensor_size, dx, dy;
|
||||
@ -293,12 +293,12 @@ void camera_params_compute_viewplane(CameraParams *params, int winx, int winy, f
|
||||
}
|
||||
else {
|
||||
/* perspective camera */
|
||||
sensor_size= camera_sensor_size(params->sensor_fit, params->sensor_x, params->sensor_y);
|
||||
sensor_size= BKE_camera_sensor_size(params->sensor_fit, params->sensor_x, params->sensor_y);
|
||||
pixsize= (sensor_size * params->clipsta)/params->lens;
|
||||
}
|
||||
|
||||
/* determine sensor fit */
|
||||
sensor_fit = camera_sensor_fit(params->sensor_fit, xasp*winx, yasp*winy);
|
||||
sensor_fit = BKE_camera_sensor_fit(params->sensor_fit, xasp*winx, yasp*winy);
|
||||
|
||||
if (sensor_fit==CAMERA_SENSOR_FIT_HOR)
|
||||
viewfac= winx;
|
||||
@ -351,23 +351,23 @@ void camera_params_compute_viewplane(CameraParams *params, int winx, int winy, f
|
||||
}
|
||||
|
||||
/* viewplane is assumed to be already computed */
|
||||
void camera_params_compute_matrix(CameraParams *params)
|
||||
void BKE_camera_params_compute_matrix(CameraParams *params)
|
||||
{
|
||||
rctf viewplane= params->viewplane;
|
||||
rctf viewplane = params->viewplane;
|
||||
|
||||
/* compute projection matrix */
|
||||
if (params->is_ortho)
|
||||
orthographic_m4(params->winmat, viewplane.xmin, viewplane.xmax,
|
||||
viewplane.ymin, viewplane.ymax, params->clipsta, params->clipend);
|
||||
viewplane.ymin, viewplane.ymax, params->clipsta, params->clipend);
|
||||
else
|
||||
perspective_m4(params->winmat, viewplane.xmin, viewplane.xmax,
|
||||
viewplane.ymin, viewplane.ymax, params->clipsta, params->clipend);
|
||||
viewplane.ymin, viewplane.ymax, params->clipsta, params->clipend);
|
||||
}
|
||||
|
||||
/***************************** Camera View Frame *****************************/
|
||||
|
||||
void camera_view_frame_ex(Scene *scene, Camera *camera, float drawsize, const short do_clip, const float scale[3],
|
||||
float r_asp[2], float r_shift[2], float *r_drawsize, float r_vec[4][3])
|
||||
void BKE_camera_view_frame_ex(Scene *scene, Camera *camera, float drawsize, const short do_clip, const float scale[3],
|
||||
float r_asp[2], float r_shift[2], float *r_drawsize, float r_vec[4][3])
|
||||
{
|
||||
float facx, facy;
|
||||
float depth;
|
||||
@ -376,7 +376,7 @@ void camera_view_frame_ex(Scene *scene, Camera *camera, float drawsize, const sh
|
||||
if (scene) {
|
||||
float aspx= (float) scene->r.xsch*scene->r.xasp;
|
||||
float aspy= (float) scene->r.ysch*scene->r.yasp;
|
||||
int sensor_fit= camera_sensor_fit(camera->sensor_fit, aspx, aspy);
|
||||
int sensor_fit= BKE_camera_sensor_fit(camera->sensor_fit, aspx, aspy);
|
||||
|
||||
if (sensor_fit==CAMERA_SENSOR_FIT_HOR) {
|
||||
r_asp[0]= 1.0;
|
||||
@ -431,14 +431,14 @@ void camera_view_frame_ex(Scene *scene, Camera *camera, float drawsize, const sh
|
||||
r_vec[3][0]= r_shift[0] - facx; r_vec[3][1]= r_shift[1] + facy; r_vec[3][2]= depth;
|
||||
}
|
||||
|
||||
void camera_view_frame(Scene *scene, Camera *camera, float r_vec[4][3])
|
||||
void BKE_camera_view_frame(Scene *scene, Camera *camera, float r_vec[4][3])
|
||||
{
|
||||
float dummy_asp[2];
|
||||
float dummy_shift[2];
|
||||
float dummy_drawsize;
|
||||
const float dummy_scale[3]= {1.0f, 1.0f, 1.0f};
|
||||
|
||||
camera_view_frame_ex(scene, camera, FALSE, 1.0, dummy_scale,
|
||||
BKE_camera_view_frame_ex(scene, camera, FALSE, 1.0, dummy_scale,
|
||||
dummy_asp, dummy_shift, &dummy_drawsize, r_vec);
|
||||
}
|
||||
|
||||
@ -450,7 +450,7 @@ typedef struct CameraViewFrameData {
|
||||
unsigned int tot;
|
||||
} CameraViewFrameData;
|
||||
|
||||
static void camera_to_frame_view_cb(const float co[3], void *user_data)
|
||||
static void BKE_camera_to_frame_view_cb(const float co[3], void *user_data)
|
||||
{
|
||||
CameraViewFrameData *data= (CameraViewFrameData *)user_data;
|
||||
unsigned int i;
|
||||
@ -467,7 +467,7 @@ static void camera_to_frame_view_cb(const float co[3], void *user_data)
|
||||
|
||||
/* don't move the camera, just yield the fit location */
|
||||
/* only valid for perspective cameras */
|
||||
int camera_view_frame_fit_to_scene(Scene *scene, struct View3D *v3d, Object *camera_ob, float r_co[3])
|
||||
int BKE_camera_view_frame_fit_to_scene(Scene *scene, struct View3D *v3d, Object *camera_ob, float r_co[3])
|
||||
{
|
||||
float shift[2];
|
||||
float plane_tx[4][3];
|
||||
@ -477,7 +477,7 @@ int camera_view_frame_fit_to_scene(Scene *scene, struct View3D *v3d, Object *cam
|
||||
|
||||
unsigned int i;
|
||||
|
||||
camera_view_frame(scene, camera_ob->data, data_cb.frame_tx);
|
||||
BKE_camera_view_frame(scene, camera_ob->data, data_cb.frame_tx);
|
||||
|
||||
copy_m3_m4(rot_obmat, camera_ob->obmat);
|
||||
normalize_m3(rot_obmat);
|
||||
@ -514,7 +514,7 @@ int camera_view_frame_fit_to_scene(Scene *scene, struct View3D *v3d, Object *cam
|
||||
data_cb.tot= 0;
|
||||
/* run callback on all visible points */
|
||||
BKE_scene_foreach_display_point(scene, v3d, BA_SELECT,
|
||||
camera_to_frame_view_cb, &data_cb);
|
||||
BKE_camera_to_frame_view_cb, &data_cb);
|
||||
|
||||
if (data_cb.tot <= 1) {
|
||||
return FALSE;
|
||||
|
@ -4012,8 +4012,8 @@ static void followtrack_evaluate(bConstraint *con, bConstraintOb *cob, ListBase
|
||||
|
||||
add_v2_v2v2(pos, marker->pos, track->offset);
|
||||
|
||||
camera_params_init(¶ms);
|
||||
camera_params_from_object(¶ms, camob);
|
||||
BKE_camera_params_init(¶ms);
|
||||
BKE_camera_params_from_object(¶ms, camob);
|
||||
|
||||
if (params.is_ortho) {
|
||||
vec[0] = params.ortho_scale * (pos[0] - 0.5f + params.shiftx);
|
||||
|
@ -224,7 +224,7 @@ int id_make_local(ID *id, int test)
|
||||
if (!test) make_local_lamp((Lamp*)id);
|
||||
return 1;
|
||||
case ID_CA:
|
||||
if (!test) make_local_camera((Camera*)id);
|
||||
if (!test) BKE_camera_make_local((Camera*)id);
|
||||
return 1;
|
||||
case ID_SPK:
|
||||
if (!test) make_local_speaker((Speaker*)id);
|
||||
@ -258,7 +258,7 @@ int id_make_local(ID *id, int test)
|
||||
case ID_NT:
|
||||
return 0; /* not implemented */
|
||||
case ID_BR:
|
||||
if (!test) make_local_brush((Brush*)id);
|
||||
if (!test) BKE_brush_make_local((Brush*)id);
|
||||
return 1;
|
||||
case ID_PA:
|
||||
if (!test) make_local_particlesettings((ParticleSettings*)id);
|
||||
@ -315,7 +315,7 @@ int id_copy(ID *id, ID **newid, int test)
|
||||
if (!test) *newid= (ID*)copy_speaker((Speaker*)id);
|
||||
return 1;
|
||||
case ID_CA:
|
||||
if (!test) *newid= (ID*)copy_camera((Camera*)id);
|
||||
if (!test) *newid= (ID*)BKE_camera_copy((Camera*)id);
|
||||
return 1;
|
||||
case ID_IP:
|
||||
return 0; /* deprecated */
|
||||
@ -349,7 +349,7 @@ int id_copy(ID *id, ID **newid, int test)
|
||||
if (!test) *newid= (ID*)ntreeCopyTree((bNodeTree*)id);
|
||||
return 1;
|
||||
case ID_BR:
|
||||
if (!test) *newid= (ID*)copy_brush((Brush*)id);
|
||||
if (!test) *newid= (ID*)BKE_brush_copy((Brush*)id);
|
||||
return 1;
|
||||
case ID_PA:
|
||||
if (!test) *newid= (ID*)psys_copy_settings((ParticleSettings*)id);
|
||||
@ -831,7 +831,7 @@ void free_libblock(ListBase *lb, void *idv)
|
||||
free_lamp((Lamp *)id);
|
||||
break;
|
||||
case ID_CA:
|
||||
free_camera((Camera*) id);
|
||||
BKE_camera_free((Camera*) id);
|
||||
break;
|
||||
case ID_IP:
|
||||
free_ipo((Ipo *)id);
|
||||
@ -873,7 +873,7 @@ void free_libblock(ListBase *lb, void *idv)
|
||||
ntreeFreeTree((bNodeTree *)id);
|
||||
break;
|
||||
case ID_BR:
|
||||
free_brush((Brush *)id);
|
||||
BKE_brush_free((Brush *)id);
|
||||
break;
|
||||
case ID_PA:
|
||||
psys_free_settings((ParticleSettings *)id);
|
||||
|
@ -755,7 +755,7 @@ void *add_obdata_from_type(int type)
|
||||
case OB_SURF: return BKE_curve_add("Surf", OB_SURF);
|
||||
case OB_FONT: return BKE_curve_add("Text", OB_FONT);
|
||||
case OB_MBALL: return BKE_metaball_add("Meta");
|
||||
case OB_CAMERA: return add_camera("Camera");
|
||||
case OB_CAMERA: return BKE_camera_add("Camera");
|
||||
case OB_LAMP: return add_lamp("Lamp");
|
||||
case OB_LATTICE: return add_lattice("Lattice");
|
||||
case OB_ARMATURE: return add_armature("Armature");
|
||||
|
@ -126,7 +126,7 @@ void paint_init(Paint *p, const char col[3])
|
||||
/* If there's no brush, create one */
|
||||
brush = paint_brush(p);
|
||||
if (brush == NULL)
|
||||
brush= add_brush("Brush");
|
||||
brush= BKE_brush_add("Brush");
|
||||
paint_brush_set(p, brush);
|
||||
|
||||
memcpy(p->paint_cursor_col, col, 3);
|
||||
|
@ -33,7 +33,7 @@
|
||||
*/
|
||||
|
||||
/** find the index number of a voxel, given x/y/z integer coords and resolution vector */
|
||||
#define BLI_VEXEL_INDEX(x, y, z, res) ((z) * (res)[1] * (res)[0] + (y) * (res)[0] + (x))
|
||||
#define BLI_VOXEL_INDEX(x, y, z, res) ((z) * (res)[1] * (res)[0] + (y) * (res)[0] + (x))
|
||||
|
||||
/* all input coordinates must be in bounding box 0.0 - 1.0 */
|
||||
float BLI_voxel_sample_nearest(float *data, const int res[3], const float co[3]);
|
||||
|
@ -40,7 +40,7 @@ BLI_INLINE float D(float *data, const int res[3], int x, int y, int z)
|
||||
CLAMP(x, 0, res[0] - 1);
|
||||
CLAMP(y, 0, res[1] - 1);
|
||||
CLAMP(z, 0, res[2] - 1);
|
||||
return data[ BLI_VEXEL_INDEX(x, y, z, res) ];
|
||||
return data[ BLI_VOXEL_INDEX(x, y, z, res) ];
|
||||
}
|
||||
|
||||
/* *** nearest neighbor *** */
|
||||
|
@ -1685,7 +1685,7 @@ static void direct_link_brush(FileData *fd, Brush *brush)
|
||||
if (brush->curve)
|
||||
direct_link_curvemapping(fd, brush->curve);
|
||||
else
|
||||
brush_curve_preset(brush, CURVE_PRESET_SHARP);
|
||||
BKE_brush_curve_preset(brush, CURVE_PRESET_SHARP);
|
||||
|
||||
brush->preview= NULL;
|
||||
brush->icon_imbuf= NULL;
|
||||
|
@ -802,8 +802,8 @@ bool DocumentImporter::writeCamera( const COLLADAFW::Camera* camera )
|
||||
|
||||
cam_id = camera->getOriginalId();
|
||||
cam_name = camera->getName();
|
||||
if (cam_name.size()) cam = (Camera*)add_camera((char*)cam_name.c_str());
|
||||
else cam = (Camera*)add_camera((char*)cam_id.c_str());
|
||||
if (cam_name.size()) cam = (Camera *)BKE_camera_add((char*)cam_name.c_str());
|
||||
else cam = (Camera *)BKE_camera_add((char*)cam_id.c_str());
|
||||
|
||||
if (!cam) {
|
||||
fprintf(stderr, "Cannot create camera.\n");
|
||||
|
@ -1783,7 +1783,7 @@ static Base *object_add_duplicate_internal(Main *bmain, Scene *scene, Base *base
|
||||
if (dupflag != 0) {
|
||||
ID_NEW_US2(obn->data)
|
||||
else {
|
||||
obn->data = copy_camera(obn->data);
|
||||
obn->data = BKE_camera_copy(obn->data);
|
||||
didit = 1;
|
||||
}
|
||||
id->us--;
|
||||
|
@ -1486,7 +1486,7 @@ static void single_obdata_users(Main *bmain, Scene *scene, int flag)
|
||||
}
|
||||
break;
|
||||
case OB_CAMERA:
|
||||
ob->data = copy_camera(ob->data);
|
||||
ob->data = BKE_camera_copy(ob->data);
|
||||
break;
|
||||
case OB_MESH:
|
||||
ob->data = copy_mesh(ob->data);
|
||||
|
@ -2990,7 +2990,7 @@ static void brush_puff(PEData *data, int point_index)
|
||||
}
|
||||
|
||||
|
||||
static void brush_weight(PEData *data, float UNUSED(mat[][4]), float UNUSED(imat[][4]), int point_index, int key_index, PTCacheEditKey *UNUSED(key))
|
||||
static void BKE_brush_weight_get(PEData *data, float UNUSED(mat[][4]), float UNUSED(imat[][4]), int point_index, int key_index, PTCacheEditKey *UNUSED(key))
|
||||
{
|
||||
/* roots have full weight allways */
|
||||
if (key_index) {
|
||||
@ -3622,7 +3622,7 @@ static void brush_edit_apply(bContext *C, wmOperator *op, PointerRNA *itemptr)
|
||||
|
||||
data.weightfac = brush->strength; /* note that this will never be zero */
|
||||
|
||||
foreach_mouse_hit_key(&data, brush_weight, selected);
|
||||
foreach_mouse_hit_key(&data, BKE_brush_weight_get, selected);
|
||||
}
|
||||
|
||||
break;
|
||||
|
@ -69,7 +69,7 @@ typedef struct Snapshot {
|
||||
float size[3];
|
||||
float ofs[3];
|
||||
float rot;
|
||||
int brush_size;
|
||||
int BKE_brush_size_get;
|
||||
int winx;
|
||||
int winy;
|
||||
int brush_map_mode;
|
||||
@ -87,8 +87,8 @@ static int same_snap(Snapshot *snap, Brush *brush, ViewContext *vc)
|
||||
|
||||
/* make brush smaller shouldn't cause a resample */
|
||||
((mtex->brush_map_mode == MTEX_MAP_MODE_FIXED &&
|
||||
(brush_size(vc->scene, brush) <= snap->brush_size)) ||
|
||||
(brush_size(vc->scene, brush) == snap->brush_size)) &&
|
||||
(BKE_brush_size_get(vc->scene, brush) <= snap->BKE_brush_size_get)) ||
|
||||
(BKE_brush_size_get(vc->scene, brush) == snap->BKE_brush_size_get)) &&
|
||||
|
||||
(mtex->brush_map_mode == snap->brush_map_mode) &&
|
||||
(vc->ar->winx == snap->winx) &&
|
||||
@ -110,7 +110,7 @@ static void make_snap(Snapshot *snap, Brush *brush, ViewContext *vc)
|
||||
snap->rot = -1;
|
||||
}
|
||||
|
||||
snap->brush_size = brush_size(vc->scene, brush);
|
||||
snap->BKE_brush_size_get = BKE_brush_size_get(vc->scene, brush);
|
||||
snap->winx = vc->ar->winx;
|
||||
snap->winy = vc->ar->winy;
|
||||
}
|
||||
@ -155,7 +155,7 @@ static int load_tex(Sculpt *sd, Brush *br, ViewContext *vc)
|
||||
make_snap(&snap, br, vc);
|
||||
|
||||
if (br->mtex.brush_map_mode == MTEX_MAP_MODE_FIXED) {
|
||||
int s = brush_size(vc->scene, br);
|
||||
int s = BKE_brush_size_get(vc->scene, br);
|
||||
int r = 1;
|
||||
|
||||
for (s >>= 1; s > 0; s >>= 1)
|
||||
@ -196,7 +196,7 @@ static int load_tex(Sculpt *sd, Brush *br, ViewContext *vc)
|
||||
// largely duplicated from tex_strength
|
||||
|
||||
const float rotation = -br->mtex.rot;
|
||||
float radius = brush_size(vc->scene, br);
|
||||
float radius = BKE_brush_size_get(vc->scene, br);
|
||||
int index = j * size + i;
|
||||
float x;
|
||||
float avg;
|
||||
@ -240,7 +240,7 @@ static int load_tex(Sculpt *sd, Brush *br, ViewContext *vc)
|
||||
avg += br->texture_sample_bias;
|
||||
|
||||
if (br->mtex.brush_map_mode == MTEX_MAP_MODE_FIXED)
|
||||
avg *= brush_curve_strength(br, len, 1); /* Falloff curve */
|
||||
avg *= BKE_brush_curve_strength(br, len, 1); /* Falloff curve */
|
||||
|
||||
buffer[index] = 255 - (GLubyte)(255 * avg);
|
||||
}
|
||||
@ -345,11 +345,11 @@ static int sculpt_get_brush_geometry(bContext *C, ViewContext *vc,
|
||||
sculpt_stroke_get_location(C, location, window)) {
|
||||
*pixel_radius =
|
||||
project_brush_radius(vc,
|
||||
brush_unprojected_radius(scene, brush),
|
||||
BKE_brush_unprojected_radius_get(scene, brush),
|
||||
location);
|
||||
|
||||
if (*pixel_radius == 0)
|
||||
*pixel_radius = brush_size(scene, brush);
|
||||
*pixel_radius = BKE_brush_size_get(scene, brush);
|
||||
|
||||
mul_m4_v3(vc->obact->obmat, location);
|
||||
|
||||
@ -359,7 +359,7 @@ static int sculpt_get_brush_geometry(bContext *C, ViewContext *vc,
|
||||
Sculpt *sd = CTX_data_tool_settings(C)->sculpt;
|
||||
Brush *brush = paint_brush(&sd->paint);
|
||||
|
||||
*pixel_radius = brush_size(scene, brush);
|
||||
*pixel_radius = BKE_brush_size_get(scene, brush);
|
||||
hit = 0;
|
||||
}
|
||||
|
||||
@ -414,7 +414,7 @@ static void paint_draw_alpha_overlay(Sculpt *sd, Brush *brush,
|
||||
glTranslatef(-0.5f, -0.5f, 0);
|
||||
|
||||
/* scale based on tablet pressure */
|
||||
if (sd->draw_pressure && brush_use_size_pressure(vc->scene, brush)) {
|
||||
if (sd->draw_pressure && BKE_brush_use_size_pressure(vc->scene, brush)) {
|
||||
glTranslatef(0.5f, 0.5f, 0);
|
||||
glScalef(1.0f / sd->pressure_value, 1.0f / sd->pressure_value, 1);
|
||||
glTranslatef(-0.5f, -0.5f, 0);
|
||||
@ -429,7 +429,7 @@ static void paint_draw_alpha_overlay(Sculpt *sd, Brush *brush,
|
||||
quad.ymax = aim[1] + sd->anchored_size - win->ymin;
|
||||
}
|
||||
else {
|
||||
const int radius = brush_size(vc->scene, brush);
|
||||
const int radius = BKE_brush_size_get(vc->scene, brush);
|
||||
quad.xmin = x - radius;
|
||||
quad.ymin = y - radius;
|
||||
quad.xmax = x + radius;
|
||||
@ -475,7 +475,7 @@ static void paint_cursor_on_hit(Sculpt *sd, Brush *brush, ViewContext *vc,
|
||||
float unprojected_radius, projected_radius;
|
||||
|
||||
/* update the brush's cached 3D radius */
|
||||
if (!brush_use_locked_size(vc->scene, brush)) {
|
||||
if (!BKE_brush_use_locked_size(vc->scene, brush)) {
|
||||
/* get 2D brush radius */
|
||||
if (sd->draw_anchored)
|
||||
projected_radius = sd->anchored_size;
|
||||
@ -483,7 +483,7 @@ static void paint_cursor_on_hit(Sculpt *sd, Brush *brush, ViewContext *vc,
|
||||
if (brush->flag & BRUSH_ANCHORED)
|
||||
projected_radius = 8;
|
||||
else
|
||||
projected_radius = brush_size(vc->scene, brush);
|
||||
projected_radius = BKE_brush_size_get(vc->scene, brush);
|
||||
}
|
||||
|
||||
/* convert brush radius from 2D to 3D */
|
||||
@ -491,11 +491,11 @@ static void paint_cursor_on_hit(Sculpt *sd, Brush *brush, ViewContext *vc,
|
||||
projected_radius);
|
||||
|
||||
/* scale 3D brush radius by pressure */
|
||||
if (sd->draw_pressure && brush_use_size_pressure(vc->scene, brush))
|
||||
if (sd->draw_pressure && BKE_brush_use_size_pressure(vc->scene, brush))
|
||||
unprojected_radius *= sd->pressure_value;
|
||||
|
||||
/* set cached value in either Brush or UnifiedPaintSettings */
|
||||
brush_set_unprojected_radius(vc->scene, brush, unprojected_radius);
|
||||
BKE_brush_unprojected_radius_set(vc->scene, brush, unprojected_radius);
|
||||
}
|
||||
}
|
||||
|
||||
@ -514,7 +514,7 @@ static void paint_draw_cursor(bContext *C, int x, int y, void *UNUSED(unused))
|
||||
translation[1] = y;
|
||||
outline_alpha = 0.5;
|
||||
outline_col = brush->add_col;
|
||||
final_radius = brush_size(scene, brush);
|
||||
final_radius = BKE_brush_size_get(scene, brush);
|
||||
|
||||
/* check that brush drawing is enabled */
|
||||
if (!(paint->flags & PAINT_SHOW_BRUSH))
|
||||
@ -557,8 +557,8 @@ static void paint_draw_cursor(bContext *C, int x, int y, void *UNUSED(unused))
|
||||
/* draw overlay */
|
||||
paint_draw_alpha_overlay(sd, brush, &vc, x, y);
|
||||
|
||||
if (brush_use_locked_size(scene, brush))
|
||||
brush_set_size(scene, brush, pixel_radius);
|
||||
if (BKE_brush_use_locked_size(scene, brush))
|
||||
BKE_brush_size_set(scene, brush, pixel_radius);
|
||||
|
||||
/* check if brush is subtracting, use different color then */
|
||||
/* TODO: no way currently to know state of pen flip or
|
||||
|
@ -1457,7 +1457,7 @@ static float project_paint_uvpixel_mask(
|
||||
|
||||
// This only works when the opacity dosnt change while painting, stylus pressure messes with this
|
||||
// so don't use it.
|
||||
// if (ps->is_airbrush==0) mask *= brush_alpha(ps->brush);
|
||||
// if (ps->is_airbrush==0) mask *= BKE_brush_alpha_get(ps->brush);
|
||||
|
||||
return mask;
|
||||
}
|
||||
@ -2953,7 +2953,7 @@ static void project_paint_begin(ProjPaintState *ps)
|
||||
|
||||
MemArena *arena; /* at the moment this is just ps->arena_mt[0], but use this to show were not multithreading */
|
||||
|
||||
const int diameter = 2 * brush_size(ps->scene, ps->brush);
|
||||
const int diameter = 2 * BKE_brush_size_get(ps->scene, ps->brush);
|
||||
|
||||
/* ---- end defines ---- */
|
||||
|
||||
@ -3091,10 +3091,10 @@ static void project_paint_begin(ProjPaintState *ps)
|
||||
invert_m4_m4(viewmat, viewinv);
|
||||
|
||||
/* window matrix, clipping and ortho */
|
||||
camera_params_init(¶ms);
|
||||
camera_params_from_object(¶ms, cam_ob);
|
||||
camera_params_compute_viewplane(¶ms, ps->winx, ps->winy, 1.0f, 1.0f);
|
||||
camera_params_compute_matrix(¶ms);
|
||||
BKE_camera_params_init(¶ms);
|
||||
BKE_camera_params_from_object(¶ms, cam_ob);
|
||||
BKE_camera_params_compute_viewplane(¶ms, ps->winx, ps->winy, 1.0f, 1.0f);
|
||||
BKE_camera_params_compute_matrix(¶ms);
|
||||
|
||||
copy_m4_m4(winmat, params.winmat);
|
||||
ps->clipsta = params.clipsta;
|
||||
@ -3597,7 +3597,7 @@ static int project_bucket_iter_init(ProjPaintState *ps, const float mval_f[2])
|
||||
{
|
||||
if (ps->source == PROJ_SRC_VIEW) {
|
||||
float min_brush[2], max_brush[2];
|
||||
const float radius = (float)brush_size(ps->scene, ps->brush);
|
||||
const float radius = (float)BKE_brush_size_get(ps->scene, ps->brush);
|
||||
|
||||
/* so we don't have a bucket bounds that is way too small to paint into */
|
||||
// if (radius < 1.0f) radius = 1.0f; // this doesn't work yet :/
|
||||
@ -3635,7 +3635,7 @@ static int project_bucket_iter_init(ProjPaintState *ps, const float mval_f[2])
|
||||
|
||||
static int project_bucket_iter_next(ProjPaintState *ps, int *bucket_index, rctf *bucket_bounds, const float mval[2])
|
||||
{
|
||||
const int diameter = 2 * brush_size(ps->scene, ps->brush);
|
||||
const int diameter = 2 * BKE_brush_size_get(ps->scene, ps->brush);
|
||||
|
||||
if (ps->thread_tot > 1)
|
||||
BLI_lock_thread(LOCK_CUSTOM1);
|
||||
@ -3859,7 +3859,7 @@ static void *do_projectpaint_thread(void *ph_v)
|
||||
float co[2];
|
||||
float mask = 1.0f; /* airbrush wont use mask */
|
||||
unsigned short mask_short;
|
||||
const float radius = (float)brush_size(ps->scene, ps->brush);
|
||||
const float radius = (float)BKE_brush_size_get(ps->scene, ps->brush);
|
||||
const float radius_squared = radius * radius; /* avoid a square root with every dist comparison */
|
||||
|
||||
short lock_alpha = ELEM(ps->brush->blend, IMB_BLEND_ERASE_ALPHA, IMB_BLEND_ADD_ALPHA) ? 0 : ps->brush->flag & BRUSH_LOCK_ALPHA;
|
||||
@ -3913,12 +3913,12 @@ static void *do_projectpaint_thread(void *ph_v)
|
||||
if (dist_nosqrt <= radius_squared) {
|
||||
dist = sqrtf(dist_nosqrt);
|
||||
|
||||
falloff = brush_curve_strength_clamp(ps->brush, dist, radius);
|
||||
falloff = BKE_brush_curve_strength_clamp(ps->brush, dist, radius);
|
||||
|
||||
if (falloff > 0.0f) {
|
||||
if (ps->is_texbrush) {
|
||||
/* note, for clone and smear, we only use the alpha, could be a special function */
|
||||
brush_sample_tex(ps->scene, ps->brush, projPixel->projCoSS, rgba, thread_index);
|
||||
BKE_brush_sample_tex(ps->scene, ps->brush, projPixel->projCoSS, rgba, thread_index);
|
||||
alpha = rgba[3];
|
||||
}
|
||||
else {
|
||||
@ -3927,7 +3927,7 @@ static void *do_projectpaint_thread(void *ph_v)
|
||||
|
||||
if (ps->is_airbrush) {
|
||||
/* for an aurbrush there is no real mask, so just multiply the alpha by it */
|
||||
alpha *= falloff * brush_alpha(ps->scene, ps->brush);
|
||||
alpha *= falloff * BKE_brush_alpha_get(ps->scene, ps->brush);
|
||||
mask = ((float)projPixel->mask) / 65535.0f;
|
||||
}
|
||||
else {
|
||||
@ -3935,7 +3935,7 @@ static void *do_projectpaint_thread(void *ph_v)
|
||||
falloff = 1.0f - falloff;
|
||||
falloff = 1.0f - (falloff * falloff);
|
||||
|
||||
mask_short = (unsigned short)(projPixel->mask * (brush_alpha(ps->scene, ps->brush) * falloff));
|
||||
mask_short = (unsigned short)(projPixel->mask * (BKE_brush_alpha_get(ps->scene, ps->brush) * falloff));
|
||||
if (mask_short > projPixel->mask_max) {
|
||||
mask = ((float)mask_short) / 65535.0f;
|
||||
projPixel->mask_max = mask_short;
|
||||
@ -4101,9 +4101,9 @@ static int project_paint_sub_stroke(ProjPaintState *ps, BrushPainter *painter, c
|
||||
pos[1] = (float)(mval_i[1]);
|
||||
|
||||
// we may want to use this later
|
||||
// brush_painter_require_imbuf(painter, ((ibuf->rect_float)? 1: 0), 0, 0);
|
||||
// BKE_brush_painter_require_imbuf(painter, ((ibuf->rect_float)? 1: 0), 0, 0);
|
||||
|
||||
if (brush_painter_paint(painter, project_paint_op, pos, time, pressure, ps, 0)) {
|
||||
if (BKE_brush_painter_paint(painter, project_paint_op, pos, time, pressure, ps, 0)) {
|
||||
return 1;
|
||||
}
|
||||
else return 0;
|
||||
@ -4525,9 +4525,9 @@ static int imapaint_paint_sub_stroke(ImagePaintState *s, BrushPainter *painter,
|
||||
pos[0] = uv[0] * ibuf->x;
|
||||
pos[1] = uv[1] * ibuf->y;
|
||||
|
||||
brush_painter_require_imbuf(painter, ((ibuf->rect_float) ? 1 : 0), 0, 0);
|
||||
BKE_brush_painter_require_imbuf(painter, ((ibuf->rect_float) ? 1 : 0), 0, 0);
|
||||
|
||||
if (brush_painter_paint(painter, imapaint_paint_op, pos, time, pressure, s, ibuf->profile == IB_PROFILE_LINEAR_RGB)) {
|
||||
if (BKE_brush_painter_paint(painter, imapaint_paint_op, pos, time, pressure, s, ibuf->profile == IB_PROFILE_LINEAR_RGB)) {
|
||||
if (update)
|
||||
imapaint_image_update(s->sima, image, ibuf, texpaint);
|
||||
return 1;
|
||||
@ -4580,7 +4580,7 @@ static int imapaint_paint_stroke(ViewContext *vc, ImagePaintState *s, BrushPaint
|
||||
redraw |= imapaint_paint_sub_stroke(s, painter, s->image, texpaint,
|
||||
fwuv, time, 1, pressure);
|
||||
imapaint_clear_partial_redraw();
|
||||
brush_painter_break_stroke(painter);
|
||||
BKE_brush_painter_break_stroke(painter);
|
||||
}
|
||||
|
||||
/* set new canvas */
|
||||
@ -4854,7 +4854,7 @@ static int texture_paint_init(bContext *C, wmOperator *op)
|
||||
if (pop->mode == PAINT_MODE_3D && (pop->s.tool == PAINT_TOOL_CLONE))
|
||||
pop->s.tool = PAINT_TOOL_DRAW;
|
||||
pop->s.blend = brush->blend;
|
||||
pop->orig_brush_size = brush_size(scene, brush);
|
||||
pop->orig_brush_size = BKE_brush_size_get(scene, brush);
|
||||
|
||||
if (pop->mode != PAINT_MODE_2D) {
|
||||
Object *ob = OBACT;
|
||||
@ -4920,8 +4920,8 @@ static int texture_paint_init(bContext *C, wmOperator *op)
|
||||
return 0;
|
||||
|
||||
/* Don't allow brush size below 2 */
|
||||
if (brush_size(scene, brush) < 2)
|
||||
brush_set_size(scene, brush, 2);
|
||||
if (BKE_brush_size_get(scene, brush) < 2)
|
||||
BKE_brush_size_set(scene, brush, 2);
|
||||
|
||||
/* allocate and initialize spacial data structures */
|
||||
project_paint_begin(&pop->ps);
|
||||
@ -4935,7 +4935,7 @@ static int texture_paint_init(bContext *C, wmOperator *op)
|
||||
image_undo_restore, image_undo_free);
|
||||
|
||||
/* create painter */
|
||||
pop->painter = brush_painter_new(scene, pop->s.brush);
|
||||
pop->painter = BKE_brush_painter_new(scene, pop->s.brush);
|
||||
|
||||
return 1;
|
||||
}
|
||||
@ -5002,10 +5002,10 @@ static void paint_exit(bContext *C, wmOperator *op)
|
||||
|
||||
settings->imapaint.flag &= ~IMAGEPAINT_DRAWING;
|
||||
imapaint_canvas_free(&pop->s);
|
||||
brush_painter_free(pop->painter);
|
||||
BKE_brush_painter_free(pop->painter);
|
||||
|
||||
if (pop->mode == PAINT_MODE_3D_PROJECT) {
|
||||
brush_set_size(scene, pop->ps.brush, pop->orig_brush_size);
|
||||
BKE_brush_size_set(scene, pop->ps.brush, pop->orig_brush_size);
|
||||
paint_brush_exit_tex(pop->ps.brush);
|
||||
|
||||
project_paint_end(&pop->ps);
|
||||
@ -5079,13 +5079,13 @@ static void paint_apply_event(bContext *C, wmOperator *op, wmEvent *event)
|
||||
|
||||
/* special exception here for too high pressure values on first touch in
|
||||
* windows for some tablets, then we just skip first touch .. */
|
||||
if (tablet && (pressure >= 0.99f) && ((pop->s.brush->flag & BRUSH_SPACING_PRESSURE) || brush_use_alpha_pressure(scene, pop->s.brush) || brush_use_size_pressure(scene, pop->s.brush)))
|
||||
if (tablet && (pressure >= 0.99f) && ((pop->s.brush->flag & BRUSH_SPACING_PRESSURE) || BKE_brush_use_alpha_pressure(scene, pop->s.brush) || BKE_brush_use_size_pressure(scene, pop->s.brush)))
|
||||
return;
|
||||
|
||||
/* This can be removed once fixed properly in
|
||||
* brush_painter_paint(BrushPainter *painter, BrushFunc func, float *pos, double time, float pressure, void *user)
|
||||
* BKE_brush_painter_paint(BrushPainter *painter, BrushFunc func, float *pos, double time, float pressure, void *user)
|
||||
* at zero pressure we should do nothing 1/2^12 is .0002 which is the sensitivity of the most sensitive pen tablet available */
|
||||
if (tablet && (pressure < .0002f) && ((pop->s.brush->flag & BRUSH_SPACING_PRESSURE) || brush_use_alpha_pressure(scene, pop->s.brush) || brush_use_size_pressure(scene, pop->s.brush)))
|
||||
if (tablet && (pressure < .0002f) && ((pop->s.brush->flag & BRUSH_SPACING_PRESSURE) || BKE_brush_use_alpha_pressure(scene, pop->s.brush) || BKE_brush_use_size_pressure(scene, pop->s.brush)))
|
||||
return;
|
||||
|
||||
}
|
||||
@ -5208,7 +5208,7 @@ static void brush_drawcursor(bContext *C, int x, int y, void *UNUSED(customdata)
|
||||
if (paint && brush && paint->flags & PAINT_SHOW_BRUSH) {
|
||||
ToolSettings *ts;
|
||||
float zoomx, zoomy;
|
||||
const float size = (float)brush_size(scene, brush);
|
||||
const float size = (float)BKE_brush_size_get(scene, brush);
|
||||
short use_zoom;
|
||||
float pixel_size;
|
||||
float alpha = 0.5f;
|
||||
@ -5702,8 +5702,8 @@ static int texture_paint_camera_project_exec(bContext *C, wmOperator *op)
|
||||
/* override */
|
||||
ps.is_texbrush = 0;
|
||||
ps.is_airbrush = 1;
|
||||
orig_brush_size = brush_size(scene, ps.brush);
|
||||
brush_set_size(scene, ps.brush, 32); /* cover the whole image */
|
||||
orig_brush_size = BKE_brush_size_get(scene, ps.brush);
|
||||
BKE_brush_size_set(scene, ps.brush, 32); /* cover the whole image */
|
||||
|
||||
ps.tool = PAINT_TOOL_DRAW; /* so pixels are initialized with minimal info */
|
||||
|
||||
@ -5716,7 +5716,7 @@ static int texture_paint_camera_project_exec(bContext *C, wmOperator *op)
|
||||
project_paint_begin(&ps);
|
||||
|
||||
if (ps.dm == NULL) {
|
||||
brush_set_size(scene, ps.brush, orig_brush_size);
|
||||
BKE_brush_size_set(scene, ps.brush, orig_brush_size);
|
||||
return OPERATOR_CANCELLED;
|
||||
}
|
||||
else {
|
||||
@ -5740,7 +5740,7 @@ static int texture_paint_camera_project_exec(bContext *C, wmOperator *op)
|
||||
project_paint_end(&ps);
|
||||
|
||||
scene->toolsettings->imapaint.flag &= ~IMAGEPAINT_DRAWING;
|
||||
brush_set_size(scene, ps.brush, orig_brush_size);
|
||||
BKE_brush_size_set(scene, ps.brush, orig_brush_size);
|
||||
|
||||
return OPERATOR_FINISHED;
|
||||
}
|
||||
|
@ -63,9 +63,9 @@ static int brush_add_exec(bContext *C, wmOperator *UNUSED(op))
|
||||
struct Brush *br = paint_brush(paint);
|
||||
|
||||
if (br)
|
||||
br = copy_brush(br);
|
||||
br = BKE_brush_copy(br);
|
||||
else
|
||||
br = add_brush("Brush");
|
||||
br = BKE_brush_add("Brush");
|
||||
|
||||
paint_brush_set(paint_get_active(CTX_data_scene(C)), br);
|
||||
|
||||
@ -98,7 +98,7 @@ static int brush_scale_size_exec(bContext *C, wmOperator *op)
|
||||
if (brush) {
|
||||
// pixel radius
|
||||
{
|
||||
const int old_size = brush_size(scene, brush);
|
||||
const int old_size = BKE_brush_size_get(scene, brush);
|
||||
int size = (int)(scalar * old_size);
|
||||
|
||||
if (old_size == size) {
|
||||
@ -111,17 +111,17 @@ static int brush_scale_size_exec(bContext *C, wmOperator *op)
|
||||
}
|
||||
CLAMP(size, 1, 2000); // XXX magic number
|
||||
|
||||
brush_set_size(scene, brush, size);
|
||||
BKE_brush_size_set(scene, brush, size);
|
||||
}
|
||||
|
||||
// unprojected radius
|
||||
{
|
||||
float unprojected_radius = scalar * brush_unprojected_radius(scene, brush);
|
||||
float unprojected_radius = scalar * BKE_brush_unprojected_radius_get(scene, brush);
|
||||
|
||||
if (unprojected_radius < 0.001f) // XXX magic number
|
||||
unprojected_radius = 0.001f;
|
||||
|
||||
brush_set_unprojected_radius(scene, brush, unprojected_radius);
|
||||
BKE_brush_unprojected_radius_set(scene, brush, unprojected_radius);
|
||||
}
|
||||
}
|
||||
|
||||
@ -178,7 +178,7 @@ static int brush_reset_exec(bContext *C, wmOperator *UNUSED(op))
|
||||
if (!ob) return OPERATOR_CANCELLED;
|
||||
|
||||
if (ob->mode & OB_MODE_SCULPT)
|
||||
brush_reset_sculpt(brush);
|
||||
BKE_brush_sculpt_reset(brush);
|
||||
/* TODO: other modes */
|
||||
|
||||
return OPERATOR_FINISHED;
|
||||
|
@ -146,10 +146,10 @@ static void paint_brush_stroke_add_step(bContext *C, wmOperator *op, wmEvent *ev
|
||||
if (stroke->vc.obact->sculpt) {
|
||||
float delta[2];
|
||||
|
||||
brush_jitter_pos(scene, brush, mouse_in, mouse);
|
||||
BKE_brush_jitter_pos(scene, brush, mouse_in, mouse);
|
||||
|
||||
/* XXX: meh, this is round about because
|
||||
* brush_jitter_pos isn't written in the best way to
|
||||
* BKE_brush_jitter_pos isn't written in the best way to
|
||||
* be reused here */
|
||||
if (brush->flag & BRUSH_JITTER_PRESSURE) {
|
||||
sub_v2_v2v2(delta, mouse, mouse_in);
|
||||
@ -231,11 +231,11 @@ static int paint_space_stroke(bContext *C, wmOperator *op, wmEvent *event, const
|
||||
float pressure = 1.0f;
|
||||
|
||||
/* XXX mysterious :) what has 'use size' do with this here... if you don't check for it, pressure fails */
|
||||
if (brush_use_size_pressure(scene, stroke->brush))
|
||||
if (BKE_brush_use_size_pressure(scene, stroke->brush))
|
||||
pressure = event_tablet_data(event, NULL);
|
||||
|
||||
if (pressure > FLT_EPSILON) {
|
||||
scale = (brush_size(scene, stroke->brush) * pressure * stroke->brush->spacing / 50.0f) / length;
|
||||
scale = (BKE_brush_size_get(scene, stroke->brush) * pressure * stroke->brush->spacing / 50.0f) / length;
|
||||
if (scale > FLT_EPSILON) {
|
||||
mul_v2_fl(vec, scale);
|
||||
|
||||
|
@ -358,7 +358,7 @@ void paint_sample_color(Scene *scene, ARegion *ar, int x, int y) /* frontbuf
|
||||
static int brush_curve_preset_exec(bContext *C, wmOperator *op)
|
||||
{
|
||||
Brush *br = paint_brush(paint_get_active(CTX_data_scene(C)));
|
||||
brush_curve_preset(br, RNA_enum_get(op->ptr, "shape"));
|
||||
BKE_brush_curve_preset(br, RNA_enum_get(op->ptr, "shape"));
|
||||
|
||||
return OPERATOR_FINISHED;
|
||||
}
|
||||
|
@ -859,7 +859,7 @@ static float calc_vp_strength_dl(VPaint *vp, ViewContext *vc, const float *vert_
|
||||
}
|
||||
else {
|
||||
const float dist = sqrtf(dist_squared);
|
||||
return brush_curve_strength_clamp(brush, dist, brush_size_pressure);
|
||||
return BKE_brush_curve_strength_clamp(brush, dist, brush_size_pressure);
|
||||
}
|
||||
}
|
||||
|
||||
@ -1051,7 +1051,7 @@ static int weight_sample_invoke(bContext *C, wmOperator *op, wmEvent *event)
|
||||
|
||||
if (v_idx_best != -1) { /* should always be valid */
|
||||
float vgroup_weight = defvert_find_weight(&me->dvert[v_idx_best], vgroup_active);
|
||||
brush_set_weight(scene, brush, vgroup_weight);
|
||||
BKE_brush_weight_set(scene, brush, vgroup_weight);
|
||||
change = TRUE;
|
||||
}
|
||||
}
|
||||
@ -1641,7 +1641,7 @@ typedef struct WeightPaintInfo {
|
||||
char do_multipaint;
|
||||
char do_auto_normalize;
|
||||
|
||||
float brush_alpha_value; /* result of brush_alpha() */
|
||||
float brush_alpha_value; /* result of BKE_brush_alpha_get() */
|
||||
} WeightPaintInfo;
|
||||
|
||||
/* fresh start to make multi-paint and locking modular */
|
||||
@ -2244,9 +2244,9 @@ static void wpaint_stroke_update_step(bContext *C, struct PaintStroke *stroke, P
|
||||
char *defbase_sel;
|
||||
|
||||
const float pressure = RNA_float_get(itemptr, "pressure");
|
||||
const float brush_size_pressure = brush_size(scene, brush) * (brush_use_size_pressure(scene, brush) ? pressure : 1.0f);
|
||||
const float brush_alpha_value = brush_alpha(scene, brush);
|
||||
const float brush_alpha_pressure = brush_alpha_value * (brush_use_alpha_pressure(scene, brush) ? pressure : 1.0f);
|
||||
const float brush_size_pressure = BKE_brush_size_get(scene, brush) * (BKE_brush_use_size_pressure(scene, brush) ? pressure : 1.0f);
|
||||
const float brush_alpha_value = BKE_brush_alpha_get(scene, brush);
|
||||
const float brush_alpha_pressure = brush_alpha_value * (BKE_brush_use_alpha_pressure(scene, brush) ? pressure : 1.0f);
|
||||
|
||||
/* intentionally don't initialize as NULL, make sure we initialize all members below */
|
||||
WeightPaintInfo wpi;
|
||||
@ -2342,7 +2342,7 @@ static void wpaint_stroke_update_step(bContext *C, struct PaintStroke *stroke, P
|
||||
if (brush->vertexpaint_tool == PAINT_BLEND_BLUR)
|
||||
paintweight = 0.0f;
|
||||
else
|
||||
paintweight = brush_weight(scene, brush);
|
||||
paintweight = BKE_brush_weight_get(scene, brush);
|
||||
|
||||
for (index = 0; index < totindex; index++) {
|
||||
if (indexar[index] && indexar[index] <= me->totpoly) {
|
||||
@ -2510,7 +2510,7 @@ static int weight_paint_set_exec(bContext *C, wmOperator *UNUSED(op))
|
||||
Object *obact = CTX_data_active_object(C);
|
||||
ToolSettings *ts = CTX_data_tool_settings(C);
|
||||
Brush *brush = paint_brush(&ts->wpaint->paint);
|
||||
float vgroup_weight = brush_weight(scene, brush);
|
||||
float vgroup_weight = BKE_brush_weight_get(scene, brush);
|
||||
|
||||
wpaint_fill(scene->toolsettings->wpaint, obact, vgroup_weight);
|
||||
ED_region_tag_redraw(CTX_wm_region(C)); /* XXX - should redraw all 3D views */
|
||||
@ -2870,8 +2870,8 @@ static void vpaint_stroke_update_step(bContext *C, struct PaintStroke *stroke, P
|
||||
float mval[2];
|
||||
|
||||
const float pressure = RNA_float_get(itemptr, "pressure");
|
||||
const float brush_size_pressure = brush_size(scene, brush) * (brush_use_size_pressure(scene, brush) ? pressure : 1.0f);
|
||||
const float brush_alpha_pressure = brush_alpha(scene, brush) * (brush_use_alpha_pressure(scene, brush) ? pressure : 1.0f);
|
||||
const float brush_size_pressure = BKE_brush_size_get(scene, brush) * (BKE_brush_use_size_pressure(scene, brush) ? pressure : 1.0f);
|
||||
const float brush_alpha_pressure = BKE_brush_alpha_get(scene, brush) * (BKE_brush_use_alpha_pressure(scene, brush) ? pressure : 1.0f);
|
||||
|
||||
RNA_float_get_array(itemptr, "mouse", mval);
|
||||
|
||||
|
@ -505,7 +505,7 @@ static float overlapped_curve(Brush *br, float x)
|
||||
xx = fabs(x0 + i * h);
|
||||
|
||||
if (xx < 1.0f)
|
||||
sum += brush_curve_strength(br, xx, 1);
|
||||
sum += BKE_brush_curve_strength(br, xx, 1);
|
||||
}
|
||||
|
||||
return sum;
|
||||
@ -618,10 +618,10 @@ static float brush_strength(Sculpt *sd, StrokeCache *cache, float feather)
|
||||
Brush *brush = paint_brush(&sd->paint);
|
||||
|
||||
/* Primary strength input; square it to make lower values more sensitive */
|
||||
const float root_alpha = brush_alpha(scene, brush);
|
||||
const float root_alpha = BKE_brush_alpha_get(scene, brush);
|
||||
float alpha = root_alpha * root_alpha;
|
||||
float dir = brush->flag & BRUSH_DIR_IN ? -1 : 1;
|
||||
float pressure = brush_use_alpha_pressure(scene, brush) ? cache->pressure : 1;
|
||||
float pressure = BKE_brush_use_alpha_pressure(scene, brush) ? cache->pressure : 1;
|
||||
float pen_flip = cache->pen_flip ? -1 : 1;
|
||||
float invert = cache->invert ? -1 : 1;
|
||||
float accum = integrate_overlap(brush);
|
||||
@ -752,7 +752,7 @@ static float tex_strength(SculptSession *ss, Brush *br, float point[3],
|
||||
/* leave the coordinates relative to the screen */
|
||||
|
||||
/* use unadjusted size for tiled mode */
|
||||
radius = brush_size(ss->cache->vc->scene, br);
|
||||
radius = BKE_brush_size_get(ss->cache->vc->scene, br);
|
||||
|
||||
x = point_2d[0];
|
||||
y = point_2d[1];
|
||||
@ -792,7 +792,7 @@ static float tex_strength(SculptSession *ss, Brush *br, float point[3],
|
||||
avg += br->texture_sample_bias;
|
||||
|
||||
/* Falloff curve */
|
||||
avg *= brush_curve_strength(br, len, ss->cache->radius);
|
||||
avg *= BKE_brush_curve_strength(br, len, ss->cache->radius);
|
||||
|
||||
avg *= frontface(br, sculpt_normal, vno, fno);
|
||||
|
||||
@ -1250,8 +1250,8 @@ static void do_crease_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnod
|
||||
|
||||
/* we divide out the squared alpha and multiply by the squared crease to give us the pinch strength */
|
||||
|
||||
if (brush_alpha(scene, brush) > 0.0f)
|
||||
crease_correction = brush->crease_pinch_factor * brush->crease_pinch_factor / (brush_alpha(scene, brush) * brush_alpha(scene, brush));
|
||||
if (BKE_brush_alpha_get(scene, brush) > 0.0f)
|
||||
crease_correction = brush->crease_pinch_factor * brush->crease_pinch_factor / (BKE_brush_alpha_get(scene, brush) * BKE_brush_alpha_get(scene, brush));
|
||||
else
|
||||
crease_correction = brush->crease_pinch_factor * brush->crease_pinch_factor;
|
||||
|
||||
@ -2720,7 +2720,7 @@ static void do_symmetrical_brush_actions(Sculpt *sd, Object *ob)
|
||||
static void sculpt_update_tex(const Scene *scene, Sculpt *sd, SculptSession *ss)
|
||||
{
|
||||
Brush *brush = paint_brush(&sd->paint);
|
||||
const int radius = brush_size(scene, brush);
|
||||
const int radius = BKE_brush_size_get(scene, brush);
|
||||
|
||||
if (ss->texcache) {
|
||||
MEM_freeN(ss->texcache);
|
||||
@ -2730,7 +2730,7 @@ static void sculpt_update_tex(const Scene *scene, Sculpt *sd, SculptSession *ss)
|
||||
/* Need to allocate a bigger buffer for bigger brush size */
|
||||
ss->texcache_side = 2 * radius;
|
||||
if (!ss->texcache || ss->texcache_side > ss->texcache_actual) {
|
||||
ss->texcache = brush_gen_texture_cache(brush, radius);
|
||||
ss->texcache = BKE_brush_gen_texture_cache(brush, radius);
|
||||
ss->texcache_actual = ss->texcache_side;
|
||||
}
|
||||
}
|
||||
@ -3130,19 +3130,19 @@ static void sculpt_update_cache_variants(bContext *C, Sculpt *sd, Object *ob,
|
||||
sd->pressure_value = cache->pressure;
|
||||
|
||||
cache->previous_pixel_radius = cache->pixel_radius;
|
||||
cache->pixel_radius = brush_size(scene, brush);
|
||||
cache->pixel_radius = BKE_brush_size_get(scene, brush);
|
||||
|
||||
if (cache->first_time) {
|
||||
if (!brush_use_locked_size(scene, brush)) {
|
||||
cache->initial_radius = paint_calc_object_space_radius(cache->vc, cache->true_location, brush_size(scene, brush));
|
||||
brush_set_unprojected_radius(scene, brush, cache->initial_radius);
|
||||
if (!BKE_brush_use_locked_size(scene, brush)) {
|
||||
cache->initial_radius = paint_calc_object_space_radius(cache->vc, cache->true_location, BKE_brush_size_get(scene, brush));
|
||||
BKE_brush_unprojected_radius_set(scene, brush, cache->initial_radius);
|
||||
}
|
||||
else {
|
||||
cache->initial_radius = brush_unprojected_radius(scene, brush);
|
||||
cache->initial_radius = BKE_brush_unprojected_radius_get(scene, brush);
|
||||
}
|
||||
}
|
||||
|
||||
if (brush_use_size_pressure(scene, brush)) {
|
||||
if (BKE_brush_use_size_pressure(scene, brush)) {
|
||||
cache->pixel_radius *= cache->pressure;
|
||||
cache->radius = cache->initial_radius * cache->pressure;
|
||||
}
|
||||
@ -3374,7 +3374,7 @@ static void sculpt_restore_mesh(Sculpt *sd, SculptSession *ss)
|
||||
/* Restore the mesh before continuing with anchored stroke */
|
||||
if ((brush->flag & BRUSH_ANCHORED) ||
|
||||
(brush->sculpt_tool == SCULPT_TOOL_GRAB &&
|
||||
brush_use_size_pressure(ss->cache->vc->scene, brush)) ||
|
||||
BKE_brush_use_size_pressure(ss->cache->vc->scene, brush)) ||
|
||||
(brush->flag & BRUSH_RESTORE_MESH))
|
||||
{
|
||||
paint_mesh_restore_co(sd, ss);
|
||||
|
@ -205,7 +205,7 @@ void HC_relaxation_iteration_uv(BMEditMesh *em, UvSculptData *sculptdata, float
|
||||
if ((dist = dot_v2v2(diff, diff)) <= radius) {
|
||||
UvElement *element;
|
||||
float strength;
|
||||
strength = alpha * brush_curve_strength(brush, sqrt(dist), radius_root);
|
||||
strength = alpha * BKE_brush_curve_strength(brush, sqrt(dist), radius_root);
|
||||
|
||||
sculptdata->uv[i].uv[0] = (1.0f - strength) * sculptdata->uv[i].uv[0] + strength * (tmp_uvdata[i].p[0] - 0.5f * (tmp_uvdata[i].b[0] + tmp_uvdata[i].sum_b[0] / tmp_uvdata[i].ncounter));
|
||||
sculptdata->uv[i].uv[1] = (1.0f - strength) * sculptdata->uv[i].uv[1] + strength * (tmp_uvdata[i].p[1] - 0.5f * (tmp_uvdata[i].b[1] + tmp_uvdata[i].sum_b[1] / tmp_uvdata[i].ncounter));
|
||||
@ -269,7 +269,7 @@ static void laplacian_relaxation_iteration_uv(BMEditMesh *em, UvSculptData *scul
|
||||
if ((dist = dot_v2v2(diff, diff)) <= radius) {
|
||||
UvElement *element;
|
||||
float strength;
|
||||
strength = alpha * brush_curve_strength(brush, sqrt(dist), radius_root);
|
||||
strength = alpha * BKE_brush_curve_strength(brush, sqrt(dist), radius_root);
|
||||
|
||||
sculptdata->uv[i].uv[0] = (1.0f - strength) * sculptdata->uv[i].uv[0] + strength * tmp_uvdata[i].p[0];
|
||||
sculptdata->uv[i].uv[1] = (1.0f - strength) * sculptdata->uv[i].uv[1] + strength * tmp_uvdata[i].p[1];
|
||||
@ -311,14 +311,14 @@ static void uv_sculpt_stroke_apply(bContext *C, wmOperator *op, wmEvent *event,
|
||||
ToolSettings *toolsettings = CTX_data_tool_settings(C);
|
||||
tool = sculptdata->tool;
|
||||
invert = sculptdata->invert ? -1 : 1;
|
||||
alpha = brush_alpha(scene, brush);
|
||||
alpha = BKE_brush_alpha_get(scene, brush);
|
||||
UI_view2d_region_to_view(&ar->v2d, event->mval[0], event->mval[1], &co[0], &co[1]);
|
||||
|
||||
sima = CTX_wm_space_image(C);
|
||||
ED_space_image_size(sima, &width, &height);
|
||||
ED_space_image_zoom(sima, ar, &zoomx, &zoomy);
|
||||
|
||||
radius = brush_size(scene, brush) / (width * zoomx);
|
||||
radius = BKE_brush_size_get(scene, brush) / (width * zoomx);
|
||||
aspectRatio = width / (float)height;
|
||||
|
||||
/* We will compare squares to save some computation */
|
||||
@ -344,7 +344,7 @@ static void uv_sculpt_stroke_apply(bContext *C, wmOperator *op, wmEvent *event,
|
||||
if ((dist = dot_v2v2(diff, diff)) <= radius) {
|
||||
UvElement *element;
|
||||
float strength;
|
||||
strength = alpha * brush_curve_strength(brush, sqrt(dist), radius_root);
|
||||
strength = alpha * BKE_brush_curve_strength(brush, sqrt(dist), radius_root);
|
||||
normalize_v2(diff);
|
||||
|
||||
sculptdata->uv[i].uv[0] -= strength * diff[0] * 0.001f;
|
||||
@ -679,9 +679,9 @@ static UvSculptData *uv_sculpt_stroke_init(bContext *C, wmOperator *op, wmEvent
|
||||
float alpha, zoomx, zoomy;
|
||||
Brush *brush = paint_brush(sculptdata->uvsculpt);
|
||||
|
||||
alpha = brush_alpha(scene, brush);
|
||||
alpha = BKE_brush_alpha_get(scene, brush);
|
||||
|
||||
radius = brush_size(scene, brush);
|
||||
radius = BKE_brush_size_get(scene, brush);
|
||||
sima = CTX_wm_space_image(C);
|
||||
ED_space_image_size(sima, &width, &height);
|
||||
ED_space_image_zoom(sima, ar, &zoomx, &zoomy);
|
||||
@ -715,7 +715,7 @@ static UvSculptData *uv_sculpt_stroke_init(bContext *C, wmOperator *op, wmEvent
|
||||
diff[1] /= aspectRatio;
|
||||
if ((dist = dot_v2v2(diff, diff)) <= radius) {
|
||||
float strength;
|
||||
strength = alpha * brush_curve_strength(brush, sqrt(dist), radius_root);
|
||||
strength = alpha * BKE_brush_curve_strength(brush, sqrt(dist), radius_root);
|
||||
|
||||
data->initial_stroke->initialSelection[counter].uv = i;
|
||||
data->initial_stroke->initialSelection[counter].strength = strength;
|
||||
|
@ -606,7 +606,7 @@ static void draw_image_view_tool(Scene *scene)
|
||||
if (draw) {
|
||||
getmouseco_areawin(mval);
|
||||
|
||||
radius = brush_size(brush) * G.sima->zoom;
|
||||
radius = BKE_brush_size_get(brush) * G.sima->zoom;
|
||||
fdrawXORcirc(mval[0], mval[1], radius);
|
||||
|
||||
if (brush->innerradius != 1.0) {
|
||||
|
@ -1762,7 +1762,7 @@ static void drawcamera(Scene *scene, View3D *v3d, RegionView3D *rv3d, Base *base
|
||||
scale[1] = 1.0f / len_v3(ob->obmat[1]);
|
||||
scale[2] = 1.0f / len_v3(ob->obmat[2]);
|
||||
|
||||
camera_view_frame_ex(scene, cam, cam->drawsize, is_view, scale,
|
||||
BKE_camera_view_frame_ex(scene, cam, cam->drawsize, is_view, scale,
|
||||
asp, shift, &drawsize, vec);
|
||||
|
||||
glDisable(GL_LIGHTING);
|
||||
@ -1834,7 +1834,7 @@ static void drawcamera(Scene *scene, View3D *v3d, RegionView3D *rv3d, Base *base
|
||||
if (cam->flag & CAM_SHOWLIMITS) {
|
||||
draw_limit_line(cam->clipsta, cam->clipend, 0x77FFFF);
|
||||
/* qdn: was yafray only, now also enabled for Blender to be used with defocus composite node */
|
||||
draw_focus_cross(object_camera_dof_distance(ob), cam->drawsize);
|
||||
draw_focus_cross(BKE_camera_object_dof_distance(ob), cam->drawsize);
|
||||
}
|
||||
|
||||
wrld = scene->world;
|
||||
|
@ -939,21 +939,21 @@ static void view3d_camera_border(Scene *scene, ARegion *ar, View3D *v3d, RegionV
|
||||
rctf rect_view, rect_camera;
|
||||
|
||||
/* get viewport viewplane */
|
||||
camera_params_init(¶ms);
|
||||
camera_params_from_view3d(¶ms, v3d, rv3d);
|
||||
BKE_camera_params_init(¶ms);
|
||||
BKE_camera_params_from_view3d(¶ms, v3d, rv3d);
|
||||
if (no_zoom)
|
||||
params.zoom = 1.0f;
|
||||
camera_params_compute_viewplane(¶ms, ar->winx, ar->winy, 1.0f, 1.0f);
|
||||
BKE_camera_params_compute_viewplane(¶ms, ar->winx, ar->winy, 1.0f, 1.0f);
|
||||
rect_view = params.viewplane;
|
||||
|
||||
/* get camera viewplane */
|
||||
camera_params_init(¶ms);
|
||||
camera_params_from_object(¶ms, v3d->camera);
|
||||
BKE_camera_params_init(¶ms);
|
||||
BKE_camera_params_from_object(¶ms, v3d->camera);
|
||||
if (no_shift) {
|
||||
params.shiftx = 0.0f;
|
||||
params.shifty = 0.0f;
|
||||
}
|
||||
camera_params_compute_viewplane(¶ms, scene->r.xsch, scene->r.ysch, scene->r.xasp, scene->r.yasp);
|
||||
BKE_camera_params_compute_viewplane(¶ms, scene->r.xsch, scene->r.ysch, scene->r.xasp, scene->r.yasp);
|
||||
rect_camera = params.viewplane;
|
||||
|
||||
/* get camera border within viewport */
|
||||
@ -1226,7 +1226,7 @@ static void drawviewborder(Scene *scene, ARegion *ar, View3D *v3d)
|
||||
* assume and square sensor and only use sensor_x */
|
||||
float sizex = scene->r.xsch * scene->r.xasp;
|
||||
float sizey = scene->r.ysch * scene->r.yasp;
|
||||
int sensor_fit = camera_sensor_fit(ca->sensor_fit, sizex, sizey);
|
||||
int sensor_fit = BKE_camera_sensor_fit(ca->sensor_fit, sizex, sizey);
|
||||
float sensor_x = ca->sensor_x;
|
||||
float sensor_y = (ca->sensor_fit == CAMERA_SENSOR_FIT_AUTO) ? ca->sensor_x : ca->sensor_y;
|
||||
|
||||
@ -2612,10 +2612,10 @@ ImBuf *ED_view3d_draw_offscreen_imbuf(Scene *scene, View3D *v3d, ARegion *ar,
|
||||
if (rv3d->persp == RV3D_CAMOB && v3d->camera) {
|
||||
CameraParams params;
|
||||
|
||||
camera_params_init(¶ms);
|
||||
camera_params_from_object(¶ms, v3d->camera);
|
||||
camera_params_compute_viewplane(¶ms, sizex, sizey, scene->r.xasp, scene->r.yasp);
|
||||
camera_params_compute_matrix(¶ms);
|
||||
BKE_camera_params_init(¶ms);
|
||||
BKE_camera_params_from_object(¶ms, v3d->camera);
|
||||
BKE_camera_params_compute_viewplane(¶ms, sizex, sizey, scene->r.xasp, scene->r.yasp);
|
||||
BKE_camera_params_compute_matrix(¶ms);
|
||||
|
||||
ED_view3d_draw_offscreen(scene, v3d, ar, sizex, sizey, NULL, params.winmat, draw_background);
|
||||
}
|
||||
@ -2673,10 +2673,10 @@ ImBuf *ED_view3d_draw_offscreen_imbuf_simple(Scene *scene, Object *camera, int w
|
||||
{
|
||||
CameraParams params;
|
||||
|
||||
camera_params_init(¶ms);
|
||||
camera_params_from_object(¶ms, v3d.camera);
|
||||
camera_params_compute_viewplane(¶ms, width, height, scene->r.xasp, scene->r.yasp);
|
||||
camera_params_compute_matrix(¶ms);
|
||||
BKE_camera_params_init(¶ms);
|
||||
BKE_camera_params_from_object(¶ms, v3d.camera);
|
||||
BKE_camera_params_compute_viewplane(¶ms, width, height, scene->r.xasp, scene->r.yasp);
|
||||
BKE_camera_params_compute_matrix(¶ms);
|
||||
|
||||
copy_m4_m4(rv3d.winmat, params.winmat);
|
||||
v3d.near = params.clipsta;
|
||||
|
@ -3660,8 +3660,8 @@ void ED_view3d_from_object(Object *ob, float ofs[3], float quat[4], float *dist,
|
||||
if (lens) {
|
||||
CameraParams params;
|
||||
|
||||
camera_params_init(¶ms);
|
||||
camera_params_from_object(¶ms, ob);
|
||||
BKE_camera_params_init(¶ms);
|
||||
BKE_camera_params_from_object(¶ms, ob);
|
||||
*lens = params.lens;
|
||||
}
|
||||
}
|
||||
|
@ -412,7 +412,7 @@ static int view3d_camera_to_view_selected_exec(bContext *C, wmOperator *UNUSED(o
|
||||
float r_co[3]; /* the new location to apply */
|
||||
|
||||
/* this function does all the important stuff */
|
||||
if (camera_view_frame_fit_to_scene(scene, v3d, camera_ob, r_co)) {
|
||||
if (BKE_camera_view_frame_fit_to_scene(scene, v3d, camera_ob, r_co)) {
|
||||
|
||||
ObjectTfmProtectedChannels obtfm;
|
||||
float obmat_new[4][4];
|
||||
@ -1000,8 +1000,8 @@ int ED_view3d_clip_range_get(View3D *v3d, RegionView3D *rv3d, float *clipsta, fl
|
||||
{
|
||||
CameraParams params;
|
||||
|
||||
camera_params_init(¶ms);
|
||||
camera_params_from_view3d(¶ms, v3d, rv3d);
|
||||
BKE_camera_params_init(¶ms);
|
||||
BKE_camera_params_from_view3d(¶ms, v3d, rv3d);
|
||||
|
||||
if (clipsta) *clipsta = params.clipsta;
|
||||
if (clipend) *clipend = params.clipend;
|
||||
@ -1015,9 +1015,9 @@ int ED_view3d_viewplane_get(View3D *v3d, RegionView3D *rv3d, int winx, int winy,
|
||||
{
|
||||
CameraParams params;
|
||||
|
||||
camera_params_init(¶ms);
|
||||
camera_params_from_view3d(¶ms, v3d, rv3d);
|
||||
camera_params_compute_viewplane(¶ms, winx, winy, 1.0f, 1.0f);
|
||||
BKE_camera_params_init(¶ms);
|
||||
BKE_camera_params_from_view3d(¶ms, v3d, rv3d);
|
||||
BKE_camera_params_compute_viewplane(¶ms, winx, winy, 1.0f, 1.0f);
|
||||
|
||||
if (viewplane) *viewplane = params.viewplane;
|
||||
if (clipsta) *clipsta = params.clipsta;
|
||||
|
@ -288,7 +288,7 @@ static void rna_Brush_set_size(PointerRNA *ptr, int value)
|
||||
Brush* brush = ptr->data;
|
||||
|
||||
/* scale unprojected radius so it stays consistent with brush size */
|
||||
brush_scale_unprojected_radius(&brush->unprojected_radius,
|
||||
BKE_brush_scale_unprojected_radius(&brush->unprojected_radius,
|
||||
value, brush->size);
|
||||
brush->size = value;
|
||||
}
|
||||
@ -298,7 +298,7 @@ static void rna_Brush_set_unprojected_radius(PointerRNA *ptr, float value)
|
||||
Brush* brush = ptr->data;
|
||||
|
||||
/* scale brush size so it stays consistent with unprojected_radius */
|
||||
brush_scale_size(&brush->size, value, brush->unprojected_radius);
|
||||
BKE_brush_scale_size(&brush->size, value, brush->unprojected_radius);
|
||||
brush->unprojected_radius = value;
|
||||
}
|
||||
|
||||
|
@ -46,14 +46,14 @@
|
||||
static float rna_Camera_angle_get(PointerRNA *ptr)
|
||||
{
|
||||
Camera *cam = ptr->id.data;
|
||||
float sensor = camera_sensor_size(cam->sensor_fit, cam->sensor_x, cam->sensor_y);
|
||||
float sensor = BKE_camera_sensor_size(cam->sensor_fit, cam->sensor_x, cam->sensor_y);
|
||||
return focallength_to_fov(cam->lens, sensor);
|
||||
}
|
||||
|
||||
static void rna_Camera_angle_set(PointerRNA *ptr, float value)
|
||||
{
|
||||
Camera *cam = ptr->id.data;
|
||||
float sensor = camera_sensor_size(cam->sensor_fit, cam->sensor_x, cam->sensor_y);
|
||||
float sensor = BKE_camera_sensor_size(cam->sensor_fit, cam->sensor_x, cam->sensor_y);
|
||||
cam->lens = fov_to_focallength(value, sensor);
|
||||
}
|
||||
|
||||
|
@ -46,7 +46,7 @@ void rna_camera_view_frame(struct Camera *camera, struct Scene *scene,
|
||||
{
|
||||
float vec[4][3];
|
||||
|
||||
camera_view_frame(scene, camera, vec);
|
||||
BKE_camera_view_frame(scene, camera, vec);
|
||||
|
||||
copy_v3_v3(vec1_r, vec[0]);
|
||||
copy_v3_v3(vec2_r, vec[1]);
|
||||
|
@ -92,7 +92,7 @@
|
||||
|
||||
Camera *rna_Main_cameras_new(Main *UNUSED(bmain), const char *name)
|
||||
{
|
||||
ID *id = add_camera(name);
|
||||
ID *id = BKE_camera_add(name);
|
||||
id_us_min(id);
|
||||
return (Camera *)id;
|
||||
}
|
||||
@ -385,7 +385,7 @@ void rna_Main_textures_remove(Main *bmain, ReportList *reports, struct Tex *tex)
|
||||
|
||||
Brush *rna_Main_brushes_new(Main *UNUSED(bmain), const char *name)
|
||||
{
|
||||
Brush *brush = add_brush(name);
|
||||
Brush *brush = BKE_brush_add(name);
|
||||
id_us_min(&brush->id);
|
||||
return brush;
|
||||
}
|
||||
|
@ -1370,7 +1370,7 @@ static void rna_UnifiedPaintSettings_size_set(PointerRNA *ptr, int value)
|
||||
UnifiedPaintSettings* ups = ptr->data;
|
||||
|
||||
/* scale unprojected radius so it stays consistent with brush size */
|
||||
brush_scale_unprojected_radius(&ups->unprojected_radius,
|
||||
BKE_brush_scale_unprojected_radius(&ups->unprojected_radius,
|
||||
value, ups->size);
|
||||
ups->size = value;
|
||||
}
|
||||
@ -1380,7 +1380,7 @@ static void rna_UnifiedPaintSettings_unprojected_radius_set(PointerRNA *ptr, flo
|
||||
UnifiedPaintSettings* ups = ptr->data;
|
||||
|
||||
/* scale brush size so it stays consistent with unprojected_radius */
|
||||
brush_scale_size(&ups->size, value, ups->unprojected_radius);
|
||||
BKE_brush_scale_size(&ups->size, value, ups->unprojected_radius);
|
||||
ups->unprojected_radius = value;
|
||||
}
|
||||
|
||||
|
@ -199,8 +199,8 @@ static DerivedMesh *uvprojectModifier_do(UVProjectModifierData *umd,
|
||||
free_uci= 1;
|
||||
}
|
||||
else {
|
||||
float sensor= camera_sensor_size(cam->sensor_fit, cam->sensor_x, cam->sensor_y);
|
||||
int sensor_fit= camera_sensor_fit(cam->sensor_fit, aspx, aspy);
|
||||
float sensor= BKE_camera_sensor_size(cam->sensor_fit, cam->sensor_x, cam->sensor_y);
|
||||
int sensor_fit= BKE_camera_sensor_fit(cam->sensor_fit, aspx, aspy);
|
||||
float scale= (cam->type == CAM_PERSP) ? cam->clipsta * sensor / cam->lens : cam->ortho_scale;
|
||||
float xmax, xmin, ymax, ymin;
|
||||
|
||||
|
@ -261,7 +261,7 @@ static void defocus_blur(bNode *node, CompBuf *new, CompBuf *img, CompBuf *zbuf,
|
||||
if (camob && camob->type==OB_CAMERA) {
|
||||
Camera* cam = (Camera*)camob->data;
|
||||
cam_lens = cam->lens;
|
||||
cam_fdist = object_camera_dof_distance(camob);
|
||||
cam_fdist = BKE_camera_object_dof_distance(camob);
|
||||
if (cam_fdist==0.0f) cam_fdist = 1e10f; /* if the dof is 0.0 then set it be be far away */
|
||||
cam_invfdist = 1.f/cam_fdist;
|
||||
}
|
||||
|
@ -463,7 +463,7 @@ static void re_camera_params_get(Render *re, CameraParams *params, Object *cam_o
|
||||
re->viewdy= params->viewdy;
|
||||
re->viewplane= params->viewplane;
|
||||
|
||||
object_camera_mode(&re->r, cam_ob);
|
||||
BKE_camera_object_mode(&re->r, cam_ob);
|
||||
}
|
||||
|
||||
void RE_SetEnvmapCamera(Render *re, Object *cam_ob, float viewscale, float clipsta, float clipend)
|
||||
@ -471,8 +471,8 @@ void RE_SetEnvmapCamera(Render *re, Object *cam_ob, float viewscale, float clips
|
||||
CameraParams params;
|
||||
|
||||
/* setup parameters */
|
||||
camera_params_init(¶ms);
|
||||
camera_params_from_object(¶ms, cam_ob);
|
||||
BKE_camera_params_init(¶ms);
|
||||
BKE_camera_params_from_object(¶ms, cam_ob);
|
||||
|
||||
params.lens= 16.0f*viewscale;
|
||||
params.sensor_x= 32.0f;
|
||||
@ -482,8 +482,8 @@ void RE_SetEnvmapCamera(Render *re, Object *cam_ob, float viewscale, float clips
|
||||
params.clipend= clipend;
|
||||
|
||||
/* compute matrix, viewplane, .. */
|
||||
camera_params_compute_viewplane(¶ms, re->winx, re->winy, 1.0f, 1.0f);
|
||||
camera_params_compute_matrix(¶ms);
|
||||
BKE_camera_params_compute_viewplane(¶ms, re->winx, re->winy, 1.0f, 1.0f);
|
||||
BKE_camera_params_compute_matrix(¶ms);
|
||||
|
||||
/* extract results */
|
||||
re_camera_params_get(re, ¶ms, cam_ob);
|
||||
@ -496,16 +496,16 @@ void RE_SetCamera(Render *re, Object *cam_ob)
|
||||
CameraParams params;
|
||||
|
||||
/* setup parameters */
|
||||
camera_params_init(¶ms);
|
||||
camera_params_from_object(¶ms, cam_ob);
|
||||
BKE_camera_params_init(¶ms);
|
||||
BKE_camera_params_from_object(¶ms, cam_ob);
|
||||
|
||||
params.use_fields= (re->r.mode & R_FIELDS);
|
||||
params.field_second= (re->flag & R_SEC_FIELD);
|
||||
params.field_odd= (re->r.mode & R_ODDFIELD);
|
||||
|
||||
/* compute matrix, viewplane, .. */
|
||||
camera_params_compute_viewplane(¶ms, re->winx, re->winy, re->r.xasp, re->r.yasp);
|
||||
camera_params_compute_matrix(¶ms);
|
||||
BKE_camera_params_compute_viewplane(¶ms, re->winx, re->winy, re->r.xasp, re->r.yasp);
|
||||
BKE_camera_params_compute_matrix(¶ms);
|
||||
|
||||
/* extract results */
|
||||
re_camera_params_get(re, ¶ms, cam_ob);
|
||||
|
@ -1872,7 +1872,7 @@ int RE_is_rendering_allowed(Scene *scene, Object *camera_override, ReportList *r
|
||||
}
|
||||
|
||||
/* get panorama & ortho, only after camera is set */
|
||||
object_camera_mode(&scene->r, camera_override ? camera_override : scene->camera);
|
||||
BKE_camera_object_mode(&scene->r, camera_override ? camera_override : scene->camera);
|
||||
|
||||
/* forbidden combinations */
|
||||
if (scene->r.mode & R_PANORAMA) {
|
||||
|
@ -177,7 +177,7 @@ static float get_avg_surrounds(float *cache, int *res, int xx, int yy, int zz)
|
||||
for (x=-1; x <= 1; x++) {
|
||||
x_ = xx+x;
|
||||
if (x_ >= 0 && x_ <= res[0]-1) {
|
||||
const int i= BLI_VEXEL_INDEX(x_, y_, z_, res);
|
||||
const int i = BLI_VOXEL_INDEX(x_, y_, z_, res);
|
||||
|
||||
if (cache[i] > 0.0f) {
|
||||
tot += cache[i];
|
||||
@ -208,7 +208,7 @@ static void lightcache_filter(VolumePrecache *vp)
|
||||
for (y=0; y < vp->res[1]; y++) {
|
||||
for (x=0; x < vp->res[0]; x++) {
|
||||
/* trigger for outside mesh */
|
||||
const int i= BLI_VEXEL_INDEX(x, y, z, vp->res);
|
||||
const int i = BLI_VOXEL_INDEX(x, y, z, vp->res);
|
||||
|
||||
if (vp->data_r[i] < -0.f)
|
||||
vp->data_r[i] = get_avg_surrounds(vp->data_r, vp->res, x, y, z);
|
||||
@ -240,7 +240,7 @@ static void lightcache_filter2(VolumePrecache *vp)
|
||||
for (y=0; y < vp->res[1]; y++) {
|
||||
for (x=0; x < vp->res[0]; x++) {
|
||||
/* trigger for outside mesh */
|
||||
const int i= BLI_VEXEL_INDEX(x, y, z, vp->res);
|
||||
const int i = BLI_VOXEL_INDEX(x, y, z, vp->res);
|
||||
if (vp->data_r[i] < -0.f)
|
||||
new_r[i] = get_avg_surrounds(vp->data_r, vp->res, x, y, z);
|
||||
if (vp->data_g[i] < -0.f)
|
||||
@ -291,7 +291,7 @@ static float total_ss_energy(Render *re, int do_test_break, VolumePrecache *vp)
|
||||
for (z=0; z < res[2]; z++) {
|
||||
for (y=0; y < res[1]; y++) {
|
||||
for (x=0; x < res[0]; x++) {
|
||||
const int i=BLI_VEXEL_INDEX(x, y, z, res);
|
||||
const int i = BLI_VOXEL_INDEX(x, y, z, res);
|
||||
|
||||
if (vp->data_r[i] > 0.f) energy += vp->data_r[i];
|
||||
if (vp->data_g[i] > 0.f) energy += vp->data_g[i];
|
||||
@ -527,7 +527,7 @@ static void *vol_precache_part(void *data)
|
||||
/* convert from world->camera space for shading */
|
||||
mul_v3_m4v3(cco, pa->viewmat, co);
|
||||
|
||||
i= BLI_VEXEL_INDEX(x, y, z, res);
|
||||
i = BLI_VOXEL_INDEX(x, y, z, res);
|
||||
|
||||
// don't bother if the point is not inside the volume mesh
|
||||
if (!point_inside_obi(tree, obi, cco)) {
|
||||
|
@ -184,7 +184,7 @@ static void load_frame_image_sequence(VoxelData *vd, Tex *tex)
|
||||
for (y=0; y < ibuf->y; y++) {
|
||||
for (x=0; x < ibuf->x; x++) {
|
||||
/* currently averaged to monchrome */
|
||||
vd->dataset[ BLI_VEXEL_INDEX(x, y, z, vd->resol) ] = (rf[0] + rf[1] + rf[2]) * 0.333f;
|
||||
vd->dataset[ BLI_VOXEL_INDEX(x, y, z, vd->resol) ] = (rf[0] + rf[1] + rf[2]) * 0.333f;
|
||||
rf +=4;
|
||||
}
|
||||
}
|
||||
|
@ -2987,7 +2987,7 @@ static void radial_control_set_tex(RadialControl *rc)
|
||||
|
||||
switch (RNA_type_to_ID_code(rc->image_id_ptr.type)) {
|
||||
case ID_BR:
|
||||
if ((ibuf = brush_gen_radial_control_imbuf(rc->image_id_ptr.data))) {
|
||||
if ((ibuf = BKE_brush_gen_radial_control_imbuf(rc->image_id_ptr.data))) {
|
||||
glGenTextures(1, &rc->gltex);
|
||||
glBindTexture(GL_TEXTURE_2D, rc->gltex);
|
||||
glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, ibuf->x, ibuf->y, 0,
|
||||
|
Loading…
Reference in New Issue
Block a user