def __init__(self, scene, projection=None, navigation=None, parent=None):
# super init
super().__init__(parent)
fmt = QSurfaceFormat()
fmt.setVersion(*opengl_version)
fmt.setProfile(QSurfaceFormat.CoreProfile)
fmt.setSamples(4)
self.setFormat(fmt)
self.setFocusPolicy(Qt.StrongFocus)
self.setAttribute(Qt.WA_AcceptTouchEvents, True)
# interaction methods
self.projection = projection or globals()[settings.scene['projection']]()
self.navigation = navigation or globals()[settings.controls['navigation']]()
self.tool = [Tool(self.navigation.tool, self)] # tool stack, the last tool is used for input events, until it is removed
# render parameters
self.scene = scene if isinstance(scene, Scene) else Scene(scene)
self.uniforms = {'proj':fmat4(1), 'view':fmat4(1), 'projview':fmat4(1)} # last frame rendering constants
self.targets = []
self.steps = []
self.step = 0
self.stepi = 0
# dump targets
self.map_depth = None
self.map_idents = None
self.fresh = set() # set of refreshed internal variables since the last render
def setContext(cls,
major_version: int,
minor_version: int,
core=False,
profile=None):
new_format = QSurfaceFormat()
new_format.setMajorVersion(major_version)
new_format.setMinorVersion(minor_version)
if core:
profile_ = QSurfaceFormat.CoreProfile
else:
profile_ = QSurfaceFormat.CompatibilityProfile
if profile is not None:
profile_ = profile
new_format.setProfile(profile_)
new_context = QOpenGLContext()
new_context.setFormat(new_format)
success = new_context.create()
if success:
return new_context
else:
Logger.log(
"e", "Failed creating OpenGL context (%d, %d, core=%s)" %
(major_version, minor_version, core))
return None
def setContext(cls,
major_version: int,
minor_version: int,
core=False,
profile=None):
"""Set OpenGL context, given major, minor version + core using QOpenGLContext
Unfortunately, what you get back does not have to be the requested version.
"""
new_format = QSurfaceFormat()
new_format.setMajorVersion(major_version)
new_format.setMinorVersion(minor_version)
if core:
profile_ = QSurfaceFormat.CoreProfile
else:
profile_ = QSurfaceFormat.CompatibilityProfile
if profile is not None:
profile_ = profile
new_format.setProfile(profile_)
new_context = QOpenGLContext()
new_context.setFormat(new_format)
success = new_context.create()
if success:
return new_context
else:
Logger.log(
"e", "Failed creating OpenGL context (%d, %d, core=%s)" %
(major_version, minor_version, core))
return None
def setDefaultFormat(cls,
major_version: int,
minor_version: int,
core=False,
profile=None) -> None:
"""Set the default format for each new OpenGL context
:param major_version:
:param minor_version:
:param core: (optional) True for QSurfaceFormat.CoreProfile, False for CompatibilityProfile
:param profile: (optional) QSurfaceFormat.CoreProfile, CompatibilityProfile or NoProfile, overrules option core
"""
new_format = QSurfaceFormat()
new_format.setMajorVersion(major_version)
new_format.setMinorVersion(minor_version)
if core:
profile_ = QSurfaceFormat.CoreProfile
else:
profile_ = QSurfaceFormat.CompatibilityProfile
if profile is not None:
profile_ = profile
new_format.setProfile(profile_)
QSurfaceFormat.setDefaultFormat(new_format)
cls.major_version = major_version
cls.minor_version = minor_version
cls.profile = profile_
def __init__(self, scene, camera, light):
super().__init__()
fmt = QSurfaceFormat()
fmt.setVersion(3, 3)
fmt.setProfile(QSurfaceFormat.CoreProfile)
fmt.setStencilBufferSize(8)
self.setFormat(fmt)
self.scene, self.camera, self.light = scene, camera, light
def create_format():
fmt = QSurfaceFormat()
fmt.setProfile(QSurfaceFormat.CoreProfile)
fmt.setVersion(3, 3) #vmware max opengl version is 3.3
fmt.setAlphaBufferSize(8)
fmt.setStencilBufferSize(8)
fmt.setDepthBufferSize(24)
fmt.setOption(QSurfaceFormat.DebugContext)
return fmt
def __init__(self, parent=None, **kwargs):
super(ViewerWindow, self).__init__(parent)
self.setSurfaceType(QWindow.OpenGLSurface)
format = QSurfaceFormat()
format.setVersion(3, 3)
format.setProfile(QSurfaceFormat.CoreProfile)
format.setStereo(False)
format.setSwapBehavior(QSurfaceFormat.DoubleBuffer)
format.setDepthBufferSize(24)
format.setSamples(16)
self.context = QOpenGLContext(self)
self.context.setFormat(format)
if not self.context.create():
raise Exception('self.context.create() failed')
self.create()
size = 720, 720
self.resize(*size)
self.context.makeCurrent(self)
self.hud_program = CrossHairProgram()
self.default_view = np.eye(4, dtype=np.float32)
self.view = self.default_view
self.model = np.eye(4, dtype=np.float32)
self.projection = np.eye(4, dtype=np.float32)
self.layer_manager = LayerManager()
self.visibility_toggle_listeners = []
self.multiview = True
self.rotation = q.quaternion()
self.scale = 0.6
self.translation = np.zeros(3)
self.radius = 0.5 * min(*size)
self.fov = 5.
self.camera_position = -12.
self.near_clip = .1
if 'near_clip' in kwargs:
self.near_clip = kwargs['near_clip']
self.far_clip = 100.
if 'far_clip' in kwargs:
self.far_clip = kwargs['far_clip']
self.projection_mode = 'perspective' # 'orthographic'
self.size = size
self.bg_white = False
self.viewpoint_dict = {}
print((self.instructions))
def __init__(self, parent=None, **kwargs):
super(ViewerWindow, self).__init__(parent)
self.setSurfaceType(QWindow.OpenGLSurface)
format = QSurfaceFormat()
format.setVersion(3, 3)
format.setProfile(QSurfaceFormat.CoreProfile)
format.setStereo(False)
format.setSwapBehavior(QSurfaceFormat.DoubleBuffer)
format.setDepthBufferSize(24)
format.setSamples(16)
self.context = QOpenGLContext(self)
self.context.setFormat(format)
if not self.context.create():
raise Exception('self.context.create() failed')
self.create()
size = 720, 720
self.resize(*size)
self.context.makeCurrent(self)
self.hud_program = CrossHairProgram()
self.default_view = np.eye(4, dtype=np.float32)
self.view = self.default_view
self.model = np.eye(4, dtype=np.float32)
self.projection = np.eye(4, dtype=np.float32)
self.layer_manager = LayerManager()
self.visibility_toggle_listeners = []
self.multiview = True
self.rotation = q.quaternion()
self.scale = 0.6
self.translation = np.zeros(3)
self.radius = 0.5 * min(*size)
self.fov = 5.
self.camera_position = -12.
self.near_clip = .1
if 'near_clip' in kwargs:
self.near_clip = kwargs['near_clip']
self.far_clip = 100.
if 'far_clip' in kwargs:
self.far_clip = kwargs['far_clip']
self.projection_mode = 'perspective' # 'orthographic'
self.size = size
self.bg_white = False
self.viewpoint_dict = {}
print((self.instructions))
def __init__(self,
args,
glWidget=QOpenGLWidget,
requestedGLVersion=(2, 1)):
super(_TestApplication, self).__init__(args)
glType = QOpenGLContext.openGLModuleType()
format = QSurfaceFormat()
format.setDepthBufferSize(24)
if glType == QOpenGLContext.LibGL:
info("OPENGL MODULE TYPE", "LibGL")
format.setVersion(requestedGLVersion[0], requestedGLVersion[1])
format.setProfile(QSurfaceFormat.CompatibilityProfile)
format.setOption(QSurfaceFormat.DebugContext)
QSurfaceFormat.setDefaultFormat(format)
else:
info(
"OPENGL MODULE TYPE",
"Unknown or LibGLES <--- this is likely to cause problems down the line"
)
self.debugMembers = False
self.mainWin = QWidget()
if glWidget == QOpenGLWidget:
# Only hard code size if we're not using a canvas
self.mainWin.resize(600, 600)
self.mainWin.setWindowTitle('TestApplication')
self.mainWidget = glWidget()
self.layout = QHBoxLayout(self.mainWin)
self.layout.addWidget(self.mainWidget)
self.mainWin.show()
ctx = QOpenGLContext.currentContext()
info("GL CURRENT CONTEXT", ctx)
format = ctx.format()
info("EFFECTIVE GL VERSION", ctx.format().version())
self.aboutToQuit.connect(self.applicationClosing)
def setDefaultFormat(cls, major_version, minor_version, core = False, profile = None):
new_format = QSurfaceFormat()
new_format.setMajorVersion(major_version)
new_format.setMinorVersion(minor_version)
if core:
profile_ = QSurfaceFormat.CoreProfile
else:
profile_ = QSurfaceFormat.CompatibilityProfile
if profile is not None:
profile_ = profile
new_format.setProfile(profile_)
QSurfaceFormat.setDefaultFormat(new_format)
cls.major_version = major_version
cls.minor_version = minor_version
cls.profile = profile_
def setDefaultFormat(cls, major_version, minor_version, core = False, profile = None):
new_format = QSurfaceFormat()
new_format.setMajorVersion(major_version)
new_format.setMinorVersion(minor_version)
if core:
profile_ = QSurfaceFormat.CoreProfile
else:
profile_ = QSurfaceFormat.CompatibilityProfile
if profile is not None:
profile_ = profile
new_format.setProfile(profile_)
QSurfaceFormat.setDefaultFormat(new_format)
cls.major_version = major_version
cls.minor_version = minor_version
cls.profile = profile_
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
fmt = QSurfaceFormat()
fmt.setVersion(3, 3)
fmt.setProfile(QSurfaceFormat.CoreProfile)
# fmt.setDepthBufferSize(24)
self.setFormat(fmt)
timer = QTimer(self)
timer.timeout.connect(self.update)
timer.start(1000/60) # 60 FPS
self.rotation_speed = np.zeros(3)
self.last_update = None
self.last_pos = None
def __init__(self):
super().__init__()
fmt = QSurfaceFormat()
fmt.setVersion(2, 0)
fmt.setProfile(QSurfaceFormat.CompatibilityProfile)
fmt.setStereo(False)
fmt.setSwapBehavior(QSurfaceFormat.DoubleBuffer)
self.setSurfaceType(QWindow.OpenGLSurface)
self.context = QOpenGLContext()
self.context.setFormat(fmt)
if not self.context.create():
raise Exception("Unable to create context")
self.create()
self.setTitle("OpenGL")
def __init__(self, scene, projection=None, navigation=None, parent=None):
# super init
super(QOpenGLWidget, self).__init__(parent)
fmt = QSurfaceFormat()
fmt.setVersion(*opengl_version)
fmt.setProfile(QSurfaceFormat.CoreProfile)
fmt.setSamples(4)
self.setFormat(fmt)
# ugly trick to receive interaction events in a different function than QOpenGLWidget.event (that one is locking the GIL during the whole rendering, killing any possibility of having a computing thread aside)
# that event reception should be in the current widget ...
self.handler = GhostWidget(self)
self.handler.setFocusPolicy(Qt.StrongFocus)
self.handler.setAttribute(Qt.WA_AcceptTouchEvents, True)
ViewCommon.__init__(self, scene, projection=None, navigation=None)
self.tool = [
Tool(self.navigation.tool, self)
] # tool stack, the last tool is used for input events, until it is removed
def setContext(cls, major_version, minor_version, core = False, profile = None):
new_format = QSurfaceFormat()
new_format.setMajorVersion(major_version)
new_format.setMinorVersion(minor_version)
if core:
profile_ = QSurfaceFormat.CoreProfile
else:
profile_ = QSurfaceFormat.CompatibilityProfile
if profile is not None:
profile_ = profile
new_format.setProfile(profile_)
new_context = QOpenGLContext()
new_context.setFormat(new_format)
success = new_context.create()
if success:
return new_context
else:
Logger.log("e", "Failed creating OpenGL context (%d, %d, core=%s)" % (major_version, minor_version, core))
return None
def detectBestOpenGLVersion(cls):
Logger.log("d", "Trying OpenGL context 4.1...")
ctx = cls.setContext(4, 1, core=True)
if ctx is not None:
fmt = ctx.format()
profile = fmt.profile()
# First test: we hope for this
if ((fmt.majorVersion() == 4 and fmt.minorVersion() >= 1) or
(fmt.majorVersion() >
4)) and profile == QSurfaceFormat.CoreProfile:
Logger.log(
"d", "Yay, we got at least OpenGL 4.1 core: %s",
cls.versionAsText(fmt.majorVersion(), fmt.minorVersion(),
profile))
# https://riverbankcomputing.com/pipermail/pyqt/2017-January/038640.html
# PyQt currently only implements 2.0, 2.1 and 4.1Core
# If eg 4.5Core would be detected and used here, PyQt would not be able to handle it.
major_version = 4
minor_version = 1
# CURA-6092: Check if we're not using software backed 4.1 context; A software 4.1 context
# is much slower than a hardware backed 2.0 context
gl_window = QWindow()
gl_window.setSurfaceType(QWindow.OpenGLSurface)
gl_window.showMinimized()
gl_format = QSurfaceFormat()
gl_format.setMajorVersion(major_version)
gl_format.setMinorVersion(minor_version)
gl_format.setProfile(profile)
gl_context = QOpenGLContext()
gl_context.setFormat(gl_format)
gl_context.create()
gl_context.makeCurrent(gl_window)
gl_profile = QOpenGLVersionProfile()
gl_profile.setVersion(major_version, minor_version)
gl_profile.setProfile(profile)
gl = gl_context.versionFunctions(
gl_profile
) # type: Any #It's actually a protected class in PyQt that depends on the requested profile and the implementation of your graphics card.
gpu_type = "Unknown" # type: str
result = None
if gl:
result = gl.initializeOpenGLFunctions()
if not result:
Logger.log("e",
"Could not initialize OpenGL to get gpu type")
else:
# WORKAROUND: Cura/#1117 Cura-packaging/12
# Some Intel GPU chipsets return a string, which is not undecodable via PyQt5.
# This workaround makes the code fall back to a "Unknown" renderer in these cases.
try:
gpu_type = gl.glGetString(gl.GL_RENDERER) #type: str
except UnicodeDecodeError:
Logger.log(
"e",
"DecodeError while getting GL_RENDERER via glGetString!"
)
Logger.log("d",
"OpenGL renderer type for this OpenGL version: %s",
gpu_type)
if "software" in gpu_type.lower():
Logger.log(
"w",
"Unfortunately OpenGL 4.1 uses software rendering")
else:
return major_version, minor_version, QSurfaceFormat.CoreProfile
else:
Logger.log("d", "Failed to create OpenGL context 4.1.")
# Fallback: check min spec
Logger.log("d", "Trying OpenGL context 2.0...")
ctx = cls.setContext(2, 0, profile=QSurfaceFormat.NoProfile)
if ctx is not None:
fmt = ctx.format()
profile = fmt.profile()
if fmt.majorVersion() >= 2 and fmt.minorVersion() >= 0:
Logger.log(
"d", "We got at least OpenGL context 2.0: %s",
cls.versionAsText(fmt.majorVersion(), fmt.minorVersion(),
profile))
return 2, 0, QSurfaceFormat.NoProfile
else:
Logger.log(
"d", "Current OpenGL context is too low: %s" %
cls.versionAsText(fmt.majorVersion(), fmt.minorVersion(),
profile))
return None, None, None
else:
Logger.log("d", "Failed to create OpenGL context 2.0.")
return None, None, None
def main():
# make the Python warnings go to Friture logger
logging.captureWarnings(True)
logFormat = "%(asctime)s %(levelname)s %(name)s: %(message)s"
formatter = logging.Formatter(logFormat)
logFileName = "friture.log.txt"
dirs = appdirs.AppDirs("Friture", "")
logDir = dirs.user_data_dir
try:
os.makedirs(logDir)
except OSError as e:
if e.errno != errno.EEXIST:
raise
logFilePath = os.path.join(logDir, logFileName)
# log to file
fileHandler = logging.handlers.RotatingFileHandler(logFilePath,
maxBytes=100000,
backupCount=5)
fileHandler.setLevel(logging.DEBUG)
fileHandler.setFormatter(formatter)
rootLogger = logging.getLogger()
rootLogger.setLevel(logging.DEBUG)
rootLogger.addHandler(fileHandler)
if hasattr(sys, "frozen"):
# redirect stdout and stderr to the logger if this is a pyinstaller bundle
sys.stdout = StreamToLogger(logging.getLogger('STDOUT'), logging.INFO)
sys.stderr = StreamToLogger(logging.getLogger('STDERR'), logging.ERROR)
else:
# log to console if this is not a pyinstaller bundle
console = logging.StreamHandler()
console.setLevel(logging.DEBUG)
console.setFormatter(formatter)
rootLogger.addHandler(console)
# make Qt logs go to Friture logger
QtCore.qInstallMessageHandler(qt_message_handler)
logger = logging.getLogger(__name__)
logger.info("Friture %s starting on %s (%s)", friture.__version__,
platform.system(), sys.platform)
# make sure Qt loads the desktop OpenGL stack, rather than OpenGL ES or a software OpenGL
# only the former option is compatible with the use of PyOpenGL
QtCore.QCoreApplication.setAttribute(QtCore.Qt.AA_UseDesktopOpenGL)
if platform.system() == "Windows":
logger.info("Applying Windows-specific setup")
# enable automatic scaling for high-DPI screens
os.environ["QT_AUTO_SCREEN_SCALE_FACTOR"] = "1"
# set the App ID for Windows 7 to properly display the icon in the
# taskbar.
import ctypes
myappid = 'Friture.Friture.Friture.current' # arbitrary string
try:
ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(
myappid)
except:
logger.error(
"Could not set the app model ID. If the plaftorm is older than Windows 7, this is normal."
)
app = QApplication(sys.argv)
if platform.system() == "Darwin":
logger.info("Applying Mac OS-specific setup")
# help the packaged application find the Qt plugins (imageformats and platforms)
pluginsPath = os.path.normpath(
os.path.join(QApplication.applicationDirPath(), os.path.pardir,
'PlugIns'))
logger.info("Adding the following to the Library paths: %s",
pluginsPath)
QApplication.addLibraryPath(pluginsPath)
# on macOS, OpenGL 2.1 does not work well
# request a 3.2 Core context instead
format = QSurfaceFormat()
format.setDepthBufferSize(24)
format.setStencilBufferSize(8)
format.setVersion(3, 2)
format.setProfile(QSurfaceFormat.CoreProfile)
QSurfaceFormat.setDefaultFormat(format)
# Splash screen
#pixmap = QPixmap(":/images/splash.png")
#splash = QSplashScreen(pixmap)
#splash.show()
#splash.showMessage("Initializing the audio subsystem")
app.processEvents()
window = Friture()
window.show()
#splash.finish(window)
profile = "no" # "python" or "kcachegrind" or anything else to disable
if len(sys.argv) > 1:
if sys.argv[1] == "--python":
profile = "python"
elif sys.argv[1] == "--kcachegrind":
profile = "kcachegrind"
elif sys.argv[1] == "--no":
profile = "no"
else:
logger.info("command-line arguments (%s) not recognized",
sys.argv[1:])
return_code = 0
if profile == "python":
import cProfile
import pstats
# friture.cprof can be visualized with SnakeViz
# http://jiffyclub.github.io/snakeviz/
# snakeviz friture.cprof
cProfile.runctx('app.exec_()',
globals(),
locals(),
filename="friture.cprof")
logger.info("Profile saved to '%s'", "friture.cprof")
stats = pstats.Stats("friture.cprof")
stats.strip_dirs().sort_stats('time').print_stats(20)
stats.strip_dirs().sort_stats('cumulative').print_stats(20)
elif profile == "kcachegrind":
import cProfile
import lsprofcalltree
p = cProfile.Profile()
p.run('app.exec_()')
k = lsprofcalltree.KCacheGrind(p)
with open('cachegrind.out.00000', 'wb') as data:
k.output(data)
else:
return_code = app.exec_()
# explicitly delete the main windows instead of waiting for the interpreter shutdown
# tentative to prevent errors on exit on macos
del window
sys.exit(return_code)
from _004_3d_loading_model_and_rotating.object import ModelUnderlay
import platform
if __name__ == '__main__':
# Not working in Ubuntu 16.04, result in 1282 error for simple calling like glViewport(...)
# TODO
if platform.uname().system == 'Darwin':
f = QSurfaceFormat()
f.setVersion(4, 1)
f.setDepthBufferSize(1) # fix depth buffer error
f.setStencilBufferSize(1) # fix stencil buffer error
# If CoreProfile is used, all the other QML rendering will fail, because they only use 2.1
f.setProfile(QSurfaceFormat.CompatibilityProfile)
QSurfaceFormat.setDefaultFormat(f)
qmlRegisterType(ModelUnderlay, 'OpenGLUnderQml', 1, 0, 'ModelUnderlay')
app = QGuiApplication(sys.argv)
view = QQuickView()
# view.setFormat(f)
view.setPersistentSceneGraph(True)
view.setPersistentOpenGLContext(True)
view.setResizeMode(QQuickView.SizeRootObjectToView) # Set for the object to resize correctly
view.setSource(QUrl('ModelWindow.qml'))
view.show()
app.exec()
from PyQt5.QtWidgets import QApplication, QTreeWidget, QTreeWidgetItem, QAbstractItemView, QDockWidget
from OpenGL import GL as gl
import ctypes
import numpy as np
import math
from .linalg import quaternion as q
from .transforms import *
from .gloo import *
# import threading
DEFAULT_FORMAT = QSurfaceFormat()
DEFAULT_FORMAT.setVersion(3, 3)
DEFAULT_FORMAT.setProfile(QSurfaceFormat.CoreProfile)
DEFAULT_FORMAT.setStereo(False)
DEFAULT_FORMAT.setSwapBehavior(QSurfaceFormat.DoubleBuffer)
DEFAULT_FORMAT.setDepthBufferSize(24)
DEFAULT_FORMAT.setSamples(4)
class OpenGLWindow(QWindow):
def __init__(self, parent=None):
super(OpenGLWindow, self).__init__(parent)
self.m_update_pending = False
self.m_animating = False
self.m_context = None
self.m_gl = None
def init():
''' Startup initialisation of OpenGL. '''
if gl is None:
version, profile = get_profile_settings()
# Initialise application-wide GL version
fmt = QSurfaceFormat()
fmt.setVersion(*version)
# profile = QSurfaceFormat.CoreProfile if sys.platform == 'darwin' else QSurfaceFormat.CompatibilityProfile
fmt.setProfile(profile or QSurfaceFormat.CompatibilityProfile)
QSurfaceFormat.setDefaultFormat(fmt)
if profile is not None:
# Use a dummy context to get GL functions
glprofile = QOpenGLVersionProfile(fmt)
ctx = QOpenGLContext()
globals()['gl'] = ctx.versionFunctions(glprofile)
# Check and set OpenGL capabilities
if not glprofile.hasProfiles():
raise RuntimeError(
'No OpenGL version >= 3.3 support detected for this system!'
)
else:
# If profile was none, PyQt5 is not shipped with any OpenGL function modules. Use PyOpenGL instead
print(
"Couldn't find OpenGL functions in Qt. Falling back to PyOpenGL"
)
globals()['gl'] = importlib.import_module('OpenGL.GL')
globals()['_glvar_sizes'] = {
gl.GL_FLOAT: 1,
gl.GL_FLOAT_VEC2: 2,
gl.GL_FLOAT_VEC3: 3,
gl.GL_FLOAT_VEC4: 4,
gl.GL_FLOAT_MAT2: 4,
gl.GL_FLOAT_MAT3: 9,
gl.GL_FLOAT_MAT4: 16,
gl.GL_FLOAT_MAT2x3: 6,
gl.GL_FLOAT_MAT2x4: 8,
gl.GL_FLOAT_MAT3x2: 6,
gl.GL_FLOAT_MAT3x4: 12,
gl.GL_FLOAT_MAT4x2: 8,
gl.GL_FLOAT_MAT4x3: 12,
gl.GL_INT: 1,
gl.GL_INT_VEC2: 2,
gl.GL_INT_VEC3: 3,
gl.GL_INT_VEC4: 4,
gl.GL_UNSIGNED_INT: 1,
gl.GL_UNSIGNED_INT_VEC2: 2,
gl.GL_UNSIGNED_INT_VEC3: 3,
gl.GL_UNSIGNED_INT_VEC4: 4,
gl.GL_DOUBLE: 1,
gl.GL_DOUBLE_VEC2: 2,
gl.GL_DOUBLE_VEC3: 3,
gl.GL_DOUBLE_VEC4: 4,
gl.GL_DOUBLE_MAT2: 4,
gl.GL_DOUBLE_MAT3: 9,
gl.GL_DOUBLE_MAT4: 16,
gl.GL_DOUBLE_MAT2x3: 6,
gl.GL_DOUBLE_MAT2x4: 8,
gl.GL_DOUBLE_MAT3x2: 6,
gl.GL_DOUBLE_MAT3x4: 12,
gl.GL_DOUBLE_MAT4x2: 8,
gl.GL_DOUBLE_MAT4x3: 12
}
return gl
def initialize_opengl():
surface_format = QSurfaceFormat()
surface_format.setProfile(QSurfaceFormat.CoreProfile)
surface_format.setVersion(4, 5)
surface_format.setSamples(4)
QSurfaceFormat.setDefaultFormat(surface_format)
self.translate = False
def wheelEvent(self,event) :
numPixels = event.pixelDelta();
if numPixels.x() > 0 :
self.modelPos.m_z += self.ZOOM
elif numPixels.x() < 0 :
self.modelPos.m_z -= self.ZOOM
self.update();
if __name__ == '__main__':
app = QApplication(sys.argv)
format=QSurfaceFormat()
format.setSamples(4);
format.setMajorVersion(4);
format.setMinorVersion(1);
format.setProfile(QSurfaceFormat.CoreProfile);
# now set the depth buffer to 24 bits
format.setDepthBufferSize(24);
# set that as the default format for all windows
QSurfaceFormat.setDefaultFormat(format);
window = MainWindow()
window.setFormat(format)
window.resize(1024,720)
window.show()
sys.exit(app.exec_())
#!/usr/bin/env python3
import sys
# Check if we're in a virtual environment.
if sys.prefix == sys.base_prefix:
raise Exception('Not using a virtual environment! (See README.md)')
from PyQt5.QtWidgets import QApplication
from PyQt5.QtGui import QSurfaceFormat
from widgets import *
if __name__ == '__main__':
qsf = QSurfaceFormat()
qsf.setRenderableType(QSurfaceFormat.OpenGL)
qsf.setProfile(QSurfaceFormat.CoreProfile)
qsf.setVersion(4, 1)
QSurfaceFormat.setDefaultFormat(qsf)
app = QApplication(sys.argv)
imp = IMPWindow()
sys.exit(app.exec_())
from PIL import Image
from PyQt5 import QtCore, QtWidgets
from PyQt5.QtGui import QSurfaceFormat
from PyQt5.QtWidgets import QFormLayout, QHBoxLayout, QInputDialog, QLabel, QLineEdit
from PyQt5.QtWidgets import QMessageBox, QOpenGLWidget, QPushButton, QVBoxLayout
from PyQt5.QtWidgets import QWidget
from strike_with_a_pose.scene import Scene
from strike_with_a_pose.settings import INITIAL_PARAMS, MODEL, TRUE_CLASS
INSTRUCTIONS_F = pkg_resources.resource_filename("strike_with_a_pose",
"instructions.html")
ABOUT_F = pkg_resources.resource_filename("strike_with_a_pose", "about.html")
fmt = QSurfaceFormat()
fmt.setVersion(3, 3)
fmt.setProfile(QSurfaceFormat.CoreProfile)
fmt.setSwapInterval(1)
fmt.setDepthBufferSize(24)
fmt.setSamples(3)
QSurfaceFormat.setDefaultFormat(fmt)
class WindowInfo:
def __init__(self):
self.size = (0, 0)
self.mouse = (0, 0)
self.wheel = 0
self.time = 0
self.ratio = 1.0
self.viewport = (0, 0, 0, 0)
self.keys = np.full(256, False)
import sys
from PyQt5.QtGui import QSurfaceFormat
from PyQt5.QtWidgets import QApplication
from mcjsontool.ui.ui import JSONToolUI
import mcjsontool.plugin
if __name__ == "__main__":
app = QApplication(sys.argv)
format_ = QSurfaceFormat()
format_.setVersion(4, 3)
format_.setDepthBufferSize(24)
format_.setProfile(QSurfaceFormat.CoreProfile)
QSurfaceFormat.setDefaultFormat(format_)
# temp: setup temp workspac
w = JSONToolUI()
w.show()
sys.exit(app.exec_())
class OpenGLWindow(QWindow):
def __init__(self, parent=None):
super(OpenGLWindow, self).__init__(parent)
self.m_update_pending = False
self.m_animating = False
self.m_context = None
self.setSurfaceType(QWindow.OpenGLSurface)
def initialize(self):
pass
def setAnimating(self, animating):
self.m_animating = animating
if animating:
self.renderLater()
def renderLater(self):
if not self.m_update_pending:
self.m_update_pending = True
QGuiApplication.postEvent(self, QEvent(QEvent.UpdateRequest))
def renderNow(self):
if not self.isExposed():
return
self.m_update_pending = False
needsInitialize = False
if self.m_context is None:
self.m_context = QOpenGLContext(self)
self.surface_format = QSurfaceFormat()
self.surface_format.setVersion(4, 1)
self.surface_format.setProfile(QSurfaceFormat.CoreProfile)
self.m_context.setFormat(self.surface_format)
self.m_context.create()
needsInitialize = True
self.m_context.makeCurrent(self)
if needsInitialize:
self.initialize()
self.render()
self.m_context.swapBuffers(self)
if self.m_animating:
self.renderLater()
def event(self, event):
if event.type() == QEvent.UpdateRequest:
self.renderNow()
return True
return super(OpenGLWindow, self).event(event)
def exposeEvent(self, event):
self.renderNow()
def resizeEvent(self, event):
self.renderNow()
self.spinYFace = 0
self.modelPos.set(Vec3.zero())
elif key == Qt.Key.Key_L:
self.transformLight ^= True
self.update()
if __name__ == '__main__':
app = QApplication(sys.argv)
format = QSurfaceFormat()
format.setSamples(4)
format.setMajorVersion(4)
format.setMinorVersion(1)
print(format.profile())
if PyQtVersion == 5:
format.setProfile(QSurfaceFormat.CoreProfile)
else:
format.setProfile(QSurfaceFormat.OpenGLContextProfile.CoreProfile)
# now set the depth buffer to 24 bits
format.setDepthBufferSize(24)
# set that as the default format for all windows
QSurfaceFormat.setDefaultFormat(format)
window = MainWindow()
window.setFormat(format)
window.resize(1024, 720)
window.show()
if PyQtVersion == 5:
sys.exit(app.exec_())
else: