Example usage for org.lwjgl.opengl GL20 glDrawBuffers

Introduction

In this page you can find the example usage for org.lwjgl.opengl GL20 glDrawBuffers.

Prototype

public static void glDrawBuffers(@NativeType("GLenum const *") int[] bufs) 

Source Link

Document

Array version of: #glDrawBuffers DrawBuffers

Usage

From source file:com.badlogic.gdx.backends.jglfw.JglfwGL30.java

License:Apache License

@Override
public void glDrawBuffers(int n, IntBuffer bufs) {
    GL20.glDrawBuffers(bufs);
}

---

From source file:com.flowpowered.caustic.lwjgl.gl20.GL20FrameBuffer.java

License:MIT License

private void updateOutputBuffers() {
    // Set the output to the proper buffers
    if (outputBuffers.isEmpty()) {
        // No color to output
        GL20.glDrawBuffers(GL11.GL_NONE);
    } else {//from w ww.ja  v  a  2  s. c om
        // Keep track of the buffers to output
        final int[] outputBuffersArray = outputBuffers.toArray();
        // Sorting the array ensures that attachments are in order n, n + 1, n + 2...
        // This is important!
        Arrays.sort(outputBuffersArray);
        final IntBuffer buffer = CausticUtil.createIntBuffer(outputBuffers.size());
        buffer.put(outputBuffersArray);
        buffer.flip();
        GL20.glDrawBuffers(buffer);
    }
}

---

From source file:de.ikosa.mars.viewer.glviewer.engine.GLRenderer2Stage.java

License:Open Source License

public void Draw() {
    // forward pass
    GL30.glBindFramebuffer(GL30.GL_FRAMEBUFFER, fbAId);
    GL20.glDrawBuffers(GL30.GL_COLOR_ATTACHMENT0);
    GL11.glClear(GL11.GL_COLOR_BUFFER_BIT | GL11.GL_DEPTH_BUFFER_BIT);

    scene.Pass(GLScene.PassType.Forward, camera);

    // post pass/*from   w ww  . j a  v  a  2  s  .c  o m*/
    GL30.glBindFramebuffer(GL30.GL_FRAMEBUFFER, fbBId);
    GL11.glClear(GL11.GL_COLOR_BUFFER_BIT | GL11.GL_DEPTH_BUFFER_BIT);
    ssqScene.Pass(GLScene.PassType.PostProcess);

    // post B pass
    GL30.glBindFramebuffer(GL30.GL_FRAMEBUFFER, 0);
    GL11.glClear(GL11.GL_COLOR_BUFFER_BIT | GL11.GL_DEPTH_BUFFER_BIT);
    ssqScene.Pass(GLScene.PassType.PostProcess2);

}

---

From source file:de.ikosa.mars.viewer.glviewer.engine.GLRendererForward.java

License:Open Source License

public void Draw() {
    // forward pass
    GL20.glDrawBuffers(GL30.GL_COLOR_ATTACHMENT0);
    GL11.glClear(GL11.GL_COLOR_BUFFER_BIT | GL11.GL_DEPTH_BUFFER_BIT);

    scene.Pass(GLScene.PassType.Forward, camera);
}

---

From source file:io.root.gfx.glutils.GL.java

License:Apache License

public static void glDrawBuffers(int n, IntBuffer bufs) {
    GL20.glDrawBuffers(bufs);
}

---

From source file:kubex.gui.DepthPeelingLiquidRenderer.java

License:Creative Commons License

/**
 * Resources had been initcialized on KubexGame class, but here they are propperly configured.
 *///from w w w .j  av a2  s  . co  m
@Override
public void initResources(int layersTex, int currentNormalTex) {
    for (int i = 0; i < this.layersFbos.length; i++) {
        this.layersFbos[i] = glGenFramebuffers();
        glBindFramebuffer(GL_FRAMEBUFFER, this.layersFbos[i]);
        GL30.glFramebufferTextureLayer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, layersTex, 0, i); //assign one layer of the texture array to each layer fbo

        IntBuffer drawBuffers = null;

        if (i == 0) { //The first layer will render the normal of the water to a texture, too.
            drawBuffers = BufferUtils.createIntBuffer(1);
            GL30.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, currentNormalTex,
                    0);

            drawBuffers.put(GL_COLOR_ATTACHMENT0);
            drawBuffers.flip();
        } else {
            drawBuffers = BufferUtils.createIntBuffer(0);
        }

        GL20.glDrawBuffers(drawBuffers);

    }
}

