void RE_InitFBOs()
{
GLenum DrawBuffers[1];
GLenum status;
GLenum buffers[] = { GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT };
glConfig.oculusFBL = 0;
glConfig.oculusFBR = 0;
glGenFramebuffersEXT(1, &glConfig.oculusFBL);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, glConfig.oculusFBL);
// The depth buffer
glGenRenderbuffers(1, &glConfig.oculusDepthRenderBufferLeft);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, glConfig.oculusDepthRenderBufferLeft);
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, glConfig.vidWidth, glConfig.vidHeight);
glGenTextures(1, &glConfig.oculusRenderTargetLeft);
glBindTexture(GL_TEXTURE_2D, glConfig.oculusRenderTargetLeft);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, glConfig.vidWidth, glConfig.vidHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, 0); // Empty Image
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glGenerateMipmapEXT(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, 0);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, glConfig.oculusRenderTargetLeft, 0);
glGenTextures(1, &glConfig.oculusRenderTargetRight);
glBindTexture(GL_TEXTURE_2D, glConfig.oculusRenderTargetRight);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, glConfig.vidWidth, glConfig.vidHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, 0); // Empty Image
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glGenerateMipmapEXT(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, 0);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT1_EXT, GL_TEXTURE_2D, glConfig.oculusRenderTargetRight, 0);
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, glConfig.oculusDepthRenderBufferLeft);
//glDrawBuffers(2, (GLenum*)buffers);
status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
if(status != GL_FRAMEBUFFER_COMPLETE_EXT)
exit(1);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); // Unbind the FBO for now
}
t_value ml_glgeneratemipmapext (value target)
{
CAMLparam1 (target);
GLenum _target = conv_texture_binding_table[Int_val(target)];
glGenerateMipmapEXT(_target);
CAMLreturn (Val_unit);
}
Texture2D Texture2D::createLinkedWith(FrameBuffer &buffer)
{
Texture2D ret;
ret.m_id = ResourceHeap::instance().create(textureConstructor,
textureDestructor,
ResourceHeap::Texture2D);
ret.bind();
// Set filtering parameters
useParameter(GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
useParameter(GL_TEXTURE_MAG_FILTER, GL_LINEAR);
if (GLEW_EXT_texture_filter_anisotropic)
{
int maxAnisotropy = 0;
glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &maxAnisotropy);
useParameter(GL_TEXTURE_MAX_ANISOTROPY_EXT, maxAnisotropy);
}
// Link texture with framebuffer
glTexImage2D(GL_TEXTURE_2D, /*level*/0,
GL_RGBA, buffer.width(), buffer.height(), /*border*/ 0,
GL_RGBA, GL_UNSIGNED_BYTE, /*pixels from FB*/ nullptr);
glGenerateMipmapEXT(GL_TEXTURE_2D);
// Link framebuffer with texture
glFramebufferTexture2DEXT(
buffer.type(),
GL_COLOR_ATTACHMENT0_EXT, // attachment point
GL_TEXTURE_2D,
ret.m_id,
0 // initial mip-level
);
return ret;
}
void GLTexture::loadImpl()
{
if( mUsage & TU_RENDERTARGET )
{
createRenderTexture();
return;
}
// Now the only copy is on the stack and will be cleaned in case of
// exceptions being thrown from _loadImages
LoadedImages loadedImages = mLoadedImages;
mLoadedImages.setNull();
// Call internal _loadImages, not loadImage since that's external and
// will determine load status etc again
ConstImagePtrList imagePtrs;
for (size_t i=0 ; i<loadedImages->size() ; ++i) {
imagePtrs.push_back(&(*loadedImages)[i]);
}
_loadImages(imagePtrs);
// Generate mipmaps after all texture levels have been loaded
// This is required for compressed formats such as DXT
// If we can do automip generation and the user desires this, do so
if((mUsage & TU_AUTOMIPMAP) &&
mNumRequestedMipmaps && mMipmapsHardwareGenerated)
{
glGenerateMipmapEXT(getGLTextureTarget());
}
}
bool Texture::LoadXOR() {
width_ = height_ = 256;
unsigned char *buf = new unsigned char[width_*height_*4];
for (int y = 0; y < 256; y++) {
for (int x = 0; x < 256; x++) {
buf[(y*width_ + x)*4 + 0] = x^y;
buf[(y*width_ + x)*4 + 1] = x^y;
buf[(y*width_ + x)*4 + 2] = x^y;
buf[(y*width_ + x)*4 + 3] = 0xFF;
}
}
GL_CHECK();
glGenTextures(1, &id_);
glBindTexture(GL_TEXTURE_2D, id_);
SetTextureParameters(ZIM_GEN_MIPS);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width_, height_, 0,
GL_RGBA, GL_UNSIGNED_BYTE, buf);
if(gl_extensions.FBO_ARB){
glGenerateMipmap(GL_TEXTURE_2D);
}else{
#ifndef USING_GLES2
glGenerateMipmapEXT(GL_TEXTURE_2D);
#endif
}
GL_CHECK();
delete [] buf;
return true;
}
void GFXGLTextureObject::reloadFromCache()
{
if(!mZombieCache)
return;
if(mBinding == GL_TEXTURE_3D)
{
static_cast<GFXGLTextureManager*>(TEXMGR)->_loadTexture(this, mZombieCache);
delete[] mZombieCache;
mZombieCache = NULL;
return;
}
PRESERVE_TEXTURE(mBinding);
glBindTexture(mBinding, mHandle);
if(mBinding == GL_TEXTURE_2D)
glTexSubImage2D(mBinding, 0, 0, 0, mTextureSize.x, mTextureSize.y, GFXGLTextureFormat[mFormat], GFXGLTextureType[mFormat], mZombieCache);
else if(mBinding == GL_TEXTURE_1D)
glTexSubImage1D(mBinding, 0, 0, (mTextureSize.x > 1 ? mTextureSize.x : mTextureSize.y), GFXGLTextureFormat[mFormat], GFXGLTextureType[mFormat], mZombieCache);
if(GFX->getCardProfiler()->queryProfile("GL::Workaround::needsExplicitGenerateMipmap") && mMipLevels != 1)
glGenerateMipmapEXT(mBinding);
delete[] mZombieCache;
mZombieCache = NULL;
mIsZombie = false;
}
bool Texture::LoadJPEG(const char *filename, bool genMips) {
ILOG("Loading jpeg %s", filename);
unsigned char *image_data;
int actual_comps;
image_data = jpgd::decompress_jpeg_image_from_file(filename, &width_, &height_, &actual_comps, 4);
if (!image_data) {
ELOG("jpeg: image data returned was 0");
return false;
}
ILOG("Jpeg decoder failed to get RGB, got: %i x %i x %i", actual_comps, width_, height_);
ILOG("First four bytes: %i %i %i %i", image_data[0], image_data[1], image_data[2], image_data[3]);
GL_CHECK();
glGenTextures(1, &id_);
glBindTexture(GL_TEXTURE_2D, id_);
SetTextureParameters(genMips ? ZIM_GEN_MIPS : ZIM_CLAMP);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width_, height_, 0, GL_RGBA, GL_UNSIGNED_BYTE, image_data);
if (genMips) {
if (gl_extensions.FBO_ARB) {
glGenerateMipmap(GL_TEXTURE_2D);
} else {
#ifndef USING_GLES2
glGenerateMipmapEXT(GL_TEXTURE_2D);
#endif
}
}
GL_CHECK();
free(image_data);
return true;
}
void ToneMapping::process() {
if (getInvalidationLevel() >= Processor::INVALID_PROGRAM)
compile();
outport_.activateTarget();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
TextureUnit colorUnit, depthUnit;
inport_.bindColorTexture(colorUnit.getEnum());
if (toneMappingMethod_.get() == "rahman-retinex") {
glHint(GL_GENERATE_MIPMAP_HINT, GL_NICEST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glGenerateMipmapEXT(GL_TEXTURE_2D);
}
inport_.bindDepthTexture(depthUnit.getEnum());
// initialize shader
program_->activate();
setGlobalShaderParameters(program_);
// set uniforms
program_->setUniform("colorTex_", colorUnit.getUnitNumber());
program_->setUniform("depthTex_", depthUnit.getUnitNumber());
inport_.setTextureParameters(program_, "textureParameters_");
// set method specific uniforms
if (toneMappingMethod_.get() == "s-curve") {
program_->setUniform("sigma_", scurveSigma_.get());
program_->setUniform("power_", scurvePower_.get());
}
if (toneMappingMethod_.get() == "rahman-retinex") {
if(rahmanTotalUpdate_ || inport_.hasChanged()){
wTotal_ = 0.0f;
float i = 0.0f;
while(i<rahmanIterations_.get()){
wTotal_ += pow(rahmanIterations_.get() - i + 1, rahmanFrequency_.get());
i++;
}
rahmanTotalUpdate_ = false;
}
//colorUnit.activate();
//glGenerateMipmapEXT(GL_TEXTURE_2D);
program_->setUniform("frequency_", rahmanFrequency_.get());
program_->setUniform("subtractionFactor_", rahmanSubtractionFactor_.get());
program_->setUniform("iterations_", rahmanIterations_.get());
program_->setUniform("maxLevel_", rahmanMaxLevel_.get());
program_->setUniform("wTotal_", wTotal_);
}
renderQuad();
program_->deactivate();
outport_.deactivateTarget();
TextureUnit::setZeroUnit();
LGL_ERROR;
}
void addTexture(TextureData *textureData, TextureRef *textureRef) {
SDL_Surface *surface = (SDL_Surface *) textureData->data;
int byteSize = surface->format->BytesPerPixel;
// add a new texture. (update for RGBA)
GLuint textureBuffer;
glGenTextures(1, &textureBuffer);
glBindTexture(GL_TEXTURE_2D, textureBuffer);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
if (byteSize == 3) {
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, surface->w, surface->h, 0,
GL_BGR, GL_UNSIGNED_BYTE, surface->pixels);
}
else {
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, surface->w, surface->h, 0,
GL_BGRA, GL_UNSIGNED_BYTE, surface->pixels);
}
glGenerateMipmapEXT(GL_TEXTURE_2D);
// Update the texture reference
textureRef->textureBuffer = textureBuffer;
textureRef->loaded = true;
textureRef->loading = false;
delete surface;
delete textureData;
}
void Image::checkMipmapsCreated() const
{
if (filter.mipmap != FILTER_NEAREST && filter.mipmap != FILTER_LINEAR)
return;
if (!hasMipmapSupport())
throw love::Exception("Mipmap filtering is not supported on this system!");
// some old GPUs/systems claim support for NPOT textures, but fail when generating mipmaps
// we can't detect which systems will do this, so we fail gracefully for all NPOT images
int w = int(width), h = int(height);
if (w != next_p2(w) || h != next_p2(h))
throw love::Exception("Could not generate mipmaps: image does not have power of two dimensions!");
bind();
GLint mipmapscreated;
glGetTexParameteriv(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, &mipmapscreated);
// generate mipmaps for this image if we haven't already
if (!mipmapscreated)
{
glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE);
if (GLEE_VERSION_3_0 || GLEE_ARB_framebuffer_object)
glGenerateMipmap(GL_TEXTURE_2D);
else if (GLEE_EXT_framebuffer_object)
glGenerateMipmapEXT(GL_TEXTURE_2D);
else
// modify single texel to trigger mipmap chain generation
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, data->getData());
}
}
void Texture::createTextureObject(int context_id)
{
GLuint& id = _ids[context_id];
glEnable(GL_TEXTURE_2D);
glGenTextures(1, &id);
glBindTexture(GL_TEXTURE_2D, id);
applyParams();
// Get the maximum texture size for this GPU.
GLint max_size = 0;
glGetIntegerv (GL_MAX_TEXTURE_SIZE, &max_size);
if (_width > max_size || _height > max_size)
{
gluBuild2DMipmaps(GL_TEXTURE_2D,
_params.internalFormat,
_width, _height,
GL_BGRA,
GL_UNSIGNED_BYTE,
FreeImage_GetBits (_data));
checkGLErrors("Texture::createTextureObject1 - gluBuild2DMipmaps");
}
else
{
glTexImage2D (GL_TEXTURE_2D, 0, _params.internalFormat, _width, _height, 0, GL_BGRA, GL_UNSIGNED_BYTE, FreeImage_GetBits (_data));
glGenerateMipmapEXT (GL_TEXTURE_2D);
checkGLErrors("Texture::createTextureObject1 - glTexImage2D");
}
unbind();
}
static int
create_fbo(void)
{
GLuint tex, fb;
GLenum status;
int i, dim;
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_2D, tex);
for (i = 0, dim = TEX_WIDTH; dim >0; i++, dim /= 2) {
glTexImage2D(GL_TEXTURE_2D, i, GL_RGBA,
dim, dim,
0,
GL_RGBA, GL_UNSIGNED_BYTE, NULL);
}
if (!piglit_check_gl_error(GL_NO_ERROR))
piglit_report_result(PIGLIT_FAIL);
glGenFramebuffersEXT(1, &fb);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,
GL_COLOR_ATTACHMENT0_EXT,
GL_TEXTURE_2D,
tex,
0);
if (!piglit_check_gl_error(GL_NO_ERROR))
piglit_report_result(PIGLIT_FAIL);
status = glCheckFramebufferStatusEXT (GL_FRAMEBUFFER_EXT);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
fprintf(stderr, "FBO incomplete\n");
goto done;
}
glViewport(0, 0, TEX_WIDTH, TEX_HEIGHT);
piglit_ortho_projection(TEX_WIDTH, TEX_HEIGHT, GL_FALSE);
glColor4fv(red);
piglit_draw_rect(0, 0, TEX_WIDTH / 2, TEX_HEIGHT / 2);
glColor4fv(green);
piglit_draw_rect(TEX_WIDTH / 2, 0, TEX_WIDTH, TEX_HEIGHT / 2);
glColor4fv(blue);
piglit_draw_rect(0, TEX_HEIGHT / 2, TEX_WIDTH/2, TEX_HEIGHT);
glColor4fv(white);
piglit_draw_rect(TEX_WIDTH / 2, TEX_HEIGHT / 2, TEX_WIDTH, TEX_HEIGHT);
glScissor(10, 10, 10, 10);
glEnable(GL_SCISSOR_TEST);
glGenerateMipmapEXT(GL_TEXTURE_2D);
glDisable(GL_SCISSOR_TEST);
done:
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, piglit_winsys_fbo);
glDeleteFramebuffersEXT(1, &fb);
return tex;
}
static GLuint
create_array_fbo_2d(void)
{
GLuint tex, fb;
GLenum status;
int i, dim;
int layer;
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_2D_ARRAY_EXT, tex);
if (!piglit_check_gl_error(GL_NO_ERROR))
piglit_report_result(PIGLIT_FAIL);
for (i = 0, dim = TEX_WIDTH; dim >0; i++, dim /= 2) {
glTexImage3D(GL_TEXTURE_2D_ARRAY_EXT, i, format,
dim, dim, num_layers, 0,
GL_RGBA, GL_UNSIGNED_BYTE, NULL);
}
if (!piglit_check_gl_error(GL_NO_ERROR))
piglit_report_result(PIGLIT_FAIL);
glGenFramebuffersEXT(1, &fb);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb);
for (layer = 0; layer < num_layers; layer++) {
glFramebufferTextureLayer(GL_FRAMEBUFFER_EXT,
GL_COLOR_ATTACHMENT0_EXT,
tex,
0,
layer);
if (!piglit_check_gl_error(GL_NO_ERROR))
piglit_report_result(PIGLIT_FAIL);
status = glCheckFramebufferStatusEXT (GL_FRAMEBUFFER_EXT);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
load_texture_2d_array();
goto done;
}
glViewport(0, 0, TEX_WIDTH, TEX_HEIGHT);
piglit_ortho_projection(TEX_WIDTH, TEX_HEIGHT, GL_FALSE);
glColor4fv(layer_color[layer]);
piglit_draw_rect(0, 0, TEX_WIDTH / 2, TEX_HEIGHT / 2);
glColor4fv(green);
piglit_draw_rect(TEX_WIDTH / 2, 0, TEX_WIDTH, TEX_HEIGHT / 2);
glColor4fv(blue);
piglit_draw_rect(0, TEX_HEIGHT / 2, TEX_WIDTH/2, TEX_HEIGHT);
glColor4fv(white);
piglit_draw_rect(TEX_WIDTH / 2, TEX_HEIGHT / 2, TEX_WIDTH, TEX_HEIGHT);
}
done:
glGenerateMipmapEXT(GL_TEXTURE_2D_ARRAY_EXT);
glDeleteFramebuffersEXT(1, &fb);
return tex;
}
void FrameBuffer::automaticallyGenerateMipmaps(int attachment)
{
assert(m_automaticMipmapsEnabled);
GLenum type = textureType(attachment);
glBindTexture(type, textureID(attachment));
glGenerateMipmapEXT(type);
glBindTexture(type, 0);
}
void GLTexture::refresh() {
Bitmap *bitmap = getBitmap();
/* Bind to the texture */
glBindTexture(m_glType, m_id);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
if (m_type == ETexture1D) {
Assert((math::isPowerOfTwo(m_size.x) && m_size.y == 1)
|| (math::isPowerOfTwo(m_size.y) && m_size.x == 1));
if (isMipMapped()) {
/* Let GLU generate mipmaps for us */
gluBuild1DMipmaps(m_glType, m_internalFormat, m_size.x == 1 ? m_size.y : m_size.x,
m_format, m_dataFormat, bitmap->getData());
} else {
}
glTexImage1D(m_glType, 0, m_internalFormat, m_size.x == 1 ? m_size.y : m_size.x,
0, m_format, m_dataFormat, bitmap->getData());
} else if (m_type == ETexture2D) {
/* Anisotropic texture filtering */
float anisotropy = (float) getMaxAnisotropy();
if (isMipMapped() && m_filterType == EMipMapLinear && anisotropy > 1.0f)
glTexParameterf(m_glType, GL_TEXTURE_MAX_ANISOTROPY_EXT, anisotropy);
glTexImage2D(m_glType, 0, m_internalFormat, m_size.x, m_size.y,
0, m_format, m_dataFormat, bitmap->getData());
} else if (m_type == ETextureCubeMap) {
Assert(bitmap != NULL);
Assert(bitmap->getWidth() == bitmap->getHeight());
Assert(math::isPowerOfTwo(bitmap->getWidth()));
if (isMipMapped())
glTexParameteri(m_glType, GL_GENERATE_MIPMAP, GL_TRUE);
for (int i=0; i<6; i++) {
Bitmap *bitmap = getBitmap(i);
GLuint pos;
switch (i) {
case ECubeMapPositiveX: pos = GL_TEXTURE_CUBE_MAP_POSITIVE_X; break;
case ECubeMapNegativeX: pos = GL_TEXTURE_CUBE_MAP_NEGATIVE_X; break;
case ECubeMapPositiveY: pos = GL_TEXTURE_CUBE_MAP_POSITIVE_Y; break;
case ECubeMapNegativeY: pos = GL_TEXTURE_CUBE_MAP_NEGATIVE_Y; break;
case ECubeMapPositiveZ: pos = GL_TEXTURE_CUBE_MAP_POSITIVE_Z; break;
case ECubeMapNegativeZ: pos = GL_TEXTURE_CUBE_MAP_NEGATIVE_Z; break;
default: Log(EError, "Unknown cube map index"); return;
};
glTexImage2D(pos, 0, m_internalFormat, bitmap->getWidth(), bitmap->getHeight(),
0, m_format, m_dataFormat, bitmap->getData());
}
} else {
Log(EError, "Unknown texture type!");
}
if (isMipMapped())
glGenerateMipmapEXT(m_glType);
}
void Texture::createMipmaps (int context_id)
{
if (valid (context_id))
{
bind (context_id);
glGenerateMipmapEXT (GL_TEXTURE_2D);
unbind ();
}
}
void WebGraphicsContext3DDefaultImpl::generateMipmap(unsigned long target)
{
makeContextCurrent();
if (glGenerateMipmapEXT)
glGenerateMipmapEXT(target);
// FIXME: provide alternative code path? This will be unpleasant
// to implement if glGenerateMipmapEXT is not available -- it will
// require a texture readback and re-upload.
}
void
piglit_init(int argc, char **argv)
{
piglit_require_extension("GL_EXT_framebuffer_object");
glGenerateMipmapEXT(GL_TEXTURE_2D);
piglit_report_result(PIGLIT_PASS);
}
void Renderer::endRenderFBO()
{
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); // unbind
glBindTexture(GL_TEXTURE_2D, img);
glGenerateMipmapEXT(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, 0);
glViewport(0, 0, WIDTH, HEIGHT);
}
inline void VL_glGenerateMipmap(GLenum target)
{
if (glGenerateMipmap)
glGenerateMipmap(target);
else
if (glGenerateMipmapEXT)
glGenerateMipmapEXT(target);
else
VL_UNSUPPORTED_FUNC();
}
static int
create_fbo(void)
{
GLuint tex, fb;
GLenum status;
int i, dim;
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_2D, tex);
for (i = 0, dim = TEX_WIDTH; dim >0; i++, dim /= 2) {
glTexImage2D(GL_TEXTURE_2D, i, GL_RGBA,
dim, dim,
0,
GL_RGBA, GL_UNSIGNED_BYTE, NULL);
}
assert(glGetError() == 0);
glGenFramebuffersEXT(1, &fb);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,
GL_COLOR_ATTACHMENT0_EXT,
GL_TEXTURE_2D,
tex,
0);
assert(glGetError() == 0);
status = glCheckFramebufferStatusEXT (GL_FRAMEBUFFER_EXT);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
fprintf(stderr, "FBO incomplete\n");
goto done;
}
glViewport(0, 0, TEX_WIDTH, TEX_HEIGHT);
piglit_ortho_projection(TEX_WIDTH, TEX_HEIGHT, GL_FALSE);
glColor4fv(red);
piglit_draw_rect(0, 0, TEX_WIDTH / 2, TEX_HEIGHT / 2);
glColor4fv(green);
piglit_draw_rect(TEX_WIDTH / 2, 0, TEX_WIDTH, TEX_HEIGHT / 2);
glColor4fv(blue);
piglit_draw_rect(0, TEX_HEIGHT / 2, TEX_WIDTH/2, TEX_HEIGHT);
glColor4fv(white);
piglit_draw_rect(TEX_WIDTH / 2, TEX_HEIGHT / 2, TEX_WIDTH, TEX_HEIGHT);
/* Bind back to the (small) window to trigger the bug */
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, piglit_winsys_fbo);
glGenerateMipmapEXT(GL_TEXTURE_2D);
done:
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, piglit_winsys_fbo);
glDeleteFramebuffersEXT(1, &fb);
return tex;
}
void
BufferToTexture::performAction(GLSourceBuffer theSourceBuffer)
{
if (theSourceBuffer == FRAME_BUFFER) {
glReadBuffer(GL_BACK);
}
unsigned myWidth = getWidth();
unsigned myHeight = getHeight();
GLuint myTextureID = _myTexture->getTextureId();
AC_DEBUG << "BufferToTexture::performAction '" << _myTexture->get<NameTag>() << "' id=" << _myTexture->get<IdTag>() << " offset=" << _myOffset << " " << myWidth << "x" << myHeight << " texId=" << myTextureID;
if (_myCopyToImage) {
ImagePtr myImage = _myTexture->getImage();
if (!myImage) {
AC_WARNING << "Texture '" << _myTexture->get<NameTag>() << "' id=" << _myTexture->get<IdTag>() << " has no image associated";
} else {
AC_DEBUG << "BufferToTexture::performAction copy to image '" << myImage->get<NameTag>() << "' id=" << myImage->get<IdTag>();
// copy framebuffer to Image raster
PixelEncodingInfo myPixelEncodingInfo = getDefaultGLTextureParams(myImage->getRasterEncoding());
myPixelEncodingInfo.internalformat = asGLTextureInternalFormat(_myTexture->getInternalEncoding());
glReadPixels(_myOffset[0],_myOffset[1], myWidth,myHeight,
myPixelEncodingInfo.externalformat, myPixelEncodingInfo.pixeltype,
myImage->getRasterPtr()->pixels().begin());
CHECK_OGL_ERROR;
//_myTexture->preload();
}
} else if (myTextureID > 0) {
GLenum myTextureTarget = asGLTextureTarget(_myTexture->getType());
if (myTextureTarget == GL_TEXTURE_2D) {
AC_DEBUG << "BufferToTexture::performAction copy to texture";
// copy framebuffer to texture
glBindTexture(GL_TEXTURE_2D, myTextureID);
glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0,0, _myOffset[0],_myOffset[1], myWidth,myHeight);
CHECK_OGL_ERROR;
// generate mipmap levels
if (hasCap("GL_GENERATE_MIPMAP") && _myTexture->get<TextureMipmapTag>()) {
AC_TRACE << "BufferToTexture::performAction: generating mipmap levels";
glGenerateMipmapEXT(GL_TEXTURE_2D);
CHECK_OGL_ERROR;
}
glBindTexture(GL_TEXTURE_2D, 0);
} else {
AC_WARNING << "Copy to texture only supported for 'texture_2d'";
}
} else {
AC_DEBUG << "BufferToTexture::performAction texture '" << _myTexture->get<NameTag>() << "' is not valid";
}
}
enum piglit_result
piglit_display(void)
{
bool pass = true;
float red[4] = {1.0, 0.0, 0.0, 0.0};
float green[4] = {0.0, 1.0, 0.0, 0.0};
GLuint q, texture;
int tex_size = 64;
int i;
glClearColor(0.5, 0.5, 0.5, 0.5);
glClear(GL_COLOR_BUFFER_BIT);
/* Set up a texture object with green at level 0, red elsewhere */
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
GL_LINEAR_MIPMAP_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE);
for (i = 0; tex_size / (1 << i) > 0; i++)
fill_level(i, tex_size / (1 << i), i == 0 ? green : red);
glGenQueries(1, &q);
/* Generate query fail. */
glBeginQuery(GL_SAMPLES_PASSED, q);
glEndQuery(GL_SAMPLES_PASSED);
/* Mipmap generation should not be affected by conditional rendering. */
glBeginConditionalRenderNV(q, GL_QUERY_WAIT_NV);
glGenerateMipmapEXT(GL_TEXTURE_2D);
glEndConditionalRenderNV();
/* This should draw level 1, since starting window size is 32
* and texture is 64.
*/
glEnable(GL_TEXTURE_2D);
piglit_draw_rect_tex(-1, -1, 2, 2,
0, 0, 1, 1);
glDisable(GL_TEXTURE_2D);
pass = piglit_probe_rect_rgba(0, 0, piglit_width, piglit_height,
green);
glutSwapBuffers();
glDeleteQueries(1, &q);
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
void Texture::GenerateMipmaps(const Image& image, MipmapGeneration mipmapGeneration, const GLInfo& glInfo) const
{
Texture::SetUnpackAlignmentForPixelComponents(image.NumPixelComponents());
Texture::SendTextureData(image, 0);
if (mipmapGeneration == MipmapGeneration::Manual)
{
GenerateManualMipmaps(image);
return;
}
if (mipmapGeneration == MipmapGeneration::GLGenerateMipMap)
{
GLInfo::Vendor vendor = glInfo.GetVendor();
if ((vendor == GLInfo::Vendor::Microsoft) || (vendor == GLInfo::Vendor::Unknown))
{
GenerateMipmapsLegacy(image);
return;
}
bool vendorIsATI = (vendor == GLInfo::Vendor::ATI);
if (GLEW_VERSION_3_0)
{
if (vendorIsATI)
{
glEnable(GL_TEXTURE_2D);
}
glGenerateMipmap(GL_TEXTURE_2D);
return;
}
if (GLEW_VERSION_2_1 && glewIsExtensionSupported("GL_EXT_framebuffer_object"))
{
if (vendorIsATI)
{
glEnable(GL_TEXTURE_2D);
}
glGenerateMipmapEXT(GL_TEXTURE_2D);
return;
}
}
if (mipmapGeneration == MipmapGeneration::None)
{
return;
}
GenerateMipmapsLegacy(image);
}
void RenderToTexture::unbind()
{
// output goes to the FBO and it’s attached buffers
glPopAttrib();
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
if (generate_mipmaps)
{
glBindTexture(GL_TEXTURE_2D, texture_id);
glGenerateMipmapEXT(GL_TEXTURE_2D);
}
}
static GLuint
create_array_fbo_1d(void)
{
GLuint tex, fb;
GLenum status;
int i, dim;
int layer;
if (format == GL_COMPRESSED_RGB_S3TC_DXT1_EXT)
return 0;
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_1D_ARRAY_EXT, tex);
assert(glGetError() == 0);
for (i = 0, dim = TEX_WIDTH; dim >0; i++, dim /= 2) {
glTexImage2D(GL_TEXTURE_1D_ARRAY_EXT, i, format,
dim, num_layers, 0,
GL_RGBA, GL_UNSIGNED_BYTE, NULL);
}
assert(glGetError() == 0);
glGenFramebuffersEXT(1, &fb);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb);
for (layer = 0; layer < num_layers; layer++) {
glFramebufferTextureLayer(GL_FRAMEBUFFER_EXT,
GL_COLOR_ATTACHMENT0_EXT,
tex,
0,
layer);
assert(glGetError() == 0);
status = glCheckFramebufferStatusEXT (GL_FRAMEBUFFER_EXT);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
load_texture_1d_array();
goto done;
}
glViewport(0, 0, TEX_WIDTH, 1);
piglit_ortho_projection(TEX_WIDTH, 1, GL_FALSE);
glColor4fv(layer_color[layer]);
piglit_draw_rect(0, 0, TEX_WIDTH / 2, 1);
glColor4fv(layer_color[(layer + 1) % 4]);
piglit_draw_rect(TEX_WIDTH / 2, 0, TEX_WIDTH, 1);
}
done:
glDeleteFramebuffersEXT(1, &fb);
glGenerateMipmapEXT(GL_TEXTURE_1D_ARRAY_EXT);
return tex;
}
void FrameBufferObject::generateDepthBufferMipMap() const
{
if(this->depthType==FBO_DepthBufferType_TEXTURE)
{
if(this->depthMinificationFiltering==GL_NEAREST
|| this->depthMinificationFiltering==GL_LINEAR)
return; //don't allow to generate mipmap chain for texture that don't support it at the creation
glBindTexture(GL_TEXTURE_2D, this->depthID);
glGenerateMipmapEXT(GL_TEXTURE_2D);
}
}
void FrameBufferObject::generateColorBufferMipMap(const unsigned int colorBufferNum) const
{
if(this->nbColorAttachement>0 && (int)colorBufferNum<this->nbColorAttachement)
{
if(this->colorMinificationFiltering[colorBufferNum]==GL_NEAREST
|| this->colorMinificationFiltering[colorBufferNum]==GL_LINEAR)
return; //don't allow to generate mipmap chain for texture that don't support it at the creation
glBindTexture(GL_TEXTURE_2D, this->colorTextures[colorBufferNum]);
glGenerateMipmapEXT(GL_TEXTURE_2D);
}
}
void OGLTexture::BuildMipSubLevels()
{
if (glloader_GL_EXT_framebuffer_object())
{
this->GLBindTexture();
glGenerateMipmapEXT(target_type_);
}
else
{
THR(errc::function_not_supported);
}
}
void glBuildMipmaps(const GLenum target, GLint internalFormat, const GLsizei width, const GLsizei height, const GLenum format, const GLenum type, const void* data)
{
ScopedTimer timer("Textures::glBuildMipmaps");
if (globalRendering->compressTextures) {
switch ( internalFormat ) {
case 4:
case GL_RGBA8 :
case GL_RGBA : internalFormat = GL_COMPRESSED_RGBA_ARB; break;
case 3:
case GL_RGB8 :
case GL_RGB : internalFormat = GL_COMPRESSED_RGB_ARB; break;
case GL_LUMINANCE: internalFormat = GL_COMPRESSED_LUMINANCE_ARB; break;
}
}
// create mipmapped texture
if (IS_GL_FUNCTION_AVAILABLE(glGenerateMipmapEXT) && !globalRendering->atiHacks) {
// newest method
glTexImage2D(target, 0, internalFormat, width, height, 0, format, type, data);
if (globalRendering->atiHacks) {
glEnable(target);
glGenerateMipmapEXT(target);
glDisable(target);
} else {
glGenerateMipmapEXT(target);
}
} else if (GLEW_VERSION_1_4) {
// This required GL-1.4
// instead of using glu, we rely on glTexImage2D to create the Mipmaps.
glTexParameteri(target, GL_GENERATE_MIPMAP, GL_TRUE);
glTexImage2D(target, 0, internalFormat, width, height, 0, format, type, data);
} else {
gluBuild2DMipmaps(target, internalFormat, width, height, format, type, data);
}
}
