Esempio n. 1
0
    def get(self,
            vert_name,
            frag_name,
            defines={},
            vertex_defines={},
            fragment_defines={}):

        _fragment_defines = {}
        _fragment_defines.update(fragment_defines)
        _fragment_defines.update(defines)

        _vertex_defines = {}
        _vertex_defines.update(vertex_defines)
        _vertex_defines.update(defines)

        frag_prepend = self.__build_s(_fragment_defines)
        vert_prepend = self.__build_s(_vertex_defines)

        # The defines to a shader affect compilation, create an unordered key
        _defines_key = (frozenset(_fragment_defines.items()),
                        frozenset(_vertex_defines.items()))

        key = vert_name, frag_name, _defines_key

        if key not in self.cache:
            frag1s = self.__get_shader_text(frag_name)
            vert1s = self.__get_shader_text(vert_name)

            frag_version, frag1s = self.extract_version(frag1s)
            vert_version, vert1s = self.extract_version(vert1s)
            try:
                frag = compileShader([frag_version, frag_prepend, frag1s],
                                     GL.GL_FRAGMENT_SHADER)
                vert = compileShader([vert_version, vert_prepend, vert1s],
                                     GL.GL_VERTEX_SHADER)
                obj = compileProgram(vert, frag)
            except RuntimeError as e:
                msg, shader, _ = e.args
                print("During Shader Compilation: ", msg)
                shader_body = b"".join(shader).decode('ascii')
                lines = shader_body.split("\n")
                for i in lines:
                    print("\t%s" % i.strip())
                return None

            obj.uniforms = UniformProxy(obj)

            self.cache[key] = obj
        return self.cache[key]
Esempio n. 2
0
    def setUp(self):

        f = QtOpenGL.QGLFormat()
        f.setVersion(3, 3)
        f.setProfile(QtOpenGL.QGLFormat.CoreProfile)

        c = QtOpenGL.QGLContext(f)
        self.mockWidget = QtOpenGL.QGLWidget(c)

        self.assertTrue(self.mockWidget.isValid())

        self.mockWidget.makeCurrent()

        s1 = S.compileShader(VERT_1, GL.GL_VERTEX_SHADER)
        s2 = S.compileShader(FRAG_1, GL.GL_FRAGMENT_SHADER)

        self.prog = S.compileProgram(s1, s2)
Esempio n. 3
0
    def setUp(self):

        if self.ctx is None:
            f = QtOpenGL.QGLFormat()
            f.setVersion(3, 2)
            f.setProfile(QtOpenGL.QGLFormat.CoreProfile)

            self.ctx = QtOpenGL.QGLContext(f)
            self.mockWidget = QtOpenGL.QGLWidget(self.ctx)

        self.assertTrue(self.ctx.isValid())
        self.ctx.makeCurrent()

        # Compile the two shaders individually
        s1 = S.compileShader(VERT_1, GL.GL_VERTEX_SHADER)
        s2 = S.compileShader(FRAG_1, GL.GL_FRAGMENT_SHADER)

        # now build the whole program
        self.prog = S.compileProgram(s1, s2)
Esempio n. 4
0
    def setUp(self):

        if self.ctx is None:
            f = QtOpenGL.QGLFormat()
            f.setVersion(3, 2)
            f.setProfile(QtOpenGL.QGLFormat.CoreProfile)

            self.ctx = QtOpenGL.QGLContext(f)
            self.mockWidget = QtOpenGL.QGLWidget(self.ctx)

        self.assertTrue(self.ctx.isValid())
        self.ctx.makeCurrent()


        # Compile the two shaders individually
        s1 = S.compileShader(VERT_1, GL.GL_VERTEX_SHADER)
        s2 = S.compileShader(FRAG_1, GL.GL_FRAGMENT_SHADER)

        # now build the whole program
        self.prog = S.compileProgram(s1, s2)
Esempio n. 5
0
    def get(self, vert_name, frag_name, defines={}, vertex_defines={}, fragment_defines={}):

        _fragment_defines={}
        _fragment_defines.update(fragment_defines)
        _fragment_defines.update(defines)

        _vertex_defines={}
        _vertex_defines.update(vertex_defines)
        _vertex_defines.update(defines)

        frag_prepend = self.__build_s(_fragment_defines)
        vert_prepend = self.__build_s(_vertex_defines)

        # The defines to a shader affect compilation, create an unordered key
        _defines_key = (frozenset(_fragment_defines.items()), frozenset(_vertex_defines.items()))

        key = vert_name, frag_name, _defines_key

        if key not in self.cache:
            frag1s = self.__get_shader_text(frag_name)
            vert1s = self.__get_shader_text(vert_name)

            frag_version, frag1s = self.extract_version(frag1s)
            vert_version, vert1s = self.extract_version(vert1s)
            try:
                frag = compileShader([frag_version, frag_prepend, frag1s], GL.GL_FRAGMENT_SHADER)
                vert = compileShader([vert_version, vert_prepend, vert1s], GL.GL_VERTEX_SHADER)
                obj = compileProgram(vert, frag)
            except RuntimeError as e:
                msg, shader, _ = e.args
                print("During Shader Compilation: ", msg)
                shader_body = b"".join(shader).decode('ascii')
                lines = shader_body.split("\n")
                for i in lines:
                    print("\t%s" % i.strip())
                return None

            obj.uniforms = UniformProxy(obj)

            self.cache[key] = obj
        return self.cache[key]
