void View::draw_help()
{
set_ortho_projection(true);
glDisable(GL_DEPTH_TEST);
glDisable(GL_LIGHTING);
glDisable(GL_TEXTURE_1D);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
const char* text = get_help_text();
int n = 1;
for (const char* p = text; *p; p++)
if (*p == '\n') n++;
int width = get_text_width(text);
int height = n * glutBitmapHeight(GLUT_BITMAP_9_BY_15);
int x = 10, y = 10, b = 6;
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glColor4f(1.0f, 1.0f, 1.0f, 0.65f);
glBegin(GL_QUADS);
glVertex2d(x, y+height+2*b);
glVertex2d(x+width+2*b, y+height+2*b);
glVertex2d(x+width+2*b, y);
glVertex2d(x, y);
glEnd();
glDisable(GL_BLEND);
glColor3f(0, 0, 0);
draw_text(x+b, y+b+7, text);
}
void View::draw_fps()
{
//calculate FPS
double frame_time_sum = 0;
for(int i = 0; i < FPS_FRAME_SIZE; i++)
frame_time_sum += rendering_frames[i];
//prepare text
unsigned char buffer[128];
sprintf((char*)buffer, "avg. frame: %.1f ms", (float)(frame_time_sum / FPS_FRAME_SIZE));
//prepare environment
void* font = GLUT_BITMAP_HELVETICA_10;
int width_px = glutBitmapLength(font, buffer);
int height_px = glutBitmapHeight(font);
int edge_thickness = 2;
set_ortho_projection(false);
//render background
glEnable(GL_BLEND);
glBlendFunc(GL_ONE_MINUS_SRC_ALPHA, GL_SRC_ALPHA);
glBegin(GL_QUADS);
glColor4f(1.0f, 1.0f, 1.0f, 0.5f);
glVertex2i(output_width - (width_px + 2*edge_thickness), 0);
glVertex2i(output_width, 0);
glVertex2i(output_width, height_px + 2*edge_thickness);
glVertex2i(output_width - (width_px + 2*edge_thickness), height_px + 2*edge_thickness);
glEnd();
//render text
glDisable(GL_BLEND);
glColor3f(1.0f, 0.0f, 0.0f);
glRasterPos2i(output_width - (width_px + edge_thickness), edge_thickness + height_px);
glutBitmapString(font, buffer);
}
void c_RendererViewer::reshape(int _width, int _height)
{
if (!_height)
_height = 1;
if (!_width)
_width = 1;
m_width = _width;
m_height = _height;
set_ortho_projection(m_width, m_height);
return;
}
void View::display_antialiased()
{
glClear(GL_ACCUM_BUFFER_BIT);
for (int i = 0; i < 16; i++)
{
jitter_x = jitter16[i][0];
jitter_y = jitter16[i][1];
set_ortho_projection();
clear_background();
on_display();
glAccum(GL_ACCUM, 1.0 / 16);
}
glAccum(GL_RETURN, 1.0);
jitter_x = jitter_y = 0.0;
}
void View::draw_continuous_scale(char* title, bool righttext)
{
int i;
double y0 = scale_y + scale_height;
set_ortho_projection(true);
glDisable(GL_DEPTH_TEST);
glDisable(GL_LIGHTING);
glDisable(GL_TEXTURE_1D);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
// background
const int b = 5;
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glColor4f(1.0f, 1.0f, 1.0f, 0.65f);
int rt = righttext ? 0 : labels_width + 8;
glBegin(GL_QUADS);
glVertex2d(scale_x - b - rt, y0 + 5 + b);
glVertex2d(scale_x + scale_width + 8 + labels_width + b - rt, y0 + 5 + b);
glVertex2d(scale_x + scale_width + 8 + labels_width + b - rt, scale_y - 5 - b);
glVertex2d(scale_x - b - rt, scale_y - 5 - b);
glEnd();
// palette
glDisable(GL_BLEND);
glColor3f(0.0f, 0.0f, 0.0f);
glBegin(GL_QUADS);
glVertex2d(scale_x, scale_y);
glVertex2d(scale_x, scale_y + scale_height + 1);
glVertex2d(scale_x + scale_width + 1, scale_y + scale_height + 1);
glVertex2d(scale_x + scale_width + 1, scale_y);
glEnd();
glEnable(GL_TEXTURE_1D);
glBindTexture(GL_TEXTURE_1D, gl_pallete_tex_id);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
glBegin(GL_QUADS);
glTexCoord1d(tex_scale + tex_shift);
glVertex2d(scale_x + 1, scale_y + 1);
glVertex2d(scale_x + scale_width, scale_y + 1);
glTexCoord1d(tex_shift);
glVertex2d(scale_x + scale_width, scale_y + scale_height);
glVertex2d(scale_x + 1, scale_y + scale_height);
glEnd();
// focus
glDisable(GL_TEXTURE_1D);
if (scale_focused)
{
glEnable(GL_BLEND);
glColor4f(1.0f, 1.0f, 1.0f, 0.3f);
glBegin(GL_QUADS);
glVertex2d(scale_x + 1, scale_y + 1);
glVertex2d(scale_x + scale_width, scale_y + 1);
glVertex2d(scale_x + scale_width, scale_y + scale_height);
glVertex2d(scale_x + 1, scale_y + scale_height);
glEnd();
}
// ticks
glColor3f(0, 0, 0);
glDisable(GL_BLEND);
glDisable(GL_LINE_STIPPLE);
glLineWidth(1.0);
glBegin(GL_LINES);
for (i = 0; i < scale_numticks; i++)
{
y0 = scale_y + scale_height - (double) (i+1) * scale_height / (scale_numticks+1);
glVertex2d(scale_x, y0);
glVertex2d(scale_x + 0.2 * scale_width + 1, y0);
glVertex2d(scale_x + 0.8 * scale_width, y0);
glVertex2d(scale_x + scale_width, y0);
}
glEnd();
// labels
for (i = 0; i <= scale_numticks+1; i++)
{
double value = range_min + (double) i * (range_max - range_min) / (scale_numticks+1);
if (fabs(value) < 1e-8) value = 0.0;
char text[50];
sprintf(text, scale_fmt, value);
y0 = scale_y + scale_height - (double) i * scale_height / (scale_numticks+1);
if (righttext)
draw_text(scale_x + scale_width + 8, y0, text);
else
draw_text(scale_x - 8, y0, text, 1);
}
}
void View::draw_discrete_scale(int numboxes, const char* boxnames[], const float boxcolors[][3])
{
set_ortho_projection(true);
glDisable(GL_DEPTH_TEST);
glDisable(GL_LIGHTING);
glDisable(GL_TEXTURE_1D);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
// background
const int b = 5;
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glColor4f(1.0f, 1.0f, 1.0f, 0.65f);
glBegin(GL_QUADS);
glVertex2d(scale_x - b, scale_y - b);
glVertex2d(scale_x - b, scale_y + scale_height + b+1);
glVertex2d(scale_x + scale_width + b+1, scale_y + scale_height + b+1);
glVertex2d(scale_x + scale_width + b+1, scale_y - b);
glEnd();
// boxes
glDisable(GL_BLEND);
int y = scale_y;
for (int i = 0; i < numboxes; i++)
{
glColor3f(0.0, 0.0, 0.0);
glBegin(GL_QUADS);
glVertex2d(scale_x, y);
glVertex2d(scale_x, y + scale_box_height + 1);
glVertex2d(scale_x + scale_width + 1, y + scale_box_height + 1);
glVertex2d(scale_x + scale_width + 1, y);
glEnd();
const float* color = boxcolors[numboxes-1-i];
float bcolor[3] = { color[0], color[1], color[2] };
if (scale_focused) {
bcolor[0] = color[0]*0.7f + 1.0f*0.3f;
bcolor[1] = color[1]*0.7f + 1.0f*0.3f;
bcolor[2] = color[2]*0.7f + 1.0f*0.3f;
}
glColor3f(bcolor[0], bcolor[1], bcolor[2]);
glBegin(GL_QUADS);
glVertex2d(scale_x+1, y+1);
glVertex2d(scale_x+1, y + scale_box_height);
glVertex2d(scale_x + scale_width, y + scale_box_height);
glVertex2d(scale_x + scale_width, y+1);
glEnd();
if ((color[0] + color[1] + color[2]) / 3 > 0.5)
glColor3f(0, 0, 0);
else
glColor3f(1, 1, 1);
int a = scale_x + scale_width/2;
int b = y + scale_box_height/2;
draw_text(a, b, boxnames[numboxes-1-i], 0);
draw_text(a+1, b, boxnames[numboxes-1-i], 0);
y += scale_box_height + scale_box_skip;
}
}
static void display() {
totalVerts = 0;
glLoadIdentity();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glPushMatrix();
glRotatef(angle, 0, 0, 1);
glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, specLight); // Make sphere glow (emissive)
glLightfv(GL_LIGHT0, GL_POSITION, dirI );
glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, Noemit);
glPopMatrix();
// set camera viewpoint
camera_lookat();
center[0] = sphereCenter[0];
center[1] = sphereCenter[1];
center[2] = sphereCenter[2];
glColor3f(1.0, 1.0, 1.0);
draw_verts(center, 0, false, 0);//draw sphere
center[0] = 0;
center[1] = 0;
center[2] = 10.0;
draw_verts(center, 1, true, 3);//draw arena
center[0] = -18.5;
center[1] = 0;
center[2] = 0;
for(int i = 0; i < numOfBars; i++){//draw bars
barHeight = get_bar_height(center);
glColor3f(0.5, 0.1, barHeight/5);
draw_cube(center, 30/barHeight, 3, false);
center[0] += 4;
}
center[0] = actionCenter[0];
center[1] = actionCenter[1];
center[2] = actionCenter[2];
glColor3f(1.0, 1.0, 1.0);
draw_cube(center, .7, .7, true);//draw action block
center[0] = 18.5;
center[1] = 0.1;
center[2] = 3.0;
glColor3f(1.0, 1.0, 1.0);
draw_verts(center, 2, false, 0);//draw end 1
center[0] = -18.5;
draw_verts(center, 3, false, 0);//draw end 2
center[0] = 0;
center[1] = sphereCenter[1];
draw_verts(center, 5, false, 0);//draw bar
grid_terrain_draw(num_adj_levels);//draw terrain
glColor3f(0.5, 0.5, 0.5);
center[0] = -40;
glRotatef(rotation, 0, 1, 0);
draw_verts(center, 4, false, 0);//draw stands
glRotatef(90, 0, 1, 0);
draw_verts(center, 4, false, 0);//draw stands
glRotatef(90, 0, 1, 0);
draw_verts(center, 4, false, 0);
glRotatef(90, 0, 1, 0);
draw_verts(center, 4, false, 0);
center[1] = 15;
glColor3f(.4, .4, 1.0);
glutSolidSphere(50, 20, 10);
draw_diagnostics(fps_vertices);//draw text
if(display_help){
set_ortho_projection();
glparams_draw();
set_projection();
}
glFlush();
// increment frame count for framerate code
++frame_count;
}
void VectorView::on_display()
{
set_ortho_projection();
glDisable(GL_LIGHTING);
glDisable(GL_DEPTH_TEST);
glDisable(GL_TEXTURE_1D);
glPolygonMode(GL_FRONT_AND_BACK, pmode ? GL_LINE : GL_FILL);
// initial grid point and grid step
double gt = gs;
if (hexa) gt *= sqrt(3.0)/2.0;
double max_length = 0.0;
// transform all vertices
vec.lock_data();
int i;
int nv = vec.get_num_vertices();
double4* vert = vec.get_vertices();
double2* tvert = new double2[nv];
for (i = 0; i < nv; i++)
{
tvert[i][0] = transform_x(vert[i][0]);
tvert[i][1] = transform_y(vert[i][1]);
// find max length of vectors
double length = sqr(vert[i][2]) + sqr(vert[i][3]);
if (length > max_length) max_length = length;
}
max_length = sqrt(max_length);
// value range
double min = range_min, max = range_max;
if (range_auto) { min = vec.get_min_value(); max = vec.get_max_value(); }
double irange = 1.0 / (max - min);
// special case: constant solution
if (fabs(min - max) < 1e-8) { irange = 1.0; min -= 0.5; }
// draw all triangles
int3* xtris = vec.get_triangles();
if (mode != 1) glEnable(GL_TEXTURE_1D);
glBindTexture(GL_TEXTURE_1D, gl_pallete_tex_id);
glBegin(GL_TRIANGLES);
glColor3f(0.95f, 0.95f, 0.95f);
for (i = 0; i < vec.get_num_triangles(); i++)
{
double mag = sqrt(sqr(vert[xtris[i][0]][2]) + sqr(vert[xtris[i][0]][3]));
glTexCoord2d((mag -min) * irange * tex_scale + tex_shift, 0.0);
glVertex2d(tvert[xtris[i][0]][0], tvert[xtris[i][0]][1]);
mag = sqrt(sqr(vert[xtris[i][1]][2]) + sqr(vert[xtris[i][1]][3]));
glTexCoord2d((mag -min) * irange * tex_scale + tex_shift, 0.0);
glVertex2d(tvert[xtris[i][1]][0], tvert[xtris[i][1]][1]);
mag = sqrt(sqr(vert[xtris[i][2]][2]) + sqr(vert[xtris[i][2]][3]));
glTexCoord2d((mag -min) * irange * tex_scale + tex_shift, 0.0);
glVertex2d(tvert[xtris[i][2]][0], tvert[xtris[i][2]][1]);
}
glEnd();
glDisable(GL_TEXTURE_1D);
// draw all edges
/*if (mode == 0) glColor3f(0.3, 0.3, 0.3);
else*/ glColor3f(0.5, 0.5, 0.5);
glBegin(GL_LINES);
int3* edges = vec.get_edges();
for (i = 0; i < vec.get_num_edges(); i++)
{
if (lines || edges[i][2] != 0)
{
glVertex2d(tvert[edges[i][0]][0], tvert[edges[i][0]][1]);
glVertex2d(tvert[edges[i][1]][0], tvert[edges[i][1]][1]);
}
}
glEnd();
// draw dashed edges
if (lines)
{
glEnable(GL_LINE_STIPPLE);
glLineStipple(1, 0xCCCC);
glBegin(GL_LINES);
int2* dashes = vec.get_dashes();
for (i = 0; i < vec.get_num_dashes(); i++)
{
glVertex2d(tvert[dashes[i][0]][0], tvert[dashes[i][0]][1]);
glVertex2d(tvert[dashes[i][1]][0], tvert[dashes[i][1]][1]);
}
glEnd();
glDisable(GL_LINE_STIPPLE);
}
// draw arrows
if (mode != 2)
{
for (i = 0; i < vec.get_num_triangles(); i++)
{
double miny = 1e100;
int idx, k, l1, l2, r2, r1, s;
double lry, x;
double mr, ml, lx, rx, xval, yval;
double wh = output_height + gt, ww = output_width + gs;
if ((tvert[xtris[i][0]][0] < -gs) && (tvert[xtris[i][1]][0] < -gs) && (tvert[xtris[i][2]][0] < -gs)) continue;
if ((tvert[xtris[i][0]][0] > ww) && (tvert[xtris[i][1]][0] > ww) && (tvert[xtris[i][2]][0] > ww)) continue;
if ((tvert[xtris[i][0]][1] < -gt) && (tvert[xtris[i][1]][1] < -gt) && (tvert[xtris[i][2]][1] < -gt)) continue;
if ((tvert[xtris[i][0]][1] > wh) && (tvert[xtris[i][1]][1] > wh) && (tvert[xtris[i][2]][1] > wh)) continue;
// find vertex with min y-coordinate
for (k = 0; k < 3; k++)
if (tvert[xtris[i][k]][1] < miny)
miny = tvert[xtris[i][idx = k]][1];
l1 = r1 = xtris[i][idx];
l2 = xtris[i][n_vert(idx)];
r2 = xtris[i][p_vert(idx)];
// plane of x and y values on triangle
double a[2], b[2], c[2], d[2];
for (int n = 0; n < 2; n++)
{
a[n] = (tvert[l1][1] - tvert[l2][1])*(vert[r1][2 +n] - vert[r2][2+n]) - (vert[l1][2+n] - vert[l2][2+n])*(tvert[r1][1] - tvert[r2][1]);
b[n] = (vert[l1][2+n] - vert[l2][2+n])*(tvert[r1][0] - tvert[r2][0]) - (tvert[l1][0] - tvert[l2][0])*(vert[r1][2+n] - vert[r2][2+n]);
c[n] = (tvert[l1][0] - tvert[l2][0])*(tvert[r1][1] - tvert[r2][1]) - (tvert[l1][1] - tvert[l2][1])*(tvert[r1][0] - tvert[r2][0]);
d[n] = -a[n] * tvert[l1][0] - b[n] * tvert[l1][1] - c[n] * vert[l1][2+n];
a[n] /= c[n]; b[n] /= c[n]; d[n] /= c[n];
}
s = (int) ceil((tvert[l1][1] - gy)/gt); // first step
lry = gy + s*gt;
bool shift = hexa && (s & 1);
// if there are two points with min y-coordinate, switch to the next segment
if ((tvert[l1][1] == tvert[l2][1]) || (tvert[r1][1] == tvert[r2][1]))
if (tvert[l1][1] == tvert[l2][1])
{l1 = l2; l2 = r2;}
else if (tvert[r1][1] == tvert[r2][1])
{r1 = r2; r2 = l2;}
// slope of the left and right segment
ml = (tvert[l1][0] - tvert[l2][0])/(tvert[l1][1] - tvert[l2][1]);
mr = (tvert[r1][0] - tvert[r2][0])/(tvert[r1][1] - tvert[r2][1]);
// x-coordinates of the endpoints of the first line
lx = tvert[l1][0] + ml * (lry - (tvert[l1][1]));
rx = tvert[r1][0] + mr * (lry - (tvert[r1][1]));
if (lry < -gt)
{
k = (int) floor(-lry/gt);
lry += gt * k;
lx += k * ml * gt;
rx += k * mr * gt;
}
// while we are in triangle
while (((lry < tvert[l2][1]) || (lry < tvert[r2][1])) && (lry < wh))
{
// while we are in the segment
while (((lry <= tvert[l2][1]) && (lry <= tvert[r2][1])) && (lry < wh))
{
double gz = gx;
if (shift) gz -= 0.5*gs;
s = (int) ceil((lx - gz)/gs);
x = gz + s*gs;
if (hexa) shift = !shift;
if (x < -gs)
{
k = (int) floor(-x/gs);
x += gs * k;
}
// go along the line
while ((x < rx) && (x < ww))
{
// plot the arrow
xval = -a[0]*x - b[0]*lry - d[0];
yval = -a[1]*x - b[1]*lry - d[1];
plot_arrow(x, lry, xval, yval, max, min, gs);
x += gs;
}
// move to the next line
lx += ml*gt;
rx += mr*gt;
lry += gt;
}
// change segment
if (lry >= tvert[l2][1]) {
l1 = l2; l2 = r2;
ml = (tvert[l1][0] - tvert[l2][0])/(tvert[l1][1] - tvert[l2][1]);
lx = tvert[l1][0] + ml * (lry - (tvert[l1][1]));
}
else {
r1 = r2; r2 = l2;
mr = (tvert[r1][0] - tvert[r2][0])/(tvert[r1][1] - tvert[r2][1]);
rx = tvert[r1][0] + mr * (lry - (tvert[r1][1]));
}
}
}
}
delete [] tvert;
vec.unlock_data();
}
void OrderView::on_display()
{
set_ortho_projection();
glDisable(GL_TEXTURE_1D);
glDisable(GL_LIGHTING);
glDisable(GL_DEPTH_TEST);
// transform all vertices
ord.lock_data();
int i, nv = ord.get_num_vertices();
double3* vert = ord.get_vertices();
double2* tvert = malloc_with_check<double2>(nv);
for (i = 0; i < nv; i++)
{
tvert[i][0] = transform_x(vert[i][0]);
tvert[i][1] = transform_y(vert[i][1]);
}
// draw all triangles
int3* tris = ord.get_triangles();
glBegin(GL_TRIANGLES);
for (i = 0; i < ord.get_num_triangles(); i++)
{
const float* color = order_colors[(int)vert[tris[i][0]][2]];
glColor3f(color[0], color[1], color[2]);
glVertex2d(tvert[tris[i][0]][0], tvert[tris[i][0]][1]);
glVertex2d(tvert[tris[i][1]][0], tvert[tris[i][1]][1]);
glVertex2d(tvert[tris[i][2]][0], tvert[tris[i][2]][1]);
}
glEnd();
// draw all edges
if (pal_type == 0)
glColor3f(0.4f, 0.4f, 0.4f);
else if (pal_type == 1)
glColor3f(1.0f, 1.0f, 1.0f);
else
glColor3f(0.0f, 0.0f, 0.0f);
glBegin(GL_LINES);
int2* edges = ord.get_edges();
for (i = 0; i < ord.get_num_edges(); i++)
{
glVertex2d(tvert[edges[i][0]][0], tvert[edges[i][0]][1]);
glVertex2d(tvert[edges[i][1]][0], tvert[edges[i][1]][1]);
}
glEnd();
// draw labels
if (b_orders)
{
int* lvert;
char** ltext;
double2* lbox;
int nl = ord.get_labels(lvert, ltext, lbox);
for (i = 0; i < nl; i++)
if (lbox[i][0] * scale > get_text_width(ltext[i]) &&
lbox[i][1] * scale > 13)
{
//color = get_palette_color((vert[lvert[i]][2] - 1) / 9.0);
const float* color = order_colors[(int)vert[lvert[i]][2]];
if ((color[0] * 0.39f + color[1] * 0.50f + color[2] * 0.11f) > 0.5f)
glColor3f(0, 0, 0);
else
glColor3f(1, 1, 1);
draw_text(tvert[lvert[i]][0], tvert[lvert[i]][1], ltext[i], 0);
}
}
free_with_check(tvert);
ord.unlock_data();
}
