#include "qtofflinegl.h"
#include <traster.h>
#include <tconvert.h>
//-----------------------------------------------------------------------------
#ifdef WIN32
void swapRedBlueChannels(void *buffer, int bufferSize) // Flips The Red And Blue Bytes (WidthxHeight)
{
void *b = buffer; // Pointer To The Buffer
#ifdef x64
int size = bufferSize;
UCHAR *pix = (UCHAR *)b;
while (size > 0) {
UCHAR r = *pix;
UCHAR b = *(pix + 2);
*pix = b;
*(pix + 2) = r;
pix += 4;
size--;
}
#else
__asm // Assembler Code To Follow
{
mov ecx, bufferSize // Counter Set To Dimensions Of Our Memory Block
mov ebx, b // Points ebx To Our Data (b)
label: // Label Used For Looping
mov al,[ebx+0] // Loads Value At ebx Into al
mov ah,[ebx+2] // Loads Value At ebx+2 Into ah
mov [ebx+2],al // Stores Value In al At ebx+2
mov [ebx+0],ah // Stores Value In ah At ebx
add ebx,4 // Moves Through The Data By 4 Bytes
dec ecx // Decreases Our Loop Counter
jnz label // If Not Zero Jump Back To Label
}
#endif
}
#endif
//-----------------------------------------------------------------------------
#if defined(MACOSX)
#if defined(powerpc)
void rightRotateBits(UCHAR *buf, int bufferSize)
{
UINT *buffer = (UINT *)buf;
register UINT app;
for (int i = 0; i < bufferSize; i++, buffer++) {
app = *buffer;
*buffer = app >> 8 | app << 24;
}
}
#else
void rightRotateBits(UCHAR *buf, int bufferSize)
{
UINT *buffer = (UINT *)buf;
register UINT app;
for (int i = 0; i < bufferSize; i++, buffer++) {
app = *buffer;
*buffer = (app >> 16 & 0x000000ff) | (app << 16 & 0x00ff0000) | (app & 0xff00ff00);
}
}
#endif
#endif
//-----------------------------------------------------------------------------
//=============================================================================
// QtOfflineGL : implem. offlineGL usando QT
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
QtOfflineGL::QtOfflineGL(TDimension rasterSize, const TOfflineGL::Imp *shared)
: TOfflineGL::Imp(rasterSize.lx, rasterSize.ly), m_context(0), m_oldContext(0)
{
createContext(rasterSize, shared);
/*
makeCurrent();
glClearColor(0.0f,0.0f,0.0f,0.0f);
glClear(GL_COLOR_BUFFER_BIT);
doneCurrent();
*/
}
//-----------------------------------------------------------------------------
QtOfflineGL::~QtOfflineGL()
{
delete m_context;
}
//-----------------------------------------------------------------------------
void QtOfflineGL::createContext(TDimension rasterSize, const TOfflineGL::Imp *shared)
{
// Imposto il formato dei Pixel (pixelFormat)
/*
32, // 32-bit color depth
0, 0, 0, 0, 0, 0, // color bits ignored
8, // no alpha buffer
0, // shift bit ignored
0, // no accumulation buffer
0, 0, 0, 0, // accum bits ignored
32, // 32-bit z-buffer
32, // max stencil buffer
0, // no auxiliary buffer
PFD_MAIN_PLANE, // main layer
0, // reserved
0, 0, 0 // layer masks ignored
ATTENZIONE !! SU MAC IL FORMATO E' DIVERSO (casomai possiamo mettere un ifdef)
SPECIFICHE MAC = depth_size 24, stencil_size 8, alpha_size 1
*/
QGLFormat fmt;
#ifdef WIN32
fmt.setAlphaBufferSize(8);
fmt.setAlpha(true);
fmt.setRgba(true);
fmt.setDepthBufferSize(32);
fmt.setDepth(true);
fmt.setStencilBufferSize(32);
fmt.setStencil(true);
fmt.setAccum(false);
fmt.setPlane(0);
#elif MACOSX
fmt = QGLFormat::defaultFormat();
//printf("GL Version: %s\n",glGetString(GL_VERSION));
fmt.setVersion(2, 1); /* OSX10.8 では 3.2 だめかも */
#if 0
fmt.setAlphaBufferSize(8);
fmt.setAlpha(true);
fmt.setRgba(true);
fmt.setDepthBufferSize(32);
fmt.setDepth(true);
fmt.setStencilBufferSize(8);
fmt.setStencil(true);
fmt.setAccum(false);
fmt.setPlane(0);
fmt.setDirectRendering(false);
#endif
#endif
/* FIXME: ここでいう QPixmap は Level Strip のセルに相当する.
QPixmap に GLContext を生成して bind できれば描画したベクタのラスタ画像がそこに反映されるはずだが
QLContext の生成ができないためにうまくいかない.
*/
printf("QPixmap(%d, %d)\n", rasterSize.lx, rasterSize.ly);
//QPixmap *m_pixmap = new QPixmap(rasterSize.lx, rasterSize.ly);
// Inizializzo un contesto openGL utilizzando una QPixmap
m_context = new QOpenGLContext();
//m_context = new QGLContext(fmt);
m_surface = new QOffscreenSurface();
m_surface->setFormat(m_context->format());
//QSurfaceFormat sfmt = QGuiApplication::focusWindow()->format();
m_surface->create();
printf("create context:%p [thread:0x%x]\n", m_context, QThread::currentThreadId());
//m_context->setFormat(sfmt);
// Creo il contesto OpenGL - assicurandomi che sia effettivamente creato
// NOTA: Se il contesto non viene creato, di solito basta ritentare qualche volta.
bool ret = m_context->create();
}
//-----------------------------------------------------------------------------
void QtOfflineGL::makeCurrent()
{
if (m_context) {
m_context->makeCurrent(m_surface);
}
// else
// m_oldContext = 0;
}
//-----------------------------------------------------------------------------
void QtOfflineGL::doneCurrent()
{
if (m_context) {
m_context->doneCurrent();
}
}
//-----------------------------------------------------------------------------
void QtOfflineGL::saveCurrentContext()
{
// m_oldContext = const_cast<QGLContext*>(QGLContext::currentContext());
}
//-----------------------------------------------------------------------------
void QtOfflineGL::restoreCurrentContext()
{
// if(m_oldContext) m_oldContext->makeCurrent();
// m_oldContext = 0;
}
//-----------------------------------------------------------------------------
void QtOfflineGL::getRaster(TRaster32P raster)
{
makeCurrent();
glFlush();
int lx = raster->getLx();
int ly = raster->getLy();
raster->lock();
glReadPixels(0, 0, lx, ly,
GL_RGBA /*GL_BGRA_EXT*/, GL_UNSIGNED_BYTE,
raster->getRawData());
#ifdef WIN32
swapRedBlueChannels(raster->getRawData(), lx * ly);
#elif MACOSX
rightRotateBits(raster->getRawData(), lx * ly);
#endif
raster->unlock();
}
//QGLPixelBuffer::hasOpenGLPbuffers() (statica) -> true se la scheda supporta i PBuffer
//=============================================================================
// QtOfflineGLPBuffer : implem. offlineGL usando QT e PBuffer
//-----------------------------------------------------------------------------
QtOfflineGLPBuffer::QtOfflineGLPBuffer(TDimension rasterSize)
: TOfflineGL::Imp(rasterSize.lx, rasterSize.ly), m_context(0)
{
createContext(rasterSize);
makeCurrent();
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClear(GL_COLOR_BUFFER_BIT);
doneCurrent();
}
//-----------------------------------------------------------------------------
QtOfflineGLPBuffer::~QtOfflineGLPBuffer()
{
delete m_context;
}
//-----------------------------------------------------------------------------
void QtOfflineGLPBuffer::createContext(TDimension rasterSize)
{
// Imposto il formato dei Pixel (pixelFormat)
/*
32, // 32-bit color depth
0, 0, 0, 0, 0, 0, // color bits ignored
8, // no alpha buffer
0, // shift bit ignored
0, // no accumulation buffer
0, 0, 0, 0, // accum bits ignored
32, // 32-bit z-buffer
32, // max stencil buffer
0, // no auxiliary buffer
PFD_MAIN_PLANE, // main layer
0, // reserved
0, 0, 0 // layer masks ignored
ATTENZIONE !! SU MAC IL FORMATO E' DIVERSO (casomai possiamo mettere un ifdef)
SPECIFICHE MAC = depth_size 24, stencil_size 8, alpha_size 1
*/
QGLFormat fmt;
#ifdef WIN32
fmt.setAlphaBufferSize(8);
fmt.setAlpha(false);
fmt.setRgba(true);
fmt.setDepthBufferSize(32);
fmt.setDepth(true);
fmt.setStencilBufferSize(32);
fmt.setStencil(true);
fmt.setAccum(false);
fmt.setPlane(0);
#elif MACOSX
fmt.setAlphaBufferSize(1);
fmt.setAlpha(false);
fmt.setRgba(true);
fmt.setDepthBufferSize(24);
fmt.setDepth(true);
fmt.setStencilBufferSize(8);
fmt.setStencil(true);
fmt.setAccum(false);
fmt.setPlane(0);
#endif
// Il PixelBuffer deve essere con width ed height potenze di 2
int sizeMax = tmax(rasterSize.lx, rasterSize.ly);
// trovo la potenza di 2 che "contiene" sizeMax e la utilizzo per il PBuffer
int pBufferSize = 2;
while (pBufferSize < sizeMax)
pBufferSize *= 2;
m_context = new QGLPixelBuffer(QSize(pBufferSize, pBufferSize), fmt);
}
//-----------------------------------------------------------------------------
void QtOfflineGLPBuffer::makeCurrent()
{
if (m_context)
m_context->makeCurrent();
}
//-----------------------------------------------------------------------------
void QtOfflineGLPBuffer::doneCurrent()
{
if (m_context)
m_context->doneCurrent();
}
//-----------------------------------------------------------------------------
void QtOfflineGLPBuffer::getRaster(TRaster32P raster)
{
makeCurrent();
glFlush();
//The image is stored using a 32-bit ARGB format (0xAARRGGBB).
QImage image = m_context->toImage();
int lx = raster->getLx(), ly = raster->getLy();
static const TRaster32P emptyRaster;
if (image.height() == 0 || image.width() == 0)
return;
// devo iniziare a leggere la Y da un certo offset
// dato dalla differenza tra la y della image e la y del raster
int yOffset = image.height() - ly;
raster->lock();
for (int y = 0; y < ly; y++) {
QRgb *inpPix = (QRgb *)image.scanLine(yOffset + y);
TPixel32 *pix = raster->pixels(ly - 1 - y);
TPixel32 *endPix = pix + lx;
for (; pix < endPix; ++pix) {
pix->m = 255;
pix->r = qRed(*inpPix);
pix->g = qGreen(*inpPix);
pix->b = qBlue(*inpPix);
*inpPix++;
}
}
raster->unlock();
}