Java Code Examples for com.jogamp.opengl.GL3#glDisable()

@Override
public void display(GLAutoDrawable drawable, Matrix44f pMatrix) {

    // Draw the graph texture to the screen
    final GL3 gl = drawable.getGL().getGL3();
    gl.glBindFramebuffer(GL3.GL_DRAW_FRAMEBUFFER, 0);
    gl.glActiveTexture(GL3.GL_TEXTURE0);
    gl.glBindTexture(GL3.GL_TEXTURE_2D, graphColorTextureName[0]);
    gl.glActiveTexture(GL3.GL_TEXTURE0 + 1);
    gl.glBindTexture(GL3.GL_TEXTURE_2D, graphDepthTextureName[0]);
    gl.glUseProgram(graphTextureShader);
    gl.glUniform1i(graphColorTextureShaderLocation, 0);
    gl.glUniform1i(graphDepthTextureShaderLocation, 1);
    bindShaderLocations(gl);
    gl.glDisable(GL3.GL_DEPTH_TEST);
    graphTextureBatch.draw(gl);
    gl.glEnable(GL3.GL_DEPTH_TEST);
}
 

@Override
public void drawBatch(final GL3 gl, final Camera camera, final Matrix44f mvMatrix, final Matrix44f pMatrix) {

    if (batch.isDrawable()) {
        gl.glUseProgram(shader);
        gl.glUniformMatrix4fv(shaderMVMatrix, 1, false, mvMatrix.a, 0);
        gl.glUniformMatrix4fv(shaderPMatrix, 1, false, pMatrix.a, 0);
        gl.glUniform1f(shaderVisibilityLow, camera.getVisibilityLow());
        gl.glUniform1f(shaderVisibilityHigh, camera.getVisibilityHigh());
        gl.glUniform1f(shaderMorphMix, camera.getMix());
        gl.glUniform1i(shaderXyzTexture, TextureUnits.VERTICES);
        gl.glUniform1i(shaderImagesTexture, TextureUnits.ICONS);
        gl.glUniform1f(shaderScale, blazeSize);
        gl.glUniform1f(shaderOpacity, blazeOpacity);

        gl.glDisable(GL3.GL_DEPTH_TEST);
        batch.draw(gl);
        gl.glEnable(GL3.GL_DEPTH_TEST);
    }
}
 

@Override
protected boolean render(GL gl) {

    GL3 gl3 = (GL3) gl;

    // Clear the framebuffer
    gl3.glBindFramebuffer(GL_FRAMEBUFFER, 0);
    gl3.glClearBufferfv(GL_COLOR, 0, clearColor.put(0, 0).put(1, .5f).put(2, 1).put(3, 1));

    // Pass 1
    // Render the scene in a multisampled framebuffer
    gl3.glEnable(GL_MULTISAMPLE);
    renderFBO(gl3);
    gl3.glDisable(GL_MULTISAMPLE);

    // Pass 2
    // Resolved and render the colorbuffer from the multisampled framebuffer
    resolveMultisampling(gl3);

    return true;
}
 

@Override
protected boolean render(GL gl) {

    GL3 gl3 = (GL3) gl;

    // Clear the framebuffer
    gl3.glBindFramebuffer(GL_FRAMEBUFFER, 0);
    gl3.glClearBufferfv(GL_COLOR, 0, new float[]{0.0f, 0.5f, 1.0f, 1.0f}, 0);

    // Pass 1
    // Render the scene in a multisampled framebuffer
    gl3.glEnable(GL_MULTISAMPLE);
    renderFBO(gl3, framebufferRenderName.get(0));
    gl3.glDisable(GL_MULTISAMPLE);

    // Pass 2
    // Resolved and render the colorbuffer from the multisampled framebuffer
    resolveMultisampling(gl3);

    return true;
}
 

@Override
public boolean render(GL gl) {

    GL3 gl3 = (GL3) gl;

    // Clear the framebuffer
    gl3.glBindFramebuffer(GL_FRAMEBUFFER, 0);
    gl3.glClearBufferfv(GL_COLOR, 0, new float[]{1.0f, 0.5f, 0.0f, 1.0f}, 0);

    gl3.glUseProgram(programName);
    gl3.glUniform1i(uniformDiffuse, 0);

    // Pass 1
    // Render the scene in a multisampled framebuffer
    gl3.glEnable(GL_MULTISAMPLE);
    renderFBO(gl3, framebufferName.get(Framebuffer.RENDER));
    gl3.glDisable(GL_MULTISAMPLE);

    // Resolved multisampling
    gl3.glBindFramebuffer(GL_READ_FRAMEBUFFER, framebufferName.get(Framebuffer.RENDER));
    gl3.glBindFramebuffer(GL_DRAW_FRAMEBUFFER, framebufferName.get(Framebuffer.RESOLVE));
    gl3.glDrawBuffer(GL_COLOR_ATTACHMENT0);
    gl3.glBlitFramebuffer(
            0, 0, FRAMEBUFFER_SIZE.x, FRAMEBUFFER_SIZE.y,
            0, 0, FRAMEBUFFER_SIZE.x, FRAMEBUFFER_SIZE.y,
            GL_COLOR_BUFFER_BIT, GL_LINEAR);
    gl3.glBindFramebuffer(GL_FRAMEBUFFER, 0);

    // Pass 2
    // Render the colorbuffer from the multisampled framebuffer
    gl3.glViewport(0, 0, windowSize.x, windowSize.y);
    renderFB(gl3, textureName.get(Texture.RESOLVE));
    return true;
}
 

