Esempio n. 1
0
def check_shaderError(shader, flag, isProgram, errorMessage):
    success = bgl.Buffer(bgl.GL_INT, 1)
    slen = 1024
    if isProgram:
        bgl.glGetProgramiv(shader, flag, success)
        check_error("glGetProgramiv")

    else:
        bgl.glGetShaderiv(shader, flag, success)
        check_error("glGetShaderiv")

    import numpy as np
    from .bgl_ext import VoidBufValue

    offset = VoidBufValue(None)
    error = bgl.Buffer(bgl.GL_BYTE, slen)

    if isProgram:
        bgl.glGetProgramInfoLog(shader, slen, offset.buf, error)
        check_error("glGetProgramInfoLog")
    else:
        bgl.glGetShaderInfoLog(shader, slen, offset.buf, error)
        check_error("glGetShaderInfoLog")

    print(np.bytes_(error).decode("utf-8"))

    del offset
    if success[0] != bgl.GL_TRUE:
        print(errorMessage, np.bytes_(error).decode("utf-8"))
        raise RuntimeError(errorMessage, error)
Esempio n. 2
0
    def shader_compile(name, shader, src):
        '''
        logging and error-checking not quite working :(
        '''

        bgl.glCompileShader(shader)

        # report shader compilation log (if any)
        bufLogLen = bgl.Buffer(bgl.GL_INT, 1)
        bgl.glGetShaderiv(shader, bgl.GL_INFO_LOG_LENGTH, bufLogLen)
        if bufLogLen[0] > 0:
            # report log available
            bufLog = bgl.Buffer(bgl.GL_BYTE, bufLogLen)
            bgl.glGetShaderInfoLog(shader, bufLogLen[0], bufLogLen, bufLog)
            log = ''.join(chr(v) for v in bufLog.to_list() if v)
            if log:
                print('SHADER REPORT %s' % name)
                print('\n'.join(['    %s' % l for l in log.splitlines()]))
            else:
                print('Shader %s has no report' % name)
        else:
            log = ''

        # report shader compilation status
        bufStatus = bgl.Buffer(bgl.GL_INT, 1)
        bgl.glGetShaderiv(shader, bgl.GL_COMPILE_STATUS, bufStatus)
        if bufStatus[0] == 0:
            print('ERROR WHILE COMPILING SHADER %s' % name)
            print('\n'.join([
                '   % 4d  %s' % (i + 1, l)
                for (i, l) in enumerate(src.splitlines())
            ]))
            assert False

        return log
Esempio n. 3
0
def compile_shader(type, source):
    shader = bgl.glCreateShader(type)
    bgl.glShaderSource(shader, source)
    bgl.glCompileShader(shader)
    status = bgl.Buffer(bgl.GL_INT, 1)
    bgl.glGetShaderiv(shader, bgl.GL_COMPILE_STATUS, status)
    if status[0] != bgl.GL_TRUE:
        infoLog = bgl.Buffer(bgl.GL_BYTE, 1024)
        length = bgl.Buffer(bgl.GL_INT, 1)
        bgl.glGetShaderInfoLog(shader, 1024, length, infoLog)
        raise RuntimeError(''.join(chr(infoLog[i]) for i in range(length[0])))
    return shader
