void draw_found_segments(void)
{
int s;
gr_setcolor(FOUND_COLOR);
for (s=0; s<N_found_segs; s++)
if (Segments[Found_segs[s]].segnum != -1)
draw_segment(&Segments[Found_segs[s]]);
}
void draw_selected_segments(void)
{
int s;
gr_setcolor(SELECT_COLOR);
for (s=0; s<N_selected_segs; s++)
if (Segments[Selected_segs[s]].segnum != -1)
draw_segment(&Segments[Selected_segs[s]]);
}
void draw_group_segments(void)
{
int s;
if (current_group > -1) {
gr_setcolor(GROUP_COLOR);
for (s=0; s<GroupList[current_group].num_segments; s++)
if (Segments[GroupList[current_group].segments[s]].segnum != -1)
draw_segment(&Segments[GroupList[current_group].segments[s]]);
}
}
void
RenderObservationZone::Visit(const SectorZone& oz)
{
parms_sector(oz);
if (draw_style(!m_past)) {
draw_segment(oz.getStartRadial(), oz.getEndRadial());
draw_two_lines();
}
m_buffer.mix_copy();
}
inline void draw(const polygon<T,2>& polygon)
{
if (polygon.size() < 3) return;
std::size_t j = polygon.size() - 1;
for (std::size_t i = 0; i < polygon.size(); ++i)
{
draw_segment(polygon[i],polygon[j]);
j = i;
}
}
void draw_rx(const RX &rx){
glPushMatrix();
glLineWidth(1.5f);
glBegin(GL_LINES);
glColor3f (1.0f, .0f, 0.0f);
draw_segment(rx.pos,rx.pos+0.15*rx.x_v);
glColor3f (0.0f, 1.0f, 0.0f);
draw_segment(rx.pos,rx.pos+0.15*rx.y_v);
glColor3f (0.0f, 0.0f, 1.0f);
draw_segment(rx.pos-0.10*rx.z_v,rx.pos+0.20*rx.z_v);
glEnd();
glLineWidth(1.0f);
glColor3f (1.0f, 1.0f, 0.0f);
glTranslatef(rx.pos.x,rx.pos.y,rx.pos.z);
glutSolidSphere(0.1, 20, 20);
glPopMatrix();
}
void
RenderObservationZone::Visit(const BGAEnhancedOptionZone& oz)
{
parms_sector(oz);
if (draw_style(false)) {
draw_segment(oz.getStartRadial(), oz.getEndRadial());
p_radius = m_proj.DistanceMetersToScreen(fixed(500));
draw_circle();
}
if (draw_style(!m_past)) {
draw_two_lines();
}
m_buffer.mix_copy();
}
void R_s_k_2::draw_edge_with_arrow(const Point& s, const Point& t)
{
Vector vec = t - s;
Vector vec90(-vec.y(),vec.x());
// draw edge
draw_segment(s, t);
// draw an arrow toward merged vertex
Point a = t - 0.4 * vec;
Point b = a - 0.2 * vec - 0.1 * vec90;
Point c = a - 0.2 * vec + 0.1 * vec90;
viewer->glBegin(GL_TRIANGLES);
viewer->glVertex2d(a.x(), a.y());
viewer->glVertex2d(b.x(), b.y());
viewer->glVertex2d(c.x(), c.y());
viewer->glEnd();
}
static void draw_drive(lemuria_engine_t * e, void * user_data)
{
int index_1;
int index_2;
int i;
float delta_phi;
float angle;
float speed;
float speed_norm;
drive_data * d = (drive_data*)(user_data);
lemuria_range_update(&(d->curvature_range));
lemuria_range_update(&(d->speed_range));
/* Change stuff */
lemuria_range_get(&(d->speed_range),
&(d->speed_start),
&(d->speed_end),
&speed);
speed_norm = speed / SPEED_MAX;
// fprintf(stderr, "Speed: %f speed_max: %f (Speed/speed_max)^2: %f\n",
// speed, SPEED_MAX, speed_norm * speed_norm);
// fprintf(stderr, "Speed: %f %f\n", speed, SPEED_MAX);
if(e->quiet)
{
d->speed_start = speed;
d->speed_end = SPEED_MIN;
lemuria_range_init(e, &(d->speed_range),
1, 100, 200);
}
else if(e->beat_detected)
{
if(lemuria_range_done(&(d->speed_range)) &&
lemuria_decide(e, 0.2))
{
d->speed_start = d->speed_end;
d->speed_end =
SPEED_MIN + (lemuria_random(e, 0.0, 0.5) +
0.5 * (float)e->loudness/32768.0)*(SPEED_MAX - SPEED_MIN);
lemuria_range_init(e, &(d->speed_range),
1, 100, 200);
}
if(lemuria_range_done(&(d->curvature_range)) &&
lemuria_decide(e, 0.2))
{
d->delta_phi_start = d->delta_phi_end;
// if(d->delta_phi_end > 0.0)
if(lemuria_decide(e, 0.3))
d->delta_phi_end = 0.0;
else
{
// d->delta_phi_end = lemuria_random(DELTA_PHI_MIN, DELTA_PHI_MAX);
d->delta_phi_end =
DELTA_PHI_MIN +
(lemuria_random(e, 0.0, 0.5) +
0.5 * (float)e->loudness / 32768.0)*(DELTA_PHI_MAX - DELTA_PHI_MIN);
if(lemuria_decide(e, 0.5))
d->delta_phi_end *= -1.0;
}
// fprintf(stderr, "New phi: %f\n", d->delta_phi_end * 180.0 / M_PI);
lemuria_range_init(e, &(d->curvature_range), 2, 50, 100);
}
}
/* Create new rings if necessary */
d->z_start += speed;
lemuria_range_get(&(d->curvature_range),
&(d->delta_phi_start),
&(d->delta_phi_end),
&delta_phi);
if(fabs(delta_phi) < DELTA_PHI_MIN)
delta_phi = 0.0;
while(d->z_start >= DELTA_Z)
{
d->segments[d->start_segment].delta_phi = delta_phi;
d->texture_y += TEXTURE_DELTA_Y;
d->segments[d->start_segment].texture_y_before = d->texture_y;
if(d->texture_y > 1.0)
d->texture_y -= 1.0;
d->segments[d->start_segment].texture_y_after = d->texture_y;
d->start_segment++;
if(d->start_segment >= NUM_SEGMENTS)
d->start_segment = 0;
d->z_start -= DELTA_Z;
}
update_coords(d);
/* Set up Opengl */
glClearColor(0.0, 0.0, 0.0, 0.0);
// glDisable(GL_DEPTH_TEST);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
lemuria_set_perspective(e, 1, 1000.0);
/* Set up light and materials */
#ifndef DRAW_MESH
glShadeModel(GL_SMOOTH);
#endif
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
index_1 = d->start_segment;
index_2 = index_1 + 1;
if(index_2 >= NUM_SEGMENTS)
index_2 = 0;
/* Do curvature transformation */
angle =
atan2(20.0 * (speed_norm * speed_norm) * d->segments[d->start_segment].delta_phi,
DELTA_PHI_MAX);
/* / (SPEED_MAX * SPEED_MAX) */
d->angle = 0.8 * d->angle + 0.2 * angle;
/* */
glTranslatef(0.0, SEGMENT_RADIUS - CAMERA_HEIGHT, 0.0);
glRotatef(d->angle * 180.0 / M_PI, 0.0, 0.0, 1.0);
glTranslatef(0.0, CAMERA_HEIGHT - SEGMENT_RADIUS, 0.0);
#ifndef DRAW_MESH
draw_sky(d, 0.0);
glFogi(GL_FOG_MODE, GL_LINEAR );
glFogfv(GL_FOG_COLOR, fog_color);
glFogf(GL_FOG_START, FOG_START);
glFogf(GL_FOG_END, FOG_END);
glEnable(GL_FOG);
/* We set the light after we rotated stuff */
lemuria_set_material(&material, GL_FRONT);
glEnable(GL_LIGHTING);
lemuria_background_set(&(d->drive_background));
lemuria_set_light(&light_0, GL_LIGHT0);
glEnable(GL_LIGHT0);
glEnable(GL_TEXTURE_2D);
#endif
// lemuria_set_light(&light_1, GL_LIGHT1);
// glEnable(GL_LIGHT1);
// fprintf(stderr, "Segments: %d %d\n", d->start_segment, d->end_segment);
for(i = 0; i < NUM_SEGMENTS-1; i++)
{
draw_segment(d, index_1, index_2);
if(index_2 == d->end_segment)
break;
index_1++;
if(index_1 >= NUM_SEGMENTS)
index_1 = 0;
index_2++;
if(index_2 >= NUM_SEGMENTS)
index_2 = 0;
}
glPopMatrix();
glDisable(GL_TEXTURE_2D);
glDisable(GL_LIGHTING);
glDisable(GL_LIGHT0);
glDisable(GL_LIGHT1);
glDisable(GL_FOG);
}
void draw_world(grs_canvas *screen_canvas,editor_view *v,segment *mine_ptr,int depth)
{
vms_vector viewer_position;
#if DOUBLE_BUFFER
grs_canvas temp_canvas;
// mprintf(0, "\n");
// if ( screen_canvas == LargeViewBox->canvas ) {
// CurrentBigCanvas ^= 1;
//
// gr_set_current_canvas( BigCanvas[CurrentBigCanvas] );
//
// } else {
gr_init_sub_canvas(&temp_canvas,canv_offscreen,0,0,
screen_canvas->cv_bitmap.bm_w,screen_canvas->cv_bitmap.bm_h);
gr_set_current_canvas(&temp_canvas);
// }
#else
gr_set_current_canvas(screen_canvas);
#endif
//mprintf(0, "\n");
ui_mouse_hide();
//g3_set_points(Segment_points,Vertices);
viewer_position = v->ev_matrix.fvec;
vm_vec_scale(&viewer_position,-v->ev_dist);
vm_vec_add2(&viewer_position,&Ed_view_target);
gr_clear_canvas(0);
g3_start_frame();
g3_set_view_matrix(&viewer_position,&v->ev_matrix,v->ev_zoom);
render_start_frame();
gr_setcolor(PLAINSEG_COLOR);
// Draw all segments or only connected segments.
// We might want to draw all segments if we have broken the mine into pieces.
if (Draw_all_segments)
draw_mine_all(Segments, Automap_test);
else
draw_mine(mine_ptr,depth);
// Draw the found segments
if (!Automap_test) {
draw_warning_segments();
draw_group_segments();
draw_found_segments();
draw_selected_segments();
draw_special_segments();
// Highlight group segment and side.
if (current_group > -1)
if (Groupsegp[current_group]) {
gr_setcolor(GROUPSEG_COLOR);
draw_segment(Groupsegp[current_group]);
gr_setcolor(GROUPSIDE_COLOR);
draw_seg_side(Groupsegp[current_group],Groupside[current_group]);
}
// Highlight marked segment and side.
if (Markedsegp) {
gr_setcolor(MARKEDSEG_COLOR);
draw_segment(Markedsegp);
gr_setcolor(MARKEDSIDE_COLOR);
draw_seg_side(Markedsegp,Markedside);
}
// Highlight current segment and current side.
gr_setcolor(CURSEG_COLOR);
draw_segment(Cursegp);
gr_setcolor(CURSIDE_COLOR);
draw_seg_side(Cursegp,Curside);
gr_setcolor(CUREDGE_COLOR);
draw_side_edge(Cursegp,Curside,Curedge);
// Draw coordinate axes if we are rendering the large view.
if (Show_axes_flag)
if (screen_canvas == LargeViewBox->canvas)
draw_coordinate_axes();
// Label the window
gr_set_fontcolor((v==current_view)?CRED:CWHITE, -1 );
if ( screen_canvas == LargeViewBox->canvas ) {
gr_ustring( 5, 5, "USER VIEW" );
switch (Large_view_index) {
case 0: gr_ustring( 85, 5, "-- TOP"); break;
case 1: gr_ustring( 85, 5, "-- FRONT"); break;
case 2: gr_ustring( 85, 5, "-- RIGHT"); break;
}
} else
#if ORTHO_VIEWS
else if ( screen_canvas == TopViewBox->canvas )
gr_ustring( 5, 5, "TOP" );
else if ( screen_canvas == FrontViewBox->canvas )
gr_ustring( 5, 5, "FRONT" );
else if ( screen_canvas == RightViewBox->canvas )
gr_ustring( 5, 5, "RIGHT" );
#else
Error("Ortho views have been removed, what gives?\n");
#endif
}
void Renderer2d::draw_segment(const math::VectorPair3 &l, const Rgb &rgb)
{
draw_segment(math::VectorPair2(project(l[0]), project(l[1])), rgb);
}
inline void draw(const segment<T,2>& segment) { draw_segment(segment[0],segment[1]); }
inline void draw_segment(const point2d<T>& point1, const point2d<T>& point2) const
{
draw_segment(point1.x,point1.y,point2.x,point2.y);
}
