/* draw a given stroke - just a single dot (only one point) */
static void gp_draw_stroke_point(bGPDspoint *points, short thickness, short dflag, short sflag,
int offsx, int offsy, int winx, int winy)
{
/* set point thickness (since there's only one of these) */
glPointSize((float)(thickness + 2) * points->pressure);
/* draw point */
if (sflag & GP_STROKE_3DSPACE) {
glBegin(GL_POINTS);
glVertex3fv(&points->x);
glEnd();
}
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
*/
if ((thickness < GP_DRAWTHICKNESS_SPECIAL) ||
((dflag & GP_DRAWDATA_IEDITHACK) && (sflag & GP_STROKE_2DSPACE)))
{
glBegin(GL_POINTS);
glVertex2fv(co);
glEnd();
}
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);
/* need to translate drawing position, but must reset after too! */
glTranslate2fv(co);
gluDisk(qobj, 0.0, thickness, 32, 1);
glTranslatef(-co[0], -co[1], 0.0);
gluDeleteQuadric(qobj);
}
}
}
/* draw grease pencil */
void clip_draw_grease_pencil(bContext *C, int onlyv2d)
{
SpaceClip *sc = CTX_wm_space_clip(C);
MovieClip *clip = ED_space_clip_get_clip(sc);
if (!clip)
return;
if (onlyv2d) {
bool is_track_source = sc->gpencil_src == SC_GPENCIL_SRC_TRACK;
/* if manual calibration is used then grease pencil data
* associated with the clip is already drawn in draw_distortion
*/
if ((sc->flag & SC_MANUAL_CALIBRATION) == 0 || is_track_source) {
glPushMatrix();
glMultMatrixf(sc->unistabmat);
if (is_track_source) {
MovieTrackingTrack *track = BKE_tracking_track_get_active(&sc->clip->tracking);
if (track) {
int framenr = ED_space_clip_get_clip_frame_number(sc);
MovieTrackingMarker *marker = BKE_tracking_marker_get(track, framenr);
glTranslate2fv(marker->pos);
}
}
ED_gpencil_draw_2dimage(C);
glPopMatrix();
}
}
else {
ED_gpencil_draw_view2d(C, 0);
}
}
void drawSnapping(const struct bContext *C, TransInfo *t)
{
unsigned char col[4], selectedCol[4], activeCol[4];
if (!activeSnap(t))
return;
UI_GetThemeColor3ubv(TH_TRANSFORM, col);
col[3] = 128;
UI_GetThemeColor3ubv(TH_SELECT, selectedCol);
selectedCol[3] = 128;
UI_GetThemeColor3ubv(TH_ACTIVE, activeCol);
activeCol[3] = 192;
if (t->spacetype == SPACE_VIEW3D) {
if (validSnap(t)) {
TransSnapPoint *p;
View3D *v3d = CTX_wm_view3d(C);
RegionView3D *rv3d = CTX_wm_region_view3d(C);
float imat[4][4];
float size;
glDisable(GL_DEPTH_TEST);
size = 2.5f * UI_GetThemeValuef(TH_VERTEX_SIZE);
invert_m4_m4(imat, rv3d->viewmat);
for (p = t->tsnap.points.first; p; p = p->next) {
if (p == t->tsnap.selectedPoint) {
glColor4ubv(selectedCol);
}
else {
glColor4ubv(col);
}
drawcircball(GL_LINE_LOOP, p->co, ED_view3d_pixel_size(rv3d, p->co) * size * 0.75f, imat);
}
if (t->tsnap.status & POINT_INIT) {
glColor4ubv(activeCol);
drawcircball(GL_LINE_LOOP, t->tsnap.snapPoint, ED_view3d_pixel_size(rv3d, t->tsnap.snapPoint) * size, imat);
}
/* draw normal if needed */
if (usingSnappingNormal(t) && validSnappingNormal(t)) {
glColor4ubv(activeCol);
glBegin(GL_LINES);
glVertex3f(t->tsnap.snapPoint[0], t->tsnap.snapPoint[1], t->tsnap.snapPoint[2]);
glVertex3f(t->tsnap.snapPoint[0] + t->tsnap.snapNormal[0],
t->tsnap.snapPoint[1] + t->tsnap.snapNormal[1],
t->tsnap.snapPoint[2] + t->tsnap.snapNormal[2]);
glEnd();
}
if (v3d->zbuf)
glEnable(GL_DEPTH_TEST);
}
}
else if (t->spacetype == SPACE_IMAGE) {
if (validSnap(t)) {
/* This will not draw, and Im nor sure why - campbell */
#if 0
float xuser_asp, yuser_asp;
int wi, hi;
float w, h;
calc_image_view(G.sima, 'f'); // float
myortho2(G.v2d->cur.xmin, G.v2d->cur.xmax, G.v2d->cur.ymin, G.v2d->cur.ymax);
glLoadIdentity();
ED_space_image_get_aspect(t->sa->spacedata.first, &xuser_aspx, &yuser_asp);
ED_space_image_width(t->sa->spacedata.first, &wi, &hi);
w = (((float)wi) / IMG_SIZE_FALLBACK) * G.sima->zoom * xuser_asp;
h = (((float)hi) / IMG_SIZE_FALLBACK) * G.sima->zoom * yuser_asp;
cpack(0xFFFFFF);
glTranslate2fv(t->tsnap.snapPoint);
//glRectf(0, 0, 1, 1);
setlinestyle(0);
cpack(0x0);
fdrawline(-0.020 / w, 0, -0.1 / w, 0);
fdrawline(0.1 / w, 0, 0.020 / w, 0);
fdrawline(0, -0.020 / h, 0, -0.1 / h);
fdrawline(0, 0.1 / h, 0, 0.020 / h);
glTranslatef(-t->tsnap.snapPoint[0], -t->tsnap.snapPoint[1], 0.0f);
setlinestyle(0);
#endif
}
}
else if (t->spacetype == SPACE_NODE) {
if (validSnap(t)) {
ARegion *ar = CTX_wm_region(C);
TransSnapPoint *p;
float size;
size = 2.5f * UI_GetThemeValuef(TH_VERTEX_SIZE);
glEnable(GL_BLEND);
for (p = t->tsnap.points.first; p; p = p->next) {
if (p == t->tsnap.selectedPoint) {
glColor4ubv(selectedCol);
}
else {
glColor4ubv(col);
}
ED_node_draw_snap(&ar->v2d, p->co, size, 0);
}
if (t->tsnap.status & POINT_INIT) {
glColor4ubv(activeCol);
ED_node_draw_snap(&ar->v2d, t->tsnap.snapPoint, size, t->tsnap.snapNodeBorder);
}
glDisable(GL_BLEND);
}
}
}
static void draw_marker_slide_zones(SpaceClip *sc, MovieTrackingTrack *track, MovieTrackingMarker *marker,
const float marker_pos[2], int outline, int sel, int act, int width, int height)
{
float dx, dy, patdx, patdy, searchdx, searchdy;
int tiny = sc->flag & SC_SHOW_TINY_MARKER;
float col[3], scol[3], px[2], side;
if ((tiny && outline) || (marker->flag & MARKER_DISABLED))
return;
if (!TRACK_VIEW_SELECTED(sc, track) || track->flag & TRACK_LOCKED)
return;
track_colors(track, act, col, scol);
if (outline) {
UI_ThemeColor(TH_MARKER_OUTLINE);
}
glPushMatrix();
glTranslate2fv(marker_pos);
dx = 6.0f / width / sc->zoom;
dy = 6.0f / height / sc->zoom;
side = get_shortest_pattern_side(marker);
patdx = min_ff(dx * 2.0f / 3.0f, side / 6.0f) * UI_DPI_FAC;
patdy = min_ff(dy * 2.0f / 3.0f, side * width / height / 6.0f) * UI_DPI_FAC;
searchdx = min_ff(dx, (marker->search_max[0] - marker->search_min[0]) / 6.0f) * UI_DPI_FAC;
searchdy = min_ff(dy, (marker->search_max[1] - marker->search_min[1]) / 6.0f) * UI_DPI_FAC;
px[0] = 1.0f / sc->zoom / width / sc->scale;
px[1] = 1.0f / sc->zoom / height / sc->scale;
if ((sc->flag & SC_SHOW_MARKER_SEARCH) && ((track->search_flag & SELECT) == sel || outline)) {
if (!outline) {
if (track->search_flag & SELECT)
glColor3fv(scol);
else
glColor3fv(col);
}
/* search offset square */
draw_marker_slide_square(marker->search_min[0], marker->search_max[1], searchdx, searchdy, outline, px);
/* search re-sizing triangle */
draw_marker_slide_triangle(marker->search_max[0], marker->search_min[1], searchdx, searchdy, outline, px);
}
if ((sc->flag & SC_SHOW_MARKER_PATTERN) && ((track->pat_flag & SELECT) == sel || outline)) {
int i;
float pat_min[2], pat_max[2];
/* float dx = 12.0f / width, dy = 12.0f / height;*/ /* XXX UNUSED */
float tilt_ctrl[2];
if (!outline) {
if (track->pat_flag & SELECT)
glColor3fv(scol);
else
glColor3fv(col);
}
/* pattern's corners sliding squares */
for (i = 0; i < 4; i++) {
draw_marker_slide_square(marker->pattern_corners[i][0], marker->pattern_corners[i][1],
patdx / 1.5f, patdy / 1.5f, outline, px);
}
/* ** sliders to control overall pattern ** */
add_v2_v2v2(tilt_ctrl, marker->pattern_corners[1], marker->pattern_corners[2]);
BKE_tracking_marker_pattern_minmax(marker, pat_min, pat_max);
glLineWidth(outline ? 3.0f : 1.0f);
glBegin(GL_LINES);
glVertex2f(0.0f, 0.0f);
glVertex2fv(tilt_ctrl);
glEnd();
GPU_basic_shader_bind_disable(GPU_SHADER_LINE | GPU_SHADER_STIPPLE);
/* slider to control pattern tilt */
draw_marker_slide_square(tilt_ctrl[0], tilt_ctrl[1], patdx, patdy, outline, px);
}
glPopMatrix();
}
static void draw_marker_areas(SpaceClip *sc, MovieTrackingTrack *track, MovieTrackingMarker *marker,
const float marker_pos[2], int width, int height, int act, int sel)
{
int tiny = sc->flag & SC_SHOW_TINY_MARKER;
bool show_search = false;
float col[3], scol[3], px[2];
track_colors(track, act, col, scol);
px[0] = 1.0f / width / sc->zoom;
px[1] = 1.0f / height / sc->zoom;
glLineWidth(1.0f);
/* marker position and offset position */
if ((track->flag & SELECT) == sel && (marker->flag & MARKER_DISABLED) == 0) {
float pos[2], p[2];
if (track->flag & TRACK_LOCKED) {
if (act)
UI_ThemeColor(TH_ACT_MARKER);
else if (track->flag & SELECT)
UI_ThemeColorShade(TH_LOCK_MARKER, 64);
else
UI_ThemeColor(TH_LOCK_MARKER);
}
else {
if (track->flag & SELECT)
glColor3fv(scol);
else
glColor3fv(col);
}
add_v2_v2v2(pos, marker->pos, track->offset);
ED_clip_point_undistorted_pos(sc, pos, pos);
sub_v2_v2v2(p, pos, marker_pos);
if (isect_point_quad_v2(p, marker->pattern_corners[0], marker->pattern_corners[1],
marker->pattern_corners[2], marker->pattern_corners[3]))
{
glPointSize(tiny ? 1.0f : 2.0f);
glBegin(GL_POINTS);
glVertex2f(pos[0], pos[1]);
glEnd();
}
else {
glBegin(GL_LINES);
glVertex2f(pos[0] + px[0] * 3, pos[1]);
glVertex2f(pos[0] + px[0] * 7, pos[1]);
glVertex2f(pos[0] - px[0] * 3, pos[1]);
glVertex2f(pos[0] - px[0] * 7, pos[1]);
glVertex2f(pos[0], pos[1] - px[1] * 3);
glVertex2f(pos[0], pos[1] - px[1] * 7);
glVertex2f(pos[0], pos[1] + px[1] * 3);
glVertex2f(pos[0], pos[1] + px[1] * 7);
glEnd();
glColor3f(0.0f, 0.0f, 0.0f);
GPU_basic_shader_bind_enable(GPU_SHADER_LINE | GPU_SHADER_STIPPLE);
GPU_basic_shader_line_stipple(3, 0xAAAA);
glEnable(GL_COLOR_LOGIC_OP);
glLogicOp(GL_NOR);
glBegin(GL_LINES);
glVertex2fv(pos);
glVertex2fv(marker_pos);
glEnd();
glDisable(GL_COLOR_LOGIC_OP);
GPU_basic_shader_bind_disable(GPU_SHADER_LINE | GPU_SHADER_STIPPLE);
}
}
/* pattern */
glPushMatrix();
glTranslate2fv(marker_pos);
if (tiny) {
GPU_basic_shader_bind_enable(GPU_SHADER_LINE | GPU_SHADER_STIPPLE);
GPU_basic_shader_line_stipple(3, 0xAAAA);
}
else {
GPU_basic_shader_bind_enable(GPU_SHADER_LINE);
}
if ((track->pat_flag & SELECT) == sel && (sc->flag & SC_SHOW_MARKER_PATTERN)) {
if (track->flag & TRACK_LOCKED) {
if (act)
UI_ThemeColor(TH_ACT_MARKER);
else if (track->pat_flag & SELECT)
UI_ThemeColorShade(TH_LOCK_MARKER, 64);
else UI_ThemeColor(TH_LOCK_MARKER);
}
else if (marker->flag & MARKER_DISABLED) {
if (act)
UI_ThemeColor(TH_ACT_MARKER);
else if (track->pat_flag & SELECT)
UI_ThemeColorShade(TH_DIS_MARKER, 128);
else UI_ThemeColor(TH_DIS_MARKER);
}
else {
if (track->pat_flag & SELECT)
glColor3fv(scol);
else glColor3fv(col);
}
glBegin(GL_LINE_LOOP);
glVertex2fv(marker->pattern_corners[0]);
glVertex2fv(marker->pattern_corners[1]);
glVertex2fv(marker->pattern_corners[2]);
glVertex2fv(marker->pattern_corners[3]);
glEnd();
}
/* search */
show_search = (TRACK_VIEW_SELECTED(sc, track) &&
((marker->flag & MARKER_DISABLED) == 0 || (sc->flag & SC_SHOW_MARKER_PATTERN) == 0)) != 0;
if ((track->search_flag & SELECT) == sel && (sc->flag & SC_SHOW_MARKER_SEARCH) && show_search) {
if (track->flag & TRACK_LOCKED) {
if (act)
UI_ThemeColor(TH_ACT_MARKER);
else if (track->search_flag & SELECT)
UI_ThemeColorShade(TH_LOCK_MARKER, 64);
else UI_ThemeColor(TH_LOCK_MARKER);
}
else if (marker->flag & MARKER_DISABLED) {
if (act)
UI_ThemeColor(TH_ACT_MARKER);
else if (track->search_flag & SELECT)
UI_ThemeColorShade(TH_DIS_MARKER, 128);
else UI_ThemeColor(TH_DIS_MARKER);
}
else {
if (track->search_flag & SELECT)
glColor3fv(scol);
else
glColor3fv(col);
}
glBegin(GL_LINE_LOOP);
glVertex2f(marker->search_min[0], marker->search_min[1]);
glVertex2f(marker->search_max[0], marker->search_min[1]);
glVertex2f(marker->search_max[0], marker->search_max[1]);
glVertex2f(marker->search_min[0], marker->search_max[1]);
glEnd();
}
if (tiny) {
GPU_basic_shader_bind_disable(GPU_SHADER_LINE | GPU_SHADER_STIPPLE);
}
else {
GPU_basic_shader_bind_disable(GPU_SHADER_LINE);
}
glPopMatrix();
}
static void draw_marker_outline(SpaceClip *sc, MovieTrackingTrack *track, MovieTrackingMarker *marker,
const float marker_pos[2], int width, int height)
{
int tiny = sc->flag & SC_SHOW_TINY_MARKER;
bool show_search = false;
float px[2];
UI_ThemeColor(TH_MARKER_OUTLINE);
px[0] = 1.0f / width / sc->zoom;
px[1] = 1.0f / height / sc->zoom;
glLineWidth(tiny ? 1.0f : 3.0f);
if ((marker->flag & MARKER_DISABLED) == 0) {
float pos[2];
float p[2];
add_v2_v2v2(pos, marker->pos, track->offset);
ED_clip_point_undistorted_pos(sc, pos, pos);
sub_v2_v2v2(p, pos, marker_pos);
if (isect_point_quad_v2(p, marker->pattern_corners[0], marker->pattern_corners[1],
marker->pattern_corners[2], marker->pattern_corners[3]))
{
glPointSize(tiny ? 3.0f : 4.0f);
glBegin(GL_POINTS);
glVertex2f(pos[0], pos[1]);
glEnd();
}
else {
glBegin(GL_LINES);
glVertex2f(pos[0] + px[0] * 2, pos[1]);
glVertex2f(pos[0] + px[0] * 8, pos[1]);
glVertex2f(pos[0] - px[0] * 2, pos[1]);
glVertex2f(pos[0] - px[0] * 8, pos[1]);
glVertex2f(pos[0], pos[1] - px[1] * 2);
glVertex2f(pos[0], pos[1] - px[1] * 8);
glVertex2f(pos[0], pos[1] + px[1] * 2);
glVertex2f(pos[0], pos[1] + px[1] * 8);
glEnd();
}
}
/* pattern and search outline */
glPushMatrix();
glTranslate2fv(marker_pos);
if (sc->flag & SC_SHOW_MARKER_PATTERN) {
glBegin(GL_LINE_LOOP);
glVertex2fv(marker->pattern_corners[0]);
glVertex2fv(marker->pattern_corners[1]);
glVertex2fv(marker->pattern_corners[2]);
glVertex2fv(marker->pattern_corners[3]);
glEnd();
}
show_search = (TRACK_VIEW_SELECTED(sc, track) &&
((marker->flag & MARKER_DISABLED) == 0 || (sc->flag & SC_SHOW_MARKER_PATTERN) == 0)) != 0;
if (sc->flag & SC_SHOW_MARKER_SEARCH && show_search) {
glBegin(GL_LINE_LOOP);
glVertex2f(marker->search_min[0], marker->search_min[1]);
glVertex2f(marker->search_max[0], marker->search_min[1]);
glVertex2f(marker->search_max[0], marker->search_max[1]);
glVertex2f(marker->search_min[0], marker->search_max[1]);
glEnd();
}
glPopMatrix();
}