TextureRenderData::TextureRenderData(const ImgColor& imgColor) { const Image& image = imgColor.image; glGenTextures(1, &handle_); glBindTexture(GL_TEXTURE_2D, handle_); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, Core::get().renderer().textureMinFilter()); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, Core::get().renderer().textureMaxAnisotropy()); switch(image.format()) { case PixelFormat::kA8R8G8B8: glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, image.width(), image.height(), 0, GL_BGRA, GL_UNSIGNED_BYTE, image.data()); break; case PixelFormat::kR8G8B8: glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, image.width(), image.height(), 0, GL_BGR, GL_UNSIGNED_BYTE, image.data()); break; case PixelFormat::kDXT1: glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, image.width(), image.height(), 0, (GLsizei)image.size(), image.data()); break; case PixelFormat::kDXT3: glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, image.width(), image.height(), 0, (GLsizei)image.size(), image.data()); break; case PixelFormat::kDXT5: glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, image.width(), image.height(), 0, (GLsizei)image.size(), image.data()); break; default: throw runtime_error("Unsupported image format"); } glGenerateMipmap(GL_TEXTURE_2D); }
void Texture::_makeTexture() { int i = 0; int mipmapFactor = 0; glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glGenTextures(1, &mOpenglName); glBindTexture(GL_TEXTURE_2D, mOpenglName); if (mFormat == GL_RGBA || mFormat == GL_RGB) { /* http://www.khronos.org/opengles/sdk/docs/man/xhtml/glTexImage2D.xml */ glTexImage2D(GL_TEXTURE_2D, \ 0, \ mFormat, \ mWidth, \ mHeight, \ 0, \ mFormat, \ mType, \ mTextureData); /* if (mMipmapLevel != 0) glGenerateMipmap(GL_TEXTURE_2D); */ } else { glCompressedTexImage2D(GL_TEXTURE_2D, \ 0, \ mFormat, \ mWidth, \ mHeight, \ 0, \ (int)mTextureDataSize, \ mTextureData); mipmapFactor = 2; for (i = 0; i < mMipmapLevel; i++, mipmapFactor *= 2) { glCompressedTexImage2D(GL_TEXTURE_2D, \ i + 1, \ mFormat, \ mWidth/mipmapFactor, \ mHeight/mipmapFactor, \ 0, \ (int)mMipmapData[i]->getSize(), \ mMipmapData[i]->getData()); } } if (KMMathIsPowerOfTwo(mWidth) && KMMathIsPowerOfTwo(mHeight)) mPOT = true; glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, mMipmapLevel == 0 ? GL_NEAREST : GL_LINEAR_MIPMAP_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, mPOT ? HGCTextureDefaultWrapMode : GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, mPOT ? HGCTextureDefaultWrapMode : GL_CLAMP_TO_EDGE); }
bool initTexture() { glGenTextures(texture::MAX, TextureName); { glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, TextureName[texture::RGB]); 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); gli::texture2D Texture(gli::loadStorageDDS(glf::DATA_DIRECTORY + TEXTURE_DIFFUSE)); for(std::size_t Level = 0; Level < Texture.levels(); ++Level) { glCompressedTexImage2D( GL_TEXTURE_2D, GLint(Level), GL_COMPRESSED_RGB_S3TC_DXT1_EXT, GLsizei(Texture[Level].dimensions().x), GLsizei(Texture[Level].dimensions().y), 0, GLsizei(Texture[Level].size()), Texture[Level].data()); } } { glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, TextureName[texture::BGR]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, GL_BLUE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_G, GL_GREEN); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_RED); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_A, GL_ALPHA); gli::texture2D Texture(gli::loadStorageDDS(glf::DATA_DIRECTORY + TEXTURE_DIFFUSE)); for(std::size_t Level = 0; Level < Texture.levels(); ++Level) { glCompressedTexImage2D( GL_TEXTURE_2D, GLint(Level), GL_COMPRESSED_RGB_S3TC_DXT1_EXT, GLsizei(Texture[Level].dimensions().x), GLsizei(Texture[Level].dimensions().y), 0, GLsizei(Texture[Level].size()), Texture[Level].data()); } } return glf::checkError("initTexture2D"); }
bool CDDS::UploadTexture() const { if (m_pixels.empty()) return false; // Missing mipmaps won't be a problem anymore. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, GLint(m_nbMipmaps) - 1); // Upload each mipmaps size_t Offset = 0; size_t Width = m_width; size_t Height = m_height; for (size_t i = 0; (i < m_nbMipmaps) && ((Width != 0) || (Height != 0)); ++i) { size_t BufSize = ((Width + 3) / 4) * ((Height + 3) / 4) * m_blockSize; glCompressedTexImage2D(GL_TEXTURE_2D, GLint(i), m_format, GLsizei(Width), GLsizei(Height), 0, GLsizei(BufSize), &m_pixels[Offset]); Offset += BufSize; if ((Width /= 2) == 0) Width = 1; if ((Height /= 2) == 0) Height = 1; } return true; }
bool initTexture() { glGenTextures(1, &TextureName); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, TextureName); gli::gl GL; gli::texture2d Texture(gli::load_dds((getDataDirectory() + TEXTURE_DIFFUSE).c_str())); assert(!Texture.empty()); gli::gl::format const Format = GL.translate(Texture.format()); for(std::size_t Level = 0; Level < Texture.levels(); ++Level) { glCompressedTexImage2D(GL_TEXTURE_2D, GLint(Level), Format.Internal, GLsizei(Texture[Level].extent().x), GLsizei(Texture[Level].extent().y), 0, GLsizei(Texture[Level].size()), Texture[Level].data()); } glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, 0); return this->checkError("initTexture"); }
static int test_etc1_rgb8_texture_8x8(const struct etc1_rgb8_texture_8x8 *tex) { const GLenum format = GL_ETC1_RGB8_OES; const GLsizei width = 8, height = 8; unsigned x, y; int pass = GL_TRUE; glCompressedTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, sizeof(tex->data), tex->data); pass = piglit_check_gl_error(GL_NO_ERROR) && pass; glEnable(GL_TEXTURE_2D); piglit_draw_rect_tex(0, 0, width, height, 0.0f, 0.0f, 1.0f, 1.0f); glDisable(GL_TEXTURE_2D); for (y = 0; y < height; y++) { for (x = 0; x < width; x++) { const GLubyte *rgb = tex->rgb[y * width + x]; float expected[3] = { rgb[0] / 255.0f, rgb[1] / 255.0f, rgb[2] / 255.0f }; pass = piglit_probe_pixel_rgb(x, y, expected) && pass; } } return pass; }
// Test the destination texture cannot be immutable TEST_P(CopyCompressedTextureTest, Immutable) { if (!checkExtensions() || getClientMajorVersion() < 3) { return; } glBindTexture(GL_TEXTURE_2D, mTextures[0]); 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_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGB_S3TC_DXT1_EXT, 4, 4, 0, sizeof(CompressedImageDXT1), CompressedImageDXT1); ASSERT_GL_NO_ERROR(); glBindTexture(GL_TEXTURE_2D, mTextures[1]); glTexStorage2D(GL_TEXTURE_2D, 1, GL_COMPRESSED_RGB_S3TC_DXT1_EXT, 4, 4); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); ASSERT_GL_NO_ERROR(); glCompressedCopyTextureCHROMIUM(mTextures[0], mTextures[1]); EXPECT_GL_ERROR(GL_INVALID_OPERATION); }
bool CCTextureASTC::createGLTexture(){ /* We now have file contents in memory so let's fill a texture object with the data. */ if (m_uName != 0) { ccGLDeleteTexture(m_uName); } glGenTextures(1, &m_uName); ccGLBindTexture2D(m_uName); /* Upload texture data to ES. */ glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_ASTC_6x5_KHR, m_uWidth, m_uHeight, 0, m_dataLen, m_data+sizeof(astc_header)); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); return true; }
bool initTexture() { gli::texture2D Texture(gli::load_dds((getDataDirectory() + TEXTURE_DIFFUSE_DXT5).c_str())); glGenTextures(1, &TextureName); 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)); for(std::size_t Level = 0; Level < Texture.levels(); ++Level) { glCompressedTexImage2D( GL_TEXTURE_2D, GLint(Level), GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GLsizei(Texture[Level].dimensions().x), GLsizei(Texture[Level].dimensions().y), 0, GLsizei(Texture[Level].size()), Texture[Level].data()); } return this->checkError("initTexture"); }
void rglCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data) { glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data); }
bool initTexture2D() { glGenTextures(1, &Image2DName); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, Image2DName); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 1000); 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); gli::texture2D Image = gli::load(TEXTURE_DIFFUSE_DXT5); for(std::size_t Level = 0; Level < Image.levels(); ++Level) { glCompressedTexImage2D( GL_TEXTURE_2D, GLint(Level), GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GLsizei(Image[Level].dimensions().x), GLsizei(Image[Level].dimensions().y), 0, GLsizei(Image[Level].capacity()), Image[Level].data()); } return glf::checkError("initTexture2D"); }
bool initTexture() { glGenTextures(1, &Texture2DName); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, Texture2DName); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 1000); 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); gli::texture2D Texture(gli::load_dds((getDataDirectory() + TEXTURE_DIFFUSE).c_str())); for(std::size_t Level = 0; Level < Texture.levels(); ++Level) { glCompressedTexImage2D( GL_TEXTURE_2D, GLint(Level), GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GLsizei(Texture[Level].dimensions().x), GLsizei(Texture[Level].dimensions().y), 0, GLsizei(Texture[Level].size()), Texture[Level].data()); } glBindTexture(GL_TEXTURE_2D, 0); return this->checkError("initTexture"); }
TextureOpenGL* TextureOpenGL::Create( RenderOpenGL* parent,TextureFormat fmt,UInt32 w,UInt32 h, const Data* data) { if (fmt==TEXTURE_FORMAT_UNKNOWN) return 0; GLuint name = 0; glActiveTexture(GL_TEXTURE0); glGenTextures(1, &name); if (!name) return 0; glBindTexture(GL_TEXTURE_2D, name); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_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); if (format_compressed(fmt)) { if ( data ) glCompressedTexImage2D(GL_TEXTURE_2D, 0, convert_int_format(fmt), w, h, 0, data->GetSize(), data->GetData() ); else { glBindTexture(GL_TEXTURE_2D, 0); glDeleteTextures(1, &name); return 0; } } else { glTexImage2D(GL_TEXTURE_2D, 0, convert_int_format(fmt), w, h, 0, convert_format(fmt), convert_storage(fmt), data ? data->GetData() : 0); } return new TextureOpenGL( name, parent, fmt, w,h ); }
bool initTexture() { gli::gl GL; glGenTextures(texture::MAX, &TextureName[0]); { gli::texture2D Texture(gli::load_dds((getDataDirectory() + TEXTURE_DIFFUSE_RGB8).c_str())); assert(!Texture.empty()); gli::gl::format const Format = GL.translate(Texture.format()); gli::gl::swizzles const Swizzles = GL.translate(Texture.swizzles()); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, TextureName[texture::RGB8]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, GLint(Texture.levels())); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, Swizzles[0]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_G, Swizzles[1]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, Swizzles[2]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_A, Swizzles[3]); for(std::size_t Level = 0; Level < Texture.levels(); ++Level) { glTexImage2D(GL_TEXTURE_2D, GLint(Level), Format.Internal, GLsizei(Texture[Level].dimensions().x), GLsizei(Texture[Level].dimensions().y), 0, Format.External, Format.Type, Texture[Level].data()); } } { gli::texture2D Texture(gli::load_dds((getDataDirectory() + TEXTURE_DIFFUSE_DXT1).c_str())); assert(!Texture.empty()); gli::gl::format const Format = GL.translate(Texture.format()); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, TextureName[texture::DXT1]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, GLint(Texture.levels())); 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); for(std::size_t Level = 0; Level < Texture.levels(); ++Level) { glCompressedTexImage2D(GL_TEXTURE_2D, GLint(Level), Format.Internal, GLsizei(Texture[Level].dimensions().x), GLsizei(Texture[Level].dimensions().y), 0, GLsizei(Texture[Level].size()), Texture[Level].data()); } } return true; }
bool initTexture() { glGenTextures(1, &Texture2DName); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, Texture2DName); gli::texture2d Texture(gli::load_dds((getDataDirectory() + TEXTURE_DIFFUSE).c_str())); for(std::size_t Level = 0; Level < Texture.levels(); ++Level) { glCompressedTexImage2D( GL_TEXTURE_2D, GLint(Level), GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GLsizei(Texture[Level].extent().x), GLsizei(Texture[Level].extent().y), 0, GLsizei(Texture[Level].size()), Texture[Level].data()); } glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, 0); return this->checkError("initTexture"); }
void APIENTRY FWGLExtension::initCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data) { spCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2D)FW_GETGLPROC("glCompressedTexImage2D"); if(!spCompressedTexImage2D) reportError("glCompressedTexImage2D"); glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data); }
/** Try to load a compressed texture from the given file name. * Data in the specified file need to have a specific format. See the * saveCompressedTexture() function for a description of the format. * \return true if the loading succeeded, false otherwise. * \see saveCompressedTexture */ bool loadCompressedTexture(const std::string& compressed_tex) { std::ifstream ifs(compressed_tex.c_str(), std::ios::in | std::ios::binary); if (!ifs.is_open()) return false; int internal_format; int w, h; int size = -1; ifs.read((char*)&internal_format, sizeof(int)); ifs.read((char*)&w, sizeof(int)); ifs.read((char*)&h, sizeof(int)); ifs.read((char*)&size, sizeof(int)); if (ifs.fail() || size == -1) return false; char *data = new char[size]; ifs.read(data, size); if (!ifs.fail()) { glCompressedTexImage2D(GL_TEXTURE_2D, 0, internal_format, w, h, 0, size, (GLvoid*)data); glGenerateMipmap(GL_TEXTURE_2D); delete[] data; ifs.close(); return true; } delete[] data; return false; }
bool initTexture2D() { glGenTextures(1, &Image2DName); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, Image2DName); gli::image Image = gli::import_as(TEXTURE_DIFFUSE_DXT5); for(std::size_t Level = 0; Level < Image.levels(); ++Level) { glCompressedTexImage2D( GL_TEXTURE_2D, GLint(Level), GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GLsizei(Image[Level].dimensions().x), GLsizei(Image[Level].dimensions().y), 0, GLsizei(Image[Level].capacity()), Image[Level].data()); } glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, 0); return glf::checkError("initTexture2D"); }
// Test that only 2D textures are valid TEST_P(CopyCompressedTextureTest, BindingPoints) { if (!checkExtensions()) { return; } glBindTexture(GL_TEXTURE_CUBE_MAP, mTextures[0]); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_NEAREST); for (GLenum face = GL_TEXTURE_CUBE_MAP_POSITIVE_X; face <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z; face++) { glCompressedTexImage2D(face, 0, GL_COMPRESSED_RGB_S3TC_DXT1_EXT, 4, 4, 0, sizeof(CompressedImageDXT1), CompressedImageDXT1); } ASSERT_GL_NO_ERROR(); glBindTexture(GL_TEXTURE_CUBE_MAP, mTextures[1]); glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_NEAREST); ASSERT_GL_NO_ERROR(); glCompressedCopyTextureCHROMIUM(mTextures[0], mTextures[1]); EXPECT_GL_ERROR(GL_INVALID_VALUE); }
void UpLoadTextureToGPU(texture_t* texture) { if (!texture || !texture->data || texture->textureId != 0) return; glActiveTexture(GL_TEXTURE0); glGenTextures(1, &texture->textureId); glBindTexture(GL_TEXTURE_2D, texture->textureId); if (texture->format == TEXTURE_GL_RGB ||texture->format == TEXTURE_GL_RGBA) glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, texture->width, texture->height, 0, GL_RGBA, GL_UNSIGNED_BYTE, texture->data); else glCompressedTexImage2D(GL_TEXTURE_2D, 0, texture->format, texture->width,texture->height, 0, texture->dataLength, texture->data); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, DE_DEFAULT_FILTERING); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, DE_DEFAULT_FILTERING); if (texture->file != NULL) FS_CloseFile(texture->file); free(texture->data); }
void render_texture_update(struct render *R, RID id, int width, int height, const void *pixels, int slice, int miplevel) { struct texture * tex = (struct texture *)array_ref(&R->texture, id); if (tex == NULL) return; GLenum type; int target; bind_texture(R, tex, slice, &type, &target); if (tex->mipmap) { glTexParameteri( type, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR ); } else { glTexParameteri( type, GL_TEXTURE_MIN_FILTER, GL_LINEAR ); } glTexParameteri( type, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); glTexParameteri( type, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE ); glTexParameteri( type, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE ); glPixelStorei(GL_UNPACK_ALIGNMENT,1); GLint format = 0; GLenum itype = 0; int compressed = texture_format(tex, &format, &itype); if (compressed) { glCompressedTexImage2D(target, miplevel, format, (GLsizei)tex->width, (GLsizei)tex->height, 0, calc_texture_size(tex->format, width, height), pixels); } else { glTexImage2D(target, miplevel, format, (GLsizei)width, (GLsizei)height, 0, format, itype, pixels); } CHECK_GL_ERROR }
uint32_t NvImage::UploadTexture(NvImage* image) { GLuint texID = 0; if (!image) return 0; glGenTextures(1, &texID); const NvGfxAPIVersion& api = NvImage::getAPIVersion(); uint32_t internalFormat = (api.api == NvGfxAPI::GLES) ? image->getFormat() : image->getInternalFormat(); if (image->isCubeMap()) { int32_t error = glGetError(); glBindTexture(GL_TEXTURE_CUBE_MAP, texID); error = glGetError(); for (int32_t f = GL_TEXTURE_CUBE_MAP_POSITIVE_X; f <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z; f++) { int32_t w = image->getWidth(); int32_t h = image->getHeight(); for (int32_t l = 0; l < image->getMipLevels(); l++) { if (image->isCompressed()) { glCompressedTexImage2D( f, l, internalFormat, w, h, 0, image->getImageSize(l), image->getLevel(l, f)); } else { glTexImage2D( f, l, internalFormat, w, h, 0, image->getFormat(), image->getType(), image->getLevel(l, f)); } error = glGetError(); w >>= 1; h >>= 1; w = w ? w : 1; h = h ? h : 1; } } } else {
extern "C" int load_crn_to_texture(unsigned char *data, size_t length) { crnd::crn_level_info level_info; crnd::crnd_unpack_context cuc = crnd::crnd_unpack_begin(data, length); if (!crnd::crnd_get_level_info(data, length, 0, &level_info)) return 0; size_t size = level_info.m_blocks_x * level_info.m_blocks_y * level_info.m_bytes_per_block; unsigned char *output = (unsigned char *) malloc(size); for (int level=0; level < 13; ++level) { if (!crnd::crnd_get_level_info(data, length, level, &level_info)) break; unsigned int pitch_bytes = level_info.m_blocks_x * level_info.m_bytes_per_block; if (!crnd::crnd_unpack_level(cuc, (void **) &output, size, pitch_bytes, level)) break; glCompressedTexImage2D(GL_TEXTURE_2D, level, GL_COMPRESSED_RGB_S3TC_DXT1_EXT, level_info.m_width, level_info.m_height, 0, pitch_bytes*level_info.m_blocks_y, output); } free(output); crnd::crnd_unpack_end(cuc); return 1; }
void Texture2D::init(int w, int h, TextureInternalFormat tf, TextureFormat f, PixelType t, const Parameters ¶ms, const Buffer::Parameters &s, const Buffer &pixels) { Texture::init(tf, params); this->w = w; this->h = h; pixels.bind(GL_PIXEL_UNPACK_BUFFER); if (isCompressed() && s.compressedSize() > 0) { glCompressedTexImage2D(textureTarget, 0, getTextureInternalFormat(internalFormat), w, h, 0, s.compressedSize(), pixels.data(0)); } else { s.set(); glTexImage2D(textureTarget, 0, getTextureInternalFormat(internalFormat), w, h, 0, getTextureFormat(f), getPixelType(t), pixels.data(0)); s.unset(); } pixels.unbind(GL_PIXEL_UNPACK_BUFFER); generateMipMap(); if (FrameBuffer::getError() != 0) { throw exception(); } }
// Test validation of texture IDs TEST_P(CopyCompressedTextureTest, InvalidTextureIds) { if (!checkExtensions()) { return; } glBindTexture(GL_TEXTURE_2D, mTextures[0]); 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_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGB_S3TC_DXT1_EXT, 4, 4, 0, sizeof(CompressedImageDXT1), CompressedImageDXT1); ASSERT_GL_NO_ERROR(); glBindTexture(GL_TEXTURE_2D, mTextures[1]); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); ASSERT_GL_NO_ERROR(); glCompressedCopyTextureCHROMIUM(mTextures[0], 99993); EXPECT_GL_ERROR(GL_INVALID_VALUE); glCompressedCopyTextureCHROMIUM(99994, mTextures[1]); EXPECT_GL_ERROR(GL_INVALID_VALUE); glCompressedCopyTextureCHROMIUM(99995, 99996); EXPECT_GL_ERROR(GL_INVALID_VALUE); glCompressedCopyTextureCHROMIUM(mTextures[0], mTextures[1]); EXPECT_GL_NO_ERROR(); }
bool initTexture() { glGenTextures(texture::MAX, TextureName); { gli::texture2D Texture(gli::loadStorageDDS(glf::DATA_DIRECTORY + TEXTURE_DIFFUSE_RGB8)); assert(!Texture.empty()); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, TextureName[texture::RGB8]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, GLint(Texture.levels())); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, GL_BLUE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_G, GL_GREEN); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_RED); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_A, GL_ALPHA); for(std::size_t Level = 0; Level < Texture.levels(); ++Level) { glTexImage2D( GL_TEXTURE_2D, GLint(Level), GL_RGB8, GLsizei(Texture[Level].dimensions().x), GLsizei(Texture[Level].dimensions().y), 0, GL_BGR, GL_UNSIGNED_BYTE, Texture[Level].data()); } } { gli::texture2D Texture(gli::loadStorageDDS(glf::DATA_DIRECTORY + TEXTURE_DIFFUSE_DXT1)); assert(!Texture.empty()); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, TextureName[texture::DXT1]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, GLint(Texture.levels())); 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); for(std::size_t Level = 0; Level < Texture.levels(); ++Level) { glCompressedTexImage2D( GL_TEXTURE_2D, GLint(Level), GL_COMPRESSED_RGB_S3TC_DXT1_EXT, GLsizei(Texture[Level].dimensions().x), GLsizei(Texture[Level].dimensions().y), 0, GLsizei(Texture[Level].size()), Texture[Level].data()); } } return true; }
inline void gl_compressed_texture_image2d(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data) { glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data); #if defined(DEBUG) gl_get_error(); #endif }
void QOpenGLTextureHelper::qt_CompressedTextureImage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *bits) { GLint oldTexture; glGetIntegerv(bindingTarget, &oldTexture); glBindTexture(target, texture); glCompressedTexImage2D(target, level, internalFormat, width, height, border, imageSize, bits); glBindTexture(target, oldTexture); }
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]); 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_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); for(std::size_t Level = 0; Level < Texture.levels(); ++Level) { glCompressedTexImage2D(GL_TEXTURE_2D, GLint(Level), GL_COMPRESSED_RGB_S3TC_DXT1_EXT, GLsizei(Texture[Level].extent().x), GLsizei(Texture[Level].extent().y), 0, GLsizei(Texture[Level].size()), Texture[Level].data()); } glm::ivec2 WindowSize(this->getWindowSize() * this->FramebufferScale); glActiveTexture(GL_TEXTURE0); 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_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexImage2D(GL_TEXTURE_2D, GLint(0), GL_RGBA8, GLsizei(WindowSize.x), GLsizei(WindowSize.y), 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, TextureName[texture::DEPTHBUFFER]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0); glTexImage2D(GL_TEXTURE_2D, GLint(0), GL_DEPTH_COMPONENT24, GLsizei(WindowSize.x), GLsizei(WindowSize.y), 0, GL_DEPTH_COMPONENT, GL_FLOAT, nullptr); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, TextureName[texture::STENCILBUFFER]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0); glTexImage2D(GL_TEXTURE_2D, GLint(0), GL_STENCIL_INDEX8, GLsizei(WindowSize.x), GLsizei(WindowSize.y), 0, GL_STENCIL_INDEX, GL_UNSIGNED_BYTE, nullptr); glPixelStorei(GL_UNPACK_ALIGNMENT, 4); return Validated; }
void CCubemapTexture::onResourceLoaded(ISharedResourceRef resource, bool success) { glBindTexture(GL_TEXTURE_CUBE_MAP, m_textureId); CSharedTexture texture = std::static_pointer_cast<CTexture>(resource); GLenum face = GL_TEXTURE_CUBE_MAP_POSITIVE_X; if(resource == m_xpositive) { face = GL_TEXTURE_CUBE_MAP_POSITIVE_X; } else if(resource == m_xnegative) { face = GL_TEXTURE_CUBE_MAP_NEGATIVE_X; } else if(resource == m_ypositive) { face = GL_TEXTURE_CUBE_MAP_POSITIVE_Y; } else if(resource == m_ynegative) { face = GL_TEXTURE_CUBE_MAP_NEGATIVE_Y; } else if(resource == m_zpositive) { face = GL_TEXTURE_CUBE_MAP_POSITIVE_Z; } else if(resource == m_znegative) { face = GL_TEXTURE_CUBE_MAP_NEGATIVE_Z; } i32 width = texture->getWidth(); i32 height = texture->getHeight(); const ui8* data = texture->getData(); for (ui32 mip = 0; mip < texture->getNumMips() && width > 0 && height > 0; ++mip) { GLsizei size = MAX_VALUE(32, static_cast<i32>(width) * static_cast<i32>(height) * texture->getBPP() / 8); texture->isCompressed() ? glCompressedTexImage2D(face, mip, texture->getFormat(), width, height, 0, size, data) : glTexImage2D(face, mip, texture->getFormat(), width, height, 0, texture->getFormat(), GL_UNSIGNED_BYTE, data); data += size; width >>= 1; height >>= 1; } if(m_xpositive->isCommited() && m_xpositive->isLoaded() && m_xnegative->isCommited() && m_xnegative->isLoaded() && m_ypositive->isCommited() && m_ypositive->isLoaded() && m_ynegative->isCommited() && m_ynegative->isLoaded() && m_zpositive->isCommited() && m_zpositive->isLoaded() && m_znegative->isCommited() && m_znegative->isLoaded()) { m_status |= E_RESOURCE_STATUS_LOADED; m_status |= E_RESOURCE_STATUS_COMMITED; } }