summaryrefslogtreecommitdiff
path: root/progs/samples/tri.c
diff options
context:
space:
mode:
Diffstat (limited to 'progs/samples/tri.c')
-rw-r--r--progs/samples/tri.c403
1 files changed, 403 insertions, 0 deletions
diff --git a/progs/samples/tri.c b/progs/samples/tri.c
new file mode 100644
index 0000000000..700325132e
--- /dev/null
+++ b/progs/samples/tri.c
@@ -0,0 +1,403 @@
+/*
+ * 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.
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <GL/glut.h>
+
+
+#define SOLID 1
+#define LINE 2
+#define POINT 3
+
+
+GLenum rgb, doubleBuffer, windType;
+GLint windW, windH;
+
+GLenum dithering = GL_TRUE;
+GLenum showVerticies = GL_TRUE;
+GLenum hideBottomTriangle = GL_FALSE;
+GLenum outline = GL_TRUE;
+GLenum culling = GL_FALSE;
+GLenum winding = GL_FALSE;
+GLenum face = GL_FALSE;
+GLenum state = SOLID;
+GLenum aaMode = GL_FALSE;
+GLenum shade = GL_TRUE;
+
+GLint color1, color2, color3;
+
+float zRotation = 90.0;
+float zoom = 1.0;
+
+float boxA[3] = {-100, -100, 0};
+float boxB[3] = { 100, -100, 0};
+float boxC[3] = { 100, 100, 0};
+float boxD[3] = {-100, 100, 0};
+
+float p0[3] = {-125,-80, 0};
+float p1[3] = {-125, 80, 0};
+float p2[3] = { 172, 0, 0};
+
+
+#include "tkmap.c"
+
+static void Init(void)
+{
+ float r, g, b;
+ float percent1, percent2;
+ GLint i, j;
+
+ glClearColor(0.0, 0.0, 0.0, 0.0);
+
+ glLineStipple(1, 0xF0F0);
+
+ glEnable(GL_SCISSOR_TEST);
+
+ if (!rgb) {
+ for (j = 0; j <= 12; j++) {
+ if (j <= 6) {
+ percent1 = j / 6.0;
+ r = 1.0 - 0.8 * percent1;
+ g = 0.2 + 0.8 * percent1;
+ b = 0.2;
+ } else {
+ percent1 = (j - 6) / 6.0;
+ r = 0.2;
+ g = 1.0 - 0.8 * percent1;
+ b = 0.2 + 0.8 * percent1;
+ }
+ glutSetColor(j+18, r, g, b);
+ for (i = 0; i < 16; i++) {
+ percent2 = i / 15.0;
+ glutSetColor(j*16+1+32, r*percent2, g*percent2, b*percent2);
+ }
+ }
+ color1 = 18;
+ color2 = 24;
+ color3 = 30;
+ }
+}
+
+static void Reshape(int width, int height)
+{
+
+ windW = (GLint)width;
+ windH = (GLint)height;
+}
+
+static void Key2(int key, int x, int y)
+{
+
+ switch (key) {
+ case GLUT_KEY_LEFT:
+ zRotation += 0.5;
+ break;
+ case GLUT_KEY_RIGHT:
+ zRotation -= 0.5;
+ break;
+ default:
+ return;
+ }
+
+ glutPostRedisplay();
+}
+
+static void Key(unsigned char key, int x, int y)
+{
+
+ switch (key) {
+ case 27:
+ exit(1);
+ case 'Z':
+ zoom *= 0.75;
+ break;
+ case 'z':
+ zoom /= 0.75;
+ if (zoom > 10) {
+ zoom = 10;
+ }
+ break;
+ case '1':
+ glPolygonMode(GL_FRONT_AND_BACK, GL_POINT);
+ break;
+ case '2':
+ glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+ break;
+ case '3':
+ glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+ break;
+ case '4':
+ state = POINT;
+ break;
+ case '5':
+ state = LINE;
+ break;
+ case '6':
+ state = SOLID;
+ break;
+ case '7':
+ culling = !culling;
+ break;
+ case '8':
+ winding = !winding;
+ break;
+ case '9':
+ face = !face;
+ break;
+ case 'v':
+ showVerticies = !showVerticies;
+ break;
+ case 's':
+ shade = !shade;
+ (shade) ? glShadeModel(GL_SMOOTH) : glShadeModel(GL_FLAT);
+ break;
+ case 'h':
+ hideBottomTriangle = !hideBottomTriangle;
+ break;
+ case 'o':
+ outline = !outline;
+ break;
+ case 'm':
+ dithering = !dithering;
+ break;
+ case '0':
+ aaMode = !aaMode;
+ if (aaMode) {
+ glEnable(GL_POLYGON_SMOOTH);
+ glEnable(GL_BLEND);
+ glBlendFunc(GL_SRC_ALPHA, GL_ONE);
+ if (!rgb) {
+ color1 = 32;
+ color2 = 128;
+ color3 = 224;
+ }
+ } else {
+ glDisable(GL_POLYGON_SMOOTH);
+ glDisable(GL_BLEND);
+ if (!rgb) {
+ color1 = 18;
+ color2 = 24;
+ color3 = 30;
+ }
+ }
+ break;
+ default:
+ return;
+ }
+
+ glutPostRedisplay();
+}
+
+static void BeginPrim(void)
+{
+
+ switch (state) {
+ case SOLID:
+ glBegin(GL_POLYGON);
+ break;
+ case LINE:
+ glBegin(GL_LINE_LOOP);
+ break;
+ case POINT:
+ glBegin(GL_POINTS);
+ break;
+ default:
+ break;
+ }
+}
+
+static void EndPrim(void)
+{
+
+ glEnd();
+}
+
+static void Draw(void)
+{
+ float scaleX, scaleY;
+
+ glViewport(0, 0, windW, windH);
+
+ glMatrixMode(GL_PROJECTION);
+ glLoadIdentity();
+ gluOrtho2D(-175, 175, -175, 175);
+ glMatrixMode(GL_MODELVIEW);
+
+ glScissor(0, 0, windW, windH);
+
+ (culling) ? glEnable(GL_CULL_FACE) : glDisable(GL_CULL_FACE);
+ (winding) ? glFrontFace(GL_CCW) : glFrontFace(GL_CW);
+ (face) ? glCullFace(GL_FRONT) : glCullFace(GL_BACK);
+
+ (dithering) ? glEnable(GL_DITHER) : glDisable(GL_DITHER);
+
+ glClear(GL_COLOR_BUFFER_BIT);
+
+ SetColor(COLOR_GREEN);
+ glBegin(GL_LINE_LOOP);
+ glVertex3fv(boxA);
+ glVertex3fv(boxB);
+ glVertex3fv(boxC);
+ glVertex3fv(boxD);
+ glEnd();
+
+ if (!hideBottomTriangle) {
+ glPushMatrix();
+
+ glScalef(zoom, zoom, zoom);
+ glRotatef(zRotation, 0, 0, 1);
+
+ SetColor(COLOR_BLUE);
+ BeginPrim();
+ glVertex3fv(p0);
+ glVertex3fv(p1);
+ glVertex3fv(p2);
+ EndPrim();
+
+ if (showVerticies) {
+ (rgb) ? glColor3fv(RGBMap[COLOR_RED]) : glIndexf(color1);
+ glRectf(p0[0]-2, p0[1]-2, p0[0]+2, p0[1]+2);
+ (rgb) ? glColor3fv(RGBMap[COLOR_GREEN]) : glIndexf(color2);
+ glRectf(p1[0]-2, p1[1]-2, p1[0]+2, p1[1]+2);
+ (rgb) ? glColor3fv(RGBMap[COLOR_BLUE]) : glIndexf(color3);
+ glRectf(p2[0]-2, p2[1]-2, p2[0]+2, p2[1]+2);
+ }
+
+ glPopMatrix();
+ }
+
+ scaleX = (float)(windW - 20) / 2 / 175 * (175 - 100) + 10;
+ scaleY = (float)(windH - 20) / 2 / 175 * (175 - 100) + 10;
+
+ glViewport(scaleX, scaleY, windW-2*scaleX, windH-2*scaleY);
+
+ glMatrixMode(GL_PROJECTION);
+ glLoadIdentity();
+ gluOrtho2D(-100, 100, -100, 100);
+ glMatrixMode(GL_MODELVIEW);
+
+ glScissor(scaleX, scaleY, windW-2*scaleX, windH-2*scaleY);
+
+ glPushMatrix();
+
+ glScalef(zoom, zoom, zoom);
+ glRotatef(zRotation, 0,0,1);
+
+ glPointSize(10);
+ glLineWidth(5);
+ glEnable(GL_POINT_SMOOTH);
+ glEnable(GL_LINE_STIPPLE);
+ glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+ SetColor(COLOR_RED);
+ BeginPrim();
+ (rgb) ? glColor3fv(RGBMap[COLOR_RED]) : glIndexf(color1);
+ glVertex3fv(p0);
+ (rgb) ? glColor3fv(RGBMap[COLOR_GREEN]) : glIndexf(color2);
+ glVertex3fv(p1);
+ (rgb) ? glColor3fv(RGBMap[COLOR_BLUE]) : glIndexf(color3);
+ glVertex3fv(p2);
+ EndPrim();
+
+ glPointSize(1);
+ glLineWidth(1);
+ glDisable(GL_POINT_SMOOTH);
+ glDisable(GL_LINE_STIPPLE);
+ glBlendFunc(GL_ONE, GL_ZERO);
+
+ if (outline) {
+ SetColor(COLOR_WHITE);
+ glBegin(GL_LINE_LOOP);
+ glVertex3fv(p0);
+ glVertex3fv(p1);
+ glVertex3fv(p2);
+ glEnd();
+ }
+
+ glPopMatrix();
+
+ glFlush();
+
+ if (doubleBuffer) {
+ glutSwapBuffers();
+ }
+}
+
+static GLenum Args(int argc, char **argv)
+{
+ GLint i;
+
+ rgb = GL_TRUE;
+ doubleBuffer = GL_FALSE;
+
+ for (i = 1; i < argc; i++) {
+ if (strcmp(argv[i], "-ci") == 0) {
+ rgb = GL_FALSE;
+ } else if (strcmp(argv[i], "-rgb") == 0) {
+ rgb = GL_TRUE;
+ } else if (strcmp(argv[i], "-sb") == 0) {
+ doubleBuffer = GL_FALSE;
+ } else if (strcmp(argv[i], "-db") == 0) {
+ doubleBuffer = GL_TRUE;
+ } else {
+ printf("%s (Bad option).\n", argv[i]);
+ return GL_FALSE;
+ }
+ }
+ return GL_TRUE;
+}
+
+int main(int argc, char **argv)
+{
+ glutInit(&argc, argv);
+
+ if (Args(argc, argv) == GL_FALSE) {
+ exit(1);
+ }
+
+ windW = 600;
+ windH = 300;
+ glutInitWindowPosition(0, 0); glutInitWindowSize( windW, windH);
+
+ windType = (rgb) ? GLUT_RGB : GLUT_INDEX;
+ windType |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE;
+ glutInitDisplayMode(windType);
+
+ if (glutCreateWindow("Triangle Test") == GL_FALSE) {
+ exit(1);
+ }
+
+ InitMap();
+
+ Init();
+
+ glutReshapeFunc(Reshape);
+ glutKeyboardFunc(Key);
+ glutSpecialFunc(Key2);
+ glutDisplayFunc(Draw);
+ glutMainLoop();
+ return 0;
+}