コード例 #1
0
ファイル: editor2.py プロジェクト: springtangent/ld34
def generateAttachmentTexture(attachment_type, width, height):
    # What enum to use?
    """
    attachment_type = 0

    if (not depth) and (not stencil):
        attachment_type = gl.RGB
    GLenum attachment_type;
    if(!depth && !stencil)
        attachment_type = gl.RGB;
    else if(depth && !stencil)
        attachment_type = gl.DEPTH_COMPONENT;
    else if(!depth && stencil)
        attachment_type = gl.STENCIL_INDEX;
    """

    # Generate texture ID and load texture data 
    textureID = gl.genTextures(1)[0]
    gl.bindTexture(gl.TEXTURE_2D, textureID);

    if attachment_type == gl.RGB:
        gl.texImage2D(gl.TEXTURE_2D, 0, attachment_type, width, height, 0, attachment_type, gl.UNSIGNED_BYTE, None)
    else: # Using both a stencil and depth test, needs special format arguments
        gl.texImage2D(gl.TEXTURE_2D, 0, gl.DEPTH24_STENCIL8, width, height, 0, gl.DEPTH_STENCIL, gl.UNSIGNED_INT_24_8, None)

    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR)
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR)
    gl.bindTexture(gl.TEXTURE_2D, 0)

    return textureID
コード例 #2
0
ファイル: graphics.py プロジェクト: springtangent/ld34
def load_texture(fname):
    """
    TODO: allow texture parameters to be set through arguments.
          allow mipmap creation.
          add a texture cache.
    """
    texture_id = gl.genTextures(1)[0]

    gl.bindTexture(gl.TEXTURE_2D, texture_id) # All upcoming GL_TEXTURE_2D operations now have effect on our texture object

    # Set our texture parameters
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.REPEAT)   # Set texture wrapping to GL_REPEAT
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.REPEAT)

    # Set texture filtering
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR)
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR)
    # Load, create texture and generate mipmaps

    img = PIL.Image.open(fname)
    img = PIL.ImageOps.flip(img)
    width, height = img.size
    data = img.convert("RGBA").tobytes("raw", "RGBA")
    # unsigned char* image = SOIL_load_image(FileSystem::getPath("resources/textures/container.jpg").c_str(), &width, &height, 0, SOIL_LOAD_RGB);

    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, width, height, 0, gl.RGBA, gl.UNSIGNED_BYTE, data)
    gl.generateMipmap(gl.TEXTURE_2D)
    gl.bindTexture(gl.TEXTURE_2D, 0)  # Unbind texture when done, so we won't accidentily mess up our texture.

    return texture_id
コード例 #3
0
ファイル: shadowmap.py プロジェクト: springtangent/ld34
def load_texture(fname, min_filter = gl.LINEAR_MIPMAP_LINEAR, mag_filter=gl.LINEAR, texture_wrap_s=gl.REPEAT, texture_wrap_t=gl.REPEAT):
    img = PIL.Image.open(fname)
    img = PIL.ImageOps.flip(img)
    width, height = img.size
    data = img.convert("RGBA").tobytes("raw", "RGBA")

    texture_id = gl.genTextures(1)[0]
    gl.bindTexture(gl.TEXTURE_2D, texture_id) # All upcoming GL_TEXTURE_2D operations now have effect on our texture object
    
    # Set our texture parameters
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, texture_wrap_s)   # Set texture wrapping to GL_REPEAT
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, texture_wrap_t)

    # Set texture filtering
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, min_filter)
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, mag_filter)

    # create texture and generate mipmaps
    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, width, height, 0, gl.RGBA, gl.UNSIGNED_BYTE, data)
    gl.generateMipmap(gl.TEXTURE_2D)

    # Unbind texture when done, so we won't accidentily mess up our texture.
    gl.bindTexture(gl.TEXTURE_2D, 0) 

    return texture_id
