Example usage for org.lwjgl.opengl GL14 GL_DEPTH_COMPONENT16

List of usage examples for org.lwjgl.opengl GL14 GL_DEPTH_COMPONENT16

  1. HOME
  2. Java
  3. org.lwjgl.opengl
  4. org.lwjgl.opengl.*
  5. GL14
  6. GL_DEPTH_COMPONENT16

Introduction

In this page you can find the example usage for org.lwjgl.opengl GL14 GL_DEPTH_COMPONENT16.

Prototype

int GL_DEPTH_COMPONENT16

To view the source code for org.lwjgl.opengl GL14 GL_DEPTH_COMPONENT16.

Click Source Link

Document

Accepted by the internalFormat parameter of TexImage1D, TexImage2D, CopyTexImage1D and CopyTexImage2D.

Usage

From source file:com.grillecube.engine.renderer.world.WorldRenderer.java

private void createShadowFBO() {

    this._shadow_fbo = GLH.glhGenFBO();
    this._shadow_fbo.bind();
    this._shadow_fbo.createDrawBuffer(GL11.GL_NONE);

    this._shadow_map = GLH.glhGenTexture();
    this._shadow_map.bind(GL11.GL_TEXTURE_2D);

    this._shadow_map.image2D(GL11.GL_TEXTURE_2D, 0, GL14.GL_DEPTH_COMPONENT16, SHADOW_FBO_WIDTH,
            SHADOW_FBO_HEIGHT, 0, GL11.GL_DEPTH_COMPONENT, GL11.GL_FLOAT, (ByteBuffer) null);
    this._shadow_map.parameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_NEAREST);
    this._shadow_map.parameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_NEAREST);
    this._shadow_map.parameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL12.GL_CLAMP_TO_EDGE);
    this._shadow_map.parameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL12.GL_CLAMP_TO_EDGE);
    this._shadow_fbo.createTextureAttachment(this._shadow_map, GL30.GL_DEPTH_ATTACHMENT);

    this._shadow_fbo.unbind();
}

From source file:com.samrj.devil.graphics.TexUtil.java

License:Open Source License

/**
 * @param format an OpenGL texture format.
 * @return the base OpenGL internal texture format corresponding with the
 *         given format.//w  w  w  .  j av  a2  s. c  o m
 */
public static int getBaseFormat(int format) {
    switch (format) {
    //Forward-compatible formats.
    case GL11.GL_DEPTH_COMPONENT:
    case GL14.GL_DEPTH_COMPONENT16:
    case GL14.GL_DEPTH_COMPONENT24:
    case GL14.GL_DEPTH_COMPONENT32:
    case GL30.GL_DEPTH_COMPONENT32F:
        return GL11.GL_DEPTH_COMPONENT;

    case GL11.GL_RED:
    case GL30.GL_R8:
    case GL30.GL_R16:
    case GL30.GL_R16F:
    case GL30.GL_R16I:
    case GL30.GL_R32F:
    case GL30.GL_R32I:
        return GL11.GL_RED;

    case GL30.GL_DEPTH_STENCIL:
    case GL30.GL_DEPTH24_STENCIL8:
    case GL30.GL_DEPTH32F_STENCIL8:
        return GL30.GL_DEPTH_STENCIL;

    case GL30.GL_RG:
    case GL30.GL_RG8:
    case GL30.GL_RG16:
    case GL30.GL_RG16F:
    case GL30.GL_RG16I:
    case GL30.GL_RG32F:
    case GL30.GL_RG32I:
        return GL30.GL_RG;

    case GL11.GL_RGB:
    case GL11.GL_R3_G3_B2:
    case GL11.GL_RGB4:
    case GL11.GL_RGB5:
    case GL11.GL_RGB8:
    case GL11.GL_RGB10:
    case GL11.GL_RGB12:
    case GL11.GL_RGB16:
    case GL30.GL_RGB16F:
    case GL30.GL_RGB16I:
    case GL30.GL_RGB32F:
    case GL30.GL_RGB32I:
        return GL11.GL_RGB;

    case GL11.GL_RGBA:
    case GL11.GL_RGBA2:
    case GL11.GL_RGBA4:
    case GL11.GL_RGBA8:
    case GL11.GL_RGBA12:
    case GL11.GL_RGBA16:
    case GL30.GL_RGBA16F:
    case GL30.GL_RGBA16I:
    case GL30.GL_RGBA32F:
    case GL30.GL_RGBA32I:
        return GL11.GL_RGBA;

    //Deprecated formats.
    case GL11.GL_LUMINANCE:
    case GL11.GL_LUMINANCE8:
    case GL11.GL_LUMINANCE16:
        return GL11.GL_LUMINANCE;

    case GL11.GL_ALPHA:
    case GL11.GL_ALPHA8:
    case GL11.GL_ALPHA16:
        return GL11.GL_ALPHA;

    case GL11.GL_LUMINANCE_ALPHA:
    case GL11.GL_LUMINANCE8_ALPHA8:
    case GL11.GL_LUMINANCE16_ALPHA16:
        return GL11.GL_LUMINANCE_ALPHA;

    default:
        return -1;
    }
}

