More cruft remove for 2d painting. Remove functions from brush interface
authorAntony Riakiotakis <kalast@gmail.com>
Sun, 10 Mar 2013 18:05:13 +0000 (18:05 +0000)
committerAntony Riakiotakis <kalast@gmail.com>
Sun, 10 Mar 2013 18:05:13 +0000 (18:05 +0000)
that were in fact 2d painting specific. Also remove old stroke managing
function completely.

source/blender/blenkernel/BKE_brush.h
source/blender/editors/sculpt_paint/paint_image_2d.c

index 95c39ba..3c65cb0 100644 (file)
@@ -74,19 +74,6 @@ void BKE_brush_sample_tex_2D(const struct Scene *scene, struct Brush *brush, con
 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 */
-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_2d_new(struct Scene *scene, struct Brush *brush);
-void brush_painter_2d_require_imbuf(BrushPainter *painter, short flt,
-                                     short texonly, int size);
-int brush_painter_2d_paint(BrushPainter *painter, BrushFunc func, const float pos[2],
-                            double time, float pressure, void *user, int use_color_correction);
-void brush_painter_2d_break_stroke(BrushPainter *painter);
-void brush_painter_2d_free(BrushPainter *painter);
-
 /* texture */
 unsigned int *BKE_brush_gen_texture_cache(struct Brush *br, int half_side);
 
index 5447ad0..8a2ff2b 100644 (file)
@@ -86,6 +86,34 @@ BLI_INLINE unsigned char f_to_char(const float val)
 
 #define IMAPAINT_FLOAT_RGB_COPY(a, b) copy_v3_v3(a, b)
 
+typedef struct BrushPainterCache {
+       short enabled;
+
+       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 */
+
+       int lastsize;
+       float lastalpha;
+       float lastjitter;
+
+       ImBuf *ibuf;
+       ImBuf *texibuf;
+       ImBuf *maskibuf;
+} BrushPainterCache;
+
+typedef struct BrushPainter {
+       Scene *scene;
+       Brush *brush;
+
+       float lastpaintpos[2];  /* position of last paint op */
+       float startpaintpos[2]; /* position of first paint */
+
+       short firsttouch;       /* first paint op */
+
+       BrushPainterCache cache;
+} BrushPainter;
+
 typedef struct ImagePaintRegion {
        int destx, desty;
        int srcx, srcy;
@@ -114,48 +142,8 @@ typedef struct ImagePaintState {
        int do_facesel;
 } ImagePaintState;
 
-typedef struct BrushPainterCache {
-       short enabled;
-
-       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 */
-
-       int lastsize;
-       float lastalpha;
-       float lastjitter;
-
-       ImBuf *ibuf;
-       ImBuf *texibuf;
-       ImBuf *maskibuf;
-} BrushPainterCache;
-
-struct BrushPainter {
-       Scene *scene;
-       Brush *brush;
-
-       float lastmousepos[2];  /* mouse position of last paint call */
-
-       float accumdistance;    /* accumulated distance of brush since last paint op */
-       float lastpaintpos[2];  /* position of last paint op */
-       float startpaintpos[2]; /* position of first paint */
-
-       double accumtime;       /* accumulated time since last paint op (airbrush) */
-       double lasttime;        /* time of last update */
-
-       float lastpressure;
-
-       short firsttouch;       /* first paint op */
-
-       float startsize;
-       float startalpha;
-       float startjitter;
-       float startspacing;
-
-       BrushPainterCache cache;
-};
 
-BrushPainter *brush_painter_2d_new(Scene *scene, Brush *brush)
+static BrushPainter *brush_painter_2d_new(Scene *scene, Brush *brush)
 {
        BrushPainter *painter = MEM_callocN(sizeof(BrushPainter), "BrushPainter");
 
@@ -164,25 +152,11 @@ BrushPainter *brush_painter_2d_new(Scene *scene, Brush *brush)
        painter->firsttouch = 1;
        painter->cache.lastsize = -1; /* force ibuf create in refresh */
 
-       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;
 }
 
 
-static void brush_pressure_apply(BrushPainter *painter, Brush *brush, float pressure)
-{
-       if (BKE_brush_use_alpha_pressure(painter->scene, brush))
-               BKE_brush_alpha_set(painter->scene, brush, max_ff(0.0f, painter->startalpha * pressure));
-       if (BKE_brush_use_size_pressure(painter->scene, brush))
-               BKE_brush_size_set(painter->scene, brush, max_ff(1.0f, painter->startsize * pressure));
-}
-
-
-void brush_painter_2d_require_imbuf(BrushPainter *painter, short flt, short texonly, int size)
+static void brush_painter_2d_require_imbuf(BrushPainter *painter, short flt, short texonly, int size)
 {
        if ((painter->cache.flt != flt) || (painter->cache.size != size) ||
            ((painter->cache.texonly != texonly) && texonly))
@@ -205,15 +179,8 @@ void brush_painter_2d_require_imbuf(BrushPainter *painter, short flt, short texo
        painter->cache.enabled = 1;
 }
 
-void brush_painter_2d_free(BrushPainter *painter)
+static void brush_painter_2d_free(BrushPainter *painter)
 {
-       Brush *brush = painter->brush;
-
-       BKE_brush_size_set(painter->scene, brush, painter->startsize);
-       BKE_brush_alpha_set(painter->scene, brush, painter->startalpha);
-       brush->jitter = painter->startjitter;
-       brush->spacing = painter->startspacing;
-
        if (painter->cache.ibuf) IMB_freeImBuf(painter->cache.ibuf);
        if (painter->cache.texibuf) IMB_freeImBuf(painter->cache.texibuf);
        if (painter->cache.maskibuf) IMB_freeImBuf(painter->cache.maskibuf);
@@ -413,173 +380,6 @@ static void brush_painter_2d_refresh_cache(BrushPainter *painter, const float po
        }
 }
 
-void brush_painter_2d_break_stroke(BrushPainter *painter)
-{
-       painter->firsttouch = 1;
-}
-
-
-int brush_painter_2d_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;
-       int totpaintops = 0;
-
-       if (pressure == 0.0f) {
-               if (painter->lastpressure) // XXX - hack, operator misses
-                       pressure = painter->lastpressure;
-               else
-                       pressure = 1.0f;    /* zero pressure == not using tablet */
-       }
-       if (painter->firsttouch) {
-               /* paint exactly once on first touch */
-               painter->startpaintpos[0] = pos[0];
-               painter->startpaintpos[1] = pos[1];
-
-               brush_pressure_apply(painter, brush, pressure);
-               if (painter->cache.enabled)
-                       brush_painter_2d_refresh_cache(painter, pos, use_color_correction);
-               totpaintops += func(user, painter->cache.ibuf, pos, pos);
-               
-               painter->lasttime = time;
-               painter->firsttouch = 0;
-               painter->lastpaintpos[0] = pos[0];
-               painter->lastpaintpos[1] = pos[1];
-       }
-#if 0
-       else if (painter->brush->flag & BRUSH_AIRBRUSH) {
-               float spacing, step, paintpos[2], dmousepos[2], len;
-               double starttime, curtime = time;
-
-               /* compute brush spacing adapted to brush size */
-               spacing = brush->rate; //radius*brush->spacing * 0.01f;
-
-               /* setup starting time, direction vector and accumulated time */
-               starttime = painter->accumtime;
-               sub_v2_v2v2(dmousepos, pos, painter->lastmousepos);
-               len = normalize_v2(dmousepos);
-               painter->accumtime += curtime - painter->lasttime;
-
-               /* do paint op over unpainted time distance */
-               while (painter->accumtime >= spacing) {
-                       step = (spacing - starttime) * len;
-                       paintpos[0] = painter->lastmousepos[0] + dmousepos[0] * step;
-                       paintpos[1] = painter->lastmousepos[1] + dmousepos[1] * step;
-
-                       if (painter->cache.enabled)
-                               brush_painter_refresh_cache(painter);
-                       totpaintops += func(user, painter->cache.ibuf,
-                                           painter->lastpaintpos, paintpos);
-
-                       painter->lastpaintpos[0] = paintpos[0];
-                       painter->lastpaintpos[1] = paintpos[1];
-                       painter->accumtime -= spacing;
-                       starttime -= spacing;
-               }
-               
-               painter->lasttime = curtime;
-       }
-#endif
-       else {
-               float startdistance, spacing, step, paintpos[2], dmousepos[2], finalpos[2];
-               float t, len, press;
-               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_pressure_apply(painter, brush, painter->lastpressure);
-               spacing = max_ff(1.0f, radius) * brush->spacing * 0.01f;
-
-               /* setup starting distance, direction vector and accumulated distance */
-               startdistance = painter->accumdistance;
-               sub_v2_v2v2(dmousepos, pos, painter->lastmousepos);
-               len = normalize_v2(dmousepos);
-               painter->accumdistance += len;
-
-               if (brush->flag & BRUSH_SPACE) {
-                       /* do paint op over unpainted distance */
-                       while ((len > 0.0f) && (painter->accumdistance >= spacing)) {
-                               step = spacing - startdistance;
-                               paintpos[0] = painter->lastmousepos[0] + dmousepos[0] * step;
-                               paintpos[1] = painter->lastmousepos[1] + dmousepos[1] * step;
-
-                               t = step / len;
-                               press = (1.0f - t) * painter->lastpressure + t * pressure;
-                               brush_pressure_apply(painter, brush, press);
-                               spacing = max_ff(1.0f, radius) * brush->spacing * 0.01f;
-
-                               BKE_brush_jitter_pos(scene, brush, paintpos, finalpos);
-
-                               if (painter->cache.enabled)
-                                       brush_painter_2d_refresh_cache(painter, finalpos, use_color_correction);
-
-                               totpaintops +=
-                                   func(user, painter->cache.ibuf, painter->lastpaintpos, finalpos);
-
-                               painter->lastpaintpos[0] = paintpos[0];
-                               painter->lastpaintpos[1] = paintpos[1];
-                               painter->accumdistance -= spacing;
-                               startdistance -= spacing;
-                       }
-               }
-               else {
-                       BKE_brush_jitter_pos(scene, brush, pos, finalpos);
-
-                       if (painter->cache.enabled)
-                               brush_painter_2d_refresh_cache(painter, finalpos, use_color_correction);
-
-                       totpaintops += func(user, painter->cache.ibuf, pos, finalpos);
-
-                       painter->lastpaintpos[0] = pos[0];
-                       painter->lastpaintpos[1] = pos[1];
-                       painter->accumdistance = 0;
-               }
-
-               /* do airbrush paint ops, based on the number of paint ops left over
-                * from regular painting. this is a temporary solution until we have
-                * accurate time stamps for mouse move events */
-               if (brush->flag & BRUSH_AIRBRUSH) {
-                       double curtime = time;
-                       double painttime = brush->rate * totpaintops;
-
-                       painter->accumtime += curtime - painter->lasttime;
-                       if (painter->accumtime <= painttime)
-                               painter->accumtime = 0.0;
-                       else
-                               painter->accumtime -= painttime;
-
-                       while (painter->accumtime >= (double)brush->rate) {
-                               brush_pressure_apply(painter, brush, pressure);
-
-                               BKE_brush_jitter_pos(scene, brush, pos, finalpos);
-
-                               if (painter->cache.enabled)
-                                       brush_painter_2d_refresh_cache(painter, finalpos, use_color_correction);
-
-                               totpaintops +=
-                                   func(user, painter->cache.ibuf, painter->lastmousepos, finalpos);
-                               painter->accumtime -= (double)brush->rate;
-                       }
-
-                       painter->lasttime = curtime;
-               }
-       }
-
-       painter->lastmousepos[0] = pos[0];
-       painter->lastmousepos[1] = pos[1];
-       painter->lastpressure = pressure;
-
-       BKE_brush_alpha_set(scene, brush, painter->startalpha);
-       BKE_brush_size_set(scene, brush, painter->startsize);
-       brush->jitter = painter->startjitter;
-       brush->spacing = painter->startspacing;
-
-       return totpaintops;
-}
-
-/* Image Paint Operations */
-
 /* keep these functions in sync */
 static void paint_2d_ibuf_rgb_get(ImBuf *ibuf, int x, int y, const short is_torus, float r_rgb[3])
 {