X-Git-Url: http://git.hungrycats.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=hacks%2Fglx%2Fsproingiewrap.c;fp=hacks%2Fglx%2Fsproingiewrap.c;h=dff236b08cef160a6b87e0718d133d429b0e5246;hb=df7adbee81405e2849728a24b498ad2117784b1f;hp=0000000000000000000000000000000000000000;hpb=41fae2ad67bc37e31c4d967bae81e4f3f50fa55a;p=xscreensaver diff --git a/hacks/glx/sproingiewrap.c b/hacks/glx/sproingiewrap.c new file mode 100644 index 00000000..dff236b0 --- /dev/null +++ b/hacks/glx/sproingiewrap.c @@ -0,0 +1,244 @@ +/* -*- Mode: C; tab-width: 4 -*- */ +/* sproingiewrap.c - sproingies wrapper */ + +#if !defined( lint ) && !defined( SABER ) +static const char sccsid[] = "@(#)sproingiewrap.c 4.07 97/11/24 xlockmore"; + +#endif + +/*- + * sproingiewrap.c - Copyright 1996 Sproingie Technologies Incorporated. + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose and without fee is hereby granted, + * provided that the above copyright notice appear in all copies and that + * both that copyright notice and this permission notice appear in + * supporting documentation. + * + * This file is provided AS IS with no warranties of any kind. The author + * shall have no liability with respect to the infringement of copyrights, + * trade secrets or any patents by this file or any part thereof. In no + * event will the author be liable for any lost revenue or profits or + * other special, indirect and consequential damages. + * + * Programming: Ed Mackey, http://www.netaxs.com/~emackey/ + * Sproingie 3D objects modeled by: Al Mackey, al@iam.com + * (using MetaNURBS in NewTek's Lightwave 3D v5). + * + * Revision History: + * 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. + * Also, support for multiscreens added. + * 20-Mar-97: Updated for xlockmore v4.02alpha7 and higher, using + * xlockmore's built-in Mesa/OpenGL support instead of + * my own. Submitted for inclusion in xlockmore. + * 09-Dec-96: Written. + */ + +/*- + * 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 "*delay: 100 \n" \ + "*count: 5 \n" \ + "*cycles: 0 \n" \ + "*size: 0 \n" \ + "*wireframe: False \n" +# include "xlockmore.h" /* from the xscreensaver distribution */ +#else /* !STANDALONE */ +# include "xlock.h" /* from the xlockmore distribution */ +#endif /* !STANDALONE */ + +#ifdef USE_GL + +ModeSpecOpt sproingies_opts = +{0, NULL, 0, NULL, 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 +#include + +void NextSproingie(int screen); +void NextSproingieDisplay(int screen); +void DisplaySproingies(int screen); + +#if 0 +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); + +typedef struct { + GLfloat view_rotx, view_roty, view_rotz; + GLint gear1, gear2, gear3; + GLfloat angle; + GLuint limit; + GLuint count; + GLXContext *glx_context; + int mono; + Window window; +} sproingiesstruct; + +static sproingiesstruct *sproingies = NULL; + +static Display *swap_display; +static Window swap_window; + +void +SproingieSwap(void) +{ + glFinish(); + glXSwapBuffers(swap_display, swap_window); +} + + +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 count = MI_COUNT(mi); + int size = MI_SIZE(mi); + + sproingiesstruct *sp; + int wfmode = 0, grnd, 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 ((cycles & 1) || MI_IS_WIREFRAME(mi)) + wfmode = 1; + grnd = (cycles >> 1); + if (grnd > 2) + grnd = 2; + + mspr = count; + 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_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(); + + swap_display = display; + swap_window = window; + DisplaySproingies(MI_SCREEN(mi)); + } else { + MI_CLEARWINDOW(mi); + } +} + +/* ARGSUSED */ +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)); + + swap_display = display; + swap_window = window; + + NextSproingieDisplay(MI_SCREEN(mi)); /* It will swap. */ +} + +void +refresh_sproingies(ModeInfo * mi) +{ + /* No need to do anything here... The whole screen is updated + * every frame anyway. Otherwise this would be just like + * draw_sproingies, above, but replace NextSproingieDisplay(...) + * with DisplaySproingies(...). + */ +} + +void +release_sproingies(ModeInfo * mi) +{ + if (sproingies != NULL) { + int screen; + + for (screen = 0; screen < MI_NUM_SCREENS(mi); screen++) { + sproingiesstruct *sp = &sproingies[screen]; + + if (sp->glx_context) { + + glXMakeCurrent(MI_DISPLAY(mi), sp->window, *(sp->glx_context)); + CleanupSproingies(MI_SCREEN(mi)); + } + } + + (void) free((void *) sproingies); + sproingies = NULL; + } + FreeAllGL(mi); +} + +#endif + +/* End of sproingiewrap.c */