@Override
public void display(final GLAutoDrawable drawable, final Matrix44f projectionMatrix) {
    final GL3 gl = drawable.getGL().getGL3();

    // Extract the rotation matrix from the mvp matrix.
    final Matrix44f rotationMatrix = new Matrix44f();
    parent.getDisplayModelViewProjectionMatrix().getRotationMatrix(rotationMatrix);

    // Scale down to size.
    final Matrix44f scalingMatrix = new Matrix44f();
    scalingMatrix.makeScalingMatrix(pScale, pScale, 0);
    final Matrix44f srMatrix = new Matrix44f();
    srMatrix.multiply(scalingMatrix, rotationMatrix);

    // Translate to the top right corner.
    final Matrix44f translationMatrix = new Matrix44f();
    translationMatrix.makeTranslationMatrix(topRightCorner.getX(), topRightCorner.getY(), topRightCorner.getZ());
    final Matrix44f axesMatrix = new Matrix44f();
    axesMatrix.multiply(translationMatrix, srMatrix);

    // Disable depth so the axes are drawn over everything else.
    gl.glDisable(GL3.GL_DEPTH_TEST);
    gl.glDepthMask(false);

    // Draw.
    gl.glLineWidth(1);
    gl.glUseProgram(axesShader);
    gl.glUniformMatrix4fv(axesShaderLocMVP, 1, false, axesMatrix.a, 0);
    axesBatch.draw(gl);

    // Reenable depth.
    gl.glEnable(GL3.GL_DEPTH_TEST);
    gl.glDepthMask(true);
}
 

private void renderFBO(GL3 gl3, int framebuffer) {

        Mat4 perspective = glm.perspective_((float) Math.PI * 0.25f, (float) FRAMEBUFFER_SIZE.x / FRAMEBUFFER_SIZE.y,
                0.1f, 100.0f);
        Mat4 model = new Mat4(1.0f).scale(new Vec3(1.0f));
        Mat4 mvp = perspective.mul(viewMat4()).mul(model);

        gl3.glEnable(GL_DEPTH_TEST);

        gl3.glUseProgram(programName[Program.THROUGH]);
        gl3.glUniform1i(uniformDiffuse[Program.THROUGH], 0);
        gl3.glUniformMatrix4fv(uniformMvp[Program.THROUGH], 1, false, mvp.toFa_(), 0);

        gl3.glViewport(0, 0, FRAMEBUFFER_SIZE.x, FRAMEBUFFER_SIZE.y);

        gl3.glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
        float[] depth = new float[]{1.0f};
        gl3.glClearBufferfv(GL_DEPTH, 0, depth, 0);
        gl3.glClearBufferfv(GL_COLOR, 0, new float[]{1.0f, 0.5f, 0.0f, 1.0f}, 0);

        gl3.glActiveTexture(GL_TEXTURE0);
        gl3.glBindTexture(GL_TEXTURE_2D, textureName.get(Texture.DIFFUSE));
        gl3.glBindVertexArray(vertexArrayName.get(0));

        gl3.glDrawArraysInstanced(GL_TRIANGLES, 0, vertexCount, 5);

        gl3.glDisable(GL_DEPTH_TEST);
    }
 

private void resolveMultisampling(GL3 gl3) {

        Mat4 perspective = glm.perspective_((float) Math.PI * 0.25f, (float) windowSize.x / windowSize.y, 0.1f, 100.0f);
        Mat4 model = new Mat4(1.0f);
        Mat4 mvp = perspective.mul(viewMat4()).mul(model);

        gl3.glViewport(0, 0, windowSize.x, windowSize.y);
        gl3.glBindFramebuffer(GL_FRAMEBUFFER, 0);

        gl3.glClearBufferfv(GL_COLOR, 0, clearColor.put(0, 1).put(1, 1).put(2, 1).put(3, 1));

        gl3.glActiveTexture(GL_TEXTURE0);
        gl3.glBindTexture(GL_TEXTURE_RENDERBUFFER_NV, textureName.get(Texture.COLOR));
        gl3.glBindSampler(0, samplerName.get(0));

        gl3.glBindVertexArray(vertexArrayName.get(0));

        gl3.glEnable(GL_SCISSOR_TEST);

        // Box
        {
            gl3.glScissor(1, 1, windowSize.x / 2 - 2, windowSize.y - 2);
            gl3.glUseProgram(programName[Program.RESOLVE_BOX]);
            gl3.glUniform1i(uniformDiffuse[Program.RESOLVE_BOX], 0);
            gl3.glUniformMatrix4fv(uniformMvp[Program.RESOLVE_BOX], 1, false, mvp.toFa_(), 0);
            gl3.glDrawArraysInstanced(GL_TRIANGLES, 0, vertexCount, 5);
        }

        // Near
        {
            gl3.glScissor(windowSize.x / 2 + 1, 1, windowSize.x / 2 - 2, windowSize.y - 2);
            gl3.glUseProgram(programName[Program.RESOLVE_NEAR]);
            gl3.glUniform1i(uniformDiffuse[Program.RESOLVE_NEAR], 0);
            gl3.glUniformMatrix4fv(uniformMvp[Program.RESOLVE_NEAR], 1, false, mvp.toFa_(), 0);
            gl3.glDrawArraysInstanced(GL_TRIANGLES, 0, vertexCount, 5);
        }

        gl3.glDisable(GL_SCISSOR_TEST);
    }
 

