void draw_princess_room_stars (ALLEGRO_BITMAP *bitmap, enum vm vm) { int i, min_x = INT_MAX, min_y = INT_MAX, max_x = INT_MIN, max_y = INT_MIN; static struct star s[6] = { {20,97,0}, {16,104,1}, {23,110,0}, {17,116,1}, {24,120,2}, {18,128,2}}; static struct stars stars = {.b = NULL, .s = s, .count = 6}; if (! stars.b) { for (i = 0; i < 6; i++) { min_x = min_int (min_x, stars.s[i].x); min_y = min_int (min_y, stars.s[i].y); max_x = max_int (max_x, stars.s[i].x); max_y = max_int (max_y, stars.s[i].y); } stars.b = create_bitmap (max_x - min_x + 1, max_y - min_y + 1); clear_bitmap (stars.b, TRANSPARENT_COLOR); stars.c.x = min_x; stars.c.y = min_y; redraw_stars_bitmap (&stars, vm); } if (vm != mr.last.vm) redraw_stars_bitmap (&stars, vm); draw_stars (bitmap, &stars, vm); } void draw_balcony_stars (ALLEGRO_BITMAP *bitmap, struct pos *p, enum vm vm) { if (con (p)->bg != BALCONY) return; struct pos np; npos (p, &np); if (! np.room) return; struct stars *stars = &mr.cell[mr.dx][mr.dy].stars[np.floor][np.place]; if (vm != mr.last.vm) redraw_stars_bitmap (stars, vm); draw_stars (bitmap, stars, vm); } static struct star * star_coord (struct pos *p, int i, struct star *s) { s->x = PLACE_WIDTH * p->place + 16 + prandom_pos_uniq (p, 2 * i, 1, 28); s->y = PLACE_HEIGHT * p->floor - 3 + prandom_pos_uniq (p, 2 * i + 1, 1, 21); return s; }
void draw_princess_room_stars (ALLEGRO_BITMAP *bitmap, enum vm vm) { int i, min_x = INT_MAX, min_y = INT_MAX, max_x = INT_MIN, max_y = INT_MIN; static struct star s[6] = { {20,97,0}, {16,104,1}, {23,110,0}, {17,116,1}, {24,120,2}, {18,128,2}}; static struct stars_bitmap sb = {.b = NULL}; if (! sb.b) { for (i = 0; i < 6; i++) { min_x = min_int (min_x, s[i].x); min_y = min_int (min_y, s[i].y); max_x = max_int (max_x, s[i].x); max_y = max_int (max_y, s[i].y); } sb.b = create_bitmap (max_x - min_x + 1, max_y - min_y + 1); clear_bitmap (sb.b, TRANSPARENT_COLOR); sb.c.x = min_x; sb.c.y = min_y; redraw_stars_bitmap (&s[0], &sb, 6, vm); } if (vm != last_vm) { redraw_stars_bitmap (&s[0], &sb, 6, vm); last_vm = vm; } draw_stars (bitmap, s, &sb, 6, vm); }
render_external_scene(fix eye_offset) { Viewer_eye = Viewer->pos; if (eye_offset) vm_vec_scale_add2(&Viewer_eye,&Viewer->orient.rvec,eye_offset); g3_set_view_matrix(&Viewer->pos,&Viewer->orient,Render_zoom); //g3_draw_horizon(BM_XRGB(0,0,0),BM_XRGB(16,16,16)); //,-1); gr_clear_canvas(BM_XRGB(0,0,0)); g3_start_instance_matrix(&vmd_zero_vector,&surface_orient); draw_stars(); g3_done_instance(); { //draw satellite vms_vector delta; g3s_point p,top_pnt; g3_rotate_point(&p,&satellite_pos); g3_rotate_delta_vec(&delta,&satellite_upvec); g3_add_delta_vec(&top_pnt,&p,&delta); if (! (p.p3_codes & CC_BEHIND)) { int save_im = Interpolation_method; //p.p3_flags &= ~PF_PROJECTED; //g3_project_point(&p); if (! (p.p3_flags & PF_OVERFLOW)) { Interpolation_method = 0; //gr_bitmapm(f2i(p.p3_sx)-32,f2i(p.p3_sy)-32,satellite_bitmap); g3_draw_rod_tmap(satellite_bitmap,&p,SATELLITE_WIDTH,&top_pnt,SATELLITE_WIDTH,f1_0); Interpolation_method = save_im; } } } #ifdef STATION_ENABLED draw_polygon_model(&station_pos,&vmd_identity_matrix,NULL,station_modelnum,0,f1_0,NULL,NULL); #endif render_terrain(&mine_ground_exit_point,exit_point_bmx,exit_point_bmy); draw_exit_model(); if (ext_expl_playing) draw_fireball(&external_explosion); Lighting_on=0; render_object(ConsoleObject); Lighting_on=1; }
int main(void){ init_allegro(); bool redraw = true; bool done = false; al_clear_to_color(al_map_rgb(0,0,0)); al_flip_display(); al_start_timer(timer); init_stars(); while(!done){ ALLEGRO_EVENT event; al_wait_for_event(event_queue, &event); switch (event.type) { case ALLEGRO_EVENT_TIMER: redraw = true; break; case ALLEGRO_EVENT_DISPLAY_CLOSE: done = true; break; case ALLEGRO_EVENT_KEY_UP: switch(event.keyboard.keycode){ case ALLEGRO_KEY_MINUS: // decrease velocity of each plane velocity_1-=1; velocity_2-=2; velocity_3-=3; break; case ALLEGRO_KEY_EQUALS: // decrease velocity of each plane velocity_1+=1; velocity_2+=2; velocity_3+=3; break; case ALLEGRO_KEY_Q: done = true; break; } } if(redraw && al_is_event_queue_empty(event_queue)) { redraw = false; draw_stars(); } } return 0; }
// Draw background image with parallax effect void draw_backdrop(void) { SDL_Rect position; if (g_backdropy < 0) { g_backdropy += BACKDROP_SPEED; } position.x = g_backdropx; position.y = g_backdropy; SDL_BlitSurface(g_backdrop_img, NULL, screen, &position); draw_stars(); }
/* Draw the level for all players */ static inline void draw_level (void) { int p; for (p = 0; p < 4; p++) { if (players[p].state==ALIVE || players[p].state==DEAD) { SDL_BlitSurface (lev_level.terrain, &cam_rects[p], screen, &viewport_rects[p]); if(level_settings.stars) draw_stars (&cam_rects[p], &viewport_rects[p]); } } }
void draw_balcony_stars (ALLEGRO_BITMAP *bitmap, struct pos *p, enum vm vm) { if (con (p)->bg != BALCONY) return; if (vm != last_vm) { redraw_stars_bitmap (star[p->floor + 1][p->place + 1], &stars_bitmap [p->floor + 1][p->place + 1], STARS, vm); last_vm = vm; } draw_stars (bitmap, star[p->floor + 1][p->place + 1], &stars_bitmap [p->floor + 1][p->place + 1], STARS, vm); }
static void draw_scene() { // stars: to simulate infinite distance, // translate the sphere of stars to the eye // and perform the arcball rotation around the eye // (also disable depth test so they become the background) glPushMatrix(); glDisable( GL_DEPTH_TEST ); glTranslatef( eye.x, eye.y, eye.z ); arcball_rotate(); draw_stars(); glEnable( GL_DEPTH_TEST ); glPopMatrix(); // now render the regular scene under the arcball rotation about 0,0,0 // (generally you would want to render everything here) arcball_rotate(); draw_sphere(); }
ENTRYPOINT void draw_planet (ModeInfo * mi) { planetstruct *gp = &planets[MI_SCREEN(mi)]; Display *display = MI_DISPLAY(mi); Window window = MI_WINDOW(mi); double x, y, z; if (!gp->glx_context) return; glDrawBuffer(GL_BACK); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glXMakeCurrent (display, window, *(gp->glx_context)); mi->polygon_count = 0; if (do_stars) { draw_stars (mi); mi->polygon_count += NUM_STARS; } if (do_light) glEnable(GL_LIGHTING); if (do_texture) glEnable(GL_TEXTURE_2D); glEnable (GL_LINE_SMOOTH); glEnable(GL_DEPTH_TEST); glEnable(GL_CULL_FACE); glCullFace(GL_BACK); glPushMatrix(); get_position (gp->rot, &x, &y, &z, !gp->button_down_p); glTranslatef((x - 0.5) * 15, (y - 0.5) * 15, (z - 0.5) * 8); /* Do it twice because we don't track the device's orientation. */ glRotatef( current_device_rotation(), 0, 0, 1); gltrackball_rotate (gp->trackball); glRotatef(-current_device_rotation(), 0, 0, 1); glRotatef (90,1,0,0); if (do_roll) { get_rotation (gp->rot, &x, &y, 0, !gp->button_down_p); glRotatef (x * 360, 1.0, 0.0, 0.0); glRotatef (y * 360, 0.0, 1.0, 0.0); } glLightfv (GL_LIGHT0, GL_POSITION, gp->sunpos); glRotatef (gp->z * 360, 0.0, 0.0, 1.0); if (do_rotate && !gp->button_down_p) { gp->z -= 0.005; /* the sun sets in the west */ if (gp->z < 0) gp->z += 1; } glCallList (gp->platelist); mi->polygon_count += resolution*resolution; if (gp->button_down_p) { glCallList (gp->latlonglist); mi->polygon_count += 24*24; } glPopMatrix(); if (mi->fps_p) do_fps (mi); glFinish(); glXSwapBuffers(display, window); gp->star_theta += star_spin; }
ENTRYPOINT void draw_sws (ModeInfo *mi) { sws_configuration *sc = &scs[MI_SCREEN(mi)]; /* XtAppContext app = XtDisplayToApplicationContext (sc->dpy);*/ Display *dpy = MI_DISPLAY(mi); Window window = MI_WINDOW(mi); int i; if (!sc->glx_context) return; glDrawBuffer (GL_BACK); glXMakeCurrent (dpy, window, *(sc->glx_context)); glClear (GL_COLOR_BUFFER_BIT); draw_stars (mi); glMatrixMode (GL_MODELVIEW); glPushMatrix (); # ifdef USE_IPHONE /* Need to do this every time to get device rotation right */ reshape_sws (mi, MI_WIDTH(mi), MI_HEIGHT(mi)); # endif if (debug_p) { int i; glPushMatrix (); if (textures_p) glDisable (GL_TEXTURE_2D); glLineWidth (1); glTranslatef (0,-1, 0); glColor3f(1, 0, 0); /* Red line is where text appears */ glPushMatrix(); glTranslatef(0, -0.028, 0); glLineWidth (4); glBegin(GL_LINES); glVertex3f(-0.5, 1, 0); glVertex3f( 0.5, 1, 0); glVertex3f(-0.5, -1, 0); glVertex3f( 0.5, -1, 0); glEnd(); glLineWidth (1); glPopMatrix(); glColor3f (0.4, 0.4, 0.4); for (i = 0; i < 16; i++) { box (1, 1, 1); grid (1, 1, sc->char_width * sc->font_scale, sc->line_height, 0); glTranslatef(0, 1, 0); } if (textures_p) glEnable (GL_TEXTURE_2D); glPopMatrix (); } /* Scroll to current position */ glTranslatef (0.0, sc->intra_line_scroll, 0.0); glColor3f (1.0, 1.0, 0.4); glCallList (sc->text_list); mi->polygon_count = sc->polygon_count; sc->intra_line_scroll += sc->line_height / scroll_steps; if (sc->intra_line_scroll >= sc->line_height) { sc->intra_line_scroll = 0; /* Drop the oldest line off the end. */ if (sc->lines[0]) free (sc->lines[0]); /* Scroll the contents of the lines array toward 0. */ if (sc->total_lines > 0) { for (i = 1; i < sc->total_lines; i++) sc->lines[i-1] = sc->lines[i]; sc->lines[--sc->total_lines] = 0; } /* Bring in new lines at the end. */ get_more_lines (sc); if (sc->total_lines < max_lines) /* Oops, we ran out of text... well, insert some blank lines here so that new text still pulls in from the bottom of the screen, isntead of just appearing. */ sc->total_lines = max_lines; glDeleteLists (sc->text_list, 1); sc->text_list = glGenLists (1); glNewList (sc->text_list, GL_COMPILE); sc->polygon_count = 0; glPushMatrix (); glScalef (sc->font_scale, sc->font_scale, sc->font_scale); for (i = 0; i < sc->total_lines; i++) { double fade = (fade_p ? 1.0 * i / sc->total_lines : 1.0); int offscreen_lines = 2; double x = -0.5; double y = ((sc->total_lines - (i + offscreen_lines) - 1) * sc->line_height); double xoff = 0; char *line = sc->lines[i]; if (debug_p) { double xx = x * 1.4; /* a little more to the left */ char n[20]; sprintf(n, "%d:", i); draw_string (sc, xx / sc->font_scale, y / sc->font_scale, n); } if (!line || !*line) continue; if (sc->line_thickness != 1 && !textures_p) { int max_thick_lines = MAX_THICK_LINES; GLfloat thinnest_line = 1.0; GLfloat thickest_line = sc->line_thickness; GLfloat range = thickest_line - thinnest_line; GLfloat thickness; int j = sc->total_lines - i - 1; if (j > max_thick_lines) thickness = thinnest_line; else thickness = (thinnest_line + (range * ((max_thick_lines - j) / (GLfloat) max_thick_lines))); glLineWidth (thickness); } if (alignment >= 0) { int n = string_width (sc, line); xoff = 1.0 - (n * sc->font_scale); } if (alignment == 0) xoff /= 2; glColor3f (fade, fade, 0.5 * fade); draw_string (sc, (x + xoff) / sc->font_scale, y / sc->font_scale, line); if (textures_p) sc->polygon_count += strlen (line); } glPopMatrix (); glEndList (); } glPopMatrix (); if (mi->fps_p) do_fps (mi); glFinish(); glXSwapBuffers(dpy, window); sc->star_theta += star_spin; }
int main (int argc, char* args[]) { //SDL Window setup if (init(SCREEN_WIDTH, SCREEN_HEIGHT) == 1) { return 0; } init_stars(snow, SCREEN_WIDTH, SCREEN_HEIGHT); //create circle image in pixel buffer and copy to a texture draw_circle(&vb, vb.width / 2, vb.height / 2, 8, 0xffffffff); SDL_UpdateTexture(vector_ball, NULL, vb.pixels, vb.width * sizeof (uint32_t)); int sleep = 0; int quit = 0; struct vector3d vel = {0, 0, -.005}; //snow movment vector Uint32 next_game_tick = SDL_GetTicks(); Uint32 current_tick = next_game_tick; //render loop while(quit == 0) { //check for new events every frame SDL_PumpEvents(); const Uint8 *state = SDL_GetKeyboardState(NULL); if (state[SDL_SCANCODE_ESCAPE]) { quit = 1; } clear_pixels(&pb, 0x00000000); SDL_UpdateTexture(screen, NULL, pb.pixels, pb.width * sizeof (uint32_t)); //draw to the screen SDL_RenderClear(renderer); SDL_RenderCopy(renderer, screen, NULL, NULL); //draw screen pixel_buffer draw_stars(renderer, vector_ball, snow); //draw all snow flakes with vector ball texture SDL_RenderPresent(renderer); //show fintal frame on the screen update_stars(snow, SCREEN_WIDTH, SCREEN_HEIGHT, &vel); //time it takes to render 1 frame in milliseconds next_game_tick += 1000 / 60; current_tick = SDL_GetTicks(); sleep = next_game_tick - current_tick; if( sleep >= 0 ) { SDL_Delay(sleep); } } //free the screen buffer free(pb.pixels); //free the vector_ball buffer free(vb.pixels); //free the source image SDL_FreeSurface(source); //Destroy window SDL_DestroyWindow(window); //Quit SDL subsystems SDL_Quit(); return 0; }
//funkce pro kresleni void draw_game() { float t; draw_stars(); draw_enemies(); draw_bullets(); draw_particles(); draw_bonuses(); //mod pro koncovy screen hry if (playerdead) { //smesovani barev glEnable(GL_BLEND); //vyber blendovaci funkce glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); //zesednuti pozadi glColor4f(0, 0, 0, 0.6); glBegin(GL_QUADS); glVertex2f(-250, -350); glVertex2f(250, -350); glVertex2f(250, 350); glVertex2f(-250, 350); glEnd(); glDisable(GL_BLEND); //kresleni statistik hry na konci hry glPushMatrix(); glTranslatef(-240, 0, 0); glScalef(18, 18, 0); glColor3f(0, 1, 0); glPushMatrix(); glTranslatef(2, 5, 0); glScalef(4, 4, 0); draw_string("GAME OVER"); glColor3f(1, 1, 1); glTranslatef(0.03, 0.03, 0); draw_string("GAME OVER"); glPopMatrix(); draw_string("LEVEL"); glTranslatef(3.5, 0, 0); draw_int(level); glTranslatef(-3.5, -1, 0); draw_string("SCORE"); glTranslatef(3.5, 0, 0); draw_int(score); glTranslatef(-3.5, -5, 0); glPushMatrix(); glTranslatef(0.3, -4, 0); glScalef(2, 2, 0); glColor3f(0, 1, 0); draw_string("PRESS FIRE TO RESTART"); glPopMatrix(); glPopMatrix(); } else { //statistika hry v levem spodnim rohu glPushMatrix(); glTranslatef(-240, -305, 0); glScalef(18, 18, 1); glColor3f(0, 1, 0); draw_string("POWER"); glTranslatef(3.5, 0, 0); draw_int(plevel); glTranslatef(-3.5, -1, 0); draw_string("LEVEL"); glTranslatef(3.5, 0, 0); draw_int(level); glTranslatef(-3.5, -1, 0); draw_string("SCORE"); glTranslatef(3.5, 0, 0); draw_int(score); glPopMatrix(); glTranslatef(posx, posy, 0); //raketka glBegin(GL_TRIANGLES); glColor3f(0, 0, 1); glVertex2f(-20, -10); glColor3f(0.5, 0.5, 1); glVertex2f(0, 0); glVertex2f(0, 50); glVertex2f(0, 50); glVertex2f(0, 0); glColor3f(0, 0, 1); glVertex2f(20, -10); glColor3f(1, 0, 0); glVertex2f(0, 0); glColor3f(1, 1, 0); glVertex2f(-2.5, -6); glVertex2f(2.5, -6); glEnd(); //pokud hrac sebere stitovy bonus if (shieldtimer>0) { //poslednich 5 vterin stit blika if (shieldtimer<5) t=sinf(shieldtimer*20); else t=1; glColor3f(0.3*t*t, 0.3*t*t, 0.6*t*t); //nakresleni trojuhelnikoveho stitu glBegin(GL_LINE_LOOP); glVertex2f(0, 55); glVertex2f(-25, -15); glVertex2f(25, -15); glEnd(); } } }
int main(int argc, char *argv[]) { unsigned row, col, core; e_platform_t platform; e_epiphany_t dev; int all_done, core_done; int i, x, y; int res; unsigned int *fp; fb = open(FB, O_RDWR); if (fb == -1) { perror("Unable to open fb " FB); return 1; } // rest here res = ioctl(fb, FBIOGET_FSCREENINFO, &fix); if (res != 0) { perror("getscreeninfo failed"); close(fb); return 1; } //printf("framebuffer size %d @ %08x\n", fix.smem_len, fix.smem_start); res = ioctl(fb, FBIOGET_VSCREENINFO, &var); if (res != 0) { perror("getscreeninfo failed"); close(fb); return 1; } //printf("size %dx%d @ %d bits per pixel\n", var.xres_virtual, var.yres_virtual, var.bits_per_pixel); fp = mmap(NULL, fix.smem_len, O_RDWR, MAP_SHARED, fb, 0); if (fp == (void *)-1) { perror("mmap failed"); close(fb); return 1; } //printf("virtual @ %p\n", fp); int stride = var.xres_virtual; srand(time(NULL)); int nBodies = 30000; int startFlag = 0x00000001; int iters = 5000; // simulation iterations const float dt = 0.05f; // time step if (argc > 1) nBodies = atoi(argv[1]); if (argc > 2) iters = atoi(argv[2]); Body *buf = (Body *) malloc(sizeof(Body) * nBodies); Body *bufOutput = (Body *) malloc(sizeof(Body) * nBodies); randomizeBodies(buf, nBodies); // Init pos / vel data e_init(NULL); e_reset_system(); e_get_platform_info(&platform); e_open(&dev, 0, 0, 4, 4); e_reset_group(&dev); e_load_group("e_rob_nbody.srec", &dev, 0, 0, 4, 4, E_FALSE); for (row = 0; row < platform.rows; row++){ for (col = 0; col < platform.cols; col++){ e_write(&dev, row, col, 0x00000004, &nBodies, sizeof(int)); } } e_write(&dev, 0, 0, 0x1000, (Body *) buf, sizeof(Body) * nBodies); x = 0; // for(x = 0; x < iters; x++){ while(1){ //fprintf(stderr, "Iter %d\n", x); for (row = 0; row < platform.rows; row++){ for (col = 0; col < platform.cols; col++){ e_write(&dev, row, col, 0x00000008, &startFlag, sizeof(int)); } } e_start_group(&dev); //Check if all cores are done while(1){ all_done = 0; for (row = 0; row < platform.rows; row++){ for (col = 0; col < platform.cols; col++){ e_read(&dev, row, col, 0x00000008, &core_done, sizeof(int)); all_done += core_done; } } if(all_done == 0){ break; } } e_read(&dev, 0, 0, 0x1000, (Body *) bufOutput, sizeof(Body) * nBodies); if(x != 0){ draw_stars(buf, nBodies, fp, stride, 0x00000000); } else{ x = 1; } draw_stars(bufOutput, nBodies, fp, stride, 0x00ffffff); memcpy(buf, bufOutput, sizeof(Body) * nBodies); } e_close(&dev); // Release the allocated buffer and finalize the // e-platform connection. e_finalize(); return 0; }
void display(int d) { int i; glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); if(lock) { if(eye[0] < -23.0 - 28.0*tan(M_PI/6)) eye[0] = -23.0 - 28.0*tan(M_PI/6); if(eye[0] > 33.0) eye[0] = 33.0; if(eye[1] < -28.0 - 26.5*tan(M_PI/6)) eye[1] = -28.0 - 26.5*tan(M_PI/6); if(eye[1] > 25.0) eye[1] = 25.0; if(eye[2] < -25.0) eye[2] = -25.0; if(eye[2] > 51.0 + 65.0*tan(M_PI/6)) eye[2] = 51.0 + 65.0*tan(M_PI/6); } if(!helmet) { for(i=0; i < 3; i++) view[i] = (2 * negview * eye[i]); up[0] = 0; up[1] = negup * 1.0; up[2] = 0; } if(d==D_LEFT) { glTranslatef(-2.5, 0.0, 0.0); } else if(d==D_RIGHT) { glTranslatef(2.5, 0.0, 0.0); } gluLookAt(eye[0], eye[1], eye[2], view[0], view[1], view[2], up[0], up[1], up[2]); glTranslatef(global_translate[0], global_translate[1], global_translate[2]); glPushAttrib(GL_ALL_ATTRIB_BITS); glPushMatrix(); /* glRotatef(theta, 0.0, 1.0, 0.0); glRotatef(phi, 1.0, 0.0, 0.0);*/ glColor3f(1.0, 1.0, 1.0); if(wireframe) { glPolygonMode(GL_FRONT, GL_LINE); glDisable(GL_CULL_FACE); } else { glPolygonMode(GL_FRONT, GL_FILL); glEnable(GL_CULL_FACE); } /* Draw coordinate axes */ glDisable(GL_LIGHTING); glDisable(GL_TEXTURE_2D); if(axes) { glPushMatrix(); glTranslatef(-global_translate[0], -global_translate[1], -global_translate[2]); glBegin(GL_LINES); glVertex3f(-100.0, 0.0, 0.0); glVertex3f(100.0, 0.0, 0.0); glVertex3f(0.0, -100.0, 0.0); glVertex3f(0.0, 100.0, 0.0); glVertex3f(0.0, 0.0, -100.0); glVertex3f(0.0, 0.0, 100.0); glEnd(); glPopMatrix(); } if(texture) glEnable(GL_TEXTURE_2D); if(lighting) glEnable(GL_LIGHTING); if(!smooth) {glDisable(GL_SMOOTH); glShadeModel(GL_FLAT); glEnable(GL_FLAT);} else {glDisable(GL_FLAT); glShadeModel(GL_SMOOTH); glEnable(GL_SMOOTH);} if(filtering) { glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); } else { glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); } draw_scene(); glDisable(GL_LIGHTING); glDisable(GL_TEXTURE_2D); if(terrain) draw_terrain(); /* Draw w/o lighting */ if(stars) draw_stars(); glPopMatrix(); glPopAttrib(); /* And swap buffers to display the image */ glutSwapBuffers(); /* if(helmet) child(1);*/ }