static Bool load_texture (ModeInfo *mi, const char *filename) { Display *dpy = mi->dpy; Visual *visual = mi->xgwa.visual; char buf[1024]; XImage *image; if (MI_IS_WIREFRAME(mi)) return False; if (!filename || !*filename || !strcasecmp (filename, "(none)")) { glDisable (GL_TEXTURE_2D); return False; } image = file_to_ximage (dpy, visual, filename); if (!image) return False; clear_gl_error(); glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, image->width, image->height, 0, GL_RGBA, GL_UNSIGNED_BYTE, image->data); sprintf (buf, "texture: %.100s (%dx%d)", filename, image->width, image->height); check_gl_error(buf); glPixelStorei (GL_UNPACK_ALIGNMENT, 4); glPixelStorei (GL_UNPACK_ROW_LENGTH, image->width); return True; }
ENTRYPOINT void init_stonerview (ModeInfo *mi) { stonerview_configuration *bp; if (!bps) { bps = (stonerview_configuration *) calloc (MI_NUM_SCREENS(mi), sizeof (stonerview_configuration)); if (!bps) { fprintf(stderr, "%s: out of memory\n", progname); exit(1); } } bp = &bps[MI_SCREEN(mi)]; bp->glx_context = init_GL(mi); bp->trackball = gltrackball_init (); bp->st = stonerview_init_view(MI_IS_WIREFRAME(mi), transparent_p); stonerview_init_move(bp->st); reshape_stonerview (mi, MI_WIDTH(mi), MI_HEIGHT(mi)); clear_gl_error(); /* WTF? sometimes "invalid op" from glViewport! */ }
static void pinit(ModeInfo *mi) { int status; glClearDepth(1.0); glClearColor(0.0, 0.0, 0.0, 1.0); if (MI_IS_WIREFRAME(mi)) return; glLightfv(GL_LIGHT0, GL_AMBIENT, ambient); glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse); glLightfv(GL_LIGHT0, GL_POSITION, position0); glLightfv(GL_LIGHT1, GL_AMBIENT, ambient); glLightfv(GL_LIGHT1, GL_DIFFUSE, diffuse); glLightfv(GL_LIGHT1, GL_POSITION, position1); glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient); glLightModelfv(GL_LIGHT_MODEL_TWO_SIDE, lmodel_twoside); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glEnable(GL_LIGHT1); glEnable(GL_NORMALIZE); glFrontFace(GL_CCW); glCullFace(GL_BACK); /* cage */ glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialWhite); glShadeModel(GL_FLAT); glDisable(GL_DEPTH_TEST); glEnable(GL_TEXTURE_2D); glEnable(GL_CULL_FACE); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); clear_gl_error(); if (MI_IS_MONO(mi)) status = 0; else status = gluBuild2DMipmaps(GL_TEXTURE_2D, 3, WoodTextureWidth, WoodTextureHeight, GL_RGB, GL_UNSIGNED_BYTE, WoodTextureData); if (status) { const char *s = (char *) gluErrorString (status); fprintf (stderr, "%s: error mipmapping texture: %s\n", progname, (s ? s : "(unknown)")); exit (1); } check_gl_error("mipmapping"); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, front_shininess); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, front_specular); }
static void setup_file_texture (ModeInfo *mi, char *filename) { Display *dpy = mi->dpy; Visual *visual = mi->xgwa.visual; char buf[1024]; Colormap cmap = mi->xgwa.colormap; XImage *image = xpm_file_to_ximage (dpy, visual, cmap, filename); clear_gl_error(); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, image->width, image->height, 0, GL_RGBA, /* GL_UNSIGNED_BYTE, */ GL_UNSIGNED_INT_8_8_8_8_REV, image->data); sprintf (buf, "texture: %.100s (%dx%d)", filename, image->width, image->height); check_gl_error(buf); /* setup parameters for texturing */ glPixelStorei(GL_UNPACK_ALIGNMENT, 4); glPixelStorei(GL_UNPACK_ROW_LENGTH, image->width); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); }
static Bool setup_file_texture (ModeInfo *mi, char *filename) { Display *dpy = mi->dpy; Visual *visual = mi->xgwa.visual; char buf[1024]; Colormap cmap = mi->xgwa.colormap; XImage *image = xpm_file_to_ximage (dpy, visual, cmap, filename); if (!image) return False; clear_gl_error(); glPixelStorei(GL_UNPACK_ALIGNMENT, 4); glPixelStorei(GL_UNPACK_ROW_LENGTH, image->width); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, image->width, image->height, 0, GL_RGBA, /* GL_UNSIGNED_BYTE, */ GL_UNSIGNED_INT_8_8_8_8_REV, image->data); sprintf (buf, "texture: %.100s (%dx%d)", filename, image->width, image->height); check_gl_error(buf); return True; }
void cone::gl_render(view& scene) { if (degenerate()) return; init_model(scene); clear_gl_error(); // See sphere::gl_render() for a description of the level of detail calc. double coverage = scene.pixel_coverage( pos, radius); int lod = 0; if (coverage < 0) lod = 5; else if (coverage < 10) lod = 0; else if (coverage < 30) lod = 1; else if (coverage < 90) lod = 2; else if (coverage < 250) lod = 3; else if (coverage < 450) lod = 4; else lod = 5; lod += scene.lod_adjust; if (lod < 0) lod = 0; else if (lod > 5) lod = 5; gl_matrix_stackguard guard; const double length = axis.mag(); model_world_transform( scene.gcf, vector( length, radius, radius ) ).gl_mult(); color.gl_set(opacity); if (translucent()) { gl_enable cull_face( GL_CULL_FACE); // Render the back half. glCullFace( GL_FRONT); scene.cone_model[lod].gl_render(); // Render the front half. glCullFace( GL_BACK); scene.cone_model[lod].gl_render(); } else { scene.cone_model[lod].gl_render(); } check_gl_error(); }
static void load_textures (ModeInfo *mi) { toaster_configuration *bp = &bps[MI_SCREEN(mi)]; XImage *xi; xi = xpm_to_ximage (mi->dpy, mi->xgwa.visual, mi->xgwa.colormap, chromesphere_xpm); clear_gl_error(); glGenTextures (1, &bp->chrome_texture); glBindTexture (GL_TEXTURE_2D, bp->chrome_texture); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glPixelStorei (GL_UNPACK_ALIGNMENT, 1); glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, xi->width, xi->height, 0, GL_RGBA, # ifndef USE_IPHONE GL_UNSIGNED_INT_8_8_8_8_REV, # else GL_UNSIGNED_BYTE, # endif xi->data); check_gl_error("texture"); xi = xpm_to_ximage (mi->dpy, mi->xgwa.visual, mi->xgwa.colormap, toast_xpm); glGenTextures (1, &bp->toast_texture); glBindTexture (GL_TEXTURE_2D, bp->toast_texture); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); # ifndef HAVE_JWZGLES glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); # endif glPixelStorei (GL_UNPACK_ALIGNMENT, 1); glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, xi->width, xi->height, 0, GL_RGBA, # ifndef USE_IPHONE GL_UNSIGNED_INT_8_8_8_8_REV, # else GL_UNSIGNED_BYTE, # endif xi->data); check_gl_error("texture"); glEnable(GL_TEXTURE_GEN_S); glEnable(GL_TEXTURE_GEN_T); glEnable(GL_TEXTURE_2D); }
ENTRYPOINT void init_pinion (ModeInfo *mi) { pinion_configuration *pp; int wire = MI_IS_WIREFRAME(mi); if (!pps) { pps = (pinion_configuration *) calloc (MI_NUM_SCREENS(mi), sizeof (pinion_configuration)); if (!pps) { fprintf(stderr, "%s: out of memory\n", progname); exit(1); } } pp = &pps[MI_SCREEN(mi)]; pp->glx_context = init_GL(mi); load_fonts (mi); reshape_pinion (mi, MI_WIDTH(mi), MI_HEIGHT(mi)); clear_gl_error(); /* WTF? sometimes "invalid op" from glViewport! */ pp->title_list = glGenLists (1); pp->ngears = 0; pp->gears_size = 0; pp->gears = 0; pp->plane_displacement = gear_size * 0.1; if (!wire) { GLfloat pos[4] = {-3.0, 1.0, 1.0, 0.0}; GLfloat amb[4] = { 0.0, 0.0, 0.0, 1.0}; GLfloat dif[4] = { 1.0, 1.0, 1.0, 1.0}; GLfloat spc[4] = { 1.0, 1.0, 1.0, 1.0}; glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glEnable(GL_DEPTH_TEST); glEnable(GL_CULL_FACE); glLightfv(GL_LIGHT0, GL_POSITION, pos); glLightfv(GL_LIGHT0, GL_AMBIENT, amb); glLightfv(GL_LIGHT0, GL_DIFFUSE, dif); glLightfv(GL_LIGHT0, GL_SPECULAR, spc); } pp->trackball = gltrackball_init (); ffwd (mi); }
static void free_fonts (ModeInfo *mi) { molecule_configuration *mc = &mcs[MI_SCREEN(mi)]; clear_gl_error (); if (glIsList(mc->molecule_dlist)) { glDeleteLists(mc->molecule_dlist, 1); (void) check_gl_error ("glDeleteLists"); mc->molecule_dlist = 0; } if (mc->xfont1) { int last; last = mc->xfont1->max_char_or_byte2; clear_gl_error (); if (glIsList(mc->font1_dlist)) { glDeleteLists (mc->font1_dlist,(GLuint) last+1); (void) check_gl_error ("glDeleteLists"); mc->font1_dlist = 0; } XFreeFont(MI_DISPLAY(mi),mc->xfont1); mc->xfont1 = (XFontStruct *) NULL; } if (mc->xfont2) { int last; last = mc->xfont2->max_char_or_byte2; clear_gl_error (); if (glIsList(mc->font2_dlist)) { glDeleteLists (mc->font2_dlist,(GLuint) last+1); (void) check_gl_error ("glDeleteLists"); mc->font2_dlist = 0; } XFreeFont(MI_DISPLAY(mi),mc->xfont2); mc->xfont2 = (XFontStruct *) NULL; } }
static GLuint gen_texture (void) { int x, y, i; float color; GLuint tex; unsigned char *texture = (unsigned char *)calloc (TEX_WIDTH * TEX_HEIGHT, 4); unsigned char *ptr = texture; float tint[3]; for (i = 0; i < 3; i++) tint[i] = 1.0 * random() / RAND_MAX; for (y = 0; y < TEX_HEIGHT; y++) { for (x = 0; x < TEX_WIDTH; x++) { color = 255 - sqrt((x - TEX_WIDTH / 2) * (x - TEX_WIDTH / 2) / COEFF + (y - TEX_HEIGHT / 2) * (y - TEX_HEIGHT / 2) / COEFF); if (color < 0) color = 0; for (i = 0; i < 3; i++) ptr[i] = (unsigned char)(color * tint[i]); ptr[3] = color ? 255 : 0; ptr += 4; } } glGenTextures (1, &tex); #ifdef HAVE_GLBINDTEXTURE glBindTexture (GL_TEXTURE_2D, tex); #endif /* HAVE_GLBINDTEXTURE */ glPixelStorei (GL_UNPACK_ALIGNMENT, 4); clear_gl_error (); glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, TEX_WIDTH, TEX_HEIGHT, 0, GL_RGBA, GL_UNSIGNED_BYTE, texture); check_gl_error ("texture"); /* Texture parameters, LINEAR scaling for better texture quality */ glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); free (texture); return tex; }
void cylinder::init_model(view& scene) { if (!scene.cylinder_model[0].compiled()) { clear_gl_error(); // The number of faces corrisponding to each level of detail. size_t n_faces[] = { 8, 16, 32, 64, 96, 188 }; size_t n_stacks[] = {1, 1, 3, 6, 10, 20 }; for (size_t i = 0; i < 6; ++i) { scene.cylinder_model[i].gl_compile_begin(); render_cylinder_model( n_faces[i], n_stacks[i]); scene.cylinder_model[i].gl_compile_end(); } check_gl_error(); } }
void cone::init_model(view& scene) { if (!scene.cone_model[0].compiled()) { clear_gl_error(); // The number of faces corrisponding to each level of detail. size_t n_faces[] = { 8, 16, 32, 46, 68, 90 }; size_t n_stacks[] = { 1, 2, 4, 7, 10, 14 }; for (size_t i = 0; i < 6; ++i) { scene.cone_model[i].gl_compile_begin(); render_cone_model( n_faces[i], n_stacks[i]); scene.cone_model[i].gl_compile_end(); } check_gl_error(); } }
void cone::gl_pick_render(view& scene) { if (degenerate()) return; init_model(scene); size_t lod = 2; clear_gl_error(); gl_matrix_stackguard guard; const double length = axis.mag(); model_world_transform( scene.gcf, vector( length, radius, radius ) ).gl_mult(); scene.cone_model[lod].gl_render(); check_gl_error(); }
/* Set up and enable texturing on our object */ static void setup_xpm_texture (ModeInfo *mi, const unsigned char *data, unsigned long size) { XImage *image = image_data_to_ximage (MI_DISPLAY (mi), MI_VISUAL (mi), data, size); char buf[1024]; clear_gl_error(); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); /* iOS invalid enum: glPixelStorei(GL_UNPACK_ROW_LENGTH, image->width); */ glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, image->width, image->height, 0, GL_RGBA, GL_UNSIGNED_BYTE, image->data); sprintf (buf, "builtin texture (%dx%d)", image->width, image->height); check_gl_error(buf); XDestroyImage (image); }
ENTRYPOINT void init_photopile (ModeInfo *mi) { int screen = MI_SCREEN(mi); photopile_state *ss; int wire = MI_IS_WIREFRAME(mi); if (sss == NULL) { if ((sss = (photopile_state *) calloc (MI_NUM_SCREENS(mi), sizeof(photopile_state))) == NULL) return; } ss = &sss[screen]; ss->mi = mi; if ((ss->glx_context = init_GL(mi)) != NULL) { reshape_photopile (mi, MI_WIDTH(mi), MI_HEIGHT(mi)); clear_gl_error(); /* WTF? sometimes "invalid op" from glViewport! */ } else { MI_CLEARWINDOW(mi); } ss->shadow = init_drop_shadow(); ss->texfont = load_texture_font (MI_DISPLAY(mi), "font"); if (debug_p) hack_resources (MI_DISPLAY (mi)); ss->frames = (image *)calloc (MI_COUNT(mi) + 1, sizeof(image)); ss->nframe = 0; if (!wire) { int i; for (i = 0; i < MI_COUNT(mi) + 1; ++i) { glGenTextures (1, &(ss->frames[i].texid)); if (ss->frames[i].texid <= 0) abort(); } } ss->mode = EARLY; load_image(mi); /* start loading the first image */ }
/* Set up and enable texturing on our object */ static void setup_xpm_texture (ModeInfo *mi, char **xpm_data) { XImage *image = xpm_to_ximage (MI_DISPLAY (mi), MI_VISUAL (mi), MI_COLORMAP (mi), xpm_data); char buf[1024]; clear_gl_error(); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); /* iOS invalid enum: glPixelStorei(GL_UNPACK_ROW_LENGTH, image->width); */ glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, image->width, image->height, 0, GL_RGBA, /* GL_UNSIGNED_BYTE, */ GL_UNSIGNED_INT_8_8_8_8_REV, image->data); sprintf (buf, "builtin texture (%dx%d)", image->width, image->height); check_gl_error(buf); }
/*=================== Load Texture =========================================*/ static void LoadTexture(ModeInfo * mi, char **fn, int t_num) { #if defined( I_HAVE_XPM ) atunnelstruct *sa = &Atunnel[MI_SCREEN(mi)]; XImage *teximage; /* Texture data */ if ((teximage = xpm_to_ximage(MI_DISPLAY(mi), MI_VISUAL(mi), MI_COLORMAP(mi), fn)) == None) { (void) fprintf(stderr, "Error reading the texture.\n"); glDeleteTextures(1, &sa->texture[t_num]); do_texture = False; #ifdef STANDALONE exit(0); #else return; #endif } #ifdef HAVE_GLBINDTEXTURE glBindTexture(GL_TEXTURE_2D, sa->texture[t_num]); #endif /* HAVE_GLBINDTEXTURE */ glPixelStorei(GL_UNPACK_ALIGNMENT, 4); clear_gl_error(); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, teximage->width, teximage->height, 0, GL_RGBA, /* GL_UNSIGNED_BYTE, */ GL_UNSIGNED_INT_8_8_8_8_REV, teximage->data); check_gl_error("texture"); /* Texture parameters, LINEAR scaling for better texture quality */ glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); XDestroyImage(teximage); #else /* !I_HAVE_XPM */ do_texture = False; #endif /* !I_HAVE_XPM */ }
static Bool load_texture (ModeInfo *mi, const char *filename) { Display *dpy = mi->dpy; Visual *visual = mi->xgwa.visual; Colormap cmap = mi->xgwa.colormap; char buf[1024]; XImage *image; if (!filename || !*filename || !strcasecmp (filename, "(none)")) { glDisable (GL_TEXTURE_2D); return False; } image = xpm_file_to_ximage (dpy, visual, cmap, filename); clear_gl_error(); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, image->width, image->height, 0, GL_RGBA, GL_UNSIGNED_BYTE, image->data); sprintf (buf, "texture: %.100s (%dx%d)", filename, image->width, image->height); check_gl_error(buf); glPixelStorei (GL_UNPACK_ALIGNMENT, 4); glPixelStorei (GL_UNPACK_ROW_LENGTH, image->width); glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); glTexParameterf (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameterf (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameterf (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameterf (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glEnable (GL_TEXTURE_2D); return True; }
static Bool load_font (ModeInfo *mi, char *res, XFontStruct **fontP, GLuint *dlistP) { #ifdef STANDALONE const char *font = get_string_resource (res, "Font"); #else const char *font = res; #endif XFontStruct *f; Font id; int first, last; if (!font) font = "-*-times-bold-r-normal-*-180-*"; f = XLoadQueryFont(MI_DISPLAY(mi), font); if (!f) f = XLoadQueryFont(MI_DISPLAY(mi), "fixed"); id = f->fid; first = f->min_char_or_byte2; last = f->max_char_or_byte2; clear_gl_error (); *dlistP = glGenLists ((GLuint) last+1); if (check_gl_error ("glGenLists")) return False; /*- * PURIFY reports a cumulative memory leak on the next line with Mesa 3.4.1 * on Solaris 2.X and SunOS 4.1.X. This can be fixed with a patch to Mesa * 3.4.1. OpenGL on Solaris does not have the memory leak. */ glXUseXFont(id, first, last-first+1, *dlistP + first); if (check_gl_error ("glXUseXFont")) return False; *fontP = f; return True; }
/* Set up and enable texturing on our object */ static void setup_xpm_texture (ModeInfo *mi, char **xpm_data) { XImage *image = xpm_to_ximage (MI_DISPLAY (mi), MI_VISUAL (mi), MI_COLORMAP (mi), xpm_data); char buf[1024]; clear_gl_error(); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, image->width, image->height, 0, GL_RGBA, /* GL_UNSIGNED_BYTE, */ GL_UNSIGNED_INT_8_8_8_8_REV, image->data); sprintf (buf, "builtin texture (%dx%d)", image->width, image->height); check_gl_error(buf); /* setup parameters for texturing */ glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); }
void GFXVertexList::BeginDrawState( GFXBOOL lock ) { if (!numVertices) return; //don't do anything if there are no vertices #ifndef NO_VBO_SUPPORT if (vbo_data) { clear_gl_error(); GFXBindBuffer( vbo_data ); print_gl_error("VBO18.5a Error %d\n"); if (changed&HAS_INDEX) { GFXBindElementBuffer( display_list ); print_gl_error("VBO18.5b Error %d\n"); } if (changed&HAS_COLOR) { EnableArrays((GFXColorVertex*)NULL); } else { EnableArrays((GFXVertex*)NULL); } } else #endif if (display_list == 0) { if (changed&HAS_COLOR) { EnableArrays(data.colors); } else { EnableArrays(data.vertices); } #ifndef NO_COMPILEDVERTEXARRAY_SUPPORT if (lock && glLockArraysEXT_p) (*glLockArraysEXT_p)(0, numVertices); #endif } }
void sphere::init_model() { if (lod_cache[0]) return; clear_gl_error(); quadric sph; lod_cache[0].gl_compile_begin(); sph.render_sphere( 1.0, 13, 7); lod_cache[0].gl_compile_end(); lod_cache[1].gl_compile_begin(); sph.render_sphere( 1.0, 19, 11); lod_cache[1].gl_compile_end(); lod_cache[2].gl_compile_begin(); sph.render_sphere( 1.0, 35, 19); lod_cache[2].gl_compile_end(); lod_cache[3].gl_compile_begin(); sph.render_sphere( 1.0, 55, 29); lod_cache[3].gl_compile_end(); lod_cache[4].gl_compile_begin(); sph.render_sphere( 1.0, 70, 34); lod_cache[4].gl_compile_end(); // Only for the very largest bodies. lod_cache[5].gl_compile_begin(); sph.render_sphere( 1.0, 140, 69); lod_cache[5].gl_compile_end(); check_gl_error(); }
static void pinit(ModeInfo *mi) { /* int status; */ glClearDepth(1.0); glLightfv(GL_LIGHT0, GL_AMBIENT, ambient); glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse); glLightfv(GL_LIGHT0, GL_POSITION, position0); glLightfv(GL_LIGHT1, GL_AMBIENT, ambient); glLightfv(GL_LIGHT1, GL_DIFFUSE, diffuse); glLightfv(GL_LIGHT1, GL_POSITION, position1); glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient); glLightModelfv(GL_LIGHT_MODEL_TWO_SIDE, lmodel_twoside); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glEnable(GL_LIGHT1); glEnable(GL_NORMALIZE); glCullFace(GL_BACK); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialWhite); glShadeModel(GL_FLAT); glEnable(GL_DEPTH_TEST); glEnable(GL_TEXTURE_2D); glEnable(GL_CULL_FACE); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); #if 0 clear_gl_error(); status = gluBuild2DMipmaps(GL_TEXTURE_2D, 3, WoodTextureWidth, WoodTextureHeight, GL_RGB, GL_UNSIGNED_BYTE, WoodTextureData); if (status) { const char *s = (char *) gluErrorString (status); fprintf (stderr, "%s: error mipmapping %dx%d texture: %s\n", progname, WoodTextureWidth, WoodTextureHeight, (s ? s : "(unknown)")); exit (1); } check_gl_error("mipmapping"); #else { XImage *img = xpm_to_ximage (mi->dpy, mi->xgwa.visual, mi->xgwa.colormap, wood_texture); glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, img->width, img->height, 0, GL_RGBA, /* GL_UNSIGNED_BYTE, */ GL_UNSIGNED_INT_8_8_8_8_REV, img->data); check_gl_error("texture"); XDestroyImage (img); } #endif glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, front_shininess); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, front_specular); }
ENTRYPOINT void init_sws (ModeInfo *mi) { double font_height; sws_configuration *sc = 0; if (!scs) { scs = (sws_configuration *) calloc (MI_NUM_SCREENS(mi), sizeof (sws_configuration)); if (!scs) { fprintf(stderr, "%s: out of memory\n", progname); exit(1); } } sc = &scs[MI_SCREEN(mi)]; sc->dpy = MI_DISPLAY(mi); sc = &scs[MI_SCREEN(mi)]; sc->lines = (char **) calloc (max_lines+1, sizeof(char *)); if ((sc->glx_context = init_GL(mi)) != NULL) { gl_init(mi); reshape_sws (mi, MI_WIDTH(mi), MI_HEIGHT(mi)); clear_gl_error(); /* WTF? sometimes "invalid op" from glViewport! */ init_stars (mi, MI_WIDTH(mi), MI_HEIGHT(mi)); } if (textures_p) { int cw, lh; sc->texfont = load_texture_font (MI_DISPLAY(mi), "font"); cw = texture_string_width (sc->texfont, "n", &lh); sc->char_width = cw; font_height = lh; glEnable(GL_ALPHA_TEST); glEnable (GL_TEXTURE_2D); check_gl_error ("loading font"); /* "Anistropic filtering helps for quadrilateral-angled textures. A sharper image is accomplished by interpolating and filtering multiple samples from one or more mipmaps to better approximate very distorted textures. This is the next level of filtering after trilinear filtering." */ if (smooth_p && strstr ((char *) glGetString(GL_EXTENSIONS), "GL_EXT_texture_filter_anisotropic")) { GLfloat anisotropic = 0.0; glGetFloatv (GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &anisotropic); if (anisotropic >= 1.0) glTexParameterf (GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, anisotropic); } } else { font_height = GLUT_FONT->top - GLUT_FONT->bottom; sc->char_width = glutStrokeWidth (GLUT_FONT, 'z'); /* 'n' seems wide */ } sc->font_scale = 1.0 / sc->char_width; /* We consider a font that consumes 80 columns to be "18 points". If neither -size nor -columns was specified, default to 60 columns (which is 24 points.) If both were specified, -columns has priority. */ { int base_col = 80; int base_size = 18; if (target_columns <= 0 && font_size <= 0) target_columns = 60; if (target_columns > 0) font_size = base_size * (base_col / (double) target_columns); else if (font_size > 0) target_columns = base_col * (base_size / (double) font_size); } sc->line_pixel_width = target_columns * sc->char_width; sc->font_scale /= target_columns; sc->line_height = font_height * sc->font_scale; /* Buffer only two lines of text. If the buffer is too big, there's a significant delay between when the program launches and when the text appears, which can be irritating for time-sensitive output (clock, current music, etc.) */ sc->buf_size = target_columns * 2; if (sc->buf_size < 80) sc->buf_size = 80; sc->buf = (char *) calloc (1, sc->buf_size); sc->total_lines = max_lines-1; if (random() & 1) star_spin = -star_spin; if (!alignment_str || !*alignment_str || !strcasecmp(alignment_str, "left")) alignment = -1; else if (!strcasecmp(alignment_str, "center") || !strcasecmp(alignment_str, "middle")) alignment = 0; else if (!strcasecmp(alignment_str, "right")) alignment = 1; else { fprintf (stderr, "%s: alignment must be left, center, or right, not \"%s\"\n", progname, alignment_str); exit (1); } sc->tc = textclient_open (sc->dpy); /* one more reshape, after line_height has been computed */ reshape_sws (mi, MI_WIDTH(mi), MI_HEIGHT(mi)); }
/* Create a texture in OpenGL. First an image is loaded and stored in a raster buffer, then it's */ static void Create_Texture(ModeInfo *mi, const char *filename) { int height, width; GLubyte *image; int format; if ( !strncmp(filename, "BUILTIN", 7)) { BUILTIN: image = Generate_Image(&width, &height, &format); } else { XImage *ximage = file_to_ximage (MI_DISPLAY (mi), MI_VISUAL (mi), filename); if (! ximage) goto BUILTIN; image = (GLubyte *) ximage->data; width = ximage->width; height = ximage->height; format = GL_RGBA; } /* GL_MODULATE or GL_DECAL depending on what you want */ glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); /* perhaps we can edge a bit more speed at the expense of quality */ glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST); if (do_texture_quality) { /* with texture_quality, the min and mag filters look *much* nice but are *much* slower */ glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); } else { /* default is to do it quick and dirty */ /* if you have mipmaps turned on, but not texture quality, nothing will happen! */ glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); } /* mipmaps make the image look much nicer */ if (do_mipmap) { int status; clear_gl_error(); status = gluBuild2DMipmaps(GL_TEXTURE_2D, 3, width, height, format, GL_UNSIGNED_BYTE, image); if (status) { const char *s = (char *) gluErrorString (status); fprintf (stderr, "%s: error mipmapping %dx%d texture: %s\n", progname, width, height, (s ? s : "(unknown)")); exit (1); } check_gl_error("mipmapping"); } else { clear_gl_error(); glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, image); check_gl_error("texture"); } }
static void gl_init (ModeInfo *mi) { lament_configuration *lc = &lcs[MI_SCREEN(mi)]; Bool wire = MI_IS_WIREFRAME(mi); int i; if (wire) do_texture = False; if (!wire) { static const GLfloat pos0[] = { -4.0, 2.0, 5.0, 1.0 }; static const GLfloat pos1[] = { 6.0, -1.0, 3.0, 1.0 }; static const GLfloat amb0[] = { 0.7, 0.7, 0.7, 1.0 }; /* static const GLfloat amb1[] = { 0.7, 0.0, 0.0, 1.0 }; */ static const GLfloat dif0[] = { 1.0, 1.0, 1.0, 1.0 }; static const GLfloat dif1[] = { 0.3, 0.1, 0.1, 1.0 }; glLightfv(GL_LIGHT0, GL_POSITION, pos0); glLightfv(GL_LIGHT1, GL_POSITION, pos1); glLightfv(GL_LIGHT0, GL_AMBIENT, amb0); /* glLightfv(GL_LIGHT1, GL_AMBIENT, amb1); */ glLightfv(GL_LIGHT0, GL_DIFFUSE, dif0); glLightfv(GL_LIGHT1, GL_DIFFUSE, dif1); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); /* glEnable(GL_LIGHT1); */ glEnable(GL_DEPTH_TEST); glEnable(GL_TEXTURE_2D); glEnable(GL_NORMALIZE); glEnable(GL_CULL_FACE); } if (do_texture) { int i; for (i = 0; i < countof(lc->texids); i++) glGenTextures(1, &lc->texids[i]); lc->texture = xpm_to_ximage (mi->dpy, mi->xgwa.visual, mi->xgwa.colormap, lament512); glPixelStorei(GL_UNPACK_ALIGNMENT, 4); /* messes up -fps */ /* glPixelStorei(GL_UNPACK_ROW_LENGTH, lc->texture->width); */ for (i = 0; i < countof(lc->texids); i++) { int height = lc->texture->width; /* assume square */ glBindTexture(GL_TEXTURE_2D, lc->texids[i]); clear_gl_error(); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, lc->texture->width, height, 0, GL_RGBA, /* GL_UNSIGNED_BYTE, */ GL_UNSIGNED_INT_8_8_8_8_REV, (lc->texture->data + (lc->texture->bytes_per_line * height * i))); check_gl_error("texture"); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); check_gl_error("texture"); /* This makes scaled pixmaps tolerable to look at. */ # if !defined(GL_TEXTURE_LOD_BIAS) && defined(GL_TEXTURE_LOD_BIAS_EXT) # define GL_TEXTURE_LOD_BIAS GL_TEXTURE_LOD_BIAS_EXT # endif # ifdef GL_TEXTURE_LOD_BIAS glTexParameterf (GL_TEXTURE_2D, GL_TEXTURE_LOD_BIAS, 0.25); # endif clear_gl_error(); /* invalid enum on iPad 3 */ } } for (i = 0; i < countof(all_objs); i++) { GLfloat s = 1/3.0; /* box is 3" square */ const struct gllist *L = *all_objs[i]; const GLfloat *f = (const GLfloat *) L->data; int j; lc->dlists[i] = glGenLists(1); lc->polys[i] = L->points / 3; glNewList(lc->dlists[i], GL_COMPILE); if (L->primitive != GL_TRIANGLES) abort(); if (L->format != GL_N3F_V3F) abort(); glPushMatrix(); glTranslatef (-0.5, -0.5, -0.5); glScalef (s, s, s); for (j = 0; j < L->points; j += 3) { int face, outerp; Bool blackp = (i == OBJ_ISO_BASE_A || i == OBJ_ISO_BASE_B); which_face (mi, f, &face, &outerp); /* from norm of first vert */ set_colors (outerp ? exterior_color : blackp ? black_color : interior_color); glBindTexture (GL_TEXTURE_2D, (outerp ? lc->texids[face-1] : blackp ? 0 : lc->texids[6])); glBegin (wire ? GL_LINE_LOOP : GL_TRIANGLES); if (face) texturize_vert (mi, face, f+3); glNormal3fv (f); f += 3; glVertex3fv (f); f += 3; if (face) texturize_vert (mi, face, f+3); glNormal3fv (f); f += 3; glVertex3fv (f); f += 3; if (face) texturize_vert (mi, face, f+3); glNormal3fv (f); f += 3; glVertex3fv (f); f += 3; glEnd(); } glPopMatrix(); glEndList(); } }
GLXContext * init_GL(ModeInfo * mi) { Display *dpy = mi->dpy; Window window = mi->window; Screen *screen = mi->xgwa.screen; Visual *visual = mi->xgwa.visual; XVisualInfo vi_in, *vi_out; int out_count; if (mi->glx_context) { glXMakeCurrent (dpy, window, mi->glx_context); return &mi->glx_context; } # ifdef HAVE_JWZGLES jwzgles_make_current(jwzgles_make_state(state)); # endif vi_in.screen = screen_number (screen); vi_in.visualid = XVisualIDFromVisual (visual); vi_out = XGetVisualInfo (dpy, VisualScreenMask|VisualIDMask, &vi_in, &out_count); if (! vi_out) abort (); { XSync (dpy, False); orig_ehandler = XSetErrorHandler (BadValue_ehandler); mi->glx_context = glXCreateContext (dpy, vi_out, 0, GL_TRUE); XSync (dpy, False); XSetErrorHandler (orig_ehandler); if (got_error) mi->glx_context = 0; } XFree((char *) vi_out); if (!mi->glx_context) { fprintf(stderr, "%s: couldn't create GL context for visual 0x%x.\n", progname, (unsigned int) XVisualIDFromVisual (visual)); exit(1); } glXMakeCurrent (dpy, window, mi->glx_context); { GLboolean rgba_mode = 0; glGetBooleanv(GL_RGBA_MODE, &rgba_mode); if (!rgba_mode) { glIndexi (WhitePixelOfScreen (screen)); glClearIndex (BlackPixelOfScreen (screen)); } } /* jwz: the doc for glDrawBuffer says "The initial value is GL_FRONT for single-buffered contexts, and GL_BACK for double-buffered contexts." However, I find that this is not always the case, at least with Mesa 3.4.2 -- sometimes the default seems to be GL_FRONT even when glGet(GL_DOUBLEBUFFER) is true. So, let's make sure. Oh, hmm -- maybe this only happens when we are re-using the xscreensaver window, and the previous GL hack happened to die with the other buffer selected? I'm not sure. Anyway, this fixes it. */ { GLboolean d = False; glGetBooleanv (GL_DOUBLEBUFFER, &d); if (d) glDrawBuffer (GL_BACK); else glDrawBuffer (GL_FRONT); } /* Sometimes glDrawBuffer() throws "invalid op". Dunno why. Ignore. */ clear_gl_error (); /* Process the -background argument. */ { char *s = get_string_resource(mi->dpy, "background", "Background"); XColor c = { 0, }; if (! XParseColor (dpy, mi->xgwa.colormap, s, &c)) fprintf (stderr, "%s: can't parse color %s; using black.\n", progname, s); glClearColor (c.red / 65535.0, c.green / 65535.0, c.blue / 65535.0, 1.0); } glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); /* GLXContext is already a pointer type. Why this function returns a pointer to a pointer, I have no idea... */ return &mi->glx_context; }
/* initialise textures */ static void inittextures(ModeInfo * mi) { sballsstruct *sb = &sballs[MI_SCREEN(mi)]; #if defined( I_HAVE_XPM ) if (do_texture) { glGenTextures(1, &sb->backid); #ifdef HAVE_GLBINDTEXTURE glBindTexture(GL_TEXTURE_2D, sb->backid); #endif /* HAVE_GLBINDTEXTURE */ sb->btexture = xpm_to_ximage(MI_DISPLAY(mi), MI_VISUAL(mi), MI_COLORMAP(mi), sball_bg); if (!(sb->btexture)) { (void) fprintf(stderr, "Error reading the background texture.\n"); glDeleteTextures(1, &sb->backid); do_texture = False; sb->faceid = 0; /* default textures */ sb->backid = 0; return; } glPixelStorei(GL_UNPACK_ALIGNMENT, 1); clear_gl_error(); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, sb->btexture->width, sb->btexture->height, 0, GL_RGBA, /* GL_UNSIGNED_BYTE, */ GL_UNSIGNED_INT_8_8_8_8_REV, sb->btexture->data); check_gl_error("texture"); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); glGenTextures(1, &sb->faceid); #ifdef HAVE_GLBINDTEXTURE glBindTexture(GL_TEXTURE_2D, sb->faceid); #endif /* HAVE_GLBINDTEXTURE */ sb->ftexture = xpm_to_ximage(MI_DISPLAY(mi), MI_VISUAL(mi), MI_COLORMAP(mi), sball); if (!(sb->ftexture)) { (void) fprintf(stderr, "Error reading the face texture.\n"); glDeleteTextures(1, &sb->faceid); sb->faceid = 0; return; } glPixelStorei(GL_UNPACK_ALIGNMENT, 1); clear_gl_error(); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, sb->ftexture->width, sb->ftexture->height, 0, GL_RGBA, /* GL_UNSIGNED_BYTE, */ GL_UNSIGNED_INT_8_8_8_8_REV, sb->ftexture->data); check_gl_error("texture"); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); } else { sb->faceid = 0; /* default textures */ sb->backid = 0; } #else /* !I_HAVE_XPM */ do_texture = False; sb->faceid = 0; /* default textures */ sb->backid = 0; #endif /* !I_HAVE_XPM */ }
static int displayTexture(gfluxstruct *gp) { int polys = 0; double x,y,u,v; double z; double dx = 2.0/((double)_squares); double dy = 2.0/((double)_squares); double du = 2.0/((double)_squares); double dv = 2.0/((double)_squares); double xs = gp->tex_xscale; double ys = gp->tex_yscale; double minx, miny, maxx, maxy; double minu, minv; #if 0 minx = (GLfloat) gp->img_geom.x / gp->img_width; miny = (GLfloat) gp->img_geom.y / gp->img_height; maxx = ((GLfloat) (gp->img_geom.x + gp->img_geom.width) / gp->img_width); maxy = ((GLfloat) (gp->img_geom.y + gp->img_geom.height) / gp->img_height); minu = minx; minv = miny; minx = (minx * 2) - 1; miny = (miny * 2) - 1; maxx = (maxx * 2) - 1; maxy = (maxy * 2) - 1; #else minx = -1; miny = -1; maxx = 1; maxy = 1; minv = 0; minu = 0; #endif glMatrixMode (GL_TEXTURE); glLoadIdentity (); glTranslatef(-1,-1,0); glScalef(0.5,0.5,1); glMatrixMode (GL_MODELVIEW); glLoadIdentity(); userRot(gp); glRotatef(gp->anglex,1,0,0); glRotatef(gp->angley,0,1,0); glRotatef(gp->anglez,0,0,1); glScalef(1,1,(GLfloat)_waveHeight); glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); glEnable(GL_TEXTURE_2D); clear_gl_error(); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); glBindTexture(GL_TEXTURE_2D, gp->texName); check_gl_error("texture binding"); glColor3f(0.5,0.5,0.5); for(x = minx, u = minu; x < maxx - 0.01; x += dx, u += du) { glBegin(GL_QUAD_STRIP); for (y = miny, v = minv; y <= maxy + 0.01; y += dy, v += dv) { z = getGrid(gp,x,y,gp->time); glTexCoord2f(u*xs,v*ys); glNormal3f( getGrid(gp,x+dx,y,gp->time)-getGrid(gp, x-dx,y,gp->time), getGrid(gp,x,y+dy,gp->time)-getGrid(gp, x,y-dy,gp->time), 1 ); glVertex3f(x,y,z); z = getGrid(gp,x+dx,y,gp->time); glTexCoord2f((u+du)*xs,v*ys); glNormal3f( getGrid(gp,x+dx+dx,y,gp->time)-getGrid(gp, x,y,gp->time), getGrid(gp,x+dx,y+dy,gp->time)-getGrid(gp, x+dx,y-dy,gp->time), 1 ); glVertex3f(x+dx,y,z); polys++; } glEnd(); } /* Draw a border around the grid. */ glColor3f(0.4, 0.4, 0.4); glDisable(GL_TEXTURE_2D); glEnable (GL_LINE_SMOOTH); glBegin(GL_LINE_LOOP); y = miny; for (x = minx; x <= maxx; x += dx) { glVertex3f (x, y, getGrid (gp, x, y, gp->time)); polys++; } x = maxx; for (y = miny; y <= maxy; y += dy) { glVertex3f (x, y, getGrid (gp, x, y, gp->time)); polys++; } y = maxy; for (x = maxx; x >= minx; x -= dx) { glVertex3f (x, y, getGrid (gp, x, y, gp->time)); polys++; } x = minx; for (y = maxy; y >= miny; y -= dy) { glVertex3f (x, y, getGrid (gp, x, y, gp->time)); polys++; } glEnd(); glEnable(GL_TEXTURE_2D); if (! gp->button_down_p) { gp->time -= _speed; gp->anglex -= _rotationx; gp->angley -= _rotationy; gp->anglez -= _rotationz; } return polys; }
static void init_gl(ModeInfo *mi) { cube21_conf *cp = &cube21[MI_SCREEN(mi)]; #ifdef MIPMAP int status; #endif parse_colmode(); cp->wire = MI_IS_WIREFRAME(mi); cp->cmat = !cp->wire && (colmode != CUBE21_COLOR_WHITE); if(MI_IS_MONO(mi)) { tex = False; cp->cmat = False; } if(cp->wire) { glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); return; } if(!tex) cp->color_inner[0] = cp->color_inner[1] = cp->color_inner[2] = 0.4; else cp->color_inner[0] = cp->color_inner[1] = cp->color_inner[2] = 1.0; glClearDepth(1.0); glClearColor(0.0, 0.0, 0.0, 1.0); glDrawBuffer(GL_BACK); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glShadeModel(GL_FLAT); glDepthFunc(GL_LESS); glLightfv(GL_LIGHT0, GL_AMBIENT, ambient); glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse); glLightfv(GL_LIGHT0, GL_POSITION, position0); glLightfv(GL_LIGHT1, GL_AMBIENT, ambient); glLightfv(GL_LIGHT1, GL_DIFFUSE, diffuse); glLightfv(GL_LIGHT1, GL_POSITION, position1); glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient); glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE); glEnable(GL_DEPTH_TEST); glEnable(GL_LIGHT0); glEnable(GL_LIGHT1); glEnable(GL_LIGHTING); glEnable(GL_NORMALIZE); glEnable(GL_COLOR_MATERIAL); glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, material_ambient); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, material_diffuse); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, material_specular); glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, shininess); if(!tex) return; glEnable(GL_TEXTURE_2D); #ifdef MIPMAP clear_gl_error(); status = gluBuild2DMipmaps(GL_TEXTURE_2D, 1, TEX_WIDTH, TEX_HEIGHT, GL_LUMINANCE, GL_UNSIGNED_BYTE, texture); if (status) { const char *s = gluErrorString(status); fprintf (stderr, "%s: error mipmapping texture: %s\n", progname, (s?s:"(unknown)")); exit (1); } check_gl_error("mipmapping"); #else glTexImage2D(GL_TEXTURE_2D, 0, 1, TEX_WIDTH, TEX_HEIGHT, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, cp->texture); #endif glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); #ifdef MIPMAP glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); #else glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); #endif }