BKE_sketch.h

Go to the documentation of this file.

/*
 * $Id: BKE_sketch.h 36644 2011-05-12 16:47:36Z campbellbarton $ 
 *
 * ***** BEGIN GPL LICENSE BLOCK *****
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * Contributor(s): none yet.
 *
 * ***** END GPL LICENSE BLOCK *****
 */
#ifndef BKE_SKETCH_H
#define BKE_SKETCH_H

typedef enum SK_PType
{
        PT_CONTINUOUS,
        PT_EXACT,
} SK_PType;

typedef enum SK_PMode
{
        PT_SNAP,
        PT_PROJECT,
} SK_PMode;

typedef struct SK_Point
{
        float p[3];
        short p2d[2];
        float no[3];
        float size;
        SK_PType type;
        SK_PMode mode;
} SK_Point;

typedef struct SK_Stroke
{
        struct SK_Stroke *next, *prev;

        SK_Point *points;
        int nb_points;
        int buf_size;
        int selected;
} SK_Stroke;

#define SK_OVERDRAW_LIMIT       5

typedef struct SK_Overdraw
{
        SK_Stroke *target;
        int     start, end;
        int count;
} SK_Overdraw;

#define SK_Stroke_BUFFER_INIT_SIZE 20

typedef struct SK_DrawData
{
        int mval[2];
        int previous_mval[2];
        SK_PType type;
} SK_DrawData;

typedef struct SK_Intersection
{
        struct SK_Intersection *next, *prev;
        SK_Stroke *stroke;
        int                     before;
        int                     after;
        int                     gesture_index;
        float           p[3];
        float           lambda; /* used for sorting intersection points */
} SK_Intersection;

typedef struct SK_Sketch
{
        ListBase        strokes;
        ListBase        depth_peels;
        SK_Stroke       *active_stroke;
        SK_Stroke       *gesture;
        SK_Point        next_point;
        SK_Overdraw over;
} SK_Sketch;


typedef struct SK_Gesture {
        SK_Stroke       *stk;
        SK_Stroke       *segments;

        ListBase        intersections;
        ListBase        self_intersections;

        int                     nb_self_intersections;
        int                     nb_intersections;
        int                     nb_segments;
} SK_Gesture;


/************************************************/

void freeSketch(SK_Sketch *sketch);
SK_Sketch* createSketch(void);

void sk_removeStroke(SK_Sketch *sketch, SK_Stroke *stk);

void sk_freeStroke(SK_Stroke *stk);
SK_Stroke* sk_createStroke(void);

SK_Point *sk_lastStrokePoint(SK_Stroke *stk);

void sk_allocStrokeBuffer(SK_Stroke *stk);
void sk_shrinkStrokeBuffer(SK_Stroke *stk);
void sk_growStrokeBuffer(SK_Stroke *stk);
void sk_growStrokeBufferN(SK_Stroke *stk, int n);

void sk_replaceStrokePoint(SK_Stroke *stk, SK_Point *pt, int n);
void sk_insertStrokePoint(SK_Stroke *stk, SK_Point *pt, int n);
void sk_appendStrokePoint(SK_Stroke *stk, SK_Point *pt);
void sk_insertStrokePoints(SK_Stroke *stk, SK_Point *pts, int len, int start, int end);

void sk_trimStroke(SK_Stroke *stk, int start, int end);
void sk_straightenStroke(SK_Stroke *stk, int start, int end, float p_start[3], float p_end[3]);
void sk_polygonizeStroke(SK_Stroke *stk, int start, int end);
void sk_flattenStroke(SK_Stroke *stk, int start, int end);
void sk_reverseStroke(SK_Stroke *stk);

void sk_filterLastContinuousStroke(SK_Stroke *stk);
void sk_filterStroke(SK_Stroke *stk, int start, int end);

void sk_initPoint(SK_Point *pt, SK_DrawData *dd, float *no);
void sk_copyPoint(SK_Point *dst, SK_Point *src);

int sk_stroke_filtermval(SK_DrawData *dd);
void sk_endContinuousStroke(SK_Stroke *stk);

void sk_updateNextPoint(SK_Sketch *sketch, SK_Stroke *stk);

void sk_initDrawData(SK_DrawData *dd, const int mval[2]);

void sk_deleteSelectedStrokes(SK_Sketch *sketch);
void sk_selectAllSketch(SK_Sketch *sketch, int mode);

#endif