*
* Revision History:
*
+ * 10-Nov-14: jwz@jwz.org Night map. Better stars.
* 16-Jan-02: jwz@jwz.org gdk_pixbuf support.
* 21-Mar-01: jwz@jwz.org Broke sphere routine out into its own file.
*
*
* 8-Oct-98: Released initial version of "glplanet"
* (David Konerding, dek@cgl.ucsf.edu)
- *
- * BUGS:
- * -bounce is broken
- *
- * For even more spectacular results, grab the images from the "SSystem"
- * package (http://www.msu.edu/user/kamelkev/) and use its JPEGs!
- */
-
-
-/*-
- * due to a Bug/feature in VMS X11/Intrinsic.h has to be placed before xlock.
- * otherwise caddr_t is not defined correctly
*/
-#include <X11/Intrinsic.h>
#ifdef STANDALONE
-# define PROGCLASS "Planet"
-# define HACK_INIT init_planet
-# define HACK_DRAW draw_planet
-# define HACK_RESHAPE reshape_planet
-# define planet_opts xlockmore_opts
-#define DEFAULTS "*delay: 15000 \n" \
+#define DEFAULTS "*delay: 20000 \n" \
"*showFPS: False \n" \
- "*rotate: True \n" \
- "*roll: True \n" \
- "*bounce: True \n" \
"*wireframe: False \n" \
- "*light: True \n" \
- "*texture: True \n" \
- "*stars: True \n" \
- "*image: BUILTIN \n" \
"*imageForeground: Green \n" \
- "*imageBackground: Blue \n"
+ "*imageBackground: Blue \n" \
+ "*suppressRotationAnimation: True\n" \
+# define release_planet 0
# include "xlockmore.h" /* from the xscreensaver distribution */
#else /* !STANDALONE */
# include "xlock.h" /* from the xlockmore distribution */
# endif /* VMS */
#endif
-
-#include <GL/glu.h>
-
#define DEF_ROTATE "True"
#define DEF_ROLL "True"
-#define DEF_BOUNCE "True"
+#define DEF_WANDER "True"
+#define DEF_SPIN "0.03"
#define DEF_TEXTURE "True"
-#define DEF_STARS "True"
-#define DEF_LIGHT "True"
+#define DEF_STARS "True"
+#define DEF_RESOLUTION "128"
#define DEF_IMAGE "BUILTIN"
+#define DEF_IMAGE2 "BUILTIN"
#undef countof
#define countof(x) (sizeof((x))/sizeof((*x)))
+#undef BELLRAND
+#define BELLRAND(n) ((frand((n)) + frand((n)) + frand((n))) / 3)
+
static int do_rotate;
static int do_roll;
-static int do_bounce;
+static int do_wander;
static int do_texture;
static int do_stars;
-static int do_light;
static char *which_image;
+static char *which_image2;
+static int resolution;
+
static XrmOptionDescRec opts[] = {
- {"-rotate", ".glplanet.rotate", XrmoptionNoArg, (caddr_t) "true" },
- {"+rotate", ".glplanet.rotate", XrmoptionNoArg, (caddr_t) "false" },
- {"-roll", ".glplanet.roll", XrmoptionNoArg, (caddr_t) "true" },
- {"+roll", ".glplanet.roll", XrmoptionNoArg, (caddr_t) "false" },
- {"-bounce", ".glplanet.bounce", XrmoptionNoArg, (caddr_t) "true" },
- {"+bounce", ".glplanet.bounce", XrmoptionNoArg, (caddr_t) "false" },
- {"-texture", ".glplanet.texture", XrmoptionNoArg, (caddr_t) "true" },
- {"+texture", ".glplanet.texture", XrmoptionNoArg, (caddr_t) "false" },
- {"-stars", ".glplanet.stars", XrmoptionNoArg, (caddr_t) "true" },
- {"+stars", ".glplanet.stars", XrmoptionNoArg, (caddr_t) "false" },
- {"-light", ".glplanet.light", XrmoptionNoArg, (caddr_t) "true" },
- {"+light", ".glplanet.light", XrmoptionNoArg, (caddr_t) "false" },
- {"-image", ".glplanet.image", XrmoptionSepArg, (caddr_t) 0 },
+ {"-rotate", ".glplanet.rotate", XrmoptionNoArg, "true" },
+ {"+rotate", ".glplanet.rotate", XrmoptionNoArg, "false" },
+ {"-roll", ".glplanet.roll", XrmoptionNoArg, "true" },
+ {"+roll", ".glplanet.roll", XrmoptionNoArg, "false" },
+ {"-wander", ".glplanet.wander", XrmoptionNoArg, "true" },
+ {"+wander", ".glplanet.wander", XrmoptionNoArg, "false" },
+ {"-texture", ".glplanet.texture", XrmoptionNoArg, "true" },
+ {"+texture", ".glplanet.texture", XrmoptionNoArg, "false" },
+ {"-stars", ".glplanet.stars", XrmoptionNoArg, "true" },
+ {"+stars", ".glplanet.stars", XrmoptionNoArg, "false" },
+ {"-spin", ".glplanet.spin", XrmoptionSepArg, 0 },
+ {"-image", ".glplanet.image", XrmoptionSepArg, 0 },
+ {"-image2", ".glplanet.image2", XrmoptionSepArg, 0 },
+ {"-resolution", ".glplanet.resolution", XrmoptionSepArg, 0 },
};
static argtype vars[] = {
- {(caddr_t *) &do_rotate, "rotate", "Rotate", DEF_ROTATE, t_Bool},
- {(caddr_t *) &do_roll, "roll", "Roll", DEF_ROLL, t_Bool},
- {(caddr_t *) &do_bounce, "bounce", "Bounce", DEF_BOUNCE, t_Bool},
- {(caddr_t *) &do_texture, "texture", "Texture", DEF_TEXTURE, t_Bool},
- {(caddr_t *) &do_stars, "stars", "Stars", DEF_STARS, t_Bool},
- {(caddr_t *) &do_light, "light", "Light", DEF_LIGHT, t_Bool},
- {(caddr_t *) &which_image, "image", "Image", DEF_IMAGE, t_String},
+ {&do_rotate, "rotate", "Rotate", DEF_ROTATE, t_Bool},
+ {&do_roll, "roll", "Roll", DEF_ROLL, t_Bool},
+ {&do_wander, "wander", "Wander", DEF_WANDER, t_Bool},
+ {&do_texture, "texture", "Texture", DEF_TEXTURE, t_Bool},
+ {&do_stars, "stars", "Stars", DEF_STARS, t_Bool},
+ {&which_image, "image", "Image", DEF_IMAGE, t_String},
+ {&which_image2,"image2", "Image", DEF_IMAGE2, t_String},
+ {&resolution, "resolution","Resolution", DEF_RESOLUTION, t_Int},
};
-ModeSpecOpt planet_opts = {countof(opts), opts, countof(vars), vars, NULL};
+ENTRYPOINT ModeSpecOpt planet_opts = {countof(opts), opts, countof(vars), vars, NULL};
#ifdef USE_MODULES
ModStruct planet_description =
-{"planet", "init_planet", "draw_planet", "release_planet",
- "draw_planet", "init_planet", NULL, &planet_opts,
+{"planet", "init_planet", "draw_planet", NULL,
+ "draw_planet", "init_planet", "free_planet", &planet_opts,
1000, 1, 2, 1, 4, 1.0, "",
"Animates texture mapped sphere (planet)", 0, NULL};
#endif
-#include "../images/earth.xbm"
-#include "xpm-ximage.h"
+#include "images/gen/earth_png.h"
+#include "images/gen/earth_night_png.h"
+
+#include "ximage-loader.h"
+#include "rotator.h"
+#include "gltrackball.h"
/*-
* at the expense of rendering speed
*/
-#define NUM_STARS 1000
-#define SLICES 32
-#define STACKS 32
-
-/* radius of the sphere- fairly arbitrary */
-#define RADIUS 4
-
-/* distance away from the sphere model */
-#define DIST 40
-
-
-
/* structure for holding the planet data */
typedef struct {
GLuint platelist;
+ GLuint shadowlist;
+ GLuint latlonglist;
GLuint starlist;
+ int starcount;
int screen_width, screen_height;
GLXContext *glx_context;
Window window;
-
XColor fg, bg;
-
- GLfloat tx, ty, tz;
- GLfloat dtx, dty, dtz;
- GLfloat xpos, ypos, zpos;
- GLfloat dx, dy, dz;
- GLfloat box_width, box_height, box_depth;
+ GLfloat z;
+ GLfloat tilt;
+ rotator *rot;
+ trackball_state *trackball;
+ Bool button_down_p;
+ GLuint tex1, tex2;
+ int draw_axis;
} planetstruct;
static planetstruct *planets = NULL;
-static inline void
-normalize(GLfloat v[3])
-{
- GLfloat d = (GLfloat) sqrt((double) (v[0] * v[0] + v[1] * v[1] + v[2] * v[2]));
-
- if (d != 0) {
- v[0] /= d;
- v[1] /= d;
- v[2] /= d;
- } else {
- v[0] = v[1] = v[2] = 0;
- }
-}
-
-
/* Set up and enable texturing on our object */
static void
-setup_xbm_texture (char *bits, int width, int height,
- XColor *fgc, XColor *bgc)
+setup_xpm_texture (ModeInfo *mi, const unsigned char *data, unsigned long size)
{
- unsigned int fg = (((fgc->red >> 8) << 16) |
- ((fgc->green >> 8) << 8) |
- ((fgc->blue >> 8)));
- unsigned int bg = (((bgc->red >> 8) << 16) |
- ((bgc->green >> 8) << 8) |
- ((bgc->blue >> 8)));
-
- unsigned char *data = (unsigned char *)
- malloc ((width * height * 24) / 8);
- unsigned char *out = data;
- int x, y;
-
- for (y = 0; y < height; y++)
- for (x = 0; x < width; x++)
- {
- unsigned char byte = bits [(y * (width / 8) + (x / 8))];
- unsigned char bit = (byte & (1 << (x % 8))) >> (x % 8);
- unsigned int word = (bit ? bg : fg);
- *out++ = (word & 0xFF0000) >> 16;
- *out++ = (word & 0x00FF00) >> 8;
- *out++ = (word & 0x0000FF);
- }
-
+ XImage *image = image_data_to_ximage (MI_DISPLAY (mi), MI_VISUAL (mi),
+ data, size);
+ char buf[1024];
clear_gl_error();
- glTexImage2D(GL_TEXTURE_2D, 0, 3, width, height, 0,
- GL_RGB, GL_UNSIGNED_BYTE, data);
- check_gl_error("texture");
-
- /* 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);
+ /* 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);
}
-static void
+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);
+ XImage *image = file_to_ximage (dpy, visual, 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, image->data);
- check_gl_error("texture");
+ sprintf (buf, "texture: %.100s (%dx%d)",
+ filename, image->width, image->height);
+ check_gl_error(buf);
+ return True;
+}
- /* setup parameters for texturing */
- glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
- glPixelStorei(GL_UNPACK_ROW_LENGTH, image->width);
+static void
+setup_texture(ModeInfo * mi)
+{
+ planetstruct *gp = &planets[MI_SCREEN(mi)];
+
+ glGenTextures (1, &gp->tex1);
+ glBindTexture (GL_TEXTURE_2D, gp->tex1);
+
+ /* Must be after glBindTexture */
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
-setup_texture(ModeInfo * mi)
-{
- planetstruct *gp = &planets[MI_SCREEN(mi)];
if (!which_image ||
!*which_image ||
!strcmp(which_image, "BUILTIN"))
- setup_xbm_texture (earth_bits, earth_width, earth_height,
- &gp->fg, &gp->bg);
+ {
+ BUILTIN1:
+ setup_xpm_texture (mi, earth_png, sizeof(earth_png));
+ }
else
- setup_file_texture (mi, which_image);
-}
+ {
+ if (! setup_file_texture (mi, which_image))
+ goto BUILTIN1;
+ }
+ check_gl_error("texture 1 initialization");
-/* Set up and enable lighting */
-static void
-setup_light(void)
-{
- /* set a number of parameters which make the scene look much nicer */
- glEnable(GL_BLEND);
- glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
- glShadeModel(GL_SMOOTH);
-}
-
-
-/* Set up and enable face culling so we don't see the inside of the sphere */
-static void
-setup_face(void)
-{
- glEnable(GL_CULL_FACE);
- glCullFace(GL_BACK);
-}
+ glGenTextures (1, &gp->tex2);
+ glBindTexture (GL_TEXTURE_2D, gp->tex2);
+ /* Must be after glBindTexture */
+ 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);
-#if 0
-/* Function for determining points on the surface of the sphere */
-static void inline ParametricSphere(float theta, float rho, GLfloat *vector)
-{
- vector[0] = -sin(theta) * sin(rho);
- vector[1] = cos(theta) * sin(rho);
- vector[2] = cos(rho);
+ if (!which_image2 ||
+ !*which_image2 ||
+ !strcmp(which_image2, "BUILTIN"))
+ {
+ BUILTIN2:
+ setup_xpm_texture (mi, earth_night_png, sizeof(earth_night_png));
+ }
+ else
+ {
+ if (! setup_file_texture (mi, which_image2))
+ goto BUILTIN2;
+ }
-#if DO_HELIX
- vector[0] = -(1- cos(theta)) * cos(rho);
- vector[1] = -(1- cos(theta)) * sin(rho);
- vector[2] = -(sin(theta) + rho);
-#endif /* DO_HELIX */
+ check_gl_error("texture 2 initialization");
- return;
+ /* Need to flip the texture top for bottom for some reason. */
+ glMatrixMode (GL_TEXTURE);
+ glScalef (1, -1, 1);
+ glMatrixMode (GL_MODELVIEW);
}
-#endif
-/* lame way to generate some random stars */
-void generate_stars(int width, int height)
+static void
+init_stars (ModeInfo *mi)
{
+ planetstruct *gp = &planets[MI_SCREEN(mi)];
int i, j;
+ int width = MI_WIDTH(mi);
+ int height = MI_HEIGHT(mi);
+ int size = (width > height ? width : height);
+ int nstars = size * size / 80;
int max_size = 3;
GLfloat inc = 0.5;
int steps = max_size / inc;
+ GLfloat scale = 1;
+
+ if (MI_WIDTH(mi) > 2560) { /* Retina displays */
+ scale *= 2;
+ nstars /= 2;
+ }
- planetstruct *gp = &planets[MI_SCREEN(mi)];
-
gp->starlist = glGenLists(1);
glNewList(gp->starlist, GL_COMPILE);
-
- /* this hackery makes the viewport map one-to-one with Vertex arguments */
- glMatrixMode(GL_PROJECTION);
- glPushMatrix();
- glMatrixMode(GL_PROJECTION);
- glLoadIdentity();
- gluOrtho2D(0, width, 0, height);
- glMatrixMode(GL_MODELVIEW);
- glLoadIdentity();
-
- /* disable depth testing for the stars, so they don't obscure the planet */
- glDisable(GL_DEPTH_TEST);
- glEnable(GL_BLEND);
- glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-
- glColor3f(1,1,1);
-
- glEnable(GL_POINT_SMOOTH);
-
for (j = 1; j <= steps; j++)
{
- glPointSize(inc * j);
- glBegin(GL_POINTS);
- for(i = 0 ; i < NUM_STARS / steps; i++)
+ glPointSize(inc * j * scale);
+ glBegin (GL_POINTS);
+ for (i = 0; i < nstars / steps; i++)
{
- glColor3f (0.6 + frand(0.3),
- 0.6 + frand(0.3),
- 0.6 + frand(0.3));
- glVertex2f ((GLfloat) (random() % width),
- (GLfloat) (random() % height));
+ GLfloat d = 0.1;
+ GLfloat r = 0.15 + frand(0.3);
+ GLfloat g = r + frand(d) - d;
+ GLfloat b = r + frand(d) - d;
+
+ GLfloat x = frand(1)-0.5;
+ GLfloat y = frand(1)-0.5;
+ GLfloat z = ((random() & 1)
+ ? frand(1)-0.5
+ : (BELLRAND(1)-0.5)/12); /* milky way */
+ d = sqrt (x*x + y*y + z*z);
+ x /= d;
+ y /= d;
+ z /= d;
+ glColor3f (r, g, b);
+ glVertex3f (x, y, z);
+ gp->starcount++;
}
- glEnd();
+ glEnd ();
}
+ glEndList ();
- /* return to original PROJECT and MODELVIEW */
- glMatrixMode(GL_PROJECTION);
- glPopMatrix();
- glMatrixMode(GL_MODELVIEW);
-
-
- glEndList();
-
+ check_gl_error("stars initialization");
}
-/* Set up lighting */
-static void
-init_sun (ModeInfo * mi)
-{
- GLfloat light[4];
- light[0] = frand(2.0) - 1.0;
- light[1] = frand(2.0) - 1.0;
- light[2] = 1.0;
- light[3] = 0;
-
- glLightfv(GL_LIGHT0, GL_POSITION, light);
-}
-
-/* Initialization function for screen saver */
-static void
-pinit(ModeInfo * mi)
+ENTRYPOINT void
+reshape_planet (ModeInfo *mi, int width, int height)
{
- Bool wire = MI_IS_WIREFRAME(mi);
planetstruct *gp = &planets[MI_SCREEN(mi)];
+ GLfloat h = (GLfloat) height / (GLfloat) width;
- if (wire) {
- glEnable(GL_LINE_SMOOTH);
- do_texture = False;
- }
-
- /* turn on various options we like */
- if (do_texture)
- setup_texture(mi);
- if (do_light)
- setup_light();
+ glXMakeCurrent(MI_DISPLAY(mi), gp->window, *(gp->glx_context));
- setup_face();
+ glViewport(0, 0, (GLint) width, (GLint) height);
+ glMatrixMode(GL_PROJECTION);
+ glLoadIdentity();
+ glFrustum(-1.0, 1.0, -h, h, 5.0, 200.0);
+ glMatrixMode(GL_MODELVIEW);
+ glLoadIdentity();
+ glTranslatef(0.0, 0.0, -40);
- if (do_stars) {
- glEnable(GL_POINT_SMOOTH);
- generate_stars(MI_WIDTH(mi), MI_HEIGHT(mi));
+# ifdef HAVE_MOBILE /* Keep it the same relative size when rotated. */
+ {
+ int o = (int) current_device_rotation();
+ if (o != 0 && o != 180 && o != -180)
+ glScalef (h, h, h);
}
+# endif
- gp->platelist=glGenLists(1);
- glNewList(gp->platelist, GL_COMPILE);
- glPushMatrix ();
- glScalef (RADIUS, RADIUS, RADIUS);
- unit_sphere (STACKS, SLICES, wire);
- glPopMatrix ();
- glEndList();
-
- init_sun (mi);
-}
-
-static void
-draw_sphere(ModeInfo * mi)
-{
- planetstruct *gp = &planets[MI_SCREEN(mi)];
-
- glEnable(GL_DEPTH_TEST);
-
- /* turn on the various attributes for making the sphere look nice */
- if (do_texture)
- glEnable(GL_TEXTURE_2D);
-
- if (do_light)
- {
- glEnable(GL_LIGHTING);
- glEnable(GL_LIGHT0);
- glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
- glEnable(GL_COLOR_MATERIAL);
- }
-
- glCallList(gp->platelist);
-
+ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
-#define RANDSIGN() ((random() & 1) ? 1 : -1)
-
-static void
-pick_velocity (ModeInfo * mi)
+ENTRYPOINT Bool
+planet_handle_event (ModeInfo *mi, XEvent *event)
{
planetstruct *gp = &planets[MI_SCREEN(mi)];
- gp->box_width = 15.0;
- gp->box_height = 15.0;
- gp->box_depth = 5.0;
-
- gp->tx = 0.0;
- gp->ty = 0.0;
- gp->tz = frand(360);
+ if (gltrackball_event_handler (event, gp->trackball,
+ MI_WIDTH (mi), MI_HEIGHT (mi),
+ &gp->button_down_p))
+ return True;
- gp->dtx = (frand(0.4) + frand(0.3)) * RANDSIGN();
- gp->dty = (frand(0.4) + frand(0.3)) * RANDSIGN();
- gp->dtz = (frand(5.0) + frand(5.0)); /* the sun sets in the west */
-
- gp->dx = (frand(0.2) + frand(0.2)) * RANDSIGN();
- gp->dy = (frand(0.2) + frand(0.2)) * RANDSIGN();
- gp->dz = (frand(0.2) + frand(0.2)) * RANDSIGN();
+ return False;
}
-static void
-rotate_and_move (ModeInfo * mi)
+ENTRYPOINT void
+init_planet (ModeInfo * mi)
{
- planetstruct *gp = &planets[MI_SCREEN(mi)];
-
- if (do_roll)
- {
- gp->tx += gp->dtx;
- while (gp->tx < 0) gp->tx += 360;
- while (gp->tx > 360) gp->tx -= 360;
-
- gp->ty += gp->dty;
- while (gp->ty < 0) gp->ty += 360;
- while (gp->ty > 360) gp->ty -= 360;
- }
-
- if (do_rotate)
- {
- gp->tz += gp->dtz;
- while (gp->tz < 0) gp->tz += 360;
- while (gp->tz > 360) gp->tz -= 360;
- }
-
- if (do_bounce)
- {
- static int frame = 0;
-# define SINOID(SCALE,SIZE) \
- ((((1 + sin((frame * (SCALE)) / 2 * M_PI)) / 2.0) * (SIZE)) - (SIZE)/2)
- gp->xpos = SINOID(0.031, gp->box_width);
- gp->ypos = SINOID(0.023, gp->box_height);
- gp->zpos = SINOID(0.017, gp->box_depth);
- frame++;
- }
-}
-
-
-/* Standard reshape function */
-void
-reshape_planet(ModeInfo *mi, int width, int height)
-{
- GLfloat h = (GLfloat) height / (GLfloat) width;
-
- glViewport(0, 0, (GLint) width, (GLint) height);
- glMatrixMode(GL_PROJECTION);
- glLoadIdentity();
- glFrustum(-1.0, 1.0, -h, h, 5.0, 100.0);
- glMatrixMode(GL_MODELVIEW);
- glLoadIdentity();
- glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
- glTranslatef(0.0, 0.0, -DIST);
-}
-
-
-void
-init_planet(ModeInfo * mi)
-{
- int screen = MI_SCREEN(mi);
-
planetstruct *gp;
+ int screen = MI_SCREEN(mi);
+ Bool wire = MI_IS_WIREFRAME(mi);
- if (planets == NULL) {
- if ((planets = (planetstruct *) calloc(MI_NUM_SCREENS(mi),
- sizeof (planetstruct))) == NULL)
- return;
- }
+ MI_INIT (mi, planets);
gp = &planets[screen];
- pick_velocity (mi);
+ gp->window = MI_WINDOW(mi);
+
+ if ((gp->glx_context = init_GL(mi)) != NULL) {
+ reshape_planet(mi, MI_WIDTH(mi), MI_HEIGHT(mi));
+ }
{
- char *f = get_string_resource("imageForeground", "Foreground");
- char *b = get_string_resource("imageBackground", "Background");
+ char *f = get_string_resource(mi->dpy, "imageForeground", "Foreground");
+ char *b = get_string_resource(mi->dpy, "imageBackground", "Background");
char *s;
if (!f) f = strdup("white");
if (!b) b = strdup("black");
free (b);
}
-
- gp->window = MI_WINDOW(mi);
- if ((gp->glx_context = init_GL(mi)) != NULL) {
- reshape_planet(mi, MI_WIDTH(mi), MI_HEIGHT(mi));
- pinit(mi);
- } else {
- MI_CLEARWINDOW(mi);
+ {
+ double spin_speed = 0.1;
+ double wander_speed = 0.005;
+ gp->rot = make_rotator (do_roll ? spin_speed : 0,
+ do_roll ? spin_speed : 0,
+ 0, 1,
+ do_wander ? wander_speed : 0,
+ True);
+ gp->z = frand (1.0);
+ gp->tilt = frand (23.4);
+ gp->trackball = gltrackball_init (True);
}
+
+ if (wire)
+ do_texture = False;
+
+ if (do_texture)
+ setup_texture (mi);
+
+ if (do_stars)
+ init_stars (mi);
+
+ /* construct the polygons of the planet
+ */
+ gp->platelist = glGenLists(1);
+ glNewList (gp->platelist, GL_COMPILE);
+ glFrontFace(GL_CCW);
+ glPushMatrix();
+ glRotatef (90, 1, 0, 0);
+ unit_sphere (resolution, resolution, wire);
+ glPopMatrix();
+ glEndList();
+
+ gp->shadowlist = glGenLists(1);
+ glNewList (gp->shadowlist, GL_COMPILE);
+ glFrontFace(GL_CCW);
+ unit_dome (resolution, resolution, wire);
+ glEndList();
+
+ /* construct the polygons of the latitude/longitude/axis lines.
+ */
+ gp->latlonglist = glGenLists(1);
+ glNewList (gp->latlonglist, GL_COMPILE);
+ glPushMatrix ();
+ glRotatef (90, 1, 0, 0); /* unit_sphere is off by 90 */
+ glRotatef (8, 0, 1, 0); /* line up the time zones */
+ unit_sphere (12, 24, 1);
+ unit_sphere (12, 24, 1);
+ glBegin(GL_LINES);
+ glVertex3f(0, -2, 0);
+ glVertex3f(0, 2, 0);
+ glEnd();
+ glPopMatrix ();
+ glEndList();
}
-void
-draw_planet(ModeInfo * mi)
+
+ENTRYPOINT void
+draw_planet (ModeInfo * mi)
{
planetstruct *gp = &planets[MI_SCREEN(mi)];
- Display *display = MI_DISPLAY(mi);
- Window window = MI_WINDOW(mi);
+ int wire = MI_IS_WIREFRAME(mi);
+ Display *dpy = MI_DISPLAY(mi);
+ Window window = MI_WINDOW(mi);
+ double x, y, z;
if (!gp->glx_context)
return;
glDrawBuffer(GL_BACK);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
- glXMakeCurrent(display, window, *(gp->glx_context));
+ glXMakeCurrent (dpy, window, *(gp->glx_context));
+ mi->polygon_count = 0;
- if (do_stars) {
- /* protect our modelview matrix and attributes */
- glPushMatrix();
- glCallList(gp->starlist);
- glPopMatrix();
- }
+ if (gp->button_down_p)
+ gp->draw_axis = 60;
+ else if (!gp->draw_axis && !(random() % 1000))
+ gp->draw_axis = 60 + (random() % 90);
+
+ if (do_rotate && !gp->button_down_p)
+ {
+ gp->z -= 0.001; /* the sun sets in the west */
+ if (gp->z < 0) gp->z += 1;
+ }
+
+ glEnable(GL_LINE_SMOOTH);
+ glEnable(GL_POINT_SMOOTH);
+ glEnable(GL_DEPTH_TEST);
+ glEnable(GL_CULL_FACE);
+ glCullFace(GL_BACK);
- /* protect our modelview matrix and attributes */
glPushMatrix();
- glPushAttrib(GL_ALL_ATTRIB_BITS);
- {
- /* this pair of rotations seem to be necessary to orient the earth correctly */
- glRotatef(90,0,0,1);
- glRotatef(90,0,1,0);
-
- glTranslatef(gp->xpos, gp->ypos, gp->zpos);
- glRotatef(gp->tx, 1, 0, 0);
- glRotatef(gp->ty, 0, 1, 0);
- glRotatef(gp->tz, 0, 0, 1);
- /* draw the sphere */
- draw_sphere(mi);
- }
+
+ get_position (gp->rot, &x, &y, &z, !gp->button_down_p);
+ x = (x - 0.5) * 6;
+ y = (y - 0.5) * 6;
+ z = (z - 0.5) * 3;
+ glTranslatef(x, y, z);
+
+ gltrackball_rotate (gp->trackball);
+
+ if (do_roll)
+ {
+ get_rotation (gp->rot, &x, &y, 0, !gp->button_down_p);
+ glRotatef (x * 360, 1.0, 0.0, 0.0);
+ glRotatef (y * 360, 0.0, 1.0, 0.0);
+ }
+ else
+ glRotatef (current_device_rotation(), 0, 0, 1);
+
+ if (do_stars)
+ {
+ glDisable(GL_TEXTURE_2D);
+ glPushMatrix();
+ glScalef (60, 60, 60);
+ glRotatef (90, 1, 0, 0);
+ glRotatef (35, 1, 0, 0);
+ glCallList (gp->starlist);
+ mi->polygon_count += gp->starcount;
+ glPopMatrix();
+ glClear(GL_DEPTH_BUFFER_BIT);
+ }
+
+ glRotatef (90, 1, 0, 0);
+ glRotatef (35, 1, 0, 0);
+ glRotatef (10, 0, 1, 0);
+ glRotatef (120, 0, 0, 1);
+
+ glScalef (3, 3, 3);
+
+# ifdef HAVE_MOBILE
+ glScalef (2, 2, 2);
+# endif
+
+ if (wire)
+ glColor3f (0.5, 0.5, 1);
+ else
+ glColor3f (1, 1, 1);
+
+ if (do_texture)
+ {
+ glEnable(GL_TEXTURE_2D);
+ glBindTexture (GL_TEXTURE_2D, gp->tex1);
+ }
+
+ glPushMatrix();
+ glRotatef (gp->z * 360, 0, 0, 1);
+ glCallList (gp->platelist);
+ mi->polygon_count += resolution*resolution;
glPopMatrix();
- glPopAttrib();
+ /* Originally we just used GL_LIGHT0 to produce the day/night sides of
+ the planet, but that always looked crappy, even with a vast number of
+ polygons, because the day/night terminator didn't exactly line up with
+ the polygon edges.
+
+ So instead, draw the full "day" sphere; clear the depth buffer; draw
+ a rotated/tilted half-sphere into the depth buffer only; then draw
+ the "night" sphere. That lets us divide the sphere into the two maps,
+ and the dividing line can be at any angle, regardless of polygon layout.
+ The half-sphere is scaled slightly larger to avoid polygon fighting,
+ since those triangles won't exactly line up because of the rotation.
+
+ The downside of this is that the day/night terminator is 100% sharp.
+ It would be nice if it was a little blurry.
+ */
+
+ if (wire)
+ {
+ glPushMatrix();
+ glRotatef (gp->tilt, 1, 0, 0);
+ glColor3f(0, 0, 0);
+ glLineWidth(4);
+ glCallList (gp->shadowlist);
+ glLineWidth(1);
+ mi->polygon_count += resolution*(resolution/2);
+ glPopMatrix();
+ }
+ else if (do_texture && gp->tex2)
+ {
+ glClear(GL_DEPTH_BUFFER_BIT);
+ glDisable(GL_TEXTURE_2D);
+ glColorMask (0, 0, 0, 0);
+ glPushMatrix();
+ glRotatef (gp->tilt, 1, 0, 0);
+ glScalef (1.01, 1.01, 1.01);
+ glCallList (gp->shadowlist);
+ mi->polygon_count += resolution*(resolution/2);
+ glPopMatrix();
+ glColorMask (1, 1, 1, 1);
+ glEnable(GL_TEXTURE_2D);
+
+ glBindTexture (GL_TEXTURE_2D, gp->tex2);
+ glPushMatrix();
+ glRotatef (gp->z * 360, 0, 0, 1);
+ glCallList (gp->platelist);
+ mi->polygon_count += resolution*resolution;
+ glPopMatrix();
+ }
+
+ if (gp->draw_axis)
+ {
+ glPushMatrix();
+ glRotatef (gp->z * 360, 0.0, 0.0, 1.0);
+ glScalef (1.02, 1.02, 1.02);
+ glDisable (GL_TEXTURE_2D);
+ glDisable (GL_LIGHTING);
+ glDisable (GL_LINE_SMOOTH);
+ glColor3f (0.1, 0.3, 0.1);
+ glCallList (gp->latlonglist);
+ mi->polygon_count += 24*24;
+ glPopMatrix();
+ if (gp->draw_axis) gp->draw_axis--;
+ }
+ glPopMatrix();
if (mi->fps_p) do_fps (mi);
glFinish();
- glXSwapBuffers(display, window);
-
- rotate_and_move (mi);
+ glXSwapBuffers(dpy, window);
}
-void
-release_planet(ModeInfo * mi)
+
+ENTRYPOINT void
+free_planet (ModeInfo * mi)
{
- if (planets != NULL) {
- int screen;
-
- for (screen = 0; screen < MI_NUM_SCREENS(mi); screen++) {
- planetstruct *gp = &planets[screen];
-
- if (gp->glx_context) {
- /* Display lists MUST be freed while their glXContext is current. */
- glXMakeCurrent(MI_DISPLAY(mi), gp->window, *(gp->glx_context));
-
- if (glIsList(gp->platelist))
- glDeleteLists(gp->platelist, 1);
- if (glIsList(gp->starlist))
- glDeleteLists(gp->starlist, 1);
- }
- }
- (void) free((void *) planets);
- planets = NULL;
+ planetstruct *gp = &planets[MI_SCREEN(mi)];
+
+ if (gp->glx_context) {
+ glXMakeCurrent(MI_DISPLAY(mi), gp->window, *(gp->glx_context));
+
+ if (glIsList(gp->platelist))
+ glDeleteLists(gp->platelist, 1);
+ if (glIsList(gp->starlist))
+ glDeleteLists(gp->starlist, 1);
}
- FreeAllGL(mi);
}
-#endif
+XSCREENSAVER_MODULE_2 ("GLPlanet", glplanet, planet)
+#endif