From source file:com.samrj.devil.graphics.TexUtil.java

License:Open Source License

/**
 * Returns the OpenGL field name for the given format.
 * //from   w w  w.j  av a2  s  .  c o m
 * @param format An OpenGL texture format.
 * @return The OpenGL field name for the given format.
 */
public static String formatToString(int format) {
    switch (format) {
    case GL11.GL_DEPTH_COMPONENT:
        return "GL_DEPTH_COMPONENT";
    case GL14.GL_DEPTH_COMPONENT16:
        return "GL_DEPTH_COMPONENT16";
    case GL14.GL_DEPTH_COMPONENT24:
        return "GL_DEPTH_COMPONENT24";
    case GL14.GL_DEPTH_COMPONENT32:
        return "GL_DEPTH_COMPONENT32";
    case GL30.GL_DEPTH_COMPONENT32F:
        return "GL_DEPTH_COMPONENT32F";

    case GL11.GL_RED:
        return "GL_RED";
    case GL30.GL_R8:
        return "GL_R8";
    case GL30.GL_R16:
        return "GL_R16";
    case GL30.GL_R16F:
        return "GL_R16F";
    case GL30.GL_R16I:
        return "GL_R16I";
    case GL30.GL_R32F:
        return "GL_R32F";
    case GL30.GL_R32I:
        return "GL_R32I";

    case GL30.GL_DEPTH_STENCIL:
        return "GL_DEPTH_STENCIL";
    case GL30.GL_DEPTH24_STENCIL8:
        return "GL_DEPTH24_STENCIL8";
    case GL30.GL_DEPTH32F_STENCIL8:
        return "GL_DEPTH32F_STENCIL8";

    case GL30.GL_RG:
        return "GL_RG";
    case GL30.GL_RG8:
        return "GL_RG8";
    case GL30.GL_RG16:
        return "GL_RG16";
    case GL30.GL_RG16F:
        return "GL_RG16F";
    case GL30.GL_RG16I:
        return "GL_RG16I";
    case GL30.GL_RG32F:
        return "GL_RG32F";
    case GL30.GL_RG32I:
        return "GL_RG32I";

    case GL11.GL_RGB:
        return "GL_RGB";
    case GL11.GL_RGB8:
        return "GL_RGB8";
    case GL11.GL_RGB16:
        return "GL_RGB16";
    case GL30.GL_RGB16F:
        return "GL_RGB16F";
    case GL30.GL_RGB16I:
        return "GL_RGB16I";
    case GL30.GL_RGB32F:
        return "GL_RGB32F";
    case GL30.GL_RGB32I:
        return "GL_RGB32I";

    case GL11.GL_RGBA:
        return "GL_RGBA";
    case GL11.GL_RGBA8:
        return "GL_RGBA8";
    case GL11.GL_RGBA16:
        return "GL_RGBA16";
    case GL30.GL_RGBA16F:
        return "GL_RGBA16F";
    case GL30.GL_RGBA16I:
        return "GL_RGBA16I";
    case GL30.GL_RGBA32F:
        return "GL_RGBA32F";
    case GL30.GL_RGBA32I:
        return "GL_RGBA32I";

    case GL11.GL_LUMINANCE:
        return "GL_LUMINANCE";
    case GL11.GL_LUMINANCE8:
        return "GL_LUMINANCE8";
    case GL11.GL_LUMINANCE16:
        return "GL_LUMINANCE16";

    case GL11.GL_ALPHA:
        return "GL_ALPHA";
    case GL11.GL_ALPHA8:
        return "GL_ALPHA8";
    case GL11.GL_ALPHA16:
        return "GL_ALPHA16";

    case GL11.GL_LUMINANCE_ALPHA:
        return "GL_LUMINANCE_ALPHA";
    case GL11.GL_LUMINANCE8_ALPHA8:
        return "GL_LUMINANCE8_ALPHA8";
    case GL11.GL_LUMINANCE16_ALPHA16:
        return "GL_LUMINANCE16_ALPHA16";

    default:
        return "UNSUPPORTED_FORMAT";
    }
}

