KonstantinSeurer
/
mesa
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
mesa/progs/windml/uglolympic.c

480 lines
11 KiB
C
Raw Blame History

/*
* Copyright (c) 1991, 1992, 1993 Silicon Graphics, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in
* all copies of the software and related documentation, and (ii) the name of
* Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written
* permission of Silicon Graphics.
*
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF
* ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
*
* IN NO EVENT SHALL SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/
/*
* Nov 20, 1995 use stdlib's rand()/srand() instead of random()/srand48(), etc.
*/
/*
* Modified by Stephane Raimbault to be able to run in VxWorks 07/18/01
*
* Modified by Li Wei(liwei@aiar.xjtu.edu.cn) to be able to run in Windows
* 6/13
*
* Modified by Brian Paul to compile with Windows OR Unix. 7/23/97
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <ugl/ugl.h>
#include <ugl/uglevent.h>
#include <ugl/uglinput.h>
#include <ugl/uglucode.h>
#include <GL/uglmesa.h>
#include <GL/glu.h>
#ifndef RAND_MAX
# define RAND_MAX 32767
#endif
#define XSIZE 100
#define YSIZE 75
#define RINGS 5
#define BLUERING 0
#define BLACKRING 1
#define REDRING 2
#define YELLOWRING 3
#define GREENRING 4
#define BACKGROUND 8
UGL_LOCAL UGL_EVENT_SERVICE_ID eventServiceId;
UGL_LOCAL UGL_EVENT_Q_ID qId;
UGL_LOCAL UGL_MESA_CONTEXT umc;
UGL_LOCAL volatile UGL_BOOL stopWex;
UGL_LOCAL int rgb;
UGL_LOCAL unsigned char rgb_colors[RINGS][3];
UGL_LOCAL int mapped_colors[RINGS];
UGL_LOCAL float dests[RINGS][3];
UGL_LOCAL float offsets[RINGS][3];
UGL_LOCAL float angs[RINGS];
UGL_LOCAL float rotAxis[RINGS][3];
UGL_LOCAL int iters[RINGS];
UGL_LOCAL GLuint theTorus;
enum {
COLOR_BLACK = 0,
COLOR_RED,
COLOR_GREEN,
COLOR_YELLOW,
COLOR_BLUE,
COLOR_MAGENTA,
COLOR_CYAN,
COLOR_WHITE
};
/*
UGL_LOCAL float RGBMap[9][3] = {
{0, 0, 0},
{1, 0, 0},
{0, 1, 0},
{1, 1, 0},
{0, 0, 1},
{1, 0, 1},
{0, 1, 1},
{1, 1, 1},
{0.5, 0.5, 0.5}
};
UGL_LOCAL void SetColor(int c)
{
(rgb) ? glColor3fv(RGBMap[c]): glIndexf(c);
}
UGL_LOCAL void InitMap(void)
{
int i;
if (rgb)
return;
for (i = 0; i < 9; i++)
uglMesaSetColor(i, RGBMap[i][0], RGBMap[i][1], RGBMap[i][2]);
}
UGL_LOCAL void SetFogRamp(int density, int startIndex)
{
int fogValues, colorValues;
int i, j, k;
float intensity;
fogValues = 1 << density;
colorValues = 1 << startIndex;
for (i = 0; i < colorValues; i++)
{
for (j = 0; j < fogValues; j++)
{
k = i * fogValues + j;
intensity = (i * fogValues + j * colorValues) / 255.0;
uglMesaSetColor(k, intensity, intensity, intensity);
}
}
}
UGL_LOCAL void SetGreyRamp(void)
{
int i;
float intensity;
for (i = 0; i < 255; i++)
{
intensity = i / 255.0;
uglMesaSetColor(i, intensity, intensity, intensity);
}
}
*/
UGL_LOCAL void FillTorus(float rc, int numc, float rt, int numt)
{
int i, j, k;
double s, t;
double x, y, z;
double pi, twopi;
pi = 3.14159265358979323846;
twopi = 2 * pi;
for (i = 0; i < numc; i++)
{
glBegin(GL_QUAD_STRIP);
for (j = 0; j <= numt; j++)
{
for (k = 1; k >= 0; k--)
{
s = (i + k) % numc + 0.5;
t = j % numt;
x = cos(t*twopi/numt) * cos(s*twopi/numc);
y = sin(t*twopi/numt) * cos(s*twopi/numc);
z = sin(s*twopi/numc);
glNormal3f(x, y, z);
x = (rt + rc * cos(s*twopi/numc)) * cos(t*twopi/numt);
y = (rt + rc * cos(s*twopi/numc)) * sin(t*twopi/numt);
z = rc * sin(s*twopi/numc);
glVertex3f(x, y, z);
}
}
glEnd();
}
}
UGL_LOCAL float Clamp(int iters_left, float t)
{
if (iters_left < 3)
{
return 0.0;
}
return (iters_left-2)*t/iters_left;
}
UGL_LOCAL void drawGL(void)
{
int i, j;
for (i = 0; i < RINGS; i++)
{
if (iters[i]) {
for (j = 0; j < 3; j++)
{
offsets[i][j] = Clamp(iters[i], offsets[i][j]);
}
angs[i] = Clamp(iters[i], angs[i]);
iters[i]--;
}
}
glPushMatrix();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
gluLookAt(0,0,10, 0,0,0, 0,1,0);
for (i = 0; i < RINGS; i++)
{
if (rgb)
{
glColor3ubv(rgb_colors[i]);
}
else
{
glIndexi(mapped_colors[i]);
}
glPushMatrix();
glTranslatef(dests[i][0]+offsets[i][0], dests[i][1]+offsets[i][1],
dests[i][2]+offsets[i][2]);
glRotatef(angs[i], rotAxis[i][0], rotAxis[i][1], rotAxis[i][2]);
glCallList(theTorus);
glPopMatrix();
}
glPopMatrix();
glFlush();
uglMesaSwapBuffers();
}
UGL_LOCAL float MyRand(void)
{
return 10.0 * ( (float) rand() / (float) RAND_MAX - 0.5 );
}
UGL_LOCAL void ReInit(void)
{
int i;
float deviation;
deviation = MyRand() / 2;
deviation = deviation * deviation;
for (i = 0; i < RINGS; i++)
{
offsets[i][0] = MyRand();
offsets[i][1] = MyRand();
offsets[i][2] = MyRand();
angs[i] = 260.0 * MyRand();
rotAxis[i][0] = MyRand();
rotAxis[i][1] = MyRand();
rotAxis[i][2] = MyRand();
iters[i] = (deviation * MyRand() + 60.0);
}
}
UGL_LOCAL void initGL(void)
{
float base, height;
float aspect, x, y;
int i;
float top_y = 1.0;
float bottom_y = 0.0;
float top_z = 0.15;
float bottom_z = 0.69;
float spacing = 2.5;
static float lmodel_ambient[] = {0.0, 0.0, 0.0, 0.0};
static float lmodel_twoside[] = {GL_FALSE};
static float lmodel_local[] = {GL_FALSE};
static float light0_ambient[] = {0.1, 0.1, 0.1, 1.0};
static float light0_diffuse[] = {1.0, 1.0, 1.0, 0.0};
static float light0_position[] = {0.8660254, 0.5, 1, 0};
static float light0_specular[] = {1.0, 1.0, 1.0, 0.0};
static float bevel_mat_ambient[] = {0.0, 0.0, 0.0, 1.0};
static float bevel_mat_shininess[] = {40.0};
static float bevel_mat_specular[] = {1.0, 1.0, 1.0, 0.0};
static float bevel_mat_diffuse[] = {1.0, 0.0, 0.0, 0.0};
ReInit();
for (i = 0; i < RINGS; i++)
{
rgb_colors[i][0] = rgb_colors[i][1] = rgb_colors[i][2] = 0;
}
rgb_colors[BLUERING][2] = 255;
rgb_colors[REDRING][0] = 255;
rgb_colors[GREENRING][1] = 255;
rgb_colors[YELLOWRING][0] = 255;
rgb_colors[YELLOWRING][1] = 255;
mapped_colors[BLUERING] = COLOR_BLUE;
mapped_colors[REDRING] = COLOR_RED;
mapped_colors[GREENRING] = COLOR_GREEN;
mapped_colors[YELLOWRING] = COLOR_YELLOW;
mapped_colors[BLACKRING] = COLOR_BLACK;
dests[BLUERING][0] = -spacing;
dests[BLUERING][1] = top_y;
dests[BLUERING][2] = top_z;
dests[BLACKRING][0] = 0.0;
dests[BLACKRING][1] = top_y;
dests[BLACKRING][2] = top_z;
dests[REDRING][0] = spacing;
dests[REDRING][1] = top_y;
dests[REDRING][2] = top_z;
dests[YELLOWRING][0] = -spacing / 2.0;
dests[YELLOWRING][1] = bottom_y;
dests[YELLOWRING][2] = bottom_z;
dests[GREENRING][0] = spacing / 2.0;
dests[GREENRING][1] = bottom_y;
dests[GREENRING][2] = bottom_z;
base = 2.0;
height = 2.0;
theTorus = glGenLists(1);
glNewList(theTorus, GL_COMPILE);
FillTorus(0.1, 8, 1.0, 25);
glEndList();
x = (float)XSIZE;
y = (float)YSIZE;
aspect = x / y;
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glEnable(GL_DEPTH_TEST);
glClearDepth(1.0);
if (rgb)
{
glClearColor(0.5, 0.5, 0.5, 0.0);
glLightfv(GL_LIGHT0, GL_AMBIENT, light0_ambient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, light0_diffuse);
glLightfv(GL_LIGHT0, GL_SPECULAR, light0_specular);
glLightfv(GL_LIGHT0, GL_POSITION, light0_position);
glEnable(GL_LIGHT0);
glLightModelfv(GL_LIGHT_MODEL_LOCAL_VIEWER, lmodel_local);
glLightModelfv(GL_LIGHT_MODEL_TWO_SIDE, lmodel_twoside);
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
glEnable(GL_LIGHTING);
glMaterialfv(GL_FRONT, GL_AMBIENT, bevel_mat_ambient);
glMaterialfv(GL_FRONT, GL_SHININESS, bevel_mat_shininess);
glMaterialfv(GL_FRONT, GL_SPECULAR, bevel_mat_specular);
glMaterialfv(GL_FRONT, GL_DIFFUSE, bevel_mat_diffuse);
glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
glEnable(GL_COLOR_MATERIAL);
glShadeModel(GL_SMOOTH);
}
else
{
glClearIndex(BACKGROUND);
glShadeModel(GL_FLAT);
}
glMatrixMode(GL_PROJECTION);
gluPerspective(45, 1.33, 0.1, 100.0);
glMatrixMode(GL_MODELVIEW);
}
UGL_LOCAL void echoUse(void)
{
printf("tOlympic keys:\n");
printf(" SPACE Reinitialize\n");
printf(" ESC Exit\n");
}
UGL_LOCAL void readKey (UGL_WCHAR key)
{
switch(key)
{
case UGL_UNI_SPACE:
ReInit();
break;
case UGL_UNI_ESCAPE:
stopWex = 1;
break;
}
}
UGL_LOCAL void loopEvent(void)
{
UGL_EVENT event;
UGL_INPUT_EVENT * pInputEvent;
UGL_FOREVER
{
if (uglEventGet (qId, &event, sizeof (event), UGL_NO_WAIT)
!= UGL_STATUS_Q_EMPTY)
{
pInputEvent = (UGL_INPUT_EVENT *)&event;
if (pInputEvent->header.type == UGL_EVENT_TYPE_KEYBOARD &&
pInputEvent->modifiers & UGL_KEYBOARD_KEYDOWN)
readKey(pInputEvent->type.keyboard.key);
}
drawGL();
if (stopWex)
break;
}
}
void windMLOlympic (UGL_BOOL windMLMode);
void uglolympic (void)
{
taskSpawn("tOlympic", 210, VX_FP_TASK, 100000, (FUNCPTR)windMLOlympic,
0,1,2,3,4,5,6,7,8,9);
}
void windMLOlympic(UGL_BOOL windMLMode)
{
UGL_INPUT_DEVICE_ID keyboardDevId;
uglInitialize();
uglDriverFind (UGL_KEYBOARD_TYPE, 0, (UGL_UINT32 *)&keyboardDevId);
if (uglDriverFind (UGL_EVENT_SERVICE_TYPE, 0,
(UGL_UINT32 *)&eventServiceId) == UGL_STATUS_OK)
{
qId = uglEventQCreate (eventServiceId, 100);
}
else
{
eventServiceId = UGL_NULL;
}
if (windMLMode)
umc = uglMesaCreateNewContext(UGL_MESA_DOUBLE
| UGL_MESA_WINDML_EXCLUSIVE, NULL);
else
umc = uglMesaCreateNewContext(UGL_MESA_DOUBLE, NULL);
if (umc == NULL)
{
uglDeinitialize();
return;
}
uglMesaMakeCurrentContext(umc, 0, 0, UGL_MESA_FULLSCREEN_WIDTH,
UGL_MESA_FULLSCREEN_HEIGHT);
uglMesaGetIntegerv(UGL_MESA_RGB, &rgb);
initGL();
echoUse();
stopWex = 0;
loopEvent();
if (eventServiceId != UGL_NULL)
uglEventQDestroy (eventServiceId, qId);
uglMesaDestroyContext();
uglDeinitialize();
return;
}
Reference in New Issue View Git Blame Copy Permalink