Beispiel #1
0
    def __init__(self, file_path, make_opengl_textures=True):
        image_reader = QImageReader(file_path)
        self.is_animated = image_reader.supportsAnimation()
        if self.is_animated:
            self.num_frames = image_reader.imageCount()
            # -1 means loop infinitely, 0 means no loop, > 0 is finite # of loops
            self.loop_count = image_reader.loopCount()
            self.loops_remaining = 0
            self.frames = []
            self.delays = []
            while image_reader.currentImageNumber() < image_reader.imageCount() - 1:
                self.frames.append(image_reader.read())
                self.delays.append(image_reader.nextImageDelay())

            if make_opengl_textures:
                self.open_gl_textures = [QOpenGLTexture(this_frame.mirrored()) for this_frame in self.frames]
                self.made_opengl_textures = True

            self.frames_and_delays = zip(self.frames, self.delays)

            self.current_frame = 0
            self.animating = False
        else:
            self.image = image_reader.read()
            assert isinstance(self.image, QImage)
            if make_opengl_textures:
                self.open_gl_texture = QOpenGLTexture(self.image.mirrored())
                self.made_opengl_textures = True
Beispiel #2
0
    def __init__(self):
        super().__init__()

        self._qt_texture = QOpenGLTexture(QOpenGLTexture.Target2D)
        self._gl = OpenGL.getInstance().getBindingsObject()
        self._file_name = None
        self._image = None
Beispiel #3
0
    def __init__(self, open_gl_binding_object):
        super().__init__()

        self._qt_texture = QOpenGLTexture(QOpenGLTexture.Target2D)
        self._gl = open_gl_binding_object
        self._file_name = None
        self._image = None
Beispiel #4
0
    def __init__(self):
        super().__init__()

        self._qt_texture = QOpenGLTexture(QOpenGLTexture.Target2D)
        self._qt_texture.setMinMagFilters(QOpenGLTexture.Linear,
                                          QOpenGLTexture.Linear)
        self._gl = OpenGL.getInstance().getBindingsObject()
Beispiel #5
0
class QtTexture(Texture):
    def __init__(self):
        super().__init__()

        self._qt_texture = QOpenGLTexture(QOpenGLTexture.Target2D)
        self._gl = OpenGL.getInstance().getBindingsObject()
        self._file_name = None

    def getTextureId(self):
        return self._qt_texture.textureId()

    def bind(self, unit):
        if not self._qt_texture.isCreated():
            if self._file_name != None:
                image = QImage(self._file_name).mirrored()
            else:
                image = QImage(1, 1, QImage.Format_ARGB32)
            self._qt_texture.setData(image)
            self._qt_texture.setMinMagFilters(QOpenGLTexture.Linear, QOpenGLTexture.Linear)

        self._qt_texture.bind(unit)

    def release(self, unit):
        self._qt_texture.release(unit)

    def load(self, file_name):
        self._file_name = file_name
Beispiel #6
0
    def __init__(self,
                 open_gl_binding_object: QAbstractOpenGLFunctions) -> None:
        super().__init__()

        self._qt_texture = QOpenGLTexture(QOpenGLTexture.Target2D)
        self._gl = open_gl_binding_object
        self._file_name = None
        self._image = None
