Windows-4.7.4/src/opengl/gl2paintengineex/qtextureglyphcache_gl.cpp - platform/external/qt - Git at Google

 /****************************************************************************
 **
 ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtOpenGL module of the Qt Toolkit.
 **
 ** $QT_BEGIN_LICENSE:LGPL$
 ** GNU Lesser General Public License Usage
 ** This file may be used under the terms of the GNU Lesser General Public
 ** License version 2.1 as published by the Free Software Foundation and
 ** appearing in the file LICENSE.LGPL included in the packaging of this
 ** file. Please review the following information to ensure the GNU Lesser
 ** General Public License version 2.1 requirements will be met:
 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
 ** In addition, as a special exception, Nokia gives you certain additional
 ** rights. These rights are described in the Nokia Qt LGPL Exception
 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
 ** Alternatively, this file may be used under the terms of the GNU General
 ** Public License version 3.0 as published by the Free Software Foundation
 ** and appearing in the file LICENSE.GPL included in the packaging of this
 ** file. Please review the following information to ensure the GNU General
 ** Public License version 3.0 requirements will be met:
 ** http://www.gnu.org/copyleft/gpl.html.
 **
 ** Other Usage
 ** Alternatively, this file may be used in accordance with the terms and
 ** conditions contained in a signed written agreement between you and Nokia.
 **
 **
 **
 **
 **
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/

 #include "qtextureglyphcache_gl_p.h"
 #include "qpaintengineex_opengl2_p.h"

 #if defined QT_OPENGL_ES_2 && !defined(QT_NO_EGL)
 #include "private/qeglcontext_p.h"
 #endif

 QT_BEGIN_NAMESPACE

 #ifdef Q_WS_WIN
 extern Q_GUI_EXPORT bool qt_cleartype_enabled;
 #endif

 QBasicAtomicInt qgltextureglyphcache_serial_number = Q_BASIC_ATOMIC_INITIALIZER(1);

 QGLTextureGlyphCache::QGLTextureGlyphCache(QGLContext *context, QFontEngineGlyphCache::Type type, const QTransform &matrix)
     : QImageTextureGlyphCache(type, matrix)
     , ctx(0)
     , m_width(0)
     , m_height(0)
     , m_filterMode(Nearest)
     , m_serialNumber(qgltextureglyphcache_serial_number.fetchAndAddRelaxed(1))
 {
     setContext(context);
 }

 void QGLTextureGlyphCache::setContext(QGLContext *context)
 {
     ctx = context;

     // broken FBO readback is a bug in the SGX 1.3 and 1.4 drivers for the N900 where
     // copying between FBO's is broken if the texture is either GL_ALPHA or POT. The
     // workaround is to use a system-memory copy of the glyph cache for this device.
     // Switching to NPOT and GL_RGBA would both cost a lot more graphics memory and
     // be slower, so that is not desireable.
     if (!ctx->d_ptr->workaround_brokenFBOReadBack)
         glGenFramebuffers(1, &m_fbo);

     connect(QGLSignalProxy::instance(), SIGNAL(aboutToDestroyContext(const QGLContext*)),
             SLOT(contextDestroyed(const QGLContext*)));
 }

 void QGLTextureGlyphCache::clear()
 {
     if (ctx) {
         QGLShareContextScope scope(ctx);

         if (m_width || m_height)
             glDeleteTextures(1, &m_texture);

         m_texture = 0;
         m_width = 0;
         m_height = 0;
         m_w = 0;
         m_h = 0;
         m_cx = 0;
         m_cy = 0;
         m_currentRowHeight = 0;
         coords.clear();
     }

 }

 QGLTextureGlyphCache::~QGLTextureGlyphCache()
 {
     if (ctx) {
         QGLShareContextScope scope(ctx);

         if (!ctx->d_ptr->workaround_brokenFBOReadBack)
             glDeleteFramebuffers(1, &m_fbo);
     }

     clear();
 }

 void QGLTextureGlyphCache::createTextureData(int width, int height)
 {
     // create in QImageTextureGlyphCache baseclass is meant to be called
     // only to create the initial image and does not preserve the content,
     // so we don't call when this function is called from resize.
     if (ctx->d_ptr->workaround_brokenFBOReadBack && image().isNull())
         QImageTextureGlyphCache::createTextureData(width, height);

     // Make the lower glyph texture size 16 x 16.
     if (width < 16)
         width = 16;
     if (height < 16)
         height = 16;

     glGenTextures(1, &m_texture);
     glBindTexture(GL_TEXTURE_2D, m_texture);

     m_width = width;
     m_height = height;

     if (m_type == QFontEngineGlyphCache::Raster_RGBMask) {
         QVarLengthArray<uchar> data(width * height * 4);
         for (int i = 0; i < data.size(); ++i)
             data[i] = 0;
         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, &data[0]);
     } else {
         QVarLengthArray<uchar> data(width * height);
         for (int i = 0; i < data.size(); ++i)
             data[i] = 0;
         glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, width, height, 0, GL_ALPHA, GL_UNSIGNED_BYTE, &data[0]);
     }

     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     m_filterMode = Nearest;
 }

 void QGLTextureGlyphCache::resizeTextureData(int width, int height)
 {
     int oldWidth = m_width;
     int oldHeight = m_height;

     // Make the lower glyph texture size 16 x 16.
     if (width < 16)
         width = 16;
     if (height < 16)
         height = 16;

     GLuint oldTexture = m_texture;
     createTextureData(width, height);

     if (ctx->d_ptr->workaround_brokenFBOReadBack) {
         QImageTextureGlyphCache::resizeTextureData(width, height);
         Q_ASSERT(image().depth() == 8);
         glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, oldHeight, GL_ALPHA, GL_UNSIGNED_BYTE, image().constBits());
         glDeleteTextures(1, &oldTexture);
         return;
     }

     // ### the QTextureGlyphCache API needs to be reworked to allow
     // ### resizeTextureData to fail

     glBindFramebuffer(GL_FRAMEBUFFER_EXT, m_fbo);

     GLuint tmp_texture;
     glGenTextures(1, &tmp_texture);
     glBindTexture(GL_TEXTURE_2D, tmp_texture);
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, oldWidth, oldHeight, 0,
                  GL_RGBA, GL_UNSIGNED_BYTE, NULL);
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     m_filterMode = Nearest;
     glBindTexture(GL_TEXTURE_2D, 0);
     glFramebufferTexture2D(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
                            GL_TEXTURE_2D, tmp_texture, 0);

     glActiveTexture(GL_TEXTURE0 + QT_IMAGE_TEXTURE_UNIT);
     glBindTexture(GL_TEXTURE_2D, oldTexture);

     pex->transferMode(BrushDrawingMode);

     glDisable(GL_STENCIL_TEST);
     glDisable(GL_DEPTH_TEST);
     glDisable(GL_SCISSOR_TEST);
     glDisable(GL_BLEND);

     glViewport(0, 0, oldWidth, oldHeight);

     GLfloat* vertexCoordinateArray = pex->staticVertexCoordinateArray;
     vertexCoordinateArray[0] = -1.0f;
     vertexCoordinateArray[1] = -1.0f;
     vertexCoordinateArray[2] =  1.0f;
     vertexCoordinateArray[3] = -1.0f;
     vertexCoordinateArray[4] =  1.0f;
     vertexCoordinateArray[5] =  1.0f;
     vertexCoordinateArray[6] = -1.0f;
     vertexCoordinateArray[7] =  1.0f;

     GLfloat* textureCoordinateArray = pex->staticTextureCoordinateArray;
     textureCoordinateArray[0] = 0.0f;
     textureCoordinateArray[1] = 0.0f;
     textureCoordinateArray[2] = 1.0f;
     textureCoordinateArray[3] = 0.0f;
     textureCoordinateArray[4] = 1.0f;
     textureCoordinateArray[5] = 1.0f;
     textureCoordinateArray[6] = 0.0f;
     textureCoordinateArray[7] = 1.0f;

     pex->setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, vertexCoordinateArray);
     pex->setVertexAttributePointer(QT_TEXTURE_COORDS_ATTR, textureCoordinateArray);

     pex->shaderManager->useBlitProgram();
     pex->shaderManager->blitProgram()->setUniformValue("imageTexture", QT_IMAGE_TEXTURE_UNIT);

     glDrawArrays(GL_TRIANGLE_FAN, 0, 4);

     glBindTexture(GL_TEXTURE_2D, m_texture);

     glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, oldWidth, oldHeight);

     glFramebufferRenderbuffer(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
                               GL_RENDERBUFFER_EXT, 0);
     glDeleteTextures(1, &tmp_texture);
     glDeleteTextures(1, &oldTexture);

     glBindFramebuffer(GL_FRAMEBUFFER_EXT, ctx->d_ptr->current_fbo);

     glViewport(0, 0, pex->width, pex->height);
     pex->updateClipScissorTest();
 }

 void QGLTextureGlyphCache::fillTexture(const Coord &c, glyph_t glyph)
 {
     if (ctx->d_ptr->workaround_brokenFBOReadBack) {
         QImageTextureGlyphCache::fillTexture(c, glyph);

         glBindTexture(GL_TEXTURE_2D, m_texture);
         const QImage &texture = image();
         const uchar *bits = texture.constBits();
         bits += c.y * texture.bytesPerLine() + c.x;
         for (int i=0; i<c.h; ++i) {
             glTexSubImage2D(GL_TEXTURE_2D, 0, c.x, c.y + i, c.w, 1, GL_ALPHA, GL_UNSIGNED_BYTE, bits);
             bits += texture.bytesPerLine();
         }

         return;
     }

     QImage mask = textureMapForGlyph(glyph);
     const int maskWidth = mask.width();
     const int maskHeight = mask.height();

     if (mask.format() == QImage::Format_Mono) {
         mask = mask.convertToFormat(QImage::Format_Indexed8);
         for (int y = 0; y < maskHeight; ++y) {
             uchar *src = (uchar *) mask.scanLine(y);
             for (int x = 0; x < maskWidth; ++x)
                 src[x] = -src[x]; // convert 0 and 1 into 0 and 255
         }
     } else if (mask.format() == QImage::Format_RGB32) {
         // Make the alpha component equal to the average of the RGB values.
         // This is needed when drawing sub-pixel antialiased text on translucent targets.
         for (int y = 0; y < maskHeight; ++y) {
             quint32 *src = (quint32 *) mask.scanLine(y);
             for (int x = 0; x < maskWidth; ++x) {
                 uchar r = src[x] >> 16;
                 uchar g = src[x] >> 8;
                 uchar b = src[x];
                 quint32 avg = (quint32(r) + quint32(g) + quint32(b) + 1) / 3; // "+1" for rounding.
                 src[x] = (src[x] & 0x00ffffff) | (avg << 24);
             }
         }
     }

     glBindTexture(GL_TEXTURE_2D, m_texture);
     if (mask.format() == QImage::Format_RGB32) {
         glTexSubImage2D(GL_TEXTURE_2D, 0, c.x, c.y, maskWidth, maskHeight, GL_BGRA, GL_UNSIGNED_BYTE, mask.bits());
     } else {
         // glTexSubImage2D() might cause some garbage to appear in the texture if the mask width is
         // not a multiple of four bytes. The bug appeared on a computer with 32-bit Windows Vista
         // and nVidia GeForce 8500GT. GL_UNPACK_ALIGNMENT is set to four bytes, 'mask' has a
         // multiple of four bytes per line, and most of the glyph shows up correctly in the
         // texture, which makes me think that this is a driver bug.
         // One workaround is to make sure the mask width is a multiple of four bytes, for instance
         // by converting it to a format with four bytes per pixel. Another is to copy one line at a
         // time.

         for (int i = 0; i < maskHeight; ++i)
             glTexSubImage2D(GL_TEXTURE_2D, 0, c.x, c.y + i, qMin(c.w, maskWidth), 1, GL_ALPHA, GL_UNSIGNED_BYTE, mask.scanLine(i));
     }
 }

 int QGLTextureGlyphCache::glyphPadding() const
 {
     return 1;
 }

 int QGLTextureGlyphCache::maxTextureWidth() const
 {
     return ctx->d_ptr->maxTextureSize();
 }

 int QGLTextureGlyphCache::maxTextureHeight() const
 {
     if (ctx->d_ptr->workaround_brokenTexSubImage)
         return qMin(1024, ctx->d_ptr->maxTextureSize());
     else
         return ctx->d_ptr->maxTextureSize();
 }
 QT_END_NAMESPACE
	/****************************************************************************
	**
	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
	** All rights reserved.
	** Contact: Nokia Corporation (qt-info@nokia.com)
	**
	** This file is part of the QtOpenGL module of the Qt Toolkit.
	**
	** $QT_BEGIN_LICENSE:LGPL$
	** GNU Lesser General Public License Usage
	** This file may be used under the terms of the GNU Lesser General Public
	** License version 2.1 as published by the Free Software Foundation and
	** appearing in the file LICENSE.LGPL included in the packaging of this
	** file. Please review the following information to ensure the GNU Lesser
	** General Public License version 2.1 requirements will be met:
	** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
	**
	** In addition, as a special exception, Nokia gives you certain additional
	** rights. These rights are described in the Nokia Qt LGPL Exception
	** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
	**
	** GNU General Public License Usage
	** Alternatively, this file may be used under the terms of the GNU General
	** Public License version 3.0 as published by the Free Software Foundation
	** and appearing in the file LICENSE.GPL included in the packaging of this
	** file. Please review the following information to ensure the GNU General
	** Public License version 3.0 requirements will be met:
	** http://www.gnu.org/copyleft/gpl.html.
	**
	** Other Usage
	** Alternatively, this file may be used in accordance with the terms and
	** conditions contained in a signed written agreement between you and Nokia.
	**
	**
	**
	**
	**
	** $QT_END_LICENSE$
	**
	****************************************************************************/

	#include "qtextureglyphcache_gl_p.h"
	#include "qpaintengineex_opengl2_p.h"

	#if defined QT_OPENGL_ES_2 && !defined(QT_NO_EGL)
	#include "private/qeglcontext_p.h"
	#endif

	QT_BEGIN_NAMESPACE

	#ifdef Q_WS_WIN
	extern Q_GUI_EXPORT bool qt_cleartype_enabled;
	#endif

	QBasicAtomicInt qgltextureglyphcache_serial_number = Q_BASIC_ATOMIC_INITIALIZER(1);

	QGLTextureGlyphCache::QGLTextureGlyphCache(QGLContext *context, QFontEngineGlyphCache::Type type, const QTransform &matrix)
	: QImageTextureGlyphCache(type, matrix)
	, ctx(0)
	, m_width(0)
	, m_height(0)
	, m_filterMode(Nearest)
	, m_serialNumber(qgltextureglyphcache_serial_number.fetchAndAddRelaxed(1))
	{
	setContext(context);
	}

	void QGLTextureGlyphCache::setContext(QGLContext *context)
	{
	ctx = context;

	// broken FBO readback is a bug in the SGX 1.3 and 1.4 drivers for the N900 where
	// copying between FBO's is broken if the texture is either GL_ALPHA or POT. The
	// workaround is to use a system-memory copy of the glyph cache for this device.
	// Switching to NPOT and GL_RGBA would both cost a lot more graphics memory and
	// be slower, so that is not desireable.
	if (!ctx->d_ptr->workaround_brokenFBOReadBack)
	glGenFramebuffers(1, &m_fbo);

	connect(QGLSignalProxy::instance(), SIGNAL(aboutToDestroyContext(const QGLContext*)),
	SLOT(contextDestroyed(const QGLContext*)));
	}

	void QGLTextureGlyphCache::clear()
	{
	if (ctx) {
	QGLShareContextScope scope(ctx);

	if (m_width \|\| m_height)
	glDeleteTextures(1, &m_texture);

	m_texture = 0;
	m_width = 0;
	m_height = 0;
	m_w = 0;
	m_h = 0;
	m_cx = 0;
	m_cy = 0;
	m_currentRowHeight = 0;
	coords.clear();
	}

	}

	QGLTextureGlyphCache::~QGLTextureGlyphCache()
	{
	if (ctx) {
	QGLShareContextScope scope(ctx);

	if (!ctx->d_ptr->workaround_brokenFBOReadBack)
	glDeleteFramebuffers(1, &m_fbo);
	}

	clear();
	}

	void QGLTextureGlyphCache::createTextureData(int width, int height)
	{
	// create in QImageTextureGlyphCache baseclass is meant to be called
	// only to create the initial image and does not preserve the content,
	// so we don't call when this function is called from resize.
	if (ctx->d_ptr->workaround_brokenFBOReadBack && image().isNull())
	QImageTextureGlyphCache::createTextureData(width, height);

	// Make the lower glyph texture size 16 x 16.
	if (width < 16)
	width = 16;
	if (height < 16)
	height = 16;

	glGenTextures(1, &m_texture);
	glBindTexture(GL_TEXTURE_2D, m_texture);

	m_width = width;
	m_height = height;

	if (m_type == QFontEngineGlyphCache::Raster_RGBMask) {
	QVarLengthArray<uchar> data(width * height * 4);
	for (int i = 0; i < data.size(); ++i)
	data[i] = 0;
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, &data[0]);
	} else {
	QVarLengthArray<uchar> data(width * height);
	for (int i = 0; i < data.size(); ++i)
	data[i] = 0;
	glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, width, height, 0, GL_ALPHA, GL_UNSIGNED_BYTE, &data[0]);
	}

	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	m_filterMode = Nearest;
	}

	void QGLTextureGlyphCache::resizeTextureData(int width, int height)
	{
	int oldWidth = m_width;
	int oldHeight = m_height;

	// Make the lower glyph texture size 16 x 16.
	if (width < 16)
	width = 16;
	if (height < 16)
	height = 16;

	GLuint oldTexture = m_texture;
	createTextureData(width, height);

	if (ctx->d_ptr->workaround_brokenFBOReadBack) {
	QImageTextureGlyphCache::resizeTextureData(width, height);
	Q_ASSERT(image().depth() == 8);
	glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, oldHeight, GL_ALPHA, GL_UNSIGNED_BYTE, image().constBits());
	glDeleteTextures(1, &oldTexture);
	return;
	}

	// ### the QTextureGlyphCache API needs to be reworked to allow
	// ### resizeTextureData to fail

	glBindFramebuffer(GL_FRAMEBUFFER_EXT, m_fbo);

	GLuint tmp_texture;
	glGenTextures(1, &tmp_texture);
	glBindTexture(GL_TEXTURE_2D, tmp_texture);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, oldWidth, oldHeight, 0,
	GL_RGBA, GL_UNSIGNED_BYTE, NULL);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	m_filterMode = Nearest;
	glBindTexture(GL_TEXTURE_2D, 0);
	glFramebufferTexture2D(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
	GL_TEXTURE_2D, tmp_texture, 0);

	glActiveTexture(GL_TEXTURE0 + QT_IMAGE_TEXTURE_UNIT);
	glBindTexture(GL_TEXTURE_2D, oldTexture);

	pex->transferMode(BrushDrawingMode);

	glDisable(GL_STENCIL_TEST);
	glDisable(GL_DEPTH_TEST);
	glDisable(GL_SCISSOR_TEST);
	glDisable(GL_BLEND);

	glViewport(0, 0, oldWidth, oldHeight);

	GLfloat* vertexCoordinateArray = pex->staticVertexCoordinateArray;
	vertexCoordinateArray[0] = -1.0f;
	vertexCoordinateArray[1] = -1.0f;
	vertexCoordinateArray[2] = 1.0f;
	vertexCoordinateArray[3] = -1.0f;
	vertexCoordinateArray[4] = 1.0f;
	vertexCoordinateArray[5] = 1.0f;
	vertexCoordinateArray[6] = -1.0f;
	vertexCoordinateArray[7] = 1.0f;

	GLfloat* textureCoordinateArray = pex->staticTextureCoordinateArray;
	textureCoordinateArray[0] = 0.0f;
	textureCoordinateArray[1] = 0.0f;
	textureCoordinateArray[2] = 1.0f;
	textureCoordinateArray[3] = 0.0f;
	textureCoordinateArray[4] = 1.0f;
	textureCoordinateArray[5] = 1.0f;
	textureCoordinateArray[6] = 0.0f;
	textureCoordinateArray[7] = 1.0f;

	pex->setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, vertexCoordinateArray);
	pex->setVertexAttributePointer(QT_TEXTURE_COORDS_ATTR, textureCoordinateArray);

	pex->shaderManager->useBlitProgram();
	pex->shaderManager->blitProgram()->setUniformValue("imageTexture", QT_IMAGE_TEXTURE_UNIT);

	glDrawArrays(GL_TRIANGLE_FAN, 0, 4);

	glBindTexture(GL_TEXTURE_2D, m_texture);

	glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, oldWidth, oldHeight);

	glFramebufferRenderbuffer(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
	GL_RENDERBUFFER_EXT, 0);
	glDeleteTextures(1, &tmp_texture);
	glDeleteTextures(1, &oldTexture);

	glBindFramebuffer(GL_FRAMEBUFFER_EXT, ctx->d_ptr->current_fbo);

	glViewport(0, 0, pex->width, pex->height);
	pex->updateClipScissorTest();
	}

	void QGLTextureGlyphCache::fillTexture(const Coord &c, glyph_t glyph)
	{
	if (ctx->d_ptr->workaround_brokenFBOReadBack) {
	QImageTextureGlyphCache::fillTexture(c, glyph);

	glBindTexture(GL_TEXTURE_2D, m_texture);
	const QImage &texture = image();
	const uchar *bits = texture.constBits();
	bits += c.y * texture.bytesPerLine() + c.x;
	for (int i=0; i<c.h; ++i) {
	glTexSubImage2D(GL_TEXTURE_2D, 0, c.x, c.y + i, c.w, 1, GL_ALPHA, GL_UNSIGNED_BYTE, bits);
	bits += texture.bytesPerLine();
	}

	return;
	}

	QImage mask = textureMapForGlyph(glyph);
	const int maskWidth = mask.width();
	const int maskHeight = mask.height();

	if (mask.format() == QImage::Format_Mono) {
	mask = mask.convertToFormat(QImage::Format_Indexed8);
	for (int y = 0; y < maskHeight; ++y) {
	uchar src = (uchar ) mask.scanLine(y);
	for (int x = 0; x < maskWidth; ++x)
	src[x] = -src[x]; // convert 0 and 1 into 0 and 255
	}
	} else if (mask.format() == QImage::Format_RGB32) {
	// Make the alpha component equal to the average of the RGB values.
	// This is needed when drawing sub-pixel antialiased text on translucent targets.
	for (int y = 0; y < maskHeight; ++y) {
	quint32 src = (quint32 ) mask.scanLine(y);
	for (int x = 0; x < maskWidth; ++x) {
	uchar r = src[x] >> 16;
	uchar g = src[x] >> 8;
	uchar b = src[x];
	quint32 avg = (quint32(r) + quint32(g) + quint32(b) + 1) / 3; // "+1" for rounding.
	src[x] = (src[x] & 0x00ffffff) \| (avg << 24);
	}
	}
	}

	glBindTexture(GL_TEXTURE_2D, m_texture);
	if (mask.format() == QImage::Format_RGB32) {
	glTexSubImage2D(GL_TEXTURE_2D, 0, c.x, c.y, maskWidth, maskHeight, GL_BGRA, GL_UNSIGNED_BYTE, mask.bits());
	} else {
	// glTexSubImage2D() might cause some garbage to appear in the texture if the mask width is
	// not a multiple of four bytes. The bug appeared on a computer with 32-bit Windows Vista
	// and nVidia GeForce 8500GT. GL_UNPACK_ALIGNMENT is set to four bytes, 'mask' has a
	// multiple of four bytes per line, and most of the glyph shows up correctly in the
	// texture, which makes me think that this is a driver bug.
	// One workaround is to make sure the mask width is a multiple of four bytes, for instance
	// by converting it to a format with four bytes per pixel. Another is to copy one line at a
	// time.

	for (int i = 0; i < maskHeight; ++i)
	glTexSubImage2D(GL_TEXTURE_2D, 0, c.x, c.y + i, qMin(c.w, maskWidth), 1, GL_ALPHA, GL_UNSIGNED_BYTE, mask.scanLine(i));
	}
	}

	int QGLTextureGlyphCache::glyphPadding() const
	{
	return 1;
	}

	int QGLTextureGlyphCache::maxTextureWidth() const
	{
	return ctx->d_ptr->maxTextureSize();
	}

	int QGLTextureGlyphCache::maxTextureHeight() const
	{
	if (ctx->d_ptr->workaround_brokenTexSubImage)
	return qMin(1024, ctx->d_ptr->maxTextureSize());
	else
	return ctx->d_ptr->maxTextureSize();
	}
	QT_END_NAMESPACE