From source file:com.samrj.devil.graphics.TexUtil.java

License:Open Source License

/**
 * Returns the OpenGL enumerator for the given primitive type.
 * /*from   www . j a va 2s .  c o m*/
 * @param format an OpenGL texture format.
 * @return the primitive data type associated with the given OpenGL format.
 */
public static int getPrimitiveType(int format) {
    switch (format) {
    default:
    case GL11.GL_LUMINANCE8:
    case GL11.GL_ALPHA8:
    case GL11.GL_LUMINANCE8_ALPHA8:
    case GL30.GL_R8:
    case GL30.GL_RG8:
    case GL11.GL_RGB8:
    case GL11.GL_RGBA8:
        return GL11.GL_UNSIGNED_BYTE;

    case GL11.GL_LUMINANCE16:
    case GL11.GL_ALPHA16:
    case GL11.GL_LUMINANCE16_ALPHA16:
    case GL14.GL_DEPTH_COMPONENT16:
    case GL30.GL_R16:
    case GL30.GL_RG16:
    case GL11.GL_RGB16:
    case GL11.GL_RGBA16:
        return GL11.GL_UNSIGNED_SHORT;

    case GL30.GL_R16I:
    case GL30.GL_RG16I:
    case GL30.GL_RGB16I:
    case GL30.GL_RGBA16I:
        return GL11.GL_SHORT;

    case GL30.GL_DEPTH_COMPONENT32F:
    case GL30.GL_R32F:
    case GL30.GL_RG32F:
    case GL30.GL_RGB32F:
    case GL30.GL_RGBA32F:
        return GL11.GL_FLOAT;

    case GL30.GL_R32I:
    case GL30.GL_RG32I:
    case GL30.GL_RGB32I:
    case GL30.GL_RGBA32I:
        return GL11.GL_INT;

    case GL30.GL_DEPTH24_STENCIL8:
        return GL30.GL_UNSIGNED_INT_24_8;
    }
}

From source file:com.samrj.devil.graphics.TexUtil.java

License:Open Source License

/**
 * @param format an OpenGL texture format.
 * @return Approximately how many bits are stored per texel for the given format.
 *///w w w.  j  av a 2 s  .  co  m
public static long getBits(int format) {
    switch (format) {
    //Forward-compatible formats.
    case GL11.GL_DEPTH_COMPONENT:
        return 24;
    case GL14.GL_DEPTH_COMPONENT16:
        return 16;
    case GL14.GL_DEPTH_COMPONENT24:
        return 24;
    case GL14.GL_DEPTH_COMPONENT32:
    case GL30.GL_DEPTH_COMPONENT32F:
        return 32;
    case GL11.GL_RED:
    case GL30.GL_R8:
        return 8;
    case GL30.GL_R16:
    case GL30.GL_R16F:
    case GL30.GL_R16I:
        return 16;
    case GL30.GL_R32F:
    case GL30.GL_R32I:
        return 32;
    case GL30.GL_DEPTH_STENCIL:
        return 8;
    case GL30.GL_DEPTH24_STENCIL8:
        return 32;
    case GL30.GL_DEPTH32F_STENCIL8:
        return 40;

    case GL30.GL_RG:
    case GL30.GL_RG8:
        return 16;
    case GL30.GL_RG16:
    case GL30.GL_RG16F:
    case GL30.GL_RG16I:
        return 32;
    case GL30.GL_RG32F:
    case GL30.GL_RG32I:
        return 64;

    case GL11.GL_RGB:
        return 24;
    case GL11.GL_R3_G3_B2:
        return 8;
    case GL11.GL_RGB4:
        return 12;
    case GL11.GL_RGB5:
        return 15;
    case GL11.GL_RGB8:
        return 24;
    case GL11.GL_RGB10:
        return 30;
    case GL11.GL_RGB12:
        return 36;
    case GL11.GL_RGB16:
    case GL30.GL_RGB16F:
    case GL30.GL_RGB16I:
        return 48;
    case GL30.GL_RGB32F:
    case GL30.GL_RGB32I:
        return 96;

    case GL11.GL_RGBA:
        return 32;
    case GL11.GL_RGBA2:
        return 8;
    case GL11.GL_RGBA4:
        return 16;
    case GL11.GL_RGBA8:
        return 32;
    case GL11.GL_RGBA12:
        return 48;
    case GL11.GL_RGBA16:
    case GL30.GL_RGBA16F:
    case GL30.GL_RGBA16I:
        return 64;
    case GL30.GL_RGBA32F:
    case GL30.GL_RGBA32I:
        return 128;

    //Deprecated formats.
    case GL11.GL_LUMINANCE:
    case GL11.GL_LUMINANCE8:
        return 8;
    case GL11.GL_LUMINANCE16:
        return 16;

    case GL11.GL_ALPHA:
    case GL11.GL_ALPHA8:
        return 8;
    case GL11.GL_ALPHA16:
        return 16;

    case GL11.GL_LUMINANCE_ALPHA:
    case GL11.GL_LUMINANCE8_ALPHA8:
        return 16;
    case GL11.GL_LUMINANCE16_ALPHA16:
        return 32;

    default:
        return -1;
    }
}