コード例 #4
0
ファイル: shadowmap.py プロジェクト: springtangent/ld34
def main():
    global lastFrame, planeVAO, planeVBO

    # Init GLFW
    glfw.setErrorCallback(error_callback)

    glfw.init()
    glfw.windowHint(glfw.CONTEXT_VERSION_MAJOR, 3)
    glfw.windowHint(glfw.CONTEXT_VERSION_MINOR, 3)
    glfw.windowHint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
    # glfw.windowHint(glfw.RESIZABLE, gl.FALSE)
    glfw.windowHint(glfw.OPENGL_FORWARD_COMPAT, 1)

    window = glfw.createWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL")

    if window is None:
        print('could not open window.')
        glfw.terminate()
        sys.exit()

    inputMap = InputMap()

    window.makeContextCurrent()
    window.setKeyCallback(inputMap.key_callback)
    window.setCursorPosCallback(inputMap.mouse_callback)
    #window.setScrollCallback(inputMap.scroll_callback)
    window.setInputMode(glfw.CURSOR, glfw.CURSOR_DISABLED)

    # some versions of glfw cause an opengl error when creating a window, make sure that's ignored.
    gl.init()
    err = gl.getError()
    if err:
        print("WINDOW OPEN ERROR:", err)

    # Define the viewport dimensions
    VP_WIDTH, VP_HEIGHT = window.getFramebufferSize()
    gl.viewport(0, 0, VP_WIDTH, VP_HEIGHT)

    # Setup some OpenGL options
    gl.enable(gl.DEPTH_TEST);

    # Setup and compile our shaders
    shaderProgram = Shader(SHADOW_MAPPING_VERT, SHADOW_MAPPING_FRAG);
    simpleDepthShader = Shader(SHADOW_MAPPING_DEPTH_VERT, SHADOW_MAPPING_DEPTH_FRAG);
    debugDepthQuad = Shader(DEBUG_QUAD_VERT, DEBUG_QUAD_FRAG);

    # Set texture samples
    shaderProgram.use();
    # shaderProgram.uniforms.diffuseTexture = 0
    # shaderProgram.uniforms.shadowMap = 1

    # print(dir(Vertex))
    planeVertices = (Vertex * 6)(
        # Positions             # Normals           # Texture Coords
        (( 25.0, -0.5,  25.0),  (0.0,  1.0,  0.0),  (25.0,  0.0)),
        ((-25.0, -0.5, -25.0),  (0.0,  1.0,  0.0),  ( 0.0, 25.0)),
        ((-25.0, -0.5,  25.0),  (0.0,  1.0,  0.0),  ( 0.0,  0.0)),

        (( 25.0, -0.5,  25.0),  (0.0,  1.0,  0.0),  (25.0,  0.0)),
        (( 25.0, -0.5, -25.0),  (0.0,  1.0,  0.0),  (25.0, 25.0)),
        ((-25.0, -0.5, -25.0),  (0.0,  1.0,  0.0),  ( 0.0, 25.0))
    )

    # Setup plane VAO
    planeVAO = gl.genVertexArrays(1)[0]
    planeVBO = gl.genBuffers(1)[0]

    gl.bindVertexArray(planeVAO)
    gl.bindBuffer(gl.ARRAY_BUFFER, planeVBO)
    gl.bufferData(gl.ARRAY_BUFFER, bytes(planeVertices), gl.STATIC_DRAW)
    gl.enableVertexAttribArray(0)
    gl.vertexAttribPointer(0, 3, gl.FLOAT, gl.FALSE, sizeof(Vertex), Vertex.position.offset)
    gl.enableVertexAttribArray(1)
    gl.vertexAttribPointer(1, 3, gl.FLOAT, gl.FALSE, sizeof(Vertex), Vertex.normal.offset)
    gl.enableVertexAttribArray(2)
    gl.vertexAttribPointer(2, 2, gl.FLOAT, gl.FALSE, sizeof(Vertex), Vertex.texcoord.offset)
    gl.bindVertexArray(0)

    # Light source
    lightPos = Vec3(-2.0, 4.0, -1.0)

    # Load textures
    woodTexture = load_texture("learningopengl/resources/textures/wood.png")

    # Configure depth map FBO
    SHADOW_WIDTH = SHADOW_HEIGHT = 4096
    

    depthMapFBO = gl.genFramebuffers(1)[0]
    
    # - Create depth texture
    depthMap = gl.genTextures(1)[0]
    
    gl.bindTexture(gl.TEXTURE_2D, depthMap)

    gl.texImage2D(gl.TEXTURE_2D, 0, gl.DEPTH_COMPONENT, SHADOW_WIDTH, SHADOW_HEIGHT, 0, gl.DEPTH_COMPONENT, gl.FLOAT, None)
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST)
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST)
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_BORDER)
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_BORDER)
    borderColor = Vec4(1.0, 1.0, 1.0, 1.0)
    gl.texParameterfv(gl.TEXTURE_2D, gl.TEXTURE_BORDER_COLOR, borderColor)

    gl.bindFramebuffer(gl.FRAMEBUFFER, depthMapFBO)
    gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.TEXTURE_2D, depthMap, 0)
    gl.drawBuffer(gl.NONE)
    gl.readBuffer(gl.NONE);
    gl.bindFramebuffer(gl.FRAMEBUFFER, 0);

    gl.clearColor(0.1, 0.1, 0.1, 1.0)

    # Game loop
    while not window.shouldClose():
        # Set frame time
        currentFrame = time.perf_counter()
        deltaTime = currentFrame - lastFrame;
        lastFrame = currentFrame;

        # Check and call events
        inputMap.begin_frame()
        glfw.pollEvents()
        input = inputMap.get_input()
        camera.processInput(input, 1.0/30.0)

        # Change light position over time
        lightPos.z = math.cos(time.perf_counter()) * 2.0

        # 1. Render depth of scene to texture (from light's perspective)
        # - Get light projection/view matrix.
        near_plane = 1.0
        far_plane = 7.5
        lightProjection = Mat4.Ortho(-10.0, 10.0, -10.0, 10.0, near_plane, far_plane)
        # lightProjection = glm::perspective(45.0f, (GLfloat)SHADOW_WIDTH / (GLfloat)SHADOW_HEIGHT, near_plane, far_plane); // Note that if you use a perspective projection matrix you'll have to change the light position as the current light position isn't enough to reflect the whole scene.
        lightView = Mat4.LookAt(lightPos, Vec3(0.0, 0.0, 0.0), Vec3(1.0, 1.0, 1.0))
        lightSpaceMatrix = lightProjection * lightView;
        # - now render scene from light's point of view
        simpleDepthShader.use()
        simpleDepthShader.uniforms.lightSpaceMatrix = lightSpaceMatrix
        # glUniformMatrix4fv(glGetUniformLocation(simpleDepthShader.Program, "lightSpaceMatrix"), 1, GL_FALSE, glm::value_ptr(lightSpaceMatrix));
        gl.viewport(0, 0, SHADOW_WIDTH, SHADOW_HEIGHT)
        gl.bindFramebuffer(gl.FRAMEBUFFER, depthMapFBO)
        gl.clear(gl.DEPTH_BUFFER_BIT);
        RenderScene(simpleDepthShader);
        gl.bindFramebuffer(gl.FRAMEBUFFER, 0)

        # 2. Render scene as normal
        gl.viewport(0, 0, VP_WIDTH, VP_HEIGHT)
        gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
        shaderProgram.use()
        # TODO: use zoon
        projection = Mat4.Perspective(45.0, float(SCR_WIDTH) / float(SCR_HEIGHT), 0.1, 100.0)
        view = camera.getViewMatrix()
        shaderProgram.uniforms.projection = projection
        shaderProgram.uniforms.view = view

        shaderProgram.uniforms.lightPos = lightPos
        shaderProgram.uniforms.viewPos = camera.position
        shaderProgram.uniforms.lightSpaceMatrix = lightSpaceMatrix

        shaderProgram.uniforms.shadows = 1
        shaderProgram.uniforms.diffuseTexture = woodTexture
        shaderProgram.uniforms.shadowMap = depthMap

        RenderScene(shaderProgram)

        # 3. DEBUG: visualize depth map by rendering it to plane
        debugDepthQuad.use()
        # these are not actually used.
        #debugDepthQuad.uniforms.near_plane = near_plane
        #debugDepthQuad.uniforms.far_plane = far_plane

        debugDepthQuad.uniforms.depthMap = depthMap
        # RenderQuad() # uncomment this line to see depth map


        # Swap the buffers
        window.swapBuffers()

    return 0
