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
}
