static void datadropper_draw_cb(const struct bContext *C, ARegion *ar, void *arg)
{
DataDropper *ddr = arg;
int width;
const char *name = ddr->name;
wmWindow *win = CTX_wm_window(C);
int x = win->eventstate->x;
int y = win->eventstate->y;
if ((name[0] == '\0') ||
(BLI_rcti_isect_pt(&ar->winrct, x, y) == false))
{
return;
}
width = UI_GetStringWidth(name);
x = x - ar->winrct.xmin;
y = y - ar->winrct.ymin;
y += 20;
glColor4ub(0, 0, 0, 50);
uiSetRoundBox(UI_CNR_ALL | UI_RB_ALPHA);
uiRoundBox(x, y, x + width + 8, y + 15, 4);
glColor4ub(255, 255, 255, 255);
UI_DrawString(x + 4, y + 4, name);
}
static void draw_scope_end(const rctf *rect, GLint *scissor)
{
float scaler_x1, scaler_x2;
/* restore scissortest */
glScissor(scissor[0], scissor[1], scissor[2], scissor[3]);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
/* scale widget */
scaler_x1 = rect->xmin + BLI_rctf_size_x(rect) / 2 - SCOPE_RESIZE_PAD;
scaler_x2 = rect->xmin + BLI_rctf_size_x(rect) / 2 + SCOPE_RESIZE_PAD;
glColor4f(0.f, 0.f, 0.f, 0.25f);
fdrawline(scaler_x1, rect->ymin - 4, scaler_x2, rect->ymin - 4);
fdrawline(scaler_x1, rect->ymin - 7, scaler_x2, rect->ymin - 7);
glColor4f(1.f, 1.f, 1.f, 0.25f);
fdrawline(scaler_x1, rect->ymin - 5, scaler_x2, rect->ymin - 5);
fdrawline(scaler_x1, rect->ymin - 8, scaler_x2, rect->ymin - 8);
/* outline */
glColor4f(0.f, 0.f, 0.f, 0.5f);
uiSetRoundBox(UI_CNR_ALL);
uiDrawBox(GL_LINE_LOOP, rect->xmin - 1, rect->ymin, rect->xmax + 1, rect->ymax + 1, 3.0f);
}
static void wm_drop_operator_draw(char *name, int x, int y)
{
int width= UI_GetStringWidth(name);
glColor4ub(0, 0, 0, 50);
uiSetRoundBox(UI_CNR_ALL | UI_RB_ALPHA);
uiRoundBox(x, y, x + width + 8, y + 15, 4);
glColor4ub(255, 255, 255, 255);
UI_DrawString(x+4, y+4, name);
}
void ui_draw_but_HISTOGRAM(ARegion *ar, uiBut *but, uiWidgetColors *UNUSED(wcol), rcti *recti)
{
Histogram *hist = (Histogram *)but->poin;
int res = hist->x_resolution;
rctf rect;
int i;
float w, h;
//float alpha;
GLint scissor[4];
rect.xmin = (float)recti->xmin+1;
rect.xmax = (float)recti->xmax-1;
rect.ymin = (float)recti->ymin+SCOPE_RESIZE_PAD+2;
rect.ymax = (float)recti->ymax-1;
w = rect.xmax - rect.xmin;
h = (rect.ymax - rect.ymin) * hist->ymax;
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
glColor4f(0.f, 0.f, 0.f, 0.3f);
uiSetRoundBox(UI_CNR_ALL);
uiDrawBox(GL_POLYGON, rect.xmin-1, rect.ymin-1, rect.xmax+1, rect.ymax+1, 3.0f);
/* need scissor test, histogram can draw outside of boundary */
glGetIntegerv(GL_VIEWPORT, scissor);
glScissor(ar->winrct.xmin + (rect.xmin-1), ar->winrct.ymin+(rect.ymin-1), (rect.xmax+1)-(rect.xmin-1), (rect.ymax+1)-(rect.ymin-1));
glColor4f(1.f, 1.f, 1.f, 0.08f);
/* draw grid lines here */
for (i=1; i<4; i++) {
fdrawline(rect.xmin, rect.ymin+(i/4.f)*h, rect.xmax, rect.ymin+(i/4.f)*h);
fdrawline(rect.xmin+(i/4.f)*w, rect.ymin, rect.xmin+(i/4.f)*w, rect.ymax);
}
if (hist->mode == HISTO_MODE_LUMA)
histogram_draw_one(1.0, 1.0, 1.0, 0.75, rect.xmin, rect.ymin, w, h, hist->data_luma, res);
else {
if (hist->mode == HISTO_MODE_RGB || hist->mode == HISTO_MODE_R)
histogram_draw_one(1.0, 0.0, 0.0, 0.75, rect.xmin, rect.ymin, w, h, hist->data_r, res);
if (hist->mode == HISTO_MODE_RGB || hist->mode == HISTO_MODE_G)
histogram_draw_one(0.0, 1.0, 0.0, 0.75, rect.xmin, rect.ymin, w, h, hist->data_g, res);
if (hist->mode == HISTO_MODE_RGB || hist->mode == HISTO_MODE_B)
histogram_draw_one(0.0, 0.0, 1.0, 0.75, rect.xmin, rect.ymin, w, h, hist->data_b, res);
}
/* outline, scale gripper */
draw_scope_end(&rect, scissor);
}
static void draw_textscroll(SpaceText *st, rcti *scroll, rcti *back)
{
bTheme *btheme = UI_GetTheme();
uiWidgetColors wcol = btheme->tui.wcol_scroll;
unsigned char col[4];
float rad;
UI_ThemeColor(TH_BACK);
glRecti(back->xmin, back->ymin, back->xmax, back->ymax);
uiWidgetScrollDraw(&wcol, scroll, &st->txtbar, (st->flags & ST_SCROLL_SELECT) ? UI_SCROLL_PRESSED : 0);
uiSetRoundBox(UI_CNR_ALL);
rad = 0.4f * min_ii(BLI_rcti_size_x(&st->txtscroll), BLI_rcti_size_y(&st->txtscroll));
UI_GetThemeColor3ubv(TH_HILITE, col);
col[3] = 48;
glColor4ubv(col);
glEnable(GL_BLEND);
uiRoundBox(st->txtscroll.xmin + 1, st->txtscroll.ymin, st->txtscroll.xmax - 1, st->txtscroll.ymax, rad);
glDisable(GL_BLEND);
}
void file_draw_list(const bContext *C, ARegion *ar)
{
SpaceFile *sfile = CTX_wm_space_file(C);
FileSelectParams *params = ED_fileselect_get_params(sfile);
FileLayout *layout = ED_fileselect_get_layout(sfile, ar);
View2D *v2d = &ar->v2d;
struct FileList *files = sfile->files;
struct direntry *file;
ImBuf *imb;
uiBlock *block = uiBeginBlock(C, ar, __func__, UI_EMBOSS);
int numfiles;
int numfiles_layout;
int sx, sy;
int offset;
int textwidth, textheight;
int i;
short is_icon;
short align;
numfiles = filelist_numfiles(files);
if (params->display != FILE_IMGDISPLAY) {
draw_background(layout, v2d);
draw_dividers(layout, v2d);
}
offset = ED_fileselect_layout_offset(layout, (int)ar->v2d.cur.xmin, (int)-ar->v2d.cur.ymax);
if (offset < 0) offset = 0;
numfiles_layout = ED_fileselect_layout_numfiles(layout, ar);
/* adjust, so the next row is already drawn when scrolling */
if (layout->flag & FILE_LAYOUT_HOR) {
numfiles_layout += layout->rows;
}
else {
numfiles_layout += layout->columns;
}
textwidth = (FILE_IMGDISPLAY == params->display) ? layout->tile_w : (int)layout->column_widths[COLUMN_NAME];
textheight = (int)(layout->textheight * 3.0 / 2.0 + 0.5);
align = (FILE_IMGDISPLAY == params->display) ? UI_STYLE_TEXT_CENTER : UI_STYLE_TEXT_LEFT;
for (i = offset; (i < numfiles) && (i < offset + numfiles_layout); i++) {
ED_fileselect_layout_tilepos(layout, i, &sx, &sy);
sx += (int)(v2d->tot.xmin + 2.0f);
sy = (int)(v2d->tot.ymax - sy);
file = filelist_file(files, i);
UI_ThemeColor4(TH_TEXT);
if (!(file->selflag & EDITING_FILE)) {
if ((params->active_file == i) || (file->selflag & HILITED_FILE) || (file->selflag & SELECTED_FILE)) {
int colorid = (file->selflag & SELECTED_FILE) ? TH_HILITE : TH_BACK;
int shade = (params->active_file == i) || (file->selflag & HILITED_FILE) ? 20 : 0;
draw_tile(sx, sy - 1, layout->tile_w + 4, sfile->layout->tile_h + layout->tile_border_y, colorid, shade);
}
}
uiSetRoundBox(UI_CNR_NONE);
if (FILE_IMGDISPLAY == params->display) {
is_icon = 0;
imb = filelist_getimage(files, i);
if (!imb) {
imb = filelist_geticon(files, i);
is_icon = 1;
}
file_draw_preview(block, file, sx, sy, imb, layout, !is_icon && (file->flags & IMAGEFILE));
}
else {
file_draw_icon(block, file->path, sx, sy - (UI_UNIT_Y / 6), get_file_icon(file), ICON_DEFAULT_WIDTH_SCALE, ICON_DEFAULT_HEIGHT_SCALE);
sx += ICON_DEFAULT_WIDTH_SCALE + 4;
}
UI_ThemeColor4(TH_TEXT);
if (file->selflag & EDITING_FILE) {
uiBut *but = uiDefBut(block, TEX, 1, "", sx, sy - layout->tile_h - 3,
textwidth, textheight, sfile->params->renameedit, 1.0f, (float)sizeof(sfile->params->renameedit), 0, 0, "");
uiButSetRenameFunc(but, renamebutton_cb, file);
uiButSetFlag(but, UI_BUT_NO_UTF8); /* allow non utf8 names */
uiButClearFlag(but, UI_BUT_UNDO);
if (0 == uiButActiveOnly(C, block, but)) {
file->selflag &= ~EDITING_FILE;
}
}
if (!(file->selflag & EDITING_FILE)) {
int tpos = (FILE_IMGDISPLAY == params->display) ? sy - layout->tile_h + layout->textheight : sy;
file_draw_string(sx + 1, tpos, file->relname, (float)textwidth, textheight, align);
}
if (params->display == FILE_SHORTDISPLAY) {
sx += (int)layout->column_widths[COLUMN_NAME] + 12;
if (!(file->type & S_IFDIR)) {
file_draw_string(sx, sy, file->size, layout->column_widths[COLUMN_SIZE], layout->tile_h, align);
sx += (int)layout->column_widths[COLUMN_SIZE] + 12;
}
}
else if (params->display == FILE_LONGDISPLAY) {
sx += (int)layout->column_widths[COLUMN_NAME] + 12;
#ifndef WIN32
/* rwx rwx rwx */
file_draw_string(sx, sy, file->mode1, layout->column_widths[COLUMN_MODE1], layout->tile_h, align);
sx += layout->column_widths[COLUMN_MODE1] + 12;
file_draw_string(sx, sy, file->mode2, layout->column_widths[COLUMN_MODE2], layout->tile_h, align);
sx += layout->column_widths[COLUMN_MODE2] + 12;
file_draw_string(sx, sy, file->mode3, layout->column_widths[COLUMN_MODE3], layout->tile_h, align);
sx += layout->column_widths[COLUMN_MODE3] + 12;
file_draw_string(sx, sy, file->owner, layout->column_widths[COLUMN_OWNER], layout->tile_h, align);
sx += layout->column_widths[COLUMN_OWNER] + 12;
#endif
file_draw_string(sx, sy, file->date, layout->column_widths[COLUMN_DATE], layout->tile_h, align);
sx += (int)layout->column_widths[COLUMN_DATE] + 12;
file_draw_string(sx, sy, file->time, layout->column_widths[COLUMN_TIME], layout->tile_h, align);
sx += (int)layout->column_widths[COLUMN_TIME] + 12;
if (!(file->type & S_IFDIR)) {
file_draw_string(sx, sy, file->size, layout->column_widths[COLUMN_SIZE], layout->tile_h, align);
sx += (int)layout->column_widths[COLUMN_SIZE] + 12;
}
}
}
uiEndBlock(C, block);
uiDrawBlock(C, block);
}
static void draw_tile(int sx, int sy, int width, int height, int colorid, int shade)
{
UI_ThemeColorShade(colorid, shade);
uiSetRoundBox(UI_CNR_ALL);
uiRoundBox((float)sx, (float)(sy - height), (float)(sx + width), (float)sy, 5.0f);
}
void draw_image_seq(const bContext *C, Scene *scene, ARegion *ar, SpaceSeq *sseq, int cfra, int frame_ofs, int draw_overlay)
{
struct Main *bmain = CTX_data_main(C);
struct ImBuf *ibuf = NULL;
struct ImBuf *scope = NULL;
struct View2D *v2d = &ar->v2d;
/* int rectx, recty; */ /* UNUSED */
float viewrectx, viewrecty;
float render_size = 0.0;
float proxy_size = 100.0;
float col[3];
GLuint texid;
GLuint last_texid;
void *display_buffer;
void *cache_handle = NULL;
const int is_imbuf = ED_space_sequencer_check_show_imbuf(sseq);
int format, type;
bool glsl_used = false;
if (G.is_rendering == FALSE && (scene->r.seq_flag & R_SEQ_GL_PREV) == 0) {
/* stop all running jobs, except screen one. currently previews frustrate Render
* needed to make so sequencer's rendering doesn't conflict with compositor
*/
WM_jobs_kill_type(CTX_wm_manager(C), WM_JOB_TYPE_COMPOSITE);
if ((scene->r.seq_flag & R_SEQ_GL_PREV) == 0) {
/* in case of final rendering used for preview, kill all previews,
* otherwise threading conflict will happen in rendering module
*/
WM_jobs_kill_type(CTX_wm_manager(C), WM_JOB_TYPE_RENDER_PREVIEW);
}
}
render_size = sseq->render_size;
if (render_size == 0) {
render_size = scene->r.size;
}
else {
proxy_size = render_size;
}
if (render_size < 0) {
return;
}
viewrectx = (render_size * (float)scene->r.xsch) / 100.0f;
viewrecty = (render_size * (float)scene->r.ysch) / 100.0f;
/* rectx = viewrectx + 0.5f; */ /* UNUSED */
/* recty = viewrecty + 0.5f; */ /* UNUSED */
if (sseq->mainb == SEQ_DRAW_IMG_IMBUF) {
viewrectx *= scene->r.xasp / scene->r.yasp;
viewrectx /= proxy_size / 100.0f;
viewrecty /= proxy_size / 100.0f;
}
if (!draw_overlay || sseq->overlay_type == SEQ_DRAW_OVERLAY_REFERENCE) {
UI_GetThemeColor3fv(TH_SEQ_PREVIEW, col);
glClearColor(col[0], col[1], col[2], 0.0);
glClear(GL_COLOR_BUFFER_BIT);
}
/* without this colors can flicker from previous opengl state */
glColor4ub(255, 255, 255, 255);
UI_view2d_totRect_set(v2d, viewrectx + 0.5f, viewrecty + 0.5f);
UI_view2d_curRect_validate(v2d);
/* only initialize the preview if a render is in progress */
if (G.is_rendering)
return;
ibuf = sequencer_ibuf_get(bmain, scene, sseq, cfra, frame_ofs);
if (ibuf == NULL)
return;
if (ibuf->rect == NULL && ibuf->rect_float == NULL)
return;
if (sseq->mainb != SEQ_DRAW_IMG_IMBUF || sseq->zebra != 0) {
SequencerScopes *scopes = &sseq->scopes;
sequencer_check_scopes(scopes, ibuf);
switch (sseq->mainb) {
case SEQ_DRAW_IMG_IMBUF:
if (!scopes->zebra_ibuf) {
ImBuf *display_ibuf = IMB_dupImBuf(ibuf);
if (display_ibuf->rect_float) {
IMB_colormanagement_imbuf_make_display_space(display_ibuf, &scene->view_settings,
&scene->display_settings);
}
scopes->zebra_ibuf = make_zebra_view_from_ibuf(display_ibuf, sseq->zebra);
IMB_freeImBuf(display_ibuf);
}
scope = scopes->zebra_ibuf;
break;
case SEQ_DRAW_IMG_WAVEFORM:
if ((sseq->flag & SEQ_DRAW_COLOR_SEPARATED) != 0) {
if (!scopes->sep_waveform_ibuf)
scopes->sep_waveform_ibuf = sequencer_make_scope(scene, ibuf, make_sep_waveform_view_from_ibuf);
scope = scopes->sep_waveform_ibuf;
}
else {
if (!scopes->waveform_ibuf)
scopes->waveform_ibuf = sequencer_make_scope(scene, ibuf, make_waveform_view_from_ibuf);
scope = scopes->waveform_ibuf;
}
break;
case SEQ_DRAW_IMG_VECTORSCOPE:
if (!scopes->vector_ibuf)
scopes->vector_ibuf = sequencer_make_scope(scene, ibuf, make_vectorscope_view_from_ibuf);
scope = scopes->vector_ibuf;
break;
case SEQ_DRAW_IMG_HISTOGRAM:
if (!scopes->histogram_ibuf)
scopes->histogram_ibuf = sequencer_make_scope(scene, ibuf, make_histogram_view_from_ibuf);
scope = scopes->histogram_ibuf;
break;
}
scopes->reference_ibuf = ibuf;
}
/* setting up the view - actual drawing starts here */
UI_view2d_view_ortho(v2d);
/* only draw alpha for main buffer */
if (sseq->mainb == SEQ_DRAW_IMG_IMBUF) {
if (sseq->flag & SEQ_USE_ALPHA) {
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
fdrawcheckerboard(v2d->tot.xmin, v2d->tot.ymin, v2d->tot.xmax, v2d->tot.ymax);
glColor4f(1.0, 1.0, 1.0, 1.0);
}
}
if (scope) {
IMB_freeImBuf(ibuf);
ibuf = scope;
if (ibuf->rect_float && ibuf->rect == NULL) {
IMB_rect_from_float(ibuf);
}
display_buffer = (unsigned char *)ibuf->rect;
format = GL_RGBA;
type = GL_UNSIGNED_BYTE;
}
else {
bool force_fallback = false;
force_fallback |= (U.image_draw_method != IMAGE_DRAW_METHOD_GLSL);
force_fallback |= (ibuf->dither != 0.0f);
if (force_fallback) {
/* Fallback to CPU based color space conversion */
glsl_used = false;
format = GL_RGBA;
type = GL_UNSIGNED_BYTE;
display_buffer = NULL;
}
else if (ibuf->rect_float) {
display_buffer = ibuf->rect_float;
if (ibuf->channels == 4) {
format = GL_RGBA;
}
else if (ibuf->channels == 3) {
format = GL_RGB;
}
else {
BLI_assert(!"Incompatible number of channels for float buffer in sequencer");
format = GL_RGBA;
display_buffer = NULL;
}
type = GL_FLOAT;
if (ibuf->float_colorspace) {
glsl_used = IMB_colormanagement_setup_glsl_draw_from_space_ctx(C, ibuf->float_colorspace, true);
}
else {
glsl_used = IMB_colormanagement_setup_glsl_draw_ctx(C, true);
}
}
else if (ibuf->rect) {
display_buffer = ibuf->rect;
format = GL_RGBA;
type = GL_UNSIGNED_BYTE;
glsl_used = IMB_colormanagement_setup_glsl_draw_from_space_ctx(C, ibuf->rect_colorspace, false);
}
else {
format = GL_RGBA;
type = GL_UNSIGNED_BYTE;
display_buffer = NULL;
}
/* there's a data to be displayed, but GLSL is not initialized
* properly, in this case we fallback to CPU-based display transform
*/
if ((ibuf->rect || ibuf->rect_float) && !glsl_used) {
display_buffer = IMB_display_buffer_acquire_ctx(C, ibuf, &cache_handle);
format = GL_RGBA;
type = GL_UNSIGNED_BYTE;
}
}
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glColor4f(1.0, 1.0, 1.0, 1.0);
last_texid = glaGetOneInteger(GL_TEXTURE_2D);
glEnable(GL_TEXTURE_2D);
glGenTextures(1, (GLuint *)&texid);
glBindTexture(GL_TEXTURE_2D, texid);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
if (type == GL_FLOAT)
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F_ARB, ibuf->x, ibuf->y, 0, format, type, display_buffer);
else
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, ibuf->x, ibuf->y, 0, format, type, display_buffer);
glBegin(GL_QUADS);
if (draw_overlay) {
if (sseq->overlay_type == SEQ_DRAW_OVERLAY_RECT) {
rctf tot_clip;
tot_clip.xmin = v2d->tot.xmin + (fabsf(BLI_rctf_size_x(&v2d->tot)) * scene->ed->over_border.xmin);
tot_clip.ymin = v2d->tot.ymin + (fabsf(BLI_rctf_size_y(&v2d->tot)) * scene->ed->over_border.ymin);
tot_clip.xmax = v2d->tot.xmin + (fabsf(BLI_rctf_size_x(&v2d->tot)) * scene->ed->over_border.xmax);
tot_clip.ymax = v2d->tot.ymin + (fabsf(BLI_rctf_size_y(&v2d->tot)) * scene->ed->over_border.ymax);
glTexCoord2f(scene->ed->over_border.xmin, scene->ed->over_border.ymin); glVertex2f(tot_clip.xmin, tot_clip.ymin);
glTexCoord2f(scene->ed->over_border.xmin, scene->ed->over_border.ymax); glVertex2f(tot_clip.xmin, tot_clip.ymax);
glTexCoord2f(scene->ed->over_border.xmax, scene->ed->over_border.ymax); glVertex2f(tot_clip.xmax, tot_clip.ymax);
glTexCoord2f(scene->ed->over_border.xmax, scene->ed->over_border.ymin); glVertex2f(tot_clip.xmax, tot_clip.ymin);
}
else if (sseq->overlay_type == SEQ_DRAW_OVERLAY_REFERENCE) {
glTexCoord2f(0.0f, 0.0f); glVertex2f(v2d->tot.xmin, v2d->tot.ymin);
glTexCoord2f(0.0f, 1.0f); glVertex2f(v2d->tot.xmin, v2d->tot.ymax);
glTexCoord2f(1.0f, 1.0f); glVertex2f(v2d->tot.xmax, v2d->tot.ymax);
glTexCoord2f(1.0f, 0.0f); glVertex2f(v2d->tot.xmax, v2d->tot.ymin);
}
}
else {
glTexCoord2f(0.0f, 0.0f); glVertex2f(v2d->tot.xmin, v2d->tot.ymin);
glTexCoord2f(0.0f, 1.0f); glVertex2f(v2d->tot.xmin, v2d->tot.ymax);
glTexCoord2f(1.0f, 1.0f); glVertex2f(v2d->tot.xmax, v2d->tot.ymax);
glTexCoord2f(1.0f, 0.0f); glVertex2f(v2d->tot.xmax, v2d->tot.ymin);
}
glEnd();
glBindTexture(GL_TEXTURE_2D, last_texid);
glDisable(GL_TEXTURE_2D);
if (sseq->mainb == SEQ_DRAW_IMG_IMBUF && sseq->flag & SEQ_USE_ALPHA)
glDisable(GL_BLEND);
glDeleteTextures(1, &texid);
if (glsl_used)
IMB_colormanagement_finish_glsl_draw();
if (sseq->mainb == SEQ_DRAW_IMG_IMBUF) {
float x1 = v2d->tot.xmin;
float y1 = v2d->tot.ymin;
float x2 = v2d->tot.xmax;
float y2 = v2d->tot.ymax;
/* border */
setlinestyle(3);
UI_ThemeColorBlendShade(TH_WIRE, TH_BACK, 1.0, 0);
glBegin(GL_LINE_LOOP);
glVertex2f(x1 - 0.5f, y1 - 0.5f);
glVertex2f(x1 - 0.5f, y2 + 0.5f);
glVertex2f(x2 + 0.5f, y2 + 0.5f);
glVertex2f(x2 + 0.5f, y1 - 0.5f);
glEnd();
/* safety border */
if ((sseq->flag & SEQ_DRAW_SAFE_MARGINS) != 0) {
float fac = 0.1;
float a = fac * (x2 - x1);
x1 += a;
x2 -= a;
a = fac * (y2 - y1);
y1 += a;
y2 -= a;
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
uiSetRoundBox(UI_CNR_ALL);
uiDrawBox(GL_LINE_LOOP, x1, y1, x2, y2, 12.0);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}
setlinestyle(0);
}
if (sseq->flag & SEQ_SHOW_GPENCIL) {
if (is_imbuf) {
/* draw grease-pencil (image aligned) */
draw_gpencil_2dimage(C);
}
}
if (!scope)
IMB_freeImBuf(ibuf);
/* ortho at pixel level */
UI_view2d_view_restore(C);
if (sseq->flag & SEQ_SHOW_GPENCIL) {
if (is_imbuf) {
/* draw grease-pencil (screen aligned) */
draw_gpencil_view2d(C, 0);
}
}
/* NOTE: sequencer mask editing isnt finished, the draw code is working but editing not,
* for now just disable drawing since the strip frame will likely be offset */
//if (sc->mode == SC_MODE_MASKEDIT) {
if (0 && sseq->mainb == SEQ_DRAW_IMG_IMBUF) {
Mask *mask = BKE_sequencer_mask_get(scene);
if (mask) {
int width, height;
float aspx = 1.0f, aspy = 1.0f;
// ED_mask_get_size(C, &width, &height);
//Scene *scene = CTX_data_scene(C);
width = (scene->r.size * scene->r.xsch) / 100;
height = (scene->r.size * scene->r.ysch) / 100;
ED_mask_draw_region(mask, ar,
0, 0, /* TODO */
width, height,
aspx, aspy,
FALSE, TRUE,
NULL, C);
}
}
if (cache_handle)
IMB_display_buffer_release(cache_handle);
}
// TODO: depreceate this code...
static void draw_nla_channel_list_gl(bAnimContext *ac, ListBase *anim_data, View2D *v2d, float y)
{
SpaceNla *snla = (SpaceNla *)ac->sl;
bAnimListElem *ale;
float x = 0.0f;
/* loop through channels, and set up drawing depending on their type */
for (ale = anim_data->first; ale; ale = ale->next) {
const float yminc = (float)(y - NLACHANNEL_HEIGHT_HALF(snla));
const float ymaxc = (float)(y + NLACHANNEL_HEIGHT_HALF(snla));
const float ydatac = (float)(y - 0.35f * U.widget_unit);
/* check if visible */
if (IN_RANGE(yminc, v2d->cur.ymin, v2d->cur.ymax) ||
IN_RANGE(ymaxc, v2d->cur.ymin, v2d->cur.ymax) )
{
AnimData *adt = ale->adt;
short indent = 0, offset = 0, sel = 0, group = 0;
int special = -1;
char name[128];
bool do_draw = false;
/* determine what needs to be drawn */
switch (ale->type) {
case ANIMTYPE_NLAACTION: /* NLA Action-Line */
{
bAction *act = (bAction *)ale->data;
group = 5;
special = ICON_ACTION;
BLI_strncpy(name, act ? act->id.name + 2 : "<No Action>", sizeof(name));
/* draw manually still */
do_draw = TRUE;
break;
}
default: /* handled by standard channel-drawing API */
/* (draw backdrops only...) */
ANIM_channel_draw(ac, ale, yminc, ymaxc);
break;
}
/* if special types, draw manually for now... */
if (do_draw) {
if (ale->id) {
/* special exception for textures */
if (GS(ale->id->name) == ID_TE) {
offset = 0.7f * U.widget_unit;
indent = 1;
}
/* special exception for nodetrees */
else if (GS(ale->id->name) == ID_NT) {
bNodeTree *ntree = (bNodeTree *)ale->id;
switch (ntree->type) {
case NTREE_SHADER:
{
/* same as for textures */
offset = 0.7f * U.widget_unit;
indent = 1;
break;
}
case NTREE_TEXTURE:
{
/* even more */
offset = U.widget_unit;
indent = 1;
break;
}
default:
/* normal will do */
offset = 0.7f * U.widget_unit;
break;
}
}
else {
offset = 0.7f * U.widget_unit;
}
}
else {
offset = 0;
}
/* now, start drawing based on this information */
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
/* draw backing strip behind channel name */
if (group == 5) {
float color[4];
/* Action Line
* The alpha values action_get_color returns are only useful for drawing
* strips backgrounds but here we're doing channel list backgrounds instead
* so we ignore that and use our own when needed
*/
nla_action_get_color(adt, (bAction *)ale->data, color);
if (adt && (adt->flag & ADT_NLA_EDIT_ON)) {
/* Yes, the color vector has 4 components, BUT we only want to be using 3 of them! */
glColor3fv(color);
}
else {
float alpha = (adt && (adt->flag & ADT_NLA_SOLO_TRACK)) ? 0.3f : 1.0f;
glColor4f(color[0], color[1], color[2], alpha);
}
offset += 0.35f * U.widget_unit * indent;
/* only on top two corners, to show that this channel sits on top of the preceding ones */
uiSetRoundBox(UI_CNR_TOP_LEFT | UI_CNR_TOP_RIGHT);
/* draw slightly shifted up vertically to look like it has more separation from other channels,
* but we then need to slightly shorten it so that it doesn't look like it overlaps
*/
uiDrawBox(GL_POLYGON, x + offset, yminc + NLACHANNEL_SKIP, (float)v2d->cur.xmax, ymaxc + NLACHANNEL_SKIP - 1, 8);
/* clear group value, otherwise we cause errors... */
group = 0;
}
/* draw special icon indicating certain data-types */
if (special > -1) {
/* for normal channels */
UI_icon_draw(x + offset, ydatac, special);
offset += 0.85f * U.widget_unit;
}
glDisable(GL_BLEND);
/* draw name */
if (sel)
UI_ThemeColor(TH_TEXT_HI);
else
UI_ThemeColor(TH_TEXT);
offset += 3;
UI_DrawString(x + offset, y - 4, name);
/* reset offset - for RHS of panel */
offset = 0;
/* set blending again, as text drawing may clear it */
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
/* draw NLA-action line 'status-icons' - only when there's an action */
if ((ale->type == ANIMTYPE_NLAACTION) && (ale->data)) {
offset += 0.8f * U.widget_unit;
/* now draw some indicator icons */
if ((adt) && (adt->flag & ADT_NLA_EDIT_ON)) {
/* toggle for tweaking with mapping/no-mapping (i.e. 'in place editing' toggle) */
// for now, use pin icon to symbolise this
if (adt->flag & ADT_NLA_EDIT_NOMAP)
UI_icon_draw((float)(v2d->cur.xmax - offset), ydatac, ICON_PINNED);
else
UI_icon_draw((float)(v2d->cur.xmax - offset), ydatac, ICON_UNPINNED);
fdrawline((float)(v2d->cur.xmax - offset), yminc,
(float)(v2d->cur.xmax - offset), ymaxc);
offset += 0.8f * U.widget_unit;
/* 'tweaking action' indicator - not a button */
UI_icon_draw((float)(v2d->cur.xmax - offset), ydatac, ICON_EDIT);
}
else {
/* XXX firstly draw a little rect to help identify that it's different from the toggles */
glBegin(GL_LINE_LOOP);
glVertex2f((float)v2d->cur.xmax - offset - 1, y - 0.35f * U.widget_unit);
glVertex2f((float)v2d->cur.xmax - offset - 1, y + 0.45f * U.widget_unit);
glVertex2f((float)v2d->cur.xmax - 1, y + 0.45f * U.widget_unit);
glVertex2f((float)v2d->cur.xmax - 1, y - 0.35f * U.widget_unit);
glEnd();
/* 'push down' icon for normal active-actions */
UI_icon_draw((float)v2d->cur.xmax - offset, ydatac, ICON_FREEZE);
}
}
glDisable(GL_BLEND);
}
}
/* adjust y-position for next one */
y -= NLACHANNEL_STEP(snla);
}
}
void ui_draw_but_VECTORSCOPE(ARegion *ar, uiBut *but, uiWidgetColors *UNUSED(wcol), rcti *recti)
{
const float skin_rad = DEG2RADF(123.0f); /* angle in radians of the skin tone line */
Scopes *scopes = (Scopes *)but->poin;
rctf rect;
int i, j;
float w, h, centerx, centery, diam;
float alpha;
const float colors[6][3] = {
{0.75, 0.0, 0.0}, {0.75, 0.75, 0.0}, {0.0, 0.75, 0.0},
{0.0, 0.75, 0.75}, {0.0, 0.0, 0.75}, {0.75, 0.0, 0.75}};
GLint scissor[4];
rect.xmin = (float)recti->xmin + 1;
rect.xmax = (float)recti->xmax - 1;
rect.ymin = (float)recti->ymin + SCOPE_RESIZE_PAD + 2;
rect.ymax = (float)recti->ymax - 1;
w = BLI_rctf_size_x(&rect);
h = BLI_rctf_size_y(&rect);
centerx = rect.xmin + w / 2;
centery = rect.ymin + h / 2;
diam = (w < h) ? w : h;
alpha = scopes->vecscope_alpha * scopes->vecscope_alpha * scopes->vecscope_alpha;
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glColor4f(0.f, 0.f, 0.f, 0.3f);
uiSetRoundBox(UI_CNR_ALL);
uiDrawBox(GL_POLYGON, rect.xmin - 1, rect.ymin - 1, rect.xmax + 1, rect.ymax + 1, 3.0f);
/* need scissor test, hvectorscope can draw outside of boundary */
glGetIntegerv(GL_VIEWPORT, scissor);
glScissor(ar->winrct.xmin + (rect.xmin - 1),
ar->winrct.ymin + (rect.ymin - 1),
(rect.xmax + 1) - (rect.xmin - 1),
(rect.ymax + 1) - (rect.ymin - 1));
glColor4f(1.f, 1.f, 1.f, 0.08f);
/* draw grid elements */
/* cross */
fdrawline(centerx - (diam / 2) - 5, centery, centerx + (diam / 2) + 5, centery);
fdrawline(centerx, centery - (diam / 2) - 5, centerx, centery + (diam / 2) + 5);
/* circles */
for (j = 0; j < 5; j++) {
glBegin(GL_LINE_STRIP);
for (i = 0; i <= 360; i = i + 15) {
const float a = DEG2RADF((float)i);
const float r = (j + 1) / 10.0f;
glVertex2f(polar_to_x(centerx, diam, r, a), polar_to_y(centery, diam, r, a));
}
glEnd();
}
/* skin tone line */
glColor4f(1.f, 0.4f, 0.f, 0.2f);
fdrawline(polar_to_x(centerx, diam, 0.5f, skin_rad), polar_to_y(centery, diam, 0.5, skin_rad),
polar_to_x(centerx, diam, 0.1f, skin_rad), polar_to_y(centery, diam, 0.1, skin_rad));
/* saturation points */
for (i = 0; i < 6; i++)
vectorscope_draw_target(centerx, centery, diam, colors[i]);
if (scopes->ok && scopes->vecscope != NULL) {
/* pixel point cloud */
glBlendFunc(GL_ONE, GL_ONE);
glColor3f(alpha, alpha, alpha);
glPushMatrix();
glEnableClientState(GL_VERTEX_ARRAY);
glTranslatef(centerx, centery, 0.f);
glScalef(diam, diam, 0.f);
glVertexPointer(2, GL_FLOAT, 0, scopes->vecscope);
glDrawArrays(GL_POINTS, 0, scopes->waveform_tot);
glDisableClientState(GL_VERTEX_ARRAY);
glPopMatrix();
}
/* outline, scale gripper */
draw_scope_end(&rect, scissor);
glDisable(GL_BLEND);
}
/* panel integrated in buttonswindow, tool/property lists etc */
void ui_draw_aligned_panel(uiStyle *style, uiBlock *block, rcti *rect)
{
Panel *panel= block->panel;
rcti headrect;
rctf itemrect;
int ofsx;
if(panel->paneltab) return;
if(panel->type && (panel->type->flag & PNL_NO_HEADER)) return;
/* calculate header rect */
/* + 0.001f to prevent flicker due to float inaccuracy */
headrect= *rect;
headrect.ymin= headrect.ymax;
headrect.ymax= headrect.ymin + floor(PNL_HEADER/block->aspect + 0.001f);
if(!(panel->runtime_flag & PNL_FIRST)) {
float minx= rect->xmin+5.0f/block->aspect;
float maxx= rect->xmax-5.0f/block->aspect;
float y= headrect.ymax;
glEnable(GL_BLEND);
glColor4f(0.0f, 0.0f, 0.0f, 0.5f);
fdrawline(minx, y+1, maxx, y+1);
glColor4f(1.0f, 1.0f, 1.0f, 0.25f);
fdrawline(minx, y, maxx, y);
glDisable(GL_BLEND);
}
/* horizontal title */
if(!(panel->flag & PNL_CLOSEDX)) {
ui_draw_aligned_panel_header(style, block, &headrect, 'h');
/* itemrect smaller */
itemrect.xmax= headrect.xmax - 5.0f/block->aspect;
itemrect.xmin= itemrect.xmax - (headrect.ymax-headrect.ymin);
itemrect.ymin= headrect.ymin;
itemrect.ymax= headrect.ymax;
rectf_scale(&itemrect, 0.8f);
ui_draw_panel_dragwidget(&itemrect);
}
/* if the panel is minimized vertically:
* (------)
*/
if(panel->flag & PNL_CLOSEDY) {
}
else if(panel->flag & PNL_CLOSEDX) {
/* draw vertical title */
ui_draw_aligned_panel_header(style, block, &headrect, 'v');
}
/* an open panel */
else {
/* in some occasions, draw a border */
if(panel->flag & PNL_SELECT) {
if(panel->control & UI_PNL_SOLID) uiSetRoundBox(15);
else uiSetRoundBox(3);
UI_ThemeColorShade(TH_BACK, -120);
uiRoundRect(0.5f + rect->xmin, 0.5f + rect->ymin, 0.5f + rect->xmax, 0.5f + headrect.ymax+1, 8);
}
if(panel->control & UI_PNL_SCALE)
ui_draw_panel_scalewidget(rect);
}
/* draw optional close icon */
ofsx= 6;
if(panel->control & UI_PNL_CLOSE) {
UI_ThemeColor(TH_TEXT);
ui_draw_x_icon(rect->xmin+2+ofsx, rect->ymax+2);
ofsx= 22;
}
/* draw collapse icon */
UI_ThemeColor(TH_TEXT);
/* itemrect smaller */
itemrect.xmin= headrect.xmin + 5.0f/block->aspect;
itemrect.xmax= itemrect.xmin + (headrect.ymax-headrect.ymin);
itemrect.ymin= headrect.ymin;
itemrect.ymax= headrect.ymax;
rectf_scale(&itemrect, 0.5f);
if(panel->flag & PNL_CLOSEDY)
ui_draw_tria_rect(&itemrect, 'h');
else if(panel->flag & PNL_CLOSEDX)
ui_draw_tria_rect(&itemrect, 'h');
else
ui_draw_tria_rect(&itemrect, 'v');
}
// TODO: depreceate this code...
static void draw_nla_channel_list_gl (bAnimContext *ac, ListBase *anim_data, View2D *v2d, float y)
{
bAnimListElem *ale;
float x = 0.0f;
/* loop through channels, and set up drawing depending on their type */
for (ale= anim_data->first; ale; ale= ale->next) {
const float yminc= (float)(y - NLACHANNEL_HEIGHT_HALF);
const float ymaxc= (float)(y + NLACHANNEL_HEIGHT_HALF);
const float ydatac= (float)(y - 7);
/* check if visible */
if ( IN_RANGE(yminc, v2d->cur.ymin, v2d->cur.ymax) ||
IN_RANGE(ymaxc, v2d->cur.ymin, v2d->cur.ymax) )
{
short indent= 0, offset= 0, sel= 0, group= 0;
int expand= -1, protect = -1, special= -1, mute = -1;
char name[128];
short doDraw=0;
/* determine what needs to be drawn */
switch (ale->type) {
case ANIMTYPE_NLATRACK: /* NLA Track */
{
NlaTrack *nlt= (NlaTrack *)ale->data;
indent= 0;
if (ale->id) {
/* special exception for materials and particles */
if (ELEM(GS(ale->id->name),ID_MA,ID_PA)) {
offset= 21;
indent= 1;
}
else
offset= 14;
}
else
offset= 0;
/* FIXME: 'solo' as the 'special' button?
* - need special icons for these
*/
if (nlt->flag & NLATRACK_SOLO)
special= ICON_LAYER_ACTIVE;
else
special= ICON_LAYER_USED;
/* if this track is active and we're tweaking it, don't draw these toggles */
// TODO: need a special macro for this...
if ( ((nlt->flag & NLATRACK_ACTIVE) && (nlt->flag & NLATRACK_DISABLED)) == 0 )
{
if (nlt->flag & NLATRACK_MUTED)
mute = ICON_MUTE_IPO_ON;
else
mute = ICON_MUTE_IPO_OFF;
if (EDITABLE_NLT(nlt))
protect = ICON_UNLOCKED;
else
protect = ICON_LOCKED;
}
sel = SEL_NLT(nlt);
strcpy(name, nlt->name);
// draw manually still
doDraw= 1;
}
break;
case ANIMTYPE_NLAACTION: /* NLA Action-Line */
{
bAction *act= (bAction *)ale->data;
group = 5;
if (ale->id) {
/* special exception for materials and particles */
if (ELEM(GS(ale->id->name),ID_MA,ID_PA)) {
offset= 21;
indent= 1;
}
else
offset= 14;
}
else
offset= 0;
special = ICON_ACTION;
if (act)
sprintf(name, "ActAction: <%s>", act->id.name+2);
else
sprintf(name, "<No Action>");
// draw manually still
doDraw= 1;
}
break;
default: /* handled by standard channel-drawing API */
// draw backdrops only...
ANIM_channel_draw(ac, ale, yminc, ymaxc);
break;
}
/* if special types, draw manually for now... */
if (doDraw) {
/* now, start drawing based on this information */
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
/* draw backing strip behind channel name */
if (group == 5) {
/* Action Line */
AnimData *adt= ale->adt;
// TODO: if tweaking some action, use the same color as for the tweaked track (quick hack done for now)
if (adt && (adt->flag & ADT_NLA_EDIT_ON)) {
// greenish color (same as tweaking strip) - hardcoded for now
glColor3f(0.3f, 0.95f, 0.1f);
}
else {
if (ale->data)
glColor3f(0.8f, 0.2f, 0.0f); // reddish color - hardcoded for now
else
glColor3f(0.6f, 0.5f, 0.5f); // greyish-red color - hardcoded for now
}
offset += 7 * indent;
/* only on top two corners, to show that this channel sits on top of the preceeding ones */
uiSetRoundBox((1|2));
/* draw slightly shifted up vertically to look like it has more separtion from other channels,
* but we then need to slightly shorten it so that it doesn't look like it overlaps
*/
gl_round_box(GL_POLYGON, x+offset, yminc+NLACHANNEL_SKIP, (float)v2d->cur.xmax, ymaxc+NLACHANNEL_SKIP-1, 8);
/* clear group value, otherwise we cause errors... */
group = 0;
}
else {
/* for normal channels
* - use 3 shades of color group/standard color for 3 indention level
*/
UI_ThemeColorShade(TH_HEADER, ((indent==0)?20: (indent==1)?-20: -40));
indent += group;
offset += 7 * indent;
glBegin(GL_QUADS);
glVertex2f(x+offset, yminc);
glVertex2f(x+offset, ymaxc);
glVertex2f((float)v2d->cur.xmax, ymaxc);
glVertex2f((float)v2d->cur.xmax, yminc);
glEnd();
}
/* draw expand/collapse triangle */
if (expand > 0) {
UI_icon_draw(x+offset, ydatac, expand);
offset += 17;
}
/* draw special icon indicating certain data-types */
if (special > -1) {
/* for normal channels */
UI_icon_draw(x+offset, ydatac, special);
offset += 17;
}
glDisable(GL_BLEND);
/* draw name */
if (sel)
UI_ThemeColor(TH_TEXT_HI);
else
UI_ThemeColor(TH_TEXT);
offset += 3;
UI_DrawString(x+offset, y-4, name);
/* reset offset - for RHS of panel */
offset = 0;
/* set blending again, as text drawing may clear it */
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
/* draw protect 'lock' */
if (protect > -1) {
offset = 16;
UI_icon_draw((float)(v2d->cur.xmax-offset), ydatac, protect);
}
/* draw mute 'eye' */
if (mute > -1) {
offset += 16;
UI_icon_draw((float)(v2d->cur.xmax-offset), ydatac, mute);
}
/* draw NLA-action line 'status-icons' - only when there's an action */
if ((ale->type == ANIMTYPE_NLAACTION) && (ale->data)) {
AnimData *adt= ale->adt;
offset += 16;
/* now draw some indicator icons */
if ((adt) && (adt->flag & ADT_NLA_EDIT_ON)) {
/* toggle for tweaking with mapping/no-mapping (i.e. 'in place editing' toggle) */
// for now, use pin icon to symbolise this
if (adt->flag & ADT_NLA_EDIT_NOMAP)
UI_icon_draw((float)(v2d->cur.xmax-offset), ydatac, ICON_PINNED);
else
UI_icon_draw((float)(v2d->cur.xmax-offset), ydatac, ICON_UNPINNED);
fdrawline((float)(v2d->cur.xmax-offset), yminc,
(float)(v2d->cur.xmax-offset), ymaxc);
offset += 16;;
/* 'tweaking action' indicator - not a button */
UI_icon_draw((float)(v2d->cur.xmax-offset), ydatac, ICON_EDIT);
}
else {
/* XXX firstly draw a little rect to help identify that it's different from the toggles */
glBegin(GL_LINE_LOOP);
glVertex2f((float)v2d->cur.xmax-offset-1, y-7);
glVertex2f((float)v2d->cur.xmax-offset-1, y+9);
glVertex2f((float)v2d->cur.xmax-1, y+9);
glVertex2f((float)v2d->cur.xmax-1, y-7);
glEnd(); // GL_LINES
/* 'push down' icon for normal active-actions */
UI_icon_draw((float)NLACHANNEL_NAMEWIDTH-offset, ydatac, ICON_FREEZE);
}
}
glDisable(GL_BLEND);
}
}
/* adjust y-position for next one */
y -= NLACHANNEL_STEP;
}
}
static void ruler_info_draw_pixel(const struct bContext *C, ARegion *ar, void *arg)
{
Scene *scene = CTX_data_scene(C);
UnitSettings *unit = &scene->unit;
RulerItem *ruler_item;
RulerInfo *ruler_info = arg;
RegionView3D *rv3d = ruler_info->ar->regiondata;
// ARegion *ar = ruler_info->ar;
const float cap_size = 4.0f;
const float bg_margin = 4.0f * U.pixelsize;
const float bg_radius = 4.0f * U.pixelsize;
const float arc_size = 64.0f * U.pixelsize;
#define ARC_STEPS 24
const int arc_steps = ARC_STEPS;
int i;
//unsigned int color_act = 0x666600;
unsigned int color_act = 0xffffff;
unsigned int color_base = 0x0;
unsigned char color_back[4] = {0xff, 0xff, 0xff, 0x80};
unsigned char color_text[3];
unsigned char color_wire[3];
/* anti-aliased lines for more consistent appearance */
glEnable(GL_LINE_SMOOTH);
BLF_enable(blf_mono_font, BLF_ROTATION);
BLF_size(blf_mono_font, 14 * U.pixelsize, U.dpi);
BLF_rotation(blf_mono_font, 0.0f);
UI_GetThemeColor3ubv(TH_TEXT, color_text);
UI_GetThemeColor3ubv(TH_WIRE, color_wire);
for (ruler_item = ruler_info->items.first, i = 0; ruler_item; ruler_item = ruler_item->next, i++) {
const bool is_act = (i == ruler_info->item_active);
float dir_ruler[2];
float co_ss[3][2];
int j;
/* should these be checked? - ok for now not to */
for (j = 0; j < 3; j++) {
ED_view3d_project_float_global(ar, ruler_item->co[j], co_ss[j], V3D_PROJ_TEST_NOP);
}
glEnable(GL_BLEND);
cpack(is_act ? color_act : color_base);
if (ruler_item->flag & RULERITEM_USE_ANGLE) {
glBegin(GL_LINE_STRIP);
for (j = 0; j < 3; j++) {
glVertex2fv(co_ss[j]);
}
glEnd();
cpack(0xaaaaaa);
setlinestyle(3);
glBegin(GL_LINE_STRIP);
for (j = 0; j < 3; j++) {
glVertex2fv(co_ss[j]);
}
glEnd();
setlinestyle(0);
/* arc */
{
float dir_tmp[3];
float co_tmp[3];
float arc_ss_coords[ARC_STEPS + 1][2];
float dir_a[3];
float dir_b[3];
float quat[4];
float axis[3];
float angle;
const float px_scale = (ED_view3d_pixel_size(rv3d, ruler_item->co[1]) *
min_fff(arc_size,
len_v2v2(co_ss[0], co_ss[1]) / 2.0f,
len_v2v2(co_ss[2], co_ss[1]) / 2.0f));
sub_v3_v3v3(dir_a, ruler_item->co[0], ruler_item->co[1]);
sub_v3_v3v3(dir_b, ruler_item->co[2], ruler_item->co[1]);
normalize_v3(dir_a);
normalize_v3(dir_b);
cross_v3_v3v3(axis, dir_a, dir_b);
angle = angle_normalized_v3v3(dir_a, dir_b);
axis_angle_to_quat(quat, axis, angle / arc_steps);
copy_v3_v3(dir_tmp, dir_a);
glColor3ubv(color_wire);
for (j = 0; j <= arc_steps; j++) {
madd_v3_v3v3fl(co_tmp, ruler_item->co[1], dir_tmp, px_scale);
ED_view3d_project_float_global(ar, co_tmp, arc_ss_coords[j], V3D_PROJ_TEST_NOP);
mul_qt_v3(quat, dir_tmp);
}
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(2, GL_FLOAT, 0, arc_ss_coords);
glDrawArrays(GL_LINE_STRIP, 0, arc_steps + 1);
glDisableClientState(GL_VERTEX_ARRAY);
}
/* text */
{
char numstr[256];
float numstr_size[2];
float pos[2];
const int prec = 2; /* XXX, todo, make optional */
ruler_item_as_string(ruler_item, unit, numstr, sizeof(numstr), prec);
BLF_width_and_height(blf_mono_font, numstr, sizeof(numstr), &numstr_size[0], &numstr_size[1]);
pos[0] = co_ss[1][0] + (cap_size * 2.0f);
pos[1] = co_ss[1][1] - (numstr_size[1] / 2.0f);
/* draw text (bg) */
glColor4ubv(color_back);
uiSetRoundBox(UI_CNR_ALL);
uiRoundBox(pos[0] - bg_margin, pos[1] - bg_margin,
pos[0] + bg_margin + numstr_size[0], pos[1] + bg_margin + numstr_size[1],
bg_radius);
/* draw text */
glColor3ubv(color_text);
BLF_position(blf_mono_font, pos[0], pos[1], 0.0f);
BLF_rotation(blf_mono_font, 0.0f);
BLF_draw(blf_mono_font, numstr, sizeof(numstr));
}
/* capping */
{
float rot_90_vec_a[2];
float rot_90_vec_b[2];
float cap[2];
sub_v2_v2v2(dir_ruler, co_ss[0], co_ss[1]);
rot_90_vec_a[0] = -dir_ruler[1];
rot_90_vec_a[1] = dir_ruler[0];
normalize_v2(rot_90_vec_a);
sub_v2_v2v2(dir_ruler, co_ss[1], co_ss[2]);
rot_90_vec_b[0] = -dir_ruler[1];
rot_90_vec_b[1] = dir_ruler[0];
normalize_v2(rot_90_vec_b);
glEnable(GL_BLEND);
glColor3ubv(color_wire);
glBegin(GL_LINES);
madd_v2_v2v2fl(cap, co_ss[0], rot_90_vec_a, cap_size);
glVertex2fv(cap);
madd_v2_v2v2fl(cap, co_ss[0], rot_90_vec_a, -cap_size);
glVertex2fv(cap);
madd_v2_v2v2fl(cap, co_ss[2], rot_90_vec_b, cap_size);
glVertex2fv(cap);
madd_v2_v2v2fl(cap, co_ss[2], rot_90_vec_b, -cap_size);
glVertex2fv(cap);
/* angle vertex */
glVertex2f(co_ss[1][0] - cap_size, co_ss[1][1] - cap_size);
glVertex2f(co_ss[1][0] + cap_size, co_ss[1][1] + cap_size);
glVertex2f(co_ss[1][0] - cap_size, co_ss[1][1] + cap_size);
glVertex2f(co_ss[1][0] + cap_size, co_ss[1][1] - cap_size);
glEnd();
glDisable(GL_BLEND);
}
}
else {
glBegin(GL_LINE_STRIP);
for (j = 0; j < 3; j += 2) {
glVertex2fv(co_ss[j]);
}
glEnd();
cpack(0xaaaaaa);
setlinestyle(3);
glBegin(GL_LINE_STRIP);
for (j = 0; j < 3; j += 2) {
glVertex2fv(co_ss[j]);
}
glEnd();
setlinestyle(0);
sub_v2_v2v2(dir_ruler, co_ss[0], co_ss[2]);
/* text */
{
char numstr[256];
float numstr_size[2];
const int prec = 6; /* XXX, todo, make optional */
float pos[2];
ruler_item_as_string(ruler_item, unit, numstr, sizeof(numstr), prec);
BLF_width_and_height(blf_mono_font, numstr, sizeof(numstr), &numstr_size[0], &numstr_size[1]);
mid_v2_v2v2(pos, co_ss[0], co_ss[2]);
/* center text */
pos[0] -= numstr_size[0] / 2.0f;
pos[1] -= numstr_size[1] / 2.0f;
/* draw text (bg) */
glColor4ubv(color_back);
uiSetRoundBox(UI_CNR_ALL);
uiRoundBox(pos[0] - bg_margin, pos[1] - bg_margin,
pos[0] + bg_margin + numstr_size[0], pos[1] + bg_margin + numstr_size[1],
bg_radius);
/* draw text */
glColor3ubv(color_text);
BLF_position(blf_mono_font, pos[0], pos[1], 0.0f);
BLF_draw(blf_mono_font, numstr, sizeof(numstr));
}
/* capping */
{
float rot_90_vec[2] = {-dir_ruler[1], dir_ruler[0]};
float cap[2];
normalize_v2(rot_90_vec);
glEnable(GL_BLEND);
glColor3ubv(color_wire);
glBegin(GL_LINES);
madd_v2_v2v2fl(cap, co_ss[0], rot_90_vec, cap_size);
glVertex2fv(cap);
madd_v2_v2v2fl(cap, co_ss[0], rot_90_vec, -cap_size);
glVertex2fv(cap);
madd_v2_v2v2fl(cap, co_ss[2], rot_90_vec, cap_size);
glVertex2fv(cap);
madd_v2_v2v2fl(cap, co_ss[2], rot_90_vec, -cap_size);
glVertex2fv(cap);
glEnd();
glDisable(GL_BLEND);
}
}
}
glDisable(GL_LINE_SMOOTH);
BLF_disable(blf_mono_font, BLF_ROTATION);
#undef ARC_STEPS
/* draw snap */
if ((ruler_info->snap_flag & RULER_SNAP_OK) && (ruler_info->state == RULER_STATE_DRAG)) {
ruler_item = ruler_item_active_get(ruler_info);
if (ruler_item) {
/* size from drawSnapping */
const float size = 2.5f * UI_GetThemeValuef(TH_VERTEX_SIZE);
float co_ss[3];
ED_view3d_project_float_global(ar, ruler_item->co[ruler_item->co_index], co_ss, V3D_PROJ_TEST_NOP);
cpack(color_act);
circ(co_ss[0], co_ss[1], size * U.pixelsize);
}
}
}
void ui_draw_but_TRACKPREVIEW(ARegion *ar, uiBut *but, uiWidgetColors *UNUSED(wcol), rcti *recti)
{
rctf rect;
int ok = 0, width, height;
GLint scissor[4];
MovieClipScopes *scopes = (MovieClipScopes *)but->poin;
rect.xmin = (float)recti->xmin + 1;
rect.xmax = (float)recti->xmax - 1;
rect.ymin = (float)recti->ymin + SCOPE_RESIZE_PAD + 2;
rect.ymax = (float)recti->ymax - 1;
width = BLI_rctf_size_x(&rect) + 1;
height = BLI_rctf_size_y(&rect);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
/* need scissor test, preview image can draw outside of boundary */
glGetIntegerv(GL_VIEWPORT, scissor);
glScissor(ar->winrct.xmin + (rect.xmin - 1),
ar->winrct.ymin + (rect.ymin - 1),
(rect.xmax + 1) - (rect.xmin - 1),
(rect.ymax + 1) - (rect.ymin - 1));
if (scopes->track_disabled) {
glColor4f(0.7f, 0.3f, 0.3f, 0.3f);
uiSetRoundBox(UI_CNR_ALL);
uiDrawBox(GL_POLYGON, rect.xmin - 1, rect.ymin, rect.xmax + 1, rect.ymax + 1, 3.0f);
ok = 1;
}
else if ((scopes->track_search) &&
((!scopes->track_preview) ||
(scopes->track_preview->x != width || scopes->track_preview->y != height)))
{
ImBuf *tmpibuf;
if (scopes->track_preview)
IMB_freeImBuf(scopes->track_preview);
tmpibuf = BKE_tracking_sample_pattern(scopes->frame_width, scopes->frame_height,
scopes->track_search, scopes->track,
&scopes->undist_marker, TRUE, scopes->use_track_mask,
width, height, scopes->track_pos);
if (tmpibuf) {
if (tmpibuf->rect_float)
IMB_rect_from_float(tmpibuf);
if (tmpibuf->rect)
scopes->track_preview = tmpibuf;
else
IMB_freeImBuf(tmpibuf);
}
}
if (!ok && scopes->track_preview) {
float track_pos[2];
int a;
ImBuf *drawibuf;
glPushMatrix();
track_pos[0] = scopes->track_pos[0];
track_pos[1] = scopes->track_pos[1];
/* draw content of pattern area */
glScissor(ar->winrct.xmin + rect.xmin, ar->winrct.ymin + rect.ymin, scissor[2], scissor[3]);
if (width > 0 && height > 0) {
drawibuf = scopes->track_preview;
if (scopes->use_track_mask) {
glColor4f(0.0f, 0.0f, 0.0f, 0.3f);
uiSetRoundBox(UI_CNR_ALL);
uiDrawBox(GL_POLYGON, rect.xmin - 1, rect.ymin, rect.xmax + 1, rect.ymax + 1, 3.0f);
}
glaDrawPixelsSafe(rect.xmin, rect.ymin + 1, drawibuf->x, drawibuf->y,
drawibuf->x, GL_RGBA, GL_UNSIGNED_BYTE, drawibuf->rect);
/* draw cross for pizel position */
glTranslatef(rect.xmin + track_pos[0], rect.ymin + track_pos[1], 0.f);
glScissor(ar->winrct.xmin + rect.xmin,
ar->winrct.ymin + rect.ymin,
BLI_rctf_size_x(&rect),
BLI_rctf_size_y(&rect));
for (a = 0; a < 2; a++) {
if (a == 1) {
glLineStipple(3, 0xaaaa);
glEnable(GL_LINE_STIPPLE);
UI_ThemeColor(TH_SEL_MARKER);
}
else {
UI_ThemeColor(TH_MARKER_OUTLINE);
}
glBegin(GL_LINES);
glVertex2f(-10.0f, 0.0f);
glVertex2f(10.0f, 0.0f);
glVertex2f(0.0f, -10.0f);
glVertex2f(0.0f, 10.0f);
glEnd();
}
}
glDisable(GL_LINE_STIPPLE);
glPopMatrix();
ok = 1;
}
if (!ok) {
glColor4f(0.f, 0.f, 0.f, 0.3f);
uiSetRoundBox(UI_CNR_ALL);
uiDrawBox(GL_POLYGON, rect.xmin - 1, rect.ymin, rect.xmax + 1, rect.ymax + 1, 3.0f);
}
/* outline, scale gripper */
draw_scope_end(&rect, scissor);
glDisable(GL_BLEND);
}
void ui_draw_but_NORMAL(uiBut *but, uiWidgetColors *wcol, rcti *rect)
{
static GLuint displist = 0;
int a, old[8];
GLfloat diff[4], diffn[4] = {1.0f, 1.0f, 1.0f, 1.0f};
float vec0[4] = {0.0f, 0.0f, 0.0f, 0.0f};
float dir[4], size;
/* store stuff */
glGetMaterialfv(GL_FRONT, GL_DIFFUSE, diff);
/* backdrop */
glColor3ubv((unsigned char *)wcol->inner);
uiSetRoundBox(UI_CNR_ALL);
uiDrawBox(GL_POLYGON, rect->xmin, rect->ymin, rect->xmax, rect->ymax, 5.0f);
/* sphere color */
glMaterialfv(GL_FRONT, GL_DIFFUSE, diffn);
glCullFace(GL_BACK);
glEnable(GL_CULL_FACE);
/* disable blender light */
for (a = 0; a < 8; a++) {
old[a] = glIsEnabled(GL_LIGHT0 + a);
glDisable(GL_LIGHT0 + a);
}
/* own light */
glEnable(GL_LIGHT7);
glEnable(GL_LIGHTING);
ui_get_but_vectorf(but, dir);
dir[3] = 0.0f; /* glLightfv needs 4 args, 0.0 is sun */
glLightfv(GL_LIGHT7, GL_POSITION, dir);
glLightfv(GL_LIGHT7, GL_DIFFUSE, diffn);
glLightfv(GL_LIGHT7, GL_SPECULAR, vec0);
glLightf(GL_LIGHT7, GL_CONSTANT_ATTENUATION, 1.0f);
glLightf(GL_LIGHT7, GL_LINEAR_ATTENUATION, 0.0f);
/* transform to button */
glPushMatrix();
glTranslatef(rect->xmin + 0.5f * BLI_rcti_size_x(rect), rect->ymin + 0.5f * BLI_rcti_size_y(rect), 0.0f);
if (BLI_rcti_size_x(rect) < BLI_rcti_size_y(rect))
size = BLI_rcti_size_x(rect) / 200.f;
else
size = BLI_rcti_size_y(rect) / 200.f;
glScalef(size, size, size);
if (displist == 0) {
GLUquadricObj *qobj;
displist = glGenLists(1);
glNewList(displist, GL_COMPILE);
qobj = gluNewQuadric();
gluQuadricDrawStyle(qobj, GLU_FILL);
glShadeModel(GL_SMOOTH);
gluSphere(qobj, 100.0, 32, 24);
glShadeModel(GL_FLAT);
gluDeleteQuadric(qobj);
glEndList();
}
glCallList(displist);
/* restore */
glDisable(GL_LIGHTING);
glDisable(GL_CULL_FACE);
glMaterialfv(GL_FRONT, GL_DIFFUSE, diff);
glDisable(GL_LIGHT7);
/* AA circle */
glEnable(GL_BLEND);
glEnable(GL_LINE_SMOOTH);
glColor3ubv((unsigned char *)wcol->inner);
glutil_draw_lined_arc(0.0f, M_PI * 2.0, 100.0f, 32);
glDisable(GL_BLEND);
glDisable(GL_LINE_SMOOTH);
/* matrix after circle */
glPopMatrix();
/* enable blender light */
for (a = 0; a < 8; a++) {
if (old[a])
glEnable(GL_LIGHT0 + a);
}
}
void ui_draw_but_TRACKPREVIEW(ARegion *ar, uiBut *but, uiWidgetColors *UNUSED(wcol), rcti *recti)
{
rctf rect;
int ok= 0;
GLint scissor[4];
MovieClipScopes *scopes = (MovieClipScopes *)but->poin;
rect.xmin = (float)recti->xmin+1;
rect.xmax = (float)recti->xmax-1;
rect.ymin = (float)recti->ymin+SCOPE_RESIZE_PAD+2;
rect.ymax = (float)recti->ymax-1;
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
/* need scissor test, preview image can draw outside of boundary */
glGetIntegerv(GL_VIEWPORT, scissor);
glScissor(ar->winrct.xmin + (rect.xmin-1), ar->winrct.ymin+(rect.ymin-1), (rect.xmax+1)-(rect.xmin-1), (rect.ymax+1)-(rect.ymin-1));
if(scopes->track_disabled) {
glColor4f(0.7f, 0.3f, 0.3f, 0.3f);
uiSetRoundBox(15);
uiDrawBox(GL_POLYGON, rect.xmin-1, rect.ymin-1, rect.xmax+1, rect.ymax+1, 3.0f);
ok= 1;
}
else if(scopes->track_preview) {
int a, off_x, off_y;
float zoomx, zoomy;
ImBuf *drawibuf;
glPushMatrix();
/* draw content of pattern area */
glScissor(ar->winrct.xmin+rect.xmin, ar->winrct.ymin+rect.ymin, scissor[2], scissor[3]);
zoomx= (rect.xmax-rect.xmin) / (scopes->track_preview->x-2.0f);
zoomy= (rect.ymax-rect.ymin) / (scopes->track_preview->y-2.0f);
off_x= ((int)scopes->track_pos[0]-scopes->track_pos[0]-0.5f)*zoomx;
off_y= ((int)scopes->track_pos[1]-scopes->track_pos[1]-0.5f)*zoomy;
drawibuf= scale_trackpreview_ibuf(scopes->track_preview, zoomx, zoomy);
glaDrawPixelsSafe(off_x+rect.xmin, off_y+rect.ymin, rect.xmax-rect.xmin+1.f-off_x, rect.ymax-rect.ymin+1.f-off_y, drawibuf->x, GL_RGBA, GL_UNSIGNED_BYTE, drawibuf->rect);
IMB_freeImBuf(drawibuf);
/* draw cross for pizel position */
glTranslatef(off_x+rect.xmin+scopes->track_pos[0]*zoomx, off_y+rect.ymin+scopes->track_pos[1]*zoomy, 0.f);
glScissor(ar->winrct.xmin + rect.xmin, ar->winrct.ymin+rect.ymin, rect.xmax-rect.xmin, rect.ymax-rect.ymin);
for(a= 0; a< 2; a++) {
if(a==1) {
glLineStipple(3, 0xaaaa);
glEnable(GL_LINE_STIPPLE);
UI_ThemeColor(TH_SEL_MARKER);
}
else {
UI_ThemeColor(TH_MARKER_OUTLINE);
}
glBegin(GL_LINES);
glVertex2f(-10.0f, 0.0f);
glVertex2f(10.0f, 0.0f);
glVertex2f(0.0f, -10.0f);
glVertex2f(0.0f, 10.0f);
glEnd();
}
glDisable(GL_LINE_STIPPLE);
glPopMatrix();
ok= 1;
}
if(!ok) {
glColor4f(0.f, 0.f, 0.f, 0.3f);
uiSetRoundBox(15);
uiDrawBox(GL_POLYGON, rect.xmin-1, rect.ymin-1, rect.xmax+1, rect.ymax+1, 3.0f);
}
/* outline, scale gripper */
draw_scope_end(&rect, scissor);
glDisable(GL_BLEND);
}
// TODO: depreceate this code...
static void draw_nla_channel_list_gl(bAnimContext *ac, ListBase *anim_data, View2D *v2d, float y)
{
SpaceNla *snla = (SpaceNla *)ac->sl;
bAnimListElem *ale;
float x = 0.0f;
/* loop through channels, and set up drawing depending on their type */
for (ale = anim_data->first; ale; ale = ale->next) {
const float yminc = (float)(y - NLACHANNEL_HEIGHT_HALF(snla));
const float ymaxc = (float)(y + NLACHANNEL_HEIGHT_HALF(snla));
const float ydatac = (float)(y - 7);
/* check if visible */
if (IN_RANGE(yminc, v2d->cur.ymin, v2d->cur.ymax) ||
IN_RANGE(ymaxc, v2d->cur.ymin, v2d->cur.ymax) )
{
AnimData *adt = ale->adt;
short indent = 0, offset = 0, sel = 0, group = 0, nonSolo = 0;
int expand = -1, protect = -1, special = -1, mute = -1;
char name[128];
short do_draw = FALSE;
/* determine what needs to be drawn */
switch (ale->type) {
case ANIMTYPE_NLATRACK: /* NLA Track */
{
NlaTrack *nlt = (NlaTrack *)ale->data;
/* 'solo' as the 'special' button? */
if (nlt->flag & NLATRACK_SOLO)
special = ICON_SOLO_ON;
else
special = ICON_SOLO_OFF;
/* if this track is active and we're tweaking it, don't draw these toggles */
// TODO: need a special macro for this...
if (((nlt->flag & NLATRACK_ACTIVE) && (nlt->flag & NLATRACK_DISABLED)) == 0) {
if (nlt->flag & NLATRACK_MUTED)
mute = ICON_MUTE_IPO_ON;
else
mute = ICON_MUTE_IPO_OFF;
if (EDITABLE_NLT(nlt))
protect = ICON_UNLOCKED;
else
protect = ICON_LOCKED;
}
/* is track enabled for solo drawing? */
if ((adt) && (adt->flag & ADT_NLA_SOLO_TRACK)) {
if ((nlt->flag & NLATRACK_SOLO) == 0) {
/* tag for special non-solo handling; also hide the mute toggles */
nonSolo = 1;
mute = 0;
}
}
sel = SEL_NLT(nlt);
BLI_strncpy(name, nlt->name, sizeof(name));
/* draw manually still */
do_draw = TRUE;
}
break;
case ANIMTYPE_NLAACTION: /* NLA Action-Line */
{
bAction *act = (bAction *)ale->data;
group = 5;
special = ICON_ACTION;
if (act)
BLI_snprintf(name, sizeof(name), "%s", act->id.name + 2);
else
BLI_strncpy(name, "<No Action>", sizeof(name));
/* draw manually still */
do_draw = TRUE;
}
break;
default: /* handled by standard channel-drawing API */
// draw backdrops only...
ANIM_channel_draw(ac, ale, yminc, ymaxc);
break;
}
/* if special types, draw manually for now... */
if (do_draw) {
if (ale->id) {
/* special exception for textures */
if (GS(ale->id->name) == ID_TE) {
offset = 14;
indent = 1;
}
/* special exception for nodetrees */
else if (GS(ale->id->name) == ID_NT) {
bNodeTree *ntree = (bNodeTree *)ale->id;
switch (ntree->type) {
case NTREE_SHADER:
{
/* same as for textures */
offset = 14;
indent = 1;
}
break;
case NTREE_TEXTURE:
{
/* even more */
offset = 21;
indent = 1;
}
break;
default:
/* normal will do */
offset = 14;
break;
}
}
else {
offset = 14;
}
}
else {
offset = 0;
}
/* now, start drawing based on this information */
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
/* draw backing strip behind channel name */
// FIXME: hardcoded colors!!!
if (group == 5) {
float color[4];
/* Action Line
* The alpha values action_get_color returns are only useful for drawing
* strips backgrounds but here we're doing channel list backgrounds instead
* so we ignore that and use our own when needed
*/
nla_action_get_color(adt, (bAction *)ale->data, color);
if (adt && (adt->flag & ADT_NLA_EDIT_ON)) {
/* Yes, the color vector has 4 components, BUT we only want to be using 3 of them! */
glColor3fv(color);
}
else {
float alpha = (adt && (adt->flag & ADT_NLA_SOLO_TRACK)) ? 0.3 : 1.0f;
glColor4f(color[0], color[1], color[2], alpha);
}
offset += 7 * indent;
/* only on top two corners, to show that this channel sits on top of the preceding ones */
uiSetRoundBox(UI_CNR_TOP_LEFT | UI_CNR_TOP_RIGHT);
/* draw slightly shifted up vertically to look like it has more separation from other channels,
* but we then need to slightly shorten it so that it doesn't look like it overlaps
*/
uiDrawBox(GL_POLYGON, x + offset, yminc + NLACHANNEL_SKIP, (float)v2d->cur.xmax, ymaxc + NLACHANNEL_SKIP - 1, 8);
/* clear group value, otherwise we cause errors... */
group = 0;
}
else {
/* NLA tracks - darker color if not solo track when we're showing solo */
UI_ThemeColorShade(TH_HEADER, ((nonSolo == 0) ? 20 : -20));
indent += group;
offset += 7 * indent;
glBegin(GL_QUADS);
glVertex2f(x + offset, yminc);
glVertex2f(x + offset, ymaxc);
glVertex2f((float)v2d->cur.xmax, ymaxc);
glVertex2f((float)v2d->cur.xmax, yminc);
glEnd();
}
/* draw expand/collapse triangle */
if (expand > 0) {
UI_icon_draw(x + offset, ydatac, expand);
offset += 17;
}
/* draw special icon indicating certain data-types */
if (special > -1) {
/* for normal channels */
UI_icon_draw(x + offset, ydatac, special);
offset += 17;
}
glDisable(GL_BLEND);
/* draw name */
if (sel)
UI_ThemeColor(TH_TEXT_HI);
else
UI_ThemeColor(TH_TEXT);
offset += 3;
UI_DrawString(x + offset, y - 4, name);
/* reset offset - for RHS of panel */
offset = 0;
/* set blending again, as text drawing may clear it */
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
/* draw protect 'lock' */
if (protect > -1) {
offset = 16;
UI_icon_draw((float)(v2d->cur.xmax - offset), ydatac, protect);
}
/* draw mute 'eye' */
if (mute > -1) {
offset += 16;
UI_icon_draw((float)(v2d->cur.xmax - offset), ydatac, mute);
}
/* draw NLA-action line 'status-icons' - only when there's an action */
if ((ale->type == ANIMTYPE_NLAACTION) && (ale->data)) {
AnimData *adt = ale->adt;
offset += 16;
/* now draw some indicator icons */
if ((adt) && (adt->flag & ADT_NLA_EDIT_ON)) {
/* toggle for tweaking with mapping/no-mapping (i.e. 'in place editing' toggle) */
// for now, use pin icon to symbolise this
if (adt->flag & ADT_NLA_EDIT_NOMAP)
UI_icon_draw((float)(v2d->cur.xmax - offset), ydatac, ICON_PINNED);
else
UI_icon_draw((float)(v2d->cur.xmax - offset), ydatac, ICON_UNPINNED);
fdrawline((float)(v2d->cur.xmax - offset), yminc,
(float)(v2d->cur.xmax - offset), ymaxc);
offset += 16;
/* 'tweaking action' indicator - not a button */
UI_icon_draw((float)(v2d->cur.xmax - offset), ydatac, ICON_EDIT);
}
else {
/* XXX firstly draw a little rect to help identify that it's different from the toggles */
glBegin(GL_LINE_LOOP);
glVertex2f((float)v2d->cur.xmax - offset - 1, y - 7);
glVertex2f((float)v2d->cur.xmax - offset - 1, y + 9);
glVertex2f((float)v2d->cur.xmax - 1, y + 9);
glVertex2f((float)v2d->cur.xmax - 1, y - 7);
glEnd(); // GL_LINES
/* 'push down' icon for normal active-actions */
UI_icon_draw((float)v2d->cur.xmax - offset, ydatac, ICON_FREEZE);
}
}
glDisable(GL_BLEND);
}
}
/* adjust y-position for next one */
y -= NLACHANNEL_STEP(snla);
}
}
void draw_image_seq(const bContext *C, Scene *scene, ARegion *ar, SpaceSeq *sseq, int cfra, int frame_ofs)
{
struct Main *bmain = CTX_data_main(C);
struct ImBuf *ibuf = NULL;
struct ImBuf *scope = NULL;
struct View2D *v2d = &ar->v2d;
int rectx, recty;
float viewrectx, viewrecty;
float render_size = 0.0;
float proxy_size = 100.0;
float col[3];
GLuint texid;
GLuint last_texid;
SeqRenderData context;
render_size = sseq->render_size;
if (render_size == 0) {
render_size = scene->r.size;
}
else {
proxy_size = render_size;
}
if (render_size < 0) {
return;
}
viewrectx = (render_size * (float)scene->r.xsch) / 100.0f;
viewrecty = (render_size * (float)scene->r.ysch) / 100.0f;
rectx = viewrectx + 0.5f;
recty = viewrecty + 0.5f;
if (sseq->mainb == SEQ_DRAW_IMG_IMBUF) {
viewrectx *= scene->r.xasp / scene->r.yasp;
viewrectx /= proxy_size / 100.0f;
viewrecty /= proxy_size / 100.0f;
}
if (frame_ofs == 0) {
UI_GetThemeColor3fv(TH_SEQ_PREVIEW, col);
glClearColor(col[0], col[1], col[2], 0.0);
glClear(GL_COLOR_BUFFER_BIT);
}
/* without this colors can flicker from previous opengl state */
glColor4ub(255, 255, 255, 255);
UI_view2d_totRect_set(v2d, viewrectx + 0.5f, viewrecty + 0.5f);
UI_view2d_curRect_validate(v2d);
/* only initialize the preview if a render is in progress */
if (G.rendering)
return;
context = seq_new_render_data(bmain, scene, rectx, recty, proxy_size);
if (special_seq_update)
ibuf = give_ibuf_seq_direct(context, cfra + frame_ofs, special_seq_update);
else if (!U.prefetchframes) // XXX || (G.f & G_PLAYANIM) == 0) {
ibuf = give_ibuf_seq(context, cfra + frame_ofs, sseq->chanshown);
else
ibuf = give_ibuf_seq_threaded(context, cfra + frame_ofs, sseq->chanshown);
if (ibuf == NULL)
return;
if (ibuf->rect == NULL && ibuf->rect_float == NULL)
return;
switch (sseq->mainb) {
case SEQ_DRAW_IMG_IMBUF:
if (sseq->zebra != 0) {
scope = make_zebra_view_from_ibuf(ibuf, sseq->zebra);
}
break;
case SEQ_DRAW_IMG_WAVEFORM:
if ((sseq->flag & SEQ_DRAW_COLOR_SEPARATED) != 0) {
scope = make_sep_waveform_view_from_ibuf(ibuf);
}
else {
scope = make_waveform_view_from_ibuf(ibuf);
}
break;
case SEQ_DRAW_IMG_VECTORSCOPE:
scope = make_vectorscope_view_from_ibuf(ibuf);
break;
case SEQ_DRAW_IMG_HISTOGRAM:
scope = make_histogram_view_from_ibuf(ibuf);
break;
}
if (scope) {
IMB_freeImBuf(ibuf);
ibuf = scope;
}
if (ibuf->rect_float && ibuf->rect == NULL) {
IMB_rect_from_float(ibuf);
}
/* setting up the view - actual drawing starts here */
UI_view2d_view_ortho(v2d);
last_texid = glaGetOneInteger(GL_TEXTURE_2D);
glEnable(GL_TEXTURE_2D);
glGenTextures(1, (GLuint *)&texid);
glBindTexture(GL_TEXTURE_2D, texid);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, ibuf->x, ibuf->y, 0, GL_RGBA, GL_UNSIGNED_BYTE, ibuf->rect);
glBegin(GL_QUADS);
if (frame_ofs) {
rctf tot_clip;
tot_clip.xmin = v2d->tot.xmin + (ABS(v2d->tot.xmax - v2d->tot.xmin) * scene->ed->over_border.xmin);
tot_clip.ymin = v2d->tot.ymin + (ABS(v2d->tot.ymax - v2d->tot.ymin) * scene->ed->over_border.ymin);
tot_clip.xmax = v2d->tot.xmin + (ABS(v2d->tot.xmax - v2d->tot.xmin) * scene->ed->over_border.xmax);
tot_clip.ymax = v2d->tot.ymin + (ABS(v2d->tot.ymax - v2d->tot.ymin) * scene->ed->over_border.ymax);
glTexCoord2f(scene->ed->over_border.xmin, scene->ed->over_border.ymin); glVertex2f(tot_clip.xmin, tot_clip.ymin);
glTexCoord2f(scene->ed->over_border.xmin, scene->ed->over_border.ymax); glVertex2f(tot_clip.xmin, tot_clip.ymax);
glTexCoord2f(scene->ed->over_border.xmax, scene->ed->over_border.ymax); glVertex2f(tot_clip.xmax, tot_clip.ymax);
glTexCoord2f(scene->ed->over_border.xmax, scene->ed->over_border.ymin); glVertex2f(tot_clip.xmax, tot_clip.ymin);
}
else {
glTexCoord2f(0.0f, 0.0f); glVertex2f(v2d->tot.xmin, v2d->tot.ymin);
glTexCoord2f(0.0f, 1.0f); glVertex2f(v2d->tot.xmin, v2d->tot.ymax);
glTexCoord2f(1.0f, 1.0f); glVertex2f(v2d->tot.xmax, v2d->tot.ymax);
glTexCoord2f(1.0f, 0.0f); glVertex2f(v2d->tot.xmax, v2d->tot.ymin);
}
glEnd();
glBindTexture(GL_TEXTURE_2D, last_texid);
glDisable(GL_TEXTURE_2D);
glDeleteTextures(1, &texid);
if (sseq->mainb == SEQ_DRAW_IMG_IMBUF) {
float x1 = v2d->tot.xmin;
float y1 = v2d->tot.ymin;
float x2 = v2d->tot.xmax;
float y2 = v2d->tot.ymax;
/* border */
setlinestyle(3);
UI_ThemeColorBlendShade(TH_WIRE, TH_BACK, 1.0, 0);
glBegin(GL_LINE_LOOP);
glVertex2f(x1 - 0.5f, y1 - 0.5f);
glVertex2f(x1 - 0.5f, y2 + 0.5f);
glVertex2f(x2 + 0.5f, y2 + 0.5f);
glVertex2f(x2 + 0.5f, y1 - 0.5f);
glEnd();
/* safety border */
if ((sseq->flag & SEQ_DRAW_SAFE_MARGINS) != 0) {
float fac = 0.1;
float a = fac * (x2 - x1);
x1 += a;
x2 -= a;
a = fac * (y2 - y1);
y1 += a;
y2 -= a;
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
uiSetRoundBox(UI_CNR_ALL);
uiDrawBox(GL_LINE_LOOP, x1, y1, x2, y2, 12.0);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}
setlinestyle(0);
}
/* draw grease-pencil (image aligned) */
draw_gpencil_2dimage(C);
IMB_freeImBuf(ibuf);
/* ortho at pixel level */
UI_view2d_view_restore(C);
/* draw grease-pencil (screen aligned) */
draw_gpencil_view2d(C, 0);
//if (sc->mode == SC_MODE_MASKEDIT) {
if (sseq->mainb == SEQ_DRAW_IMG_IMBUF) {
Mask *mask = BKE_sequencer_mask_get(scene);
if (mask) {
int width, height;
// ED_mask_get_size(C, &width, &height);
//Scene *scene = CTX_data_scene(C);
width = (scene->r.size * scene->r.xsch) / 100;
height = (scene->r.size * scene->r.ysch) / 100;
ED_mask_draw_region(mask, ar,
0, 0, /* TODO */
width, height,
FALSE, TRUE,
NULL, C);
}
}
}
/* main call for drawing a single NLA-strip */
static void nla_draw_strip (SpaceNla *snla, AnimData *adt, NlaTrack *nlt, NlaStrip *strip, View2D *v2d, float yminc, float ymaxc)
{
float color[3];
/* get color of strip */
nla_strip_get_color_inside(adt, strip, color);
/* draw extrapolation info first (as backdrop) */
if (strip->extendmode != NLASTRIP_EXTEND_NOTHING) {
/* enable transparency... */
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
switch (strip->extendmode) {
/* since this does both sides, only do the 'before' side, and leave the rest to the next case */
case NLASTRIP_EXTEND_HOLD:
/* only need to draw here if there's no strip before since
* it only applies in such a situation
*/
if (strip->prev == NULL) {
/* set the drawing color to the color of the strip, but with very faint alpha */
glColor4f(color[0], color[1], color[2], 0.15f);
/* draw the rect to the edge of the screen */
glBegin(GL_QUADS);
glVertex2f(v2d->cur.xmin, yminc);
glVertex2f(v2d->cur.xmin, ymaxc);
glVertex2f(strip->start, ymaxc);
glVertex2f(strip->start, yminc);
glEnd();
}
/* no break needed... */
/* this only draws after the strip */
case NLASTRIP_EXTEND_HOLD_FORWARD:
/* only need to try and draw if the next strip doesn't occur immediately after */
if ((strip->next == NULL) || (IS_EQ(strip->next->start, strip->end)==0)) {
/* set the drawing color to the color of the strip, but this time less faint */
glColor4f(color[0], color[1], color[2], 0.3f);
/* draw the rect to the next strip or the edge of the screen */
glBegin(GL_QUADS);
glVertex2f(strip->end, yminc);
glVertex2f(strip->end, ymaxc);
if (strip->next) {
glVertex2f(strip->next->start, ymaxc);
glVertex2f(strip->next->start, yminc);
}
else {
glVertex2f(v2d->cur.xmax, ymaxc);
glVertex2f(v2d->cur.xmax, yminc);
}
glEnd();
}
break;
}
glDisable(GL_BLEND);
}
/* draw 'inside' of strip itself */
glColor3fv(color);
uiSetRoundBox(15); /* all corners rounded */
gl_round_box_shade(GL_POLYGON, strip->start, yminc, strip->end, ymaxc, 0.0, 0.5, 0.1);
/* draw strip's control 'curves'
* - only if user hasn't hidden them...
*/
if ((snla->flag & SNLA_NOSTRIPCURVES) == 0)
nla_draw_strip_curves(strip, v2d, yminc, ymaxc);
/* draw strip outline
* - color used here is to indicate active vs non-active
*/
if (strip->flag & NLASTRIP_FLAG_ACTIVE) {
/* strip should appear 'sunken', so draw a light border around it */
glColor3f(0.9f, 1.0f, 0.9f); // FIXME: hardcoded temp-hack colors
}
else {
/* strip should appear to stand out, so draw a dark border around it */
glColor3f(0.0f, 0.0f, 0.0f);
}
/* - line style: dotted for muted */
if (strip->flag & NLASTRIP_FLAG_MUTED)
setlinestyle(4);
/* draw outline */
gl_round_box_shade(GL_LINE_LOOP, strip->start, yminc, strip->end, ymaxc, 0.0, 0.0, 0.1);
/* if action-clip strip, draw lines delimiting repeats too (in the same color as outline) */
if ((strip->type == NLASTRIP_TYPE_CLIP) && IS_EQ(strip->repeat, 1.0f)==0) {
float repeatLen = (strip->actend - strip->actstart) * strip->scale;
int i;
/* only draw lines for whole-numbered repeats, starting from the first full-repeat
* up to the last full repeat (but not if it lies on the end of the strip)
*/
for (i = 1; i < strip->repeat; i++) {
float repeatPos = strip->start + (repeatLen * i);
/* don't draw if line would end up on or after the end of the strip */
if (repeatPos < strip->end)
fdrawline(repeatPos, yminc+4, repeatPos, ymaxc-4);
}
}
/* or if meta-strip, draw lines delimiting extents of sub-strips (in same color as outline, if more than 1 exists) */
else if ((strip->type == NLASTRIP_TYPE_META) && (strip->strips.first != strip->strips.last)) {
NlaStrip *cs;
float y= (ymaxc-yminc)/2.0f + yminc;
/* only draw first-level of child-strips, but don't draw any lines on the endpoints */
for (cs= strip->strips.first; cs; cs= cs->next) {
/* draw start-line if not same as end of previous (and only if not the first strip)
* - on upper half of strip
*/
if ((cs->prev) && IS_EQ(cs->prev->end, cs->start)==0)
fdrawline(cs->start, y, cs->start, ymaxc);
/* draw end-line if not the last strip
* - on lower half of strip
*/
if (cs->next)
fdrawline(cs->end, yminc, cs->end, y);
}
}
/* reset linestyle */
setlinestyle(0);
}
void ui_draw_but_HISTOGRAM(ARegion *ar, uiBut *but, uiWidgetColors *UNUSED(wcol), rcti *recti)
{
Histogram *hist = (Histogram *)but->poin;
int res = hist->x_resolution;
rctf rect;
int i;
float w, h;
const short is_line = (hist->flag & HISTO_FLAG_LINE) != 0;
//float alpha;
GLint scissor[4];
rect.xmin = (float)recti->xmin + 1;
rect.xmax = (float)recti->xmax - 1;
rect.ymin = (float)recti->ymin + SCOPE_RESIZE_PAD + 2;
rect.ymax = (float)recti->ymax - 1;
w = BLI_rctf_size_x(&rect);
h = BLI_rctf_size_y(&rect) * hist->ymax;
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glColor4f(0.f, 0.f, 0.f, 0.3f);
uiSetRoundBox(UI_CNR_ALL);
uiDrawBox(GL_POLYGON, rect.xmin - 1, rect.ymin - 1, rect.xmax + 1, rect.ymax + 1, 3.0f);
/* need scissor test, histogram can draw outside of boundary */
glGetIntegerv(GL_VIEWPORT, scissor);
glScissor(ar->winrct.xmin + (rect.xmin - 1),
ar->winrct.ymin + (rect.ymin - 1),
(rect.xmax + 1) - (rect.xmin - 1),
(rect.ymax + 1) - (rect.ymin - 1));
glColor4f(1.f, 1.f, 1.f, 0.08f);
/* draw grid lines here */
for (i = 1; i <= HISTOGRAM_TOT_GRID_LINES; i++) {
const float fac = (float)i / (float)HISTOGRAM_TOT_GRID_LINES;
/* so we can tell the 1.0 color point */
if (i == HISTOGRAM_TOT_GRID_LINES) {
glColor4f(1.0f, 1.0f, 1.0f, 0.5f);
}
fdrawline(rect.xmin, rect.ymin + fac * h, rect.xmax, rect.ymin + fac * h);
fdrawline(rect.xmin + fac * w, rect.ymin, rect.xmin + fac * w, rect.ymax);
}
if (hist->mode == HISTO_MODE_LUMA) {
histogram_draw_one(1.0, 1.0, 1.0, 0.75, rect.xmin, rect.ymin, w, h, hist->data_luma, res, is_line);
}
else if (hist->mode == HISTO_MODE_ALPHA) {
histogram_draw_one(1.0, 1.0, 1.0, 0.75, rect.xmin, rect.ymin, w, h, hist->data_a, res, is_line);
}
else {
if (hist->mode == HISTO_MODE_RGB || hist->mode == HISTO_MODE_R)
histogram_draw_one(1.0, 0.0, 0.0, 0.75, rect.xmin, rect.ymin, w, h, hist->data_r, res, is_line);
if (hist->mode == HISTO_MODE_RGB || hist->mode == HISTO_MODE_G)
histogram_draw_one(0.0, 1.0, 0.0, 0.75, rect.xmin, rect.ymin, w, h, hist->data_g, res, is_line);
if (hist->mode == HISTO_MODE_RGB || hist->mode == HISTO_MODE_B)
histogram_draw_one(0.0, 0.0, 1.0, 0.75, rect.xmin, rect.ymin, w, h, hist->data_b, res, is_line);
}
/* outline, scale gripper */
draw_scope_end(&rect, scissor);
}
void ui_draw_but_WAVEFORM(ARegion *ar, uiBut *but, uiWidgetColors *UNUSED(wcol), rcti *recti)
{
Scopes *scopes = (Scopes *)but->poin;
rctf rect;
int i, c;
float w, w3, h, alpha, yofs;
GLint scissor[4];
float colors[3][3] = MAT3_UNITY;
float colorsycc[3][3] = {{1, 0, 1}, {1, 1, 0}, {0, 1, 1}};
float colors_alpha[3][3], colorsycc_alpha[3][3]; /* colors pre multiplied by alpha for speed up */
float min, max;
if (scopes == NULL) return;
rect.xmin = (float)recti->xmin + 1;
rect.xmax = (float)recti->xmax - 1;
rect.ymin = (float)recti->ymin + SCOPE_RESIZE_PAD + 2;
rect.ymax = (float)recti->ymax - 1;
if (scopes->wavefrm_yfac < 0.5f)
scopes->wavefrm_yfac = 0.98f;
w = BLI_rctf_size_x(&rect) - 7;
h = BLI_rctf_size_y(&rect) * scopes->wavefrm_yfac;
yofs = rect.ymin + (BLI_rctf_size_y(&rect) - h) / 2.0f;
w3 = w / 3.0f;
/* log scale for alpha */
alpha = scopes->wavefrm_alpha * scopes->wavefrm_alpha;
for (c = 0; c < 3; c++) {
for (i = 0; i < 3; i++) {
colors_alpha[c][i] = colors[c][i] * alpha;
colorsycc_alpha[c][i] = colorsycc[c][i] * alpha;
}
}
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glColor4f(0.f, 0.f, 0.f, 0.3f);
uiSetRoundBox(UI_CNR_ALL);
uiDrawBox(GL_POLYGON, rect.xmin - 1, rect.ymin - 1, rect.xmax + 1, rect.ymax + 1, 3.0f);
/* need scissor test, waveform can draw outside of boundary */
glGetIntegerv(GL_VIEWPORT, scissor);
glScissor(ar->winrct.xmin + (rect.xmin - 1),
ar->winrct.ymin + (rect.ymin - 1),
(rect.xmax + 1) - (rect.xmin - 1),
(rect.ymax + 1) - (rect.ymin - 1));
glColor4f(1.f, 1.f, 1.f, 0.08f);
/* draw grid lines here */
for (i = 0; i < 6; i++) {
char str[4];
BLI_snprintf(str, sizeof(str), "%-3d", i * 20);
str[3] = '\0';
fdrawline(rect.xmin + 22, yofs + (i / 5.f) * h, rect.xmax + 1, yofs + (i / 5.f) * h);
BLF_draw_default(rect.xmin + 1, yofs - 5 + (i / 5.f) * h, 0, str, sizeof(str) - 1);
/* in the loop because blf_draw reset it */
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
/* 3 vertical separation */
if (scopes->wavefrm_mode != SCOPES_WAVEFRM_LUMA) {
for (i = 1; i < 3; i++) {
fdrawline(rect.xmin + i * w3, rect.ymin, rect.xmin + i * w3, rect.ymax);
}
}
/* separate min max zone on the right */
fdrawline(rect.xmin + w, rect.ymin, rect.xmin + w, rect.ymax);
/* 16-235-240 level in case of ITU-R BT601/709 */
glColor4f(1.f, 0.4f, 0.f, 0.2f);
if (ELEM(scopes->wavefrm_mode, SCOPES_WAVEFRM_YCC_601, SCOPES_WAVEFRM_YCC_709)) {
fdrawline(rect.xmin + 22, yofs + h * 16.0f / 255.0f, rect.xmax + 1, yofs + h * 16.0f / 255.0f);
fdrawline(rect.xmin + 22, yofs + h * 235.0f / 255.0f, rect.xmin + w3, yofs + h * 235.0f / 255.0f);
fdrawline(rect.xmin + 3 * w3, yofs + h * 235.0f / 255.0f, rect.xmax + 1, yofs + h * 235.0f / 255.0f);
fdrawline(rect.xmin + w3, yofs + h * 240.0f / 255.0f, rect.xmax + 1, yofs + h * 240.0f / 255.0f);
}
/* 7.5 IRE black point level for NTSC */
if (scopes->wavefrm_mode == SCOPES_WAVEFRM_LUMA)
fdrawline(rect.xmin, yofs + h * 0.075f, rect.xmax + 1, yofs + h * 0.075f);
if (scopes->ok && scopes->waveform_1 != NULL) {
/* LUMA (1 channel) */
glBlendFunc(GL_ONE, GL_ONE);
glColor3f(alpha, alpha, alpha);
if (scopes->wavefrm_mode == SCOPES_WAVEFRM_LUMA) {
glBlendFunc(GL_ONE, GL_ONE);
glPushMatrix();
glEnableClientState(GL_VERTEX_ARRAY);
glTranslatef(rect.xmin, yofs, 0.f);
glScalef(w, h, 0.f);
glVertexPointer(2, GL_FLOAT, 0, scopes->waveform_1);
glDrawArrays(GL_POINTS, 0, scopes->waveform_tot);
glDisableClientState(GL_VERTEX_ARRAY);
glPopMatrix();
/* min max */
glColor3f(0.5f, 0.5f, 0.5f);
min = yofs + scopes->minmax[0][0] * h;
max = yofs + scopes->minmax[0][1] * h;
CLAMP(min, rect.ymin, rect.ymax);
CLAMP(max, rect.ymin, rect.ymax);
fdrawline(rect.xmax - 3, min, rect.xmax - 3, max);
}
/* RGB / YCC (3 channels) */
else if (ELEM4(scopes->wavefrm_mode,
SCOPES_WAVEFRM_RGB,
SCOPES_WAVEFRM_YCC_601,
SCOPES_WAVEFRM_YCC_709,
SCOPES_WAVEFRM_YCC_JPEG))
{
int rgb = (scopes->wavefrm_mode == SCOPES_WAVEFRM_RGB);
glBlendFunc(GL_ONE, GL_ONE);
glPushMatrix();
glEnableClientState(GL_VERTEX_ARRAY);
glTranslatef(rect.xmin, yofs, 0.f);
glScalef(w3, h, 0.f);
glColor3fv((rgb) ? colors_alpha[0] : colorsycc_alpha[0]);
glVertexPointer(2, GL_FLOAT, 0, scopes->waveform_1);
glDrawArrays(GL_POINTS, 0, scopes->waveform_tot);
glTranslatef(1.f, 0.f, 0.f);
glColor3fv((rgb) ? colors_alpha[1] : colorsycc_alpha[1]);
glVertexPointer(2, GL_FLOAT, 0, scopes->waveform_2);
glDrawArrays(GL_POINTS, 0, scopes->waveform_tot);
glTranslatef(1.f, 0.f, 0.f);
glColor3fv((rgb) ? colors_alpha[2] : colorsycc_alpha[2]);
glVertexPointer(2, GL_FLOAT, 0, scopes->waveform_3);
glDrawArrays(GL_POINTS, 0, scopes->waveform_tot);
glDisableClientState(GL_VERTEX_ARRAY);
glPopMatrix();
/* min max */
for (c = 0; c < 3; c++) {
if (scopes->wavefrm_mode == SCOPES_WAVEFRM_RGB)
glColor3f(colors[c][0] * 0.75f, colors[c][1] * 0.75f, colors[c][2] * 0.75f);
else
glColor3f(colorsycc[c][0] * 0.75f, colorsycc[c][1] * 0.75f, colorsycc[c][2] * 0.75f);
min = yofs + scopes->minmax[c][0] * h;
max = yofs + scopes->minmax[c][1] * h;
CLAMP(min, rect.ymin, rect.ymax);
CLAMP(max, rect.ymin, rect.ymax);
fdrawline(rect.xmin + w + 2 + c * 2, min, rect.xmin + w + 2 + c * 2, max);
}
}
}
/* outline, scale gripper */
draw_scope_end(&rect, scissor);
}
void Console::Draw()
{
int uiround=uiGetRoundBox();
uiSetRoundBox("0000");
if (Get_Active())
gl_round_box_Hshade(GL_POLYGON, Get_x(), Get_y(), Get_x()+Get_widht(), Get_y()+Get_height(),10, "FFFFFF", "FFFFFF");
int line=Get_y()+10;
int posx=Get_x();
int found;
int i=0;
while( m_text.size()>(int)(Get_height()/11))
{
m_text.pop_front();
}
for( listItor itor = m_text.begin(); itor != m_text.end(); ++itor )
{
i++;
found = (*itor).content.find_first_of ('\n');
if( found <=0) {
switch ((*itor).font)
{
case 1:
drawText(posx,line+15,(*itor).content, (*itor).color, (*itor).font);
break;
case 2:
drawText(posx,line+13,(*itor).content, (*itor).color, (*itor).font);
break;
case 3:
drawText(posx,line+10,(*itor).content, (*itor).color, (*itor).font);
break;
case 4:
drawText(posx,line+24,(*itor).content, (*itor).color, (*itor).font);
break;
case 5:
drawText(posx,line+12,(*itor).content, (*itor).color, (*itor).font);
break;
case 6:
drawText(posx,line+18,(*itor).content, (*itor).color, (*itor).font);
break;
default:
drawText(posx,line+10,(*itor).content, (*itor).color, (*itor).font);
break;
}
posx=posx+((*itor).content.size()*6);
}
else
{
switch ((*itor).font)
{
case 1:
drawText(posx,line+15,(*itor).content, (*itor).color, (*itor).font);
line=line+15;
break;
case 2:
drawText(posx,line+13,(*itor).content, (*itor).color, (*itor).font);
line=line+13;
break;
case 3:
drawText(posx,line+10,(*itor).content, (*itor).color, (*itor).font);
line=line+10;
break;
case 4:
drawText(posx,line+24,(*itor).content, (*itor).color, (*itor).font);
line=line+24;
break;
case 5:
drawText(posx,line+12,(*itor).content, (*itor).color, (*itor).font);
line=line+12;
break;
case 6:
drawText(posx,line+18,(*itor).content, (*itor).color, (*itor).font);
line=line+18;
break;
default:
drawText(posx,line+10,(*itor).content, (*itor).color, (*itor).font);
line=line+10;
break;
}
posx=Get_x();
}
}
uiSetRoundBox(uiround);
}