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 __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, 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 __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
class OpenGLApp(QMainWindow): """Main window.""" def __init__(self, versionprofile=None, *args, **kwargs): """Initialize with an OpenGL Widget.""" super(OpenGLApp, self).__init__(*args, **kwargs) self.widget = QOpenGLControllerWidget(versionprofile=versionprofile) self.setMinimumSize(400, 400) self.setCentralWidget(self.widget) self.show() if __name__ == '__main__': import sys fmt = QSurfaceFormat() fmt.setVersion(4, 1) fmt.setProfile(QSurfaceFormat.CoreProfile) fmt.setSamples(4) fmt.setSwapInterval(0) QSurfaceFormat.setDefaultFormat(fmt) vp = QOpenGLVersionProfile() vp.setVersion(4, 1) vp.setProfile(QSurfaceFormat.CoreProfile) app = QApplication(sys.argv) window = OpenGLApp(versionprofile=vp) window.show() sys.exit(app.exec_())
from PyQt5.QtCore import QUrl from PyQt5.QtGui import QGuiApplication, QOpenGLVersionProfile, QSurfaceFormat from PyQt5.QtQuick import QQuickView from PyQt5.QtQml import qmlRegisterType 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)
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_())
QSurfaceFormat, QWindow) 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
from PyQt5.QtGui import QSurfaceFormat format = QSurfaceFormat() format.setDepthBufferSize(24) format.setStencilBufferSize(8) format.setVersion(3, 3) format.setProfile(QSurfaceFormat.CoreProfile) QSurfaceFormat.setDefaultFormat(format)
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 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)
#!/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_())
def initialize_opengl(): surface_format = QSurfaceFormat() surface_format.setProfile(QSurfaceFormat.CoreProfile) surface_format.setVersion(4, 5) surface_format.setSamples(4) QSurfaceFormat.setDefaultFormat(surface_format)
from OpenGL import GL 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)
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()