Esempio n. 4
0
    def __init__(self, vertexcode, geomcode, fragcode):

        success = bgl.Buffer(bgl.GL_INT, 1)
        program = bgl.glCreateProgram()

        shader1 = bgl.glCreateShader(bgl.GL_VERTEX_SHADER)
        bgl.glShaderSource(shader1, vertexcode)
        check_error("glShaderSource")
        bgl.glCompileShader(shader1)
        check_error("glCompileShader")
        bgl.glGetShaderiv(shader1, bgl.GL_COMPILE_STATUS, success)
        if success[0] != bgl.GL_TRUE:
            print("shader vertexcode compile error")

        shader2 = bgl.glCreateShader(bgl.GL_FRAGMENT_SHADER)
        bgl.glShaderSource(shader2, fragcode)
        check_error("glShaderSource")
        bgl.glCompileShader(shader2)
        check_error("glCompileShader")
        bgl.glGetShaderiv(shader2, bgl.GL_COMPILE_STATUS, success)
        check_error("glGetShaderiv")
        if success[0] != bgl.GL_TRUE:
            print("shader fragcode compile error")

        bgl.glAttachShader(program, shader1)
        check_error("glAttachShader")

        bgl.glAttachShader(program, shader2)
        check_error("glAttachShader")

        bgl.glLinkProgram(program)
        check_error("glLinkProgram")

        bgl.glGetProgramiv(program, bgl.GL_LINK_STATUS, success)
        check_error("glGetProgramiv")
        if success[0] != bgl.GL_TRUE:
            print("Program link error")

        bgl.glValidateProgram(program)
        check_error("glValidateProgram")
        bgl.glGetProgramiv(program, bgl.GL_VALIDATE_STATUS, success)
        check_error("glGetProgramiv")
        if success[0] != bgl.GL_TRUE:
            print("Program invalid")

        self.program = program
Esempio n. 5
0
def gl_compile_error(program_name, shader_name, shader):
    """
    Print OpenGL compilation errors, if any, for a given shader.
    
    program_name and shader_name are arbitrary human readable strings.
    shader is an int (an OpenGL shader name)
    """
    buf = bgl.Buffer(bgl.GL_INT,1)
    bgl.glGetShaderiv(shader,bgl.GL_COMPILE_STATUS,buf)
    if buf[0] == bgl.GL_TRUE:
        return False
    err = buf[0]
    charbuf = bgl.Buffer(bgl.GL_BYTE,4000)
    lenbuf = bgl.Buffer(bgl.GL_INT,1)
    bgl.glGetShaderInfoLog(shader,4000,lenbuf,charbuf)
    print('GL Error: %d (%s:%s)\n%s'%(err, program_name, shader_name, "".join(map( chr, charbuf[:lenbuf[0]]))))
    return True
Esempio n. 6
0
    def shader_compile(name, shader):
        '''
        logging and error-checking not quite working :(
        '''

        bufLen = bgl.Buffer(bgl.GL_BYTE, 4)
        bufLog = bgl.Buffer(bgl.GL_BYTE, 2000)
        bufStatus = bgl.Buffer(bgl.GL_INT, 1)

        bgl.glCompileShader(shader)

        # get shader compilation log and status (successfully compiled?)
        bgl.glGetShaderiv(shader, bgl.GL_COMPILE_STATUS, bufStatus)
        bgl.glGetShaderInfoLog(shader, 2000, bufLen, bufLog)
        log = ''.join(chr(v) for v in bufLog.to_list() if v)
        if bufStatus[0] == 0:
            print('ERROR WHILE COMPILING SHADER %s' % name)
            print('\n'.join(['    %s'%l for l in log.splitlines()]))
            assert False
        return log
Esempio n. 7
0
def createShader(shader_type, shader_source):
    shader = bgl.glCreateShader(shader_type)
    bgl.glShaderSource(shader, shader_source)
    bgl.glCompileShader(shader)
    success = bgl.Buffer(bgl.GL_INT, [1])
    bgl.glGetShaderiv(shader, bgl.GL_COMPILE_STATUS, success)
    if (success[0] == bgl.GL_TRUE):
        print("shader compiled")
        return shader
    bgl.glGetShaderiv(shader, bgl.GL_INFO_LOG_LENGTH, success);
    success[0] = success[0] + 1
    log = bgl.Buffer(bgl.GL_BYTE, [success[0]])
    start = bgl.Buffer(bgl.GL_INT, [1])
    start[0] =0
    bgl.glGetShaderInfoLog(shader, success[0]+1,start, log)
    py_log = log[:]
    py_log_str = ""
    for c in py_log:
        py_log_str += str(chr(c))
    print(str(py_log_str))
    bgl.glDeleteShader(shader)
