code cleanup: brush/camera naming
authorCampbell Barton <ideasman42@gmail.com>
Sat, 5 May 2012 00:58:22 +0000 (00:58 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Sat, 5 May 2012 00:58:22 +0000 (00:58 +0000)
40 files changed:
source/blender/blenkernel/BKE_brush.h
source/blender/blenkernel/BKE_camera.h
source/blender/blenkernel/intern/brush.c
source/blender/blenkernel/intern/camera.c
source/blender/blenkernel/intern/constraint.c
source/blender/blenkernel/intern/library.c
source/blender/blenkernel/intern/object.c
source/blender/blenkernel/intern/paint.c
source/blender/blenlib/BLI_voxel.h
source/blender/blenlib/intern/voxel.c
source/blender/blenloader/intern/readfile.c
source/blender/collada/DocumentImporter.cpp
source/blender/editors/object/object_add.c
source/blender/editors/object/object_relations.c
source/blender/editors/physics/particle_edit.c
source/blender/editors/sculpt_paint/paint_cursor.c
source/blender/editors/sculpt_paint/paint_image.c
source/blender/editors/sculpt_paint/paint_ops.c
source/blender/editors/sculpt_paint/paint_stroke.c
source/blender/editors/sculpt_paint/paint_utils.c
source/blender/editors/sculpt_paint/paint_vertex.c
source/blender/editors/sculpt_paint/sculpt.c
source/blender/editors/sculpt_paint/sculpt_uv.c
source/blender/editors/space_image/image_draw.c
source/blender/editors/space_view3d/drawobject.c
source/blender/editors/space_view3d/view3d_draw.c
source/blender/editors/space_view3d/view3d_edit.c
source/blender/editors/space_view3d/view3d_view.c
source/blender/makesrna/intern/rna_brush.c
source/blender/makesrna/intern/rna_camera.c
source/blender/makesrna/intern/rna_camera_api.c
source/blender/makesrna/intern/rna_main_api.c
source/blender/makesrna/intern/rna_scene.c
source/blender/modifiers/intern/MOD_uvproject.c
source/blender/nodes/composite/nodes/node_composite_defocus.c
source/blender/render/intern/source/initrender.c
source/blender/render/intern/source/pipeline.c
source/blender/render/intern/source/volume_precache.c
source/blender/render/intern/source/voxeldata.c
source/blender/windowmanager/intern/wm_operators.c

index 52666ca1538d08d6e93c8430d48481be00d6e58a..b5edc8f3e50c0e0788875d681c3cbf2c3f80ed61 100644 (file)
@@ -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
 
index 6d10219e74c5daa378e8b1b9770123089be3cd86..8f68d7abcacb8883fa722921dac4b7e8d0e4109a 100644 (file)
@@ -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]);
 
index b3d128bf2b47f51a6eed09ee5ef83012a69ea76a..51258b13f68af422a2a77665de2fdd513bafd52b 100644 (file)
@@ -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);
                }
        }
 
index 6b1c6a26493ac504ad156b2a16d1a2e286e61ec3..11c628e78482d99407fba01c59cdb211b2f9838b 100644 (file)
@@ -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;
index 47b497188ec5e241bd0a851f276f6591ac773c7d..424ded0397ef51dc803504d5d079346fa83c3c8c 100644 (file)
@@ -4012,8 +4012,8 @@ static void followtrack_evaluate(bConstraint *con, bConstraintOb *cob, ListBase
 
                        add_v2_v2v2(pos, marker->pos, track->offset);
 
-                       camera_params_init(&params);
-                       camera_params_from_object(&params, camob);
+                       BKE_camera_params_init(&params);
+                       BKE_camera_params_from_object(&params, camob);
 
                        if (params.is_ortho) {
                                vec[0] = params.ortho_scale * (pos[0] - 0.5f + params.shiftx);
index 14ab8166f0a915786531b99b61b789a23bafe91e..14e2d75bee501005b7bd63bb2f750d375d2a216d 100644 (file)
@@ -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);
index 280a8fdc2b20fdce4603e285708d3d15a6983396..fde8f8e3f3d1ce50bcab312d8b60429aca0af5ac 100644 (file)
@@ -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");
index f417f9b79fbbe9bf9f6ea86d9f64b8d767f0ed6d..08d8479fd93990953a07254e057d27cdea996ab9 100644 (file)
@@ -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);
index 4e9e6f111dbbd00ce5a7a4962b81b6fff9011fb5..7b92ac05d292a8643f78a44fd8ea643b945376f2 100644 (file)
@@ -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]);
index 1fe42384eb62ab35b430ad672499eed07d6858ea..3ad9edd14a3b28d59d0c08f0079ea9a4be6e5032 100644 (file)
@@ -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 *** */
index c07b1d4f66a8dad01b1d07a92ca6fff202ca5c58..c0ae6415fe1e0532774380f6529ec71cb15dcfe8 100644 (file)
@@ -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;
index c793453227ad6cfd9b66bacce405331a8f8ee542..1d315b6ea061512e859d074d5a174517b0a8a151 100644 (file)
@@ -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");
index 85735c1ac1c7096b45de6307b3487431856cc30c..d030e61952ecfa835e8134f68e51dac80ac900b5 100644 (file)
@@ -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--;
index 35b3b0a0407c84e1d26670ff78b0f84deb3d6b6f..4678416e1c917f730171bf11646e1bdd127325c2 100644 (file)
@@ -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);
index ba80fd83de71b962d4b0edcd784a44521190a460..7fb5352979d9d0e7c985fbc44a380a875ef585f2 100644 (file)
@@ -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;
index 553a9a335d7ec6b691e207f068b5fae71fc68162..c681f8ddb7566b9ff633100681a1334894bd36fe 100644 (file)
@@ -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
index dcf4efeff132e29e2eec710e1c6ba89662658c0d..a025a84bea9d99c0cadbf3d631fd9e85e8c25d6e 100644 (file)
@@ -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(&params);
-                               camera_params_from_object(&params, cam_ob);
-                               camera_params_compute_viewplane(&params, ps->winx, ps->winy, 1.0f, 1.0f);
-                               camera_params_compute_matrix(&params);
+                               BKE_camera_params_init(&params);
+                               BKE_camera_params_from_object(&params, cam_ob);
+                               BKE_camera_params_compute_viewplane(&params, ps->winx, ps->winy, 1.0f, 1.0f);
+                               BKE_camera_params_compute_matrix(&params);
 
                                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;
 }