From source file:com.samrj.devil.graphics.TexUtil.java

License:Open Source License

/**
 * Returns the OpenGL depth texture format for the given number of bits, or
 * -1 if none could be found./*from ww w .  jav a2  s. co  m*/
 * 
 * @param bits The desired number of depth bits.
 * @return An OpenGL depth format.
 */
public static int getDepthFormat(int bits) {
    switch (bits) {
    case 16:
        return GL14.GL_DEPTH_COMPONENT16;
    case 24:
        return GL14.GL_DEPTH_COMPONENT24;
    case 32:
        return GL14.GL_DEPTH_COMPONENT32;
    default:
        return -1;
    }
}

From source file:com.xrbpowered.gl.res.buffers.OffscreenBuffers.java

License:Open Source License

protected void create(int w, int h, boolean depthBuffer, boolean hdr) {
    colorTexId = GL11.glGenTextures();//  w  ww  .j a  v a2s .c  o  m
    GL11.glBindTexture(GL11.GL_TEXTURE_2D, colorTexId);
    GL11.glTexImage2D(GL11.GL_TEXTURE_2D, 0, hdr ? GL30.GL_RGB16F : GL11.GL_RGB, w, h, 0, GL11.GL_RGB,
            GL11.GL_UNSIGNED_BYTE, (ByteBuffer) null);
    GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL12.GL_CLAMP_TO_EDGE);
    GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL12.GL_CLAMP_TO_EDGE);
    GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_LINEAR);
    GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_LINEAR);
    GL11.glBindTexture(GL11.GL_TEXTURE_2D, 0);
    GL30.glFramebufferTexture2D(GL30.GL_FRAMEBUFFER, GL30.GL_COLOR_ATTACHMENT0, GL11.GL_TEXTURE_2D, colorTexId,
            0);

    depthTexId = 0;
    if (depthBuffer) {
        depthTexId = GL11.glGenTextures();
        GL11.glBindTexture(GL11.GL_TEXTURE_2D, depthTexId);
        GL11.glTexImage2D(GL11.GL_TEXTURE_2D, 0, GL14.GL_DEPTH_COMPONENT16, w, h, 0, GL11.GL_DEPTH_COMPONENT,
                GL11.GL_FLOAT, (ByteBuffer) null);
        GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL12.GL_CLAMP_TO_EDGE);
        GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL12.GL_CLAMP_TO_EDGE);
        GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_NEAREST);
        GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_NEAREST);
        GL11.glBindTexture(GL11.GL_TEXTURE_2D, 0);
        GL30.glFramebufferTexture2D(GL30.GL_FRAMEBUFFER, GL30.GL_DEPTH_ATTACHMENT, GL11.GL_TEXTURE_2D,
                depthTexId, 0);
    }
    checkStatus();
    GL30.glBindFramebuffer(GL30.GL_FRAMEBUFFER, 0);
}

From source file:kubex.KubexGame.java

License:Creative Commons License

/**
 * Inits the game resources (Images, pools, shaders, objects, etc.)
 *///from   ww  w. j a va 2 s .co m
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:net.neilcsmith.praxis.video.opengl.internal.FrameBuffer.java

License:Apache License