@Override
protected boolean render(GL gl) {

    GL3 gl3 = (GL3) gl;

    Mat4 projection = glm.perspective_((float) Math.PI * 0.25f, 4.0f / 3.0f, 0.1f, 100.0f);
    Mat4 view = viewMat4();
    Mat4 model = new Mat4(1.0f);
    Mat4 mvp = projection.mul(view).mul(model);
    Mat4 mv = view.mul(model);

    gl3.glViewport(0, 0, windowSize.x, windowSize.y);
    gl3.glClearBufferfv(GL_COLOR, 0, clearColor);
    gl3.glClearBufferfv(GL_DEPTH, 0, clearDepth);

    gl3.glDisable(GL_SCISSOR_TEST);

    gl3.glUseProgram(programName);
    gl3.glUniformMatrix4fv(uniformMv, 1, false, mv.toFa_(), 0);
    gl3.glUniformMatrix4fv(uniformMvp, 1, false, mvp.toFa_(), 0);

    gl3.glBindVertexArray(vertexArrayName.get(0));

    gl3.glDrawArraysInstanced(GL_POINTS, 0, vertexCount, 1);

    return true;
}
 

@Override
protected boolean render(GL gl) {

    GL3 gl3 = (GL3) gl;

    // Clear the framebuffer
    gl3.glBindFramebuffer(GL_FRAMEBUFFER, 0);
    gl3.glClearBufferfv(GL_COLOR, 0, new float[]{1.0f, 0.5f, 0.0f, 1.0f}, 0);

    // Pass 1
    // Render the scene in a multisampled framebuffer
    gl3.glEnable(GL_MULTISAMPLE);
    renderFBO(gl3, framebufferName.get(Framebuffer.RENDER));
    gl3.glDisable(GL_MULTISAMPLE);

    // Resolved multisampling
    gl3.glBindFramebuffer(GL_READ_FRAMEBUFFER, framebufferName.get(Framebuffer.RENDER));
    gl3.glBindFramebuffer(GL_DRAW_FRAMEBUFFER, framebufferName.get(Framebuffer.RESOLVE));
    gl3.glBlitFramebuffer(
            0, 0, windowSize.x / framebufferSize, windowSize.y / framebufferSize,
            0, 0, windowSize.x / framebufferSize, windowSize.y / framebufferSize,
            GL_COLOR_BUFFER_BIT, GL_NEAREST);
    gl3.glBindFramebuffer(GL_FRAMEBUFFER, 0);

    // Pass 2
    // Render the colorbuffer from the multisampled framebuffer
    renderFB(gl3, textureName.get(Texture.COLORBUFFER));

    return checkError(gl3, "render");
}
 

private void renderFBO(GL3 gl3) {

        Mat4 perspective = glm.perspective_((float) Math.PI * 0.25f, (float) FRAMEBUFFER_SIZE.x / FRAMEBUFFER_SIZE.y,
                0.1f, 100.0f);
        Mat4 model = new Mat4(1.0f).scale(new Vec3(1, -1, 1));
        Mat4 mvp = perspective.mul(viewMat4()).mul(model);

        gl3.glEnable(GL_DEPTH_TEST);

        gl3.glUseProgram(programName[Program.THROUGH]);
        gl3.glUniform1i(uniformDiffuse[Program.THROUGH], 0);
        gl3.glUniformMatrix4fv(uniformMvp[Program.THROUGH], 1, false, mvp.toFa_(), 0);

        gl3.glViewport(0, 0, FRAMEBUFFER_SIZE.x, FRAMEBUFFER_SIZE.y);

        gl3.glBindFramebuffer(GL_FRAMEBUFFER, framebufferName.get(0));
        gl3.glClearBufferfv(GL_DEPTH, 0, clearDepth.put(0, 1));
        gl3.glClearBufferfv(GL_COLOR, 0, clearColor.put(0, 1).put(1, .5f).put(2, 0).put(3, 1));

        gl3.glActiveTexture(GL_TEXTURE0);
        gl3.glBindTexture(GL_TEXTURE_2D, textureName.get(Texture.DIFFUSE));
        gl3.glBindSampler(0, samplerName.get(0));
        gl3.glBindVertexArray(vertexArrayName.get(0));

        gl3.glDrawArraysInstanced(GL_TRIANGLES, 0, vertexCount, 5);

        gl3.glDisable(GL_DEPTH_TEST);

        checkError(gl3, "renderFBO");
    }
 