Esempio n. 8
0
def check_shaderError(shader, flag, isProgram, errorMessage):
    success = bgl.Buffer(bgl.GL_INT, 1)

    if isProgram:
        bgl.glGetProgramiv(shader, flag, success)
    else:
        bgl.glGetShaderiv(shader, flag, success)

    if success[0] == bgl.GL_FALSE:
        import numpy as np
        import ctypes

        offset = bgl.Buffer(bgl.GL_INT, 1, (ctypes.c_int * 1).from_address(0))
        error = bgl.Buffer(bgl.GL_BYTE, 1024)
        if isProgram:
            bgl.glGetProgramInfoLog(shader, 1024, offset, error)
            print(errorMessage, np.bytes_(error).decode("utf-8"))
        else:
            bgl.glGetShaderInfoLog(shader, 1024, offset, error)
            print(errorMessage, np.bytes_(error).decode("utf-8"))

        del offset
        raise #RuntimeError(errorMessage, bgl.glGetShaderInfoLog(shader))
Esempio n. 9
0
def check_shaderError(shader, flag, isProgram, errorMessage):
    success = bgl.Buffer(bgl.GL_INT, 1)

    if isProgram:
        bgl.glGetProgramiv(shader, flag, success)
    else:
        bgl.glGetShaderiv(shader, flag, success)

    if success[0] == bgl.GL_FALSE:
        import numpy as np
        from .bgl_ext import VoidBufValue

        offset = VoidBufValue(None)
        error = bgl.Buffer(bgl.GL_BYTE, 1024)
        if isProgram:
            bgl.glGetProgramInfoLog(shader, 1024, offset.buf, error)
            print(errorMessage, np.bytes_(error).decode("utf-8"))
        else:
            bgl.glGetShaderInfoLog(shader, 1024, offset.buf, error)
            print(errorMessage, np.bytes_(error).decode("utf-8"))

        del offset
        raise #RuntimeError(errorMessage, bgl.glGetShaderInfoLog(shader))
Esempio n. 10
0
def check_shaderError(shader, flag, isProgram, errorMessage):
    success = bgl.Buffer(bgl.GL_INT, 1)

    if isProgram:
        bgl.glGetProgramiv(shader, flag, success)
    else:
        bgl.glGetShaderiv(shader, flag, success)

    if success[0] == bgl.GL_FALSE:
        import numpy as np
        import ctypes

        offset = bgl.Buffer(bgl.GL_INT, 1, (ctypes.c_int32 * 1).from_address(0))
        error = bgl.Buffer(bgl.GL_BYTE, 1024)
        if isProgram:
            bgl.glGetProgramInfoLog(shader, 1024, offset, error)
            print(errorMessage, np.bytes_(error).decode("utf-8"))
        else:
            bgl.glGetShaderInfoLog(shader, 1024, offset, error)
            print(errorMessage, np.bytes_(error).decode("utf-8"))

        del offset
        raise #RuntimeError(errorMessage, bgl.glGetShaderInfoLog(shader))
