void Texture2DArray::pushToGPU(bool deleteAfterPush) { glTextureStorage3D(name, mipmapLevels, images[0].format.sizedFormat, images[0].width, images[0].height, images.size()); //allocate space for all for (unsigned int i = 0; i < images.size(); ++i) { ImageData &imageData = images[i]; if (imageData.data != 0) glTextureSubImage3D(name, 0, 0, 0, i, imageData.width, imageData.height, 1, imageData.format.baseFormat, imageData.format.type, imageData.data); if (deleteAfterPush) { delete[] imageData.data; imageData.data = 0; } } if (mipmapLevels > 1) { glGenerateTextureMipmap(name); //generate the remaining mipmaps glTextureParameterf(name, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); } else glTextureParameterf(name, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTextureParameterf(name, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTextureParameterf(name, GL_TEXTURE_WRAP_S, GL_REPEAT); glTextureParameterf(name, GL_TEXTURE_WRAP_T, GL_REPEAT); }
void GSTextureOGL::GenerateMipmap() { if (m_generate_mipmap && m_max_layer > 1) { glGenerateTextureMipmap(m_texture_id); m_generate_mipmap = false; } }
void kit::Texture::generateMipmap() { #ifndef KIT_SHITTY_INTEL glGenerateTextureMipmap(m_glHandle); #else bind(); glGenerateMipmap(m_type); #endif }
Texture::Texture(const Core::Image<unsigned char>& imageParameters, TextureFormat format) { glGenTextures(1, &m_id); glBindTexture(GL_TEXTURE_2D, m_id); glTexImage2D(GL_TEXTURE_2D, 0, format, imageParameters.m_Width, imageParameters.m_Height, 0, format, GL_UNSIGNED_BYTE, imageParameters.m_ImageData.data()); glGenerateTextureMipmap(m_id); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); //LowLevelAPI::GenerateTexture(m_id, imageParameters, format); //m_path = imageParameters.path; glBindTexture(GL_TEXTURE_2D, 0); }
static int glnvg__renderCreateTexture(void* uptr, int type, int w, int h, int imageFlags, const unsigned char* data) { GLNVGcontext* gl = (GLNVGcontext*)uptr; GLNVGtexture* tex = glnvg__allocTexture(gl); if (tex == NULL) return 0; const bool formatRGBA8 = type == NVG_TEXTURE_RGBA; const bool useMipmaps = (imageFlags & NVG_IMAGE_GENERATE_MIPMAPS) != 0; glCreateTextures(GL_TEXTURE_2D, 1, &tex->tex); const uint32_t mipCount = useMipmaps ? bit_fls(core::max<uint32_t>(w, h)) : 1; glTextureStorage2D(tex->tex, mipCount, formatRGBA8 ? GL_RGBA8 : GL_R8, w, h); tex->width = w; tex->height = h; tex->type = type; if (data) { glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glPixelStorei(GL_UNPACK_ROW_LENGTH, tex->width); glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0); glPixelStorei(GL_UNPACK_SKIP_ROWS, 0); glTextureSubImage2D(tex->tex, 0, 0, 0, w, h, formatRGBA8 ? GL_RGBA : GL_RED, GL_UNSIGNED_BYTE, data); glPixelStorei(GL_UNPACK_ALIGNMENT, 4); glPixelStorei(GL_UNPACK_ROW_LENGTH, 0); glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0); glPixelStorei(GL_UNPACK_SKIP_ROWS, 0); // The new way to build mipmaps on GLES and GL3 if (useMipmaps) { glGenerateTextureMipmap(tex->tex); } } glTextureParameteri(tex->tex, GL_TEXTURE_MIN_FILTER, useMipmaps ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR); glTextureParameteri(tex->tex, GL_TEXTURE_MAG_FILTER, GL_LINEAR); return tex->id; }
void TextureGL::GenMipChain() { glGenerateTextureMipmap( ID ); }
void kit::Texture::generateMipmap() { KIT_GL(glGenerateTextureMipmap(this->m_glHandle)); }
//[-------------------------------------------------------] //[ Public methods ] //[-------------------------------------------------------] Texture2DArrayDsa::Texture2DArrayDsa(OpenGLRenderer &openGLRenderer, uint32_t width, uint32_t height, uint32_t numberOfSlices, Renderer::TextureFormat::Enum textureFormat, const void *data, uint32_t flags) : Texture2DArray(openGLRenderer, width, height, numberOfSlices) { #ifndef OPENGLRENDERER_NO_STATE_CLEANUP // Backup the currently set alignment GLint openGLAlignmentBackup = 0; glGetIntegerv(GL_UNPACK_ALIGNMENT, &openGLAlignmentBackup); #endif // Set correct alignment glPixelStorei(GL_UNPACK_ALIGNMENT, 1); // Create the OpenGL texture instance const bool isARB_DSA = openGLRenderer.getExtensions().isGL_ARB_direct_state_access(); if (isARB_DSA) { glCreateTextures(GL_TEXTURE_2D_ARRAY_EXT, 1, &mOpenGLTexture); } else { glGenTextures(1, &mOpenGLTexture); } // Upload the base map of the texture (mipmaps are automatically created as soon as the base map is changed) if (isARB_DSA) { glTextureStorage3D(mOpenGLTexture, 1, Mapping::getOpenGLInternalFormat(textureFormat), static_cast<GLsizei>(width), static_cast<GLsizei>(height), static_cast<GLsizei>(numberOfSlices)); if (nullptr != data) { glTextureSubImage3D(mOpenGLTexture, 0, 0, 0, 0, static_cast<GLsizei>(width), static_cast<GLsizei>(height), static_cast<GLsizei>(numberOfSlices), Mapping::getOpenGLFormat(textureFormat), Mapping::getOpenGLType(textureFormat), data); } } else { glTextureImage3DEXT(mOpenGLTexture, GL_TEXTURE_2D_ARRAY_EXT, 0, static_cast<GLint>(Mapping::getOpenGLInternalFormat(textureFormat)), static_cast<GLsizei>(width), static_cast<GLsizei>(height), static_cast<GLsizei>(numberOfSlices), 0, Mapping::getOpenGLFormat(textureFormat), Mapping::getOpenGLType(textureFormat), data); } // Build mipmaps automatically on the GPU? (or GPU driver) if (flags & Renderer::TextureFlag::GENERATE_MIPMAPS) { if (isARB_DSA) { glGenerateTextureMipmap(mOpenGLTexture); glTextureParameteri(mOpenGLTexture, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST); } else { glGenerateTextureMipmapEXT(mOpenGLTexture, GL_TEXTURE_2D_ARRAY_EXT); glTextureParameteriEXT(mOpenGLTexture, GL_TEXTURE_2D_ARRAY_EXT, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST); } } else { if (isARB_DSA) { glTextureParameteri(mOpenGLTexture, GL_TEXTURE_MIN_FILTER, GL_LINEAR); } else { glTextureParameteriEXT(mOpenGLTexture, GL_TEXTURE_2D_ARRAY_EXT, GL_TEXTURE_MIN_FILTER, GL_LINEAR); } } if (isARB_DSA) { glTextureParameteri(mOpenGLTexture, GL_TEXTURE_MAG_FILTER, GL_LINEAR); } else { glTextureParameteriEXT(mOpenGLTexture, GL_TEXTURE_2D_ARRAY_EXT, GL_TEXTURE_MAG_FILTER, GL_LINEAR); } #ifndef OPENGLRENDERER_NO_STATE_CLEANUP // Restore previous alignment glPixelStorei(GL_UNPACK_ALIGNMENT, openGLAlignmentBackup); #endif }
Image2D::Image2D(std::string const &path) : AbstractTexture(GL_TEXTURE_2D, true, true) { ImageLoader il(path); GLsizei levels = log2(std::max(il.width(), il.height())) + 1; glTextureStorage2D(mId, levels, il.internalFormat(), il.width(), il.height()); glTextureSubImage2D(mId, 0, 0, 0, il.width(), il.height(), il.format(), GL_UNSIGNED_BYTE, il.data()); glGenerateTextureMipmap(mId); makeResident(); }