diff options
Diffstat (limited to 'nx-X11/extras/Mesa_6.4.1/progs/tests')
66 files changed, 16628 insertions, 0 deletions
diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/.cvsignore b/nx-X11/extras/Mesa_6.4.1/progs/tests/.cvsignore new file mode 100644 index 000000000..d0f2a87a8 --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/.cvsignore @@ -0,0 +1,2 @@ +.cvsignore +getproclist.h diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/Makefile b/nx-X11/extras/Mesa_6.4.1/progs/tests/Makefile new file mode 100644 index 000000000..768820cf3 --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/Makefile @@ -0,0 +1,135 @@ +# progs/tests/Makefile + + +# These programs aren't intended to be included with the normal distro. +# They're not too interesting but they're good for testing. + +TOP = ../.. +include $(TOP)/configs/current + + +LIBS = $(APP_LIB_DEPS) + +SOURCES = antialias.c \ + arbfpspec.c \ + arbfptest1.c \ + arbfptexture.c \ + arbfptrig.c \ + arbvptest1.c \ + arbvptest3.c \ + arbvptorus.c \ + arbvpwarpmesh.c \ + blendminmax.c \ + blendsquare.c \ + bufferobj.c \ + bug_3101.c \ + bug_3195.c \ + crossbar.c \ + cva.c \ + dinoshade.c \ + floattex.c \ + fbotest1.c \ + fbotexture.c \ + fogcoord.c \ + fptest1.c \ + fptexture.c \ + getprocaddress.c \ + invert.c \ + manytex.c \ + multipal.c \ + no_s3tc.c \ + packedpixels.c \ + pbo.c \ + projtex.c \ + seccolor.c \ + sharedtex.c \ + stencilwrap.c \ + stencil_wrap.c \ + tex1d.c \ + texline.c \ + texobjshare.c \ + texrect.c \ + texwrap.c \ + vparray.c \ + vptest1.c \ + vptest2.c \ + vptest3.c \ + vptorus.c \ + vpwarpmesh.c \ + yuvrect.c \ + yuvsquare.c \ + zreaddraw.c + +PROGS = $(SOURCES:%.c=%) + +INCLUDES = -I. -I$(TOP)/include + +UTIL_FILES = readtex.h readtex.c + + +##### RULES ##### + +.SUFFIXES: +.SUFFIXES: .c + +.c: + $(CC) $(INCLUDES) $(CFLAGS) $< $(LIBS) -o $@ + +.c.o: + $(CC) -c $(INCLUDES) $(CFLAGS) $(DEFINES) $< -o $@ + +.S.o: + $(CC) -c $(INCLUDES) $(CFLAGS) $(DEFINES) $< -o $@ + + +##### TARGETS ##### + +default: $(UTIL_FILES) $(PROGS) + +clean: + rm -f $(PROGS) + rm -f *.o + rm -f getproclist.h + + +# auto code generation +getprocaddress: getprocaddress.c getproclist.h + +getproclist.h: $(TOP)/src/mesa/glapi/gl_API.xml getprocaddress.c getprocaddress.py + python getprocaddress.py > getproclist.h + + +texrect: texrect.o readtex.o + $(CC) texrect.o readtex.o $(LIBS) -o $@ + +texrect.o: texrect.c readtex.h + $(CC) -c $(INCLUDES) $(CFLAGS) $(DEFINES) $< -o $@ + +bug_3195: bug_3195.o readtex.o + $(CC) $(CFLAGS) bug_3195.o readtex.o $(LIBS) -o $@ + +bug_3195.o: bug_3195.c readtex.h + $(CC) -c $(INCLUDES) $(CFLAGS) $(DEFINES) $< -o $@ + +invert: invert.o readtex.o + $(CC) invert.o readtex.o $(LIBS) -o $@ + +invert.o: invert.c readtex.h + $(CC) -c $(INCLUDES) $(CFLAGS) $(DEFINES) $< -o $@ + +readtex.o: readtex.c + $(CC) -c $(INCLUDES) $(CFLAGS) $(DEFINES) $< -o $@ + + +readtex.h: $(TOP)/progs/util/readtex.h + ln -s $(TOP)/progs/util/readtex.h . + +readtex.c: $(TOP)/progs/util/readtex.c + ln -s $(TOP)/progs/util/readtex.c . + + + + +# Emacs tags +tags: + etags `find . -name \*.[ch]` `find ../include` diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/Makefile.win b/nx-X11/extras/Mesa_6.4.1/progs/tests/Makefile.win new file mode 100644 index 000000000..0de6c42e3 --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/Makefile.win @@ -0,0 +1,44 @@ +# $Id: Makefile.win,v 1.1 2002/01/16 01:03:25 kschultz Exp $ + +# Mesa 3-D graphics library +# Version: 3.5 +# Copyright (C) 1995-2001 Brian Paul + +# Makefile for GLUT-based demo programs for Windows + +!include <win32.mak> + +##### MACROS ##### + +TOP = .. +INCDIR = ..\include +LIBDIR = ..\lib + +SRCS = cva.c \ + dinoshade.c \ + fogcoord.c \ + manytex.c \ + multipal.c \ + projtex.c \ + seccolor.c \ +# sharedtex.c \ + texline.c \ + texwrap.c \ + vptest1.c \ + vptest2.c \ + vptest3.c \ + vptorus.c \ + vpwarpmesh.c + +!include "../mesawin32.mak" + +##### TARGETS ##### + +clean:: + +clobber:: + @del readtex.c readtex.h + +$(EXES) :$*.obj + @echo $@ + $(link) -out:$@ $* /LIBPATH:$(LIBDIR) $(LIBS) diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/antialias.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/antialias.c new file mode 100644 index 000000000..79b5ab75c --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/antialias.c @@ -0,0 +1,229 @@ +/* $Id: antialias.c,v 1.2 2003/03/29 16:42:57 brianp Exp $ */ + +/* + * Test multisampling and polygon smoothing. + * + * Brian Paul + * 4 November 2002 + */ + +#include <stdio.h> +#include <stdlib.h> +#include <math.h> +#include <GL/glut.h> + + +static GLfloat Zrot = 0; +static GLboolean Anim = GL_TRUE; +static GLboolean HaveMultisample = GL_TRUE; + + +static void +PrintString(const char *s) +{ + while (*s) { + glutBitmapCharacter(GLUT_BITMAP_8_BY_13, (int) *s); + s++; + } +} + + +static void +Polygon( GLint verts, GLfloat radius, GLfloat z ) +{ + int i; + for (i = 0; i < verts; i++) { + float a = (i * 2.0 * 3.14159) / verts; + float x = radius * cos(a); + float y = radius * sin(a); + glVertex3f(x, y, z); + } +} + + +static void +DrawObject( void ) +{ + glLineWidth(3.0); + glColor3f(1, 1, 1); + glBegin(GL_LINE_LOOP); + Polygon(12, 1.2, 0); + glEnd(); + + glLineWidth(1.0); + glColor3f(1, 1, 1); + glBegin(GL_LINE_LOOP); + Polygon(12, 1.1, 0); + glEnd(); + + glColor3f(1, 0, 0); + glBegin(GL_POLYGON); + Polygon(12, 0.4, 0.3); + glEnd(); + + glColor3f(0, 1, 0); + glBegin(GL_POLYGON); + Polygon(12, 0.6, 0.2); + glEnd(); + + glColor3f(0, 0, 1); + glBegin(GL_POLYGON); + Polygon(12, 0.8, 0.1); + glEnd(); + + glColor3f(1, 1, 1); + glBegin(GL_POLYGON); + Polygon(12, 1.0, 0); + glEnd(); +} + + +static void +Display( void ) +{ + glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); + + glColor3f(1, 1, 1); + if (HaveMultisample) { + glRasterPos2f(-3.1, -1.6); + PrintString("MULTISAMPLE"); + } + glRasterPos2f(-0.8, -1.6); + PrintString("No antialiasing"); + glRasterPos2f(1.6, -1.6); + PrintString("GL_POLYGON_SMOOTH"); + + /* multisample */ + if (HaveMultisample) { + glEnable(GL_DEPTH_TEST); + glEnable(GL_MULTISAMPLE_ARB); + glPushMatrix(); + glTranslatef(-2.5, 0, 0); + glPushMatrix(); + glRotatef(Zrot, 0, 0, 1); + DrawObject(); + glPopMatrix(); + glPopMatrix(); + glDisable(GL_MULTISAMPLE_ARB); + glDisable(GL_DEPTH_TEST); + } + + /* non-aa */ + glEnable(GL_DEPTH_TEST); + glPushMatrix(); + glTranslatef(0, 0, 0); + glPushMatrix(); + glRotatef(Zrot, 0, 0, 1); + DrawObject(); + glPopMatrix(); + glPopMatrix(); + glDisable(GL_DEPTH_TEST); + + /* polygon smooth */ + glEnable(GL_POLYGON_SMOOTH); + glEnable(GL_LINE_SMOOTH); + glEnable(GL_BLEND); + glPushMatrix(); + glTranslatef(2.5, 0, 0); + glPushMatrix(); + glRotatef(Zrot, 0, 0, 1); + DrawObject(); + glPopMatrix(); + glPopMatrix(); + glDisable(GL_LINE_SMOOTH); + glDisable(GL_POLYGON_SMOOTH); + glDisable(GL_BLEND); + + glutSwapBuffers(); +} + + +static void +Reshape( int width, int height ) +{ + GLfloat ar = (float) width / (float) height; + glViewport( 0, 0, width, height ); + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glOrtho(-2.0*ar, 2.0*ar, -2.0, 2.0, -1.0, 1.0); + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); +} + + +static void +Idle( void ) +{ + Zrot = 0.01 * glutGet(GLUT_ELAPSED_TIME); + glutPostRedisplay(); +} + + +static void +Key( unsigned char key, int x, int y ) +{ + const GLfloat step = 1.0; + (void) x; + (void) y; + switch (key) { + case 'a': + Anim = !Anim; + if (Anim) + glutIdleFunc(Idle); + else + glutIdleFunc(NULL); + break; + case 'z': + Zrot = (int) (Zrot - step); + break; + case 'Z': + Zrot = (int) (Zrot + step); + break; + case 27: + exit(0); + break; + } + glutPostRedisplay(); +} + + +static void +Init( void ) +{ + /* GLUT imposes the four samples/pixel requirement */ + int s; + glGetIntegerv(GL_SAMPLES_ARB, &s); + if (!glutExtensionSupported("GL_ARB_multisample") || s < 1) { + printf("Warning: multisample antialiasing not supported.\n"); + HaveMultisample = GL_FALSE; + } + printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER)); + printf("GL_SAMPLES_ARB = %d\n", s); + + glBlendFunc(GL_SRC_ALPHA, GL_ONE); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + glBlendFunc(GL_SRC_ALPHA_SATURATE, GL_ONE); + + glGetIntegerv(GL_MULTISAMPLE_ARB, &s); + printf("GL_MULTISAMPLE_ARB = %d\n", s); +} + + +int +main( int argc, char *argv[] ) +{ + glutInit( &argc, argv ); + glutInitWindowPosition( 0, 0 ); + glutInitWindowSize( 600, 300 ); + glutInitDisplayMode( GLUT_RGB | GLUT_ALPHA | GLUT_DOUBLE | + GLUT_DEPTH | GLUT_MULTISAMPLE ); + glutCreateWindow(argv[0]); + glutReshapeFunc( Reshape ); + glutKeyboardFunc( Key ); + glutDisplayFunc( Display ); + if (Anim) + glutIdleFunc( Idle ); + Init(); + glutMainLoop(); + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/api_speed.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/api_speed.c new file mode 100644 index 000000000..aed65b35f --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/api_speed.c @@ -0,0 +1,146 @@ +/* + * (C) Copyright IBM Corporation 2002 + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * on the rights to use, copy, modify, merge, publish, distribute, sub + * license, and/or sell copies of the Software, and to permit persons to whom + * the Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL + * VA LINUX SYSTEM, IBM AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE + * USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +/** + * \file api_speed.c + * Simple test to measure the overhead of making GL calls. + * + * The main purpose of this test is to measure the difference in calling + * overhead of different dispatch methods. Since it uses asm/timex.h to + * access the Pentium's cycle counters, it will probably only compile on + * Linux (though most architectures have a get_cycles function in timex.h). + * That is why it isn't in the default Makefile. + * + * \author Ian Romanick <idr@us.ibm.com> + */ + +#include <stdio.h> +#include <stdlib.h> +#define GL_GLEXT_PROTOTYPES +#include <GL/gl.h> +#include <GL/glext.h> +#include <GL/glut.h> + +#define inline __inline__ +#include <asm/timex.h> + +static float Width = 400; +static float Height = 400; +static unsigned count = 1000000; + + +static void Idle( void ) +{ + glutPostRedisplay(); +} + +#define DO_FUNC(f,p) \ + do { \ + t0 = get_cycles(); \ + for ( i = 0 ; i < count ; i++ ) { \ + f p ; \ + } \ + t1 = get_cycles(); \ + printf("%u calls to % 20s required %llu cycles.\n", count, # f, t1 - t0); \ + } while( 0 ) + +/** + * Main display function. This is the place to add more API calls. + */ +static void Display( void ) +{ + int i; + const float v[3] = { 1.0, 0.0, 0.0 }; + cycles_t t0; + cycles_t t1; + + glBegin(GL_TRIANGLE_STRIP); + + DO_FUNC( glColor3fv, (v) ); + DO_FUNC( glNormal3fv, (v) ); + DO_FUNC( glTexCoord2fv, (v) ); + DO_FUNC( glTexCoord3fv, (v) ); + DO_FUNC( glMultiTexCoord2fv, (GL_TEXTURE0, v) ); + DO_FUNC( glMultiTexCoord2f, (GL_TEXTURE0, 0.0, 0.0) ); + DO_FUNC( glFogCoordfvEXT, (v) ); + DO_FUNC( glFogCoordfEXT, (0.5) ); + + glEnd(); + + exit(0); +} + + +static void Reshape( int width, int height ) +{ + Width = width; + Height = height; + glViewport( 0, 0, width, height ); + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glOrtho(0.0, width, 0.0, height, -1.0, 1.0); + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); +} + + +static void Key( unsigned char key, int x, int y ) +{ + (void) x; + (void) y; + switch (key) { + case 27: + exit(0); + break; + } + glutPostRedisplay(); +} + + +int main( int argc, char *argv[] ) +{ + glutInit( &argc, argv ); + glutInitWindowSize( (int) Width, (int) Height ); + glutInitWindowPosition( 0, 0 ); + + glutInitDisplayMode( GLUT_RGB ); + + glutCreateWindow( argv[0] ); + + if ( argc > 1 ) { + count = strtoul( argv[1], NULL, 0 ); + if ( count == 0 ) { + fprintf( stderr, "Usage: %s [iterations]\n", argv[0] ); + exit(1); + } + } + + glutReshapeFunc( Reshape ); + glutKeyboardFunc( Key ); + glutDisplayFunc( Display ); + glutIdleFunc( Idle ); + + glutMainLoop(); + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/api_speed.py b/nx-X11/extras/Mesa_6.4.1/progs/tests/api_speed.py new file mode 100755 index 000000000..0ddaf5836 --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/api_speed.py @@ -0,0 +1,143 @@ +#!/usr/bin/env python2 + +# (C) Copyright IBM Corporation 2004 +# All Rights Reserved. +# +# Permission is hereby granted, free of charge, to any person obtaining a +# copy of this software and associated documentation files (the "Software"), +# to deal in the Software without restriction, including without limitation +# on the rights to use, copy, modify, merge, publish, distribute, sub +# license, and/or sell copies of the Software, and to permit persons to whom +# the Software is furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice (including the next +# paragraph) shall be included in all copies or substantial portions of the +# Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL +# IBM AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +# IN THE SOFTWARE. +# +# Authors: +# Ian Romanick <idr@us.ibm.com> + + +# This script is used to run api_speed against several different libGL +# libraries and compare the results. See the show_usage function for more +# details on how to use it. + + +import re, os, sys, getopt + +class results: + def process_file(self, f): + self.cycles = {} + self.iterations = -1 + + for line in f.readlines(): + m = re.match("(\d+) calls to (.{20}) required (\d+) cycles.", line) + + if self.iterations != -1 and int(m.group(1)) != self.iterations: + raise + + # This could be done with lstrip, but the version of + # the Python library on my system doesn't have it. + # The installed version of Python is quite old. :( + + temp = m.group(2) + function_name = None + for i in range(len(temp)): + if temp[i] != ' ': + function_name = temp[i:] + break + + if function_name == None: + raise + + self.cycles[ function_name ] = int(m.group(3)) + self.iterations = int(m.group(1)) + + + def show_results(self): + for name in self.cycles: + print "%s -> %f" % (name, float(self.cycles[name]) / self.iterations) + + + def compare_results(self, other): + for name in self.cycles: + if other.cycles.has_key(name): + a = float(self.cycles[name]) / float(self.iterations) + b = float(other.cycles[name]) / float(other.iterations) + if abs( a ) < 0.000001: + print "a = %f, b = %f" % (a, b) + else: + p = (100.0 * b / a) - 100.0 + print "%- 20s %7.2f - %7.2f = % -6.2f (%+.1f%%)" % (name, a, b, a - b, p) + return + + +def make_execution_string(lib, iterations): + if lib == None: + return "./api_speed %u" % (iterations) + else: + return "LD_PRELOAD=%s ./api_speed %u" % (lib, iterations) + + +def show_usage(): + print """Usage: %s [-i iterations] {library ...} + +The full path to one or more libGL libraries (including the full name of the +library) can be included on the command-line. Each library will be tested, +and the results compared. The first library listed will be used as the +"base line" for all comparisons.""" % (sys.argv[0]) + sys.exit(1) + + +if __name__ == '__main__': + try: + (args, trail) = getopt.getopt(sys.argv[1:], "i:") + except Exception,e: + show_usage() + + iterations = 1000000 + try: + for (arg,val) in args: + if arg == "-i": + iterations = int(val) + except Exception,e: + show_usage() + + + # If no libraries were specifically named, just run the test against + # the default system libGL. + + if len(trail) == 0: + trail.append(None) + + + result_array = [] + names = [] + + for lib in trail: + s = make_execution_string( lib, iterations ) + r = results() + r.process_file( os.popen(s) ) + names.append(lib) + result_array.append(r) + + + # If the test was only run against one library, just show the results + # of the test run. Otherwise, compare each successive run against + # the first run. + + if len( result_array ) == 1: + result_array[0].show_results() + else: + for i in range(1, len( result_array )): + print "%s vs. %s" % (names[0], names[i]) + result_array[0].compare_results( result_array[i] ) + print "" diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/arbfpspec.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/arbfpspec.c new file mode 100644 index 000000000..73c55369e --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/arbfpspec.c @@ -0,0 +1,194 @@ +/* + * To demo that specular color gets lost someplace after vertex + * program completion and fragment program startup + */ + +#include <assert.h> +#include <string.h> +#include <stdio.h> +#include <stdlib.h> +#include <math.h> +#define GL_GLEXT_PROTOTYPES +#include <GL/glut.h> + +static float Xrot = 0.0, Yrot = 0.0, Zrot = 0.0; +static GLboolean Anim = GL_TRUE; + + +static void Idle( void ) +{ + Xrot += .3; + Yrot += .4; + Zrot += .2; + glutPostRedisplay(); +} + + +static void Display( void ) +{ + glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); + + glPushMatrix(); + glRotatef(Xrot, 1, 0, 0); + glRotatef(Yrot, 0, 1, 0); + glRotatef(Zrot, 0, 0, 1); + glutSolidTorus(0.75, 2.0, 10, 20); + glPopMatrix(); + + glutSwapBuffers(); +} + + +static void Reshape( int width, int height ) +{ + glViewport( 0, 0, width, height ); + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glFrustum( -2.0, 2.0, -2.0, 2.0, 5.0, 25.0 ); + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); + glTranslatef( 0.0, 0.0, -12.0 ); +} + + +static void Key( unsigned char key, int x, int y ) +{ + (void) x; + (void) y; + switch (key) { + case ' ': + Xrot = Yrot = Zrot = 0; + break; + case 'a': + Anim = !Anim; + if (Anim) + glutIdleFunc(Idle); + else + glutIdleFunc(NULL); + break; + case 'z': + Zrot -= 5.0; + break; + case 'Z': + Zrot += 5.0; + break; + case 27: + exit(0); + break; + } + glutPostRedisplay(); +} + + +static void SpecialKey( int key, int x, int y ) +{ + const GLfloat step = 3.0; + (void) x; + (void) y; + switch (key) { + case GLUT_KEY_UP: + Xrot -= step; + break; + case GLUT_KEY_DOWN: + Xrot += step; + break; + case GLUT_KEY_LEFT: + Yrot -= step; + break; + case GLUT_KEY_RIGHT: + Yrot += step; + break; + } + glutPostRedisplay(); +} + + +static void Init( void ) +{ + GLint errno; + GLuint prognum, fprognum; + + static const char prog[] = + "!!ARBvp1.0\n" + "DP4 result.position.x, state.matrix.mvp.row[0], vertex.position ;\n" + "DP4 result.position.y, state.matrix.mvp.row[1], vertex.position ;\n" + "DP4 result.position.z, state.matrix.mvp.row[2], vertex.position ;\n" + "DP4 result.position.w, state.matrix.mvp.row[3], vertex.position ;\n" + "MOV result.color.front.primary, {.5, .5, .5, 1};\n" + "MOV result.color.front.secondary, {1, 1, 1, 1};\n" + "END"; + + static const char fprog[] = + "!!ARBfp1.0\n" + "MOV result.color, fragment.color.secondary;\n" + "END"; + + if (!glutExtensionSupported("GL_ARB_vertex_program")) { + printf("Sorry, this program requires GL_ARB_vertex_program"); + exit(1); + } + + if (!glutExtensionSupported("GL_ARB_fragment_program")) { + printf("Sorry, this program requires GL_ARB_fragment_program"); + exit(1); + } + + + + glGenProgramsARB(1, &prognum); + glGenProgramsARB(1, &fprognum); + + glBindProgramARB(GL_VERTEX_PROGRAM_ARB, prognum); + glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, + strlen(prog), (const GLubyte *) prog); + + assert(glIsProgramARB(prognum)); + errno = glGetError(); + printf("glGetError = %d\n", errno); + if (errno != GL_NO_ERROR) + { + GLint errorpos; + + glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &errorpos); + printf("errorpos: %d\n", errorpos); + printf("%s\n", (char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB)); + } + + glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, fprognum); + glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, + strlen(fprog), (const GLubyte *) fprog); + errno = glGetError(); + printf("glGetError = %d\n", errno); + if (errno != GL_NO_ERROR) + { + GLint errorpos; + + glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &errorpos); + printf("errorpos: %d\n", errorpos); + printf("%s\n", (char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB)); + } + + glEnable(GL_VERTEX_PROGRAM_ARB); + glEnable(GL_FRAGMENT_PROGRAM_ARB); + glEnable(GL_DEPTH_TEST); + glClearColor(0.3, 0.3, 0.3, 1); +} + + +int main( int argc, char *argv[] ) +{ + glutInit( &argc, argv ); + glutInitWindowPosition( 0, 0 ); + glutInitWindowSize( 250, 250 ); + glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH ); + glutCreateWindow(argv[0]); + glutReshapeFunc( Reshape ); + glutKeyboardFunc( Key ); + glutSpecialFunc( SpecialKey ); + glutDisplayFunc( Display ); + if (Anim) + glutIdleFunc(Idle); + Init(); + glutMainLoop(); + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/arbfptest1.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/arbfptest1.c new file mode 100644 index 000000000..45d05125b --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/arbfptest1.c @@ -0,0 +1,210 @@ +/* Test GL_ARB_fragment_program */ + +#include <assert.h> +#include <string.h> +#include <stdio.h> +#include <stdlib.h> +#include <math.h> +#define GL_GLEXT_PROTOTYPES +#include <GL/glut.h> + + + +static void Display( void ) +{ + glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); + + glPushMatrix(); + + glColor4f(0, 0.5, 0, 1); + glColor4f(0, 1, 0, 1); + glBegin(GL_POLYGON); + glVertex2f(-1, -1); + glVertex2f( 1, -1); + glVertex2f( 0, 1); + glEnd(); + + glPopMatrix(); + + glutSwapBuffers(); +} + + +static void Reshape( int width, int height ) +{ + glViewport( 0, 0, width, height ); + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glFrustum( -1.0, 1.0, -1.0, 1.0, 5.0, 25.0 ); + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); + glTranslatef( 0.0, 0.0, -15.0 ); +} + + +static void Key( unsigned char key, int x, int y ) +{ + (void) x; + (void) y; + switch (key) { + case 27: + exit(0); + break; + } + glutPostRedisplay(); +} + +static void load_program(const char *prog, GLuint prognum) +{ + int a; + GLint errorpos, errno; + + glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, prognum); + glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, + strlen(prog), (const GLubyte *) prog); + + assert(glIsProgramARB(prognum)); + errno = glGetError(); + printf("glGetError = %d\n", errno); + if (errno != GL_NO_ERROR) + { + glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &errorpos); + printf("errorpos: %d\n", errorpos); + printf("%s\n", (char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB)); + + for (a=-10; a<10; a++) + { + if ((errorpos+a < 0) || (errorpos+a >= strlen(prog))) continue; + printf("%c", prog[errorpos+a]); + } + printf("\n"); + exit(1); + } +} + +static void Init( void ) +{ + static const char *prog0 = + "!!ARBfp1.0\n" + "TEMP R0, RC, HC, H0, H1, H2, H3, H30 ;\n" + "MUL result.color, R0, fragment.position; \n" + "ADD result.color, H3, fragment.texcoord; \n" + "ADD_SAT result.color, H3, fragment.texcoord; \n" + "MUL result.color.xy, R0.wzyx, fragment.position; \n" + "MUL result.color, H0, fragment.position; \n" + "MUL result.color, -H0, fragment.position; \n" + "MOV RC, H1; \n" + "MOV HC, H2; \n" + "END \n" + ; + /* masked updates, defines, declarations */ + static const char *prog1 = + "!!ARBfp1.0\n" + "PARAM foo = {1., 2., 3., 4.}; \n" + "PARAM foo2 = 5.; \n" + "PARAM foo3 = {5., 6., 7., 8.}; \n" + "PARAM bar = 3.; \n" + "TEMP R0, R1, RC, EQ, NE, bar2; \n" + "ALIAS bar3 = bar; \n" + "MOV result.color.xy, R0; \n" + "MOV result.color, R0; \n" + "MOV result.color.xyzw, R0; \n" + "MOV result.color.xy, R0; \n" + "MOV RC.x, R1.x; \n" + "KIL NE; \n" + "KIL EQ.xyxy; \n" + "END \n" + ; + + /* texture instructions */ + static const char *prog2 = + "!!ARBfp1.0\n" + "TEMP R0, R1, R2, R3;\n" + "TEX R0, fragment.texcoord, texture[1], 2D; \n" + "TEX R1, fragment.texcoord[1], texture[1], CUBE; \n" + "TEX R2, fragment.texcoord[2], texture[2], 3D; \n" + "TXP R3, fragment.texcoord[3], texture[3], RECT; \n" + "MUL result.color, R0, fragment.color; \n" + "END \n" + ; + + /* test negation, absolute value */ + static const char *prog3 = + "!!ARBfp1.0\n" + "TEMP R0, R1;\n" + "MOV R0, R1; \n" + "MOV R0, -R1; \n" + "MOV result.color, R0; \n" + "END \n" + ; + + /* literal constant sources */ + static const char *prog4 = + "!!ARBfp1.0\n" + "TEMP R0, R1;\n" + "PARAM Pi = 3.14159; \n" + "MOV R0, {1., -2., +3., 4.}; \n" + "MOV R0, 5.; \n" + "MOV R0, -5.; \n" + "MOV R0, 5.; \n" + "MOV R0, Pi; \n" + "MOV result.color, R0; \n" + "END \n" + ; + + /* change the fragment color in a simple way */ + static const char *prog10 = + "!!ARBfp1.0\n" + "PARAM blue = {0., 0., 1., 0.};\n" + "PARAM color = {1., 0., 0., 1.};\n" + "TEMP R0; \n" + "MOV R0, fragment.color; \n" + "#ADD result.color, R0, fragment.color; \n" + "#ADD result.color, blue, fragment.color; \n" + "#ADD result.color, {1., 0., 0., 0.}, fragment.color; \n" + "ADD result.color, color, fragment.color; \n" + "END \n" + ; + + GLuint progs[20]; + + glGenProgramsARB(20, progs); + assert(progs[0]); + assert(progs[1]); + assert(progs[0] != progs[1]); + + + printf("program 0:\n"); + load_program(prog0, progs[0]); + printf("program 1:\n"); + load_program(prog1, progs[1]); + printf("program 2:\n"); + load_program(prog2, progs[2]); + printf("program 3:\n"); + load_program(prog3, progs[3]); + printf("program 4:\n"); + load_program(prog4, progs[4]); + printf("program 10:\n"); + load_program(prog10, progs[5]); + + + glEnable(GL_FRAGMENT_PROGRAM_ARB); + glEnable(GL_ALPHA_TEST); + glAlphaFunc(GL_ALWAYS, 0.0); +} + + +int main( int argc, char *argv[] ) +{ + glutInit( &argc, argv ); + glutInitWindowPosition( 0, 0 ); + glutInitWindowSize( 250, 250 ); + glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH ); + glutCreateWindow(argv[0]); + glutReshapeFunc( Reshape ); + glutKeyboardFunc( Key ); + glutDisplayFunc( Display ); + Init(); + glutMainLoop(); + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/arbfptexture.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/arbfptexture.c new file mode 100644 index 000000000..a854908c3 --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/arbfptexture.c @@ -0,0 +1,153 @@ +/* GL_ARB_fragment_program texture test */ + +#include <assert.h> +#include <string.h> +#include <stdio.h> +#include <stdlib.h> +#include <math.h> +#define GL_GLEXT_PROTOTYPES +#include <GL/glut.h> + +#include "readtex.c" + + +#define TEXTURE_FILE "../images/girl.rgb" + +static GLfloat Xrot = 0.0, Yrot = 0.0, Zrot = 0.0; + + +static void Display( void ) +{ + glClear( GL_COLOR_BUFFER_BIT ); + + glPushMatrix(); + glRotatef(Xrot, 1.0, 0.0, 0.0); + glRotatef(Yrot, 0.0, 1.0, 0.0); + glRotatef(Zrot, 0.0, 0.0, 1.0); + + glBegin(GL_POLYGON); +#define Q 2 + glColor4f(1.0, 1.0, 1.0, 1); glTexCoord4f(0, 0, 0, Q); glVertex2f(-1, -1); + glColor4f(0.2, 0.2, 1.0, 1); glTexCoord4f(1, 0, 0, Q); glVertex2f( 1, -1); + glColor4f(0.2, 1.0, 0.2, 1); glTexCoord4f(1, 1, 0, Q); glVertex2f( 1, 1); + glColor4f(1.0, 0.2, 0.2, 1); glTexCoord4f(0, 1, 0, Q); glVertex2f(-1, 1); + glEnd(); + + glPopMatrix(); + + glutSwapBuffers(); +} + + +static void Reshape( int width, int height ) +{ + glViewport( 0, 0, width, height ); + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glFrustum( -1.0, 1.0, -1.0, 1.0, 5.0, 25.0 ); + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); + glTranslatef( 0.0, 0.0, -8.0 ); +} + + +static void SpecialKey( int key, int x, int y ) +{ + float step = 3.0; + (void) x; + (void) y; + + switch (key) { + case GLUT_KEY_UP: + Xrot += step; + break; + case GLUT_KEY_DOWN: + Xrot -= step; + break; + case GLUT_KEY_LEFT: + Yrot += step; + break; + case GLUT_KEY_RIGHT: + Yrot -= step; + break; + } + glutPostRedisplay(); +} + + +static void Key( unsigned char key, int x, int y ) +{ + (void) x; + (void) y; + switch (key) { + case 27: + exit(0); + break; + } + glutPostRedisplay(); +} + + +static void Init( void ) +{ + static const char *modulate2D = + "!!ARBfp1.0\n" + "TEMP R0;\n" + "TEX R0, fragment.texcoord[0], texture[0], 2D; \n" + "MUL result.color, R0, fragment.color; \n" + "END" + ; + GLuint modulateProg; + GLuint Texture; + + if (!glutExtensionSupported("GL_ARB_fragment_program")) { + printf("Error: GL_ARB_fragment_program not supported!\n"); + exit(1); + } + printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER)); + + /* Setup the fragment program */ + glGenProgramsARB(1, &modulateProg); + glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, modulateProg); + glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, + strlen(modulate2D), (const GLubyte *)modulate2D); + + printf("glGetError = 0x%x\n", (int) glGetError()); + printf("glError(GL_PROGRAM_ERROR_STRING_ARB) = %s\n", + (char *) glGetString(GL_PROGRAM_ERROR_STRING_ARB)); + assert(glIsProgramARB(modulateProg)); + + glEnable(GL_FRAGMENT_PROGRAM_ARB); + + /* Load texture */ + glGenTextures(1, &Texture); + glBindTexture(GL_TEXTURE_2D, Texture); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + if (!LoadRGBMipmaps(TEXTURE_FILE, GL_RGB)) { + printf("Error: couldn't load texture image file %s\n", TEXTURE_FILE); + exit(1); + } + /* XXX this enable shouldn't really be needed!!! */ + glEnable(GL_TEXTURE_2D); + + glClearColor(.3, .3, .3, 0); +} + + +int main( int argc, char *argv[] ) +{ + glutInit( &argc, argv ); + glutInitWindowPosition( 0, 0 ); + glutInitWindowSize( 250, 250 ); + glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH ); + glutCreateWindow(argv[0]); + glutReshapeFunc( Reshape ); + glutKeyboardFunc( Key ); + glutSpecialFunc( SpecialKey ); + glutDisplayFunc( Display ); + Init(); + glutMainLoop(); + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/arbfptrig.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/arbfptrig.c new file mode 100644 index 000000000..26b68c6b4 --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/arbfptrig.c @@ -0,0 +1,156 @@ +/* GL_ARB_fragment_program texture test */ + +#include <assert.h> +#include <string.h> +#include <stdio.h> +#include <stdlib.h> +#include <math.h> +#define GL_GLEXT_PROTOTYPES +#include <GL/glut.h> + +#include "readtex.c" + + +#define TEXTURE_FILE "../images/girl.rgb" + +static GLfloat Xrot = 0.0, Yrot = 0.0, Zrot = 0.0; + +#define PI 3.141592 + +static void Display( void ) +{ + glClear( GL_COLOR_BUFFER_BIT ); + + glPushMatrix(); + glRotatef(Xrot, 1.0, 0.0, 0.0); + glRotatef(Yrot, 0.0, 1.0, 0.0); + glRotatef(Zrot, 0.0, 0.0, 1.0); + + glBegin(GL_POLYGON); + glTexCoord2f(-PI, 0); glVertex2f(-1, -1); + glTexCoord2f(PI, 0); glVertex2f( 1, -1); + glTexCoord2f(PI, 1); glVertex2f( 1, 1); + glTexCoord2f(-PI, 1); glVertex2f(-1, 1); + glEnd(); + + glPopMatrix(); + + glutSwapBuffers(); +} + + +static void Reshape( int width, int height ) +{ + glViewport( 0, 0, width, height ); + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glFrustum( -1.0, 1.0, -1.0, 1.0, 5.0, 25.0 ); + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); + glTranslatef( 0.0, 0.0, -8.0 ); +} + + +static void SpecialKey( int key, int x, int y ) +{ + float step = 3.0; + (void) x; + (void) y; + + switch (key) { + case GLUT_KEY_UP: + Xrot += step; + break; + case GLUT_KEY_DOWN: + Xrot -= step; + break; + case GLUT_KEY_LEFT: + Yrot += step; + break; + case GLUT_KEY_RIGHT: + Yrot -= step; + break; + } + glutPostRedisplay(); +} + + +static void Key( unsigned char key, int x, int y ) +{ + (void) x; + (void) y; + switch (key) { + case 27: + exit(0); + break; + } + glutPostRedisplay(); +} + + +static void Init( void ) +{ + static const char *modulate2D = + "!!ARBfp1.0\n" + "TEMP R0;\n" + "MOV R0, {0,0,0,1};\n" + "SCS R0, fragment.texcoord[0].x; \n" + "ADD R0, R0, {1.0}.x;\n" + "MUL R0, R0, {0.5}.x;\n" + "MOV result.color, R0; \n" + "END" + ; + GLuint modulateProg; + GLuint Texture; + + if (!glutExtensionSupported("GL_ARB_fragment_program")) { + printf("Error: GL_ARB_fragment_program not supported!\n"); + exit(1); + } + printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER)); + + /* Setup the fragment program */ + glGenProgramsARB(1, &modulateProg); + glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, modulateProg); + glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, + strlen(modulate2D), (const GLubyte *)modulate2D); + + printf("glGetError = 0x%x\n", (int) glGetError()); + printf("glError(GL_PROGRAM_ERROR_STRING_ARB) = %s\n", + (char *) glGetString(GL_PROGRAM_ERROR_STRING_ARB)); + assert(glIsProgramARB(modulateProg)); + + glEnable(GL_FRAGMENT_PROGRAM_ARB); + + /* Load texture */ + glGenTextures(1, &Texture); + glBindTexture(GL_TEXTURE_2D, Texture); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + if (!LoadRGBMipmaps(TEXTURE_FILE, GL_RGB)) { + printf("Error: couldn't load texture image file %s\n", TEXTURE_FILE); + exit(1); + } + /* XXX this enable shouldn't really be needed!!! */ + glEnable(GL_TEXTURE_2D); + + glClearColor(.3, .3, .3, 0); +} + + +int main( int argc, char *argv[] ) +{ + glutInit( &argc, argv ); + glutInitWindowPosition( 0, 0 ); + glutInitWindowSize( 250, 250 ); + glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH ); + glutCreateWindow(argv[0]); + glutReshapeFunc( Reshape ); + glutKeyboardFunc( Key ); + glutSpecialFunc( SpecialKey ); + glutDisplayFunc( Display ); + Init(); + glutMainLoop(); + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/arbnpot.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/arbnpot.c new file mode 100644 index 000000000..8107717e2 --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/arbnpot.c @@ -0,0 +1,174 @@ +/* + * Test NPOT textures with the GL_ARB_texture_non_power_of_two extension. + * Brian Paul + * 2 July 2003 + */ + +#include <assert.h> +#include <stdio.h> +#include <stdlib.h> +#include <math.h> +#include <GL/glut.h> +#include "../util/readtex.c" + +#define IMAGE_FILE "../images/girl.rgb" + +static GLfloat Zrot = 0; + +static void Display( void ) +{ + glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); + + glPushMatrix(); + glRotatef(Zrot, 0, 0, 1); + glBegin(GL_POLYGON); + glTexCoord2f(0, 0); + glVertex2f(-1, -1); + glTexCoord2f(1, 0); + glVertex2f(1, -1); + glTexCoord2f(1, 1); + glVertex2f(1, 1); + glTexCoord2f(0, 1); + glVertex2f(-1, 1); + glEnd(); + glPopMatrix(); + + glutSwapBuffers(); +} + + +static void Reshape( int width, int height ) +{ + glViewport( 0, 0, width, height ); + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glFrustum( -1.0, 1.0, -1.0, 1.0, 5.0, 25.0 ); + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); + glTranslatef( 0.0, 0.0, -7.0 ); +} + + +static void Key( unsigned char key, int x, int y ) +{ + (void) x; + (void) y; + switch (key) { + case 'z': + Zrot -= 1.0; + break; + case 'Z': + Zrot += 1.0; + break; + case 27: + exit(0); + break; + } + glutPostRedisplay(); +} + + +static void Init( void ) +{ + GLubyte *image; + int imgWidth, imgHeight, minDim, w; + GLenum imgFormat; + + if (!glutExtensionSupported("GL_ARB_texture_non_power_of_two")) { + printf("Sorry, this program requires GL_ARB_texture_non_power_of_two\n"); + exit(1); + } + +#if 1 + image = LoadRGBImage( IMAGE_FILE, &imgWidth, &imgHeight, &imgFormat ); + if (!image) { + printf("Couldn't read %s\n", IMAGE_FILE); + exit(0); + } +#else + int i, j; + imgFormat = GL_RGB; + imgWidth = 3; + imgHeight = 3; + image = malloc(imgWidth * imgHeight * 3); + for (i = 0; i < imgHeight; i++) { + for (j = 0; j < imgWidth; j++) { + int k = (i * imgWidth + j) * 3; + if ((i + j) & 1) { + image[k+0] = 255; + image[k+1] = 0; + image[k+2] = 0; + } + else { + image[k+0] = 0; + image[k+1] = 255; + image[k+2] = 0; + } + } + } +#endif + + printf("Read %d x %d\n", imgWidth, imgHeight); + + minDim = imgWidth < imgHeight ? imgWidth : imgHeight; + + glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + glTexImage1D(GL_TEXTURE_1D, 0, GL_RGB, imgWidth, 0, + imgFormat, GL_UNSIGNED_BYTE, image); + assert(glGetError() == GL_NO_ERROR); + + glTexImage1D(GL_PROXY_TEXTURE_1D, 0, GL_RGB, imgWidth, 0, + imgFormat, GL_UNSIGNED_BYTE, image); + glGetTexLevelParameteriv(GL_PROXY_TEXTURE_1D, 0, GL_TEXTURE_WIDTH, &w); + assert(w == imgWidth); + + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, imgWidth, imgHeight, 0, + imgFormat, GL_UNSIGNED_BYTE, image); + assert(glGetError() == GL_NO_ERROR); + + glTexImage2D(GL_PROXY_TEXTURE_2D, 0, GL_RGB, imgWidth, imgHeight, 0, + imgFormat, GL_UNSIGNED_BYTE, image); + glGetTexLevelParameteriv(GL_PROXY_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &w); + assert(w == imgWidth); + + glTexImage3D(GL_TEXTURE_3D, 0, GL_RGB, imgWidth, imgHeight, 1, 0, + imgFormat, GL_UNSIGNED_BYTE, image); + assert(glGetError() == GL_NO_ERROR); + + glTexImage3D(GL_PROXY_TEXTURE_3D, 0, GL_RGB, imgWidth, imgHeight, 1, 0, + imgFormat, GL_UNSIGNED_BYTE, image); + glGetTexLevelParameteriv(GL_PROXY_TEXTURE_3D, 0, GL_TEXTURE_WIDTH, &w); + assert(w == imgWidth); + + glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB, + minDim, minDim, 0, + imgFormat, GL_UNSIGNED_BYTE, image); + assert(glGetError() == GL_NO_ERROR); + + glTexImage2D(GL_PROXY_TEXTURE_CUBE_MAP, 0, GL_RGB, + minDim, minDim, 0, + imgFormat, GL_UNSIGNED_BYTE, image); + glGetTexLevelParameteriv(GL_PROXY_TEXTURE_CUBE_MAP, 0, GL_TEXTURE_WIDTH, &w); + assert(w == minDim); + + + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + glEnable(GL_TEXTURE_2D); +} + + +int main( int argc, char *argv[] ) +{ + glutInit( &argc, argv ); + glutInitWindowPosition( 0, 0 ); + glutInitWindowSize( 400, 400 ); + glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH ); + glutCreateWindow(argv[0]); + glutReshapeFunc( Reshape ); + glutKeyboardFunc( Key ); + glutDisplayFunc( Display ); + Init(); + glutMainLoop(); + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/arbvptest1.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/arbvptest1.c new file mode 100644 index 000000000..5c462c42c --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/arbvptest1.c @@ -0,0 +1,164 @@ +/* Test glGenProgramsNV(), glIsProgramNV(), glLoadProgramNV() */ + +#include <assert.h> +#include <string.h> +#include <stdio.h> +#include <stdlib.h> +#include <math.h> +#define GL_GLEXT_PROTOTYPES +#include <GL/glut.h> + +static void Display( void ) +{ + glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); + + glPushMatrix(); + + glBegin(GL_POLYGON); + glVertexAttrib2fNV(0, -1, -1); + glVertexAttrib2fNV(0, 1, -1); + glVertexAttrib2fNV(0, 0, 1); + glEnd(); + + glPopMatrix(); + + glutSwapBuffers(); +} + + +static void Reshape( int width, int height ) +{ + glViewport( 0, 0, width, height ); + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glFrustum( -1.0, 1.0, -1.0, 1.0, 5.0, 25.0 ); + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); + glTranslatef( 0.0, 0.0, -15.0 ); +} + + +static void Key( unsigned char key, int x, int y ) +{ + (void) x; + (void) y; + switch (key) { + case 27: + exit(0); + break; + } + glutPostRedisplay(); +} + +static void load_program(const char *prog, GLuint prognum) +{ + int a; + GLint errorpos, errno; + + glBindProgramARB(GL_VERTEX_PROGRAM_ARB, prognum); + glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, + strlen(prog), (const GLubyte *) prog); + + assert(glIsProgramARB(prognum)); + errno = glGetError(); + printf("glGetError = %d\n", errno); + if (errno != GL_NO_ERROR) + { + glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &errorpos); + printf("errorpos: %d\n", errorpos); + printf("%s\n", (char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB)); + + for (a=-10; a<10; a++) + { + if ((errorpos+a < 0) || (errorpos+a >= strlen(prog))) continue; + printf("%c", prog[errorpos+a]); + } + printf("\n"); + exit(1); + } +} + +static void Init( void ) +{ + GLuint prognum[4]; + + static const char *prog1 = + "!!ARBvp1.0\n" + "TEMP R0;\n" + "MUL result.color.primary.xyz, R0, program.local[35]; \n" + "END\n"; + static const char *prog2 = + "!!ARBvp1.0\n" + "#\n" + "# c[0-3] = modelview projection (composite) matrix\n" + "# c[32] = normalized light direction in object-space\n" + "# c[35] = yellow diffuse material, (1.0, 1.0, 0.0, 1.0)\n" + "# c[64].x = 0.0\n" + "# c[64].z = 0.125, a scaling factor\n" + "TEMP R0, R1;\n" + "#\n" + "# outputs diffuse illumination for color and perturbed position\n" + "#\n" + "DP3 R0, program.local[32], vertex.normal; # light direction DOT normal\n" + "MUL result.color.primary.xyz, R0, program.local[35]; \n" + "MAX R0, program.local[64].x, R0; \n" + "MUL R0, R0, vertex.normal; \n" + "MUL R0, R0, program.local[64].z; \n" + "ADD R1, vertex.position, -R0; # perturb object space position\n" + "DP4 result.position.x, state.matrix.mvp.row[3], R1; \n" + "DP4 result.position.y, state.matrix.mvp.row[1], R1; \n" + "DP4 result.position.z, state.matrix.mvp.row[2], R1; \n" + "DP4 result.position.w, state.matrix.mvp.row[3], R1; \n" + "END\n"; + static const char *prog3 = + "!!ARBvp1.0\n" + "TEMP R0, R1, R2, R3;\n" + "DP4 result.position.x, state.matrix.mvp.row[0], vertex.position;\n" + "DP4 result.position.y, state.matrix.mvp.row[1], vertex.position;\n" + "DP4 result.position.z, state.matrix.mvp.row[2], vertex.position;\n" + "DP4 result.position.w, state.matrix.mvp.row[3], vertex.position;\n" + "DP3 R0.x, state.matrix.modelview.inverse.row[0], vertex.normal;\n" + "DP3 R0.y, state.matrix.modelview.inverse.row[1], vertex.normal;\n" + "DP3 R0.z, state.matrix.modelview.inverse.row[2], vertex.normal;\n" + "DP3 R1.x, program.env[32], R0; # R1.x = Lpos DOT n'\n" + "DP3 R1.y, program.env[33], R0; # R1.y = hHat DOT n'\n" + "MOV R1.w, program.local[38].x; # R1.w = specular power\n" + "LIT R2, R1; # Compute lighting values\n" + "MAD R3, program.env[35].x, R2.y, program.env[35].y; # diffuse + emissive\n" + "MAD result.color.primary.xyz, program.env[36], R2.z, R3; # + specular\n" + "END\n"; + static const char *prog4 = + "!!ARBvp1.0\n" + "TEMP R2, R3;\n" + "PARAM foo = {0., 0., 0., 1.};\n" + "PARAM blah[] = { program.local[0..8] };\n" + "ADDRESS A0;\n" + "ARL A0.x, foo.x;\n" + "DP4 R2, R3, blah[A0.x].x;\n" + "DP4 R2, R3, blah[A0.x + 5];\n" + "DP4 result.position, R3, blah[A0.x - 4];\n" + "END\n"; + + glGenProgramsNV(4, prognum); + + load_program(prog1, prognum[0]); + load_program(prog2, prognum[1]); + load_program(prog3, prognum[2]); + load_program(prog4, prognum[3]); +} + + +int main( int argc, char *argv[] ) +{ + glutInit( &argc, argv ); + glutInitWindowPosition( 0, 0 ); + glutInitWindowSize( 250, 250 ); + glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH ); + glutCreateWindow(argv[0]); + glutReshapeFunc( Reshape ); + glutKeyboardFunc( Key ); + glutDisplayFunc( Display ); + Init(); + glutMainLoop(); + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/arbvptest3.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/arbvptest3.c new file mode 100644 index 000000000..5f6d4f7e9 --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/arbvptest3.c @@ -0,0 +1,128 @@ +/* Test glGenProgramsNV(), glIsProgramNV(), glLoadProgramNV() */ + +#include <assert.h> +#include <string.h> +#include <stdio.h> +#include <stdlib.h> +#include <math.h> +#define GL_GLEXT_PROTOTYPES +#include <GL/glut.h> + +static float Zrot = 0.0; + + +static void Display( void ) +{ + glClearColor(0.3, 0.3, 0.3, 1); + glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); + + glEnable(GL_VERTEX_PROGRAM_NV); + + glLoadIdentity(); + glRotatef(Zrot, 0, 0, 1); + + glPushMatrix(); + + glVertexAttrib3fARB(3, 1, 0.5, 0.25); + glBegin(GL_TRIANGLES); +#if 1 + glVertexAttrib3fARB(3, 1.0, 0.0, 0.0); + glVertexAttrib2fARB(0, -0.5, -0.5); + glVertexAttrib3fARB(3, 0.0, 1.0, 0.0); + glVertexAttrib2fARB(0, 0.5, -0.5); + glVertexAttrib3fARB(3, 0.0, 0.0, 1.0); + glVertexAttrib2fARB(0, 0, 0.5); +#else + glVertex2f( -1, -1); + glVertex2f( 1, -1); + glVertex2f( 0, 1); +#endif + glEnd(); + + glPopMatrix(); + + glutSwapBuffers(); +} + + +static void Reshape( int width, int height ) +{ + glViewport( 0, 0, width, height ); + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + /* glFrustum( -2.0, 2.0, -2.0, 2.0, 5.0, 25.0 );*/ + glOrtho(-2.0, 2.0, -2.0, 2.0, -2.0, 2.0 ); + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); + /*glTranslatef( 0.0, 0.0, -15.0 );*/ +} + + +static void Key( unsigned char key, int x, int y ) +{ + (void) x; + (void) y; + switch (key) { + case 'z': + Zrot -= 5.0; + break; + case 'Z': + Zrot += 5.0; + break; + case 27: + exit(0); + break; + } + glutPostRedisplay(); +} + + +static void Init( void ) +{ + GLint errno; + GLuint prognum; + + static const char *prog1 = + "!!ARBvp1.0\n" + "MOV result.color, vertex.color;\n" + + "DP4 result.position.x, vertex.position, state.matrix.modelview.row[0];\n" + "DP4 result.position.y, vertex.position, state.matrix.modelview.row[1];\n" + "DP4 result.position.z, vertex.position, state.matrix.modelview.row[2];\n" + "DP4 result.position.w, vertex.position, state.matrix.modelview.row[3];\n" + "END\n"; + + glGenProgramsARB(1, &prognum); + + glBindProgramARB(GL_VERTEX_PROGRAM_ARB, prognum); + glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, + strlen(prog1), (const GLubyte *) prog1); + + assert(glIsProgramARB(prognum)); + errno = glGetError(); + printf("glGetError = %d\n", errno); + if (errno != GL_NO_ERROR) + { + GLint errorpos; + + glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &errorpos); + printf("errorpos: %d\n", errorpos); + printf("%s\n", (char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB)); + } +} + + +int main( int argc, char *argv[] ) +{ + glutInit( &argc, argv ); + glutInitWindowPosition( 0, 0 ); + glutInitWindowSize( 250, 250 ); + glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH ); + glutCreateWindow(argv[0]); + glutReshapeFunc( Reshape ); + glutKeyboardFunc( Key ); + glutDisplayFunc( Display ); + Init(); + glutMainLoop(); + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/arbvptorus.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/arbvptorus.c new file mode 100644 index 000000000..c1e2d0b76 --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/arbvptorus.c @@ -0,0 +1,191 @@ +/* + * A lit, rotating torus via vertex program + */ + +#include <assert.h> +#include <string.h> +#include <stdio.h> +#include <stdlib.h> +#include <math.h> +#define GL_GLEXT_PROTOTYPES +#include <GL/glut.h> + +static float Xrot = 0.0, Yrot = 0.0, Zrot = 0.0; +static GLboolean Anim = GL_TRUE; + + +static void Idle( void ) +{ + Xrot += .3; + Yrot += .4; + Zrot += .2; + glutPostRedisplay(); +} + + +static void Display( void ) +{ + glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); + + glPushMatrix(); + glRotatef(Xrot, 1, 0, 0); + glRotatef(Yrot, 0, 1, 0); + glRotatef(Zrot, 0, 0, 1); + glutSolidTorus(0.75, 2.0, 10, 20); + glPopMatrix(); + + glutSwapBuffers(); +} + + +static void Reshape( int width, int height ) +{ + glViewport( 0, 0, width, height ); + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glFrustum( -2.0, 2.0, -2.0, 2.0, 5.0, 25.0 ); + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); + glTranslatef( 0.0, 0.0, -12.0 ); +} + + +static void Key( unsigned char key, int x, int y ) +{ + (void) x; + (void) y; + switch (key) { + case ' ': + Xrot = Yrot = Zrot = 0; + break; + case 'a': + Anim = !Anim; + if (Anim) + glutIdleFunc(Idle); + else + glutIdleFunc(NULL); + break; + case 'z': + Zrot -= 5.0; + break; + case 'Z': + Zrot += 5.0; + break; + case 27: + exit(0); + break; + } + glutPostRedisplay(); +} + + +static void SpecialKey( int key, int x, int y ) +{ + const GLfloat step = 3.0; + (void) x; + (void) y; + switch (key) { + case GLUT_KEY_UP: + Xrot -= step; + break; + case GLUT_KEY_DOWN: + Xrot += step; + break; + case GLUT_KEY_LEFT: + Yrot -= step; + break; + case GLUT_KEY_RIGHT: + Yrot += step; + break; + } + glutPostRedisplay(); +} + + +static void Init( void ) +{ + GLint errno; + GLuint prognum; + + /* borrowed from an nvidia demo: + * c[0..3] = modelview matrix + * c[4..7] = invtrans modelview matrix + * c[32] = light pos + * c[35] = diffuse color + */ + static const char prog[] = + "!!ARBvp1.0\n" + "TEMP R0, R1; \n" + "#Simple transform and diffuse lighting\n" + "# object x MVP -> clip\n" + "DP4 result.position.x, state.matrix.mvp.row[0], vertex.position ;\n" + "DP4 result.position.y, state.matrix.mvp.row[1], vertex.position ;\n" + "DP4 result.position.z, state.matrix.mvp.row[2], vertex.position ;\n" + "DP4 result.position.w, state.matrix.mvp.row[3], vertex.position ;\n" + + "# normal x MV-1T -> lighting normal\n" + "DP3 R1.x, state.matrix.modelview.invtrans.row[0], vertex.normal ;\n" + "DP3 R1.y, state.matrix.modelview.invtrans.row[1], vertex.normal;\n" + "DP3 R1.z, state.matrix.modelview.invtrans.row[2], vertex.normal;\n" + + "DP3 R0, program.local[32], R1; # L.N\n" +#if 0 + "MUL result.color.xyz, R0, program.local[35] ; # col = L.N * diffuse\n" +#else + "MUL result.color.primary.xyz, R0, program.local[35] ; # col = L.N * diffuse\n" +#endif + "MOV result.texcoord, vertex.texcoord;\n" + "END"; + + if (!glutExtensionSupported("GL_ARB_vertex_program")) { + printf("Sorry, this program requires GL_ARB_vertex_program"); + exit(1); + } + + + glGenProgramsARB(1, &prognum); + + glBindProgramARB(GL_VERTEX_PROGRAM_ARB, prognum); + glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, + strlen(prog), (const GLubyte *) prog); + + assert(glIsProgramARB(prognum)); + errno = glGetError(); + printf("glGetError = %d\n", errno); + if (errno != GL_NO_ERROR) + { + GLint errorpos; + + glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &errorpos); + printf("errorpos: %d\n", errorpos); + printf("%s\n", (char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB)); + } + + /* Light position */ + glProgramLocalParameter4fARB(GL_VERTEX_PROGRAM_ARB, 32, 2, 2, 4, 1); + /* Diffuse material color */ + glProgramLocalParameter4fARB(GL_VERTEX_PROGRAM_ARB, 35, 0.25, 0, 0.25, 1); + + glEnable(GL_VERTEX_PROGRAM_ARB); + glEnable(GL_DEPTH_TEST); + glClearColor(0.3, 0.3, 0.3, 1); +} + + +int main( int argc, char *argv[] ) +{ + glutInit( &argc, argv ); + glutInitWindowPosition( 0, 0 ); + glutInitWindowSize( 250, 250 ); + glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH ); + glutCreateWindow(argv[0]); + glutReshapeFunc( Reshape ); + glutKeyboardFunc( Key ); + glutSpecialFunc( SpecialKey ); + glutDisplayFunc( Display ); + if (Anim) + glutIdleFunc(Idle); + Init(); + glutMainLoop(); + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/arbvpwarpmesh.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/arbvpwarpmesh.c new file mode 100644 index 000000000..a9e2564bc --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/arbvpwarpmesh.c @@ -0,0 +1,246 @@ +/* + * Warp a triangle mesh with a vertex program. + */ + +#include <assert.h> +#include <string.h> +#include <stdio.h> +#include <stdlib.h> +#include <math.h> +#define GL_GLEXT_PROTOTYPES +#include <GL/glut.h> + +static float Xrot = -60.0, Yrot = 0.0, Zrot = 0.0; +static GLboolean Anim = GL_TRUE; +static GLfloat Phi = 0.0; + + +static void Idle( void ) +{ + Phi += 0.01; + glutPostRedisplay(); +} + + +static void DrawMesh( int rows, int cols ) +{ + static const GLfloat colorA[3] = { 0, 1, 0 }; + static const GLfloat colorB[3] = { 0, 0, 1 }; + const float dx = 2.0 / (cols - 1); + const float dy = 2.0 / (rows - 1); + float x, y; + int i, j; + +#if 1 +#define COLOR3FV(c) glVertexAttrib3fvARB(3, c) +#define VERTEX2F(x, y) glVertexAttrib2fARB(0, x, y) +#else +#define COLOR3FV(c) glColor3fv(c) +#define VERTEX2F(x, y) glVertex2f(x, y) +#endif + + y = -1.0; + for (i = 0; i < rows - 1; i++) { + glBegin(GL_QUAD_STRIP); + x = -1.0; + for (j = 0; j < cols; j++) { + if ((i + j) & 1) + COLOR3FV(colorA); + else + COLOR3FV(colorB); + VERTEX2F(x, y); + VERTEX2F(x, y + dy); + x += dx; + } + glEnd(); + y += dy; + } +} + + +static void Display( void ) +{ + glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); + + glPushMatrix(); + glRotatef(Xrot, 1, 0, 0); + glRotatef(Yrot, 0, 1, 0); + glRotatef(Zrot, 0, 0, 1); + + /* Position the gravity source */ + { + GLfloat x, y, z, r = 0.5; + x = r * cos(Phi); + y = r * sin(Phi); + z = 1.0; + glProgramLocalParameter4fARB(GL_VERTEX_PROGRAM_ARB, 30, x, y, z, 1); + glDisable(GL_VERTEX_PROGRAM_ARB); + glBegin(GL_POINTS); + glColor3f(1,1,1); + glVertex3f(x, y, z); + glEnd(); + } + + glEnable(GL_VERTEX_PROGRAM_ARB); + DrawMesh(8, 8); + glPopMatrix(); + + glutSwapBuffers(); +} + + +static void Reshape( int width, int height ) +{ + float ar = (float) width / (float) height; + glViewport( 0, 0, width, height ); + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glFrustum( -1.0 * ar, 1.0 * ar, -1.0, 1.0, 5.0, 25.0 ); + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); + glTranslatef( 0.0, 0.0, -12.0 ); + glScalef(2, 2, 2); +} + + +static void Key( unsigned char key, int x, int y ) +{ + (void) x; + (void) y; + switch (key) { + case 'a': + Anim = !Anim; + if (Anim) + glutIdleFunc(Idle); + else + glutIdleFunc(NULL); + break; + case 'p': + Phi += 0.2; + break; + case 'z': + Zrot -= 5.0; + break; + case 'Z': + Zrot += 5.0; + break; + case 27: + exit(0); + break; + } + glutPostRedisplay(); +} + + +static void SpecialKey( int key, int x, int y ) +{ + const GLfloat step = 3.0; + (void) x; + (void) y; + switch (key) { + case GLUT_KEY_UP: + Xrot -= step; + break; + case GLUT_KEY_DOWN: + Xrot += step; + break; + case GLUT_KEY_LEFT: + Yrot -= step; + break; + case GLUT_KEY_RIGHT: + Yrot += step; + break; + } + glutPostRedisplay(); +} + + +static void Init( void ) +{ + GLuint prognum; + GLint errno; + + /* + * c[0..3] = modelview matrix + * c[4..7] = inverse modelview matrix + * c[30] = gravity source location + * c[31] = gravity source strength + * c[32] = light pos + * c[35] = diffuse color + */ + static const char prog[] = + "!!ARBvp1.0\n" + "TEMP R1, R2, R3; " + + "# Compute distance from vertex to gravity source\n" + "ADD R1, program.local[30], -vertex.position; # vector from vertex to gravity\n" + "DP3 R2, R1, R1; # dot product\n" + "RSQ R2, R2.x; # square root = distance\n" + "MUL R2, R2, program.local[31].xxxx; # scale by the gravity factor\n" + + "# Displace vertex by gravity factor along R1 vector\n" + "MAD R3, R1, R2, vertex.position;\n" + + "# Continue with typical modelview/projection\n" + "DP4 result.position.x, state.matrix.mvp.row[0], R3 ; # object x MVP -> clip\n" + "DP4 result.position.y, state.matrix.mvp.row[1], R3 ;\n" + "DP4 result.position.z, state.matrix.mvp.row[2], R3 ;\n" + "DP4 result.position.w, state.matrix.mvp.row[3], R3 ;\n" + + "MOV result.color, vertex.color;\n # copy input color to output color\n" + + "END"; + + if (!glutExtensionSupported("GL_ARB_vertex_program")) { + printf("Sorry, this program requires GL_ARB_vertex_program\n"); + exit(1); + } + + glGenProgramsARB(1, &prognum); + glBindProgramARB(GL_VERTEX_PROGRAM_ARB, prognum); + glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, + strlen(prog), (const GLubyte *)prog); + errno = glGetError(); + printf("glGetError = %d\n", errno); + + if (errno != GL_NO_ERROR) + { + GLint errorpos; + + glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &errorpos); + printf("errorpos: %d\n", errorpos); + printf("%s\n", glGetString(GL_PROGRAM_ERROR_STRING_ARB)); + } + + /* Light position */ + glProgramLocalParameter4fARB(GL_VERTEX_PROGRAM_ARB, 32, 2, 2, 4, 1); + /* Diffuse material color */ + glProgramLocalParameter4fARB(GL_VERTEX_PROGRAM_ARB, 35, 0.25, 0, 0.25, 1); + + /* Gravity strength */ + glProgramLocalParameter4fARB(GL_VERTEX_PROGRAM_ARB, 31, .5, 0, 0, 0); + + glEnable(GL_DEPTH_TEST); + glClearColor(0.3, 0.3, 0.3, 1); + glShadeModel(GL_FLAT); + glPointSize(3); +} + + +int main( int argc, char *argv[] ) +{ + glutInit( &argc, argv ); + glutInitWindowPosition( 0, 0 ); + glutInitWindowSize( 250, 250 ); + glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH ); + glutCreateWindow(argv[0]); + glutReshapeFunc( Reshape ); + glutKeyboardFunc( Key ); + glutSpecialFunc( SpecialKey ); + glutDisplayFunc( Display ); + if (Anim) + glutIdleFunc(Idle); + Init(); + glutMainLoop(); + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/auxbuffer.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/auxbuffer.c new file mode 100644 index 000000000..70f0b7391 --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/auxbuffer.c @@ -0,0 +1,499 @@ +/* + * Test AUX buffer rendering + * Use GLX since GLUT doesn't support AUX buffers + */ + + +/* + * Copyright (C) 1999-2001 Brian Paul All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +/* + * This is a port of the infamous "gears" demo to straight GLX (i.e. no GLUT) + * Port by Brian Paul 23 March 2001 + * + * Command line options: + * -info print GL implementation information + * + */ + + +#include <math.h> +#include <stdlib.h> +#include <stdio.h> +#include <string.h> +#include <X11/Xlib.h> +#include <X11/keysym.h> +#include <GL/gl.h> +#include <GL/glx.h> + + +static int +current_time(void) +{ + return 0; +} + + + + +#ifndef M_PI +#define M_PI 3.14159265 +#endif + +static int WinWidth = 300, WinHeight = 300; +static GLfloat view_rotx = 20.0, view_roty = 30.0, view_rotz = 0.0; +static GLint gear1, gear2, gear3; +static GLfloat angle = 0.0; + + +/* + * + * Draw a gear wheel. You'll probably want to call this function when + * building a display list since we do a lot of trig here. + * + * Input: inner_radius - radius of hole at center + * outer_radius - radius at center of teeth + * width - width of gear + * teeth - number of teeth + * tooth_depth - depth of tooth + */ +static void +gear(GLfloat inner_radius, GLfloat outer_radius, GLfloat width, + GLint teeth, GLfloat tooth_depth) +{ + GLint i; + GLfloat r0, r1, r2; + GLfloat angle, da; + GLfloat u, v, len; + + r0 = inner_radius; + r1 = outer_radius - tooth_depth / 2.0; + r2 = outer_radius + tooth_depth / 2.0; + + da = 2.0 * M_PI / teeth / 4.0; + + glShadeModel(GL_FLAT); + + glNormal3f(0.0, 0.0, 1.0); + + /* draw front face */ + glBegin(GL_QUAD_STRIP); + for (i = 0; i <= teeth; i++) { + angle = i * 2.0 * M_PI / teeth; + glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5); + glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5); + if (i < teeth) { + glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5); + glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), + width * 0.5); + } + } + glEnd(); + + /* draw front sides of teeth */ + glBegin(GL_QUADS); + da = 2.0 * M_PI / teeth / 4.0; + for (i = 0; i < teeth; i++) { + angle = i * 2.0 * M_PI / teeth; + + glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5); + glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), width * 0.5); + glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da), + width * 0.5); + glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), + width * 0.5); + } + glEnd(); + + glNormal3f(0.0, 0.0, -1.0); + + /* draw back face */ + glBegin(GL_QUAD_STRIP); + for (i = 0; i <= teeth; i++) { + angle = i * 2.0 * M_PI / teeth; + glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5); + glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5); + if (i < teeth) { + glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), + -width * 0.5); + glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5); + } + } + glEnd(); + + /* draw back sides of teeth */ + glBegin(GL_QUADS); + da = 2.0 * M_PI / teeth / 4.0; + for (i = 0; i < teeth; i++) { + angle = i * 2.0 * M_PI / teeth; + + glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), + -width * 0.5); + glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da), + -width * 0.5); + glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), -width * 0.5); + glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5); + } + glEnd(); + + /* draw outward faces of teeth */ + glBegin(GL_QUAD_STRIP); + for (i = 0; i < teeth; i++) { + angle = i * 2.0 * M_PI / teeth; + + glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5); + glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5); + u = r2 * cos(angle + da) - r1 * cos(angle); + v = r2 * sin(angle + da) - r1 * sin(angle); + len = sqrt(u * u + v * v); + u /= len; + v /= len; + glNormal3f(v, -u, 0.0); + glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), width * 0.5); + glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), -width * 0.5); + glNormal3f(cos(angle), sin(angle), 0.0); + glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da), + width * 0.5); + glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da), + -width * 0.5); + u = r1 * cos(angle + 3 * da) - r2 * cos(angle + 2 * da); + v = r1 * sin(angle + 3 * da) - r2 * sin(angle + 2 * da); + glNormal3f(v, -u, 0.0); + glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), + width * 0.5); + glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), + -width * 0.5); + glNormal3f(cos(angle), sin(angle), 0.0); + } + + glVertex3f(r1 * cos(0), r1 * sin(0), width * 0.5); + glVertex3f(r1 * cos(0), r1 * sin(0), -width * 0.5); + + glEnd(); + + glShadeModel(GL_SMOOTH); + + /* draw inside radius cylinder */ + glBegin(GL_QUAD_STRIP); + for (i = 0; i <= teeth; i++) { + angle = i * 2.0 * M_PI / teeth; + glNormal3f(-cos(angle), -sin(angle), 0.0); + glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5); + glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5); + } + glEnd(); +} + + +static void +draw(void) +{ + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + + glPushMatrix(); + glRotatef(view_rotx, 1.0, 0.0, 0.0); + glRotatef(view_roty, 0.0, 1.0, 0.0); + glRotatef(view_rotz, 0.0, 0.0, 1.0); + + glPushMatrix(); + glTranslatef(-3.0, -2.0, 0.0); + glRotatef(angle, 0.0, 0.0, 1.0); + glCallList(gear1); + glPopMatrix(); + + glPushMatrix(); + glTranslatef(3.1, -2.0, 0.0); + glRotatef(-2.0 * angle - 9.0, 0.0, 0.0, 1.0); + glCallList(gear2); + glPopMatrix(); + + glPushMatrix(); + glTranslatef(-3.1, 4.2, 0.0); + glRotatef(-2.0 * angle - 25.0, 0.0, 0.0, 1.0); + glCallList(gear3); + glPopMatrix(); + + glPopMatrix(); +} + + +/* new window size or exposure */ +static void +reshape(int width, int height) +{ + GLfloat h = (GLfloat) height / (GLfloat) width; + + WinWidth = width; + WinHeight = height; + glViewport(0, 0, (GLint) width, (GLint) height); + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + glFrustum(-1.0, 1.0, -h, h, 5.0, 60.0); + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + glTranslatef(0.0, 0.0, -40.0); +} + + +static void +init(void) +{ + static GLfloat pos[4] = { 5.0, 5.0, 10.0, 0.0 }; + static GLfloat red[4] = { 0.8, 0.1, 0.0, 1.0 }; + static GLfloat green[4] = { 0.0, 0.8, 0.2, 1.0 }; + static GLfloat blue[4] = { 0.2, 0.2, 1.0, 1.0 }; + int i; + + glGetIntegerv(GL_AUX_BUFFERS, &i); + printf("AUX BUFFERS: %d\n", i); + + glLightfv(GL_LIGHT0, GL_POSITION, pos); + glEnable(GL_CULL_FACE); + glEnable(GL_LIGHTING); + glEnable(GL_LIGHT0); + glEnable(GL_DEPTH_TEST); + + /* make the gears */ + gear1 = glGenLists(1); + glNewList(gear1, GL_COMPILE); + glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, red); + gear(1.0, 4.0, 1.0, 20, 0.7); + glEndList(); + + gear2 = glGenLists(1); + glNewList(gear2, GL_COMPILE); + glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, green); + gear(0.5, 2.0, 2.0, 10, 0.7); + glEndList(); + + gear3 = glGenLists(1); + glNewList(gear3, GL_COMPILE); + glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, blue); + gear(1.3, 2.0, 0.5, 10, 0.7); + glEndList(); + + glEnable(GL_NORMALIZE); +} + + +/* + * Create an RGB, double-buffered window. + * Return the window and context handles. + */ +static void +make_window( Display *dpy, const char *name, + int x, int y, int width, int height, + Window *winRet, GLXContext *ctxRet) +{ + int attrib[] = { GLX_RGBA, + GLX_RED_SIZE, 1, + GLX_GREEN_SIZE, 1, + GLX_BLUE_SIZE, 1, + GLX_DOUBLEBUFFER, + GLX_DEPTH_SIZE, 1, + GLX_AUX_BUFFERS, 1, + None }; + int scrnum; + XSetWindowAttributes attr; + unsigned long mask; + Window root; + Window win; + GLXContext ctx; + XVisualInfo *visinfo; + + scrnum = DefaultScreen( dpy ); + root = RootWindow( dpy, scrnum ); + + visinfo = glXChooseVisual( dpy, scrnum, attrib ); + if (!visinfo) { + printf("Error: couldn't get an RGB, Double-buffered visual\n"); + exit(1); + } + + /* window attributes */ + attr.background_pixel = 0; + attr.border_pixel = 0; + attr.colormap = XCreateColormap( dpy, root, visinfo->visual, AllocNone); + attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask; + mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask; + + win = XCreateWindow( dpy, root, 0, 0, width, height, + 0, visinfo->depth, InputOutput, + visinfo->visual, mask, &attr ); + + /* set hints and properties */ + { + XSizeHints sizehints; + sizehints.x = x; + sizehints.y = y; + sizehints.width = width; + sizehints.height = height; + sizehints.flags = USSize | USPosition; + XSetNormalHints(dpy, win, &sizehints); + XSetStandardProperties(dpy, win, name, name, + None, (char **)NULL, 0, &sizehints); + } + + ctx = glXCreateContext( dpy, visinfo, NULL, True ); + if (!ctx) { + printf("Error: glXCreateContext failed\n"); + exit(1); + } + + XFree(visinfo); + + *winRet = win; + *ctxRet = ctx; +} + + +static void +event_loop(Display *dpy, Window win) +{ + while (1) { + while (XPending(dpy) > 0) { + XEvent event; + XNextEvent(dpy, &event); + switch (event.type) { + case Expose: + /* we'll redraw below */ + break; + case ConfigureNotify: + reshape(event.xconfigure.width, event.xconfigure.height); + break; + case KeyPress: + { + char buffer[10]; + int r, code; + code = XLookupKeysym(&event.xkey, 0); + if (code == XK_Left) { + view_roty += 5.0; + } + else if (code == XK_Right) { + view_roty -= 5.0; + } + else if (code == XK_Up) { + view_rotx += 5.0; + } + else if (code == XK_Down) { + view_rotx -= 5.0; + } + else { + r = XLookupString(&event.xkey, buffer, sizeof(buffer), + NULL, NULL); + if (buffer[0] == 27) { + /* escape */ + return; + } + } + } + } + } + + /* next frame */ + angle += 2.0; + + /* draw to aux buffer */ + glDrawBuffer(GL_AUX0); + + draw(); + + /* Copy aux buffer image to back color buffer */ + glReadBuffer(GL_AUX0); + glDrawBuffer(GL_BACK); + glWindowPos2iARB(0, 0); + glDisable(GL_DEPTH_TEST); + glCopyPixels(0, 0, WinWidth, WinHeight, GL_COLOR); + glEnable(GL_DEPTH_TEST); + + glXSwapBuffers(dpy, win); + + /* calc framerate */ + { + static int t0 = -1; + static int frames = 0; + int t = current_time(); + + if (t0 < 0) + t0 = t; + + frames++; + + if (t - t0 >= 5.0) { + GLfloat seconds = t - t0; + GLfloat fps = frames / seconds; + printf("%d frames in %3.1f seconds = %6.3f FPS\n", frames, seconds, + fps); + t0 = t; + frames = 0; + } + } + } +} + + +int +main(int argc, char *argv[]) +{ + Display *dpy; + Window win; + GLXContext ctx; + char *dpyName = ":0"; + GLboolean printInfo = GL_FALSE; + int i; + + for (i = 1; i < argc; i++) { + if (strcmp(argv[i], "-display") == 0) { + dpyName = argv[i+1]; + i++; + } + else if (strcmp(argv[i], "-info") == 0) { + printInfo = GL_TRUE; + } + } + + dpy = XOpenDisplay(dpyName); + if (!dpy) { + printf("Error: couldn't open display %s\n", dpyName); + return -1; + } + + make_window(dpy, "glxgears", 0, 0, WinWidth, WinHeight, &win, &ctx); + XMapWindow(dpy, win); + glXMakeCurrent(dpy, win, ctx); + + if (printInfo) { + printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER)); + printf("GL_VERSION = %s\n", (char *) glGetString(GL_VERSION)); + printf("GL_VENDOR = %s\n", (char *) glGetString(GL_VENDOR)); + printf("GL_EXTENSIONS = %s\n", (char *) glGetString(GL_EXTENSIONS)); + } + + init(); + + event_loop(dpy, win); + + glXDestroyContext(dpy, ctx); + XDestroyWindow(dpy, win); + XCloseDisplay(dpy); + + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/blendminmax.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/blendminmax.c new file mode 100644 index 000000000..2aab1a39d --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/blendminmax.c @@ -0,0 +1,209 @@ +/* + * (C) Copyright IBM Corporation 2004 + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * on the rights to use, copy, modify, merge, publish, distribute, sub + * license, and/or sell copies of the Software, and to permit persons to whom + * the Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL + * VA LINUX SYSTEM, IBM AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE + * USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +/** + * \file blendminmax.c + * + * Simple test of GL_EXT_blend_minmax functionality. Four squares are drawn + * with different blending modes, but all should be rendered with the same + * final color. + * + * \author Ian Romanick <idr@us.ibm.com> + */ + +#include <stdio.h> +#include <stdlib.h> +#include <GL/glut.h> + +static int Width = 400; +static int Height = 200; +static const GLfloat Near = 5.0, Far = 25.0; + + +static void Display( void ) +{ + glClearColor(0.2, 0.2, 0.8, 0); + glClear( GL_COLOR_BUFFER_BIT ); + + glPushMatrix(); + + /* This is the "reference" square. + */ + + glTranslatef(-4.5, 0, 0); + glBlendEquation( GL_FUNC_ADD ); + glBlendFunc( GL_ONE, GL_ZERO ); + glBegin(GL_QUADS); + glColor3f( 0.5, 0.5, 0.5 ); + glVertex2f(-1, -1); + glVertex2f( 1, -1); + glVertex2f( 1, 1); + glVertex2f(-1, 1); + glEnd(); + + + /* GL_MIN and GL_MAX are supposed to ignore the blend function setting. + * To test that, we set the blend function to GL_ZERO for both color and + * alpha each time GL_MIN or GL_MAX is used. + * + * Apple ships an extension called GL_ATI_blend_weighted_minmax (supported + * on Mac OS X 10.2 and later). I believe the difference with that + * extension is that it uses the blend function. However, I have no idea + * what the enums are for it. The extension is listed at Apple's developer + * site, but there is no documentation. + * + * http://developer.apple.com/opengl/extensions.html + */ + + glTranslatef(3.0, 0, 0); + glBlendEquation( GL_FUNC_ADD ); + glBlendFunc( GL_ONE, GL_ZERO ); + glBegin(GL_QUADS); + glColor3f( 0.5, 0.5, 0.5 ); + glVertex2f(-1, -1); + glVertex2f( 1, -1); + glVertex2f( 1, 1); + glVertex2f(-1, 1); + glEnd(); + + glBlendEquation( GL_MAX ); + glBlendFunc( GL_ZERO, GL_ZERO ); + glBegin(GL_QUADS); + glColor3f( 0.2, 0.2, 0.2 ); + glVertex2f(-1, -1); + glVertex2f( 1, -1); + glVertex2f( 1, 1); + glVertex2f(-1, 1); + glEnd(); + + + glTranslatef(3.0, 0, 0); + glBlendEquation( GL_FUNC_ADD ); + glBlendFunc( GL_ONE, GL_ZERO ); + glBegin(GL_QUADS); + glColor3f( 0.5, 0.5, 0.5 ); + glVertex2f(-1, -1); + glVertex2f( 1, -1); + glVertex2f( 1, 1); + glVertex2f(-1, 1); + glEnd(); + + glBlendEquation( GL_MIN ); + glBlendFunc( GL_ZERO, GL_ZERO ); + glBegin(GL_QUADS); + glColor3f( 0.8, 0.8, 0.8 ); + glVertex2f(-1, -1); + glVertex2f( 1, -1); + glVertex2f( 1, 1); + glVertex2f(-1, 1); + glEnd(); + + + glTranslatef(3.0, 0, 0); + glBlendEquation( GL_FUNC_ADD ); + glBlendFunc( GL_ONE, GL_ZERO ); + glBegin(GL_QUADS); + glColor3f( 0.8, 0.8, 0.8 ); + glVertex2f(-1, -1); + glVertex2f( 1, -1); + glVertex2f( 1, 1); + glVertex2f(-1, 1); + glEnd(); + + glBlendEquation( GL_MIN ); + glBlendFunc( GL_ZERO, GL_ZERO ); + glBegin(GL_QUADS); + glColor3f( 0.5, 0.5, 0.5 ); + glVertex2f(-1, -1); + glVertex2f( 1, -1); + glVertex2f( 1, 1); + glVertex2f(-1, 1); + glEnd(); + + glPopMatrix(); + + glutSwapBuffers(); +} + + +static void Reshape( int width, int height ) +{ + GLfloat ar = (float) width / (float) height; + Width = width; + Height = height; + glViewport( 0, 0, width, height ); + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glFrustum( -ar, ar, -1.0, 1.0, Near, Far ); + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); + glTranslatef( 0.0, 0.0, -15.0 ); +} + + +static void Key( unsigned char key, int x, int y ) +{ + (void) x; + (void) y; + switch (key) { + case 27: + exit(0); + break; + } + glutPostRedisplay(); +} + + +static void Init( void ) +{ + const char * const ver_string = (const char * const) + glGetString( GL_VERSION ); + + printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER)); + printf("GL_VERSION = %s\n", ver_string); + + if ( !glutExtensionSupported("GL_ARB_imaging") && !glutExtensionSupported("GL_EXT_blend_minmax")) { + printf("Sorry, this program requires either GL_ARB_imaging or GL_EXT_blend_minmax.\n"); + exit(1); + } + + printf("\nAll 4 squares should be the same color.\n"); + glEnable( GL_BLEND ); +} + + +int main( int argc, char *argv[] ) +{ + glutInit( &argc, argv ); + glutInitWindowPosition( 0, 0 ); + glutInitWindowSize( Width, Height ); + glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE ); + glutCreateWindow( "GL_EXT_blend_minmax test" ); + glutReshapeFunc( Reshape ); + glutKeyboardFunc( Key ); + glutDisplayFunc( Display ); + Init(); + glutMainLoop(); + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/blendsquare.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/blendsquare.c new file mode 100644 index 000000000..1694866a5 --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/blendsquare.c @@ -0,0 +1,178 @@ +/* + * (C) Copyright IBM Corporation 2004 + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * on the rights to use, copy, modify, merge, publish, distribute, sub + * license, and/or sell copies of the Software, and to permit persons to whom + * the Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL + * VA LINUX SYSTEM, IBM AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE + * USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +/** + * \file blendsquare.c + * + * Simple test of GL_NV_blend_square functionality. Four squares are drawn + * with different blending modes, but all should be rendered with the same + * final color. + * + * \author Ian Romanick <idr@us.ibm.com> + */ + +#include <stdio.h> +#include <stdlib.h> +#include <GL/glut.h> + +static int Width = 400; +static int Height = 200; +static const GLfloat Near = 5.0, Far = 25.0; + + +static void Display( void ) +{ + glClearColor(0.2, 0.2, 0.8, 0); + glClear( GL_COLOR_BUFFER_BIT ); + + glPushMatrix(); + + glTranslatef(-4.5, 0, 0); + glBlendFunc( GL_ONE, GL_ZERO ); + glBegin(GL_QUADS); + glColor3f( 0.5 * 0.5, 0.5 * 0.5, 0.5 * 0.5 ); + glVertex2f(-1, -1); + glVertex2f( 1, -1); + glVertex2f( 1, 1); + glVertex2f(-1, 1); + glEnd(); + + + glTranslatef(3.0, 0, 0); + glBlendFunc( GL_ONE, GL_ZERO ); + glBegin(GL_QUADS); + glColor3f( 0.5, 0.5, 0.5 ); + glVertex2f(-1, -1); + glVertex2f( 1, -1); + glVertex2f( 1, 1); + glVertex2f(-1, 1); + glEnd(); + + glBlendFunc( GL_DST_COLOR, GL_ZERO ); + glBegin(GL_QUADS); + glVertex2f(-1, -1); + glVertex2f( 1, -1); + glVertex2f( 1, 1); + glVertex2f(-1, 1); + glEnd(); + + + glTranslatef(3.0, 0, 0); + glBlendFunc( GL_SRC_COLOR, GL_ZERO ); + glBegin(GL_QUADS); + glVertex2f(-1, -1); + glVertex2f( 1, -1); + glVertex2f( 1, 1); + glVertex2f(-1, 1); + glEnd(); + + + glTranslatef(3.0, 0, 0); + glBlendFunc( GL_ONE, GL_ZERO ); + glBegin(GL_QUADS); + glVertex2f(-1, -1); + glVertex2f( 1, -1); + glVertex2f( 1, 1); + glVertex2f(-1, 1); + glEnd(); + + glBlendFunc( GL_ZERO, GL_DST_COLOR ); + glBegin(GL_QUADS); + glVertex2f(-1, -1); + glVertex2f( 1, -1); + glVertex2f( 1, 1); + glVertex2f(-1, 1); + glEnd(); + + glPopMatrix(); + + glutSwapBuffers(); +} + + +static void Reshape( int width, int height ) +{ + GLfloat ar = (float) width / (float) height; + Width = width; + Height = height; + glViewport( 0, 0, width, height ); + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glFrustum( -ar, ar, -1.0, 1.0, Near, Far ); + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); + glTranslatef( 0.0, 0.0, -15.0 ); +} + + +static void Key( unsigned char key, int x, int y ) +{ + (void) x; + (void) y; + switch (key) { + case 27: + exit(0); + break; + } + glutPostRedisplay(); +} + + +static void Init( void ) +{ + const char * const ver_string = (const char * const) + glGetString( GL_VERSION ); + const double version = strtod( ver_string, NULL ); + + printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER)); + printf("GL_VERSION = %s\n", ver_string); + + if ( (version < 1.4) && !glutExtensionSupported("GL_NV_blend_square")) { + printf("Sorry, this program requires either OpenGL 1.4 or GL_NV_blend_square\n"); + exit(1); + } + + printf("\nAll 4 squares should be the same color. The two on the left are drawn\n" + "without NV_blend_square functionality, and the two on the right are drawn\n" + "with NV_blend_square functionality. If the two on the left are dark, but\n" + "the two on the right are not, then NV_blend_square is broken.\n"); + glEnable( GL_BLEND ); + glBlendEquation( GL_FUNC_ADD ); +} + + +int main( int argc, char *argv[] ) +{ + glutInit( &argc, argv ); + glutInitWindowPosition( 0, 0 ); + glutInitWindowSize( Width, Height ); + glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE ); + glutCreateWindow( "GL_NV_blend_square test" ); + glutReshapeFunc( Reshape ); + glutKeyboardFunc( Key ); + glutDisplayFunc( Display ); + Init(); + glutMainLoop(); + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/bufferobj.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/bufferobj.c new file mode 100644 index 000000000..c765d2516 --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/bufferobj.c @@ -0,0 +1,359 @@ +/* + * Test GL_ARB_vertex_buffer_object + * + * Brian Paul + * 16 Sep 2003 + */ + + +#define GL_GLEXT_PROTOTYPES +#include <assert.h> +#include <stdio.h> +#include <stdlib.h> +#include <math.h> +#include <GL/glut.h> + +#define NUM_OBJECTS 10 + +struct object +{ + GLuint BufferID; + GLuint ElementsBufferID; + GLuint NumVerts; + GLuint VertexOffset; + GLuint ColorOffset; + GLuint NumElements; +}; + +static struct object Objects[NUM_OBJECTS]; +static GLuint NumObjects; + +static GLfloat Xrot = 0, Yrot = 0, Zrot = 0; +static GLboolean Anim = GL_TRUE; + + +static void CheckError(int line) +{ + GLenum err = glGetError(); + if (err) { + printf("GL Error 0x%x at line %d\n", (int) err, line); + } +} + + +static void DrawObject( const struct object *obj ) +{ + glBindBufferARB(GL_ARRAY_BUFFER_ARB, obj->BufferID); + glVertexPointer(3, GL_FLOAT, 0, (void *) obj->VertexOffset); + glEnable(GL_VERTEX_ARRAY); + + /* test push/pop attrib */ + /* XXX this leads to a segfault with NVIDIA's 53.36 driver */ +#if 0 + if (1) + { + glPushClientAttrib(GL_CLIENT_VERTEX_ARRAY_BIT); + /*glVertexPointer(3, GL_FLOAT, 0, (void *) (obj->VertexOffset + 10000));*/ + glBindBufferARB(GL_ARRAY_BUFFER_ARB, 999999); + glPopClientAttrib(); + } +#endif + glColorPointer(3, GL_FLOAT, 0, (void *) obj->ColorOffset); + glEnable(GL_COLOR_ARRAY); + + if (obj->NumElements > 0) { + /* indexed arrays */ + glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, obj->ElementsBufferID); + glDrawElements(GL_LINE_LOOP, obj->NumElements, GL_UNSIGNED_INT, NULL); + } + else { + /* non-indexed arrays */ + glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0); + glDrawArrays(GL_LINE_LOOP, 0, obj->NumVerts); + } +} + + +static void Idle( void ) +{ + Zrot = 0.05 * glutGet(GLUT_ELAPSED_TIME); + glutPostRedisplay(); +} + + +static void Display( void ) +{ + int i; + + glClear( GL_COLOR_BUFFER_BIT ); + + for (i = 0; i < NumObjects; i++) { + float x = 5.0 * ((float) i / (NumObjects-1) - 0.5); + glPushMatrix(); + glTranslatef(x, 0, 0); + glRotatef(Xrot, 1, 0, 0); + glRotatef(Yrot, 0, 1, 0); + glRotatef(Zrot, 0, 0, 1); + + DrawObject(Objects + i); + + glPopMatrix(); + } + + CheckError(__LINE__); + glutSwapBuffers(); +} + + +static void Reshape( int width, int height ) +{ + float ar = (float) width / (float) height; + glViewport( 0, 0, width, height ); + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glFrustum( -ar, ar, -1.0, 1.0, 5.0, 25.0 ); + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); + glTranslatef( 0.0, 0.0, -15.0 ); +} + + +static void Key( unsigned char key, int x, int y ) +{ + const GLfloat step = 3.0; + (void) x; + (void) y; + switch (key) { + case 'a': + Anim = !Anim; + if (Anim) + glutIdleFunc(Idle); + else + glutIdleFunc(NULL); + break; + case 'z': + Zrot -= step; + break; + case 'Z': + Zrot += step; + break; + case 27: + exit(0); + break; + } + glutPostRedisplay(); +} + + +static void SpecialKey( int key, int x, int y ) +{ + const GLfloat step = 3.0; + (void) x; + (void) y; + switch (key) { + case GLUT_KEY_UP: + Xrot -= step; + break; + case GLUT_KEY_DOWN: + Xrot += step; + break; + case GLUT_KEY_LEFT: + Yrot -= step; + break; + case GLUT_KEY_RIGHT: + Yrot += step; + break; + } + glutPostRedisplay(); +} + + + +static void MakeObject1(struct object *obj) +{ + GLfloat *v, *c; + void *p; + int i; + GLubyte buffer[500]; + + for (i = 0; i < 500; i++) + buffer[i] = i & 0xff; + + obj->BufferID = 0; + glGenBuffersARB(1, &obj->BufferID); + assert(obj->BufferID != 0); + glBindBufferARB(GL_ARRAY_BUFFER_ARB, obj->BufferID); + glBufferDataARB(GL_ARRAY_BUFFER_ARB, 500, buffer, GL_STATIC_DRAW_ARB); + + for (i = 0; i < 500; i++) + buffer[i] = 0; + + glGetBufferSubDataARB(GL_ARRAY_BUFFER_ARB, 0, 500, buffer); + + for (i = 0; i < 500; i++) + assert(buffer[i] == (i & 0xff)); + + glGetBufferParameterivARB(GL_ARRAY_BUFFER_ARB, GL_BUFFER_MAPPED_ARB, &i); + assert(!i); + + glGetBufferParameterivARB(GL_ARRAY_BUFFER_ARB, GL_BUFFER_USAGE_ARB, &i); + + v = (GLfloat *) glMapBufferARB(GL_ARRAY_BUFFER_ARB, GL_WRITE_ONLY_ARB); + + /* do some sanity tests */ + glGetBufferPointervARB(GL_ARRAY_BUFFER_ARB, GL_BUFFER_MAP_POINTER_ARB, &p); + assert(p == v); + + glGetBufferParameterivARB(GL_ARRAY_BUFFER_ARB, GL_BUFFER_SIZE_ARB, &i); + assert(i == 500); + + glGetBufferParameterivARB(GL_ARRAY_BUFFER_ARB, GL_BUFFER_USAGE_ARB, &i); + assert(i == GL_STATIC_DRAW_ARB); + + glGetBufferParameterivARB(GL_ARRAY_BUFFER_ARB, GL_BUFFER_ACCESS_ARB, &i); + assert(i == GL_WRITE_ONLY_ARB); + + glGetBufferParameterivARB(GL_ARRAY_BUFFER_ARB, GL_BUFFER_MAPPED_ARB, &i); + assert(i); + + /* Make rectangle */ + v[0] = -1; v[1] = -1; v[2] = 0; + v[3] = 1; v[4] = -1; v[5] = 0; + v[6] = 1; v[7] = 1; v[8] = 0; + v[9] = -1; v[10] = 1; v[11] = 0; + c = v + 12; + c[0] = 1; c[1] = 0; c[2] = 0; + c[3] = 1; c[4] = 0; c[5] = 0; + c[6] = 1; c[7] = 0; c[8] = 1; + c[9] = 1; c[10] = 0; c[11] = 1; + obj->NumVerts = 4; + obj->VertexOffset = 0; + obj->ColorOffset = 3 * sizeof(GLfloat) * obj->NumVerts; + obj->NumElements = 0; + + glUnmapBufferARB(GL_ARRAY_BUFFER_ARB); + + glGetBufferPointervARB(GL_ARRAY_BUFFER_ARB, GL_BUFFER_MAP_POINTER_ARB, &p); + assert(!p); + + glGetBufferParameterivARB(GL_ARRAY_BUFFER_ARB, GL_BUFFER_MAPPED_ARB, &i); + assert(!i); +} + + +static void MakeObject2(struct object *obj) +{ + GLfloat *v, *c; + + glGenBuffersARB(1, &obj->BufferID); + glBindBufferARB(GL_ARRAY_BUFFER_ARB, obj->BufferID); + glBufferDataARB(GL_ARRAY_BUFFER_ARB, 1000, NULL, GL_STATIC_DRAW_ARB); + v = (GLfloat *) glMapBufferARB(GL_ARRAY_BUFFER_ARB, GL_WRITE_ONLY_ARB); + + /* Make triangle */ + v[0] = -1; v[1] = -1; v[2] = 0; + v[3] = 1; v[4] = -1; v[5] = 0; + v[6] = 0; v[7] = 1; v[8] = 0; + c = v + 9; + c[0] = 0; c[1] = 1; c[2] = 0; + c[3] = 0; c[4] = 1; c[5] = 0; + c[6] = 1; c[7] = 1; c[8] = 0; + obj->NumVerts = 3; + obj->VertexOffset = 0; + obj->ColorOffset = 3 * sizeof(GLfloat) * obj->NumVerts; + obj->NumElements = 0; + + glUnmapBufferARB(GL_ARRAY_BUFFER_ARB); +} + + +static void MakeObject3(struct object *obj) +{ + GLfloat vertexData[1000]; + GLfloat *v, *c; + GLuint *i; + int bytes; + + /* Make rectangle */ + v = vertexData; + v[0] = -1; v[1] = -0.5; v[2] = 0; + v[3] = 1; v[4] = -0.5; v[5] = 0; + v[6] = 1; v[7] = 0.5; v[8] = 0; + v[9] = -1; v[10] = 0.5; v[11] = 0; + c = vertexData + 12; + c[0] = 0; c[1] = 0; c[2] = 1; + c[3] = 0; c[4] = 0; c[5] = 1; + c[6] = 0; c[7] = 1; c[8] = 1; + c[9] = 0; c[10] = 1; c[11] = 1; + obj->NumVerts = 4; + obj->VertexOffset = 0; + obj->ColorOffset = 3 * sizeof(GLfloat) * obj->NumVerts; + + bytes = obj->NumVerts * (3 + 3) * sizeof(GLfloat); + + /* Don't use glMap/UnmapBuffer for this object */ + glGenBuffersARB(1, &obj->BufferID); + glBindBufferARB(GL_ARRAY_BUFFER_ARB, obj->BufferID); + glBufferDataARB(GL_ARRAY_BUFFER_ARB, bytes, vertexData, GL_STATIC_DRAW_ARB); + + /* Setup a buffer of indices to test the ELEMENTS path */ + glGenBuffersARB(1, &obj->ElementsBufferID); + glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, obj->ElementsBufferID); + glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 100, NULL, GL_STATIC_DRAW_ARB); + i = (GLuint *) glMapBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, GL_READ_WRITE_ARB); + i[0] = 0; + i[1] = 1; + i[2] = 2; + i[3] = 3; + glUnmapBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB); + obj->NumElements = 4; +} + + + +static void Init( void ) +{ + if (!glutExtensionSupported("GL_ARB_vertex_buffer_object")) { + printf("GL_ARB_vertex_buffer_object not found!\n"); + exit(0); + } + printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER)); + + /* Test buffer object deletion */ + if (1) { + static GLubyte data[1000]; + GLuint id = 999; + glBindBufferARB(GL_ARRAY_BUFFER_ARB, id); + glBufferDataARB(GL_ARRAY_BUFFER_ARB, 1000, data, GL_STATIC_DRAW_ARB); + glVertexPointer(3, GL_FLOAT, 0, (void *) 0); + glDeleteBuffersARB(1, &id); + assert(!glIsBufferARB(id)); + glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0); + glVertexPointer(3, GL_FLOAT, 0, (void *) 0); + assert(!glIsBufferARB(id)); + } + + MakeObject1(Objects + 0); + MakeObject2(Objects + 1); + MakeObject3(Objects + 2); + NumObjects = 3; +} + + +int main( int argc, char *argv[] ) +{ + glutInit( &argc, argv ); + glutInitWindowPosition( 0, 0 ); + glutInitWindowSize( 600, 300 ); + glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE ); + glutCreateWindow(argv[0]); + glutReshapeFunc( Reshape ); + glutKeyboardFunc( Key ); + glutSpecialFunc( SpecialKey ); + glutDisplayFunc( Display ); + if (Anim) + glutIdleFunc(Idle); + Init(); + glutMainLoop(); + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/bug_3101.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/bug_3101.c new file mode 100644 index 000000000..761dcbb95 --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/bug_3101.c @@ -0,0 +1,128 @@ +/* + * (C) Copyright IBM Corporation 2005 + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * on the rights to use, copy, modify, merge, publish, distribute, sub + * license, and/or sell copies of the Software, and to permit persons to whom + * the Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL + * VA LINUX SYSTEM, IBM AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE + * USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +/** + * \file bug_3101.c + * + * Simple regression test for bug #3101. Attempt to draw a single square. + * After emiting the first vertex, call \c glEdgeFlag to change the vertex + * format. If the bug still exists, this will cause a segfault. + * + * \author Ian Romanick <idr@us.ibm.com> + */ + +#include <stdio.h> +#include <stdlib.h> +#include <GL/glut.h> + +static int Width = 400; +static int Height = 200; +static const GLfloat Near = 5.0, Far = 25.0; + + +static void Display( void ) +{ + glClearColor(0.2, 0.2, 0.8, 0); + glClear( GL_COLOR_BUFFER_BIT ); + + glPushMatrix(); + + /* This is the "reference" square. + */ + + glTranslatef(-4.5, 0, 0); + glBlendEquation( GL_FUNC_ADD ); + glBlendFunc( GL_ONE, GL_ZERO ); + glBegin(GL_QUADS); + glColor3f( 0.5, 0.5, 0.5 ); + glVertex2f(-1, -1); + glVertex2f( 1, -1); + glEdgeFlag(GL_TRUE); + glVertex2f( 1, 1); + glVertex2f(-1, 1); + glEnd(); + + glPopMatrix(); + + glutSwapBuffers(); +} + + +static void Reshape( int width, int height ) +{ + GLfloat ar = (float) width / (float) height; + Width = width; + Height = height; + glViewport( 0, 0, width, height ); + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glFrustum( -ar, ar, -1.0, 1.0, Near, Far ); + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); + glTranslatef( 0.0, 0.0, -15.0 ); +} + + +static void Key( unsigned char key, int x, int y ) +{ + (void) x; + (void) y; + switch (key) { + case 27: + exit(0); + break; + } + glutPostRedisplay(); +} + + +static void Init( void ) +{ + const char * const ver_string = (const char * const) + glGetString( GL_VERSION ); + + printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER)); + printf("GL_VERSION = %s\n", ver_string); + + printf("\nThis program should draw a single square, but not crash.\n"); + printf("This is a regression test for bug #3101.\n"); + printf("https://bugs.freedesktop.org/show_bug.cgi?id=3101\n"); + glEnable( GL_BLEND ); +} + + +int main( int argc, char *argv[] ) +{ + glutInit( &argc, argv ); + glutInitWindowPosition( 0, 0 ); + glutInitWindowSize( Width, Height ); + glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE ); + glutCreateWindow( "Bug #3101 Test" ); + glutReshapeFunc( Reshape ); + glutKeyboardFunc( Key ); + glutDisplayFunc( Display ); + Init(); + glutMainLoop(); + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/bug_3195.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/bug_3195.c new file mode 100644 index 000000000..75de58b07 --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/bug_3195.c @@ -0,0 +1,275 @@ +/* + * Copyright (C) 2000 Brian Paul All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +/** + * \file bug_3195.c + * + * Simple regression test for bug #3195. A bug in the i180 driver caused + * a segfault (inside the driver) when the LOD bias is adjusted and no texture + * is enabled. This test, which is based on progs/demos/lodbias.c, sets up + * all the texturing, disables all textures, adjusts the LOD bias, then + * re-enables \c GL_TEXTURE_2D. + * + * \author Brian Paul + * \author Ian Romanick <idr@us.ibm.com> + */ + +#include <assert.h> +#include <stdlib.h> +#include <stdio.h> +#include <math.h> +#include <GL/glut.h> +#include <GL/glext.h> + +#include "readtex.h" + +#define TEXTURE_FILE "../images/girl.rgb" + +static GLfloat Xrot = 0, Yrot = -30, Zrot = 0; +static GLint Bias = 0, BiasStepSign = +1; /* ints avoid fp precision problem */ +static GLint BiasMin = -400, BiasMax = 400; + + + +static void +PrintString(const char *s) +{ + while (*s) { + glutBitmapCharacter(GLUT_BITMAP_8_BY_13, (int) *s); + s++; + } +} + +static void Idle( void ) +{ + static int lastTime = 0; + int time = glutGet(GLUT_ELAPSED_TIME); + int step; + + if (lastTime == 0) + lastTime = time; + else if (time - lastTime < 10) + return; + + step = (time - lastTime) / 10 * BiasStepSign; + lastTime = time; + + Bias += step; + if (Bias < BiasMin) { + exit(0); + } + else if (Bias > BiasMax) { + Bias = BiasMax; + BiasStepSign = -1; + } + + glutPostRedisplay(); +} + + +static void Display( void ) +{ + char str[100]; + + glClear( GL_COLOR_BUFFER_BIT ); + + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glOrtho(-1, 1, -1, 1, -1, 1); + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); + + glDisable(GL_TEXTURE_2D); + glColor3f(1,1,1); + glRasterPos3f(-0.9, -0.9, 0.0); + sprintf(str, "Texture LOD Bias = %4.1f", Bias * 0.01); + PrintString(str); + + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glFrustum( -1.0, 1.0, -1.0, 1.0, 5.0, 25.0 ); + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); + glTranslatef( 0.0, 0.0, -8.0 ); + + glPushMatrix(); + glRotatef(Xrot, 1, 0, 0); + glRotatef(Yrot, 0, 1, 0); + glRotatef(Zrot, 0, 0, 1); + + glTexEnvf(GL_TEXTURE_FILTER_CONTROL_EXT, GL_TEXTURE_LOD_BIAS_EXT, 0.01 * Bias); + glEnable(GL_TEXTURE_2D); + + glBegin(GL_POLYGON); + glTexCoord2f(0, 0); glVertex2f(-1, -1); + glTexCoord2f(2, 0); glVertex2f( 1, -1); + glTexCoord2f(2, 2); glVertex2f( 1, 1); + glTexCoord2f(0, 2); glVertex2f(-1, 1); + glEnd(); + + glPopMatrix(); + + glutSwapBuffers(); +} + + +static void Reshape( int width, int height ) +{ + glViewport( 0, 0, width, height ); +} + + +static void Key( unsigned char key, int x, int y ) +{ + (void) x; + (void) y; + switch (key) { + case 27: + exit(0); + break; + } + glutPostRedisplay(); +} + + +static void SpecialKey( int key, int x, int y ) +{ + const GLfloat step = 3.0; + (void) x; + (void) y; + switch (key) { + case GLUT_KEY_UP: + Xrot -= step; + break; + case GLUT_KEY_DOWN: + Xrot += step; + break; + case GLUT_KEY_LEFT: + Yrot -= step; + break; + case GLUT_KEY_RIGHT: + Yrot += step; + break; + } + glutPostRedisplay(); +} + + +static void Init( void ) +{ + GLfloat maxBias; + const char * const ver_string = (const char * const) + glGetString( GL_VERSION ); + + printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER)); + printf("GL_VERSION = %s\n", ver_string); + + printf("\nThis program should function nearly identically to Mesa's lodbias demo.\n" + "It should cycle through the complet LOD bias range once and exit. If bug\n" + "#3195 still exists, the demo should crash almost immediatly.\n"); + printf("This is a regression test for bug #3101.\n"); + printf("https://bugs.freedesktop.org/show_bug.cgi?id=3101\n"); + + if (!glutExtensionSupported("GL_EXT_texture_lod_bias")) { + printf("Sorry, GL_EXT_texture_lod_bias not supported by this renderer.\n"); + exit(1); + } + + glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + + if (glutExtensionSupported("GL_SGIS_generate_mipmap")) { + /* test auto mipmap generation */ + GLint width, height, i; + GLenum format; + GLubyte *image = LoadRGBImage(TEXTURE_FILE, &width, &height, &format); + if (!image) { + printf("Error: could not load texture image %s\n", TEXTURE_FILE); + exit(1); + } + /* resize to 256 x 256 */ + if (width != 256 || height != 256) { + GLubyte *newImage = malloc(256 * 256 * 4); + gluScaleImage(format, width, height, GL_UNSIGNED_BYTE, image, + 256, 256, GL_UNSIGNED_BYTE, newImage); + free(image); + image = newImage; + } + printf("Using GL_SGIS_generate_mipmap\n"); + glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP_SGIS, GL_TRUE); + glTexImage2D(GL_TEXTURE_2D, 0, format, 256, 256, 0, + format, GL_UNSIGNED_BYTE, image); + free(image); + + /* make sure mipmap was really generated correctly */ + width = height = 256; + for (i = 0; i < 9; i++) { + GLint w, h; + glGetTexLevelParameteriv(GL_TEXTURE_2D, i, GL_TEXTURE_WIDTH, &w); + glGetTexLevelParameteriv(GL_TEXTURE_2D, i, GL_TEXTURE_HEIGHT, &h); + printf("Level %d size: %d x %d\n", i, w, h); + assert(w == width); + assert(h == height); + width /= 2; + height /= 2; + } + + } + else if (!LoadRGBMipmaps(TEXTURE_FILE, GL_RGB)) { + printf("Error: could not load texture image %s\n", TEXTURE_FILE); + exit(1); + } + + /* mipmapping required for this extension */ + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); + + glGetFloatv(GL_MAX_TEXTURE_LOD_BIAS_EXT, &maxBias); + printf("LOD bias range: [%g, %g]\n", -maxBias, maxBias); + BiasMin = -100 * maxBias; + BiasMax = 100 * maxBias; + + /* Since we have (about) 8 mipmap levels, no need to bias beyond + * the range [-1, +8]. + */ + if (BiasMin < -100) + BiasMin = -100; + if (BiasMax > 800) + BiasMax = 800; +} + + +int main( int argc, char *argv[] ) +{ + glutInit( &argc, argv ); + glutInitWindowPosition( 0, 0 ); + glutInitWindowSize( 350, 350 ); + glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE ); + glutCreateWindow( "Bug #3195 Test" ); + glutReshapeFunc( Reshape ); + glutKeyboardFunc( Key ); + glutSpecialFunc( SpecialKey ); + glutDisplayFunc( Display ); + glutIdleFunc(Idle); + Init(); + glutMainLoop(); + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/crossbar.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/crossbar.c new file mode 100644 index 000000000..12aabb1c9 --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/crossbar.c @@ -0,0 +1,235 @@ +/* + * (C) Copyright IBM Corporation 2005 + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * on the rights to use, copy, modify, merge, publish, distribute, sub + * license, and/or sell copies of the Software, and to permit persons to whom + * the Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL + * VA LINUX SYSTEM, IBM AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE + * USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +/** + * \file crossbar.c + * + * Simple test of GL_ARB_texture_env_crossbar functionality. Several squares + * are drawn with different texture combine modes, but all should be rendered + * with the same final color. + * + * \author Ian Romanick <idr@us.ibm.com> + */ + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <GL/glut.h> + +static const GLint tests[][8] = { + { 1, GL_REPLACE, GL_PRIMARY_COLOR, GL_PRIMARY_COLOR, + 2, GL_REPLACE, GL_TEXTURE, GL_PRIMARY_COLOR }, + { 3, GL_REPLACE, GL_PRIMARY_COLOR, GL_PRIMARY_COLOR, + 2, GL_SUBTRACT, GL_TEXTURE0, GL_TEXTURE1 }, + { 2, GL_REPLACE, GL_PRIMARY_COLOR, GL_PRIMARY_COLOR, + 2, GL_REPLACE, GL_TEXTURE0, GL_TEXTURE0 }, + { 2, GL_REPLACE, GL_PRIMARY_COLOR, GL_PRIMARY_COLOR, + 1, GL_SUBTRACT, GL_TEXTURE0, GL_TEXTURE1 }, + { 3, GL_ADD, GL_TEXTURE1, GL_TEXTURE1, + 2, GL_MODULATE, GL_TEXTURE1, GL_PREVIOUS }, + { 3, GL_ADD, GL_TEXTURE1, GL_TEXTURE1, + 4, GL_MODULATE, GL_TEXTURE0, GL_PREVIOUS }, +}; + +#define NUM_TESTS (sizeof(tests) / sizeof(tests[0])) + +static int Width = 100 * (NUM_TESTS + 1); +static int Height = 200; +static const GLfloat Near = 5.0, Far = 25.0; + + +static void Display( void ) +{ + unsigned i; + + + glClearColor(0.2, 0.2, 0.8, 0); + glClear( GL_COLOR_BUFFER_BIT ); + + glPushMatrix(); + + /* This is the "reference" square. + */ + + glActiveTexture( GL_TEXTURE0 ); + glDisable( GL_TEXTURE_2D ); + glActiveTexture( GL_TEXTURE1 ); + glDisable( GL_TEXTURE_2D ); + + glTranslatef(-(NUM_TESTS * 1.5), 0, 0); + glBegin(GL_QUADS); + glColor3f( 0.5, 0.5, 0.5 ); + glVertex2f(-1, -1); + glVertex2f( 1, -1); + glVertex2f( 1, 1); + glVertex2f(-1, 1); + glEnd(); + + for ( i = 0 ; i < NUM_TESTS ; i++ ) { + glActiveTexture( GL_TEXTURE0 ); + glEnable( GL_TEXTURE_2D ); + glBindTexture( GL_TEXTURE_2D, tests[i][0] ); + glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE ); + glTexEnvi( GL_TEXTURE_ENV, GL_COMBINE_RGB, tests[i][1] ); + glTexEnvi( GL_TEXTURE_ENV, GL_SOURCE0_RGB, tests[i][2] ); + glTexEnvi( GL_TEXTURE_ENV, GL_SOURCE1_RGB, tests[i][3] ); + + glActiveTexture( GL_TEXTURE1 ); + glEnable( GL_TEXTURE_2D ); + glBindTexture( GL_TEXTURE_2D, tests[i][4] ); + glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE ); + glTexEnvi( GL_TEXTURE_ENV, GL_COMBINE_RGB, tests[i][5] ); + glTexEnvi( GL_TEXTURE_ENV, GL_SOURCE0_RGB, tests[i][6] ); + glTexEnvi( GL_TEXTURE_ENV, GL_SOURCE1_RGB, tests[i][7] ); + + glCallList(1); + } + + glPopMatrix(); + + glutSwapBuffers(); +} + + +static void Reshape( int width, int height ) +{ + GLfloat ar = (float) width / (float) height; + Width = width; + Height = height; + glViewport( 0, 0, width, height ); + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glFrustum( -ar, ar, -1.0, 1.0, Near, Far ); + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); + glTranslatef( 0.0, 0.0, -15.0 ); +} + + +static void Key( unsigned char key, int x, int y ) +{ + (void) x; + (void) y; + switch (key) { + case 27: + exit(0); + break; + } + glutPostRedisplay(); +} + + +static void Init( void ) +{ + const char * const ver_string = (const char * const) + glGetString( GL_VERSION ); + float ver = strtof( ver_string, NULL ); + GLint tex_units; + GLint temp[ 256 ]; + + + printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER)); + printf("GL_VERSION = %s\n", ver_string); + + if ( (!glutExtensionSupported("GL_ARB_multitexture") + && (ver < 1.3)) + || (!glutExtensionSupported("GL_ARB_texture_env_combine") + && !glutExtensionSupported("GL_EXT_texture_env_combine") + && (ver < 1.3)) + || (!glutExtensionSupported("GL_ARB_texture_env_crossbar") + && !glutExtensionSupported("GL_NV_texture_env_combine4") + && (ver < 1.4)) ) { + printf("\nSorry, this program requires GL_ARB_multitexture and either\n" + "GL_ARB_texture_env_combine or GL_EXT_texture_env_combine (or OpenGL 1.3).\n" + "Either GL_ARB_texture_env_crossbar or GL_NV_texture_env_combine4 (or\n" + "OpenGL 1.4) are also required.\n"); + exit(1); + } + + glGetIntegerv( GL_MAX_TEXTURE_UNITS, & tex_units ); + if ( tex_units < 2 ) { + printf("\nSorry, this program requires at least 2 texture units.\n"); + exit(1); + } + + printf("\nAll %u squares should be the same color.\n", NUM_TESTS + 1); + + (void) memset( temp, 0x00, sizeof( temp ) ); + glBindTexture( GL_TEXTURE_2D, 1 ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST ); + glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, 8, 8, 0, + GL_RGBA, GL_UNSIGNED_BYTE, temp ); + + (void) memset( temp, 0x7f, sizeof( temp ) ); + glBindTexture( GL_TEXTURE_2D, 2 ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST ); + glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, 8, 8, 0, + GL_RGBA, GL_UNSIGNED_BYTE, temp ); + + (void) memset( temp, 0xff, sizeof( temp ) ); + glBindTexture( GL_TEXTURE_2D, 3 ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST ); + glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, 8, 8, 0, + GL_RGBA, GL_UNSIGNED_BYTE, temp ); + + (void) memset( temp, 0x3f, sizeof( temp ) ); + glBindTexture( GL_TEXTURE_2D, 4 ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST ); + glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, 8, 8, 0, + GL_RGBA, GL_UNSIGNED_BYTE, temp ); + + + glNewList( 1, GL_COMPILE ); + glTranslatef(3.0, 0, 0); + glBegin(GL_QUADS); + glColor3f( 0.9, 0.0, 0.0 ); + glMultiTexCoord2f( GL_TEXTURE0, 0.5, 0.5 ); + glMultiTexCoord2f( GL_TEXTURE1, 0.5, 0.5 ); + glVertex2f(-1, -1); + glVertex2f( 1, -1); + glVertex2f( 1, 1); + glVertex2f(-1, 1); + glEnd(); + glEndList(); +} + + +int main( int argc, char *argv[] ) +{ + glutInit( &argc, argv ); + glutInitWindowPosition( 0, 0 ); + glutInitWindowSize( Width, Height ); + glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE ); + glutCreateWindow( "GL_ARB_texture_env_crossbar test" ); + glutReshapeFunc( Reshape ); + glutKeyboardFunc( Key ); + glutDisplayFunc( Display ); + Init(); + glutMainLoop(); + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/cva.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/cva.c new file mode 100644 index 000000000..3f7960f53 --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/cva.c @@ -0,0 +1,164 @@ +/* $Id: cva.c,v 1.7 2003/12/08 09:03:35 joukj Exp $ */ + +/* + * Trivial CVA test, good for testing driver fastpaths (especially + * indexed vertex buffers if they are supported). + * + * Gareth Hughes + * November 2000 + */ + +#include <stdlib.h> +#include <stdio.h> +#include <string.h> +#ifdef __VMS +# include <stddef.h> /* for ptrdiff_t, referenced by GL.h when GL_GLEXT_LEGACY defined */ +#else +# include <malloc.h> /* for ptrdiff_t, referenced by GL.h when GL_GLEXT_LEGACY defined */ +#endif +#ifdef _WIN32 +#include <windows.h> +#endif +#define GL_GLEXT_LEGACY +#include <GL/glut.h> + + +GLfloat verts[][4] = { + { -0.5, -0.5, -2.0, 0.0 }, + { 0.5, -0.5, -2.0, 0.0 }, + { -0.5, 0.5, -2.0, 0.0 }, + { 0.5, 0.5, -2.0, 0.0 }, +}; + +GLubyte color[][4] = { + { 0xff, 0x00, 0x00, 0x00 }, + { 0x00, 0xff, 0x00, 0x00 }, + { 0x00, 0x00, 0xff, 0x00 }, + { 0xff, 0xff, 0xff, 0x00 }, +}; + +GLuint indices[] = { 0, 1, 2, 3 }; + +GLboolean compiled = GL_TRUE; +GLboolean doubleBuffer = GL_TRUE; + + +void init( void ) +{ + glClearColor( 0.0, 0.0, 0.0, 0.0 ); + glShadeModel( GL_SMOOTH ); + + glFrontFace( GL_CCW ); + glCullFace( GL_BACK ); + glEnable( GL_CULL_FACE ); + + glEnable( GL_DEPTH_TEST ); + + glEnableClientState( GL_VERTEX_ARRAY ); + glEnableClientState( GL_COLOR_ARRAY ); + + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glFrustum( -1.0, 1.0, -1.0, 1.0, 2.0, 10.0 ); + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); + + glVertexPointer( 3, GL_FLOAT, sizeof(verts[0]), verts ); + glColorPointer( 4, GL_UNSIGNED_BYTE, 0, color ); + +#ifdef GL_EXT_compiled_vertex_array + if ( compiled ) { + glLockArraysEXT( 0, 4 ); + } +#endif +} + +void display( void ) +{ + glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); + + glDrawElements( GL_TRIANGLES, 3, GL_UNSIGNED_INT, indices ); + + glFlush(); + if ( doubleBuffer ) { + glutSwapBuffers(); + } +} + +void keyboard( unsigned char key, int x, int y ) +{ + switch ( key ) { + case 27: + exit( 0 ); + break; + } + + glutPostRedisplay(); +} + +GLboolean args( int argc, char **argv ) +{ + GLint i; + + doubleBuffer = GL_TRUE; + + 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; + char *string; + + glutInit( &argc, argv ); + + if ( args( argc, argv ) == GL_FALSE ) { + exit( 1 ); + } + + type = GLUT_RGB | GLUT_DEPTH; + type |= ( doubleBuffer ) ? GLUT_DOUBLE : GLUT_SINGLE; + + glutInitDisplayMode( type ); + glutInitWindowSize( 250, 250 ); + glutInitWindowPosition( 100, 100 ); + glutCreateWindow( "CVA Test" ); + + /* Make sure the server supports GL 1.2 vertex arrays. + */ + string = (char *) glGetString( GL_VERSION ); + + if ( !strstr(string, "1.2") && + !strstr(string, "1.3") && + !strstr(string, "1.4")) { + fprintf( stderr, "This program requires OpenGL 1.2 vertex arrays.\n" ); + exit( -1 ); + } + + /* See if the server supports compiled vertex arrays. + */ + string = (char *) glGetString( GL_EXTENSIONS ); + + if ( !strstr( string, "GL_EXT_compiled_vertex_array" ) ) { + fprintf( stderr, "Compiled vertex arrays not supported by this renderer.\n" ); + compiled = GL_FALSE; + } + + init(); + + glutDisplayFunc( display ); + glutKeyboardFunc( keyboard ); + glutMainLoop(); + + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/debugger.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/debugger.c new file mode 100644 index 000000000..4c6955bcf --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/debugger.c @@ -0,0 +1,733 @@ +/* + * Test the GL_MESA_program_debug extension + */ + + +#include <assert.h> +#include <ctype.h> +#include <string.h> +#include <stdio.h> +#include <stdlib.h> +#include <math.h> +#define GL_GLEXT_PROTOTYPES +#include <GL/glut.h> + + +/* + * Print the string with line numbers + */ +static void list_program(const GLubyte *string, GLsizei len) +{ + const char *c = (const char *) string; + int i, line = 1, printNumber = 1; + + for (i = 0; i < len; i++) { + if (printNumber) { + printf("%3d ", line); + printNumber = 0; + } + if (*c == '\n') { + line++; + printNumber = 1; + } + putchar(*c); + c++; + } + putchar('\n'); +} + + +/* + * Return the line number and column number that corresponds to the + * given program position. Also return a null-terminated copy of that + * line of the program string. + */ +static const GLubyte * +find_line_column(const GLubyte *string, const GLubyte *pos, + GLint *line, GLint *col) +{ + const GLubyte *lineStart = string; + const GLubyte *p = string; + GLubyte *s; + int len; + + *line = 1; + + while (p != pos) { + if (*p == (GLubyte) '\n') { + (*line)++; + lineStart = p + 1; + } + p++; + } + + *col = (pos - lineStart) + 1; + + /* return copy of this line */ + while (*p != 0 && *p != '\n') + p++; + len = p - lineStart; + s = (GLubyte *) malloc(len + 1); + memcpy(s, lineStart, len); + s[len] = 0; + + return s; +} + + +#define ARB_VERTEX_PROGRAM 1 +#define ARB_FRAGMENT_PROGRAM 2 +#define NV_VERTEX_PROGRAM 3 +#define NV_FRAGMENT_PROGRAM 4 + + +struct breakpoint { + enum {PIXEL, LINE} type; + int x, y; + int line; + GLboolean enabled; +}; + +#define MAX_BREAKPOINTS 100 +static struct breakpoint Breakpoints[MAX_BREAKPOINTS]; +static int NumBreakpoints = 0; + + + +/* + * Interactive debugger + */ +static void Debugger2(GLenum target, GLvoid *data) +{ + static GLuint skipCount = 0; + const GLubyte *ln; + GLint pos, line, column; + GLint id; + int progType; + GLint len; + GLubyte *program; + GLboolean stop; + int i; + + /* Sigh, GL_VERTEX_PROGRAM_ARB == GL_VERTEX_PROGRAM_NV so it's a bit + * hard to distinguish between them. + */ + if (target == GL_FRAGMENT_PROGRAM_ARB) + progType = ARB_FRAGMENT_PROGRAM; + else if (target == GL_FRAGMENT_PROGRAM_NV) + progType = NV_FRAGMENT_PROGRAM; + else + progType = NV_VERTEX_PROGRAM; + + /* Until we hit zero, continue rendering */ + if (skipCount > 0) { + skipCount--; + return; + } + + /* Get id of the program and current position */ + switch (progType) { + case ARB_FRAGMENT_PROGRAM: + glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_BINDING_ARB, &id); + glGetIntegerv(GL_FRAGMENT_PROGRAM_POSITION_MESA, &pos); + break; + case NV_FRAGMENT_PROGRAM: + glGetIntegerv(GL_FRAGMENT_PROGRAM_BINDING_NV, &id); + glGetIntegerv(GL_FRAGMENT_PROGRAM_POSITION_MESA, &pos); + break; + case ARB_VERTEX_PROGRAM: + glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_BINDING_ARB, &id); + glGetIntegerv(GL_VERTEX_PROGRAM_POSITION_MESA, &pos); + break; + case NV_VERTEX_PROGRAM: + glGetIntegerv(GL_VERTEX_PROGRAM_BINDING_NV, &id); + glGetIntegerv(GL_VERTEX_PROGRAM_POSITION_MESA, &pos); + break; + default: + abort(); + } + + /* get program string */ + if (progType == ARB_VERTEX_PROGRAM || + progType == ARB_FRAGMENT_PROGRAM) + glGetProgramivARB(target, GL_PROGRAM_LENGTH_ARB, &len); + else + glGetProgramivNV(id, GL_PROGRAM_LENGTH_NV, &len); + program = malloc(len + 1); + if (progType == ARB_VERTEX_PROGRAM || + progType == ARB_FRAGMENT_PROGRAM) + glGetProgramStringARB(target, GL_PROGRAM_STRING_ARB, program); + else + glGetProgramStringNV(id, GL_PROGRAM_STRING_NV, program); + + + /* Get current line number, column, line string */ + ln = find_line_column(program, program + pos, &line, &column); + + /* test breakpoints */ + if (NumBreakpoints > 0) + stop = GL_FALSE; + else + stop = GL_TRUE; + for (i = 0; i < NumBreakpoints; i++) { + if (Breakpoints[i].enabled) { + switch (Breakpoints[i].type) { + case PIXEL: + if (progType == ARB_FRAGMENT_PROGRAM) { + + } + else if (progType == NV_FRAGMENT_PROGRAM) { + GLfloat pos[4]; + int px, py; + glGetProgramRegisterfvMESA(GL_FRAGMENT_PROGRAM_NV, + 6, (GLubyte *) "f[WPOS]", pos); + px = (int) pos[0]; + py = (int) pos[1]; + printf("%d, %d\n", px, py); + if (px == Breakpoints[i].x && + py == Breakpoints[i].y) { + printf("Break at pixel (%d, %d)\n", px, py); + stop = GL_TRUE; + } + } + break; + case LINE: + if (line == Breakpoints[i].line) { + /* hit a breakpoint! */ + printf("Break at line %d\n", line); + stop = GL_TRUE; + } + break; + } + } + } + if (!stop) { + free(program); + return; + } + + printf("%d: %s\n", line, ln); + + /* get commands from stdin */ + while (1) { + char command[1000], *cmd; + + /* print prompt and get command */ + printf("(%s %d) ", (target == GL_VERTEX_PROGRAM_ARB ? "vert" : "frag"), + line); + fgets(command, 999, stdin); + + /* skip leading whitespace */ + for (cmd = command; cmd[0] == ' '; cmd++) + ; + + if (!cmd[0]) + /* nothing (repeat the previous cmd?) */ + continue; + + switch (cmd[0]) { + case 's': + /* skip N instructions */ + i = atoi(cmd + 2); + skipCount = i; + printf("Skipping %d instructions\n", i); + return; + case 'n': + /* next */ + return; + case 'c': + return; + case 'd': + /* dump machine state */ + if (progType == NV_FRAGMENT_PROGRAM) { + static const char *inRegs[] = { + "f[WPOS]", "f[COL0]", "f[COL1]", "f[FOGC]", + "f[TEX0]", "f[TEX1]", "f[TEX2]", "f[TEX3]", + NULL + }; + static const char *outRegs[] = { + "o[COLR]", "o[COLH]", "o[DEPR]", NULL + }; + GLfloat v[4]; + int i; + printf("Fragment input attributes:\n"); + for (i = 0; inRegs[i]; i++) { + glGetProgramRegisterfvMESA(GL_FRAGMENT_PROGRAM_NV, + strlen(inRegs[i]), + (const GLubyte *) inRegs[i], v); + printf(" %s: %g, %g, %g, %g\n", inRegs[i], + v[0], v[1], v[2], v[3]); + } + printf("Fragment output attributes:\n"); + for (i = 0; outRegs[i]; i++) { + glGetProgramRegisterfvMESA(GL_FRAGMENT_PROGRAM_NV, + strlen(outRegs[i]), + (const GLubyte *) outRegs[i], v); + printf(" %s: %g, %g, %g, %g\n", outRegs[i], + v[0], v[1], v[2], v[3]); + } + printf("Temporaries:\n"); + for (i = 0; i < 4; i++) { + char temp[100]; + GLfloat v[4]; + sprintf(temp, "R%d", i); + glGetProgramRegisterfvMESA(GL_FRAGMENT_PROGRAM_NV, + strlen(temp), + (const GLubyte *) temp, v); + printf(" %s: %g, %g, %g, %g\n", temp, v[0],v[1],v[2],v[3]); + } + } + else if (progType == NV_VERTEX_PROGRAM) { + GLfloat v[4]; + int i; + static const char *inRegs[] = { + "v[OPOS]", "v[WGHT]", "v[NRML]", "v[COL0]", + "v[COL1]", "v[FOGC]", "v[6]", "v[7]", + "v[TEX0]", "v[TEX1]", "v[TEX2]", "v[TEX3]", + "v[TEX4]", "v[TEX5]", "v[TEX6]", "v[TEX7]", + NULL + }; + static const char *outRegs[] = { + "o[HPOS]", "o[COL0]", "o[COL1]", "o[BFC0]", + "o[BFC1]", "o[FOGC]", "o[PSIZ]", + "o[TEX0]", "o[TEX1]", "o[TEX2]", "o[TEX3]", + "o[TEX4]", "o[TEX5]", "o[TEX6]", "o[TEX7]", + NULL + }; + printf("Vertex input attributes:\n"); + for (i = 0; inRegs[i]; i++) { + glGetProgramRegisterfvMESA(GL_VERTEX_PROGRAM_NV, + strlen(inRegs[i]), + (const GLubyte *) inRegs[i], v); + printf(" %s: %g, %g, %g, %g\n", inRegs[i], + v[0], v[1], v[2], v[3]); + } + printf("Vertex output attributes:\n"); + for (i = 0; outRegs[i]; i++) { + glGetProgramRegisterfvMESA(GL_VERTEX_PROGRAM_NV, + strlen(outRegs[i]), + (const GLubyte *) outRegs[i], v); + printf(" %s: %g, %g, %g, %g\n", outRegs[i], + v[0], v[1], v[2], v[3]); + } + printf("Temporaries:\n"); + for (i = 0; i < 4; i++) { + char temp[100]; + GLfloat v[4]; + sprintf(temp, "R%d", i); + glGetProgramRegisterfvMESA(GL_VERTEX_PROGRAM_NV, + strlen(temp), + (const GLubyte *) temp, v); + printf(" %s: %g, %g, %g, %g\n", temp, v[0],v[1],v[2],v[3]); + } + } + break; + case 'l': + /* list */ + list_program(program, len); + break; + case 'p': + /* print */ + { + GLfloat v[4]; + char *c; + cmd++; + while (*cmd == ' ') + cmd++; + c = cmd; + while (*c) { + if (*c == '\n' || *c == '\r') + *c = 0; + else + c++; + } + glGetProgramRegisterfvMESA(target, strlen(cmd), + (const GLubyte *) cmd, v); + if (glGetError() == GL_NO_ERROR) + printf("%s = %g, %g, %g, %g\n", cmd, v[0], v[1], v[2], v[3]); + else + printf("Invalid expression\n"); + } + break; + case 'b': + if (cmd[1] == ' ' && isdigit(cmd[2])) { + char *comma = strchr(cmd, ','); + if (comma) { + /* break at pixel */ + int x = atoi(cmd + 2); + int y = atoi(comma + 1); + if (NumBreakpoints < MAX_BREAKPOINTS) { + Breakpoints[NumBreakpoints].type = PIXEL; + Breakpoints[NumBreakpoints].x = x; + Breakpoints[NumBreakpoints].y = y; + Breakpoints[NumBreakpoints].enabled = GL_TRUE; + NumBreakpoints++; + printf("Breakpoint %d: break at pixel (%d, %d)\n", + NumBreakpoints, x, y); + } + } + else { + /* break at line */ + int l = atoi(cmd + 2); + if (l && NumBreakpoints < MAX_BREAKPOINTS) { + Breakpoints[NumBreakpoints].type = LINE; + Breakpoints[NumBreakpoints].line = l; + Breakpoints[NumBreakpoints].enabled = GL_TRUE; + NumBreakpoints++; + printf("Breakpoint %d: break at line %d\n", + NumBreakpoints, l); + } + } + } + else { + /* list breakpoints */ + printf("Breakpoints:\n"); + for (i = 0; i < NumBreakpoints; i++) { + switch (Breakpoints[i].type) { + case LINE: + printf(" %d: break at line %d\n", + i + 1, Breakpoints[i].line); + break; + case PIXEL: + printf(" %d: break at pixel (%d, %d)\n", + i + 1, Breakpoints[i].x, Breakpoints[i].y); + break; + } + } + } + break; + case 'h': + /* help */ + printf("Debugger commands:\n"); + printf(" b list breakpoints\n"); + printf(" b N break at line N\n"); + printf(" b x,y break at pixel x,y\n"); + printf(" c continue execution\n"); + printf(" d display register values\n"); + printf(" h help\n"); + printf(" l list program\n"); + printf(" n next instruction\n"); + printf(" p V print value V\n"); + printf(" s N skip N instructions\n"); + break; + default: + printf("Unknown command: %c\n", cmd[0]); + } + } +} + + +/* + * Print current line, some registers, and continue. + */ +static void Debugger(GLenum target, GLvoid *data) +{ + GLint pos; + const GLubyte *ln; + GLint line, column; + GLfloat v[4]; + + assert(target == GL_FRAGMENT_PROGRAM_NV); + + glGetIntegerv(GL_FRAGMENT_PROGRAM_POSITION_MESA, &pos); + + ln = find_line_column((const GLubyte *) data, (const GLubyte *) data + pos, + &line, &column); + printf("%d:%d: %s\n", line, column, (char *) ln); + + glGetProgramRegisterfvMESA(GL_FRAGMENT_PROGRAM_NV, + 2, (const GLubyte *) "R0", v); + printf(" R0 = %g, %g, %g, %g\n", v[0], v[1], v[2], v[3]); + glGetProgramRegisterfvMESA(GL_FRAGMENT_PROGRAM_NV, + 7, (const GLubyte *) "f[WPOS]", v); + printf(" o[WPOS] = %g, %g, %g, %g\n", v[0], v[1], v[2], v[3]); + glGetProgramRegisterfvMESA(GL_FRAGMENT_PROGRAM_NV, + 7, (const GLubyte *) "o[COLR]", v); + printf(" o[COLR] = %g, %g, %g, %g\n", v[0], v[1], v[2], v[3]); + + free((void *) ln); +} + + + + +/**********************************************************************/ + +static GLfloat Diffuse[4] = { 0.5, 0.5, 1.0, 1.0 }; +static GLfloat Specular[4] = { 0.8, 0.8, 0.8, 1.0 }; +static GLfloat LightPos[4] = { 0.0, 10.0, 20.0, 1.0 }; +static GLfloat Delta = 1.0; + +static GLuint FragProg; +static GLuint VertProg; +static GLboolean Anim = GL_TRUE; +static GLboolean Wire = GL_FALSE; +static GLboolean PixelLight = GL_TRUE; + +static GLfloat Xrot = 0, Yrot = 0; + + +#define NAMED_PARAMETER4FV(prog, name, v) \ + glProgramNamedParameter4fvNV(prog, strlen(name), (const GLubyte *) name, v) + + +static void Display( void ) +{ + glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); + + if (PixelLight) { + NAMED_PARAMETER4FV(FragProg, "LightPos", LightPos); + glEnable(GL_FRAGMENT_PROGRAM_NV); + glEnable(GL_VERTEX_PROGRAM_NV); + glDisable(GL_LIGHTING); + } + else { + glLightfv(GL_LIGHT0, GL_POSITION, LightPos); + glDisable(GL_FRAGMENT_PROGRAM_NV); + glDisable(GL_VERTEX_PROGRAM_NV); + glEnable(GL_LIGHTING); + } + + glPushMatrix(); + glRotatef(Xrot, 1, 0, 0); + glRotatef(Yrot, 0, 1, 0); + +#if 1 + glutSolidSphere(2.0, 10, 5); +#else + { + GLUquadricObj *q = gluNewQuadric(); + gluQuadricNormals(q, GL_SMOOTH); + gluQuadricTexture(q, GL_TRUE); + glRotatef(90, 1, 0, 0); + glTranslatef(0, 0, -1); + gluCylinder(q, 1.0, 1.0, 2.0, 24, 1); + gluDeleteQuadric(q); + } +#endif + + glPopMatrix(); + + glutSwapBuffers(); +} + + +static void Idle(void) +{ + LightPos[0] += Delta; + if (LightPos[0] > 25.0) + Delta = -1.0; + else if (LightPos[0] <- 25.0) + Delta = 1.0; + glutPostRedisplay(); +} + + +static void Reshape( int width, int height ) +{ + glViewport( 0, 0, width, height ); + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glFrustum( -1.0, 1.0, -1.0, 1.0, 5.0, 25.0 ); + /*glOrtho( -2.0, 2.0, -2.0, 2.0, 5.0, 25.0 );*/ + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); + glTranslatef( 0.0, 0.0, -15.0 ); +} + + +static void Key( unsigned char key, int x, int y ) +{ + (void) x; + (void) y; + switch (key) { + case ' ': + Anim = !Anim; + if (Anim) + glutIdleFunc(Idle); + else + glutIdleFunc(NULL); + break; + case 'x': + LightPos[0] -= 1.0; + break; + case 'X': + LightPos[0] += 1.0; + break; + case 'w': + Wire = !Wire; + if (Wire) + glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); + else + glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); + break; + case 'p': + PixelLight = !PixelLight; + if (PixelLight) { + printf("Per-pixel lighting\n"); + } + else { + printf("Conventional lighting\n"); + } + break; + case 27: + exit(0); + break; + } + glutPostRedisplay(); +} + +static void SpecialKey( int key, int x, int y ) +{ + const GLfloat step = 3.0; + (void) x; + (void) y; + switch (key) { + case GLUT_KEY_UP: + Xrot -= step; + break; + case GLUT_KEY_DOWN: + Xrot += step; + break; + case GLUT_KEY_LEFT: + Yrot -= step; + break; + case GLUT_KEY_RIGHT: + Yrot += step; + break; + } + glutPostRedisplay(); +} + + +static void Init( int argc, char *argv[] ) +{ + static const char *fragProgramText = + "!!FP1.0\n" + "DECLARE Diffuse; \n" + "DECLARE Specular; \n" + "DECLARE LightPos; \n" + + "# Compute normalized LightPos, put it in R0\n" + "DP3 R0.x, LightPos, LightPos;\n" + "RSQ R0.y, R0.x;\n" + "MUL R0, LightPos, R0.y;\n" + + "# Compute normalized normal, put it in R1\n" + "DP3 R1, f[TEX0], f[TEX0]; \n" + "RSQ R1.y, R1.x;\n" + "MUL R1, f[TEX0], R1.y;\n" + + "# Compute dot product of light direction and normal vector\n" + "DP3 R2, R0, R1;\n" + + "MUL R3, Diffuse, R2; # diffuse attenuation\n" + + "POW R4, R2.x, {20.0}.x; # specular exponent\n" + + "MUL R5, Specular, R4; # specular attenuation\n" + + "ADD o[COLR], R3, R5; # add diffuse and specular colors\n" + "END \n" + ; + + static const char *vertProgramText = + "!!VP1.0\n" + "# typical modelview/projection transform\n" + "DP4 o[HPOS].x, c[0], v[OPOS] ;\n" + "DP4 o[HPOS].y, c[1], v[OPOS] ;\n" + "DP4 o[HPOS].z, c[2], v[OPOS] ;\n" + "DP4 o[HPOS].w, c[3], v[OPOS] ;\n" + "# transform normal by inv transpose of modelview, put in tex0\n" + "DP4 o[TEX0].x, c[4], v[NRML] ;\n" + "DP4 o[TEX0].y, c[5], v[NRML] ;\n" + "DP4 o[TEX0].z, c[6], v[NRML] ;\n" + "DP4 o[TEX0].w, c[7], v[NRML] ;\n" + "END\n"; + ; + + if (!glutExtensionSupported("GL_NV_vertex_program")) { + printf("Sorry, this demo requires GL_NV_vertex_program\n"); + exit(1); + } + if (!glutExtensionSupported("GL_NV_fragment_program")) { + printf("Sorry, this demo requires GL_NV_fragment_program\n"); + exit(1); + } + + glGenProgramsNV(1, &FragProg); + assert(FragProg > 0); + glGenProgramsNV(1, &VertProg); + assert(VertProg > 0); + + /* + * Fragment program + */ + glLoadProgramNV(GL_FRAGMENT_PROGRAM_NV, FragProg, + strlen(fragProgramText), + (const GLubyte *) fragProgramText); + assert(glIsProgramNV(FragProg)); + glBindProgramNV(GL_FRAGMENT_PROGRAM_NV, FragProg); + + NAMED_PARAMETER4FV(FragProg, "Diffuse", Diffuse); + NAMED_PARAMETER4FV(FragProg, "Specular", Specular); + + /* + * Vertex program + */ + glLoadProgramNV(GL_VERTEX_PROGRAM_NV, VertProg, + strlen(vertProgramText), + (const GLubyte *) vertProgramText); + assert(glIsProgramNV(VertProg)); + glBindProgramNV(GL_VERTEX_PROGRAM_NV, VertProg); + glTrackMatrixNV(GL_VERTEX_PROGRAM_NV, 0, GL_MODELVIEW_PROJECTION_NV, GL_IDENTITY_NV); + glTrackMatrixNV(GL_VERTEX_PROGRAM_NV, 4, GL_MODELVIEW, GL_INVERSE_TRANSPOSE_NV); + + /* + * Misc init + */ + glClearColor(0.3, 0.3, 0.3, 0.0); + glEnable(GL_DEPTH_TEST); + glEnable(GL_LIGHT0); + glEnable(GL_LIGHTING); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, Diffuse); + glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, Specular); + glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 20.0); + + printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER)); + printf("Press p to toggle between per-pixel and per-vertex lighting\n"); + +#ifdef GL_MESA_program_debug + if (argc > 1 && strcmp(argv[1], "fragment") == 0) { + printf(">> Debugging fragment program\n"); + glProgramCallbackMESA(GL_FRAGMENT_PROGRAM_ARB, Debugger2, + (GLvoid *) fragProgramText); + glEnable(GL_FRAGMENT_PROGRAM_CALLBACK_MESA); + } + else { + printf(">> Debugging vertex program\n"); + glProgramCallbackMESA(GL_VERTEX_PROGRAM_ARB, Debugger2, + (GLvoid *) fragProgramText); + glEnable(GL_VERTEX_PROGRAM_CALLBACK_MESA); + } +#endif +} + + +int main( int argc, char *argv[] ) +{ + glutInit( &argc, argv ); + glutInitWindowPosition( 0, 0 ); + glutInitWindowSize( 200, 200 ); + glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH ); + glutCreateWindow(argv[0]); + glutReshapeFunc( Reshape ); + glutKeyboardFunc( Key ); + glutSpecialFunc( SpecialKey ); + glutDisplayFunc( Display ); + if (Anim) + glutIdleFunc(Idle); + Init(argc, argv); + glutMainLoop(); + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/descrip.mms b/nx-X11/extras/Mesa_6.4.1/progs/tests/descrip.mms new file mode 100644 index 000000000..b0ff2610d --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/descrip.mms @@ -0,0 +1,84 @@ +# Makefile for GLUT-based demo programs for VMS +# contributed by Jouk Jansen joukj@hrem.stm.tudelft.nl + + +.first + define gl [--.include.gl] + +.include [--]mms-config. + +##### MACROS ##### + +INCDIR = ([--.include],[-.util]) +CFLAGS = /include=$(INCDIR)/prefix=all/name=(as_is,short) + +.ifdef SHARE +GL_LIBS = $(XLIBS) +.else +GL_LIBS = [--.lib]libGLUT/l,libMesaGLU/l,libMesaGL/l,$(XLIBS) +.endif + +LIB_DEP = [--.lib]$(GL_LIB) [--.lib]$(GLU_LIB) [--.lib]$(GLUT_LIB) + +PROGS = cva.exe,\ + dinoshade.exe,\ + fogcoord.exe,\ + manytex.exe,\ + multipal.exe,\ + projtex.exe,\ + seccolor.exe,\ + sharedtex.exe,\ + texline.exe,\ + texwrap.exe,\ + vptest1.exe,\ + vptest2.exe,\ + vptest3.exe,\ + vptorus.exe,\ + vpwarpmesh.exe + +##### RULES ##### +.obj.exe : + cxxlink $(MMS$TARGET_NAME),$(GL_LIBS) + +##### TARGETS ##### +default : + $(MMS)$(MMSQUALIFIERS) $(PROGS) + +clean : + delete *.obj;* + +realclean : + delete $(PROGS) + delete *.obj;* + +cva.exe : cva.obj $(LIB_DEP) +dinoshade.exe : dinoshade.obj $(LIB_DEP) +fogcoord.exe : fogcoord.obj $(LIB_DEP) +manytex.exe : manytex.obj $(LIB_DEP) +multipal.exe : multipal.obj $(LIB_DEP) +projtex.exe : projtex.obj $(LIB_DEP) +seccolor.exe : seccolor.obj $(LIB_DEP) +sharedtex.exe : sharedtex.obj $(LIB_DEP) +texline.exe : texline.obj $(LIB_DEP) +texwrap.exe : texwrap.obj $(LIB_DEP) +vptest1.exe : vptest1.obj $(LIB_DEP) +vptest2.exe : vptest2.obj $(LIB_DEP) +vptest3.exe : vptest3.obj $(LIB_DEP) +vptorus.exe : vptorus.obj $(LIB_DEP) +vpwarpmesh.exe : vpwarpmesh.obj $(LIB_DEP) + +cva.obj : cva.c +dinoshade.obj : dinoshade.c +fogcoord.obj : fogcoord.c +manytex.obj : manytex.c +multipal.obj : multipal.c +projtex.obj : projtex.c +seccolor.obj : seccolor.c +sharedtex.obj : sharedtex.c +texline.obj : texline.c +texwrap.obj : texwrap.c +vptest1.obj : vptest1.c +vptest2.obj : vptest2.c +vptest3.obj : vptest3.c +vptorus.obj : vptorus.c +vpwarpmesh.obj : vpwarpmesh.c diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/dinoshade.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/dinoshade.c new file mode 100644 index 000000000..ed7b879bc --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/dinoshade.c @@ -0,0 +1,914 @@ + +/* Copyright (c) Mark J. Kilgard, 1994, 1997. */ + +/* This program is freely distributable without licensing fees + and is provided without guarantee or warrantee expressed or + implied. This program is -not- in the public domain. */ + +/* Example for PC game developers to show how to *combine* texturing, + reflections, and projected shadows all in real-time with OpenGL. + Robust reflections use stenciling. Robust projected shadows + use both stenciling and polygon offset. PC game programmers + should realize that neither stenciling nor polygon offset are + supported by Direct3D, so these real-time rendering algorithms + are only really viable with OpenGL. + + The program has modes for disabling the stenciling and polygon + offset uses. It is worth running this example with these features + toggled off so you can see the sort of artifacts that result. + + Notice that the floor texturing, reflections, and shadowing + all co-exist properly. */ + +/* When you run this program: Left mouse button controls the + view. Middle mouse button controls light position (left & + right rotates light around dino; up & down moves light + position up and down). Right mouse button pops up menu. */ + +/* Check out the comments in the "redraw" routine to see how the + reflection blending and surface stenciling is done. You can + also see in "redraw" how the projected shadows are rendered, + including the use of stenciling and polygon offset. */ + +/* This program is derived from glutdino.c */ + +/* Compile: cc -o dinoshade dinoshade.c -lglut -lGLU -lGL -lXmu -lXext -lX11 -lm */ + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <math.h> /* for cos(), sin(), and sqrt() */ +#ifdef __VMS +# include <stddef.h> /* for ptrdiff_t, referenced by GL.h when GL_GLEXT_LEGACY defined */ +#else +# include <malloc.h> /* for ptrdiff_t, referenced by GL.h when GL_GLEXT_LEGACY defined */ +#endif +#ifdef _WIN32 +#include <windows.h> +#endif +#define GL_GLEXT_LEGACY +#include <GL/glut.h> /* OpenGL Utility Toolkit header */ + +/* Some <math.h> files do not define M_PI... */ +#ifndef M_PI +#define M_PI 3.14159265358979323846 +#endif + +/* Variable controlling various rendering modes. */ +static int stencilReflection = 1, stencilShadow = 1, offsetShadow = 1; +static int renderShadow = 1, renderDinosaur = 1, renderReflection = 1; +static int linearFiltering = 0, useMipmaps = 0, useTexture = 1; +static int reportSpeed = 0; +static int animation = 1; +static GLboolean lightSwitch = GL_TRUE; +static int directionalLight = 1; +static int forceExtension = 0; + +/* Time varying or user-controled variables. */ +static float jump = 0.0; +static float lightAngle = 0.0, lightHeight = 20; +GLfloat angle = -150; /* in degrees */ +GLfloat angle2 = 30; /* in degrees */ + +int moving, startx, starty; +int lightMoving = 0, lightStartX, lightStartY; + +enum { + MISSING, EXTENSION, ONE_DOT_ONE +}; +int polygonOffsetVersion; + +static GLdouble bodyWidth = 3.0; +/* *INDENT-OFF* */ +static GLfloat body[][2] = { {0, 3}, {1, 1}, {5, 1}, {8, 4}, {10, 4}, {11, 5}, + {11, 11.5}, {13, 12}, {13, 13}, {10, 13.5}, {13, 14}, {13, 15}, {11, 16}, + {8, 16}, {7, 15}, {7, 13}, {8, 12}, {7, 11}, {6, 6}, {4, 3}, {3, 2}, + {1, 2} }; +static GLfloat arm[][2] = { {8, 10}, {9, 9}, {10, 9}, {13, 8}, {14, 9}, {16, 9}, + {15, 9.5}, {16, 10}, {15, 10}, {15.5, 11}, {14.5, 10}, {14, 11}, {14, 10}, + {13, 9}, {11, 11}, {9, 11} }; +static GLfloat leg[][2] = { {8, 6}, {8, 4}, {9, 3}, {9, 2}, {8, 1}, {8, 0.5}, {9, 0}, + {12, 0}, {10, 1}, {10, 2}, {12, 4}, {11, 6}, {10, 7}, {9, 7} }; +static GLfloat eye[][2] = { {8.75, 15}, {9, 14.7}, {9.6, 14.7}, {10.1, 15}, + {9.6, 15.25}, {9, 15.25} }; +static GLfloat lightPosition[4]; +static GLfloat lightColor[] = {0.8, 1.0, 0.8, 1.0}; /* green-tinted */ +static GLfloat skinColor[] = {0.1, 1.0, 0.1, 1.0}, eyeColor[] = {1.0, 0.2, 0.2, 1.0}; +/* *INDENT-ON* */ + +/* Nice floor texture tiling pattern. */ +static char *circles[] = { + "....xxxx........", + "..xxxxxxxx......", + ".xxxxxxxxxx.....", + ".xxx....xxx.....", + "xxx......xxx....", + "xxx......xxx....", + "xxx......xxx....", + "xxx......xxx....", + ".xxx....xxx.....", + ".xxxxxxxxxx.....", + "..xxxxxxxx......", + "....xxxx........", + "................", + "................", + "................", + "................", +}; + +static void +makeFloorTexture(void) +{ + GLubyte floorTexture[16][16][3]; + GLubyte *loc; + int s, t; + + /* Setup RGB image for the texture. */ + loc = (GLubyte*) floorTexture; + for (t = 0; t < 16; t++) { + for (s = 0; s < 16; s++) { + if (circles[t][s] == 'x') { + /* Nice green. */ + loc[0] = 0x1f; + loc[1] = 0x8f; + loc[2] = 0x1f; + } else { + /* Light gray. */ + loc[0] = 0xaa; + loc[1] = 0xaa; + loc[2] = 0xaa; + } + loc += 3; + } + } + + glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + + if (useMipmaps) { + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, + GL_LINEAR_MIPMAP_LINEAR); + gluBuild2DMipmaps(GL_TEXTURE_2D, 3, 16, 16, + GL_RGB, GL_UNSIGNED_BYTE, floorTexture); + } else { + if (linearFiltering) { + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + } else { + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + } + glTexImage2D(GL_TEXTURE_2D, 0, 3, 16, 16, 0, + GL_RGB, GL_UNSIGNED_BYTE, floorTexture); + } +} + +enum { + X, Y, Z, W +}; +enum { + A, B, C, D +}; + +/* Create a matrix that will project the desired shadow. */ +void +shadowMatrix(GLfloat shadowMat[4][4], + GLfloat groundplane[4], + GLfloat lightpos[4]) +{ + GLfloat dot; + + /* Find dot product between light position vector and ground plane normal. */ + dot = groundplane[X] * lightpos[X] + + groundplane[Y] * lightpos[Y] + + groundplane[Z] * lightpos[Z] + + groundplane[W] * lightpos[W]; + + shadowMat[0][0] = dot - lightpos[X] * groundplane[X]; + shadowMat[1][0] = 0.f - lightpos[X] * groundplane[Y]; + shadowMat[2][0] = 0.f - lightpos[X] * groundplane[Z]; + shadowMat[3][0] = 0.f - lightpos[X] * groundplane[W]; + + shadowMat[X][1] = 0.f - lightpos[Y] * groundplane[X]; + shadowMat[1][1] = dot - lightpos[Y] * groundplane[Y]; + shadowMat[2][1] = 0.f - lightpos[Y] * groundplane[Z]; + shadowMat[3][1] = 0.f - lightpos[Y] * groundplane[W]; + + shadowMat[X][2] = 0.f - lightpos[Z] * groundplane[X]; + shadowMat[1][2] = 0.f - lightpos[Z] * groundplane[Y]; + shadowMat[2][2] = dot - lightpos[Z] * groundplane[Z]; + shadowMat[3][2] = 0.f - lightpos[Z] * groundplane[W]; + + shadowMat[X][3] = 0.f - lightpos[W] * groundplane[X]; + shadowMat[1][3] = 0.f - lightpos[W] * groundplane[Y]; + shadowMat[2][3] = 0.f - lightpos[W] * groundplane[Z]; + shadowMat[3][3] = dot - lightpos[W] * groundplane[W]; + +} + +/* Find the plane equation given 3 points. */ +void +findPlane(GLfloat plane[4], + GLfloat v0[3], GLfloat v1[3], GLfloat v2[3]) +{ + GLfloat vec0[3], vec1[3]; + + /* Need 2 vectors to find cross product. */ + vec0[X] = v1[X] - v0[X]; + vec0[Y] = v1[Y] - v0[Y]; + vec0[Z] = v1[Z] - v0[Z]; + + vec1[X] = v2[X] - v0[X]; + vec1[Y] = v2[Y] - v0[Y]; + vec1[Z] = v2[Z] - v0[Z]; + + /* find cross product to get A, B, and C of plane equation */ + plane[A] = vec0[Y] * vec1[Z] - vec0[Z] * vec1[Y]; + plane[B] = -(vec0[X] * vec1[Z] - vec0[Z] * vec1[X]); + plane[C] = vec0[X] * vec1[Y] - vec0[Y] * vec1[X]; + + plane[D] = -(plane[A] * v0[X] + plane[B] * v0[Y] + plane[C] * v0[Z]); +} + +void +extrudeSolidFromPolygon(GLfloat data[][2], unsigned int dataSize, + GLdouble thickness, GLuint side, GLuint edge, GLuint whole) +{ + static GLUtriangulatorObj *tobj = NULL; + GLdouble vertex[3], dx, dy, len; + int i; + int count = (int) (dataSize / (2 * sizeof(GLfloat))); + + if (tobj == NULL) { + tobj = gluNewTess(); /* create and initialize a GLU + polygon tesselation object */ + gluTessCallback(tobj, GLU_BEGIN, glBegin); + gluTessCallback(tobj, GLU_VERTEX, glVertex2fv); /* semi-tricky */ + gluTessCallback(tobj, GLU_END, glEnd); + } + glNewList(side, GL_COMPILE); + glShadeModel(GL_SMOOTH); /* smooth minimizes seeing + tessellation */ + gluBeginPolygon(tobj); + for (i = 0; i < count; i++) { + vertex[0] = data[i][0]; + vertex[1] = data[i][1]; + vertex[2] = 0; + gluTessVertex(tobj, vertex, data[i]); + } + gluEndPolygon(tobj); + glEndList(); + glNewList(edge, GL_COMPILE); + glShadeModel(GL_FLAT); /* flat shade keeps angular hands + from being "smoothed" */ + glBegin(GL_QUAD_STRIP); + for (i = 0; i <= count; i++) { +#if 1 /* weird, but seems to be legal */ + /* mod function handles closing the edge */ + glVertex3f(data[i % count][0], data[i % count][1], 0.0); + glVertex3f(data[i % count][0], data[i % count][1], thickness); + /* Calculate a unit normal by dividing by Euclidean + distance. We * could be lazy and use + glEnable(GL_NORMALIZE) so we could pass in * arbitrary + normals for a very slight performance hit. */ + dx = data[(i + 1) % count][1] - data[i % count][1]; + dy = data[i % count][0] - data[(i + 1) % count][0]; + len = sqrt(dx * dx + dy * dy); + glNormal3f(dx / len, dy / len, 0.0); +#else /* the nice way of doing it */ + /* Calculate a unit normal by dividing by Euclidean + distance. We * could be lazy and use + glEnable(GL_NORMALIZE) so we could pass in * arbitrary + normals for a very slight performance hit. */ + dx = data[i % count][1] - data[(i - 1 + count) % count][1]; + dy = data[(i - 1 + count) % count][0] - data[i % count][0]; + len = sqrt(dx * dx + dy * dy); + glNormal3f(dx / len, dy / len, 0.0); + /* mod function handles closing the edge */ + glVertex3f(data[i % count][0], data[i % count][1], 0.0); + glVertex3f(data[i % count][0], data[i % count][1], thickness); +#endif + } + glEnd(); + glEndList(); + glNewList(whole, GL_COMPILE); + glFrontFace(GL_CW); + glCallList(edge); + glNormal3f(0.0, 0.0, -1.0); /* constant normal for side */ + glCallList(side); + glPushMatrix(); + glTranslatef(0.0, 0.0, thickness); + glFrontFace(GL_CCW); + glNormal3f(0.0, 0.0, 1.0); /* opposite normal for other side */ + glCallList(side); + glPopMatrix(); + glEndList(); +} + +/* Enumerants for refering to display lists. */ +typedef enum { + RESERVED, BODY_SIDE, BODY_EDGE, BODY_WHOLE, ARM_SIDE, ARM_EDGE, ARM_WHOLE, + LEG_SIDE, LEG_EDGE, LEG_WHOLE, EYE_SIDE, EYE_EDGE, EYE_WHOLE +} displayLists; + +static void +makeDinosaur(void) +{ + extrudeSolidFromPolygon(body, sizeof(body), bodyWidth, + BODY_SIDE, BODY_EDGE, BODY_WHOLE); + extrudeSolidFromPolygon(arm, sizeof(arm), bodyWidth / 4, + ARM_SIDE, ARM_EDGE, ARM_WHOLE); + extrudeSolidFromPolygon(leg, sizeof(leg), bodyWidth / 2, + LEG_SIDE, LEG_EDGE, LEG_WHOLE); + extrudeSolidFromPolygon(eye, sizeof(eye), bodyWidth + 0.2, + EYE_SIDE, EYE_EDGE, EYE_WHOLE); +} + +static void +drawDinosaur(void) + +{ + glPushMatrix(); + /* Translate the dinosaur to be at (0,8,0). */ + glTranslatef(-8, 0, -bodyWidth / 2); + glTranslatef(0.0, jump, 0.0); + glMaterialfv(GL_FRONT, GL_DIFFUSE, skinColor); + glCallList(BODY_WHOLE); + glTranslatef(0.0, 0.0, bodyWidth); + glCallList(ARM_WHOLE); + glCallList(LEG_WHOLE); + glTranslatef(0.0, 0.0, -bodyWidth - bodyWidth / 4); + glCallList(ARM_WHOLE); + glTranslatef(0.0, 0.0, -bodyWidth / 4); + glCallList(LEG_WHOLE); + glTranslatef(0.0, 0.0, bodyWidth / 2 - 0.1); + glMaterialfv(GL_FRONT, GL_DIFFUSE, eyeColor); + glCallList(EYE_WHOLE); + glPopMatrix(); +} + +static GLfloat floorVertices[4][3] = { + { -20.0, 0.0, 20.0 }, + { 20.0, 0.0, 20.0 }, + { 20.0, 0.0, -20.0 }, + { -20.0, 0.0, -20.0 }, +}; + +/* Draw a floor (possibly textured). */ +static void +drawFloor(void) +{ + glDisable(GL_LIGHTING); + + if (useTexture) { + glEnable(GL_TEXTURE_2D); + } + + glBegin(GL_QUADS); + glTexCoord2f(0.0, 0.0); + glVertex3fv(floorVertices[0]); + glTexCoord2f(0.0, 16.0); + glVertex3fv(floorVertices[1]); + glTexCoord2f(16.0, 16.0); + glVertex3fv(floorVertices[2]); + glTexCoord2f(16.0, 0.0); + glVertex3fv(floorVertices[3]); + glEnd(); + + if (useTexture) { + glDisable(GL_TEXTURE_2D); + } + + glEnable(GL_LIGHTING); +} + +static GLfloat floorPlane[4]; +static GLfloat floorShadow[4][4]; + +static void +redraw(void) +{ + int start, end; + + if (reportSpeed) { + start = glutGet(GLUT_ELAPSED_TIME); + } + + /* Clear; default stencil clears to zero. */ + if ((stencilReflection && renderReflection) || (stencilShadow && renderShadow)) { + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); + } else { + /* Avoid clearing stencil when not using it. */ + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + } + + /* Reposition the light source. */ + lightPosition[0] = 12*cos(lightAngle); + lightPosition[1] = lightHeight; + lightPosition[2] = 12*sin(lightAngle); + if (directionalLight) { + lightPosition[3] = 0.0; + } else { + lightPosition[3] = 1.0; + } + + shadowMatrix(floorShadow, floorPlane, lightPosition); + + glPushMatrix(); + /* Perform scene rotations based on user mouse input. */ + glRotatef(angle2, 1.0, 0.0, 0.0); + glRotatef(angle, 0.0, 1.0, 0.0); + + /* Tell GL new light source position. */ + glLightfv(GL_LIGHT0, GL_POSITION, lightPosition); + + if (renderReflection) { + if (stencilReflection) { + /* We can eliminate the visual "artifact" of seeing the "flipped" + dinosaur underneath the floor by using stencil. The idea is + draw the floor without color or depth update but so that + a stencil value of one is where the floor will be. Later when + rendering the dinosaur reflection, we will only update pixels + with a stencil value of 1 to make sure the reflection only + lives on the floor, not below the floor. */ + + /* Don't update color or depth. */ + glDisable(GL_DEPTH_TEST); + glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); + + /* Draw 1 into the stencil buffer. */ + glEnable(GL_STENCIL_TEST); + glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE); + glStencilFunc(GL_ALWAYS, 1, 0xffffffff); + + /* Now render floor; floor pixels just get their stencil set to 1. */ + drawFloor(); + + /* Re-enable update of color and depth. */ + glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); + glEnable(GL_DEPTH_TEST); + + /* Now, only render where stencil is set to 1. */ + glStencilFunc(GL_EQUAL, 1, 0xffffffff); /* draw if ==1 */ + glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP); + } + + glPushMatrix(); + + /* The critical reflection step: Reflect dinosaur through the floor + (the Y=0 plane) to make a relection. */ + glScalef(1.0, -1.0, 1.0); + + /* Reflect the light position. */ + glLightfv(GL_LIGHT0, GL_POSITION, lightPosition); + + /* To avoid our normals getting reversed and hence botched lighting + on the reflection, turn on normalize. */ + glEnable(GL_NORMALIZE); + glCullFace(GL_FRONT); + + /* Draw the reflected dinosaur. */ + drawDinosaur(); + + /* Disable noramlize again and re-enable back face culling. */ + glDisable(GL_NORMALIZE); + glCullFace(GL_BACK); + + glPopMatrix(); + + /* Switch back to the unreflected light position. */ + glLightfv(GL_LIGHT0, GL_POSITION, lightPosition); + + if (stencilReflection) { + glDisable(GL_STENCIL_TEST); + } + } + + /* Back face culling will get used to only draw either the top or the + bottom floor. This let's us get a floor with two distinct + appearances. The top floor surface is reflective and kind of red. + The bottom floor surface is not reflective and blue. */ + + /* Draw "bottom" of floor in blue. */ + glFrontFace(GL_CW); /* Switch face orientation. */ + glColor4f(0.1, 0.1, 0.7, 1.0); + drawFloor(); + glFrontFace(GL_CCW); + + if (renderShadow) { + if (stencilShadow) { + /* Draw the floor with stencil value 3. This helps us only + draw the shadow once per floor pixel (and only on the + floor pixels). */ + glEnable(GL_STENCIL_TEST); + glStencilFunc(GL_ALWAYS, 3, 0xffffffff); + glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE); + } + } + + /* Draw "top" of floor. Use blending to blend in reflection. */ + glEnable(GL_BLEND); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + glColor4f(0.7, 0.0, 0.0, 0.3); + glColor4f(1.0, 1.0, 1.0, 0.3); + drawFloor(); + glDisable(GL_BLEND); + + if (renderDinosaur) { + /* Draw "actual" dinosaur, not its reflection. */ + drawDinosaur(); + } + + if (renderShadow) { + + /* Render the projected shadow. */ + + if (stencilShadow) { + + /* Now, only render where stencil is set above 2 (ie, 3 where + the top floor is). Update stencil with 2 where the shadow + gets drawn so we don't redraw (and accidently reblend) the + shadow). */ + glStencilFunc(GL_LESS, 2, 0xffffffff); /* draw if ==1 */ + glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE); + } + + /* To eliminate depth buffer artifacts, we use polygon offset + to raise the depth of the projected shadow slightly so + that it does not depth buffer alias with the floor. */ + if (offsetShadow) { + switch (polygonOffsetVersion) { + case EXTENSION: +#ifdef GL_EXT_polygon_offset + glEnable(GL_POLYGON_OFFSET_EXT); + break; +#endif +#ifdef GL_VERSION_1_1 + case ONE_DOT_ONE: + glEnable(GL_POLYGON_OFFSET_FILL); + break; +#endif + case MISSING: + /* Oh well. */ + break; + } + } + + /* Render 50% black shadow color on top of whatever the + floor appareance is. */ + glEnable(GL_BLEND); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + glDisable(GL_LIGHTING); /* Force the 50% black. */ + glColor4f(0.0, 0.0, 0.0, 0.5); + + glPushMatrix(); + /* Project the shadow. */ + glMultMatrixf((GLfloat *) floorShadow); + drawDinosaur(); + glPopMatrix(); + + glDisable(GL_BLEND); + glEnable(GL_LIGHTING); + + if (offsetShadow) { + switch (polygonOffsetVersion) { +#ifdef GL_EXT_polygon_offset + case EXTENSION: + glDisable(GL_POLYGON_OFFSET_EXT); + break; +#endif +#ifdef GL_VERSION_1_1 + case ONE_DOT_ONE: + glDisable(GL_POLYGON_OFFSET_FILL); + break; +#endif + case MISSING: + /* Oh well. */ + break; + } + } + if (stencilShadow) { + glDisable(GL_STENCIL_TEST); + } + } + + glPushMatrix(); + glDisable(GL_LIGHTING); + glColor3f(1.0, 1.0, 0.0); + if (directionalLight) { + /* Draw an arrowhead. */ + glDisable(GL_CULL_FACE); + glTranslatef(lightPosition[0], lightPosition[1], lightPosition[2]); + glRotatef(lightAngle * -180.0 / M_PI, 0, 1, 0); + glRotatef(atan(lightHeight/12) * 180.0 / M_PI, 0, 0, 1); + glBegin(GL_TRIANGLE_FAN); + glVertex3f(0, 0, 0); + glVertex3f(2, 1, 1); + glVertex3f(2, -1, 1); + glVertex3f(2, -1, -1); + glVertex3f(2, 1, -1); + glVertex3f(2, 1, 1); + glEnd(); + /* Draw a white line from light direction. */ + glColor3f(1.0, 1.0, 1.0); + glBegin(GL_LINES); + glVertex3f(0, 0, 0); + glVertex3f(5, 0, 0); + glEnd(); + glEnable(GL_CULL_FACE); + } else { + /* Draw a yellow ball at the light source. */ + glTranslatef(lightPosition[0], lightPosition[1], lightPosition[2]); + glutSolidSphere(1.0, 5, 5); + } + glEnable(GL_LIGHTING); + glPopMatrix(); + + glPopMatrix(); + + if (reportSpeed) { + glFinish(); + end = glutGet(GLUT_ELAPSED_TIME); + printf("Speed %.3g frames/sec (%d ms)\n", 1000.0/(end-start), end-start); + } + + glutSwapBuffers(); +} + +/* ARGSUSED2 */ +static void +mouse(int button, int state, int x, int y) +{ + if (button == GLUT_LEFT_BUTTON) { + if (state == GLUT_DOWN) { + moving = 1; + startx = x; + starty = y; + } + if (state == GLUT_UP) { + moving = 0; + } + } + if (button == GLUT_MIDDLE_BUTTON) { + if (state == GLUT_DOWN) { + lightMoving = 1; + lightStartX = x; + lightStartY = y; + } + if (state == GLUT_UP) { + lightMoving = 0; + } + } +} + +/* ARGSUSED1 */ +static void +motion(int x, int y) +{ + if (moving) { + angle = angle + (x - startx); + angle2 = angle2 + (y - starty); + startx = x; + starty = y; + glutPostRedisplay(); + } + if (lightMoving) { + lightAngle += (x - lightStartX)/40.0; + lightHeight += (lightStartY - y)/20.0; + lightStartX = x; + lightStartY = y; + glutPostRedisplay(); + } +} + +/* Advance time varying state when idle callback registered. */ +static void +idle(void) +{ + static float time = 0.0; + + time = glutGet(GLUT_ELAPSED_TIME) / 500.0; + + jump = 4.0 * fabs(sin(time)*0.5); + if (!lightMoving) { + lightAngle += 0.03; + } + glutPostRedisplay(); +} + +enum { + M_NONE, M_MOTION, M_LIGHT, M_TEXTURE, M_SHADOWS, M_REFLECTION, M_DINOSAUR, + M_STENCIL_REFLECTION, M_STENCIL_SHADOW, M_OFFSET_SHADOW, + M_POSITIONAL, M_DIRECTIONAL, M_PERFORMANCE +}; + +static void +controlLights(int value) +{ + switch (value) { + case M_NONE: + return; + case M_MOTION: + animation = 1 - animation; + if (animation) { + glutIdleFunc(idle); + } else { + glutIdleFunc(NULL); + } + break; + case M_LIGHT: + lightSwitch = !lightSwitch; + if (lightSwitch) { + glEnable(GL_LIGHT0); + } else { + glDisable(GL_LIGHT0); + } + break; + case M_TEXTURE: + useTexture = !useTexture; + break; + case M_SHADOWS: + renderShadow = 1 - renderShadow; + break; + case M_REFLECTION: + renderReflection = 1 - renderReflection; + break; + case M_DINOSAUR: + renderDinosaur = 1 - renderDinosaur; + break; + case M_STENCIL_REFLECTION: + stencilReflection = 1 - stencilReflection; + break; + case M_STENCIL_SHADOW: + stencilShadow = 1 - stencilShadow; + break; + case M_OFFSET_SHADOW: + offsetShadow = 1 - offsetShadow; + break; + case M_POSITIONAL: + directionalLight = 0; + break; + case M_DIRECTIONAL: + directionalLight = 1; + break; + case M_PERFORMANCE: + reportSpeed = 1 - reportSpeed; + break; + } + glutPostRedisplay(); +} + +/* When not visible, stop animating. Restart when visible again. */ +static void +visible(int vis) +{ + if (vis == GLUT_VISIBLE) { + if (animation) + glutIdleFunc(idle); + } else { + if (!animation) + glutIdleFunc(NULL); + } +} + +/* Press any key to redraw; good when motion stopped and + performance reporting on. */ +/* ARGSUSED */ +static void +key(unsigned char c, int x, int y) +{ + if (c == 27) { + exit(0); /* IRIS GLism, Escape quits. */ + } + glutPostRedisplay(); +} + +/* Press any key to redraw; good when motion stopped and + performance reporting on. */ +/* ARGSUSED */ +static void +special(int k, int x, int y) +{ + glutPostRedisplay(); +} + +static int +supportsOneDotOne(void) +{ + const char *version; + int major, minor; + + version = (char *) glGetString(GL_VERSION); + if (sscanf(version, "%d.%d", &major, &minor) == 2) + return major >= 1 && minor >= 1; + return 0; /* OpenGL version string malformed! */ +} + +int +main(int argc, char **argv) +{ + int i; + + glutInit(&argc, argv); + + for (i=1; i<argc; i++) { + if (!strcmp("-linear", argv[i])) { + linearFiltering = 1; + } else if (!strcmp("-mipmap", argv[i])) { + useMipmaps = 1; + } else if (!strcmp("-ext", argv[i])) { + forceExtension = 1; + } + } + + glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH | GLUT_STENCIL); + +#if 0 + /* In GLUT 4.0, you'll be able to do this an be sure to + get 2 bits of stencil if the machine has it for you. */ + glutInitDisplayString("samples stencil>=2 rgb double depth"); +#endif + + glutCreateWindow("Shadowy Leapin' Lizards"); + + if (glutGet(GLUT_WINDOW_STENCIL_SIZE) <= 1) { + printf("dinoshade: Sorry, I need at least 2 bits of stencil.\n"); + exit(1); + } + + /* Register GLUT callbacks. */ + glutDisplayFunc(redraw); + glutMouseFunc(mouse); + glutMotionFunc(motion); + glutVisibilityFunc(visible); + glutKeyboardFunc(key); + glutSpecialFunc(special); + + glutCreateMenu(controlLights); + + glutAddMenuEntry("Toggle motion", M_MOTION); + glutAddMenuEntry("-----------------------", M_NONE); + glutAddMenuEntry("Toggle light", M_LIGHT); + glutAddMenuEntry("Toggle texture", M_TEXTURE); + glutAddMenuEntry("Toggle shadows", M_SHADOWS); + glutAddMenuEntry("Toggle reflection", M_REFLECTION); + glutAddMenuEntry("Toggle dinosaur", M_DINOSAUR); + glutAddMenuEntry("-----------------------", M_NONE); + glutAddMenuEntry("Toggle reflection stenciling", M_STENCIL_REFLECTION); + glutAddMenuEntry("Toggle shadow stenciling", M_STENCIL_SHADOW); + glutAddMenuEntry("Toggle shadow offset", M_OFFSET_SHADOW); + glutAddMenuEntry("----------------------", M_NONE); + glutAddMenuEntry("Positional light", M_POSITIONAL); + glutAddMenuEntry("Directional light", M_DIRECTIONAL); + glutAddMenuEntry("-----------------------", M_NONE); + glutAddMenuEntry("Toggle performance", M_PERFORMANCE); + glutAttachMenu(GLUT_RIGHT_BUTTON); + makeDinosaur(); + +#ifdef GL_VERSION_1_1 + if (supportsOneDotOne() && !forceExtension) { + polygonOffsetVersion = ONE_DOT_ONE; + glPolygonOffset(-2.0, -9.0); + } else +#endif + { +#ifdef GL_EXT_polygon_offset + /* check for the polygon offset extension */ + if (glutExtensionSupported("GL_EXT_polygon_offset")) { + polygonOffsetVersion = EXTENSION; + glPolygonOffsetEXT(-2.0, -0.002); + } else +#endif + { + polygonOffsetVersion = MISSING; + printf("\ndinoshine: Missing polygon offset.\n"); + printf(" Expect shadow depth aliasing artifacts.\n\n"); + } + } + + glEnable(GL_CULL_FACE); + glEnable(GL_DEPTH_TEST); + glEnable(GL_TEXTURE_2D); + glLineWidth(3.0); + + glMatrixMode(GL_PROJECTION); + gluPerspective( /* field of view in degree */ 40.0, + /* aspect ratio */ 1.0, + /* Z near */ 20.0, /* Z far */ 100.0); + glMatrixMode(GL_MODELVIEW); + gluLookAt(0.0, 8.0, 60.0, /* eye is at (0,8,60) */ + 0.0, 8.0, 0.0, /* center is at (0,8,0) */ + 0.0, 1.0, 0.); /* up is in postivie Y direction */ + + glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1); + glLightfv(GL_LIGHT0, GL_DIFFUSE, lightColor); + glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, 0.1); + glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, 0.05); + glEnable(GL_LIGHT0); + glEnable(GL_LIGHTING); + + makeFloorTexture(); + + /* Setup floor plane for projected shadow calculations. */ + findPlane(floorPlane, floorVertices[1], floorVertices[2], floorVertices[3]); + + glutMainLoop(); + return 0; /* ANSI C requires main to return int. */ +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/ext422square.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/ext422square.c new file mode 100644 index 000000000..6533514d6 --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/ext422square.c @@ -0,0 +1,258 @@ +/* + * Exercise the EXT_422_pixels extension, a less convenient + * alternative to MESA_ycbcr_texture. Requires ARB_fragment_program + * to perform the final YUV->RGB conversion. + * + * Brian Paul 13 September 2002 + * Keith Whitwell 30 November 2004 + */ + + +#include <math.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#define GL_GLEXT_PROTOTYPES +#include <GL/glut.h> +#include <assert.h> + +#include "../util/readtex.c" /* I know, this is a hack. */ + +#define TEXTURE_FILE "../images/tile.rgb" + +static GLfloat Xrot = 0, Yrot = 0, Zrot = 0; +static GLint ImgWidth, ImgHeight; +static GLushort *ImageYUV = NULL; +static const GLuint yuvObj = 100; +static const GLuint rgbObj = 101; + +static void Init( int argc, char *argv[] ); + +static void DrawObject(void) +{ + glBegin(GL_QUADS); + + glTexCoord2f(0, 0); + glVertex2f(-1.0, -1.0); + + glTexCoord2f(1, 0); + glVertex2f(1.0, -1.0); + + glTexCoord2f(1, 1); + glVertex2f(1.0, 1.0); + + glTexCoord2f(0, 1); + glVertex2f(-1.0, 1.0); + + glEnd(); +} + +static void Display( void ) +{ + static int firsttime = 1; + + if (firsttime) { + firsttime = 0; + Init( 0, 0 ); /* don't ask */ + } + + glClear( GL_COLOR_BUFFER_BIT ); + glBindTexture(GL_TEXTURE_2D, yuvObj); + + glPushMatrix(); + glEnable(GL_FRAGMENT_PROGRAM_ARB); + glTranslatef( -1.1, 0.0, -15.0 ); + glRotatef(Xrot, 1.0, 0.0, 0.0); + glRotatef(Yrot, 0.0, 1.0, 0.0); + glRotatef(Zrot, 0.0, 0.0, 1.0); + glBindTexture(GL_TEXTURE_2D, yuvObj); + DrawObject(); + glPopMatrix(); + + glPushMatrix(); + glDisable(GL_FRAGMENT_PROGRAM_ARB); + glTranslatef( 1.1, 0.0, -15.0 ); + glRotatef(Xrot, 1.0, 0.0, 0.0); + glRotatef(Yrot, 0.0, 1.0, 0.0); + glRotatef(Zrot, 0.0, 0.0, 1.0); + glBindTexture(GL_TEXTURE_2D, rgbObj); + DrawObject(); + glPopMatrix(); + + glutSwapBuffers(); +} + + +static void Reshape( int width, int height ) +{ + glViewport( 0, 0, width, height ); + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glFrustum( -1.1, 1.1, -1.1, 1.1, 10.0, 100.0 ); + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); + glTranslatef( 0.0, 0.0, -15.0 ); +} + + +static void Key( unsigned char key, int x, int y ) +{ + (void) x; + (void) y; + switch (key) { + case 27: + exit(0); + break; + } + glutPostRedisplay(); +} + + +static void SpecialKey( int key, int x, int y ) +{ + float step = 3.0; + (void) x; + (void) y; + + switch (key) { + case GLUT_KEY_UP: + Xrot += step; + break; + case GLUT_KEY_DOWN: + Xrot -= step; + break; + case GLUT_KEY_LEFT: + Yrot += step; + break; + case GLUT_KEY_RIGHT: + Yrot -= step; + break; + } + glutPostRedisplay(); +} + + + + +/* #define LINEAR_FILTER */ + +static void Init( int argc, char *argv[] ) +{ + const char *file; + const GLfloat yuvtorgb[16] = { + 1.164, 1.164, 1.164, 0, + 0, -.391, 2.018, 0, + 1.596, -.813, 0.0, 0, + (-.0625*1.164 + -.5*1.596), (-.0625*1.164 + -.5*-.813 + -.5*-.391), (-.0625*1.164 + -.5*2.018), 1 + }; + + if (!glutExtensionSupported("GL_ARB_fragment_program")) { + printf("Error: GL_ARB_fragment_program not supported!\n"); + exit(1); + } + + if (!glutExtensionSupported("GL_EXT_422_pixels")) { + printf("Error: GL_EXT_422_pixels not supported!\n"); + exit(1); + } + + glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + + file = TEXTURE_FILE; + + /* Load the texture as YCbCr. + */ + glBindTexture(GL_TEXTURE_2D, yuvObj); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + + ImageYUV = LoadYUVImage(file, &ImgWidth, &ImgHeight ); + if (!ImageYUV) { + printf("Couldn't read %s\n", TEXTURE_FILE); + exit(0); + } + + glTexImage2D(GL_TEXTURE_2D, 0, + GL_RGB, + ImgWidth, ImgHeight, 0, + GL_422_EXT, + GL_UNSIGNED_BYTE, ImageYUV); + + glEnable(GL_TEXTURE_2D); + + glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); + + { + static const char *modulateYUV = + "!!ARBfp1.0\n" + "TEMP R0;\n" + "TEX R0, fragment.texcoord[0], texture[0], 2D; \n" + + "ADD R0, R0, {-0.0625, -0.5, -0.5, 0.0}; \n" + "DP3 result.color.x, R0, {1.164, 1.596, 0.0}; \n" + "DP3 result.color.y, R0, {1.164, -0.813, -0.391}; \n" + "DP3 result.color.z, R0, {1.164, 0.0, 2.018}; \n" + "MOV result.color.w, R0.w; \n" + + "END" + ; + + GLuint modulateProg; + + + /* Setup the fragment program */ + glGenProgramsARB(1, &modulateProg); + glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, modulateProg); + glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, + strlen(modulateYUV), (const GLubyte *)modulateYUV); + + printf("glGetError = 0x%x\n", (int) glGetError()); + printf("glError(GL_PROGRAM_ERROR_STRING_ARB) = %s\n", + (char *) glGetString(GL_PROGRAM_ERROR_STRING_ARB)); + assert(glIsProgramARB(modulateProg)); + + } + + /* Now the same, but use a color matrix to do the conversion at + * upload time: + */ + glBindTexture(GL_TEXTURE_2D, rgbObj); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + + glMatrixMode( GL_COLOR_MATRIX ); + glLoadMatrixf( yuvtorgb ); + + glTexImage2D(GL_TEXTURE_2D, 0, + GL_RGB, + ImgWidth, ImgHeight, 0, + GL_422_EXT, + GL_UNSIGNED_BYTE, ImageYUV); + + glLoadIdentity(); + glMatrixMode( GL_MODELVIEW ); + + glEnable(GL_TEXTURE_2D); + + glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); + + + glShadeModel(GL_FLAT); + glClearColor(0.3, 0.3, 0.4, 1.0); +} + + +int main( int argc, char *argv[] ) +{ + glutInit( &argc, argv ); + glutInitWindowSize( 300, 300 ); + glutInitWindowPosition( 0, 0 ); + glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE ); + glutCreateWindow(argv[0] ); + glutReshapeFunc( Reshape ); + glutKeyboardFunc( Key ); + glutSpecialFunc( SpecialKey ); + glutDisplayFunc( Display ); + glutMainLoop(); + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/fbotest1.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/fbotest1.c new file mode 100644 index 000000000..3faa55eb9 --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/fbotest1.c @@ -0,0 +1,190 @@ +/* + * Test GL_EXT_framebuffer_object + * + * Brian Paul + * 7 Feb 2005 + */ + + +#define GL_GLEXT_PROTOTYPES +#include <assert.h> +#include <stdio.h> +#include <stdlib.h> +#include <math.h> +#include <GL/glut.h> + +static int Width = 400, Height = 400; +static GLuint MyFB; + + +static void +CheckError(int line) +{ + GLenum err = glGetError(); + if (err) { + printf("GL Error 0x%x at line %d\n", (int) err, line); + } +} + + +static void +Display( void ) +{ + GLubyte *buffer = malloc(Width * Height * 4); + GLenum status; + + /* draw to user framebuffer */ + glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, MyFB); + glDrawBuffer(GL_COLOR_ATTACHMENT1_EXT); + glReadBuffer(GL_COLOR_ATTACHMENT1_EXT); + + status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); + if (status != GL_FRAMEBUFFER_COMPLETE_EXT) { + printf("Framebuffer incomplete!!!\n"); + } + + glClearColor(0.5, 0.5, 1.0, 0.0); + glClear( GL_COLOR_BUFFER_BIT ); + + glBegin(GL_POLYGON); + glColor3f(1, 0, 0); + glVertex2f(-1, -1); + glColor3f(0, 1, 0); + glVertex2f(1, -1); + glColor3f(0, 0, 1); + glVertex2f(0, 1); + glEnd(); + + /* read from user framebuffer */ + glReadPixels(0, 0, Width, Height, GL_RGBA, GL_UNSIGNED_BYTE, buffer); + + /* draw to window */ + glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); + glWindowPos2iARB(0, 0); + glDrawPixels(Width, Height, GL_RGBA, GL_UNSIGNED_BYTE, buffer); + + free(buffer); + glutSwapBuffers(); +} + + +static void +Reshape( int width, int height ) +{ +#if 0 + float ar = (float) width / (float) height; +#endif + glViewport( 0, 0, width, height ); + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); +#if 0 + glFrustum( -ar, ar, -1.0, 1.0, 5.0, 25.0 ); +#else + glOrtho(-1.0, 1.0, -1.0, 1.0, 5.0, 25.0 ); +#endif + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); + glTranslatef( 0.0, 0.0, -15.0 ); + Width = width; + Height = height; + glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_RGB, Width, Height); +} + + +static void +Key( unsigned char key, int x, int y ) +{ + (void) x; + (void) y; + switch (key) { + case 27: + exit(0); + break; + } + glutPostRedisplay(); +} + + +static void +Init( void ) +{ + GLuint rb; + GLint i; + + if (!glutExtensionSupported("GL_EXT_framebuffer_object")) { + printf("GL_EXT_framebuffer_object not found!\n"); + /*exit(0);*/ + } + printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER)); + + glGenFramebuffersEXT(1, &MyFB); + assert(MyFB); + assert(!glIsFramebufferEXT(MyFB)); + glDeleteFramebuffersEXT(1, &MyFB); + assert(!glIsFramebufferEXT(MyFB)); + /* Note, continue to use MyFB below */ + + glGenRenderbuffersEXT(1, &rb); + assert(rb); + assert(!glIsRenderbufferEXT(rb)); + glDeleteRenderbuffersEXT(1, &rb); + assert(!glIsRenderbufferEXT(rb)); + rb = 42; /* an arbitrary ID */ + + glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, MyFB); + assert(glIsFramebufferEXT(MyFB)); + glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, rb); + assert(glIsRenderbufferEXT(rb)); + + glGetIntegerv(GL_RENDERBUFFER_BINDING_EXT, &i); + assert(i == rb); + + glGetIntegerv(GL_FRAMEBUFFER_BINDING_EXT, &i); + assert(i == MyFB); + + glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT1_EXT, + GL_RENDERBUFFER_EXT, rb); + + glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_RGB, Width, Height); + + { + GLint r, g, b, a; + glGetRenderbufferParameterivEXT(GL_RENDERBUFFER_EXT, + GL_RENDERBUFFER_RED_SIZE_EXT, &r); + glGetRenderbufferParameterivEXT(GL_RENDERBUFFER_EXT, + GL_RENDERBUFFER_GREEN_SIZE_EXT, &g); + glGetRenderbufferParameterivEXT(GL_RENDERBUFFER_EXT, + GL_RENDERBUFFER_BLUE_SIZE_EXT, &b); + glGetRenderbufferParameterivEXT(GL_RENDERBUFFER_EXT, + GL_RENDERBUFFER_ALPHA_SIZE_EXT, &a); + printf("renderbuffer RGBA sizes = %d %d %d %d\n", r, g, b, a); + + glGetIntegerv(GL_RED_BITS, &r); + glGetIntegerv(GL_GREEN_BITS, &g); + glGetIntegerv(GL_BLUE_BITS, &b); + glGetIntegerv(GL_ALPHA_BITS, &a); + printf("Visual RGBA sizes = %d %d %d %d\n", r, g, b, a); + } + + CheckError(__LINE__); + + /* restore to default */ + glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); +} + + +int +main( int argc, char *argv[] ) +{ + glutInit( &argc, argv ); + glutInitWindowPosition( 0, 0 ); + glutInitWindowSize(Width, Height); + glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE ); + glutCreateWindow(argv[0]); + glutReshapeFunc( Reshape ); + glutKeyboardFunc( Key ); + glutDisplayFunc( Display ); + Init(); + glutMainLoop(); + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/fbotexture.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/fbotexture.c new file mode 100644 index 000000000..f348d202f --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/fbotexture.c @@ -0,0 +1,288 @@ +/* + * Test GL_EXT_framebuffer_object render-to-texture + * + * Draw a teapot into a texture image with stenciling. + * Then draw a textured quad using that texture. + * + * Brian Paul + * 18 Apr 2005 + */ + + +#define GL_GLEXT_PROTOTYPES +#include <assert.h> +#include <stdio.h> +#include <stdlib.h> +#include <math.h> +#include <GL/glut.h> + +static int Width = 400, Height = 400; +static int TexWidth = 512, TexHeight = 512; +static GLuint MyFB; +static GLuint TexObj; +static GLuint DepthRB, StencilRB; +static GLboolean Anim = GL_FALSE; +static GLfloat Rot = 0.0; + + +static void +CheckError(int line) +{ + GLenum err = glGetError(); + if (err) { + printf("GL Error 0x%x at line %d\n", (int) err, line); + } +} + + +static void +Idle(void) +{ + Rot = glutGet(GLUT_ELAPSED_TIME) * 0.05; + glutPostRedisplay(); +} + + +static void +RenderTexture(void) +{ + GLint level = 0; + GLenum status; + + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + glOrtho(-1.0, 1.0, -1.0, 1.0, 5.0, 25.0); + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + glTranslatef(0.0, 0.0, -15.0); + + /* draw to texture image */ + glBindTexture(GL_TEXTURE_2D, 0); + glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, MyFB); + glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, + GL_TEXTURE_2D, TexObj, level); + + status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); + if (status != GL_FRAMEBUFFER_COMPLETE_EXT) { + printf("Framebuffer incomplete!!!\n"); + } + + glViewport(0, 0, TexWidth, TexHeight); + + glClearColor(0.5, 0.5, 1.0, 0.0); + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); + + glEnable(GL_DEPTH_TEST); + glEnable(GL_STENCIL_TEST); + glStencilFunc(GL_NEVER, 1, ~0); + glStencilOp(GL_REPLACE, GL_KEEP, GL_REPLACE); + + /* draw diamond-shaped stencil pattern */ + glColor3f(0, 1, 0); + glBegin(GL_POLYGON); + glVertex2f(-0.2, 0.0); + glVertex2f( 0.0, -0.2); + glVertex2f( 0.2, 0.0); + glVertex2f( 0.0, 0.2); + glEnd(); + + /* draw teapot where stencil != 1 */ + glStencilFunc(GL_NOTEQUAL, 1, ~0); + glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP); + +#if 0 + glBegin(GL_POLYGON); + glColor3f(1, 0, 0); + glVertex2f(-1, -1); + glColor3f(0, 1, 0); + glVertex2f(1, -1); + glColor3f(0, 0, 1); + glVertex2f(0, 1); + glEnd(); +#else + glEnable(GL_LIGHTING); + glEnable(GL_LIGHT0); + glPushMatrix(); + glRotatef(0.5 * Rot, 1.0, 0.0, 0.0); + glutSolidTeapot(0.5); + glPopMatrix(); + glDisable(GL_LIGHTING); +#endif + glDisable(GL_DEPTH_TEST); + glDisable(GL_STENCIL_TEST); + + /* Bind normal framebuffer */ + glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); + + CheckError(__LINE__); +} + + + +static void +Display(void) +{ + float ar = (float) Width / (float) Height; + + RenderTexture(); + + /* draw textured quad in the window */ + + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + glFrustum(-ar, ar, -1.0, 1.0, 5.0, 25.0); + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + glTranslatef(0.0, 0.0, -7.0); + + glViewport(0, 0, Width, Height); + + glClearColor(0.25, 0.25, 0.25, 0); + glClear(GL_COLOR_BUFFER_BIT); + + glPushMatrix(); + glRotatef(Rot, 0, 1, 0); + glEnable(GL_TEXTURE_2D); + glBindTexture(GL_TEXTURE_2D, TexObj); + glBegin(GL_POLYGON); + glColor3f(0.25, 0.25, 0.25); + glTexCoord2f(0, 0); + glVertex2f(-1, -1); + glTexCoord2f(1, 0); + glVertex2f(1, -1); + glColor3f(1.0, 1.0, 1.0); + glTexCoord2f(1, 1); + glVertex2f(1, 1); + glTexCoord2f(0, 1); + glVertex2f(-1, 1); + glEnd(); + glPopMatrix(); + glDisable(GL_TEXTURE_2D); + + glutSwapBuffers(); + CheckError(__LINE__); +} + + +static void +Reshape(int width, int height) +{ + glViewport(0, 0, width, height); + Width = width; + Height = height; +} + + +static void +Key(unsigned char key, int x, int y) +{ + (void) x; + (void) y; + switch (key) { + case 'a': + Anim = !Anim; + if (Anim) + glutIdleFunc(Idle); + else + glutIdleFunc(NULL); + break; + case 27: + exit(0); + break; + } + glutPostRedisplay(); +} + + +static void +Init(void) +{ + GLint i; + + if (!glutExtensionSupported("GL_EXT_framebuffer_object")) { + printf("GL_EXT_framebuffer_object not found!\n"); + exit(0); + } + printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER)); + + /* gen framebuffer id, delete it, do some assertions, just for testing */ + glGenFramebuffersEXT(1, &MyFB); + assert(MyFB); + assert(!glIsFramebufferEXT(MyFB)); + glDeleteFramebuffersEXT(1, &MyFB); + assert(!glIsFramebufferEXT(MyFB)); + /* Note, continue to use MyFB below */ + + glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, MyFB); + assert(glIsFramebufferEXT(MyFB)); + glGetIntegerv(GL_FRAMEBUFFER_BINDING_EXT, &i); + assert(i == MyFB); + + /* make depth renderbuffer */ + glGenRenderbuffersEXT(1, &DepthRB); + assert(DepthRB); + assert(!glIsRenderbufferEXT(DepthRB)); + glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, DepthRB); + assert(glIsRenderbufferEXT(DepthRB)); + glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, + TexWidth, TexHeight); + glGetRenderbufferParameterivEXT(GL_RENDERBUFFER_EXT, + GL_RENDERBUFFER_DEPTH_SIZE_EXT, &i); + printf("Depth renderbuffer size = %d bits\n", i); + assert(i > 0); + + /* make stencil renderbuffer */ + glGenRenderbuffersEXT(1, &StencilRB); + assert(StencilRB); + assert(!glIsRenderbufferEXT(StencilRB)); + glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, StencilRB); + assert(glIsRenderbufferEXT(StencilRB)); + glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_STENCIL_INDEX, + TexWidth, TexHeight); + glGetRenderbufferParameterivEXT(GL_RENDERBUFFER_EXT, + GL_RENDERBUFFER_STENCIL_SIZE_EXT, &i); + printf("Stencil renderbuffer size = %d bits\n", i); + assert(i > 0); + + /* attach DepthRB to MyFB */ + glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, + GL_RENDERBUFFER_EXT, DepthRB); + + /* attach StencilRB to MyFB */ + glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, + GL_RENDERBUFFER_EXT, StencilRB); + + + /* bind regular framebuffer */ + glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); + + /* Make texture object/image */ + glGenTextures(1, &TexObj); + glBindTexture(GL_TEXTURE_2D, TexObj); + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, TexWidth, TexHeight, 0, + GL_RGBA, GL_UNSIGNED_BYTE, NULL); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); + + CheckError(__LINE__); +} + + +int +main(int argc, char *argv[]) +{ + glutInit(&argc, argv); + glutInitWindowPosition(0, 0); + glutInitWindowSize(Width, Height); + glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE); + glutCreateWindow(argv[0]); + glutReshapeFunc(Reshape); + glutKeyboardFunc(Key); + glutDisplayFunc(Display); + if (Anim) + glutIdleFunc(Idle); + Init(); + glutMainLoop(); + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/floattex.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/floattex.c new file mode 100644 index 000000000..2345a49b2 --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/floattex.c @@ -0,0 +1,169 @@ +/* + * Test floating point textures. + * No actual rendering, yet. + */ + + +#include <assert.h> +#include <stdio.h> +#include <stdlib.h> +#include <math.h> +#include <GL/glut.h> + + +/* XXX - temporary */ +#ifndef GL_ARB_texture_float +#define GL_ARB_texture_float 1 +#define GL_TEXTURE_RED_TYPE_ARB 0x9000 +#define GL_TEXTURE_GREEN_TYPE_ARB 0x9001 +#define GL_TEXTURE_BLUE_TYPE_ARB 0x9002 +#define GL_TEXTURE_ALPHA_TYPE_ARB 0x9003 +#define GL_TEXTURE_LUMINANCE_TYPE_ARB 0x9004 +#define GL_TEXTURE_INTENSITY_TYPE_ARB 0x9005 +#define GL_TEXTURE_DEPTH_TYPE_ARB 0x9006 +#define GL_UNSIGNED_NORMALIZED_ARB 0x9007 +#define GL_RGBA32F_ARB 0x8814 +#define GL_RGB32F_ARB 0x8815 +#define GL_ALPHA32F_ARB 0x8816 +#define GL_INTENSITY32F_ARB 0x8817 +#define GL_LUMINANCE32F_ARB 0x8818 +#define GL_LUMINANCE_ALPHA32F_ARB 0x8819 +#define GL_RGBA16F_ARB 0x881A +#define GL_RGB16F_ARB 0x881B +#define GL_ALPHA16F_ARB 0x881C +#define GL_INTENSITY16F_ARB 0x881D +#define GL_LUMINANCE16F_ARB 0x881E +#define GL_LUMINANCE_ALPHA16F_ARB 0x881F +#endif + + +static GLboolean +CheckError( int line ) +{ + GLenum error = glGetError(); + if (error) { + char *err = (char *) gluErrorString( error ); + fprintf( stderr, "GL Error: %s at line %d\n", err, line ); + return GL_TRUE; + } + return GL_FALSE; +} + + +static void +Draw(void) +{ + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + + glPushMatrix(); + + glutSolidCube(2.0); + + glPopMatrix(); + + glutSwapBuffers(); +} + + +static void +Reshape(int width, int height) +{ + glViewport(0, 0, width, height); + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + glFrustum(-1.0, 1.0, -1.0, 1.0, 5.0, 25.0); + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + glTranslatef(0.0, 0.0, -15.0); +} + + +static void +Key(unsigned char key, int x, int y) +{ + (void) x; + (void) y; + switch (key) { + case 27: + exit(0); + break; + } + glutPostRedisplay(); +} + + + +static void +Init(void) +{ + GLfloat tex[16][16][4]; + GLfloat tex2[16][16][4]; + GLint i, j, t; + + if (!glutExtensionSupported("GL_MESAX_texture_float")) { + printf("Sorry, this test requires GL_MESAX_texture_float\n"); + exit(1); + } + + for (i = 0; i < 16; i++) { + for (j = 0; j < 16; j++) { + GLfloat s = i / 15.0; + tex[i][j][0] = s; + tex[i][j][1] = 2.0 * s; + tex[i][j][2] = -3.0 * s; + tex[i][j][3] = 4.0 * s; + } + } + + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F_ARB, 16, 16, 0, GL_RGBA, + GL_FLOAT, tex); + CheckError(__LINE__); + + glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_RED_TYPE_ARB, &t); + assert(t == GL_FLOAT); + glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_GREEN_TYPE_ARB, &t); + assert(t == GL_FLOAT); + glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_BLUE_TYPE_ARB, &t); + assert(t == GL_FLOAT); + glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_ALPHA_TYPE_ARB, &t); + assert(t == GL_FLOAT); + + CheckError(__LINE__); + + /* read back the texture and make sure values are correct */ + glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_FLOAT, tex2); + CheckError(__LINE__); + for (i = 0; i < 16; i++) { + for (j = 0; j < 16; j++) { + if (tex[i][j][0] != tex2[i][j][0] || + tex[i][j][1] != tex2[i][j][1] || + tex[i][j][2] != tex2[i][j][2] || + tex[i][j][3] != tex2[i][j][3]) { + printf("tex[%d][%d] %g %g %g %g != tex2[%d][%d] %g %g %g %g\n", + i, j, + tex[i][j][0], tex[i][j][1], tex[i][j][2], tex[i][j][3], + i, j, + tex2[i][j][0], tex2[i][j][1], tex2[i][j][2], tex2[i][j][3]); + } + } + } + + +} + + +int +main(int argc, char *argv[]) +{ + glutInit(&argc, argv); + glutInitWindowPosition(0, 0); + glutInitWindowSize(400, 400); + glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH); + glutCreateWindow(argv[0]); + glutReshapeFunc(Reshape); + glutKeyboardFunc(Key); + glutDisplayFunc(Draw); + Init(); + glutMainLoop(); + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/fogcoord.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/fogcoord.c new file mode 100644 index 000000000..89355742a --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/fogcoord.c @@ -0,0 +1,102 @@ +/* + * Exercise GL_EXT_fog_coord + */ + + +#define GL_GLEXT_PROTOTYPES +#include <stdio.h> +#include <stdlib.h> +#include <math.h> +#include <GL/glut.h> + +static int Width = 600; +static int Height = 200; +static GLfloat Near = 5.0, Far = 25.0; + + +static void Display( void ) +{ + GLfloat t; + + glClearColor(0.2, 0.2, 0.8, 0); + glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); + + for (t = 0.0; t <= 1.0; t += 0.25) { + GLfloat f = Near + t * (Far - Near); + printf("glFogCoord(%4.1f)\n", f); + glFogCoordfEXT(f); + + glPushMatrix(); + glTranslatef(t * 10.0 - 5.0, 0, 0); + glBegin(GL_POLYGON); + glVertex2f(-1, -1); + glVertex2f( 1, -1); + glVertex2f( 1, 1); + glVertex2f(-1, 1); + glEnd(); + glPopMatrix(); + } + glutSwapBuffers(); +} + + +static void Reshape( int width, int height ) +{ + GLfloat ar = (float) width / (float) height; + Width = width; + Height = height; + glViewport( 0, 0, width, height ); + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glFrustum( -ar, ar, -1.0, 1.0, Near, Far ); + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); + glTranslatef( 0.0, 0.0, -15.0 ); +} + + +static void Key( unsigned char key, int x, int y ) +{ + (void) x; + (void) y; + switch (key) { + case 27: + exit(0); + break; + } + glutPostRedisplay(); +} + + +static void Init( void ) +{ + printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER)); + printf("GL_VERSION = %s\n", (char *) glGetString(GL_VERSION)); + /* setup lighting, etc */ + if (!glutExtensionSupported("GL_EXT_fog_coord")) { + printf("Sorry, this program requires GL_EXT_fog_coord\n"); + exit(1); + } + glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FOG_COORDINATE_EXT); + glFogi(GL_FOG_MODE, GL_LINEAR); + glFogf(GL_FOG_START, Near); + glFogf(GL_FOG_END, Far); + glEnable(GL_FOG); + printf("Squares should be colored from white -> gray -> black.\n"); +} + + +int main( int argc, char *argv[] ) +{ + glutInit( &argc, argv ); + glutInitWindowPosition( 0, 0 ); + glutInitWindowSize( Width, Height ); + glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH ); + glutCreateWindow(argv[0]); + glutReshapeFunc( Reshape ); + glutKeyboardFunc( Key ); + glutDisplayFunc( Display ); + Init(); + glutMainLoop(); + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/fptest1.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/fptest1.c new file mode 100644 index 000000000..d0bcdaa22 --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/fptest1.c @@ -0,0 +1,220 @@ +/* Test GL_NV_fragment_program */ + +#include <assert.h> +#include <string.h> +#include <stdio.h> +#include <stdlib.h> +#include <math.h> +#define GL_GLEXT_PROTOTYPES +#include <GL/glut.h> + + + +static void Display( void ) +{ + glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); + + glPushMatrix(); + + glColor4f(0, 0.5, 0, 1); + glColor4f(0, 1, 0, 1); + glBegin(GL_POLYGON); + glVertex2f(-1, -1); + glVertex2f( 1, -1); + glVertex2f( 0, 1); + glEnd(); + + glPopMatrix(); + + glutSwapBuffers(); +} + + +static void Reshape( int width, int height ) +{ + glViewport( 0, 0, width, height ); + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glFrustum( -1.0, 1.0, -1.0, 1.0, 5.0, 25.0 ); + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); + glTranslatef( 0.0, 0.0, -15.0 ); +} + + +static void Key( unsigned char key, int x, int y ) +{ + (void) x; + (void) y; + switch (key) { + case 27: + exit(0); + break; + } + glutPostRedisplay(); +} + + +static void Init( void ) +{ + static const char *prog0 = + "!!FP1.0\n" + "MUL o[COLR], R0, f[WPOS]; \n" + "ADD o[COLH], H3, f[TEX0]; \n" + "ADD_SAT o[COLH], H3, f[TEX0]; \n" + "ADDX o[COLH], H3, f[TEX0]; \n" + "ADDHC o[COLH], H3, f[TEX0]; \n" + "ADDXC o[COLH], H3, f[TEX0]; \n" + "ADDXC_SAT o[COLH], H30, f[TEX0]; \n" + "MUL o[COLR].xy, R0.wzyx, f[WPOS]; \n" + "MUL o[COLR], H0, f[WPOS]; \n" + "MUL o[COLR], -H0, f[WPOS]; \n" + "MOV RC, H1; \n" + "MOV HC, H2; \n" + "END \n" + ; + + /* masked updates, defines, declarations */ + static const char *prog1 = + "!!FP1.0\n" + "DEFINE foo = {1, 2, 3, 4}; \n" + "DEFINE foo2 = 5; \n" + "DECLARE foo3 = {5, 6, 7, 8}; \n" + "DECLARE bar = 3; \n" + "DECLARE bar2; \n" + "DECLARE bar3 = bar; \n" + "#DECLARE bar4 = { a, b, c, d }; \n" + "MOV o[COLR].xy, R0; \n" + "MOV o[COLR] (NE), R0; \n" + "MOV o[COLR] (NE.wzyx), R0; \n" + "MOV o[COLR].xy (NE.wzyx), R0; \n" + "MOV RC.x (EQ), R1.x; \n" + "KIL NE; \n" + "KIL EQ.xyxy; \n" + "END \n" + ; + + /* texture instructions */ + static const char *prog2 = + "!!FP1.0\n" + "TEX R0, f[TEX0], TEX0, 2D; \n" + "TEX R1, f[TEX1], TEX1, CUBE; \n" + "TEX R2, f[TEX2], TEX2, 3D; \n" + "TXP R3, f[TEX3], TEX3, RECT; \n" + "TXD R3, R2, R1, f[TEX3], TEX3, RECT; \n" + "MUL o[COLR], R0, f[COL0]; \n" + "END \n" + ; + + /* test negation, absolute value */ + static const char *prog3 = + "!!FP1.0\n" + "MOV R0, -R1; \n" + "MOV R0, +R1; \n" + "MOV R0, |-R1|; \n" + "MOV R0, |+R1|; \n" + "MOV R0, -|R1|; \n" + "MOV R0, +|R1|; \n" + "MOV R0, -|-R1|; \n" + "MOV R0, -|+R1|; \n" + "MOV o[COLR], R0; \n" + "END \n" + ; + + /* literal constant sources */ + static const char *prog4 = + "!!FP1.0\n" + "DEFINE Pi = 3.14159; \n" + "MOV R0, {1, -2, +3, 4}; \n" + "MOV R0, 5; \n" + "MOV R0, -5; \n" + "MOV R0, +5; \n" + "MOV R0, Pi; \n" + "MOV o[COLR], R0; \n" + "END \n" + ; + + /* change the fragment color in a simple way */ + static const char *prog10 = + "!!FP1.0\n" + "DEFINE blue = {0, 0, 1, 0};\n" + "DECLARE color; \n" + "MOV R0, f[COL0]; \n" + "#ADD o[COLR], R0, f[COL0]; \n" + "#ADD o[COLR], blue, f[COL0]; \n" + "#ADD o[COLR], {1, 0, 0, 0}, f[COL0]; \n" + "ADD o[COLR], color, f[COL0]; \n" + "END \n" + ; + + GLuint progs[20]; + + glGenProgramsNV(20, progs); + assert(progs[0]); + assert(progs[1]); + assert(progs[0] != progs[1]); + +#if 0 + glLoadProgramNV(GL_FRAGMENT_PROGRAM_NV, progs[0], + strlen(prog0), + (const GLubyte *) prog0); + assert(glIsProgramNV(progs[0])); +#endif + + glLoadProgramNV(GL_FRAGMENT_PROGRAM_NV, progs[1], + strlen(prog1), + (const GLubyte *) prog1); + assert(glIsProgramNV(progs[1])); + + glLoadProgramNV(GL_FRAGMENT_PROGRAM_NV, progs[2], + strlen(prog2), + (const GLubyte *) prog2); + assert(glIsProgramNV(progs[2])); + glBindProgramNV(GL_FRAGMENT_PROGRAM_NV, progs[2]); + + glLoadProgramNV(GL_FRAGMENT_PROGRAM_NV, progs[3], + strlen(prog3), + (const GLubyte *) prog3); + assert(glIsProgramNV(progs[3])); + glBindProgramNV(GL_FRAGMENT_PROGRAM_NV, progs[3]); + + glLoadProgramNV(GL_FRAGMENT_PROGRAM_NV, progs[4], + strlen(prog4), + (const GLubyte *) prog4); + assert(glIsProgramNV(progs[4])); + glBindProgramNV(GL_FRAGMENT_PROGRAM_NV, progs[4]); + + + /* a real program */ + glLoadProgramNV(GL_FRAGMENT_PROGRAM_NV, progs[10], + strlen(prog10), + (const GLubyte *) prog10); + assert(glIsProgramNV(progs[10])); + glBindProgramNV(GL_FRAGMENT_PROGRAM_NV, progs[10]); + + glProgramNamedParameter4fNV(progs[10], + strlen("color"), (const GLubyte *) "color", + 1, 0, 0, 1); + + glEnable(GL_FRAGMENT_PROGRAM_NV); + glEnable(GL_ALPHA_TEST); + glAlphaFunc(GL_ALWAYS, 0.0); + + printf("glGetError = %d\n", (int) glGetError()); +} + + +int main( int argc, char *argv[] ) +{ + glutInit( &argc, argv ); + glutInitWindowPosition( 0, 0 ); + glutInitWindowSize( 250, 250 ); + glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH ); + glutCreateWindow(argv[0]); + glutReshapeFunc( Reshape ); + glutKeyboardFunc( Key ); + glutDisplayFunc( Display ); + Init(); + glutMainLoop(); + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/fptexture.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/fptexture.c new file mode 100644 index 000000000..f57ad6282 --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/fptexture.c @@ -0,0 +1,151 @@ +/* GL_NV_fragment_program texture test */ + +#include <assert.h> +#include <string.h> +#include <stdio.h> +#include <stdlib.h> +#include <math.h> +#define GL_GLEXT_PROTOTYPES +#include <GL/glut.h> + +#include "../util/readtex.c" + + +#define TEXTURE_FILE "../images/girl.rgb" + +static GLfloat Xrot = 0.0, Yrot = 0.0, Zrot = 0.0; + + +static void Display( void ) +{ + glClear( GL_COLOR_BUFFER_BIT ); + + glPushMatrix(); + glRotatef(Xrot, 1.0, 0.0, 0.0); + glRotatef(Yrot, 0.0, 1.0, 0.0); + glRotatef(Zrot, 0.0, 0.0, 1.0); + + glBegin(GL_POLYGON); + glColor4f(1.0, 1.0, 1.0, 1); glTexCoord2f(0, 0); glVertex2f(-1, -1); + glColor4f(0.2, 0.2, 1.0, 1); glTexCoord2f(1, 0); glVertex2f( 1, -1); + glColor4f(0.2, 1.0, 0.2, 1); glTexCoord2f(1, 1); glVertex2f( 1, 1); + glColor4f(1.0, 0.2, 0.2, 1); glTexCoord2f(0, 1); glVertex2f(-1, 1); + glEnd(); + + glPopMatrix(); + + glutSwapBuffers(); +} + + +static void Reshape( int width, int height ) +{ + glViewport( 0, 0, width, height ); + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glFrustum( -1.0, 1.0, -1.0, 1.0, 5.0, 25.0 ); + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); + glTranslatef( 0.0, 0.0, -8.0 ); +} + + +static void SpecialKey( int key, int x, int y ) +{ + float step = 3.0; + (void) x; + (void) y; + + switch (key) { + case GLUT_KEY_UP: + Xrot += step; + break; + case GLUT_KEY_DOWN: + Xrot -= step; + break; + case GLUT_KEY_LEFT: + Yrot += step; + break; + case GLUT_KEY_RIGHT: + Yrot -= step; + break; + } + glutPostRedisplay(); +} + + +static void Key( unsigned char key, int x, int y ) +{ + (void) x; + (void) y; + switch (key) { + case 27: + exit(0); + break; + } + glutPostRedisplay(); +} + + +static void Init( void ) +{ + static const char *modulate2D = + "!!FP1.0\n" + "TEX R0, f[TEX0], TEX0, 2D; \n" + "MUL o[COLR], R0, f[COL0]; \n" + "END" + ; + GLuint modulateProg; + GLuint Texture; + + if (!glutExtensionSupported("GL_NV_fragment_program")) { + printf("Error: GL_NV_fragment_program not supported!\n"); + exit(1); + } + printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER)); + + /* Setup the fragment program */ + glGenProgramsNV(1, &modulateProg); + glLoadProgramNV(GL_FRAGMENT_PROGRAM_NV, modulateProg, + strlen(modulate2D), + (const GLubyte *) modulate2D); + printf("glGetError = 0x%x\n", (int) glGetError()); + printf("glError(GL_PROGRAM_ERROR_STRING_NV) = %s\n", + (char *) glGetString(GL_PROGRAM_ERROR_STRING_NV)); + assert(glIsProgramNV(modulateProg)); + + glBindProgramNV(GL_FRAGMENT_PROGRAM_NV, modulateProg); + glEnable(GL_FRAGMENT_PROGRAM_NV); + + /* Load texture */ + glGenTextures(1, &Texture); + glBindTexture(GL_TEXTURE_2D, Texture); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + if (!LoadRGBMipmaps(TEXTURE_FILE, GL_RGB)) { + printf("Error: couldn't load texture image file %s\n", TEXTURE_FILE); + exit(1); + } + /* XXX this enable shouldn't really be needed!!! */ + glEnable(GL_TEXTURE_2D); + + glClearColor(.3, .3, .3, 0); +} + + +int main( int argc, char *argv[] ) +{ + glutInit( &argc, argv ); + glutInitWindowPosition( 0, 0 ); + glutInitWindowSize( 250, 250 ); + glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH ); + glutCreateWindow(argv[0]); + glutReshapeFunc( Reshape ); + glutKeyboardFunc( Key ); + glutSpecialFunc( SpecialKey ); + glutDisplayFunc( Display ); + Init(); + glutMainLoop(); + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/getprocaddress.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/getprocaddress.c new file mode 100644 index 000000000..2480ed44c --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/getprocaddress.c @@ -0,0 +1,438 @@ +/* + * Copyright (C) 1999-2002 Brian Paul All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +/* + * Test that glXGetProcAddress works. + */ + +#define GLX_GLXEXT_PROTOTYPES + +#include <X11/Xlib.h> +#include <X11/Xutil.h> +#include <GL/gl.h> +#include <GL/glx.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <math.h> + + +typedef void (*generic_func)(); + +#define EQUAL(X, Y) (fabs((X) - (Y)) < 0.001) + +static GLboolean +test_ActiveTextureARB(generic_func func) +{ + PFNGLACTIVETEXTUREARBPROC activeTexture = (PFNGLACTIVETEXTUREARBPROC) func; + GLint t; + GLboolean pass; + (*activeTexture)(GL_TEXTURE1_ARB); + glGetIntegerv(GL_ACTIVE_TEXTURE_ARB, &t); + pass = (t == GL_TEXTURE1_ARB); + (*activeTexture)(GL_TEXTURE0_ARB); /* restore default */ + return pass; +} + + +static GLboolean +test_SecondaryColor3fEXT(generic_func func) +{ + PFNGLSECONDARYCOLOR3FEXTPROC secColor3f = (PFNGLSECONDARYCOLOR3FEXTPROC) func; + GLfloat color[4]; + GLboolean pass; + (*secColor3f)(1.0, 1.0, 0.0); + glGetFloatv(GL_CURRENT_SECONDARY_COLOR_EXT, color); + pass = (color[0] == 1.0 && color[1] == 1.0 && color[2] == 0.0); + (*secColor3f)(0.0, 0.0, 0.0); /* restore default */ + return pass; +} + + +static GLboolean +test_ActiveStencilFaceEXT(generic_func func) +{ + PFNGLACTIVESTENCILFACEEXTPROC activeFace = (PFNGLACTIVESTENCILFACEEXTPROC) func; + GLint face; + GLboolean pass; + (*activeFace)(GL_BACK); + glGetIntegerv(GL_ACTIVE_STENCIL_FACE_EXT, &face); + pass = (face == GL_BACK); + (*activeFace)(GL_FRONT); /* restore default */ + return pass; +} + + +static GLboolean +test_VertexAttrib1fvARB(generic_func func) +{ + PFNGLVERTEXATTRIB1FVARBPROC vertexAttrib1fvARB = (PFNGLVERTEXATTRIB1FVARBPROC) func; + PFNGLGETVERTEXATTRIBFVARBPROC getVertexAttribfvARB = (PFNGLGETVERTEXATTRIBFVARBPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvARB"); + + const GLfloat v[1] = {25.0}; + const GLfloat def[1] = {0}; + GLfloat res[4]; + GLboolean pass; + (*vertexAttrib1fvARB)(6, v); + (*getVertexAttribfvARB)(6, GL_CURRENT_VERTEX_ATTRIB_ARB, res); + pass = (res[0] == 25.0 && res[1] == 0.0 && res[2] == 0.0 && res[3] == 1.0); + (*vertexAttrib1fvARB)(6, def); + return pass; +} + +static GLboolean +test_VertexAttrib4NubvARB(generic_func func) +{ + PFNGLVERTEXATTRIB4NUBVARBPROC vertexAttrib4NubvARB = (PFNGLVERTEXATTRIB4NUBVARBPROC) func; + PFNGLGETVERTEXATTRIBFVARBPROC getVertexAttribfvARB = (PFNGLGETVERTEXATTRIBFVARBPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvARB"); + + const GLubyte v[4] = {255, 0, 255, 0}; + const GLubyte def[4] = {0, 0, 0, 255}; + GLfloat res[4]; + GLboolean pass; + (*vertexAttrib4NubvARB)(6, v); + (*getVertexAttribfvARB)(6, GL_CURRENT_VERTEX_ATTRIB_ARB, res); + pass = (res[0] == 1.0 && res[1] == 0.0 && res[2] == 1.0 && res[3] == 0.0); + (*vertexAttrib4NubvARB)(6, def); + return pass; +} + + +static GLboolean +test_VertexAttrib4NuivARB(generic_func func) +{ + PFNGLVERTEXATTRIB4NUIVARBPROC vertexAttrib4NuivARB = (PFNGLVERTEXATTRIB4NUIVARBPROC) func; + PFNGLGETVERTEXATTRIBFVARBPROC getVertexAttribfvARB = (PFNGLGETVERTEXATTRIBFVARBPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvARB"); + + const GLuint v[4] = {0xffffffff, 0, 0xffffffff, 0}; + const GLuint def[4] = {0, 0, 0, 0xffffffff}; + GLfloat res[4]; + GLboolean pass; + (*vertexAttrib4NuivARB)(6, v); + (*getVertexAttribfvARB)(6, GL_CURRENT_VERTEX_ATTRIB_ARB, res); + pass = (EQUAL(res[0], 1.0) && EQUAL(res[1], 0.0) && EQUAL(res[2], 1.0) && EQUAL(res[3], 0.0)); + (*vertexAttrib4NuivARB)(6, def); + return pass; +} + + +static GLboolean +test_VertexAttrib4ivARB(generic_func func) +{ + PFNGLVERTEXATTRIB4IVARBPROC vertexAttrib4ivARB = (PFNGLVERTEXATTRIB4IVARBPROC) func; + PFNGLGETVERTEXATTRIBFVARBPROC getVertexAttribfvARB = (PFNGLGETVERTEXATTRIBFVARBPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvARB"); + + const GLint v[4] = {1, 2, -3, 4}; + const GLint def[4] = {0, 0, 0, 1}; + GLfloat res[4]; + GLboolean pass; + (*vertexAttrib4ivARB)(6, v); + (*getVertexAttribfvARB)(6, GL_CURRENT_VERTEX_ATTRIB_ARB, res); + pass = (EQUAL(res[0], 1.0) && EQUAL(res[1], 2.0) && EQUAL(res[2], -3.0) && EQUAL(res[3], 4.0)); + (*vertexAttrib4ivARB)(6, def); + return pass; +} + + +static GLboolean +test_VertexAttrib4NsvARB(generic_func func) +{ + PFNGLVERTEXATTRIB4NSVARBPROC vertexAttrib4NsvARB = (PFNGLVERTEXATTRIB4NSVARBPROC) func; + PFNGLGETVERTEXATTRIBFVARBPROC getVertexAttribfvARB = (PFNGLGETVERTEXATTRIBFVARBPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvARB"); + + const GLshort v[4] = {0, 32767, 32767, 0}; + const GLshort def[4] = {0, 0, 0, 32767}; + GLfloat res[4]; + GLboolean pass; + (*vertexAttrib4NsvARB)(6, v); + (*getVertexAttribfvARB)(6, GL_CURRENT_VERTEX_ATTRIB_ARB, res); + pass = (EQUAL(res[0], 0.0) && EQUAL(res[1], 1.0) && EQUAL(res[2], 1.0) && EQUAL(res[3], 0.0)); + (*vertexAttrib4NsvARB)(6, def); + return pass; +} + + +static GLboolean +test_VertexAttrib4NusvARB(generic_func func) +{ + PFNGLVERTEXATTRIB4NUSVARBPROC vertexAttrib4NusvARB = (PFNGLVERTEXATTRIB4NUSVARBPROC) func; + PFNGLGETVERTEXATTRIBFVARBPROC getVertexAttribfvARB = (PFNGLGETVERTEXATTRIBFVARBPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvARB"); + + const GLushort v[4] = {0xffff, 0, 0xffff, 0}; + const GLushort def[4] = {0, 0, 0, 0xffff}; + GLfloat res[4]; + GLboolean pass; + (*vertexAttrib4NusvARB)(6, v); + (*getVertexAttribfvARB)(6, GL_CURRENT_VERTEX_ATTRIB_ARB, res); + pass = (EQUAL(res[0], 1.0) && EQUAL(res[1], 0.0) && EQUAL(res[2], 1.0) && EQUAL(res[3], 0.0)); + (*vertexAttrib4NusvARB)(6, def); + return pass; +} + + +static GLboolean +test_VertexAttrib4ubNV(generic_func func) +{ + PFNGLVERTEXATTRIB4UBNVPROC vertexAttrib4ubNV = (PFNGLVERTEXATTRIB4UBNVPROC) func; + PFNGLGETVERTEXATTRIBFVNVPROC getVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvNV"); + + const GLubyte v[4] = {255, 0, 255, 0}; + const GLubyte def[4] = {0, 0, 0, 255}; + GLfloat res[4]; + GLboolean pass; + (*vertexAttrib4ubNV)(6, v[0], v[1], v[2], v[3]); + (*getVertexAttribfvNV)(6, GL_CURRENT_ATTRIB_NV, res); + pass = (res[0] == 1.0 && res[1] == 0.0 && res[2] == 1.0 && res[3] == 0.0); + (*vertexAttrib4ubNV)(6, def[0], def[1], def[2], def[3]); + return pass; +} + + +static GLboolean +test_VertexAttrib2sNV(generic_func func) +{ + PFNGLVERTEXATTRIB2SNVPROC vertexAttrib2sNV = (PFNGLVERTEXATTRIB2SNVPROC) func; + PFNGLGETVERTEXATTRIBFVNVPROC getVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvNV"); + + const GLshort v[2] = {2, -4,}; + const GLshort def[2] = {0, 0}; + GLfloat res[4]; + GLboolean pass; + (*vertexAttrib2sNV)(6, v[0], v[1]); + (*getVertexAttribfvNV)(6, GL_CURRENT_ATTRIB_NV, res); + pass = (EQUAL(res[0], 2) && EQUAL(res[1], -4) && EQUAL(res[2], 0) && res[3] == 1.0); + (*vertexAttrib2sNV)(6, def[0], def[1]); + return pass; +} + + +static GLboolean +test_VertexAttrib3fNV(generic_func func) +{ + PFNGLVERTEXATTRIB3FNVPROC vertexAttrib3fNV = (PFNGLVERTEXATTRIB3FNVPROC) func; + PFNGLGETVERTEXATTRIBFVNVPROC getVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvNV"); + + const GLfloat v[3] = {0.2, 0.4, 0.8}; + const GLfloat def[3] = {0, 0, 0}; + GLfloat res[4]; + GLboolean pass; + (*vertexAttrib3fNV)(6, v[0], v[1], v[2]); + (*getVertexAttribfvNV)(6, GL_CURRENT_ATTRIB_NV, res); + pass = (EQUAL(res[0], 0.2) && EQUAL(res[1], 0.4) && EQUAL(res[2], 0.8) && res[3] == 1.0); + (*vertexAttrib3fNV)(6, def[0], def[1], def[2]); + return pass; +} + + +static GLboolean +test_VertexAttrib4dvNV(generic_func func) +{ + PFNGLVERTEXATTRIB4DVNVPROC vertexAttrib4dvNV = (PFNGLVERTEXATTRIB4DVNVPROC) func; + PFNGLGETVERTEXATTRIBFVNVPROC getVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC) glXGetProcAddressARB((const GLubyte *) "glGetVertexAttribfvNV"); + + const GLdouble v[4] = {0.2, 0.4, 0.8, 1.2}; + const GLdouble def[4] = {0, 0, 0, 1}; + GLfloat res[4]; + GLboolean pass; + (*vertexAttrib4dvNV)(6, v); + (*getVertexAttribfvNV)(6, GL_CURRENT_ATTRIB_NV, res); + pass = (EQUAL(res[0], 0.2) && EQUAL(res[1], 0.4) && EQUAL(res[2], 0.8) && EQUAL(res[3], 1.2)); + (*vertexAttrib4dvNV)(6, def); + return pass; +} + + +/* + * The following header file is auto-generated with Python. The Python + * script looks in this file for functions named "test_*" as seen above. + */ +#include "getproclist.h" + + + +static int +extension_supported(const char *haystack, const char *needle) +{ + if (strstr(haystack, needle)) + return 1; + else + return 0; +} + + +static void +check_functions( const char *extensions ) +{ + struct name_test_pair *entry; + int failures = 0, passes = 0; + int totalFail = 0, totalPass = 0; + int doTests; + + for (entry = functions; entry->name; entry++) { + if (entry->name[0] == '-') { + /* XXX update for OpenGL 2.0 */ + if (entry->name[1] == '1') { + /* check GL version X.Y */ + const char *version = (const char *) glGetString(GL_VERSION); + if (version[0] == entry->name[1] && + version[1] == entry->name[2] && + version[2] >= entry->name[3]) + doTests = 1; + else + doTests = 0; + } + else { + /* check if the named extension is available */ + doTests = extension_supported(extensions, entry->name+1); + } + if (doTests) + printf("Testing %s functions\n", entry->name + 1); + totalFail += failures; + totalPass += passes; + failures = 0; + passes = 0; + } + else if (doTests) { + generic_func funcPtr = (generic_func) glXGetProcAddressARB((const GLubyte *) entry->name); + if (funcPtr) { + if (entry->test) { + GLboolean b; + printf(" Validating %s:", entry->name); + b = (*entry->test)(funcPtr); + if (b) { + printf(" Pass\n"); + passes++; + } + else { + printf(" FAIL!!!\n"); + failures++; + } + } + else { + passes++; + } + } + else { + printf(" glXGetProcAddress(%s) failed!\n", entry->name); + failures++; + } + } + + if (doTests && (!(entry+1)->name || (entry+1)->name[0] == '-')) { + if (failures > 0) { + printf(" %d failed.\n", failures); + } + if (passes > 0) { + printf(" %d passed.\n", passes); + } + } + } + totalFail += failures; + totalPass += passes; + + printf("-----------------------------\n"); + printf("Total: %d pass %d fail\n", totalPass, totalFail); +} + + + +static void +print_screen_info(Display *dpy, int scrnum, Bool allowDirect) +{ + Window win; + int attribSingle[] = { + GLX_RGBA, + GLX_RED_SIZE, 1, + GLX_GREEN_SIZE, 1, + GLX_BLUE_SIZE, 1, + None }; + int attribDouble[] = { + GLX_RGBA, + GLX_RED_SIZE, 1, + GLX_GREEN_SIZE, 1, + GLX_BLUE_SIZE, 1, + GLX_DOUBLEBUFFER, + None }; + + XSetWindowAttributes attr; + unsigned long mask; + Window root; + GLXContext ctx; + XVisualInfo *visinfo; + int width = 100, height = 100; + + root = RootWindow(dpy, scrnum); + + visinfo = glXChooseVisual(dpy, scrnum, attribSingle); + if (!visinfo) { + visinfo = glXChooseVisual(dpy, scrnum, attribDouble); + if (!visinfo) { + fprintf(stderr, "Error: couldn't find RGB GLX visual\n"); + return; + } + } + + attr.background_pixel = 0; + attr.border_pixel = 0; + attr.colormap = XCreateColormap(dpy, root, visinfo->visual, AllocNone); + attr.event_mask = StructureNotifyMask | ExposureMask; + mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask; + win = XCreateWindow(dpy, root, 0, 0, width, height, + 0, visinfo->depth, InputOutput, + visinfo->visual, mask, &attr); + + ctx = glXCreateContext( dpy, visinfo, NULL, allowDirect ); + if (!ctx) { + fprintf(stderr, "Error: glXCreateContext failed\n"); + XDestroyWindow(dpy, win); + return; + } + + if (glXMakeCurrent(dpy, win, ctx)) { + check_functions( (const char *) glGetString(GL_EXTENSIONS) ); + } + else { + fprintf(stderr, "Error: glXMakeCurrent failed\n"); + } + + glXDestroyContext(dpy, ctx); + XDestroyWindow(dpy, win); +} + + +int +main(int argc, char *argv[]) +{ + char *displayName = NULL; + Display *dpy; + + dpy = XOpenDisplay(displayName); + if (!dpy) { + fprintf(stderr, "Error: unable to open display %s\n", displayName); + return -1; + } + + print_screen_info(dpy, 0, GL_TRUE); + + XCloseDisplay(dpy); + + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/getprocaddress.py b/nx-X11/extras/Mesa_6.4.1/progs/tests/getprocaddress.py new file mode 100644 index 000000000..d16b2d93d --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/getprocaddress.py @@ -0,0 +1,93 @@ +#!/usr/bin/env python + +# $Id: getprocaddress.py,v 1.7 2005/06/21 23:42:43 idr Exp $ + +# Helper for the getprocaddress.c test. + +import sys, getopt, re +sys.path.append("../../src/mesa/glapi/" ) +import gl_XML +import license + + +def FindTestFunctions(): + """Scan getprocaddress.c for lines that start with "test_" to find + extension function tests. Return a list of names found.""" + functions = [] + f = open("getprocaddress.c") + if not f: + return functions + for line in f.readlines(): + v = re.search("^test_([a-zA-Z0-9]+)", line) + if v: + func = v.group(1) + functions.append(func) + f.close + return functions + + +class PrintExports(gl_XML.gl_print_base): + def __init__(self): + gl_XML.gl_print_base.__init__(self) + + self.name = "getprocaddress.py (from Mesa)" + self.license = license.bsd_license_template % ( \ +"""Copyright (C) 1999-2001 Brian Paul All Rights Reserved. +(C) Copyright IBM Corporation 2004""", "BRIAN PAUL, IBM") + + self.tests = FindTestFunctions() + self.prevCategory = "" + return + + + def printRealHeader(self): + print """ +struct name_test_pair { + const char *name; + GLboolean (*test)(generic_func); +}; + +static struct name_test_pair functions[] = {""" + + def printBody(self, api): + prev_category = None + + + for f in api.functionIterateByOffset(): + [category, num] = api.get_category_for_name( f.name ) + if category != prev_category: + print ' { "-%s", NULL},' % category + prev_category = category + + test = "NULL" + for name in f.entry_points: + if name in self.tests: + test = "test_%s" % name + break + + print ' { "gl%s", %s },' % (f.name, test) + + print '' + print ' { NULL, NULL }' + print '};' + print '' + return + + +if __name__ == '__main__': + file_name = "../../src/mesa/glapi/gl_API.xml" + + try: + (args, trail) = getopt.getopt(sys.argv[1:], "f:") + except Exception,e: + show_usage() + + for (arg,val) in args: + if arg == "-f": + file_name = val + + printer = PrintExports() + + api = gl_XML.parse_GL_API( file_name, gl_XML.gl_item_factory() ) + + printer.Print( api ) diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/invert.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/invert.c new file mode 100644 index 000000000..750592ed7 --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/invert.c @@ -0,0 +1,195 @@ +/* + * (C) Copyright IBM Corporation 2005 + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * on the rights to use, copy, modify, merge, publish, distribute, sub + * license, and/or sell copies of the Software, and to permit persons to whom + * the Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL + * VA LINUX SYSTEM, IBM AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE + * USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +/** + * \file invert.c + * + * Simple test of GL_MESA_pack_invert functionality. Three squares are + * drawn. The first two should look the same, and the third one should + * look inverted. + * + * \author Ian Romanick <idr@us.ibm.com> + */ + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <GL/glut.h> + +#include "readtex.h" + +#define IMAGE_FILE "../images/tree3.rgb" + +static int Width = 420; +static int Height = 150; +static const GLfloat Near = 5.0, Far = 25.0; + +static GLubyte * image = NULL; +static GLubyte * temp_image = NULL; +static GLuint img_width = 0; +static GLuint img_height = 0; +static GLuint img_format = 0; + +PFNGLWINDOWPOS2IPROC win_pos_2i = NULL; + + +static void Display( void ) +{ + GLint err; + + + glClearColor(0.2, 0.2, 0.8, 0); + glClear( GL_COLOR_BUFFER_BIT ); + + + /* This is the "reference" square. + */ + + (*win_pos_2i)( 5, 5 ); + glDrawPixels( img_width, img_height, img_format, GL_UNSIGNED_BYTE, image ); + + glPixelStorei( GL_PACK_INVERT_MESA, GL_FALSE ); + err = glGetError(); + if ( err != GL_NO_ERROR ) { + printf( "Setting PACK_INVERT_MESA to false generated an error (0x%04x).\n", + err ); + } + + glReadPixels( 5, 5, img_width, img_height, img_format, GL_UNSIGNED_BYTE, temp_image ); + (*win_pos_2i)( 5 + 1 * (10 + img_width), 5 ); + glDrawPixels( img_width, img_height, img_format, GL_UNSIGNED_BYTE, temp_image ); + + glPixelStorei( GL_PACK_INVERT_MESA, GL_TRUE ); + err = glGetError(); + if ( err != GL_NO_ERROR ) { + printf( "Setting PACK_INVERT_MESA to true generated an error (0x%04x).\n", + err ); + } + + glReadPixels( 5, 5, img_width, img_height, img_format, GL_UNSIGNED_BYTE, temp_image ); + (*win_pos_2i)( 5 + 2 * (10 + img_width), 5 ); + glDrawPixels( img_width, img_height, img_format, GL_UNSIGNED_BYTE, temp_image ); + + glutSwapBuffers(); +} + + +static void Reshape( int width, int height ) +{ + GLfloat ar = (float) width / (float) height; + Width = width; + Height = height; + glViewport( 0, 0, width, height ); + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glFrustum( -ar, ar, -1.0, 1.0, Near, Far ); + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); + glTranslatef( 0.0, 0.0, -15.0 ); +} + + +static void Key( unsigned char key, int x, int y ) +{ + (void) x; + (void) y; + switch (key) { + case 27: + exit(0); + break; + } + glutPostRedisplay(); +} + + +static void Init( void ) +{ + const char * const ver_string = (const char * const) + glGetString( GL_VERSION ); + const float ver = strtof( ver_string, NULL ); + + + printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER)); + printf("GL_VERSION = %s\n", ver_string); + + if ( !glutExtensionSupported("GL_MESA_pack_invert") ) { + printf("\nSorry, this program requires GL_MESA_pack_invert.\n"); + exit(1); + } + + if ( ver >= 1.4 ) { + win_pos_2i = (PFNGLWINDOWPOS2IPROC) glutGetProcAddress( "glWindowPos2i" ); + } + else if ( glutExtensionSupported("GL_ARB_window_pos") ) { + win_pos_2i = (PFNGLWINDOWPOS2IPROC) glutGetProcAddress( "glWindowPos2iARB" ); + } + else if ( glutExtensionSupported("GL_MESA_window_pos") ) { + win_pos_2i = (PFNGLWINDOWPOS2IPROC) glutGetProcAddress( "glWindowPos2iMESA" ); + } + + + /* Do this check as a separate if-statement instead of as an else in case + * one of the required extensions is supported but glutGetProcAddress + * returns NULL. + */ + + if ( win_pos_2i == NULL ) { + printf("\nSorry, this program requires either GL 1.4 (or higher),\n" + "GL_ARB_window_pos, or GL_MESA_window_pos.\n"); + exit(1); + } + + printf("\nThe left 2 squares should be the same color, and the right\n" + "square should look upside-down.\n"); + + + image = LoadRGBImage( IMAGE_FILE, & img_width, & img_height, + & img_format ); + if ( image == NULL ) { + printf( "Could not open image file \"%s\".\n", IMAGE_FILE ); + exit(1); + } + + temp_image = malloc( 3 * img_height * img_width ); + if ( temp_image == NULL ) { + printf( "Could not allocate memory for temporary image.\n" ); + exit(1); + } +} + + +int main( int argc, char *argv[] ) +{ + glutInit( &argc, argv ); + glutInitWindowPosition( 0, 0 ); + glutInitWindowSize( Width, Height ); + glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE ); + glutCreateWindow( "GL_MESA_pack_invert test" ); + glutReshapeFunc( Reshape ); + glutKeyboardFunc( Key ); + glutDisplayFunc( Display ); + Init(); + glutMainLoop(); + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/jkrahntest.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/jkrahntest.c new file mode 100644 index 000000000..520dbb84e --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/jkrahntest.c @@ -0,0 +1,177 @@ +/* $Id: jkrahntest.c,v 1.1 2002/06/16 03:57:48 brianp Exp $ */ + +/* This is a good test for glXSwapBuffers on non-current windows, + * and the glXCopyContext function. Fixed several Mesa/DRI bugs with + * this program on 15 June 2002. + * + * Joe's comments follow: + * + * I have tried some different approaches for being able to + * draw to multiple windows using one context, or a copied + * context. Mesa/indirect rendering works to use one context + * for multiple windows, but crashes with glXCopyContext. + * DRI is badly broken, at least for ATI. + * + * I also noticed that glXMakeCurrent allows a window and context + * from different visuals to be attached (haven't tested recently). + * + * Joe Krahn <jkrahn@nc.rr.com> + */ + +#include <GL/glx.h> +#include <GL/gl.h> +#include <string.h> +#include <stdio.h> +#include <stdlib.h> +#include <unistd.h> +#include <math.h> +#define M_PI 3.14159 +#define DEGTOR (M_PI/180.0) + +static int AttributeList[] = { GLX_RGBA, GLX_DOUBLEBUFFER, None }; + +int main(int argc, char **argv) +{ + Window win1, win2; + XVisualInfo *vi; + XSetWindowAttributes swa; + Display *dpy; + GLXContext ctx1, ctx2; + float angle; + int test; + + if (argc < 2) { + fprintf(stderr, "This program tests GLX context switching.\n"); + fprintf(stderr, "Usage: cxbug <n>\n"); + fprintf(stderr, "Where n is:\n"); + fprintf(stderr, "\t1) Use two contexts and swap only when the context is current (typical case).\n"); + fprintf(stderr, "\t2) Use two contexts and swap at the same time.\n"); + fprintf(stderr, "\t\t Used to crash Mesa & nVidia, and DRI artifacts. Seems OK now.\n"); + fprintf(stderr, "\t3) Use one context, but only swap when a context is current.\n"); + fprintf(stderr, "\t\t Serious artifacts for DRI at least with ATI.\n"); + fprintf(stderr, "\t4) Use one context, swap both windows at the same time, so the left\n"); + fprintf(stderr, "\t\t window has no context at swap time. Severe artifacts for DRI.\n"); + fprintf(stderr, "\t5) Use two contexts, copying one to the other when switching windows.\n"); + fprintf(stderr, "\t\t DRI gives an error, indirect rendering crashes server.\n"); + + exit(1); + } + test = atoi(argv[1]); + + /* get a connection */ + dpy = XOpenDisplay(NULL); + + /* Get an appropriate visual */ + vi = glXChooseVisual(dpy, DefaultScreen(dpy), AttributeList); + if (vi == 0) { + fprintf(stderr, "No matching visuals found.\n"); + exit(-1); + } + + /* Create two GLX contexts, with list sharing */ + ctx1 = glXCreateContext(dpy, vi, 0, True); + ctx2 = glXCreateContext(dpy, vi, ctx1, True); + + /* create a colormap */ + swa.colormap = XCreateColormap(dpy, RootWindow(dpy, vi->screen), + vi->visual, AllocNone); + swa.border_pixel = 0; + + /* Create two windows */ + win1 = XCreateWindow(dpy, RootWindow(dpy, vi->screen), + 10, 10, 200, 200, + 0, vi->depth, InputOutput, vi->visual, + CWBorderPixel | CWColormap, &swa); + XStoreName(dpy, win1, "Test [L]"); + XMapWindow(dpy, win1); + XMoveWindow(dpy, win1, 10, 10); /* Initial requested x,y may not be honored */ + { + XSizeHints sizehints; + static const char *name = "window"; + sizehints.x = 10; + sizehints.y = 10; + sizehints.width = 200; + sizehints.height = 200; + sizehints.flags = USSize | USPosition; + XSetNormalHints(dpy, win1, &sizehints); + XSetStandardProperties(dpy, win1, name, name, + None, (char **)NULL, 0, &sizehints); + } + + + win2 = XCreateWindow(dpy, RootWindow(dpy, vi->screen), + 250, 10, 200, 200, + 0, vi->depth, InputOutput, vi->visual, + CWBorderPixel | CWColormap, &swa); + XStoreName(dpy, win1, "Test [R]"); + XMapWindow(dpy, win2); + XMoveWindow(dpy, win2, 260, 10); + { + XSizeHints sizehints; + static const char *name = "window"; + sizehints.x = 10; + sizehints.y = 10; + sizehints.width = 200; + sizehints.height = 200; + sizehints.flags = USSize | USPosition; + XSetNormalHints(dpy, win2, &sizehints); + XSetStandardProperties(dpy, win2, name, name, + None, (char **)NULL, 0, &sizehints); + } + + + /* Now draw some spinning things */ + for (angle = 0; angle < 360*4; angle += 10.0) { + /* Connect the context to window 1 */ + glXMakeCurrent(dpy, win1, ctx1); + + /* Clear and draw in window 1 */ + glDrawBuffer(GL_BACK); + glClearColor(1, 1, 0, 1); + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + glColor3f(1, 0, 0); + glBegin(GL_TRIANGLES); + glVertex2f(0, 0); + glVertex2f(cos(angle * DEGTOR), sin(angle * DEGTOR)); + glVertex2f(cos((angle + 20.0) * DEGTOR), + sin((angle + 20.0) * DEGTOR)); + glEnd(); + glFlush(); + + if (test == 1 || test == 3 || test == 5) + glXSwapBuffers(dpy, win1); + + if (test == 5) + glXCopyContext(dpy, ctx1, ctx2, GL_ALL_ATTRIB_BITS); + /* Connect the context to window 2 */ + if (test == 3 || test == 4) { + glXMakeCurrent(dpy, win2, ctx1); + } else { + glXMakeCurrent(dpy, win2, ctx2); + } + + /* Clear and draw in window 2 */ + glDrawBuffer(GL_BACK); + glClearColor(0, 0, 1, 1); + glClear(GL_COLOR_BUFFER_BIT); + glColor3f(1, 1, 0); + glBegin(GL_TRIANGLES); + glVertex2f(0, 0); + glVertex2f(cos(angle * DEGTOR), sin(angle * DEGTOR)); + glVertex2f(cos((angle + 20.0) * DEGTOR), + sin((angle + 20.0) * DEGTOR)); + glEnd(); + glFlush(); + + /* Swap buffers */ + if (test == 2 || test == 4) + glXSwapBuffers(dpy, win1); + glXSwapBuffers(dpy, win2); + + /* wait a while */ + glXWaitX(); + usleep(20000); + } + + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/manytex.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/manytex.c new file mode 100644 index 000000000..8add125a6 --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/manytex.c @@ -0,0 +1,381 @@ +/* $Id: manytex.c,v 1.4 2002/10/18 17:47:36 kschultz Exp $ */ + +/* + * test handling of many texture maps + * Also tests texture priority and residency. + * + * Brian Paul + * August 2, 2000 + */ + + +#include <assert.h> +#include <stdio.h> +#include <stdlib.h> +#include <math.h> +#include <GL/glut.h> + + +static GLint NumTextures = 20; +static GLuint *TextureID = NULL; +static GLint *TextureWidth = NULL, *TextureHeight = NULL; +static GLboolean *TextureResidency = NULL; +static GLint TexWidth = 128, TexHeight = 128; +static GLfloat Zrot = 0; +static GLboolean Anim = GL_TRUE; +static GLint WinWidth = 500, WinHeight = 400; +static GLboolean MipMap = GL_FALSE; +static GLboolean LinearFilter = GL_FALSE; +static GLboolean RandomSize = GL_FALSE; +static GLint Rows, Columns; +static GLint LowPriorityCount = 0; + + +static void Idle( void ) +{ + Zrot += 1.0; + glutPostRedisplay(); +} + + +static void Display( void ) +{ + GLfloat spacing = WinWidth / Columns; + GLfloat size = spacing * 0.4; + GLint i; + + /* test residency */ + if (0) + { + GLboolean b; + GLint i, resident; + b = glAreTexturesResident(NumTextures, TextureID, TextureResidency); + if (b) { + printf("all resident\n"); + } + else { + resident = 0; + for (i = 0; i < NumTextures; i++) { + if (TextureResidency[i]) { + resident++; + } + } + printf("%d of %d texture resident\n", resident, NumTextures); + } + } + + /* render the textured quads */ + glClear( GL_COLOR_BUFFER_BIT ); + for (i = 0; i < NumTextures; i++) { + GLint row = i / Columns; + GLint col = i % Columns; + GLfloat x = col * spacing + spacing * 0.5; + GLfloat y = row * spacing + spacing * 0.5; + + GLfloat maxDim = (TextureWidth[i] > TextureHeight[i]) + ? TextureWidth[i] : TextureHeight[i]; + GLfloat w = TextureWidth[i] / maxDim; + GLfloat h = TextureHeight[i] / maxDim; + + glPushMatrix(); + glTranslatef(x, y, 0.0); + glRotatef(Zrot, 0, 0, 1); + glScalef(size, size, 1); + + glBindTexture(GL_TEXTURE_2D, TextureID[i]); + glBegin(GL_POLYGON); +#if 0 + glTexCoord2f(0, 0); glVertex2f(-1, -1); + glTexCoord2f(1, 0); glVertex2f( 1, -1); + glTexCoord2f(1, 1); glVertex2f( 1, 1); + glTexCoord2f(0, 1); glVertex2f(-1, 1); +#else + glTexCoord2f(0, 0); glVertex2f(-w, -h); + glTexCoord2f(1, 0); glVertex2f( w, -h); + glTexCoord2f(1, 1); glVertex2f( w, h); + glTexCoord2f(0, 1); glVertex2f(-w, h); +#endif + glEnd(); + glPopMatrix(); + } + + glutSwapBuffers(); +} + + +static void Reshape( int width, int height ) +{ + WinWidth = width; + WinHeight = height; + glViewport( 0, 0, width, height ); + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glOrtho(0, width, 0, height, -1, 1); + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); +} + + +/* + * Return a random int in [min, max]. + */ +static int RandomInt(int min, int max) +{ + int i = rand(); + int j = i % (max - min + 1); + return min + j; +} + + + +static void Init( void ) +{ + GLint i; + + if (RandomSize) { + printf("Creating %d %s random-size textures, ", NumTextures, + MipMap ? "Mipmapped" : "non-Mipmapped"); + } + else { + printf("Creating %d %s %d x %d textures, ", NumTextures, + MipMap ? "Mipmapped" : "non-Mipmapped", + TexWidth, TexHeight); + } + + if (LinearFilter) { + printf("bilinear filtering\n"); + } + else { + printf("nearest filtering\n"); + } + + + /* compute number of rows and columns of rects */ + { + GLfloat area = (GLfloat) (WinWidth * WinHeight) / (GLfloat) NumTextures; + GLfloat edgeLen = sqrt(area); + + Columns = WinWidth / edgeLen; + Rows = (NumTextures + Columns - 1) / Columns; + printf("Rows: %d Cols: %d\n", Rows, Columns); + } + + + if (!TextureID) { + TextureID = (GLuint *) malloc(sizeof(GLuint) * NumTextures); + assert(TextureID); + glGenTextures(NumTextures, TextureID); + } + + if (!TextureResidency) { + TextureResidency = (GLboolean *) malloc(sizeof(GLboolean) * NumTextures); + assert(TextureResidency); + } + + if (!TextureWidth) { + TextureWidth = (GLint *) malloc(sizeof(GLint) * NumTextures); + assert(TextureWidth); + } + if (!TextureHeight) { + TextureHeight = (GLint *) malloc(sizeof(GLint) * NumTextures); + assert(TextureHeight); + } + + for (i = 0; i < NumTextures; i++) { + GLubyte color[4]; + GLubyte *texImage; + GLint j, row, col; + + row = i / Columns; + col = i % Columns; + + glBindTexture(GL_TEXTURE_2D, TextureID[i]); + + if (i < LowPriorityCount) + glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_PRIORITY, 0.5F); + + if (RandomSize) { +#if 0 + int k = (glutGet(GLUT_ELAPSED_TIME) % 7) + 2; + TexWidth = 1 << k; + TexHeight = 1 << k; +#else + TexWidth = 1 << RandomInt(2, 7); + TexHeight = 1 << RandomInt(2, 7); + printf("Random size of %3d: %d x %d\n", i, TexWidth, TexHeight); +#endif + } + + TextureWidth[i] = TexWidth; + TextureHeight[i] = TexHeight; + + texImage = (GLubyte*) malloc(4 * TexWidth * TexHeight * sizeof(GLubyte)); + assert(texImage); + + /* determine texture color */ + color[0] = (GLint) (255.0 * ((float) col / (Columns - 1))); + color[1] = 127; + color[2] = (GLint) (255.0 * ((float) row / (Rows - 1))); + color[3] = 255; + + /* fill in solid-colored teximage */ + for (j = 0; j < TexWidth * TexHeight; j++) { + texImage[j*4+0] = color[0]; + texImage[j*4+1] = color[1]; + texImage[j*4+2] = color[2]; + texImage[j*4+3] = color[3]; + } + + if (MipMap) { + GLint level = 0; + GLint w = TexWidth, h = TexHeight; + while (1) { + glTexImage2D(GL_TEXTURE_2D, level, GL_RGBA, w, h, 0, + GL_RGBA, GL_UNSIGNED_BYTE, texImage); + if (w == 1 && h == 1) + break; + if (w > 1) + w /= 2; + if (h > 1) + h /= 2; + level++; + /*printf("%d: %d x %d\n", level, w, h);*/ + } + if (LinearFilter) { + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, + GL_LINEAR_MIPMAP_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + } + else { + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, + GL_NEAREST_MIPMAP_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + } + } + else { + /* Set corners to white */ + int k = 0; + texImage[k+0] = texImage[k+1] = texImage[k+2] = texImage[k+3] = 255; + k = (TexWidth - 1) * 4; + texImage[k+0] = texImage[k+1] = texImage[k+2] = texImage[k+3] = 255; + k = (TexWidth * TexHeight - TexWidth) * 4; + texImage[k+0] = texImage[k+1] = texImage[k+2] = texImage[k+3] = 255; + k = (TexWidth * TexHeight - 1) * 4; + texImage[k+0] = texImage[k+1] = texImage[k+2] = texImage[k+3] = 255; + + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, TexWidth, TexHeight, 0, + GL_RGBA, GL_UNSIGNED_BYTE, texImage); + if (LinearFilter) { + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + } + else { + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + } + } + + free(texImage); + } + + glEnable(GL_TEXTURE_2D); +} + + +static void Key( unsigned char key, int x, int y ) +{ + const GLfloat step = 3.0; + (void) x; + (void) y; + switch (key) { + case 'a': + Anim = !Anim; + if (Anim) + glutIdleFunc(Idle); + else + glutIdleFunc(NULL); + break; + case 's': + Idle(); + break; + case 'z': + Zrot -= step; + break; + case 'Z': + Zrot += step; + break; + case ' ': + Init(); + break; + case 27: + exit(0); + break; + } + glutPostRedisplay(); +} + + +int main( int argc, char *argv[] ) +{ + GLint i; + + glutInit( &argc, argv ); + glutInitWindowPosition( 0, 0 ); + glutInitWindowSize( WinWidth, WinHeight ); + glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE ); + glutCreateWindow(argv[0]); + glutReshapeFunc( Reshape ); + glutKeyboardFunc( Key ); + glutDisplayFunc( Display ); + if (Anim) + glutIdleFunc(Idle); + + for (i = 1; i < argc; i++) { + if (strcmp(argv[i], "-n") == 0) { + NumTextures = atoi(argv[i+1]); + if (NumTextures <= 0) { + printf("Error, bad number of textures\n"); + return 1; + } + i++; + } + else if (strcmp(argv[i], "-mipmap") == 0) { + MipMap = GL_TRUE; + } + else if (strcmp(argv[i], "-linear") == 0) { + LinearFilter = GL_TRUE; + } + else if (strcmp(argv[i], "-size") == 0) { + TexWidth = atoi(argv[i+1]); + TexHeight = atoi(argv[i+2]); + assert(TexWidth >= 1); + assert(TexHeight >= 1); + i += 2; + } + else if (strcmp(argv[i], "-randomsize") == 0) { + RandomSize = GL_TRUE; + } + else if (strcmp(argv[i], "-lowpri") == 0) { + LowPriorityCount = atoi(argv[i+1]); + i++; + } + else { + printf("Usage:\n"); + printf(" manytex [options]\n"); + printf("Options:\n"); + printf(" -n <number of texture objects>\n"); + printf(" -size <width> <height> - specify texture size\n"); + printf(" -randomsize - use random size textures\n"); + printf(" -mipmap - generate mipmaps\n"); + printf(" -linear - use linear filtering instead of nearest\n"); + printf(" -lowpri <n> - Set lower priority on <n> textures\n"); + return 0; + } + } + + Init(); + + glutMainLoop(); + + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/multipal.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/multipal.c new file mode 100644 index 000000000..c824b3870 --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/multipal.c @@ -0,0 +1,377 @@ +/* $Id: multipal.c,v 1.6 2003/12/08 09:03:36 joukj Exp $ */ + +/* + * Test multitexture and paletted textures. + */ + +#include <assert.h> +#include <math.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#ifdef __VMS +# include <stddef.h> /* for ptrdiff_t, referenced by GL.h when GL_GLEXT_LEGACY defined */ +#else +# include <malloc.h> /* for ptrdiff_t, referenced by GL.h when GL_GLEXT_LEGACY defined */ +#endif +#ifdef _WIN32 +#include <windows.h> +#endif +#define GL_GLEXT_LEGACY +#include <GL/glut.h> + +#include "../util/readtex.c" /* I know, this is a hack. */ + +#define TEXTURE_1_FILE "../images/tile.rgb" +#define TEXTURE_2_FILE "../images/reflect.rgb" + +#define TEX0 1 +#define TEX1 2 +#define TEXBOTH 3 +#define ANIMATE 10 +#define QUIT 100 + +static GLboolean Animate = GL_TRUE; + +static GLfloat Drift = 0.0; +static GLfloat Xrot = 20.0, Yrot = 30.0, Zrot = 0.0; + + + +static void Idle( void ) +{ + if (Animate) { + Drift += 0.05; + if (Drift >= 1.0) + Drift = 0.0; + +#ifdef GL_ARB_multitexture + glActiveTextureARB(GL_TEXTURE0_ARB); +#endif + glMatrixMode(GL_TEXTURE); + glLoadIdentity(); + glTranslatef(Drift, 0.0, 0.0); + glMatrixMode(GL_MODELVIEW); + +#ifdef GL_ARB_multitexture + glActiveTextureARB(GL_TEXTURE1_ARB); +#endif + glMatrixMode(GL_TEXTURE); + glLoadIdentity(); + glTranslatef(0.0, Drift, 0.0); + glMatrixMode(GL_MODELVIEW); + + glutPostRedisplay(); + } +} + + +static void DrawObject(void) +{ + glBegin(GL_QUADS); + +#ifdef GL_ARB_multitexture + glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 0.0, 0.0); + glMultiTexCoord2fARB(GL_TEXTURE1_ARB, 0.0, 0.0); + glVertex2f(-1.0, -1.0); + + glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 2.0, 0.0); + glMultiTexCoord2fARB(GL_TEXTURE1_ARB, 1.0, 0.0); + glVertex2f(1.0, -1.0); + + glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 2.0, 2.0); + glMultiTexCoord2fARB(GL_TEXTURE1_ARB, 1.0, 1.0); + glVertex2f(1.0, 1.0); + + glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 0.0, 2.0); + glMultiTexCoord2fARB(GL_TEXTURE1_ARB, 0.0, 1.0); + glVertex2f(-1.0, 1.0); +#else + glTexCoord2f(0.0, 0.0); + glVertex2f(-1.0, -1.0); + + glTexCoord2f(1.0, 0.0); + glVertex2f(1.0, -1.0); + + glTexCoord2f(1.0, 1.0); + glVertex2f(1.0, 1.0); + + glTexCoord2f(0.0, 1.0); + glVertex2f(-1.0, 1.0); +#endif + + glEnd(); +} + + + +static void Display( void ) +{ + glClear( GL_COLOR_BUFFER_BIT ); + + glPushMatrix(); + glRotatef(Xrot, 1.0, 0.0, 0.0); + glRotatef(Yrot, 0.0, 1.0, 0.0); + glRotatef(Zrot, 0.0, 0.0, 1.0); + glScalef(5.0, 5.0, 5.0); + DrawObject(); + glPopMatrix(); + + glutSwapBuffers(); +} + + +static void Reshape( int width, int height ) +{ + glViewport( 0, 0, width, height ); + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glFrustum( -1.0, 1.0, -1.0, 1.0, 10.0, 100.0 ); + /*glOrtho( -6.0, 6.0, -6.0, 6.0, 10.0, 100.0 );*/ + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); + glTranslatef( 0.0, 0.0, -70.0 ); +} + + +static void ModeMenu(int entry) +{ + GLboolean enable0 = GL_FALSE, enable1 = GL_FALSE; + if (entry==TEX0) { + enable0 = GL_TRUE; + } + else if (entry==TEX1) { + enable1 = GL_TRUE; + } + else if (entry==TEXBOTH) { + enable0 = GL_TRUE; + enable1 = GL_TRUE; + } + else if (entry==ANIMATE) { + Animate = !Animate; + } + else if (entry==QUIT) { + exit(0); + } + + if (entry != ANIMATE) { +#ifdef GL_ARB_multitexture + glActiveTextureARB(GL_TEXTURE0_ARB); +#endif + if (enable0) { + glEnable(GL_TEXTURE_2D); + } + else + glDisable(GL_TEXTURE_2D); + +#ifdef GL_ARB_multitexture + glActiveTextureARB(GL_TEXTURE1_ARB); +#endif + if (enable1) { + glEnable(GL_TEXTURE_2D); + } + else + glDisable(GL_TEXTURE_2D); + } + + glutPostRedisplay(); +} + + +static void Key( unsigned char key, int x, int y ) +{ + (void) x; + (void) y; + switch (key) { + case 27: + exit(0); + break; + } + glutPostRedisplay(); +} + + +static void SpecialKey( int key, int x, int y ) +{ + float step = 3.0; + (void) x; + (void) y; + + switch (key) { + case GLUT_KEY_UP: + Xrot += step; + break; + case GLUT_KEY_DOWN: + Xrot -= step; + break; + case GLUT_KEY_LEFT: + Yrot += step; + break; + case GLUT_KEY_RIGHT: + Yrot -= step; + break; + } + glutPostRedisplay(); +} + + +static void load_tex(const char *fname, int channel) +{ + GLubyte *image; + GLenum format; + GLint w, h; + GLubyte *grayImage; + int i; + GLubyte table[256][4]; + + image = LoadRGBImage(fname, &w, &h, &format); + if (!image) + exit(1); + + printf("%s %d x %d\n", fname, w, h); + grayImage = malloc(w * h * 1); + assert(grayImage); + for (i = 0; i < w * h; i++) { + int g = (image[i*3+0] + image[i*3+1] + image[i*3+2]) / 3; + assert(g < 256); + grayImage[i] = g; + } + + glTexImage2D(GL_TEXTURE_2D, 0, GL_COLOR_INDEX, w, h, 0, GL_COLOR_INDEX, + GL_UNSIGNED_BYTE, grayImage); + + for (i = 0; i < 256; i++) { + table[i][0] = channel ? i : 0; + table[i][1] = i; + table[i][2] = channel ? 0 : i; + table[i][3] = 255; + } + + glColorTableEXT(GL_TEXTURE_2D, /* target */ + GL_RGBA, /* internal format */ + 256, /* table size */ + GL_RGBA, /* table format */ + GL_UNSIGNED_BYTE, /* table type */ + table); /* the color table */ + + free(grayImage); + free(image); +} + + + +static void Init( int argc, char *argv[] ) +{ + GLuint texObj[2]; + GLint units; + + if (!glutExtensionSupported("GL_ARB_multitexture")) { + printf("Sorry, GL_ARB_multitexture not supported by this renderer.\n"); + exit(1); + } + if (!glutExtensionSupported("GL_EXT_paletted_texture")) { + printf("Sorry, GL_EXT_paletted_texture not supported by this renderer.\n"); + exit(1); + } + + glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &units); + printf("%d texture units supported\n", units); + + /* allocate two texture objects */ + glGenTextures(2, texObj); + + /* setup texture obj 0 */ + glBindTexture(GL_TEXTURE_2D, texObj[0]); +#ifdef LINEAR_FILTER + /* linear filtering looks much nicer but is much slower for Mesa */ + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); +foo +#else + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); +#endif + + glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); + + glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + + load_tex(TEXTURE_1_FILE, 0); +#if 0 + if (!LoadRGBMipmaps(TEXTURE_1_FILE, GL_RGB)) { + printf("Error: couldn't load texture image\n"); + exit(1); + } +#endif + + /* setup texture obj 1 */ + glBindTexture(GL_TEXTURE_2D, texObj[1]); +#ifdef LINEAR_FILTER + /* linear filtering looks much nicer but is much slower for Mesa */ + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); +foo +#else + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); +#endif + + glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); + + load_tex(TEXTURE_2_FILE, 1); +#if 0 + if (!LoadRGBMipmaps(TEXTURE_2_FILE, GL_RGB)) { + printf("Error: couldn't load texture image\n"); + exit(1); + } +#endif + + /* now bind the texture objects to the respective texture units */ +#ifdef GL_ARB_multitexture + glActiveTextureARB(GL_TEXTURE0_ARB); + glBindTexture(GL_TEXTURE_2D, texObj[0]); + glActiveTextureARB(GL_TEXTURE1_ARB); + glBindTexture(GL_TEXTURE_2D, texObj[1]); +#endif + + glShadeModel(GL_FLAT); + glClearColor(0.3, 0.3, 0.4, 1.0); + + ModeMenu(TEXBOTH); + + if (argc > 1 && strcmp(argv[1], "-info")==0) { + printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER)); + printf("GL_VERSION = %s\n", (char *) glGetString(GL_VERSION)); + printf("GL_VENDOR = %s\n", (char *) glGetString(GL_VENDOR)); + printf("GL_EXTENSIONS = %s\n", (char *) glGetString(GL_EXTENSIONS)); + } +} + + +int main( int argc, char *argv[] ) +{ + glutInit( &argc, argv ); + glutInitWindowSize( 300, 300 ); + glutInitWindowPosition( 0, 0 ); + glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE ); + glutCreateWindow(argv[0] ); + + Init( argc, argv ); + + glutReshapeFunc( Reshape ); + glutKeyboardFunc( Key ); + glutSpecialFunc( SpecialKey ); + glutDisplayFunc( Display ); + glutIdleFunc( Idle ); + + glutCreateMenu(ModeMenu); + glutAddMenuEntry("Texture 0", TEX0); + glutAddMenuEntry("Texture 1", TEX1); + glutAddMenuEntry("Multi-texture", TEXBOTH); + glutAddMenuEntry("Toggle Animation", ANIMATE); + glutAddMenuEntry("Quit", QUIT); + glutAttachMenu(GLUT_RIGHT_BUTTON); + + glutMainLoop(); + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/multitexarray.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/multitexarray.c new file mode 100644 index 000000000..b4fab004a --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/multitexarray.c @@ -0,0 +1,238 @@ +/* + * Test vertex arrays and multitexture. + * Press 'a' to toggle vertex arrays on/off. + * When you run this program you should see a square with four colors: + * + * +------+------+ + * |yellow| pink | + * +------+------+ + * |green | blue | + * +------+------+ + */ + + +#include <assert.h> +#include <math.h> +#include <stdlib.h> +#include <stdio.h> +#include <string.h> +#include "GL/glut.h" + +static GLuint Window = 0; + +static GLuint TexObj[2]; +static GLfloat Angle = 0.0f; +static GLboolean UseArrays = 1, Anim = 0; + +static GLfloat VertArray[4][2] = { + {-1.2, -1.2}, {1.2, -1.2}, {1.2, 1.2}, {-1.2, 1.2} +}; + +static GLfloat Tex0Array[4][2] = { + {0, 0}, {1, 0}, {1, 1}, {0, 1} +}; + +static GLfloat Tex1Array[4][2] = { + {0, 0}, {1, 0}, {1, 1}, {0, 1} +}; + + +static void init_arrays(void) +{ + glVertexPointer(2, GL_FLOAT, 0, VertArray); + glEnableClientState(GL_VERTEX_ARRAY); + + glClientActiveTextureARB(GL_TEXTURE0_ARB); + glTexCoordPointer(2, GL_FLOAT, 0, Tex0Array); + glEnableClientState(GL_TEXTURE_COORD_ARRAY); + + glClientActiveTextureARB(GL_TEXTURE1_ARB); + glTexCoordPointer(2, GL_FLOAT, 0, Tex1Array); + glEnableClientState(GL_TEXTURE_COORD_ARRAY); +} + + +static void draw( void ) +{ + glClear( GL_COLOR_BUFFER_BIT ); + + glColor3f( 0.0, 0.0, 0.0 ); + + /* draw first polygon */ + glPushMatrix(); + glRotatef( Angle, 0.0, 0.0, 1.0 ); + + if (UseArrays) { + glDrawArrays(GL_POLYGON, 0, 4); + } + else { + glBegin( GL_POLYGON ); + glTexCoord2f( 0.0, 0.0 ); + glMultiTexCoord2fARB(GL_TEXTURE1_ARB, 0.0, 0.0); + glVertex2f( -1.0, -1.0 ); + + glTexCoord2f( 1.0, 0.0 ); + glMultiTexCoord2fARB(GL_TEXTURE1_ARB, 1.0, 0.0); + glVertex2f( 1.0, -1.0 ); + + glTexCoord2f( 1.0, 1.0 ); + glMultiTexCoord2fARB(GL_TEXTURE1_ARB, 1.0, 1.0); + glVertex2f( 1.0, 1.0 ); + + glTexCoord2f( 0.0, 1.0 ); + glMultiTexCoord2fARB(GL_TEXTURE1_ARB, 0.0, 1.0); + glVertex2f( -1.0, 1.0 ); + glEnd(); + } + + glPopMatrix(); + + glutSwapBuffers(); +} + + + +static void idle( void ) +{ + Angle += 2.0; + glutPostRedisplay(); +} + + + +/* change view Angle, exit upon ESC */ +static void key(unsigned char k, int x, int y) +{ + (void) x; + (void) y; + switch (k) { + case 'a': + UseArrays = !UseArrays; + printf("UseArrays: %d\n", UseArrays); + break; + case ' ': + Anim = !Anim; + if (Anim) + glutIdleFunc(idle); + else + glutIdleFunc(NULL); + break; + case 27: + glDeleteTextures( 2, TexObj ); + glutDestroyWindow(Window); + exit(0); + } + glutPostRedisplay(); +} + + + +/* new window size or exposure */ +static void reshape( int width, int height ) +{ + glViewport(0, 0, (GLint)width, (GLint)height); + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + /* glOrtho( -3.0, 3.0, -3.0, 3.0, -10.0, 10.0 );*/ + glFrustum( -2.0, 2.0, -2.0, 2.0, 6.0, 20.0 ); + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + glTranslatef( 0.0, 0.0, -8.0 ); +} + + +static void init( void ) +{ + static int width=8, height=8; + GLubyte tex[64][3]; + GLint i, j; + + /* generate texture object IDs */ + glGenTextures( 2, TexObj ); + + /* + * setup first texture object + */ + glActiveTextureARB(GL_TEXTURE0_ARB); + glEnable( GL_TEXTURE_2D ); + glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_ADD ); + + glBindTexture( GL_TEXTURE_2D, TexObj[0] ); + assert(glIsTexture(TexObj[0])); + + /* red over black */ + for (i=0;i<height;i++) { + for (j=0;j<width;j++) { + int p = i*width+j; + if (i < height / 2) { + tex[p][0] = 0; tex[p][1] = 0; tex[p][2] = 0; + } + else { + tex[p][0] = 255; tex[p][1] = 0; tex[p][2] = 0; + } + } + } + + glTexImage2D( GL_TEXTURE_2D, 0, 3, width, height, 0, + GL_RGB, GL_UNSIGNED_BYTE, tex ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT ); + + + /* + * setup second texture object + */ + glActiveTextureARB(GL_TEXTURE1_ARB); + glEnable( GL_TEXTURE_2D ); + glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_ADD ); + + glBindTexture( GL_TEXTURE_2D, TexObj[1] ); + assert(glIsTexture(TexObj[1])); + + /* left=green, right = blue */ + for (i=0;i<height;i++) { + for (j=0;j<width;j++) { + int p = i*width+j; + if (j < width / 2) { + tex[p][0] = 0; tex[p][1] = 255; tex[p][2] = 0; + } + else { + tex[p][0] = 0; tex[p][1] = 0; tex[p][2] = 255; + } + } + } + glTexImage2D( GL_TEXTURE_2D, 0, 3, width, height, 0, + GL_RGB, GL_UNSIGNED_BYTE, tex ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT ); +} + + + +int main( int argc, char *argv[] ) +{ + glutInit(&argc, argv); + glutInitWindowPosition(0, 0); + glutInitWindowSize(300, 300); + glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE ); + + Window = glutCreateWindow("Texture Objects"); + if (!Window) { + exit(1); + } + + init(); + init_arrays(); + + glutReshapeFunc( reshape ); + glutKeyboardFunc( key ); + if (Anim) + glutIdleFunc( idle ); + glutDisplayFunc( draw ); + glutMainLoop(); + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/multiwindow.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/multiwindow.c new file mode 100644 index 000000000..e004b0336 --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/multiwindow.c @@ -0,0 +1,169 @@ +/* $Id: multiwindow.c,v 1.1 2001/08/21 14:25:31 brianp Exp $ */ + +/* + * A skeleton/template GLUT program + * + * Written by Brian Paul and in the public domain. + */ + + +/* + * $Log: multiwindow.c,v $ + * Revision 1.1 2001/08/21 14:25:31 brianp + * simple multi-window GLUT test prog + * + * Revision 1.1.1.1 1999/08/19 00:55:42 jtg + * Imported sources + * + * Revision 1.2 1998/11/07 14:20:14 brianp + * added simple rotation, animation of cube + * + * Revision 1.1 1998/11/07 14:14:37 brianp + * Initial revision + * + */ + + +#include <stdio.h> +#include <stdlib.h> +#include <math.h> +#include <GL/glut.h> + + +static GLint Window[2]; + +static GLfloat Xrot = 0, Yrot = 0, Zrot = 0; +static GLboolean Anim = GL_TRUE; + + +static void Idle( void ) +{ + Xrot += 3.0; + Yrot += 4.0; + Zrot += 2.0; + + glutSetWindow(Window[0]); + glutPostRedisplay(); + glutSetWindow(Window[1]); + glutPostRedisplay(); +} + + +static void Display0( void ) +{ + glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); + + glEnable(GL_LIGHTING); + glEnable(GL_LIGHT0); + glEnable(GL_DEPTH_TEST); + + glPushMatrix(); + glRotatef(Xrot, 1, 0, 0); + glRotatef(Yrot, 0, 1, 0); + glRotatef(Zrot, 0, 0, 1); + + glColor3f(0, 1, 0); + glutSolidCube(2.0); + + glPopMatrix(); + + glutSwapBuffers(); +} + + +static void Display1( void ) +{ + glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); + + glPushMatrix(); + glRotatef(Xrot, 1, 0, 0); + glRotatef(Yrot, 0, 1, 0); + glRotatef(Zrot, 0, 0, 1); + + glShadeModel(GL_FLAT); + + glBegin(GL_TRIANGLE_STRIP); + glColor3f(1, 0, 0); + glVertex2f(-1, -1); + glVertex2f( 1, -1); + glColor3f(1, 0, 0); + glVertex2f( -1, 1); + glColor3f(0, 0, 1); + glVertex2f( 1, 1); + glEnd(); + + glPopMatrix(); + + glutSwapBuffers(); +} + + +static void Reshape( int width, int height ) +{ + glViewport( 0, 0, width, height ); + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glFrustum( -1.0, 1.0, -1.0, 1.0, 5.0, 25.0 ); + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); + glTranslatef( 0.0, 0.0, -15.0 ); +} + + +static void Key( unsigned char key, int x, int y ) +{ + const GLfloat step = 3.0; + (void) x; + (void) y; + switch (key) { + case 'a': + Anim = !Anim; + if (Anim) + glutIdleFunc(Idle); + else + glutIdleFunc(NULL); + break; + case 'z': + Zrot -= step; + break; + case 'Z': + Zrot += step; + break; + case 27: + exit(0); + break; + } + glutPostRedisplay(); +} + + + + +int main( int argc, char *argv[] ) +{ + glutInit( &argc, argv ); + + glutInitWindowPosition( 0, 0 ); + glutInitWindowSize( 400, 400 ); + glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH ); + Window[0] = glutCreateWindow(argv[0]); + glutReshapeFunc( Reshape ); + glutKeyboardFunc( Key ); + glutDisplayFunc( Display0 ); + glutIdleFunc(Idle); + printf("GL_RENDERER[0] = %s\n", (char *) glGetString(GL_RENDERER)); + + glutInitWindowPosition( 500, 0 ); + glutInitWindowSize( 400, 400 ); + glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH ); + Window[1] = glutCreateWindow(argv[0]); + glutReshapeFunc( Reshape ); + glutKeyboardFunc( Key ); + glutDisplayFunc( Display1 ); + glutIdleFunc(Idle); + printf("GL_RENDERER[1] = %s\n", (char *) glGetString(GL_RENDERER)); + + glutMainLoop(); + + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/no_s3tc.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/no_s3tc.c new file mode 100644 index 000000000..d3383ff98 --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/no_s3tc.c @@ -0,0 +1,97 @@ +/* + * (C) Copyright IBM Corporation 2004 + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * on the rights to use, copy, modify, merge, publish, distribute, sub + * license, and/or sell copies of the Software, and to permit persons to whom + * the Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL + * VA LINUX SYSTEM, IBM AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE + * USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +/** + * \file no_s3tc.c + * Test program to verify the behavior of an OpenGL implementation when + * an application calls \c glCompressedTexImage2D with an unsupported (but + * valid) compression format. The most common example is calling it with + * \c GL_COMPRESSED_RGBA_S3TC_DXT1_EXT when GL_EXT_texture_compression_s3tc + * is not supported. + * + * This tests Mesa bug #1028405. + * + * \author Ian Romanick <idr@us.ibm.com> + */ + +#include <stdlib.h> +#include <stdio.h> +#include <string.h> +#include <GL/glut.h> +#include <GL/glext.h> + +static unsigned data[16]; + +int +main( int argc, char ** argv ) +{ + float gl_version; + GLenum format; + GLuint size; + GLuint width; + GLenum err; + + + glutInit( & argc, argv ); + glutInitDisplayMode( GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE ); + + glutInitWindowPosition( 0, 0 ); + glutInitWindowSize( 300, 300 ); + glutCreateWindow( "No S3TC Test" ); + + gl_version = strtod( (const char *) glGetString( GL_VERSION ), NULL ); + if ( ! glutExtensionSupported( "GL_ARB_texture_compression" ) + && (gl_version < 1.3) ) { + fprintf( stderr, "Either OpenGL 1.3 or GL_ARB_texture_compression " + "must be supported.\n" ); + return( EXIT_SUCCESS ); + } + + + if ( ! glutExtensionSupported( "GL_EXT_texture_compression_s3tc" ) ) { + format = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT; + width = 4; + size = 8; + } + else if ( ! glutExtensionSupported( "GL_3DFX_texture_compression_FXT1" ) ) { + format = GL_COMPRESSED_RGBA_FXT1_3DFX; + width = 8; + size = 16; + } + else { + fprintf( stderr, "Either GL_EXT_texture_compression_s3tc or " + "GL_3DFX_texture_compression_FXT1 must NOT be supported.\n" ); + return( EXIT_SUCCESS ); + } + + glCompressedTexImage2D( GL_TEXTURE_2D, 0, format, width, 4, 0, + size, data ); + err = glGetError(); + if ( err != GL_INVALID_ENUM ) { + fprintf( stderr, "GL error 0x%04x should have been generated, but " + "0x%04x was generated instead.\n", GL_INVALID_ENUM, err ); + } + + return (err == GL_INVALID_ENUM) ? EXIT_SUCCESS : EXIT_FAILURE; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/packedpixels.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/packedpixels.c new file mode 100644 index 000000000..842cf7f34 --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/packedpixels.c @@ -0,0 +1,299 @@ +/* + * Test packed pixel formats for textures. + * Brian Paul + * 12 May 2004 + */ + +#include <stdio.h> +#include <stdlib.h> +#include <math.h> +#include <string.h> +#include <GL/glut.h> + + +struct pixel_format { + const char *name; + GLenum format; + GLenum type; + GLint bytes; + GLuint redTexel, greenTexel; +}; + +static const struct pixel_format Formats[] = { + + { "GL_RGBA/GL_UNSIGNED_INT_8_8_8_8", + GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, 4, 0xff000000, 0x00ff0000 }, + { "GL_RGBA/GL_UNSIGNED_INT_8_8_8_8_REV", + GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, 4, 0x000000ff, 0x0000ff00 }, + { "GL_RGBA/GL_UNSIGNED_INT_10_10_10_2", + GL_RGBA, GL_UNSIGNED_INT_10_10_10_2, 4, 0xffc00000, 0x3ff000 }, + { "GL_RGBA/GL_UNSIGNED_INT_2_10_10_10_REV", + GL_RGBA, GL_UNSIGNED_INT_2_10_10_10_REV, 4, 0x3ff, 0xffc00 }, + { "GL_RGBA/GL_UNSIGNED_SHORT_4_4_4_4", + GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, 2, 0xf000, 0x0f00 }, + { "GL_RGBA/GL_UNSIGNED_SHORT_4_4_4_4_REV", + GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4_REV, 2, 0x000f, 0x00f0 }, + { "GL_RGBA/GL_UNSIGNED_SHORT_5_5_5_1", + GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1, 2, 0xf800, 0x7c0 }, + { "GL_RGBA/GL_UNSIGNED_SHORT_1_5_5_5_REV", + GL_RGBA, GL_UNSIGNED_SHORT_1_5_5_5_REV, 2, 0x1f, 0x3e0 }, + + { "GL_BGRA/GL_UNSIGNED_INT_8_8_8_8", + GL_BGRA, GL_UNSIGNED_INT_8_8_8_8, 4, 0x0000ff00, 0x00ff0000 }, + { "GL_BGRA/GL_UNSIGNED_INT_8_8_8_8_REV", + GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, 4, 0x00ff0000, 0x0000ff00 }, + { "GL_BGRA/GL_UNSIGNED_SHORT_4_4_4_4", + GL_BGRA, GL_UNSIGNED_SHORT_4_4_4_4, 2, 0x00f0, 0x0f00 }, + { "GL_BGRA/GL_UNSIGNED_SHORT_4_4_4_4_REV", + GL_BGRA, GL_UNSIGNED_SHORT_4_4_4_4_REV, 2, 0x0f00, 0x00f0 }, + { "GL_BGRA/GL_UNSIGNED_SHORT_5_5_5_1", + GL_BGRA, GL_UNSIGNED_SHORT_5_5_5_1, 2, 0x3e, 0x7c0 }, + { "GL_BGRA/GL_UNSIGNED_SHORT_1_5_5_5_REV", + GL_BGRA, GL_UNSIGNED_SHORT_1_5_5_5_REV, 2, 0x7c00, 0x3e0 }, + + { "GL_ABGR_EXT/GL_UNSIGNED_INT_8_8_8_8", + GL_ABGR_EXT, GL_UNSIGNED_INT_8_8_8_8, 4, 0x000000ff, 0x0000ff00 }, + { "GL_ABGR_EXT/GL_UNSIGNED_INT_8_8_8_8_REV", + GL_ABGR_EXT, GL_UNSIGNED_INT_8_8_8_8_REV, 4, 0xff000000, 0x00ff0000 }, + { "GL_ABGR_EXT/GL_UNSIGNED_SHORT_4_4_4_4", + GL_ABGR_EXT, GL_UNSIGNED_SHORT_4_4_4_4, 2, 0x000f, 0x00f0 }, + { "GL_ABGR_EXT/GL_UNSIGNED_SHORT_4_4_4_4_REV", + GL_ABGR_EXT, GL_UNSIGNED_SHORT_4_4_4_4_REV, 2, 0xf000, 0x0f00 }, + { "GL_ABGR_EXT/GL_UNSIGNED_SHORT_5_5_5_1", + GL_ABGR_EXT, GL_UNSIGNED_SHORT_5_5_5_1, 2, 0x1, 0x3e }, + { "GL_ABGR_EXT/GL_UNSIGNED_SHORT_1_5_5_5_REV", + GL_ABGR_EXT, GL_UNSIGNED_SHORT_1_5_5_5_REV, 2, 0x8000, 0x7c00 }, + + { "GL_RGB/GL_UNSIGNED_SHORT_5_6_5", + GL_RGB, GL_UNSIGNED_SHORT_5_6_5, 2, 0xf800, 0x7e0 }, + { "GL_RGB/GL_UNSIGNED_SHORT_5_6_5_REV", + GL_RGB, GL_UNSIGNED_SHORT_5_6_5_REV, 2, 0x1f, 0x7e0 }, + { "GL_RGB/GL_UNSIGNED_BYTE_3_3_2", + GL_RGB, GL_UNSIGNED_BYTE_3_3_2, 1, 0xe0, 0x1c }, + { "GL_RGB/GL_UNSIGNED_BYTE_2_3_3_REV", + GL_RGB, GL_UNSIGNED_BYTE_2_3_3_REV, 1, 0x7, 0x38 }, + + { NULL, 0, 0, 0, 0, 0 } +}; + + +struct name_format { + const char *name; + GLenum format; +}; + +static const struct name_format IntFormats[] = { + { "GL_RGBA", GL_RGBA }, + { "GL_RGBA2", GL_RGBA2 }, + { "GL_RGBA4", GL_RGBA4 }, + { "GL_RGB5_A1", GL_RGB5_A1 }, + { "GL_RGBA8", GL_RGBA8 }, + { "GL_RGBA12", GL_RGBA12 }, + { "GL_RGBA16", GL_RGBA16 }, + { "GL_RGB10_A2", GL_RGB10_A2 }, + + { "GL_RGB", GL_RGB }, + { "GL_R3_G3_B2", GL_R3_G3_B2 }, + { "GL_RGB4", GL_RGB4 }, + { "GL_RGB5", GL_RGB5 }, + { "GL_RGB8", GL_RGB8 }, + { "GL_RGB10", GL_RGB10 }, + { "GL_RGB12", GL_RGB12 }, + { "GL_RGB16", GL_RGB16 }, + +}; + +#define NUM_INT_FORMATS (sizeof(IntFormats) / sizeof(IntFormats[0])) +static GLuint CurFormat = 0; + + +static void +PrintString(const char *s) +{ + while (*s) { + glutBitmapCharacter(GLUT_BITMAP_8_BY_13, (int) *s); + s++; + } +} + + +static void +MakeTexture(const struct pixel_format *format, GLenum intFormat, GLboolean swap) +{ + GLubyte texBuffer[1000]; + int i; + + glPixelStorei(GL_UNPACK_SWAP_BYTES, swap); + + if (format->bytes == 1) { + for (i = 0; i < 8; i++) { + texBuffer[i] = format->redTexel; + } + for (i = 8; i < 16; i++) { + texBuffer[i] = format->greenTexel; + } + } + else if (format->bytes == 2) { + GLushort *us = (GLushort *) texBuffer; + for (i = 0; i < 8; i++) { + us[i] = format->redTexel; + } + for (i = 8; i < 16; i++) { + us[i] = format->greenTexel; + } + if (swap) { + for (i = 0; i < 16; i++) + us[i] = (us[i] << 8) | (us[i] >> 8); + } + } + else if (format->bytes == 4) { + GLuint *ui = (GLuint *) texBuffer; + for (i = 0; i < 8; i++) { + ui[i] = format->redTexel; + } + for (i = 8; i < 16; i++) { + ui[i] = format->greenTexel; + } + if (swap) { + for (i = 0; i < 16; i++) { + GLuint b = ui[i]; + ui[i] = (b >> 24) + | ((b >> 8) & 0xff00) + | ((b << 8) & 0xff0000) + | ((b << 24) & 0xff000000); + } + } + } + else { + abort(); + } + glTexImage2D(GL_TEXTURE_2D, 0, intFormat, 4, 4, 0, + format->format, format->type, texBuffer); + + if (glGetError()) { + printf("GL Error for %s\n", format->name); + memset(texBuffer, 255, 1000); + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 4, 4, 0, + GL_RGB, GL_UNSIGNED_BYTE, texBuffer); + } +} + + + +static void +Draw(void) +{ + char s[1000]; + int w = 350, h = 20; + int i, swap; + + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + + for (swap = 0; swap < 2; swap++) { + for (i = 0; Formats[i].name; i++) { + glPushMatrix(); + glTranslatef(swap * (w + 2), i * (h + 2), 0); + + MakeTexture(Formats + i, IntFormats[CurFormat].format, swap); + + glEnable(GL_TEXTURE_2D); + glBegin(GL_POLYGON); + glTexCoord2f(0, 0); glVertex2f(0, 0); + glTexCoord2f(1, 0); glVertex2f(w, 0); + glTexCoord2f(1, 1); glVertex2f(w, h); + glTexCoord2f(0, 1); glVertex2f(0, h); + glEnd(); + + glDisable(GL_TEXTURE_2D); + glColor3f(0, 0, 0); + glRasterPos2i(8, 6); + PrintString(Formats[i].name); + + glPopMatrix(); + } + } + + glPushMatrix(); + glTranslatef(2, i * (h + 2), 0); + glColor3f(1, 1, 1); + glRasterPos2i(8, 6); + PrintString("Normal"); + glRasterPos2i(w + 2, 6); + PrintString("Byte Swapped"); + glPopMatrix(); + + glPushMatrix(); + glTranslatef(2, (i + 1) * (h + 2), 0); + glRasterPos2i(8, 6); + sprintf(s, "Internal Texture Format [f/F]: %s (%d of %d)", + IntFormats[CurFormat].name, CurFormat + 1, NUM_INT_FORMATS); + PrintString(s); + glPopMatrix(); + + glutSwapBuffers(); +} + + +static void +Reshape(int width, int height) +{ + glViewport(0, 0, width, height); + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + glOrtho(0, width, 0, height, -1, 1); + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); +} + + +static void +Key(unsigned char key, int x, int y) +{ + (void) x; + (void) y; + switch (key) { + case 'F': + if (CurFormat == 0) + CurFormat = NUM_INT_FORMATS - 1; + else + CurFormat--; + break; + case 'f': + CurFormat++; + if (CurFormat == NUM_INT_FORMATS) + CurFormat = 0; + break; + case 27: + exit(0); + break; + } + glutPostRedisplay(); +} + + +static void +Init(void) +{ + printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER)); + printf("GL_VERSION = %s\n", (char *) glGetString(GL_VERSION)); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); +} + + +int +main(int argc, char *argv[]) +{ + glutInit(&argc, argv); + glutInitWindowPosition(0, 0); + glutInitWindowSize(700, 800); + glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH); + glutCreateWindow(argv[0]); + glutReshapeFunc(Reshape); + glutKeyboardFunc(Key); + glutDisplayFunc(Draw); + Init(); + glutMainLoop(); + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/pbo.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/pbo.c new file mode 100644 index 000000000..a74e8e148 --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/pbo.c @@ -0,0 +1,283 @@ +/* + * GL_EXT_pixel_buffer_object test + * + * Brian Paul + * 11 March 2004 + */ + +#define GL_GLEXT_PROTOTYPES + +#include <assert.h> +#include <stdio.h> +#include <stdlib.h> +#include <math.h> +#include <GL/glut.h> + +#include "../util/readtex.c" /* a hack, I know */ + +#define IMAGE_FILE "../images/girl.rgb" + +static int ImgWidth, ImgHeight; +static GLenum ImgFormat; +static GLubyte *Image = NULL; + +static int APosX, APosY; /* simple drawpixels */ +static int BPosX, BPosY; /* read/draw pixels */ +static int CPosX, CPosY; /* copypixels */ + +static GLboolean DrawFront = GL_FALSE; +static GLboolean ScaleAndBias = GL_FALSE; +static GLboolean Benchmark = GL_FALSE; + +static GLuint DrawPBO, TempPBO; + + +static GLenum ReadFormat = GL_RGBA; +static GLenum ReadType = GL_UNSIGNED_BYTE; + + + + +static void +Reset( void ) +{ + APosX = 5; APosY = 20; + BPosX = APosX + ImgWidth + 5; BPosY = 20; + CPosX = BPosX + ImgWidth + 5; CPosY = 20; +} + + +static void +PrintString(const char *s) +{ + while (*s) { + glutBitmapCharacter(GLUT_BITMAP_8_BY_13, (int) *s); + s++; + } +} + + +static void +SetupPixelTransfer(GLboolean invert) +{ + if (invert) { + glPixelTransferf(GL_RED_SCALE, -1.0); + glPixelTransferf(GL_RED_BIAS, 1.0); + glPixelTransferf(GL_GREEN_SCALE, -1.0); + glPixelTransferf(GL_GREEN_BIAS, 1.0); + glPixelTransferf(GL_BLUE_SCALE, -1.0); + glPixelTransferf(GL_BLUE_BIAS, 1.0); + } + else { + glPixelTransferf(GL_RED_SCALE, 1.0); + glPixelTransferf(GL_RED_BIAS, 0.0); + glPixelTransferf(GL_GREEN_SCALE, 1.0); + glPixelTransferf(GL_GREEN_BIAS, 0.0); + glPixelTransferf(GL_BLUE_SCALE, 1.0); + glPixelTransferf(GL_BLUE_BIAS, 0.0); + } +} + + +static void +Display( void ) +{ + glClearColor(.3, .3, .3, 1); + glClear( GL_COLOR_BUFFER_BIT ); + + /** Unbind UNPACK pixel buffer before calling glBitmap */ + glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_EXT, 0); + + glRasterPos2i(5, ImgHeight+25); + PrintString("f = toggle front/back s = toggle scale/bias b = benchmark"); + + glRasterPos2i(5, ImgHeight+40); + PrintString("GL_EXT_pixel_buffer_object test"); + + /* draw original image */ + glRasterPos2i(APosX, 5); + PrintString("Original"); + glRasterPos2i(APosX, APosY); + glEnable(GL_DITHER); + SetupPixelTransfer(GL_FALSE); + /*** Draw from the DrawPBO */ + glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_EXT, DrawPBO); + glDrawPixels(ImgWidth, ImgHeight, ImgFormat, GL_UNSIGNED_BYTE, 0); + glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_EXT, 0); + + /* do readpixels, drawpixels */ + glRasterPos2i(BPosX, 5); + PrintString("Read/DrawPixels"); + SetupPixelTransfer(ScaleAndBias); + /*** read into the Temp PBO */ + glBindBufferARB(GL_PIXEL_PACK_BUFFER_EXT, TempPBO); + if (Benchmark) { + GLint reads = 0; + GLint endTime; + GLint startTime = glutGet(GLUT_ELAPSED_TIME); + GLdouble seconds, pixelsPerSecond; + printf("Benchmarking...\n"); + do { + glReadPixels(APosX, APosY, ImgWidth, ImgHeight, + ReadFormat, ReadType, 0); + reads++; + endTime = glutGet(GLUT_ELAPSED_TIME); + } while (endTime - startTime < 4000); /* 4 seconds */ + seconds = (double) (endTime - startTime) / 1000.0; + pixelsPerSecond = reads * ImgWidth * ImgHeight / seconds; + printf("Result: %d reads in %f seconds = %f pixels/sec\n", + reads, seconds, pixelsPerSecond); + Benchmark = GL_FALSE; + } + else { + glReadPixels(APosX, APosY, ImgWidth, ImgHeight, + ReadFormat, ReadType, 0); + } + glRasterPos2i(BPosX, BPosY); + glDisable(GL_DITHER); + SetupPixelTransfer(GL_FALSE); + /*** draw from the Temp PBO */ + glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_EXT, TempPBO); + glDrawPixels(ImgWidth, ImgHeight, ReadFormat, ReadType, 0); + glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_EXT, 0); + + /* do copypixels */ + glRasterPos2i(CPosX, 5); + PrintString("CopyPixels"); + glRasterPos2i(CPosX, CPosY); + glDisable(GL_DITHER); + SetupPixelTransfer(ScaleAndBias); + glCopyPixels(APosX, APosY, ImgWidth, ImgHeight, GL_COLOR); + + if (!DrawFront) + glutSwapBuffers(); + else + glFinish(); +} + + +static void +Reshape( int width, int height ) +{ + glViewport( 0, 0, width, height ); + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glOrtho( 0.0, width, 0.0, height, -1.0, 1.0 ); + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); +} + + +static void +Key( unsigned char key, int x, int y ) +{ + (void) x; + (void) y; + switch (key) { + case 'b': + Benchmark = GL_TRUE; + break; + case 's': + ScaleAndBias = !ScaleAndBias; + break; + case 'f': + DrawFront = !DrawFront; + if (DrawFront) { + glDrawBuffer(GL_FRONT); + glReadBuffer(GL_FRONT); + } + else { + glDrawBuffer(GL_BACK); + glReadBuffer(GL_BACK); + } + printf("glDrawBuffer(%s)\n", DrawFront ? "GL_FRONT" : "GL_BACK"); + break; + case 27: + exit(0); + break; + } + glutPostRedisplay(); +} + + +static void +Init( GLboolean ciMode ) +{ + printf("GL_VERSION = %s\n", (char *) glGetString(GL_VERSION)); + printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER)); + + if (!glutExtensionSupported("GL_EXT_pixel_buffer_object")) { + printf("Sorry, this demo requires GL_EXT_pixel_buffer_object\n"); + exit(0); + } + + Image = LoadRGBImage( IMAGE_FILE, &ImgWidth, &ImgHeight, &ImgFormat ); + if (!Image) { + printf("Couldn't read %s\n", IMAGE_FILE); + exit(0); + } + + if (ciMode) { + /* Convert RGB image to grayscale */ + GLubyte *indexImage = (GLubyte *) malloc( ImgWidth * ImgHeight ); + GLint i; + for (i=0; i<ImgWidth*ImgHeight; i++) { + int gray = Image[i*3] + Image[i*3+1] + Image[i*3+2]; + indexImage[i] = gray / 3; + } + free(Image); + Image = indexImage; + ImgFormat = GL_COLOR_INDEX; + + for (i=0;i<255;i++) { + float g = i / 255.0; + glutSetColor(i, g, g, g); + } + } + + printf("Loaded %d by %d image\n", ImgWidth, ImgHeight ); + + glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + glPixelStorei(GL_UNPACK_ROW_LENGTH, ImgWidth); + glPixelStorei(GL_PACK_ALIGNMENT, 1); + glPixelStorei(GL_PACK_ROW_LENGTH, ImgWidth); + + Reset(); + + /* put image into DrawPBO */ + glGenBuffersARB(1, &DrawPBO); + glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_EXT, DrawPBO); + glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_EXT, + ImgWidth * ImgHeight * 4, Image, GL_STATIC_DRAW); + + /* Setup TempPBO - used for glReadPixels & glDrawPixels */ + glGenBuffersARB(1, &TempPBO); + glBindBufferARB(GL_PIXEL_PACK_BUFFER_EXT, TempPBO); + glBufferDataARB(GL_PIXEL_PACK_BUFFER_EXT, + ImgWidth * ImgHeight * 4, NULL, GL_DYNAMIC_COPY); + +} + + +int +main( int argc, char *argv[] ) +{ + GLboolean ciMode = GL_FALSE; + if (argc > 1 && strcmp(argv[1], "-ci")==0) { + ciMode = GL_TRUE; + } + glutInit( &argc, argv ); + glutInitWindowPosition( 0, 0 ); + glutInitWindowSize( 750, 250 ); + if (ciMode) + glutInitDisplayMode( GLUT_INDEX | GLUT_DOUBLE ); + else + glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE ); + glutCreateWindow(argv[0]); + Init(ciMode); + glutReshapeFunc( Reshape ); + glutKeyboardFunc( Key ); + glutDisplayFunc( Display ); + glutMainLoop(); + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/projtex.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/projtex.c new file mode 100644 index 000000000..e3ef948ab --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/projtex.c @@ -0,0 +1,1028 @@ + +/* projtex.c - by David Yu and David Blythe, SGI */ + +/** + ** Demonstrates simple projective texture mapping. + ** + ** Button1 changes view, Button2 moves texture. + ** + ** (See: Segal, Korobkin, van Widenfelt, Foran, and Haeberli + ** "Fast Shadows and Lighting Effects Using Texture Mapping", SIGGRAPH '92) + ** + ** 1994,1995 -- David G Yu + ** + ** cc -o projtex projtex.c texture.c -lglut -lGLU -lGL -lX11 -lm + **/ + +#include <assert.h> +#include <stdio.h> +#include <stdlib.h> +#include <math.h> +#include <GL/glut.h> +#if 0 +#include "texture.h" +#else +#include "../util/readtex.c" +#endif + + +/* Some <math.h> files do not define M_PI... */ +#ifndef M_PI +#define M_PI 3.14159265358979323846 +#endif + +#define MAX_TEX 4 +int NumTextures = 1; + +int winWidth, winHeight; + +GLboolean redrawContinuously = GL_FALSE; + +float angle, axis[3]; +enum MoveModes { + MoveNone, MoveView, MoveObject, MoveTexture +}; +enum MoveModes mode = MoveNone; + +GLfloat objectXform[4][4]; +GLfloat textureXform[MAX_TEX][4][4]; + +void (*drawObject) (void); +void (*loadTexture) (void); +GLboolean textureEnabled = GL_TRUE; +GLboolean showProjection = GL_TRUE; +GLboolean linearFilter = GL_TRUE; + +char *texFilename[MAX_TEX] = { + "../images/girl.rgb", + "../images/tile.rgb", + "../images/bw.rgb", + "../images/reflect.rgb" +}; + + +GLfloat zoomFactor = 1.0; + +/*****************************************************************/ + + +void ActiveTexture(int i) +{ + glActiveTextureARB(i); +} + + +/* matrix = identity */ +void +matrixIdentity(GLfloat matrix[16]) +{ + matrix[0] = 1.0; + matrix[1] = 0.0; + matrix[2] = 0.0; + matrix[3] = 0.0; + matrix[4] = 0.0; + matrix[5] = 1.0; + matrix[6] = 0.0; + matrix[7] = 0.0; + matrix[8] = 0.0; + matrix[9] = 0.0; + matrix[10] = 1.0; + matrix[11] = 0.0; + matrix[12] = 0.0; + matrix[13] = 0.0; + matrix[14] = 0.0; + matrix[15] = 1.0; +} + +/* matrix2 = transpose(matrix1) */ +void +matrixTranspose(GLfloat matrix2[16], GLfloat matrix1[16]) +{ + matrix2[0] = matrix1[0]; + matrix2[1] = matrix1[4]; + matrix2[2] = matrix1[8]; + matrix2[3] = matrix1[12]; + + matrix2[4] = matrix1[1]; + matrix2[5] = matrix1[5]; + matrix2[6] = matrix1[9]; + matrix2[7] = matrix1[13]; + + matrix2[8] = matrix1[2]; + matrix2[9] = matrix1[6]; + matrix2[10] = matrix1[10]; + matrix2[11] = matrix1[14]; + + matrix2[12] = matrix1[3]; + matrix2[13] = matrix1[7]; + matrix2[14] = matrix1[14]; + matrix2[15] = matrix1[15]; +} + +/*****************************************************************/ + +/* load SGI .rgb image (pad with a border of the specified width and color) */ +#if 0 +static void +imgLoad(char *filenameIn, int borderIn, GLfloat borderColorIn[4], + int *wOut, int *hOut, GLubyte ** imgOut) +{ + int border = borderIn; + int width, height; + int w, h; + GLubyte *image, *img, *p; + int i, j, components; + + image = (GLubyte *) read_texture(filenameIn, &width, &height, &components); + w = width + 2 * border; + h = height + 2 * border; + img = (GLubyte *) calloc(w * h, 4 * sizeof(unsigned char)); + + p = img; + for (j = -border; j < height + border; ++j) { + for (i = -border; i < width + border; ++i) { + if (0 <= j && j <= height - 1 && 0 <= i && i <= width - 1) { + p[0] = image[4 * (j * width + i) + 0]; + p[1] = image[4 * (j * width + i) + 1]; + p[2] = image[4 * (j * width + i) + 2]; + p[3] = 0xff; + } else { + p[0] = borderColorIn[0] * 0xff; + p[1] = borderColorIn[1] * 0xff; + p[2] = borderColorIn[2] * 0xff; + p[3] = borderColorIn[3] * 0xff; + } + p += 4; + } + } + free(image); + *wOut = w; + *hOut = h; + *imgOut = img; +} +#endif + + +/*****************************************************************/ + +/* Load the image file specified on the command line as the current texture */ +void +loadImageTextures(void) +{ + GLfloat borderColor[4] = + {1.0, 1.0, 1.0, 1.0}; + int tex; + + for (tex = 0; tex < NumTextures; tex++) { + GLubyte *image, *texData3, *texData4; + GLint imgWidth, imgHeight; + GLenum imgFormat; + int i, j; + + printf("loading %s\n", texFilename[tex]); + image = LoadRGBImage(texFilename[tex], &imgWidth, &imgHeight, &imgFormat); + if (!image) { + printf("can't find %s\n", texFilename[tex]); + exit(1); + } + assert(imgFormat == GL_RGB); + + /* scale to 256x256 */ + texData3 = malloc(256 * 256 * 4); + texData4 = malloc(256 * 256 * 4); + assert(texData3); + assert(texData4); + gluScaleImage(imgFormat, imgWidth, imgHeight, GL_UNSIGNED_BYTE, image, + 256, 256, GL_UNSIGNED_BYTE, texData3); + + /* convert to rgba */ + for (i = 0; i < 256 * 256; i++) { + texData4[i*4+0] = texData3[i*3+0]; + texData4[i*4+1] = texData3[i*3+1]; + texData4[i*4+2] = texData3[i*3+2]; + texData4[i*4+3] = 128; + } + + /* put transparent border around image */ + for (i = 0; i < 256; i++) { + texData4[i*4+0] = 255; + texData4[i*4+1] = 255; + texData4[i*4+2] = 255; + texData4[i*4+3] = 0; + } + j = 256 * 255 * 4; + for (i = 0; i < 256; i++) { + texData4[j + i*4+0] = 255; + texData4[j + i*4+1] = 255; + texData4[j + i*4+2] = 255; + texData4[j + i*4+3] = 0; + } + for (i = 0; i < 256; i++) { + j = i * 256 * 4; + texData4[j+0] = 255; + texData4[j+1] = 255; + texData4[j+2] = 255; + texData4[j+3] = 0; + } + for (i = 0; i < 256; i++) { + j = i * 256 * 4 + 255 * 4; + texData4[j+0] = 255; + texData4[j+1] = 255; + texData4[j+2] = 255; + texData4[j+3] = 0; + } + + ActiveTexture(GL_TEXTURE0_ARB + tex); + glBindTexture(GL_TEXTURE_2D, tex + 1); + + glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 256, 256, 0, + GL_RGBA, GL_UNSIGNED_BYTE, texData4); + + if (linearFilter) { + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + } else { + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + } + glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, borderColor); + } +} + +/* Create a simple spotlight pattern and make it the current texture */ +void +loadSpotlightTexture(void) +{ + static int texWidth = 64, texHeight = 64; + static GLubyte *texData; + GLfloat borderColor[4] = + {0.1, 0.1, 0.1, 1.0}; + + if (!texData) { + GLubyte *p; + int i, j; + + texData = (GLubyte *) malloc(texWidth * texHeight * 4 * sizeof(GLubyte)); + + p = texData; + for (j = 0; j < texHeight; ++j) { + float dy = (texHeight * 0.5 - j + 0.5) / (texHeight * 0.5); + + for (i = 0; i < texWidth; ++i) { + float dx = (texWidth * 0.5 - i + 0.5) / (texWidth * 0.5); + float r = cos(M_PI / 2.0 * sqrt(dx * dx + dy * dy)); + float c; + + r = (r < 0) ? 0 : r * r; + c = 0xff * (r + borderColor[0]); + p[0] = (c <= 0xff) ? c : 0xff; + c = 0xff * (r + borderColor[1]); + p[1] = (c <= 0xff) ? c : 0xff; + c = 0xff * (r + borderColor[2]); + p[2] = (c <= 0xff) ? c : 0xff; + c = 0xff * (r + borderColor[3]); + p[3] = (c <= 0xff) ? c : 0xff; + p += 4; + } + } + } + if (linearFilter) { + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + } else { + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + } + glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, borderColor); + gluBuild2DMipmaps(GL_TEXTURE_2D, 4, texWidth, texHeight, + GL_RGBA, GL_UNSIGNED_BYTE, texData); +} + +/*****************************************************************/ + +void +checkErrors(void) +{ + GLenum error; + while ((error = glGetError()) != GL_NO_ERROR) { + fprintf(stderr, "Error: %s\n", (char *) gluErrorString(error)); + } +} + +void +drawCube(void) +{ + glBegin(GL_QUADS); + + glNormal3f(-1.0, 0.0, 0.0); + glColor3f(0.80, 0.50, 0.50); + glVertex3f(-0.5, -0.5, -0.5); + glVertex3f(-0.5, -0.5, 0.5); + glVertex3f(-0.5, 0.5, 0.5); + glVertex3f(-0.5, 0.5, -0.5); + + glNormal3f(1.0, 0.0, 0.0); + glColor3f(0.50, 0.80, 0.50); + glVertex3f(0.5, 0.5, 0.5); + glVertex3f(0.5, -0.5, 0.5); + glVertex3f(0.5, -0.5, -0.5); + glVertex3f(0.5, 0.5, -0.5); + + glNormal3f(0.0, -1.0, 0.0); + glColor3f(0.50, 0.50, 0.80); + glVertex3f(-0.5, -0.5, -0.5); + glVertex3f(0.5, -0.5, -0.5); + glVertex3f(0.5, -0.5, 0.5); + glVertex3f(-0.5, -0.5, 0.5); + + glNormal3f(0.0, 1.0, 0.0); + glColor3f(0.50, 0.80, 0.80); + glVertex3f(0.5, 0.5, 0.5); + glVertex3f(0.5, 0.5, -0.5); + glVertex3f(-0.5, 0.5, -0.5); + glVertex3f(-0.5, 0.5, 0.5); + + glNormal3f(0.0, 0.0, -1.0); + glColor3f(0.80, 0.50, 0.80); + glVertex3f(-0.5, -0.5, -0.5); + glVertex3f(-0.5, 0.5, -0.5); + glVertex3f(0.5, 0.5, -0.5); + glVertex3f(0.5, -0.5, -0.5); + + glNormal3f(0.0, 0.0, 1.0); + glColor3f(1.00, 0.80, 0.50); + glVertex3f(0.5, 0.5, 0.5); + glVertex3f(-0.5, 0.5, 0.5); + glVertex3f(-0.5, -0.5, 0.5); + glVertex3f(0.5, -0.5, 0.5); + glEnd(); +} + +void +drawDodecahedron(void) +{ +#define A (0.5 * 1.61803) /* (sqrt(5) + 1) / 2 */ +#define B (0.5 * 0.61803) /* (sqrt(5) - 1) / 2 */ +#define C (0.5 * 1.0) + GLfloat vertexes[20][3] = + { + {-A, 0.0, B}, + {-A, 0.0, -B}, + {A, 0.0, -B}, + {A, 0.0, B}, + {B, -A, 0.0}, + {-B, -A, 0.0}, + {-B, A, 0.0}, + {B, A, 0.0}, + {0.0, B, -A}, + {0.0, -B, -A}, + {0.0, -B, A}, + {0.0, B, A}, + {-C, -C, C}, + {-C, -C, -C}, + {C, -C, -C}, + {C, -C, C}, + {-C, C, C}, + {-C, C, -C}, + {C, C, -C}, + {C, C, C}, + }; +#undef A +#undef B +#undef C + GLint polygons[12][5] = + { + {0, 12, 10, 11, 16}, + {1, 17, 8, 9, 13}, + {2, 14, 9, 8, 18}, + {3, 19, 11, 10, 15}, + {4, 14, 2, 3, 15}, + {5, 12, 0, 1, 13}, + {6, 17, 1, 0, 16}, + {7, 19, 3, 2, 18}, + {8, 17, 6, 7, 18}, + {9, 14, 4, 5, 13}, + {10, 12, 5, 4, 15}, + {11, 19, 7, 6, 16}, + }; + int i; + + glColor3f(0.75, 0.75, 0.75); + for (i = 0; i < 12; ++i) { + GLfloat *p0, *p1, *p2, d; + GLfloat u[3], v[3], n[3]; + + p0 = &vertexes[polygons[i][0]][0]; + p1 = &vertexes[polygons[i][1]][0]; + p2 = &vertexes[polygons[i][2]][0]; + + u[0] = p2[0] - p1[0]; + u[1] = p2[1] - p1[1]; + u[2] = p2[2] - p1[2]; + + v[0] = p0[0] - p1[0]; + v[1] = p0[1] - p1[1]; + v[2] = p0[2] - p1[2]; + + n[0] = u[1] * v[2] - u[2] * v[1]; + n[1] = u[2] * v[0] - u[0] * v[2]; + n[2] = u[0] * v[1] - u[1] * v[0]; + + d = 1.0 / sqrt(n[0] * n[0] + n[1] * n[1] + n[2] * n[2]); + n[0] *= d; + n[1] *= d; + n[2] *= d; + + glBegin(GL_POLYGON); + glNormal3fv(n); + glVertex3fv(p0); + glVertex3fv(p1); + glVertex3fv(p2); + glVertex3fv(vertexes[polygons[i][3]]); + glVertex3fv(vertexes[polygons[i][4]]); + glEnd(); + } +} + +void +drawSphere(void) +{ + int numMajor = 24; + int numMinor = 32; + float radius = 0.8; + double majorStep = (M_PI / numMajor); + double minorStep = (2.0 * M_PI / numMinor); + int i, j; + + glColor3f(0.50, 0.50, 0.50); + for (i = 0; i < numMajor; ++i) { + double a = i * majorStep; + double b = a + majorStep; + double r0 = radius * sin(a); + double r1 = radius * sin(b); + GLfloat z0 = radius * cos(a); + GLfloat z1 = radius * cos(b); + + glBegin(GL_TRIANGLE_STRIP); + for (j = 0; j <= numMinor; ++j) { + double c = j * minorStep; + GLfloat x = cos(c); + GLfloat y = sin(c); + + glNormal3f((x * r0) / radius, (y * r0) / radius, z0 / radius); + glTexCoord2f(j / (GLfloat) numMinor, i / (GLfloat) numMajor); + glVertex3f(x * r0, y * r0, z0); + + glNormal3f((x * r1) / radius, (y * r1) / radius, z1 / radius); + glTexCoord2f(j / (GLfloat) numMinor, (i + 1) / (GLfloat) numMajor); + glVertex3f(x * r1, y * r1, z1); + } + glEnd(); + } +} + +/*****************************************************************/ + +float xmin = -0.035, xmax = 0.035; +float ymin = -0.035, ymax = 0.035; +float nnear = 0.1; +float ffar = 1.9; +float distance = -1.0; + +static void +loadTextureProjection(int texUnit, GLfloat m[16]) +{ + GLfloat mInverse[4][4]; + + /* Should use true inverse, but since m consists only of rotations, we can + just use the transpose. */ + matrixTranspose((GLfloat *) mInverse, m); + + ActiveTexture(GL_TEXTURE0_ARB + texUnit); + glMatrixMode(GL_TEXTURE); + glLoadIdentity(); + glTranslatef(0.5, 0.5, 0.0); + glScalef(0.5, 0.5, 1.0); + glFrustum(xmin, xmax, ymin, ymax, nnear, ffar); + glTranslatef(0.0, 0.0, distance); + glMultMatrixf((GLfloat *) mInverse); + glMatrixMode(GL_MODELVIEW); +} + +static void +drawTextureProjection(void) +{ + float t = ffar / nnear; + GLfloat n[4][3]; + GLfloat f[4][3]; + + n[0][0] = xmin; + n[0][1] = ymin; + n[0][2] = -(nnear + distance); + + n[1][0] = xmax; + n[1][1] = ymin; + n[1][2] = -(nnear + distance); + + n[2][0] = xmax; + n[2][1] = ymax; + n[2][2] = -(nnear + distance); + + n[3][0] = xmin; + n[3][1] = ymax; + n[3][2] = -(nnear + distance); + + f[0][0] = xmin * t; + f[0][1] = ymin * t; + f[0][2] = -(ffar + distance); + + f[1][0] = xmax * t; + f[1][1] = ymin * t; + f[1][2] = -(ffar + distance); + + f[2][0] = xmax * t; + f[2][1] = ymax * t; + f[2][2] = -(ffar + distance); + + f[3][0] = xmin * t; + f[3][1] = ymax * t; + f[3][2] = -(ffar + distance); + + glColor3f(1.0, 1.0, 0.0); + glBegin(GL_LINE_LOOP); + glVertex3fv(n[0]); + glVertex3fv(n[1]); + glVertex3fv(n[2]); + glVertex3fv(n[3]); + glVertex3fv(f[3]); + glVertex3fv(f[2]); + glVertex3fv(f[1]); + glVertex3fv(f[0]); + glVertex3fv(n[0]); + glVertex3fv(n[1]); + glVertex3fv(f[1]); + glVertex3fv(f[0]); + glVertex3fv(f[3]); + glVertex3fv(f[2]); + glVertex3fv(n[2]); + glVertex3fv(n[3]); + glEnd(); +} + +/*****************************************************************/ + +void +initialize(void) +{ + GLfloat light0Pos[4] = + {0.3, 0.3, 0.0, 1.0}; + GLfloat matAmb[4] = + {0.01, 0.01, 0.01, 1.00}; + GLfloat matDiff[4] = + {0.65, 0.65, 0.65, 1.00}; + GLfloat matSpec[4] = + {0.30, 0.30, 0.30, 1.00}; + GLfloat matShine = 10.0; + GLfloat eyePlaneS[] = + {1.0, 0.0, 0.0, 0.0}; + GLfloat eyePlaneT[] = + {0.0, 1.0, 0.0, 0.0}; + GLfloat eyePlaneR[] = + {0.0, 0.0, 1.0, 0.0}; + GLfloat eyePlaneQ[] = + {0.0, 0.0, 0.0, 1.0}; + int i; + + /* Setup Misc. */ + glClearColor(0.41, 0.41, 0.31, 0.0); + + glEnable(GL_DEPTH_TEST); + + /* glLineWidth(2.0);*/ + + glCullFace(GL_FRONT); + glEnable(GL_CULL_FACE); + + glMatrixMode(GL_PROJECTION); + glFrustum(-0.5, 0.5, -0.5, 0.5, 1, 3); + glMatrixMode(GL_MODELVIEW); + glTranslatef(0, 0, -2); + + matrixIdentity((GLfloat *) objectXform); + for (i = 0; i < NumTextures; i++) { + matrixIdentity((GLfloat *) textureXform[i]); + } + + glMatrixMode(GL_PROJECTION); + glPushMatrix(); + glLoadIdentity(); + glOrtho(0, 1, 0, 1, -1, 1); + glMatrixMode(GL_MODELVIEW); + glPushMatrix(); + glLoadIdentity(); + + glRasterPos2i(0, 0); + + glPopMatrix(); + glMatrixMode(GL_PROJECTION); + glPopMatrix(); + glMatrixMode(GL_MODELVIEW); + + /* Setup Lighting */ + glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, matAmb); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, matDiff); + glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, matSpec); + glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, matShine); + + glEnable(GL_COLOR_MATERIAL); + + glLightfv(GL_LIGHT0, GL_POSITION, light0Pos); + glEnable(GL_LIGHT0); + + glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE); + glEnable(GL_LIGHTING); + + /* Setup Texture */ + + (*loadTexture) (); + + + for (i = 0; i < NumTextures; i++) { + ActiveTexture(GL_TEXTURE0_ARB + i); + + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); + glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); + + glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR); + glTexGenfv(GL_S, GL_EYE_PLANE, eyePlaneS); + + glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR); + glTexGenfv(GL_T, GL_EYE_PLANE, eyePlaneT); + + glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR); + glTexGenfv(GL_R, GL_EYE_PLANE, eyePlaneR); + + glTexGeni(GL_Q, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR); + glTexGenfv(GL_Q, GL_EYE_PLANE, eyePlaneQ); + } +} + +void +display(void) +{ + int i; + + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + + if (textureEnabled) { + if (mode == MoveTexture || mode == MoveView) { + /* Have OpenGL compute the new transformation (simple but slow). */ + for (i = 0; i < NumTextures; i++) { + glPushMatrix(); + glLoadIdentity(); +#if 0 + if (i & 1) + glRotatef(angle, axis[0], axis[1], axis[2]); + else +#endif + glRotatef(angle*(i+1), axis[0], axis[1], axis[2]); + + glMultMatrixf((GLfloat *) textureXform[i]); + glGetFloatv(GL_MODELVIEW_MATRIX, (GLfloat *) textureXform[i]); + glPopMatrix(); + } + } + for (i = 0; i < NumTextures; i++) { + loadTextureProjection(i, (GLfloat *) textureXform[i]); + } + + if (showProjection) { + for (i = 0; i < NumTextures; i++) { + ActiveTexture(GL_TEXTURE0_ARB + i); + glPushMatrix(); + glMultMatrixf((GLfloat *) textureXform[i]); + glDisable(GL_LIGHTING); + drawTextureProjection(); + glEnable(GL_LIGHTING); + glPopMatrix(); + } + } + for (i = 0; i < NumTextures; i++) { + ActiveTexture(GL_TEXTURE0_ARB + i); + glEnable(GL_TEXTURE_2D); + glEnable(GL_TEXTURE_GEN_S); + glEnable(GL_TEXTURE_GEN_T); + glEnable(GL_TEXTURE_GEN_R); + glEnable(GL_TEXTURE_GEN_Q); + } + } + if (mode == MoveObject || mode == MoveView) { + /* Have OpenGL compute the new transformation (simple but slow). */ + glPushMatrix(); + glLoadIdentity(); + glRotatef(angle, axis[0], axis[1], axis[2]); + glMultMatrixf((GLfloat *) objectXform); + glGetFloatv(GL_MODELVIEW_MATRIX, (GLfloat *) objectXform); + glPopMatrix(); + } + glPushMatrix(); + glMultMatrixf((GLfloat *) objectXform); + (*drawObject) (); + glPopMatrix(); + + for (i = 0; i < NumTextures; i++) { + ActiveTexture(GL_TEXTURE0_ARB + i); + glDisable(GL_TEXTURE_2D); + glDisable(GL_TEXTURE_GEN_S); + glDisable(GL_TEXTURE_GEN_T); + glDisable(GL_TEXTURE_GEN_R); + glDisable(GL_TEXTURE_GEN_Q); + } + + if (zoomFactor > 1.0) { + glDisable(GL_DEPTH_TEST); + glCopyPixels(0, 0, winWidth / zoomFactor, winHeight / zoomFactor, GL_COLOR); + glEnable(GL_DEPTH_TEST); + } + glFlush(); + glutSwapBuffers(); + checkErrors(); +} + +/*****************************************************************/ + +/* simple trackball-like motion control */ +float lastPos[3]; +int lastTime; + +void +ptov(int x, int y, int width, int height, float v[3]) +{ + float d, a; + + /* project x,y onto a hemi-sphere centered within width, height */ + v[0] = (2.0 * x - width) / width; + v[1] = (height - 2.0 * y) / height; + d = sqrt(v[0] * v[0] + v[1] * v[1]); + v[2] = cos((M_PI / 2.0) * ((d < 1.0) ? d : 1.0)); + a = 1.0 / sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]); + v[0] *= a; + v[1] *= a; + v[2] *= a; +} + +void +startMotion(int x, int y, int but, int time) +{ + if (but == GLUT_LEFT_BUTTON) { + mode = MoveView; + } else if (but == GLUT_MIDDLE_BUTTON) { + mode = MoveTexture; + } else { + return; + } + + lastTime = time; + ptov(x, y, winWidth, winHeight, lastPos); +} + +void +animate(void) +{ + glutPostRedisplay(); +} + +void +vis(int visible) +{ + if (visible == GLUT_VISIBLE) { + if (redrawContinuously) + glutIdleFunc(animate); + } else { + if (redrawContinuously) + glutIdleFunc(NULL); + } +} + +void +stopMotion(int but, int time) +{ + if ((but == GLUT_LEFT_BUTTON && mode == MoveView) || + (but == GLUT_MIDDLE_BUTTON && mode == MoveTexture)) { + } else { + return; + } + + if (time == lastTime) { + /* redrawContinuously = GL_TRUE;*/ + glutIdleFunc(animate); + } else { + angle = 0.0; + redrawContinuously = GL_FALSE; + glutIdleFunc(0); + } + if (!redrawContinuously) { + mode = MoveNone; + } +} + +void +trackMotion(int x, int y) +{ + float curPos[3], dx, dy, dz; + + ptov(x, y, winWidth, winHeight, curPos); + + dx = curPos[0] - lastPos[0]; + dy = curPos[1] - lastPos[1]; + dz = curPos[2] - lastPos[2]; + angle = 90.0 * sqrt(dx * dx + dy * dy + dz * dz); + + axis[0] = lastPos[1] * curPos[2] - lastPos[2] * curPos[1]; + axis[1] = lastPos[2] * curPos[0] - lastPos[0] * curPos[2]; + axis[2] = lastPos[0] * curPos[1] - lastPos[1] * curPos[0]; + + lastTime = glutGet(GLUT_ELAPSED_TIME); + lastPos[0] = curPos[0]; + lastPos[1] = curPos[1]; + lastPos[2] = curPos[2]; + glutPostRedisplay(); +} + +/*****************************************************************/ + +void +object(void) +{ + static int object; + + object++; + object %= 3; + switch (object) { + case 0: + drawObject = drawCube; + break; + case 1: + drawObject = drawDodecahedron; + break; + case 2: + drawObject = drawSphere; + break; + default: + break; + } +} + +static void +nop(void) +{ +} + +void +texture(void) +{ + static int texture = 0; + + texture++; + texture %= 3; + if (texture == 1 && texFilename == NULL) { + /* Skip file texture if not loaded. */ + texture++; + } + switch (texture) { + case 0: + loadTexture = nop; + textureEnabled = GL_FALSE; + break; + case 1: + loadTexture = loadImageTextures; + (*loadTexture) (); + textureEnabled = GL_TRUE; + break; + case 2: + loadTexture = loadSpotlightTexture; + (*loadTexture) (); + textureEnabled = GL_TRUE; + break; + default: + break; + } +} + +void +help(void) +{ + printf("'h' - help\n"); + printf("'l' - toggle linear/nearest filter\n"); + printf("'s' - toggle projection frustum\n"); + printf("'t' - toggle projected texture\n"); + printf("'o' - toggle object\n"); + printf("'z' - increase zoom factor\n"); + printf("'Z' - decrease zoom factor\n"); + printf("left mouse - move view\n"); + printf("middle mouse - move projection\n"); +} + +/* ARGSUSED1 */ +void +key(unsigned char key, int x, int y) +{ + switch (key) { + case '\033': + exit(0); + break; + case 'l': + linearFilter = !linearFilter; + (*loadTexture) (); + break; + case 's': + showProjection = !showProjection; + break; + case 't': + texture(); + break; + case 'o': + object(); + break; + case 'z': + zoomFactor += 1.0; + glPixelZoom(zoomFactor, zoomFactor); + glViewport(0, 0, winWidth / zoomFactor, winHeight / zoomFactor); + break; + case 'Z': + zoomFactor -= 1.0; + if (zoomFactor < 1.0) + zoomFactor = 1.0; + glPixelZoom(zoomFactor, zoomFactor); + glViewport(0, 0, winWidth / zoomFactor, winHeight / zoomFactor); + break; + case 'h': + help(); + break; + } + glutPostRedisplay(); +} + +void +mouse(int button, int state, int x, int y) +{ + if (state == GLUT_DOWN) + startMotion(x, y, button, glutGet(GLUT_ELAPSED_TIME)); + else if (state == GLUT_UP) + stopMotion(button, glutGet(GLUT_ELAPSED_TIME)); + glutPostRedisplay(); +} + +void +reshape(int w, int h) +{ + winWidth = w; + winHeight = h; + glViewport(0, 0, w / zoomFactor, h / zoomFactor); +} + + +void +menu(int selection) +{ + if (selection == 666) { + exit(0); + } + key((unsigned char) selection, 0, 0); +} + +int +main(int argc, char **argv) +{ + glutInit(&argc, argv); + + if (argc > 1) { + NumTextures = atoi(argv[1]); + } + assert(NumTextures <= MAX_TEX); + + glutInitDisplayMode(GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE); + (void) glutCreateWindow("projtex"); + + loadTexture = loadImageTextures; + drawObject = drawCube; + initialize(); + glutDisplayFunc(display); + glutKeyboardFunc(key); + glutReshapeFunc(reshape); + glutMouseFunc(mouse); + glutMotionFunc(trackMotion); + glutVisibilityFunc(vis); + glutCreateMenu(menu); + glutAddMenuEntry("Toggle showing projection", 's'); + glutAddMenuEntry("Switch texture", 't'); + glutAddMenuEntry("Switch object", 'o'); + glutAddMenuEntry("Toggle filtering", 'l'); + glutAddMenuEntry("Quit", 666); + glutAttachMenu(GLUT_RIGHT_BUTTON); + texture(); + glutMainLoop(); + return 0; /* ANSI C requires main to return int. */ +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/seccolor.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/seccolor.c new file mode 100644 index 000000000..77fd40647 --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/seccolor.c @@ -0,0 +1,145 @@ +/* + * Exercise GL_EXT_secondary_color + */ + + +#define GL_GLEXT_PROTOTYPES +#include <stdio.h> +#include <stdlib.h> +#include <math.h> +#include <GL/glut.h> + +static int Width = 600; +static int Height = 200; +static GLfloat Near = 5.0, Far = 25.0; + + +static void Display( void ) +{ + GLfloat t; + + glClearColor(0.2, 0.2, 0.8, 0); + glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); + + for (t = 0.0; t <= 1.0; t += 0.25) { + GLfloat x = t * 10.0 - 5.0; + GLfloat g = t; + + /* top row: untextured */ + glColor3f(1, 0, 0); + glPushMatrix(); + glTranslatef(x, 1.2, 0); +#if defined(GL_EXT_secondary_color) + glSecondaryColor3fEXT(0, g, 0); +#endif + glBegin(GL_POLYGON); + glVertex2f(-1, -1); + glVertex2f( 1, -1); + glVertex2f( 1, 1); + glVertex2f(-1, 1); + glEnd(); + glPopMatrix(); + + /* bottom row: textured */ + glColor3f(1, 1, 1); + glEnable(GL_TEXTURE_2D); + glPushMatrix(); + glTranslatef(x, -1.2, 0); +#if defined(GL_EXT_secondary_color) + glSecondaryColor3fEXT(0, g, 0); +#endif + glBegin(GL_POLYGON); + glTexCoord2f(0, 0); glVertex2f(-1, -1); + glTexCoord2f(1, 0); glVertex2f( 1, -1); + glTexCoord2f(1, 1); glVertex2f( 1, 1); + glTexCoord2f(0, 1); glVertex2f(-1, 1); + glEnd(); + glPopMatrix(); + glDisable(GL_TEXTURE_2D); + } + glutSwapBuffers(); +} + + +static void Reshape( int width, int height ) +{ + GLfloat ar = (float) width / (float) height; + Width = width; + Height = height; + glViewport( 0, 0, width, height ); + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glFrustum( -ar, ar, -1.0, 1.0, Near, Far ); + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); + glTranslatef( 0.0, 0.0, -15.0 ); +} + + +static void Key( unsigned char key, int x, int y ) +{ + (void) x; + (void) y; + switch (key) { + case 27: + exit(0); + break; + } + glutPostRedisplay(); +} + + +static void Init( void ) +{ + GLubyte image[4*4][3]; + GLint i; + if (!glutExtensionSupported("GL_EXT_secondary_color")) { + printf("Sorry, this program requires GL_EXT_secondary_color\n"); + exit(1); + } + + /* setup red texture with one back texel */ + for (i = 0; i < 4*4; i++) { + if (i == 0) { + image[i][0] = 0; + image[i][1] = 0; + image[i][2] = 0; + } + else { + image[i][0] = 255; + image[i][1] = 0; + image[i][2] = 0; + } + } + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 4, 4, 0, + GL_RGB, GL_UNSIGNED_BYTE, image); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); + +#if defined(GL_EXT_secondary_color) + glEnable(GL_COLOR_SUM_EXT); +#endif + glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR); + + printf("Squares should be colored from red -> orange -> yellow.\n"); + printf("Top row is untextured.\n"); + printf("Bottom row is textured (red texture with one black texel).\n"); + printf("Rows should be identical, except for lower-left texel.\n"); +} + + +int main( int argc, char *argv[] ) +{ + glutInit( &argc, argv ); + glutInitWindowPosition( 0, 0 ); + glutInitWindowSize( Width, Height ); + glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE ); + glutCreateWindow(argv[0]); + glutReshapeFunc( Reshape ); + glutKeyboardFunc( Key ); + glutDisplayFunc( Display ); + Init(); + glutMainLoop(); + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/sharedtex.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/sharedtex.c new file mode 100644 index 000000000..ebe73f19f --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/sharedtex.c @@ -0,0 +1,438 @@ +/* $Id: sharedtex.c,v 1.2 2002/01/16 14:32:46 joukj Exp $ */ + +/* + * Test sharing of display lists and texture objects between GLX contests. + * Brian Paul + * Summer 2000 + * + * + * Copyright (C) 2000 Brian Paul All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + + +#include <GL/gl.h> +#include <GL/glx.h> +#include <stdio.h> +#include <stdlib.h> +#include <unistd.h> +#include <string.h> + + +struct window { + char DisplayName[1000]; + Display *Dpy; + Window Win; + GLXContext Context; + float Angle; + int Id; +}; + + +#define MAX_WINDOWS 20 +static struct window Windows[MAX_WINDOWS]; +static int NumWindows = 0; + + +static GLuint Textures[3]; +static GLuint CubeList; + + + +static void +Error(const char *display, const char *msg) +{ + fprintf(stderr, "Error on display %s - %s\n", display, msg); + exit(1); +} + + +static struct window * +AddWindow(const char *displayName, int xpos, int ypos, + const struct window *shareWindow) +{ + Display *dpy; + Window win; + GLXContext ctx; + int attrib[] = { GLX_RGBA, + GLX_RED_SIZE, 1, + GLX_GREEN_SIZE, 1, + GLX_BLUE_SIZE, 1, + GLX_DOUBLEBUFFER, + GLX_DEPTH_SIZE, 1, + None }; + int scrnum; + XSetWindowAttributes attr; + unsigned long mask; + Window root; + XVisualInfo *visinfo; + int width = 300, height = 300; + + if (NumWindows >= MAX_WINDOWS) + return NULL; + + dpy = XOpenDisplay(displayName); + if (!dpy) { + Error(displayName, "Unable to open display"); + return NULL; + } + + scrnum = DefaultScreen(dpy); + root = RootWindow(dpy, scrnum); + + visinfo = glXChooseVisual(dpy, scrnum, attrib); + if (!visinfo) { + Error(displayName, "Unable to find RGB, double-buffered visual"); + return NULL; + } + + /* window attributes */ + attr.background_pixel = 0; + attr.border_pixel = 0; + attr.colormap = XCreateColormap(dpy, root, visinfo->visual, AllocNone); + attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask; + mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask; + + win = XCreateWindow(dpy, root, xpos, ypos, width, height, + 0, visinfo->depth, InputOutput, + visinfo->visual, mask, &attr); + if (!win) { + Error(displayName, "Couldn't create window"); + return NULL; + } + + { + XSizeHints sizehints; + sizehints.x = xpos; + sizehints.y = ypos; + sizehints.width = width; + sizehints.height = height; + sizehints.flags = USSize | USPosition; + XSetNormalHints(dpy, win, &sizehints); + XSetStandardProperties(dpy, win, displayName, displayName, + None, (char **)NULL, 0, &sizehints); + } + + + ctx = glXCreateContext(dpy, visinfo, + shareWindow ? shareWindow->Context : NULL, + True); + if (!ctx) { + Error(displayName, "Couldn't create GLX context"); + return NULL; + } + + XMapWindow(dpy, win); + + if (!glXMakeCurrent(dpy, win, ctx)) { + Error(displayName, "glXMakeCurrent failed"); + printf("glXMakeCurrent failed in Redraw()\n"); + return NULL; + } + + /* save the info for this window */ + { + static int id = 0; + struct window *h = &Windows[NumWindows]; + strcpy(h->DisplayName, displayName); + h->Dpy = dpy; + h->Win = win; + h->Context = ctx; + h->Angle = 0.0; + h->Id = id++; + NumWindows++; + return &Windows[NumWindows-1]; + } + +} + + +static void +InitGLstuff(struct window *h) +{ + if (!glXMakeCurrent(h->Dpy, h->Win, h->Context)) { + Error(h->DisplayName, "glXMakeCurrent failed in InitGLstuff"); + return; + } + + glGenTextures(3, Textures); + + /* setup first texture object */ + { + GLubyte image[16][16][4]; + GLint i, j; + glBindTexture(GL_TEXTURE_2D, Textures[0]); + + /* red/white checkerboard */ + for (i = 0; i < 16; i++) { + for (j = 0; j < 16; j++) { + if ((i ^ j) & 1) { + image[i][j][0] = 255; + image[i][j][1] = 255; + image[i][j][2] = 255; + image[i][j][3] = 255; + } + else { + image[i][j][0] = 255; + image[i][j][1] = 0; + image[i][j][2] = 0; + image[i][j][3] = 255; + } + } + } + + glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, + GL_UNSIGNED_BYTE, image); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + } + + /* setup second texture object */ + { + GLubyte image[8][8][3]; + GLint i, j; + glBindTexture(GL_TEXTURE_2D, Textures[1]); + + /* green/yellow checkerboard */ + for (i = 0; i < 8; i++) { + for (j = 0; j < 8; j++) { + if ((i ^ j) & 1) { + image[i][j][0] = 0; + image[i][j][1] = 255; + image[i][j][2] = 0; + } + else { + image[i][j][0] = 255; + image[i][j][1] = 255; + image[i][j][2] = 0; + } + } + } + + glPixelStorei(GL_UNPACK_ALIGNMENT, 2); + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 8, 8, 0, GL_RGB, + GL_UNSIGNED_BYTE, image); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + } + + /* setup second texture object */ + { + GLubyte image[4][4][3]; + GLint i, j; + glBindTexture(GL_TEXTURE_2D, Textures[2]); + + /* blue/gray checkerboard */ + for (i = 0; i < 4; i++) { + for (j = 0; j < 4; j++) { + if ((i ^ j) & 1) { + image[i][j][0] = 0; + image[i][j][1] = 0; + image[i][j][2] = 255; + } + else { + image[i][j][0] = 200; + image[i][j][1] = 200; + image[i][j][2] = 200; + } + } + } + + glPixelStorei(GL_UNPACK_ALIGNMENT, 2); + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 4, 4, 0, GL_RGB, + GL_UNSIGNED_BYTE, image); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + } + + /* Now make the cube object display list */ + CubeList = glGenLists(1); + glNewList(CubeList, GL_COMPILE); + { + glBindTexture(GL_TEXTURE_2D, Textures[0]); + glBegin(GL_POLYGON); + glTexCoord2f(0, 0); glVertex3f(-1, -1, -1); + glTexCoord2f(1, 0); glVertex3f(-1, 1, -1); + glTexCoord2f(1, 1); glVertex3f(-1, 1, 1); + glTexCoord2f(0, 1); glVertex3f(-1, -1, 1); + glEnd(); + glBegin(GL_POLYGON); + glTexCoord2f(0, 0); glVertex3f(1, -1, -1); + glTexCoord2f(1, 0); glVertex3f(1, 1, -1); + glTexCoord2f(1, 1); glVertex3f(1, 1, 1); + glTexCoord2f(0, 1); glVertex3f(1, -1, 1); + glEnd(); + + glBindTexture(GL_TEXTURE_2D, Textures[1]); + glBegin(GL_POLYGON); + glTexCoord2f(0, 0); glVertex3f(-1, -1, -1); + glTexCoord2f(1, 0); glVertex3f( 1, -1, -1); + glTexCoord2f(1, 1); glVertex3f( 1, -1, 1); + glTexCoord2f(0, 1); glVertex3f(-1, -1, 1); + glEnd(); + glBegin(GL_POLYGON); + glTexCoord2f(0, 0); glVertex3f(-1, 1, -1); + glTexCoord2f(1, 0); glVertex3f( 1, 1, -1); + glTexCoord2f(1, 1); glVertex3f( 1, 1, 1); + glTexCoord2f(0, 1); glVertex3f(-1, 1, 1); + glEnd(); + + glBindTexture(GL_TEXTURE_2D, Textures[2]); + glBegin(GL_POLYGON); + glTexCoord2f(0, 0); glVertex3f(-1, -1, -1); + glTexCoord2f(1, 0); glVertex3f( 1, -1, -1); + glTexCoord2f(1, 1); glVertex3f( 1, 1, -1); + glTexCoord2f(0, 1); glVertex3f(-1, 1, -1); + glEnd(); + glBegin(GL_POLYGON); + glTexCoord2f(0, 0); glVertex3f(-1, -1, 1); + glTexCoord2f(1, 0); glVertex3f( 1, -1, 1); + glTexCoord2f(1, 1); glVertex3f( 1, 1, 1); + glTexCoord2f(0, 1); glVertex3f(-1, 1, 1); + glEnd(); + } + glEndList(); + + printf("GL_RENDERER: %s\n", (char *) glGetString(GL_RENDERER)); + printf("GL_VERSION: %s\n", (char *) glGetString(GL_VERSION)); + printf("GL_VENDOR: %s\n", (char *) glGetString(GL_VENDOR)); +} + + + +static void +Redraw(struct window *h) +{ + if (!glXMakeCurrent(h->Dpy, h->Win, h->Context)) { + Error(h->DisplayName, "glXMakeCurrent failed"); + printf("glXMakeCurrent failed in Redraw()\n"); + return; + } + + h->Angle += 1.0; + + glShadeModel(GL_FLAT); + glClearColor(0.25, 0.25, 0.25, 1.0); + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + + glEnable(GL_TEXTURE_2D); + glEnable(GL_DEPTH_TEST); + glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); + + glColor3f(1, 1, 1); + + glPushMatrix(); + if (h->Id == 0) + glRotatef(h->Angle, 0, 1, -1); + else if (h->Id == 1) + glRotatef(-(h->Angle), 0, 1, -1); + else if (h->Id == 2) + glRotatef(h->Angle, 0, 1, 1); + else if (h->Id == 3) + glRotatef(-(h->Angle), 0, 1, 1); + glCallList(CubeList); + glPopMatrix(); + + glXSwapBuffers(h->Dpy, h->Win); +} + + + +static void +Resize(const struct window *h, unsigned int width, unsigned int height) +{ + if (!glXMakeCurrent(h->Dpy, h->Win, h->Context)) { + Error(h->DisplayName, "glXMakeCurrent failed in Resize()"); + return; + } + glViewport(0, 0, width, height); + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + glFrustum(-1, 1, -1, 1, 2, 10); + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + glTranslatef(0, 0, -3.5); +} + + + +static void +EventLoop(void) +{ + while (1) { + int i; + for (i = 0; i < NumWindows; i++) { + struct window *h = &Windows[i]; + while (XPending(h->Dpy) > 0) { + XEvent event; + XNextEvent(h->Dpy, &event); + if (event.xany.window == h->Win) { + switch (event.type) { + case Expose: + Redraw(h); + break; + case ConfigureNotify: + Resize(h, event.xconfigure.width, event.xconfigure.height); + break; + case KeyPress: + return; + default: + /*no-op*/ ; + } + } + else { + printf("window mismatch\n"); + } + } + Redraw(h); + } + usleep(1); + } +} + + + +static void +PrintInfo(const struct window *h) +{ + printf("Name: %s\n", h->DisplayName); + printf(" Display: 0x%x\n", h->Dpy); + printf(" Window: 0x%x\n", h->Win); + printf(" Context: 0x%x\n", h->Context); +} + + +int +main(int argc, char *argv[]) +{ + int i; + struct window *h0, *h1, *h2, *h3; + + /* four windows and contexts sharing display lists and texture objects */ + h0 = AddWindow(":0", 10, 10, NULL); + h1 = AddWindow(":0", 330, 10, h0); + h2 = AddWindow(":0", 10, 350, h0); + h3 = AddWindow(":0", 330, 350, h0); + + InitGLstuff(h0); + + EventLoop(); + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/stencil_wrap.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/stencil_wrap.c new file mode 100644 index 000000000..88cf3809c --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/stencil_wrap.c @@ -0,0 +1,257 @@ +/* + * (C) Copyright IBM Corporation 2004 + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * on the rights to use, copy, modify, merge, publish, distribute, sub + * license, and/or sell copies of the Software, and to permit persons to whom + * the Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL + * VA LINUX SYSTEM, IBM AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE + * USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +/** + * \file stencil_wrap.c + * + * Simple test of GL_EXT_stencil_wrap functionality. Four squares are drawn + * with different stencil modes, but all should be rendered with the same + * final color. + * + * \author Ian Romanick <idr@us.ibm.com> + */ + +#include <stdio.h> +#include <stdlib.h> +#include <GL/glut.h> + +static int Width = 550; +static int Height = 200; +static const GLfloat Near = 5.0, Far = 25.0; + + +static void Display( void ) +{ + GLint max_stencil; + GLint stencil_bits; + unsigned i; + + + glGetIntegerv( GL_STENCIL_BITS, & stencil_bits ); + max_stencil = (1U << stencil_bits) - 1; + printf( "Stencil bits = %u, maximum stencil value = 0x%08x\n", + stencil_bits, max_stencil ); + + glClearStencil( 0 ); + glClearColor( 0.2, 0.2, 0.8, 0 ); + glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT + | GL_STENCIL_BUFFER_BIT ); + + + glPushMatrix(); + + /* This is the "reference" square. + */ + + glDisable(GL_STENCIL_TEST); + glTranslatef(-6.0, 0, 0); + glBegin(GL_QUADS); + glColor3f( 0.5, 0.5, 0.5 ); + glVertex2f(-1, -1); + glVertex2f( 1, -1); + glVertex2f( 1, 1); + glVertex2f(-1, 1); + glEnd(); + + + glEnable(GL_STENCIL_TEST); + + /* Draw the first two squares using the two non-wrap (i.e., saturate) + * modes. + */ + + glStencilFunc(GL_ALWAYS, 0, ~0); + glStencilOp(GL_KEEP, GL_KEEP, GL_INCR); + + glTranslatef(3.0, 0, 0); + glBegin(GL_QUADS); + glColor3f( 0.9, 0.9, 0.9 ); + + for ( i = 0 ; i < (max_stencil + 5) ; i++ ) { + glVertex2f(-1, -1); + glVertex2f( 1, -1); + glVertex2f( 1, 1); + glVertex2f(-1, 1); + } + glEnd(); + + glStencilFunc(GL_EQUAL, max_stencil, ~0); + glBegin(GL_QUADS); + glColor3f( 0.5, 0.5, 0.5 ); + glVertex2f(-1, -1); + glVertex2f( 1, -1); + glVertex2f( 1, 1); + glVertex2f(-1, 1); + glEnd(); + + + glStencilFunc(GL_ALWAYS, 0, ~0); + glStencilOp(GL_KEEP, GL_KEEP, GL_DECR); + + glTranslatef(3.0, 0, 0); + glBegin(GL_QUADS); + glColor3f( 0.9, 0.9, 0.9 ); + + for ( i = 0 ; i < (max_stencil + 5) ; i++ ) { + glVertex2f(-1, -1); + glVertex2f( 1, -1); + glVertex2f( 1, 1); + glVertex2f(-1, 1); + } + glEnd(); + + glStencilFunc(GL_EQUAL, 0, ~0); + glBegin(GL_QUADS); + glColor3f( 0.5, 0.5, 0.5 ); + glVertex2f(-1, -1); + glVertex2f( 1, -1); + glVertex2f( 1, 1); + glVertex2f(-1, 1); + glEnd(); + + + + + /* Draw the last two squares using the two wrap modes. + */ + + glStencilFunc(GL_ALWAYS, 0, ~0); + glStencilOp(GL_KEEP, GL_KEEP, GL_INCR_WRAP); + + glTranslatef(3.0, 0, 0); + glBegin(GL_QUADS); + glColor3f( 0.9, 0.9, 0.9 ); + + for ( i = 0 ; i < (max_stencil + 5) ; i++ ) { + glVertex2f(-1, -1); + glVertex2f( 1, -1); + glVertex2f( 1, 1); + glVertex2f(-1, 1); + } + glEnd(); + + glStencilFunc(GL_EQUAL, 4, ~0); + glBegin(GL_QUADS); + glColor3f( 0.5, 0.5, 0.5 ); + glVertex2f(-1, -1); + glVertex2f( 1, -1); + glVertex2f( 1, 1); + glVertex2f(-1, 1); + glEnd(); + + + + glStencilFunc(GL_ALWAYS, 0, ~0); + glStencilOp(GL_KEEP, GL_KEEP, GL_DECR_WRAP); + + glTranslatef(3.0, 0, 0); + glBegin(GL_QUADS); + glColor3f( 0.9, 0.9, 0.9 ); + + for ( i = 0 ; i < 5 ; i++ ) { + glVertex2f(-1, -1); + glVertex2f( 1, -1); + glVertex2f( 1, 1); + glVertex2f(-1, 1); + } + glEnd(); + + glStencilFunc(GL_EQUAL, (max_stencil - 4), ~0); + glBegin(GL_QUADS); + glColor3f( 0.5, 0.5, 0.5 ); + glVertex2f(-1, -1); + glVertex2f( 1, -1); + glVertex2f( 1, 1); + glVertex2f(-1, 1); + glEnd(); + + + + glPopMatrix(); + + glutSwapBuffers(); +} + + +static void Reshape( int width, int height ) +{ + GLfloat ar = (float) width / (float) height; + Width = width; + Height = height; + glViewport( 0, 0, width, height ); + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glFrustum( -ar, ar, -1.0, 1.0, Near, Far ); + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); + glTranslatef( 0.0, 0.0, -15.0 ); +} + + +static void Key( unsigned char key, int x, int y ) +{ + (void) x; + (void) y; + switch (key) { + case 27: + exit(0); + break; + } + glutPostRedisplay(); +} + + +static void Init( void ) +{ + const char * const ver_string = (const char * const) + glGetString( GL_VERSION ); + + printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER)); + printf("GL_VERSION = %s\n", ver_string); + + if ( !glutExtensionSupported("GL_EXT_stencil_wrap") + && (atof( ver_string ) < 1.4) ) { + printf("Sorry, this program requires either GL_EXT_stencil_wrap or OpenGL 1.4.\n"); + exit(1); + } + + printf("\nAll 5 squares should be the same color.\n"); + glEnable( GL_BLEND ); +} + + +int main( int argc, char *argv[] ) +{ + glutInit( &argc, argv ); + glutInitWindowPosition( 0, 0 ); + glutInitWindowSize( Width, Height ); + glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH | GLUT_STENCIL ); + glutCreateWindow( "GL_EXT_stencil_wrap test" ); + glutReshapeFunc( Reshape ); + glutKeyboardFunc( Key ); + glutDisplayFunc( Display ); + Init(); + glutMainLoop(); + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/stencilwrap.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/stencilwrap.c new file mode 100644 index 000000000..753375d0f --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/stencilwrap.c @@ -0,0 +1,281 @@ +/* Test GL_EXT_stencil_wrap extension. + * This is by no means complete, just a quick check. + * + * Brian Paul 30 October 2002 + */ + +#include <assert.h> +#include <stdio.h> +#include <stdlib.h> +#include <math.h> +#include <GL/glut.h> + +GLboolean wrapping; + +static void RunTest(void) +{ + const GLenum prim = GL_QUAD_STRIP; + GLubyte val; + int bits, max, i; + int expected; + GLboolean failed; + + glGetIntegerv(GL_STENCIL_BITS, &bits); + max = (1 << bits) - 1; + + + glEnable(GL_STENCIL_TEST); + glStencilFunc(GL_ALWAYS, 0, ~0); + + /* test GL_KEEP */ + glClearStencil(max); + glClear(GL_STENCIL_BUFFER_BIT); + glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP); + failed = GL_FALSE; + printf("Testing GL_KEEP...\n"); + expected = max; + glBegin(prim); + glVertex2f(0, 0); + glVertex2f(10, 0); + glVertex2f(0, 10); + glVertex2f(10, 10); + glEnd(); + glReadPixels(0, 0, 1, 1, GL_STENCIL_INDEX, GL_UNSIGNED_BYTE, &val); + if (val != expected) { + printf("Failed GL_KEEP test(got %u, expected %u)\n", val, expected); + failed = GL_TRUE; + } + else + printf("OK!\n"); + + /* test GL_ZERO */ + glClearStencil(max); + glClear(GL_STENCIL_BUFFER_BIT); + glStencilOp(GL_KEEP, GL_KEEP, GL_ZERO); + failed = GL_FALSE; + printf("Testing GL_ZERO...\n"); + expected = 0; + glBegin(prim); + glVertex2f(0, 0); + glVertex2f(10, 0); + glVertex2f(0, 10); + glVertex2f(10, 10); + glEnd(); + glReadPixels(0, 0, 1, 1, GL_STENCIL_INDEX, GL_UNSIGNED_BYTE, &val); + if (val != expected) { + printf("Failed GL_ZERO test(got %u, expected %u)\n", val, expected); + failed = GL_TRUE; + } + else + printf("OK!\n"); + + /* test GL_REPLACE */ + glClearStencil(max); + glClear(GL_STENCIL_BUFFER_BIT); + glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE); + failed = GL_FALSE; + printf("Testing GL_REPLACE...\n"); + expected = 0; + glBegin(prim); + glVertex2f(0, 0); + glVertex2f(10, 0); + glVertex2f(0, 10); + glVertex2f(10, 10); + glEnd(); + glReadPixels(0, 0, 1, 1, GL_STENCIL_INDEX, GL_UNSIGNED_BYTE, &val); + if (val != expected) { + printf("Failed GL_REPLACE test(got %u, expected %u)\n", val, expected); + failed = GL_TRUE; + } + else + printf("OK!\n"); + + /* test GL_INCR (saturation) */ + glClearStencil(0); + glClear(GL_STENCIL_BUFFER_BIT); + glStencilOp(GL_KEEP, GL_KEEP, GL_INCR); + failed = GL_FALSE; + printf("Testing GL_INCR...\n"); + for (i = 1; i < max+10; i++) { + expected = (i > max) ? max : i; + glBegin(prim); + glVertex2f(0, 0); glVertex2f(10, 0); + glVertex2f(0, 10); glVertex2f(10, 10); + glEnd(); + + glReadPixels(0, 0, 1, 1, GL_STENCIL_INDEX, GL_UNSIGNED_BYTE, &val); + if (val != expected) { + printf( "Failed GL_INCR test on iteration #%u " + "(got %u, expected %u)\n", i, val, expected ); + failed = GL_TRUE; + } + } + if ( !failed ) + printf("OK!\n"); + + /* test GL_DECR (saturation) */ + glClearStencil(max); + glClear(GL_STENCIL_BUFFER_BIT); + glStencilOp(GL_KEEP, GL_KEEP, GL_DECR); + failed = GL_FALSE; + printf("Testing GL_DECR...\n"); + for (i = max-1; i > -10; i--) { + expected = (i < 0) ? 0 : i; + glBegin(prim); + glVertex2f(0, 0); glVertex2f(10, 0); + glVertex2f(0, 10); glVertex2f(10, 10); + glEnd(); + glReadPixels(0, 0, 1, 1, GL_STENCIL_INDEX, GL_UNSIGNED_BYTE, &val); + if (val != expected) { + printf( "Failed GL_DECR test on iteration #%u " + "(got %u, expected %u)\n", max - i, val, expected ); + failed = GL_TRUE; + } + } + if ( !failed ) + printf("OK!\n"); + + /* test GL_INVERT */ + glClearStencil(0); + glClear(GL_STENCIL_BUFFER_BIT); + glStencilOp(GL_KEEP, GL_KEEP, GL_INVERT); + failed = GL_FALSE; + printf("Testing GL_INVERT...\n"); + expected = max; + glBegin(prim); + glVertex2f(0, 0); + glVertex2f(10, 0); + glVertex2f(0, 10); + glVertex2f(10, 10); + glEnd(); + glReadPixels(0, 0, 1, 1, GL_STENCIL_INDEX, GL_UNSIGNED_BYTE, &val); + if (val != expected) { + printf("Failed GL_INVERT test(got %u, expected %u)\n", val, expected); + failed = GL_TRUE; + } + else + printf("OK!\n"); + + if(wrapping) + { + /* test GL_INCR_WRAP_EXT (wrap around) */ + glClearStencil(0); + glClear(GL_STENCIL_BUFFER_BIT); + glStencilOp(GL_KEEP, GL_KEEP, GL_INCR_WRAP_EXT); + failed = GL_FALSE; + printf("Testing GL_INCR_WRAP_EXT...\n"); + for (i = 1; i < max+10; i++) { + expected = i % (max + 1); + glBegin(prim); + glVertex2f(0, 0); glVertex2f(10, 0); + glVertex2f(0, 10); glVertex2f(10, 10); + glEnd(); + glReadPixels(0, 0, 1, 1, GL_STENCIL_INDEX, GL_UNSIGNED_BYTE, &val); + if (val != expected) { + printf( "Failed GL_INCR_WRAP test on iteration #%u " + "(got %u, expected %u)\n", i, val, expected ); + failed = GL_TRUE; + } + } + if ( !failed ) + printf("OK!\n"); + + /* test GL_DECR_WRAP_EXT (wrap-around) */ + glClearStencil(max); + glClear(GL_STENCIL_BUFFER_BIT); + glStencilOp(GL_KEEP, GL_KEEP, GL_DECR_WRAP_EXT); + failed = GL_FALSE; + printf("Testing GL_DECR_WRAP_EXT...\n"); + for (i = max-1; i > -10; i--) { + expected = (i < 0) ? max + i + 1: i; + glBegin(prim); + glVertex2f(0, 0); glVertex2f(10, 0); + glVertex2f(0, 10); glVertex2f(10, 10); + glEnd(); + glReadPixels(0, 0, 1, 1, GL_STENCIL_INDEX, GL_UNSIGNED_BYTE, &val); + if (val != expected) { + printf( "Failed GL_DECR_WRAP test on iteration #%u " + "(got %u, expected %u)\n", max - i, val, expected ); + failed = GL_TRUE; + } + } + if ( !failed ) + printf("OK!\n"); + } + + glDisable(GL_STENCIL_TEST); +} + + +static void Display( void ) +{ + glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); + + RunTest(); + + glutSwapBuffers(); +} + + +static void Reshape( int width, int height ) +{ + glViewport( 0, 0, width, height ); + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glOrtho(0, width, 0, height, -1, 1); + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); +} + + +static void Key( unsigned char key, int x, int y ) +{ + (void) x; + (void) y; + switch (key) { + case 27: + exit(0); + break; + } + glutPostRedisplay(); +} + + +static void Init( void ) +{ + const char * ver_str; + float version; + + printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER)); + printf("GL_VERSION = %s\n", (char *) glGetString(GL_VERSION)); + + + /* Check for both the extension string and GL version 1.4 on the + * outside chance that some vendor exports version 1.4 but doesn't + * export the extension string. The stencil-wrap modes are a required + * part of GL 1.4. + */ + + ver_str = glGetString( GL_VERSION ); + version = (ver_str == NULL) ? 1.0 : atof( ver_str ); + + wrapping = (glutExtensionSupported("GL_EXT_stencil_wrap") || (version >= 1.4)); + if (!wrapping) + printf("GL_EXT_stencil_wrap not supported. Only testing the rest.\n"); +} + + +int main( int argc, char *argv[] ) +{ + glutInit( &argc, argv ); + glutInitWindowPosition( 0, 0 ); + glutInitWindowSize( 400, 400 ); + glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE | GLUT_STENCIL ); + glutCreateWindow(argv[0]); + glutReshapeFunc( Reshape ); + glutKeyboardFunc( Key ); + glutDisplayFunc( Display ); + Init(); + glutMainLoop(); + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/tex1d.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/tex1d.c new file mode 100644 index 000000000..1fab849dd --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/tex1d.c @@ -0,0 +1,139 @@ + +/* Exercise 1D textures + */ + +#include <assert.h> +#include <math.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include "GL/glut.h" + +static GLuint Window = 0; +static GLuint TexObj[2]; +static GLfloat Angle = 0.0f; + + +static void draw( void ) +{ + glClear( GL_COLOR_BUFFER_BIT ); + + glColor3f( 1.0, 1.0, 1.0 ); + + /* draw first polygon */ + glPushMatrix(); + glTranslatef( -1.0, 0.0, 0.0 ); + glRotatef( Angle, 0.0, 0.0, 1.0 ); + glBindTexture( GL_TEXTURE_1D, TexObj[0] ); + glBegin( GL_POLYGON ); + glTexCoord1f( 0.0 ); glVertex2f( -1.0, -1.0 ); + glTexCoord1f( 1.0 ); glVertex2f( 1.0, -1.0 ); + glTexCoord1f( 1.0 ); glVertex2f( 1.0, 1.0 ); + glTexCoord1f( 0.0 ); glVertex2f( -1.0, 1.0 ); + glEnd(); + glPopMatrix(); + + glutSwapBuffers(); +} + + + +static void idle( void ) +{ + Angle += 2.0; + glutPostRedisplay(); +} + + + +/* change view Angle, exit upon ESC */ +static void key(unsigned char k, int x, int y) +{ + (void) x; + (void) y; + switch (k) { + case 27: + exit(0); + } +} + + + +/* new window size or exposure */ +static void reshape( int width, int height ) +{ + glViewport(0, 0, (GLint)width, (GLint)height); + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + /* glOrtho( -3.0, 3.0, -3.0, 3.0, -10.0, 10.0 );*/ + glFrustum( -2.0, 2.0, -2.0, 2.0, 6.0, 20.0 ); + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + glTranslatef( 0.0, 0.0, -8.0 ); +} + + +static void init( void ) +{ + GLubyte tex[256][3]; + GLint i; + + + glDisable( GL_DITHER ); + + /* Setup texturing */ + glEnable( GL_TEXTURE_1D ); + glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL ); + + + /* generate texture object IDs */ + glGenTextures( 2, TexObj ); + + /* setup first texture object */ + glBindTexture( GL_TEXTURE_1D, TexObj[0] ); + + + for (i = 0; i < 256; i++) { + GLfloat f; + + /* map 0..255 to -PI .. PI */ + f = ((i / 255.0) - .5) * (3.141592 * 2); + + f = sin(f); + + /* map -1..1 to 0..255 */ + tex[i][0] = (f+1.0)/2.0 * 255.0; + tex[i][1] = 0; + tex[i][2] = 0; + } + + glTexImage1D( GL_TEXTURE_1D, 0, 3, 256, 0, GL_RGB, GL_UNSIGNED_BYTE, tex ); + glTexParameteri( GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_NEAREST ); + glTexParameteri( GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_NEAREST ); + glTexParameteri( GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_REPEAT ); + glTexParameteri( GL_TEXTURE_1D, GL_TEXTURE_WRAP_T, GL_REPEAT ); +} + + + +int main( int argc, char *argv[] ) +{ + glutInit(&argc, argv); + glutInitWindowPosition(0, 0); + glutInitWindowSize(300, 300); + glutInitDisplayMode( GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE ); + + Window = glutCreateWindow("Texture Objects"); + if (!Window) { + exit(1); + } + + init(); + + glutReshapeFunc( reshape ); + glutKeyboardFunc( key ); +/* glutIdleFunc( idle ); */ + glutDisplayFunc( draw ); + glutMainLoop(); + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/texcmp.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/texcmp.c new file mode 100644 index 000000000..6e822fb68 --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/texcmp.c @@ -0,0 +1,414 @@ +/* + * Compressed texture demo. Written by Daniel Borca. + * This program is in the public domain. + */ + +#include <stdio.h> +#include <stdlib.h> +#include <math.h> +#include <string.h> +#define GL_GLEXT_PROTOTYPES 1 +#include <GL/glut.h> + +#include "readtex.c" /* I know, this is a hack. */ +#define TEXTURE_FILE "../images/tree2.rgba" + + +static float Rot = 0.0; +static GLboolean Anim = 1; + +typedef struct { + GLubyte *data; + GLuint size; + GLenum format; + GLuint w, h; + + GLenum TC; + + GLubyte *cData; + GLuint cSize; + GLenum cFormat; +} TEXTURE; + +static TEXTURE *Tx, t1, t2, t3; +static GLboolean fxt1, dxtc, s3tc; + + +static const char *TextureName (GLenum TC) +{ + switch (TC) { + case GL_RGB: + return "RGB"; + case GL_RGBA: + return "RGBA"; + case GL_COMPRESSED_RGB: + return "COMPRESSED_RGB"; + case GL_COMPRESSED_RGBA: + return "COMPRESSED_RGBA"; + case GL_COMPRESSED_RGB_FXT1_3DFX: + return "GL_COMPRESSED_RGB_FXT1_3DFX"; + case GL_COMPRESSED_RGBA_FXT1_3DFX: + return "GL_COMPRESSED_RGBA_FXT1_3DFX"; + case GL_COMPRESSED_RGB_S3TC_DXT1_EXT: + return "GL_COMPRESSED_RGB_S3TC_DXT1_EXT"; + case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: + return "GL_COMPRESSED_RGBA_S3TC_DXT1_EXT"; + case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT: + return "GL_COMPRESSED_RGBA_S3TC_DXT3_EXT"; + case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT: + return "GL_COMPRESSED_RGBA_S3TC_DXT5_EXT"; + case GL_RGB_S3TC: + return "GL_RGB_S3TC"; + case GL_RGB4_S3TC: + return "GL_RGB4_S3TC"; + case GL_RGBA_S3TC: + return "GL_RGBA_S3TC"; + case GL_RGBA4_S3TC: + return "GL_RGBA4_S3TC"; + case 0: + return "Invalid format"; + default: + return "Unknown format"; + } +} + + +static void +PrintString(const char *s) +{ + while (*s) { + glutBitmapCharacter(GLUT_BITMAP_8_BY_13, (int) *s); + s++; + } +} + + +static void Idle( void ) +{ + float t = glutGet(GLUT_ELAPSED_TIME) * 0.001; /* in seconds */ + Rot = t * 360 / 4; /* 1 rotation per 4 seconds */ + glutPostRedisplay(); +} + + +static void Display( void ) +{ + /* draw background gradient */ + glDisable(GL_TEXTURE_2D); + glBegin(GL_POLYGON); + glColor3f(1.0, 0.0, 0.2); glVertex2f(-1.5, -1.0); + glColor3f(1.0, 0.0, 0.2); glVertex2f( 1.5, -1.0); + glColor3f(0.0, 0.0, 1.0); glVertex2f( 1.5, 1.0); + glColor3f(0.0, 0.0, 1.0); glVertex2f(-1.5, 1.0); + glEnd(); + + glPushMatrix(); + glRotatef(Rot, 0, 0, 1); + + glEnable(GL_TEXTURE_2D); + glBegin(GL_POLYGON); + glTexCoord2f(0, 1); glVertex2f(-1, -0.5); + glTexCoord2f(1, 1); glVertex2f( 1, -0.5); + glTexCoord2f(1, 0); glVertex2f( 1, 0.5); + glTexCoord2f(0, 0); glVertex2f(-1, 0.5); + glEnd(); + + glPopMatrix(); + + /* info */ + glColor4f(1, 1, 1, 1); + + glRasterPos3f(-1.2, -0.7, 0); + PrintString("Selected: "); + PrintString(TextureName(Tx->TC)); + if (Tx->cData) { + char tmp[64]; + glRasterPos3f(-1.2, -0.8, 0); + PrintString("Internal: "); + PrintString(TextureName(Tx->cFormat)); + glRasterPos3f(-1.2, -0.9, 0); + PrintString("Size : "); + sprintf(tmp, "%d (%d%% of %d)", Tx->cSize, Tx->cSize * 100 / Tx->size, Tx->size); + PrintString(tmp); + } + + glutSwapBuffers(); +} + + +static void Reshape( int width, int height ) +{ + glViewport( 0, 0, width, height ); + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glOrtho( -1.5, 1.5, -1.0, 1.0, -1.0, 1.0 ); + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); +} + + +static void ReInit( GLenum TC, TEXTURE *Tx ) +{ + GLint rv; + + if ((Tx->TC == TC) && (Tx->cData != NULL)) { + glCompressedTexImage2DARB(GL_TEXTURE_2D, /* target */ + 0, /* level */ + Tx->cFormat, /* real format */ + Tx->w, /* original width */ + Tx->h, /* original height */ + 0, /* border */ + Tx->cSize, /* compressed size*/ + Tx->cData); /* compressed data*/ + } else { + glTexImage2D(GL_TEXTURE_2D, /* target */ + 0, /* level */ + TC, /* internal format */ + Tx->w, Tx->h, /* width, height */ + 0, /* border */ + Tx->format, /* texture format */ + GL_UNSIGNED_BYTE, /* texture type */ + Tx->data); /* the texture */ + + /* okay, now cache the compressed texture */ + Tx->TC = TC; + if (Tx->cData != NULL) { + free(Tx->cData); + Tx->cData = NULL; + } + glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_COMPRESSED_ARB, &rv); + if (rv) { + glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_INTERNAL_FORMAT, (GLint *)&Tx->cFormat); + glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB, (GLint *)&Tx->cSize); + if ((Tx->cData = malloc(Tx->cSize)) != NULL) { + glGetCompressedTexImageARB(GL_TEXTURE_2D, 0, Tx->cData); + } + } + } +} + + +static void Init( void ) +{ + /* HEIGHT * WIDTH + 1 (for trailing '\0') */ + static char pattern[8 * 32 + 1] = {"\ + \ + MMM EEEE SSS AAA \ + M M M E S S A A \ + M M M EEEE SS A A \ + M M M E SS AAAAA \ + M M E S S A A \ + M M EEEE SSS A A \ + " + }; + + GLuint i, j; + + GLubyte (*texture1)[8 * 32][4]; + GLubyte (*texture2)[256][256][4]; + + t1.w = 32; + t1.h = 8; + t1.size = t1.w * t1.h * 4; + t1.data = malloc(t1.size); + t1.format = GL_RGBA; + t1.TC = GL_RGBA; + + texture1 = (GLubyte (*)[8 * 32][4])t1.data; + for (i = 0; i < sizeof(pattern) - 1; i++) { + switch (pattern[i]) { + default: + case ' ': + (*texture1)[i][0] = 255; + (*texture1)[i][1] = 255; + (*texture1)[i][2] = 255; + (*texture1)[i][3] = 64; + break; + case 'M': + (*texture1)[i][0] = 255; + (*texture1)[i][1] = 0; + (*texture1)[i][2] = 0; + (*texture1)[i][3] = 255; + break; + case 'E': + (*texture1)[i][0] = 0; + (*texture1)[i][1] = 255; + (*texture1)[i][2] = 0; + (*texture1)[i][3] = 255; + break; + case 'S': + (*texture1)[i][0] = 0; + (*texture1)[i][1] = 0; + (*texture1)[i][2] = 255; + (*texture1)[i][3] = 255; + break; + case 'A': + (*texture1)[i][0] = 255; + (*texture1)[i][1] = 255; + (*texture1)[i][2] = 0; + (*texture1)[i][3] = 255; + break; + } + } + + t2.w = 256; + t2.h = 256; + t2.size = t2.w * t2.h * 4; + t2.data = malloc(t2.size); + t2.format = GL_RGBA; + t2.TC = GL_RGBA; + + texture2 = (GLubyte (*)[256][256][4])t2.data; + for (j = 0; j < t2.h; j++) { + for (i = 0; i < t2.w; i++) { + (*texture2)[j][i][0] = sqrt(i * j * 255 * 255 / (t2.w * t2.h)); + (*texture2)[j][i][1] = 0; + (*texture2)[j][i][2] = 0; + (*texture2)[j][i][3] = 255; + } + } + + t3.data = LoadRGBImage(TEXTURE_FILE, (GLint *)&t3.w, (GLint *)&t3.h, &t3.format); + t3.size = t3.w * t3.h * ((t3.format == GL_RGB) ? 3 : 4); + t3.TC = GL_RGBA; + + ReInit(GL_RGBA, Tx = &t1); + + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); + glEnable(GL_TEXTURE_2D); + + glEnable(GL_BLEND); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); +} + + +static void Key( unsigned char key, int x, int y ) +{ + (void) x; + (void) y; + switch (key) { + case 27: + exit(0); + break; + case ' ': + Anim = !Anim; + if (Anim) + glutIdleFunc( Idle ); + else + glutIdleFunc( NULL ); + break; + case 't': + if (Tx == &t1) { + Tx = &t2; + } else if (Tx == &t2) { + Tx = &t3; + } else { + Tx = &t1; + } + ReInit(Tx->TC, Tx); + break; + case '9': + ReInit(GL_RGB, Tx); + break; + case '0': + ReInit(GL_RGBA, Tx); + break; + case '1': + ReInit(GL_COMPRESSED_RGB, Tx); + break; + case '2': + ReInit(GL_COMPRESSED_RGBA, Tx); + break; + case '3': + if (fxt1) ReInit(GL_COMPRESSED_RGB_FXT1_3DFX, Tx); + break; + case '4': + if (fxt1) ReInit(GL_COMPRESSED_RGBA_FXT1_3DFX, Tx); + break; + case '5': + if (dxtc) ReInit(GL_COMPRESSED_RGB_S3TC_DXT1_EXT, Tx); + break; + case '6': + if (dxtc) ReInit(GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, Tx); + break; + case '7': + if (dxtc) ReInit(GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, Tx); + break; + case '8': + if (dxtc) ReInit(GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, Tx); + break; + case 'a': + if (s3tc) ReInit(GL_RGB_S3TC, Tx); + break; + case 's': + if (s3tc) ReInit(GL_RGB4_S3TC, Tx); + break; + case 'd': + if (s3tc) ReInit(GL_RGBA_S3TC, Tx); + break; + case 'f': + if (s3tc) ReInit(GL_RGBA4_S3TC, Tx); + break; + } + glutPostRedisplay(); +} + + +int main( int argc, char *argv[] ) +{ + float gl_version; + GLint num_formats; + GLint i; + GLint formats[64]; + + + glutInit( &argc, argv ); + glutInitWindowPosition( 0, 0 ); + glutInitWindowSize( 400, 300 ); + + glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE ); + + if (glutCreateWindow(argv[0]) <= 0) { + printf("Couldn't create window\n"); + exit(0); + } + + gl_version = atof( (const char *) glGetString( GL_VERSION ) ); + if ( (gl_version < 1.3) + && !glutExtensionSupported("GL_ARB_texture_compression") ) { + printf("Sorry, GL_ARB_texture_compression not supported\n"); + exit(0); + } + if (glutExtensionSupported("GL_3DFX_texture_compression_FXT1")) { + fxt1 = GL_TRUE; + } + if (glutExtensionSupported("GL_EXT_texture_compression_s3tc")) { + dxtc = GL_TRUE; + } + if (glutExtensionSupported("GL_S3_s3tc")) { + s3tc = GL_TRUE; + } + + glGetIntegerv( GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB, & num_formats ); + + (void) memset( formats, 0, sizeof( formats ) ); + glGetIntegerv( GL_COMPRESSED_TEXTURE_FORMATS_ARB, formats ); + + printf( "The following texture formats are supported:\n" ); + for ( i = 0 ; i < num_formats ; i++ ) { + printf( "\t%s\n", TextureName( formats[i] ) ); + } + + Init(); + + glutReshapeFunc( Reshape ); + glutKeyboardFunc( Key ); + glutDisplayFunc( Display ); + if (Anim) + glutIdleFunc( Idle ); + + glutMainLoop(); + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/texgenmix.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/texgenmix.c new file mode 100644 index 000000000..be8f6775c --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/texgenmix.c @@ -0,0 +1,640 @@ + +/* + * Demonstrates mixed texgen/non-texgen texture coordinates. + */ + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <GL/glut.h> + +#undef max +#undef min +#define max( a, b ) ((a) >= (b) ? (a) : (b)) +#define min( a, b ) ((a) <= (b) ? (a) : (b)) + +GLfloat labelColor0[4] = { 1.0, 1.0, 1.0, 1.0 }; +GLfloat labelColor1[4] = { 1.0, 1.0, 0.4, 1.0 }; +GLfloat *labelInfoColor = labelColor0; + +GLboolean doubleBuffered = GL_TRUE; +GLboolean drawTextured = GL_TRUE; + +int textureWidth = 64; +int textureHeight = 64; + +int winWidth = 580, winHeight = 720; + +const GLfloat texmat_swap_rq[16] = { 1.0, 0.0, 0.0, 0.0, + 0.0, 1.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 1.0, + 0.0, 0.0, 1.0, 0.0}; + +const GLfloat nullPlane[4] = { 0.0, 0.0, 0.0, 0.0 }; +const GLfloat ObjPlaneS1[4] = { 1.0, 0.0, 1.0, 0.0 }; +const GLfloat ObjPlaneS2[4] = { 0.5, 0.0, 0.0, 0.0 }; +const GLfloat ObjPlaneS3[4] = { 1.0, 0.0, 0.0, 0.0 }; +const GLfloat ObjPlaneT[4] = { 0.0, 1.0, 0.0, 0.0 }; +const GLfloat ObjPlaneT2[4] = { 0.0, 0.5, 0.0, 0.0 }; +const GLfloat ObjPlaneT3[4] = { 0.0, 1.0, 0.0, 0.0 }; +const GLfloat ObjPlaneR[4] = { 0.0, 0.0, 1.0, 0.0 }; +const GLfloat ObjPlaneQ[4] = { 0.0, 0.0, 0.0, 0.5 }; + + +static void checkErrors( void ) +{ + GLenum error; + + while ( (error = glGetError()) != GL_NO_ERROR ) { + fprintf( stderr, "Error: %s\n", (char *) gluErrorString( error ) ); + } +} + +static void drawString( const char *string, GLfloat x, GLfloat y, + const GLfloat color[4] ) +{ + glColor4fv( color ); + glRasterPos2f( x, y ); + + while ( *string ) { + glutBitmapCharacter( GLUT_BITMAP_TIMES_ROMAN_10, *string ); + string++; + } +} + +static void begin2D( int width, int height ) +{ + glMatrixMode( GL_PROJECTION ); + + glPushMatrix(); + glLoadIdentity(); + + glOrtho( 0, width, 0, height, -1, 1 ); + glMatrixMode( GL_MODELVIEW ); + + glPushMatrix(); + glLoadIdentity(); +} + +static void end2D( void ) +{ + glMatrixMode( GL_PROJECTION ); + glPopMatrix(); + glMatrixMode( GL_MODELVIEW ); + glPopMatrix(); +} + +static void initialize( void ) +{ + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + + glOrtho( -1.5, 1.5, -1.5, 1.5, -1.5, 1.5 ); + + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + + glShadeModel( GL_FLAT ); +} + +/* ARGSUSED1 */ +static void keyboard( unsigned char c, int x, int y ) +{ + switch ( c ) { + case 't': + drawTextured = !drawTextured; + break; + case 27: /* Escape key should force exit. */ + exit(0); + break; + default: + break; + } + glutPostRedisplay(); +} + +/* ARGSUSED1 */ +static void special( int key, int x, int y ) +{ + switch ( key ) { + case GLUT_KEY_DOWN: + break; + case GLUT_KEY_UP: + break; + case GLUT_KEY_LEFT: + break; + case GLUT_KEY_RIGHT: + break; + default: + break; + } + glutPostRedisplay(); +} + +static void +reshape( int w, int h ) +{ + winWidth = w; + winHeight = h; + /* No need to call glViewPort here since "draw" calls it! */ +} + +static void loadTexture( int width, int height ) +{ + int alphaSize = 1; + int rgbSize = 3; + GLubyte *texImage, *p; + int elementsPerGroup, elementSize, groupSize, rowSize; + int i, j; + + + elementsPerGroup = alphaSize + rgbSize; + elementSize = sizeof(GLubyte); + groupSize = elementsPerGroup * elementSize; + rowSize = width * groupSize; + + if ( (texImage = (GLubyte *) malloc( height * rowSize ) ) == NULL ) { + fprintf( stderr, "texture malloc failed\n" ); + return; + } + + for ( i = 0 ; i < height ; i++ ) + { + p = texImage + i * rowSize; + + for ( j = 0 ; j < width ; j++ ) + { + if ( rgbSize > 0 ) + { + /** + ** +-----+-----+ + ** | | | + ** | R | G | + ** | | | + ** +-----+-----+ + ** | | | + ** | Y | B | + ** | | | + ** +-----+-----+ + **/ + if ( i > height / 2 ) { + if ( j < width / 2 ) { + p[0] = 0xff; + p[1] = 0x00; + p[2] = 0x00; + } else { + p[0] = 0x00; + p[1] = 0xff; + p[2] = 0x00; + } + } else { + if ( j < width / 2 ) { + p[0] = 0xff; + p[1] = 0xff; + p[2] = 0x00; + } else { + p[0] = 0x00; + p[1] = 0x00; + p[2] = 0xff; + } + } + p += 3 * elementSize; + } + + if ( alphaSize > 0 ) + { + /** + ** +-----------+ + ** | W | + ** | +-----+ | + ** | | | | + ** | | B | | + ** | | | | + ** | +-----+ | + ** | | + ** +-----------+ + **/ + int i2 = i - height / 2; + int j2 = j - width / 2; + int h8 = height / 8; + int w8 = width / 8; + if ( -h8 <= i2 && i2 <= h8 && -w8 <= j2 && j2 <= w8 ) { + p[0] = 0x00; + } else if ( -2 * h8 <= i2 && i2 <= 2 * h8 && -2 * w8 <= j2 && j2 <= 2 * w8 ) { + p[0] = 0x55; + } else if ( -3 * h8 <= i2 && i2 <= 3 * h8 && -3 * w8 <= j2 && j2 <= 3 * w8 ) { + p[0] = 0xaa; + } else { + p[0] = 0xff; + } + p += elementSize; + } + } + } + + glTexImage2D( GL_TEXTURE_2D, 0, + GL_RGBA, width, height, 0, + GL_RGBA, GL_UNSIGNED_BYTE, texImage ); + + free( texImage ); +} + + +static void drawSample( int x, int y, int w, int h, + int texgenenabled, int coordnr ) +{ + char buf[255]; + + glViewport( x, y, w, h ); + glScissor( x, y, w, h ); + + glClearColor( 0.1, 0.1, 0.1, 1.0 ); + glClear( GL_COLOR_BUFFER_BIT ); + + begin2D( w, h ); + if (texgenenabled == 2) { + sprintf( buf, "TexCoord%df", coordnr); + drawString( buf, 10, h - 15, labelInfoColor ); + sprintf( buf, "texgen enabled for %s coordinate(s)", coordnr == 2 ? "S" : "S/T"); + drawString( buf, 10, 5, labelInfoColor ); + } + else if (texgenenabled == 0) { + sprintf( buf, "TexCoord%df", coordnr); + drawString( buf, 10, h - 15, labelInfoColor ); + drawString( "no texgen", 10, 5, labelInfoColor ); + } + else if (texgenenabled == 1) { + drawString( "no TexCoord", 10, h - 15, labelInfoColor ); + sprintf( buf, "texgen enabled for %s coordinate(s)", + coordnr == 2 ? "S/T" : (coordnr == 3 ? "S/T/R" : "S/T/R/Q")); + drawString( buf, 10, 5, labelInfoColor ); + } + + end2D(); + + glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE ); + + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST ); + + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP ); + + loadTexture( textureWidth, textureHeight ); + + if ( drawTextured ) { + glEnable( GL_TEXTURE_2D ); + } + + glDisable( GL_TEXTURE_GEN_S ); + glDisable( GL_TEXTURE_GEN_T ); + glDisable( GL_TEXTURE_GEN_R ); + glDisable( GL_TEXTURE_GEN_Q ); + + glMatrixMode( GL_TEXTURE ); + glLoadIdentity(); + glMatrixMode( GL_MODELVIEW ); + glPushMatrix(); + + switch (coordnr) { + case 2: + switch (texgenenabled) { + case 0: + glBegin( GL_QUADS ); + glTexCoord2f( 0.0, 0.0 ); + glVertex2f( -0.8, -0.8 ); + + glTexCoord2f( 1.0, 0.0 ); + glVertex2f( 0.8, -0.8 ); + + glTexCoord2f( 1.0, 1.0 ); + glVertex2f( 0.8, 0.8 ); + + glTexCoord2f( 0.0, 1.0 ); + glVertex2f( -0.8, 0.8 ); + glEnd(); + break; + case 1: + glTranslatef( -0.8, -0.8, 0.0 ); + glScalef( 1.6, 1.6, 1.0 ); + glTexGeni( GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR ); + glTexGeni( GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR ); + glTexGeni( GL_R, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR ); + glTexGeni( GL_Q, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR ); + glTexGenfv(GL_S, GL_OBJECT_PLANE, ObjPlaneS3); + glTexGenfv(GL_T, GL_OBJECT_PLANE, ObjPlaneT3); + glTexGenfv(GL_R, GL_OBJECT_PLANE, nullPlane); + glTexGenfv(GL_Q, GL_OBJECT_PLANE, nullPlane); + + glEnable( GL_TEXTURE_GEN_S ); + glEnable( GL_TEXTURE_GEN_T ); + + /* Issue a texcoord here to be sure Q isn't left over from a + * previous sample. + */ + glTexCoord1f( 0.0 ); + glBegin( GL_QUADS ); + glVertex2f( 0.0, 0.0 ); + glVertex2f( 1.0, 0.0 ); + glVertex2f( 1.0, 1.0 ); + glVertex2f( 0.0, 1.0 ); + glEnd(); + break; + case 2: + /* make sure that texgen T and non-texgen S coordinate are wrong */ + glTexGeni( GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR ); + glTexGeni( GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR ); + glTexGeni( GL_R, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR ); + glTexGeni( GL_Q, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR ); + glTexGenfv(GL_S, GL_OBJECT_PLANE, ObjPlaneS1); + glTexGenfv(GL_T, GL_OBJECT_PLANE, nullPlane); + glTexGenfv(GL_R, GL_OBJECT_PLANE, nullPlane); + glTexGenfv(GL_Q, GL_OBJECT_PLANE, nullPlane); + + glEnable( GL_TEXTURE_GEN_S ); + + glBegin( GL_QUADS ); + /* use z coordinate to get correct texgen values... */ + glTexCoord2f( 0.0, 0.0 ); + glVertex3f( -0.8, -0.8, 0.8 ); + + glTexCoord2f( 0.0, 0.0 ); + glVertex3f( 0.8, -0.8, 0.2 ); + + glTexCoord2f( 0.0, 1.0 ); + glVertex3f( 0.8, 0.8, 0.2 ); + + glTexCoord2f( 0.0, 1.0 ); + glVertex3f( -0.8, 0.8, 0.8 ); + glEnd(); + break; + } + break; + case 3: + glMatrixMode( GL_TEXTURE ); + glLoadMatrixf( texmat_swap_rq ); + glMatrixMode( GL_MODELVIEW ); + glTranslatef( -0.8, -0.8, 0.0 ); + glScalef( 1.6, 1.6, 1.0 ); + switch (texgenenabled) { + case 0: + glBegin( GL_QUADS ); + glTexCoord3f( 0.0, 0.0, 0.5 ); + glVertex2f( 0.0, 0.0 ); + + glTexCoord3f( 0.5, 0.0, 0.5 ); + glVertex2f( 1.0, 0.0 ); + + glTexCoord3f( 0.5, 0.5, 0.5 ); + glVertex2f( 1.0, 1.0 ); + + glTexCoord3f( 0.0, 0.5, 0.5 ); + glVertex2f( 0.0, 1.0 ); + glEnd(); + break; + case 1: + glTexGeni( GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR ); + glTexGeni( GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR ); + glTexGeni( GL_R, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR ); + glTexGeni( GL_Q, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR ); + glTexGenfv(GL_S, GL_OBJECT_PLANE, ObjPlaneS2); + glTexGenfv(GL_T, GL_OBJECT_PLANE, ObjPlaneT2); + glTexGenfv(GL_R, GL_OBJECT_PLANE, ObjPlaneR); + glTexGenfv(GL_Q, GL_OBJECT_PLANE, nullPlane); + + glEnable( GL_TEXTURE_GEN_S ); + glEnable( GL_TEXTURE_GEN_T ); + glEnable( GL_TEXTURE_GEN_R ); + + glTexCoord1f( 0.0 ); /* to make sure Q is 1.0 */ + glBegin( GL_QUADS ); + glVertex3f( 0.0, 0.0, 0.5 ); + glVertex3f( 1.0, 0.0, 0.5 ); + glVertex3f( 1.0, 1.0, 0.5 ); + glVertex3f( 0.0, 1.0, 0.5 ); + glEnd(); + break; + case 2: + /* make sure that texgen R/Q and non-texgen S/T coordinates are wrong */ + glTexGeni( GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR ); + glTexGeni( GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR ); + glTexGeni( GL_R, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR ); + glTexGeni( GL_Q, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR ); + glTexGenfv(GL_S, GL_OBJECT_PLANE, ObjPlaneS2); + glTexGenfv(GL_T, GL_OBJECT_PLANE, ObjPlaneT2); + glTexGenfv(GL_R, GL_OBJECT_PLANE, nullPlane); + glTexGenfv(GL_Q, GL_OBJECT_PLANE, nullPlane); + + glEnable( GL_TEXTURE_GEN_S ); + glEnable( GL_TEXTURE_GEN_T ); + + glBegin( GL_QUADS ); + glTexCoord3f( 0.0, 0.0, 0.5 ); + glVertex2f( 0.0, 0.0); + + glTexCoord3f( 0.0, 0.0, 0.5 ); + glVertex2f( 1.0, 0.0); + + glTexCoord3f( 0.0, 0.0, 0.5 ); + glVertex2f( 1.0, 1.0); + + glTexCoord3f( 0.0, 0.0, 0.5 ); + glVertex2f( 0.0, 1.0); + glEnd(); + break; + } + break; + case 4: + switch (texgenenabled) { + case 0: + glBegin( GL_QUADS ); + /* don't need r coordinate but still setting it I'm mean */ + glTexCoord4f( 0.0, 0.0, 0.0, 0.5 ); + glVertex2f( -0.8, -0.8 ); + + glTexCoord4f( 0.5, 0.0, 0.2, 0.5 ); + glVertex2f( 0.8, -0.8 ); + + glTexCoord4f( 0.5, 0.5, 0.5, 0.5 ); + glVertex2f( 0.8, 0.8 ); + + glTexCoord4f( 0.0, 0.5, 0.5, 0.5 ); + glVertex2f( -0.8, 0.8 ); + glEnd(); + break; + case 1: + glTranslatef( -0.8, -0.8, 0.0 ); + glScalef( 1.6, 1.6, 1.0 ); + /* make sure that texgen R/Q and non-texgen S/T coordinates are wrong */ + glTexGeni( GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR ); + glTexGeni( GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR ); + glTexGeni( GL_R, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR ); + glTexGeni( GL_Q, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR ); + glTexGenfv(GL_S, GL_OBJECT_PLANE, ObjPlaneS2); + glTexGenfv(GL_T, GL_OBJECT_PLANE, ObjPlaneT2); + glTexGenfv(GL_R, GL_OBJECT_PLANE, ObjPlaneR); + glTexGenfv(GL_Q, GL_OBJECT_PLANE, ObjPlaneQ); + + glEnable( GL_TEXTURE_GEN_S ); + glEnable( GL_TEXTURE_GEN_T ); + glEnable( GL_TEXTURE_GEN_R ); + glEnable( GL_TEXTURE_GEN_Q ); + + glBegin( GL_QUADS ); + glVertex2f( 0.0, 0.0 ); + glVertex2f( 1.0, 0.0 ); + glVertex2f( 1.0, 1.0 ); + glVertex2f( 0.0, 1.0 ); + glEnd(); + break; + case 2: + glTranslatef( -0.8, -0.8, 0.0 ); + glScalef( 1.6, 1.6, 1.0 ); + /* make sure that texgen R/Q and non-texgen S/T coordinates are wrong */ + glTexGeni( GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR ); + glTexGeni( GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR ); + glTexGeni( GL_R, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR ); + glTexGeni( GL_Q, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR ); + glTexGenfv(GL_S, GL_OBJECT_PLANE, ObjPlaneS2); + glTexGenfv(GL_T, GL_OBJECT_PLANE, ObjPlaneT2); + glTexGenfv(GL_R, GL_OBJECT_PLANE, nullPlane); + glTexGenfv(GL_Q, GL_OBJECT_PLANE, nullPlane); + + glEnable( GL_TEXTURE_GEN_S ); + glEnable( GL_TEXTURE_GEN_T ); + + glBegin( GL_QUADS ); + glTexCoord4f( 0.0, 0.0, 0.0, 0.5 ); + glVertex2f( 0.0, 0.0 ); + + glTexCoord4f( 0.0, 0.0, 0.2, 0.5 ); + glVertex2f( 1.0, 0.0 ); + + glTexCoord4f( 0.0, 0.0, 0.5, 0.5 ); + glVertex2f( 1.0, 1.0 ); + + glTexCoord4f( 0.0, 0.0, 0.75, 0.5 ); + glVertex2f( 0.0, 1.0 ); + glEnd(); + break; + } + break; + } + + glPopMatrix(); + glDisable( GL_TEXTURE_2D ); + +} + +static void display( void ) +{ + int numX = 3, numY = 3; + float xBase = (float) winWidth * 0.01; + float xOffset = (winWidth - xBase) / numX; + float xSize = max( xOffset - xBase, 1 ); + float yBase = (float) winHeight * 0.01; + float yOffset = (winHeight - yBase) / numY; + float ySize = max( yOffset - yBase, 1 ); + float x, y; + int i, j; + + glViewport( 0, 0, winWidth, winHeight ); + glDisable( GL_SCISSOR_TEST ); + glClearColor( 0.0, 0.0, 0.0, 0.0 ); + glClear( GL_COLOR_BUFFER_BIT ); + glEnable( GL_SCISSOR_TEST ); + + x = xBase; + y = (winHeight - 1) - yOffset; + + for ( i = 0 ; i < numY ; i++ ) + { + + labelInfoColor = labelColor1; + + + for ( j = 0 ; j < numX ; j++ ) { + drawSample( x, y, xSize, ySize, i, j+2 ); + x += xOffset; + } + + x = xBase; + y -= yOffset; + } + + if ( doubleBuffered ) { + glutSwapBuffers(); + } else { + glFlush(); + } + + checkErrors(); +} + +static void usage( char *name ) +{ + fprintf( stderr, "usage: %s [ options ]\n", name ); + fprintf( stderr, "\n" ); + fprintf( stderr, "options:\n" ); + fprintf( stderr, " -sb single buffered\n" ); + fprintf( stderr, " -db double buffered\n" ); + fprintf( stderr, " -info print OpenGL driver info\n" ); +} + +static void instructions( void ) +{ + fprintf( stderr, "texgenmix - mixed texgen/non-texgen texture coordinate test\n" ); + fprintf( stderr, "all quads should look the same!\n" ); + fprintf( stderr, "\n" ); + fprintf( stderr, " [t] - toggle texturing\n" ); +} + +int main( int argc, char *argv[] ) +{ + GLboolean info = GL_FALSE; + int i; + + glutInit( &argc, argv ); + + for ( i = 1 ; i < argc ; i++ ) { + if ( !strcmp( "-sb", argv[i] ) ) { + doubleBuffered = GL_FALSE; + } else if ( !strcmp( "-db", argv[i] ) ) { + doubleBuffered = GL_TRUE; + } else if ( !strcmp( "-info", argv[i] ) ) { + info = GL_TRUE; + } else { + usage( argv[0] ); + exit( 1 ); + } + } + + if ( doubleBuffered ) { + glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE ); + } else { + glutInitDisplayMode( GLUT_RGB | GLUT_SINGLE ); + } + + glutInitWindowSize( winWidth, winHeight ); + glutInitWindowPosition( 0, 0 ); + glutCreateWindow( "Mixed texgen/non-texgen texture coordinate test" ); + + initialize(); + instructions(); + + if ( info ) { + printf( "\n" ); + printf( "GL_RENDERER = %s\n", (char *) glGetString( GL_RENDERER ) ); + printf( "GL_VERSION = %s\n", (char *) glGetString( GL_VERSION ) ); + printf( "GL_VENDOR = %s\n", (char *) glGetString( GL_VENDOR ) ) ; + printf( "GL_EXTENSIONS = %s\n", (char *) glGetString( GL_EXTENSIONS ) ); + } + + glutDisplayFunc( display ); + glutReshapeFunc( reshape ); + glutKeyboardFunc( keyboard ); + glutSpecialFunc( special ); + glutMainLoop(); + + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/texline.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/texline.c new file mode 100644 index 000000000..3d59d9ac2 --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/texline.c @@ -0,0 +1,269 @@ +/* $Id: texline.c,v 1.5 2004/01/28 10:07:48 keithw Exp $ */ + +/* + * Test textured lines. + * + * Brian Paul + * September 2000 + */ + + +#include <stdio.h> +#include <stdlib.h> +#include <math.h> +#include <GL/glut.h> +#include "../util/readtex.c" /* I know, this is a hack. */ + +#define TEXTURE_FILE "../images/girl.rgb" + +static GLboolean Antialias = GL_FALSE; +static GLboolean Animate = GL_FALSE; +static GLint Texture = 1; +static GLboolean Stipple = GL_FALSE; +static GLfloat LineWidth = 1.0; + +static GLfloat Xrot = -60.0, Yrot = 0.0, Zrot = 0.0; +static GLfloat DYrot = 1.0; +static GLboolean Points = GL_FALSE; +static GLfloat Scale = 1.0; + +static void Idle( void ) +{ + if (Animate) { + Zrot += DYrot; + glutPostRedisplay(); + } +} + + +static void Display( void ) +{ + GLfloat x, y, s, t; + + glClear( GL_COLOR_BUFFER_BIT ); + + glPushMatrix(); + glRotatef(Xrot, 1.0, 0.0, 0.0); + glRotatef(Yrot, 0.0, 1.0, 0.0); + glRotatef(Zrot, 0.0, 0.0, 1.0); + glScalef(Scale, Scale, Scale); + + if (Texture) + glColor3f(1, 1, 1); + + if (Points) { + glBegin(GL_POINTS); + for (t = 0.0; t <= 1.0; t += 0.025) { + for (s = 0.0; s <= 1.0; s += 0.025) { + x = s * 2.0 - 1.0; + y = t * 2.0 - 1.0; + if (!Texture) + glColor3f(1, 0, 1); + glMultiTexCoord2fARB(GL_TEXTURE1_ARB, t, s); + glTexCoord2f(s, t); + glVertex2f(x, y); + } + } + glEnd(); + } + else { + glBegin(GL_LINES); + for (t = 0.0; t <= 1.0; t += 0.025) { + x = t * 2.0 - 1.0; + if (!Texture) + glColor3f(1, 0, 1); + glTexCoord2f(t, 0.0); + glMultiTexCoord2fARB(GL_TEXTURE1_ARB, 0.0, t); + glVertex2f(x, -1.0); + if (!Texture) + glColor3f(0, 1, 0); + glTexCoord2f(t, 1.0); + glMultiTexCoord2fARB(GL_TEXTURE1_ARB, 1.0, t); + glVertex2f(x, 1.0); + } + glEnd(); + } + + glPopMatrix(); + + glutSwapBuffers(); +} + + +static void Reshape( int width, int height ) +{ + GLfloat ar = (float) width / height; + glViewport( 0, 0, width, height ); + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glFrustum( -ar, ar, -1.0, 1.0, 10.0, 100.0 ); + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); + glTranslatef( 0.0, 0.0, -12.0 ); +} + + +static void Key( unsigned char key, int x, int y ) +{ + (void) x; + (void) y; + switch (key) { + case 'a': + Antialias = !Antialias; + if (Antialias) { + glEnable(GL_LINE_SMOOTH); + glEnable(GL_POINT_SMOOTH); + glEnable(GL_BLEND); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + } + else { + glDisable(GL_LINE_SMOOTH); + glDisable(GL_POINT_SMOOTH); + glDisable(GL_BLEND); + } + break; + case 't': + Texture++; + if (Texture > 2) + Texture = 0; + if (Texture == 0) { + glActiveTextureARB(GL_TEXTURE0_ARB); + glDisable(GL_TEXTURE_2D); + glActiveTextureARB(GL_TEXTURE1_ARB); + glDisable(GL_TEXTURE_2D); + } + else if (Texture == 1) { + glActiveTextureARB(GL_TEXTURE0_ARB); + glEnable(GL_TEXTURE_2D); + glActiveTextureARB(GL_TEXTURE1_ARB); + glDisable(GL_TEXTURE_2D); + } + else { + glActiveTextureARB(GL_TEXTURE0_ARB); + glEnable(GL_TEXTURE_2D); + glActiveTextureARB(GL_TEXTURE1_ARB); + glEnable(GL_TEXTURE_2D); + } + break; + case 'w': + LineWidth -= 0.25; + if (LineWidth < 0.25) + LineWidth = 0.25; + glLineWidth(LineWidth); + glPointSize(LineWidth); + break; + case 'W': + LineWidth += 0.25; + if (LineWidth > 8.0) + LineWidth = 8.0; + glLineWidth(LineWidth); + glPointSize(LineWidth); + break; + case 'p': + Points = !Points; + break; + case 's': + Stipple = !Stipple; + if (Stipple) + glEnable(GL_LINE_STIPPLE); + else + glDisable(GL_LINE_STIPPLE); + break; + case ' ': + Animate = !Animate; + if (Animate) + glutIdleFunc(Idle); + else + glutIdleFunc(NULL); + break; + case 27: + exit(0); + break; + } + printf("LineWidth, PointSize = %f\n", LineWidth); + glutPostRedisplay(); +} + + +static void SpecialKey( int key, int x, int y ) +{ + float step = 3.0; + (void) x; + (void) y; + + switch (key) { + case GLUT_KEY_UP: + Xrot += step; + break; + case GLUT_KEY_DOWN: + Xrot -= step; + break; + case GLUT_KEY_LEFT: + Yrot += step; + break; + case GLUT_KEY_RIGHT: + Yrot -= step; + break; + } + glutPostRedisplay(); +} + + +static void Init( int argc, char *argv[] ) +{ + GLuint u; + for (u = 0; u < 2; u++) { + glActiveTextureARB(GL_TEXTURE0_ARB + u); + glBindTexture(GL_TEXTURE_2D, 10+u); + if (u == 0) + glEnable(GL_TEXTURE_2D); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + + if (u == 0) + glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); + else + glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_ADD); + + glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + if (!LoadRGBMipmaps(TEXTURE_FILE, GL_RGB)) { + printf("Error: couldn't load texture image\n"); + exit(1); + } + } + + glLineStipple(1, 0xff); + + if (argc > 1 && strcmp(argv[1], "-info")==0) { + printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER)); + printf("GL_VERSION = %s\n", (char *) glGetString(GL_VERSION)); + printf("GL_VENDOR = %s\n", (char *) glGetString(GL_VENDOR)); + printf("GL_EXTENSIONS = %s\n", (char *) glGetString(GL_EXTENSIONS)); + } +} + + +int main( int argc, char *argv[] ) +{ + glutInit( &argc, argv ); + glutInitWindowPosition(0, 0); + glutInitWindowSize( 400, 300 ); + + glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE ); + + glutCreateWindow(argv[0] ); + + Init(argc, argv); + + glutReshapeFunc( Reshape ); + glutKeyboardFunc( Key ); + glutSpecialFunc( SpecialKey ); + glutDisplayFunc( Display ); + if (Animate) + glutIdleFunc( Idle ); + + glutMainLoop(); + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/texobjshare.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/texobjshare.c new file mode 100644 index 000000000..2b31cb6c4 --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/texobjshare.c @@ -0,0 +1,219 @@ +/* + * Create several OpenGL rendering contexts, sharing textures, display + * lists, etc. Exercise binding, deleting, etc. + * + * Brian Paul + * 21 December 2004 + */ + + +#include <GL/gl.h> +#include <GL/glx.h> +#include <assert.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> +#include <X11/keysym.h> + + +/* + * Each display/window/context: + */ +struct context { + char DisplayName[1000]; + Display *Dpy; + Window Win; + GLXContext Context; +}; + + +#define MAX_CONTEXTS 200 +static struct context Contexts[MAX_CONTEXTS]; +static int NumContexts = 0; + + +static void +Error(const char *display, const char *msg) +{ + fprintf(stderr, "Error on display %s - %s\n", display, msg); + exit(1); +} + + +static struct context * +CreateContext(const char *displayName, const char *name) +{ + Display *dpy; + Window win; + GLXContext ctx; + int attrib[] = { GLX_RGBA, + GLX_RED_SIZE, 1, + GLX_GREEN_SIZE, 1, + GLX_BLUE_SIZE, 1, + GLX_DOUBLEBUFFER, + None }; + int scrnum; + XSetWindowAttributes attr; + unsigned long mask; + Window root; + XVisualInfo *visinfo; + int width = 90, height = 90; + int xpos = 0, ypos = 0; + + if (NumContexts >= MAX_CONTEXTS) + return NULL; + + dpy = XOpenDisplay(displayName); + if (!dpy) { + Error(displayName, "Unable to open display"); + return NULL; + } + + scrnum = DefaultScreen(dpy); + root = RootWindow(dpy, scrnum); + + visinfo = glXChooseVisual(dpy, scrnum, attrib); + if (!visinfo) { + Error(displayName, "Unable to find RGB, double-buffered visual"); + return NULL; + } + + /* window attributes */ + xpos = (NumContexts % 10) * 100; + ypos = (NumContexts / 10) * 100; + attr.background_pixel = 0; + attr.border_pixel = 0; + attr.colormap = XCreateColormap(dpy, root, visinfo->visual, AllocNone); + attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask; + mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask; + + win = XCreateWindow(dpy, root, xpos, ypos, width, height, + 0, visinfo->depth, InputOutput, + visinfo->visual, mask, &attr); + if (!win) { + Error(displayName, "Couldn't create window"); + return NULL; + } + + { + XSizeHints sizehints; + sizehints.x = xpos; + sizehints.y = ypos; + sizehints.width = width; + sizehints.height = height; + sizehints.flags = USSize | USPosition; + XSetNormalHints(dpy, win, &sizehints); + XSetStandardProperties(dpy, win, name, name, + None, (char **)NULL, 0, &sizehints); + } + + if (NumContexts == 0) { + ctx = glXCreateContext(dpy, visinfo, NULL, True); + } + else { + /* share textures & dlists with 0th context */ + ctx = glXCreateContext(dpy, visinfo, Contexts[0].Context, True); + } + if (!ctx) { + Error(displayName, "Couldn't create GLX context"); + return NULL; + } + + XMapWindow(dpy, win); + + if (!glXMakeCurrent(dpy, win, ctx)) { + Error(displayName, "glXMakeCurrent failed"); + return NULL; + } + + if (NumContexts == 0) { + printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER)); + } + + /* save the info for this context */ + { + struct context *h = &Contexts[NumContexts]; + strcpy(h->DisplayName, name); + h->Dpy = dpy; + h->Win = win; + h->Context = ctx; + NumContexts++; + return &Contexts[NumContexts-1]; + } +} + + +static void +MakeCurrent(int i) +{ + if (!glXMakeCurrent(Contexts[i].Dpy, Contexts[i].Win, Contexts[i].Context)) { + fprintf(stderr, "glXMakeCurrent failed!\n"); + } +} + + + +static void +DestroyContext(int i) +{ + XDestroyWindow(Contexts[i].Dpy, Contexts[i].Win); + glXDestroyContext(Contexts[i].Dpy, Contexts[i].Context); + XCloseDisplay(Contexts[i].Dpy); +} + + +int +main(int argc, char *argv[]) +{ + char *dpyName = NULL; + int i; + GLuint t; + GLint tb; + + for (i = 0; i < 2; i++) { + CreateContext(dpyName, "context"); + } + + /* Create texture and bind it in context 0 */ + MakeCurrent(0); + glGenTextures(1, &t); + printf("Generated texture ID %u\n", t); + assert(!glIsTexture(t)); + glBindTexture(GL_TEXTURE_2D, t); + assert(glIsTexture(t)); + glGetIntegerv(GL_TEXTURE_BINDING_2D, &tb); + assert(tb == t); + + /* Bind texture in context 1 */ + MakeCurrent(1); + assert(glIsTexture(t)); + glBindTexture(GL_TEXTURE_2D, t); + glGetIntegerv(GL_TEXTURE_BINDING_2D, &tb); + assert(tb == t); + + /* Delete texture from context 0 */ + MakeCurrent(0); + glDeleteTextures(1, &t); + assert(!glIsTexture(t)); + glGetIntegerv(GL_TEXTURE_BINDING_2D, &tb); + printf("After delete, binding = %d\n", tb); + + /* Check texture state from context 1 */ + MakeCurrent(1); + assert(!glIsTexture(t)); + glGetIntegerv(GL_TEXTURE_BINDING_2D, &tb); + printf("In second context, binding = %d\n", tb); + glBindTexture(GL_TEXTURE_2D, 0); + glGetIntegerv(GL_TEXTURE_BINDING_2D, &tb); + assert(tb == 0); + + + for (i = 0; i < NumContexts; i++) { + DestroyContext(i); + } + + printf("Success!\n"); + + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/texrect.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/texrect.c new file mode 100644 index 000000000..61c1fdd6b --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/texrect.c @@ -0,0 +1,360 @@ +/* $Id: texrect.c,v 1.5 2004/05/06 20:27:32 brianp Exp $ */ + +/* GL_NV_texture_rectangle test + * + * Brian Paul + * 14 June 2002 + */ + + +#define GL_GLEXT_PROTOTYPES +#include <math.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <GL/glut.h> +#include "readtex.h" + +#define TEXTURE_0_FILE "../images/girl.rgb" +#define TEXTURE_1_FILE "../images/reflect.rgb" + +#define TEX0 1 +#define TEX7 8 +#define ANIMATE 10 +#define CLAMP 20 +#define CLAMP_TO_EDGE 21 +#define CLAMP_TO_BORDER 22 +#define LINEAR_FILTER 30 +#define NEAREST_FILTER 31 +#define QUIT 100 + +static GLboolean Animate = GL_FALSE; +static GLint NumUnits = 2; +static GLboolean TexEnabled[8]; +static GLint Width[8], Height[8]; /* image sizes */ +static GLenum Format[8]; + +static GLfloat Xrot = 00.0, Yrot = 00.0, Zrot = 0.0; + + +static void Idle( void ) +{ + Zrot = glutGet(GLUT_ELAPSED_TIME) * 0.01; + glutPostRedisplay(); +} + + +static void DrawObject(void) +{ + GLint i; + GLfloat d = 10; /* so we can see how borders are handled */ + + glColor3f(.1, .1, .1); /* modulate this */ + + glPushMatrix(); + + glRotatef(Zrot, 0, 0, 1); + + glBegin(GL_QUADS); + + for (i = 0; i < NumUnits; i++) + glMultiTexCoord2fARB(GL_TEXTURE0_ARB + i, -d, -d); + glVertex2f(-1.0, -1.0); + + for (i = 0; i < NumUnits; i++) + glMultiTexCoord2fARB(GL_TEXTURE0_ARB + i, Width[i]+d, -d); + glVertex2f(1.0, -1.0); + + for (i = 0; i < NumUnits; i++) + glMultiTexCoord2fARB(GL_TEXTURE0_ARB + i, Width[i]+d, Height[i]+d); + glVertex2f(1.0, 1.0); + + for (i = 0; i < NumUnits; i++) + glMultiTexCoord2fARB(GL_TEXTURE0_ARB + i, -d, Height[i]+d); + glVertex2f(-1.0, 1.0); + + glEnd(); + glPopMatrix(); +} + + +static void Display( void ) +{ + glClear( GL_COLOR_BUFFER_BIT ); + + glPushMatrix(); + glRotatef(Xrot, 1.0, 0.0, 0.0); + glRotatef(Yrot, 0.0, 1.0, 0.0); + glRotatef(Zrot, 0.0, 0.0, 1.0); + glScalef(5.0, 5.0, 5.0); + DrawObject(); + glPopMatrix(); + + glutSwapBuffers(); +} + + +static void Reshape( int width, int height ) +{ + glViewport( 0, 0, width, height ); + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glFrustum( -1.0, 1.0, -1.0, 1.0, 5.0, 100.0 ); + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); + glTranslatef( 0.0, 0.0, -35.0 ); +} + + +static void ModeMenu(int entry) +{ + GLint i; + if (entry >= TEX0 && entry < TEX0 + NumUnits) { + /* toggle */ + i = entry - TEX0; + TexEnabled[i] = !TexEnabled[i]; + glActiveTextureARB(GL_TEXTURE0_ARB + i); + if (TexEnabled[i]) { + glEnable(GL_TEXTURE_RECTANGLE_NV); + } + else { + glDisable(GL_TEXTURE_RECTANGLE_NV); + } + printf("Enabled: "); + for (i = 0; i < NumUnits; i++) + printf("%d ", (int) TexEnabled[i]); + printf("\n"); + } + else if (entry==ANIMATE) { + Animate = !Animate; + if (Animate) + glutIdleFunc(Idle); + else + glutIdleFunc(NULL); + } + else if (entry==CLAMP) { + for (i = 0; i < NumUnits; i++) { + glActiveTextureARB(GL_TEXTURE0_ARB + i); + glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_S, GL_CLAMP); + glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_T, GL_CLAMP); + } + } + else if (entry==CLAMP_TO_EDGE) { + for (i = 0; i < NumUnits; i++) { + glActiveTextureARB(GL_TEXTURE0_ARB + i); + glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); + } + } + else if (entry==CLAMP_TO_BORDER) { + for (i = 0; i < NumUnits; i++) { + glActiveTextureARB(GL_TEXTURE0_ARB + i); + glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER); + glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER); + } + } + else if (entry==NEAREST_FILTER) { + for (i = 0; i < NumUnits; i++) { + glActiveTextureARB(GL_TEXTURE0_ARB + i); + glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + } + } + else if (entry==LINEAR_FILTER) { + for (i = 0; i < NumUnits; i++) { + glActiveTextureARB(GL_TEXTURE0_ARB + i); + glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + } + } + + else if (entry==QUIT) { + exit(0); + } + + glutPostRedisplay(); +} + + +static void Key( unsigned char key, int x, int y ) +{ + (void) x; + (void) y; + switch (key) { + case 'z': + Zrot -= 1.0; + break; + case 'Z': + Zrot += 1.0; + break; + case 'a': + Animate = !Animate; + if (Animate) + glutIdleFunc(Idle); + else + glutIdleFunc(NULL); + break; + case 27: + exit(0); + break; + } + glutPostRedisplay(); +} + + +static void SpecialKey( int key, int x, int y ) +{ + float step = 3.0; + (void) x; + (void) y; + + switch (key) { + case GLUT_KEY_UP: + Xrot += step; + break; + case GLUT_KEY_DOWN: + Xrot -= step; + break; + case GLUT_KEY_LEFT: + Yrot += step; + break; + case GLUT_KEY_RIGHT: + Yrot -= step; + break; + } + glutPostRedisplay(); +} + + +static void Init( int argc, char *argv[] ) +{ + const GLenum wrap = GL_CLAMP; + GLuint texObj[8]; + GLint size, i; + + if (!glutExtensionSupported("GL_ARB_multitexture")) { + printf("Sorry, GL_ARB_multitexture needed by this program\n"); + exit(1); + } + + if (!glutExtensionSupported("GL_NV_texture_rectangle")) { + printf("Sorry, GL_NV_texture_rectangle needed by this program\n"); + exit(1); + } + + glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &NumUnits); + printf("%d texture units supported, using 2.\n", NumUnits); + if (NumUnits > 2) + NumUnits = 2; + + glGetIntegerv(GL_MAX_RECTANGLE_TEXTURE_SIZE_NV, &size); + printf("%d x %d max texture rectangle size\n", size, size); + + glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + + for (i = 0; i < NumUnits; i++) { + TexEnabled[i] = GL_TRUE; + } + + /* allocate two texture objects */ + glGenTextures(NumUnits, texObj); + + /* setup the texture objects */ + for (i = 0; i < NumUnits; i++) { + + glActiveTextureARB(GL_TEXTURE0_ARB + i); + + glBindTexture(GL_TEXTURE_RECTANGLE_NV, texObj[i]); + glTexParameteri(GL_TEXTURE_RECTANGLE_NV, + GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_RECTANGLE_NV, + GL_TEXTURE_MAG_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_S, wrap); + glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_T, wrap); + + if (i == 0) { + GLubyte *img = LoadRGBImage(TEXTURE_0_FILE, &Width[0], &Height[0], + &Format[0]); + if (!img) { + printf("Error: couldn't load texture image\n"); + exit(1); + } + printf("Texture %d: %s (%d x %d)\n", i, + TEXTURE_0_FILE, Width[0], Height[0]); + glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_RGB, + Width[0], Height[0], 0, + Format[0], GL_UNSIGNED_BYTE, img); + } + else { + GLubyte *img = LoadRGBImage(TEXTURE_1_FILE, &Width[1], &Height[1], + &Format[1]); + if (!img) { + printf("Error: couldn't load texture image\n"); + exit(1); + } + printf("Texture %d: %s (%d x %d)\n", i, + TEXTURE_1_FILE, Width[1], Height[1]); + glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_RGB, + Width[1], Height[1], 0, + Format[1], GL_UNSIGNED_BYTE, img); + } + + if (i < 1) + glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_ADD); + else + glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_ADD); + + if (TexEnabled[i]) + glEnable(GL_TEXTURE_RECTANGLE_NV); + } + + glShadeModel(GL_FLAT); + glClearColor(0.3, 0.3, 0.4, 1.0); + + if (argc > 1 && strcmp(argv[1], "-info")==0) { + printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER)); + printf("GL_VERSION = %s\n", (char *) glGetString(GL_VERSION)); + printf("GL_VENDOR = %s\n", (char *) glGetString(GL_VENDOR)); + printf("GL_EXTENSIONS = %s\n", (char *) glGetString(GL_EXTENSIONS)); + } +} + + +int main( int argc, char *argv[] ) +{ + GLint i; + + glutInit( &argc, argv ); + glutInitWindowSize( 300, 300 ); + glutInitWindowPosition( 0, 0 ); + glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE ); + glutCreateWindow(argv[0] ); + + Init( argc, argv ); + + glutReshapeFunc( Reshape ); + glutKeyboardFunc( Key ); + glutSpecialFunc( SpecialKey ); + glutDisplayFunc( Display ); + if (Animate) + glutIdleFunc( Idle ); + + glutCreateMenu(ModeMenu); + + for (i = 0; i < NumUnits; i++) { + char s[100]; + sprintf(s, "Toggle Texture %d", i); + glutAddMenuEntry(s, TEX0 + i); + } + glutAddMenuEntry("Toggle Animation", ANIMATE); + glutAddMenuEntry("GL_CLAMP", CLAMP); + glutAddMenuEntry("GL_CLAMP_TO_EDGE", CLAMP_TO_EDGE); + glutAddMenuEntry("GL_CLAMP_TO_BORDER", CLAMP_TO_BORDER); + glutAddMenuEntry("GL_NEAREST", NEAREST_FILTER); + glutAddMenuEntry("GL_LINEAR", LINEAR_FILTER); + glutAddMenuEntry("Quit", QUIT); + glutAttachMenu(GLUT_RIGHT_BUTTON); + + glutMainLoop(); + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/texwrap.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/texwrap.c new file mode 100644 index 000000000..35f5050ef --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/texwrap.c @@ -0,0 +1,303 @@ +/* $Id: texwrap.c,v 1.7 2003/09/02 19:25:18 idr Exp $ */ + +/* + * Test texture wrap modes. + * Press 'b' to toggle texture image borders. You should see the same + * rendering whether or not you're using borders. + * + * Brian Paul March 2001 + */ + + +#define GL_GLEXT_PROTOTYPES +#include <stdio.h> +#include <stdlib.h> +#include <math.h> +#include <GL/glut.h> + + +#ifndef GL_CLAMP_TO_BORDER +#define GL_CLAMP_TO_BORDER 0x812D +#endif + +#ifndef GL_MIRRORED_REPEAT +#define GL_MIRRORED_REPEAT 0x8370 +#endif + +#ifndef GL_EXT_texture_mirror_clamp +#define GL_MIRROR_CLAMP_EXT 0x8742 +#define GL_MIRROR_CLAMP_TO_EDGE_EXT 0x8743 +#define GL_MIRROR_CLAMP_TO_BORDER_EXT 0x8912 +#endif + +#define BORDER_TEXTURE 1 +#define NO_BORDER_TEXTURE 2 + +#define SIZE 8 +static GLubyte BorderImage[SIZE+2][SIZE+2][4]; +static GLubyte NoBorderImage[SIZE][SIZE][4]; +static GLuint Border = 0; + + +#define WRAP_MODE(m) { m , # m, GL_TRUE, 1.0, { NULL, NULL } } +#define WRAP_EXT(m,e1,e2,v) { m , # m, GL_FALSE, v, { e1, e2 } } + +struct wrap_mode { + GLenum mode; + const char * name; + GLboolean supported; + GLfloat version; + const char * extension_names[2]; +}; + +static struct wrap_mode modes[] = { + WRAP_MODE( GL_REPEAT ), + WRAP_MODE( GL_CLAMP ), + WRAP_EXT ( GL_CLAMP_TO_EDGE, "GL_EXT_texture_edge_clamp", + "GL_SGIS_texture_edge_clamp", + 1.2 ), + WRAP_EXT ( GL_CLAMP_TO_BORDER, "GL_ARB_texture_border_clamp", + "GL_SGIS_texture_border_clamp", + 1.3 ), + WRAP_EXT ( GL_MIRRORED_REPEAT, "GL_ARB_texture_mirrored_repeat", + "GL_IBM_texture_mirrored_repeat", + 1.4 ), + WRAP_EXT ( GL_MIRROR_CLAMP_EXT, "GL_ATI_texture_mirror_once", + "GL_EXT_texture_mirror_clamp", + 999.0 ), + WRAP_EXT ( GL_MIRROR_CLAMP_TO_EDGE_EXT, "GL_ATI_texture_mirror_once", + "GL_EXT_texture_mirror_clamp", + 999.0 ), + WRAP_EXT ( GL_MIRROR_CLAMP_TO_BORDER_EXT, "GL_EXT_texture_mirror_clamp", + NULL, + 999.0 ), + { 0 } +}; + +static void +PrintString(const char *s) +{ + while (*s) { + glutBitmapCharacter(GLUT_BITMAP_8_BY_13, (int) *s); + s++; + } +} + + +static void Display( void ) +{ + GLenum i, j; + GLint offset; + GLfloat version; + + /* Fill in the extensions that are supported. + */ + + version = atof( (char *) glGetString( GL_VERSION ) ); + for ( i = 0 ; modes[i].mode != 0 ; i++ ) { + if ( ((modes[i].extension_names[0] != NULL) + && glutExtensionSupported(modes[i].extension_names[0])) + || ((modes[i].extension_names[1] != NULL) + && glutExtensionSupported(modes[i].extension_names[1])) ) { + modes[i].supported = GL_TRUE; + } + else if ( !modes[i].supported && (modes[i].version <= version) ) { + fprintf( stderr, "WARNING: OpenGL library meets minimum version\n" + " requirement for %s, but the\n" + " extension string is not advertised.\n" + " (%s%s%s)\n", + modes[i].name, + modes[i].extension_names[0], + (modes[i].extension_names[1] != NULL) + ? " or " : "", + (modes[i].extension_names[1] != NULL) + ? modes[i].extension_names[1] : "" ); + modes[i].supported = GL_TRUE; + } + } + + + glClearColor(0.5, 0.5, 0.5, 1.0); + glClear( GL_COLOR_BUFFER_BIT ); + +#if 0 + /* draw texture as image */ + glDisable(GL_TEXTURE_2D); + glWindowPos2iARB(1, 1); + glDrawPixels(6, 6, GL_RGBA, GL_UNSIGNED_BYTE, (void *) TexImage); +#endif + + glBindTexture(GL_TEXTURE_2D, Border ? BORDER_TEXTURE : NO_BORDER_TEXTURE); + + + /* loop over min/mag filters */ + for (i = 0; i < 2; i++) { + offset = 0; + + if (i) { + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + } + else { + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + } + + /* loop over border modes */ + for (j = 0; j < modes[j].mode != 0; j++) { + const GLfloat x0 = 0, y0 = 0, x1 = 140, y1 = 140; + const GLfloat b = 1.2; + const GLfloat s0 = -b, t0 = -b, s1 = 1.0+b, t1 = 1.0+b; + + if ( modes[j].supported != GL_TRUE ) + continue; + + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, modes[j].mode); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, modes[j].mode); + + glPushMatrix(); + glTranslatef(offset * 150 + 10, i * 150 + 40, 0); + offset++; + + glEnable(GL_TEXTURE_2D); + glColor3f(1, 1, 1); + glBegin(GL_POLYGON); + glTexCoord2f(s0, t0); glVertex2f(x0, y0); + glTexCoord2f(s1, t0); glVertex2f(x1, y0); + glTexCoord2f(s1, t1); glVertex2f(x1, y1); + glTexCoord2f(s0, t1); glVertex2f(x0, y1); + glEnd(); + + /* draw red outline showing bounds of texture at s=0,1 and t=0,1 */ + glDisable(GL_TEXTURE_2D); + glColor3f(1, 0, 0); + glBegin(GL_LINE_LOOP); + glVertex2f(x0 + b * (x1-x0) / (s1-s0), y0 + b * (y1-y0) / (t1-t0)); + glVertex2f(x1 - b * (x1-x0) / (s1-s0), y0 + b * (y1-y0) / (t1-t0)); + glVertex2f(x1 - b * (x1-x0) / (s1-s0), y1 - b * (y1-y0) / (t1-t0)); + glVertex2f(x0 + b * (x1-x0) / (s1-s0), y1 - b * (y1-y0) / (t1-t0)); + glEnd(); + + glPopMatrix(); + } + } + + glDisable(GL_TEXTURE_2D); + glColor3f(1, 1, 1); + offset = 0; + for (i = 0; i < modes[i].mode != 0; i++) { + if ( modes[i].supported ) { + glWindowPos2iARB( offset * 150 + 10, 5 + ((offset & 1) * 15) ); + PrintString(modes[i].name); + offset++; + } + } + + glutSwapBuffers(); +} + + +static void Reshape( int width, int height ) +{ + glViewport( 0, 0, width, height ); + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glOrtho(0, width, 0, height, -1, 1); + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); +} + + +static void Key( unsigned char key, int x, int y ) +{ + (void) x; + (void) y; + switch (key) { + case 'b': + Border = !Border; + printf("Texture Border Size = %d\n", Border); + break; + case 27: + exit(0); + break; + } + glutPostRedisplay(); +} + + +static void Init( void ) +{ + static const GLubyte border[4] = { 0, 255, 0, 255 }; + static const GLfloat borderf[4] = { 0, 1.0, 0, 1.0 }; + GLint i, j; + + for (i = 0; i < SIZE+2; i++) { + for (j = 0; j < SIZE+2; j++) { + if (i == 0 || j == 0 || i == SIZE+1 || j == SIZE+1) { + /* border color */ + BorderImage[i][j][0] = border[0]; + BorderImage[i][j][1] = border[1]; + BorderImage[i][j][2] = border[2]; + BorderImage[i][j][3] = border[3]; + } + else if ((i + j) & 1) { + /* white */ + BorderImage[i][j][0] = 255; + BorderImage[i][j][1] = 255; + BorderImage[i][j][2] = 255; + BorderImage[i][j][3] = 255; + } + else { + /* black */ + BorderImage[i][j][0] = 0; + BorderImage[i][j][1] = 0; + BorderImage[i][j][2] = 0; + BorderImage[i][j][3] = 0; + } + } + } + + glBindTexture(GL_TEXTURE_2D, BORDER_TEXTURE); + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, SIZE+2, SIZE+2, 1, + GL_RGBA, GL_UNSIGNED_BYTE, (void *) BorderImage); + + for (i = 0; i < SIZE; i++) { + for (j = 0; j < SIZE; j++) { + if ((i + j) & 1) { + /* white */ + NoBorderImage[i][j][0] = 255; + NoBorderImage[i][j][1] = 255; + NoBorderImage[i][j][2] = 255; + NoBorderImage[i][j][3] = 255; + } + else { + /* black */ + NoBorderImage[i][j][0] = 0; + NoBorderImage[i][j][1] = 0; + NoBorderImage[i][j][2] = 0; + NoBorderImage[i][j][3] = 0; + } + } + } + + glBindTexture(GL_TEXTURE_2D, NO_BORDER_TEXTURE); + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, SIZE, SIZE, 0, + GL_RGBA, GL_UNSIGNED_BYTE, (void *) NoBorderImage); + glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, borderf); +} + + +int main( int argc, char *argv[] ) +{ + glutInit( &argc, argv ); + glutInitWindowPosition( 0, 0 ); + glutInitWindowSize( 800, 355 ); + glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE ); + glutCreateWindow(argv[0]); + glutReshapeFunc( Reshape ); + glutKeyboardFunc( Key ); + glutDisplayFunc( Display ); + Init(); + glutMainLoop(); + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/vparray.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/vparray.c new file mode 100644 index 000000000..580a670f8 --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/vparray.c @@ -0,0 +1,294 @@ +/* + * Test vertex arrays with GL_NV_vertex_program + * + * Based on a stripped-down version of the isosurf demo. + * The vertex program is trivial: compute the resulting + * RGB color as a linear function of vertex XYZ. + */ + +#include <assert.h> +#include <stdio.h> +#include <string.h> +#include <stdlib.h> +#include <string.h> +#include <math.h> +#define GL_GLEXT_PROTOTYPES +#include "GL/glut.h" + +#define MAXVERTS 10000 +static float data[MAXVERTS][6]; +static GLint numverts; + +static GLfloat xrot; +static GLfloat yrot; +static GLboolean useArrays = GL_TRUE; +static GLboolean useProgram = GL_TRUE; +static GLboolean useList = GL_FALSE; + + +static void read_surface( char *filename ) +{ + FILE *f; + + f = fopen(filename,"r"); + if (!f) { + printf("couldn't read %s\n", filename); + exit(1); + } + + numverts = 0; + while (!feof(f) && numverts < MAXVERTS) { + fscanf( f, "%f %f %f %f %f %f", + &data[numverts][0], &data[numverts][1], &data[numverts][2], + &data[numverts][3], &data[numverts][4], &data[numverts][5] ); + numverts++; + } + numverts--; + + printf("%d vertices, %d triangles\n", numverts, numverts-2); + printf("data = %p\n", (void *) data); + fclose(f); +} + + + + +static void Display(void) +{ + if (useProgram) + glEnable(GL_VERTEX_PROGRAM_NV); + else + glDisable(GL_VERTEX_PROGRAM_NV); + + glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); + + glPushMatrix(); + glRotatef(xrot, 1, 0, 0); + glRotatef(yrot, 0, 1, 0); + glScalef(2, 2, 2); + if (useArrays) { + if (useProgram) { + glVertexAttribPointerNV( 0, 3, GL_FLOAT, 6 * sizeof(GLfloat), data ); + glEnableClientState( GL_VERTEX_ATTRIB_ARRAY0_NV ); + glVertexAttribPointerNV( 2, 3, GL_FLOAT, 6 * sizeof(GLfloat), ((GLfloat *) data) + 3); + glEnableClientState( GL_VERTEX_ATTRIB_ARRAY2_NV); + } + else { + glVertexPointer( 3, GL_FLOAT, 6 * sizeof(GLfloat), data ); + glEnableClientState( GL_VERTEX_ARRAY ); + glNormalPointer( GL_FLOAT, 6 * sizeof(GLfloat), ((GLfloat *) data) + 3); + glEnableClientState( GL_NORMAL_ARRAY ); + } + + if (useList) { + /* dumb, but a good test */ + glNewList(1,GL_COMPILE); + glDrawArrays(GL_TRIANGLE_STRIP, 0, numverts); + glEndList(); + glCallList(1); + } + else { + glDrawArrays(GL_TRIANGLE_STRIP, 0, numverts); + } + + glDisableClientState( GL_VERTEX_ATTRIB_ARRAY0_NV ); + glDisableClientState( GL_VERTEX_ATTRIB_ARRAY2_NV); + glDisableClientState( GL_VERTEX_ARRAY ); + glDisableClientState( GL_NORMAL_ARRAY ); + } + else { + int i; + glBegin(GL_TRIANGLE_STRIP); + for (i = 0; i < numverts; i++) { + glNormal3fv( data[i] + 3 ); + glVertex3fv( data[i] + 0 ); + } + glEnd(); + } + glPopMatrix(); + + if (glGetError()) + printf("Error!\n"); + + glutSwapBuffers(); +} + + +static void InitMaterials(void) +{ + static float ambient[] = {0.1, 0.1, 0.1, 1.0}; + static float diffuse[] = {0.5, 1.0, 1.0, 1.0}; + static float position0[] = {0.0, 0.0, 20.0, 0.0}; + static float position1[] = {0.0, 0.0, -20.0, 0.0}; + static float front_mat_shininess[] = {60.0}; + static float front_mat_specular[] = {0.2, 0.2, 0.2, 1.0}; + static float front_mat_diffuse[] = {0.5, 0.28, 0.38, 1.0}; + /* + static float back_mat_shininess[] = {60.0}; + static float back_mat_specular[] = {0.5, 0.5, 0.2, 1.0}; + static float back_mat_diffuse[] = {1.0, 1.0, 0.2, 1.0}; + */ + static float lmodel_ambient[] = {1.0, 1.0, 1.0, 1.0}; + static float lmodel_twoside[] = {GL_FALSE}; + + glLightfv(GL_LIGHT0, GL_AMBIENT, ambient); + glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse); + glLightfv(GL_LIGHT0, GL_POSITION, position0); + glEnable(GL_LIGHT0); + + glLightfv(GL_LIGHT1, GL_AMBIENT, ambient); + glLightfv(GL_LIGHT1, GL_DIFFUSE, diffuse); + glLightfv(GL_LIGHT1, GL_POSITION, position1); + glEnable(GL_LIGHT1); + + glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient); + glLightModelfv(GL_LIGHT_MODEL_TWO_SIDE, lmodel_twoside); + + glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, front_mat_shininess); + glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, front_mat_specular); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, front_mat_diffuse); + glEnable(GL_LIGHTING); +} + + +static void init_program(void) +{ + /* + * c[0..3] = modelview matrix + * c[4..7] = inverse modelview matrix + * c[30] = color scale + * c[31] = color bias + */ + static const char prog[] = + "!!VP1.0\n" + + "# RGB is proportional to XYZ \n" + + "MUL R0, v[OPOS], c[30]; \n" + "ADD o[COL0], R0, c[31]; \n" + + "# Continue with typical modelview/projection\n" + "MOV R3, v[OPOS]; \n" + "DP4 o[HPOS].x, c[0], R3 ; # object x MVP -> clip\n" + "DP4 o[HPOS].y, c[1], R3 ;\n" + "DP4 o[HPOS].z, c[2], R3 ;\n" + "DP4 o[HPOS].w, c[3], R3 ;\n" + + "END"; + + static const GLfloat scale[4] = {2.0, 2.0, 2.0, 0.0}; + static const GLfloat bias[4] = {1.0, 1.0, 1.0, 0.0}; + + if (!glutExtensionSupported("GL_NV_vertex_program")) { + printf("Sorry, this program requires GL_NV_vertex_program"); + exit(1); + } + + glLoadProgramNV(GL_VERTEX_PROGRAM_NV, 1, + strlen(prog), (const GLubyte *) prog); + assert(glIsProgramNV(1)); + glBindProgramNV(GL_VERTEX_PROGRAM_NV, 1); + + /* Load the program registers */ + glTrackMatrixNV(GL_VERTEX_PROGRAM_NV, 0, GL_MODELVIEW_PROJECTION_NV, GL_IDENTITY_NV); + glTrackMatrixNV(GL_VERTEX_PROGRAM_NV, 4, GL_MODELVIEW, GL_INVERSE_TRANSPOSE_NV); + + glProgramParameter4fvNV(GL_VERTEX_PROGRAM_NV, 30, scale); + glProgramParameter4fvNV(GL_VERTEX_PROGRAM_NV, 31, bias); +} + + +static void init(void) +{ + xrot = 0; + yrot = 0; + glClearColor(0.0, 0.0, 1.0, 0.0); + glEnable( GL_DEPTH_TEST ); + glEnable(GL_NORMALIZE); + InitMaterials(); + read_surface( "../demos/isosurf.dat" ); + init_program(); +} + + +static void Reshape(int width, int height) +{ + glViewport(0, 0, (GLint)width, (GLint)height); + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + glFrustum( -1.0, 1.0, -1.0, 1.0, 5, 25 ); + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + glTranslatef(0, 0, -15); +} + + + +static void Key( unsigned char key, int x, int y ) +{ + (void) x; + (void) y; + switch (key) { + case 27: + exit(0); + case 'a': + useArrays = !useArrays; + printf("use arrays: %s\n", useArrays ? "yes" : "no"); + break; + case 'l': + useList = !useList; + printf("use list: %s\n", useList ? "yes" : "no"); + break; + case 'p': + useProgram = !useProgram; + printf("use program: %s\n", useProgram ? "yes" : "no"); + break; + } + glutPostRedisplay(); +} + + +static void SpecialKey( int key, int x, int y ) +{ + (void) x; + (void) y; + switch (key) { + case GLUT_KEY_LEFT: + yrot -= 15.0; + break; + case GLUT_KEY_RIGHT: + yrot += 15.0; + break; + case GLUT_KEY_UP: + xrot += 15.0; + break; + case GLUT_KEY_DOWN: + xrot -= 15.0; + break; + default: + return; + } + glutPostRedisplay(); +} + + + +int main(int argc, char **argv) +{ + glutInit(&argc, argv); + glutInitDisplayMode( GLUT_DEPTH | GLUT_RGB | GLUT_DOUBLE ); + glutInitWindowPosition(0, 0); + glutInitWindowSize(400, 400); + if (glutCreateWindow("Isosurface") <= 0) { + exit(0); + } + glutReshapeFunc(Reshape); + glutKeyboardFunc(Key); + glutSpecialFunc(SpecialKey); + glutDisplayFunc(Display); + + init(); + + glutMainLoop(); + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/vpeval.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/vpeval.c new file mode 100644 index 000000000..8b6996d3b --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/vpeval.c @@ -0,0 +1,231 @@ +/* + * Vertex program evaluators test. + * Based on book/bezmesh.c + * + * Brian Paul + * 22 June 2002 + */ + +#include <assert.h> +#include <stdlib.h> +#include <stdio.h> +#include <string.h> +#define GL_GLEXT_PROTOTYPES +#include <GL/glut.h> + + +/* + * Transform position by modelview/projection. + * Square incoming color. + */ +static const char prog[] = +"!!VP1.0\n" + +"# Typical modelview/projection\n" +"DP4 o[HPOS].x, c[0], v[OPOS] ; # object x MVP -> clip\n" +"DP4 o[HPOS].y, c[1], v[OPOS] ;\n" +"DP4 o[HPOS].z, c[2], v[OPOS] ;\n" +"DP4 o[HPOS].w, c[3], v[OPOS] ;\n" + +"MOV R0, v[COL0];\n # square the color\n" +"MUL R0, R0, R0;\n" +"MOV o[COL0], R0;\n # store output color\n" + +"END"; + + +static int program = 1; + + +GLfloat ctrlpoints[4][4][4] = +{ + { + {-1.5, -1.5, 4.0, 1.0}, + {-0.5, -1.5, 2.0, 1.0}, + {0.5, -1.5, -1.0, 1.0}, + {1.5, -1.5, 2.0, 1.0}}, + { + {-1.5, -0.5, 1.0, 1.0}, + {-0.5, -0.5, 3.0, 1.0}, + {0.5, -0.5, 0.0, 1.0}, + {1.5, -0.5, -1.0, 1.0}}, + { + {-1.5, 0.5, 4.0, 1.0}, + {-0.5, 0.5, 0.0, 1.0}, + {0.5, 0.5, 3.0, 1.0}, + {1.5, 0.5, 4.0, 1.0}}, + { + {-1.5, 1.5, -2.0, 1.0}, + {-0.5, 1.5, -2.0, 1.0}, + {0.5, 1.5, 0.0, 1.0}, + {1.5, 1.5, -1.0, 1.0}} +}; + +/* + * +-------------+ + * |green |yellow + * | | + * | | + * |black |red + * +-------------+ + */ +GLfloat colorPoints[4][4][4] = +{ + { + {0.0, 0.0, 0.0, 1.0}, + {0.3, 0.0, 0.0, 1.0}, + {0.6, 0.0, 0.0, 1.0}, + {1.0, 0.0, 0.0, 1.0}}, + { + {0.0, 0.3, 0.0, 1.0}, + {0.3, 0.3, 0.0, 1.0}, + {0.6, 0.3, 0.0, 1.0}, + {1.0, 0.3, 0.0, 1.0}}, + { + {0.0, 0.6, 0.0, 1.0}, + {0.3, 0.6, 0.0, 1.0}, + {0.6, 0.6, 0.0, 1.0}, + {1.0, 0.6, 0.0, 1.0}}, + { + {0.0, 1.0, 0.0, 1.0}, + {0.3, 1.0, 0.0, 1.0}, + {0.6, 1.0, 0.0, 1.0}, + {1.0, 1.0, 0.0, 1.0}} +}; + + +void +initlights(void) +{ + GLfloat ambient[] = {0.2, 0.2, 0.2, 1.0}; + GLfloat position[] = {0.0, 0.0, 2.0, 1.0}; + GLfloat mat_diffuse[] = {0.6, 0.6, 0.6, 1.0}; + GLfloat mat_specular[] = {1.0, 1.0, 1.0, 1.0}; + GLfloat mat_shininess[] = {50.0}; + +#if 0 /* no lighting for now */ + glEnable(GL_LIGHTING); + glEnable(GL_LIGHT0); + + glLightfv(GL_LIGHT0, GL_AMBIENT, ambient); + glLightfv(GL_LIGHT0, GL_POSITION, position); + + glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse); + glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular); + glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess); +#endif +} + +void +display(void) +{ + glClearColor(.3, .3, .3, 0); + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + glPushMatrix(); +#if 1 + glRotatef(85.0, 1.0, 1.0, 1.0); +#endif + glEvalMesh2(GL_FILL, 0, 8, 0, 8); + glPopMatrix(); + glFlush(); +} + +void +myinit(int argc, char *argv[]) +{ + glClearColor(0.0, 0.0, 0.0, 1.0); + glEnable(GL_DEPTH_TEST); + + initlights(); /* for lighted version only */ + + glMapGrid2f(8, 0.0, 1.0, 8, 0.0, 1.0); + + if (argc > 1) + program = 0; + + printf("Using vertex program attribs? %s\n", program ? "yes" : "no"); + + if (!program) { + glMap2f(GL_MAP2_VERTEX_4, + 0.0, 1.0, 4, 4, + 0.0, 1.0, 16, 4, &ctrlpoints[0][0][0]); + glMap2f(GL_MAP2_COLOR_4, + 0.0, 1.0, 4, 4, + 0.0, 1.0, 16, 4, &colorPoints[0][0][0]); + glEnable(GL_MAP2_VERTEX_4); + glEnable(GL_MAP2_COLOR_4); + /* + glEnable(GL_AUTO_NORMAL); + glEnable(GL_NORMALIZE); + */ + } + else { + glMap2f(GL_MAP2_VERTEX_ATTRIB0_4_NV, + 0.0, 1.0, 4, 4, + 0.0, 1.0, 16, 4, &ctrlpoints[0][0][0]); + glMap2f(GL_MAP2_VERTEX_ATTRIB3_4_NV, + 0.0, 1.0, 4, 4, + 0.0, 1.0, 16, 4, &colorPoints[0][0][0]); + glEnable(GL_MAP2_VERTEX_ATTRIB0_4_NV); + glEnable(GL_MAP2_VERTEX_ATTRIB3_4_NV); + + /* + glEnable(GL_AUTO_NORMAL); + glEnable(GL_NORMALIZE); + */ + + /* vertex program init */ + glLoadProgramNV(GL_VERTEX_PROGRAM_NV, 1, + strlen(prog), (const GLubyte *) prog); + assert(glIsProgramNV(1)); + glBindProgramNV(GL_VERTEX_PROGRAM_NV, 1); + + /* track matrices */ + glTrackMatrixNV(GL_VERTEX_PROGRAM_NV, 0, GL_MODELVIEW_PROJECTION_NV, GL_IDENTITY_NV); + glEnable(GL_VERTEX_PROGRAM_NV); + } +} + +void +myReshape(int w, int h) +{ + glViewport(0, 0, w, h); + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + if (w <= h) + glOrtho(-4.0, 4.0, -4.0 * (GLfloat) h / (GLfloat) w, + 4.0 * (GLfloat) h / (GLfloat) w, -4.0, 4.0); + else + glOrtho(-4.0 * (GLfloat) w / (GLfloat) h, + 4.0 * (GLfloat) w / (GLfloat) h, -4.0, 4.0, -4.0, 4.0); + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); +} + +static void +key(unsigned char k, int x, int y) +{ + switch (k) { + case 27: /* Escape */ + exit(0); + break; + default: + return; + } + glutPostRedisplay(); +} + +int +main(int argc, char **argv) +{ + glutInit(&argc, argv); + glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH); + glutInitWindowPosition(0, 0); + glutCreateWindow(argv[0]); + myinit(argc, argv); + glutReshapeFunc(myReshape); + glutDisplayFunc(display); + glutKeyboardFunc(key); + glutMainLoop(); + return 0; /* ANSI C requires main to return int. */ +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/vptest1.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/vptest1.c new file mode 100644 index 000000000..560df2c3f --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/vptest1.c @@ -0,0 +1,170 @@ +/* Test glGenProgramsNV(), glIsProgramNV(), glLoadProgramNV() */ + +#include <assert.h> +#include <string.h> +#include <stdio.h> +#include <stdlib.h> +#include <math.h> +#define GL_GLEXT_PROTOTYPES +#include <GL/glut.h> + + + +static void Display( void ) +{ + glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); + + glPushMatrix(); + + glBegin(GL_POLYGON); + glVertexAttrib2fNV(0, -1, -1); + glVertexAttrib2fNV(0, 1, -1); + glVertexAttrib2fNV(0, 0, 1); + glEnd(); + + glPopMatrix(); + + glutSwapBuffers(); +} + + +static void Reshape( int width, int height ) +{ + glViewport( 0, 0, width, height ); + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glFrustum( -1.0, 1.0, -1.0, 1.0, 5.0, 25.0 ); + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); + glTranslatef( 0.0, 0.0, -15.0 ); +} + + +static void Key( unsigned char key, int x, int y ) +{ + (void) x; + (void) y; + switch (key) { + case 27: + exit(0); + break; + } + glutPostRedisplay(); +} + + +static void Init( void ) +{ + static const char *prog1 = + "!!VP1.0\n" + "MUL o[COL0].xyz, R0, c[35]; \n" + "END\n"; + static const char *prog2 = + "!!VP1.0\n" + "#\n" + "# c[0-3] = modelview projection (composite) matrix\n" + "# c[32] = normalized light direction in object-space\n" + "# c[35] = yellow diffuse material, (1.0, 1.0, 0.0, 1.0)\n" + "# c[64].x = 0.0\n" + "# c[64].z = 0.125, a scaling factor\n" + "#\n" + "# outputs diffuse illumination for color and perturbed position\n" + "#\n" + "DP3 R0, c[32], v[NRML]; # light direction DOT normal\n" + "MUL o[COL0].xyz, R0, c[35]; \n" + "MAX R0, c[64].x, R0; \n" + "MUL R0, R0, v[NRML]; \n" + "MUL R0, R0, c[64].z; \n" + "ADD R1, v[OPOS], -R0; # perturb object space position\n" + "DP4 o[HPOS].x, c[0], R1; \n" + "DP4 o[HPOS].y, c[1], R1; \n" + "DP4 o[HPOS].z, c[2], R1; \n" + "DP4 o[HPOS].w, c[3], R1; \n" + "END\n"; + static const char *prog3 = + "!!VP1.0\n" + "DP4 o[HPOS].x, c[0], v[OPOS];\n" + "DP4 o[HPOS].y, c[1], v[OPOS];\n" + "DP4 o[HPOS].z, c[2], v[OPOS];\n" + "DP4 o[HPOS].w, c[3], v[OPOS];\n" + "DP3 R0.x, c[4], v[NRML];\n" + "DP3 R0.y, c[5], v[NRML]; \n" + "DP3 R0.z, c[6], v[NRML]; # R0 = n' = transformed normal\n" + "DP3 R1.x, c[32], R0; # R1.x = Lpos DOT n'\n" + "DP3 R1.y, c[33], R0; # R1.y = hHat DOT n'\n" + "MOV R1.w, c[38].x; # R1.w = specular power\n" + "LIT R2, R1; # Compute lighting values\n" + "MAD R3, c[35].x, R2.y, c[35].y; # diffuse + emissive\n" + "MAD o[COL0].xyz, c[36], R2.z, R3; # + specular\n" + "END\n"; + static const char *prog4 = + "!!VP1.0\n" + "DP4 R2, R3, c[A0.x];\n" + "DP4 R2, R3, c[A0.x + 5];\n" + "DP4 o[HPOS], R3, c[A0.x - 4];\n" + "END\n"; + static const char *prog5 = + "!!VSP1.0\n" + "DP4 R2, R3, c[A0.x];\n" + "DP4 R2, R3, v[0];\n" + "DP4 c[3], R3, R2;\n" + "END\n"; + + + GLuint progs[5]; + + glGenProgramsNV(2, progs); + assert(progs[0]); + assert(progs[1]); + assert(progs[0] != progs[1]); + + glGenProgramsNV(3, progs + 2); + assert(progs[2]); + assert(progs[3]); + assert(progs[2] != progs[3]); + assert(progs[0] != progs[2]); + + + glLoadProgramNV(GL_VERTEX_PROGRAM_NV, 1, + strlen(prog1), + (const GLubyte *) prog1); + assert(!glIsProgramNV(1)); + + glLoadProgramNV(GL_VERTEX_PROGRAM_NV, 2, + strlen(prog2), + (const GLubyte *) prog2); + assert(glIsProgramNV(2)); + + glLoadProgramNV(GL_VERTEX_PROGRAM_NV, 3, + strlen(prog3), + (const GLubyte *) prog3); + assert(glIsProgramNV(3)); + + glLoadProgramNV(GL_VERTEX_PROGRAM_NV, 4, + strlen(prog4), + (const GLubyte *) prog4); + assert(glIsProgramNV(4)); + + glLoadProgramNV(GL_VERTEX_STATE_PROGRAM_NV, 5, + strlen(prog5), + (const GLubyte *) prog5); + assert(glIsProgramNV(5)); + + printf("glGetError = %d\n", (int) glGetError()); +} + + +int main( int argc, char *argv[] ) +{ + glutInit( &argc, argv ); + glutInitWindowPosition( 0, 0 ); + glutInitWindowSize( 250, 250 ); + glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH ); + glutCreateWindow(argv[0]); + glutReshapeFunc( Reshape ); + glutKeyboardFunc( Key ); + glutDisplayFunc( Display ); + Init(); + glutMainLoop(); + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/vptest2.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/vptest2.c new file mode 100644 index 000000000..2158e07f0 --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/vptest2.c @@ -0,0 +1,151 @@ +/* Test vertex state program execution */ + +#include <assert.h> +#include <string.h> +#include <stdio.h> +#include <stdlib.h> +#include <math.h> +#define GL_GLEXT_PROTOTYPES +#include <GL/glut.h> + + + +static void Display( void ) +{ + glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); + glPushMatrix(); + glutSolidCube(2.0); + glPopMatrix(); + glutSwapBuffers(); +} + + +static void Reshape( int width, int height ) +{ + glViewport( 0, 0, width, height ); + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glFrustum( -1.0, 1.0, -1.0, 1.0, 5.0, 25.0 ); + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); + glTranslatef( 0.0, 0.0, -15.0 ); +} + + +static void Key( unsigned char key, int x, int y ) +{ + (void) x; + (void) y; + switch (key) { + case 27: + exit(0); + break; + } + glutPostRedisplay(); +} + + +static void Test1( void ) +{ + static const GLfloat p[4] = {9, 8, 7, 6}; + GLfloat q[4]; + /* test addition */ + static const char *prog = + "!!VSP1.0\n" + "MOV R0, c[0];\n" + "MOV R1, c[1];\n" + "ADD c[2], R0, R1;\n" + "END\n"; + + glLoadProgramNV(GL_VERTEX_STATE_PROGRAM_NV, 1, + strlen(prog), + (const GLubyte *) prog); + assert(glIsProgramNV(1)); + + glProgramParameter4fNV(GL_VERTEX_PROGRAM_NV, 0, 1, 2, 3, 4); + glProgramParameter4fNV(GL_VERTEX_PROGRAM_NV, 1, 10, 20, 30, 40); + + glExecuteProgramNV(GL_VERTEX_STATE_PROGRAM_NV, 1, p); + + glGetProgramParameterfvNV(GL_VERTEX_PROGRAM_NV, 2, GL_PROGRAM_PARAMETER_NV, q); + printf("Result c[2] = %g %g %g %g (should be 11 22 33 44)\n", + q[0], q[1], q[2], q[3]); +} + + +static void Test2( void ) +{ + static const GLfloat p[4] = {9, 8, 7, 6}; + GLfloat q[4]; + /* test swizzling */ + static const char *prog = + "!!VSP1.0\n" + "MOV R0, c[0].wzyx;\n" + "MOV R1, c[1].wzyx;\n" + "ADD c[2], R0, R1;\n" + "END\n"; + + glLoadProgramNV(GL_VERTEX_STATE_PROGRAM_NV, 1, + strlen(prog), + (const GLubyte *) prog); + assert(glIsProgramNV(1)); + + glProgramParameter4fNV(GL_VERTEX_PROGRAM_NV, 0, 1, 2, 3, 4); + glProgramParameter4fNV(GL_VERTEX_PROGRAM_NV, 1, 10, 20, 30, 40); + + glExecuteProgramNV(GL_VERTEX_STATE_PROGRAM_NV, 1, p); + + glGetProgramParameterfvNV(GL_VERTEX_PROGRAM_NV, 2, GL_PROGRAM_PARAMETER_NV, q); + printf("Result c[2] = %g %g %g %g (should be 44 33 22 11)\n", + q[0], q[1], q[2], q[3]); +} + + +static void Test3( void ) +{ + static const GLfloat p[4] = {0, 0, 0, 0}; + GLfloat q[4]; + /* normalize vector */ + static const char *prog = + "!!VSP1.0\n" + "# c[0] = (nx,ny,nz)\n" + "# R0.xyz = normalize(R1)\n" + "# R0.w = 1/sqrt(nx*nx + ny*ny + nz*nz)\n" + "# c[2] = R0\n" + "DP3 R0.w, c[0], c[0];\n" + "RSQ R0.w, R0.w;\n" + "MUL R0.xyz, c[0], R0.w;\n" + "MOV c[2], R0;\n" + "END\n"; + + glLoadProgramNV(GL_VERTEX_STATE_PROGRAM_NV, 1, + strlen(prog), + (const GLubyte *) prog); + assert(glIsProgramNV(1)); + + glProgramParameter4fNV(GL_VERTEX_PROGRAM_NV, 0, 0, 10, 0, 0); + + glExecuteProgramNV(GL_VERTEX_STATE_PROGRAM_NV, 1, p); + + glGetProgramParameterfvNV(GL_VERTEX_PROGRAM_NV, 2, GL_PROGRAM_PARAMETER_NV, q); + printf("Result c[2] = %g %g %g %g (should be 0, 1, 0, 0.1)\n", + q[0], q[1], q[2], q[3]); +} + + +int main( int argc, char *argv[] ) +{ + glutInit( &argc, argv ); + glutInitWindowPosition( 0, 0 ); + glutInitWindowSize( 50, 50 ); + glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH ); + glutCreateWindow(argv[0]); + glutReshapeFunc( Reshape ); + glutKeyboardFunc( Key ); + glutDisplayFunc( Display ); + Test1(); + Test2(); + Test3(); + glutMainLoop(); + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/vptest3.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/vptest3.c new file mode 100644 index 000000000..2c5c80004 --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/vptest3.c @@ -0,0 +1,120 @@ +/* Test glGenProgramsNV(), glIsProgramNV(), glLoadProgramNV() */ + +#include <assert.h> +#include <string.h> +#include <stdio.h> +#include <stdlib.h> +#include <math.h> +#define GL_GLEXT_PROTOTYPES +#include <GL/glut.h> + +static float Zrot = 0.0; + + +static void Display( void ) +{ + glClearColor(0.3, 0.3, 0.3, 1); + glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); + + glEnable(GL_VERTEX_PROGRAM_NV); + + glLoadIdentity(); + glRotatef(Zrot, 0, 0, 1); + + glTrackMatrixNV(GL_VERTEX_PROGRAM_NV, 0, GL_MODELVIEW, GL_IDENTITY_NV); + glPushMatrix(); + + glVertexAttrib3fNV(3, 1, 0.5, 0.25); + glBegin(GL_TRIANGLES); +#if 1 + glVertexAttrib3fNV(3, 1.0, 0.0, 0.0); + glVertexAttrib2fNV(0, -0.5, -0.5); + glVertexAttrib3fNV(3, 0.0, 1.0, 0.0); + glVertexAttrib2fNV(0, 0.5, -0.5); + glVertexAttrib3fNV(3, 0.0, 0.0, 1.0); + glVertexAttrib2fNV(0, 0, 0.5); +#else + glVertex2f( -1, -1); + glVertex2f( 1, -1); + glVertex2f( 0, 1); +#endif + glEnd(); + + glPopMatrix(); + + glutSwapBuffers(); +} + + +static void Reshape( int width, int height ) +{ + glViewport( 0, 0, width, height ); + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + /* glFrustum( -2.0, 2.0, -2.0, 2.0, 5.0, 25.0 );*/ + glOrtho(-2.0, 2.0, -2.0, 2.0, -2.0, 2.0 ); + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); + /*glTranslatef( 0.0, 0.0, -15.0 );*/ +} + + +static void Key( unsigned char key, int x, int y ) +{ + (void) x; + (void) y; + switch (key) { + case 'z': + Zrot -= 5.0; + break; + case 'Z': + Zrot += 5.0; + break; + case 27: + exit(0); + break; + } + glutPostRedisplay(); +} + + +static void Init( void ) +{ + static const char *prog1 = + "!!VP1.0\n" + "MOV o[COL0], v[COL0];\n" +#if 0 + "MOV o[HPOS], v[OPOS];\n" +#else + "DP4 o[HPOS].x, v[OPOS], c[0];\n" + "DP4 o[HPOS].y, v[OPOS], c[1];\n" + "DP4 o[HPOS].z, v[OPOS], c[2];\n" + "DP4 o[HPOS].w, v[OPOS], c[3];\n" +#endif + "END\n"; + + glLoadProgramNV(GL_VERTEX_PROGRAM_NV, 1, + strlen(prog1), + (const GLubyte *) prog1); + assert(glIsProgramNV(1)); + + glBindProgramNV(GL_VERTEX_PROGRAM_NV, 1); + + printf("glGetError = %d\n", (int) glGetError()); +} + + +int main( int argc, char *argv[] ) +{ + glutInit( &argc, argv ); + glutInitWindowPosition( 0, 0 ); + glutInitWindowSize( 250, 250 ); + glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH ); + glutCreateWindow(argv[0]); + glutReshapeFunc( Reshape ); + glutKeyboardFunc( Key ); + glutDisplayFunc( Display ); + Init(); + glutMainLoop(); + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/vptorus.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/vptorus.c new file mode 100644 index 000000000..764dea4ec --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/vptorus.c @@ -0,0 +1,174 @@ +/* + * A lit, rotating torus via vertex program + */ + +#include <assert.h> +#include <string.h> +#include <stdio.h> +#include <stdlib.h> +#include <math.h> +#define GL_GLEXT_PROTOTYPES +#include <GL/glut.h> + +static float Xrot = 0.0, Yrot = 0.0, Zrot = 0.0; +static GLboolean Anim = GL_TRUE; + + +static void Idle( void ) +{ + Xrot += .3; + Yrot += .4; + Zrot += .2; + glutPostRedisplay(); +} + + +static void Display( void ) +{ + glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); + + glPushMatrix(); + glRotatef(Xrot, 1, 0, 0); + glRotatef(Yrot, 0, 1, 0); + glRotatef(Zrot, 0, 0, 1); + glutSolidTorus(0.75, 2.0, 10, 20); + glPopMatrix(); + + glutSwapBuffers(); +} + + +static void Reshape( int width, int height ) +{ + glViewport( 0, 0, width, height ); + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glFrustum( -2.0, 2.0, -2.0, 2.0, 5.0, 25.0 ); + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); + glTranslatef( 0.0, 0.0, -12.0 ); +} + + +static void Key( unsigned char key, int x, int y ) +{ + (void) x; + (void) y; + switch (key) { + case ' ': + Xrot = Yrot = Zrot = 0; + break; + case 'a': + Anim = !Anim; + if (Anim) + glutIdleFunc(Idle); + else + glutIdleFunc(NULL); + break; + case 'z': + Zrot -= 5.0; + break; + case 'Z': + Zrot += 5.0; + break; + case 27: + exit(0); + break; + } + glutPostRedisplay(); +} + + +static void SpecialKey( int key, int x, int y ) +{ + const GLfloat step = 3.0; + (void) x; + (void) y; + switch (key) { + case GLUT_KEY_UP: + Xrot -= step; + break; + case GLUT_KEY_DOWN: + Xrot += step; + break; + case GLUT_KEY_LEFT: + Yrot -= step; + break; + case GLUT_KEY_RIGHT: + Yrot += step; + break; + } + glutPostRedisplay(); +} + + +static void Init( void ) +{ + /* borrowed from an nvidia demo: + * c[0..3] = modelview matrix + * c[4..7] = inverse modelview matrix + * c[32] = light pos + * c[35] = diffuse color + */ + static const char prog[] = + "!!VP1.0\n" + "#Simple transform and diffuse lighting\n" + "\n" + "DP4 o[HPOS].x, c[0], v[OPOS] ; # object x MVP -> clip\n" + "DP4 o[HPOS].y, c[1], v[OPOS] ;\n" + "DP4 o[HPOS].z, c[2], v[OPOS] ;\n" + "DP4 o[HPOS].w, c[3], v[OPOS] ;\n" + + "DP3 R1.x, c[4], v[NRML] ; # normal x MV-1T -> lighting normal\n" + "DP3 R1.y, c[5], v[NRML] ;\n" + "DP3 R1.z, c[6], v[NRML] ;\n" + + "DP3 R0, c[32], R1 ; # L.N\n" + "MUL o[COL0].xyz, R0, c[35] ; # col = L.N * diffuse\n" + "MOV o[TEX0], v[TEX0];\n" + "END"; + + if (!glutExtensionSupported("GL_NV_vertex_program")) { + printf("Sorry, this program requires GL_NV_vertex_program"); + exit(1); + } + + glLoadProgramNV(GL_VERTEX_PROGRAM_NV, 1, + strlen(prog), (const GLubyte *) prog); + assert(glIsProgramNV(1)); + glBindProgramNV(GL_VERTEX_PROGRAM_NV, 1); + + /* Load the program registers */ + glTrackMatrixNV(GL_VERTEX_PROGRAM_NV, 0, GL_MODELVIEW_PROJECTION_NV, GL_IDENTITY_NV); + glTrackMatrixNV(GL_VERTEX_PROGRAM_NV, 4, GL_MODELVIEW, GL_INVERSE_TRANSPOSE_NV); + + /* Light position */ + glProgramParameter4fNV(GL_VERTEX_PROGRAM_NV, 32, 2, 2, 4, 1); + /* Diffuse material color */ + glProgramParameter4fNV(GL_VERTEX_PROGRAM_NV, 35, 0.25, 0, 0.25, 1); + + glEnable(GL_VERTEX_PROGRAM_NV); + glEnable(GL_DEPTH_TEST); + glClearColor(0.3, 0.3, 0.3, 1); + + printf("glGetError = %d\n", (int) glGetError()); +} + + +int main( int argc, char *argv[] ) +{ + glutInit( &argc, argv ); + glutInitWindowPosition( 0, 0 ); + glutInitWindowSize( 250, 250 ); + glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH ); + glutCreateWindow(argv[0]); + glutReshapeFunc( Reshape ); + glutKeyboardFunc( Key ); + glutSpecialFunc( SpecialKey ); + glutDisplayFunc( Display ); + if (Anim) + glutIdleFunc(Idle); + Init(); + glutMainLoop(); + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/vpwarpmesh.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/vpwarpmesh.c new file mode 100644 index 000000000..56aa8200e --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/vpwarpmesh.c @@ -0,0 +1,236 @@ +/* + * Warp a triangle mesh with a vertex program. + */ + +#include <assert.h> +#include <string.h> +#include <stdio.h> +#include <stdlib.h> +#include <math.h> +#define GL_GLEXT_PROTOTYPES +#include <GL/glut.h> + +static float Xrot = -60.0, Yrot = 0.0, Zrot = 0.0; +static GLboolean Anim = GL_TRUE; +static GLfloat Phi = 0.0; + + +static void Idle( void ) +{ + Phi += 0.01; + glutPostRedisplay(); +} + + +static void DrawMesh( int rows, int cols ) +{ + static const GLfloat colorA[3] = { 0, 1, 0 }; + static const GLfloat colorB[3] = { 0, 0, 1 }; + const float dx = 2.0 / (cols - 1); + const float dy = 2.0 / (rows - 1); + float x, y; + int i, j; + +#if 1 +#define COLOR3FV(c) glVertexAttrib3fvNV(3, c) +#define VERTEX2F(x, y) glVertexAttrib2fNV(0, x, y) +#else +#define COLOR3FV(c) glColor3fv(c) +#define VERTEX2F(x, y) glVertex2f(x, y) +#endif + + y = -1.0; + for (i = 0; i < rows - 1; i++) { + glBegin(GL_QUAD_STRIP); + x = -1.0; + for (j = 0; j < cols; j++) { + if ((i + j) & 1) + COLOR3FV(colorA); + else + COLOR3FV(colorB); + VERTEX2F(x, y); + VERTEX2F(x, y + dy); + x += dx; + } + glEnd(); + y += dy; + } +} + + +static void Display( void ) +{ + glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); + + glPushMatrix(); + glRotatef(Xrot, 1, 0, 0); + glRotatef(Yrot, 0, 1, 0); + glRotatef(Zrot, 0, 0, 1); + + /* Position the gravity source */ + { + GLfloat x, y, z, r = 0.5; + x = r * cos(Phi); + y = r * sin(Phi); + z = 1.0; + glProgramParameter4fNV(GL_VERTEX_PROGRAM_NV, 30, x, y, z, 1); + glDisable(GL_VERTEX_PROGRAM_NV); + glBegin(GL_POINTS); + glColor3f(1,1,1); + glVertex3f(x, y, z); + glEnd(); + } + + glEnable(GL_VERTEX_PROGRAM_NV); + DrawMesh(8, 8); + glPopMatrix(); + + glutSwapBuffers(); +} + + +static void Reshape( int width, int height ) +{ + float ar = (float) width / (float) height; + glViewport( 0, 0, width, height ); + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glFrustum( -1.0 * ar, 1.0 * ar, -1.0, 1.0, 5.0, 25.0 ); + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); + glTranslatef( 0.0, 0.0, -12.0 ); + glScalef(2, 2, 2); +} + + +static void Key( unsigned char key, int x, int y ) +{ + (void) x; + (void) y; + switch (key) { + case 'a': + Anim = !Anim; + if (Anim) + glutIdleFunc(Idle); + else + glutIdleFunc(NULL); + break; + case 'p': + Phi += 0.2; + break; + case 'z': + Zrot -= 5.0; + break; + case 'Z': + Zrot += 5.0; + break; + case 27: + exit(0); + break; + } + glutPostRedisplay(); +} + + +static void SpecialKey( int key, int x, int y ) +{ + const GLfloat step = 3.0; + (void) x; + (void) y; + switch (key) { + case GLUT_KEY_UP: + Xrot -= step; + break; + case GLUT_KEY_DOWN: + Xrot += step; + break; + case GLUT_KEY_LEFT: + Yrot -= step; + break; + case GLUT_KEY_RIGHT: + Yrot += step; + break; + } + glutPostRedisplay(); +} + + +static void Init( void ) +{ + /* + * c[0..3] = modelview matrix + * c[4..7] = inverse modelview matrix + * c[30] = gravity source location + * c[31] = gravity source strength + * c[32] = light pos + * c[35] = diffuse color + */ + static const char prog[] = + "!!VP1.0\n" + + "# Compute distance from vertex to gravity source\n" + "ADD R1, c[30], -v[OPOS]; # vector from vertex to gravity\n" + "DP3 R2, R1, R1; # dot product\n" + "RSQ R2, R2.x; # square root = distance\n" + "MUL R2, R2, c[31].xxxx; # scale by the gravity factor\n" + + "# Displace vertex by gravity factor along R1 vector\n" + "MAD R3, R1, R2, v[OPOS];\n" + + "# Continue with typical modelview/projection\n" + "DP4 o[HPOS].x, c[0], R3 ; # object x MVP -> clip\n" + "DP4 o[HPOS].y, c[1], R3 ;\n" + "DP4 o[HPOS].z, c[2], R3 ;\n" + "DP4 o[HPOS].w, c[3], R3 ;\n" + + "MOV o[COL0], v[COL0];\n # copy input color to output color\n" + + "END"; + + if (!glutExtensionSupported("GL_NV_vertex_program")) { + printf("Sorry, this program requires GL_NV_vertex_program\n"); + exit(1); + } + + glLoadProgramNV(GL_VERTEX_PROGRAM_NV, 1, + strlen(prog), (const GLubyte *) prog); + assert(glIsProgramNV(1)); + glBindProgramNV(GL_VERTEX_PROGRAM_NV, 1); + + /* Load the program registers */ + glTrackMatrixNV(GL_VERTEX_PROGRAM_NV, 0, GL_MODELVIEW_PROJECTION_NV, GL_IDENTITY_NV); + glTrackMatrixNV(GL_VERTEX_PROGRAM_NV, 4, GL_MODELVIEW, GL_INVERSE_TRANSPOSE_NV); + + /* Light position */ + glProgramParameter4fNV(GL_VERTEX_PROGRAM_NV, 32, 2, 2, 4, 1); + /* Diffuse material color */ + glProgramParameter4fNV(GL_VERTEX_PROGRAM_NV, 35, 0.25, 0, 0.25, 1); + + /* Gravity strength */ + glProgramParameter4fNV(GL_VERTEX_PROGRAM_NV, 31, .5, 0, 0, 0); + + glEnable(GL_DEPTH_TEST); + glClearColor(0.3, 0.3, 0.3, 1); + glShadeModel(GL_FLAT); + glPointSize(3); + printf("glGetError = %d\n", (int) glGetError()); +} + + +int main( int argc, char *argv[] ) +{ + glutInit( &argc, argv ); + glutInitWindowPosition( 0, 0 ); + glutInitWindowSize( 250, 250 ); + glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH ); + glutCreateWindow(argv[0]); + glutReshapeFunc( Reshape ); + glutKeyboardFunc( Key ); + glutSpecialFunc( SpecialKey ); + glutDisplayFunc( Display ); + if (Anim) + glutIdleFunc(Idle); + Init(); + glutMainLoop(); + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/yuvrect.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/yuvrect.c new file mode 100644 index 000000000..acef40609 --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/yuvrect.c @@ -0,0 +1,193 @@ +/* + * Test the GL_NV_texture_rectangle and GL_MESA_ycrcb_texture extensions. + * + * Brian Paul 13 September 2002 + */ + +#include <assert.h> +#include <math.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#define GL_GLEXT_PROTOTYPES +#include <GL/glut.h> + +#include "../util/readtex.c" /* I know, this is a hack. */ + +#define TEXTURE_FILE "../images/girl.rgb" + +static GLfloat Xrot = 0, Yrot = 0, Zrot = 0; +static GLint ImgWidth, ImgHeight; +static GLushort *ImageYUV = NULL; + + +static void DrawObject(void) +{ + glBegin(GL_QUADS); + + glTexCoord2f(0, 0); + glVertex2f(-1.0, -1.0); + + glTexCoord2f(ImgWidth, 0); + glVertex2f(1.0, -1.0); + + glTexCoord2f(ImgWidth, ImgHeight); + glVertex2f(1.0, 1.0); + + glTexCoord2f(0, ImgHeight); + glVertex2f(-1.0, 1.0); + + glEnd(); +} + + +static void Display( void ) +{ + glClear( GL_COLOR_BUFFER_BIT ); + + glPushMatrix(); + glRotatef(Xrot, 1.0, 0.0, 0.0); + glRotatef(Yrot, 0.0, 1.0, 0.0); + glRotatef(Zrot, 0.0, 0.0, 1.0); + DrawObject(); + glPopMatrix(); + + glutSwapBuffers(); +} + + +static void Reshape( int width, int height ) +{ + glViewport( 0, 0, width, height ); + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glFrustum( -1.0, 1.0, -1.0, 1.0, 10.0, 100.0 ); + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); + glTranslatef( 0.0, 0.0, -15.0 ); +} + + +static void Key( unsigned char key, int x, int y ) +{ + (void) x; + (void) y; + switch (key) { + case 27: + exit(0); + break; + } + glutPostRedisplay(); +} + + +static void SpecialKey( int key, int x, int y ) +{ + float step = 3.0; + (void) x; + (void) y; + + switch (key) { + case GLUT_KEY_UP: + Xrot += step; + break; + case GLUT_KEY_DOWN: + Xrot -= step; + break; + case GLUT_KEY_LEFT: + Yrot += step; + break; + case GLUT_KEY_RIGHT: + Yrot -= step; + break; + } + glutPostRedisplay(); +} + + + +static void Init( int argc, char *argv[] ) +{ + GLuint texObj = 100; + const char *file; + + if (!glutExtensionSupported("GL_NV_texture_rectangle")) { + printf("Sorry, GL_NV_texture_rectangle is required\n"); + exit(0); + } + + if (!glutExtensionSupported("GL_MESA_ycbcr_texture")) { + printf("Sorry, GL_MESA_ycbcr_texture is required\n"); + exit(0); + } + + glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + + glBindTexture(GL_TEXTURE_RECTANGLE_NV, texObj); +#ifdef LINEAR_FILTER + /* linear filtering looks much nicer but is much slower for Mesa */ + glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MAG_FILTER, GL_LINEAR); +#else + glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MAG_FILTER, GL_NEAREST); +#endif + + if (argc > 1) + file = argv[1]; + else + file = TEXTURE_FILE; + + ImageYUV = LoadYUVImage(file, &ImgWidth, &ImgHeight); + if (!ImageYUV) { + printf("Couldn't read %s\n", TEXTURE_FILE); + exit(0); + } + + printf("Image: %dx%d\n", ImgWidth, ImgHeight); + + glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, + GL_YCBCR_MESA, ImgWidth, ImgHeight, 0, + GL_YCBCR_MESA, GL_UNSIGNED_SHORT_8_8_MESA, ImageYUV); + + assert(glGetError() == GL_NO_ERROR); + glTexSubImage2D(GL_TEXTURE_RECTANGLE_NV, 0, + 0, 0, ImgWidth, ImgHeight, + GL_YCBCR_MESA, GL_UNSIGNED_SHORT_8_8_MESA, ImageYUV); + + assert(glGetError() == GL_NO_ERROR); + + glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); + + glEnable(GL_TEXTURE_RECTANGLE_NV); + + glShadeModel(GL_FLAT); + glClearColor(0.3, 0.3, 0.4, 1.0); + + if (argc > 1 && strcmp(argv[1], "-info")==0) { + printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER)); + printf("GL_VERSION = %s\n", (char *) glGetString(GL_VERSION)); + printf("GL_VENDOR = %s\n", (char *) glGetString(GL_VENDOR)); + printf("GL_EXTENSIONS = %s\n", (char *) glGetString(GL_EXTENSIONS)); + } +} + + +int main( int argc, char *argv[] ) +{ + glutInit( &argc, argv ); + glutInitWindowSize( 300, 300 ); + glutInitWindowPosition( 0, 0 ); + glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE ); + glutCreateWindow(argv[0] ); + + Init( argc, argv ); + + glutReshapeFunc( Reshape ); + glutKeyboardFunc( Key ); + glutSpecialFunc( SpecialKey ); + glutDisplayFunc( Display ); + + glutMainLoop(); + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/yuvsquare.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/yuvsquare.c new file mode 100644 index 000000000..3601e7a31 --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/yuvsquare.c @@ -0,0 +1,232 @@ +/* + * Test the GL_NV_texture_rectangle and GL_MESA_ycrcb_texture extensions. + * + * Brian Paul 13 September 2002 + */ + + +#include <math.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#define GL_GLEXT_PROTOTYPES +#include <GL/glut.h> + +#include "../util/readtex.c" /* I know, this is a hack. */ + +#define TEXTURE_FILE "../images/tile.rgb" + +static GLfloat Xrot = 0, Yrot = 0, Zrot = 0; +static GLint ImgWidth, ImgHeight; +static GLushort *ImageYUV = NULL; +static GLubyte *ImageRGB = NULL; +static const GLuint yuvObj = 100; +static const GLuint rgbObj = 101; + + +static void DrawObject(void) +{ + glBegin(GL_QUADS); + + glTexCoord2f(0, 0); + glVertex2f(-1.0, -1.0); + + glTexCoord2f(1, 0); + glVertex2f(1.0, -1.0); + + glTexCoord2f(1, 1); + glVertex2f(1.0, 1.0); + + glTexCoord2f(0, 1); + glVertex2f(-1.0, 1.0); + + glEnd(); +} + + +static void Display( void ) +{ + glClear( GL_COLOR_BUFFER_BIT ); + + glPushMatrix(); + glTranslatef( -1.1, 0.0, -15.0 ); + glRotatef(Xrot, 1.0, 0.0, 0.0); + glRotatef(Yrot, 0.0, 1.0, 0.0); + glRotatef(Zrot, 0.0, 0.0, 1.0); + glBindTexture(GL_TEXTURE_2D, yuvObj); + DrawObject(); + glPopMatrix(); + + glPushMatrix(); + glTranslatef( 1.1, 0.0, -15.0 ); + glRotatef(Xrot, 1.0, 0.0, 0.0); + glRotatef(Yrot, 0.0, 1.0, 0.0); + glRotatef(Zrot, 0.0, 0.0, 1.0); + glBindTexture(GL_TEXTURE_2D, rgbObj); + DrawObject(); + glPopMatrix(); + + glutSwapBuffers(); +} + + +static void Reshape( int width, int height ) +{ + glViewport( 0, 0, width, height ); + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + glFrustum( -1.1, 1.1, -1.1, 1.1, 10.0, 100.0 ); + glMatrixMode( GL_MODELVIEW ); + glLoadIdentity(); + glTranslatef( 0.0, 0.0, -15.0 ); +} + + +static void Key( unsigned char key, int x, int y ) +{ + (void) x; + (void) y; + switch (key) { + case 27: + exit(0); + break; + } + glutPostRedisplay(); +} + + +static void SpecialKey( int key, int x, int y ) +{ + float step = 3.0; + (void) x; + (void) y; + + switch (key) { + case GLUT_KEY_UP: + Xrot += step; + break; + case GLUT_KEY_DOWN: + Xrot -= step; + break; + case GLUT_KEY_LEFT: + Yrot += step; + break; + case GLUT_KEY_RIGHT: + Yrot -= step; + break; + } + glutPostRedisplay(); +} + + +#define CLAMP( X, MIN, MAX ) ( (X)<(MIN) ? (MIN) : ((X)>(MAX) ? (MAX) : (X)) ) + + + +/* #define LINEAR_FILTER */ + +static void Init( int argc, char *argv[] ) +{ + const char *file; + GLenum format; + + if (!glutExtensionSupported("GL_MESA_ycbcr_texture")) { + printf("Sorry, GL_MESA_ycbcr_texture is required\n"); + exit(0); + } + + glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + + if (argc > 1) + file = argv[1]; + else + file = TEXTURE_FILE; + + /* First load the texture as YCbCr. + */ + + glBindTexture(GL_TEXTURE_2D, yuvObj); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + + ImageYUV = LoadYUVImage(file, &ImgWidth, &ImgHeight ); + if (!ImageYUV) { + printf("Couldn't read %s\n", TEXTURE_FILE); + exit(0); + } + + printf("Image: %dx%d\n", ImgWidth, ImgHeight); + + + glTexImage2D(GL_TEXTURE_2D, 0, + GL_YCBCR_MESA, + ImgWidth, ImgHeight, 0, + GL_YCBCR_MESA, + GL_UNSIGNED_SHORT_8_8_MESA, ImageYUV); + + glEnable(GL_TEXTURE_2D); + + glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); + + + + /* Now load the texture as RGB. + */ + + glBindTexture(GL_TEXTURE_2D, rgbObj); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + + ImageRGB = LoadRGBImage(file, &ImgWidth, &ImgHeight, &format ); + if (!ImageRGB) { + printf("Couldn't read %s\n", TEXTURE_FILE); + exit(0); + } + + printf("Image: %dx%d\n", ImgWidth, ImgHeight); + + + glTexImage2D(GL_TEXTURE_2D, 0, + format, + ImgWidth, ImgHeight, 0, + format, + GL_UNSIGNED_BYTE, ImageRGB); + + glEnable(GL_TEXTURE_2D); + + glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); + + + + glShadeModel(GL_FLAT); + glClearColor(0.3, 0.3, 0.4, 1.0); + + if (argc > 1 && strcmp(argv[1], "-info")==0) { + printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER)); + printf("GL_VERSION = %s\n", (char *) glGetString(GL_VERSION)); + printf("GL_VENDOR = %s\n", (char *) glGetString(GL_VENDOR)); + printf("GL_EXTENSIONS = %s\n", (char *) glGetString(GL_EXTENSIONS)); + } + + printf( "Both images should appear the same.\n" ); +} + + +int main( int argc, char *argv[] ) +{ + glutInit( &argc, argv ); + glutInitWindowSize( 300, 300 ); + glutInitWindowPosition( 0, 0 ); + glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE ); + glutCreateWindow(argv[0] ); + + Init( argc, argv ); + + glutReshapeFunc( Reshape ); + glutKeyboardFunc( Key ); + glutSpecialFunc( SpecialKey ); + glutDisplayFunc( Display ); + + glutMainLoop(); + return 0; +} diff --git a/nx-X11/extras/Mesa_6.4.1/progs/tests/zreaddraw.c b/nx-X11/extras/Mesa_6.4.1/progs/tests/zreaddraw.c new file mode 100644 index 000000000..e2dacbf7f --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.1/progs/tests/zreaddraw.c @@ -0,0 +1,116 @@ +/* + * Test glRead/DrawPixels for GL_DEPTH_COMPONENT, with pixelzoom. + * + * Brian Paul + * 23 August 2003 + */ + +#include <stdio.h> +#include <stdlib.h> +#include <math.h> +#define GL_GLEXT_PROTOTYPES +#include <GL/glut.h> + +static GLint WinWidth = 500, WinHeight = 500; + + +static void Display(void) +{ + GLfloat depth[100 * 100]; + GLfloat depth2[400 * 400]; + GLfloat min, max; + int i; + + glClearColor(0.5, 0.5, 0.5, 0); + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + + /* draw a sphere */ + glViewport(0, 0, 100, 100); + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + glOrtho(-1, 1, -1, 1, -1, 0); /* clip away back half of sphere */ + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + glutSolidSphere(1.0, 20, 10); + + /* read the depth image */ + glReadPixels(0, 0, 100, 100, GL_DEPTH_COMPONENT, GL_FLOAT, depth); + min = max = depth[0]; + for (i = 1; i < 100 * 100; i++) { + if (depth[i] < min) + min = depth[i]; + if (depth[i] > max) + max = depth[i]; + } + printf("Depth value range: [%f, %f]\n", min, max); + + /* draw depth image with scaling (into z buffer) */ + glPixelZoom(4.0, 4.0); + glWindowPos2i(100, 0); + glDrawPixels(100, 100, GL_DEPTH_COMPONENT, GL_FLOAT, depth); + + /* read back scaled depth image */ + glReadPixels(100, 0, 400, 400, GL_DEPTH_COMPONENT, GL_FLOAT, depth2); + /* draw as luminance */ + glPixelZoom(1.0, 1.0); + glDrawPixels(400, 400, GL_LUMINANCE, GL_FLOAT, depth2); + + glutSwapBuffers(); +} + + +static void Reshape(int width, int height) +{ + WinWidth = width; + WinHeight = height; + glViewport(0, 0, width, height); +} + + +static void Key(unsigned char key, int x, int y) +{ + (void) x; + (void) y; + switch (key) { + case 27: + exit(0); + break; + } + glutPostRedisplay(); +} + + +static void Init(void) +{ + const GLfloat blue[4] = {.1, .1, 1.0, 0.0}; + const GLfloat gray[4] = {0.2, 0.2, 0.2, 1.0}; + const GLfloat white[4] = {1.0, 1.0, 1.0, 1.0}; + const GLfloat pos[4] = {0, 0, 10, 0}; + + printf("GL_VERSION = %s\n", (char *) glGetString(GL_VERSION)); + printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER)); + + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, blue); + glLightfv(GL_LIGHT0, GL_AMBIENT, gray); + glLightfv(GL_LIGHT0, GL_DIFFUSE, white); + glLightfv(GL_LIGHT0, GL_POSITION, pos); + glEnable(GL_LIGHTING); + glEnable(GL_LIGHT0); + glEnable(GL_DEPTH_TEST); +} + + +int main(int argc, char *argv[]) +{ + glutInit(&argc, argv); + glutInitWindowPosition(0, 0); + glutInitWindowSize(WinWidth, WinHeight); + glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE); + glutCreateWindow(argv[0]); + glutReshapeFunc(Reshape); + glutKeyboardFunc(Key); + glutDisplayFunc(Display); + Init(); + glutMainLoop(); + return 0; +} |