#! /usr/bin/env python import unittest, pygame, pygame.display, time, traceback, os, sys import logging logging.basicConfig() try: from numpy import * except ImportError, err: try: from Numeric import * except ImportError, err: array = None pygame.display.init() import OpenGL OpenGL.CONTEXT_CHECKING = True OpenGL.FORWARD_COMPATIBLE_ONLY = True from OpenGL.GL import * try: glGetError() except error.NoContext, err: # good, should have got this error pass else: raise RuntimeError( """Did not catch invalid context!""" ) from OpenGL import constants, error from OpenGL.GLU import * from OpenGL.arrays import arraydatatype import OpenGL from OpenGL.extensions import alternate import ctypes from OpenGL.GL.EXT.framebuffer_object import * from OpenGL.GL.EXT.multi_draw_arrays import * from OpenGL.GL.ARB.imaging import * glMultiDrawElements = alternate( glMultiDrawElementsEXT, glMultiDrawElements, ) class Tests( unittest.TestCase ): evaluator_ctrlpoints = [[[ -1.5, -1.5, 4.0], [-0.5, -1.5, 2.0], [0.5, -1.5, -1.0], [1.5, -1.5, 2.0]], [[-1.5, -0.5, 1.0], [-0.5, -0.5, 3.0], [0.5, -0.5, 0.0], [1.5, -0.5, -1.0]], [[-1.5, 0.5, 4.0], [-0.5, 0.5, 0.0], [0.5, 0.5, 3.0], [1.5, 0.5, 4.0]], [[-1.5, 1.5, -2.0], [-0.5, 1.5, -2.0], [0.5, 1.5, 0.0], [1.5, 1.5, -1.0]]] width = height = 300 def setUp( self ): """Set up the operation""" self.screen = pygame.display.set_mode( (self.width,self.height), pygame.OPENGL | pygame.DOUBLEBUF, ) pygame.display.set_caption('Testing system') pygame.key.set_repeat(500,30) glMatrixMode (GL_PROJECTION) glLoadIdentity() gluPerspective(40.0, 300/300, 1.0, 20.0) glMatrixMode(GL_MODELVIEW) glLoadIdentity() gluLookAt( -2,0,3, # eyepoint 0,0,0, # center-of-view 0,1,0, # up-vector ) glClearColor( 0,0,.25, 0 ) glClear( GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT ) def tearDown( self ): glFlush() pygame.display.flip() time.sleep( .25 ) #raw_input( 'Okay? ' ) def test_arrayPointer( self ): dt = arraydatatype.GLuintArray d = dt.zeros( (3,)) dp = dt.typedPointer( d ) assert dp[0] == 0 assert dp[1] == 0 assert dp[2] == 0 dp[1] = 1 assert dp[1] == 1 assert d[1] == 1 def test_ctypes_array( self ): color = (GLfloat * 3)( 0,1,0 ) glColor3fv( color ) if (not OpenGL.ERROR_ON_COPY) or array: def test_evaluator( self ): """Test whether the evaluator functions work""" glDisable(GL_CULL_FACE) glEnable(GL_MAP2_VERTEX_3) glEnable(GL_DEPTH_TEST) glEnable(GL_NORMALIZE) if array: ctrl_points = array( self.evaluator_ctrlpoints,'f') else: ctrl_points = self.evaluator_ctrlpoints glMap2f(GL_MAP2_VERTEX_3, 0, 1, 0, 1, ctrl_points) glMapGrid2f(20, 0.0, 1.0, 20, 0.0, 1.0) glShadeModel(GL_FLAT) glEvalMesh2(GL_FILL, 0, 20, 0, 20) glTranslatef( 0,0.001, 0 ) glEvalMesh2(GL_POINT, 0, 20, 0, 20) def test_nurbs_raw( self ): """Test nurbs rendering using raw API calls""" from OpenGL.raw import GLU knots = (constants.GLfloat* 8) ( 0,0,0,0,1,1,1,1 ) ctlpoints = (constants.GLfloat*(3*4*4))( -3., -3., -3., -3., -1., -3., -3., 1., -3., -3., 3., -3., -1., -3., -3., -1., -1., 3., -1., 1., 3., -1., 3., -3., 1., -3., -3., 1., -1., 3., 1., 1., 3., 1., 3., -3., 3., -3., -3., 3., -1., -3., 3., 1., -3., 3., 3., -3. ) theNurb = gluNewNurbsRenderer() GLU.gluBeginSurface(theNurb) GLU.gluNurbsSurface( theNurb, 8, ctypes.byref(knots), 8, ctypes.byref(knots), 4 * 3, 3, ctypes.byref( ctlpoints ), 4, 4, GL_MAP2_VERTEX_3 ) GLU.gluEndSurface(theNurb) if array: def test_nurbs_raw_arrays( self ): """Test nurbs rendering using raw API calls with arrays""" from OpenGL.raw import GLU import numpy knots = numpy.array( ( 0,0,0,0,1,1,1,1 ), 'f' ) ctlpoints = numpy.array( [[[-3., -3., -3.], [-3., -1., -3.], [-3., 1., -3.], [-3., 3., -3.]], [[-1., -3., -3.], [-1., -1., 3.], [-1., 1., 3.], [-1., 3., -3.]], [[ 1., -3., -3.], [ 1., -1., 3.], [ 1., 1., 3.], [ 1., 3., -3.]], [[ 3., -3., -3.], [ 3., -1., -3.], [ 3., 1., -3.], [ 3., 3., -3.]]], 'f' ) theNurb = GLU.gluNewNurbsRenderer() GLU.gluBeginSurface(theNurb) GLU.gluNurbsSurface( theNurb, 8, knots, 8, knots, 4 * 3, 3, ctlpoints , 4, 4, GL_MAP2_VERTEX_3 ) GLU.gluEndSurface(theNurb) def test_nurbs( self ): """Test nurbs rendering""" from OpenGL.raw import GLU def buildControlPoints( ): ctlpoints = zeros( (4,4,3), 'd') for u in range( 4 ): for v in range( 4): ctlpoints[u][v][0] = 2.0*(u - 1.5) ctlpoints[u][v][1] = 2.0*(v - 1.5); if (u == 1 or u ==2) and (v == 1 or v == 2): ctlpoints[u][v][2] = 3.0; else: ctlpoints[u][v][2] = -3.0; return ctlpoints controlPoints = buildControlPoints() theNurb = GLU.gluNewNurbsRenderer()[0] #theNurb = gluNewNurbsRenderer(); gluNurbsProperty(theNurb, GLU_SAMPLING_TOLERANCE, 25.0); gluNurbsProperty(theNurb, GLU_DISPLAY_MODE, GLU_FILL); knots= array ([0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0], "d") glPushMatrix(); try: glRotatef(330.0, 1.,0.,0.); glScalef (0.5, 0.5, 0.5); gluBeginSurface(theNurb); try: gluNurbsSurface( theNurb, knots, knots, controlPoints, GL_MAP2_VERTEX_3 ); finally: gluEndSurface(theNurb); finally: glPopMatrix(); def test_errors( self ): """Test for error catching/checking""" try: glClear( GL_INVALID_VALUE ) except Exception, err: assert err.err == 1281, ("""Expected invalid value (1281)""", err.err) else: raise RuntimeError( """No error on invalid glClear""" ) try: glColorPointer(GL_INVALID_VALUE,GL_BYTE,0,None) except Exception, err: assert err.err == 1281, ("""Expected invalid value (1281)""", err.err) assert err.baseOperation, err.baseOperation assert err.pyArgs == (GL_INVALID_VALUE, GL_BYTE, 0, None), err.pyArgs assert err.cArgs == (GL_INVALID_VALUE, GL_BYTE, 0, None), err.cArgs else: raise RuntimeError( """No error on invalid glColorPointer""" ) try: glBitmap(-1,-1,0,0,0,0,"") except Exception, err: assert err.err in (1281,1282), ("""Expected invalid value (1281) or invalid operation (1282)""", err.err) else: raise RuntimeError( """No error on invalid glBitmap""" ) def test_quadrics( self ): """Test for rendering quadric objects""" quad = gluNewQuadric() glColor3f( 1,0, 0 ) gluSphere( quad, 1.0, 16, 16 ) if not OpenGL.ERROR_ON_COPY: def test_simple( self ): """Test for simple vertex-based drawing""" glDisable( GL_LIGHTING ) glBegin( GL_TRIANGLES ) try: try: glVertex3f( 0.,1.,0. ) except Exception, err: traceback.print_exc() glVertex3fv( [-1,0,0] ) glVertex3dv( [1,0,0] ) try: glVertex3dv( [1,0] ) except ValueError, err: #Got expected value error (good) pass else: raise RuntimeError( """Should have raised a value error on passing 2-element array to 3-element function!""", ) finally: glEnd() a = glGenTextures( 1 ) assert a b = glGenTextures( 2 ) assert len(b) == 2 def test_arbwindowpos( self ): """Test the ARB window_pos extension will load if available""" from OpenGL.GL.ARB.window_pos import glWindowPos2dARB if glWindowPos2dARB: glWindowPos2dARB( 0.0, 3.0 ) def test_getstring( self ): assert glGetString( GL_EXTENSIONS ) if not OpenGL.ERROR_ON_COPY: def test_pointers( self ): """Test that basic pointer functions work""" vertex = constants.GLdouble * 3 vArray = vertex * 2 glVertexPointerd( [[2,3,4,5],[2,3,4,5]] ) glVertexPointeri( ([2,3,4,5],[2,3,4,5]) ) glVertexPointers( [[2,3,4,5],[2,3,4,5]] ) glVertexPointerd( vArray( vertex(2,3,4),vertex(2,3,4) ) ) myVector = vArray( vertex(2,3,4),vertex(2,3,4) ) glVertexPointer( 3, GL_DOUBLE, 0, ctypes.cast( myVector, ctypes.POINTER(constants.GLdouble)) ) repr(glVertexPointerb( [[2,3],[4,5]] )) glVertexPointerf( [[2,3],[4,5]] ) assert arrays.ArrayDatatype.dataPointer( None ) == None glVertexPointerf( None ) glNormalPointerd( [[2,3,4],[2,3,4]] ) glNormalPointerd( None ) glTexCoordPointerd( [[2,3,4],[2,3,4]] ) glTexCoordPointerd( None ) glColorPointerd( [[2,3,4],[2,3,4]] ) glColorPointerd( None ) glEdgeFlagPointerb( [0,1,0,0,1,0] ) glEdgeFlagPointerb( None ) glIndexPointerd( [0,1,0,0,1,0] ) glIndexPointerd( None ) glColor4fv( [0,0,0,1] ) # string data-types... import struct s = struct.pack( '>iiii', 2,3,4,5 ) * 2 result = glVertexPointer( 4,GL_INT,0,s ) TESS_TEST_SHAPE = [ [191, 0], [ 191, 1480], [ 191, 1480], [ 401, 1480], [ 401, 1480], [401, 856], [401, 856], [1105, 856], [1105, 856], [1105, 1480], [1105, 1480], [1315, 1480], [1315, 1480], [1315, 0], [1315, 0], [1105, 0], [1105, 0], [1105, 699], [1105, 699], [401, 699], [401, 699], [401, 0], [401, 0], [191, 0], [191, 0], [191, 0], ] def test_tess(self ): """Test that tessellation works""" glDisable( GL_LIGHTING ) glColor3f( 1,1,1 ) glNormal3f( 0,0,1 ) def begin( *args ): return glBegin( *args ) def vertex( *args ): return glVertex3dv( *args ) def end( *args ): return glEnd( *args ) def combine( coords, vertex_data, weight): return coords tobj = gluNewTess() gluTessCallback(tobj, GLU_TESS_BEGIN, begin); gluTessCallback(tobj, GLU_TESS_VERTEX, vertex); gluTessCallback(tobj, GLU_TESS_END, end); gluTessCallback(tobj, GLU_TESS_COMBINE, combine); gluTessBeginPolygon(tobj, None); gluTessBeginContour(tobj); for (x,y) in self.TESS_TEST_SHAPE: vert = (x,y,0.0) gluTessVertex(tobj, vert, vert); gluTessEndContour(tobj); gluTessEndPolygon(tobj); def test_texture( self ): """Test texture (requires OpenGLContext and PIL)""" try: from OpenGLContext import texture import Image from OpenGL.GLUT import glutSolidTeapot except ImportError, err: pass else: glEnable( GL_TEXTURE_2D ) ourTexture = texture.Texture( Image.open( 'yingyang.png' ) ) ourTexture() glEnable( GL_LIGHTING ) glEnable( GL_LIGHT0 ) glBegin( GL_TRIANGLES ) try: try: glTexCoord2f( .5, 1 ) glVertex3f( 0.,1.,0. ) except Exception, err: traceback.print_exc() glTexCoord2f( 0, 0 ) glVertex3fv( [-1,0,0] ) glTexCoord2f( 1, 0 ) glVertex3dv( [1,0,0] ) try: glVertex3dv( [1,0] ) except ValueError, err: #Got expected value error (good) pass else: raise RuntimeError( """Should have raised a value error on passing 2-element array to 3-element function!""", ) finally: glEnd() if array: def test_numpyConversion( self ): """Test that we can run a numpy conversion from double to float for glColorArray""" import numpy a = numpy.arange( 0,1.2, .1, 'd' ).reshape( (-1,3 )) glEnableClientState(GL_VERTEX_ARRAY) try: glColorPointerf( a ) glColorPointerd( a ) finally: glDisableClientState( GL_VERTEX_ARRAY ) def test_constantPickle( self ): """Test that our constants can be pickled/unpickled properly""" import pickle, cPickle for p in pickle,cPickle: v = p.loads( p.dumps( GL_VERTEX_ARRAY )) assert v == GL_VERTEX_ARRAY, (v,GL_VERTEX_ARRAY) assert v.name == GL_VERTEX_ARRAY.name, v.name if not OpenGL.ERROR_ON_COPY: def test_copyNonContiguous( self ): """Test that a non-contiguous (transposed) array gets applied as a copy""" glMatrixMode(GL_MODELVIEW) glPushMatrix( ) try: import numpy transf = numpy.identity(4, dtype=numpy.float32) # some arbitrary transformation... transf[0,3] = 2.5 transf[2,3] = -80 # what do we get with the un-transposed version... glMatrixMode(GL_MODELVIEW) glLoadIdentity() glMultMatrixf(transf) untransposed = glGetFloatv(GL_MODELVIEW_MATRIX) # now transposed... # with a copy it works... t2 = transf.transpose().copy() # This doesn't work: glLoadIdentity() glMultMatrixf(t2) # This does work: #glMultMatrixf(transf.transpose().copy()) transposed = glGetFloatv(GL_MODELVIEW_MATRIX) assert not numpy.allclose( transposed, untransposed ), (transposed, untransposed) t2 = transf.transpose() # This doesn't work: glLoadIdentity() glMultMatrixf(t2) # This does work: #glMultMatrixf(transf.transpose().copy()) transposed = glGetFloatv(GL_MODELVIEW_MATRIX) assert not numpy.allclose( transposed, untransposed ), (transposed, untransposed) finally: glMatrixMode(GL_MODELVIEW) glPopMatrix() def test_nullTexture( self ): """Test that we can create null textures""" glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, 512, 512, 0, GL_RGB, GL_INT, None) def test_nonFloatColor( self ): """Test that we handle non-floating-point colour inputs""" for notFloat,shouldWork in ((0,True), (object(),False), (object,False)): try: glColor4f( 0,1,1,notFloat ) except Exception, err: if shouldWork: raise else: if not shouldWork: raise RuntimeError( """Expected failure for non-float value %s, succeeded"""%( notFloat, )) someData = [ (0,255,0)] def test_glAreTexturesResident( self ): """Test that PyOpenGL api for glAreTexturesResident is working Note: not currently working on AMD64 Linux for some reason """ import numpy textures = glGenTextures(2) residents = [] data = numpy.array( self.someData,'i' ) for texture in textures: glBindTexture( GL_TEXTURE_2D,int(texture) ) glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, 1, 1, 0, GL_RGB, GL_INT, data) residents.append( glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_RESIDENT ) ) error.glCheckError(None) result = glAreTexturesResident( textures) assert len(result) == 2 for (tex,expected,found) in zip( textures, residents, result ): if expected != found: print 'Warning: texture %s residence expected %s got %s'%( tex, expected, found ) if OpenGL.ALLOW_NUMPY_SCALARS: def test_passBackResults( self ): """Test ALLOW_NUMPY_SCALARS to allow numpy scalars to be passed in""" textures = glGenTextures(2) glBindTexture( GL_TEXTURE_2D, textures[0] ) if array: def test_arrayTranspose( self ): import numpy m = glGetFloatv( GL_MODELVIEW_MATRIX ) glMatrixMode( GL_MODELVIEW ) glLoadIdentity() t = eye(4) t[3,0] = 20.0 # the following glMultMatrixf call ignored this transpose t = t.T glMultMatrixf( t ) m = glGetFloatv( GL_MODELVIEW_MATRIX ) assert numpy.allclose( m[-1], [0,0,0,1] ), m def test_glreadpixelsf( self ): """Issue #1979002 crash due to mis-calculation of resulting array size""" width,height = self.width, self.height readback_image1 = glReadPixelsub(0,0,width,height,GL_RGB) readback_image2 = glReadPixelsf(0,0,width,height,GL_RGB) def test_glreadpixels_is_string( self ): """Issue #1959860 incompatable change to returning arrays reversed""" width,height = self.width, self.height readback_image1 = glReadPixels(0,0,width,height,GL_RGB, GL_UNSIGNED_BYTE) assert isinstance( readback_image1, str ), type( readback_image1 ) readback_image1 = glReadPixels(0,0,width,height,GL_RGB, GL_BYTE) assert not isinstance( readback_image1, str ), type(readback_image2) if array: def test_glreadpixels_warray( self ): """SF#1311265 allow passing in the array object""" width,height = self.width, self.height data = zeros( (width,height,3), 'B' ) image1 = glReadPixelsub(0,0,width,height,GL_RGB,array=data) def test_mmap_data( self ): """Test that we can use mmap data array If we had a reasonable lib that dumped raw image data to a shared-mem file we might be able to use this for movie display :) """ fh = open( 'mmap-test-data.dat', 'w+' ) fh.write( '\000'*(32*32*3+1)) fh.flush() fh.close() # using numpy.memmap here... data = memmap( 'mmap-test-data.dat' ) for i in range( 0,255,2 ): glDrawPixels( 32,32, GL_RGB, GL_UNSIGNED_BYTE, data, ) glFlush() pygame.display.flip() data[::2] = i time.sleep( 0.001 ) if array: def test_vbo( self ): """Test utility vbo wrapper""" import numpy from OpenGL.arrays import vbo assert vbo.get_implementation() dt = arraydatatype.GLdoubleArray array = numpy.array( [ [0,0,0], [0,1,0], [1,.5,0], [1,0,0], [1.5,.5,0], [1.5,0,0], ], dtype='d') indices = numpy.array( range(len(array)), 'i', ) d = vbo.VBO(array) glDisable( GL_CULL_FACE ) glNormal3f( 0,0,1 ) glColor3f( 1,1,1 ) glEnableClientState(GL_VERTEX_ARRAY) try: for x in range( 1, 255, 10 ): d.bind() try: glVertexPointerd( d ) glDrawElements( GL_LINE_LOOP, len(indices), GL_UNSIGNED_INT, indices ) finally: d.unbind() lastPoint = numpy.array( [[1.5,(1/255.) * float(x),0]] ) d[-2:-1] = lastPoint glFlush() pygame.display.flip() glClear( GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT ) time.sleep( 0.001 ) finally: glDisableClientState( GL_VERTEX_ARRAY ) # bug report from Dan Helfman, delete shouldn't cause # errors if called explicitly d.delete() def test_fbo( self ): """Test that we support framebuffer objects http://www.gamedev.net/reference/articles/article2331.asp """ if not glGenFramebuffersEXT: return False width = height = 128 fbo = glGenFramebuffersEXT(1) glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo) depthbuffer = glGenRenderbuffersEXT(1 ) glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depthbuffer) glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, width, height) glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depthbuffer ) img = glGenTextures(1) glBindTexture(GL_TEXTURE_2D, img) # NOTE: these lines are *key*, without them you'll likely get an unsupported format error, # ie. GL_FRAMEBUFFER_UNSUPPORTED_EXT glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST); glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB8, width, height, 0, GL_RGB, GL_INT, None # no data transferred ) glFramebufferTexture2DEXT( GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, img, 0 # mipmap level, normally 0 ) status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT) assert status == GL_FRAMEBUFFER_COMPLETE_EXT, status glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo) glPushAttrib(GL_VIEWPORT_BIT) # viewport is shared with the main context try: glViewport(0,0,width, height) # rendering to the texture here... glColor3f( 1,0,0 ) glNormal3f( 0,0,1 ) glBegin( GL_QUADS ) for v in [[0,0,0],[0,1,0],[1,1,0],[1,0,0]]: glColor3f( *v ) glVertex3d( *v ) glEnd() finally: glPopAttrib(); # restore viewport glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0) # unbind glBindTexture(GL_TEXTURE_2D, img) glEnable( GL_TEXTURE_2D ) # rendering with the texture here... glColor3f( 1,1,1 ) glNormal3f( 0,0,1 ) glDisable( GL_LIGHTING ) glBegin( GL_QUADS ) try: for v in [[0,0,0],[0,1,0],[1,1,0],[1,0,0]]: glTexCoord2f( *v[:2] ) glVertex3d( *v ) finally: glEnd() def test_gl_1_2_support( self ): if glBlendColor: glBlendColor( .3, .4, 1.0, .3 ) print 'OpenGL 1.2 support' if array: def test_glmultidraw( self ): """Test that glMultiDrawElements works, uses glDrawElements""" if glMultiDrawElements: points = array([ (i,0,0) for i in range( 8 ) ] + [ (i,1,0) for i in range( 8 ) ], 'd') indices = array([ [0,8,9,1, 2,10,11,3,], [4,12,13,5,6,14,15,7], ],'B') counts = [ len(x) for x in indices ] glEnableClientState( GL_VERTEX_ARRAY ) glDisableClientState( GL_COLOR_ARRAY ) glDisableClientState( GL_NORMAL_ARRAY ) try: glVertexPointerd( points ) glDisable( GL_LIGHTING ) try: glMultiDrawElements(GL_QUAD_STRIP, counts, GL_UNSIGNED_BYTE, indices, 2) finally: glEnable( GL_LIGHTING ) finally: glDisableClientState( GL_VERTEX_ARRAY ) else: print 'No multi_draw_arrays support' def test_glDrawBuffers_list( self ): """Test that glDrawBuffers with list argument doesn't crash""" a_type = constants.GLenum*2 args = a_type( GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT, ) try: glDrawBuffers( 2, args ) except GLError, err: assert err.err == GL_INVALID_OPERATION, err def test_glDrawBuffers_list_valid( self ): """Test that glDrawBuffers with list argument where value is set""" previous = glGetIntegerv( GL_READ_BUFFER ) fbo = glGenFramebuffersEXT(1) glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo) try: img1,img2 = glGenTextures(2) for img in img1,img2: glBindTexture( GL_TEXTURE_2D, img ) glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB8, 300, 300, 0, GL_RGB, GL_INT, None # no data transferred ) glFramebufferTexture2DEXT( GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, img1, 0 ) glFramebufferTexture2DEXT( GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT1_EXT, GL_TEXTURE_2D, img2, 0 ) a_type = constants.GLenum*2 drawingBuffers = a_type( GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT, ) glDrawBuffers(2, drawingBuffers ) glReadBuffer( GL_COLOR_ATTACHMENT1_EXT ) pixels = glReadPixels( 0,0, 10,10, GL_RGB, GL_UNSIGNED_BYTE ) assert len(pixels) == 300, len(pixels) finally: glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, 0 ) glReadBuffer( previous ) def test_enable_histogram( self ): if glInitImagingARB(): glHistogram(GL_HISTOGRAM, 256, GL_LUMINANCE, GL_FALSE) glEnable( GL_HISTOGRAM ) glDisable( GL_HISTOGRAM ) else: print 'No ARB imaging extension' if not OpenGL.ERROR_ON_COPY: def test_gluNurbsCurve( self ): """Test that gluNurbsCurve raises error on invalid arguments""" nurb = gluNewNurbsRenderer() gluBeginCurve( nurb ) self.failUnlessRaises( error.GLUerror, gluNurbsCurve, nurb, [0, 1.0], [[0,0,0],[1,0,0],[1,1,0]], GL_MAP1_VERTEX_3, ) self.failUnlessRaises( error.GLUerror, gluNurbsCurve, nurb, [], [[0,0,0],[1,0,0],[1,1,0]], GL_MAP1_VERTEX_3, ) self.failUnlessRaises( error.GLUerror, gluNurbsCurve, nurb, [], [], GL_MAP1_VERTEX_3, ) def test_get_version( self ): from OpenGL.extensions import getGLVersion version = getGLVersion() if version >= [2,0]: assert glShaderSource assert glUniform1f else: assert not glShaderSource assert not glUniform1f def test_tess_collection( self ): """SF#2354596 tessellation combine results collected""" def tessvertex(vertex_data, polygon_data): polygon_data.append(vertex_data) def tesscombine(coords, vertex_data, weight): return (True,coords) # generated vertices marked as True def tessedge(flag): pass # dummy collected=[] # collect triangle vertices # set up tessellator in CSG intersection mode tess=gluNewTess() gluTessProperty(tess, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_ABS_GEQ_TWO) gluTessCallback(tess, GLU_TESS_VERTEX_DATA, tessvertex) gluTessCallback(tess, GLU_TESS_COMBINE, tesscombine) gluTessCallback(tess, GLU_TESS_EDGE_FLAG, tessedge) # no strips gluTessBeginPolygon(tess, collected) # First square gluTessBeginContour(tess) gluTessVertex(tess, [-1,0,-1], (False,[-1,0,-1])) gluTessVertex(tess, [ 1,0,-1], (False,[ 1,0,-1])) gluTessVertex(tess, [ 1,0, 1], (False,[ 1,0, 1])) gluTessVertex(tess, [-1,0, 1], (False,[-1,0, 1])) gluTessEndContour(tess) # Second square, intersects with first gluTessBeginContour(tess) gluTessVertex(tess, [0.5,0,-0.5], (False,[0.5,0,-0.5])) gluTessVertex(tess, [1.5,0,-0.5], (False,[1.5,0,-0.5])) gluTessVertex(tess, [1.5,0, 0.5], (False,[1.5,0, 0.5])) gluTessVertex(tess, [0.5,0, 0.5], (False,[0.5,0, 0.5])) gluTessEndContour(tess) gluTessEndPolygon(tess) # Show collected triangle vertices :- # Original input vertices are marked as False. # Vertices generated in combine callback are marked as True. assert collected def test_get_boolean_bitmap( self ): # should not raise error value = glGetBoolean(GL_TEXTURE_2D) if array: def test_draw_bitmap_pixels( self ): """SF#2152623 Drawing pixels as bitmaps (bits)""" pixels = array([0,0,0,0,0,0,0,0],'B') glDrawPixels( 8,8, GL_COLOR_INDEX, GL_BITMAP, pixels ) def test_glCallLists_twice2( self ): """SF#2829309 report that glCallLists doubles operation""" glRenderMode (GL_RENDER) glMatrixMode(GL_PROJECTION) glLoadIdentity() gluPerspective(40.0, 1.0, 1.0, 10.0) glMatrixMode (GL_MODELVIEW) glLoadIdentity () glTranslatef (0, 0, -3) first = glGenLists( 2 ) second = first+1 glNewList(first, GL_COMPILE_AND_EXECUTE) glInitNames () glCallLists([second]) # replace with gCallList(2) #glCallList(second) glEndList () glNewList(second, GL_COMPILE) glPushName (1) glBegin (GL_POINTS) glVertex3f (0, 0, 0) glEnd () glEndList () glCallList( second ) glPopName() depth = glGetIntegerv( GL_NAME_STACK_DEPTH ) assert depth == (0,), depth # have popped, but even then, were' not in the mode... glSelectBuffer (100) glRenderMode (GL_SELECT) glCallList(1) depth = glGetIntegerv( GL_NAME_STACK_DEPTH ) assert depth == (1,), depth # should have a single record glPopName() records = glRenderMode (GL_RENDER) # reporter says sees two records, Linux sees none, Win32 sees 1 :( assert len(records) == 1, records def test_get_max_tex_units( self ): """SF#2895081 glGetIntegerv( GL_MAX_TEXTURE_IMAGE_UNITS )""" units = glGetIntegerv( GL_MAX_TEXTURE_IMAGE_UNITS ) if __name__ == "__main__": unittest.main() pygame.display.quit() pygame.quit()