static void
parse_color (ModeInfo *mi, const char *name, const char *s, GLfloat *a)
{
XColor c;
if (! XParseColor (MI_DISPLAY(mi), MI_COLORMAP(mi), s, &c))
{
fprintf (stderr, "%s: can't parse %s color %s", progname, name, s);
exit (1);
}
a[0] = c.red / 65536.0;
a[1] = c.green / 65536.0;
a[2] = c.blue / 65536.0;
a[3] = 1.0;
}
/* 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 void
set_atom_color (ModeInfo *mi, molecule_atom *a, Bool font_p)
{
atom_data *d;
GLfloat *gl_color;
if (a)
d = a->data;
else
{
static atom_data *def_data = 0;
if (!def_data) def_data = get_atom_data ("bond");
d = def_data;
}
gl_color = (!font_p ? d->gl_color : (d->gl_color + 4));
if (gl_color[3] == 0)
{
const char *string = !font_p ? d->color : d->text_color;
XColor xcolor;
if (!XParseColor (MI_DISPLAY(mi), MI_COLORMAP(mi), string, &xcolor))
{
(void) fprintf (stderr, "molecule: unparsable color in %s: %s\n",
(a ? a->label : d->name), string);
/* exit (1); */
}
gl_color[0] = xcolor.red / 65536.0;
gl_color[1] = xcolor.green / 65536.0;
gl_color[2] = xcolor.blue / 65536.0;
gl_color[3] = 1.0;
}
if (font_p)
glColor3f (gl_color[0], gl_color[1], gl_color[2]);
else
glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, gl_color);
}
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);
}
/* 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 */
}
/* 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))
image = Generate_Image(&width, &height, &format);
else
{
XImage *ximage = xpm_file_to_ximage (MI_DISPLAY (mi), MI_VISUAL (mi),
MI_COLORMAP (mi), filename);
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_tex_qual) {
/* 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");
}
}
/* 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));
}
ENTRYPOINT void init_soma (ModeInfo *mi)
{
int loop;
int colorincrement;
GLfloat fogColor[4] = {0., 0., 0., 1.};
GLfloat pos[4] = {0.0, 1.0, 1.0, 0.0};
GLfloat amb[4] = {0.2, 0.2, 0.2, 1.0};
GLfloat dif[4] = {1.0, 1.0, 1.0, 1.0};
GLfloat spc[4] = {0.4, 0.4, 0.4, 1.0};
GLfloat shininess[] = {75.};
GLfloat specular[] = {1., 1., 1., 1.};
soma_configuration *lp;
if (!lps) {
lps = (soma_configuration *)
calloc (MI_NUM_SCREENS(mi), sizeof (soma_configuration));
if (!lps) {
fprintf(stderr, "%s: out of memory\n", progname);
exit(1);
}
lp = &lps[MI_SCREEN(mi)];
}
lp = &lps[MI_SCREEN(mi)];
lp->glx_context = init_GL(mi);
lp->currentfigure = malloc (sizeof (figure));
lp->basefigure = malloc (sizeof (figure));
lp->fduration = ((duration > 0 && duration <= 5000) ? duration : 500);
lp->cduration = ((colorchangerate > 0 && colorchangerate <= 1000) ? colorchangerate: 10);
lp->tduration = ((changerate > 0 && changerate <= 500) ? changerate : 100);
lp->viewangle = 0.;
lp->vanglestep = ((spinrate >= -100 && spinrate <= 100) ? (spinrate / 500.0) : 0.02);
if (do_clockwise) lp->vanglestep *= -1;
lp->dstate = exploding;
makedlists(lp->piecedlists);
if(!MI_IS_MONO(mi))
{
lp->numcolors = ((ncolors > 0 && ncolors < 2049) ?
ncolors : 256);
lp->colors = calloc ( lp->numcolors, sizeof (*lp->colors));
make_smooth_colormap (MI_DISPLAY(mi),MI_VISUAL(mi), MI_COLORMAP(mi),
lp->colors, &lp->numcolors, False, 0, True);
}
if( (MI_IS_MONO(mi)) || (lp->numcolors < 1))
{
/* GLfloat white[] = {1., 1., 1., 1.}; */
lp->numcolors = 1;
lp->colors = calloc (1, sizeof (*lp->colors));
lp->colors[0].pixel = MI_WHITE_PIXEL(mi);
XQueryColor( MI_DISPLAY(mi), MI_COLORMAP(mi), &lp->colors[0]);
/* glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, white); */
}
colorincrement = (int)lp->numcolors / 7;
for (loop = 1; loop < 8; loop++)
{
if (do_multicolors && lp->numcolors > 6)
{
lp->colorindices[loop] = colorincrement * loop;
}
else
{
lp->colorindices[loop] = 0;
}
}
lp->ftimer = lp->ctimer = 1;
if (lp->numcolors < 2) reset_color(lp, lp->currentfigure);
glEnable(GL_FOG);
glFogi(GL_FOG_MODE, GL_LINEAR);
glFogf(GL_FOG_DENSITY, 0.50);
glHint(GL_FOG_HINT, GL_NICEST);
glFogf(GL_FOG_START, 15);
glFogf(GL_FOG_END, 25);
glFogfv(GL_FOG_COLOR, fogColor);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
glShadeModel(GL_SMOOTH);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClearDepth(1.0f);
glLightfv(GL_LIGHT0, GL_POSITION, pos);
glLightfv(GL_LIGHT0, GL_AMBIENT, amb);
glLightfv(GL_LIGHT0, GL_DIFFUSE, dif);
glLightfv(GL_LIGHT0, GL_SPECULAR, spc);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glMaterialfv(GL_FRONT, GL_SPECULAR, specular);
glMaterialfv(GL_FRONT, GL_SHININESS, shininess);
handleGLerrors("init");
reshape_soma(mi, MI_WIDTH(mi), MI_HEIGHT(mi));
glFlush();
}
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);
}
void
getImage(ModeInfo * mi, XImage ** logo,
int default_width, int default_height, unsigned char *default_bits,
#ifdef HAVE_XPM
int default_xpm, char **name,
#endif
int *graphics_format, Colormap * ncm,
unsigned long *black)
{
Display *display = MI_DISPLAY(mi);
static char *bitmap_local = (char *) NULL;
#ifndef STANDALONE
#ifdef HAVE_XPM
XpmAttributes attrib;
#endif
#if 0
/* This probably works best in most cases but for random mode used
with random selection of a file it will fail often. */
*ncm = None;
#else
if (!fixedColors(mi))
*ncm = XCreateColormap(display, MI_WINDOW(mi), MI_VISUAL(mi), AllocNone);
else
*ncm = None;
#endif
#ifdef HAVE_XPM
attrib.visual = MI_VISUAL(mi);
if (*ncm == None) {
attrib.colormap = MI_COLORMAP(mi);
} else {
attrib.colormap = *ncm;
}
attrib.depth = MI_DEPTH(mi);
attrib.valuemask = XpmVisual | XpmColormap | XpmDepth;
#endif
#endif /* !STANDALONE */
*graphics_format = 0;
if (bitmap_local != NULL) {
free(bitmap_local);
bitmap_local = (char *) NULL;
}
if (MI_BITMAP(mi) && strlen(MI_BITMAP(mi))) {
#ifdef STANDALONE
bitmap_local = MI_BITMAP(mi);
#else
if ((bitmap_local = (char *) malloc(256)) == NULL) {
(void) fprintf(stderr , "no memory for \"%s\"\n" ,
MI_BITMAP(mi));
return;
}
(void) strncpy(bitmap_local, MI_BITMAP(mi), 256);
#if HAVE_DIRENT_H
getRandomFile(MI_BITMAP(mi), bitmap_local);
#endif
#endif /* STANDALONE */
}
if (bitmap_local && strlen(bitmap_local)) {
#if defined( USE_MAGICK ) && !defined( STANDALONE )
if ( readable( bitmap_local ) )
{
if ( MI_NPIXELS( mi ) > 2 )
{
Colormap magick_colormap;
if (*ncm == None) {
magick_colormap = MI_COLORMAP(mi);
} else {
magick_colormap = *ncm;
}
if ( MagickSuccess == MagickFileToImage( mi ,
bitmap_local ,
logo ,
magick_colormap
) )
{
*graphics_format = IS_MAGICKFILE;
*black = GetColor(mi, MI_BLACK_PIXEL(mi));
(void) GetColor(mi, MI_WHITE_PIXEL(mi));
(void) GetColor(mi, MI_BG_PIXEL(mi));
(void) GetColor(mi, MI_FG_PIXEL(mi));
}
}
}
else
{
(void) fprintf(stderr , "could not read file \"%s\"\n" ,
bitmap_local);
}
#else
# ifndef STANDALONE
if (readable(bitmap_local)) {
if (MI_NPIXELS(mi) > 2) {
Colormap ras_colormap;
if (*ncm == None) {
ras_colormap = MI_COLORMAP(mi);
} else {
ras_colormap = *ncm;
}
if (RasterSuccess == RasterFileToImage(mi,
bitmap_local, logo ,
ras_colormap )) {
*graphics_format = IS_RASTERFILE;
*black = GetColor(mi, MI_BLACK_PIXEL(mi));
(void) GetColor(mi, MI_WHITE_PIXEL(mi));
(void) GetColor(mi, MI_BG_PIXEL(mi));
(void) GetColor(mi, MI_FG_PIXEL(mi));
}
}
} else {
(void) fprintf(stderr,
"could not read file \"%s\"\n", bitmap_local);
}
#ifdef HAVE_XPM
#ifndef USE_MONOXPM
if (MI_NPIXELS(mi) > 2)
#endif
{
if (*graphics_format <= 0) {
if (*ncm != None)
reserveColors(mi, *ncm, black);
if (XpmSuccess == XpmReadFileToImage(display,
bitmap_local, logo,
(XImage **) NULL, &attrib))
*graphics_format = IS_XPMFILE;
}
}
#endif
#endif /* !STANDALONE */
if (*graphics_format <= 0) {
if (!blogo.data) {
if (BitmapSuccess == XbmReadFileToImage(bitmap_local,
&blogo.width, &blogo.height,
(unsigned char **) &blogo.data)) {
blogo.bytes_per_line = (blogo.width + 7) / 8;
*graphics_format = IS_XBMFILE;
*logo = &blogo;
}
} else {
*graphics_format = IS_XBMDONE;
*logo = &blogo;
}
}
#endif
if (*graphics_format <= 0 && MI_IS_VERBOSE(mi))
(void) fprintf(stderr,
"\"%s\" is in an unrecognized format or not compatible with screen\n",
bitmap_local);
}
#ifndef STANDALONE
#ifdef HAVE_XPM
if (*graphics_format <= 0 &&
((MI_IS_FULLRANDOM(mi)) ? LRAND() & 1: default_xpm))
#ifndef USE_MONOXPM
if (MI_NPIXELS(mi) > 2)
#endif
if (XpmSuccess == XpmCreateImageFromData(display, name,
logo, (XImage **) NULL, &attrib))
*graphics_format = IS_XPM;
#endif
#endif /* STANDALONE */
if (*graphics_format <= 0) {
if (!blogo.data) {
blogo.data = (char *) default_bits;
blogo.width = default_width;
blogo.height = default_height;
blogo.bytes_per_line = (blogo.width + 7) / 8;
*graphics_format = IS_XBM;
} else
*graphics_format = IS_XBMDONE;
*logo = &blogo;
}
#ifndef STANDALONE /* Come back later */
if (*ncm != None && *graphics_format != IS_RASTERFILE &&
*graphics_format != IS_XPMFILE && *graphics_format != IS_XPM &&
*graphics_format != IS_MAGICKFILE) {
XFreeColormap(display, *ncm);
*ncm = None;
}
#endif /* STANDALONE */ /* Come back later */
}
void
fixColormap(ModeInfo * mi, int ncolors, float saturation,
Bool mono, Bool install, Bool inroot, Bool inwindow, Bool verbose)
{
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
Screen *scr = MI_SCREENPTR(mi);
Colormap cmap = MI_COLORMAP(mi);
Colormap dcmap = DefaultColormapOfScreen(scr);
XColor xcolor;
unsigned char *red = (unsigned char *) NULL,
*green = (unsigned char *) NULL,
*blue = (unsigned char *) NULL;
int colorcount, i, fixed, visualclass;
#ifndef COMPLIANT_COLORMAP
Bool retry = False;
#endif
if (mono || CellsOfScreen(scr) <= 2) {
if (MI_PIXELS(mi))
return;
if ((MI_PIXELS(mi) = (unsigned long *) calloc(2,
sizeof (unsigned long))) == NULL) {
(void) fprintf(stderr, "could not get the 2 colors for mono\n");
}
monoColormap(scr, MI_SCREENINFO(mi), foreground, background);
return;
}
colorcount = ncolors;
if ((( red = (unsigned char *) calloc(ncolors,
sizeof (unsigned char))) == NULL) ||
((green = (unsigned char *) calloc(ncolors,
sizeof (unsigned char))) == NULL) ||
(( blue = (unsigned char *) calloc(ncolors,
sizeof (unsigned char))) == NULL)) {
(void) fprintf(stderr, "could not get the %d colors\n", ncolors);
if (red != NULL)
free(red);
if (green != NULL)
free(green);
return;
}
visualclass = MI_VISUALCLASS(mi);
fixed = (visualclass == StaticGray) || (visualclass == StaticColor) ||
(visualclass == TrueColor);
if (
#ifdef USE_DTSAVER
dtsaver || /* needs to be in focus without mouse */
#endif
inroot || (!install && !fixed) || cmap == None) {
cmap = dcmap;
}
if (cmap != dcmap && MI_PIXELS(mi)) {
XFreeColors(display, cmap, MI_PIXELS(mi), MI_NPIXELS(mi), 0);
#ifndef COMPLIANT_COLORMAP
XFreeColors(display, cmap, &(MI_BLACK_PIXEL(mi)), 1, 0);
XFreeColors(display, cmap, &(MI_WHITE_PIXEL(mi)), 1, 0);
#endif
XFreeColors(display, cmap, &(MI_BG_PIXEL(mi)), 1, 0);
XFreeColors(display, cmap, &(MI_FG_PIXEL(mi)), 1, 0);
}
/* else if (cmap) { (void) printf("cmap: this case is possible?\n"); } */
if (MI_PIXELS(mi))
free(MI_PIXELS(mi));
if ((MI_PIXELS(mi) = (unsigned long *) calloc(ncolors,
sizeof (unsigned long))) == NULL) {
(void) fprintf(stderr, "could not get the %d colors\n", ncolors);
}
/* "allocate" the black and white pixels, so that they
will be included by XCopyColormapAndFree() if it gets called */
#ifdef COMPLIANT_COLORMAP
MI_BLACK_PIXEL(mi) = BlackPixelOfScreen(scr);
MI_WHITE_PIXEL(mi) = WhitePixelOfScreen(scr);
#else
MI_BLACK_PIXEL(mi) = allocPixel(display, cmap, "Black", "Black");
MI_WHITE_PIXEL(mi) = allocPixel(display, cmap, "White", "White");
#endif
MI_BG_PIXEL(mi) = allocPixel(display, cmap, background, "White");
MI_FG_PIXEL(mi) = allocPixel(display, cmap, foreground, "Black");
hsbramp(0.0, saturation, 1.0, 1.0, saturation, 1.0, colorcount,
red, green, blue);
MI_NPIXELS(mi) = 0;
for (i = 0; i < colorcount; i++) {
xcolor.red = red[i] << 8;
xcolor.green = green[i] << 8;
xcolor.blue = blue[i] << 8;
xcolor.flags = DoRed | DoGreen | DoBlue;
if (!XAllocColor(display, cmap, &xcolor)) {
#ifdef COMPLIANT_COLORMAP
if (!install || cmap != dcmap)
break;
if ((cmap = XCopyColormapAndFree(display, cmap)) == dcmap)
break;
if (verbose)
(void) fprintf(stderr, "using private colormap\n");
if (!XAllocColor(display, cmap, &xcolor))
break;
#else
if (verbose)
(void) fprintf(stderr, "ran out of colors on colormap\n");
if ((saturation != 1.0 || ncolors != 64) && MI_NPIXELS(mi) < 2) {
if (verbose)
(void) fprintf(stderr,
"retrying with saturation = 1.0 and ncolors = 64\n");
retry = True;
}
break;
#endif
}
MI_PIXELS(mi)[i] = xcolor.pixel;
MI_NPIXELS(mi)++;
}
free(red);
free(green);
free(blue);
if (verbose)
(void) fprintf(stderr, "%d pixel%s allocated\n", MI_NPIXELS(mi),
(MI_NPIXELS(mi) == 1) ? "" : "s");
if (MI_NPIXELS(mi) <= 4) {
XFreeColors(display, cmap, MI_PIXELS(mi), MI_NPIXELS(mi), 0);
#ifndef COMPLIANT_COLORMAP
XFreeColors(display, cmap, &(MI_BLACK_PIXEL(mi)), 1, 0);
XFreeColors(display, cmap, &(MI_WHITE_PIXEL(mi) ), 1, 0);
#endif
XFreeColors(display, cmap, &(MI_BG_PIXEL(mi)), 1, 0);
XFreeColors(display, cmap, &(MI_FG_PIXEL(mi)), 1, 0);
#ifndef COMPLIANT_COLORMAP
if (retry) {
fixColormap(mi, 64, 1.0,
mono, install, inroot, inwindow, verbose);
return;
}
#endif
monoColormap(scr, MI_SCREENINFO(mi), foreground, background);
MI_COLORMAP(mi) = cmap = DefaultColormapOfScreen(scr);
return;
}
MI_COLORMAP(mi) = cmap;
if ((install || fixed) && !inroot && MI_NPIXELS(mi) > 2) {
#if 0
(void) XGetWindowAttributes(display, window, &xgwa);
if (cmap != xgwa.colormap)
#endif
#if 1 /* Turn off to simulate fvwm and tvwm */
setColormap(display, window, cmap, inwindow);
#endif
}
#if 0
else {
/* white and black colors may not be right for GL modes so lets set them */
MI_BLACK_PIXEL(mi) = BlackPixelOfScreen(scr);
MI_WHITE_PIXEL(mi) = WhitePixelOfScreen(scr);
/* foreground and background colors may not be right.... */
BlackPixelOfScreen(scr) = MI_BLACK_PIXEL(mi);
WhitePixelOfScreen(scr) = MI_WHITE_PIXEL(mi);
}
#endif
}