-/* -*- Mode: C; tab-width: 4 -*-
- * sproingies.c --- 3D sproingies
- */
-#if !defined( lint ) && !defined( SABER )
-static const char sccsid[] = "@(#)sproingiewrap.c 4.04 97/07/28 xlockmore";
+/* -*- Mode: C; tab-width: 4 -*- */
+/* sproingiewrap.c - sproingies wrapper */
+
+#if 0
+static const char sccsid[] = "@(#)sproingiewrap.c 4.07 97/11/24 xlockmore";
#endif
-/*
+
+/*-
* sproingiewrap.c - Copyright 1996 Sproingie Technologies Incorporated.
- * Source and binary freely distributable under the
- * terms in xlock.c
*
* Permission to use, copy, modify, and distribute this software and its
* documentation for any purpose and without fee is hereby granted,
* event will the author be liable for any lost revenue or profits or
* other special, indirect and consequential damages.
*
- ***************************************************************************
- * Programming: Ed Mackey, http://www.early.com/~emackey/
+ * Programming: Ed Mackey, http://www.netaxs.com/~emackey/
+ * Gordon Wrigley, gdw33@student.canterbury.ac.nz
+ * Sergio Gutiérrez "Sergut", sergut@gmail.com
* Sproingie 3D objects modeled by: Al Mackey, al@iam.com
* (using MetaNURBS in NewTek's Lightwave 3D v5).
*
* Revision History:
+ * 01-Sep-06: Make the sproingies select a new direction after each hop
+ * (6 frames); if they fall towards the edge, they explode.
+ * (TODO: let them fall for a time before they explode or
+ * disappear) [sergut]
+ * 13-Dec-02: Changed triangle normals into vertex normals to give a smooth
+ * apperance and moved the sproingies from Display Lists to
+ * Vertex Arrays, still need to do this for the TopsSides.
+ * [gordon]
* 26-Apr-97: Added glPointSize() calls around explosions, plus other fixes.
* 28-Mar-97: Added size support.
* 22-Mar-97: Updated to use glX interface instead of xmesa one.
* xlockmore's built-in Mesa/OpenGL support instead of
* my own. Submitted for inclusion in xlockmore.
* 09-Dec-96: Written.
- *
- * Ed Mackey
- */
-
-/*-
- * The sproingies have six "real" frames, (s1_1 to s1_6) that show a
- * sproingie jumping off a block, headed down and to the right. But
- * the program thinks of sproingies as having twelve "virtual" frames,
- * with the latter six being copies of the first, only lowered and
- * rotated by 90 degrees (jumping to the left). So after going
- * through 12 frames, a sproingie has gone down two rows but not
- * moved horizontally.
- *
- * To have the sproingies randomly choose left/right jumps at each
- * block, the program should go back to thinking of only 6 frames,
- * and jumping down only one row when it is done. Then it can pick a
- * direction for the next row.
- *
- * (Falling off the end might not be so bad either. :) )
*/
#ifdef STANDALONE
-# define PROGCLASS "Sproingies"
-# define HACK_INIT init_sproingies
-# define HACK_DRAW draw_sproingies
-# define sproingies_opts xlockmore_opts
-# define DEFAULTS "*count: 5 \n" \
- "*cycles: 0 \n" \
- "*delay: 100 \n" \
+# define DEFAULTS "*delay: 30000 \n" \
+ "*count: 8 \n" \
"*size: 0 \n" \
+ "*showFPS: False \n" \
+ "*fpsTop: True \n" \
"*wireframe: False \n"
+
+# define refresh_sproingies 0
+# define sproingies_handle_event 0
# include "xlockmore.h" /* from the xscreensaver distribution */
#else /* !STANDALONE */
# include "xlock.h" /* from the xlockmore distribution */
#ifdef USE_GL
-ModeSpecOpt sproingies_opts = {
- 0, NULL, 0, NULL, NULL };
+#define DEF_SMART_SPROINGIES "True" /* Smart sproingies do not fall down the edge */
+
+#include "sproingies.h"
+
+#undef countof
+#define countof(x) (sizeof((x))/sizeof((*x)))
+
+static XrmOptionDescRec opts[] = {
+ {"-fall", ".smartSproingies", XrmoptionNoArg, "False"},
+ {"-no-fall", ".smartSproingies", XrmoptionNoArg, "True"},
+};
+
+static int smrt_spr;
+
+static argtype vars[] = {
+ {&smrt_spr, "smartSproingies", "Boolean", DEF_SMART_SPROINGIES, t_Bool},
+};
+
+ENTRYPOINT ModeSpecOpt sproingies_opts =
+{countof(opts), opts, countof(vars), vars, NULL};
+
+#ifdef USE_MODULES
+ModStruct sproingies_description =
+{"sproingies", "init_sproingies", "draw_sproingies", "release_sproingies",
+ "refresh_sproingies", "init_sproingies", NULL, &sproingies_opts,
+ 1000, 5, 0, 400, 4, 1.0, "",
+ "Shows Sproingies! Nontoxic. Safe for pets and small children", 0, NULL};
+
+#endif
#define MINSIZE 32
-#include <GL/glu.h>
#include <time.h>
void NextSproingie(int screen);
-void NextSproingieDisplay(int screen);
-void DisplaySproingies(int screen);
-#if 0
+void NextSproingieDisplay(int screen,int pause);
+void DisplaySproingies(int screen,int pause);
void ReshapeSproingies(int w, int h);
-#endif
void CleanupSproingies(int screen);
-void InitSproingies(int wfmode, int grnd, int mspr, int screen, int numscreens, int mono);
+void InitSproingies(int wfmode, int grnd, int mspr, int smrtspr,
+ int screen, int numscreens, int mono);
typedef struct {
GLfloat view_rotx, view_roty, view_rotz;
GLfloat angle;
GLuint limit;
GLuint count;
- GLXContext glx_context;
+ GLXContext *glx_context;
int mono;
+ Window window;
} sproingiesstruct;
static sproingiesstruct *sproingies = NULL;
-static Display *swap_display;
-static Window swap_window;
-void
-SproingieSwap(void)
+ENTRYPOINT void
+init_sproingies (ModeInfo * mi)
{
- glFinish();
- glXSwapBuffers(swap_display, swap_window);
-}
+ Window window = MI_WINDOW(mi);
+ int screen = MI_SCREEN(mi);
+
+ int count = MI_COUNT(mi);
+ int size = MI_SIZE(mi);
+
+ sproingiesstruct *sp;
+ int wfmode = 0, grnd = 0, mspr, w, h;
+
+ if (sproingies == NULL) {
+ if ((sproingies = (sproingiesstruct *) calloc(MI_NUM_SCREENS(mi),
+ sizeof (sproingiesstruct))) == NULL)
+ return;
+ }
+ sp = &sproingies[screen];
+
+ sp->mono = (MI_IS_MONO(mi) ? 1 : 0);
+ sp->window = window;
+ if ((sp->glx_context = init_GL(mi)) != NULL) {
+
+ if (MI_IS_WIREFRAME(mi))
+ wfmode = 1;
+
+ if (grnd > 2)
+ grnd = 2;
+
+ mspr = count;
+ if (mspr > 100)
+ mspr = 100;
+
+ /* wireframe, ground, maxsproingies */
+ InitSproingies(wfmode, grnd, mspr, smrt_spr, MI_SCREEN(mi), MI_NUM_SCREENS(mi), sp->mono);
+
+ /* Viewport is specified size if size >= MINSIZE && size < screensize */
+ if (size == 0) {
+ w = MI_WIDTH(mi);
+ h = MI_HEIGHT(mi);
+ } else if (size < MINSIZE) {
+ w = MINSIZE;
+ h = MINSIZE;
+ } else {
+ w = (size > MI_WIDTH(mi)) ? MI_WIDTH(mi) : size;
+ h = (size > MI_HEIGHT(mi)) ? MI_HEIGHT(mi) : size;
+ }
+
+ glViewport((MI_WIDTH(mi) - w) / 2, (MI_HEIGHT(mi) - h) / 2, w, h);
+ glMatrixMode(GL_PROJECTION);
+ glLoadIdentity();
+ gluPerspective(65.0, (GLfloat) w / (GLfloat) h, 0.1, 2000.0); /* was 200000.0 */
+ glMatrixMode(GL_MODELVIEW);
+ glLoadIdentity();
+ DisplaySproingies(MI_SCREEN(mi),mi->pause);
+
+ } else {
+ MI_CLEARWINDOW(mi);
+ }
+}
/* ARGSUSED */
-void
-draw_sproingies(ModeInfo * mi)
+ENTRYPOINT void
+draw_sproingies (ModeInfo * mi)
{
sproingiesstruct *sp = &sproingies[MI_SCREEN(mi)];
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
+ if (!sp->glx_context)
+ return;
+
glDrawBuffer(GL_BACK);
- glXMakeCurrent(display, window, sp->glx_context);
+ glXMakeCurrent(display, window, *(sp->glx_context));
- swap_display = display;
- swap_window = window;
+ NextSproingieDisplay(MI_SCREEN(mi),mi->pause); /* It will swap. */
- NextSproingieDisplay(MI_SCREEN(mi)); /* It will swap. */
+ if (mi->fps_p) do_fps (mi);
+ glFinish();
+ glXSwapBuffers(MI_DISPLAY(mi), MI_WINDOW(mi));
}
-void
+#ifndef STANDALONE
+ENTRYPOINT void
refresh_sproingies(ModeInfo * mi)
{
/* No need to do anything here... The whole screen is updated
* with DisplaySproingies(...).
*/
}
+#endif /* !STANDALONE */
+
+ENTRYPOINT void
+reshape_sproingies (ModeInfo *mi, int w, int h)
+{
+ ReshapeSproingies(w, h);
+}
+
-void
-release_sproingies(ModeInfo * mi)
+ENTRYPOINT void
+release_sproingies (ModeInfo * mi)
{
if (sproingies != NULL) {
int screen;
for (screen = 0; screen < MI_NUM_SCREENS(mi); screen++) {
sproingiesstruct *sp = &sproingies[screen];
- glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), sp->glx_context);
- CleanupSproingies(MI_SCREEN(mi));
- }
+ if (sp->glx_context) {
- /* Don't destroy the glXContext. init_GL does that. */
+ glXMakeCurrent(MI_DISPLAY(mi), sp->window, *(sp->glx_context));
+ CleanupSproingies(MI_SCREEN(mi));
+ }
+ }
(void) free((void *) sproingies);
sproingies = NULL;
}
+ FreeAllGL(mi);
}
-void
-init_sproingies(ModeInfo * mi)
-{
- Display *display = MI_DISPLAY(mi);
- Window window = MI_WINDOW(mi);
- int screen = MI_SCREEN(mi);
-
- int cycles = MI_CYCLES(mi);
- int batchcount = MI_BATCHCOUNT(mi);
- int size = MI_SIZE(mi);
-
- sproingiesstruct *sp;
- int wfmode = 0, grnd, mspr, w, h;
+XSCREENSAVER_MODULE ("Sproingies", sproingies)
- if (sproingies == NULL) {
- if ((sproingies = (sproingiesstruct *) calloc(MI_NUM_SCREENS(mi),
- sizeof (sproingiesstruct))) == NULL)
- return;
- }
- sp = &sproingies[screen];
-
- sp->mono = (MI_WIN_IS_MONO(mi) ? 1 : 0);
-
- sp->glx_context = init_GL(mi);
-
- if ((cycles & 1) || MI_WIN_IS_WIREFRAME(mi) || sp->mono)
- wfmode = 1;
- grnd = (cycles >> 1);
- if (grnd > 2)
- grnd = 2;
-
- mspr = batchcount;
- if (mspr > 100)
- mspr = 100;
-
- /* wireframe, ground, maxsproingies */
- InitSproingies(wfmode, grnd, mspr, MI_SCREEN(mi), MI_NUM_SCREENS(mi), sp->mono);
-
- /* Viewport is specified size if size >= MINSIZE && size < screensize */
- if (size == 0) {
- w = MI_WIN_WIDTH(mi);
- h = MI_WIN_HEIGHT(mi);
- } else if (size < MINSIZE) {
- w = MINSIZE;
- h = MINSIZE;
- } else {
- w = (size > MI_WIN_WIDTH(mi)) ? MI_WIN_WIDTH(mi) : size;
- h = (size > MI_WIN_HEIGHT(mi)) ? MI_WIN_HEIGHT(mi) : size;
- }
-
- glViewport((MI_WIN_WIDTH(mi) - w) / 2, (MI_WIN_HEIGHT(mi) - h) / 2, w, h);
- glMatrixMode(GL_PROJECTION);
- glLoadIdentity();
- gluPerspective(65.0, (GLfloat) w / (GLfloat) h, 0.1, 2000.0); /* was 200000.0 */
- glMatrixMode(GL_MODELVIEW);
- glLoadIdentity();
-
- swap_display = display;
- swap_window = window;
- DisplaySproingies(MI_SCREEN(mi));
-}
-
-#endif
+#endif /* USE_GL */
/* End of sproingiewrap.c */
projects / xscreensaver / blobdiff