def start_game(self, event=None):
# 启动游戏
select = self.game_item_list.curselection()
if select == ():
log_warn('no world selected')
return
select = self.game_item_list.get(select[0])
self.destroy()
try:
data = load_window()
game = Game(width=max(data['width'], 800), height=max(data['height'], 600),
caption='minecraft %s' % VERSION['str'], resizable=True)
game.set_name(select)
setup_opengl()
pyglet.app.run()
except SystemExit:
pass
except:
name = time.strftime('error-%Y-%m-%d_%H.%M.%S.log')
log_err('Catch error, saved in: log/%s' % name)
with open(os.path.join(search_mcpy(), 'log', name), 'a+') as err_log:
err_log.write('Minecraft version: %s\n' % VERSION['str'])
err_log.write('python version: %s for %s\n' % ('.'.join([str(s) for s in sys.version_info[:3]]), sys.platform))
err_log.write('pyglet version: %s(OpenGL %s)\n' % (pyglet.version, gl_info.get_version()))
err_log.write('time: %s\n' % time.ctime())
err_log.write('save: %s\n' % select)
err_log.write('traceback:\n' + '=' * 34 + '\n')
traceback.print_exc(file=err_log)
err_log.write('=' * 34 + '\n')
with open(os.path.join(search_mcpy(), 'log', 'error-latest.log'), 'w+') as latest_log:
with open(os.path.join(search_mcpy(), 'log', name), 'r+') as err_log:
latest_log.write(err_log.read())
exit(1)
def graphics_test():
from pyglet.gl import gl_info
win = visual.Window([100, 100]) # some drivers want a window open first
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())
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']
for ext in GLextensionsOfInterest:
self['openGLext.'+ext] = bool(gl_info.have_extension(ext))
def dump_gl():
'''Dump GL info.'''
from pyglet.gl import gl_info
_print('gl_info.get_version():', gl_info.get_version())
_print('gl_info.get_vendor():', gl_info.get_vendor())
_print('gl_info.get_renderer():', gl_info.get_renderer())
_print('gl_info.get_extensions():')
extensions = list(gl_info.get_extensions())
extensions.sort()
for name in extensions:
_print(' ', name)
def dump_gl():
'''Dump GL info.'''
from pyglet.gl import gl_info
print 'gl_info.get_version():', gl_info.get_version()
print 'gl_info.get_vendor():', gl_info.get_vendor()
print 'gl_info.get_renderer():', gl_info.get_renderer()
print 'gl_info.get_extensions():'
extensions = list(gl_info.get_extensions())
extensions.sort()
for name in extensions:
print ' ', name
def dump_gl(context=None):
"""Dump GL info."""
if context is not None:
info = context.get_info()
else:
from pyglet.gl import gl_info as info
print('gl_info.get_version():', info.get_version())
print('gl_info.get_vendor():', info.get_vendor())
print('gl_info.get_renderer():', info.get_renderer())
print('gl_info.get_extensions():')
extensions = list(info.get_extensions())
extensions.sort()
for name in extensions:
print(' ', name)
def dump_gl(context=None):
"""Dump GL info."""
if context is not None:
info = context.get_info()
else:
from pyglet.gl import gl_info as info
print("gl_info.get_version():", info.get_version())
print("gl_info.get_vendor():", info.get_vendor())
print("gl_info.get_renderer():", info.get_renderer())
print("gl_info.get_extensions():")
extensions = list(info.get_extensions())
extensions.sort()
for name in extensions:
print(" ", name)
def dump_gl(context=None):
'''Dump GL info.'''
if context is not None:
info = context.get_info()
else:
from pyglet.gl import gl_info as info
print 'gl_info.get_version():', info.get_version()
print 'gl_info.get_vendor():', info.get_vendor()
print 'gl_info.get_renderer():', info.get_renderer()
print 'gl_info.get_extensions():'
extensions = list(info.get_extensions())
extensions.sort()
for name in extensions:
print ' ', name
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'
]
for ext in GLextensionsOfInterest:
self['openGLext.' + ext] = bool(gl_info.have_extension(ext))
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 _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
print('Screens:')
for screen in display.get_screens():
print(' %r' % screen)
print()
print('Creating default context...')
w = pyglet.window.Window(1, 1, visible=True)
print('Window:')
print(' %s' % w)
print('GL attributes:')
attrs = w.config.get_gl_attributes()
attrs = ' '.join(['%s=%s' % (name, value) for name, value in attrs])
print(' ', '\n '.join(textwrap.wrap(attrs)))
print('GL version:', gl_info.get_version())
print('GL vendor:', gl_info.get_vendor())
print('GL renderer:', gl_info.get_renderer())
print('GL extensions:')
exts = ' '.join(gl_info.get_extensions())
print(' ', '\n '.join(textwrap.wrap(exts)))
print()
context = w.context
print('Context is', context)
if "xlib" in globals() and isinstance(context, xlib.BaseXlibContext):
from pyglet.gl import glx_info
print('GLX %s direct' % (context.is_direct() and 'is' or 'is not'))
if not glx_info.have_version(1, 1):
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 _getGfxCardString(self):
from pyglet.gl import gl_info
return "%s: %s" % (gl_info.get_renderer(), gl_info.get_version())
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
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):
raise HardwareSupportError("the %s extension" % ext)
hardware_info = {'vendor': gli.get_vendor(),
'renderer': gli.get_renderer(),
'version': gli.get_version()}
# Check hardware support
_opengl_version = hardware_info['version'].split(' ')[0]
if _opengl_version < "2.0":
raise DriverError("This package requires OpenGL v2.0 or higher. "
"Your version is %s." % _opengl_version)
# This extension is required to return floats outside [0, 1]
# in gl_FragColor
require_extension('ARB_color_buffer_float')
require_extension('ARB_texture_float')
gl.glClampColorARB(gl.GL_CLAMP_VERTEX_COLOR_ARB, False)
gl.glClampColorARB(gl.GL_CLAMP_FRAGMENT_COLOR_ARB, False)
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
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)
from sys import platform, version_info
from minecraft.utils.utils import *
from pyglet import version
from pyglet.gl import gl_info
log_info('** Start Minecraft-in-python **')
log_info('This is not official Minecraft product.')
log_info('Not approved by or associated with Mojang.')
log_info('Operation system: %s' % platform, where='l')
log_info('python version: %s' % '.'.join([str(s) for s in version_info[:3]]),
where='l')
log_info('pyglet version: %s(OpenGL %s)' % (version, gl_info.get_version()),
where='l')
log_info('Minecraft-in-python version: %s(data version: %s)' %
(VERSION['str'], VERSION['data']),
where='l')
print 'Platform instance is %r' % platform
display = platform.get_default_display()
print 'Display instance is %r' % display
print 'Screens:'
for screen in display.get_screens():
print ' %r' % screen
print 'Creating default context...'
w = pyglet.window.Window(1, 1, visible=True)
print 'GL attributes:'
attrs = w.config.get_gl_attributes()
attrs = ' '.join(['%s=%s'%(name, value) for name, value in attrs])
print '\n'.join(textwrap.wrap(attrs))
print 'GL version:', gl_info.get_version()
print 'GL vendor:', gl_info.get_vendor()
print 'GL renderer:', gl_info.get_renderer()
print 'GL extensions:'
exts = ' '.join(gl_info.get_extensions())
print ' ', '\n '.join(textwrap.wrap(exts))
print 'GLU version:', glu_info.get_version()
print 'GLU extensions:'
exts = ' '.join(glu_info.get_extensions())
print ' ', '\n '.join(textwrap.wrap(exts))
print
context = w.context
print 'Context is', context
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 _getGfxCardString(self):
from pyglet.gl import gl_info
thisStr = "%s: %s" %(gl_info.get_renderer(), gl_info.get_version())
return thisStr
def run(self):
import pyglet
pyglet.options['debug_gl'] = False
from dypy.tools.PortraitTool import PortraitTool
from dypy.tools.OrbitTool import OrbitTool
from dypy.tools.CobwebTool import CobwebTool
# unfortunately, pyglet imports must occur in the same scope as the pyglet window
from pyglet.gl import glBlendFunc, glEnable, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, \
GL_BLEND, glClear, GL_COLOR_BUFFER_BIT, glMatrixMode, GL_PROJECTION, GL_MODELVIEW, \
glLoadIdentity, glTranslatef, glRotatef, gl_info, glViewport, glOrtho, \
glHint, GL_LINE_SMOOTH, GL_LINE_SMOOTH_HINT, GL_NICEST, glDisable
import pyglet.clock
import pyglet.window
import select
self.window = pyglet.window.Window(width=self.width, height=self.height, visible=False)
self.window.set_location(450, 0)
self.window.on_resize = self.on_resize
self.window.on_close = self.on_close
self.window.on_key_press = self.on_key_press
self.window.on_mouse_drag = self.on_mouse_drag
self.window.on_mouse_scroll = self.on_mouse_scroll
self.window.on_mouse_press = self.on_mouse_press
self.window.on_mouse_release = self.on_mouse_release
# create and wait for object server
self.object_server = PyroServer()
self.object_server.start()
self.object_server.waitUntilStarted()
# create p5 vr glove server
self.glove_server = P5Device(self)
self.glove_server.start()
# create nintento wiimote server
self.wiimote_server = WiimoteDevice(self)
self.wiimote_server.start()
# create 3Dconnexion space navigator server
self.sn_server = SpaceNavigatorDevice(self)
self.sn_server.start()
# visualization parameters
self.rotation_velocity = 0.8
self.iteration = 0
self.reset_rotation()
self.set_axes_center()
self.set_bounds((-1, 1), (-1, 1), (-1, 1), False)
# don't hog more cpu than is useful
pyglet.clock.set_fps_limit(self.fps)
# create tools and connect them to server
self.object_server.daemon.connect(self, 'ToolServer')
t = PortraitTool(server=self)
self.object_server.daemon.connect(t, 'PortraitTool')
t = CobwebTool(server=self)
self.object_server.daemon.connect(t, 'CobwebTool')
t = OrbitTool(server=self)
self.object_server.daemon.connect(t, 'OrbitTool')
self.update_tool(t)
# set alpha blending function
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
# enable line anti-aliasing
glEnable(GL_LINE_SMOOTH)
glHint(GL_LINE_SMOOTH_HINT, GL_NICEST)
# gl diagnostics
dypy.debug("ToolServer", "GL version is %s." % gl_info.get_version())
dypy.debug("ToolServer", "GL renderer is %s." % gl_info.get_renderer())
dypy.debug("ToolServer", "Pyglet version is %s." % pyglet.version)
# event flags
self.ready = True
self.tool_updated = False
self.window_resized = False
self.visible = False
self.visibility_changed = False
self.show_axes = False
while not self.window.has_exit:
pyglet.clock.tick()
gl_lock.acquire()
try:
self.window.dispatch_events()
if self.visibility_changed:
self.visibility_changed = False
self.window.set_visible(self.visible)
if self.tool_updated:
self.tool_updated = False
self.tool.init_points()
if self.window_resized:
self.window_resized = False
if (self.x_min == 0 and self.x_max == 0) or (self.y_min == 0 and self.y_max == 0):
continue
glViewport(0, 0, self.width, self.height)
glMatrixMode(GL_PROJECTION)
glLoadIdentity()
dypy.debug("ToolServer", "Setting projection to %.1f %.1f %.1f %.1f %.1f %.1f" % (self.x_min, self.x_max, self.y_min, self.y_max, -self.dimension_max, self.dimension_max))
glOrtho(self.x_min, self.x_max, self.y_min, self.y_max, -self.dimension_max**2, self.dimension_max**2)
if self.window.visible:
# reset model matrix
glMatrixMode(GL_MODELVIEW)
glLoadIdentity()
# translate to center
glTranslatef(self.x_center, self.y_center, self.z_center)
# rotate around axes
glRotatef(self.x_rotate, 1, 0, 0)
glRotatef(self.y_rotate, 0, 1, 0)
glRotatef(self.z_rotate, 0, 0, 1)
# clear iteration 0 as well as iteration 1 to clear axes after rotation
if self.iteration <= 1 or self.tool.clear_each_frame:
glClear(GL_COLOR_BUFFER_BIT)
glEnable(GL_BLEND)
# draw reference axes during rotation only
if self.show_axes:
self.draw_axes()
glDisable(GL_BLEND)
# translate back to lower left corner
glTranslatef(-self.x_center, -self.y_center, -self.z_center)
# tell the tool to draw its content
self.tool.draw_points()
# iteration is done, swap display buffers
self.iteration += 1
self.window.flip()
# process server requests
socks = self.object_server.daemon.getServerSockets()
ins, outs, exs = select.select(socks, [], [], 0)
for s in socks:
if s in ins:
self.object_server.daemon.handleRequests()
break
except Exception, detail:
print type(detail), detail
finally:
