def screen_to_model(c): """ Returns the 3D coordinate of given screen coordinate :param c: The screen coordinates for example :type c: 3-tuple of float (x,y,0) :rtype: 3-tuple float (x,y,z) """ m = (c_double*16)() glGetDoublev(GL_MODELVIEW_MATRIX, m) p = (c_double*16)() glGetDoublev(GL_PROJECTION_MATRIX, p) v = (c_int*4)() glGetIntegerv(GL_VIEWPORT, v) x, y, z = c_double(), c_double(), c_double() y.value = v[3] - y.value gluUnProject(c[0], c[1], c[2], m, p, v, x, y, z) return x, y, z
def select_object(x, y, objects=None): from miru.context import context if objects is None: objects = context.camera.objects # following technique is adapted from # http://www.cse.msu.edu/~cse872/tutorial9.html w = context.window.width h = context.window.height select_buffer = ctypes.cast((100 * gl.GLuint)(), ctypes.POINTER(gl.GLuint)) gl.glSelectBuffer(100, select_buffer) viewport = (4 * gl.GLint)() gl.glGetIntegerv(gl.GL_VIEWPORT, viewport) gl.glMatrixMode(gl.GL_PROJECTION) gl.glLoadIdentity() # rotate the camera first angle = context.camera.angle gl.glRotatef(angle.z, 0, 0, 1) gl.glRotatef(angle.y, 0, 1, 0) gl.glRotatef(angle.x, 1, 0, 0) gl.gluPickMatrix(x, y, 3, 3, viewport) gl.glRenderMode(gl.GL_SELECT) gl.gluPerspective(45., w / float(h), 0.1, 1000.) gl.glMatrixMode(gl.GL_MODELVIEW) gl.glInitNames() gl.glPushName(-1) context.camera.render(select_pass=1, visible=objects) gl.glFlush() hits = gl.glRenderMode(gl.GL_RENDER) gl.glPopName() selected = None if hits: try: m = sys.maxint << 100 idx = 0 for i in range(0, 100, 4): if not select_buffer[i]: selected = objects[idx] break m = min(select_buffer[i+1], m) if m == select_buffer[i+1]: idx = select_buffer[i+3] except IndexError: pass context.window.on_resize(context.window.width, context.window.height) return selected
def texture_from_data(internalformat, size, data_format, data_type, data): '''Create texture from a data buffer (whatever can be passed as pointer to ctypes) internalformat - GL_RGBA8 or GL_RGB8 recommended size - a 1-, 2- or 3-tuple describing the image sizes data_format - see 'format' parameter of glDrawPixels data_type - see 'type' parameter of glDrawPixels data - pointer to memory''' size = list(size) dimensions = len(size) binding = getattr(gl, 'GL_TEXTURE_BINDING_{0:d}D'.format(dimensions)) target = getattr(gl,'GL_TEXTURE_{0:d}D'.format(dimensions)) texImage = getattr(gl,'glTexImage{0:d}D'.format(dimensions)) oldbind = ctypes.c_uint(0) gl.glGetIntegerv(binding, ctypes.cast(ctypes.byref(oldbind), ctypes.POINTER(ctypes.c_int))) texid = ctypes.c_uint(0) gl.glEnable(target) gl.glGenTextures(1, ctypes.byref(texid)) gl.glBindTexture(target, texid) gl.glTexParameteri(target, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR) gl.glTexParameteri(target, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR) args = [target, 0, internalformat] + size + [0, data_format, data_type, data] texImage(*args) gl.glBindTexture(target, oldbind) return texid
def get_viewport(): """ Returns the current viewport. """ m = (c_int*4)() pgl.glGetIntegerv(pgl.GL_VIEWPORT, m) return m
def set_state(self): # preserve gl scissors info self._scissor_enabled = gl.glIsEnabled(gl.GL_SCISSOR_TEST) self._old_scissor_flat = (gl.GLint * 4)() # 4-tuple gl.glGetIntegerv(gl.GL_SCISSOR_BOX, self._old_scissor_flat) # set our scissor if not self._scissor_enabled: gl.glEnable(gl.GL_SCISSOR_TEST) gl.glScissor(*self._scissor_flat)
def bind(self): """Bind the FBO. Anything drawn afterward will be stored in the FBO's texture.""" # This is called simply to deal with anything that might be currently bound (for example, Pyglet objects), gl.glBindTexture(gl.GL_TEXTURE_2D, 0) # Store current viewport size for later gl.glGetIntegerv(gl.GL_VIEWPORT, self._old_viewport_size) # Bind the FBO, and change the viewport to fit its texture. gl.glBindFramebufferEXT(gl.GL_FRAMEBUFFER_EXT, self.id) # Rendering off-screen gl.glViewport(0, 0, self.texture.width, self.texture.height)
def __max_vertex_attribute(): """__max_vertex_attribute() -> int Maximal valid value for vertex attribute identifiers. """ buffy = (1 * gl.GLint)() gl.glGetIntegerv( gl.GL_MAX_VERTEX_ATTRIBS, buffy) return buffy[0]
def __enter__(self): from utils import Rect from pyglet.gl import GLint, glGetIntegerv, GL_SCISSOR_BOX, glScissor ob = (GLint*4)() glGetIntegerv(GL_SCISSOR_BOX, ob) ob = list(ob) box = [int(i) for i in self.box] nb = Rect(*ob).intersect(Rect(*box)) if nb: glScissor(nb.x, nb.y, nb.width, nb.height) self.ob, self.nb = ob, nb return self
def _setOpenGLInfo(self): # OpenGL info: self['openGLVendor'] = gl_info.get_vendor() self['openGLRenderingEngine'] = gl_info.get_renderer() self['openGLVersion'] = gl_info.get_version() GLextensionsOfInterest = ['GL_ARB_multitexture', 'GL_EXT_framebuffer_object', 'GL_ARB_fragment_program', 'GL_ARB_shader_objects', 'GL_ARB_vertex_shader', 'GL_ARB_texture_non_power_of_two', 'GL_ARB_texture_float', 'GL_STEREO'] for ext in GLextensionsOfInterest: self['openGLext.'+ext] = bool(gl_info.have_extension(ext)) maxVerts = GLint() glGetIntegerv(GL_MAX_ELEMENTS_VERTICES, maxVerts) self['openGLmaxVerticesInVertexArray'] = maxVerts.value
def mouse_to_ray(self, x, y, local_transform = False): x = float(x) y = self.height - float(y) pmat = (GLdouble * 16)() mvmat = (GLdouble * 16)() viewport = (GLint * 4)() px = (GLdouble)() py = (GLdouble)() pz = (GLdouble)() glGetIntegerv(GL_VIEWPORT, viewport) glGetDoublev(GL_PROJECTION_MATRIX, pmat) mvmat = self.get_modelview_mat(local_transform) gluUnProject(x, y, 1, mvmat, pmat, viewport, px, py, pz) ray_far = (px.value, py.value, pz.value) gluUnProject(x, y, 0., mvmat, pmat, viewport, px, py, pz) ray_near = (px.value, py.value, pz.value) return ray_near, ray_far
def mouse_to_3d(self, x, y, z=1.0, local_transform=False): x = float(x) y = self.height - float(y) # The following could work if we were not initially scaling to zoom on # the bed # if self.orthographic: # return (x - self.width / 2, y - self.height / 2, 0) pmat = (GLdouble * 16)() mvmat = self.get_modelview_mat(local_transform) viewport = (GLint * 4)() px = (GLdouble)() py = (GLdouble)() pz = (GLdouble)() glGetIntegerv(GL_VIEWPORT, viewport) glGetDoublev(GL_PROJECTION_MATRIX, pmat) glGetDoublev(GL_MODELVIEW_MATRIX, mvmat) gluUnProject(x, y, z, mvmat, pmat, viewport, px, py, pz) return (px.value, py.value, pz.value)
def mouse_to_3d(self, x, y, z = 1.0, local_transform = False): x = float(x) y = self.height - float(y) # The following could work if we were not initially scaling to zoom on # the bed # if self.orthographic: # return (x - self.width / 2, y - self.height / 2, 0) pmat = (GLdouble * 16)() mvmat = self.get_modelview_mat(local_transform) viewport = (GLint * 4)() px = (GLdouble)() py = (GLdouble)() pz = (GLdouble)() glGetIntegerv(GL_VIEWPORT, viewport) glGetDoublev(GL_PROJECTION_MATRIX, pmat) glGetDoublev(GL_MODELVIEW_MATRIX, mvmat) gluUnProject(x, y, z, mvmat, pmat, viewport, px, py, pz) return (px.value, py.value, pz.value)
def _setOpenGLInfo(self): # OpenGL info: self['openGLVendor'] = gl_info.get_vendor() self['openGLRenderingEngine'] = gl_info.get_renderer() self['openGLVersion'] = gl_info.get_version() GLextensionsOfInterest = [ 'GL_ARB_multitexture', 'GL_EXT_framebuffer_object', 'GL_ARB_fragment_program', 'GL_ARB_shader_objects', 'GL_ARB_vertex_shader', 'GL_ARB_texture_non_power_of_two', 'GL_ARB_texture_float', 'GL_STEREO' ] for ext in GLextensionsOfInterest: self['openGLext.' + ext] = bool(gl_info.have_extension(ext)) maxVerts = GLint() glGetIntegerv(GL_MAX_ELEMENTS_VERTICES, maxVerts) self['openGLmaxVerticesInVertexArray'] = maxVerts.value
def send(self): """ Sends all the key-value pairs to the graphics card. These uniform variables will be available in the currently-bound shader. """ for name, array in iteritems(self): shader_id = c_int(0) gl.glGetIntegerv(gl.GL_CURRENT_PROGRAM, byref(shader_id)) if shader_id.value == 0: raise UnboundLocalError( """Shader not bound to OpenGL context--uniform cannot be sent. ------------ Tip ------------- with ratcave.default_shader: mesh.draw() ------------------------------ """) # Attach a shader location value to the array, for quick memory lookup. (gl calls are expensive, for some reason) try: loc, shader_id_for_array = array.loc if shader_id.value != shader_id_for_array: raise Exception( 'Uniform location bound to a different shader') except (AttributeError, Exception) as e: array.loc = (gl.glGetUniformLocation(shader_id.value, name.encode('ascii')), shader_id.value) if array.ndim == 2: # Assuming a 4x4 float32 matrix (common for graphics operations) try: pointer = array.pointer except AttributeError: array.pointer = array.ctypes.data_as(POINTER(c_float * 16)).contents pointer = array.pointer gl.glUniformMatrix4fv(array.loc[0], 1, True, pointer) else: sendfun = self._sendfuns[array.dtype.kind][ len(array) - 1] # Find correct glUniform function sendfun(array.loc[0], *array)
def texture_sub_data(texid, place, size, data_format, data_type, data): '''Upload data to part of a texture texid - texture id place - point within the texture (tuple), coordinates of the lower-left image corner (as per OpenGL) See the documentation for texture_from_data for the other args''' dimensions = len(size) size = list(size) place = list(place) binding = getattr(gl, 'GL_TEXTURE_BINDING_{0:d}D'.format(dimensions)) target = getattr(gl,'GL_TEXTURE_{0:d}D'.format(dimensions)) texSubImage = getattr(gl,'glTexSubImage{0:d}D'.format(dimensions)) oldbind = ctypes.c_uint(0) gl.glEnable(target) gl.glGetIntegerv(binding, ctypes.cast(ctypes.byref(oldbind), ctypes.POINTER(ctypes.c_int))) gl.glBindTexture(target, texid) args = [target, 0] + place + size + [data_format, data_type, data] texSubImage(*args) gl.glBindTexture(target, oldbind)
def load_vertex_program(filename): vertex_program = gl.GLuint() gl.glGenProgramsNV( 1, ctypes.byref(vertex_program) ) gl.glBindProgramNV( gl.GL_VERTEX_PROGRAM_NV, vertex_program ) #LoadNV_vertex_program("normalmap00.txt", vertex_program) data = file(filename).read() data = (ctypes.c_ubyte * len(data))( *[ord(c) for c in data]) gl.glLoadProgramNV( gl.GL_VERTEX_PROGRAM_NV, vertex_program, len(data), data) error_pos = gl.GLint() gl.glGetIntegerv( gl.GL_PROGRAM_ERROR_POSITION_NV, ctypes.byref(error_pos)) if (error_pos.value != -1): raise NVLoadException, 'Something bad happened' return vertex_program
def _worldobj_on_translate(control, target, x, y, dx, dy): from miru.context import context from miru import camera self = control if isinstance(context.camera, camera.MetaCamera): context.camera.focussed.render() viewport = (gl.GLint * 4)() mvmatrix = (gl.GLdouble * 16)() projmatrix = (gl.GLdouble * 16)() gl.glGetIntegerv(gl.GL_VIEWPORT, viewport) gl.glGetDoublev(gl.GL_MODELVIEW_MATRIX, mvmatrix) gl.glGetDoublev(gl.GL_PROJECTION_MATRIX, projmatrix) wx = gl.GLdouble() wy = gl.GLdouble() wz = gl.GLdouble() sz = gl.GLdouble() ex = target.pos.x ey = target.pos.y ez = target.pos.z gl.gluProject(ex, ey, ez, mvmatrix, projmatrix, viewport, wx, wy, sz) gl.gluUnProject(x, y, sz, mvmatrix, projmatrix, viewport, wx, wy, wz) if self.axis == self.AXIS_X: target.pos = (wx.value, wz.value, target.pos.z) elif self.axis == self.AXIS_Y: target.pos = (target.pos.x, wy.value, wz.value) elif self.axis == self.AXIS_Z: tz = dy * 0.01 tz += (dx * 0.01) target.pos += (0, 0, tz) else: target.pos = (wx.value, wy.value, wz.value)
def refresh_font_texture(self): # save texture state last_texture = gl.GLint() gl.glGetIntegerv(gl.GL_TEXTURE_BINDING_2D, byref(last_texture)) width, height, pixels = self.io.fonts.get_tex_data_as_rgba32() if self._font_texture is not None: gl.glDeleteTextures(1, self._font_texture) self._font_texture = gl.GLuint() gl.glGenTextures(1, byref(self._font_texture)) gl.glBindTexture(gl.GL_TEXTURE_2D, self._font_texture) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR) gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA, width, height, 0, gl.GL_RGBA, gl.GL_UNSIGNED_BYTE, pixels) self.io.fonts.texture_id = self._font_texture gl.glBindTexture(gl.GL_TEXTURE_2D, cast((c_int*1)(last_texture), POINTER(c_uint)).contents) self.io.fonts.clear_tex_data()
def _create_device_objects(self): # save state last_texture = gl.GLint() gl.glGetIntegerv(gl.GL_TEXTURE_BINDING_2D, byref(last_texture)) last_array_buffer = gl.GLint() gl.glGetIntegerv(gl.GL_ARRAY_BUFFER_BINDING, byref(last_array_buffer)) last_vertex_array = gl.GLint() gl.glGetIntegerv(gl.GL_VERTEX_ARRAY_BINDING, byref(last_vertex_array)) self._shader_handle = gl.glCreateProgram() # note: no need to store shader parts handles after linking vertex_shader = gl.glCreateShader(gl.GL_VERTEX_SHADER) fragment_shader = gl.glCreateShader(gl.GL_FRAGMENT_SHADER) gl.glShaderSource(vertex_shader, 1, make_string_buffer(self.VERTEX_SHADER_SRC), None) gl.glShaderSource(fragment_shader, 1, make_string_buffer(self.FRAGMENT_SHADER_SRC), None) gl.glCompileShader(vertex_shader) gl.glCompileShader(fragment_shader) gl.glAttachShader(self._shader_handle, vertex_shader) gl.glAttachShader(self._shader_handle, fragment_shader) gl.glLinkProgram(self._shader_handle) # note: after linking shaders can be removed gl.glDeleteShader(vertex_shader) gl.glDeleteShader(fragment_shader) self._attrib_location_tex = gl.glGetUniformLocation(self._shader_handle, create_string_buffer(b"Texture")) self._attrib_proj_mtx = gl.glGetUniformLocation(self._shader_handle, create_string_buffer(b"ProjMtx")) self._attrib_location_position = gl.glGetAttribLocation(self._shader_handle, create_string_buffer(b"Position")) self._attrib_location_uv = gl.glGetAttribLocation(self._shader_handle, create_string_buffer(b"UV")) self._attrib_location_color = gl.glGetAttribLocation(self._shader_handle, create_string_buffer(b"Color")) self._vbo_handle = gl.GLuint() gl.glGenBuffers(1, byref(self._vbo_handle)) self._elements_handle = gl.GLuint() gl.glGenBuffers(1, byref(self._elements_handle)) self._vao_handle = gl.GLuint() gl.glGenVertexArrays(1, byref(self._vao_handle)) gl.glBindVertexArray(self._vao_handle) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self._vbo_handle) gl.glEnableVertexAttribArray(self._attrib_location_position) gl.glEnableVertexAttribArray(self._attrib_location_uv) gl.glEnableVertexAttribArray(self._attrib_location_color) gl.glVertexAttribPointer(self._attrib_location_position, 2, gl.GL_FLOAT, gl.GL_FALSE, imgui.VERTEX_SIZE, c_void_p(imgui.VERTEX_BUFFER_POS_OFFSET)) gl.glVertexAttribPointer(self._attrib_location_uv, 2, gl.GL_FLOAT, gl.GL_FALSE, imgui.VERTEX_SIZE, c_void_p(imgui.VERTEX_BUFFER_UV_OFFSET)) gl.glVertexAttribPointer(self._attrib_location_color, 4, gl.GL_UNSIGNED_BYTE, gl.GL_TRUE, imgui.VERTEX_SIZE, c_void_p(imgui.VERTEX_BUFFER_COL_OFFSET)) # restore state gl.glBindTexture(gl.GL_TEXTURE_2D, cast((c_int*1)(last_texture), POINTER(c_uint)).contents) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, cast((c_int*1)(last_array_buffer), POINTER(c_uint)).contents) gl.glBindVertexArray(cast((c_int*1)(last_vertex_array), POINTER(c_uint)).contents)
def _set_view(self): left = int(self._pixel_per_point[0] * self.rect.left) bottom = int(self._pixel_per_point[1] * self.rect.bottom) width = int(self._pixel_per_point[0] * self.rect.width) height = int(self._pixel_per_point[1] * self.rect.height) gl.glPushAttrib(gl.GL_ENABLE_BIT) gl.glEnable(gl.GL_SCISSOR_TEST) gl.glScissor(left, bottom, width, height) self._mode = (gl.GLint)() gl.glGetIntegerv(gl.GL_MATRIX_MODE, self._mode) self._viewport = (gl.GLint * 4)() gl.glGetIntegerv(gl.GL_VIEWPORT, self._viewport) gl.glViewport(left, bottom, width, height) gl.glMatrixMode(gl.GL_PROJECTION) gl.glPushMatrix() gl.glLoadIdentity() near = 0.01 far = 1000. gl.gluPerspective(self.scene.camera.fov[1], width / height, near, far) gl.glMatrixMode(gl.GL_MODELVIEW)
def model_to_screen(c): """ Returns the screen point of given 3D coordinate :param c: The 3D coordinates :type c: 3-tuple of float (x,y,z) :rtype: 3-tuple float (x,y,z) """ m = (c_double*16)() glGetDoublev(GL_MODELVIEW_MATRIX, m) p = (c_double*16)() glGetDoublev(GL_PROJECTION_MATRIX, p) v = (c_int*4)() glGetIntegerv(GL_VIEWPORT, v) x, y, z = c_double(), c_double(), c_double() gluProject(c[0], c[1], c[2], m, p, v, x, y, z) return x, y, z
def _set_view(self): left = int(self._pixel_per_point[0] * self.rect.left) bottom = int(self._pixel_per_point[1] * self.rect.bottom) width = int(self._pixel_per_point[0] * self.rect.width) height = int(self._pixel_per_point[1] * self.rect.height) gl.glPushAttrib(gl.GL_ENABLE_BIT) gl.glEnable(gl.GL_SCISSOR_TEST) gl.glScissor(left, bottom, width, height) self._mode = (gl.GLint)() gl.glGetIntegerv(gl.GL_MATRIX_MODE, self._mode) self._viewport = (gl.GLint * 4)() gl.glGetIntegerv(gl.GL_VIEWPORT, self._viewport) gl.glViewport(left, bottom, width, height) gl.glMatrixMode(gl.GL_PROJECTION) gl.glPushMatrix() gl.glLoadIdentity() near = 0.01 far = 1000. gl.gluPerspective(self.scene.camera.fov[1], width / height, near, far) gl.glMatrixMode(gl.GL_MODELVIEW)
def reset_aspect(self): """Gets the viewport size, and matches the camera aspect ratio to it.""" viewport_size = (gl.GLint * 4)() gl.glGetIntegerv(gl.GL_VIEWPORT, viewport_size) self.aspect = float(viewport_size[2]) / viewport_size[3]
def reset_aspect(self): """Gets the viewport size, and matches the camera aspect ratio to it.""" viewport_size = (gl.GLint * 4)() gl.glGetIntegerv(gl.GL_VIEWPORT, viewport_size) self.aspect = float(viewport_size[2]) / viewport_size[3]
def generate_map(self): scene_radius = 95.0 light_to_scene_distance = math.sqrt( light_pos[0]**2 + light_pos[1]**2 + light_pos[2]**2) near_plane = light_to_scene_distance - scene_radius field_of_view = math3d.radians_to_degrees(2.0 * math.atan(scene_radius / float(light_to_scene_distance))) tmp = (gl.GLfloat * 16)() gl.glMatrixMode( gl.GL_PROJECTION ) gl.glLoadIdentity() gl.gluPerspective( field_of_view, 1.0, near_plane, near_plane + (2.0 * scene_radius) ) gl.glGetFloatv( gl.GL_PROJECTION_MATRIX, tmp ) gl.light_projection = euclid.Matrix4() gl.light_projection[0:16] = tmp[:] # Switch to light's point of view gl.glMatrixMode( gl.GL_MODELVIEW ) gl.glLoadIdentity() gl.gluLookAt( self.light.pos.x, self.light.pos.y, self.light.pos.z, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0 ) gl.glGetFloatv( gl.GL_MODELVIEW_MATRIX, tmp ) light_mview = euclid.Matrix4() light_mview[0:16] = tmp[:] #glViewport(0, 0, shadow_width, shadow_height) # Clear the depth buffer only gl.glClear( gl.GL_DEPTH_BUFFER_BIT ) # Remember the current shade model gl.glPushAttrib( gl.GL_ENABLE_BIT ) prev_shade_model = cypes.GLint() gl.glGetIntegerv( gl.GL_SHADE_MODEL, prev_shade_model ) # All we care about here is resulting depth values gl.glShadeModel( gl.GL_FLAT ) gl.glDisable( gl.GL_LIGHTING ) gl.glDisable( gl.GL_COLOR_MATERIAL ) gl.glDisable( gl.GL_NORMALIZE ) gl.glColorMask( 0, 0, 0, 0 ) # Overcome imprecision gl.glEnable( gl.GL_POLYGON_OFFSET_FILL ) #draw_models(False) self.context.render( exclude=self.exclude_shadows ) # Copy depth values into depth texture gl.glCopyTexImage2D( gl.GL_TEXTURE_2D, 0, gl.GL_DEPTH_COMPONENT, 0, 0, shadow_width, shadow_height, 0 ) # Restore normal drawing state gl.glShadeModel( gl.GL_SMOOTH ) gl.glEnable( gl.GL_LIGHTING ) gl.glEnable( gl.GL_COLOR_MATERIAL ) gl.glEnable( gl.GL_NORMALIZE ) gl.glColorMask( 1, 1, 1, 1 ) gl.glDisable( gl.GL_POLYGON_OFFSET_FILL ) # Setup up the texture matrix which will be use in eye-linear # texture mapping self.tex_matrix = euclid.Matrix4() self.tex_matrix.translate(0.5, 0.5, 0.5).scale(0.5, 0.5, 0.5) tmp_matrix.scale(0.5, 0.5, 0.5) tex_matrix = (tmp_matrix * light_projection) * light_mview self.tex_matrix.transpose() # Give us immediate access to ctypes arrays self.tex_matrix = ( (gl.GLfloat * 4)(*self.tex_matrix[0:4]), (gl.GLfloat * 4)(*self.tex_matrix[4:8]), (gl.GLfloat * 4)(*self.tex_matrix[8:12]), (gl.GLfloat * 4)(*self.tex_matrix[12:16]) )
def getInfoText(self): """Get system information text.""" outputText = "" # text to return # show the PsychoPy version from psychopy import __version__ outputText += self.getLine("PsychoPy", __version__) # get system paths outputText += self.getLine("\nPaths to files on the system:") for key in ['userPrefsFile', 'appDataFile', 'demos', 'appFile']: outputText += self.getLine( " %s: %s" % (key, preferences.prefs.paths[key])) # system information such as OS, CPU and memory outputText += self.getLine("\nSystem Info:") outputText += self.getLine( ' '*4, 'Operating System: {}'.format(platform.platform())) outputText += self.getLine( ' ' * 4, 'Processor: {}'.format(platform.processor())) # requires psutil try: import psutil outputText += self.getLine( ' ' * 4, 'CPU freq (MHz): {}'.format(psutil.cpu_freq().max)) outputText += self.getLine( ' ' * 4, 'CPU cores: {} (physical), {} (logical)'.format( psutil.cpu_count(False), psutil.cpu_count())) outputText += self.getLine( ' ' * 4, 'Installed memory: {} (Total), {} (Available)'.format( *psutil.virtual_memory())) except ImportError: outputText += self.getLine(' ' * 4, 'CPU freq (MHz): N/A') outputText += self.getLine( ' ' * 4, 'CPU cores: {} (logical)'.format(os.cpu_count())) outputText += self.getLine(' ' * 4, 'Installed memory: N/A') # if on MacOS if sys.platform == 'darwin': OSXver, junk, architecture = platform.mac_ver() outputText += self.getLine( ' ' * 4, "macOS %s running on %s" % (OSXver, architecture)) # Python information outputText += self.getLine("\nPython info:") outputText += self.getLine(' '*4, 'Executable path:', sys.executable) outputText += self.getLine(' '*4, 'Version:', sys.version) outputText += self.getLine(' ' * 4, '(Selected) Installed Packages:') import numpy outputText += self.getLine(' '*8, "numpy ({})".format( numpy.__version__)) import scipy outputText += self.getLine(' '*8, "scipy ({})".format( scipy.__version__)) import matplotlib outputText += self.getLine(' '*8, "matplotlib ({})".format( matplotlib.__version__)) import pyglet outputText += self.getLine(' '*8, "pyglet ({})".format(pyglet.version)) try: import glfw outputText += self.getLine(' '*8, "PyGLFW ({})".format( glfw.__version__)) except Exception: outputText += self.getLine(' '*8, 'PyGLFW [not installed]') # sound related try: import pyo outputText += self.getLine( ' '*8, "pyo", ('%i.%i.%i' % pyo.getVersion())) except Exception: outputText += self.getLine(' '*8, 'pyo [not installed]') try: import psychtoolbox outputText += self.getLine(' '*8, "psychtoolbox ({})".format( psychtoolbox._version.__version__)) except Exception: outputText += self.getLine(' '*8, 'psychtoolbox [not installed]') # wxpython version try: import wx outputText += self.getLine(' '*8, "wxPython ({})".format( wx.__version__)) except Exception: outputText += self.getLine(' '*8, 'wxPython [not installed]') # get OpenGL details win = visual.Window([100, 100]) # some drivers want a window open first outputText += self.getLine("\nOpenGL Info:") # # get info about the graphics card and drivers outputText += self.getLine( ' '*4, "Vendor:", gl_info.get_vendor()) outputText += self.getLine( ' '*4, "Rendering engine:", gl_info.get_renderer()) outputText += self.getLine( ' '*4, "OpenGL version:", gl_info.get_version()) outputText += self.getLine( ' '*4, "Shaders supported: ", win._haveShaders) # get opengl extensions outputText += self.getLine(' '*4, "(Selected) Extensions:") extensionsOfInterest = [ 'GL_ARB_multitexture', 'GL_EXT_framebuffer_object', 'GL_ARB_fragment_program', 'GL_ARB_shader_objects', 'GL_ARB_vertex_shader', 'GL_ARB_texture_non_power_of_two', 'GL_ARB_texture_float', 'GL_STEREO'] for ext in extensionsOfInterest: outputText += self.getLine( ' '*8, ext + ':', bool(gl_info.have_extension(ext))) # also determine nVertices that can be used in vertex arrays maxVerts = GLint() glGetIntegerv(GL_MAX_ELEMENTS_VERTICES, maxVerts) outputText += self.getLine( ' '*4, 'max vertices in vertex array:', maxVerts.value) win.close() return outputText
def get_max_texture_size(): max_texture_size = gl.GLint() gl.glGetIntegerv(gl.GL_MAX_TEXTURE_SIZE, byref(max_texture_size)) return max_texture_size.value
def get_viewport(): data = (pyglet_gl.GLint * 4)() pyglet_gl.glGetIntegerv(pyglet_gl.GL_VIEWPORT, data) return Viewport(*data)
import sys import os from pyglet.gl import GLint, glGetIntegerv, GL_MAX_TEXTURE_SIZE from ctypes import byref buf = GLint() glGetIntegerv(GL_MAX_TEXTURE_SIZE, byref(buf)) max_texture = buf.value del byref, GLint, glGetIntegerv, GL_MAX_TEXTURE_SIZE, buf def resize(width, height, target): factor = (target + .0) / max(width, height) return int(width * factor), int(height * factor) def fits(width, height): return width < max_texture and height < max_texture def make_name(image, suffix): name, ext = os.path.splitext(image) return '%s_%s%s' % (name, suffix, ext) try: import pgmagick def get_image(image): return pgmagick.Image(image) def get_size(image): size = image.size()
def __enter__(self): if self.entrycount == 0: gl.glGetIntegerv(gl.GL_ARRAY_BUFFER_BINDING, ctypes.cast(byref(self.previd), c_intp)) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.bufid) self.entrycount += 1
def get_max_color_attachments(): """Get the maximum allow Framebuffer Color attachements""" number = gl.GLint() gl.glGetIntegerv(gl.GL_MAX_COLOR_ATTACHMENTS, number) return number.value
__all__ = ['HardwareSupportError', 'GLSLError', 'MAX_COLOR_ATTACHMENTS', 'require_extension', 'hardware_info'] from pyglet import gl import pyglet.gl.gl_info as gli import ctypes MAX_COLOR_ATTACHMENTS = gl.GLint() gl.glGetIntegerv(gl.GL_MAX_COLOR_ATTACHMENTS, ctypes.byref(MAX_COLOR_ATTACHMENTS)) MAX_COLOR_ATTACHMENTS = MAX_COLOR_ATTACHMENTS.value class HardwareSupportError(Exception): def __init__(self, message): self.message = "Your graphics hardware does not support %s." % \ message def __str__(self): return self.message class DriverError(Exception): pass class GLSLError(Exception): pass def require_extension(ext): """Ensure that the given graphics extension is supported. """ if not gl.gl_info.have_extension('GL_' + ext):
def __enter__(self): self.current_fbo = (gl.GLint)() gl.glGetIntegerv(gl.GL_FRAMEBUFFER_BINDING, self.current_fbo) gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.fbo) gl.glViewport(0, 0, self.texture.width, self.texture.height)
def max_texture_limit(self): """The maximum number of textures available for this graphic card's fragment shader.""" max_unit_array = (gl.GLint * 1)() gl.glGetIntegerv(gl.GL_MAX_TEXTURE_IMAGE_UNITS, max_unit_array) return max_unit_array[0]
def getSysInfo(win): try: from collections import OrderedDict except: from psychopy.iohub import OrderedDict # based on sysInfo.py from pyglet.gl import gl_info, GLint, glGetIntegerv, GL_MAX_ELEMENTS_VERTICES import sys, platform sys_info = OrderedDict() sys_info["OS"] = OrderedDict() sys_info["OS"]["Name"] = platform.platform() if sys.platform == "darwin": OSXver, _, architecture = platform.mac_ver() sys_info["OS"]["OSX Version"] = OSXver sys_info["OS"]["OSX Architecture"] = architecture sys_info["Computer Hardware"] = OrderedDict() try: import psutil def getMemoryInfo(): rdict = dict() nt = psutil.virtual_memory() for name in nt._fields: value = getattr(nt, name) if name != "percent": value = bytes2human(value) rdict[name.capitalize()] = value #'%s%s%-10s : %7s\n'%(rstr,'\t'*indent,name.capitalize(), value) return rdict core_count = psutil.cpu_count(logical=False) logical_psu_count = psutil.cpu_count() memory_info = getMemoryInfo() sys_info["Computer Hardware"]["CPUs (cores / logical)"] = (core_count, logical_psu_count) sys_info["Computer Hardware"]["System Memory"] = memory_info except: sys_info["Computer Hardware"]["Failed"] = "psutil 2.x + is required." sys_info["Python"] = OrderedDict() sys_info["Python"]["exe"] = sys.executable sys_info["Python"]["version"] = sys.version sys_info["Packages"] = OrderedDict() try: import numpy sys_info["Packages"]["numpy"] = numpy.__version__ except: sys_info["Packages"]["numpy"] = "Not Installed" try: import pyglet sys_info["Packages"]["pyglet"] = pyglet.version except: sys_info["Packages"]["pyglet"] = "Not Installed" try: import cv2 sys_info["Packages"]["cv2"] = cv2.__version__ except: sys_info["Packages"]["cv2"] = "Not Installed" try: import psychopy sys_info["Packages"]["PsychoPy"] = psychopy.__version__ except: sys_info["Packages"]["PsychoPy"] = "Not Installed" sys_info["Graphics"] = OrderedDict() sys_info["Graphics"]["shaders"] = win._haveShaders sys_info["Graphics"]["opengl"] = OrderedDict() sys_info["Graphics"]["opengl"]["version"] = gl_info.get_version() sys_info["Graphics"]["opengl"]["vendor"] = gl_info.get_vendor() sys_info["Graphics"]["opengl"]["engine"] = gl_info.get_renderer() maxVerts = GLint() glGetIntegerv(GL_MAX_ELEMENTS_VERTICES, maxVerts) sys_info["Graphics"]["opengl"]["Max vert in VA"] = maxVerts.value sys_info["Graphics"]["opengl"]["extensions"] = OrderedDict() extensionsOfInterest = [ "GL_ARB_multitexture", "GL_EXT_framebuffer_object", "GL_ARB_fragment_program", "GL_ARB_shader_objects", "GL_ARB_vertex_shader", "GL_ARB_texture_non_power_of_two", "GL_ARB_texture_float", "GL_STEREO", ] for ext in extensionsOfInterest: sys_info["Graphics"]["opengl"]["extensions"][ext] = bool(gl_info.have_extension(ext)) sys_info["Processes"] = OrderedDict() if sys.platform == "darwin": sys_info["Processes"]["Failed"] = "Not Supported on OSX." elif SAVE_PER_PROCESS_DATA: try: import psutil for proc in psutil.process_iter(): pkey = proc.pid vattrs = [ "name", "exe", "ppid", "num_threads", "memory_percent", "cpu_percent", "cpu_affinity", "nice", "num_ctx_switches", ] procinfo = proc.as_dict(attrs=vattrs, ad_value=u"Access Denied") if procinfo["exe"] is not u"Access Denied" and ( SAVE_PER_PROCESS_DATA is True or SAVE_PER_PROCESS_DATA == procinfo["name"] ): sys_info["Processes"][pkey] = procinfo except: sys_info["Processes"]["Failed"] = "psutil 2.x + is required." else: sys_info["Processes"]["Disabled"] = "Per Process details disabled by user." return sys_info
def __enter__(self): self.current_fbo = (gl.GLint)() gl.glGetIntegerv(gl.GL_FRAMEBUFFER_BINDING, self.current_fbo); gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.fbo) gl.glViewport(0, 0, self.texture.width, self.texture.height)
import pyglet print("pyglet", pyglet.version) # pyo is a new dependency, for sound: try: import pyo print("pyo", '%i.%i.%i' % pyo.getVersion()) except Exception: print('pyo [not installed]') from psychopy import __version__ print("\nPsychoPy", __version__) win = visual.Window([100, 100]) # some drivers want a window open first print("have shaders:", win._haveShaders) print("\nOpenGL info:") # get info about the graphics card and drivers print("vendor:", gl_info.get_vendor()) print("rendering engine:", gl_info.get_renderer()) print("OpenGL version:", gl_info.get_version()) print("(Selected) Extensions:") extensionsOfInterest = ['GL_ARB_multitexture', 'GL_EXT_framebuffer_object', 'GL_ARB_fragment_program', 'GL_ARB_shader_objects', 'GL_ARB_vertex_shader', 'GL_ARB_texture_non_power_of_two', 'GL_ARB_texture_float', 'GL_STEREO'] for ext in extensionsOfInterest: print("\t", bool(gl_info.have_extension(ext)), ext) # also determine nVertices that can be used in vertex arrays maxVerts = GLint() glGetIntegerv(GL_MAX_ELEMENTS_VERTICES, maxVerts) print('\tmax vertices in vertex array:', maxVerts.value)
def getSysInfo(win): try: from collections import OrderedDict except Exception: from psychopy.iohub import OrderedDict # based on sysInfo.py from pyglet.gl import gl_info, GLint, glGetIntegerv, GL_MAX_ELEMENTS_VERTICES import sys, platform sys_info = OrderedDict() sys_info['OS'] = OrderedDict() sys_info['OS']['Name'] = platform.platform() if sys.platform == 'darwin': OSXver, _, architecture = platform.mac_ver() sys_info['OS']['OSX Version'] = OSXver sys_info['OS']['OSX Architecture'] = architecture sys_info['Computer Hardware'] = OrderedDict() try: import psutil def getMemoryInfo(): rdict = dict() nt = psutil.virtual_memory() for name in nt._fields: value = getattr(nt, name) if name != 'percent': value = bytes2human(value) rdict[name.capitalize( )] = value # '%s%s%-10s : %7s\n'%(rstr, '\t' * indent, name.capitalize(), value) return rdict core_count = psutil.cpu_count(logical=False) logical_psu_count = psutil.cpu_count() memory_info = getMemoryInfo() sys_info['Computer Hardware']['CPUs (cores / logical)'] = ( core_count, logical_psu_count) sys_info['Computer Hardware']['System Memory'] = memory_info except Exception: sys_info['Computer Hardware']['Failed'] = 'psutil 2.x + is required.' sys_info['Python'] = OrderedDict() sys_info['Python']['exe'] = sys.executable sys_info['Python']['version'] = sys.version sys_info['Packages'] = OrderedDict() try: import numpy sys_info['Packages']['numpy'] = numpy.__version__ except ImportError: sys_info['Packages']['numpy'] = "Not Installed" try: import pyglet sys_info['Packages']['pyglet'] = pyglet.version except ImportError: sys_info['Packages']['pyglet'] = "Not Installed" try: import cv2 sys_info['Packages']['cv2'] = cv2.__version__ except ImportError: sys_info['Packages']['cv2'] = "Not Installed" try: import psychopy sys_info['Packages']['PsychoPy'] = psychopy.__version__ except ImportError: sys_info['Packages']['PsychoPy'] = "Not Installed" sys_info['Graphics'] = OrderedDict() sys_info['Graphics']['shaders'] = win._haveShaders sys_info['Graphics']['opengl'] = OrderedDict() sys_info['Graphics']['opengl']['version'] = gl_info.get_version() sys_info['Graphics']['opengl']['vendor'] = gl_info.get_vendor() sys_info['Graphics']['opengl']['engine'] = gl_info.get_renderer() maxVerts = GLint() glGetIntegerv(GL_MAX_ELEMENTS_VERTICES, maxVerts) sys_info['Graphics']['opengl']['Max vert in VA'] = maxVerts.value sys_info['Graphics']['opengl']['extensions'] = OrderedDict() extensionsOfInterest = [ 'GL_ARB_multitexture', 'GL_EXT_framebuffer_object', 'GL_ARB_fragment_program', 'GL_ARB_shader_objects', 'GL_ARB_vertex_shader', 'GL_ARB_texture_non_power_of_two', 'GL_ARB_texture_float', 'GL_STEREO' ] for ext in extensionsOfInterest: sys_info['Graphics']['opengl']['extensions'][ext] = bool( gl_info.have_extension(ext)) sys_info['Processes'] = OrderedDict() if sys.platform == 'darwin': sys_info['Processes']['Failed'] = 'Not Supported on OSX.' elif SAVE_PER_PROCESS_DATA: try: import psutil for proc in psutil.process_iter(): pkey = proc.pid vattrs = [ 'name', 'exe', 'ppid', 'num_threads', 'memory_percent', 'cpu_percent', 'cpu_affinity', 'nice', 'num_ctx_switches' ] procinfo = proc.as_dict(attrs=vattrs, ad_value=u"Access Denied") if procinfo['exe'] is not u"Access Denied" and ( SAVE_PER_PROCESS_DATA is True or SAVE_PER_PROCESS_DATA == procinfo['name']): sys_info['Processes'][pkey] = procinfo except ImportError: sys_info['Processes']['Failed'] = 'psutil 2.x + is required.' else: sys_info['Processes'][ 'Disabled'] = 'Per Process details disabled by user.' return sys_info
def currentProgram(): """Get the current enabled program. """ pno = gl.GLint() gl.glGetIntegerv(gl.GL_CURRENT_PROGRAM, pno) return _programs.get(pno.value)
def render(self, draw_data): # perf: local for faster access io = self.io display_width, display_height = io.display_size fb_width = int(display_width * io.display_fb_scale[0]) fb_height = int(display_height * io.display_fb_scale[1]) if fb_width == 0 or fb_height == 0: return draw_data.scale_clip_rects(*io.display_fb_scale) # backup GL state # todo: provide cleaner version of this backup-restore code last_program = gl.GLint() gl.glGetIntegerv(gl.GL_CURRENT_PROGRAM, byref(last_program)) last_texture = gl.GLint() gl.glGetIntegerv(gl.GL_TEXTURE_BINDING_2D, byref(last_texture)) last_active_texture = gl.GLint() gl.glGetIntegerv(gl.GL_ACTIVE_TEXTURE, byref(last_active_texture)) last_array_buffer = gl.GLint() gl.glGetIntegerv(gl.GL_ARRAY_BUFFER_BINDING, byref(last_array_buffer)) last_element_array_buffer = gl.GLint() gl.glGetIntegerv(gl.GL_ELEMENT_ARRAY_BUFFER_BINDING, byref(last_element_array_buffer)) last_vertex_array = gl.GLint() gl.glGetIntegerv(gl.GL_VERTEX_ARRAY_BINDING, byref(last_vertex_array)) last_blend_src = gl.GLint() gl.glGetIntegerv(gl.GL_BLEND_SRC, byref(last_blend_src)) last_blend_dst = gl.GLint() gl.glGetIntegerv(gl.GL_BLEND_DST, byref(last_blend_dst)) last_blend_equation_rgb = gl.GLint() gl.glGetIntegerv(gl.GL_BLEND_EQUATION_RGB, byref(last_blend_equation_rgb)) last_blend_equation_alpha = gl.GLint() gl.glGetIntegerv(gl.GL_BLEND_EQUATION_ALPHA, byref(last_blend_equation_alpha)) last_viewport = (gl.GLint*4)() gl.glGetIntegerv(gl.GL_VIEWPORT, last_viewport) last_scissor_box = (gl.GLint*4)() gl.glGetIntegerv(gl.GL_SCISSOR_BOX, last_scissor_box) last_enable_blend = gl.GLint() gl.glIsEnabled(gl.GL_BLEND, byref(last_enable_blend)) last_enable_cull_face = gl.GLint() gl.glIsEnabled(gl.GL_CULL_FACE, byref(last_enable_cull_face)) last_enable_depth_test = gl.GLint() gl.glIsEnabled(gl.GL_DEPTH_TEST, byref(last_enable_depth_test)) last_enable_scissor_test = gl.GLint() gl.glIsEnabled(gl.GL_SCISSOR_TEST, byref(last_enable_scissor_test)) gl.glEnable(gl.GL_BLEND) gl.glBlendEquation(gl.GL_FUNC_ADD) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glDisable(gl.GL_CULL_FACE) gl.glDisable(gl.GL_DEPTH_TEST) gl.glEnable(gl.GL_SCISSOR_TEST) gl.glActiveTexture(gl.GL_TEXTURE0) gl.glViewport(0, 0, int(fb_width), int(fb_height)) ortho_projection = [ 2.0/display_width, 0.0, 0.0, 0.0, 0.0, 2.0/-display_height, 0.0, 0.0, 0.0, 0.0, -1.0, 0.0, -1.0, 1.0, 0.0, 1.0 ] gl.glUseProgram(self._shader_handle) gl.glUniform1i(self._attrib_location_tex, 0) gl.glUniformMatrix4fv(self._attrib_proj_mtx, 1, gl.GL_FALSE, (gl.GLfloat * 16)(*ortho_projection)) gl.glBindVertexArray(self._vao_handle) for commands in draw_data.commands_lists: idx_buffer_offset = 0 gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self._vbo_handle) # todo: check this (sizes) gl.glBufferData(gl.GL_ARRAY_BUFFER, commands.vtx_buffer_size * imgui.VERTEX_SIZE, c_void_p(commands.vtx_buffer_data), gl.GL_STREAM_DRAW) gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, self._elements_handle) # todo: check this (sizes) gl.glBufferData(gl.GL_ELEMENT_ARRAY_BUFFER, commands.idx_buffer_size * imgui.INDEX_SIZE, c_void_p(commands.idx_buffer_data), gl.GL_STREAM_DRAW) # todo: allow to iterate over _CmdList for command in commands.commands: gl.glBindTexture(gl.GL_TEXTURE_2D, command.texture_id) # todo: use named tuple x, y, z, w = command.clip_rect gl.glScissor(int(x), int(fb_height - w), int(z - x), int(w - y)) if imgui.INDEX_SIZE == 2: gltype = gl.GL_UNSIGNED_SHORT else: gltype = gl.GL_UNSIGNED_INT gl.glDrawElements(gl.GL_TRIANGLES, command.elem_count, gltype, c_void_p(idx_buffer_offset)) idx_buffer_offset += command.elem_count * imgui.INDEX_SIZE # restore modified GL state gl.glUseProgram(cast((c_int*1)(last_program), POINTER(c_uint)).contents) gl.glActiveTexture(cast((c_int*1)(last_active_texture), POINTER(c_uint)).contents) gl.glBindTexture(gl.GL_TEXTURE_2D, cast((c_int*1)(last_texture), POINTER(c_uint)).contents) gl.glBindVertexArray(cast((c_int*1)(last_vertex_array), POINTER(c_uint)).contents) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, cast((c_int*1)(last_array_buffer), POINTER(c_uint)).contents) gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, cast((c_int*1)(last_element_array_buffer), POINTER(c_uint)).contents) gl.glBlendEquationSeparate(cast((c_int*1)(last_blend_equation_rgb), POINTER(c_uint)).contents, cast((c_int*1)(last_blend_equation_alpha), POINTER(c_uint)).contents) gl.glBlendFunc(cast((c_int*1)(last_blend_src), POINTER(c_uint)).contents, cast((c_int*1)(last_blend_dst), POINTER(c_uint)).contents) if last_enable_blend: gl.glEnable(gl.GL_BLEND) else: gl.glDisable(gl.GL_BLEND) if last_enable_cull_face: gl.glEnable(gl.GL_CULL_FACE) else: gl.glDisable(gl.GL_CULL_FACE) if last_enable_depth_test: gl.glEnable(gl.GL_DEPTH_TEST) else: gl.glDisable(gl.GL_DEPTH_TEST) if last_enable_scissor_test: gl.glEnable(gl.GL_SCISSOR_TEST) else: gl.glDisable(gl.GL_SCISSOR_TEST) gl.glViewport(last_viewport[0], last_viewport[1], last_viewport[2], last_viewport[3]) gl.glScissor(last_scissor_box[0], last_scissor_box[1], last_scissor_box[2], last_scissor_box[3])
def get(self, enum: gl.GLenum) -> int: """Get an integer limit""" value = c_int() gl.glGetIntegerv(enum, value) return value.value
def getSysInfo(win): from collections import OrderedDict # based on sysInfo.py from pyglet.gl import gl_info, GLint, glGetIntegerv, GL_MAX_ELEMENTS_VERTICES import sys, platform sys_info = OrderedDict() sys_info['OS'] = OrderedDict() sys_info['OS']['Name'] = platform.platform() if sys.platform == 'darwin': OSXver, _, architecture = platform.mac_ver() sys_info['OS']['OSX Version'] = OSXver sys_info['OS']['OSX Architecture'] = architecture sys_info['Computer Hardware'] = OrderedDict() try: import psutil def getMemoryInfo(): rdict = dict() nt = psutil.virtual_memory() for name in nt._fields: value = getattr(nt, name) if name != 'percent': value = bytes2human(value) rdict[name.capitalize()] = value # '%s%s%-10s : %7s\n'%(rstr, '\t' * indent, name.capitalize(), value) return rdict core_count = psutil.cpu_count(logical=False) logical_psu_count = psutil.cpu_count() memory_info = getMemoryInfo() sys_info['Computer Hardware']['CPUs (cores / logical)'] = (core_count, logical_psu_count) sys_info['Computer Hardware']['System Memory'] = memory_info except Exception: sys_info['Computer Hardware']['Failed'] = 'psutil 2.x + is required.' sys_info['Python'] = OrderedDict() sys_info['Python']['exe'] = sys.executable sys_info['Python']['version'] = sys.version sys_info['Packages'] = OrderedDict() try: import numpy sys_info['Packages']['numpy'] = numpy.__version__ except ImportError: sys_info['Packages']['numpy'] = "Not Installed" try: import pyglet sys_info['Packages']['pyglet'] = pyglet.version except ImportError: sys_info['Packages']['pyglet'] = "Not Installed" try: import cv2 sys_info['Packages']['cv2'] = cv2.__version__ except ImportError: sys_info['Packages']['cv2'] = "Not Installed" try: import psychopy sys_info['Packages']['PsychoPy'] = psychopy.__version__ except ImportError: sys_info['Packages']['PsychoPy'] = "Not Installed" sys_info['Graphics'] = OrderedDict() sys_info['Graphics']['shaders'] = win._haveShaders sys_info['Graphics']['opengl'] = OrderedDict() sys_info['Graphics']['opengl']['version'] = gl_info.get_version() sys_info['Graphics']['opengl']['vendor'] = gl_info.get_vendor() sys_info['Graphics']['opengl']['engine'] = gl_info.get_renderer() maxVerts = GLint() glGetIntegerv(GL_MAX_ELEMENTS_VERTICES, maxVerts) sys_info['Graphics']['opengl']['Max vert in VA'] = maxVerts.value sys_info['Graphics']['opengl']['extensions'] = OrderedDict() extensionsOfInterest = ['GL_ARB_multitexture', 'GL_EXT_framebuffer_object', 'GL_ARB_fragment_program', 'GL_ARB_shader_objects', 'GL_ARB_vertex_shader', 'GL_ARB_texture_non_power_of_two', 'GL_ARB_texture_float', 'GL_STEREO'] for ext in extensionsOfInterest: sys_info['Graphics']['opengl']['extensions'][ext] = bool(gl_info.have_extension(ext)) sys_info['Processes'] = OrderedDict() if sys.platform == 'darwin': sys_info['Processes']['Failed'] = 'Not Supported on OSX.' elif SAVE_PER_PROCESS_DATA: try: import psutil for proc in psutil.process_iter(): pkey = proc.pid vattrs = ['name', 'exe', 'ppid', 'num_threads', 'memory_percent', 'cpu_percent', 'cpu_affinity', 'nice', 'num_ctx_switches'] procinfo = proc.as_dict(attrs=vattrs, ad_value=u"Access Denied") if procinfo['exe'] is not u"Access Denied" and (SAVE_PER_PROCESS_DATA is True or SAVE_PER_PROCESS_DATA == procinfo['name']): sys_info['Processes'][pkey] = procinfo except ImportError: sys_info['Processes']['Failed'] = 'psutil 2.x + is required.' else: sys_info['Processes']['Disabled'] = 'Per Process details disabled by user.' return sys_info