コード例 #5
0
ファイル: deferredshading.py プロジェクト: springtangent/ld34
def main():
    draw_mode = 1
    global lastFrame, planeVAO, planeVBO

    # Init GLFW
    glfw.setErrorCallback(error_callback)

    glfw.init()
    glfw.windowHint(glfw.CONTEXT_VERSION_MAJOR, 3)
    glfw.windowHint(glfw.CONTEXT_VERSION_MINOR, 3)
    glfw.windowHint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
    # glfw.windowHint(glfw.RESIZABLE, gl.FALSE)
    glfw.windowHint(glfw.OPENGL_FORWARD_COMPAT, 1)

    window = glfw.createWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL")

    if window is None:
        print('could not open window.')
        glfw.terminate()
        sys.exit()

    inputMap = InputMap()

    window.makeContextCurrent()
    window.setKeyCallback(inputMap.key_callback)
    window.setCursorPosCallback(inputMap.mouse_callback)
    #window.setScrollCallback(inputMap.scroll_callback)
    window.setInputMode(glfw.CURSOR, glfw.CURSOR_DISABLED)

    # some versions of glfw cause an opengl error when creating a window, make sure that's ignored.
    gl.init()
    err = gl.getError()
    if err:
        print("WINDOW OPEN ERROR:", err)

    # Define the viewport dimensions
    VP_WIDTH, VP_HEIGHT = window.getFramebufferSize()
    gl.viewport(0, 0, VP_WIDTH, VP_HEIGHT)

    # Setup some OpenGL options
    gl.enable(gl.DEPTH_TEST);

    #Setup and compile our shaders
    shaderGeometryPass = Shader(G_BUFFER_VERT, G_BUFFER_FRAG);
    shaderLightingPass = Shader(DEFERRED_SHADING_VERT, DEFERRED_SHADING_FRAG);
    shaderLightBox = Shader(DEFERRED_LIGHT_BOX_VERT, DEFERRED_LIGHT_BOX_FRAG);

    gPosition, gNormal, gAlbedoSpec = gl.genTextures(3)

    shaderLightingPass.use()
    shaderLightingPass.uniforms.gPosition = gNormal
    shaderLightingPass.uniforms.gNormal = gPosition
    shaderLightingPass.uniforms.gAlbedoSpec = gAlbedoSpec

     # "learningopengl/resources/objects/cyborg/cyborg.obj"
    cyborg = Model("learningopengl/resources/objects/cyborg/cyborg.obj")

    objectPositions = [
        Vec3(-3.0, -3.0, -3.0),
        Vec3( 0.0, -3.0, -3.0),
        Vec3( 3.0, -3.0, -3.0),
        Vec3(-3.0, -3.0,  0.0),
        Vec3( 0.0, -3.0,  0.0),
        Vec3( 3.0, -3.0,  0.0),
        Vec3(-3.0, -3.0,  3.0),
        Vec3( 0.0, -3.0,  3.0),
        Vec3( 3.0, -3.0,  3.0)
    ]

    NR_LIGHTS = 32
    lightPositions = (Vec3 * NR_LIGHTS)()
    lightColors = (Vec3 * NR_LIGHTS)()

    for i in range(NR_LIGHTS):
        lightPositions[i].x = random.uniform(-3.0, 3.0)
        lightPositions[i].y = random.uniform(-4.0, 2.0)
        lightPositions[i].z = random.uniform(-3.0, 3.0)

        lightColors[i].x = random.uniform(0.5, 1.0)
        lightColors[i].y = random.uniform(0.5, 1.0)
        lightColors[i].z = random.uniform(0.5, 1.0)

    # set up the G-buffer
    # 3 textures: p
    #   1. Positions (RGB)
    #   2. Color (RGB) + Specular (A)
    #   3. Normal (RGB)
    gBuffer = gl.genFramebuffers(1)[0]
    gl.bindFramebuffer(gl.FRAMEBUFFER, gBuffer)

    # set up the position buffer
    gl.bindTexture(gl.TEXTURE_2D, gPosition)
    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGB16F, VP_WIDTH, VP_HEIGHT, 0, gl.RGB, gl.FLOAT, None)
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
    gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, gPosition, 0)

    # set up the normal buffer
    gl.bindTexture(gl.TEXTURE_2D, gNormal);
    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGB, VP_WIDTH, VP_HEIGHT, 0, gl.RGB, gl.FLOAT,None)
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST)
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST)
    gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT1, gl.TEXTURE_2D, gNormal, 0)

    # set up the color + specular buffer
    gl.bindTexture(gl.TEXTURE_2D, gAlbedoSpec);
    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, VP_WIDTH, VP_HEIGHT, 0, gl.RGBA, gl.FLOAT, None)
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
    gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT2, gl.TEXTURE_2D, gAlbedoSpec, 0)

    # - Tell OpenGL which color attachments we'll use (of this framebuffer) for rendering
    attachments = [gl.COLOR_ATTACHMENT0, gl.COLOR_ATTACHMENT1, gl.COLOR_ATTACHMENT2]
    gl.drawBuffers(attachments)

    # - Create and attach depth buffer (renderbuffer)
    rboDepth = gl.genRenderbuffers(1)[0]
    gl.bindRenderbuffer(gl.RENDERBUFFER, rboDepth)
    gl.renderbufferStorage(gl.RENDERBUFFER,gl.DEPTH_COMPONENT, VP_WIDTH, VP_HEIGHT);
    gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.RENDERBUFFER, rboDepth)

    # - Finally check if framebuffer is complete
    if gl.checkFramebufferStatus(gl.FRAMEBUFFER) != gl.FRAMEBUFFER_COMPLETE:
        print("Framebuffer not complete!")

    gl.bindFramebuffer(gl.FRAMEBUFFER, 0)

    gl.clearColor(0.0, 0.0, 0.0, 0.0)

    # Game loop
    while not window.shouldClose():
        # Set frame time
        currentFrame = time.perf_counter()
        deltaTime = currentFrame - lastFrame;
        lastFrame = currentFrame;

        # Check and call events
        inputMap.begin_frame()
        glfw.pollEvents()
        input = inputMap.get_input()
        camera.processInput(input, 1.0/30.0)

        gl.bindFramebuffer(gl.FRAMEBUFFER, gBuffer)
        gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)

        # TODO: use camera.zoom
        # 1. Geometry Pass: render scene's geometry/color data into gbuffer
        projection = Mat4.Perspective(45.0, float(SCR_WIDTH)/float(SCR_HEIGHT), 0.1, 100.0)
        view = camera.getViewMatrix()
        model = Mat4.Identity()

        shaderGeometryPass.use()
        shaderGeometryPass.uniforms.projection = projection
        shaderGeometryPass.uniforms.view = view

        for objectPosition in objectPositions:
            model = Mat4.Translation(objectPosition) * Mat4.Scale(0.25)
            shaderGeometryPass.uniforms.model = model
            cyborg.draw(shaderGeometryPass)

        gl.bindFramebuffer(gl.FRAMEBUFFER, 0)

        gl.polygonMode(gl.FRONT_AND_BACK, gl.FILL)

        # 2. Lighting Pass: calculate lighting by iterating over a screen filled quad pixel-by-pixel using the gbuffer's content.
        gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
        shaderLightingPass.use()
        shaderLightingPass.uniforms.gPosition = gPosition
        shaderLightingPass.uniforms.gNormal = gNormal
        shaderLightingPass.uniforms.gAlbedoSpec = gAlbedoSpec

        # Also send light relevant uniforms
        for i, lightPosition in enumerate(lightPositions):
            shaderLightingPass.uniforms.lights[i].Position = lightPosition
            shaderLightingPass.uniforms.lights[i].Color = lightColors[i]

            # Update attenuation parameters and calculate radius
            constant = 1.0
            linear = shaderLightingPass.uniforms.lights[i].Linear = 0.7
            quadratic = shaderLightingPass.uniforms.lights[i].Quadratic = 1.8

            # Then calculate radius of light volume/sphere
            lightThreshold = 5.0 # 5 / 256
            maxBrightness = max(max(lightColors[i].r, lightColors[i].g), lightColors[i].b)
            radius = (-linear + math.sqrt(linear * linear - 4 * quadratic * (constant - (256.0 / lightThreshold) * maxBrightness))) / (2 * quadratic)
            shaderLightingPass.uniforms.lights[i].Radius = radius

        shaderLightingPass.uniforms.viewPos = camera.position
        if window.getKey(glfw.KEY_1):
            draw_mode = 1
        if window.getKey(glfw.KEY_2):
            draw_mode = 2
        if window.getKey(glfw.KEY_3):
            draw_mode = 3
        if window.getKey(glfw.KEY_4):
            draw_mode = 4
        if window.getKey(glfw.KEY_5):
            draw_mode = 5
        # print("SETTING DRAW MODE:", draw_mode)

        try:
            shaderLightingPass.uniforms.draw_mode = draw_mode
        except:
            pass

        RenderQuad()

        # 2.5. Copy content of geometry's depth buffer to default framebuffer's depth buffer
        gl.bindFramebuffer(gl.READ_FRAMEBUFFER, gBuffer);
        gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, 0); # Write to default framebuffer
        gl.blitFramebuffer(0, 0, VP_WIDTH, VP_HEIGHT, 0, 0, VP_WIDTH, VP_HEIGHT, gl.DEPTH_BUFFER_BIT, gl.NEAREST);
        gl.bindFramebuffer(gl.FRAMEBUFFER, 0);

        # 3. Render lights on top of scene, by blitting
        shaderLightBox.use()
        shaderLightBox.uniforms.projection = projection
        # glUniformMatrix4fv(glGetUniformLocation(shaderLightBox.Program, "projection"), 1, GL_FALSE, glm::value_ptr(projection));
        shaderLightBox.uniforms.view = view
        # glUniformMatrix4fv(glGetUniformLocation(shaderLightBox.Program, "view"), 1, GL_FALSE, glm::value_ptr(view));

        for i, lightPosition in enumerate(lightPositions):
            model = Mat4.Translation(lightPosition) * Mat4.Scale(0.25)
            shaderLightBox.uniforms.model = model
            shaderLightBox.uniforms.lightColor = lightColors[i]
            RenderCube()

        # Swap the buffers
        window.swapBuffers()

    return 0