private void build() {
    LOGGER.fine("Building FBO");
    //        ByteBuffer tmp = ByteBuffer.allocateDirect(4);
    //        tmp.order(ByteOrder.nativeOrder());
    //        IntBuffer handle = tmp.asIntBuffer();
    IntBuffer handle = BufferUtils.createIntBuffer(1);

    glGenFramebuffersEXT(handle);/*  w w  w  .j  av  a 2  s  .  c o  m*/
    framebufferHandle = handle.get(0);

    if (hasDepth) {
        //            gl.glGenRenderbuffers(1, handle);
        glGenRenderbuffersEXT(handle);
        depthbufferHandle = handle.get(0);
    }

    //        GL11.glBindTexture(GL11.GL_TEXTURE_2D, colorTexture.getTextureObjectHandle());
    colorTexture.bind();

    if (hasDepth) {
        glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depthbufferHandle);
        glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL14.GL_DEPTH_COMPONENT16, colorTexture.getWidth(),
                colorTexture.getHeight());
    }

    //        gl.glBindFramebuffer(GL20.GL_FRAMEBUFFER, framebufferHandle);
    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, framebufferHandle);
    glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL11.GL_TEXTURE_2D,
            colorTexture.getTextureObjectHandle(), 0);
    if (hasDepth) {
        glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT,
                depthbufferHandle);
    }
    int result = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);

    glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);
    GL11.glBindTexture(GL11.GL_TEXTURE_2D, 0);
    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);

    if (result != GL_FRAMEBUFFER_COMPLETE_EXT) {
        LOGGER.log(Level.WARNING, "Unable to build FBO");
        colorTexture.dispose();
        if (hasDepth) {
            handle.put(depthbufferHandle);
            handle.flip();
            glDeleteRenderbuffersEXT(handle);
        }

        colorTexture.dispose();
        handle.put(framebufferHandle);
        handle.flip();
        glDeleteFramebuffersEXT(handle);

        if (result == GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT) {
            throw new IllegalStateException("frame buffer couldn't be constructed: incomplete attachment");
        }
        if (result == GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT) {
            throw new IllegalStateException("frame buffer couldn't be constructed: incomplete dimensions");
        }
        if (result == GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT) {
            throw new IllegalStateException("frame buffer couldn't be constructed: missing attachment");
        }
    }
}

From source file:org.terasology.logic.manager.PostProcessingRenderer.java

License:Apache License