index e218cfe8fd2c96bf671d0223c6cfd36923c2d746..2699e9f56f84f1b890079dfb01056691fe1f9c16 100644 (file)
@@ -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;
index 010278e86212ca99cc4d96d84da267d039c8abb4..fe228839c47c486831caa5a84c63fbe5a3c27c79 100644 (file)
@@ -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);
 
index 89a46272a8f80feefa42188c0bec55da2ec22638..fb5ddda7a3e8556ecbf4d955a792b2efa208809b 100644 (file)
@@ -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;
 }
index 9c89eb7c573960aa06513865002cc6096b428300..37d5af553abd8f046589d828b01490005b680bc5 100644 (file)
@@ -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);
 
index 32ed55854b6bb48158e1690578cabbba987d1bcb..fa560dc138c66e9ccc34dc89589f7b276a05d75d 100644 (file)
@@ -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);
index 707d5b2aa7c204c9e97c446adcc5c4110693e04f..95441600d77d8e8b8e81bf9f84ed2078e26f12fb 100644 (file)
@@ -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;
index 793e5712c8c02b4b48e8089a773f51ecd592b166..aab628180c880c870d049d37f3164ba933b746ed 100644 (file)
@@ -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) {
index c8754681e41a4fa69cb37f771b4aedca1605fd81..068a31a888ffc70e232c69aeb9f2a630828df837 100644 (file)
@@ -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;
index e1828bbef32299ba714f4274554ba6480e855723..f48b45f97939fb2ab5517e1903ce1110d7361a65 100644 (file)
@@ -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(&params);
-       camera_params_from_view3d(&params, v3d, rv3d);
+       BKE_camera_params_init(&params);
+       BKE_camera_params_from_view3d(&params, v3d, rv3d);
        if (no_zoom)
                params.zoom = 1.0f;
-       camera_params_compute_viewplane(&params, ar->winx, ar->winy, 1.0f, 1.0f);
+       BKE_camera_params_compute_viewplane(&params, ar->winx, ar->winy, 1.0f, 1.0f);
        rect_view = params.viewplane;
 
        /* get camera viewplane */
-       camera_params_init(&params);
-       camera_params_from_object(&params, v3d->camera);
+       BKE_camera_params_init(&params);
+       BKE_camera_params_from_object(&params, v3d->camera);
        if (no_shift) {
                params.shiftx = 0.0f;
                params.shifty = 0.0f;
        }
-       camera_params_compute_viewplane(&params, scene->r.xsch, scene->r.ysch, scene->r.xasp, scene->r.yasp);
+       BKE_camera_params_compute_viewplane(&params, 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(&params);
-               camera_params_from_object(&params, v3d->camera);
-               camera_params_compute_viewplane(&params, sizex, sizey, scene->r.xasp, scene->r.yasp);
-               camera_params_compute_matrix(&params);
+               BKE_camera_params_init(&params);
+               BKE_camera_params_from_object(&params, v3d->camera);
+               BKE_camera_params_compute_viewplane(&params, sizex, sizey, scene->r.xasp, scene->r.yasp);
+               BKE_camera_params_compute_matrix(&params);
 
                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(&params);
-               camera_params_from_object(&params, v3d.camera);
-               camera_params_compute_viewplane(&params, width, height, scene->r.xasp, scene->r.yasp);
-               camera_params_compute_matrix(&params);
+               BKE_camera_params_init(&params);
+               BKE_camera_params_from_object(&params, v3d.camera);
+               BKE_camera_params_compute_viewplane(&params, width, height, scene->r.xasp, scene->r.yasp);
+               BKE_camera_params_compute_matrix(&params);
 
                copy_m4_m4(rv3d.winmat, params.winmat);
                v3d.near = params.clipsta;
index 39cda3efd9308aa0b8939fdcea36d0ce22615033..ea4d28ce32fa65485fcfd02294b353975d6ba9a7 100644 (file)
@@ -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(&params);
-               camera_params_from_object(&params, ob);
+               BKE_camera_params_init(&params);
+               BKE_camera_params_from_object(&params, ob);
                *lens = params.lens;
        }
 }