Beispiel #7
0
class Texture:
    """A class describing the interface to be used for texture objects.

    This interface should be implemented by OpenGL implementations to handle texture
    objects.
    """
    def __init__(self,
                 open_gl_binding_object: QAbstractOpenGLFunctions) -> None:
        super().__init__()

        self._qt_texture = QOpenGLTexture(QOpenGLTexture.Target2D)
        self._gl = open_gl_binding_object
        self._file_name = None
        self._image = None

    def getTextureId(self) -> int:
        """Get the OpenGL ID of the texture."""
        return self._qt_texture.textureId()

    def bind(self, texture_unit):
        """Bind the texture to a certain texture unit.

        :param texture_unit: The texture unit to bind to.
        """
        if not self._qt_texture.isCreated():
            if self._file_name != None:
                self._image = QImage(self._file_name).mirrored()
            elif self._image is None:  # No filename or image set.
                self._image = QImage(1, 1, QImage.Format_ARGB32)
                self._image.fill(0)
            self._qt_texture.setData(self._image)
            self._qt_texture.setMinMagFilters(QOpenGLTexture.Linear,
                                              QOpenGLTexture.Linear)

        self._qt_texture.bind(texture_unit)

    def release(self, texture_unit):
        """Release the texture from a certain texture unit.

        :param texture_unit: The texture unit to release from.
        """
        self._qt_texture.release(texture_unit)

    def load(self, file_name):
        """Load an image and upload it to the texture.

        :param file_name: The file name of the image to load.
        """
        self._file_name = file_name
        # Actually loading the texture is postponed until the next bind() call.
        # This makes sure we are on the right thread and have a current context when trying to upload.

    def setImage(self, image):
        self._image = image
Beispiel #8
0
    def __init__(self, open_gl_binding_object):
        super().__init__()

        self._qt_texture = QOpenGLTexture(QOpenGLTexture.Target2D)
        self._gl = open_gl_binding_object
        self._file_name = None
        self._image = None
Beispiel #9
0
def load_texture(material):
    # Note that the QImage is mirrored vertically to account for the fact that OpenGL and QImage use opposite directions for the y axis.
    # (https://doc.qt.io/qt-5/qopengltexture.html#details)
    texture = QOpenGLTexture(
        QImage(get_resources_path(material['diffuse_map'])).mirrored())
    texture.setMinificationFilter(QOpenGLTexture.Nearest)
    texture.setMagnificationFilter(QOpenGLTexture.Nearest)
    texture.setWrapMode(QOpenGLTexture.ClampToEdge)
    return texture
Beispiel #10
0
class Texture:
    def __init__(self,
                 open_gl_binding_object: QAbstractOpenGLFunctions) -> None:
        super().__init__()

        self._qt_texture = QOpenGLTexture(QOpenGLTexture.Target2D)
        self._gl = open_gl_binding_object
        self._file_name = None
        self._image = None

    ##  Get the OpenGL ID of the texture.
    def getTextureId(self) -> int:
        return self._qt_texture.textureId()

    ##  Bind the texture to a certain texture unit.
    #
    #   \param texture_unit The texture unit to bind to.
    def bind(self, texture_unit):
        if not self._qt_texture.isCreated():
            if self._file_name != None:
                self._image = QImage(self._file_name).mirrored()
            elif self._image is None:  # No filename or image set.
                self._image = QImage(1, 1, QImage.Format_ARGB32)
                self._image.fill(0)
            self._qt_texture.setData(self._image)
            self._qt_texture.setMinMagFilters(QOpenGLTexture.Linear,
                                              QOpenGLTexture.Linear)

        self._qt_texture.bind(texture_unit)

    ##  Release the texture from a certain texture unit.
    #
    #   \param texture_unit The texture unit to release from.
    def release(self, texture_unit):
        self._qt_texture.release(texture_unit)

    ##  Load an image and upload it to the texture.
    #
    #   \param file_name The file name of the image to load.
    def load(self, file_name):
        self._file_name = file_name
        #Actually loading the texture is postponed until the next bind() call.
        #This makes sure we are on the right thread and have a current context when trying to upload.

    def setImage(self, image):
        self._image = image
Beispiel #11
0
    def makeObject(self):
        self.texCoords = [(True, True), (False, True), (False, False),
                          (True, False)]
        self.vertices = [(0.5, -0.5, -0.5), (-0.5, -0.5, -0.5),
                         (-0.5, 0.5, -0.5), (0.5, 0.5, -0.5)]

        my_movie = QImage('/Users/reno/Dropbox/media/cloudy.png')
        self.texture = QOpenGLTexture(my_movie.mirrored())
