def initializeGL(self):
qDebug("initializeGL()")
if self.logger:
self.logger.initialize()
self.logger.messageLogged.connect(lambda message: qDebug(self.__tr("OpenGL debug message: {0}").fomat(message.message())))
self.logger.startLogging()
gl = QOpenGLContext.currentContext().versionFunctions(glVersionProfile)
QOpenGLContext.currentContext().aboutToBeDestroyed.connect(self.cleanup)
self.clean = False
fragmentShader = None
vertexShader = vertexShader2D
if self.ddsFile.isCubemap:
fragmentShader = fragmentShaderCube
vertexShader = vertexShaderCube
if QOpenGLContext.currentContext().hasExtension(b"GL_ARB_seamless_cube_map"):
GL_TEXTURE_CUBE_MAP_SEAMLESS = 0x884F
gl.glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS)
elif self.ddsFile.glFormat.samplerType == "F":
fragmentShader = fragmentShaderFloat
elif self.ddsFile.glFormat.samplerType == "UI":
fragmentShader = fragmentShaderUInt
else:
fragmentShader = fragmentShaderSInt
self.program = QOpenGLShaderProgram(self)
self.program.addShaderFromSourceCode(QOpenGLShader.Vertex, vertexShader)
self.program.addShaderFromSourceCode(QOpenGLShader.Fragment, fragmentShader)
self.program.bindAttributeLocation("position", 0)
self.program.bindAttributeLocation("texCoordIn", 1)
self.program.link()
self.transparecyProgram = QOpenGLShaderProgram(self)
self.transparecyProgram.addShaderFromSourceCode(QOpenGLShader.Vertex, transparencyVS)
self.transparecyProgram.addShaderFromSourceCode(QOpenGLShader.Fragment, transparencyFS)
self.transparecyProgram.bindAttributeLocation("position", 0)
self.transparecyProgram.link()
self.vao = QOpenGLVertexArrayObject(self)
vaoBinder = QOpenGLVertexArrayObject.Binder(self.vao)
self.vbo = QOpenGLBuffer(QOpenGLBuffer.VertexBuffer)
self.vbo.create()
self.vbo.bind()
theBytes = struct.pack("%sf" % len(vertices), *vertices)
self.vbo.allocate(theBytes, len(theBytes))
gl.glEnableVertexAttribArray(0)
gl.glEnableVertexAttribArray(1)
gl.glVertexAttribPointer(0, 4, gl.GL_FLOAT, False, 6 * 4, 0)
gl.glVertexAttribPointer(1, 2, gl.GL_FLOAT, False, 6 * 4, 4 * 4)
self.texture = self.ddsFile.asQOpenGLTexture(gl, QOpenGLContext.currentContext())
def setupGL(self):
self.program = QOpenGLShaderProgram(self.context())
info("PROGRAM", self.program)
# addShaderFromSourceCode() only returns a bool telling whether everything went well
if self.program.addShaderFromSourceCode(QOpenGLShader.Vertex,
self.vertexShaderSource):
info("VERTEX SHADER",
"Managed to load and parse the vertex shader")
if self.program.addShaderFromSourceCode(QOpenGLShader.Fragment,
self.fragmentShaderSource):
info("FRAGMENT SHADER",
"Managed to load and parse the fragment shader")
# Compile and bind the shader program to the current context
self.program.link()
self.program.bind()
# Tell GL that whenever we run glClear, this is the color that
# should be used. We only need to do this once.
self.gl.glClearColor(0.1, 0.1, 0.1, 1.0)
self.dumpGLLogMessages("setupGL()")
def __init__(self, workspace, surface: QSurface):
super().__init__()
self.surf = surface
prof = QOpenGLVersionProfile()
prof.setVersion(2, 0)
self.vao = GL.glGenVertexArrays(1)
self.vbo, self.vbo2 = GL.glGenBuffers(2)
self.texture = -1
self.current_model: BlockModel = None
self.workspace = workspace
self.array1, array2 = None, None
self.shader = QOpenGLShaderProgram()
self.shader.addShaderFromSourceFile(QOpenGLShader.Vertex,
"shader/block.vertex.glsl")
self.shader.addShaderFromSourceFile(QOpenGLShader.Fragment,
"shader/block.fragment.glsl")
self.shader.link()
self.proj_mat = glm.perspective(
1.57,
self.surf.size().width() / self.surf.size().height(), 0.1, 100)
self.texture = GL.glGenTextures(1)
def initializeGL(self):
version_profile = QOpenGLVersionProfile()
version_profile.setVersion(2, 0)
self.gl = self.context().versionFunctions(version_profile)
self.gl.initializeOpenGLFunctions()
self.makeObject()
self.gl.glEnable(self.gl.GL_DEPTH_TEST)
self.gl.glEnable(self.gl.GL_CULL_FACE)
vshader = QOpenGLShader(QOpenGLShader.Vertex, self)
vshader.compileSourceCode(self.vsrc)
fshader = QOpenGLShader(QOpenGLShader.Fragment, self)
fshader.compileSourceCode(self.fsrc)
self.program = QOpenGLShaderProgram()
self.program.addShader(vshader)
self.program.addShader(fshader)
self.program.bindAttributeLocation("vertex",
self.PROGRAM_VERTEX_ATTRIBUTE)
self.program.bindAttributeLocation("texCoord",
self.PROGRAM_TEXCOORD_ATTRIBUTE)
self.program.link()
self.program.bind()
self.program.setUniformValue("texture", 0)
self.program.enableAttributeArray(self.PROGRAM_VERTEX_ATTRIBUTE)
self.program.enableAttributeArray(self.PROGRAM_TEXCOORD_ATTRIBUTE)
self.program.setAttributeArray(self.PROGRAM_VERTEX_ATTRIBUTE,
self.vertices)
self.program.setAttributeArray(self.PROGRAM_TEXCOORD_ATTRIBUTE,
self.texCoords)
def initializeGL(self):
self.makeObject()
glEnable(GL_DEPTH_TEST)
glEnable(GL_CULL_FACE)
vshader = QOpenGLShader(QOpenGLShader.Vertex, self)
vshader.compileSourceCode(self.vsrc)
fshader = QOpenGLShader(QOpenGLShader.Fragment, self)
fshader.compileSourceCode(self.fsrc)
self.program = QOpenGLShaderProgram(self)
self.program.addShader(vshader)
self.program.addShader(fshader)
self.program.bindAttributeLocation('vertex',
self.PROGRAM_VERTEX_ATTRIBUTE)
self.program.bindAttributeLocation('texCoord',
self.PROGRAM_TEXCOORD_ATTRIBUTE)
self.program.link()
self.program.bind()
self.program.setUniformValue('texture', 0)
self.program.enableAttributeArray(self.PROGRAM_VERTEX_ATTRIBUTE)
self.program.enableAttributeArray(self.PROGRAM_TEXCOORD_ATTRIBUTE)
self.program.setAttributeArray(self.PROGRAM_VERTEX_ATTRIBUTE,
self.vertices)
self.program.setAttributeArray(self.PROGRAM_TEXCOORD_ATTRIBUTE,
self.texCoords)
def initializeGL(self):
GL.glClearColor(0.15, 0.15, 0.15, 1.0)
GL.glEnable(GL.GL_DEPTH_TEST)
GL.glEnable(GL.GL_LIGHT0)
GL.glEnable(GL.GL_LIGHTING)
self.program = QOpenGLShaderProgram(self)
self.program.addShaderFromSourceCode(QOpenGLShader.Vertex,
self.vertexShaderSource)
self.program.addShaderFromSourceCode(QOpenGLShader.Fragment,
self.fragmentShaderSource)
self.program.link()
self.xRot = 0
self.yRot = 0
self.zRot = 0
self.vertexAtr = self.program.attributeLocation("vertexAtr")
self.colAttr = self.program.attributeLocation("colAttr")
self.projectionMatrixAttr = self.program.uniformLocation(
"projectionMatrix")
self.modelViewMatrixAttr = self.program.uniformLocation(
"modelViewMatrix")
self.normalMatrixAttr = self.program.uniformLocation("normalMatrix")
self.normalAttr = self.program.attributeLocation("normalAttr")
self.controlPtsAttr = self.program.attributeLocation("controlPtsAttr")
self.pressClick = QVector3D(0, 0, 0)
self.releaseClick = QVector3D(0, 0, 0)
self.programid = 0
def initializeGL(self):
self.resized = True
self.output = zeros((100, 100))
logger.debug("initializeGL")
self.programTex = QOpenGLShaderProgram()
self.programTex.addShaderFromSourceCode(QOpenGLShader.Vertex,
vertShaderTex)
self.programTex.addShaderFromSourceCode(QOpenGLShader.Fragment,
fragShaderTex)
self.programTex.link()
self.programTex.bind()
logger.debug("GLSL programTex log:%s", self.programTex.log())
glClearColor(0, 0, 0, 1.)
self.texture = None
self.quadCoord = np.array([[-1., -1., 0.], [1., -1., 0.], [1., 1., 0.],
[1., 1., 0.], [-1., 1., 0.], [-1., -1.,
0.]])
self.quadCoordTex = np.array([[0, 0], [1., 0.], [1., 1.], [1., 1.],
[0, 1.], [0, 0]])
self.set_colormap(spimagine.config.__DEFAULTCOLORMAP__)
glDisable(GL_DEPTH_TEST)
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
def paint(self):
# for Darwin, it's a must
if pf.uname().system == 'Darwin':
global GL
GL = self._window.openglContext().versionFunctions()
w = self._viewport_size.width()
h = self._viewport_size.height()
GL.glViewport(0, 0, int(w), int(h))
if self._shader_program is None:
self._shader_program = QOpenGLShaderProgram()
self._shader_program.addShaderFromSourceFile(
QOpenGLShader.Vertex, 'shaders/OpenGL_2_1/vertex.glsl')
self._shader_program.addShaderFromSourceFile(
QOpenGLShader.Fragment, 'shaders/OpenGL_2_1/fragment.glsl')
self._shader_program.bindAttributeLocation('position', 0)
self._shader_program.bindAttributeLocation('color', 1)
self._shader_program.link()
self._shader_program.bind()
self._shader_program.enableAttributeArray(0)
self._shader_program.enableAttributeArray(1)
self._shader_program.setAttributeArray(0, positions)
self._shader_program.setAttributeArray(1, colors)
if self._projection_type == 0:
self._projection_matrix = self._perspective_projection_matrix
elif self._projection_type == 1:
self._projection_matrix = self._orthographic_projection_matrix
self._model_matrix = self.build_rotation_matrix()
self._shader_program.setUniformValue(
'model_matrix', QMatrix4x4(self._model_matrix.flatten().tolist()))
self._shader_program.setUniformValue(
'view_matrix',
QMatrix4x4(self._camera.get_view_matrix().flatten().tolist()))
self._shader_program.setUniformValue(
'projection_matrix',
QMatrix4x4(self._projection_matrix.flatten().tolist()))
GL.glClearColor(0.2, 0.2, 0.2, 1)
GL.glEnable(GL.GL_DEPTH_TEST)
GL.glClear(GL.GL_COLOR_BUFFER_BIT)
GL.glDrawArrays(GL.GL_TRIANGLES, 0, 3)
self._shader_program.disableAttributeArray(0)
self._shader_program.disableAttributeArray(1)
self._shader_program.release()
# Restore the OpenGL state for QtQuick rendering
self._window.resetOpenGLState()
self._window.update()
def setVertexShader(self, shader):
if not self._shader_program:
self._shader_program = QOpenGLShaderProgram()
if not self._shader_program.addShaderFromSourceCode(
QOpenGLShader.Vertex, shader):
Logger.log("e", "Vertex shader failed to compile: %s",
self._shader_program.log())
def _shader_from_file(self, fname_vert, fname_frag):
shader = QOpenGLShaderProgram()
shader.addShaderFromSourceFile(QOpenGLShader.Vertex, fname_vert)
shader.addShaderFromSourceFile(QOpenGLShader.Fragment, fname_frag)
shader.link()
shader.bind()
logger.debug("GLSL program log:%s", shader.log())
return shader
def setFragmentShader(self, shader):
if not self._shader_program:
self._shader_program = QOpenGLShaderProgram()
if not self._shader_program.addShaderFromSourceCode(
QOpenGLShader.Fragment, shader):
Logger.log("e", "Fragment shader failed to compile: %s",
self._shader_program.log())
def __init__(self):
self.invert = None
self.shader_program = QOpenGLShaderProgram()
self.vertex_attribute_object = None
self.vertex_position = None
self.projection = QMatrix4x4()
self.model = QMatrix4x4()
self.view = QMatrix4x4()
def __init__(self, parent=None):
super().__init__(parent)
self.scene_shader_program = QOpenGLShaderProgram()
self.screen_shader_program = QOpenGLShaderProgram()
x0 = -0.5
y0 = -0.5
width = 1
self.vertex_data = np.array([
x0, y0, 0.0,
x0 + width, y0, 0.0,
x0 + width, y0 + width, 0.0,
x0 + width, y0 + width, 0.0,
x0, y0 + width, 0.0,
x0, y0, 0.0,
], dtype=np.float32)
def setGeometryShader(self, shader):
if not self._shader_program:
self._shader_program = QOpenGLShaderProgram()
if not self._shader_program.addShaderFromSourceCode(
QOpenGLShader.Geometry, shader):
Logger.log("e", "Geometry shader failed to compile: %s",
self._shader_program.log())
def setGeometryShader(self, shader: str) -> bool:
if not self._shader_program:
self._shader_program = QOpenGLShaderProgram()
if not cast(QOpenGLShaderProgram, self._shader_program).addShaderFromSourceCode(QOpenGLShader.Geometry, shader):
Logger.log("e", "Geometry shader failed to compile: %s", self._shader_program.log())
return False
return True
def paint(self):
if not self.m_program:
self.gl.initializeOpenGLFunctions()
self.m_program = QOpenGLShaderProgram(self)
self.m_program.addShaderFromSourceCode(
QOpenGLShader.Vertex, "attribute highp vec4 vertices;"
"varying highp vec2 coords;"
"void main() {"
" gl_Position = vertices;"
" coords = vertices.xy;"
"}")
self.m_program.addShaderFromSourceCode(
QOpenGLShader.Fragment, "uniform lowp float t;"
"varying highp vec2 coords;"
"void main() {"
" lowp float i = 1. - (pow(abs(coords.x), 4.) + pow(abs(coords.y), 4.));"
" i = smoothstep(t - 0.8, t + 0.8, i);"
" i = floor(i * 20.) / 20.;"
" gl_FragColor = vec4(coords * .5 + .5, i, i);"
"}")
self.m_program.bindAttributeLocation("vertices", 0)
self.m_program.link()
self.m_program.bind()
self.m_program.enableAttributeArray(0)
values = [(-1, -1), (1, -1), (-1, 1), (1, 1)]
self.m_program.setAttributeArray(0, values)
self.m_program.setUniformValue("t", self.m_t)
#print("DATA:",self.m_viewportSize.width(), self.m_viewportSize.height(), self.m_t)#, self.gl.glViewport)
self.gl.glViewport(0, 0, self.m_viewportSize.width(),
self.m_viewportSize.height())
self.gl.glDisable(self.gl.GL_DEPTH_TEST)
self.gl.glClearColor(0, 0, 0, 1)
self.gl.glClear(self.gl.GL_COLOR_BUFFER_BIT)
self.gl.glEnable(self.gl.GL_BLEND)
self.gl.glBlendFunc(self.gl.GL_SRC_ALPHA, self.gl.GL_ONE)
self.gl.glDrawArrays(self.gl.GL_TRIANGLE_STRIP, 0, 4)
self.m_program.disableAttributeArray(0)
self.m_program.release()
def setFragmentShader(self, shader):
"""Set the fragment shader to use.
:param shader: :type{string} The fragment shader to use.
"""
if not self._shader_program:
self._shader_program = QOpenGLShaderProgram()
if not self._shader_program.addShaderFromSourceCode(QOpenGLShader.Fragment, shader):
Logger.log("e", "Fragment shader failed to compile: %s", self._shader_program.log())
def __init__(self, processor, df, parent=None):
super().__init__(parent)
self.parent = parent
self.processor = processor
# Data
self.df = df
# UI
self.setupUi(self)
self.setupControls()
self.keyPressEvent = self.keyPressed
self.mouseMoveEvent = self.mouseMoved
# Control & Display
self.mouse_grabbed = False
self.camera_pos = QVector3D(0.5, 0.5, -2) # Start camera position
self.center = QVector3D(0.5, 0, 0.5) # Center of object
self.rot_center = QVector3D(0.5, 0.5, 0.5) # Center of rotation
self.camera_rot = QVector3D(0, 0, 1) # Camera rotation
self.scale_vec = QVector3D(1, 1, 1) # Object scale
self.real_prop = processor.get_real_scaling() # val to lat
self.light_pos = QVector3D(self.xLightSpinBox.value(),
self.yLightSpinBox.value(),
self.zLightSpinBox.value())
self.ambient = self.ambientSlider.value() / 100
self.diffuse = self.diffuseSlider.value() / 100
self.alpha = self.alphaSlider.value() / 100 # Transparency
# Drawing
self.normals = []
self.colors = []
self.coords_array = []
# !> len(self.normals) == len(self.colors) == len(self.coords_array)
self.update_light = False # Update for light is needed
self.update_buffer = False # Update for whole buffer is needed
self.show_grid = self.gridCheckBox.isChecked()
self.show_contour = self.contourCheckBox.isChecked()
self.contour_levels = self.contourLevelSpinBox.value()
self.show_light_lines = True
self.grid_freq = 10
self.grid_color = QVector4D(1, 1, 1, 1)
self.contour_color = QVector4D(1, 1, 1, 1)
self.light_line_color = QVector4D(1, 0.6, 0, 1)
self.prepareScene()
self.updateUi()
self.shaders = QOpenGLShaderProgram()
self.openGLWidget.initializeGL = self.initializeGL
self.openGLWidget.paintGL = self.paintGL
def __init__(self, parent):
super().__init__(parent)
self.shader_program = QOpenGLShaderProgram(parent=self)
self.inverted = False
self.vertex_attribute_object = None
self.vertex_data = np.array([
0.0, 1.0, 0.0, 1.0, 1.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 1.0, 0.0
],
dtype=np.float32)
self.vertex_position_uniform = None
def initialize(self):
self.m_program = QOpenGLShaderProgram(self)
self.m_program.addShaderFromSourceCode(QOpenGLShader.Vertex,
self.vertexShaderSource)
self.m_program.addShaderFromSourceCode(QOpenGLShader.Fragment,
self.fragmentShaderSource)
self.m_program.link()
self.m_posAttr = self.m_program.attributeLocation('posAttr')
self.m_colAttr = self.m_program.attributeLocation('colAttr')
self.m_matrixUniform = self.m_program.uniformLocation('matrix')
def setVertexShader(self, shader: str) -> bool:
"""Set the vertex shader to use.
:param shader: :type{string} The vertex shader to use.
"""
if not self._shader_program:
self._shader_program = QOpenGLShaderProgram()
if not cast(QOpenGLShaderProgram, self._shader_program).addShaderFromSourceCode(QOpenGLShader.Vertex, shader):
Logger.log("e", "Vertex shader failed to compile: %s", self._shader_program.log())
return False
return True
def create_shader(self):
self.m_program = QOpenGLShaderProgram(self)
self.m_program.addShaderFromSourceFile(QOpenGLShader.Vertex, "shaders/chapter2.vs.glsl")
self.m_program.addShaderFromSourceFile(QOpenGLShader.Fragment, "shaders/chapter2.fs.glsl")
self.m_program.link()
self.m_vertex = self.m_program.attributeLocation("m_vertex")
self.m_offset = self.m_program.attributeLocation("m_offset")
self.m_color = self.m_program.attributeLocation("m_color")
return self
def __init__(self, context, numAttibutesInvbo=1):
super(GLProgram, self).__init__()
self._fakeTimer = 0
self.num_of_elements_in_vbo = numAttibutesInvbo
self.vertex_elements = 3
self._program = QOpenGLShaderProgram(context)
self._textures = []
self._images = []
self._vertexBufferObject = QOpenGLBuffer(QOpenGLBuffer.VertexBuffer)
self._indexesBufferObject = QOpenGLBuffer(QOpenGLBuffer.IndexBuffer)
self._vertexArrayObject = QOpenGLVertexArrayObject()
self._vertices = []
self._indices = []
self.attributes = []
def _update(self):
if self._linkDirty:
self._program = QOpenGLShaderProgram()
if self._vertexShader is not None:
self._program.addShaderFromSourceCode(QOpenGLShader.Vertex,
self._vertexShader)
if self._geometryShader is not None:
self._program.addShaderFromSourceCode(QOpenGLShader.Geometry,
self._geometryShader)
if self._fragmentShader is not None:
self._program.addShaderFromSourceCode(QOpenGLShader.Fragment,
self._fragmentShader)
self._program.link()
self._linkDirty = False
def __init__(self, parent=None):
super().__init__(parent)
self.shader_program = QOpenGLShaderProgram()
width = 1
half_width = width / 2
rect = QRectF(-half_width, -half_width, width, width)
self.setRect(rect)
self.vertex_attribute_object = None
self.vertex_data = np.array([
-half_width, -half_width, 0.0, -half_width + width, -half_width,
0.0, -half_width + width, -half_width + width, 0.0,
-half_width + width, -half_width + width, 0.0, -half_width,
half_width, 0.0, -half_width, -half_width, 0.0
],
dtype=np.float32)
self.vertex_position_uniform = None
def __init__(self, homography_transform, parent=None):
super().__init__(parent)
self._background_colour = None
self._drawables = []
self._image = None
self._intensity_mask = None
self.centre_x_uniform = None
self.centre_y_uniform = None
self.crosshair = Crosshair(self)
self.height_uniform = None
self.image_to_upload = None
self.gl_initialised = False
self.shape_uniform = None
self.max_height_uniform = None
self.rotation_uniform = None
self.texture = -1
self.texture_uploaded = False
self.width_x_uniform = None
self.width_y_uniform = None
self.homography_transform = homography_transform
self.projection_matrix = QMatrix4x4()
self.view_matrix = QMatrix4x4()
self.set_background_colour(0)
self.shader_program = QOpenGLShaderProgram()
self._show_crosshair = False
self._show_scale_bar = False
self._crosshair_thickness = 1
self._gaussian_shape = QVector2D()
self._image_to_render = None
self._inverted = False
self._scale_bar_thickness = 1
self._scale_bar_width = 10
self._use_homography = False
self._use_intensity_mask = False
self.gaussian = Gaussian()
self.transform = QTransform()
self.dx = 0
self.dy = 0
self.rotation = 0
self.scale_value = 1
self.setWindowTitle('Stimulus Window')
self.homography_transform.matrixChanged.connect(self.update_image)
def init_shaders(self):
program = QOpenGLShaderProgram(self)
if not program.addShaderFromSourceFile(
QOpenGLShader.Vertex, get_resources_path("shader.vert")):
return None
if not program.addShaderFromSourceFile(
QOpenGLShader.Fragment, get_resources_path("shader.frag")):
return None
if not program.link():
return None
if not program.bind():
return None
return program
def __init__(self):
self.initialised = False
self.shader_program = QOpenGLShaderProgram()
self.vertex_position = None
self.texture = 0
self.frame_buffer = 0
self.recreate_frame_buffer = True
x0 = -1
y0 = -1
width = 2
self.vertex_data = np.array([
x0, y0, 0.0, 0.0, 0.0, x0 + width, y0, 0.0, 1.0, 0.0, x0 + width,
y0 + width, 0.0, 1.0, 1.0, x0 + width, y0 + width, 0.0, 1.0, 1.0,
x0, y0 + width, 0.0, 0.0, 1.0, x0, y0, 0.0, 0.0, 0.0
],
dtype=np.float32)
def __init__(self, parent):
super().__init__(parent)
self.shader_program = QOpenGLShaderProgram(self)
self.vertex_data = np.array([
# X, Y, Z U, V
-LOC, LOC, 0.0, 0.0, 1.0,
LOC, LOC, 0.0, 1.0, 1.0,
LOC, -LOC, 0.0, 1.0, 0.0,
LOC, -LOC, 0.0, 1.0, 0.0,
-LOC, -LOC, 0.0, 0.0, 0.0,
-LOC, LOC, 0.0, 0.0, 1.0,
], dtype=np.float32)
self._image = None#QImage()
self.vao = None
self.vertex_position_uniform = -1
self.
def __init__(self):
super(LogoRenderer, self).__init__()
self.m_fAngle = None
self.m_fScale = None
self.vertices = []
self.normals = []
self.program1 = QOpenGLShaderProgram()
self.vertexAttr1 = 0
self.normalAttr1 = 0
self.matrixUniform1 = 0
ver = QOpenGLVersionProfile()
ver.setVersion(2, 1)
cntx = QOpenGLContext.currentContext()
#print("QOpenGLContext:", cntx, ver)
fmt = cntx.format()
fmt.setVersion(2, 1)
cntx.setFormat(fmt)
self.gl = cntx.versionFunctions(ver)