private void resolveMultisampling(GL3 gl3) {

        Mat4 perspective = glm.ortho_(-1.0f, 1.0f, -1.0f, 1.0f, 0.0f, 100.0f);
        Mat4 viewFlip = new Mat4(1.0f).scale(new Vec3(1.0f, -1.0f, 1.0f));
        Mat4 view = viewFlip.translate(new Vec3(0.0f, 0.0f, -cameraDistance() * 1.0f));
        Mat4 model = new Mat4(1.0f);
        Mat4 mvp = perspective.mul(view).mul(model);

        gl3.glViewport(0, 0, windowSize.x, windowSize.y);
        gl3.glBindFramebuffer(GL_FRAMEBUFFER, 0);

        gl3.glActiveTexture(GL_TEXTURE0);
        gl3.glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, textureName.get(Texture.MULTISAMPLE_COLORBUFFER));

        gl3.glBindVertexArray(vertexArrayName.get(0));

        gl3.glEnable(GL_SCISSOR_TEST);

        // Box
        {
            gl3.glScissor(1, 1, windowSize.x / 2 - 2, windowSize.y - 2);

            gl3.glUseProgram(programName[Program.RESOLVE_BOX]);
            gl3.glUniform1i(uniformDiffuse[Program.RESOLVE_BOX], 0);
            gl3.glUniformMatrix4fv(uniformMvp[Program.RESOLVE_BOX], 1, false, mvp.toFa_(), 0);

            gl3.glDrawArraysInstanced(GL_TRIANGLES, 0, vertexCount, 5);
        }

        // Near
        {
            gl3.glScissor(windowSize.x / 2 + 1, 1, windowSize.x / 2 - 2, windowSize.y - 2);

            gl3.glUseProgram(programName[Program.RESOLVE_NEAR]);
            gl3.glUniform1i(uniformDiffuse[Program.RESOLVE_NEAR], 0);
            gl3.glUniformMatrix4fv(uniformMvp[Program.RESOLVE_NEAR], 1, false, mvp.toFa_(), 0);

            gl3.glDrawArraysInstanced(GL_TRIANGLES, 0, vertexCount, 5);
        }

        gl3.glDisable(GL_SCISSOR_TEST);
    }
 

@Override
protected boolean render(GL gl) {

    GL3 gl3 = (GL3) gl;

    Vec3 minScissor = new Vec3(10000.f, 10000.f, 10000.f);
    Vec3 maxScissor = new Vec3(-10000.f, -10000.f, -10000.f);

    {
        gl3.glBindBuffer(GL_UNIFORM_BUFFER, bufferName.get(Buffer.TRANSFORM));
        ByteBuffer pointer = gl3.glMapBufferRange(
                GL_UNIFORM_BUFFER, 0, Mat4.SIZE,
                GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT);

        Mat4 projection = glm.perspective_((float) Math.PI * 0.25f, 4.0f / 3.0f, 0.1f, 100.0f);
        Mat4 view = viewMat4();
        Mat4 model = new Mat4(1.0f);

        pointer.asFloatBuffer().put(projection.mul_(view).mul(model).toFa_());

        // Make sure the uniform buffer is uploaded
        gl3.glUnmapBuffer(GL_UNIFORM_BUFFER);

        for (int i = 0; i < vertexCount; ++i) {

            Vec3 projected = glm.project_(
                    new Vec3(vertexData[i * 4 + 0], vertexData[i * 4 + 1], 0.0f),
                    view.mul_(model),
                    projection,
                    new Vec4(0, 0, windowSize.x, windowSize.y));

            minScissor.min(projected);
            maxScissor.max(projected);
        }
    }

    gl3.glViewport(0, 0, windowSize.x, windowSize.y);
    clearColor.put(new float[]{1.0f, 0.5f, 0.0f, 1.0f}).rewind();
    gl3.glClearBufferfv(GL_COLOR, 0, clearColor);

    gl3.glScissor((int) minScissor.x, (int) minScissor.y, (int) (maxScissor.x - minScissor.x),
            (int) (maxScissor.y - minScissor.y));
    gl3.glEnable(GL_SCISSOR_TEST);
    clearColor.put(new float[]{0.0f, 0.0f, 0.0f, 1.0f}).rewind();
    gl3.glClearBufferfv(GL_COLOR, 0, clearColor);

    // Bind the program for use
    gl3.glUseProgram(programName);
    gl3.glUniform1i(uniformDiffuse, 0);
    gl3.glUniformBlockBinding(programName, uniformTransform, Semantic.Uniform.TRANSFORM0);

    gl3.glActiveTexture(GL_TEXTURE0);
    gl3.glBindTexture(GL_TEXTURE_2D, textureName.get(0));
    gl3.glBindBufferBase(GL_UNIFORM_BUFFER, Semantic.Uniform.TRANSFORM0, bufferName.get(Buffer.TRANSFORM));
    gl3.glBindVertexArray(vertexArrayName.get(0));

    gl3.glDrawArraysInstanced(GL_TRIANGLES, 0, vertexCount, 1);

    gl3.glDisable(GL_SCISSOR_TEST);

    return true;
}
 

