void draw_player( object * obj ) { vms_vector arrow_pos, head_pos; g3s_point sphere_point, arrow_point, head_point; // Draw Console player -- shaped like a ellipse with an arrow. g3_rotate_point(&sphere_point,&obj->pos); g3_draw_sphere(&sphere_point,obj->size); // Draw shaft of arrow vm_vec_scale_add( &arrow_pos, &obj->pos, &obj->orient.fvec, obj->size*3 ); g3_rotate_point(&arrow_point,&arrow_pos); g3_draw_line( &sphere_point, &arrow_point ); // Draw right head of arrow vm_vec_scale_add( &head_pos, &obj->pos, &obj->orient.fvec, obj->size*2 ); vm_vec_scale_add2( &head_pos, &obj->orient.rvec, obj->size*1 ); g3_rotate_point(&head_point,&head_pos); g3_draw_line( &arrow_point, &head_point ); // Draw left head of arrow vm_vec_scale_add( &head_pos, &obj->pos, &obj->orient.fvec, obj->size*2 ); vm_vec_scale_add2( &head_pos, &obj->orient.rvec, obj->size*(-1) ); g3_rotate_point(&head_point,&head_pos); g3_draw_line( &arrow_point, &head_point ); // Draw player's up vector vm_vec_scale_add( &arrow_pos, &obj->pos, &obj->orient.uvec, obj->size*2 ); g3_rotate_point(&arrow_point,&arrow_pos); g3_draw_line( &sphere_point, &arrow_point ); }
// render a bezier void herm_spline::herm_render(int divs, color *clc) { int idx; int s_idx; float inc = 1.0f / (float)divs; vertex a, b, c; vec3d pt, d_pt; // draw in red gr_set_color_fast(clc); // render each section for(idx=0; idx<num_pts-1; idx++){ // render this piece herm_get_point(&pt, 0.0f, idx); g3_rotate_vertex(&a, &pt); // draw the deriv herm_get_deriv(&d_pt, 0.0f, idx); vm_vec_add2(&d_pt, &pt); g3_rotate_vertex(&c, &d_pt); g3_draw_line(&a, &c); for(s_idx=1; s_idx<divs * 2; s_idx++){ // second point herm_get_point(&pt, (float)s_idx * inc, idx); // 2nd point on the line g3_rotate_vertex(&b, &pt); // draw the line g3_draw_line(&a, &b); // draw the deriv line herm_get_deriv(&d_pt, (float)s_idx * inc, idx); vm_vec_add2(&d_pt, &pt); g3_rotate_vertex(&c, &d_pt); g3_draw_line(&b, &c); // store b a = b; } } // draw the control points gr_set_color_fast(&Color_bright_green); for(idx=0; idx<num_pts; idx++){ g3_draw_sphere_ez(&pts[idx], 0.75f); } }
void HudGaugeRadarOrb::drawOutlines() { int i; vertex center; // vertex extents[6]; vertex proj_orb_lines_xy[NUM_ORB_RING_SLICES]; vertex proj_orb_lines_xz[NUM_ORB_RING_SLICES]; vertex proj_orb_lines_yz[NUM_ORB_RING_SLICES]; g3_start_instance_matrix(&vmd_zero_vector, &view_perturb, false); g3_start_instance_matrix(&vmd_zero_vector, &Player_obj->orient, false); g3_rotate_vertex(¢er, &vmd_zero_vector); g3_rotate_vertex(&proj_orb_lines_xy[0], &orb_ring_xy[0]); g3_rotate_vertex(&proj_orb_lines_yz[0], &orb_ring_yz[0]); g3_rotate_vertex(&proj_orb_lines_xz[0], &orb_ring_xz[0]); g3_project_vertex(¢er); gr_set_color(255,255,255); g3_draw_sphere(¢er, .05f); g3_project_vertex(&proj_orb_lines_xy[0]); g3_project_vertex(&proj_orb_lines_yz[0]); g3_project_vertex(&proj_orb_lines_xz[0]); for (i=1; i < NUM_ORB_RING_SLICES; i++) { g3_rotate_vertex(&proj_orb_lines_xy[i], &orb_ring_xy[i]); g3_rotate_vertex(&proj_orb_lines_yz[i], &orb_ring_yz[i]); g3_rotate_vertex(&proj_orb_lines_xz[i], &orb_ring_xz[i]); g3_project_vertex(&proj_orb_lines_xy[i]); g3_project_vertex(&proj_orb_lines_yz[i]); g3_project_vertex(&proj_orb_lines_xz[i]); gr_set_color(192,96,32); g3_draw_sphere(&proj_orb_lines_xy[i-1], .01f); g3_draw_sphere(&proj_orb_lines_xz[i-1], .01f); g3_draw_line(&proj_orb_lines_xy[i-1],&proj_orb_lines_xy[i]); g3_draw_line(&proj_orb_lines_xz[i-1],&proj_orb_lines_xz[i]); gr_set_color(112,16,192); g3_draw_sphere(&proj_orb_lines_yz[i-1], .01f); g3_draw_line(&proj_orb_lines_yz[i-1],&proj_orb_lines_yz[i]); } g3_done_instance(false); }
//deal with a clipped line bool must_clip_line(g3s_point *p0,g3s_point *p1,ubyte codes_or) { bool ret; if ((p0->p3_flags&PF_TEMP_POINT) || (p1->p3_flags&PF_TEMP_POINT)) ret = 0; //line has already been clipped, so give up else { clip_line(&p0,&p1,codes_or); ret = g3_draw_line(p0,p1); } //free temp points if (p0->p3_flags & PF_TEMP_POINT) free_temp_point(p0); if (p1->p3_flags & PF_TEMP_POINT) free_temp_point(p1); return ret; }
void HudGaugeRadarOrb::drawContact(vec3d *pnt, int rad) { vertex verts[2]; vec3d p; p=*pnt; vm_vec_normalize(&p); g3_rotate_vertex(&verts[0], &p); g3_project_vertex(&verts[0]); g3_rotate_vertex(&verts[1], pnt); g3_project_vertex(&verts[1]); float size = fl_sqrt(vm_vec_dist(&Orb_eye_position, pnt) * 8.0f); if (size < i2fl(rad)) size = i2fl(rad); if (rad == Radar_blip_radius_target) { g3_draw_sphere(&verts[1],size/100.0f); } else { g3_draw_sphere(&verts[1],size/300.0f); } g3_draw_line(&verts[0],&verts[1]); }
// Rotate and project points and draw a line. void rpd_line(vector *v0, vector *v1) { vertex tv0, tv1; g3_rotate_vertex(&tv0, v0); g3_rotate_vertex(&tv1, v1); g3_draw_line(&tv0, &tv1); }
// render a bezier void bez_spline::bez_render(int divs, color *c) { float inc; int idx; vertex a, b; vec3d pt; // bleh if(divs <= 0){ return; } inc = 1.0f / (float)divs; // draw in red gr_set_color_fast(c); // draw that many divisions bez_get_point(&pt, 0.0f); g3_rotate_vertex(&a, &pt); for(idx=1; idx<=divs; idx++){ // second point bez_get_point(&pt, (float)idx * inc); g3_rotate_vertex(&b, &pt); // draw the line g3_draw_line(&a, &b); // store b a = b; } // draw the control points gr_set_color_fast(&Color_bright_green); for(idx=0; idx<num_pts; idx++){ g3_draw_sphere_ez(&pts[idx], 0.75f); } }
void draw_line(int pnum0,int pnum1) { g3_draw_line(&Segment_points[pnum0],&Segment_points[pnum1]); }
void draw_all_edges(automap *am) { g3s_codes cc; int i,j,nbright; ubyte nfacing,nnfacing; Edge_info *e; vms_vector *tv1; fix distance; fix min_distance = 0x7fffffff; g3s_point *p1, *p2; nbright=0; for (i=0; i<=am->highest_edge_index; i++ ) { //e = &am->edges[Edge_used_list[i]]; e = &am->edges[i]; if (!(e->flags & EF_USED)) continue; if ( e->flags & EF_TOO_FAR) continue; if (e->flags&EF_FRONTIER) { // A line that is between what we have seen and what we haven't if ( (!(e->flags&EF_SECRET))&&(e->color==am->wall_normal_color)) continue; // If a line isn't secret and is normal color, then don't draw it } cc=rotate_list(2,e->verts); distance = Segment_points[e->verts[1]].p3_z; if (min_distance>distance ) min_distance = distance; if (!cc.uand) { //all off screen? nfacing = nnfacing = 0; tv1 = &Vertices[e->verts[0]]; j = 0; while( j<e->num_faces && (nfacing==0 || nnfacing==0) ) { #ifdef COMPACT_SEGS vms_vector temp_v; get_side_normal(&Segments[e->segnum[j]], e->sides[j], 0, &temp_v ); if (!g3_check_normal_facing( tv1, &temp_v ) ) #else if (!g3_check_normal_facing( tv1, &Segments[e->segnum[j]].sides[e->sides[j]].normals[0] ) ) #endif nfacing++; else nnfacing++; j++; } if ( nfacing && nnfacing ) { // a contour line am->drawingListBright[nbright++] = e-am->edges; } else if ( e->flags&(EF_DEFINING|EF_GRATE) ) { if ( nfacing == 0 ) { if ( e->flags & EF_NO_FADE ) gr_setcolor( e->color ); else gr_setcolor( gr_fade_table[e->color+256*8] ); g3_draw_line( &Segment_points[e->verts[0]], &Segment_points[e->verts[1]] ); } else { am->drawingListBright[nbright++] = e-am->edges; } } } } if ( min_distance < 0 ) min_distance = 0; // Sort the bright ones using a shell sort { int t; int i, j, incr, v1, v2; incr = nbright / 2; while( incr > 0 ) { for (i=incr; i<nbright; i++ ) { j = i - incr; while (j>=0 ) { // compare element j and j+incr v1 = am->edges[am->drawingListBright[j]].verts[0]; v2 = am->edges[am->drawingListBright[j+incr]].verts[0]; if (Segment_points[v1].p3_z < Segment_points[v2].p3_z) { // If not in correct order, them swap 'em t=am->drawingListBright[j+incr]; am->drawingListBright[j+incr]=am->drawingListBright[j]; am->drawingListBright[j]=t; j -= incr; } else break; } } incr = incr / 2; } } // Draw the bright ones for (i=0; i<nbright; i++ ) { int color; fix dist; e = &am->edges[am->drawingListBright[i]]; p1 = &Segment_points[e->verts[0]]; p2 = &Segment_points[e->verts[1]]; dist = p1->p3_z - min_distance; // Make distance be 1.0 to 0.0, where 0.0 is 10 segments away; if ( dist < 0 ) dist=0; if ( dist >= am->farthest_dist ) continue; if ( e->flags & EF_NO_FADE ) { gr_setcolor( e->color ); } else { dist = F1_0 - fixdiv( dist, am->farthest_dist ); color = f2i( dist*31 ); gr_setcolor( gr_fade_table[e->color+color*256] ); } g3_draw_line( p1, p2 ); } }
void ship_draw_shield( object *objp) { int model_num; int i; vec3d pnt; polymodel * pm; if (objp->flags & OF_NO_SHIELDS) return; Assert(objp->instance >= 0); model_num = Ship_info[Ships[objp->instance].ship_info_index].model_num; if ( Fred_running ) return; pm = model_get(model_num); if (pm->shield.ntris<1) return; // Scan all the triangles in the mesh. for (i=0; i<pm->shield.ntris; i++ ) { int j; vec3d gnorm, v2f, tri_point; vertex prev_pnt, pnt0; shield_tri *tri; tri = &pm->shield.tris[i]; if (i == Break_value) Int3(); // Hack! Only works for object in identity orientation. // Need to rotate eye position into object's reference frame. // Only draw facing triangles. vm_vec_rotate(&tri_point, &pm->shield.verts[tri->verts[0]].pos, &Eye_matrix); vm_vec_add2(&tri_point, &objp->pos); vm_vec_sub(&v2f, &tri_point, &Eye_position); vm_vec_unrotate(&gnorm, &tri->norm, &objp->orient); if (vm_vec_dot(&gnorm, &v2f) < 0.0f) { int intensity; intensity = (int) (Ships[objp->instance].shield_integrity[i] * 255); if (intensity < 0) intensity = 0; else if (intensity > 255) intensity = 255; gr_set_color(0, 0, intensity); // Process the vertices. // Note this rotates each vertex each time it's needed, very dumb. for (j=0; j<3; j++ ) { vertex tmp; // Rotate point into world coordinates vm_vec_unrotate(&pnt, &pm->shield.verts[tri->verts[j]].pos, &objp->orient); vm_vec_add2(&pnt, &objp->pos); // Pnt is now the x,y,z world coordinates of this vert. // For this example, I am just drawing a sphere at that // point. g3_rotate_vertex(&tmp, &pnt); if (j) g3_draw_line(&prev_pnt, &tmp); else pnt0 = tmp; prev_pnt = tmp; } g3_draw_line(&pnt0, &prev_pnt); } } }