void c3_exercise_1::loadTextures(std::array<GLuint, 2> &textures, GLuint shaderProgram)
{
glGenTextures(2, textures.data());
int width, height;
unsigned char *image;
std::string basePath = getBasePath();
std::string kittenTexPath = basePath + "Content\\sample.png";
std::string puppyTexPath = basePath + "Content\\sample2.png";
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, textures[0]);
image = SOIL_load_image(kittenTexPath.c_str(), &width, &height, 0, SOIL_LOAD_RGB);
printf("%s\n", SOIL_last_result());
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, image);
SOIL_free_image_data(image);
glUniform1i(glGetUniformLocation(shaderProgram, "texKitten"), 0);
setTextureParameters();
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, textures[1]);
image = SOIL_load_image(puppyTexPath.c_str(), &width, &height, 0, SOIL_LOAD_RGB);
printf("%s\n", SOIL_last_result());
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, image);
SOIL_free_image_data(image);
glUniform1i(glGetUniformLocation(shaderProgram, "texPuppy"), 1);
setTextureParameters();
}
Texture::Texture(const std::string& path, TextureType type): _path(path) {
// Default => empty texture
if(path.empty()){
setTextureParameters(type);
return;
}
loadImage(path);
setTextureParameters(TextureType::FROM_FILE);
}
Texture* Texture::createEmpty(
std::pair<size_t, size_t> dimensions,
Texture::Format format,
Texture::Filter filter, Texture::Wrap wrap) {
Texture* self = new Texture();
ScopedBind bind(*self);
setTextureParameters(filter, wrap);
int width = dimensions.first;
int height = dimensions.second;
GLuint internalformat;
if(!getInternalFormat(format, internalformat)) {
Log.warn() << "unknown format parameter (" << format << "), using RGBA8";
internalformat = GL_RGBA8;
}
glTexImage2D(GL_TEXTURE_2D, 0, internalformat, width, height, 0,
GL_RGBA, GL_UNSIGNED_BYTE, 0);
return self;
}
bool YUV420PGrabber::setupTextures() {
//assert(win_w && win_h && vid_w && vid_h && yuv_tex == 0);
assert(win_w && win_h && yuv_tex == 0);
assert(tex_w && tex_h); // setupTextures() must be called -after- setupSizes()
glGenTextures(1, &scene_tex);
glBindTexture(GL_TEXTURE_2D, scene_tex);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, tex_w, tex_h, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
setTextureParameters();
glGenTextures(1, &yuv_tex);
glBindTexture(GL_TEXTURE_2D, yuv_tex);
glTexImage2D(GL_TEXTURE_2D, 0, GL_R8, tex_w, tex_h, 0, GL_RED, GL_UNSIGNED_BYTE, NULL);
setTextureParameters();
return true;
}
//TODO move this into a separate centralized texture management class
void QWaylandBufferMaterial::ensureTextures(int count)
{
QOpenGLFunctions *gl = QOpenGLContext::currentContext()->functions();
const GLenum target = bufferTypes[m_format].textureTarget;
GLuint texture;
for (int plane = m_textures.size(); plane < count; plane++) {
gl->glGenTextures(1, &texture);
gl->glBindTexture(target, texture);
setTextureParameters(target);
m_textures << texture;
}
}
KisTextureTile::KisTextureTile(QRect imageRect, const KisGLTexturesInfo *texturesInfo,
const QByteArray &fillData, FilterMode filter)
: m_textureId(0)
#ifdef USE_PIXEL_BUFFERS
, m_glBuffer(0)
#endif
, m_tileRectInImagePixels(imageRect)
, m_filter(filter)
, m_texturesInfo(texturesInfo)
, m_needsMipmapRegeneration(false)
{
const GLvoid *fd = fillData.constData();
m_textureRectInImagePixels =
stretchRect(m_tileRectInImagePixels, texturesInfo->border);
m_tileRectInTexturePixels = relativeRect(m_textureRectInImagePixels,
m_tileRectInImagePixels,
m_texturesInfo);
glGenTextures(1, &m_textureId);
glBindTexture(GL_TEXTURE_2D, m_textureId);
setTextureParameters();
#ifdef USE_PIXEL_BUFFERS
createTextureBuffer(fillData);
// we set fill data to 0 so the next glTexImage2D call uses our buffer
fd = 0;
#endif
glTexImage2D(GL_TEXTURE_2D, 0,
m_texturesInfo->internalFormat,
m_texturesInfo->width,
m_texturesInfo->height, 0,
m_texturesInfo->format,
m_texturesInfo->type, fd);
#ifdef USE_PIXEL_BUFFERS
KisConfig cfg;
if (cfg.useOpenGLTextureBuffer()) {
m_glBuffer->release();
}
#endif
setNeedsMipmapRegeneration();
}
Texture* Texture::fromImage(
boost::shared_ptr<Image> image,
Texture::Format format,
Texture::Filter filter,
Texture::Wrap wrap) {
Texture* self = new Texture();
ScopedBind bind(*self);
setTextureParameters(filter, wrap);
GLuint internalformat;
GLuint sourceformat;
if(!getInternalFormat(format, internalformat)) {
Log.warn() << "unknown format parameter (" << format << "), using no image";
return self;
}
if(image) {
switch(image->getFormat()) {
case Image::RGB:
sourceformat = GL_RGB;
break;
case Image::RGBA:
sourceformat = GL_RGBA;
break;
default:
Log.warn() << "unknown source format (" << image->getFormat() << "), using no image";
return self;
}
glTexImage2D(GL_TEXTURE_2D, 0, internalformat, image->getWidth(), image->getHeight(), 0,
sourceformat, GL_UNSIGNED_BYTE, image->getData().get());
} else {
Log.debug() << "NULL image, returning an empty texture";
}
return self;
}
void QWaylandBufferMaterial::setTextureForPlane(int plane, uint texture)
{
if (plane < 0 || plane >= bufferTypes[m_format].planeCount) {
qWarning("plane index is out of range");
return;
}
QOpenGLFunctions *gl = QOpenGLContext::currentContext()->functions();
const GLenum target = bufferTypes[m_format].textureTarget;
gl->glBindTexture(target, texture);
setTextureParameters(target);
ensureTextures(plane - 1);
if (m_textures.size() <= plane) {
m_textures << texture;
} else {
std::swap(m_textures[plane], texture);
gl->glDeleteTextures(1, &texture);
}
}
void CC3PVRTexture::bindTextureContent( CC3PVRTextureContent* texContent, GLenum target )
{
if (!texContent)
return;
deleteGLTexture(); // Delete any existing texture in the GL engine
_textureID = texContent->getTextureID();
_size = texContent->getSize();
_hasMipmap = texContent->hasMipmap();
_hasPremultipliedAlpha = texContent->hasPremultipliedAlpha();
_isTextureCube = texContent->isTextureCube();
_coverage = CCSizeMake(1.0f, 1.0f); // PVR textures are always POT
_pixelFormat = texContent->getPixelFormat();
_pixelType = texContent->getPixelType();
//LogTrace(@"Bound PVR texture ID %u", _textureID);
// Update the texture parameters depending on whether the PVR file is 2D or cube-map.
setTextureParameters( isTextureCube()
? CC3TextureCube::defaultTextureParameters()
: CC3Texture2D::defaultTextureParameters() );
}
TextureHandle TextureManager::loadTexture(const std::string& name) {
// Check if texture has already been loaded.
TextureHandle existing = getLoadedResource(name);
if (existing.valid())
return existing;
std::string texture_filename;
Texture::FilterMode filter_mode = Texture::FilterMode::LINEAR;
Texture::RepeatMode repeat_mode = Texture::RepeatMode::WRAP;
int channels = 4;
HSQUIRRELVM vm = ::hw::engine::script_engine->vm;
sq_pushroottable(vm);
loadVariablePath(vm, "Resources^TextureInfo^" + name);
const SQChar* tex_filename_cstr;
CSQ(getKey(vm, "filename"));
sq_getstring(vm, -1, &tex_filename_cstr);
sq_poptop(vm);
texture_filename = tex_filename_cstr;
if (SQ_SUCCEEDED(getKey(vm, "channels"))) {
sq_getinteger(vm, -1, &channels);
sq_poptop(vm);
}
if (SQ_SUCCEEDED(getKey(vm, "filter_mode"))) {
SQInteger tmp;
sq_getinteger(vm, -1, &tmp);
sq_poptop(vm);
filter_mode = Texture::FilterMode(tmp);
}
if (SQ_SUCCEEDED(getKey(vm, "repeat_mode"))) {
SQInteger tmp;
sq_getinteger(vm, -1, &tmp);
sq_poptop(vm);
repeat_mode = Texture::RepeatMode(tmp);
}
texture_filename = "data/" + texture_filename;
if (texture_filename.empty()) {
return TextureHandle();
}
gl::Texture new_tex;
glGenTextures(1, &new_tex.name);
glBindTexture(GL_TEXTURE_2D, new_tex.name);
setTextureParameters(filter_mode, repeat_mode);
assert(channels >= 1 && channels <= 4);
static const GLint internal_formats[4] = {GL_RED, GL_RG, GL_RGB, GL_RGBA};
GLint gl_format = internal_formats[channels-1];
int width, height, comp;
unsigned char* data = stbi_load(texture_filename.c_str(), &width, &height, &comp, channels);
if (data == nullptr) {
return TextureHandle();
}
glTexImage2D(GL_TEXTURE_2D, 0, gl_format, width, height, 0, gl_format, GL_UNSIGNED_BYTE, data);
return constructResource(name, Texture(std::move(new_tex), name, width, height));
}
void KisTextureTile::update(const KisTextureTileUpdateInfo &updateInfo)
{
glBindTexture(GL_TEXTURE_2D, m_textureId);
setTextureParameters();
const GLvoid *fd = updateInfo.data();
#ifdef USE_PIXEL_BUFFERS
KisConfig cfg;
if (!m_glBuffer) {
QByteArray ba;
ba.fromRawData((const char*)updateInfo.data(), updateInfo.patchPixelsLength());
createTextureBuffer(ba);
}
#endif
if (updateInfo.isEntireTileUpdated()) {
#ifdef USE_PIXEL_BUFFERS
if (cfg.useOpenGLTextureBuffer()) {
m_glBuffer->bind();
m_glBuffer->allocate(updateInfo.patchPixelsLength());
void *vid = m_glBuffer->map(QGLBuffer::WriteOnly);
memcpy(vid, fd, updateInfo.patchPixelsLength());
m_glBuffer->unmap();
// we set fill data to 0 so the next glTexImage2D call uses our buffer
fd = 0;
}
#endif
glTexImage2D(GL_TEXTURE_2D, 0,
m_texturesInfo->internalFormat,
m_texturesInfo->width,
m_texturesInfo->height, 0,
m_texturesInfo->format,
m_texturesInfo->type,
fd);
#ifdef USE_PIXEL_BUFFERS
if (cfg.useOpenGLTextureBuffer()) {
m_glBuffer->release();
}
#endif
}
else {
QPoint patchOffset = updateInfo.patchOffset();
QSize patchSize = updateInfo.patchSize();
#ifdef USE_PIXEL_BUFFERS
if (cfg.useOpenGLTextureBuffer()) {
m_glBuffer->bind();
quint32 size = patchSize.width() * patchSize.height() * updateInfo.pixelSize();
m_glBuffer->allocate(size);
void *vid = m_glBuffer->map(QGLBuffer::WriteOnly);
memcpy(vid, fd, size);
m_glBuffer->unmap();
// we set fill data to 0 so the next glTexImage2D call uses our buffer
fd = 0;
}
#endif
glTexSubImage2D(GL_TEXTURE_2D, 0,
patchOffset.x(), patchOffset.y(),
patchSize.width(), patchSize.height(),
m_texturesInfo->format,
m_texturesInfo->type,
fd);
#ifdef USE_PIXEL_BUFFERS
if (cfg.useOpenGLTextureBuffer()) {
m_glBuffer->release();
}
#endif
}
/**
* On the boundaries of KisImage, there is a border-effect as well.
* So we just repeat the bounding pixels of the image to make
* bilinear interpolator happy.
*/
/**
* WARN: The width of the stripes will be equal to the broder
* width of the tiles.
*/
const int pixelSize = updateInfo.pixelSize();
const QRect imageRect = updateInfo.imageRect();
const QPoint patchOffset = updateInfo.patchOffset();
const QSize patchSize = updateInfo.patchSize();
const QRect patchRect = QRect(m_textureRectInImagePixels.topLeft() +
patchOffset,
patchSize);
const QSize tileSize = updateInfo.tileRect().size();
if(imageRect.top() == patchRect.top()) {
int start = 0;
int end = patchOffset.y() - 1;
for (int i = start; i <= end; i++) {
glTexSubImage2D(GL_TEXTURE_2D, 0,
patchOffset.x(), i,
patchSize.width(), 1,
m_texturesInfo->format,
m_texturesInfo->type,
updateInfo.data());
}
}
if (imageRect.bottom() == patchRect.bottom()) {
int shift = patchSize.width() * (patchSize.height() - 1) *
pixelSize;
int start = patchOffset.y() + patchSize.height();
int end = tileSize.height() - 1;
for (int i = start; i < end; i++) {
glTexSubImage2D(GL_TEXTURE_2D, 0,
patchOffset.x(), i,
patchSize.width(), 1,
m_texturesInfo->format,
m_texturesInfo->type,
updateInfo.data() + shift);
}
}
if (imageRect.left() == patchRect.left()) {
QByteArray columnBuffer(patchSize.height() * pixelSize, 0);
quint8 *srcPtr = updateInfo.data();
quint8 *dstPtr = (quint8*) columnBuffer.data();
for(int i = 0; i < patchSize.height(); i++) {
memcpy(dstPtr, srcPtr, pixelSize);
srcPtr += patchSize.width() * pixelSize;
dstPtr += pixelSize;
}
int start = 0;
int end = patchOffset.x() - 1;
for (int i = start; i <= end; i++) {
glTexSubImage2D(GL_TEXTURE_2D, 0,
i, patchOffset.y(),
1, patchSize.height(),
m_texturesInfo->format,
m_texturesInfo->type,
columnBuffer.constData());
}
}
if (imageRect.right() == patchRect.right()) {
QByteArray columnBuffer(patchSize.height() * pixelSize, 0);
quint8 *srcPtr = updateInfo.data() + (patchSize.width() - 1) * pixelSize;
quint8 *dstPtr = (quint8*) columnBuffer.data();
for(int i = 0; i < patchSize.height(); i++) {
memcpy(dstPtr, srcPtr, pixelSize);
srcPtr += patchSize.width() * pixelSize;
dstPtr += pixelSize;
}
int start = patchOffset.x() + patchSize.width();
int end = tileSize.width() - 1;
for (int i = start; i <= end; i++) {
glTexSubImage2D(GL_TEXTURE_2D, 0,
i, patchOffset.y(),
1, patchSize.height(),
m_texturesInfo->format,
m_texturesInfo->type,
columnBuffer.constData());
}
}
setNeedsMipmapRegeneration();
}
Texture::Texture(int width, int height, TextureType fboType):_width(width), _height(height), _type(fboType) {
setTextureParameters(fboType);
}