---

From source file:kubex.KubexGame.java

License:Creative Commons License

/**
 * Inits the game resources (Images, pools, shaders, objects, etc.)
 *//*from   www  . jav a2s .c om*/
private void initResources() throws IOException {
    //Inits static pools
    FloatBufferPool.init(Chunk.CHUNK_DIMENSION * Chunk.CHUNK_DIMENSION * Chunk.CHUNK_DIMENSION * 2 * 6 * 6, 20);
    ByteArrayPool.init(Chunk.CHUNK_DIMENSION,
            (settings.RENDER_DISTANCE * 2 + 1) * World.HEIGHT * (settings.RENDER_DISTANCE * 2 + 1) * 2);
    glEnable(GL11.GL_CULL_FACE);
    GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
    glEnable(GL11.GL_BLEND);
    glClearColor(0.6f, 0.8f, 1.0f, 0f);

    //Inits shaders
    GL20.glUseProgram(0);
    textManager = new GlobalTextManager();
    this.DVSP = new DepthVoxelShaderProgram(true);
    this.VSP = new TerrainVoxelShaderProgram(true);
    this.HSP = new HudShaderProgram(true);
    this.DTSP = this.settings.SHADOWS_ENABLED ? new DeferredTerrainShaderProgram(true)
            : new DeferredTerrainUnshadowShaderProgram(true);
    this.DRSP = this.settings.REFLECTIONS_ENABLED ? new DeferredReflectionsShaderProgram(true)
            : new DeferredNoReflectionsShaderProgram(true);
    this.DUTSP = this.settings.SHADOWS_ENABLED ? new DeferredUnderwaterTerrainShaderProgram(true)
            : new DeferredUnderwaterUnshadowTerrainShaderProgram(true);
    this.DUFSP = new DeferredUnderwaterFinalShaderProgram(true);

    //Inits essential objects
    this.TM = new TimeManager();
    this.cam = new Camera(CAMERA_NEAR, CAMERA_FAR, 80f, (float) (X_RES * 3 / 4) / Y_RES); //FOV more width than height BY DESIGN, so blocks looks more "plane". Looks nicer that way, i think.
    this.camInvProjEnv = new CameraInverseProjEnvelope(this.cam);
    this.shadowsManager = new ShadowsManager(SHADOW_SPLITS, this.cam);
    this.liquidRenderer = new DepthPeelingLiquidRenderer(LIQUID_LAYERS);

    this.sunCam = new Camera(new Matrix4f());
    this.sunCam.moveTo(0, 5, 0);
    this.sunCam.setPitch(0);

    this.sky = new Sky(cam, this.sunCam);
    File mapRoute = new File(this.settings.MAP_ROUTE);
    mapRoute.mkdir(); //Creates the maps folder
    this.fileManager = new FileManager(mapRoute, settings.RENDER_DISTANCE);
    this.fileManager.getSettingsFromFile(settings); //Reads default settings from settings file.
    this.world = new World(this.VSP, this.cam, this.sunCam, this.shadowsManager, this.sky, fileManager,
            this.settings);
    this.finalDrawManager = new FinalDrawManager(this.world, this.sky, this.shadowsManager, this.liquidRenderer,
            this.camInvProjEnv.getInvProjMatrix(), CAMERA_NEAR, CAMERA_FAR);
    this.hud = new Hud(this.HSP, X_RES, Y_RES);

    //Load textures here
    glActiveTexture(TEXTURE_FETCH[TILES_TEXTURE_LOCATION]);

    //GL_NEAREST for that blocky look
    //loads the tiles textures into a array
    tilesTexture = Util.loadTextureAtlasIntoTextureArray(FileLoader.loadTileImages(), GL11.GL_NEAREST,
            GL11.GL_NEAREST_MIPMAP_LINEAR, true, settings.ANISOTROPIC_FILTERING_ENABLED);

    Util.loadPNGTexture(FileLoader.loadWaterNormalImage(), TEXTURE_FETCH[WATER_NORMAL_TEXTURE_LOCATION]); //loads the water normal texture

    glActiveTexture(GL_TEXTURE0);
    nightDomeTexture = TextureLoader.getTexture("JPG",
            ResourceLoader.getResourceAsStream("images/nightdome.jpg")); //loads the nightdome

    //Without this, text printing using Slick-Utils doesn't work. Seems it still uses some old mode OpenGL.
    GL11.glEnable(GL11.GL_TEXTURE_2D);
    GL11.glShadeModel(GL11.GL_SMOOTH);
    GL11.glDisable(GL11.GL_DEPTH_TEST);
    GL11.glDisable(GL11.GL_LIGHTING);
    GL11.glClearDepth(1);
    GL11.glEnable(GL11.GL_BLEND);
    GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
    GL11.glViewport(0, 0, X_RES, Y_RES);
    GL11.glMatrixMode(GL11.GL_MODELVIEW);
    GL11.glMatrixMode(GL11.GL_PROJECTION);
    GL11.glLoadIdentity();
    GL11.glOrtho(0, X_RES, Y_RES, 0, 1, -1);
    GL11.glMatrixMode(GL11.GL_MODELVIEW);

    //First pass deferred rendering
    this.baseFbo = glGenFramebuffers();
    glBindFramebuffer(GL_FRAMEBUFFER, this.baseFbo);

    int colorTexture = glGenTextures();
    int brightnessNormalsTexture = glGenTextures();

    //Creates and inits the base color texture as a RGB texture
    glActiveTexture(TEXTURE_FETCH[BASEFBO_COLOR_TEXTURE_LOCATION]);
    glBindTexture(GL_TEXTURE_2D, colorTexture);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, X_RES, Y_RES, 0, GL_RGB, GL_UNSIGNED_BYTE, (FloatBuffer) null);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    GL30.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, colorTexture, 0);

    //Creates and inits the brightness and normals texture as a RGBA texture
    glActiveTexture(TEXTURE_FETCH[BASEFBO_NORMALS_BRIGHTNESS_TEXTURE_LOCATION]);
    glBindTexture(GL_TEXTURE_2D, brightnessNormalsTexture);
    glTexImage2D(GL_TEXTURE_2D, 0, GL11.GL_RGBA, X_RES, Y_RES, 0, GL11.GL_RGBA, GL_UNSIGNED_BYTE,
            (FloatBuffer) null);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    GL30.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_TEXTURE_2D, brightnessNormalsTexture,
            0);

    //The depth buffer of this FBO will be a texture, too. This will make depth sorting slower but we will be able to access depth values later.
    int baseFboDepth = glGenTextures();

    glActiveTexture(TEXTURE_FETCH[BASEFBO_DEPTH_TEXTURE_LOCATION]);
    glBindTexture(GL_TEXTURE_2D, baseFboDepth);
    glTexImage2D(GL_TEXTURE_2D, 0, GL14.GL_DEPTH_COMPONENT24, X_RES, Y_RES, 0, GL_DEPTH_COMPONENT,
            GL_UNSIGNED_INT, (FloatBuffer) null);
    System.out.println("ERR" + GL11.glGetError());
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL11.GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL11.GL_NEAREST);
    GL30.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, baseFboDepth, 0); //Set the depth texture as the default render depth target

    IntBuffer drawBuffers = BufferUtils.createIntBuffer(2); //Drawing to 2 textures

    drawBuffers.put(GL_COLOR_ATTACHMENT0);
    drawBuffers.put(GL_COLOR_ATTACHMENT1);

    drawBuffers.flip();
    GL20.glDrawBuffers(drawBuffers);

    //Second pass deferred rendering
    this.deferredFbo = glGenFramebuffers();
    glBindFramebuffer(GL_FRAMEBUFFER, this.deferredFbo);

    int deferredColorTex = glGenTextures();

    //Only uses one texture, a RGBA color texture
    glActiveTexture(TEXTURE_FETCH[DEFERREDFBO_COLOR_TEXTURE_LOCATION]);
    glBindTexture(GL_TEXTURE_2D, deferredColorTex);
    glTexImage2D(GL_TEXTURE_2D, 0, GL11.GL_RGBA, X_RES, Y_RES, 0, GL11.GL_RGBA, GL_UNSIGNED_BYTE,
            (FloatBuffer) null);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    GL30.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, deferredColorTex, 0);

    drawBuffers = BufferUtils.createIntBuffer(1);

    drawBuffers.put(GL_COLOR_ATTACHMENT0);

    drawBuffers.flip();
    GL20.glDrawBuffers(drawBuffers);

    //If shadows are enabled, we init each shadow map texture, placed in an array
    if (this.settings.SHADOWS_ENABLED) {

        int shadowTexture = glGenTextures();

        glActiveTexture(TEXTURE_FETCH[SHADOW_TEXTURE_LOCATION]);

        glBindTexture(GL30.GL_TEXTURE_2D_ARRAY, shadowTexture);
        //Creates a texture array to place the shadows in
        GL12.glTexImage3D(GL30.GL_TEXTURE_2D_ARRAY, 0, GL14.GL_DEPTH_COMPONENT16, SHADOW_XRES, SHADOW_YRES,
                this.shadowsManager.getNumberSplits(), 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT,
                (FloatBuffer) null);
        System.out.println("ERR" + GL11.glGetError());
        glTexParameteri(GL30.GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL11.GL_LINEAR); //Needed to do hardware PCF comparisons via shader
        glTexParameteri(GL30.GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL11.GL_LINEAR); //Needed to do hardware PCF comparisons via shader
        glTexParameteri(GL30.GL_TEXTURE_2D_ARRAY, GL14.GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE); //Needed to do hardware PCF comparisons via shader

        this.shadowFbos = new int[this.shadowsManager.getNumberSplits()];
        //Creates one framebuffer per shadow map
        for (int i = 0; i < this.shadowsManager.getNumberSplits(); i++) {
            this.shadowFbos[i] = glGenFramebuffers();
            glBindFramebuffer(GL_FRAMEBUFFER, this.shadowFbos[i]);
            GL30.glFramebufferTextureLayer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, shadowTexture, 0, i); //Each framebuffer will have one texture layer (one index of the texture array created before) assigned as render target

            drawBuffers = BufferUtils.createIntBuffer(0);

            GL20.glDrawBuffers(drawBuffers);

        }
    }

    //Liquid layers depth generation. Equal to the shadows depth textures generation.
    int liquidLayers = glGenTextures();

    glActiveTexture(TEXTURE_FETCH[LIQUIDLAYERS_TEXTURE_LOCATION]);
    glBindTexture(GL30.GL_TEXTURE_2D_ARRAY, liquidLayers);
    GL12.glTexImage3D(GL30.GL_TEXTURE_2D_ARRAY, 0, GL14.GL_DEPTH_COMPONENT24, X_RES, Y_RES,
            this.liquidRenderer.getNumLayers(), 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, (FloatBuffer) null);

    glTexParameteri(GL30.GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL11.GL_NEAREST); //We will compare manually the depth in the shader, we will not perform PCF of any sort in this case
    glTexParameteri(GL30.GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL11.GL_NEAREST);

    int currentLiquidNormalTex = glGenTextures();

    glActiveTexture(KubexGame.TEXTURE_FETCH[KubexGame.CURRENT_LIQUID_NORMAL_TEXTURE_LOCATION]);
    glBindTexture(GL_TEXTURE_2D, currentLiquidNormalTex);
    glTexImage2D(GL_TEXTURE_2D, 0, GL11.GL_RGB, X_RES, Y_RES, 0, GL11.GL_RGB, GL11.GL_UNSIGNED_BYTE,
            (FloatBuffer) null);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

    this.liquidRenderer.initResources(liquidLayers, currentLiquidNormalTex);

    //Reset active texture and fbo to the default
    glActiveTexture(GL13.GL_TEXTURE0);
    glBindFramebuffer(GL_FRAMEBUFFER, 0);
}