Esempio n. 6
0
    def get(self, vert_name, frag_name, defines={}, vertex_defines={}, fragment_defines={}):

        _fragment_defines={}
        _fragment_defines.update(fragment_defines)
        _fragment_defines.update(defines)

        _vertex_defines={}
        _vertex_defines.update(vertex_defines)
        _vertex_defines.update(defines)

        frag_prepend = self.__build_s(_fragment_defines)
        vert_prepend = self.__build_s(_vertex_defines)

        # The defines to a shader affect compilation, create an unordered key
        _defines_key = (frozenset(_fragment_defines.items()), frozenset(_vertex_defines.items()))

        key = vert_name, frag_name, _defines_key

        if key not in self.cache:
            frag1s = self.__get_shader_text(frag_name)
            vert1s = self.__get_shader_text(vert_name)

            frag_version, frag1s = self.extract_version(frag1s)
            vert_version, vert1s = self.extract_version(vert1s)
            try:
                frag = compileShader([frag_version, frag_prepend, frag1s], GL.GL_FRAGMENT_SHADER)
                vert = compileShader([vert_version, vert_prepend, vert1s], GL.GL_VERTEX_SHADER)
                obj = compileProgram(vert, frag)
            except RuntimeError as e:
                print("During Shader Compilation: ", e)
                raise e

            obj.uniforms = UniformProxy(obj)

            self.cache[key] = obj
        return self.cache[key]
Esempio n. 7
0
    def setUp(self):
        # Ensure we have a qapplication - another testcase might have created it though
        try:
            app = QtWidgets.QApplication([])
        except RuntimeError:
            pass

        if self.ctx is None:
            f = QtOpenGL.QGLFormat()
            f.setVersion(3, 2)
            f.setProfile(QtOpenGL.QGLFormat.CoreProfile)

            self.ctx = QtOpenGL.QGLContext(f)
            self.mockWidget = QtOpenGL.QGLWidget(self.ctx)

        self.assertTrue(self.ctx.isValid())
        self.ctx.makeCurrent()

        # Compile the two shaders individually
        s1 = S.compileShader(VERT_1, GL.GL_VERTEX_SHADER)
        s2 = S.compileShader(FRAG_1, GL.GL_FRAGMENT_SHADER)

        # now build the whole program
        self.prog = S.compileProgram(s1, s2)
Esempio n. 8
0
    def get(
        self,
        vert_name: str,
        frag_name: str,
        defines: Optional[Dict[str, str]] = None,
        vertex_defines: Optional[Dict[str, str]] = None,
        fragment_defines: Optional[Dict[str, str]] = None,
        fragment_bindings: Optional[Dict[str,
                                         int]] = None) -> EnhShaderProgram:

        _fragment_defines = {}
        if fragment_defines is not None:
            _fragment_defines.update(fragment_defines)

        if defines is not None:
            _fragment_defines.update(defines)

        _vertex_defines = {}
        if vertex_defines is not None:
            _vertex_defines.update(vertex_defines)

        if defines is not None:
            _vertex_defines.update(defines)

        if fragment_bindings is None:
            fragment_bindings = {}

        frag_prepend = self.__build_s(_fragment_defines)
        vert_prepend = self.__build_s(_vertex_defines)

        # The defines to a shader affect compilation, create an unordered key
        _defines_key = (frozenset(_fragment_defines.items()),
                        frozenset(_vertex_defines.items()))

        key = vert_name, frag_name, _defines_key

        if key not in self.cache:
            frag1s = self.__get_shader_text(frag_name)
            vert1s = self.__get_shader_text(vert_name)

            frag_version, frag1s = self.extract_version(frag1s)
            vert_version, vert1s = self.extract_version(vert1s)
            try:
                frag = compileShader([frag_version, frag_prepend, frag1s],
                                     GL.GL_FRAGMENT_SHADER)
                vert = compileShader([vert_version, vert_prepend, vert1s],
                                     GL.GL_VERTEX_SHADER)
                obj = compileProgram([vert, frag], fragment_bindings)
            except RuntimeError as e:
                msg, shader, _ = e.args
                print("During Shader Compilation: ", msg)
                shader_body = b"".join(shader).decode('ascii')
                lines = shader_body.split("\n")
                for i in lines:
                    print("\t%s" % i.strip())
                raise

            # TODO - determine if this is needed
            obj.uniforms = UniformProxy(obj)  # type: ignore

            self.cache[key] = obj
        return self.cache[key]