コード例 #6
0
ファイル: editor2.py プロジェクト: springtangent/ld34
def main():
    glfw.setErrorCallback(error_callback)

    glfw.init()
    glfw.windowHint(glfw.CONTEXT_VERSION_MAJOR, 3)
    glfw.windowHint(glfw.CONTEXT_VERSION_MINOR, 3)
    glfw.windowHint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
    # glfw.windowHint(glfw.RESIZABLE, gl.FALSE)
    glfw.windowHint(glfw.OPENGL_FORWARD_COMPAT, 1)

    if ENABLE_MULTISAMPLE:
        glfw.windowHint(glfw.SAMPLES, 4)

    window = glfw.createWindow(WIDTH, HEIGHT, "LearnOpenGL")

    if window is None:
        print('could not open window.')
        glfw.terminate()
        sys.exit()

    window.makeContextCurrent()
    # window.setInputMode(glfw.CURSOR, glfw.CURSOR_DISABLED)
    window.setKeyCallback(key_callback)

    gl.init()
    err = gl.getError()
    if err:
        print("WINDOW OPEN ERROR:", err)


    framebuffer_width, framebuffer_height = window.getFramebufferSize()

    # Framebuffers
    framebuffer = gl.genFramebuffers(1)[0]
    gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer); 

    # Create a color attachment texture
    textureColorbuffer = generateAttachmentTexture(gl.RGB, framebuffer_width, framebuffer_height);
    gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, textureColorbuffer, 0)

    # set up the position buffer
    gPosition = gl.genTextures(1)[0]
    gl.bindTexture(gl.TEXTURE_2D, gPosition)
    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGB16F, framebuffer_width, framebuffer_height, 0, gl.RGB, gl.FLOAT, None)
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
    gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT1, gl.TEXTURE_2D, gPosition, 0)

    # set up the normal buffer
    gNormal = gl.genTextures(1)[0]
    gl.bindTexture(gl.TEXTURE_2D, gNormal)
    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGB16F, framebuffer_width, framebuffer_height, 0, gl.RGB, gl.FLOAT, None)
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
    gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT2, gl.TEXTURE_2D, gNormal, 0)

    gLight = gl.genTextures(1)[0]
    gl.bindTexture(gl.TEXTURE_2D, gLight)
    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGB16F, framebuffer_width, framebuffer_height, 0, gl.RGB, gl.FLOAT, None)
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
    gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT3, gl.TEXTURE_2D, gLight, 0)
    # - Tell OpenGL which color attachments we'll use (of this framebuffer) for rendering
    attachments = [gl.COLOR_ATTACHMENT0, gl.COLOR_ATTACHMENT1, gl.COLOR_ATTACHMENT2]
    gl.drawBuffers(attachments)


    gDepth = gl.genTextures(1)[0]
    gl.bindTexture(gl.TEXTURE_2D, gDepth)
    gl.texImage2D(gl.TEXTURE_2D, 0, gl.DEPTH24_STENCIL8, framebuffer_width, framebuffer_height, 0, gl.DEPTH_STENCIL, gl.UNSIGNED_INT_24_8, None)
    # gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGB16F, framebuffer_width, framebuffer_height, 0, gl.RGB, gl.FLOAT, None)
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
    gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.DEPTH_STENCIL_ATTACHMENT, gl.TEXTURE_2D, gDepth, 0)

    # Create a renderbuffer object for depth and stencil attachment (we won't be sampling these)
    # rbo = gl.genRenderbuffers(1)[0]
    # gl.bindRenderbuffer(gl.RENDERBUFFER, rbo)
    # gl.renderbufferStorage(gl.RENDERBUFFER, gl.DEPTH24_STENCIL8, framebuffer_width, framebuffer_height); # Use a single renderbuffer object for both a depth AND stencil buffer.
    # gl.bindRenderbuffer(gl.RENDERBUFFER, 0);
    # gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_STENCIL_ATTACHMENT, gl.RENDERBUFFER, rbo) # Now actually attach it

    # Now that we actually created the framebuffer and added all attachments we want to check if it is actually complete now
    if gl.checkFramebufferStatus(gl.FRAMEBUFFER) != gl.FRAMEBUFFER_COMPLETE:
        print("ERROR::FRAMEBUFFER:: Framebuffer is not complete!")

    gl.bindFramebuffer(gl.FRAMEBUFFER, 0)


    deferred_textures = {
        'screenTexture': textureColorbuffer,
        'normalTexture': gNormal,
        'positionTexture': gPosition,
        'lightTexture': gLight,
        'depthTexture': gDepth
    }


    scene = Scene()
    camera = Camera(scene=scene)

    quad_scene = Scene()
    quad_camera = Camera(scene=quad_scene)

    light_scene = Scene()
    light_camera = Camera(scene=light_scene, clear=0)
    light_camera.clear = gl.COLOR_BUFFER_BIT
    light_camera.clear_color = (0.0, 0.0, 0.0, 0.0)

    light_camera.projection_matrix = camera.projection_matrix = Mat4.Perspective(45.0, framebuffer_width/framebuffer_height, 0.1, 100.0)
    light_camera.view_matrix = camera.view_matrix = Mat4.LookAt(Vec3(math.cos(time.clock()), 1.0, math.sin(time.clock())) *15.0, Vec3(0.0, 0.0, 0.0), Vec3(0.0, 1.0, 0.0))

    # light volume model
    light_volume_data = objloader.load_obj(os.path.join("springtangent-model-files", "lightsphere", "lightsphere.obj"), calculate_normals=True)
    light_volume_model = Model.FromJSON(light_volume_data, PointLightInstanceData, PlateInstance)

    # other models
    armored_plate_data = objloader.load_obj(os.path.join("springtangent-model-files", "armored_plate.75.75.decimation_test7.obj"), calculate_normals=True)
    armored_plate_model = Model.FromJSON(armored_plate_data, InstanceData, PlateInstance)

    plane_plate_data = objloader.load_obj(os.path.join("springtangent-model-files", "plane_plate.75.75.decimation_test.00.obj"), calculate_normals=True)
    plane_plate_model = Model.FromJSON(plane_plate_data, InstanceData, PlateInstance)

    angled_plate_data = objloader.load_obj(os.path.join("springtangent-model-files", "angled_plate_plane.75.25..25.decimated.obj"), calculate_normals=True)
    angled_plate_model = Model.FromJSON(angled_plate_data, InstanceData, PlateInstance)

    angled_to_rounded_data = objloader.load_obj(os.path.join("springtangent-model-files", "angled_to_round_adapter.75.25.25", "angled_to_rounded_adapter.75.25.25.decimated.obj"), calculate_normals=True)
    angled_to_rounded_model = Model.FromJSON(angled_to_rounded_data, InstanceData, PlateInstance)

    models = [armored_plate_model, plane_plate_model, angled_plate_model, angled_to_rounded_model]

    deferred_shader = ShaderProgram(GBUFFER_VERT, GBUFFER_FRAG)
    deferred_light_shader = ShaderProgram(GBUFFER_LIGHT_VERT, GBUFFER_LIGHT_FRAG)

    for mesh in light_volume_model.meshes:
        mesh.shader = deferred_light_shader
        mesh.material = deferred_textures

    # replace the shader with the deferred shader in all meshes
    for model in models:
        for mesh in model.meshes:
            mesh.shader = deferred_shader


    # set up the data for the instances.
    # 30 x 30 array of tiles, which are randomly selected among the above models
    n = 30
    instances = {}
    for i in range(n):
        for j in range(n):
            r = random.choice(range(4))
            transform = Mat4.Translation(Vec3((i-n//2) * 2, 0.0, (j-n//2) * 2)) * Mat4.Rotation(math.pi/2.0 * r, Vec3(0.0, 1.0, 0.0))
            instance = scene.add(random.choice(models), InstanceData(transform))
            instance.r = r
            instances[i,j] = instance

    nlights = 400
    for i in range(nlights):
        transform = Mat4.Translation(Vec3(random.uniform(-n/2, n/2), random.uniform(-1.0, 1.0), random.uniform(-n/2,n/2))) * Mat4.Scale(random.uniform(2.0, 10.0))
        instance = light_scene.add(light_volume_model, PointLightInstanceData(transform, diffuse=Vec3(1.0, 1.0, 1.0), linear_attenuation=0.1, quadratic_attenutation=0.01))

    # full screen rectangle
    class QuadVert(Structure):
        _fields_ = [
            ('position', Vec2),
            ('texcoord', Vec2)
        ]

    quad_points = Vector(QuadVert)
    quad_points.append(QuadVert(Vec2(-1.0,  1.0), Vec2(0.0, 1.0)))
    quad_points.append(QuadVert(Vec2(-1.0, -1.0), Vec2(0.0, 0.0)))
    quad_points.append(QuadVert(Vec2( 1.0, -1.0), Vec2(1.0, 0.0)))
    quad_points.append(QuadVert(Vec2( 1.0,  1.0), Vec2(1.0, 1.0)))

    quad_indices = Vector(c_ubyte)
    quad_indices.append(0)
    quad_indices.append(1)
    quad_indices.append(2)
    quad_indices.append(0)
    quad_indices.append(2)
    quad_indices.append(3)


    quad_attribs = BufferAttribs(sizeof(QuadVert))
    quad_attribs.add(BufferAttribs.POSITION_INDEX, 2, gl.FLOAT, gl.FALSE, QuadVert.position.offset)
    quad_attribs.add(BufferAttribs.TEXCOORD_INDEX, 2, gl.FLOAT, gl.FALSE, QuadVert.texcoord.offset)

    quad_shader = ShaderProgram(FRAMEBUFFER_VERT, FRAMEBUFFER_FRAG)

    quad_draw_call = DrawCall(gl.UNSIGNED_BYTE, gl.TRIANGLES, 0, len(quad_indices))

    quad_material = deferred_textures

    quad_mesh = Mesh(quad_shader, quad_draw_call, quad_material)

    quad_model = Model(quad_indices.get_data(), quad_points.get_data(), quad_attribs, [quad_mesh], InstanceData, PlateInstance)

    # quad_instances = ModelInstances(quad_model)

    quad_instance = quad_scene.add(quad_model, InstanceData(Mat4.Identity()))

    
    gl.enable(gl.MULTISAMPLE)
    t0 = time.perf_counter()
    frames = 0
    while not window.shouldClose():
        glfw.pollEvents()

        t = time.perf_counter()

        # render scene to gbuffer
        gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer)

        gl.enable(gl.DEPTH_TEST)
        gl.depthFunc(gl.LEQUAL)

        gl.enable(gl.CULL_FACE)
        gl.cullFace(gl.BACK)

        # set up gbuffer for writing
        attachments = [gl.COLOR_ATTACHMENT0, gl.COLOR_ATTACHMENT1, gl.COLOR_ATTACHMENT2]
        gl.drawBuffers(attachments)

        framebuffer_width, framebuffer_height = window.getFramebufferSize()
        light_camera.view_matrix = camera.view_matrix = Mat4.LookAt(Vec3(math.cos(time.clock() * 0.1), 1.0, math.sin(time.clock() * 0.1)) *15.0, Vec3(0.0, 0.0, 0.0), Vec3(0.0, 1.0, 0.0))
        viewport = (0, 0, framebuffer_width, framebuffer_height)
        camera.render_to_viewport(viewport)


        # render lights to gbuffer
        gl.drawBuffer(gl.COLOR_ATTACHMENT3)
        gl.depthFunc(gl.GREATER)

        gl.enable(gl.CULL_FACE)
        gl.cullFace(gl.FRONT)

        gl.enable(gl.BLEND)
        gl.blendEquation(gl.FUNC_ADD)
        gl.blendFunc(gl.ONE, gl.ONE)

        light_camera.render_to_viewport(viewport)

        err = gl.getError()
        if err:
            print("ERROR:", err)


        if TEST_ANIMATION:
            for i in range(n):
                for j in range(n):
                    instance = instances[i,j]
                    enabled = True # math.sin(i+j+t*10.0) > -0.8
                    # instance.set_enabled(enabled)
                    if enabled:
                        y = (math.sin(t+i) + math.cos(t+j)) * 0.25
                        transform = Mat4.Translation(Vec3((i-n//2) * 2, y, (j-n//2) * 2)) * Mat4.Rotation(math.pi/2.0 * instance.r, Vec3(0.0, 1.0, 0.0))
                        instance.model_matrix = transform

        # render quad with texture
        gl.bindFramebuffer(gl.FRAMEBUFFER, 0)

        gl.disable(gl.BLEND)
        gl.disable(gl.CULL_FACE)
        gl.disable(gl.DEPTH_TEST) # We don't care about depth information when rendering a single quad

        quad_camera.clear_color = (1.0, 1.0, 1.0, 1.0)
        quad_camera.clear = gl.COLOR_BUFFER_BIT
        quad_camera.render_to_viewport(viewport)

        scene.update_instances()
        quad_scene.update_instances()
        light_scene.update_instances()

        window.swapBuffers()

        frames += 1
        if not frames % 100:
            print("FRAME RATE:", float(frames)/(time.perf_counter() - t0))