// -------------------------------------------------------------------------------------------------------------------- GLuint NewTex2DFromDetails(const TextureDetails& _texDetails) { GLuint retVal = 0; GLuint texs[2] = { 0 }; glGenTextures(1, &retVal); if (retVal == 0) { return retVal; } glBindTexture(GL_TEXTURE_2D, retVal); glTexStorage2D(GL_TEXTURE_2D, _texDetails.szMipMapCount, _texDetails.glFormat, _texDetails.dwWidth, _texDetails.dwHeight); size_t offset = 0; for (int mip = 0; mip < _texDetails.szMipMapCount; ++mip) { glCompressedTexSubImage2D(GL_TEXTURE_2D, mip, 0, 0, _texDetails.MipMapWidth(mip), _texDetails.MipMapHeight(mip), _texDetails.glFormat, _texDetails.pSizes[mip], (char*)_texDetails.pPixels + offset); offset += _texDetails.pSizes[mip]; } assert(GLRenderer::GetApiError() == GL_NO_ERROR); return retVal; }
bool initTexture() { gli::texture2D Texture(gli::loadStorageDDS(glf::DATA_DIRECTORY + TEXTURE_DIFFUSE)); assert(!Texture.empty()); if(Texture.empty()) return false; glGenTextures(1, &TextureName); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, TextureName); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, GLint(Texture.levels() - 1)); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, GL_RED); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_G, GL_GREEN); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_BLUE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_A, GL_ALPHA); glTexStorage2D(GL_TEXTURE_2D, GLint(Texture.levels()), GL_COMPRESSED_RGB_S3TC_DXT1_EXT, GLsizei(Texture[0].dimensions().x), GLsizei(Texture[0].dimensions().y)); for(std::size_t Level = 0; Level < Texture.levels(); ++Level) { glCompressedTexSubImage2D( GL_TEXTURE_2D, GLint(Level), 0, 0, GLsizei(Texture[Level].dimensions().x), GLsizei(Texture[Level].dimensions().y), GL_COMPRESSED_RGB_S3TC_DXT1_EXT, GLsizei(Texture[Level].size()), Texture[Level].data()); } return true; }
void APIENTRY FWGLExtension::initCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data) { spCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2D)FW_GETGLPROC("glCompressedTexSubImage2D"); if(!spCompressedTexSubImage2D) reportError("glCompressedTexSubImage2D"); glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data); }
void QOpenGLTextureHelper::qt_CompressedTextureSubImage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *bits) { GLint oldTexture; glGetIntegerv(bindingTarget, &oldTexture); glBindTexture(target, texture); glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, bits); glBindTexture(target, oldTexture); }
void Texture2D::setCompressedSubImage(int level, int x, int y, int w, int h, int s, const Buffer &pixels) { bindToTextureUnit(); pixels.bind(GL_PIXEL_UNPACK_BUFFER); glCompressedTexSubImage2D(textureTarget, level, x, y, w, h, getTextureInternalFormat(internalFormat), s, pixels.data(0)); pixels.unbind(GL_PIXEL_UNPACK_BUFFER); assert(FrameBuffer::getError() == GL_NO_ERROR); }
void Texture1DArray::setCompressedSubImage(int level, int x, int l, int w, int d, int s, const Buffer &pixels) { bindToTextureUnit(); pixels.bind(GL_PIXEL_UNPACK_BUFFER); glCompressedTexSubImage2D(GL_TEXTURE_2D, level, x, l, w, d, getTextureInternalFormat(internalFormat), s, pixels.data(0)); pixels.unbind(GL_PIXEL_UNPACK_BUFFER); assert(FrameBuffer::getError() == GL_NO_ERROR); }
void OGLESTexture2D::Unmap2D(uint32_t array_index, uint32_t level) { switch (last_tma_) { case TMA_Read_Only: break; case TMA_Write_Only: case TMA_Read_Write: { GLint gl_internalFormat; GLenum gl_format; GLenum gl_type; OGLESMapping::MappingFormat(gl_internalFormat, gl_format, gl_type, format_); uint32_t const w = this->Width(level); uint32_t const h = this->Height(level); OGLESRenderEngine& re = *checked_cast<OGLESRenderEngine*>(&Context::Instance().RenderFactoryInstance().RenderEngineInstance()); re.BindTexture(0, target_type_, texture_); if (IsCompressedFormat(format_)) { uint32_t const block_size = NumFormatBytes(format_) * 4; GLsizei const image_size = ((w + 3) / 4) * ((h + 3) / 4) * block_size; if (array_size_ > 1) { glCompressedTexSubImage3D(target_type_, level, 0, 0, array_index, w, h, 1, gl_format, image_size, &tex_data_[array_index * num_mip_maps_ + level][0]); } else { glCompressedTexSubImage2D(target_type_, level, 0, 0, w, h, gl_format, image_size, &tex_data_[array_index * num_mip_maps_ + level][0]); } } else { if (array_size_ > 1) { glTexSubImage3D(target_type_, level, 0, 0, array_index, w, h, 1, gl_format, gl_type, &tex_data_[array_index * num_mip_maps_ + level][0]); } else { glTexSubImage2D(target_type_, level, 0, 0, w, h, gl_format, gl_type, &tex_data_[array_index * num_mip_maps_ + level][0]); } } } break; default: BOOST_ASSERT(false); break; } }
//----------------------------------------------------------------------------// void OpenGLTexture::loadCompressedTextureBuffer(const Rectf& dest_area, const GLvoid* buffer) const { const GLsizei image_size = getCompressedTextureSize(dest_area.getSize()); glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, static_cast<GLint>(dest_area.left()), static_cast<GLint>(dest_area.top()), static_cast<GLsizei>(dest_area.getWidth()), static_cast<GLsizei>(dest_area.getHeight()), d_format, image_size, buffer); }
void OGLESTextureCube::UnmapCube(uint32_t array_index, CubeFaces face, uint32_t level) { BOOST_ASSERT(0 == array_index); UNREF_PARAM(array_index); switch (last_tma_) { case TMA_Read_Only: break; case TMA_Write_Only: case TMA_Read_Write: { GLint gl_internalFormat; GLenum gl_format; GLenum gl_type; OGLESMapping::MappingFormat(gl_internalFormat, gl_format, gl_type, format_); glBindTexture(target_type_, texture_); if (IsCompressedFormat(format_)) { int block_size; if ((EF_BC1 == format_) || (EF_SIGNED_BC1 == format_) || (EF_BC1_SRGB == format_) || (EF_BC4 == format_) || (EF_SIGNED_BC4 == format_) || (EF_BC4_SRGB == format_)) { block_size = 8; } else { block_size = 16; } GLsizei const image_size = ((this->Width(level) + 3) / 4) * ((this->Height(level) + 3) / 4) * block_size; glCompressedTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, level, 0, 0, widths_[level], widths_[level], gl_format, image_size, &tex_data_[face * num_mip_maps_ + level][0]); } else { glTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, level, 0, 0, widths_[level], widths_[level], gl_format, gl_type, &tex_data_[face * num_mip_maps_ + level][0]); } } break; default: BOOST_ASSERT(false); break; } }
GLuint Texture::loadDDS(const char * imagepath) { GLuint textureID; glGenTextures(1, &textureID); gli::texture2D Texture(gli::load_dds(imagepath)); assert(!Texture.empty()); glBindTexture(GL_TEXTURE_2D, textureID); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, GLint(Texture.levels() - 1)); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, GL_RED); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_G, GL_GREEN); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_BLUE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_A, GL_ALPHA); glTexStorage2D(GL_TEXTURE_2D, GLint(Texture.levels()), GLenum(gli::internal_format(Texture.format())), GLsizei(Texture.dimensions().x), GLsizei(Texture.dimensions().y)); if (gli::is_compressed(Texture.format())) { for (gli::texture2D::size_type Level = 0; Level < Texture.levels(); ++Level) { glCompressedTexSubImage2D(GL_TEXTURE_2D, GLint(Level), 0, 0, GLsizei(Texture[Level].dimensions().x), GLsizei(Texture[Level].dimensions().y), GLenum(gli::internal_format(Texture.format())), GLsizei(Texture[Level].size()), Texture[Level].data()); } } else { for (gli::texture2D::size_type Level = 0; Level < Texture.levels(); ++Level) { glTexSubImage2D(GL_TEXTURE_2D, GLint(Level), 0, 0, GLsizei(Texture[Level].dimensions().x), GLsizei(Texture[Level].dimensions().y), GLenum(gli::external_format(Texture.format())), GLenum(gli::type_format(Texture.format())), Texture[Level].data()); } } return textureID; }
bool initTexture() { bool Validated(true); gli::texture2D Texture(gli::load_dds((getDataDirectory() + TEXTURE_DIFFUSE).c_str())); assert(!Texture.empty()); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glGenTextures(texture::MAX, &TextureName[0]); glBindTexture(GL_TEXTURE_2D, TextureName[texture::DIFFUSE]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, GLint(Texture.levels() - 1)); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, GL_RED); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_G, GL_GREEN); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_BLUE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_A, GL_ALPHA); glTexStorage2D(GL_TEXTURE_2D, GLint(Texture.levels()), GL_COMPRESSED_RGB_S3TC_DXT1_EXT, GLsizei(Texture.dimensions().x), GLsizei(Texture.dimensions().y)); for(std::size_t Level = 0; Level < Texture.levels(); ++Level) { glCompressedTexSubImage2D( GL_TEXTURE_2D, GLint(Level), 0, 0, GLsizei(Texture[Level].dimensions().x), GLsizei(Texture[Level].dimensions().y), GL_COMPRESSED_RGB_S3TC_DXT1_EXT, GLsizei(Texture[Level].size()), Texture[Level].data()); } glm::vec2 WindowSize(this->getWindowSize()); glBindTexture(GL_TEXTURE_2D, TextureName[texture::COLORBUFFER]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0); glTexStorage2D(GL_TEXTURE_2D, GLint(1), GL_RGBA8, GLsizei(WindowSize.x), GLsizei(WindowSize.y)); glBindTexture(GL_TEXTURE_2D, TextureName[texture::RENDERBUFFER]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0); glTexStorage2D(GL_TEXTURE_2D, GLint(1), GL_DEPTH_COMPONENT24, GLsizei(WindowSize.x), GLsizei(WindowSize.y)); glPixelStorei(GL_UNPACK_ALIGNMENT, 4); return Validated; }
void texture_storage_create2D(hUint32 levels, hBool compressed, GLuint internal_fmt, GLuint fmt, GLuint type, hMipDesc* initdata) { #if 0 glTexStorage2D(GL_TEXTURE_2D, levels, internal_fmt, initdata[0].width, initdata[0].height); if (compressed) { for (auto i = 0u; i < levels; ++i) { glCompressedTexSubImage2D(GL_TEXTURE_2D, i, 0, 0, initdata[i].width, initdata[i].height, fmt, initdata[i].size, initdata[i].data); } } else { for (auto i = 0u; i < levels; ++i) { glTexSubImage2D(GL_TEXTURE_2D, i, 0, 0, initdata[i].width, initdata[i].height, fmt, type, initdata[i].data); } } #endif }
void UploaderTextureRect::uploadImage ( TextureMipmapFlag texMipMapFlag, const std::shared_ptr<Image> &image ) { PixelFormat format = (*image)[0].getFormat(); uvec2 dim = (*image)[0].getDimensions(); if( !PixelFormatInfos::getInfos(format).isCompressed() ) GLCheck( glTexSubImage2D(GL_TEXTURE_RECTANGLE, 0, 0, 0, dim.x, dim.y, GLEnum::getExternalFormat(format), GLEnum::getType(format), (*image)[0].getPixels() )); else GLCheck( glCompressedTexSubImage2D(GL_TEXTURE_RECTANGLE, 0, 0, 0 , dim.x, dim.y, GLEnum::getExternalFormat(format), dim.x * dim.y * PixelFormatInfos::getInfos(format).size(), (*image)[0].getPixels())); }
void TextureGL::Update(const TextureCubeData &data, const vector2f &dataSize, TextureFormat format, const unsigned int numMips) { assert(m_target == GL_TEXTURE_CUBE_MAP); glBindTexture(m_target, m_texture); switch (m_target) { case GL_TEXTURE_CUBE_MAP: if (!IsCompressed(format)) { glTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, 0, 0, dataSize.x, dataSize.y, GLImageFormat(format), GLImageType(format), data.posX); glTexSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, 0, 0, dataSize.x, dataSize.y, GLImageFormat(format), GLImageType(format), data.negX); glTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, 0, 0, dataSize.x, dataSize.y, GLImageFormat(format), GLImageType(format), data.posY); glTexSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, 0, 0, dataSize.x, dataSize.y, GLImageFormat(format), GLImageType(format), data.negY); glTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, 0, 0, dataSize.x, dataSize.y, GLImageFormat(format), GLImageType(format), data.posZ); glTexSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, 0, 0, dataSize.x, dataSize.y, GLImageFormat(format), GLImageType(format), data.negZ); } else { const GLint oglInternalFormat = GLImageFormat(format); size_t Offset = 0; size_t Width = dataSize.x; size_t Height = dataSize.y; size_t bufSize = ((Width + 3) / 4) * ((Height + 3) / 4) * GetMinSize(format); const unsigned char *pData_px = static_cast<const unsigned char*>(data.posX); const unsigned char *pData_nx = static_cast<const unsigned char*>(data.negX); const unsigned char *pData_py = static_cast<const unsigned char*>(data.posY); const unsigned char *pData_ny = static_cast<const unsigned char*>(data.negY); const unsigned char *pData_pz = static_cast<const unsigned char*>(data.posZ); const unsigned char *pData_nz = static_cast<const unsigned char*>(data.negZ); for( unsigned int i = 0; i < numMips; ++i ) { glCompressedTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, i, 0, 0, Width, Height, oglInternalFormat, bufSize, &pData_px[Offset]); glCompressedTexSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, i, 0, 0, Width, Height, oglInternalFormat, bufSize, &pData_nx[Offset]); glCompressedTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, i, 0, 0, Width, Height, oglInternalFormat, bufSize, &pData_py[Offset]); glCompressedTexSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, i, 0, 0, Width, Height, oglInternalFormat, bufSize, &pData_ny[Offset]); glCompressedTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, i, 0, 0, Width, Height, oglInternalFormat, bufSize, &pData_pz[Offset]); glCompressedTexSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, i, 0, 0, Width, Height, oglInternalFormat, bufSize, &pData_nz[Offset]); if( Width<=MIN_COMPRESSED_TEXTURE_DIMENSION || Height<=MIN_COMPRESSED_TEXTURE_DIMENSION ) { break; } Offset += bufSize; bufSize /= 4; Width /= 2; Height /= 2; } } break; default: assert(0); } if (GetDescriptor().generateMipmaps) glGenerateMipmap(m_target); glBindTexture(m_target, 0); }
bool initTexture() { bool Validated(true); gli::gl GL; gli::texture2D Texture(gli::load_dds((getDataDirectory() + TEXTURE_DIFFUSE).c_str())); gli::gl::format const Format = GL.translate(Texture.format()); assert(!Texture.empty()); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glGenTextures(texture::MAX, &TextureName[0]); glBindTexture(GL_TEXTURE_2D, TextureName[texture::DIFFUSE]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, GLint(Texture.levels() - 1)); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, GL_RED); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_G, GL_GREEN); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_BLUE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_A, GL_ALPHA); glTexStorage2D(GL_TEXTURE_2D, static_cast<GLint>(Texture.levels()), Format.Internal, static_cast<GLsizei>(Texture.dimensions().x), static_cast<GLsizei>(Texture.dimensions().y)); for (std::size_t Level = 0; Level < Texture.levels(); ++Level) { glCompressedTexSubImage2D(GL_TEXTURE_2D, static_cast<GLint>(Level), 0, 0, static_cast<GLsizei>(Texture[Level].dimensions().x), static_cast<GLsizei>(Texture[Level].dimensions().y), Format.External, static_cast<GLsizei>(Texture[Level].size()), Texture[Level].data()); } glm::vec2 WindowSize(this->getWindowSize()); glBindTexture(GL_TEXTURE_2D, TextureName[texture::COLORBUFFER]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexStorage2D(GL_TEXTURE_2D, static_cast<GLint>(1), GL_RGBA8, static_cast<GLsizei>(WindowSize.x), static_cast<GLsizei>(WindowSize.y)); glPixelStorei(GL_UNPACK_ALIGNMENT, 4); return Validated; }
enum piglit_result piglit_display(void) { const GLenum format = GL_ETC1_RGB8_OES; const GLsizei width = 8, height = 8; struct etc1_rgb8_texture_8x8 tex; GLuint t; int pass = GL_TRUE; glGenTextures(1, &t); glBindTexture(GL_TEXTURE_2D, t); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); make_etc1_rgb8_texture_8x8(&tex); glClear(GL_COLOR_BUFFER_BIT); /* no compression support */ glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, tex.rgb); pass = piglit_check_gl_error(GL_INVALID_VALUE) && pass; glCopyTexImage2D(GL_TEXTURE_2D, 0, format, 0, 0, width, height, 0); pass = piglit_check_gl_error(GL_INVALID_VALUE) && pass; /* test the texture */ pass = test_etc1_rgb8_texture_8x8(&tex) && pass; /* no subimage support */ glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, GL_RGB, GL_UNSIGNED_BYTE, tex.rgb); pass = piglit_check_gl_error(GL_INVALID_OPERATION) && pass; glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, width, height); pass = piglit_check_gl_error(GL_INVALID_OPERATION) && pass; glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, format, sizeof(tex.data), tex.data); pass = piglit_check_gl_error(GL_INVALID_OPERATION) && pass; glDeleteTextures(1, &t); return (pass) ? PIGLIT_PASS : PIGLIT_FAIL;; }
void OGLTexture1D::UpdateSubresource1D(uint32_t array_index, uint32_t level, uint32_t x_offset, uint32_t width, void const * data) { OGLRenderEngine& re = *checked_cast<OGLRenderEngine*>(&Context::Instance().RenderFactoryInstance().RenderEngineInstance()); GLint gl_internalFormat; GLenum gl_format; GLenum gl_type; OGLMapping::MappingFormat(gl_internalFormat, gl_format, gl_type, format_); re.BindBuffer(GL_PIXEL_UNPACK_BUFFER, 0); re.BindTexture(0, target_type_, texture_); if (IsCompressedFormat(format_)) { uint32_t const block_size = NumFormatBytes(format_) * 4; GLsizei const image_size = ((width + 3) / 4) * block_size; if (array_size_ > 1) { glCompressedTexSubImage2D(target_type_, level, x_offset, array_index, width, 1, gl_format, image_size, data); } else { glCompressedTexSubImage1D(target_type_, level, x_offset, width, gl_format, image_size, data); } } else { if (array_size_ > 1) { glTexSubImage2D(target_type_, level, x_offset, array_index, width, 1, gl_format, gl_type, data); } else { glTexSubImage1D(target_type_, level, x_offset, width, gl_format, gl_type, data); } } }
bool initTexture() { bool Validated(true); gli::texture2d Texture(gli::load_dds((getDataDirectory() + TEXTURE_DIFFUSE).c_str())); this->FrameBufferSize = Texture.extent(); glGenTextures(texture::MAX, &TextureName[0]); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, TextureName[texture::DIFFUSE]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, GLint(Texture.levels() - 1)); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, GL_RED); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_G, GL_GREEN); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_BLUE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_A, GL_ALPHA); glTexStorage2D(GL_TEXTURE_2D, GLint(Texture.levels()), GL_COMPRESSED_RGB_S3TC_DXT1_EXT, GLsizei(Texture.extent().x), GLsizei(Texture.extent().y)); for(std::size_t Level = 0; Level < Texture.levels(); ++Level) { glCompressedTexSubImage2D(GL_TEXTURE_2D, GLint(Level), 0, 0, GLsizei(Texture[Level].extent().x), GLsizei(Texture[Level].extent().y), GL_COMPRESSED_RGB_S3TC_DXT1_EXT, GLsizei(Texture[Level].size()), Texture[Level].data()); } glBindTexture(GL_TEXTURE_2D, TextureName[texture::COLORBUFFER]); glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, this->FrameBufferSize.x, this->FrameBufferSize.y); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, GL_RED); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_G, GL_GREEN); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_BLUE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_A, GL_ALPHA); return Validated; }
/// set texture pixels void GHL_CALL TextureOpenGL::SetData(UInt32 x,UInt32 y,UInt32 w,UInt32 h,const Data* data,UInt32 level) { glActiveTexture(GL_TEXTURE0); //glClientActiveTexture(GL_TEXTURE0); bind(); glPixelStorei(GL_UNPACK_ALIGNMENT,1); #ifndef GHL_OPENGLES glPixelStorei(GL_UNPACK_ROW_LENGTH,w); #endif if (format_compressed(m_fmt)) { glCompressedTexSubImage2D(GL_TEXTURE_2D, level, x, y, w, h, convert_int_format(m_fmt), data->GetSize(), data->GetData()); } else { glTexSubImage2D(GL_TEXTURE_2D, level, x, y, w, h, convert_format(m_fmt), convert_storage(m_fmt), data->GetData()); } glPixelStorei(GL_UNPACK_ALIGNMENT,4); #ifndef GHL_OPENGLES glPixelStorei(GL_UNPACK_ROW_LENGTH,0); #endif m_parent->RestoreTexture(); }
void OGLESTextureCube::UnmapCube(uint32_t array_index, CubeFaces face, uint32_t level) { switch (last_tma_) { case TMA_Read_Only: break; case TMA_Write_Only: case TMA_Read_Write: { GLint gl_internalFormat; GLenum gl_format; GLenum gl_type; OGLESMapping::MappingFormat(gl_internalFormat, gl_format, gl_type, format_); uint32_t const w = this->Width(level); OGLESRenderEngine& re = *checked_cast<OGLESRenderEngine*>(&Context::Instance().RenderFactoryInstance().RenderEngineInstance()); re.BindTexture(0, target_type_, texture_); if (IsCompressedFormat(format_)) { uint32_t const block_size = NumFormatBytes(format_) * 4; GLsizei const image_size = ((this->Width(level) + 3) / 4) * ((this->Height(level) + 3) / 4) * block_size; glCompressedTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, level, 0, 0, w, w, gl_format, image_size, &tex_data_[(array_index * 6 + face) * num_mip_maps_ + level][0]); } else { glTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, level, 0, 0, w, w, gl_format, gl_type, &tex_data_[(array_index * 6 + face) * num_mip_maps_ + level][0]); } } break; default: BOOST_ASSERT(false); break; } }
void TextureGL::Update(const void *data, const vector2f &pos, const vector2f &dataSize, TextureFormat format, const unsigned int numMips) { assert(m_target == GL_TEXTURE_2D); glBindTexture(m_target, m_texture); switch (m_target) { case GL_TEXTURE_2D: if (!IsCompressed(format)) { glTexSubImage2D(m_target, 0, pos.x, pos.y, dataSize.x, dataSize.y, GLImageFormat(format), GLImageType(format), data); } else { const GLint oglInternalFormat = GLImageFormat(format); size_t Offset = 0; size_t Width = dataSize.x; size_t Height = dataSize.y; size_t bufSize = ((Width + 3) / 4) * ((Height + 3) / 4) * GetMinSize(format); const unsigned char *pData = static_cast<const unsigned char*>(data); for( unsigned int i = 0; i < numMips; ++i ) { glCompressedTexSubImage2D(m_target, i, pos.x, pos.y, Width, Height, oglInternalFormat, bufSize, &pData[Offset]); if( Width<=MIN_COMPRESSED_TEXTURE_DIMENSION || Height<=MIN_COMPRESSED_TEXTURE_DIMENSION ) { break; } Offset += bufSize; bufSize /= 4; Width /= 2; Height /= 2; } } break; default: assert(0); } if (GetDescriptor().generateMipmaps) glGenerateMipmap(m_target); glBindTexture(m_target, 0); }
bool initTexture() { gli::texture2D Texture(gli::load_dds((getDataDirectory() + TEXTURE_DIFFUSE).c_str())); assert(!Texture.empty()); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glGenTextures(texture::MAX, &TextureName[0]); glBindTexture(GL_TEXTURE_2D, TextureName[texture::DIFFUSE]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, GLint(Texture.levels() - 1)); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, GL_RED); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_G, GL_GREEN); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_BLUE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_A, GL_ALPHA); glTexStorage2D(GL_TEXTURE_2D, GLint(Texture.levels()), GL_COMPRESSED_RGB_S3TC_DXT1_EXT, GLsizei(Texture.dimensions().x), GLsizei(Texture.dimensions().y)); for(std::size_t Level = 0; Level < Texture.levels(); ++Level) { glCompressedTexSubImage2D( GL_TEXTURE_2D, GLint(Level), 0, 0, GLsizei(Texture[Level].dimensions().x), GLsizei(Texture[Level].dimensions().y), GL_COMPRESSED_RGB_S3TC_DXT1_EXT, GLsizei(Texture[Level].size()), Texture[Level].data()); } glPixelStorei(GL_UNPACK_ALIGNMENT, 4); return true; }
static void GLTexSubImage2DBase( GLenum target, std::uint32_t mipLevel, std::int32_t x, std::int32_t y, std::uint32_t width, std::uint32_t height, const SrcImageDescriptor& imageDesc) { if (IsCompressedFormat(imageDesc.format)) { glCompressedTexSubImage2D( target, static_cast<GLint>(mipLevel), x, y, static_cast<GLsizei>(width), static_cast<GLsizei>(height), GLTypes::Map(imageDesc.format), static_cast<GLsizei>(imageDesc.dataSize), imageDesc.data ); } else { glTexSubImage2D( target, static_cast<GLint>(mipLevel), x, y, static_cast<GLsizei>(width), static_cast<GLsizei>(height), GLTypes::Map(imageDesc.format), GLTypes::Map(imageDesc.dataType), imageDesc.data ); } }
static enum piglit_result call_CompressedTexSubImage_when_texture_is_referenced(void *data) { void *compressed; GLuint tex; GLint size; tex = piglit_rgbw_texture(GL_COMPRESSED_RGBA_BPTC_UNORM, 16, 16, GL_FALSE, GL_FALSE, GL_UNSIGNED_NORMALIZED); glGetTextureHandleARB(tex); if (!piglit_check_gl_error(GL_NO_ERROR)) return PIGLIT_FAIL; glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_COMPRESSED_IMAGE_SIZE, &size); compressed = malloc(size); glGetCompressedTexImage(GL_TEXTURE_2D, 0, compressed); /* The ARB_bindless_texture spec says: * * "The contents of the images in a texture object may still be * updated via commands such as TexSubImage*, CopyTexSubImage*, and * CompressedTexSubImage*, and by rendering to a framebuffer object, * even if the texture object is referenced by one or more texture * handles." */ glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 16, 16, GL_COMPRESSED_RGBA_BPTC_UNORM, size, compressed); free(compressed); if (!piglit_check_gl_error(GL_NO_ERROR)) return PIGLIT_FAIL; return PIGLIT_PASS; }
void UploaderTexture2D::uploadImage ( TextureMipmapFlag texMipMapFlag, const std::shared_ptr<Image> &image ) { PixelFormat format = (*image)[0].getFormat(); unsigned int levelsCount = (texMipMapFlag == TextureMipmapFlag::FromImage) ? image->levels() : 1; for(std::size_t i(0); i<levelsCount; ++i) { uvec2 dim = (*image)[i].getDimensions(); if( !PixelFormatInfos::getInfos(format).isCompressed() ) GLCheck( glTexSubImage2D(GL_TEXTURE_2D, i, 0, 0, dim.x, dim.y, GLEnum::getExternalFormat(format), GLEnum::getType(format), (*image)[i].getPixels() )); else GLCheck( glCompressedTexSubImage2D(GL_TEXTURE_2D, i, 0, 0 , dim.x, dim.y, GLEnum::getExternalFormat(format), dim.x * dim.y * PixelFormatInfos::getInfos(format).size(), (*image)[i].getPixels())); } if(texMipMapFlag == TextureMipmapFlag::GenHardware) GLCheck( glGenerateMipmap(GL_TEXTURE_2D) ); }
void render_texture_subupdate(struct render *R, RID id, const void *pixels, int x, int y, int w, int h) { struct texture * tex = (struct texture *)array_ref(&R->texture, id); if (tex == NULL) return; GLenum type; int target; bind_texture(R, tex, 0, &type, &target); glPixelStorei(GL_UNPACK_ALIGNMENT,1); GLint format = 0; GLenum itype = 0; int compressed = texture_format(tex, &format, &itype); if (compressed) { glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, x, y, w, h, format, calc_texture_size(tex->format, w, h), pixels); } else { glTexSubImage2D(GL_TEXTURE_2D, 0, x, y, w, h, format, itype, pixels); } CHECK_GL_ERROR }
void compressed_tex_sub_image_2d(texture_target_t target, gl::int_t level, gl::int_t xoffset, gl::int_t yoffset, gl::sizei_t width, gl::sizei_t height, pixel_format_t format, gl::sizei_t imageSize, const void * data) { glCompressedTexSubImage2D(static_cast<GLenum>(target), level, xoffset, yoffset, width, height, static_cast<GLenum>(format), imageSize, data); }
bool Texture2D::SetData(unsigned level, int x, int y, int width, int height, const void* data) { URHO3D_PROFILE(SetTextureData); if (!object_ || !graphics_) { URHO3D_LOGERROR("No texture created, can not set data"); return false; } if (!data) { URHO3D_LOGERROR("Null source for setting data"); return false; } if (level >= levels_) { URHO3D_LOGERROR("Illegal mip level for setting data"); return false; } if (graphics_->IsDeviceLost()) { URHO3D_LOGWARNING("Texture data assignment while device is lost"); dataPending_ = true; return true; } if (IsCompressed()) { x &= ~3; y &= ~3; } int levelWidth = GetLevelWidth(level); int levelHeight = GetLevelHeight(level); if (x < 0 || x + width > levelWidth || y < 0 || y + height > levelHeight || width <= 0 || height <= 0) { URHO3D_LOGERROR("Illegal dimensions for setting data"); return false; } graphics_->SetTextureForUpdate(this); bool wholeLevel = x == 0 && y == 0 && width == levelWidth && height == levelHeight; unsigned format = GetSRGB() ? GetSRGBFormat(format_) : format_; if (!IsCompressed()) { if (wholeLevel) glTexImage2D(target_, level, format, width, height, 0, GetExternalFormat(format_), GetDataType(format_), data); else glTexSubImage2D(target_, level, x, y, width, height, GetExternalFormat(format_), GetDataType(format_), data); } else { if (wholeLevel) glCompressedTexImage2D(target_, level, format, width, height, 0, GetDataSize(width, height), data); else glCompressedTexSubImage2D(target_, level, x, y, width, height, format, GetDataSize(width, height), data); } graphics_->SetTexture(0, 0); return true; }
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglCompressedTexSubImage2DBO(JNIEnv *env, jclass clazz, jint target, jint level, jint xoffset, jint yoffset, jint width, jint height, jint format, jint imageSize, jlong data_buffer_offset, jlong function_pointer) { const GLvoid *data_address = (const GLvoid *)(intptr_t)offsetToPointer(data_buffer_offset); glCompressedTexSubImage2DPROC glCompressedTexSubImage2D = (glCompressedTexSubImage2DPROC)((intptr_t)function_pointer); glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data_address); }
void GLTextureBuffer::upload(const PixelData &data, const PixelVolume &dest) { if((mUsage & TU_RENDERTARGET) != 0) BS_EXCEPT(NotImplementedException, "Writing to render texture from CPU not supported."); if ((mUsage & TU_DEPTHSTENCIL) != 0) BS_EXCEPT(NotImplementedException, "Writing to depth stencil texture from CPU not supported."); glBindTexture( mTarget, mTextureID ); if(PixelUtil::isCompressed(data.getFormat())) { if(data.getFormat() != mFormat || !data.isConsecutive()) BS_EXCEPT(InvalidParametersException, "Compressed images must be consecutive, in the source format"); GLenum format = GLPixelUtil::getClosestGLInternalFormat(mFormat); switch(mTarget) { case GL_TEXTURE_1D: if (dest.left == 0) { glCompressedTexImage1D(GL_TEXTURE_1D, mLevel, format, dest.getWidth(), 0, data.getConsecutiveSize(), data.getData()); } else { glCompressedTexSubImage1D(GL_TEXTURE_1D, mLevel, dest.left, dest.getWidth(), format, data.getConsecutiveSize(), data.getData()); } break; case GL_TEXTURE_2D: case GL_TEXTURE_CUBE_MAP: if (dest.left == 0 && dest.top == 0) { glCompressedTexImage2D(mFaceTarget, mLevel, format, dest.getWidth(), dest.getHeight(), 0, data.getConsecutiveSize(), data.getData()); } else { glCompressedTexSubImage2D(mFaceTarget, mLevel, dest.left, dest.top, dest.getWidth(), dest.getHeight(), format, data.getConsecutiveSize(), data.getData()); } break; case GL_TEXTURE_3D: if (dest.left == 0 && dest.top == 0 && dest.front == 0) { glCompressedTexImage3D(GL_TEXTURE_3D, mLevel, format, dest.getWidth(), dest.getHeight(), dest.getDepth(), 0, data.getConsecutiveSize(), data.getData()); } else { glCompressedTexSubImage3D(GL_TEXTURE_3D, mLevel, dest.left, dest.top, dest.front, dest.getWidth(), dest.getHeight(), dest.getDepth(), format, data.getConsecutiveSize(), data.getData()); } break; } } else { if(data.getWidth() != data.getRowPitch()) glPixelStorei(GL_UNPACK_ROW_LENGTH, data.getRowPitch()); if(data.getHeight()*data.getWidth() != data.getSlicePitch()) glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, (data.getSlicePitch()/data.getWidth())); if(data.getLeft() > 0 || data.getTop() > 0 || data.getFront() > 0) glPixelStorei(GL_UNPACK_SKIP_PIXELS, data.getLeft() + data.getRowPitch() * data.getTop() + data.getSlicePitch() * data.getFront()); if((data.getWidth()*PixelUtil::getNumElemBytes(data.getFormat())) & 3) glPixelStorei(GL_UNPACK_ALIGNMENT, 1); switch(mTarget) { case GL_TEXTURE_1D: glTexSubImage1D(GL_TEXTURE_1D, mLevel, dest.left, dest.getWidth(), GLPixelUtil::getGLOriginFormat(data.getFormat()), GLPixelUtil::getGLOriginDataType(data.getFormat()), data.getData()); break; case GL_TEXTURE_2D: case GL_TEXTURE_CUBE_MAP: glTexSubImage2D(mFaceTarget, mLevel, dest.left, dest.top, dest.getWidth(), dest.getHeight(), GLPixelUtil::getGLOriginFormat(data.getFormat()), GLPixelUtil::getGLOriginDataType(data.getFormat()), data.getData()); break; case GL_TEXTURE_3D: glTexSubImage3D( GL_TEXTURE_3D, mLevel, dest.left, dest.top, dest.front, dest.getWidth(), dest.getHeight(), dest.getDepth(), GLPixelUtil::getGLOriginFormat(data.getFormat()), GLPixelUtil::getGLOriginDataType(data.getFormat()), data.getData()); break; } } // Restore defaults glPixelStorei(GL_UNPACK_ROW_LENGTH, 0); glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, 0); glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0); glPixelStorei(GL_UNPACK_ALIGNMENT, 4); BS_INC_RENDER_STAT_CAT(ResWrite, RenderStatObject_Texture); }