---

From source file:me.thehutch.fusion.engine.render.opengl.FrameBuffer.java

License:Open Source License

protected final void updateOutputBuffers() {
    // Check if there are any attachments
    if (outputBuffers.isEmpty()) {
        // Set the draw buffers to none
        GL20.glDrawBuffers(GL_NONE);
    } else {//from www.  j  a v a 2 s  .  c  o m
        final int[] outputs = outputBuffers.toArray();
        // Sort the buffers to they are in order
        Arrays.sort(outputs);
        // Convert the output buffers to an IntBuffer
        final IntBuffer buffer = BufferUtils.createIntBuffer(outputs.length);
        buffer.put(outputs);
        buffer.flip();
        // Set the draw buffers to the output buffers
        GL20.glDrawBuffers(buffer);
    }
    // Check for errors
    RenderUtil.checkGLError();
}

---

From source file:net.smert.frameworkgl.opengl.helpers.FrameBufferObjectHelper.java

License:Apache License

public void drawBuffer(IntBuffer intBuffer) {
    GL20.glDrawBuffers(intBuffer);
}

---

From source file:org.spout.engine.filesystem.resource.ClientRenderTexture.java

License:Open Source License

@Override
public void writeGPU() {
    if (framebuffer != INVALID_BUFFER) {
        throw new IllegalStateException("Framebuffer already created!");
    }/*from  ww w .  j  ava  2s  .  c  om*/

    int buffers = 1;

    //Create the color buffer for this renderTexture
    textureID = GL11.glGenTextures();
    SpoutRenderer.checkGLError();
    GL11.glBindTexture(GL11.GL_TEXTURE_2D, textureID);
    SpoutRenderer.checkGLError();

    GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_NEAREST);
    SpoutRenderer.checkGLError();
    GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_NEAREST);
    SpoutRenderer.checkGLError();
    GL11.glTexImage2D(GL11.GL_TEXTURE_2D, 0, GL11.GL_RGBA8, width, height, 0, GL11.GL_RGBA, GL11.GL_INT,
            (ByteBuffer) null); // Create the texture data
    SpoutRenderer.checkGLError();

    if (useNormalBuffer) {
        //Create the color buffer for this renderTexture
        normalTarget = GL11.glGenTextures();
        SpoutRenderer.checkGLError();
        GL11.glBindTexture(GL11.GL_TEXTURE_2D, normalTarget);
        SpoutRenderer.checkGLError();

        GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_NEAREST);
        SpoutRenderer.checkGLError();
        GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_NEAREST);
        SpoutRenderer.checkGLError();
        GL11.glTexImage2D(GL11.GL_TEXTURE_2D, 0, GL11.GL_RGBA8, width, height, 0, GL11.GL_RGBA,
                GL11.GL_UNSIGNED_BYTE, (ByteBuffer) null); // Create the texture data
        SpoutRenderer.checkGLError();
        buffers++;
    }

    if (useDepthBuffer) {
        //Create the color buffer for this renderTexture
        depthTarget = GL11.glGenTextures();
        SpoutRenderer.checkGLError();
        GL11.glBindTexture(GL11.GL_TEXTURE_2D, depthTarget);
        SpoutRenderer.checkGLError();

        GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_NEAREST);
        SpoutRenderer.checkGLError();
        GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_NEAREST);
        SpoutRenderer.checkGLError();
        GL11.glTexImage2D(GL11.GL_TEXTURE_2D, 0, GL11.GL_DEPTH_COMPONENT, width, height, 0,
                GL11.GL_DEPTH_COMPONENT, GL11.GL_FLOAT, (ByteBuffer) null); // Create the texture data
        SpoutRenderer.checkGLError();
        buffers++;
    }

    if (useEXT) {
        framebuffer = EXTFramebufferObject.glGenFramebuffersEXT();
        SpoutRenderer.checkGLError();

        EXTFramebufferObject.glBindFramebufferEXT(EXTFramebufferObject.GL_FRAMEBUFFER_EXT, framebuffer);
        SpoutRenderer.checkGLError();

        GL11.glBindTexture(GL11.GL_TEXTURE_2D, textureID);
        SpoutRenderer.checkGLError();

        EXTFramebufferObject.glFramebufferTexture2DEXT(EXTFramebufferObject.GL_FRAMEBUFFER_EXT,
                EXTFramebufferObject.GL_COLOR_ATTACHMENT0_EXT, GL11.GL_TEXTURE_2D, textureID, 0);
        SpoutRenderer.checkGLError();

        if (useDepthBuffer) {
            GL11.glBindTexture(GL11.GL_TEXTURE_2D, depthTarget);
            SpoutRenderer.checkGLError();

            EXTFramebufferObject.glFramebufferTexture2DEXT(EXTFramebufferObject.GL_FRAMEBUFFER_EXT,
                    EXTFramebufferObject.GL_DEPTH_ATTACHMENT_EXT, GL11.GL_TEXTURE_2D, depthTarget, 0);
            SpoutRenderer.checkGLError();
        }

        if (useNormalBuffer) {

            GL11.glBindTexture(GL11.GL_TEXTURE_2D, normalTarget);
            SpoutRenderer.checkGLError();

            EXTFramebufferObject.glFramebufferTexture2DEXT(EXTFramebufferObject.GL_FRAMEBUFFER_EXT,
                    EXTFramebufferObject.GL_COLOR_ATTACHMENT1_EXT, GL11.GL_TEXTURE_2D, normalTarget, 0);
            SpoutRenderer.checkGLError();
        }

        if (EXTFramebufferObject.glCheckFramebufferStatusEXT(
                EXTFramebufferObject.GL_FRAMEBUFFER_EXT) != EXTFramebufferObject.GL_FRAMEBUFFER_COMPLETE_EXT) {
            System.out.println("ERROR: Framebuffer not complete");
            throw new ComputerIsPotatoException("Framebuffer not complete");
        }
        SpoutRenderer.checkGLError();
    } else {
        framebuffer = GL30.glGenFramebuffers();
        SpoutRenderer.checkGLError();

        GL30.glBindFramebuffer(GL30.GL_FRAMEBUFFER, framebuffer);
        SpoutRenderer.checkGLError();

        IntBuffer drawBuffers = BufferUtils.createIntBuffer(buffers);
        drawBuffers.put(GL30.GL_COLOR_ATTACHMENT0);
        if (useNormalBuffer) {
            drawBuffers.put(GL30.GL_COLOR_ATTACHMENT1);
        }
        drawBuffers.flip();
        GL20.glDrawBuffers(drawBuffers);
        SpoutRenderer.checkGLError();

        GL11.glBindTexture(GL11.GL_TEXTURE_2D, textureID);
        SpoutRenderer.checkGLError();

        GL30.glFramebufferTexture2D(GL30.GL_FRAMEBUFFER, GL30.GL_COLOR_ATTACHMENT0, GL11.GL_TEXTURE_2D,
                textureID, 0);
        SpoutRenderer.checkGLError();

        if (useDepthBuffer) {
            GL11.glBindTexture(GL11.GL_TEXTURE_2D, depthTarget);
            SpoutRenderer.checkGLError();

            GL30.glFramebufferTexture2D(GL30.GL_FRAMEBUFFER, GL30.GL_DEPTH_ATTACHMENT, GL11.GL_TEXTURE_2D,
                    depthTarget, 0);
            SpoutRenderer.checkGLError();
        }
        if (useNormalBuffer) {
            GL11.glBindTexture(GL11.GL_TEXTURE_2D, normalTarget);
            SpoutRenderer.checkGLError();

            GL30.glFramebufferTexture2D(GL30.GL_FRAMEBUFFER, GL30.GL_COLOR_ATTACHMENT1, GL11.GL_TEXTURE_2D,
                    normalTarget, 0);
            SpoutRenderer.checkGLError();
        }

        int status = GL30.glCheckFramebufferStatus(GL30.GL_FRAMEBUFFER);
        if (status != GL30.GL_FRAMEBUFFER_COMPLETE) {
            System.out.println("ERROR: Framebuffer not complete.  Status: " + status);
            throw new ComputerIsPotatoException("Framebuffer not complete");
        }
        SpoutRenderer.checkGLError();

        GL30.glBindFramebuffer(GL30.GL_FRAMEBUFFER, SCREEN_BUFFER);
        SpoutRenderer.checkGLError();
    }
    GL11.glBindTexture(GL11.GL_TEXTURE_2D, 0);
    SpoutRenderer.checkGLError();
}

---

• «
• 1
• 2
• 3
• »