@@ -45,6 +45,10 @@ SOURCES = \ | |||
tri-tex.c \ | |||
tri-xpd.c \ | |||
tri-position.c \ | |||
tri-depth.c \ | |||
tri-depth2.c \ | |||
tri-depthwrite.c \ | |||
tri-depthwrite2.c \ | |||
NOTDONE=\ | |||
tri-txb.c \ |
@@ -1,26 +1,3 @@ | |||
/* | |||
* 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> | |||
@@ -29,11 +6,6 @@ | |||
#include <GL/glut.h> | |||
#define CI_OFFSET_1 16 | |||
#define CI_OFFSET_2 32 | |||
GLenum doubleBuffer; | |||
static void Init( void ) | |||
{ | |||
@@ -106,44 +78,19 @@ static void Draw(void) | |||
glFlush(); | |||
if (doubleBuffer) { | |||
glutSwapBuffers(); | |||
} | |||
} | |||
static GLenum Args(int argc, char **argv) | |||
{ | |||
GLint i; | |||
doubleBuffer = GL_FALSE; | |||
for (i = 1; i < argc; i++) { | |||
if (strcmp(argv[i], "-sb") == 0) { | |||
doubleBuffer = GL_FALSE; | |||
} else if (strcmp(argv[i], "-db") == 0) { | |||
doubleBuffer = GL_TRUE; | |||
} else { | |||
fprintf(stderr, "%s (Bad option).\n", argv[i]); | |||
return GL_FALSE; | |||
} | |||
} | |||
return GL_TRUE; | |||
} | |||
int main(int argc, char **argv) | |||
{ | |||
GLenum type; | |||
glutInit(&argc, argv); | |||
if (Args(argc, argv) == GL_FALSE) { | |||
exit(1); | |||
} | |||
glutInitWindowPosition(0, 0); glutInitWindowSize( 250, 250); | |||
type = GLUT_RGB; | |||
type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE; | |||
type |= GLUT_SINGLE; | |||
glutInitDisplayMode(type); | |||
if (glutCreateWindow("First Tri") == GL_FALSE) { |
@@ -1,26 +1,3 @@ | |||
/* | |||
* 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> | |||
@@ -29,11 +6,6 @@ | |||
#include <GL/glut.h> | |||
#define CI_OFFSET_1 16 | |||
#define CI_OFFSET_2 32 | |||
GLenum doubleBuffer; | |||
static void Init( void ) | |||
{ | |||
@@ -106,44 +78,22 @@ static void Draw(void) | |||
glFlush(); | |||
if (doubleBuffer) { | |||
glutSwapBuffers(); | |||
} | |||
} | |||
static GLenum Args(int argc, char **argv) | |||
{ | |||
GLint i; | |||
doubleBuffer = GL_FALSE; | |||
for (i = 1; i < argc; i++) { | |||
if (strcmp(argv[i], "-sb") == 0) { | |||
doubleBuffer = GL_FALSE; | |||
} else if (strcmp(argv[i], "-db") == 0) { | |||
doubleBuffer = GL_TRUE; | |||
} else { | |||
fprintf(stderr, "%s (Bad option).\n", argv[i]); | |||
return GL_FALSE; | |||
} | |||
} | |||
return GL_TRUE; | |||
} | |||
int main(int argc, char **argv) | |||
{ | |||
GLenum type; | |||
glutInit(&argc, argv); | |||
if (Args(argc, argv) == GL_FALSE) { | |||
exit(1); | |||
} | |||
glutInitWindowPosition(0, 0); glutInitWindowSize( 250, 250); | |||
type = GLUT_RGB; | |||
type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE; | |||
type |= GLUT_SINGLE; | |||
glutInitDisplayMode(type); | |||
if (glutCreateWindow("First Tri") == GL_FALSE) { |
@@ -1,26 +1,3 @@ | |||
/* | |||
* 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> | |||
@@ -29,11 +6,6 @@ | |||
#include <GL/glut.h> | |||
#define CI_OFFSET_1 16 | |||
#define CI_OFFSET_2 32 | |||
GLenum doubleBuffer; | |||
static void Init( void ) | |||
{ | |||
@@ -106,44 +78,22 @@ static void Draw(void) | |||
glFlush(); | |||
if (doubleBuffer) { | |||
glutSwapBuffers(); | |||
} | |||
} | |||
static GLenum Args(int argc, char **argv) | |||
{ | |||
GLint i; | |||
doubleBuffer = GL_FALSE; | |||
for (i = 1; i < argc; i++) { | |||
if (strcmp(argv[i], "-sb") == 0) { | |||
doubleBuffer = GL_FALSE; | |||
} else if (strcmp(argv[i], "-db") == 0) { | |||
doubleBuffer = GL_TRUE; | |||
} else { | |||
fprintf(stderr, "%s (Bad option).\n", argv[i]); | |||
return GL_FALSE; | |||
} | |||
} | |||
return GL_TRUE; | |||
} | |||
int main(int argc, char **argv) | |||
{ | |||
GLenum type; | |||
glutInit(&argc, argv); | |||
if (Args(argc, argv) == GL_FALSE) { | |||
exit(1); | |||
} | |||
glutInitWindowPosition(0, 0); glutInitWindowSize( 250, 250); | |||
type = GLUT_RGB; | |||
type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE; | |||
type |= GLUT_SINGLE; | |||
glutInitDisplayMode(type); | |||
if (glutCreateWindow("First Tri") == GL_FALSE) { |
@@ -1,26 +1,3 @@ | |||
/* | |||
* 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> | |||
@@ -30,11 +7,6 @@ | |||
#include "GL/gl.h" | |||
#define CI_OFFSET_1 16 | |||
#define CI_OFFSET_2 32 | |||
GLenum doubleBuffer; | |||
static void Init( void ) | |||
{ | |||
@@ -109,44 +81,22 @@ static void Draw(void) | |||
glFlush(); | |||
if (doubleBuffer) { | |||
glutSwapBuffers(); | |||
} | |||
} | |||
static GLenum Args(int argc, char **argv) | |||
{ | |||
GLint i; | |||
doubleBuffer = GL_FALSE; | |||
for (i = 1; i < argc; i++) { | |||
if (strcmp(argv[i], "-sb") == 0) { | |||
doubleBuffer = GL_FALSE; | |||
} else if (strcmp(argv[i], "-db") == 0) { | |||
doubleBuffer = GL_TRUE; | |||
} else { | |||
fprintf(stderr, "%s (Bad option).\n", argv[i]); | |||
return GL_FALSE; | |||
} | |||
} | |||
return GL_TRUE; | |||
} | |||
int main(int argc, char **argv) | |||
{ | |||
GLenum type; | |||
glutInit(&argc, argv); | |||
if (Args(argc, argv) == GL_FALSE) { | |||
exit(1); | |||
} | |||
glutInitWindowPosition(0, 0); glutInitWindowSize( 250, 250); | |||
type = GLUT_RGB; | |||
type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE; | |||
type |= GLUT_SINGLE; | |||
glutInitDisplayMode(type); | |||
if (glutCreateWindow("First Tri") == GL_FALSE) { |
@@ -1,26 +1,3 @@ | |||
/* | |||
* 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> | |||
@@ -29,11 +6,6 @@ | |||
#include <GL/glut.h> | |||
#define CI_OFFSET_1 16 | |||
#define CI_OFFSET_2 32 | |||
GLenum doubleBuffer; | |||
static void Init( void ) | |||
{ | |||
@@ -105,44 +77,22 @@ static void Draw(void) | |||
glFlush(); | |||
if (doubleBuffer) { | |||
glutSwapBuffers(); | |||
} | |||
} | |||
static GLenum Args(int argc, char **argv) | |||
{ | |||
GLint i; | |||
doubleBuffer = GL_FALSE; | |||
for (i = 1; i < argc; i++) { | |||
if (strcmp(argv[i], "-sb") == 0) { | |||
doubleBuffer = GL_FALSE; | |||
} else if (strcmp(argv[i], "-db") == 0) { | |||
doubleBuffer = GL_TRUE; | |||
} else { | |||
fprintf(stderr, "%s (Bad option).\n", argv[i]); | |||
return GL_FALSE; | |||
} | |||
} | |||
return GL_TRUE; | |||
} | |||
int main(int argc, char **argv) | |||
{ | |||
GLenum type; | |||
glutInit(&argc, argv); | |||
if (Args(argc, argv) == GL_FALSE) { | |||
exit(1); | |||
} | |||
glutInitWindowPosition(0, 0); glutInitWindowSize( 250, 250); | |||
type = GLUT_RGB; | |||
type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE; | |||
type |= GLUT_SINGLE; | |||
glutInitDisplayMode(type); | |||
if (glutCreateWindow("First Tri") == GL_FALSE) { |
@@ -1,26 +1,3 @@ | |||
/* | |||
* 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> | |||
@@ -29,11 +6,6 @@ | |||
#include <GL/glut.h> | |||
#define CI_OFFSET_1 16 | |||
#define CI_OFFSET_2 32 | |||
GLenum doubleBuffer; | |||
static void Init( void ) | |||
{ | |||
@@ -105,44 +77,22 @@ static void Draw(void) | |||
glFlush(); | |||
if (doubleBuffer) { | |||
glutSwapBuffers(); | |||
} | |||
} | |||
static GLenum Args(int argc, char **argv) | |||
{ | |||
GLint i; | |||
doubleBuffer = GL_FALSE; | |||
for (i = 1; i < argc; i++) { | |||
if (strcmp(argv[i], "-sb") == 0) { | |||
doubleBuffer = GL_FALSE; | |||
} else if (strcmp(argv[i], "-db") == 0) { | |||
doubleBuffer = GL_TRUE; | |||
} else { | |||
fprintf(stderr, "%s (Bad option).\n", argv[i]); | |||
return GL_FALSE; | |||
} | |||
} | |||
return GL_TRUE; | |||
} | |||
int main(int argc, char **argv) | |||
{ | |||
GLenum type; | |||
glutInit(&argc, argv); | |||
if (Args(argc, argv) == GL_FALSE) { | |||
exit(1); | |||
} | |||
glutInitWindowPosition(0, 0); glutInitWindowSize( 250, 250); | |||
type = GLUT_RGB; | |||
type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE; | |||
type |= GLUT_SINGLE; | |||
glutInitDisplayMode(type); | |||
if (glutCreateWindow("First Tri") == GL_FALSE) { |
@@ -1,26 +1,3 @@ | |||
/* | |||
* 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> | |||
@@ -29,11 +6,6 @@ | |||
#include <GL/glut.h> | |||
#define CI_OFFSET_1 16 | |||
#define CI_OFFSET_2 32 | |||
GLenum doubleBuffer; | |||
static void Init( void ) | |||
{ | |||
@@ -105,44 +77,22 @@ static void Draw(void) | |||
glFlush(); | |||
if (doubleBuffer) { | |||
glutSwapBuffers(); | |||
} | |||
} | |||
static GLenum Args(int argc, char **argv) | |||
{ | |||
GLint i; | |||
doubleBuffer = GL_FALSE; | |||
for (i = 1; i < argc; i++) { | |||
if (strcmp(argv[i], "-sb") == 0) { | |||
doubleBuffer = GL_FALSE; | |||
} else if (strcmp(argv[i], "-db") == 0) { | |||
doubleBuffer = GL_TRUE; | |||
} else { | |||
fprintf(stderr, "%s (Bad option).\n", argv[i]); | |||
return GL_FALSE; | |||
} | |||
} | |||
return GL_TRUE; | |||
} | |||
int main(int argc, char **argv) | |||
{ | |||
GLenum type; | |||
glutInit(&argc, argv); | |||
if (Args(argc, argv) == GL_FALSE) { | |||
exit(1); | |||
} | |||
glutInitWindowPosition(0, 0); glutInitWindowSize( 250, 250); | |||
type = GLUT_RGB; | |||
type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE; | |||
type |= GLUT_SINGLE; | |||
glutInitDisplayMode(type); | |||
if (glutCreateWindow("First Tri") == GL_FALSE) { |
@@ -1,26 +1,3 @@ | |||
/* | |||
* 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> | |||
@@ -30,11 +7,6 @@ | |||
#include "GL/gl.h" | |||
#define CI_OFFSET_1 16 | |||
#define CI_OFFSET_2 32 | |||
GLenum doubleBuffer; | |||
static void Init( void ) | |||
{ | |||
@@ -105,44 +77,22 @@ static void Draw(void) | |||
glFlush(); | |||
if (doubleBuffer) { | |||
glutSwapBuffers(); | |||
} | |||
} | |||
static GLenum Args(int argc, char **argv) | |||
{ | |||
GLint i; | |||
doubleBuffer = GL_FALSE; | |||
for (i = 1; i < argc; i++) { | |||
if (strcmp(argv[i], "-sb") == 0) { | |||
doubleBuffer = GL_FALSE; | |||
} else if (strcmp(argv[i], "-db") == 0) { | |||
doubleBuffer = GL_TRUE; | |||
} else { | |||
fprintf(stderr, "%s (Bad option).\n", argv[i]); | |||
return GL_FALSE; | |||
} | |||
} | |||
return GL_TRUE; | |||
} | |||
int main(int argc, char **argv) | |||
{ | |||
GLenum type; | |||
glutInit(&argc, argv); | |||
if (Args(argc, argv) == GL_FALSE) { | |||
exit(1); | |||
} | |||
glutInitWindowPosition(0, 0); glutInitWindowSize( 250, 250); | |||
type = GLUT_RGB; | |||
type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE; | |||
type |= GLUT_SINGLE; | |||
glutInitDisplayMode(type); | |||
if (glutCreateWindow("First Tri") == GL_FALSE) { |
@@ -1,26 +1,3 @@ | |||
/* | |||
* 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> | |||
@@ -29,11 +6,6 @@ | |||
#include <GL/glut.h> | |||
#define CI_OFFSET_1 16 | |||
#define CI_OFFSET_2 32 | |||
GLenum doubleBuffer; | |||
static void Init( void ) | |||
{ | |||
@@ -106,44 +78,22 @@ static void Draw(void) | |||
glFlush(); | |||
if (doubleBuffer) { | |||
glutSwapBuffers(); | |||
} | |||
} | |||
static GLenum Args(int argc, char **argv) | |||
{ | |||
GLint i; | |||
doubleBuffer = GL_FALSE; | |||
for (i = 1; i < argc; i++) { | |||
if (strcmp(argv[i], "-sb") == 0) { | |||
doubleBuffer = GL_FALSE; | |||
} else if (strcmp(argv[i], "-db") == 0) { | |||
doubleBuffer = GL_TRUE; | |||
} else { | |||
fprintf(stderr, "%s (Bad option).\n", argv[i]); | |||
return GL_FALSE; | |||
} | |||
} | |||
return GL_TRUE; | |||
} | |||
int main(int argc, char **argv) | |||
{ | |||
GLenum type; | |||
glutInit(&argc, argv); | |||
if (Args(argc, argv) == GL_FALSE) { | |||
exit(1); | |||
} | |||
glutInitWindowPosition(0, 0); glutInitWindowSize( 250, 250); | |||
type = GLUT_RGB; | |||
type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE; | |||
type |= GLUT_SINGLE; | |||
glutInitDisplayMode(type); | |||
if (glutCreateWindow("First Tri") == GL_FALSE) { |
@@ -1,26 +1,3 @@ | |||
/* | |||
* 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> | |||
@@ -29,11 +6,6 @@ | |||
#include <GL/glut.h> | |||
#define CI_OFFSET_1 16 | |||
#define CI_OFFSET_2 32 | |||
GLenum doubleBuffer; | |||
static void Init(void) | |||
{ | |||
@@ -84,33 +56,13 @@ static void Draw(void) | |||
glFlush(); | |||
if (doubleBuffer) { | |||
glutSwapBuffers(); | |||
} | |||
/* Exit after first frame | |||
*/ | |||
exit(0); | |||
} | |||
static GLenum Args(int argc, char **argv) | |||
{ | |||
GLint i; | |||
doubleBuffer = GL_FALSE; | |||
for (i = 1; i < argc; i++) { | |||
if (strcmp(argv[i], "-sb") == 0) { | |||
doubleBuffer = GL_FALSE; | |||
} else if (strcmp(argv[i], "-db") == 0) { | |||
doubleBuffer = GL_TRUE; | |||
} else { | |||
fprintf(stderr, "%s (Bad option).\n", argv[i]); | |||
return GL_FALSE; | |||
} | |||
} | |||
return GL_TRUE; | |||
} | |||
int main(int argc, char **argv) | |||
{ | |||
@@ -118,14 +70,12 @@ int main(int argc, char **argv) | |||
glutInit(&argc, argv); | |||
if (Args(argc, argv) == GL_FALSE) { | |||
exit(1); | |||
} | |||
glutInitWindowPosition(0, 0); glutInitWindowSize( 250, 250); | |||
type = GLUT_RGB; | |||
type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE; | |||
type |= GLUT_SINGLE; | |||
glutInitDisplayMode(type); | |||
if (glutCreateWindow("First Tri") == GL_FALSE) { |
@@ -1,26 +1,3 @@ | |||
/* | |||
* 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> | |||
@@ -29,11 +6,6 @@ | |||
#include <GL/glut.h> | |||
#define CI_OFFSET_1 16 | |||
#define CI_OFFSET_2 32 | |||
GLenum doubleBuffer; | |||
static void Init( void ) | |||
{ | |||
@@ -106,44 +78,22 @@ static void Draw(void) | |||
glFlush(); | |||
if (doubleBuffer) { | |||
glutSwapBuffers(); | |||
} | |||
} | |||
static GLenum Args(int argc, char **argv) | |||
{ | |||
GLint i; | |||
doubleBuffer = GL_FALSE; | |||
for (i = 1; i < argc; i++) { | |||
if (strcmp(argv[i], "-sb") == 0) { | |||
doubleBuffer = GL_FALSE; | |||
} else if (strcmp(argv[i], "-db") == 0) { | |||
doubleBuffer = GL_TRUE; | |||
} else { | |||
fprintf(stderr, "%s (Bad option).\n", argv[i]); | |||
return GL_FALSE; | |||
} | |||
} | |||
return GL_TRUE; | |||
} | |||
int main(int argc, char **argv) | |||
{ | |||
GLenum type; | |||
glutInit(&argc, argv); | |||
if (Args(argc, argv) == GL_FALSE) { | |||
exit(1); | |||
} | |||
glutInitWindowPosition(0, 0); glutInitWindowSize( 250, 250); | |||
type = GLUT_RGB; | |||
type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE; | |||
type |= GLUT_SINGLE; | |||
glutInitDisplayMode(type); | |||
if (glutCreateWindow("First Tri") == GL_FALSE) { |
@@ -1,26 +1,3 @@ | |||
/* | |||
* 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> | |||
@@ -30,11 +7,6 @@ | |||
#include "GL/gl.h" | |||
#define CI_OFFSET_1 16 | |||
#define CI_OFFSET_2 32 | |||
GLenum doubleBuffer; | |||
static void Init( void ) | |||
{ | |||
@@ -105,44 +77,22 @@ static void Draw(void) | |||
glFlush(); | |||
if (doubleBuffer) { | |||
glutSwapBuffers(); | |||
} | |||
} | |||
static GLenum Args(int argc, char **argv) | |||
{ | |||
GLint i; | |||
doubleBuffer = GL_FALSE; | |||
for (i = 1; i < argc; i++) { | |||
if (strcmp(argv[i], "-sb") == 0) { | |||
doubleBuffer = GL_FALSE; | |||
} else if (strcmp(argv[i], "-db") == 0) { | |||
doubleBuffer = GL_TRUE; | |||
} else { | |||
fprintf(stderr, "%s (Bad option).\n", argv[i]); | |||
return GL_FALSE; | |||
} | |||
} | |||
return GL_TRUE; | |||
} | |||
int main(int argc, char **argv) | |||
{ | |||
GLenum type; | |||
glutInit(&argc, argv); | |||
if (Args(argc, argv) == GL_FALSE) { | |||
exit(1); | |||
} | |||
glutInitWindowPosition(0, 0); glutInitWindowSize( 250, 250); | |||
type = GLUT_RGB; | |||
type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE; | |||
type |= GLUT_SINGLE; | |||
glutInitDisplayMode(type); | |||
if (glutCreateWindow("First Tri") == GL_FALSE) { |
@@ -1,26 +1,3 @@ | |||
/* | |||
* 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> | |||
@@ -30,11 +7,6 @@ | |||
#include "GL/gl.h" | |||
#define CI_OFFSET_1 16 | |||
#define CI_OFFSET_2 32 | |||
GLenum doubleBuffer; | |||
static void Init( void ) | |||
{ | |||
@@ -107,44 +79,22 @@ static void Draw(void) | |||
glFlush(); | |||
if (doubleBuffer) { | |||
glutSwapBuffers(); | |||
} | |||
} | |||
static GLenum Args(int argc, char **argv) | |||
{ | |||
GLint i; | |||
doubleBuffer = GL_FALSE; | |||
for (i = 1; i < argc; i++) { | |||
if (strcmp(argv[i], "-sb") == 0) { | |||
doubleBuffer = GL_FALSE; | |||
} else if (strcmp(argv[i], "-db") == 0) { | |||
doubleBuffer = GL_TRUE; | |||
} else { | |||
fprintf(stderr, "%s (Bad option).\n", argv[i]); | |||
return GL_FALSE; | |||
} | |||
} | |||
return GL_TRUE; | |||
} | |||
int main(int argc, char **argv) | |||
{ | |||
GLenum type; | |||
glutInit(&argc, argv); | |||
if (Args(argc, argv) == GL_FALSE) { | |||
exit(1); | |||
} | |||
glutInitWindowPosition(0, 0); glutInitWindowSize( 250, 250); | |||
type = GLUT_RGB; | |||
type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE; | |||
type |= GLUT_SINGLE; | |||
glutInitDisplayMode(type); | |||
if (glutCreateWindow("First Tri") == GL_FALSE) { |
@@ -1,26 +1,3 @@ | |||
/* | |||
* 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> | |||
@@ -29,11 +6,6 @@ | |||
#include <GL/glut.h> | |||
#define CI_OFFSET_1 16 | |||
#define CI_OFFSET_2 32 | |||
GLenum doubleBuffer; | |||
static void Init( void ) | |||
{ | |||
@@ -105,44 +77,22 @@ static void Draw(void) | |||
glFlush(); | |||
if (doubleBuffer) { | |||
glutSwapBuffers(); | |||
} | |||
} | |||
static GLenum Args(int argc, char **argv) | |||
{ | |||
GLint i; | |||
doubleBuffer = GL_FALSE; | |||
for (i = 1; i < argc; i++) { | |||
if (strcmp(argv[i], "-sb") == 0) { | |||
doubleBuffer = GL_FALSE; | |||
} else if (strcmp(argv[i], "-db") == 0) { | |||
doubleBuffer = GL_TRUE; | |||
} else { | |||
fprintf(stderr, "%s (Bad option).\n", argv[i]); | |||
return GL_FALSE; | |||
} | |||
} | |||
return GL_TRUE; | |||
} | |||
int main(int argc, char **argv) | |||
{ | |||
GLenum type; | |||
glutInit(&argc, argv); | |||
if (Args(argc, argv) == GL_FALSE) { | |||
exit(1); | |||
} | |||
glutInitWindowPosition(0, 0); glutInitWindowSize( 250, 250); | |||
type = GLUT_RGB; | |||
type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE; | |||
type |= GLUT_SINGLE; | |||
glutInitDisplayMode(type); | |||
if (glutCreateWindow("First Tri") == GL_FALSE) { |
@@ -1,26 +1,3 @@ | |||
/* | |||
* 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> | |||
@@ -29,11 +6,6 @@ | |||
#include <GL/glut.h> | |||
#define CI_OFFSET_1 16 | |||
#define CI_OFFSET_2 32 | |||
GLenum doubleBuffer; | |||
static void Init( void ) | |||
{ | |||
@@ -107,44 +79,22 @@ static void Draw(void) | |||
glFlush(); | |||
if (doubleBuffer) { | |||
glutSwapBuffers(); | |||
} | |||
} | |||
static GLenum Args(int argc, char **argv) | |||
{ | |||
GLint i; | |||
doubleBuffer = GL_FALSE; | |||
for (i = 1; i < argc; i++) { | |||
if (strcmp(argv[i], "-sb") == 0) { | |||
doubleBuffer = GL_FALSE; | |||
} else if (strcmp(argv[i], "-db") == 0) { | |||
doubleBuffer = GL_TRUE; | |||
} else { | |||
fprintf(stderr, "%s (Bad option).\n", argv[i]); | |||
return GL_FALSE; | |||
} | |||
} | |||
return GL_TRUE; | |||
} | |||
int main(int argc, char **argv) | |||
{ | |||
GLenum type; | |||
glutInit(&argc, argv); | |||
if (Args(argc, argv) == GL_FALSE) { | |||
exit(1); | |||
} | |||
glutInitWindowPosition(0, 0); glutInitWindowSize( 250, 250); | |||
type = GLUT_RGB; | |||
type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE; | |||
type |= GLUT_SINGLE; | |||
glutInitDisplayMode(type); | |||
if (glutCreateWindow("First Tri") == GL_FALSE) { |
@@ -1,26 +1,3 @@ | |||
/* | |||
* 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> | |||
@@ -29,11 +6,6 @@ | |||
#include <GL/glut.h> | |||
#define CI_OFFSET_1 16 | |||
#define CI_OFFSET_2 32 | |||
GLenum doubleBuffer; | |||
static void Init( void ) | |||
{ | |||
@@ -106,44 +78,22 @@ static void Draw(void) | |||
glFlush(); | |||
if (doubleBuffer) { | |||
glutSwapBuffers(); | |||
} | |||
} | |||
static GLenum Args(int argc, char **argv) | |||
{ | |||
GLint i; | |||
doubleBuffer = GL_FALSE; | |||
for (i = 1; i < argc; i++) { | |||
if (strcmp(argv[i], "-sb") == 0) { | |||
doubleBuffer = GL_FALSE; | |||
} else if (strcmp(argv[i], "-db") == 0) { | |||
doubleBuffer = GL_TRUE; | |||
} else { | |||
fprintf(stderr, "%s (Bad option).\n", argv[i]); | |||
return GL_FALSE; | |||
} | |||
} | |||
return GL_TRUE; | |||
} | |||
int main(int argc, char **argv) | |||
{ | |||
GLenum type; | |||
glutInit(&argc, argv); | |||
if (Args(argc, argv) == GL_FALSE) { | |||
exit(1); | |||
} | |||
glutInitWindowPosition(0, 0); glutInitWindowSize( 250, 250); | |||
type = GLUT_RGB; | |||
type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE; | |||
type |= GLUT_SINGLE; | |||
glutInitDisplayMode(type); | |||
if (glutCreateWindow("First Tri") == GL_FALSE) { |
@@ -1,26 +1,3 @@ | |||
/* | |||
* 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> | |||
@@ -30,11 +7,6 @@ | |||
#include "GL/gl.h" | |||
#define CI_OFFSET_1 16 | |||
#define CI_OFFSET_2 32 | |||
GLenum doubleBuffer; | |||
static void Init( void ) | |||
{ | |||
@@ -107,44 +79,22 @@ static void Draw(void) | |||
glFlush(); | |||
if (doubleBuffer) { | |||
glutSwapBuffers(); | |||
} | |||
} | |||
static GLenum Args(int argc, char **argv) | |||
{ | |||
GLint i; | |||
doubleBuffer = GL_FALSE; | |||
for (i = 1; i < argc; i++) { | |||
if (strcmp(argv[i], "-sb") == 0) { | |||
doubleBuffer = GL_FALSE; | |||
} else if (strcmp(argv[i], "-db") == 0) { | |||
doubleBuffer = GL_TRUE; | |||
} else { | |||
fprintf(stderr, "%s (Bad option).\n", argv[i]); | |||
return GL_FALSE; | |||
} | |||
} | |||
return GL_TRUE; | |||
} | |||
int main(int argc, char **argv) | |||
{ | |||
GLenum type; | |||
glutInit(&argc, argv); | |||
if (Args(argc, argv) == GL_FALSE) { | |||
exit(1); | |||
} | |||
glutInitWindowPosition(0, 0); glutInitWindowSize( 250, 250); | |||
type = GLUT_RGB; | |||
type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE; | |||
type |= GLUT_SINGLE; | |||
glutInitDisplayMode(type); | |||
if (glutCreateWindow("First Tri") == GL_FALSE) { |
@@ -1,26 +1,3 @@ | |||
/* | |||
* 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> | |||
@@ -29,11 +6,6 @@ | |||
#include <GL/glut.h> | |||
#define CI_OFFSET_1 16 | |||
#define CI_OFFSET_2 32 | |||
GLenum doubleBuffer; | |||
static void Init( void ) | |||
{ | |||
@@ -105,44 +77,22 @@ static void Draw(void) | |||
glFlush(); | |||
if (doubleBuffer) { | |||
glutSwapBuffers(); | |||
} | |||
} | |||
static GLenum Args(int argc, char **argv) | |||
{ | |||
GLint i; | |||
doubleBuffer = GL_FALSE; | |||
for (i = 1; i < argc; i++) { | |||
if (strcmp(argv[i], "-sb") == 0) { | |||
doubleBuffer = GL_FALSE; | |||
} else if (strcmp(argv[i], "-db") == 0) { | |||
doubleBuffer = GL_TRUE; | |||
} else { | |||
fprintf(stderr, "%s (Bad option).\n", argv[i]); | |||
return GL_FALSE; | |||
} | |||
} | |||
return GL_TRUE; | |||
} | |||
int main(int argc, char **argv) | |||
{ | |||
GLenum type; | |||
glutInit(&argc, argv); | |||
if (Args(argc, argv) == GL_FALSE) { | |||
exit(1); | |||
} | |||
glutInitWindowPosition(0, 0); glutInitWindowSize( 250, 250); | |||
type = GLUT_RGB; | |||
type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE; | |||
type |= GLUT_SINGLE; | |||
glutInitDisplayMode(type); | |||
if (glutCreateWindow("First Tri") == GL_FALSE) { |
@@ -1,26 +1,3 @@ | |||
/* | |||
* 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> | |||
@@ -29,11 +6,6 @@ | |||
#include <GL/glut.h> | |||
#define CI_OFFSET_1 16 | |||
#define CI_OFFSET_2 32 | |||
GLenum doubleBuffer; | |||
static void Init( void ) | |||
{ | |||
@@ -105,44 +77,22 @@ static void Draw(void) | |||
glFlush(); | |||
if (doubleBuffer) { | |||
glutSwapBuffers(); | |||
} | |||
} | |||
static GLenum Args(int argc, char **argv) | |||
{ | |||
GLint i; | |||
doubleBuffer = GL_FALSE; | |||
for (i = 1; i < argc; i++) { | |||
if (strcmp(argv[i], "-sb") == 0) { | |||
doubleBuffer = GL_FALSE; | |||
} else if (strcmp(argv[i], "-db") == 0) { | |||
doubleBuffer = GL_TRUE; | |||
} else { | |||
fprintf(stderr, "%s (Bad option).\n", argv[i]); | |||
return GL_FALSE; | |||
} | |||
} | |||
return GL_TRUE; | |||
} | |||
int main(int argc, char **argv) | |||
{ | |||
GLenum type; | |||
glutInit(&argc, argv); | |||
if (Args(argc, argv) == GL_FALSE) { | |||
exit(1); | |||
} | |||
glutInitWindowPosition(0, 0); glutInitWindowSize( 250, 250); | |||
type = GLUT_RGB; | |||
type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE; | |||
type |= GLUT_SINGLE; | |||
glutInitDisplayMode(type); | |||
if (glutCreateWindow("First Tri") == GL_FALSE) { |
@@ -1,26 +1,3 @@ | |||
/* | |||
* 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> | |||
@@ -30,11 +7,6 @@ | |||
#include "GL/gl.h" | |||
#define CI_OFFSET_1 16 | |||
#define CI_OFFSET_2 32 | |||
GLenum doubleBuffer; | |||
static void Init( void ) | |||
{ | |||
@@ -105,44 +77,22 @@ static void Draw(void) | |||
glFlush(); | |||
if (doubleBuffer) { | |||
glutSwapBuffers(); | |||
} | |||
} | |||
static GLenum Args(int argc, char **argv) | |||
{ | |||
GLint i; | |||
doubleBuffer = GL_FALSE; | |||
for (i = 1; i < argc; i++) { | |||
if (strcmp(argv[i], "-sb") == 0) { | |||
doubleBuffer = GL_FALSE; | |||
} else if (strcmp(argv[i], "-db") == 0) { | |||
doubleBuffer = GL_TRUE; | |||
} else { | |||
fprintf(stderr, "%s (Bad option).\n", argv[i]); | |||
return GL_FALSE; | |||
} | |||
} | |||
return GL_TRUE; | |||
} | |||
int main(int argc, char **argv) | |||
{ | |||
GLenum type; | |||
glutInit(&argc, argv); | |||
if (Args(argc, argv) == GL_FALSE) { | |||
exit(1); | |||
} | |||
glutInitWindowPosition(0, 0); glutInitWindowSize( 250, 250); | |||
type = GLUT_RGB; | |||
type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE; | |||
type |= GLUT_SINGLE; | |||
glutInitDisplayMode(type); | |||
if (glutCreateWindow("First Tri") == GL_FALSE) { |
@@ -1,26 +1,3 @@ | |||
/* | |||
* 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> | |||
@@ -30,11 +7,6 @@ | |||
#include "GL/gl.h" | |||
#define CI_OFFSET_1 16 | |||
#define CI_OFFSET_2 32 | |||
GLenum doubleBuffer; | |||
static void Init( void ) | |||
{ | |||
@@ -105,44 +77,22 @@ static void Draw(void) | |||
glFlush(); | |||
if (doubleBuffer) { | |||
glutSwapBuffers(); | |||
} | |||
} | |||
static GLenum Args(int argc, char **argv) | |||
{ | |||
GLint i; | |||
doubleBuffer = GL_FALSE; | |||
for (i = 1; i < argc; i++) { | |||
if (strcmp(argv[i], "-sb") == 0) { | |||
doubleBuffer = GL_FALSE; | |||
} else if (strcmp(argv[i], "-db") == 0) { | |||
doubleBuffer = GL_TRUE; | |||
} else { | |||
fprintf(stderr, "%s (Bad option).\n", argv[i]); | |||
return GL_FALSE; | |||
} | |||
} | |||
return GL_TRUE; | |||
} | |||
int main(int argc, char **argv) | |||
{ | |||
GLenum type; | |||
glutInit(&argc, argv); | |||
if (Args(argc, argv) == GL_FALSE) { | |||
exit(1); | |||
} | |||
glutInitWindowPosition(0, 0); glutInitWindowSize( 250, 250); | |||
type = GLUT_RGB; | |||
type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE; | |||
type |= GLUT_SINGLE; | |||
glutInitDisplayMode(type); | |||
if (glutCreateWindow("First Tri") == GL_FALSE) { |
@@ -1,26 +1,3 @@ | |||
/* | |||
* 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> | |||
@@ -29,13 +6,6 @@ | |||
#include <GL/glut.h> | |||
#include "GL/gl.h" | |||
#define CI_OFFSET_1 16 | |||
#define CI_OFFSET_2 32 | |||
GLenum doubleBuffer; | |||
static void Init( void ) | |||
{ | |||
static const char *modulate2D = | |||
@@ -104,30 +74,8 @@ static void Draw(void) | |||
glEnd(); | |||
glFlush(); | |||
if (doubleBuffer) { | |||
glutSwapBuffers(); | |||
} | |||
} | |||
static GLenum Args(int argc, char **argv) | |||
{ | |||
GLint i; | |||
doubleBuffer = GL_FALSE; | |||
for (i = 1; i < argc; i++) { | |||
if (strcmp(argv[i], "-sb") == 0) { | |||
doubleBuffer = GL_FALSE; | |||
} else if (strcmp(argv[i], "-db") == 0) { | |||
doubleBuffer = GL_TRUE; | |||
} else { | |||
fprintf(stderr, "%s (Bad option).\n", argv[i]); | |||
return GL_FALSE; | |||
} | |||
} | |||
return GL_TRUE; | |||
} | |||
int main(int argc, char **argv) | |||
{ | |||
@@ -135,14 +83,9 @@ int main(int argc, char **argv) | |||
glutInit(&argc, argv); | |||
if (Args(argc, argv) == GL_FALSE) { | |||
exit(1); | |||
} | |||
glutInitWindowPosition(0, 0); glutInitWindowSize( 250, 250); | |||
type = GLUT_RGB; | |||
type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE; | |||
type = GLUT_RGB | GLUT_SINGLE; | |||
glutInitDisplayMode(type); | |||
if (glutCreateWindow("First Tri") == GL_FALSE) { |
@@ -1,26 +1,3 @@ | |||
/* | |||
* 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> | |||
@@ -30,11 +7,6 @@ | |||
#include "GL/gl.h" | |||
#define CI_OFFSET_1 16 | |||
#define CI_OFFSET_2 32 | |||
GLenum doubleBuffer; | |||
static void Init( void ) | |||
{ | |||
@@ -105,44 +77,22 @@ static void Draw(void) | |||
glFlush(); | |||
if (doubleBuffer) { | |||
glutSwapBuffers(); | |||
} | |||
} | |||
static GLenum Args(int argc, char **argv) | |||
{ | |||
GLint i; | |||
doubleBuffer = GL_FALSE; | |||
for (i = 1; i < argc; i++) { | |||
if (strcmp(argv[i], "-sb") == 0) { | |||
doubleBuffer = GL_FALSE; | |||
} else if (strcmp(argv[i], "-db") == 0) { | |||
doubleBuffer = GL_TRUE; | |||
} else { | |||
fprintf(stderr, "%s (Bad option).\n", argv[i]); | |||
return GL_FALSE; | |||
} | |||
} | |||
return GL_TRUE; | |||
} | |||
int main(int argc, char **argv) | |||
{ | |||
GLenum type; | |||
glutInit(&argc, argv); | |||
if (Args(argc, argv) == GL_FALSE) { | |||
exit(1); | |||
} | |||
glutInitWindowPosition(0, 0); glutInitWindowSize( 250, 250); | |||
type = GLUT_RGB; | |||
type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE; | |||
type |= GLUT_SINGLE; | |||
glutInitDisplayMode(type); | |||
if (glutCreateWindow("First Tri") == GL_FALSE) { |
@@ -1,26 +1,3 @@ | |||
/* | |||
* 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> | |||
@@ -30,17 +7,12 @@ | |||
#include "GL/gl.h" | |||
#define CI_OFFSET_1 16 | |||
#define CI_OFFSET_2 32 | |||
GLenum doubleBuffer; | |||
static void Init( void ) | |||
{ | |||
static const char *modulate2D = | |||
"!!ARBfp1.0\n" | |||
"MOV result.color, fragment.position; \n" | |||
"MUL result.color, fragment.position, {.005}.x; \n" | |||
"END" | |||
; | |||
GLuint modulateProg; | |||
@@ -105,44 +77,22 @@ static void Draw(void) | |||
glFlush(); | |||
if (doubleBuffer) { | |||
glutSwapBuffers(); | |||
} | |||
} | |||
static GLenum Args(int argc, char **argv) | |||
{ | |||
GLint i; | |||
doubleBuffer = GL_FALSE; | |||
for (i = 1; i < argc; i++) { | |||
if (strcmp(argv[i], "-sb") == 0) { | |||
doubleBuffer = GL_FALSE; | |||
} else if (strcmp(argv[i], "-db") == 0) { | |||
doubleBuffer = GL_TRUE; | |||
} else { | |||
fprintf(stderr, "%s (Bad option).\n", argv[i]); | |||
return GL_FALSE; | |||
} | |||
} | |||
return GL_TRUE; | |||
} | |||
int main(int argc, char **argv) | |||
{ | |||
GLenum type; | |||
glutInit(&argc, argv); | |||
if (Args(argc, argv) == GL_FALSE) { | |||
exit(1); | |||
} | |||
glutInitWindowPosition(0, 0); glutInitWindowSize( 250, 250); | |||
type = GLUT_RGB; | |||
type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE; | |||
type |= GLUT_SINGLE; | |||
glutInitDisplayMode(type); | |||
if (glutCreateWindow("First Tri") == GL_FALSE) { |
@@ -1,26 +1,3 @@ | |||
/* | |||
* 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> | |||
@@ -29,11 +6,6 @@ | |||
#include <GL/glut.h> | |||
#define CI_OFFSET_1 16 | |||
#define CI_OFFSET_2 32 | |||
GLenum doubleBuffer; | |||
static void Init( void ) | |||
{ | |||
@@ -105,44 +77,22 @@ static void Draw(void) | |||
glFlush(); | |||
if (doubleBuffer) { | |||
glutSwapBuffers(); | |||
} | |||
} | |||
static GLenum Args(int argc, char **argv) | |||
{ | |||
GLint i; | |||
doubleBuffer = GL_FALSE; | |||
for (i = 1; i < argc; i++) { | |||
if (strcmp(argv[i], "-sb") == 0) { | |||
doubleBuffer = GL_FALSE; | |||
} else if (strcmp(argv[i], "-db") == 0) { | |||
doubleBuffer = GL_TRUE; | |||
} else { | |||
fprintf(stderr, "%s (Bad option).\n", argv[i]); | |||
return GL_FALSE; | |||
} | |||
} | |||
return GL_TRUE; | |||
} | |||
int main(int argc, char **argv) | |||
{ | |||
GLenum type; | |||
glutInit(&argc, argv); | |||
if (Args(argc, argv) == GL_FALSE) { | |||
exit(1); | |||
} | |||
glutInitWindowPosition(0, 0); glutInitWindowSize( 250, 250); | |||
type = GLUT_RGB; | |||
type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE; | |||
type |= GLUT_SINGLE; | |||
glutInitDisplayMode(type); | |||
if (glutCreateWindow("First Tri") == GL_FALSE) { |
@@ -1,26 +1,3 @@ | |||
/* | |||
* 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> | |||
@@ -29,11 +6,6 @@ | |||
#include <GL/glut.h> | |||
#define CI_OFFSET_1 16 | |||
#define CI_OFFSET_2 32 | |||
GLenum doubleBuffer; | |||
static void Init( void ) | |||
{ | |||
@@ -106,44 +78,22 @@ static void Draw(void) | |||
glFlush(); | |||
if (doubleBuffer) { | |||
glutSwapBuffers(); | |||
} | |||
} | |||
static GLenum Args(int argc, char **argv) | |||
{ | |||
GLint i; | |||
doubleBuffer = GL_FALSE; | |||
for (i = 1; i < argc; i++) { | |||
if (strcmp(argv[i], "-sb") == 0) { | |||
doubleBuffer = GL_FALSE; | |||
} else if (strcmp(argv[i], "-db") == 0) { | |||
doubleBuffer = GL_TRUE; | |||
} else { | |||
fprintf(stderr, "%s (Bad option).\n", argv[i]); | |||
return GL_FALSE; | |||
} | |||
} | |||
return GL_TRUE; | |||
} | |||
int main(int argc, char **argv) | |||
{ | |||
GLenum type; | |||
glutInit(&argc, argv); | |||
if (Args(argc, argv) == GL_FALSE) { | |||
exit(1); | |||
} | |||
glutInitWindowPosition(0, 0); glutInitWindowSize( 250, 250); | |||
type = GLUT_RGB; | |||
type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE; | |||
type |= GLUT_SINGLE; | |||
glutInitDisplayMode(type); | |||
if (glutCreateWindow("First Tri") == GL_FALSE) { |
@@ -1,26 +1,3 @@ | |||
/* | |||
* 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> | |||
@@ -29,11 +6,6 @@ | |||
#include <GL/glut.h> | |||
#define CI_OFFSET_1 16 | |||
#define CI_OFFSET_2 32 | |||
GLenum doubleBuffer; | |||
static void Init( void ) | |||
{ | |||
@@ -106,44 +78,22 @@ static void Draw(void) | |||
glFlush(); | |||
if (doubleBuffer) { | |||
glutSwapBuffers(); | |||
} | |||
} | |||
static GLenum Args(int argc, char **argv) | |||
{ | |||
GLint i; | |||
doubleBuffer = GL_FALSE; | |||
for (i = 1; i < argc; i++) { | |||
if (strcmp(argv[i], "-sb") == 0) { | |||
doubleBuffer = GL_FALSE; | |||
} else if (strcmp(argv[i], "-db") == 0) { | |||
doubleBuffer = GL_TRUE; | |||
} else { | |||
fprintf(stderr, "%s (Bad option).\n", argv[i]); | |||
return GL_FALSE; | |||
} | |||
} | |||
return GL_TRUE; | |||
} | |||
int main(int argc, char **argv) | |||
{ | |||
GLenum type; | |||
glutInit(&argc, argv); | |||
if (Args(argc, argv) == GL_FALSE) { | |||
exit(1); | |||
} | |||
glutInitWindowPosition(0, 0); glutInitWindowSize( 250, 250); | |||
type = GLUT_RGB; | |||
type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE; | |||
type |= GLUT_SINGLE; | |||
glutInitDisplayMode(type); | |||
if (glutCreateWindow("First Tri") == GL_FALSE) { |
@@ -1,26 +1,3 @@ | |||
/* | |||
* 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> | |||
@@ -30,11 +7,6 @@ | |||
#include "GL/gl.h" | |||
#define CI_OFFSET_1 16 | |||
#define CI_OFFSET_2 32 | |||
GLenum doubleBuffer; | |||
static void Init( void ) | |||
{ | |||
@@ -107,44 +79,22 @@ static void Draw(void) | |||
glFlush(); | |||
if (doubleBuffer) { | |||
glutSwapBuffers(); | |||
} | |||
} | |||
static GLenum Args(int argc, char **argv) | |||
{ | |||
GLint i; | |||
doubleBuffer = GL_FALSE; | |||
for (i = 1; i < argc; i++) { | |||
if (strcmp(argv[i], "-sb") == 0) { | |||
doubleBuffer = GL_FALSE; | |||
} else if (strcmp(argv[i], "-db") == 0) { | |||
doubleBuffer = GL_TRUE; | |||
} else { | |||
fprintf(stderr, "%s (Bad option).\n", argv[i]); | |||
return GL_FALSE; | |||
} | |||
} | |||
return GL_TRUE; | |||
} | |||
int main(int argc, char **argv) | |||
{ | |||
GLenum type; | |||
glutInit(&argc, argv); | |||
if (Args(argc, argv) == GL_FALSE) { | |||
exit(1); | |||
} | |||
glutInitWindowPosition(0, 0); glutInitWindowSize( 250, 250); | |||
type = GLUT_RGB; | |||
type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE; | |||
type |= GLUT_SINGLE; | |||
glutInitDisplayMode(type); | |||
if (glutCreateWindow("First Tri") == GL_FALSE) { |
@@ -1,26 +1,3 @@ | |||
/* | |||
* 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> | |||
@@ -30,11 +7,6 @@ | |||
#include "GL/gl.h" | |||
#define CI_OFFSET_1 16 | |||
#define CI_OFFSET_2 32 | |||
GLenum doubleBuffer; | |||
static void Init( void ) | |||
{ | |||
@@ -105,44 +77,22 @@ static void Draw(void) | |||
glFlush(); | |||
if (doubleBuffer) { | |||
glutSwapBuffers(); | |||
} | |||
} | |||
static GLenum Args(int argc, char **argv) | |||
{ | |||
GLint i; | |||
doubleBuffer = GL_FALSE; | |||
for (i = 1; i < argc; i++) { | |||
if (strcmp(argv[i], "-sb") == 0) { | |||
doubleBuffer = GL_FALSE; | |||
} else if (strcmp(argv[i], "-db") == 0) { | |||
doubleBuffer = GL_TRUE; | |||
} else { | |||
fprintf(stderr, "%s (Bad option).\n", argv[i]); | |||
return GL_FALSE; | |||
} | |||
} | |||
return GL_TRUE; | |||
} | |||
int main(int argc, char **argv) | |||
{ | |||
GLenum type; | |||
glutInit(&argc, argv); | |||
if (Args(argc, argv) == GL_FALSE) { | |||
exit(1); | |||
} | |||
glutInitWindowPosition(0, 0); glutInitWindowSize( 250, 250); | |||
type = GLUT_RGB; | |||
type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE; | |||
type |= GLUT_SINGLE; | |||
glutInitDisplayMode(type); | |||
if (glutCreateWindow("First Tri") == GL_FALSE) { |
@@ -1,26 +1,3 @@ | |||
/* | |||
* 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> | |||
@@ -30,11 +7,6 @@ | |||
#include "GL/gl.h" | |||
#define CI_OFFSET_1 16 | |||
#define CI_OFFSET_2 32 | |||
GLenum doubleBuffer; | |||
static void Init( void ) | |||
{ | |||
@@ -110,44 +82,22 @@ static void Draw(void) | |||
glFlush(); | |||
if (doubleBuffer) { | |||
glutSwapBuffers(); | |||
} | |||
} | |||
static GLenum Args(int argc, char **argv) | |||
{ | |||
GLint i; | |||
doubleBuffer = GL_FALSE; | |||
for (i = 1; i < argc; i++) { | |||
if (strcmp(argv[i], "-sb") == 0) { | |||
doubleBuffer = GL_FALSE; | |||
} else if (strcmp(argv[i], "-db") == 0) { | |||
doubleBuffer = GL_TRUE; | |||
} else { | |||
fprintf(stderr, "%s (Bad option).\n", argv[i]); | |||
return GL_FALSE; | |||
} | |||
} | |||
return GL_TRUE; | |||
} | |||
int main(int argc, char **argv) | |||
{ | |||
GLenum type; | |||
glutInit(&argc, argv); | |||
if (Args(argc, argv) == GL_FALSE) { | |||
exit(1); | |||
} | |||
glutInitWindowPosition(0, 0); glutInitWindowSize( 250, 250); | |||
type = GLUT_RGB; | |||
type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE; | |||
type |= GLUT_SINGLE; | |||
glutInitDisplayMode(type); | |||
if (glutCreateWindow("First Tri") == GL_FALSE) { |
@@ -1,26 +1,3 @@ | |||
/* | |||
* 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> | |||
@@ -30,11 +7,6 @@ | |||
#include "GL/gl.h" | |||
#define CI_OFFSET_1 16 | |||
#define CI_OFFSET_2 32 | |||
GLenum doubleBuffer; | |||
static void Init( void ) | |||
{ | |||
@@ -110,44 +82,22 @@ static void Draw(void) | |||
glFlush(); | |||
if (doubleBuffer) { | |||
glutSwapBuffers(); | |||
} | |||
} | |||
static GLenum Args(int argc, char **argv) | |||
{ | |||
GLint i; | |||
doubleBuffer = GL_FALSE; | |||
for (i = 1; i < argc; i++) { | |||
if (strcmp(argv[i], "-sb") == 0) { | |||
doubleBuffer = GL_FALSE; | |||
} else if (strcmp(argv[i], "-db") == 0) { | |||
doubleBuffer = GL_TRUE; | |||
} else { | |||
fprintf(stderr, "%s (Bad option).\n", argv[i]); | |||
return GL_FALSE; | |||
} | |||
} | |||
return GL_TRUE; | |||
} | |||
int main(int argc, char **argv) | |||
{ | |||
GLenum type; | |||
glutInit(&argc, argv); | |||
if (Args(argc, argv) == GL_FALSE) { | |||
exit(1); | |||
} | |||
glutInitWindowPosition(0, 0); glutInitWindowSize( 250, 250); | |||
type = GLUT_RGB; | |||
type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE; | |||
type |= GLUT_SINGLE; | |||
glutInitDisplayMode(type); | |||
if (glutCreateWindow("First Tri") == GL_FALSE) { |
@@ -1,26 +1,3 @@ | |||
/* | |||
* 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> | |||
@@ -30,11 +7,6 @@ | |||
#include "GL/gl.h" | |||
#define CI_OFFSET_1 16 | |||
#define CI_OFFSET_2 32 | |||
GLenum doubleBuffer; | |||
static void Init( void ) | |||
{ | |||
@@ -105,44 +77,22 @@ static void Draw(void) | |||
glFlush(); | |||
if (doubleBuffer) { | |||
glutSwapBuffers(); | |||
} | |||
} | |||
static GLenum Args(int argc, char **argv) | |||
{ | |||
GLint i; | |||
doubleBuffer = GL_FALSE; | |||
for (i = 1; i < argc; i++) { | |||
if (strcmp(argv[i], "-sb") == 0) { | |||
doubleBuffer = GL_FALSE; | |||
} else if (strcmp(argv[i], "-db") == 0) { | |||
doubleBuffer = GL_TRUE; | |||
} else { | |||
fprintf(stderr, "%s (Bad option).\n", argv[i]); | |||
return GL_FALSE; | |||
} | |||
} | |||
return GL_TRUE; | |||
} | |||
int main(int argc, char **argv) | |||
{ | |||
GLenum type; | |||
glutInit(&argc, argv); | |||
if (Args(argc, argv) == GL_FALSE) { | |||
exit(1); | |||
} | |||
glutInitWindowPosition(0, 0); glutInitWindowSize( 250, 250); | |||
type = GLUT_RGB; | |||
type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE; | |||
type |= GLUT_SINGLE; | |||
glutInitDisplayMode(type); | |||
if (glutCreateWindow("First Tri") == GL_FALSE) { |
@@ -1,26 +1,3 @@ | |||
/* | |||
* 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> | |||
@@ -30,11 +7,6 @@ | |||
#include "GL/gl.h" | |||
#define CI_OFFSET_1 16 | |||
#define CI_OFFSET_2 32 | |||
GLenum doubleBuffer; | |||
static void Init( void ) | |||
{ | |||
@@ -105,44 +77,22 @@ static void Draw(void) | |||
glFlush(); | |||
if (doubleBuffer) { | |||
glutSwapBuffers(); | |||
} | |||
} | |||
static GLenum Args(int argc, char **argv) | |||
{ | |||
GLint i; | |||
doubleBuffer = GL_FALSE; | |||
for (i = 1; i < argc; i++) { | |||
if (strcmp(argv[i], "-sb") == 0) { | |||
doubleBuffer = GL_FALSE; | |||
} else if (strcmp(argv[i], "-db") == 0) { | |||
doubleBuffer = GL_TRUE; | |||
} else { | |||
fprintf(stderr, "%s (Bad option).\n", argv[i]); | |||
return GL_FALSE; | |||
} | |||
} | |||
return GL_TRUE; | |||
} | |||
int main(int argc, char **argv) | |||
{ | |||
GLenum type; | |||
glutInit(&argc, argv); | |||
if (Args(argc, argv) == GL_FALSE) { | |||
exit(1); | |||
} | |||
glutInitWindowPosition(0, 0); glutInitWindowSize( 250, 250); | |||
type = GLUT_RGB; | |||
type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE; | |||
type |= GLUT_SINGLE; | |||
glutInitDisplayMode(type); | |||
if (glutCreateWindow("First Tri") == GL_FALSE) { |
@@ -1,26 +1,3 @@ | |||
/* | |||
* 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> | |||
@@ -30,11 +7,6 @@ | |||
#include "GL/gl.h" | |||
#define CI_OFFSET_1 16 | |||
#define CI_OFFSET_2 32 | |||
GLenum doubleBuffer; | |||
static void Init( void ) | |||
{ | |||
@@ -105,44 +77,22 @@ static void Draw(void) | |||
glFlush(); | |||
if (doubleBuffer) { | |||
glutSwapBuffers(); | |||
} | |||
} | |||
static GLenum Args(int argc, char **argv) | |||
{ | |||
GLint i; | |||
doubleBuffer = GL_FALSE; | |||
for (i = 1; i < argc; i++) { | |||
if (strcmp(argv[i], "-sb") == 0) { | |||
doubleBuffer = GL_FALSE; | |||
} else if (strcmp(argv[i], "-db") == 0) { | |||
doubleBuffer = GL_TRUE; | |||
} else { | |||
fprintf(stderr, "%s (Bad option).\n", argv[i]); | |||
return GL_FALSE; | |||
} | |||
} | |||
return GL_TRUE; | |||
} | |||
int main(int argc, char **argv) | |||
{ | |||
GLenum type; | |||
glutInit(&argc, argv); | |||
if (Args(argc, argv) == GL_FALSE) { | |||
exit(1); | |||
} | |||
glutInitWindowPosition(0, 0); glutInitWindowSize( 250, 250); | |||
type = GLUT_RGB; | |||
type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE; | |||
type |= GLUT_SINGLE; | |||
glutInitDisplayMode(type); | |||
if (glutCreateWindow("First Tri") == GL_FALSE) { |
@@ -1,26 +1,3 @@ | |||
/* | |||
* 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> | |||
@@ -29,11 +6,6 @@ | |||
#include <GL/glut.h> | |||
#define CI_OFFSET_1 16 | |||
#define CI_OFFSET_2 32 | |||
GLenum doubleBuffer; | |||
static void Init( void ) | |||
{ | |||
@@ -105,44 +77,22 @@ static void Draw(void) | |||
glFlush(); | |||
if (doubleBuffer) { | |||
glutSwapBuffers(); | |||
} | |||
} | |||
static GLenum Args(int argc, char **argv) | |||
{ | |||
GLint i; | |||
doubleBuffer = GL_FALSE; | |||
for (i = 1; i < argc; i++) { | |||
if (strcmp(argv[i], "-sb") == 0) { | |||
doubleBuffer = GL_FALSE; | |||
} else if (strcmp(argv[i], "-db") == 0) { | |||
doubleBuffer = GL_TRUE; | |||
} else { | |||
fprintf(stderr, "%s (Bad option).\n", argv[i]); | |||
return GL_FALSE; | |||
} | |||
} | |||
return GL_TRUE; | |||
} | |||
int main(int argc, char **argv) | |||
{ | |||
GLenum type; | |||
glutInit(&argc, argv); | |||
if (Args(argc, argv) == GL_FALSE) { | |||
exit(1); | |||
} | |||
glutInitWindowPosition(0, 0); glutInitWindowSize( 250, 250); | |||
type = GLUT_RGB; | |||
type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE; | |||
type |= GLUT_SINGLE; | |||
glutInitDisplayMode(type); | |||
if (glutCreateWindow("First Tri") == GL_FALSE) { |
@@ -1,26 +1,3 @@ | |||
/* | |||
* 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 <assert.h> | |||
#include <stdio.h> | |||
@@ -35,7 +12,6 @@ | |||
#define TEXTURE_FILE "../images/girl.rgb" | |||
GLenum doubleBuffer; | |||
static void Init( void ) | |||
{ | |||
@@ -123,30 +99,8 @@ static void Draw(void) | |||
glEnd(); | |||
glFlush(); | |||
if (doubleBuffer) { | |||
glutSwapBuffers(); | |||
} | |||
} | |||
static GLenum Args(int argc, char **argv) | |||
{ | |||
GLint i; | |||
doubleBuffer = GL_FALSE; | |||
for (i = 1; i < argc; i++) { | |||
if (strcmp(argv[i], "-sb") == 0) { | |||
doubleBuffer = GL_FALSE; | |||
} else if (strcmp(argv[i], "-db") == 0) { | |||
doubleBuffer = GL_TRUE; | |||
} else { | |||
fprintf(stderr, "%s (Bad option).\n", argv[i]); | |||
return GL_FALSE; | |||
} | |||
} | |||
return GL_TRUE; | |||
} | |||
int main(int argc, char **argv) | |||
{ | |||
@@ -154,14 +108,12 @@ int main(int argc, char **argv) | |||
glutInit(&argc, argv); | |||
if (Args(argc, argv) == GL_FALSE) { | |||
exit(1); | |||
} | |||
glutInitWindowPosition(0, 0); glutInitWindowSize( 250, 250); | |||
type = GLUT_RGB; | |||
type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE; | |||
type |= GLUT_SINGLE; | |||
glutInitDisplayMode(type); | |||
if (glutCreateWindow("First Tri") == GL_FALSE) { |
@@ -1,26 +1,3 @@ | |||
/* | |||
* 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> | |||
@@ -30,11 +7,6 @@ | |||
#include "GL/gl.h" | |||
#define CI_OFFSET_1 16 | |||
#define CI_OFFSET_2 32 | |||
GLenum doubleBuffer; | |||
static void Init( void ) | |||
{ | |||
@@ -105,44 +77,21 @@ static void Draw(void) | |||
glFlush(); | |||
if (doubleBuffer) { | |||
glutSwapBuffers(); | |||
} | |||
} | |||
static GLenum Args(int argc, char **argv) | |||
{ | |||
GLint i; | |||
doubleBuffer = GL_FALSE; | |||
for (i = 1; i < argc; i++) { | |||
if (strcmp(argv[i], "-sb") == 0) { | |||
doubleBuffer = GL_FALSE; | |||
} else if (strcmp(argv[i], "-db") == 0) { | |||
doubleBuffer = GL_TRUE; | |||
} else { | |||
fprintf(stderr, "%s (Bad option).\n", argv[i]); | |||
return GL_FALSE; | |||
} | |||
} | |||
return GL_TRUE; | |||
} | |||
int main(int argc, char **argv) | |||
{ | |||
GLenum type; | |||
glutInit(&argc, argv); | |||
if (Args(argc, argv) == GL_FALSE) { | |||
exit(1); | |||
} | |||
glutInitWindowPosition(0, 0); glutInitWindowSize( 250, 250); | |||
type = GLUT_RGB; | |||
type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE; | |||
type |= GLUT_SINGLE; | |||
glutInitDisplayMode(type); | |||
if (glutCreateWindow("First Tri") == GL_FALSE) { |