@Override
protected boolean render(GL gl) {

    GL3 gl3 = (GL3) gl;

    Mat4 projection = glm.perspective_((float) Math.PI * 0.25f, 4.0f / 3.0f, 0.1f, 100.0f);
    Mat4 model = new Mat4(1.0f);
    Mat4 mvp = projection.mul(viewMat4()).mul(model);

    // Set the display viewport
    gl3.glViewport(0, 0, windowSize.x, windowSize.y);

    // Clear color buffer with black
    gl3.glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
    gl3.glClear(GL_COLOR_BUFFER_BIT);

    // First draw, capture the attributes
    {
        // Disable rasterisation, vertices processing only!
        gl3.glEnable(GL_RASTERIZER_DISCARD);

        gl3.glUseProgram(programName[Program.TRANSFORM]);
        gl3.glUniformMatrix4fv(uniformMvp, 1, false, mvp.toFa_(), 0);

        gl3.glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, feedbackOutput.POSITION, bufferName.get(Buffer.POSITION));
        gl3.glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, feedbackOutput.COLOR, bufferName.get(Buffer.COLOR));

        gl3.glBindVertexArray(vertexArrayName.get(Program.TRANSFORM));

        gl3.glBeginQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, queryName.get(0));
        gl3.glBeginTransformFeedback(GL_TRIANGLES);
        {
            gl3.glDrawArraysInstanced(GL_TRIANGLES, 0, vertexCount, 1);
        }
        gl3.glEndTransformFeedback();
        gl3.glEndQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN);

        gl3.glDisable(GL_RASTERIZER_DISCARD);
    }

    // Second draw, reuse the captured attributes
    {
        gl3.glUseProgram(programName[Program.FEEDBACK]);

        IntBuffer primitivesWritten = GLBuffers.newDirectIntBuffer(1);
        gl3.glGetQueryObjectuiv(queryName.get(0), GL_QUERY_RESULT, primitivesWritten);

        gl3.glBindVertexArray(vertexArrayName.get(Program.FEEDBACK));
        gl3.glDrawArraysInstanced(GL_TRIANGLES, 0, primitivesWritten.get(0) * 3, 1);

        BufferUtils.destroyDirectBuffer(primitivesWritten);
    }

    return true;
}
 

@Override
protected boolean render(GL gl) {

    GL3 gl3 = (GL3) gl;

    {
        gl3.glBindBuffer(GL_UNIFORM_BUFFER, bufferName.get(Buffer.TRANSFORM));
        ByteBuffer pointer = gl3.glMapBufferRange(GL_UNIFORM_BUFFER,
                0, Mat4.SIZE, GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT);

        Mat4 projection = glm.perspective_((float) Math.PI * 0.25f, (float) windowSize.x / windowSize.y, 0.1f, 100.0f);
        Mat4 model = new Mat4(1.0f);

        pointer.asFloatBuffer().put(projection.mul(viewMat4()).mul(model).toFa_());

        // Make sure the uniform buffer is uploaded
        gl3.glUnmapBuffer(GL_UNIFORM_BUFFER);
    }

    {
        gl3.glViewport(0, 0, windowSize.x * framebufferScale, windowSize.y * framebufferScale);

        gl3.glBindFramebuffer(GL_FRAMEBUFFER, framebufferName.get(0));
        gl3.glClearBufferfv(GL_COLOR, 0, new float[]{0.0f, 0.0f, 0.0f, 1.0f}, 0);
        gl3.glEnable(GL_FRAMEBUFFER_SRGB);

        gl3.glEnable(GL_BLEND);
        gl3.glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

        gl3.glUseProgram(programName[Program.RENDER]);

        gl3.glBindVertexArray(vertexArrayName.get(Program.RENDER));
        gl3.glBindBufferBase(GL_UNIFORM_BUFFER, Semantic.Uniform.TRANSFORM0, bufferName.get(Buffer.TRANSFORM));

        gl3.glDrawArraysInstanced(GL_POINTS, 0, 8, 1);

        gl3.glDisable(GL_BLEND);
    }

    {
        gl3.glViewport(0, 0, windowSize.x, windowSize.y);

        gl3.glBindFramebuffer(GL_FRAMEBUFFER, 0);
        gl3.glDisable(GL_FRAMEBUFFER_SRGB);

        gl3.glUseProgram(programName[Program.SPLASH]);

        gl3.glActiveTexture(GL_TEXTURE0);
        gl3.glBindVertexArray(vertexArrayName.get(Program.SPLASH));
        gl3.glBindTexture(GL_TEXTURE_2D, textureName.get(Texture.COLORBUFFER));

        gl3.glDrawArraysInstanced(GL_TRIANGLES, 0, 3, 1);
    }

    return true;
}
 

