#include "macofflinegl.h"

#include <traster.h></traster.h>

#include <tconvert.h></tconvert.h>

#include "tthread.h"

namespace {

#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

}  // namespace

GLubyte *memBuffer;

//=============================================================================

// MacOfflineGL : implem. offlineGL usando Pixel Buffer (tramite AGL)

//-----------------------------------------------------------------------------

MacOfflineGL::MacOfflineGL(TDimension rasterSize, const TOfflineGL::Imp *shared)

    : TOfflineGL::Imp(rasterSize.lx, rasterSize.ly)

    , m_context(0)

    , m_oldContext(0) {

  createContext(rasterSize, shared);

}

//-----------------------------------------------------------------------------

MacOfflineGL::~MacOfflineGL() { aglDestroyContext(m_context); }

//-----------------------------------------------------------------------------

void MacOfflineGL::createContext(TDimension rasterSize,

                                 const TOfflineGL::Imp *shared) {

  GLint attribs[20], cnt = 0;

  // NOTE: AGL_OFFSCREEN *must* be selected - or it seems that gl surfaces are

  // never destructed correctly!

  // This may lead to a kernel panic!

  attribs[cnt++] = AGL_RGBA;

  attribs[cnt++] = GL_TRUE;

  attribs[cnt++] = AGL_PIXEL_SIZE;

  attribs[cnt++] = 32;

  attribs[cnt++] = AGL_BUFFER_SIZE;

  attribs[cnt++] = 32;

  attribs[cnt++] = AGL_STENCIL_SIZE;

  attribs[cnt++] = 8;

  attribs[cnt++] = AGL_DEPTH_SIZE;

  attribs[cnt++] = 24;

  attribs[cnt++] = AGL_OFFSCREEN;

  attribs[cnt++] = AGL_ALPHA_SIZE;

  attribs[cnt++] = 8;

  attribs[cnt]   = AGL_NONE;

  AGLPixelFormat fmt = aglChoosePixelFormat(0, 0, attribs);

  if (fmt == NULL) {

    GLenum err = aglGetError();

    std::cout << "Unable to create a pixel format, AGLError =  " << err

              << std::endl;

  }

  m_context = aglCreateContext(fmt, NULL);

  if (!m_context) {

    GLenum err = aglGetError();

    /*

    AGL_NO_ERROR                 0

    AGL_BAD_ATTRIBUTE        10000

    AGL_BAD_PROPERTY         10001

    AGL_BAD_PIXELFMT         10002

    AGL_BAD_RENDINFO         10003

    AGL_BAD_CONTEXT          10004

    AGL_BAD_DRAWABLE         10005

    AGL_BAD_GDEV             10006

    AGL_BAD_STATE            10007

    AGL_BAD_VALUE            10008

    AGL_BAD_MATCH            10009

    AGL_BAD_ENUM             10010

    AGL_BAD_OFFSCREEN        10011

    AGL_BAD_FULLSCREEN       10012

    AGL_BAD_WINDOW           10013

    AGL_BAD_POINTER          10014

    AGL_BAD_MODULE           10015

    AGL_BAD_ALLOC            10016

    AGL_BAD_CONNECTION       10017

*/

    std::cout << "Unable to create an OpenGL Context, AGLError = " << err

              << std::endl;

  }

  makeCurrent();

  // Creo il pixel buffer

  GLboolean ret;

  AGLPbuffer pbuffer;

  ret = aglCreatePBuffer(rasterSize.lx, rasterSize.ly, GL_TEXTURE_RECTANGLE_EXT,

                         GL_RGBA, 0, &pbuffer);

  if (!ret) {

    GLenum err = aglGetError();

    std::cout << "Unable to create a PBuffer, AGLError = " << err << std::endl;

  }

  // memBuffer = new GLubyte[rasterSize.lx*rasterSize.ly*4];

  ret = aglSetOffScreen(m_context, rasterSize.lx, rasterSize.ly,

                        rasterSize.lx * 4, memBuffer);

  ret = aglSetPBuffer(m_context, pbuffer, 0, 0, 0);

  if (!ret) {

    GLenum err = aglGetError();

    std::cout << "Unable to set a PBuffer, AGLError = " << err << std::endl;

  }

  // Non serve piu'

  aglDestroyPixelFormat(fmt);

}

//-----------------------------------------------------------------------------

void MacOfflineGL::makeCurrent() {

  if (m_context) {

    bool ret = aglSetCurrentContext(m_context);

    if (ret == GL_FALSE) {

      GLenum err = aglGetError();

      std::cout << "Unable to set current OpenGL Context, AGLError = " << err

                << std::endl;

    }

  } else

    m_oldContext = 0;

}

//-----------------------------------------------------------------------------

void MacOfflineGL::doneCurrent() {

  if (aglGetCurrentContext() != m_context) return;

  aglSetCurrentContext(0);

}

//-----------------------------------------------------------------------------

void MacOfflineGL::saveCurrentContext() {

  m_oldContext = aglGetCurrentContext();

}

//-----------------------------------------------------------------------------

void MacOfflineGL::restoreCurrentContext() {

  if (m_oldContext) aglSetCurrentContext(m_oldContext);

  m_oldContext = 0;

}

//-----------------------------------------------------------------------------

void MacOfflineGL::getRaster(TRaster32P raster) {

  makeCurrent();

  glFinish();

  int lx = raster->getLx();

  int ly = raster->getLy();

  raster->lock();

  glReadPixels(0, 0, lx, ly, GL_RGBA, GL_UNSIGNED_BYTE, raster->getRawData());

  rightRotateBits(raster->getRawData(), lx * ly);

  raster->unlock();

}