forked from bartvdbraak/blender
GPencil: Picky whitespace cleanup
This commit is contained in:
parent
3253ed9e26
commit
fd47202043
@ -27,6 +27,7 @@
|
||||
* \ingroup edgpencil
|
||||
*/
|
||||
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
@ -92,15 +93,15 @@ static void gp_draw_stroke_buffer(tGPspoint *points, int totpoints, short thickn
|
||||
{
|
||||
tGPspoint *pt;
|
||||
int i;
|
||||
|
||||
|
||||
/* error checking */
|
||||
if ((points == NULL) || (totpoints <= 0))
|
||||
return;
|
||||
|
||||
|
||||
/* check if buffer can be drawn */
|
||||
if (dflag & (GP_DRAWDATA_ONLY3D | GP_DRAWDATA_ONLYV2D))
|
||||
return;
|
||||
|
||||
|
||||
/* if drawing a single point, draw it larger */
|
||||
if (totpoints == 1) {
|
||||
/* draw point */
|
||||
@ -113,7 +114,7 @@ static void gp_draw_stroke_buffer(tGPspoint *points, int totpoints, short thickn
|
||||
}
|
||||
else {
|
||||
float oldpressure = points[0].pressure;
|
||||
|
||||
|
||||
/* draw stroke curve */
|
||||
if (G.debug & G_DEBUG) setlinestyle(2);
|
||||
|
||||
@ -128,13 +129,13 @@ static void gp_draw_stroke_buffer(tGPspoint *points, int totpoints, short thickn
|
||||
glEnd();
|
||||
glLineWidth(pt->pressure * thickness);
|
||||
glBegin(GL_LINE_STRIP);
|
||||
|
||||
|
||||
/* need to roll-back one point to ensure that there are no gaps in the stroke */
|
||||
if (i != 0) glVertex2iv(&(pt - 1)->x);
|
||||
|
||||
/* now the point we want... */
|
||||
glVertex2iv(&pt->x);
|
||||
|
||||
|
||||
oldpressure = pt->pressure;
|
||||
}
|
||||
else
|
||||
@ -144,7 +145,7 @@ static void gp_draw_stroke_buffer(tGPspoint *points, int totpoints, short thickn
|
||||
|
||||
/* reset for predictable OpenGL context */
|
||||
glLineWidth(1.0f);
|
||||
|
||||
|
||||
if (G.debug & G_DEBUG) setlinestyle(0);
|
||||
}
|
||||
}
|
||||
@ -161,14 +162,14 @@ static void gp_calc_2d_stroke_xy(bGPDspoint *pt, short sflag, int offsx, int off
|
||||
else if (sflag & GP_STROKE_2DIMAGE) {
|
||||
const float x = (float)((pt->x * winx) + offsx);
|
||||
const float y = (float)((pt->y * winy) + offsy);
|
||||
|
||||
|
||||
r_co[0] = x;
|
||||
r_co[1] = y;
|
||||
}
|
||||
else {
|
||||
const float x = (float)(pt->x / 100 * winx) + offsx;
|
||||
const float y = (float)(pt->y / 100 * winy) + offsy;
|
||||
|
||||
|
||||
r_co[0] = x;
|
||||
r_co[1] = y;
|
||||
}
|
||||
@ -184,39 +185,39 @@ static void gp_draw_stroke_volumetric_buffer(tGPspoint *points, int totpoints, s
|
||||
{
|
||||
GLUquadricObj *qobj = gluNewQuadric();
|
||||
float modelview[4][4];
|
||||
|
||||
|
||||
tGPspoint *pt;
|
||||
int i;
|
||||
|
||||
|
||||
/* error checking */
|
||||
if ((points == NULL) || (totpoints <= 0))
|
||||
return;
|
||||
|
||||
|
||||
/* check if buffer can be drawn */
|
||||
if (dflag & (GP_DRAWDATA_ONLY3D | GP_DRAWDATA_ONLYV2D))
|
||||
return;
|
||||
|
||||
|
||||
/* get basic matrix - should be camera space (i.e "identity") */
|
||||
glGetFloatv(GL_MODELVIEW_MATRIX, (float *)modelview);
|
||||
|
||||
|
||||
/* draw points */
|
||||
glPushMatrix();
|
||||
|
||||
|
||||
for (i = 0, pt = points; i < totpoints; i++, pt++) {
|
||||
/* set the transformed position */
|
||||
// TODO: scale should change based on zoom level, which requires proper translation mult too!
|
||||
modelview[3][0] = pt->x;
|
||||
modelview[3][1] = pt->y;
|
||||
|
||||
|
||||
glLoadMatrixf((float *)modelview);
|
||||
|
||||
|
||||
/* draw the disk using the current state... */
|
||||
gluDisk(qobj, 0.0, pt->pressure * thickness, 32, 1);
|
||||
|
||||
|
||||
|
||||
|
||||
modelview[3][0] = modelview[3][1] = 0.0f;
|
||||
}
|
||||
|
||||
|
||||
glPopMatrix();
|
||||
gluDeleteQuadric(qobj);
|
||||
}
|
||||
@ -230,10 +231,10 @@ static void gp_draw_stroke_volumetric_2d(bGPDspoint *points, int totpoints, shor
|
||||
float modelview[4][4];
|
||||
float baseloc[3];
|
||||
float scalefac = 1.0f;
|
||||
|
||||
|
||||
bGPDspoint *pt;
|
||||
int i;
|
||||
|
||||
|
||||
|
||||
/* HACK: We need a scale factor for the drawing in the image editor,
|
||||
* which seems to use 1 unit as it's maximum size, whereas everything
|
||||
@ -242,30 +243,30 @@ static void gp_draw_stroke_volumetric_2d(bGPDspoint *points, int totpoints, shor
|
||||
if ((dflag & GP_DRAWDATA_IEDITHACK) && (dflag & GP_DRAWDATA_ONLYV2D)) {
|
||||
scalefac = 0.001f;
|
||||
}
|
||||
|
||||
|
||||
/* get basic matrix */
|
||||
glGetFloatv(GL_MODELVIEW_MATRIX, (float *)modelview);
|
||||
copy_v3_v3(baseloc, modelview[3]);
|
||||
|
||||
|
||||
/* draw points */
|
||||
glPushMatrix();
|
||||
|
||||
|
||||
for (i = 0, pt = points; i < totpoints; i++, pt++) {
|
||||
/* set the transformed position */
|
||||
float co[2];
|
||||
|
||||
|
||||
gp_calc_2d_stroke_xy(pt, sflag, offsx, offsy, winx, winy, co);
|
||||
translate_m4(modelview, co[0], co[1], 0.0f);
|
||||
|
||||
|
||||
glLoadMatrixf((float *)modelview);
|
||||
|
||||
|
||||
/* draw the disk using the current state... */
|
||||
gluDisk(qobj, 0.0, pt->pressure * thickness * scalefac, 32, 1);
|
||||
|
||||
|
||||
/* restore matrix */
|
||||
copy_v3_v3(modelview[3], baseloc);
|
||||
}
|
||||
|
||||
|
||||
glPopMatrix();
|
||||
gluDeleteQuadric(qobj);
|
||||
}
|
||||
@ -275,48 +276,48 @@ static void gp_draw_stroke_volumetric_3d(bGPDspoint *points, int totpoints, shor
|
||||
short UNUSED(dflag), short UNUSED(sflag))
|
||||
{
|
||||
GLUquadricObj *qobj = gluNewQuadric();
|
||||
|
||||
|
||||
float base_modelview[4][4], modelview[4][4];
|
||||
float base_loc[3];
|
||||
|
||||
|
||||
bGPDspoint *pt;
|
||||
int i;
|
||||
|
||||
|
||||
|
||||
/* Get the basic modelview matrix we use for performing calculations */
|
||||
glGetFloatv(GL_MODELVIEW_MATRIX, (float *)base_modelview);
|
||||
copy_v3_v3(base_loc, base_modelview[3]);
|
||||
|
||||
|
||||
/* Create the basic view-aligned billboard matrix we're going to actually draw qobj with:
|
||||
* - We need to knock out the rotation so that we are
|
||||
* - We need to knock out the rotation so that we are
|
||||
* simply left with a camera-facing billboard
|
||||
* - The scale factors here are chosen so that the thickness
|
||||
* is relatively reasonable. Otherwise, it gets far too
|
||||
* large!
|
||||
*/
|
||||
scale_m4_fl(modelview, 0.1f);
|
||||
|
||||
|
||||
/* draw each point as a disk... */
|
||||
glPushMatrix();
|
||||
|
||||
|
||||
for (i = 0, pt = points; i < totpoints && pt; i++, pt++) {
|
||||
/* apply translation to base_modelview, so that the translated point is put in the right place */
|
||||
translate_m4(base_modelview, pt->x, pt->y, pt->z);
|
||||
|
||||
|
||||
/* copy the translation component to the billboard matrix we're going to use,
|
||||
* then reset the base matrix to the original values so that we can do the same
|
||||
* for the next point without accumulation/pollution effects
|
||||
*/
|
||||
copy_v3_v3(modelview[3], base_modelview[3]); /* copy offset value */
|
||||
copy_v3_v3(base_modelview[3], base_loc); /* restore */
|
||||
|
||||
|
||||
/* apply our billboard matrix for drawing... */
|
||||
glLoadMatrixf((float *)modelview);
|
||||
|
||||
|
||||
/* draw the disk using the current state... */
|
||||
gluDisk(qobj, 0.0, pt->pressure * thickness, 32, 1);
|
||||
}
|
||||
|
||||
|
||||
glPopMatrix();
|
||||
gluDeleteQuadric(qobj);
|
||||
}
|
||||
@ -331,28 +332,28 @@ static void gp_draw_stroke_fill(bGPDspoint *points, int totpoints, short UNUSED(
|
||||
{
|
||||
bGPDspoint *pt;
|
||||
int i;
|
||||
|
||||
|
||||
BLI_assert(totpoints >= 3);
|
||||
|
||||
/* As an initial implementation, we use the OpenGL filled polygon drawing
|
||||
|
||||
/* As an initial implementation, we use the OpenGL filled polygon drawing
|
||||
* here since it's the easiest option to implement for this case. It does
|
||||
* come with limitations (notably for concave shapes), though it shouldn't
|
||||
* be much of an issue in most cases.
|
||||
*/
|
||||
glBegin(GL_POLYGON);
|
||||
|
||||
|
||||
for (i = 0, pt = points; i < totpoints; i++, pt++) {
|
||||
if (sflag & GP_STROKE_3DSPACE) {
|
||||
glVertex3fv(&pt->x);
|
||||
}
|
||||
else {
|
||||
float co[2];
|
||||
|
||||
|
||||
gp_calc_2d_stroke_xy(pt, sflag, offsx, offsy, winx, winy, co);
|
||||
glVertex2fv(co);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
glEnd();
|
||||
}
|
||||
|
||||
@ -370,10 +371,10 @@ static void gp_draw_stroke_point(bGPDspoint *points, short thickness, short dfla
|
||||
}
|
||||
else {
|
||||
float co[2];
|
||||
|
||||
|
||||
/* get coordinates of point */
|
||||
gp_calc_2d_stroke_xy(points, sflag, offsx, offsy, winx, winy, co);
|
||||
|
||||
|
||||
/* if thickness is less than GP_DRAWTHICKNESS_SPECIAL, simple dot looks ok
|
||||
* - also mandatory in if Image Editor 'image-based' dot
|
||||
*/
|
||||
@ -386,15 +387,15 @@ static void gp_draw_stroke_point(bGPDspoint *points, short thickness, short dfla
|
||||
}
|
||||
else {
|
||||
/* draw filled circle as is done in circf (but without the matrix push/pops which screwed things up) */
|
||||
GLUquadricObj *qobj = gluNewQuadric();
|
||||
|
||||
gluQuadricDrawStyle(qobj, GLU_FILL);
|
||||
|
||||
GLUquadricObj *qobj = gluNewQuadric();
|
||||
|
||||
gluQuadricDrawStyle(qobj, GLU_FILL);
|
||||
|
||||
/* need to translate drawing position, but must reset after too! */
|
||||
glTranslatef(co[0], co[1], 0.0);
|
||||
gluDisk(qobj, 0.0, thickness, 32, 1);
|
||||
gluDisk(qobj, 0.0, thickness, 32, 1);
|
||||
glTranslatef(-co[0], -co[1], 0.0);
|
||||
|
||||
|
||||
gluDeleteQuadric(qobj);
|
||||
}
|
||||
}
|
||||
@ -406,7 +407,7 @@ static void gp_draw_stroke_3d(bGPDspoint *points, int totpoints, short thickness
|
||||
bGPDspoint *pt;
|
||||
float curpressure = points[0].pressure;
|
||||
int i;
|
||||
|
||||
|
||||
/* draw stroke curve */
|
||||
glLineWidth(curpressure * thickness);
|
||||
glBegin(GL_LINE_STRIP);
|
||||
@ -420,10 +421,10 @@ static void gp_draw_stroke_3d(bGPDspoint *points, int totpoints, short thickness
|
||||
curpressure = pt->pressure;
|
||||
glLineWidth(curpressure * thickness);
|
||||
glBegin(GL_LINE_STRIP);
|
||||
|
||||
|
||||
/* need to roll-back one point to ensure that there are no gaps in the stroke */
|
||||
if (i != 0) glVertex3fv(&(pt - 1)->x);
|
||||
|
||||
|
||||
/* now the point we want... */
|
||||
glVertex3fv(&pt->x);
|
||||
}
|
||||
@ -432,7 +433,7 @@ static void gp_draw_stroke_3d(bGPDspoint *points, int totpoints, short thickness
|
||||
}
|
||||
}
|
||||
glEnd();
|
||||
|
||||
|
||||
/* draw debug points of curve on top? */
|
||||
/* XXX: for now, we represent "selected" strokes in the same way as debug, which isn't used anymore */
|
||||
if (debug) {
|
||||
@ -451,14 +452,13 @@ static void gp_draw_stroke_2d(bGPDspoint *points, int totpoints, short thickness
|
||||
{
|
||||
/* otherwise thickness is twice that of the 3D view */
|
||||
float thickness = (float)thickness_s * 0.5f;
|
||||
|
||||
|
||||
/* strokes in Image Editor need a scale factor, since units there are not pixels! */
|
||||
float scalefac = 1.0f;
|
||||
if ((dflag & GP_DRAWDATA_IEDITHACK) && (dflag & GP_DRAWDATA_ONLYV2D)) {
|
||||
scalefac = 0.001f;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/* tessellation code - draw stroke as series of connected quads with connection
|
||||
* edges rotated to minimize shrinking artifacts, and rounded endcaps
|
||||
*/
|
||||
@ -466,58 +466,58 @@ static void gp_draw_stroke_2d(bGPDspoint *points, int totpoints, short thickness
|
||||
bGPDspoint *pt1, *pt2;
|
||||
float pm[2];
|
||||
int i;
|
||||
|
||||
|
||||
glShadeModel(GL_FLAT);
|
||||
glBegin(GL_QUADS);
|
||||
|
||||
|
||||
for (i = 0, pt1 = points, pt2 = points + 1; i < (totpoints - 1); i++, pt1++, pt2++) {
|
||||
float s0[2], s1[2]; /* segment 'center' points */
|
||||
float t0[2], t1[2]; /* tessellated coordinates */
|
||||
float m1[2], m2[2]; /* gradient and normal */
|
||||
float mt[2], sc[2]; /* gradient for thickness, point for end-cap */
|
||||
float pthick; /* thickness at segment point */
|
||||
|
||||
|
||||
/* get x and y coordinates from points */
|
||||
gp_calc_2d_stroke_xy(pt1, sflag, offsx, offsy, winx, winy, s0);
|
||||
gp_calc_2d_stroke_xy(pt2, sflag, offsx, offsy, winx, winy, s1);
|
||||
|
||||
|
||||
/* calculate gradient and normal - 'angle'=(ny/nx) */
|
||||
m1[1] = s1[1] - s0[1];
|
||||
m1[0] = s1[0] - s0[0];
|
||||
normalize_v2(m1);
|
||||
m2[1] = -m1[0];
|
||||
m2[0] = m1[1];
|
||||
|
||||
|
||||
/* always use pressure from first point here */
|
||||
pthick = (pt1->pressure * thickness * scalefac);
|
||||
|
||||
|
||||
/* if the first segment, start of segment is segment's normal */
|
||||
if (i == 0) {
|
||||
/* draw start cap first
|
||||
* - make points slightly closer to center (about halfway across)
|
||||
/* draw start cap first
|
||||
* - make points slightly closer to center (about halfway across)
|
||||
*/
|
||||
mt[0] = m2[0] * pthick * 0.5f;
|
||||
mt[1] = m2[1] * pthick * 0.5f;
|
||||
sc[0] = s0[0] - (m1[0] * pthick * 0.75f);
|
||||
sc[1] = s0[1] - (m1[1] * pthick * 0.75f);
|
||||
|
||||
|
||||
t0[0] = sc[0] - mt[0];
|
||||
t0[1] = sc[1] - mt[1];
|
||||
t1[0] = sc[0] + mt[0];
|
||||
t1[1] = sc[1] + mt[1];
|
||||
|
||||
|
||||
glVertex2fv(t0);
|
||||
glVertex2fv(t1);
|
||||
|
||||
|
||||
/* calculate points for start of segment */
|
||||
mt[0] = m2[0] * pthick;
|
||||
mt[1] = m2[1] * pthick;
|
||||
|
||||
|
||||
t0[0] = s0[0] - mt[0];
|
||||
t0[1] = s0[1] - mt[1];
|
||||
t1[0] = s0[0] + mt[0];
|
||||
t1[1] = s0[1] + mt[1];
|
||||
|
||||
|
||||
/* draw this line twice (first to finish off start cap, then for stroke) */
|
||||
glVertex2fv(t1);
|
||||
glVertex2fv(t0);
|
||||
@ -528,13 +528,13 @@ static void gp_draw_stroke_2d(bGPDspoint *points, int totpoints, short thickness
|
||||
else {
|
||||
float mb[2]; /* bisector normal */
|
||||
float athick, dfac; /* actual thickness, difference between thicknesses */
|
||||
|
||||
|
||||
/* calculate gradient of bisector (as average of normals) */
|
||||
mb[0] = (pm[0] + m2[0]) / 2;
|
||||
mb[1] = (pm[1] + m2[1]) / 2;
|
||||
normalize_v2(mb);
|
||||
|
||||
/* calculate gradient to apply
|
||||
|
||||
/* calculate gradient to apply
|
||||
* - as basis, use just pthick * bisector gradient
|
||||
* - if cross-section not as thick as it should be, add extra padding to fix it
|
||||
*/
|
||||
@ -542,79 +542,79 @@ static void gp_draw_stroke_2d(bGPDspoint *points, int totpoints, short thickness
|
||||
mt[1] = mb[1] * pthick;
|
||||
athick = len_v2(mt);
|
||||
dfac = pthick - (athick * 2);
|
||||
|
||||
|
||||
if (((athick * 2.0f) < pthick) && (IS_EQF(athick, pthick) == 0)) {
|
||||
mt[0] += (mb[0] * dfac);
|
||||
mt[1] += (mb[1] * dfac);
|
||||
}
|
||||
|
||||
|
||||
/* calculate points for start of segment */
|
||||
t0[0] = s0[0] - mt[0];
|
||||
t0[1] = s0[1] - mt[1];
|
||||
t1[0] = s0[0] + mt[0];
|
||||
t1[1] = s0[1] + mt[1];
|
||||
|
||||
|
||||
/* draw this line twice (once for end of current segment, and once for start of next) */
|
||||
glVertex2fv(t1);
|
||||
glVertex2fv(t0);
|
||||
glVertex2fv(t0);
|
||||
glVertex2fv(t1);
|
||||
}
|
||||
|
||||
|
||||
/* if last segment, also draw end of segment (defined as segment's normal) */
|
||||
if (i == totpoints - 2) {
|
||||
/* for once, we use second point's pressure (otherwise it won't be drawn) */
|
||||
pthick = (pt2->pressure * thickness * scalefac);
|
||||
|
||||
|
||||
/* calculate points for end of segment */
|
||||
mt[0] = m2[0] * pthick;
|
||||
mt[1] = m2[1] * pthick;
|
||||
|
||||
|
||||
t0[0] = s1[0] - mt[0];
|
||||
t0[1] = s1[1] - mt[1];
|
||||
t1[0] = s1[0] + mt[0];
|
||||
t1[1] = s1[1] + mt[1];
|
||||
|
||||
|
||||
/* draw this line twice (once for end of stroke, and once for endcap)*/
|
||||
glVertex2fv(t1);
|
||||
glVertex2fv(t0);
|
||||
glVertex2fv(t0);
|
||||
glVertex2fv(t1);
|
||||
|
||||
|
||||
/* draw end cap as last step
|
||||
* - make points slightly closer to center (about halfway across)
|
||||
|
||||
|
||||
/* draw end cap as last step
|
||||
* - make points slightly closer to center (about halfway across)
|
||||
*/
|
||||
mt[0] = m2[0] * pthick * 0.5f;
|
||||
mt[1] = m2[1] * pthick * 0.5f;
|
||||
sc[0] = s1[0] + (m1[0] * pthick * 0.75f);
|
||||
sc[1] = s1[1] + (m1[1] * pthick * 0.75f);
|
||||
|
||||
|
||||
t0[0] = sc[0] - mt[0];
|
||||
t0[1] = sc[1] - mt[1];
|
||||
t1[0] = sc[0] + mt[0];
|
||||
t1[1] = sc[1] + mt[1];
|
||||
|
||||
|
||||
glVertex2fv(t1);
|
||||
glVertex2fv(t0);
|
||||
}
|
||||
|
||||
|
||||
/* store stroke's 'natural' normal for next stroke to use */
|
||||
copy_v2_v2(pm, m2);
|
||||
}
|
||||
|
||||
|
||||
glEnd();
|
||||
}
|
||||
|
||||
|
||||
/* draw debug points of curve on top? (original stroke points) */
|
||||
if (debug) {
|
||||
bGPDspoint *pt;
|
||||
int i;
|
||||
|
||||
|
||||
glBegin(GL_POINTS);
|
||||
for (i = 0, pt = points; i < totpoints && pt; i++, pt++) {
|
||||
float co[2];
|
||||
|
||||
|
||||
gp_calc_2d_stroke_xy(pt, sflag, offsx, offsy, winx, winy, co);
|
||||
glVertex2fv(co);
|
||||
}
|
||||
@ -633,24 +633,24 @@ static bool gp_can_draw_stroke(const bGPDstroke *gps, const int dflag)
|
||||
return false;
|
||||
if (!(dflag & GP_DRAWDATA_ONLY3D) && (gps->flag & GP_STROKE_3DSPACE))
|
||||
return false;
|
||||
|
||||
|
||||
/* 2) Screen Space 2D Strokes */
|
||||
if ((dflag & GP_DRAWDATA_ONLYV2D) && !(gps->flag & GP_STROKE_2DSPACE))
|
||||
return false;
|
||||
if (!(dflag & GP_DRAWDATA_ONLYV2D) && (gps->flag & GP_STROKE_2DSPACE))
|
||||
return false;
|
||||
|
||||
|
||||
/* 3) Image Space (2D) */
|
||||
if ((dflag & GP_DRAWDATA_ONLYI2D) && !(gps->flag & GP_STROKE_2DIMAGE))
|
||||
return false;
|
||||
if (!(dflag & GP_DRAWDATA_ONLYI2D) && (gps->flag & GP_STROKE_2DIMAGE))
|
||||
return false;
|
||||
|
||||
|
||||
|
||||
|
||||
/* skip stroke if it doesn't have any valid data */
|
||||
if ((gps->points == NULL) || (gps->totpoints < 1))
|
||||
return false;
|
||||
|
||||
|
||||
/* stroke can be drawn */
|
||||
return true;
|
||||
}
|
||||
@ -660,22 +660,22 @@ static void gp_draw_strokes(bGPDframe *gpf, int offsx, int offsy, int winx, int
|
||||
bool debug, short lthick, const float color[4], const float fill_color[4])
|
||||
{
|
||||
bGPDstroke *gps;
|
||||
|
||||
|
||||
for (gps = gpf->strokes.first; gps; gps = gps->next) {
|
||||
/* check if stroke can be drawn */
|
||||
if (gp_can_draw_stroke(gps, dflag) == false)
|
||||
continue;
|
||||
|
||||
|
||||
/* check which stroke-drawer to use */
|
||||
if (dflag & GP_DRAWDATA_ONLY3D) {
|
||||
const int no_xray = (dflag & GP_DRAWDATA_NO_XRAY);
|
||||
int mask_orig = 0;
|
||||
|
||||
|
||||
if (no_xray) {
|
||||
glGetIntegerv(GL_DEPTH_WRITEMASK, &mask_orig);
|
||||
glDepthMask(0);
|
||||
glEnable(GL_DEPTH_TEST);
|
||||
|
||||
|
||||
/* first arg is normally rv3d->dist, but this isn't
|
||||
* available here and seems to work quite well without */
|
||||
bglPolygonOffset(1.0f, 1.0f);
|
||||
@ -684,16 +684,16 @@ static void gp_draw_strokes(bGPDframe *gpf, int offsx, int offsy, int winx, int
|
||||
glPolygonOffset(-1.0f, -1.0f);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
/* 3D Fill */
|
||||
if ((dflag & GP_DRAWDATA_FILL) && (gps->totpoints >= 3)) {
|
||||
glColor4fv(fill_color);
|
||||
gp_draw_stroke_fill(gps->points, gps->totpoints, lthick, dflag, gps->flag, offsx, offsy, winx, winy);
|
||||
}
|
||||
|
||||
|
||||
/* 3D Stroke */
|
||||
glColor4fv(color);
|
||||
|
||||
|
||||
if (dflag & GP_DRAWDATA_VOLUMETRIC) {
|
||||
/* volumetric stroke drawing */
|
||||
gp_draw_stroke_volumetric_3d(gps->points, gps->totpoints, lthick, dflag, gps->flag);
|
||||
@ -707,11 +707,11 @@ static void gp_draw_strokes(bGPDframe *gpf, int offsx, int offsy, int winx, int
|
||||
gp_draw_stroke_3d(gps->points, gps->totpoints, lthick, debug, gps->flag);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if (no_xray) {
|
||||
glDepthMask(mask_orig);
|
||||
glDisable(GL_DEPTH_TEST);
|
||||
|
||||
|
||||
bglPolygonOffset(0.0, 0.0);
|
||||
#if 0
|
||||
glDisable(GL_POLYGON_OFFSET_LINE);
|
||||
@ -725,10 +725,10 @@ static void gp_draw_strokes(bGPDframe *gpf, int offsx, int offsy, int winx, int
|
||||
glColor4fv(fill_color);
|
||||
gp_draw_stroke_fill(gps->points, gps->totpoints, lthick, dflag, gps->flag, offsx, offsy, winx, winy);
|
||||
}
|
||||
|
||||
|
||||
/* 2D Strokes... */
|
||||
glColor4fv(color);
|
||||
|
||||
|
||||
if (dflag & GP_DRAWDATA_VOLUMETRIC) {
|
||||
/* blob/disk-based "volumetric" drawing */
|
||||
gp_draw_stroke_volumetric_2d(gps->points, gps->totpoints, lthick, dflag, gps->flag, offsx, offsy, winx, winy);
|
||||
@ -750,17 +750,17 @@ static void gp_draw_strokes(bGPDframe *gpf, int offsx, int offsy, int winx, int
|
||||
static void gp_draw_strokes_edit(bGPDframe *gpf, int offsx, int offsy, int winx, int winy, short dflag, const float tcolor[3])
|
||||
{
|
||||
bGPDstroke *gps;
|
||||
|
||||
|
||||
const int no_xray = (dflag & GP_DRAWDATA_NO_XRAY);
|
||||
int mask_orig = 0;
|
||||
|
||||
|
||||
/* set up depth masks... */
|
||||
if (dflag & GP_DRAWDATA_ONLY3D) {
|
||||
if (no_xray) {
|
||||
glGetIntegerv(GL_DEPTH_WRITEMASK, &mask_orig);
|
||||
glDepthMask(0);
|
||||
glEnable(GL_DEPTH_TEST);
|
||||
|
||||
|
||||
/* first arg is normally rv3d->dist, but this isn't
|
||||
* available here and seems to work quite well without */
|
||||
bglPolygonOffset(1.0f, 1.0f);
|
||||
@ -770,25 +770,25 @@ static void gp_draw_strokes_edit(bGPDframe *gpf, int offsx, int offsy, int winx,
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
/* draw stroke verts */
|
||||
for (gps = gpf->strokes.first; gps; gps = gps->next) {
|
||||
bGPDspoint *pt;
|
||||
float vsize, bsize;
|
||||
int i;
|
||||
|
||||
|
||||
/* check if stroke can be drawn */
|
||||
if (gp_can_draw_stroke(gps, dflag) == false)
|
||||
continue;
|
||||
|
||||
|
||||
/* Optimisation: only draw points for selected strokes
|
||||
* We assume that selected points can only occur in
|
||||
* strokes that are selected too.
|
||||
*/
|
||||
if ((gps->flag & GP_STROKE_SELECT) == 0)
|
||||
continue;
|
||||
|
||||
|
||||
/* Get size of verts:
|
||||
* - The selected state needs to be larger than the unselected state so that
|
||||
* they stand out more.
|
||||
@ -802,7 +802,7 @@ static void gp_draw_strokes_edit(bGPDframe *gpf, int offsx, int offsy, int winx,
|
||||
else {
|
||||
vsize = bsize + 2;
|
||||
}
|
||||
|
||||
|
||||
/* First Pass: Draw all the verts (i.e. these become the unselected state) */
|
||||
if (tcolor != NULL) {
|
||||
/* for now, we assume that the base color of the points is not too close to the real color */
|
||||
@ -813,7 +813,7 @@ static void gp_draw_strokes_edit(bGPDframe *gpf, int offsx, int offsy, int winx,
|
||||
UI_ThemeColor(TH_VERTEX);
|
||||
}
|
||||
glPointSize(bsize);
|
||||
|
||||
|
||||
glBegin(GL_POINTS);
|
||||
for (i = 0, pt = gps->points; i < gps->totpoints && pt; i++, pt++) {
|
||||
if (gps->flag & GP_STROKE_3DSPACE) {
|
||||
@ -821,18 +821,18 @@ static void gp_draw_strokes_edit(bGPDframe *gpf, int offsx, int offsy, int winx,
|
||||
}
|
||||
else {
|
||||
float co[2];
|
||||
|
||||
|
||||
gp_calc_2d_stroke_xy(pt, gps->flag, offsx, offsy, winx, winy, co);
|
||||
glVertex2fv(co);
|
||||
}
|
||||
}
|
||||
glEnd();
|
||||
|
||||
|
||||
|
||||
|
||||
/* Second Pass: Draw only verts which are selected */
|
||||
UI_ThemeColor(TH_VERTEX_SELECT);
|
||||
glPointSize(vsize);
|
||||
|
||||
|
||||
glBegin(GL_POINTS);
|
||||
for (i = 0, pt = gps->points; i < gps->totpoints && pt; i++, pt++) {
|
||||
if (pt->flag & GP_SPOINT_SELECT) {
|
||||
@ -841,7 +841,7 @@ static void gp_draw_strokes_edit(bGPDframe *gpf, int offsx, int offsy, int winx,
|
||||
}
|
||||
else {
|
||||
float co[2];
|
||||
|
||||
|
||||
gp_calc_2d_stroke_xy(pt, gps->flag, offsx, offsy, winx, winy, co);
|
||||
glVertex2fv(co);
|
||||
}
|
||||
@ -849,14 +849,14 @@ static void gp_draw_strokes_edit(bGPDframe *gpf, int offsx, int offsy, int winx,
|
||||
}
|
||||
glEnd();
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
/* clear depth mask */
|
||||
if (dflag & GP_DRAWDATA_ONLY3D) {
|
||||
if (no_xray) {
|
||||
glDepthMask(mask_orig);
|
||||
glDisable(GL_DEPTH_TEST);
|
||||
|
||||
|
||||
bglPolygonOffset(0.0, 0.0);
|
||||
#if 0
|
||||
glDisable(GL_POLYGON_OFFSET_LINE);
|
||||
@ -869,12 +869,12 @@ static void gp_draw_strokes_edit(bGPDframe *gpf, int offsx, int offsy, int winx,
|
||||
/* ----- General Drawing ------ */
|
||||
|
||||
/* draw onion-skinning for a layer */
|
||||
static void gp_draw_onionskins(bGPDlayer *gpl, bGPDframe *gpf, int offsx, int offsy, int winx, int winy,
|
||||
static void gp_draw_onionskins(bGPDlayer *gpl, bGPDframe *gpf, int offsx, int offsy, int winx, int winy,
|
||||
int UNUSED(cfra), int dflag, short debug, short lthick)
|
||||
{
|
||||
const float alpha = gpl->color[3];
|
||||
float color[4];
|
||||
|
||||
|
||||
/* 1) Draw Previous Frames First */
|
||||
if (gpl->flag & GP_LAYER_GHOST_PREVCOL) {
|
||||
copy_v3_v3(color, gpl->gcolor_prev);
|
||||
@ -882,11 +882,11 @@ static void gp_draw_onionskins(bGPDlayer *gpl, bGPDframe *gpf, int offsx, int of
|
||||
else {
|
||||
copy_v3_v3(color, gpl->color);
|
||||
}
|
||||
|
||||
|
||||
if (gpl->gstep) {
|
||||
bGPDframe *gf;
|
||||
float fac;
|
||||
|
||||
|
||||
/* draw previous frames first */
|
||||
for (gf = gpf->prev; gf; gf = gf->prev) {
|
||||
/* check if frame is drawable */
|
||||
@ -896,7 +896,7 @@ static void gp_draw_onionskins(bGPDlayer *gpl, bGPDframe *gpf, int offsx, int of
|
||||
color[3] = alpha * fac * 0.66f;
|
||||
gp_draw_strokes(gf, offsx, offsy, winx, winy, dflag, debug, lthick, color, color);
|
||||
}
|
||||
else
|
||||
else
|
||||
break;
|
||||
}
|
||||
}
|
||||
@ -907,8 +907,8 @@ static void gp_draw_onionskins(bGPDlayer *gpl, bGPDframe *gpf, int offsx, int of
|
||||
gp_draw_strokes(gpf->prev, offsx, offsy, winx, winy, dflag, debug, lthick, color, color);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
/* 2) Now draw next frames */
|
||||
if (gpl->flag & GP_LAYER_GHOST_NEXTCOL) {
|
||||
copy_v3_v3(color, gpl->gcolor_next);
|
||||
@ -916,11 +916,11 @@ static void gp_draw_onionskins(bGPDlayer *gpl, bGPDframe *gpf, int offsx, int of
|
||||
else {
|
||||
copy_v3_v3(color, gpl->color);
|
||||
}
|
||||
|
||||
|
||||
if (gpl->gstep_next) {
|
||||
bGPDframe *gf;
|
||||
float fac;
|
||||
|
||||
|
||||
/* now draw next frames */
|
||||
for (gf = gpf->next; gf; gf = gf->next) {
|
||||
/* check if frame is drawable */
|
||||
@ -930,7 +930,7 @@ static void gp_draw_onionskins(bGPDlayer *gpl, bGPDframe *gpf, int offsx, int of
|
||||
color[3] = alpha * fac * 0.66f;
|
||||
gp_draw_strokes(gf, offsx, offsy, winx, winy, dflag, debug, lthick, color, color);
|
||||
}
|
||||
else
|
||||
else
|
||||
break;
|
||||
}
|
||||
}
|
||||
@ -941,7 +941,7 @@ static void gp_draw_onionskins(bGPDlayer *gpl, bGPDframe *gpf, int offsx, int of
|
||||
gp_draw_strokes(gpf->next, offsx, offsy, winx, winy, dflag, debug, lthick, color, color);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* 3) restore alpha */
|
||||
glColor4fv(gpl->color);
|
||||
}
|
||||
@ -1075,7 +1075,7 @@ static void gp_draw_data(bGPdata *gpd, int offsx, int offsy, int winx, int winy,
|
||||
/* if we have strokes for scenes (3d view)/clips (movie clip editor)
|
||||
* and objects/tracks, multiple data blocks have to be drawn */
|
||||
static void gp_draw_data_all(Scene *scene, bGPdata *gpd, int offsx, int offsy, int winx, int winy,
|
||||
int cfra, int dflag, const char spacetype)
|
||||
int cfra, int dflag, const char spacetype)
|
||||
{
|
||||
bGPdata *gpd_source = NULL;
|
||||
|
||||
@ -1117,25 +1117,25 @@ void ED_gpencil_draw_2dimage(const bContext *C)
|
||||
bGPdata *gpd;
|
||||
int offsx, offsy, sizex, sizey;
|
||||
int dflag = GP_DRAWDATA_NOSTATUS;
|
||||
|
||||
|
||||
gpd = ED_gpencil_data_get_active(C); // XXX
|
||||
if (gpd == NULL) return;
|
||||
|
||||
|
||||
/* calculate rect */
|
||||
switch (sa->spacetype) {
|
||||
case SPACE_IMAGE: /* image */
|
||||
case SPACE_CLIP: /* clip */
|
||||
{
|
||||
|
||||
|
||||
/* just draw using standard scaling (settings here are currently ignored anyways) */
|
||||
/* FIXME: the opengl poly-strokes don't draw at right thickness when done this way, so disabled */
|
||||
offsx = 0;
|
||||
offsy = 0;
|
||||
sizex = ar->winx;
|
||||
sizey = ar->winy;
|
||||
|
||||
|
||||
wmOrtho2(ar->v2d.cur.xmin, ar->v2d.cur.xmax, ar->v2d.cur.ymin, ar->v2d.cur.ymax);
|
||||
|
||||
|
||||
dflag |= GP_DRAWDATA_ONLYV2D | GP_DRAWDATA_IEDITHACK;
|
||||
break;
|
||||
}
|
||||
@ -1146,9 +1146,9 @@ void ED_gpencil_draw_2dimage(const bContext *C)
|
||||
offsy = 0;
|
||||
sizex = ar->winx;
|
||||
sizey = ar->winy;
|
||||
|
||||
/* NOTE: I2D was used in 2.4x, but the old settings for that have been deprecated
|
||||
* and everything moved to standard View2d
|
||||
|
||||
/* NOTE: I2D was used in 2.4x, but the old settings for that have been deprecated
|
||||
* and everything moved to standard View2d
|
||||
*/
|
||||
dflag |= GP_DRAWDATA_ONLYV2D;
|
||||
break;
|
||||
@ -1158,17 +1158,17 @@ void ED_gpencil_draw_2dimage(const bContext *C)
|
||||
offsy = 0;
|
||||
sizex = ar->winx;
|
||||
sizey = ar->winy;
|
||||
|
||||
|
||||
dflag |= GP_DRAWDATA_ONLYI2D;
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
/* draw it! */
|
||||
gp_draw_data_all(scene, gpd, offsx, offsy, sizex, sizey, CFRA, dflag, sa->spacetype);
|
||||
}
|
||||
|
||||
/* draw grease-pencil sketches to specified 2d-view assuming that matrices are already set correctly
|
||||
/* draw grease-pencil sketches to specified 2d-view assuming that matrices are already set correctly
|
||||
* Note: this gets called twice - first time with onlyv2d=1 to draw 'canvas' strokes,
|
||||
* second time with onlyv2d=0 for screen-aligned strokes */
|
||||
void ED_gpencil_draw_view2d(const bContext *C, bool onlyv2d)
|
||||
@ -1178,23 +1178,23 @@ void ED_gpencil_draw_view2d(const bContext *C, bool onlyv2d)
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
bGPdata *gpd;
|
||||
int dflag = 0;
|
||||
|
||||
|
||||
/* check that we have grease-pencil stuff to draw */
|
||||
if (sa == NULL) return;
|
||||
gpd = ED_gpencil_data_get_active(C); // XXX
|
||||
if (gpd == NULL) return;
|
||||
|
||||
|
||||
/* special hack for Image Editor */
|
||||
/* FIXME: the opengl poly-strokes don't draw at right thickness when done this way, so disabled */
|
||||
if (ELEM(sa->spacetype, SPACE_IMAGE, SPACE_CLIP))
|
||||
dflag |= GP_DRAWDATA_IEDITHACK;
|
||||
|
||||
|
||||
/* draw it! */
|
||||
if (onlyv2d) dflag |= (GP_DRAWDATA_ONLYV2D | GP_DRAWDATA_NOSTATUS);
|
||||
gp_draw_data_all(scene, gpd, 0, 0, ar->winx, ar->winy, CFRA, dflag, sa->spacetype);
|
||||
}
|
||||
|
||||
/* draw grease-pencil sketches to specified 3d-view assuming that matrices are already set correctly
|
||||
/* draw grease-pencil sketches to specified 3d-view assuming that matrices are already set correctly
|
||||
* Note: this gets called twice - first time with only3d=1 to draw 3d-strokes,
|
||||
* second time with only3d=0 for screen-aligned strokes */
|
||||
void ED_gpencil_draw_view3d(Scene *scene, View3D *v3d, ARegion *ar, bool only3d)
|
||||
@ -1225,7 +1225,7 @@ void ED_gpencil_draw_view3d(Scene *scene, View3D *v3d, ARegion *ar, bool only3d)
|
||||
winx = ar->winx;
|
||||
winy = ar->winy;
|
||||
}
|
||||
|
||||
|
||||
/* draw it! */
|
||||
if (only3d) dflag |= (GP_DRAWDATA_ONLY3D | GP_DRAWDATA_NOSTATUS);
|
||||
|
||||
|
@ -27,7 +27,7 @@
|
||||
* \ingroup edgpencil
|
||||
*/
|
||||
|
||||
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
@ -62,18 +62,18 @@
|
||||
bool ED_gplayer_frames_looper(bGPDlayer *gpl, Scene *scene, short (*gpf_cb)(bGPDframe *, Scene *))
|
||||
{
|
||||
bGPDframe *gpf;
|
||||
|
||||
|
||||
/* error checker */
|
||||
if (gpl == NULL)
|
||||
return false;
|
||||
|
||||
|
||||
/* do loop */
|
||||
for (gpf = gpl->frames.first; gpf; gpf = gpf->next) {
|
||||
/* execute callback */
|
||||
if (gpf_cb(gpf, scene))
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
/* nothing to return */
|
||||
return false;
|
||||
}
|
||||
@ -86,19 +86,19 @@ void ED_gplayer_make_cfra_list(bGPDlayer *gpl, ListBase *elems, bool onlysel)
|
||||
{
|
||||
bGPDframe *gpf;
|
||||
CfraElem *ce;
|
||||
|
||||
|
||||
/* error checking */
|
||||
if (ELEM(NULL, gpl, elems))
|
||||
return;
|
||||
|
||||
|
||||
/* loop through gp-frames, adding */
|
||||
for (gpf = gpl->frames.first; gpf; gpf = gpf->next) {
|
||||
if ((onlysel == 0) || (gpf->flag & GP_FRAME_SELECT)) {
|
||||
ce = MEM_callocN(sizeof(CfraElem), "CfraElem");
|
||||
|
||||
|
||||
ce->cfra = (float)gpf->framenum;
|
||||
ce->sel = (gpf->flag & GP_FRAME_SELECT) ? 1 : 0;
|
||||
|
||||
|
||||
BLI_addtail(elems, ce);
|
||||
}
|
||||
}
|
||||
@ -111,17 +111,17 @@ void ED_gplayer_make_cfra_list(bGPDlayer *gpl, ListBase *elems, bool onlysel)
|
||||
bool ED_gplayer_frame_select_check(bGPDlayer *gpl)
|
||||
{
|
||||
bGPDframe *gpf;
|
||||
|
||||
|
||||
/* error checking */
|
||||
if (gpl == NULL)
|
||||
if (gpl == NULL)
|
||||
return false;
|
||||
|
||||
|
||||
/* stop at the first one found */
|
||||
for (gpf = gpl->frames.first; gpf; gpf = gpf->next) {
|
||||
if (gpf->flag & GP_FRAME_SELECT)
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
/* not found */
|
||||
return false;
|
||||
}
|
||||
@ -131,7 +131,7 @@ static void gpframe_select(bGPDframe *gpf, short select_mode)
|
||||
{
|
||||
if (gpf == NULL)
|
||||
return;
|
||||
|
||||
|
||||
switch (select_mode) {
|
||||
case SELECT_ADD:
|
||||
gpf->flag |= GP_FRAME_SELECT;
|
||||
@ -149,11 +149,11 @@ static void gpframe_select(bGPDframe *gpf, short select_mode)
|
||||
void ED_gpencil_select_frames(bGPDlayer *gpl, short select_mode)
|
||||
{
|
||||
bGPDframe *gpf;
|
||||
|
||||
|
||||
/* error checking */
|
||||
if (gpl == NULL)
|
||||
if (gpl == NULL)
|
||||
return;
|
||||
|
||||
|
||||
/* handle according to mode */
|
||||
for (gpf = gpl->frames.first; gpf; gpf = gpf->next) {
|
||||
gpframe_select(gpf, select_mode);
|
||||
@ -164,9 +164,9 @@ void ED_gpencil_select_frames(bGPDlayer *gpl, short select_mode)
|
||||
void ED_gplayer_frame_select_set(bGPDlayer *gpl, short mode)
|
||||
{
|
||||
/* error checking */
|
||||
if (gpl == NULL)
|
||||
if (gpl == NULL)
|
||||
return;
|
||||
|
||||
|
||||
/* now call the standard function */
|
||||
ED_gpencil_select_frames(gpl, mode);
|
||||
}
|
||||
@ -175,8 +175,8 @@ void ED_gplayer_frame_select_set(bGPDlayer *gpl, short mode)
|
||||
void ED_gpencil_select_frame(bGPDlayer *gpl, int selx, short select_mode)
|
||||
{
|
||||
bGPDframe *gpf;
|
||||
|
||||
if (gpl == NULL)
|
||||
|
||||
if (gpl == NULL)
|
||||
return;
|
||||
|
||||
gpf = BKE_gpencil_layer_find_frame(gpl, selx);
|
||||
@ -190,10 +190,10 @@ void ED_gpencil_select_frame(bGPDlayer *gpl, int selx, short select_mode)
|
||||
void ED_gplayer_frames_select_border(bGPDlayer *gpl, float min, float max, short select_mode)
|
||||
{
|
||||
bGPDframe *gpf;
|
||||
|
||||
|
||||
if (gpl == NULL)
|
||||
return;
|
||||
|
||||
|
||||
/* only select those frames which are in bounds */
|
||||
for (gpf = gpl->frames.first; gpf; gpf = gpf->next) {
|
||||
if (IN_RANGE(gpf->framenum, min, max))
|
||||
@ -209,15 +209,15 @@ bool ED_gplayer_frames_delete(bGPDlayer *gpl)
|
||||
{
|
||||
bGPDframe *gpf, *gpfn;
|
||||
bool changed = false;
|
||||
|
||||
|
||||
/* error checking */
|
||||
if (gpl == NULL)
|
||||
return false;
|
||||
|
||||
|
||||
/* check for frames to delete */
|
||||
for (gpf = gpl->frames.first; gpf; gpf = gpfn) {
|
||||
gpfn = gpf->next;
|
||||
|
||||
|
||||
if (gpf->flag & GP_FRAME_SELECT)
|
||||
changed |= gpencil_layer_delframe(gpl, gpf);
|
||||
}
|
||||
@ -229,38 +229,38 @@ bool ED_gplayer_frames_delete(bGPDlayer *gpl)
|
||||
void ED_gplayer_frames_duplicate(bGPDlayer *gpl)
|
||||
{
|
||||
bGPDframe *gpf, *gpfn;
|
||||
|
||||
|
||||
/* error checking */
|
||||
if (gpl == NULL)
|
||||
return;
|
||||
|
||||
|
||||
/* duplicate selected frames */
|
||||
for (gpf = gpl->frames.first; gpf; gpf = gpfn) {
|
||||
gpfn = gpf->next;
|
||||
|
||||
|
||||
/* duplicate this frame */
|
||||
if (gpf->flag & GP_FRAME_SELECT) {
|
||||
bGPDframe *gpfd;
|
||||
|
||||
bGPDframe *gpfd;
|
||||
|
||||
/* duplicate frame, and deselect self */
|
||||
gpfd = gpencil_frame_duplicate(gpf);
|
||||
gpf->flag &= ~GP_FRAME_SELECT;
|
||||
|
||||
|
||||
BLI_insertlinkafter(&gpl->frames, gpf, gpfd);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Set keyframe type for selected frames from given gp-layer
|
||||
/* Set keyframe type for selected frames from given gp-layer
|
||||
* \param type The type of keyframe (eBezTriple_KeyframeType) to set selected frames to
|
||||
*/
|
||||
void ED_gplayer_frames_keytype_set(bGPDlayer *gpl, short type)
|
||||
{
|
||||
bGPDframe *gpf;
|
||||
|
||||
|
||||
if (gpl == NULL)
|
||||
return;
|
||||
|
||||
|
||||
for (gpf = gpl->frames.first; gpf; gpf = gpf->next) {
|
||||
if (gpf->flag & GP_FRAME_SELECT) {
|
||||
gpf->key_type = type;
|
||||
@ -278,7 +278,7 @@ void ED_gplayer_frames_keytype_set(bGPDlayer *gpl, short type)
|
||||
* the current frame and the 'first keyframe' (i.e. the earliest one in all channels).
|
||||
* - The earliest frame is calculated per copy operation.
|
||||
*/
|
||||
|
||||
|
||||
/* globals for copy/paste data (like for other copy/paste buffers) */
|
||||
ListBase gpcopybuf = {NULL, NULL};
|
||||
static int gpcopy_firstframe = 999999999;
|
||||
@ -286,8 +286,8 @@ static int gpcopy_firstframe = 999999999;
|
||||
/* This function frees any MEM_calloc'ed copy/paste buffer data */
|
||||
void free_gpcopybuf()
|
||||
{
|
||||
free_gpencil_layers(&gpcopybuf);
|
||||
|
||||
free_gpencil_layers(&gpcopybuf);
|
||||
|
||||
BLI_listbase_clear(&gpcopybuf);
|
||||
gpcopy_firstframe = 999999999;
|
||||
}
|
||||
@ -302,33 +302,33 @@ void copy_gpdata()
|
||||
int filter;
|
||||
void *data;
|
||||
short datatype;
|
||||
|
||||
|
||||
/* clear buffer first */
|
||||
free_gpcopybuf();
|
||||
|
||||
|
||||
/* get data */
|
||||
data = get_action_context(&datatype);
|
||||
if (data == NULL) return;
|
||||
if (datatype != ACTCONT_GPENCIL) return;
|
||||
|
||||
|
||||
/* filter data */
|
||||
filter = (ACTFILTER_VISIBLE | ACTFILTER_SEL);
|
||||
actdata_filter(&act_data, filter, data, datatype);
|
||||
|
||||
|
||||
/* assume that each of these is an ipo-block */
|
||||
for (ale = act_data.first; ale; ale = ale->next) {
|
||||
bGPDlayer *gpls, *gpln;
|
||||
bGPDframe *gpf, *gpfn;
|
||||
|
||||
|
||||
/* get new layer to put into buffer */
|
||||
gpls = (bGPDlayer *)ale->data;
|
||||
gpln = MEM_callocN(sizeof(bGPDlayer), "GPCopyPasteLayer");
|
||||
|
||||
|
||||
BLI_listbase_clear(&gpln->frames);
|
||||
BLI_strncpy(gpln->info, gpls->info, sizeof(gpln->info));
|
||||
|
||||
|
||||
BLI_addtail(&gpcopybuf, gpln);
|
||||
|
||||
|
||||
/* loop over frames, and copy only selected frames */
|
||||
for (gpf = gpls->frames.first; gpf; gpf = gpf->next) {
|
||||
/* if frame is selected, make duplicate it and its strokes */
|
||||
@ -336,18 +336,18 @@ void copy_gpdata()
|
||||
/* add frame to buffer */
|
||||
gpfn = gpencil_frame_duplicate(gpf);
|
||||
BLI_addtail(&gpln->frames, gpfn);
|
||||
|
||||
|
||||
/* check if this is the earliest frame encountered so far */
|
||||
if (gpf->framenum < gpcopy_firstframe)
|
||||
gpcopy_firstframe = gpf->framenum;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* check if anything ended up in the buffer */
|
||||
if (ELEM(NULL, gpcopybuf.first, gpcopybuf.last))
|
||||
error("Nothing copied to buffer");
|
||||
|
||||
|
||||
/* free temp memory */
|
||||
BLI_freelistN(&act_data);
|
||||
}
|
||||
@ -359,10 +359,10 @@ void paste_gpdata(Scene *scene)
|
||||
int filter;
|
||||
void *data;
|
||||
short datatype;
|
||||
|
||||
|
||||
const int offset = (CFRA - gpcopy_firstframe);
|
||||
short no_name = 0;
|
||||
|
||||
|
||||
/* check if buffer is empty */
|
||||
if (ELEM(NULL, gpcopybuf.first, gpcopybuf.last)) {
|
||||
error("No data in buffer to paste");
|
||||
@ -371,60 +371,60 @@ void paste_gpdata(Scene *scene)
|
||||
/* check if single channel in buffer (disregard names if so) */
|
||||
if (gpcopybuf.first == gpcopybuf.last)
|
||||
no_name = 1;
|
||||
|
||||
|
||||
/* get data */
|
||||
data = get_action_context(&datatype);
|
||||
if (data == NULL) return;
|
||||
if (datatype != ACTCONT_GPENCIL) return;
|
||||
|
||||
|
||||
/* filter data */
|
||||
filter = (ACTFILTER_VISIBLE | ACTFILTER_SEL | ACTFILTER_FOREDIT);
|
||||
actdata_filter(&act_data, filter, data, datatype);
|
||||
|
||||
|
||||
/* from selected channels */
|
||||
for (ale = act_data.first; ale; ale = ale->next) {
|
||||
bGPDlayer *gpld = (bGPDlayer *)ale->data;
|
||||
bGPDlayer *gpls = NULL;
|
||||
bGPDframe *gpfs, *gpf;
|
||||
|
||||
|
||||
/* find suitable layer from buffer to use to paste from */
|
||||
for (gpls = gpcopybuf.first; gpls; gpls = gpls->next) {
|
||||
/* check if layer name matches */
|
||||
if ((no_name) || (strcmp(gpls->info, gpld->info) == 0))
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
/* this situation might occur! */
|
||||
if (gpls == NULL)
|
||||
continue;
|
||||
|
||||
|
||||
/* add frames from buffer */
|
||||
for (gpfs = gpls->frames.first; gpfs; gpfs = gpfs->next) {
|
||||
/* temporarily apply offset to buffer-frame while copying */
|
||||
gpfs->framenum += offset;
|
||||
|
||||
|
||||
/* get frame to copy data into (if no frame returned, then just ignore) */
|
||||
gpf = gpencil_layer_getframe(gpld, gpfs->framenum, 1);
|
||||
if (gpf) {
|
||||
bGPDstroke *gps, *gpsn;
|
||||
ScrArea *sa;
|
||||
|
||||
|
||||
/* get area that gp-data comes from */
|
||||
//sa = gpencil_data_findowner((bGPdata *)ale->owner);
|
||||
sa = NULL;
|
||||
|
||||
/* this should be the right frame... as it may be a pre-existing frame,
|
||||
* must make sure that only compatible stroke types get copied over
|
||||
|
||||
/* this should be the right frame... as it may be a pre-existing frame,
|
||||
* must make sure that only compatible stroke types get copied over
|
||||
* - we cannot just add a duplicate frame, as that would cause errors
|
||||
* - need to check for compatible types to minimize memory usage (copying 'junk' over)
|
||||
*/
|
||||
for (gps = gpfs->strokes.first; gps; gps = gps->next) {
|
||||
short stroke_ok;
|
||||
|
||||
|
||||
/* if there's an area, check that it supports this type of stroke */
|
||||
if (sa) {
|
||||
stroke_ok = 0;
|
||||
|
||||
|
||||
/* check if spacetype supports this type of stroke
|
||||
* - NOTE: must sync this with gp_paint_initstroke() in gpencil.c
|
||||
*/
|
||||
@ -433,14 +433,14 @@ void paste_gpdata(Scene *scene)
|
||||
if ((gps->flag == 0) || (gps->flag & GP_STROKE_3DSPACE))
|
||||
stroke_ok = 1;
|
||||
break;
|
||||
|
||||
|
||||
case SPACE_NODE: /* Nodes Editor: either screen-aligned or view-aligned */
|
||||
case SPACE_IMAGE: /* Image Editor: either screen-aligned or view\image-aligned */
|
||||
case SPACE_CLIP: /* Image Editor: either screen-aligned or view\image-aligned */
|
||||
if ((gps->flag == 0) || (gps->flag & GP_STROKE_2DSPACE))
|
||||
stroke_ok = 1;
|
||||
break;
|
||||
|
||||
|
||||
case SPACE_SEQ: /* Sequence Editor: either screen-aligned or view-aligned */
|
||||
if ((gps->flag == 0) || (gps->flag & GP_STROKE_2DIMAGE))
|
||||
stroke_ok = 1;
|
||||
@ -449,31 +449,31 @@ void paste_gpdata(Scene *scene)
|
||||
}
|
||||
else
|
||||
stroke_ok = 1;
|
||||
|
||||
|
||||
/* if stroke is ok, we make a copy of this stroke and add to frame */
|
||||
if (stroke_ok) {
|
||||
/* make a copy of stroke, then of its points array */
|
||||
gpsn = MEM_dupallocN(gps);
|
||||
gpsn->points = MEM_dupallocN(gps->points);
|
||||
|
||||
|
||||
/* append stroke to frame */
|
||||
BLI_addtail(&gpf->strokes, gpsn);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* if no strokes (i.e. new frame) added, free gpf */
|
||||
if (BLI_listbase_is_empty(&gpf->strokes))
|
||||
gpencil_layer_delframe(gpld, gpf);
|
||||
}
|
||||
|
||||
|
||||
/* unapply offset from buffer-frame */
|
||||
gpfs->framenum -= offset;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* free temp memory */
|
||||
BLI_freelistN(&act_data);
|
||||
|
||||
|
||||
/* undo and redraw stuff */
|
||||
BIF_undo_push("Paste Grease Pencil Frames");
|
||||
}
|
||||
@ -541,36 +541,36 @@ void ED_gplayer_snap_frames(bGPDlayer *gpl, Scene *scene, short mode)
|
||||
static short mirror_gpf_cframe(bGPDframe *gpf, Scene *scene)
|
||||
{
|
||||
int diff;
|
||||
|
||||
|
||||
if (gpf->flag & GP_FRAME_SELECT) {
|
||||
diff = CFRA - gpf->framenum;
|
||||
gpf->framenum = CFRA;
|
||||
}
|
||||
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static short mirror_gpf_yaxis(bGPDframe *gpf, Scene *scene)
|
||||
{
|
||||
int diff;
|
||||
|
||||
|
||||
if (gpf->flag & GP_FRAME_SELECT) {
|
||||
diff = -gpf->framenum;
|
||||
gpf->framenum = diff;
|
||||
}
|
||||
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static short mirror_gpf_xaxis(bGPDframe *gpf, Scene *scene)
|
||||
{
|
||||
int diff;
|
||||
|
||||
|
||||
if (gpf->flag & GP_FRAME_SELECT) {
|
||||
diff = -gpf->framenum;
|
||||
gpf->framenum = diff;
|
||||
}
|
||||
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -579,15 +579,15 @@ static short mirror_gpf_marker(bGPDframe *gpf, Scene *scene)
|
||||
static TimeMarker *marker;
|
||||
static short initialized = 0;
|
||||
int diff;
|
||||
|
||||
|
||||
/* In order for this mirror function to work without
|
||||
* any extra arguments being added, we use the case
|
||||
* of bezt==NULL to denote that we should find the
|
||||
* of bezt==NULL to denote that we should find the
|
||||
* marker to mirror over. The static pointer is safe
|
||||
* to use this way, as it will be set to null after
|
||||
* to use this way, as it will be set to null after
|
||||
* each cycle in which this is called.
|
||||
*/
|
||||
|
||||
|
||||
if (gpf) {
|
||||
/* mirroring time */
|
||||
if ((gpf->flag & GP_FRAME_SELECT) && (marker)) {
|
||||
@ -610,7 +610,7 @@ static short mirror_gpf_marker(bGPDframe *gpf, Scene *scene)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -27,6 +27,7 @@
|
||||
* \ingroup edgpencil
|
||||
*/
|
||||
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
@ -96,7 +97,7 @@ bGPdata **ED_gpencil_data_get_pointers_direct(ID *screen_id, Scene *scene, ScrAr
|
||||
*/
|
||||
if (sa) {
|
||||
SpaceLink *sl = sa->spacedata.first;
|
||||
|
||||
|
||||
switch (sa->spacetype) {
|
||||
case SPACE_VIEW3D: /* 3D-View */
|
||||
case SPACE_TIME: /* Timeline - XXX: this is a hack to get it to show GP keyframes for 3D view */
|
||||
@ -106,7 +107,7 @@ bGPdata **ED_gpencil_data_get_pointers_direct(ID *screen_id, Scene *scene, ScrAr
|
||||
|
||||
if (scene->toolsettings->gpencil_src == GP_TOOL_SOURCE_OBJECT) {
|
||||
/* legacy behaviour for usage with old addons requiring object-linked to objects */
|
||||
|
||||
|
||||
/* just in case no active/selected object... */
|
||||
if (ob && (ob->flag & SELECT)) {
|
||||
/* for now, as long as there's an object, default to using that in 3D-View */
|
||||
@ -196,7 +197,7 @@ bGPdata **ED_gpencil_data_get_pointers(const bContext *C, PointerRNA *ptr)
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ScrArea *sa = CTX_wm_area(C);
|
||||
Object *ob = CTX_data_active_object(C);
|
||||
|
||||
|
||||
return ED_gpencil_data_get_pointers_direct(screen_id, scene, sa, ob, ptr);
|
||||
}
|
||||
|
||||
@ -247,7 +248,7 @@ static int gp_active_layer_poll(bContext *C)
|
||||
{
|
||||
bGPdata *gpd = ED_gpencil_data_get_active(C);
|
||||
bGPDlayer *gpl = gpencil_layer_getactive(gpd);
|
||||
|
||||
|
||||
return (gpl != NULL);
|
||||
}
|
||||
|
||||
@ -319,7 +320,7 @@ static int gp_data_unlink_exec(bContext *C, wmOperator *op)
|
||||
}
|
||||
|
||||
/* notifiers */
|
||||
WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
|
||||
WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
|
||||
|
||||
return OPERATOR_FINISHED;
|
||||
}
|
||||
@ -367,9 +368,9 @@ void GPENCIL_OT_layer_add(wmOperatorType *ot)
|
||||
ot->name = "Add New Layer";
|
||||
ot->idname = "GPENCIL_OT_layer_add";
|
||||
ot->description = "Add new Grease Pencil layer for the active Grease Pencil datablock";
|
||||
|
||||
|
||||
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
|
||||
|
||||
|
||||
/* callbacks */
|
||||
ot->exec = gp_layer_add_exec;
|
||||
ot->poll = gp_add_poll;
|
||||
@ -381,17 +382,17 @@ static int gp_layer_remove_exec(bContext *C, wmOperator *op)
|
||||
{
|
||||
bGPdata *gpd = ED_gpencil_data_get_active(C);
|
||||
bGPDlayer *gpl = gpencil_layer_getactive(gpd);
|
||||
|
||||
|
||||
/* sanity checks */
|
||||
if (ELEM(NULL, gpd, gpl))
|
||||
return OPERATOR_CANCELLED;
|
||||
|
||||
|
||||
if (gpl->flag & GP_LAYER_LOCKED) {
|
||||
BKE_report(op->reports, RPT_ERROR, "Cannot delete locked layers");
|
||||
return OPERATOR_CANCELLED;
|
||||
}
|
||||
|
||||
/* make the layer before this the new active layer
|
||||
}
|
||||
|
||||
/* make the layer before this the new active layer
|
||||
* - use the one after if this is the first
|
||||
* - if this is the only layer, this naturally becomes NULL
|
||||
*/
|
||||
@ -399,13 +400,13 @@ static int gp_layer_remove_exec(bContext *C, wmOperator *op)
|
||||
gpencil_layer_setactive(gpd, gpl->prev);
|
||||
else
|
||||
gpencil_layer_setactive(gpd, gpl->next);
|
||||
|
||||
|
||||
/* delete the layer now... */
|
||||
gpencil_layer_delete(gpd, gpl);
|
||||
|
||||
|
||||
/* notifiers */
|
||||
WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
|
||||
|
||||
|
||||
return OPERATOR_FINISHED;
|
||||
}
|
||||
|
||||
@ -415,9 +416,9 @@ void GPENCIL_OT_layer_remove(wmOperatorType *ot)
|
||||
ot->name = "Remove Layer";
|
||||
ot->idname = "GPENCIL_OT_layer_remove";
|
||||
ot->description = "Remove active Grease Pencil layer";
|
||||
|
||||
|
||||
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
|
||||
|
||||
|
||||
/* callbacks */
|
||||
ot->exec = gp_layer_remove_exec;
|
||||
ot->poll = gp_active_layer_poll;
|
||||
@ -434,13 +435,13 @@ static int gp_layer_move_exec(bContext *C, wmOperator *op)
|
||||
{
|
||||
bGPdata *gpd = ED_gpencil_data_get_active(C);
|
||||
bGPDlayer *gpl = gpencil_layer_getactive(gpd);
|
||||
|
||||
|
||||
int direction = RNA_enum_get(op->ptr, "type");
|
||||
|
||||
|
||||
/* sanity checks */
|
||||
if (ELEM(NULL, gpd, gpl))
|
||||
return OPERATOR_CANCELLED;
|
||||
|
||||
|
||||
/* up or down? */
|
||||
if (direction == GP_LAYER_MOVE_UP) {
|
||||
/* up */
|
||||
@ -452,10 +453,10 @@ static int gp_layer_move_exec(bContext *C, wmOperator *op)
|
||||
BLI_remlink(&gpd->layers, gpl);
|
||||
BLI_insertlinkafter(&gpd->layers, gpl->next, gpl);
|
||||
}
|
||||
|
||||
|
||||
/* notifiers */
|
||||
WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
|
||||
|
||||
|
||||
return OPERATOR_FINISHED;
|
||||
}
|
||||
|
||||
@ -499,10 +500,10 @@ static void gp_duplicate_points(const bGPDstroke *gps, ListBase *new_strokes)
|
||||
{
|
||||
bGPDspoint *pt;
|
||||
int i;
|
||||
|
||||
|
||||
int start_idx = -1;
|
||||
|
||||
|
||||
|
||||
|
||||
/* Step through the original stroke's points:
|
||||
* - We accumulate selected points (from start_idx to current index)
|
||||
* and then convert that to a new stroke
|
||||
@ -517,8 +518,8 @@ static void gp_duplicate_points(const bGPDstroke *gps, ListBase *new_strokes)
|
||||
}
|
||||
else {
|
||||
size_t len = 0;
|
||||
|
||||
/* is this the end of current island yet?
|
||||
|
||||
/* is this the end of current island yet?
|
||||
* 1) Point i-1 was the last one that was selected
|
||||
* 2) Point i is the last in the array
|
||||
*/
|
||||
@ -529,23 +530,23 @@ static void gp_duplicate_points(const bGPDstroke *gps, ListBase *new_strokes)
|
||||
len = i - start_idx + 1;
|
||||
}
|
||||
//printf("copying from %d to %d = %d\n", start_idx, i, len);
|
||||
|
||||
|
||||
/* make copies of the relevant data */
|
||||
if (len) {
|
||||
bGPDstroke *gpsd;
|
||||
|
||||
|
||||
/* make a stupid copy first of the entire stroke (to get the flags too) */
|
||||
gpsd = MEM_dupallocN(gps);
|
||||
|
||||
|
||||
/* now, make a new points array, and copy of the relevant parts */
|
||||
gpsd->points = MEM_callocN(sizeof(bGPDspoint) * len, "gps stroke points copy");
|
||||
memcpy(gpsd->points, gps->points + start_idx, sizeof(bGPDspoint) * len);
|
||||
gpsd->totpoints = len;
|
||||
|
||||
|
||||
/* add to temp buffer */
|
||||
gpsd->next = gpsd->prev = NULL;
|
||||
BLI_addtail(new_strokes, gpsd);
|
||||
|
||||
|
||||
/* cleanup + reset for next */
|
||||
start_idx = -1;
|
||||
}
|
||||
@ -556,12 +557,12 @@ static void gp_duplicate_points(const bGPDstroke *gps, ListBase *new_strokes)
|
||||
static int gp_duplicate_exec(bContext *C, wmOperator *op)
|
||||
{
|
||||
bGPdata *gpd = ED_gpencil_data_get_active(C);
|
||||
|
||||
|
||||
if (gpd == NULL) {
|
||||
BKE_report(op->reports, RPT_ERROR, "No Grease Pencil data");
|
||||
return OPERATOR_CANCELLED;
|
||||
}
|
||||
|
||||
|
||||
/* for each visible (and editable) layer's selected strokes,
|
||||
* copy the strokes into a temporary buffer, then append
|
||||
* once all done
|
||||
@ -571,21 +572,21 @@ static int gp_duplicate_exec(bContext *C, wmOperator *op)
|
||||
ListBase new_strokes = {NULL, NULL};
|
||||
bGPDframe *gpf = gpl->actframe;
|
||||
bGPDstroke *gps;
|
||||
|
||||
|
||||
if (gpf == NULL)
|
||||
continue;
|
||||
|
||||
|
||||
/* make copies of selected strokes, and deselect these once we're done */
|
||||
for (gps = gpf->strokes.first; gps; gps = gps->next) {
|
||||
if (gps->flag & GP_STROKE_SELECT) {
|
||||
if (gps->totpoints == 1) {
|
||||
/* Special Case: If there's just a single point in this stroke... */
|
||||
bGPDstroke *gpsd;
|
||||
|
||||
|
||||
/* make direct copies of the stroke and its points */
|
||||
gpsd = MEM_dupallocN(gps);
|
||||
gpsd->points = MEM_dupallocN(gps->points);
|
||||
|
||||
|
||||
/* add to temp buffer */
|
||||
gpsd->next = gpsd->prev = NULL;
|
||||
BLI_addtail(&new_strokes, gpsd);
|
||||
@ -594,23 +595,23 @@ static int gp_duplicate_exec(bContext *C, wmOperator *op)
|
||||
/* delegate to a helper, as there's too much to fit in here (for copying subsets)... */
|
||||
gp_duplicate_points(gps, &new_strokes);
|
||||
}
|
||||
|
||||
/* deselect original stroke, or else the originals get moved too
|
||||
|
||||
/* deselect original stroke, or else the originals get moved too
|
||||
* (when using the copy + move macro)
|
||||
*/
|
||||
gps->flag &= ~GP_STROKE_SELECT;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* add all new strokes in temp buffer to the frame (preventing double-copies) */
|
||||
BLI_movelisttolist(&gpf->strokes, &new_strokes);
|
||||
BLI_assert(new_strokes.first == NULL);
|
||||
}
|
||||
CTX_DATA_END;
|
||||
|
||||
|
||||
/* updates */
|
||||
WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
|
||||
|
||||
|
||||
return OPERATOR_FINISHED;
|
||||
}
|
||||
|
||||
@ -620,11 +621,11 @@ void GPENCIL_OT_duplicate(wmOperatorType *ot)
|
||||
ot->name = "Duplicate Strokes";
|
||||
ot->idname = "GPENCIL_OT_duplicate";
|
||||
ot->description = "Duplicate the selected Grease Pencil strokes";
|
||||
|
||||
|
||||
/* callbacks */
|
||||
ot->exec = gp_duplicate_exec;
|
||||
ot->poll = gp_stroke_edit_poll;
|
||||
|
||||
|
||||
/* flags */
|
||||
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
|
||||
}
|
||||
@ -673,7 +674,7 @@ void GPENCIL_OT_active_frame_delete(wmOperatorType *ot)
|
||||
ot->name = "Delete Active Frame";
|
||||
ot->idname = "GPENCIL_OT_active_frame_delete";
|
||||
ot->description = "Delete the active frame for the active Grease Pencil datablock";
|
||||
|
||||
|
||||
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
|
||||
|
||||
/* callbacks */
|
||||
@ -699,30 +700,30 @@ typedef enum eGP_DeleteMode {
|
||||
static int gp_delete_selected_strokes(bContext *C)
|
||||
{
|
||||
bool changed = false;
|
||||
|
||||
|
||||
CTX_DATA_BEGIN(C, bGPDlayer *, gpl, editable_gpencil_layers)
|
||||
{
|
||||
bGPDframe *gpf = gpl->actframe;
|
||||
bGPDstroke *gps, *gpsn;
|
||||
|
||||
|
||||
if (gpf == NULL)
|
||||
continue;
|
||||
|
||||
|
||||
/* simply delete strokes which are selected */
|
||||
for (gps = gpf->strokes.first; gps; gps = gpsn) {
|
||||
gpsn = gps->next;
|
||||
|
||||
|
||||
if (gps->flag & GP_STROKE_SELECT) {
|
||||
/* free stroke memory arrays, then stroke itself */
|
||||
if (gps->points) MEM_freeN(gps->points);
|
||||
BLI_freelinkN(&gpf->strokes, gps);
|
||||
|
||||
|
||||
changed = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
CTX_DATA_END;
|
||||
|
||||
|
||||
if (changed) {
|
||||
WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
|
||||
return OPERATOR_FINISHED;
|
||||
@ -736,27 +737,27 @@ static int gp_delete_selected_strokes(bContext *C)
|
||||
static int gp_dissolve_selected_points(bContext *C)
|
||||
{
|
||||
bool changed = false;
|
||||
|
||||
|
||||
CTX_DATA_BEGIN(C, bGPDlayer *, gpl, editable_gpencil_layers)
|
||||
{
|
||||
bGPDframe *gpf = gpl->actframe;
|
||||
bGPDstroke *gps, *gpsn;
|
||||
|
||||
|
||||
if (gpf == NULL)
|
||||
continue;
|
||||
|
||||
|
||||
/* simply delete points from selected strokes
|
||||
* NOTE: we may still have to remove the stroke if it ends up having no points!
|
||||
*/
|
||||
for (gps = gpf->strokes.first; gps; gps = gpsn) {
|
||||
gpsn = gps->next;
|
||||
|
||||
|
||||
if (gps->flag & GP_STROKE_SELECT) {
|
||||
bGPDspoint *pt;
|
||||
int i;
|
||||
|
||||
|
||||
int tot = gps->totpoints; /* number of points in new buffer */
|
||||
|
||||
|
||||
/* First Pass: Count how many points are selected (i.e. how many to remove) */
|
||||
for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
|
||||
if (pt->flag & GP_SPOINT_SELECT) {
|
||||
@ -764,42 +765,42 @@ static int gp_dissolve_selected_points(bContext *C)
|
||||
tot--;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* if no points are left, we simply delete the entire stroke */
|
||||
if (tot <= 0) {
|
||||
/* remove the entire stroke */
|
||||
MEM_freeN(gps->points);
|
||||
BLI_freelinkN(&gpf->strokes, gps);
|
||||
}
|
||||
else {
|
||||
else {
|
||||
/* just copy all unselected into a smaller buffer */
|
||||
bGPDspoint *new_points = MEM_callocN(sizeof(bGPDspoint) * tot, "new gp stroke points copy");
|
||||
bGPDspoint *npt = new_points;
|
||||
|
||||
|
||||
for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
|
||||
if ((pt->flag & GP_SPOINT_SELECT) == 0) {
|
||||
*npt = *pt;
|
||||
npt++;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* free the old buffer */
|
||||
MEM_freeN(gps->points);
|
||||
|
||||
|
||||
/* save the new buffer */
|
||||
gps->points = new_points;
|
||||
gps->totpoints = tot;
|
||||
|
||||
|
||||
/* deselect the stroke, since none of its selected points will still be selected */
|
||||
gps->flag &= ~GP_STROKE_SELECT;
|
||||
}
|
||||
|
||||
|
||||
changed = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
CTX_DATA_END;
|
||||
|
||||
|
||||
if (changed) {
|
||||
WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
|
||||
return OPERATOR_FINISHED;
|
||||
@ -813,27 +814,27 @@ static int gp_dissolve_selected_points(bContext *C)
|
||||
static int gp_delete_selected_points(bContext *C)
|
||||
{
|
||||
bool changed = false;
|
||||
|
||||
|
||||
CTX_DATA_BEGIN(C, bGPDlayer *, gpl, editable_gpencil_layers)
|
||||
{
|
||||
bGPDframe *gpf = gpl->actframe;
|
||||
bGPDstroke *gps, *gpsn;
|
||||
|
||||
|
||||
if (gpf == NULL)
|
||||
continue;
|
||||
|
||||
|
||||
/* simply delete strokes which are selected */
|
||||
for (gps = gpf->strokes.first; gps; gps = gpsn) {
|
||||
gpsn = gps->next;
|
||||
|
||||
|
||||
if (gps->flag & GP_STROKE_SELECT) {
|
||||
bGPDspoint *pt;
|
||||
int i;
|
||||
|
||||
|
||||
/* The algorithm used here is as follows:
|
||||
* 1) We firstly identify the number of "islands" of non-selected points
|
||||
* which will all end up being in new strokes.
|
||||
* - In the most extreme case (i.e. every other vert is a 1-vert island),
|
||||
* - In the most extreme case (i.e. every other vert is a 1-vert island),
|
||||
* we have at most n / 2 islands
|
||||
* - Once we start having larger islands than that, the number required
|
||||
* becomes much less
|
||||
@ -843,11 +844,11 @@ static int gp_delete_selected_points(bContext *C)
|
||||
int start_idx;
|
||||
int end_idx;
|
||||
} tGPDeleteIsland;
|
||||
|
||||
|
||||
tGPDeleteIsland *islands = MEM_callocN(sizeof(tGPDeleteIsland) * (gps->totpoints + 1) / 2, "gp_point_islands");
|
||||
bool in_island = false;
|
||||
int num_islands = 0;
|
||||
|
||||
|
||||
/* First Pass: Identify start/end of islands */
|
||||
for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
|
||||
if (pt->flag & GP_SPOINT_SELECT) {
|
||||
@ -857,7 +858,7 @@ static int gp_delete_selected_points(bContext *C)
|
||||
else {
|
||||
/* unselected - start of a new island? */
|
||||
int idx;
|
||||
|
||||
|
||||
if (in_island) {
|
||||
/* extend existing island */
|
||||
idx = num_islands - 1;
|
||||
@ -867,33 +868,33 @@ static int gp_delete_selected_points(bContext *C)
|
||||
/* start of new island */
|
||||
in_island = true;
|
||||
num_islands++;
|
||||
|
||||
|
||||
idx = num_islands - 1;
|
||||
islands[idx].start_idx = islands[idx].end_idx = i;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* Watch out for special case where No islands = All points selected = Delete Stroke only */
|
||||
if (num_islands) {
|
||||
/* there are islands, so create a series of new strokes, adding them before the "next" stroke */
|
||||
int idx;
|
||||
|
||||
|
||||
/* deselect old stroke, since it will be used as template for the new strokes */
|
||||
gps->flag &= ~GP_STROKE_SELECT;
|
||||
|
||||
|
||||
/* create each new stroke... */
|
||||
for (idx = 0; idx < num_islands; idx++) {
|
||||
tGPDeleteIsland *island = &islands[idx];
|
||||
bGPDstroke *new_stroke = MEM_dupallocN(gps);
|
||||
|
||||
|
||||
/* compute new buffer size (+ 1 needed as the endpoint index is "inclusive") */
|
||||
new_stroke->totpoints = island->end_idx - island->start_idx + 1;
|
||||
new_stroke->points = MEM_callocN(sizeof(bGPDspoint) * new_stroke->totpoints, "gp delete stroke fragment");
|
||||
|
||||
|
||||
/* copy over the relevant points */
|
||||
memcpy(new_stroke->points, gps->points + island->start_idx, sizeof(bGPDspoint) * new_stroke->totpoints);
|
||||
|
||||
|
||||
/* add new stroke to the frame */
|
||||
if (gpsn) {
|
||||
BLI_insertlinkbefore(&gpf->strokes, gpsn, new_stroke);
|
||||
@ -903,20 +904,20 @@ static int gp_delete_selected_points(bContext *C)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* free islands */
|
||||
MEM_freeN(islands);
|
||||
|
||||
|
||||
/* Delete the old stroke */
|
||||
MEM_freeN(gps->points);
|
||||
BLI_freelinkN(&gpf->strokes, gps);
|
||||
|
||||
|
||||
changed = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
CTX_DATA_END;
|
||||
|
||||
|
||||
if (changed) {
|
||||
WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
|
||||
return OPERATOR_FINISHED;
|
||||
@ -928,28 +929,28 @@ static int gp_delete_selected_points(bContext *C)
|
||||
|
||||
|
||||
static int gp_delete_exec(bContext *C, wmOperator *op)
|
||||
{
|
||||
{
|
||||
eGP_DeleteMode mode = RNA_enum_get(op->ptr, "type");
|
||||
int result = OPERATOR_CANCELLED;
|
||||
|
||||
|
||||
switch (mode) {
|
||||
case GP_DELETEOP_STROKES: /* selected strokes */
|
||||
result = gp_delete_selected_strokes(C);
|
||||
break;
|
||||
|
||||
|
||||
case GP_DELETEOP_POINTS: /* selected points (breaks the stroke into segments) */
|
||||
result = gp_delete_selected_points(C);
|
||||
break;
|
||||
|
||||
|
||||
case GP_DELETEOP_POINTS_DISSOLVE: /* selected points (without splitting the stroke) */
|
||||
result = gp_dissolve_selected_points(C);
|
||||
break;
|
||||
|
||||
|
||||
case GP_DELETEOP_FRAME: /* active frame */
|
||||
result = gp_actframe_delete_exec(C, op);
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
@ -964,20 +965,20 @@ void GPENCIL_OT_delete(wmOperatorType *ot)
|
||||
"Delete selected points without splitting strokes"},
|
||||
{0, NULL, 0, NULL, NULL}
|
||||
};
|
||||
|
||||
|
||||
/* identifiers */
|
||||
ot->name = "Delete...";
|
||||
ot->idname = "GPENCIL_OT_delete";
|
||||
ot->description = "Delete selected Grease Pencil strokes, vertices, or frames";
|
||||
|
||||
|
||||
/* callbacks */
|
||||
ot->invoke = WM_menu_invoke;
|
||||
ot->exec = gp_delete_exec;
|
||||
ot->poll = gp_stroke_edit_poll;
|
||||
|
||||
|
||||
/* flags */
|
||||
ot->flag = OPTYPE_UNDO | OPTYPE_REGISTER;
|
||||
|
||||
|
||||
/* props */
|
||||
ot->prop = RNA_def_enum(ot->srna, "type", prop_gpencil_delete_types, 0, "Type", "Method used for deleting Grease Pencil data");
|
||||
}
|
||||
@ -1034,7 +1035,7 @@ static EnumPropertyItem *rna_GPConvert_mode_items(bContext *UNUSED(C), PointerRN
|
||||
|
||||
/* --- */
|
||||
|
||||
/* convert the coordinates from the given stroke point into 3d-coordinates
|
||||
/* convert the coordinates from the given stroke point into 3d-coordinates
|
||||
* - assumes that the active space is the 3D-View
|
||||
*/
|
||||
static void gp_strokepoint_convertcoords(bContext *C, bGPDstroke *gps, bGPDspoint *pt, float p3d[3], rctf *subrect)
|
||||
@ -1670,8 +1671,8 @@ static void gp_stroke_to_bezier_add_point(tGpTimingData *gtd, BezTriple *bezt,
|
||||
}
|
||||
|
||||
static void gp_stroke_to_bezier(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Curve *cu, rctf *subrect, Nurb **curnu,
|
||||
float minmax_weights[2], const float rad_fac, bool stitch, const bool add_start_point,
|
||||
const bool add_end_point, tGpTimingData *gtd)
|
||||
float minmax_weights[2], const float rad_fac, bool stitch, const bool add_start_point,
|
||||
const bool add_end_point, tGpTimingData *gtd)
|
||||
{
|
||||
bGPDspoint *pt;
|
||||
Nurb *nu = (curnu) ? *curnu : NULL;
|
||||
@ -2056,7 +2057,7 @@ static void gp_layer_to_curve(bContext *C, ReportList *reports, bGPdata *gpd, bG
|
||||
}
|
||||
|
||||
switch (mode) {
|
||||
case GP_STROKECONVERT_PATH:
|
||||
case GP_STROKECONVERT_PATH:
|
||||
gp_stroke_to_path(C, gpl, gps, cu, subrect_ptr, &nu, minmax_weights, rad_fac, stitch,
|
||||
add_start_point, add_end_point, gtd);
|
||||
break;
|
||||
|
@ -54,20 +54,20 @@ struct wmOperatorType;
|
||||
typedef struct GP_SpaceConversion {
|
||||
struct bGPdata *gpd;
|
||||
struct bGPDlayer *gpl;
|
||||
|
||||
|
||||
struct ScrArea *sa;
|
||||
struct ARegion *ar;
|
||||
struct View2D *v2d;
|
||||
|
||||
|
||||
rctf *subrect; /* for using the camera rect within the 3d view */
|
||||
rctf subrect_data;
|
||||
|
||||
|
||||
float mat[4][4]; /* transform matrix on the strokes (introduced in [b770964]) */
|
||||
} GP_SpaceConversion;
|
||||
|
||||
|
||||
/**
|
||||
* Check whether a given stroke segment is inside a circular brush
|
||||
/**
|
||||
* Check whether a given stroke segment is inside a circular brush
|
||||
*
|
||||
* \param mval The current screen-space coordinates (midpoint) of the brush
|
||||
* \param mvalo The previous screen-space coordinates (midpoint) of the brush (NOT CURRENTLY USED)
|
||||
@ -81,7 +81,7 @@ bool gp_stroke_inside_circle(const int mval[2], const int UNUSED(mvalo[2]),
|
||||
|
||||
|
||||
/**
|
||||
* Init settings for stroke point space conversions
|
||||
* Init settings for stroke point space conversions
|
||||
*
|
||||
* \param[out] r_gsc The space conversion settings struct, populated with necessary params
|
||||
*/
|
||||
@ -152,17 +152,17 @@ void gpencil_undo_finish(void);
|
||||
/* This struct defines a structure used for quick access */
|
||||
typedef struct bActListElem {
|
||||
struct bActListElem *next, *prev;
|
||||
|
||||
|
||||
void *data; /* source data this elem represents */
|
||||
int type; /* one of the ACTTYPE_* values */
|
||||
int flag; /* copy of elem's flags for quick access */
|
||||
int index; /* copy of adrcode where applicable */
|
||||
|
||||
|
||||
void *key_data; /* motion data - ipo or ipo-curve */
|
||||
short datatype; /* type of motion data to expect */
|
||||
|
||||
|
||||
struct bActionGroup *grp; /* action group that owns the channel */
|
||||
|
||||
|
||||
void *owner; /* will either be an action channel or fake ipo-channel (for keys) */
|
||||
short ownertype; /* type of owner */
|
||||
} bActListElem;
|
||||
|
@ -59,34 +59,34 @@ static void ed_keymap_gpencil_general(wmKeyConfig *keyconf)
|
||||
{
|
||||
wmKeyMap *keymap = WM_keymap_find(keyconf, "Grease Pencil", 0, 0);
|
||||
wmKeyMapItem *kmi;
|
||||
|
||||
|
||||
/* Draw --------------------------------------- */
|
||||
/* draw */
|
||||
kmi = WM_keymap_add_item(keymap, "GPENCIL_OT_draw", LEFTMOUSE, KM_PRESS, 0, DKEY);
|
||||
RNA_enum_set(kmi->ptr, "mode", GP_PAINTMODE_DRAW);
|
||||
RNA_boolean_set(kmi->ptr, "wait_for_input", false);
|
||||
|
||||
|
||||
/* draw - straight lines */
|
||||
kmi = WM_keymap_add_item(keymap, "GPENCIL_OT_draw", LEFTMOUSE, KM_PRESS, KM_CTRL, DKEY);
|
||||
RNA_enum_set(kmi->ptr, "mode", GP_PAINTMODE_DRAW_STRAIGHT);
|
||||
RNA_boolean_set(kmi->ptr, "wait_for_input", false);
|
||||
|
||||
|
||||
/* draw - poly lines */
|
||||
kmi = WM_keymap_add_item(keymap, "GPENCIL_OT_draw", LEFTMOUSE, KM_PRESS, KM_ALT, DKEY);
|
||||
RNA_enum_set(kmi->ptr, "mode", GP_PAINTMODE_DRAW_POLY);
|
||||
RNA_boolean_set(kmi->ptr, "wait_for_input", false);
|
||||
|
||||
|
||||
/* erase */
|
||||
kmi = WM_keymap_add_item(keymap, "GPENCIL_OT_draw", RIGHTMOUSE, KM_PRESS, 0, DKEY);
|
||||
RNA_enum_set(kmi->ptr, "mode", GP_PAINTMODE_ERASER);
|
||||
RNA_boolean_set(kmi->ptr, "wait_for_input", false);
|
||||
|
||||
|
||||
/* Viewport Tools ------------------------------- */
|
||||
|
||||
|
||||
/* Enter EditMode */
|
||||
kmi = WM_keymap_add_item(keymap, "WM_OT_context_toggle", TABKEY, KM_PRESS, 0, DKEY);
|
||||
RNA_string_set(kmi->ptr, "data_path", "gpencil_data.use_stroke_edit_mode");
|
||||
|
||||
|
||||
/* Pie Menu - For standard tools */
|
||||
WM_keymap_add_menu_pie(keymap, "GPENCIL_PIE_tool_palette", QKEY, KM_PRESS, 0, DKEY);
|
||||
WM_keymap_add_menu_pie(keymap, "GPENCIL_PIE_settings_palette", WKEY, KM_PRESS, 0, DKEY);
|
||||
@ -106,89 +106,89 @@ static void ed_keymap_gpencil_editing(wmKeyConfig *keyconf)
|
||||
{
|
||||
wmKeyMap *keymap = WM_keymap_find(keyconf, "Grease Pencil Stroke Edit Mode", 0, 0);
|
||||
wmKeyMapItem *kmi;
|
||||
|
||||
|
||||
/* set poll callback - so that this keymap only gets enabled when stroke editmode is enabled */
|
||||
keymap->poll = gp_stroke_editmode_poll;
|
||||
|
||||
|
||||
/* ----------------------------------------------- */
|
||||
|
||||
|
||||
/* Exit EditMode */
|
||||
kmi = WM_keymap_add_item(keymap, "WM_OT_context_toggle", TABKEY, KM_PRESS, 0, 0);
|
||||
RNA_string_set(kmi->ptr, "data_path", "gpencil_data.use_stroke_edit_mode");
|
||||
|
||||
|
||||
/* Selection ------------------------------------- */
|
||||
/* select all */
|
||||
kmi = WM_keymap_add_item(keymap, "GPENCIL_OT_select_all", AKEY, KM_PRESS, 0, 0);
|
||||
RNA_enum_set(kmi->ptr, "action", SEL_TOGGLE);
|
||||
|
||||
|
||||
kmi = WM_keymap_add_item(keymap, "GPENCIL_OT_select_all", IKEY, KM_PRESS, KM_CTRL, 0);
|
||||
RNA_enum_set(kmi->ptr, "action", SEL_INVERT);
|
||||
|
||||
|
||||
/* circle select */
|
||||
WM_keymap_add_item(keymap, "GPENCIL_OT_select_circle", CKEY, KM_PRESS, 0, 0);
|
||||
|
||||
|
||||
/* border select */
|
||||
WM_keymap_add_item(keymap, "GPENCIL_OT_select_border", BKEY, KM_PRESS, 0, 0);
|
||||
|
||||
|
||||
/* lasso select */
|
||||
kmi = WM_keymap_add_item(keymap, "GPENCIL_OT_select_lasso", EVT_TWEAK_A, KM_ANY, KM_CTRL, 0);
|
||||
RNA_boolean_set(kmi->ptr, "deselect", false);
|
||||
kmi = WM_keymap_add_item(keymap, "GPENCIL_OT_select_lasso", EVT_TWEAK_A, KM_ANY, KM_SHIFT | KM_CTRL, 0);
|
||||
RNA_boolean_set(kmi->ptr, "deselect", true);
|
||||
|
||||
|
||||
/* normal select */
|
||||
WM_keymap_add_item(keymap, "GPENCIL_OT_select", SELECTMOUSE, KM_PRESS, 0, 0);
|
||||
|
||||
|
||||
kmi = WM_keymap_add_item(keymap, "GPENCIL_OT_select", SELECTMOUSE, KM_PRESS, KM_SHIFT, 0);
|
||||
RNA_boolean_set(kmi->ptr, "extend", true);
|
||||
RNA_boolean_set(kmi->ptr, "toggle", true);
|
||||
|
||||
|
||||
/* whole stroke select */
|
||||
kmi = WM_keymap_add_item(keymap, "GPENCIL_OT_select", SELECTMOUSE, KM_PRESS, KM_ALT, 0);
|
||||
RNA_boolean_set(kmi->ptr, "entire_strokes", true);
|
||||
|
||||
|
||||
/* select linked */
|
||||
WM_keymap_add_item(keymap, "GPENCIL_OT_select_linked", LKEY, KM_PRESS, KM_CTRL, 0);
|
||||
|
||||
|
||||
/* select more/less */
|
||||
WM_keymap_add_item(keymap, "GPENCIL_OT_select_more", PADPLUSKEY, KM_PRESS, KM_CTRL, 0);
|
||||
WM_keymap_add_item(keymap, "GPENCIL_OT_select_less", PADMINUS, KM_PRESS, KM_CTRL, 0);
|
||||
|
||||
|
||||
|
||||
|
||||
/* Editing ----------------------------------------- */
|
||||
|
||||
|
||||
/* duplicate and move selected points */
|
||||
WM_keymap_add_item(keymap, "GPENCIL_OT_duplicate_move", DKEY, KM_PRESS, KM_SHIFT, 0);
|
||||
|
||||
|
||||
/* delete */
|
||||
WM_keymap_add_item(keymap, "GPENCIL_OT_delete", XKEY, KM_PRESS, 0, 0);
|
||||
|
||||
|
||||
|
||||
|
||||
/* Transform Tools */
|
||||
kmi = WM_keymap_add_item(keymap, "TRANSFORM_OT_translate", GKEY, KM_PRESS, 0, 0);
|
||||
RNA_boolean_set(kmi->ptr, "gpencil_strokes", true);
|
||||
|
||||
|
||||
kmi = WM_keymap_add_item(keymap, "TRANSFORM_OT_translate", EVT_TWEAK_S, KM_ANY, 0, 0);
|
||||
RNA_boolean_set(kmi->ptr, "gpencil_strokes", true);
|
||||
|
||||
|
||||
kmi = WM_keymap_add_item(keymap, "TRANSFORM_OT_rotate", RKEY, KM_PRESS, 0, 0);
|
||||
RNA_boolean_set(kmi->ptr, "gpencil_strokes", true);
|
||||
|
||||
|
||||
kmi = WM_keymap_add_item(keymap, "TRANSFORM_OT_resize", SKEY, KM_PRESS, 0, 0);
|
||||
RNA_boolean_set(kmi->ptr, "gpencil_strokes", true);
|
||||
|
||||
|
||||
kmi = WM_keymap_add_item(keymap, "TRANSFORM_OT_mirror", MKEY, KM_PRESS, KM_CTRL, 0);
|
||||
RNA_boolean_set(kmi->ptr, "gpencil_strokes", true);
|
||||
|
||||
|
||||
kmi = WM_keymap_add_item(keymap, "TRANSFORM_OT_bend", WKEY, KM_PRESS, KM_SHIFT, 0);
|
||||
RNA_boolean_set(kmi->ptr, "gpencil_strokes", true);
|
||||
|
||||
|
||||
WM_keymap_add_item(keymap, "TRANSFORM_OT_tosphere", SKEY, KM_PRESS, KM_ALT | KM_SHIFT, 0);
|
||||
RNA_boolean_set(kmi->ptr, "gpencil_strokes", true);
|
||||
|
||||
|
||||
WM_keymap_add_item(keymap, "TRANSFORM_OT_shear", SKEY, KM_PRESS, KM_ALT | KM_CTRL | KM_SHIFT, 0);
|
||||
RNA_boolean_set(kmi->ptr, "gpencil_strokes", true);
|
||||
|
||||
|
||||
/* Proportional Editing */
|
||||
ED_keymap_proportional_cycle(keyconf, keymap);
|
||||
ED_keymap_proportional_editmode(keyconf, keymap, true);
|
||||
@ -207,37 +207,37 @@ void ED_keymap_gpencil(wmKeyConfig *keyconf)
|
||||
void ED_operatortypes_gpencil(void)
|
||||
{
|
||||
/* Drawing ----------------------- */
|
||||
|
||||
|
||||
WM_operatortype_append(GPENCIL_OT_draw);
|
||||
|
||||
|
||||
/* Editing (Strokes) ------------ */
|
||||
|
||||
|
||||
WM_operatortype_append(GPENCIL_OT_select);
|
||||
WM_operatortype_append(GPENCIL_OT_select_all);
|
||||
WM_operatortype_append(GPENCIL_OT_select_circle);
|
||||
WM_operatortype_append(GPENCIL_OT_select_border);
|
||||
WM_operatortype_append(GPENCIL_OT_select_lasso);
|
||||
|
||||
|
||||
WM_operatortype_append(GPENCIL_OT_select_linked);
|
||||
WM_operatortype_append(GPENCIL_OT_select_more);
|
||||
WM_operatortype_append(GPENCIL_OT_select_less);
|
||||
|
||||
|
||||
WM_operatortype_append(GPENCIL_OT_duplicate);
|
||||
WM_operatortype_append(GPENCIL_OT_delete);
|
||||
|
||||
|
||||
/* Editing (Buttons) ------------ */
|
||||
|
||||
|
||||
WM_operatortype_append(GPENCIL_OT_data_add);
|
||||
WM_operatortype_append(GPENCIL_OT_data_unlink);
|
||||
|
||||
|
||||
WM_operatortype_append(GPENCIL_OT_layer_add);
|
||||
WM_operatortype_append(GPENCIL_OT_layer_remove);
|
||||
WM_operatortype_append(GPENCIL_OT_layer_move);
|
||||
|
||||
|
||||
WM_operatortype_append(GPENCIL_OT_active_frame_delete);
|
||||
|
||||
|
||||
WM_operatortype_append(GPENCIL_OT_convert);
|
||||
|
||||
|
||||
/* Editing (Time) --------------- */
|
||||
}
|
||||
|
||||
|
File diff suppressed because it is too large
Load Diff
@ -29,6 +29,7 @@
|
||||
* \ingroup edgpencil
|
||||
*/
|
||||
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
@ -133,12 +134,12 @@ void gpencil_undo_push(bGPdata *gpd)
|
||||
|
||||
while (undo_node) {
|
||||
bGPundonode *next_node = undo_node->next;
|
||||
|
||||
|
||||
/* HACK: animdata wasn't duplicated, so it shouldn't be freed here,
|
||||
* or else the real copy will segfault when accessed
|
||||
* or else the real copy will segfault when accessed
|
||||
*/
|
||||
undo_node->gpd->adt = NULL;
|
||||
|
||||
|
||||
BKE_gpencil_free(undo_node->gpd);
|
||||
MEM_freeN(undo_node->gpd);
|
||||
|
||||
@ -163,10 +164,10 @@ void gpencil_undo_finish(void)
|
||||
|
||||
while (undo_node) {
|
||||
/* HACK: animdata wasn't duplicated, so it shouldn't be freed here,
|
||||
* or else the real copy will segfault when accessed
|
||||
* or else the real copy will segfault when accessed
|
||||
*/
|
||||
undo_node->gpd->adt = NULL;
|
||||
|
||||
|
||||
BKE_gpencil_free(undo_node->gpd);
|
||||
MEM_freeN(undo_node->gpd);
|
||||
|
||||
|
Loading…
Reference in New Issue
Block a user