@Override
protected boolean render(GL gl) {

    GL3 gl3 = (GL3) gl;

    {
        gl3.glBindBuffer(GL_UNIFORM_BUFFER, bufferName.get(Buffer.TRANSFORM));
        ByteBuffer pointer = gl3.glMapBufferRange(
                GL_UNIFORM_BUFFER, 0, Mat4.SIZE,
                GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT);

        Mat4 projection = glm.perspective_((float) Math.PI * 0.25f, 4.0f / 3.0f, 0.5f, 8.0f);
        Mat4 model = new Mat4(1.0f).scale(new Vec3(5.0f));
        pointer.asFloatBuffer().put(projection.mul(viewMat4()).mul(model).toFa_());

        // Make sure the uniform buffer is uploaded
        gl3.glUnmapBuffer(GL_UNIFORM_BUFFER);
    }

    gl3.glEnable(GL_DEPTH_TEST);
    gl3.glDepthFunc(GL_LESS);

    gl3.glViewport(0, 0, windowSize.x, windowSize.y);

    gl3.glBindFramebuffer(GL_FRAMEBUFFER, framebufferName.get(0));
    float[] depth = {1.0f};
    gl3.glClearBufferfv(GL_DEPTH, 0, depth, 0);

    // Bind rendering objects
    gl3.glUseProgram(programName[Program.TEXTURE]);
    gl3.glUniformBlockBinding(programName[Program.TEXTURE], uniformTransform, Semantic.Uniform.TRANSFORM0);

    gl3.glActiveTexture(GL_TEXTURE0);
    gl3.glBindTexture(GL_TEXTURE_2D, textureName.get(Texture.DIFFUSE));
    gl3.glBindVertexArray(vertexArrayName.get(Program.TEXTURE));
    gl3.glBindBufferBase(GL_UNIFORM_BUFFER, Semantic.Uniform.TRANSFORM0, bufferName.get(Buffer.TRANSFORM));

    gl3.glDrawElementsInstancedBaseVertex(GL_TRIANGLES, elementCount, GL_UNSIGNED_SHORT, 0, 1, 0);

    gl3.glDisable(GL_DEPTH_TEST);

    gl3.glBindFramebuffer(GL_FRAMEBUFFER, 0);
    gl3.glUseProgram(programName[Program.SPLASH]);

    gl3.glActiveTexture(GL_TEXTURE0);
    gl3.glBindVertexArray(vertexArrayName.get(Program.SPLASH));
    gl3.glBindTexture(GL_TEXTURE_2D, textureName.get(Texture.RENDERBUFFER));

    gl3.glDrawArraysInstanced(GL_TRIANGLES, 0, 3, 1);

    return true;
}
 

@Override
protected boolean render(GL gl) {

    GL3 gl3 = (GL3) gl;

    {
        gl3.glBindBuffer(GL_UNIFORM_BUFFER, bufferName.get(Buffer.TRANSFORM));
        ByteBuffer pointer = gl3.glMapBufferRange(
                GL_UNIFORM_BUFFER, 0, Mat4.SIZE,
                GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT);

        //glm::mat4 Projection = glm::perspectiveFov(glm::pi<float>() * 0.25f, 640.f, 480.f, 0.1f, 100.0f);
        Mat4 projection = glm.perspective_((float) Math.PI * 0.25f, 4.0f / 3.0f, 0.1f, 8.0f);
        Mat4 model = new Mat4(1.0f).scale(new Vec3(5.0f));

        pointer.asFloatBuffer().put(projection.mul(viewMat4()).mul(model).toFa_());

        // Make sure the uniform buffer is uploaded
        gl3.glUnmapBuffer(GL_UNIFORM_BUFFER);
    }

    gl3.glEnable(GL_DEPTH_TEST);
    gl3.glDepthFunc(GL_LESS);

    gl3.glViewport(0, 0, windowSize.x, windowSize.y);

    gl3.glBindFramebuffer(GL_FRAMEBUFFER, framebufferName.get(Framebuffer.DEPTH_MULTISAMPLE));
    gl3.glClearBufferfv(GL_DEPTH, 0, clearDepth);

    // Bind rendering objects
    gl3.glUseProgram(programName[Program.TEXTURE]);
    gl3.glUniformBlockBinding(programName[Program.TEXTURE],
            uniformTransform, Semantic.Uniform.TRANSFORM0);

    gl3.glActiveTexture(GL_TEXTURE0);
    gl3.glBindTexture(GL_TEXTURE_2D, textureName.get(Texture.DIFFUSE));
    gl3.glBindVertexArray(vertexArrayName.get(Program.TEXTURE));
    gl3.glBindBufferBase(GL_UNIFORM_BUFFER, Semantic.Uniform.TRANSFORM0, bufferName.get(Buffer.TRANSFORM));

    gl3.glDrawElementsInstancedBaseVertex(GL_TRIANGLES, elementCount, GL_UNSIGNED_SHORT, 0, 2, 0);

    // Pass 2
    gl3.glDisable(GL_DEPTH_TEST);

    gl3.glBindFramebuffer(GL_FRAMEBUFFER, 0);
    gl3.glUseProgram(programName[Program.SPLASH]);

    gl3.glActiveTexture(GL_TEXTURE0);
    gl3.glBindVertexArray(vertexArrayName.get(Program.SPLASH));
    gl3.glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, textureName.get(Texture.MULTISAMPLE));

    gl3.glDrawArraysInstanced(GL_TRIANGLES, 0, 3, 1);

    return true;
}
 

