From 035e96ec3cf25dfa39dcdacb0f0c7b57d9d2b85a Mon Sep 17 00:00:00 2001 From: Jon Taylor Date: Sat, 21 Aug 1999 06:27:37 +0000 Subject: [PATCH] *** empty log message *** --- progs/ggi/asc-view.c | 353 +++++++++++++++++ progs/ggi/blah | 2 + progs/ggi/blat | 7 + progs/ggi/box.asc | 66 ++++ progs/ggi/cone.asc | 198 ++++++++++ progs/ggi/gears.c | 359 ++++++++++++++++++ progs/ggi/gears2.c | 359 ++++++++++++++++++ progs/ggi/sphere.asc | 132 +++++++ progs/ggi/torus.asc | 264 +++++++++++++ progs/ggi/tube.asc | 396 +++++++++++++++++++ src/glut/ggi/EXPSYMS | 2 + src/glut/ggi/ggiglut.c | 840 +++++++++++++++++++++++++++++++++++++++++ 12 files changed, 2978 insertions(+) create mode 100644 progs/ggi/asc-view.c create mode 100644 progs/ggi/blah create mode 100644 progs/ggi/blat create mode 100644 progs/ggi/box.asc create mode 100644 progs/ggi/cone.asc create mode 100644 progs/ggi/gears.c create mode 100644 progs/ggi/gears2.c create mode 100644 progs/ggi/sphere.asc create mode 100644 progs/ggi/torus.asc create mode 100644 progs/ggi/tube.asc create mode 100644 src/glut/ggi/EXPSYMS create mode 100644 src/glut/ggi/ggiglut.c diff --git a/progs/ggi/asc-view.c b/progs/ggi/asc-view.c new file mode 100644 index 00000000000..16f53e55091 --- /dev/null +++ b/progs/ggi/asc-view.c @@ -0,0 +1,353 @@ +/* + test program for the ggi-mesa driver + + Copyright (C) 1997,1998 Uwe Maurer - uwe_maurer@t-online.de + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +*/ + +#include +#include +#include +#include +#include +#include +#include +#include + +ggi_visual_t vis,vis_mem; + +GGIMesaContext ctx; + +int screen_x=320,screen_y=200; +ggi_graphtype bpp=GT_16BIT; + +//#define ZBUFFER + +//#define SMOOTH_NORMALS + +void Init() +{ + GLfloat h=(GLfloat)3/4; + GLfloat pos[4]={5,5,-20,0}; + GLfloat specular[4]={.4,.4,.4,1}; + GLfloat diffuse[4]={.3,.3,.3,1}; + GLfloat ambient[4]={.2,.2,.2,1}; + + int err; + + if (ggiInit()<0) + { + printf("ggiInit() failed\n"); + exit(1); + } + ctx=GGIMesaCreateContext(); + if (ctx==NULL) + { + printf("Can't create Context!\n"); + exit(1); + } + + vis=ggiOpen(NULL); + vis_mem=ggiOpen("display-memory",NULL); + if (vis==NULL || vis_mem==NULL) + { + printf("Can't open ggi_visuals!\n"); + exit(1); + } + err=ggiSetGraphMode(vis,screen_x,screen_y,screen_x,screen_y,bpp); + err+=ggiSetGraphMode(vis_mem,screen_x,screen_y,screen_x,screen_y,bpp); + if (err) + { + printf("Can't set %ix%i\n",screen_x,screen_y); + exit(1); + } + + if (GGIMesaSetVisual(ctx,vis_mem,GL_TRUE,GL_FALSE)<0) + { + printf("GGIMesaSetVisual() failed!\n"); + exit(1); + } + + GGIMesaMakeCurrent(ctx); + + glViewport(0,0,screen_x,screen_y); + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + glFrustum(-1,1,-h,h,1,50); + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + glTranslatef(0,0,-9); + glShadeModel(GL_FLAT); + + glFrontFace(GL_CW); + glEnable(GL_CULL_FACE); + glEnable(GL_LIGHTING); + glEnable(GL_LIGHT0); + + glLightfv(GL_LIGHT0,GL_POSITION,pos); + + glLightfv(GL_LIGHT0,GL_DIFFUSE,diffuse); + glLightfv(GL_LIGHT0,GL_AMBIENT,ambient); + glLightfv(GL_LIGHT0,GL_SPECULAR,specular); + + #ifdef ZBUFFER + glEnable(GL_DEPTH_TEST); + #endif +} + + +#define MAX_VERTS 1000 +#define MAX_TRIS 2000 +#define MAX_LEN 1024 +#define MAX_F 100000000 + +void LoadAsc(GLuint *list,char *file) +{ + FILE *fp; + + GLfloat p[MAX_VERTS][3]; + GLfloat normal[MAX_VERTS][3]; + float ncount[MAX_VERTS]; + int v[MAX_TRIS][3]; + char line[MAX_LEN]; + char *s; + int i,j; + int verts,faces; + GLuint v0,v1,v2; + GLfloat n[3]; + GLfloat len,k; + GLfloat min[3]={MAX_F,MAX_F,MAX_F}; + GLfloat max[3]={-MAX_F,-MAX_F,-MAX_F}; + char *coord_str[]={"X","Z","Y"}; + + fp=fopen(file,"r"); + if (!fp) + { + printf("Can't open %s!\n",file); + exit(1); + } + + while (strncmp(fgets(line,MAX_LEN,fp),"Tri-mesh",8)) ; + + s=strstr(line,":")+1; + verts=atoi(s); + s=strstr(s,":")+1; + faces=atoi(s); + + if (verts>MAX_VERTS) + { + printf("Too many vertices..\n"); + exit(1); + } + + while (strncmp(fgets(line,MAX_LEN,fp),"Vertex list",11)) ; + + for (i=0;imax[j]) max[j]=k; + if (klen) {len=k;j=i;} + n[i]=(max[i]+min[i])/2; + } + + len/=2; + + for (i=0;iread); + rotate+=10; + frames++; + if (frames==(*maxframes)) break; + + if (ggiKbhit(vis)) + { + *maxframes=frames; + break; + } + } + + gettimeofday(&stop,NULL); + len=(double)(stop.tv_sec-start.tv_sec)+ + (double)(stop.tv_usec-start.tv_usec)/1e6; + return len; +} + + +int main(int argc,char **argv) +{ + GLuint l; + char *file; + int maxframes=0; + double len; + + Init(); + + file=(argc>1) ? argv[1] : "asc/box.asc"; + if (argc>2) maxframes=atoi(argv[2]); + + if (argc==1) + { + printf("usage: %s filename.asc\n",argv[0]); + } + + LoadAsc(&l,file); + + len=Display(l,&maxframes); + + printf("\ttime: %.3f sec\n",len); + printf("\tframes: %i\n",maxframes); + printf("\tfps: %.3f \n",(double)maxframes/len); + + GGIMesaDestroyContext(ctx); + ggiClose(vis); + ggiClose(vis_mem); + ggiExit(); + return 0; +} + diff --git a/progs/ggi/blah b/progs/ggi/blah new file mode 100644 index 00000000000..2c1664d7d05 --- /dev/null +++ b/progs/ggi/blah @@ -0,0 +1,2 @@ +Terminating on signal 11 + diff --git a/progs/ggi/blat b/progs/ggi/blat new file mode 100644 index 00000000000..7ff64a9d10d --- /dev/null +++ b/progs/ggi/blat @@ -0,0 +1,7 @@ +#!/bin/sh + +function foobar() { + echo "foo!" +} + +foobar diff --git a/progs/ggi/box.asc b/progs/ggi/box.asc new file mode 100644 index 00000000000..f8b23fd85af --- /dev/null +++ b/progs/ggi/box.asc @@ -0,0 +1,66 @@ +Ambient light color: Red=0.039216 Green=0.039216 Blue=0.039216 + +Named object: "Object01" +Tri-mesh, Vertices: 8 Faces: 12 +Vertex list: +Vertex 0: X: -20 Y: -19.999998 Z: 20.000002 +Vertex 1: X: 20 Y: -19.999998 Z: 20.000002 +Vertex 2: X: 20 Y: 20.000002 Z: 19.999998 +Vertex 3: X: -20 Y: 20.000002 Z: 19.999998 +Vertex 4: X: -20 Y: -20.000002 Z: -19.999998 +Vertex 5: X: 20 Y: -20.000002 Z: -19.999998 +Vertex 6: X: 20 Y: 19.999998 Z: -20.000002 +Vertex 7: X: -20 Y: 19.999998 Z: -20.000002 +Face list: +Face 0: A:0 B:1 C:2 AB:1 BC:1 CA:0 +Smoothing: 1 +Face 1: A:0 B:2 C:3 AB:0 BC:1 CA:1 +Smoothing: 1 +Face 2: A:0 B:4 C:5 AB:1 BC:1 CA:0 +Smoothing: 2 +Face 3: A:0 B:5 C:1 AB:0 BC:1 CA:1 +Smoothing: 2 +Face 4: A:1 B:5 C:6 AB:1 BC:1 CA:0 +Smoothing: 3 +Face 5: A:1 B:6 C:2 AB:0 BC:1 CA:1 +Smoothing: 3 +Face 6: A:2 B:6 C:7 AB:1 BC:1 CA:0 +Smoothing: 4 +Face 7: A:2 B:7 C:3 AB:0 BC:1 CA:1 +Smoothing: 4 +Face 8: A:3 B:7 C:4 AB:1 BC:1 CA:0 +Smoothing: 5 +Face 9: A:3 B:4 C:0 AB:0 BC:1 CA:1 +Smoothing: 5 +Face 10: A:4 B:7 C:6 AB:1 BC:1 CA:0 +Smoothing: 6 +Face 11: A:4 B:6 C:5 AB:0 BC:1 CA:1 +Smoothing: 6 + + + + + + + + + + + + + + + + + + + + + + + + + Page 1 + + + diff --git a/progs/ggi/cone.asc b/progs/ggi/cone.asc new file mode 100644 index 00000000000..5c522859963 --- /dev/null +++ b/progs/ggi/cone.asc @@ -0,0 +1,198 @@ +Ambient light color: Red=0.039216 Green=0.039216 Blue=0.039216 + +Named object: "Object01" +Tri-mesh, Vertices: 34 Faces: 64 +Vertex list: +Vertex 0: X: 60.167416 Y: -87.419525 Z: -53.3088 +Vertex 1: X: 76.70787 Y: -87.419518 Z: -29.84565 +Vertex 2: X: 83.0103 Y: -87.419518 Z: -1.838764 +Vertex 3: X: 78.115204 Y: -87.419518 Z: 26.448057 +Vertex 4: X: 62.767834 Y: -87.41951 Z: 50.708401 +Vertex 5: X: 39.304672 Y: -87.41951 Z: 67.248848 +Vertex 6: X: 11.297782 Y: -87.41951 Z: 73.551254 +Vertex 7: X: -16.989004 Y: -87.41951 Z: 68.656158 +Vertex 8: X: -41.249344 Y: -87.41951 Z: 53.308777 +Vertex 9: X: -57.789783 Y: -87.419518 Z: 29.845612 +Vertex 10: X: -64.092194 Y: -87.419518 Z: 1.838721 +Vertex 11: X: -59.197079 Y: -87.419518 Z: -26.448097 +Vertex 12: X: -43.849678 Y: -87.419525 Z: -50.708427 +Vertex 13: X: -20.386503 Y: -87.419525 Z: -67.248856 +Vertex 14: X: 7.62039 Y: -87.419525 Z: -73.551239 +Vertex 15: X: 35.907204 Y: -87.419525 Z: -68.656105 +Vertex 16: X: 101.684875 Y: 94.590591 Z: -96.955391 +Vertex 17: X: 131.767838 Y: 94.590591 Z: -54.281792 +Vertex 18: X: 143.230377 Y: 94.590599 Z: -3.344275 +Vertex 19: X: 134.327423 Y: 94.590607 Z: 48.102379 +Vertex 20: X: 106.414383 Y: 94.590607 Z: 92.225876 +Vertex 21: X: 63.740765 Y: 94.590607 Z: 122.3088 +Vertex 22: X: 12.803238 Y: 94.590614 Z: 133.771301 +Vertex 23: X: -38.643349 Y: 94.590607 Z: 124.868355 +Vertex 24: X: -82.766846 Y: 94.590607 Z: 96.955307 +Vertex 25: X: -112.849762 Y: 94.590607 Z: 54.281677 +Vertex 26: X: -124.312256 Y: 94.590599 Z: 3.344152 +Vertex 27: X: -115.409271 Y: 94.590591 Z: -48.102493 +Vertex 28: X: -87.496201 Y: 94.590591 Z: -92.225967 +Vertex 29: X: -44.822552 Y: 94.590591 Z: -122.308861 +Vertex 30: X: 6.114983 Y: 94.590584 Z: -133.771332 +Vertex 31: X: 57.561623 Y: 94.590591 Z: -124.868301 +Vertex 32: X: 9.459057 Y: -87.419518 Z: 0.000008 +Vertex 33: X: 9.459057 Y: 94.590599 Z: -0.000008 +Face list: +Face 0: A:0 B:1 C:32 AB:1 BC:0 CA:0 +Smoothing: 1 +Face 1: A:1 B:2 C:32 AB:1 BC:0 CA:0 +Smoothing: 1 +Face 2: A:2 B:3 C:32 AB:1 BC:0 CA:0 +Smoothing: 1 +Face 3: A:3 B:4 C:32 AB:1 BC:0 CA:0 +Smoothing: 1 +Face 4: A:4 B:5 C:32 AB:1 BC:0 CA:0 +Smoothing: 1 +Face 5: A:5 B:6 C:32 AB:1 BC:0 CA:0 +Smoothing: 1 +Face 6: A:6 B:7 C:32 AB:1 BC:0 CA:0 +Smoothing: 1 +Face 7: A:7 B:8 C:32 AB:1 BC:0 CA:0 +Smoothing: 1 +Face 8: A:8 B:9 C:32 AB:1 BC:0 CA:0 +Smoothing: 1 +Face 9: A:9 B:10 C:32 AB:1 BC:0 CA:0 +Smoothing: 1 +Face 10: A:10 B:11 C:32 AB:1 BC:0 CA:0 + + Page 1 + + + +Smoothing: 1 +Face 11: A:11 B:12 C:32 AB:1 BC:0 CA:0 +Smoothing: 1 +Face 12: A:12 B:13 C:32 AB:1 BC:0 CA:0 +Smoothing: 1 +Face 13: A:13 B:14 C:32 AB:1 BC:0 CA:0 +Smoothing: 1 +Face 14: A:14 B:15 C:32 AB:1 BC:0 CA:0 +Smoothing: 1 +Face 15: A:15 B:0 C:32 AB:1 BC:0 CA:0 +Smoothing: 1 +Face 16: A:0 B:16 C:17 AB:1 BC:1 CA:0 +Smoothing: 2 +Face 17: A:0 B:17 C:1 AB:0 BC:1 CA:1 +Smoothing: 2 +Face 18: A:1 B:17 C:18 AB:1 BC:1 CA:0 +Smoothing: 3 +Face 19: A:1 B:18 C:2 AB:0 BC:1 CA:1 +Smoothing: 3 +Face 20: A:2 B:18 C:19 AB:1 BC:1 CA:0 +Smoothing: 4 +Face 21: A:2 B:19 C:3 AB:0 BC:1 CA:1 +Smoothing: 4 +Face 22: A:3 B:19 C:20 AB:1 BC:1 CA:0 +Smoothing: 5 +Face 23: A:3 B:20 C:4 AB:0 BC:1 CA:1 +Smoothing: 5 +Face 24: A:4 B:20 C:21 AB:1 BC:1 CA:0 +Smoothing: 6 +Face 25: A:4 B:21 C:5 AB:0 BC:1 CA:1 +Smoothing: 6 +Face 26: A:5 B:21 C:22 AB:1 BC:1 CA:0 +Smoothing: 7 +Face 27: A:5 B:22 C:6 AB:0 BC:1 CA:1 +Smoothing: 7 +Face 28: A:6 B:22 C:23 AB:1 BC:1 CA:0 +Smoothing: 8 +Face 29: A:6 B:23 C:7 AB:0 BC:1 CA:1 +Smoothing: 8 +Face 30: A:7 B:23 C:24 AB:1 BC:1 CA:0 +Smoothing: 9 +Face 31: A:7 B:24 C:8 AB:0 BC:1 CA:1 +Smoothing: 9 +Face 32: A:8 B:24 C:25 AB:1 BC:1 CA:0 +Smoothing: 10 +Face 33: A:8 B:25 C:9 AB:0 BC:1 CA:1 +Smoothing: 10 +Face 34: A:9 B:25 C:26 AB:1 BC:1 CA:0 +Smoothing: 11 +Face 35: A:9 B:26 C:10 AB:0 BC:1 CA:1 +Smoothing: 11 +Face 36: A:10 B:26 C:27 AB:1 BC:1 CA:0 +Smoothing: 12 +Face 37: A:10 B:27 C:11 AB:0 BC:1 CA:1 +Smoothing: 12 +Face 38: A:11 B:27 C:28 AB:1 BC:1 CA:0 +Smoothing: 13 +Face 39: A:11 B:28 C:12 AB:0 BC:1 CA:1 +Smoothing: 13 +Face 40: A:12 B:28 C:29 AB:1 BC:1 CA:0 +Smoothing: 14 + + Page 2 + + + +Face 41: A:12 B:29 C:13 AB:0 BC:1 CA:1 +Smoothing: 14 +Face 42: A:13 B:29 C:30 AB:1 BC:1 CA:0 +Smoothing: 15 +Face 43: A:13 B:30 C:14 AB:0 BC:1 CA:1 +Smoothing: 15 +Face 44: A:14 B:30 C:31 AB:1 BC:1 CA:0 +Smoothing: 16 +Face 45: A:14 B:31 C:15 AB:0 BC:1 CA:1 +Smoothing: 16 +Face 46: A:15 B:31 C:16 AB:1 BC:1 CA:0 +Smoothing: 17 +Face 47: A:15 B:16 C:0 AB:0 BC:1 CA:1 +Smoothing: 17 +Face 48: A:16 B:33 C:17 AB:0 BC:0 CA:1 +Smoothing: 18 +Face 49: A:17 B:33 C:18 AB:0 BC:0 CA:1 +Smoothing: 18 +Face 50: A:18 B:33 C:19 AB:0 BC:0 CA:1 +Smoothing: 18 +Face 51: A:19 B:33 C:20 AB:0 BC:0 CA:1 +Smoothing: 18 +Face 52: A:20 B:33 C:21 AB:0 BC:0 CA:1 +Smoothing: 18 +Face 53: A:21 B:33 C:22 AB:0 BC:0 CA:1 +Smoothing: 18 +Face 54: A:22 B:33 C:23 AB:0 BC:0 CA:1 +Smoothing: 18 +Face 55: A:23 B:33 C:24 AB:0 BC:0 CA:1 +Smoothing: 18 +Face 56: A:24 B:33 C:25 AB:0 BC:0 CA:1 +Smoothing: 18 +Face 57: A:25 B:33 C:26 AB:0 BC:0 CA:1 +Smoothing: 18 +Face 58: A:26 B:33 C:27 AB:0 BC:0 CA:1 +Smoothing: 18 +Face 59: A:27 B:33 C:28 AB:0 BC:0 CA:1 +Smoothing: 18 +Face 60: A:28 B:33 C:29 AB:0 BC:0 CA:1 +Smoothing: 18 +Face 61: A:29 B:33 C:30 AB:0 BC:0 CA:1 +Smoothing: 18 +Face 62: A:30 B:33 C:31 AB:0 BC:0 CA:1 +Smoothing: 18 +Face 63: A:31 B:33 C:16 AB:0 BC:0 CA:1 +Smoothing: 18 + + + + + + + + + + + + + + + + + Page 3 + + + diff --git a/progs/ggi/gears.c b/progs/ggi/gears.c new file mode 100644 index 00000000000..a6b5f7dda1a --- /dev/null +++ b/progs/ggi/gears.c @@ -0,0 +1,359 @@ +/* $Id: gears.c,v 1.1 1999/08/21 06:27:37 jtaylor Exp $ */ + +/* + * 3-D gear wheels. This program is in the public domain. + * + * Brian Paul + */ + +/* Conversion to GLUT by Mark J. Kilgard */ + +/* + * $Log: gears.c,v $ + * Revision 1.1 1999/08/21 06:27:37 jtaylor + * *** empty log message *** + * + * Revision 1.5 1999/07/31 21:51:09 jtaylor + * *** empty log message *** + * + * Revision 3.2 1999/06/03 17:07:36 brianp + * an extra quad was being drawn in front and back faces + * + * Revision 3.1 1998/11/03 02:49:10 brianp + * added fps output + * + * Revision 3.0 1998/02/14 18:42:29 brianp + * initial rev + * + */ + + +#include +#include +#include +#include + +#ifndef M_PI +#define M_PI 3.14159265 +#endif + +static GLint T0 = 0; +static GLint Frames = 0; + + +/** + + Draw a gear wheel. You'll probably want to call this function when + building a display list since we do a lot of trig here. + + Input: inner_radius - radius of hole at center + outer_radius - radius at center of teeth + width - width of gear + teeth - number of teeth + tooth_depth - depth of tooth + + **/ + +static void +gear(GLfloat inner_radius, GLfloat outer_radius, GLfloat width, + GLint teeth, GLfloat tooth_depth) +{ + GLint i; + GLfloat r0, r1, r2; + GLfloat angle, da; + GLfloat u, v, len; + + r0 = inner_radius; + r1 = outer_radius - tooth_depth / 2.0; + r2 = outer_radius + tooth_depth / 2.0; + + da = 2.0 * M_PI / teeth / 4.0; + + glShadeModel(GL_FLAT); + + glNormal3f(0.0, 0.0, 1.0); + + /* draw front face */ + glBegin(GL_QUAD_STRIP); + for (i = 0; i <= teeth; i++) { + angle = i * 2.0 * M_PI / teeth; + glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5); + glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5); + if (i < teeth) { + glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5); + glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), width * 0.5); + } + } + glEnd(); + + /* draw front sides of teeth */ + glBegin(GL_QUADS); + da = 2.0 * M_PI / teeth / 4.0; + for (i = 0; i < teeth; i++) { + angle = i * 2.0 * M_PI / teeth; + + glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5); + glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), width * 0.5); + glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da), width * 0.5); + glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), width * 0.5); + } + glEnd(); + + glNormal3f(0.0, 0.0, -1.0); + + /* draw back face */ + glBegin(GL_QUAD_STRIP); + for (i = 0; i <= teeth; i++) { + angle = i * 2.0 * M_PI / teeth; + glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5); + glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5); + if (i < teeth) { + glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), -width * 0.5); + glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5); + } + } + glEnd(); + + /* draw back sides of teeth */ + glBegin(GL_QUADS); + da = 2.0 * M_PI / teeth / 4.0; + for (i = 0; i < teeth; i++) { + angle = i * 2.0 * M_PI / teeth; + + glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), -width * 0.5); + glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da), -width * 0.5); + glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), -width * 0.5); + glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5); + } + glEnd(); + + /* draw outward faces of teeth */ + glBegin(GL_QUAD_STRIP); + for (i = 0; i < teeth; i++) { + angle = i * 2.0 * M_PI / teeth; + + glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5); + glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5); + u = r2 * cos(angle + da) - r1 * cos(angle); + v = r2 * sin(angle + da) - r1 * sin(angle); + len = sqrt(u * u + v * v); + u /= len; + v /= len; + glNormal3f(v, -u, 0.0); + glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), width * 0.5); + glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), -width * 0.5); + glNormal3f(cos(angle), sin(angle), 0.0); + glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da), width * 0.5); + glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da), -width * 0.5); + u = r1 * cos(angle + 3 * da) - r2 * cos(angle + 2 * da); + v = r1 * sin(angle + 3 * da) - r2 * sin(angle + 2 * da); + glNormal3f(v, -u, 0.0); + glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), width * 0.5); + glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), -width * 0.5); + glNormal3f(cos(angle), sin(angle), 0.0); + } + + glVertex3f(r1 * cos(0), r1 * sin(0), width * 0.5); + glVertex3f(r1 * cos(0), r1 * sin(0), -width * 0.5); + + glEnd(); + + glShadeModel(GL_SMOOTH); + + /* draw inside radius cylinder */ + glBegin(GL_QUAD_STRIP); + for (i = 0; i <= teeth; i++) { + angle = i * 2.0 * M_PI / teeth; + glNormal3f(-cos(angle), -sin(angle), 0.0); + glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5); + glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5); + } + glEnd(); + +} + +static GLfloat view_rotx = 20.0, view_roty = 30.0, view_rotz = 0.0; +static GLint gear1, gear2, gear3; +static GLfloat angle = 0.0; + +static void +draw(void) +{ + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + + glPushMatrix(); + glRotatef(view_rotx, 1.0, 0.0, 0.0); + glRotatef(view_roty, 0.0, 1.0, 0.0); + glRotatef(view_rotz, 0.0, 0.0, 1.0); + + glPushMatrix(); + glTranslatef(-3.0, -2.0, 0.0); + glRotatef(angle, 0.0, 0.0, 1.0); + glCallList(gear1); + glPopMatrix(); + + glPushMatrix(); + glTranslatef(3.1, -2.0, 0.0); + glRotatef(-2.0 * angle - 9.0, 0.0, 0.0, 1.0); + glCallList(gear2); + glPopMatrix(); + + glPushMatrix(); + glTranslatef(-3.1, 4.2, 0.0); + glRotatef(-2.0 * angle - 25.0, 0.0, 0.0, 1.0); + glCallList(gear3); + glPopMatrix(); + + glPopMatrix(); + + glutSwapBuffers(); + + Frames++; + { + GLint t = glutGet(GLUT_ELAPSED_TIME); + if (t - T0 >= 5000) { + GLfloat seconds = (t - T0) / 1000.0; + GLfloat fps = Frames / seconds; + printf("%d frames in %g seconds = %g FPS\n", Frames, seconds, fps); + T0 = t; + Frames = 0; + } + } +} + + +static void +idle(void) +{ + angle += 2.0; + glutPostRedisplay(); +} + +/* change view angle, exit upon ESC */ +/* ARGSUSED1 */ +static void +key(unsigned char k, int x, int y) +{ + switch (k) { + case 'z': + view_rotz += 5.0; + break; + case 'Z': + view_rotz -= 5.0; + break; + case 27: /* Escape */ + exit(0); + break; + default: + return; + } + glutPostRedisplay(); +} + +/* change view angle */ +/* ARGSUSED1 */ +static void +special(int k, int x, int y) +{ + switch (k) { + case GLUT_KEY_UP: + view_rotx += 5.0; + break; + case GLUT_KEY_DOWN: + view_rotx -= 5.0; + break; + case GLUT_KEY_LEFT: + view_roty += 5.0; + break; + case GLUT_KEY_RIGHT: + view_roty -= 5.0; + break; + default: + return; + } + glutPostRedisplay(); +} + +/* new window size or exposure */ +static void +reshape(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, 60.0); + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + glTranslatef(0.0, 0.0, -40.0); +} + +static void +init(void) +{ + static GLfloat pos[4] = + {5.0, 5.0, 10.0, 0.0}; + static GLfloat red[4] = + {0.8, 0.1, 0.0, 1.0}; + static GLfloat green[4] = + {0.0, 0.8, 0.2, 1.0}; + static GLfloat blue[4] = + {0.2, 0.2, 1.0, 1.0}; + + glLightfv(GL_LIGHT0, GL_POSITION, pos); + glEnable(GL_CULL_FACE); + glEnable(GL_LIGHTING); + glEnable(GL_LIGHT0); + glEnable(GL_DEPTH_TEST); + + /* make the gears */ + gear1 = glGenLists(1); + glNewList(gear1, GL_COMPILE); + glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, red); + gear(1.0, 4.0, 1.0, 20, 0.7); + glEndList(); + + gear2 = glGenLists(1); + glNewList(gear2, GL_COMPILE); + glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, green); + gear(0.5, 2.0, 2.0, 10, 0.7); + glEndList(); + + gear3 = glGenLists(1); + glNewList(gear3, GL_COMPILE); + glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, blue); + gear(1.3, 2.0, 0.5, 10, 0.7); + glEndList(); + + glEnable(GL_NORMALIZE); +} + +void +visible(int vis) +{ + if (vis == GLUT_VISIBLE) + glutIdleFunc(idle); + else + glutIdleFunc(NULL); +} + +int main(int argc, char *argv[]) +{ + glutInit(&argc, argv); + glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE); + + glutInitWindowPosition(0, 0); + glutInitWindowSize(300, 300); + glutCreateWindow("Gears"); + init(); + + glutDisplayFunc(draw); + glutReshapeFunc(reshape); + glutKeyboardFunc(key); + glutSpecialFunc(special); + glutVisibilityFunc(visible); + + glutMainLoop(); + return 0; /* ANSI C requires main to return int. */ +} diff --git a/progs/ggi/gears2.c b/progs/ggi/gears2.c new file mode 100644 index 00000000000..1d1e10db545 --- /dev/null +++ b/progs/ggi/gears2.c @@ -0,0 +1,359 @@ +/* gears.c */ + +/* + * 3-D gear wheels. This program is in the public domain. + * + * Brian Paul + * modified by Uwe Maurer (uwe_maurer@t-online.de) + */ + +#include +#include +#include +#include +#include +#ifndef M_PI +# define M_PI 3.14159265 +#endif + + +ggi_visual_t vis; +char text[100]; + +/* + * Draw a gear wheel. You'll probably want to call this function when + * building a display list since we do a lot of trig here. + * + * Input: inner_radius - radius of hole at center + * outer_radius - radius at center of teeth + * width - width of gear + * teeth - number of teeth + * tooth_depth - depth of tooth + */ +static void gear( GLfloat inner_radius, GLfloat outer_radius, GLfloat width, + GLint teeth, GLfloat tooth_depth ) +{ + GLint i; + GLfloat r0, r1, r2; + GLfloat angle, da; + GLfloat u, v, len; + + r0 = inner_radius; + r1 = outer_radius - tooth_depth/2.0; + r2 = outer_radius + tooth_depth/2.0; + + da = 2.0*M_PI / teeth / 4.0; + + glShadeModel( GL_FLAT ); + + glNormal3f( 0.0, 0.0, 1.0 ); + + /* draw front face */ + glBegin( GL_QUAD_STRIP ); + for (i=0;i<=teeth;i++) { + angle = i * 2.0*M_PI / teeth; + glVertex3f( r0*cos(angle), r0*sin(angle), width*0.5 ); + glVertex3f( r1*cos(angle), r1*sin(angle), width*0.5 ); + glVertex3f( r0*cos(angle), r0*sin(angle), width*0.5 ); + glVertex3f( r1*cos(angle+3*da), r1*sin(angle+3*da), width*0.5 ); + } + glEnd(); + + /* draw front sides of teeth */ + glBegin( GL_QUADS ); + da = 2.0*M_PI / teeth / 4.0; + for (i=0;i GGI"); + ggiPuts(vis,0,ggiGetInfo(vis)->mode->visible.y," Mesa -> GGI"); + + ggiPuts(vis,0,16,text); + ggiPuts(vis,0,ggiGetInfo(vis)->mode->visible.y+16,text); +#endif + + GGIMesaSwapBuffers(); + + count++; + if (count==limit) { + exit(1); + } +} + +static void idle( void ) +{ + angle += 2.0; + draw(); +} + +/* new window size or exposure */ +static void reshape( 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, 60.0 ); + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + glTranslatef( 0.0, 0.0, -40.0 ); + glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); + +} + + +static void init( void ) +{ + static GLfloat pos[4] = {5.0, 5.0, 10.0, 0.0 }; + static GLfloat red[4] = {0.8, 0.1, 0.0, 1.0 }; + static GLfloat green[4] = {0.0, 0.8, 0.2, 1.0 }; + static GLfloat blue[4] = {0.2, 0.2, 1.0, 1.0 }; + + glLightfv( GL_LIGHT0, GL_POSITION, pos ); + glEnable( GL_CULL_FACE ); + glEnable( GL_LIGHTING ); + glEnable( GL_LIGHT0 ); + glEnable( GL_DEPTH_TEST ); + + /* make the gears */ + gear1 = glGenLists(1); + glNewList(gear1, GL_COMPILE); + glMaterialfv( GL_FRONT, GL_AMBIENT_AND_DIFFUSE, red ); + glIndexi(1); + gear( 1.0, 4.0, 1.0, 20, 0.7 ); + glEndList(); + + gear2 = glGenLists(1); + glNewList(gear2, GL_COMPILE); + glMaterialfv( GL_FRONT, GL_AMBIENT_AND_DIFFUSE, green ); + glIndexi(2); + gear( 0.5, 2.0, 2.0, 10, 0.7 ); + glEndList(); + + gear3 = glGenLists(1); + glNewList(gear3, GL_COMPILE); + glMaterialfv( GL_FRONT, GL_AMBIENT_AND_DIFFUSE, blue ); + glIndexi(3); + gear( 1.3, 2.0, 0.5, 10, 0.7 ); + glEndList(); + + glEnable( GL_NORMALIZE ); +} + +static void usage(char *s) +{ + printf("%s visible_x visible_y virtual_x virtual_y bpp db_flag\n",s); + printf("example:\n"); + printf("%s 320 200 320 400 8 1\n",s); + exit(1); +} + +int main( int argc, char *argv[] ) +{ + GGIMesaContext ctx; + int vis_x,vis_y,vir_x,vir_y,bpp,db_flag,gt; + ggi_mode mode; + + limit=0; + + if (argc<7) usage(argv[0]); + + vis_x=atoi(argv[1]); + vis_y=atoi(argv[2]); + vir_x=atoi(argv[3]); + vir_y=atoi(argv[4]); + bpp=atoi(argv[5]); + db_flag=atoi(argv[6]); + + switch(bpp) + { + case 4: gt=GT_4BIT;break; + case 8: gt=GT_8BIT;break; + case 15:gt=GT_15BIT;break; + case 16:gt=GT_16BIT;break; + case 24:gt=GT_24BIT;break; + case 32:gt=GT_32BIT;break; + default: + printf("%i Bits per Pixel ???\n",bpp); + exit(1); + } + sprintf(text,"%sx%s %i colors, RGB mode, %s", + argv[1],argv[2],1< +#include +#include +#include +#include +#include +#include +#include "GL/ggimesa.h" + +#include +#include + +char *__glutProgramName = "GGI"; + +static ggi_visual_t __glut_vis; + +static GGIMesaContext __glut_ctx; + +static int __glut_width = WIDTH; +static int __glut_height = HEIGHT; +static ggi_graphtype __glut_gt_rgb = GRAPHTYPE_RGB; +static ggi_graphtype __glut_gt_index = GRAPHTYPE_INDEX; +static int __glut_init = GL_FALSE; + +static int mousex = WIDTH / 2; +static int mousey = HEIGHT / 2; +static int mouse_moved = GL_FALSE; +static int mouse_down = GL_FALSE; +static int mouse_showcursor = GL_FALSE; + +static void (*__glut_reshape)(int, int); +static void (*__glut_display)(void); +static void (*__glut_idle)(void); +static void (*__glut_keyboard)(unsigned char, int, int); +static void (*__glut_special)(int, int, int); +static void (*__glut_mouse)(int, int, int, int); +static void (*__glut_motion)(int, int); +static void (*__glut_passive_motion)(int, int); +static void (*__glut_visibility)(int); + +static unsigned int __glut_mode = GLUT_RGB | GLUT_SINGLE | GLUT_DEPTH; + +static int __glut_mod_keys = 0; + +static int __glut_redisplay = GL_FALSE; + +/* Menu */ +static int __glut_menubutton = -1; +static int __glut_menuactive = GL_FALSE; + +#define MAX_ENTRIES 64 + +typedef struct menu_s +{ + char *label[MAX_ENTRIES]; + int value[MAX_ENTRIES]; + struct menu_s * submenu[MAX_ENTRIES]; + void (*func)(int); + int max_strlen; + int num_entries; +} menu_t; + +static menu_t *mainmenu; +static menu_t *curmenu; +static menu_t *activemenu; + +int glut_ggi_debug = GL_FALSE; + +void glut_ggiPRINT(char *format, ...) +{ + va_list args; + va_start(args, format); + fprintf(stderr, "GGIGLUT: "); + vfprintf(stderr, format, args); + va_end(args); +} + +void glut_ggiDEBUG(char *format, ...) +{ + va_list args; + if (glut_ggi_debug) + { + va_start(args, format); + fprintf(stderr, "GGIGLUT: "); + vfprintf(stderr, format, args); + va_end(args); + } + +} + +void glutInit(int *argc, char **argv) +{ + ggi_graphtype gt; + int i, k; + char *s; + + #define REMOVE {for (k=i;k<*argc-1;k++) argv[k]=argv[k+1]; \ + (*argc)--; i--; } + + if (__glut_init) return; + + s = getenv("GGIGLUT_DEBUG"); + glut_ggi_debug = (s && atoi(s)); + + if (argc && argv) + { + + for (i = 1; i < *argc; i++) + { + if (strcmp(argv[i], "-mouse") == 0) + { + mouse_showcursor = GL_TRUE; + REMOVE; + } + else + if (strcmp(argv[i], "-bpp") == 0 && (i + 1) < (*argc)) + { + switch(atoi(argv[i + 1])) + { + case 4: gt = GT_4BIT; break; + case 8: gt = GT_8BIT; break; + case 15: gt = GT_15BIT; break; + case 16: gt = GT_16BIT; break; + case 24: gt = GT_24BIT; break; + case 32: gt = GT_32BIT; break; + default: + glut_ggiDEBUG("\"%s\" bits per pixel?\n", + argv[i+1]); + + exit(1); + } + __glut_gt_rgb = __glut_gt_index = gt; + REMOVE; + REMOVE; + } + else + if (strcmp(argv[i], "-size") == 0 && (i + 2) < (*argc)) + { + __glut_width=atoi(argv[i+1]); + __glut_height=atoi(argv[i+2]); + REMOVE; + REMOVE; + REMOVE; + } + } + } + + if (ggiInit()<0) + { + ggiPanic("ggiInit() failed!\n"); + } + __glut_init=GL_TRUE; + + #undef REMOVE +} + +void glutInitWindowPosition(int x, int y) +{ +} + +void glutInitWindowSize(int x, int y) +{ +} + +void glutFullScreen(void) +{ +} + +void glutInitDisplayMode(unsigned int mode) +{ + __glut_mode = mode; +} + +void glutInitDisplayString(const char *string) +{ + glut_ggiPRINT("glutInitDisplayString: %s\n", string); +} + +int glutCreateWindow(const char *title) +{ + ggi_graphtype gt; + ggi_mode mode = + { + 1, + { GGI_AUTO, GGI_AUTO }, + { GGI_AUTO, GGI_AUTO }, + { 0, 0 }, + GT_AUTO, + { GGI_AUTO, GGI_AUTO } + }; + int frames; + int rgb; + int err; + + if (!__glut_init) + glutInit(NULL, NULL); + + glut_ggiPRINT("GGIGLUT: %s\n", title); + + rgb = !(__glut_mode & GLUT_INDEX); + frames = (__glut_mode & GLUT_DOUBLE) ? 2 : 1; + gt = (rgb) ? __glut_gt_rgb : __glut_gt_index; + + __glut_ctx = GGIMesaCreateContext(); + + if (__glut_ctx == NULL) + ggiPanic("Can't create mesa-context\n"); + + __glut_vis = ggiOpen(NULL); + if (__glut_vis == NULL) + { + ggiPanic("ggiOpen() failed!\n"); + /* return GL_FALSE; */ + } + + ggiSetFlags(__glut_vis, GGIFLAG_ASYNC); + + ggiCheckMode(__glut_vis, &mode); + + err = ggiSetMode(__glut_vis, &mode); + if (err < 0) + { + ggiPanic("Can't set graphic mode!\n"); + /* return GL_FALSE; */ + } + + ggiGetMode(__glut_vis, &mode); + + if (GGIMesaSetVisual(__glut_ctx, __glut_vis, rgb, frames > 1) < 0) + { + ggiPanic("GGIMesaSetVisual failed!\n"); + } + + GGIMesaMakeCurrent(__glut_ctx); + + if (__glut_reshape) + __glut_reshape(__glut_width, __glut_height); + + return GL_TRUE; +} + +void glutReshapeFunc(void (*func)(int, int)) +{ + __glut_reshape = func; + if (__glut_vis && __glut_reshape) + __glut_reshape(__glut_width, __glut_height); +} + +void glutKeyboardFunc(void (*keyboard)(unsigned char key, int x, int y)) +{ + __glut_keyboard = keyboard; +} + +int glutGetModifiers(void) +{ + return __glut_mod_keys; +} + +void glutEntryFunc(void (*func)(int state)) +{ +} + +void glutVisibilitFunc(void (*func)(int state)) +{ +} + +void glutTimerFunc(unsigned int millis, void (*func)(int value), int value) +{ +} + +void glutMenuStateFunc(void (*func)(int state)) +{ +} + +int glutGet(GLenum type) +{ + switch(type) + { + case GLUT_WINDOW_X: + return 0; + case GLUT_WINDOW_Y: + return 0; + case GLUT_WINDOW_WIDTH: + return __glut_width; + case GLUT_WINDOW_HEIGHT: + return __glut_height; + case GLUT_MENU_NUM_ITEMS: + if (curmenu) + return curmenu->num_entries; + else + return 0; + default: + glut_ggiDEBUG("glutGet: unknown type %i\n", type); + } + return 0; +} + +void glutSpecialFunc(void (*special)(int key, int x, int y)) +{ + __glut_special=special; +} + +void glutDisplayFunc(void (*disp)(void)) +{ + __glut_display=disp; +} + +void glutSetColor(int index, GLfloat red, GLfloat green, GLfloat blue) +{ + ggi_color c; + GLfloat max; + + if (red > 1.0) red = 1.0; + if (red < 0.0) red = 0.0; + if (green > 1.0) green = 1.0; + if (green < 0.0) green = 0.0; + if (blue > 1.0) blue = 1.0; + if (blue < 0.0) blue = 0.0; + + max = (float)((1 << GGI_COLOR_PRECISION) - 1); + + c.r = (int)(max * red); + c.g = (int)(max * green); + c.b = (int)(max * blue); + ggiSetPalette(__glut_vis, index, 1, &c); +} + +void glutPostRedisplay(void) +{ + __glut_redisplay = GL_TRUE; +} + +void glutPostWindowRedisplay(int win) +{ + __glut_redisplay = GL_TRUE; +} + +void glutSwapBuffers(void) +{ + GGIMesaSwapBuffers(); +} + +void glutIdleFunc(void (*idle)(void)) +{ + __glut_idle = idle; +} + +static void keyboard(ggi_event *ev) +{ + int sym; + int modifer = 0, key = 0; + + sym = ev->key.sym; + + modifer = ev->key.modifiers; + if (modifer == GII_KM_SHIFT) + __glut_mod_keys |= GLUT_ACTIVE_SHIFT; + if (modifer == GII_KM_CTRL) + __glut_mod_keys |= GLUT_ACTIVE_CTRL; + if (modifer == GII_KM_ALT) + __glut_mod_keys |= GLUT_ACTIVE_ALT; + + /* if (__glut_special && key) __glut_special(GII_KTYP(key),0,0); */ + + if (__glut_keyboard) +// __glut_keyboard(GII_UNICODE(sym), 0, 0); + __glut_keyboard(sym, 0, 0); +} + +static void mouseabs(ggi_event *ev) +{ + int oldx=mousex; + int oldy=mousey; + + mousex=ev->pmove.x; + mousey=ev->pmove.y; + + if (mousex<0) mousex=0; + if (mousey<0) mousey=0; + if (mousex>=__glut_width) mousex=__glut_width-1; + if (mousey>=__glut_height) mousey=__glut_height-1; + + if (mousex!=oldx || mousey!=oldy) mouse_moved=GL_TRUE; +} + +static void mouse(ggi_event *ev) +{ + int oldx=mousex; + int oldy=mousey; + + mousex+=ev->pmove.x>>1; + mousey+=ev->pmove.y>>1; + + if (mousex<0) mousex=0; + if (mousey<0) mousey=0; + if (mousex>=__glut_width) mousex=__glut_width-1; + if (mousey>=__glut_height) mousey=__glut_height-1; + + if (mousex!=oldx || mousey!=oldy) mouse_moved=GL_TRUE; + +} + +/* FIXME: Prototypes belong in headers, not here! [JMT] */ +static void showmenu(void); +static int clickmenu(void); +static void updatemouse(void); +static void drawmouse(void); + +static void mousemove(void) +{ + if (mouse_moved) { + if (__glut_motion && mouse_down) { + __glut_motion(mousex,mousey); + } + + if (__glut_passive_motion && (!mouse_down)) { + __glut_passive_motion(mousex,mousey); + } + + if (__glut_menuactive) updatemouse(); + mouse_moved=GL_FALSE; + } +} + +static void button(ggi_event *ev) +{ + int i; + int btn[4]={0,GLUT_LEFT_BUTTON,GLUT_RIGHT_BUTTON,GLUT_MIDDLE_BUTTON}; + mousemove(); + + if (ev->pbutton.button <= 3) { /* GGI can have >3 buttons ! */ + char state = ev->any.type == evPtrButtonPress ?GLUT_DOWN:GLUT_UP; + if (__glut_menuactive) { + if (state==GLUT_UP && clickmenu()) { + glutPostRedisplay(); + __glut_menuactive=GL_FALSE; + } + } else + if (btn[ev->pbutton.button]==__glut_menubutton) { + __glut_menuactive=GL_TRUE; + activemenu=mainmenu; + showmenu(); + } else + if (__glut_mouse) { + __glut_mouse(btn[ev->pbutton.button],state,mousex,mousey); + } + if (state==GLUT_DOWN) { + mouse_down|=(1<<(ev->pbutton.button-1)); + } + else mouse_down&=~(1<<(ev->pbutton.button-1)); + } +} + +void glutMainLoop(void) +{ + ggi_event ev; + ggi_event_mask evmask = (emKeyPress | emKeyRepeat | emPtrMove | emPtrButton); + + ggiSetEventMask(__glut_vis, evmask); + + glutPostRedisplay(); + + if (__glut_visibility) + __glut_visibility(GLUT_VISIBLE); + + while (1) + { + if (!__glut_menuactive) + { + if (__glut_idle) + __glut_idle(); + if (__glut_redisplay && __glut_display) + { + __glut_redisplay = GL_FALSE; + __glut_display(); + } + } + + while (1) + { + struct timeval t = {0, 0}; + + if (ggiEventPoll(__glut_vis, evmask, &t) == 0) + break; + + ggiEventRead(__glut_vis, &ev, evmask); + + switch (ev.any.type) + { + case evKeyPress: + case evKeyRepeat: + keyboard(&ev); + break; + case evPtrAbsolute: + mouseabs(&ev); + break; + case evPtrRelative: + mouse(&ev); + break; + case evPtrButtonPress: + case evPtrButtonRelease: + button(&ev); + break; + } + } + mousemove(); + } +} + +static void showmenu() +{ + int y,i; + ggi_color col={0xffff,0xffff,0xffff}; + + ggiSetGCForeground(__glut_vis,ggiMapColor(__glut_vis,&col)); + ggiSetOrigin(__glut_vis,0,0); + + for (y=i=0;inum_entries;i++,y+=8) { + ggiPuts(__glut_vis,0,y,activemenu->label[i]); + } + drawmouse(); +} + +static int clickmenu(void) +{ + int i; + int w,h; + + i=mousey/8; + + if (i>=activemenu->num_entries) return GL_TRUE; + if (mousex>=8*strlen(activemenu->label[i])) return GL_TRUE; + + if (activemenu->submenu[i]) { + ggi_color col={0,0,0}; + ggiSetGCForeground(__glut_vis,ggiMapColor(__glut_vis,&col)); + h=activemenu->num_entries*8; + w=activemenu->max_strlen*8; + ggiDrawBox(__glut_vis,0,0,w,h); + activemenu=activemenu->submenu[i]; + showmenu(); + return GL_FALSE; + } + curmenu=activemenu; + activemenu->func(activemenu->value[i]); + return GL_TRUE; +} + +static int oldx=-1; +static int oldy=-1; +static char buffer[16*16*4]; + +static void updatemouse() +{ + ggiPutBox(__glut_vis,oldx,oldy,16,16,buffer); + drawmouse(); +} + +static void drawmouse() +{ + int x,y; + x=mousex-8; + if (x<0) x=0; + y=mousey-8; + if (y<0) y=0; + ggiGetBox(__glut_vis,x,y,16,16,buffer); + ggiDrawLine(__glut_vis,mousex-2,mousey,mousex+2,mousey); + ggiDrawLine(__glut_vis,mousex,mousey-2,mousex,mousey+2); + oldx=x; + oldy=y; +} + +int glutCreateMenu(void(*func)(int)) +{ + menu_t *m; + m=malloc(sizeof(menu_t)); + memset(m,0,sizeof(menu_t)); + curmenu=m; + curmenu->func=func; + return (int)curmenu; +} + +static void addEntry(const char *label,int value,menu_t *submenu) +{ + int i=curmenu->num_entries; + /* printf("%i %i %s %p\n",i,value,label,submenu); */ + if (ilabel[i]=strdup(label); + curmenu->value[i]=value; + curmenu->submenu[i]=submenu; + + if (strlen(label)>curmenu->max_strlen) + curmenu->max_strlen=strlen(label); + curmenu->num_entries++; + } +} + +void glutAddMenuEntry(const char *label,int value) +{ + addEntry(label,value,NULL); +} + +void glutAddSubMenu(const char *label,int submenu) +{ + char text[100]; + + if (!curmenu) return; + strncpy(text,label,98); + text[98]=0; + text[strlen(text)+1]=0; + text[strlen(text)]='>'; + + addEntry(text,0,(menu_t *) submenu); +} + +void glutAttachMenu(int button) +{ + mainmenu=curmenu; + __glut_menubutton=button; +} + +void glutDetachMenu(int button) +{ +} + +void glutVisibilityFunc(void (*func)(int state)) +{ + __glut_visibility=func; +} + +void glutMouseFunc(void (*mouse)(int, int, int, int)) +{ + __glut_mouse=mouse; +} + +void glutMotionFunc(void (*motion)(int,int)) +{ + __glut_motion=motion; +} + +void glutPassiveMotionFunc(void (*motion)(int,int)) +{ + __glut_passive_motion=motion; +} + +void glutSetWindowTitle(const char *title) +{ +} + +void glutSetIconTitle(const char *title) +{ +} + +void glutChangeToMenuEntry(int item,const char *label,int value) +{ + if (item>0 && item<=curmenu->num_entries) { + item--; + free(curmenu->label[item]); + curmenu->label[item]=strdup(label); + curmenu->value[item]=value; + curmenu->submenu[item]=NULL; + } +} +void glutChangeToSubMenu(int item,const char *label,int submenu) +{ + if (item>0 && item<=curmenu->num_entries) { + item--; + free(curmenu->label[item]); + curmenu->label[item]=strdup(label); + curmenu->value[item]=0; + curmenu->submenu[item]=(menu_t *)submenu; + } +} + +void glutDestroyMenu(int menu) +{ + menu_t *m=(menu_t *)menu; + int i; + + for (i=0;inum_entries;i++) { + free(m->label[i]); + } + free(m); +} + +int glutCreateSubWindow(int win,int x,int y,int w,int h) +{ + return 0; +} + +void glutDestroyWindow(int win) +{ +} + +int glutGetWindow(void) +{ + return 0; +} + +void glutSetWindow(int win) +{ +} + +void glutPositionWindow(int x,int y) +{ +} + +void glutReshapeWindow(int x,int y) +{ +} + +void glutPushWindow(void) +{ +} + +void glutPopWindow(void) +{ +} + +void glutIconifyWindow(void) +{ +} + +void glutShowWindow() +{ +} + +void glutHideWindow() +{ +} + +void glutSetCursor(int cursor) +{ +} + +void glutWarpPointer(int x,int y) +{ +} + +void glutEstablishOverlay(void) +{ +} + +void glutRemoveOverlay(void) +{ +} + +void glutUseLayer(GLenum layer) +{ +} + +int glutLayerGet(GLenum type) +{ + return 0; +} + +void glutPostOverlayRedisplay(void) +{ +} + +void glutPostWindowOverlayRedisplay(int w) +{ +} + +void glutShowOverlay(void) +{ +} + +void glutHideOverlay(void) +{ +} + +int glutGetMenu(void) +{ + return 0; +} + +void glutSetMenu(int menu) +{ +} + +void glutRemoveMenuItem(int item) +{ +} + +void glutSpaceBallMotionFunc(void (*func)(int key,int x,int y)) +{ +} + +void glutSpaceBallRotateFunc(void (*func)(int x,int y,int z)) +{ +} + +void glutSpaceBallButtonFunc(void (*func)(int button,int state)) +{ +} + +void glutCopyColormap(int win) +{ +} + +int glutDeviceGet(GLenum param) +{ + return 0; +} -- 2.30.2