Esempio n. 11
0
    def execute(self, context):
        namespace['projection_matrix'] = bgl.Buffer(bgl.GL_FLOAT, (4, 4))

        namespace['points'] = (-0.5, -0.5, 0.0, 0.5, -0.5, 0.0, 0.0, 0.5, 0.0)

        namespace['colors'] = (0.0, 1.0, 0.0, 0.5, 1.0, 1.0, 0.0, 0.5, 1.0,
                               0.0, 1.0, 0.5)

        namespace['data_point'] = bgl.Buffer(bgl.GL_FLOAT,
                                             len(namespace['points']),
                                             namespace['points'])
        namespace['data_color'] = bgl.Buffer(bgl.GL_FLOAT,
                                             len(namespace['colors']),
                                             namespace['colors'])

        namespace['vertex_shader_info'] = bgl.Buffer(bgl.GL_INT, 1)
        namespace['fragment_shader_info'] = bgl.Buffer(bgl.GL_INT, 1)
        namespace['shader_program_info'] = bgl.Buffer(bgl.GL_INT, 1)

        namespace['vao'] = bgl.Buffer(bgl.GL_INT, 1)
        namespace['vbo_point'] = bgl.Buffer(bgl.GL_INT, 1)
        namespace['vbo_color'] = bgl.Buffer(bgl.GL_INT, 1)

        bgl.glGenBuffers(1, namespace['vbo_point'])
        bgl.glGenBuffers(1, namespace['vbo_color'])

        # Shaders
        namespace['shader_program'] = bgl.glCreateProgram()

        namespace['vertex_shader'] = bgl.glCreateShader(bgl.GL_VERTEX_SHADER)
        namespace['fragment_shader'] = bgl.glCreateShader(
            bgl.GL_FRAGMENT_SHADER)

        bgl.glShaderSource(namespace['vertex_shader'], vertex_shader_source)
        bgl.glShaderSource(namespace['fragment_shader'],
                           fragment_shader_source)

        bgl.glCompileShader(namespace['vertex_shader'])
        bgl.glCompileShader(namespace['fragment_shader'])

        bgl.glGetShaderiv(namespace['vertex_shader'], bgl.GL_COMPILE_STATUS,
                          namespace['vertex_shader_info'])
        bgl.glGetShaderiv(namespace['fragment_shader'], bgl.GL_COMPILE_STATUS,
                          namespace['fragment_shader_info'])

        if namespace['vertex_shader_info'][0] == bgl.GL_TRUE:
            print("Vertex shader compiled successfully.")
        elif namespace['vertex_shader_info'][0] == bgl.GL_FALSE:
            print("Vertex shader failed to compile.")

        if namespace['fragment_shader_info'][0] == bgl.GL_TRUE:
            print("Fragment shader compiled successfully.")
        elif namespace['fragment_shader_info'][0] == bgl.GL_FALSE:
            print("Fragment shader failed to compile.")

        bgl.glAttachShader(namespace['shader_program'],
                           namespace['vertex_shader'])
        bgl.glAttachShader(namespace['shader_program'],
                           namespace['fragment_shader'])

        bgl.glLinkProgram(namespace['shader_program'])

        bgl.glGetProgramiv(namespace['shader_program'], bgl.GL_LINK_STATUS,
                           namespace['shader_program_info'])

        if namespace['shader_program_info'][0] == bgl.GL_TRUE:
            print("Shader program linked successfully.")
        elif namespace['shader_program_info'][0] == bgl.GL_FALSE:
            print("Shader program failed to link.")

        # glGetUniformLocation can only be used after the shader program is linked, as stated in the OpenGL Specification.
        namespace['perspective_uniform_location'] = bgl.glGetUniformLocation(
            namespace['shader_program'], "perspective")

        bgl.glValidateProgram(namespace['shader_program'])

        bgl.glGetProgramiv(namespace['shader_program'], bgl.GL_VALIDATE_STATUS,
                           namespace['shader_program_info'])

        if namespace['shader_program_info'][0] == bgl.GL_TRUE:
            print("Shader program validated successfully.")
        elif namespace['shader_program_info'][0] == bgl.GL_FALSE:
            print("Shader program failed to validate.")

        draw_handler_add()

        namespace['timer'] = context.window_manager.event_timer_add(
            time_step=0.01, window=context.window)
        namespace['data_timer'] = bgl.Buffer(bgl.GL_FLOAT, 2, [
            math.sin(namespace['timer'].time_duration),
            math.sin(namespace['timer'].time_duration) * 2
        ])

        context.window_manager.modal_handler_add(self)

        return {'RUNNING_MODAL'}