Beispiel #12
0
def load_texture(material):
    # Note that the QImage is mirrored vertically to account for the fact that OpenGL and QImage use opposite directions for the y axis.
    # (https://doc.qt.io/qt-5/qopengltexture.html#details)
    texture = QOpenGLTexture(QImage(get_resources_path(material['diffuse_map'])).mirrored())
    texture.setMinificationFilter(QOpenGLTexture.Nearest)
    texture.setMagnificationFilter(QOpenGLTexture.Nearest)
    texture.setWrapMode(QOpenGLTexture.ClampToEdge)
    return texture
Beispiel #13
0
class Texture(object):
    def __init__(self, open_gl_binding_object):
        super().__init__()

        self._qt_texture = QOpenGLTexture(QOpenGLTexture.Target2D)
        self._gl = open_gl_binding_object
        self._file_name = None
        self._image = None

    ##  Get the OpenGL ID of the texture.
    def getTextureId(self):
        return self._qt_texture.textureId()

    ##  Bind the texture to a certain texture unit.
    #
    #   \param texture_unit The texture unit to bind to.
    def bind(self, texture_unit):
        if not self._qt_texture.isCreated():
            if self._file_name != None:
                self._image = QImage(self._file_name).mirrored()
            elif self._image is None: # No filename or image set.
                self._image = QImage(1, 1, QImage.Format_ARGB32)
                self._image.fill(0)
            self._qt_texture.setData(self._image)
            self._qt_texture.setMinMagFilters(QOpenGLTexture.Linear, QOpenGLTexture.Linear)

        self._qt_texture.bind(texture_unit)
    ##  Release the texture from a certain texture unit.
    #
    #   \param texture_unit The texture unit to release from.
    def release(self, texture_unit):
        self._qt_texture.release(texture_unit)

    ##  Load an image and upload it to the texture.
    #
    #   \param file_name The file name of the image to load.
    def load(self, file_name):
        self._file_name = file_name
        #Actually loading the texture is postponed until the next bind() call.
        #This makes sure we are on the right thread and have a current context when trying to upload.

    def setImage(self, image):
        self._image = image
Beispiel #14
0
class QtTexture(Texture):
    def __init__(self):
        super().__init__()

        self._qt_texture = QOpenGLTexture(QOpenGLTexture.Target2D)
        self._qt_texture.setMinMagFilters(QOpenGLTexture.Linear, QOpenGLTexture.Linear)
        self._gl = OpenGL.getInstance().getBindingsObject()

    def getTextureId(self):
        return self._qt_texture.textureId()

    def bind(self, unit):
        self._qt_texture.bind(unit)

    def release(self, unit):
        self._qt_texture.release(unit)

    def load(self, file_name):
        image = QImage(file_name).mirrored()
        self._qt_texture.setData(image)
Beispiel #15
0
class QtTexture(Texture):
    def __init__(self):
        super().__init__()

        self._qt_texture = QOpenGLTexture(QOpenGLTexture.Target2D)
        self._qt_texture.setMinMagFilters(QOpenGLTexture.Linear,
                                          QOpenGLTexture.Linear)
        self._gl = OpenGL.getInstance().getBindingsObject()

    def getTextureId(self):
        return self._qt_texture.textureId()

    def bind(self, unit):
        self._qt_texture.bind(unit)

    def release(self, unit):
        self._qt_texture.release(unit)

    def load(self, file_name):
        image = QImage(file_name).mirrored()
        self._qt_texture.setData(image)
    def makeObject(self):
        self.textures = []
        self.texCoords = []
        self.vertices = []

        root = QFileInfo(__file__).absolutePath()

        for i in range(6):
            self.textures.append(
                    QOpenGLTexture(
                            QImage(root + ('/images/side%d.png' % (i + 1))).mirrored()))

            for j in range(4):
                self.texCoords.append(((j == 0 or j == 3), (j == 0 or j == 1)))

                x, y, z = self.coords[i][j]
                self.vertices.append((0.2 * x, 0.2 * y, 0.2 * z))