index 8a0cb4b597b8da6029912267bcd782a1693f03aa..733c5c55bfcc74da691d43b6709e16bb4801dbe8 100644 (file)
@@ -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(&params);
-       camera_params_from_view3d(&params, v3d, rv3d);
+       BKE_camera_params_init(&params);
+       BKE_camera_params_from_view3d(&params, 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(&params);
-       camera_params_from_view3d(&params, v3d, rv3d);
-       camera_params_compute_viewplane(&params, winx, winy, 1.0f, 1.0f);
+       BKE_camera_params_init(&params);
+       BKE_camera_params_from_view3d(&params, v3d, rv3d);
+       BKE_camera_params_compute_viewplane(&params, winx, winy, 1.0f, 1.0f);
 
        if (viewplane) *viewplane = params.viewplane;
        if (clipsta) *clipsta = params.clipsta;
index bdff545df5ce471a696f031683a10d04d3c375fc..ee4b34508d1857ade878ecd4714e1a632541c921 100644 (file)
@@ -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;
 }
 
index 5331cfe8775a251cbf703b4a7a0865acb981d941..70a33734c3f75faa246ebb75b1fb22e993665b6d 100644 (file)
 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);
 }
 
index 14391e74239e85db7b369d521186b0df010dd919..2d19047ef893ae67da0ec9e7c85b264ecfcdb31c 100644 (file)
@@ -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]);
index 63006af7c7269009539759e823f6a43eb6bd1b3d..f00126986a517f7a245c5bc6155732ca6bd376d9 100644 (file)
@@ -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;
 }
index eb3c1c75cf46f8e18cdf96d6c81f841a36825a55..d9f5ca1f9ed448896c3dd3f32909190fcc04333d 100644 (file)
@@ -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;
 }
 
index 4f8fd83491f832d97ee3617cae944afa4c58e9a0..ef8cf24987c1bb78fe1aee648bae4bf3a500b153 100644 (file)
@@ -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;
 
index fc6e6847f34caf079f5cb19297177f7af1d15c10..72dec01066e693b90aecaaec6988f52f73998cbd 100644 (file)
@@ -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;
        }
index 56aadfd63d002e88632d43c811890de3c1bc8255..e712950f4f8bf85d36e332b96ce91c19169461a7 100644 (file)
@@ -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(&params);
-       camera_params_from_object(&params, cam_ob);
+       BKE_camera_params_init(&params);
+       BKE_camera_params_from_object(&params, 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(&params, re->winx, re->winy, 1.0f, 1.0f);
-       camera_params_compute_matrix(&params);
+       BKE_camera_params_compute_viewplane(&params, re->winx, re->winy, 1.0f, 1.0f);
+       BKE_camera_params_compute_matrix(&params);
 
        /* extract results */
        re_camera_params_get(re, &params, cam_ob);
@@ -496,16 +496,16 @@ void RE_SetCamera(Render *re, Object *cam_ob)
        CameraParams params;
 
        /* setup parameters */
-       camera_params_init(&params);
-       camera_params_from_object(&params, cam_ob);
+       BKE_camera_params_init(&params);
+       BKE_camera_params_from_object(&params, 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(&params, re->winx, re->winy, re->r.xasp, re->r.yasp);
-       camera_params_compute_matrix(&params);
+       BKE_camera_params_compute_viewplane(&params, re->winx, re->winy, re->r.xasp, re->r.yasp);
+       BKE_camera_params_compute_matrix(&params);
 
        /* extract results */
        re_camera_params_get(re, &params, cam_ob);
index 9ca2337e27fc99985bfcd0b4e43e2d7983d51b0b..f0fea0725303f0c853b3c4b12eef92b6650e7f94 100644 (file)
@@ -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) {
index e7c97574629c0cbe235324d4c267ffeb1afad7c9..ff715eeca07db121f48047a351f97ff30062186f 100644 (file)
@@ -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)) {
index 5135061bc5cf2e3fd9798ee7ff4838d96192ac7e..90e6594d888a7e1f4377191e4fd60e4abe98262f 100644 (file)
@@ -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;
                        }
                }
index cc4cf030988e5a78b6f648d379d3e8eb334cfaa1..db0429d33abd94db28ddbbf1a761cb2ba734b2fd 100644 (file)
@@ -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,