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;
}
}
