*
*/
-#include <X11/Intrinsic.h>
-
#ifdef STANDALONE
-# define PROGCLASS "Jigglypuff"
-# define HACK_INIT init_jigglypuff
-# define HACK_DRAW draw_jigglypuff
-# define HACK_RESHAPE reshape_jigglypuff
-# define HACK_HANDLE_EVENT jigglypuff_handle_event
-# define EVENT_MASK PointerMotionMask
-# define jigglypuff_opts xlockmore_opts
-
-#define DEF_COLOR "cycle"
-#define DEF_SHININESS "100"
-#define DEF_COMPLEXITY "2"
-#define DEF_SPEED "500"
-#define DEF_DISTANCE "100"
-#define DEF_HOLD "800"
-#define DEF_SPHERISM "75"
-#define DEF_DAMPING "500"
-
# define DEFAULTS "*delay: 20000\n" \
"*showFPS: False\n" \
"*wireframe: False\n" \
+# define refresh_jigglypuff 0
+# define release_jigglypuff 0
# include "xlockmore.h"
#else
# include "xlock.h"
#include "../images/jigglymap.xpm"
#ifdef USE_GL
-#include <GL/gl.h>
+
+
+#define DEF_COLOR "cycle"
+#define DEF_SHININESS "100"
+#define DEF_COMPLEXITY "2"
+#define DEF_SPEED "500"
+#define DEF_DISTANCE "100"
+#define DEF_HOLD "800"
+#define DEF_SPHERISM "75"
+#define DEF_DAMPING "500"
#ifndef max
#define max(a,b) (((a)>(b))?(a):(b))
};
static argtype vars[] = {
- {&random_parms, "random", "Random", "False", t_Bool},
+ {&random_parms, "random", "Random", "True", t_Bool},
{&do_tetrahedron, "tetra", "Tetra", "False", t_Bool},
{&spooky, "spooky", "Spooky", "0", t_Int},
{&color, "color", "Color", DEF_COLOR, t_String},
#undef countof
#define countof(x) ((int)(sizeof(x)/sizeof(*(x))))
-ModeSpecOpt jigglypuff_opts = {countof(opts), opts, countof(vars), vars, NULL};
+ENTRYPOINT ModeSpecOpt jigglypuff_opts = {countof(opts), opts, countof(vars), vars, NULL};
#define COLOR_STYLE_NORMAL 0
#define COLOR_STYLE_CYCLE 1
#define CLOWNBARF_NCOLORS 5
-static GLfloat clownbarf_colors[CLOWNBARF_NCOLORS][4] = {
+static const GLfloat clownbarf_colors[CLOWNBARF_NCOLORS][4] = {
{0.7, 0.7, 0.0, 1.0},
{0.8, 0.1, 0.1, 1.0},
{0.1, 0.1, 0.8, 1.0},
{0.0, 0.0, 0.0, 1.0}
};
-static GLfloat flowerbox_colors[4][4] = {
+static const GLfloat flowerbox_colors[4][4] = {
{0.7, 0.7, 0.0, 1.0},
{0.9, 0.0, 0.0, 1.0},
{0.0, 0.9, 0.0, 1.0},
struct face {
solid *s;
hedge *start;
- GLfloat *color;
+ const GLfloat *color;
face *next;
};
}
}
-vertex *vertex_new(solid *s, vector v)
+static vertex *vertex_new(solid *s, vector v)
{
vertex *vtx = (vertex*)malloc(sizeof(vertex));
* i.e. it is a helper for the split_* functions, which
* maintain the consistency of the solid.
*/
-hedge *hedge_new(hedge *hafter, vertex *vtx)
+static hedge *hedge_new(hedge *hafter, vertex *vtx)
{
hedge *h = (hedge*)malloc(sizeof(hedge));
return h;
}
-edge *edge_new(solid *s)
+static edge *edge_new(solid *s)
{
edge *e = (edge*)malloc(sizeof(edge));
if(!e) {
return e;
}
-face *face_new(solid *s, hedge *h)
+static face *face_new(solid *s, hedge *h)
{
face *f = (face*)malloc(sizeof(face));
if(!f) {
* the vertex returned will have h==<the new halfedge>.
*/
-vertex *vertex_split(hedge *h, vector v)
+static vertex *vertex_split(hedge *h, vector v)
{
hedge *h2, *hn1, *hn2;
vertex *vtxn;
return vtxn;
}
-face *face_split(face *f, hedge *h1, hedge *h2)
+static face *face_split(face *f, hedge *h1, hedge *h2)
{
hedge *hn1, *hn2, *tmp;
edge *en;
return fn;
}
-solid *solid_new(vector where)
+static solid *solid_new(vector where)
{
solid *s = (solid*)malloc(sizeof(solid));
face *f1, *f2;
}
/* This is all the code directly related to constructing the jigglypuff */
-void face_tessel2(face *f)
+static void face_tessel2(face *f)
{
hedge *h1=f->start->prev, *h2=f->start->next;
* added at the head of the list. If that ever changes,
* this is borked.
*/
-void solid_tesselate(solid *s)
+static void solid_tesselate(solid *s)
{
edge *e = s->edges;
face *f = s->faces;
}
}
-void solid_spherify(solid * s, coord size)
+static void solid_spherify(solid * s, coord size)
{
vertex *vtx = s->vertices;
}
}
-solid *tetrahedron(jigglystruct *js)
+static solid *tetrahedron(jigglystruct *js)
{
solid *s;
vertex *vtx;
return s;
}
-solid *tesselated_tetrahedron(coord size, int iter, jigglystruct *js) {
+static solid *tesselated_tetrahedron(coord size, int iter, jigglystruct *js) {
solid *s = tetrahedron(js);
int i;
glEnd();
}
-void jigglypuff_render(jigglystruct *js)
+static void jigglypuff_render(jigglystruct *js)
{
face *f = js->shape->faces;
vertex *vtx = js->shape->vertices;
/* stable distance when subdivs == 4 */
#define STABLE_DISTANCE 0.088388347648
-void update_shape(jigglystruct *js)
+static void update_shape(jigglystruct *js)
{
vertex *vtx = js->shape->vertices;
edge *e = js->shape->edges;
/* These are the various initialization routines */
-void init_texture(ModeInfo *mi)
+static void init_texture(ModeInfo *mi)
{
XImage *img = xpm_to_ximage(mi->dpy, mi->xgwa.visual,
mi->xgwa.colormap, jigglymap_xpm);
XDestroyImage(img);
}
-void setup_opengl(ModeInfo *mi, jigglystruct *js)
+static void setup_opengl(ModeInfo *mi, jigglystruct *js)
{
const GLfloat lpos0[4] = {-12, 8, 12, 0};
const GLfloat lpos1[4] = {7, -5, 0, 0};
}
}
-int parse_color(jigglystruct *js)
+static int parse_color(jigglystruct *js)
{
unsigned int r, g, b;
if(!strcmp(color, "clownbarf")) {
return 1;
}
-void randomize_parameters(jigglystruct *js) {
+static void randomize_parameters(jigglystruct *js) {
do_tetrahedron = random() & 1;
js->do_wireframe = !(random() & 3);
js->color_style = random() % 5;
damping = (random() % 800) + 50;
}
-void calculate_parameters(jigglystruct *js, int subdivs) {
+static void calculate_parameters(jigglystruct *js, int subdivs) {
/* try to compensate for the inherent instability at
* low complexity. */
float dist_factor = (subdivs == 6) ? 2 : (subdivs == 5) ? 1 : 0.5;
/* The screenhack related functions begin here */
-Bool jigglypuff_handle_event(ModeInfo *mi, XEvent *event)
+ENTRYPOINT Bool jigglypuff_handle_event(ModeInfo *mi, XEvent *event)
{
jigglystruct *js = &jss[MI_SCREEN(mi)];
return False;
}
-void reshape_jigglypuff(ModeInfo *mi, int width, int height)
+ENTRYPOINT void reshape_jigglypuff(ModeInfo *mi, int width, int height)
{
GLfloat aspect = (GLfloat)width / (GLfloat)height;
/* glTranslatef(0, 0, -10);*/
}
-void draw_jigglypuff(ModeInfo *mi)
+ENTRYPOINT void draw_jigglypuff(ModeInfo *mi)
{
jigglystruct *js = &jss[MI_SCREEN(mi)];
glXSwapBuffers(MI_DISPLAY(mi), MI_WINDOW(mi));
}
-void init_jigglypuff(ModeInfo *mi)
+ENTRYPOINT void init_jigglypuff(ModeInfo *mi)
{
jigglystruct *js;
int subdivs;
if(random_parms)
randomize_parameters(js);
+ js->angle = frand(180);
+ js->axis = frand(M_PI);
+
js->shape = tesselated_tetrahedron(1, subdivs, js);
if(!do_tetrahedron)
js->do_wireframe, js->spooky, js->color_style, js->shininess);*/
}
-/* This is the end of the file */
+XSCREENSAVER_MODULE ("Jigglypuff", jigglypuff)
#endif /* USE_GL */
-
-
-
-
-
-
+/* This is the end of the file */
projects / xscreensaver / blobdiff