@Override
protected boolean render(GL gl) {

    GL3 gl3 = (GL3) gl;
    {
        gl3.glBindBuffer(GL_UNIFORM_BUFFER, bufferName.get(Buffer.TRANSFORM));
        ByteBuffer pointer = gl3.glMapBufferRange(GL_UNIFORM_BUFFER,
                0, Mat4.SIZE, GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT);

        Mat4 projection = glm.perspective_((float) Math.PI * 0.25f, (float) windowSize.x / windowSize.y, 0.1f, 100.0f);

        pointer.asFloatBuffer().put(projection.mul(viewMat4()).toFa_());

        // Make sure the uniform buffer is uploaded
        gl3.glUnmapBuffer(GL_UNIFORM_BUFFER);
    }

    // Render a textured quad to a sRGB framebuffer object.
    {
        gl3.glEnable(GL_DEPTH_TEST);
        gl3.glDepthFunc(GL_LESS);

        gl3.glViewport(0, 0, windowSize.x * framebufferScale, windowSize.y * framebufferScale);

        gl3.glBindFramebuffer(GL_FRAMEBUFFER, framebufferName.get(0));
        // Explicitly convert linear pixel color to sRGB color space, as FramebufferName is an sRGB FBO
        // Shader execution is done with linear color to get correct linear algebra working.
        gl3.glEnable(GL_FRAMEBUFFER_SRGB);

        gl3.glClearBufferfv(GL_DEPTH, 0, clearDepth);
        gl3.glClearBufferfv(GL_COLOR, 0, clearColor);

        gl3.glUseProgram(programName[Program.TEXTURE]);

        gl3.glActiveTexture(GL_TEXTURE0);
        gl3.glBindTexture(GL_TEXTURE_2D, textureName.get(Texture.DIFFUSE));
        gl3.glBindVertexArray(vertexArrayName.get(Program.TEXTURE));
        gl3.glBindBufferBase(GL_UNIFORM_BUFFER, Semantic.Uniform.TRANSFORM0, bufferName.get(Buffer.TRANSFORM));

        gl3.glDrawElementsInstancedBaseVertex(GL_TRIANGLES, elementCount, GL_UNSIGNED_SHORT, 0, 2, 0);
    }

    // Blit the sRGB framebuffer to the default framebuffer back buffer.
    {
        gl3.glDisable(GL_DEPTH_TEST);

        gl3.glViewport(0, 0, windowSize.x, windowSize.y);

        gl3.glBindFramebuffer(GL_FRAMEBUFFER, 0);
        // Uncomment to avoid the extra linear to sRGB conversion and hence get correct display
        gl3.glDisable(GL_FRAMEBUFFER_SRGB);

        gl3.glUseProgram(programName[Program.SPLASH]);

        gl3.glActiveTexture(GL_TEXTURE0);
        gl3.glBindVertexArray(vertexArrayName.get(Program.SPLASH));
        gl3.glBindTexture(GL_TEXTURE_2D, textureName.get(Texture.COLORBUFFER));

        gl3.glDrawArraysInstanced(GL_TRIANGLES, 0, 3, 1);
    }

    return true;
}
 

