// TnzCore includes
#include "texception.h"
#include "tvectorgl.h"
#include "tvectorimage.h"
#include "trasterimage.h"
#include "tgl.h"
#include "tthreadmessage.h"
#include "tsystem.h"
#include "trop.h"
// Platform-specific includes
#if defined(LINUX) || defined(FREEBSD)
#include "qtofflinegl.h"
#include <X11/Xlib.h>
#include <GL/glx.h>
#include "tthread.h"
#elif defined(MACOSX) || defined(HAIKU)
#include "qtofflinegl.h"
#endif
#include "tofflinegl.h"
#ifndef checkErrorsByGL
#define checkErrorsByGL \
{ \
GLenum err = glGetError(); \
assert(err != GL_INVALID_ENUM); \
assert(err != GL_INVALID_VALUE); \
assert(err != GL_INVALID_OPERATION); \
assert(err != GL_STACK_OVERFLOW); \
assert(err != GL_STACK_UNDERFLOW); \
assert(err != GL_OUT_OF_MEMORY); \
assert(err == GL_NO_ERROR); \
}
#endif
#undef checkErrorsByGL
#define checkErrorsByGL /**/
using namespace std;
TGLContextManager *currentContextManager = 0;
void TOfflineGL::setContextManager(TGLContextManager *contextManager) {
currentContextManager = contextManager;
if (contextManager) contextManager->store();
}
//=============================================================================
// WIN32Implementation : implementazione offlineGL WIN32
//-----------------------------------------------------------------------------
#ifdef _WIN32
namespace {
// We found out that our implementation of win32 opengl contexts can be someway
// not thread-safe. Deadlocks and errors could happen for wgl* and GDI functions
// on particular configurations (notably, Windows 7). So we mutex them as
// a temporary workaround.
static QMutex win32ImpMutex;
} // namespace
//-------------------------------
class WIN32Implementation final : public TOfflineGL::Imp {
public:
HDC m_offDC;
HGDIOBJ m_oldobj;
HGLRC m_hglRC;
HBITMAP m_offDIB;
void *m_offData;
//-----------------------------------------------------------------------------
WIN32Implementation(TDimension rasterSize,
std::shared_ptr<TOfflineGL::Imp> shared)
: TOfflineGL::Imp(rasterSize.lx, rasterSize.ly) {
m_offData = 0;
createContext(
rasterSize,
std::move(shared)); // makeCurrent is called at the end of this
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClear(GL_COLOR_BUFFER_BIT);
doneCurrent(); // doneCurrent must therefore be called here
}
//-----------------------------------------------------------------------------
~WIN32Implementation() {
QMutexLocker locker(&win32ImpMutex);
BOOL ret = wglMakeCurrent(m_offDC, NULL);
assert(ret == TRUE);
wglDeleteContext(m_hglRC);
SelectObject(m_offDC, m_oldobj);
DeleteObject(m_offDC);
// si potrebbe passare un parametro che evita di distruggere la bitmap.
// In tal caso il raster dovrebbe diventare owner del buffer, ma attualmente
// questo non e' settabile in TRaster: quando gli si passa da fuori un
// buffer,
// automaticamente bufferOwner viene settato a false e non e' modificabile!
DeleteObject(m_offDIB);
}
//-----------------------------------------------------------------------------
void makeCurrent() override {
QMutexLocker locker(&win32ImpMutex);
int ret = wglMakeCurrent(m_offDC, m_hglRC);
assert(ret == TRUE);
}
//-----------------------------------------------------------------------------
void doneCurrent() override {
QMutexLocker locker(&win32ImpMutex);
glFlush();
glFinish();
assert(glGetError() == 0);
wglMakeCurrent(NULL, NULL);
}
//-----------------------------------------------------------------------------
void initBITMAPINFO(BITMAPINFO &info, const TDimension rasterSize) {
memset(&info, 0, sizeof(BITMAPINFOHEADER));
info.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
info.bmiHeader.biWidth = rasterSize.lx;
info.bmiHeader.biHeight = rasterSize.ly;
info.bmiHeader.biPlanes = 1;
info.bmiHeader.biBitCount = 32;
info.bmiHeader.biCompression = BI_RGB;
info.bmiHeader.biSizeImage = 0;
info.bmiHeader.biXPelsPerMeter = 1000;
info.bmiHeader.biYPelsPerMeter = 1000;
info.bmiHeader.biClrUsed = 0;
info.bmiHeader.biClrImportant = 0;
}
//-----------------------------------------------------------------------------
void createContext(TDimension rasterSize,
std::shared_ptr<TOfflineGL::Imp> shared) override {
QMutexLocker locker(&win32ImpMutex);
BITMAPINFO info;
initBITMAPINFO(info, rasterSize);
// open an offscreen device
m_offDC = CreateCompatibleDC(NULL);
// and a bitmap image
m_offDIB =
CreateDIBSection(m_offDC, &info, DIB_RGB_COLORS, &m_offData, NULL, 0);
assert(m_offDIB);
assert(m_offData);
if (!m_offDIB || !m_offData)
throw TException("cannot create OpenGL context. Check system resources!");
int dataSize =
rasterSize.lx * rasterSize.ly * 4; // number of byte of raster
memset(m_offData, 0, dataSize);
m_oldobj = SelectObject(m_offDC, m_offDIB); // select BIB to write
static PIXELFORMATDESCRIPTOR pfd = {
sizeof(PIXELFORMATDESCRIPTOR), // size of this pfd
1, // version number
0 |
(false ? (PFD_DRAW_TO_WINDOW | PFD_DOUBLEBUFFER)
: (PFD_DRAW_TO_BITMAP | PFD_SUPPORT_GDI)) |
PFD_SUPPORT_OPENGL, // support OpenGL
PFD_TYPE_RGBA, // RGBA type
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
};
// get the best available match of pixel format for the device context
int iPixelFormat = ChoosePixelFormat(m_offDC, &pfd);
assert(iPixelFormat != 0);
// make that the pixel format of the device context
int ret = SetPixelFormat(m_offDC, iPixelFormat, &pfd);
assert(ret == TRUE);
// make a valid context for OpenGL rendering
m_hglRC = wglCreateContext(m_offDC);
assert(m_hglRC);
if (!m_hglRC)
throw TException("cannot create OpenGL context. Check system resources!");
if (shared) {
// Share shared's display lists
const WIN32Implementation *sharedImp =
dynamic_cast<const WIN32Implementation *>(shared.get());
assert(sharedImp);
bool ok = wglShareLists(sharedImp->m_hglRC, m_hglRC);
assert(ok);
}
ret = wglMakeCurrent(m_offDC, m_hglRC);
assert(ret == TRUE);
}
//-----------------------------------------------------------------------------
void swapRedBlueChannels(
void *buffer,
int bufferSize) // Flips The Red And Blue Bytes (WidthxHeight)
{
void *b = buffer; // Pointer To The Buffer
#if !defined(x64) && defined(_MSC_VER)
__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
}
#else
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--;
}
/*unsigned long ebx = (unsigned long)b;
while(size>0)
{
unsigned char al =__readgsbyte(ebx);
unsigned char ah =__readgsbyte(ebx+2);
__writegsbyte(ebx+2,al);
__writegsbyte(ebx,ah);
ebx+=4;
size--;
}*/
#endif
}
//-----------------------------------------------------------------------------
void getRaster(TRaster32P raster) override {
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());
swapRedBlueChannels(raster->getRawData(), lx * ly);
raster->unlock();
}
};
// default imp generator
static std::shared_ptr<TOfflineGL::Imp> defaultOfflineGLGenerator(
const TDimension &dim, std::shared_ptr<TOfflineGL::Imp> shared) {
return std::make_shared<WIN32Implementation>(dim, shared);
}
//=============================================================================
// XImplementation : implementazione offlineGL Server X (MACOSX & LINUX & BSD)
//-----------------------------------------------------------------------------
#elif defined(LINUX) || defined(FREEBSD)
namespace {
// The XScopedLock stuff doesn't seem finished,
// why not just do the same as with win32 and use a Qt lock??
static QMutex linuxImpMutex;
} // namespace
class XImplementation final : public TOfflineGL::Imp {
public:
Display *m_dpy;
GLXContext m_context;
GLXPixmap m_pixmap;
Pixmap m_xpixmap;
TRaster32P m_raster;
//-----------------------------------------------------------------------------
XImplementation(TDimension rasterSize)
: TOfflineGL::Imp(rasterSize.lx, rasterSize.ly) {
createContext(rasterSize);
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClear(GL_COLOR_BUFFER_BIT);
}
//-----------------------------------------------------------------------------
~XImplementation() {
glXDestroyContext(m_dpy, m_context);
m_context = 0;
safeGlXMakeCurrent(true);
XCloseDisplay(m_dpy);
}
//-----------------------------------------------------------------------------
bool safeGlXMakeCurrent(bool isDtor = false) {
static std::map<pthread_t, GLXContext> m_glxContext;
static TThread::Mutex mutex;
QMutexLocker sl(&mutex);
pthread_t self = pthread_self();
std::map<pthread_t, GLXContext>::iterator it = m_glxContext.find(self);
if (((it != m_glxContext.end()) && (it->second != m_context)) ||
(it == m_glxContext.end())) {
// cout << "calling GLXMakeCurrent " << self << " " << m_context <<
// endl;
Bool ret;
if (!isDtor) ret = glXMakeCurrent(m_dpy, m_pixmap, m_context);
m_glxContext[self] = m_context;
return ret;
}
// cout << "don't call GLXMakeCurrent " << self << " " << m_context << endl;
return true;
}
//-----------------------------------------------------------------------------
void makeCurrent() {
QMutexLocker locker(&linuxImpMutex);
// Bool ret = glXMakeCurrent(m_dpy,m_pixmap,m_context);
Bool ret = safeGlXMakeCurrent();
assert(ret == True);
}
//-----------------------------------------------------------------------------
// DA IMPLEMENTARE !!!
void doneCurrent() {}
//-----------------------------------------------------------------------------
void createContext(TDimension rasterSize) {
m_dpy = XOpenDisplay(NULL);
Window win = DefaultRootWindow(m_dpy);
int attribList[] = {GLX_RGBA, GLX_RED_SIZE, 1, GLX_GREEN_SIZE, 1,
GLX_BLUE_SIZE, 1,
// GLX_ALPHA_SIZE, 1,
GLX_STENCIL_SIZE, 8,
// GLX_DEPTH_SIZE, 24,
None};
int dbAttrib[] = {GLX_RGBA, GLX_RED_SIZE, 1, GLX_GREEN_SIZE,
1, GLX_BLUE_SIZE, 1, GLX_STENCIL_SIZE,
8, GLX_DOUBLEBUFFER, None};
int w = rasterSize.lx;
int h = rasterSize.ly;
XVisualInfo *vis = glXChooseVisual(m_dpy, DefaultScreen(m_dpy), attribList);
if (!vis) {
std::cout << "unable to create sb visual" << std::endl;
vis = glXChooseVisual(m_dpy, DefaultScreen(m_dpy), dbAttrib);
assert(vis && "unable to create db visual");
}
m_context = glXCreateContext(m_dpy, vis, 0, False);
// std::cout << "Direct rendering: " << (glXIsDirect(m_dpy, m_context) ?
// "Yes" : "No" )<< std::endl;
if (!m_context) assert("not m_context" && false);
TRaster32P raster(w, h);
m_xpixmap = XCreatePixmap(m_dpy, win, w, h, vis->depth);
assert(m_xpixmap && "not m_xpixmap");
m_pixmap = glXCreateGLXPixmap(m_dpy, vis, m_xpixmap);
if (!m_pixmap) assert("not m_pixmap" && m_pixmap);
/*
Bool ret = glXMakeCurrent(m_dpy,
m_pixmap,
m_context);
*/
Bool ret = safeGlXMakeCurrent();
assert(ret);
m_raster = raster;
}
//-----------------------------------------------------------------------------
#if defined(MACOSX)
#if defined(powerpc)
void rightRotateBits(UCHAR *buf, int bufferSize) {
UINT *buffer = (UINT *)buf;
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;
UINT app;
for (int i = 0; i < bufferSize; i++, buffer++) {
app = *buffer;
*buffer = (app >> 16 & 0x000000ff) | (app << 16 & 0x00ff0000) |
(app & 0xff00ff00);
}
}
#endif
#endif
//-----------------------------------------------------------------------------
const TRaster32P &getRaster() {
makeCurrent();
glFlush();
int lx = m_raster->getLx();
int ly = m_raster->getLy();
m_raster->lock();
glReadPixels(0, 0, lx, ly, GL_RGBA /*GL_BGRA_EXT*/, GL_UNSIGNED_BYTE,
m_raster->getRawData());
#if defined(MACOSX)
rightRotateBits(m_raster->getRawData(), lx * ly);
#warning "to do"
#endif
m_raster->unlock();
return m_raster;
}
//-----------------------------------------------------------------------------
int getLx() const { return m_raster->getLx(); }
//-----------------------------------------------------------------------------
int getLy() const { return m_raster->getLy(); }
};
static std::shared_ptr<TOfflineGL::Imp> defaultOfflineGLGenerator(
const TDimension &dim, std::shared_ptr<TOfflineGL::Imp> shared) {
return std::make_shared<QtOfflineGL>(dim, shared);
}
#elif defined(MACOSX) || defined(HAIKU)
std::shared_ptr<TOfflineGL::Imp> defaultOfflineGLGenerator(
const TDimension &dim, std::shared_ptr<TOfflineGL::Imp> shared) {
return std::make_shared<QtOfflineGL>(dim, shared);
}
#endif
//=============================================================================
//-----------------------------------------------------------------------------
// current imp generator
namespace {
TOfflineGL::ImpGenerator *currentImpGenerator = defaultOfflineGLGenerator;
} // namespace
//=============================================================================
// TOfflineGL
//-----------------------------------------------------------------------------
// namespace {
class MessageCreateContext final : public TThread::Message {
friend class TOfflineGL;
TOfflineGL *m_ogl;
TDimension m_size;
std::shared_ptr<TOfflineGL::Imp> m_shared;
public:
MessageCreateContext(TOfflineGL *ogl, const TDimension &size,
TOfflineGL::Imp *shared)
: m_ogl(ogl), m_size(size), m_shared(shared) {}
void onDeliver() override {
m_ogl->m_imp = currentImpGenerator(m_size, m_shared);
}
TThread::Message *clone() const override {
return new MessageCreateContext(*this);
}
};
//} // namespace
//--------------------------------------------------
TOfflineGL::TOfflineGL(TDimension dim, const TOfflineGL *shared) : m_imp(0) {
#if defined(LINUX) || defined(FREEBSD)
QMutexLocker locker(&linuxImpMutex);
#endif
/*
The original code did some incomprehensible things like creating an offline
renderer (to be called from another thread) and dispatching it to the main
thread, but Q*GLContext can't go beyond the thread context, so it is created
directly and closed in this context. It does not dispatch to another thread.
*/
m_imp = currentImpGenerator(dim, shared ? shared->m_imp : 0);
initMatrix();
}
//-----------------------------------------------------------------------------
TOfflineGL::TOfflineGL(const TRaster32P &raster, const TOfflineGL *shared) {
#if defined(LINUX) || defined(FREEBSD)
QMutexLocker locker(&linuxImpMutex);
#endif
// m_imp = new Imp(raster->getSize());
m_imp = currentImpGenerator(raster->getSize(), shared->m_imp);
initMatrix();
glRasterPos2d(0, 0);
raster->lock();
glDrawPixels(raster->getLx(), raster->getLy(), GL_BGRA_EXT, GL_UNSIGNED_BYTE,
raster->getRawData());
raster->unlock();
}
//-----------------------------------------------------------------------------
TOfflineGL::~TOfflineGL() {
// delete m_imp;
}
//-----------------------------------------------------------------------------
TOfflineGL::ImpGenerator *TOfflineGL::defineImpGenerator(
TOfflineGL::ImpGenerator *impGenerator) {
TOfflineGL::ImpGenerator *ret = currentImpGenerator;
currentImpGenerator = impGenerator;
return ret;
}
//-----------------------------------------------------------------------------
void TOfflineGL::makeCurrent() {
if (currentContextManager) currentContextManager->store();
// All the code was moved inside Imp
m_imp->makeCurrent();
assert(glGetError() == GL_NO_ERROR);
}
//-----------------------------------------------------------------------------
void TOfflineGL::doneCurrent() {
m_imp->doneCurrent();
if (currentContextManager) {
currentContextManager->restore();
}
}
//-----------------------------------------------------------------------------
void TOfflineGL::initMatrix() {
m_imp->makeCurrent();
// cfr. help: OpenGL/Programming tip/OpenGL Correctness Tips
glViewport(0, 0, m_imp->getLx(), m_imp->getLy());
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0, m_imp->getLx(), 0, m_imp->getLy());
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
// glTranslatef(0.375, 0.375, 0.0); //WRONG
/* (From Daniele)
Quoting from the aforementioned source:
"An optimum compromise that allows all primitives to be specified at integer
positions, while still ensuring predictable rasterization, is to translate x
and y by 0.375, as shown in the following code sample. Such a translation
keeps polygon and pixel image edges safely away from the centers of pixels,
while moving line vertices close enough to the pixel centers"
NOTE: This is not an acceptable excuse in our case - as we're NOT USING
INTEGER COORDINATES ONLY. OpenGL has all the rights to render pixels
at integer coordinates across the neighbouring 4 pixels - and their
(0.5, 0.5) translations at the EXACT screen pixel.
*/
}
//-----------------------------------------------------------------------------
void TOfflineGL::clear(TPixel32 color) {
const double maxValue = 255.0;
makeCurrent();
glClearColor((double)color.r / maxValue, (double)color.g / maxValue,
(double)color.b / maxValue, (double)color.m / maxValue);
glClear(GL_COLOR_BUFFER_BIT);
}
//-----------------------------------------------------------------------------
void TOfflineGL::draw(TVectorImageP image, const TVectorRenderData &rd,
bool doInitMatrix) {
checkErrorsByGL;
makeCurrent();
checkErrorsByGL;
if (doInitMatrix) {
initMatrix();
checkErrorsByGL;
}
if (image) {
checkErrorsByGL;
tglDraw(rd, image.getPointer());
checkErrorsByGL;
}
checkErrorsByGL;
glFlush();
checkErrorsByGL;
}
//-----------------------------------------------------------------------------
void TOfflineGL::draw(TRasterImageP ri, const TAffine &aff, bool doInitMatrix) {
makeCurrent();
if (doInitMatrix) initMatrix();
TRaster32P ras32 = ri->getRaster();
if (!ras32) return;
int lx = ras32->getLx();
int ly = ras32->getLy();
// lx e ly devono essere potenze di due
assert((lx & (lx - 1)) == 0);
assert((ly & (ly - 1)) == 0);
glPushMatrix();
tglMultMatrix(aff);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
glEnable(GL_TEXTURE_2D);
/*
TNZ_MACHINE_CHANNEL_ORDER_BGRM
TNZ_MACHINE_CHANNEL_ORDER_MBGR
TNZ_MACHINE_CHANNEL_ORDER_RGBM
TNZ_MACHINE_CHANNEL_ORDER_MRGB
*/
GLenum fmt = TGL_FMT;
/*
#if defined(TNZ_MACHINE_CHANNEL_ORDER_BGRM)
GL_BGRA_EXT;
#elif defined(TNZ_MACHINE_CHANNEL_ORDER_MBGR)
GL_ABGR_EXT;
#elif defined(TNZ_MACHINE_CHANNEL_ORDER_RGBM)
GL_RGBA;
#elif defined(TNZ_MACHINE_CHANNEL_ORDER_MRGB)
#warning "to do"
GL_ABGR_EXT;
#else
Error PLATFORM NOT SUPPORTED
#endif
*/
// Generate a texture id and bind it.
GLuint texId;
glGenTextures(1, &texId);
glBindTexture(GL_TEXTURE_2D, texId);
glPixelStorei(GL_UNPACK_ROW_LENGTH,
ras32->getWrap() != ras32->getLx() ? ras32->getWrap() : 0);
ras32->lock();
glTexImage2D(GL_TEXTURE_2D, // target (is a 2D texture)
0, // is one level only
GL_RGB, // number of component of a pixel
lx, // size width
ly, // height
0, // size of a border
fmt,
GL_UNSIGNED_BYTE, //
ras32->getRawData());
ras32->unlock();
double halfWidth = 0.5 * lx;
double halfHeight = 0.5 * ly;
double dpix = 1, dpiy = 1;
ri->getDpi(dpix, dpiy);
if (dpix != 0 && dpiy != 0) {
double unit = 100;
halfWidth *= unit / dpix;
halfHeight *= unit / dpiy;
}
glBegin(GL_QUAD_STRIP);
glTexCoord2d(0, 0);
glVertex2d(-halfWidth, -halfHeight);
glTexCoord2d(1, 0);
glVertex2d(halfWidth, -halfHeight);
glTexCoord2d(0, 1);
glVertex2d(-halfWidth, halfHeight);
glTexCoord2d(1, 1);
glVertex2d(halfWidth, halfHeight);
glEnd();
glDisable(GL_TEXTURE_2D);
glPopMatrix();
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
// Delete texture
glDeleteTextures(1, &texId);
glFlush();
}
//-----------------------------------------------------------------------------
void TOfflineGL::flush() {
makeCurrent();
glFlush();
}
//-----------------------------------------------------------------------------
void TOfflineGL::getRaster(TRaster32P raster) {
assert(raster->getLx() <= getLx() && raster->getLy() <= getLy());
if (raster->getWrap() == raster->getLx()) {
m_imp->getRaster(raster);
} else {
// There are 2 possible solutions: use glReadPixels multiple times for each
// row of input raster,
// OR allocate a new contiguous buffer, use glReadPixels once, and then
// memcpy each row.
// It actually seems that the *latter* is actually the fastest solution,
// although it requires
// allocating a temporary buffer of the same size of the requested raster...
// I also could not actually manage to make the former work - the code
// seemed right but results were weird...
TRaster32P ras32(raster->getSize());
m_imp->getRaster(ras32);
TRop::copy(raster, ras32);
}
}
//-----------------------------------------------------------------------------
void TOfflineGL::getRaster(TRasterP raster) {
assert(raster->getLx() <= getLx() && raster->getLy() <= getLy());
TRaster32P ras32 = raster;
if (ras32 && (raster->getWrap() == raster->getLx())) {
m_imp->getRaster(ras32);
} else {
ras32 = TRaster32P(raster->getSize());
m_imp->getRaster(ras32);
TRop::copy(raster, ras32);
}
}
//-----------------------------------------------------------------------------
TRaster32P TOfflineGL::getRaster() {
TRaster32P raster(getLx(), getLy());
m_imp->getRaster(raster);
return raster;
}
//-----------------------------------------------------------------------------
int TOfflineGL::getLx() const { return m_imp->getLx(); }
//-----------------------------------------------------------------------------
int TOfflineGL::getLy() const { return m_imp->getLy(); }
//-----------------------------------------------------------------------------
//=============================================================================
namespace {
struct DimensionLess final
: public std::binary_function<TDimension, TDimension, bool> {
bool operator()(const TDimension &d1, const TDimension &d2) const {
return d1.lx < d2.lx || (d1.lx == d2.lx && d1.ly < d2.ly);
}
};
//-----------------------------------------------------------------------------
class OglStock { // singleton
typedef std::map<const TDimension, TOfflineGL *, DimensionLess> ContextMap;
ContextMap m_table;
OglStock() {}
public:
~OglStock() {
/* // PER ADESSO, LASCIAMO IL MEMORY LEAK DATO CHE ALTRIMENTI VA IN CRASH
ContextMap::iterator it = m_table.begin();
for(; it!=m_table.end(); ++it)
{
delete it->second;
}
*/
}
TOfflineGL *get(const TDimension &d) {
ContextMap::iterator it = m_table.find(d);
if (it == m_table.end()) {
TOfflineGL *glContext;
glContext = new TOfflineGL(d);
pair<ContextMap::iterator, bool> result =
m_table.insert(ContextMap::value_type(d, glContext));
assert(result.second);
assert(m_table.size() < 15);
return glContext;
}
return it->second;
}
static OglStock *instance() {
static OglStock singleton;
return &singleton;
}
};
} // namespace
//-----------------------------------------------------------------------------
TOfflineGL *TOfflineGL::getStock(const TDimension dim) {
return OglStock::instance()->get(dim);
}