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);
}
static void
parse_image_data(ModeInfo *mi)
{
atlantisstruct *ap = &atlantis[MI_SCREEN(mi)];
ap->texture = xpm_to_ximage (mi->dpy,
mi->xgwa.visual,
mi->xgwa.colormap,
sea_texture);
}
static void init_texture(ModeInfo *mi)
{
XImage *img = xpm_to_ximage(mi->dpy, mi->xgwa.visual,
mi->xgwa.colormap, jigglymap_xpm);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB,
img->width, img->height, 0, GL_RGBA,
GL_UNSIGNED_BYTE, img->data);
XDestroyImage(img);
}
/* 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 LoadGLTextures(ModeInfo *mi)
{
blocktube_configuration *lp = &lps[MI_SCREEN(mi)];
Bool status;
status = True;
glGenTextures(1, &lp->envTexture);
glBindTexture(GL_TEXTURE_2D, lp->envTexture);
lp->texti = xpm_to_ximage(MI_DISPLAY(mi), MI_VISUAL(mi), MI_COLORMAP(mi),
blocktube_xpm);
if (!lp->texti) {
status = False;
} else {
glPixelStorei(GL_UNPACK_ALIGNMENT,1);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, lp->texti->width, lp->texti->height, 0,
GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, lp->texti->data);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
}
return status;
}
/* 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);
}
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);
}
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();
}
}
/* 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 */
}
/* initialise textures */
static void inittextures(ModeInfo * mi)
{
firestruct *fs = &fire[MI_SCREEN(mi)];
#ifdef HAVE_XPM
if (do_texture) {
glGenTextures(1, &fs->groundid);
#ifdef HAVE_GLBINDTEXTURE
glBindTexture(GL_TEXTURE_2D, fs->groundid);
#endif /* HAVE_GLBINDTEXTURE */
if ((fs->gtexture = xpm_to_ximage(MI_DISPLAY(mi), MI_VISUAL(mi),
MI_COLORMAP(mi), ground)) == None) {
(void) fprintf(stderr, "Error reading the ground texture.\n");
glDeleteTextures(1, &fs->groundid);
do_texture = False;
fs->groundid = 0;
fs->treeid = 0;
return;
}
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,
fs->gtexture->width, fs->gtexture->height, 0,
GL_RGBA, GL_UNSIGNED_BYTE, fs->gtexture->data);
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_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
if (fs->num_trees)
{
glGenTextures(1, &fs->treeid);
#ifdef HAVE_GLBINDTEXTURE
glBindTexture(GL_TEXTURE_2D,fs->treeid);
#endif /* HAVE_GLBINDTEXTURE */
if ((fs->ttexture = xpm_to_ximage(MI_DISPLAY(mi), MI_VISUAL(mi),
MI_COLORMAP(mi), tree)) == None) {
(void)fprintf(stderr,"Error reading tree texture.\n");
glDeleteTextures(1, &fs->treeid);
fs->treeid = 0;
fs->num_trees = 0;
return;
}
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,
fs->ttexture->width, fs->ttexture->height, 0,
GL_RGBA, GL_UNSIGNED_BYTE, fs->ttexture->data);
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_MIN_FILTER,GL_NEAREST);
glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_MODULATE);
}
}
else
{
fs->groundid = 0; /* default textures */
fs->treeid = 0;
}
#else /* !HAVE_XPM */
do_texture = False;
fs->groundid = 0; /* default textures */
fs->treeid = 0;
#endif /* !HAVE_XPM */
}
ENTRYPOINT void
init_tentacles (ModeInfo *mi)
{
tentacles_configuration *tc;
int wire = MI_IS_WIREFRAME(mi);
int i;
if (!tcs) {
tcs = (tentacles_configuration *)
calloc (MI_NUM_SCREENS(mi), sizeof (tentacles_configuration));
if (!tcs) {
fprintf(stderr, "%s: out of memory\n", progname);
exit(1);
}
}
tc = &tcs[MI_SCREEN(mi)];
tc->glx_context = init_GL(mi);
reshape_tentacles (mi, MI_WIDTH(mi), MI_HEIGHT(mi));
if (!wire)
{
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] = {0.0, 1.0, 1.0, 1.0};
glLightfv(GL_LIGHT0, GL_POSITION, light_pos);
glLightfv(GL_LIGHT0, GL_AMBIENT, amb);
glLightfv(GL_LIGHT0, GL_DIFFUSE, dif);
glLightfv(GL_LIGHT0, GL_SPECULAR, spc);
}
if (!wire && !cel_p)
{
glEnable (GL_LIGHTING);
glEnable (GL_LIGHT0);
}
tc->trackball = gltrackball_init (False);
tc->left_p = !(random() % 5);
if (arg_segments < 2) arg_segments = 2;
if (arg_slices < 3) arg_slices = 3;
if (arg_thickness < 0.1) arg_thickness = 0.1;
if (arg_wiggliness < 0) arg_wiggliness = 0;
if (arg_wiggliness > 1) arg_wiggliness = 1;
if (arg_flexibility < 0) arg_flexibility = 0;
if (arg_flexibility > 1) arg_flexibility = 1;
parse_color (mi, "tentacleColor", arg_color, tc->tentacle_color);
parse_color (mi, "stripeColor", arg_stripe, tc->stripe_color);
parse_color (mi, "suckerColor", arg_sucker, tc->sucker_color);
/* Black outlines for light colors, white outlines for dark colors. */
if (tc->tentacle_color[0] + tc->tentacle_color[1] + tc->tentacle_color[2]
< 0.4)
tc->outline_color[0] = 1;
tc->outline_color[1] = tc->outline_color[0];
tc->outline_color[2] = tc->outline_color[0];
tc->outline_color[3] = 1;
for (i = 0; i < MI_COUNT(mi); i++)
move_tentacle (make_tentacle (mi, i, MI_COUNT(mi)));
if (wire) texture_p = cel_p = False;
if (cel_p) texture_p = False;
if (texture_p || cel_p) {
glGenTextures(1, &tc->texid);
# ifdef HAVE_GLBINDTEXTURE
glBindTexture ((cel_p ? GL_TEXTURE_1D : GL_TEXTURE_2D), tc->texid);
# endif
tc->texture = xpm_to_ximage (MI_DISPLAY(mi), MI_VISUAL(mi),
MI_COLORMAP(mi),
(cel_p ? grey_texture : scales));
if (!tc->texture) texture_p = cel_p = False;
}
if (texture_p) {
glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
clear_gl_error();
glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA,
tc->texture->width, tc->texture->height, 0,
GL_RGBA,
/* GL_UNSIGNED_BYTE, */
GL_UNSIGNED_INT_8_8_8_8_REV,
tc->texture->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);
glEnable(GL_TEXTURE_2D);
} else if (cel_p) {
clear_gl_error();
glTexImage1D (GL_TEXTURE_1D, 0, GL_RGBA,
tc->texture->width, 0,
GL_RGBA,
/* GL_UNSIGNED_BYTE, */
GL_UNSIGNED_INT_8_8_8_8_REV,
tc->texture->data);
check_gl_error("texture");
glTexParameterf(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameterf(GL_TEXTURE_1D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glEnable(GL_TEXTURE_1D);
glHint (GL_LINE_SMOOTH_HINT, GL_NICEST);
glEnable (GL_LINE_SMOOTH);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable (GL_BLEND);
/* Dark gray instead of black, so the outlines show up */
glClearColor (0.13, 0.13, 0.13, 1.0);
}
compute_unit_torus (mi, 0.5,
MAX(5, arg_slices/6),
MAX(9, arg_slices/3));
}
static void LoadTexture(ModeInfo * mi, char **fn, const char *filename, GLuint texbind, int blur, float bw_color, Bool anegative, Bool onealpha)
{
/* looping and temporary array index variables */
int ix, iy, bx, by, indx, indy, boxsize, cchan, tmpidx, dtaidx;
float boxdiv, tmpfa, blursum ;
unsigned char *tmpbuf, tmpa;
Bool rescale;
XImage *teximage; /* Texture data */
rescale = False;
boxsize = 2;
boxdiv = 1.0 / ( boxsize * 2.0 + 1.0) / ( boxsize * 2.0 + 1.0);
if (filename)
teximage = xpm_file_to_ximage(MI_DISPLAY(mi), MI_VISUAL(mi),
MI_COLORMAP(mi), filename);
else
teximage = xpm_to_ximage(MI_DISPLAY(mi), MI_VISUAL(mi),
MI_COLORMAP(mi), fn);
if (teximage == NULL) {
fprintf(stderr, "%s: error reading the texture.\n", progname);
glDeleteTextures(1, &texbind);
do_texture = False;
exit(0);
}
/* check if image is 2^kumquat, where kumquat is an integer between 1 and 10. Recale to
nearest power of 2. */
tmpfa = mylog2((float) teximage->width);
bx = 2 << (int) (tmpfa -1);
if (bx != teximage->width) {
rescale = True;
if ((tmpfa - (int) tmpfa) > 0.5849)
bx = bx * 2;
}
tmpfa = mylog2((float) teximage->height);
by = 2 << (int) (tmpfa - 1);
if (by != teximage->height) {
rescale = True;
if ((tmpfa - (int) tmpfa) > 0.5849)
by = by * 2;
}
#ifndef HAVE_JWZGLES
if (rescale) {
tmpbuf = calloc(bx * by * 4, sizeof(unsigned char));
if (gluScaleImage(GL_RGBA, teximage->width, teximage->height, GL_UNSIGNED_BYTE, teximage->data,
bx, by, GL_UNSIGNED_BYTE, tmpbuf))
check_gl_error("scale image");
free(teximage->data);
teximage->data = (char *) tmpbuf;
teximage->width = bx;
teximage->height= by;
}
/* end rescale code */
#endif /* !HAVE_JWZGLES */
if (anegative ) {
for (ix = 0 ; ix < teximage->height * teximage->width; ix++)
{
if (!teximage->data[ ix * 4 + 3]) {
teximage->data[ ix * 4 + 3] = (unsigned char) 0xff;
tmpa = (unsigned char) (bw_color * 0xff);
} else {
if (onealpha)
teximage->data[ ix * 4 + 3] = (unsigned char) 0xff;
else
teximage->data[ ix * 4 + 3] = (unsigned char) 0xff -
teximage->data[ ix * 4 + 3];
tmpa = (unsigned char) ((1.0 - bw_color) * 0xff);
}
/* make texture uniform b/w color */
teximage->data[ ix * 4 + 0] =
(unsigned char) ( tmpa);
teximage->data[ ix * 4 + 1] =
(unsigned char) ( tmpa);
teximage->data[ ix * 4 + 2] =
(unsigned char) ( tmpa);
/* negate alpha */
}
}
if (blur > 0) {
if (! anegative ) /* anegative alread b/w's the whole image */
for (ix = 0 ; ix < teximage->height * teximage->width; ix++)
if (!teximage->data[ ix * 4 + 3])
{
teximage->data[ ix * 4 + 0] =
(unsigned char) ( 255.0 * bw_color);
teximage->data[ ix * 4 + 1] =
(unsigned char) ( 255.0 * bw_color);
teximage->data[ ix * 4 + 2] =
(unsigned char) ( 255.0 * bw_color);
}
;
tmpbuf = calloc(teximage->height * teximage->width * 4, sizeof(unsigned char) ) ;
while (blur--) {
/* zero out tmp alpha buffer */
for (iy = 0 ; iy <teximage->height * teximage->width * 4 ; iy++)
tmpbuf[iy] = 0;
for (cchan = 0; cchan < 4 ; cchan++) {
for (iy = 0 ; iy < teximage->height ; iy++) {
for (ix = 0 ; ix < teximage->width ; ix++) {
dtaidx = (teximage->width * iy + ix) * 4;
tmpa = teximage->data[dtaidx + cchan];
tmpfa = (float) tmpa * boxdiv;
/* box filter */
for (by = -boxsize ; by <= boxsize; by++) {
for (bx = -boxsize ; bx <= boxsize; bx++) {
indx = wrapVal(ix + bx, 0, teximage->width);
indy = wrapVal(iy + by, 0, teximage->height);
tmpidx = (teximage->width * indy + indx) * 4;
blursum = tmpfa;
tmpbuf[tmpidx + cchan] += (unsigned char) blursum;
} /* for bx */
} /* for by */
} /* for ix */
} /* for iy */
} /* for cchan */
/* copy back buffer */
for (ix = 0 ; ix < teximage->height * teximage->width * 4; ix++)
teximage->data[ix] = tmpbuf[ix];
} /*while blur */
free(tmpbuf); /*tidy*/
} /* if blur */
clear_gl_error();
#ifdef HAVE_GLBINDTEXTURE
glBindTexture(GL_TEXTURE_2D, texbind);
clear_gl_error(); /* WTF? sometimes "invalid op" from glBindTexture! */
#endif
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, teximage->width, teximage->height,
0, GL_RGBA, GL_UNSIGNED_BYTE, teximage->data);
check_gl_error("texture");
setTexParams();
XDestroyImage(teximage);
}
static void
load_textures (ModeInfo *mi, Bool flip_p)
{
matrix_configuration *mp = &mps[MI_SCREEN(mi)];
XImage *xi;
int x, y;
int cw, ch;
int orig_w, orig_h;
/* The Matrix XPM is 512x598 -- but GL texture sizes must be powers of 2.
So we waste some padding rows to round up.
*/
xi = xpm_to_ximage (matrix3_xpm);
orig_w = xi->width;
orig_h = xi->height;
mp->real_char_rows = CHAR_ROWS;
spank_image (mp, xi);
if (xi->height != 512 && xi->height != 1024)
{
xi->height = (xi->height < 512 ? 512 : 1024);
xi->data = realloc (xi->data, xi->height * xi->bytes_per_line);
if (!xi->data)
{
fprintf(stderr, "%s: out of memory\n", progname);
exit(1);
}
}
if (xi->width != 512) abort();
if (xi->height != 512 && xi->height != 1024) abort();
/* char size in pixels */
cw = orig_w / CHAR_COLS;
ch = orig_h / CHAR_ROWS;
/* char size in ratio of final (padded) texture size */
mp->tex_char_width = (GLfloat) cw / xi->width;
mp->tex_char_height = (GLfloat) ch / xi->height;
/* Flip each character's bits horizontally -- we could also just do this
by reversing the texture coordinates on the quads, but on some systems
that slows things down a lot.
*/
if (flip_p)
{
int xx, col;
unsigned long buf[100];
for (y = 0; y < xi->height; y++)
for (col = 0, xx = 0; col < CHAR_COLS; col++, xx += cw)
{
for (x = 0; x < cw; x++)
buf[x] = XGetPixel (xi, xx+x, y);
for (x = 0; x < cw; x++)
XPutPixel (xi, xx+x, y, buf[cw-x-1]);
}
}
/* The pixmap is a color image with no transparency. Set the texture's
alpha to be the green channel, and set the green channel to be 100%.
*/
{
int rpos, gpos, bpos, apos; /* bitfield positions */
#if 0
/* #### Cherub says that the little-endian case must be taken on MacOSX,
or else the colors/alpha are the wrong way around. How can
that be the case?
*/
if (bigendian())
rpos = 24, gpos = 16, bpos = 8, apos = 0;
else
#endif
rpos = 0, gpos = 8, bpos = 16, apos = 24;
for (y = 0; y < xi->height; y++)
for (x = 0; x < xi->width; x++)
{
unsigned long p = XGetPixel (xi, x, y);
unsigned char r = (p >> rpos) & 0xFF;
unsigned char g = (p >> gpos) & 0xFF;
unsigned char b = (p >> bpos) & 0xFF;
unsigned char a = g;
g = 0xFF;
p = (r << rpos) | (g << gpos) | (b << bpos) | (a << apos);
XPutPixel (xi, x, y, p);
}
}
/* Now load the texture into GL.
*/
clear_gl_error();
glGenTextures (1, &mp->texture);
glPixelStorei (GL_UNPACK_ALIGNMENT, 4);
glPixelStorei (GL_UNPACK_ROW_LENGTH, xi->width);
glBindTexture (GL_TEXTURE_2D, mp->texture);
check_gl_error ("texture init");
glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, xi->width, xi->height, 0, GL_RGBA,
GL_UNSIGNED_INT_8_8_8_8_REV, xi->data);
{
char buf[255];
sprintf (buf, "creating %dx%d texture:", xi->width, xi->height);
check_gl_error (buf);
}
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
/* I'd expect CLAMP to be the thing to do here, but oddly, we get a
faint solid green border around the texture if it is *not* REPEAT!
*/
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
check_gl_error ("texture param");
XDestroyImage (xi);
}