@Override
protected boolean render(GL gl) {

    GL3 gl3 = (GL3) gl;

    IntBuffer uniformBufferOffsetAlignment = GLBuffers.newDirectIntBuffer(1);
    {
        gl3.glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, uniformBufferOffsetAlignment);
        uniformBufferOffsetAlignment.put(0, glm.ceilMultiple(Mat4.SIZE, uniformBufferOffsetAlignment.get(0)));

        gl3.glBindBuffer(GL_UNIFORM_BUFFER, bufferName.get(Buffer.TRANSFORM));
        ByteBuffer pointer = gl3.glMapBufferRange(GL_UNIFORM_BUFFER, 0, uniformBufferOffsetAlignment.get(0) * 2,
                GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT);

        Mat4 projection = glm.perspective_((float) Math.PI * 0.25f, (float) windowSize.x / windowSize.y, 0.1f, 100.0f);

        pointer.asFloatBuffer().put(projection.mul_(viewMat4()).scale(new Vec3(1.00f)).toFa_());
        pointer.position(uniformBufferOffsetAlignment.get(0) * 1);
        pointer.asFloatBuffer().put(projection.mul(viewMat4()).scale(new Vec3(1.05f)).toFa_());
        pointer.rewind();

        // Make sure the uniform buffer is uploaded
        gl3.glUnmapBuffer(GL_UNIFORM_BUFFER);
    }

    {
        gl3.glEnable(GL_STENCIL_TEST);
        gl3.glEnable(GL_DEPTH_TEST);
        gl3.glDepthFunc(GL_LEQUAL);
        gl3.glStencilMask(0xFF);

        gl3.glViewport(0, 0, windowSize.x * framebufferScale, windowSize.y * framebufferScale);

        gl3.glBindFramebuffer(GL_FRAMEBUFFER, framebufferName.get(0));
        gl3.glClearBufferfi(GL_DEPTH_STENCIL, 0, 1.0f, 0);
        gl3.glClearBufferfv(GL_COLOR, 0, new float[]{1.0f, 0.5f, 0.0f, 1.0f}, 0);

        gl3.glUseProgram(programName[Program.TEXTURE]);

        gl3.glActiveTexture(GL_TEXTURE0);
        gl3.glBindTexture(GL_TEXTURE_2D, textureName.get(Texture.DIFFUSE));
        gl3.glBindVertexArray(vertexArrayName.get(Program.TEXTURE));

        gl3.glBindBufferRange(GL_UNIFORM_BUFFER, Semantic.Uniform.TRANSFORM0, bufferName.get(Buffer.TRANSFORM),
                uniformBufferOffsetAlignment.get(0) * 0, uniformBufferOffsetAlignment.get(0));

        gl3.glDisable(GL_DEPTH_TEST);
        gl3.glStencilMask(0xFF);
        gl3.glStencilFunc(GL_ALWAYS, 1, 0xFF);
        gl3.glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);

        gl3.glDrawElementsInstancedBaseVertex(GL_TRIANGLES, elementCount, GL_UNSIGNED_SHORT, 0, 1, 0);

        gl3.glBindTexture(GL_TEXTURE_2D, 0); // 
        gl3.glBindBufferRange(GL_UNIFORM_BUFFER, Semantic.Uniform.TRANSFORM0, bufferName.get(Buffer.TRANSFORM),
                uniformBufferOffsetAlignment.get(0) * 1, uniformBufferOffsetAlignment.get(0));

        gl3.glStencilMask(0x00);
        gl3.glStencilFunc(GL_NOTEQUAL, 1, 0xFF);

        gl3.glDrawElementsInstancedBaseVertex(GL_TRIANGLES, elementCount, GL_UNSIGNED_SHORT, 0, 1, 0);
    }

    {
        gl3.glDisable(GL_DEPTH_TEST);

        gl3.glViewport(0, 0, windowSize.x, windowSize.y);

        gl3.glBindFramebuffer(GL_FRAMEBUFFER, 0);

        gl3.glUseProgram(programName[Program.SPLASH]);

        gl3.glActiveTexture(GL_TEXTURE0);
        gl3.glBindVertexArray(vertexArrayName.get(Program.SPLASH));
        gl3.glBindTexture(GL_TEXTURE_2D, textureName.get(Texture.COLORBUFFER));

        gl3.glDrawArraysInstanced(GL_TRIANGLES, 0, 3, 1);
    }

    BufferUtils.destroyDirectBuffer(uniformBufferOffsetAlignment);

    return true;
}
 

/**
 * Draws the new line on the display.
 * <p>
 * @param drawable The OpenGL rendering target.
 * @param pMatrix The model view projection matrix.
 */
@Override
public void display(final GLAutoDrawable drawable, final Matrix44f pMatrix) {

    final Matrix44f mvpMatrix = parent.getDisplayModelViewProjectionMatrix();

    // If no endpoints are set, don't draw anything
    if (model != null && !model.isClear()) {
        final Vector3f startPosition = model.getStartLocation();
        final Vector3f endPosition = model.getEndLocation();

        final GL3 gl = drawable.getGL().getGL3();

        gl.glBindBuffer(GL3.GL_ARRAY_BUFFER, batch.getBufferName(vertexTarget));
        ByteBuffer bbuf = gl.glMapBuffer(GL3.GL_ARRAY_BUFFER, GL3.GL_WRITE_ONLY);
        FloatBuffer fbuf = bbuf.asFloatBuffer();

        // Update the line endpoints in the vertex buffer.
        float[] vertices = new float[]{
            startPosition.getX(), startPosition.getY(), startPosition.getZ(),
            endPosition.getX(), endPosition.getY(), endPosition.getZ()};
        fbuf.put(vertices);

        gl.glUnmapBuffer(GL3.GL_ARRAY_BUFFER);

        // Disable depth so the line is drawn over everything else.
        gl.glDisable(GL3.GL_DEPTH_TEST);
        gl.glDepthMask(false);

        // Draw the line.
        gl.glLineWidth(NEW_LINE_WIDTH);
        gl.glUseProgram(shader);
        gl.glUniformMatrix4fv(shaderMVP, 1, false, mvpMatrix.a, 0);
        batch.draw(gl);

        gl.glLineWidth(1);

        // Reenable depth.
        gl.glEnable(GL3.GL_DEPTH_TEST);
        gl.glDepthMask(true);

        // Rebind default array buffer
        gl.glBindBuffer(GL3.GL_ARRAY_BUFFER, 0);
    }
}