public FBO createFBO(String title, int width, int height, boolean hdr, boolean depth, boolean normals) {
    // Make sure to delete the existing FBO before creating a new one
    deleteFBO(title);/*from  w  w w.ja  v a2 s.c o  m*/

    // Create a new FBO object
    FBO fbo = new FBO();
    fbo._width = width;
    fbo._height = height;

    // Create the color target texture
    fbo._textureId = GL11.glGenTextures();
    GL11.glBindTexture(GL11.GL_TEXTURE_2D, fbo._textureId);

    GL11.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_LINEAR);
    GL11.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_LINEAR);
    GL11.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL12.GL_CLAMP_TO_EDGE);
    GL11.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL12.GL_CLAMP_TO_EDGE);

    if (hdr) {
        GL11.glTexImage2D(GL11.GL_TEXTURE_2D, 0, ARBTextureFloat.GL_RGBA16F_ARB, width, height, 0, GL11.GL_RGBA,
                ARBHalfFloatPixel.GL_HALF_FLOAT_ARB, (java.nio.ByteBuffer) null);
    } else {
        GL11.glTexImage2D(GL11.GL_TEXTURE_2D, 0, GL11.GL_RGBA, width, height, 0, GL11.GL_RGBA,
                GL11.GL_UNSIGNED_BYTE, (java.nio.ByteBuffer) null);
    }

    if (depth) {
        // Generate the depth texture
        fbo._depthTextureId = GL11.glGenTextures();
        GL11.glBindTexture(GL11.GL_TEXTURE_2D, fbo._depthTextureId);

        GL11.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_LINEAR);
        GL11.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_LINEAR);
        GL11.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL12.GL_CLAMP_TO_EDGE);
        GL11.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL12.GL_CLAMP_TO_EDGE);

        GL11.glTexImage2D(GL11.GL_TEXTURE_2D, 0, GL14.GL_DEPTH_COMPONENT24, width, height, 0,
                GL11.GL_DEPTH_COMPONENT, ARBHalfFloatPixel.GL_HALF_FLOAT_ARB, (java.nio.ByteBuffer) null);

        // Create depth render buffer object
        fbo._depthRboId = EXTFramebufferObject.glGenRenderbuffersEXT();
        EXTFramebufferObject.glBindRenderbufferEXT(EXTFramebufferObject.GL_RENDERBUFFER_EXT, fbo._depthRboId);
        EXTFramebufferObject.glRenderbufferStorageEXT(EXTFramebufferObject.GL_RENDERBUFFER_EXT,
                GL14.GL_DEPTH_COMPONENT16, width, height);
        EXTFramebufferObject.glBindRenderbufferEXT(EXTFramebufferObject.GL_RENDERBUFFER_EXT, 0);
    }

    if (normals) {
        // Generate the normals texture
        fbo._normalsTextureId = GL11.glGenTextures();
        GL11.glBindTexture(GL11.GL_TEXTURE_2D, fbo._normalsTextureId);

        GL11.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_LINEAR);
        GL11.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_LINEAR);
        GL11.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL12.GL_CLAMP_TO_EDGE);
        GL11.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL12.GL_CLAMP_TO_EDGE);

        GL11.glTexImage2D(GL11.GL_TEXTURE_2D, 0, GL11.GL_RGBA, width, height, 0, GL11.GL_RGBA,
                GL11.GL_UNSIGNED_BYTE, (java.nio.ByteBuffer) null);
    }

    GL11.glBindTexture(GL11.GL_TEXTURE_2D, 0);

    // Create the FBO
    fbo._fboId = EXTFramebufferObject.glGenFramebuffersEXT();
    EXTFramebufferObject.glBindFramebufferEXT(EXTFramebufferObject.GL_FRAMEBUFFER_EXT, fbo._fboId);

    EXTFramebufferObject.glFramebufferTexture2DEXT(EXTFramebufferObject.GL_FRAMEBUFFER_EXT,
            EXTFramebufferObject.GL_COLOR_ATTACHMENT0_EXT, GL11.GL_TEXTURE_2D, fbo._textureId, 0);

    if (depth) {
        // Generate the depth render buffer and depth map texture
        EXTFramebufferObject.glFramebufferRenderbufferEXT(EXTFramebufferObject.GL_FRAMEBUFFER_EXT,
                EXTFramebufferObject.GL_DEPTH_ATTACHMENT_EXT, EXTFramebufferObject.GL_RENDERBUFFER_EXT,
                fbo._depthRboId);
        EXTFramebufferObject.glFramebufferTexture2DEXT(EXTFramebufferObject.GL_FRAMEBUFFER_EXT,
                EXTFramebufferObject.GL_DEPTH_ATTACHMENT_EXT, GL11.GL_TEXTURE_2D, fbo._depthTextureId, 0);
    }

    if (normals) {
        EXTFramebufferObject.glFramebufferTexture2DEXT(EXTFramebufferObject.GL_FRAMEBUFFER_EXT,
                EXTFramebufferObject.GL_COLOR_ATTACHMENT1_EXT, GL11.GL_TEXTURE_2D, fbo._normalsTextureId, 0);
    }

    IntBuffer bufferIds = BufferUtils.createIntBuffer(3);
    bufferIds.put(EXTFramebufferObject.GL_COLOR_ATTACHMENT0_EXT);
    if (normals) {
        bufferIds.put(EXTFramebufferObject.GL_COLOR_ATTACHMENT1_EXT);
    }
    bufferIds.flip();
    GL20.glDrawBuffers(bufferIds);

    int framebuffer = EXTFramebufferObject.glCheckFramebufferStatusEXT(EXTFramebufferObject.GL_FRAMEBUFFER_EXT);
    switch (framebuffer) {
    case EXTFramebufferObject.GL_FRAMEBUFFER_COMPLETE_EXT:
        break;
    case EXTFramebufferObject.GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT:
        logger.error(
                "FrameBuffer: " + title + ", has caused a GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT exception");
    case EXTFramebufferObject.GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT:
        logger.error("FrameBuffer: " + title
                + ", has caused a GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT exception");
    case EXTFramebufferObject.GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT:
        logger.error(
                "FrameBuffer: " + title + ", has caused a GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT exception");
    case EXTFramebufferObject.GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT:
        logger.error(
                "FrameBuffer: " + title + ", has caused a GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT exception");
    case EXTFramebufferObject.GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT:
        logger.error(
                "FrameBuffer: " + title + ", has caused a GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT exception");
    case EXTFramebufferObject.GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT:
        logger.error(
                "FrameBuffer: " + title + ", has caused a GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT exception");
    default:
        throw new RuntimeException("Unexpected reply from glCheckFramebufferStatusEXT: " + framebuffer);
    }

    EXTFramebufferObject.glBindFramebufferEXT(EXTFramebufferObject.GL_FRAMEBUFFER_EXT, 0);

    _FBOs.put(title, fbo);
    return fbo;
}