Beispiel #17
0
    def attach_texture_object(self, array):
        if not hasattr(array, "___tex___"):
            target = self.to_texture_target(array)
            if target == None:
                raise RuntimeError(
                    'Unable to determine texture  binding target')

            array.___tex___ = QOpenGLTexture(target)
            array.___tex___.setMinificationFilter(QOpenGLTexture.Linear)
            array.___tex___.setMagnificationFilter(QOpenGLTexture.Linear)
            array.___tex___.setWrapMode(QOpenGLTexture.DirectionS,
                                        QOpenGLTexture.Repeat)
            if target in [QOpenGLTexture.Target2D, QOpenGLTexture.Target3D]:
                array.___tex___.setWrapMode(QOpenGLTexture.DirectionT,
                                            QOpenGLTexture.Repeat)
                if target == QOpenGLTexture.Target3D:
                    array.___tex___.setWrapMode(QOpenGLTexture.DirectionR,
                                                QOpenGLTexture.Repeat)
            array.___tex___.dirty = True
            array.productDirty.connect(
                lambda array=array: setattr(array.___tex___, "dirty", True))
Beispiel #18
0
    def setUniformTexture(self, name, file):
        if not self._shader_program or self._disable_textures:
            return

        if name not in self._uniform_indices:
            self._uniform_indices[name] = self._shader_program.uniformLocation(
                name)

        index = self._uniform_indices[name]

        texture = QOpenGLTexture(QImage(file).mirrored())
        texture.setMinMagFilters(QOpenGLTexture.Linear, QOpenGLTexture.Linear)
        self._textures[index] = texture

        self._uniform_values[index] = 1

        if self._bound:
            texture = self._textures[index]
            texture.bind()
            self._setUniformValueDirect(index, texture.textureId())
Beispiel #19
0
    def setUniformTexture(self, name, file):
        if not self._shader_program:
            return

        if name not in self._uniform_indices:
            self._uniform_indices[name] = self._shader_program.uniformLocation(name)

        index = self._uniform_indices[name]

        texture = QOpenGLTexture(QImage(file).mirrored())
        texture.setMinMagFilters(QOpenGLTexture.Linear, QOpenGLTexture.Linear)
        self._textures[index] = texture

        self._uniform_values[index] = 1

        if self._bound:
            texture = self._textures[index]
            texture.bind()
            self._setUniformValueDirect(index, texture.textureId())
Beispiel #20
0
    def __init__(self):
        super().__init__()

        self._qt_texture = QOpenGLTexture(QOpenGLTexture.Target2D)
        self._qt_texture.setMinMagFilters(QOpenGLTexture.Linear, QOpenGLTexture.Linear)
        self._gl = OpenGL.getInstance().getBindingsObject()
    def createTexture(self, gl, width=None, height=None, 
            wrapMode=QOpenGLTexture.ClampToEdge, format=QOpenGLTexture.RGBA8U, filter=QOpenGLTexture.Linear, 
            filename=None, allocate=True, **kwparams):
        ''' Creates texture object with required parameters '''
        assert width is not None or filename is not None
        if height is None: height = width

        if filename:
            texture = QOpenGLTexture(QImage('{}/{}'.format(Resources.directory, filename)).mirrored(), QOpenGLTexture.DontGenerateMipMaps)
        else:
            texture = QOpenGLTexture(QOpenGLTexture.Target2D)
            texture.setFormat(format)
            texture.setSize(width, height)
            if allocate: texture.allocateStorage()

        texture.setMinificationFilter(filter)
        texture.setMagnificationFilter(filter)
        texture.setWrapMode(wrapMode)

        assert texture.create()

        texture.bind()
        for k, v in kwparams.items():
            gl.glTexParameteri(gl.GL_TEXTURE_2D, getattr(gl, k), v)
        texture.release()

        return texture
Beispiel #22
0
    def asQOpenGLTexture(self, gl, context):
        if not self.data:
            return

        if self.glFormat.requirements:
            minVersion, extensions = self.glFormat.requirements
            glVersion = (gl.glGetIntegerv(gl.GL_MAJOR_VERSION),
                         gl.glGetIntegerv(gl.GL_MINOR_VERSION))
            if glVersion < minVersion or minVersion < (1, 0):
                compatible = False
                for extension in extensions:
                    if context.hasExtension(extension):
                        compatible = True
                        break
                if not compatible:
                    qCritical(
                        self.__tr(
                            "OpenGL driver incompatible with texture format."))
                    return None

        if self.header.dwCaps2 & DDSDefinitions.DDS_HEADER.Caps2.DDSCAPS2_CUBEMAP:
            texture = QOpenGLTexture(QOpenGLTexture.TargetCubeMap)
            if self.header.dwWidth != self.header.dwHeight:
                qCritical(self.__tr("Cubemap faces must be square"))
                return None
        else:
            # Assume GL_TEXTURE_2D for now
            texture = QOpenGLTexture(QOpenGLTexture.Target2D)
        # Assume single layer for now
        # self.texture.setLayers(1)
        mipCount = self.mipLevels()
        texture.setAutoMipMapGenerationEnabled(False)
        texture.setMipLevels(mipCount)
        texture.setMipLevelRange(0, mipCount - 1)
        texture.setSize(self.header.dwWidth, self.header.dwHeight)
        texture.setFormat(self.glFormat.internalFormat)
        texture.allocateStorage()

        if self.header.dwCaps2 & DDSDefinitions.DDS_HEADER.Caps2.DDSCAPS2_CUBEMAP:
            # Lisa hasn't whipped David Wang into shape yet. At least there are fewer bugs than under Raja.
            # The specific bug has been reported and AMD "will try to reproduce it soon"
            noDSA = "Radeon" in gl.glGetString(
                gl.GL_RENDERER) and self.glFormat.compressed
            if noDSA:
                texture.bind()
            faceIndex = 0
            for face in ddsCubemapFaces:
                if self.header.dwCaps2 & face:
                    for i in range(mipCount):
                        if self.glFormat.compressed:
                            if not noDSA:
                                texture.setCompressedData(
                                    i, 0, ddsCubemapFaces[face],
                                    len(self.data[faceIndex * mipCount + i]),
                                    self.data[faceIndex * mipCount + i])
                            else:
                                gl.glCompressedTexSubImage2D(
                                    ddsCubemapFaces[face], i, 0, 0,
                                    max(self.header.dwWidth // 2**i, 1),
                                    max(self.header.dwHeight // 2**i,
                                        1), self.glFormat.internalFormat,
                                    len(self.data[faceIndex * mipCount + i]),
                                    self.data[faceIndex * mipCount + i])
                        else:
                            texture.setData(
                                i, 0, ddsCubemapFaces[face],
                                self.glFormat.format, self.glFormat.type,
                                self.glFormat.converter(
                                    self.data[faceIndex * mipCount + i]))
                    faceIndex += 1
            if noDSA:
                texture.release()
        else:
            for i in range(mipCount):
                if self.glFormat.compressed:
                    texture.setCompressedData(i, 0, len(self.data[i]),
                                              self.data[i])
                else:
                    texture.setData(i, 0, self.glFormat.format,
                                    self.glFormat.type,
                                    self.glFormat.converter(self.data[i]))

        texture.setWrapMode(QOpenGLTexture.ClampToEdge)

        if self.glFormat.samplerType != "F":
            # integer textures can't be filtered
            texture.setMinMagFilters(QOpenGLTexture.NearestMipMapNearest,
                                     QOpenGLTexture.Nearest)

        return texture
Beispiel #23
0
 def addTexture(self, imgfile):
     self._images.append(QImage(imgfile).mirrored())
     self._textures.append(QOpenGLTexture(QOpenGLTexture.Target2D))
Beispiel #24
0
    def __init__(self):
        super().__init__()

        self._qt_texture = QOpenGLTexture(QOpenGLTexture.Target2D)
        self._gl = OpenGL.getInstance().getBindingsObject()
        self._file_name = None