#include "tstencilcontrol.h"

#include "tgl.h"

#include "tthreadmessage.h"

#include <stack></stack>

#include <qthreadstorage></qthreadstorage>

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

namespace {

// singleton

class StencilControlManager {

  QThreadStorage<tstencilcontrol *=""> m_storage;</tstencilcontrol>

  StencilControlManager() {}

public:

  static StencilControlManager *instance() {

    static StencilControlManager theInstance;

    return &theInstance;

  }

  TStencilControl *getCurrentStencilControl() {

    if (!m_storage.hasLocalData()) {

      m_storage.setLocalData(new TStencilControl);

    }

    return m_storage.localData();

  }

  ~StencilControlManager() {}

};

}  // Local namepace

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

class TStencilControl::Imp {

public:

  int m_stencilBitCount;

  int m_pushCount;

  int m_currentWriting;  // current stencil bit plane.

  // 0 is the first bit plane ; -1 menas no stencil mask is writing

  int m_virtualState;

// the state of the (eventually virtual) top mask.

// A mask is virtual if overflows stencil buffer

// 0 is closed and disabled, 1 closed and enabled and 2 is opened

#ifdef _DEBUG

  std::stack<bool> fullState;</bool>

// state of each mask in the stack (except top mask).

// 'true' means opend; 'false' means close and enabled

// Used only for assert

#endif

  unsigned char m_writingMask;  // bit mask. The i-th bit=1 iff the i-th mask is

                                // opened to write

  unsigned char m_drawOnScreenMask;  // bitmsk.The ith bit=1 iff the ith mask

                                     // WRITE also ON SCREEN WHEN WRITE ON

                                     // STENCIL BIT PLANE

  unsigned char

      m_enabledMask;  // bit mask. The i-th bit=1 iff the i-th mask is enabled

  unsigned char

      m_inOrOutMask;  // bit mask. The i-th bit=1 iff the i-th mask is inside

  unsigned char m_drawOnlyOnceMask;

  Imp();

  void updateOpenGlState();

  void pushMask();

  // make a new stencil plane the current one.

  // if there is no plane available, increase a counter and does not push

  // (virtual masks)

  // So the same number of pop has no effect

  void popMask();

  // assert if the stencil stack contains only 0

  void beginMask(DrawMode drawMode);

  // clear the current stencil plane; start writing to it

  // if drawOnScreen is not 0, it writes also to the color buffer (or stencil

  // plane if another

  // mask is open). If drawOnScreen is 2, it drows only once (by stencil buffer)

  void endMask();

  // end writing to the stencil plane.

  void enableMask(MaskType maskType);

  void disableMask();

  // between enableMask()/disableMask() drawing is filtered by the values of the

  // current

  // stencil plane

  // n.b. enableMask()/disableMask() can be nidified. Between the inner pair

  // writing is enabled

  // according to the AND of all of them

};

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

TStencilControl::Imp::Imp()

    : m_stencilBitCount(0)

    , m_pushCount(1)

    , m_currentWriting(-1)

    , m_enabledMask(0)

    , m_writingMask(0)

    , m_inOrOutMask(0)

    , m_drawOnScreenMask(0)

    , m_drawOnlyOnceMask(0)

    , m_virtualState(0) {

  glGetIntegerv(GL_STENCIL_BITS, (GLint *)&m_stencilBitCount);

  glStencilMask(0xFFFFFFFF);

  // glClearStencil(0);

  glClear(GL_STENCIL_BUFFER_BIT);

}

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

TStencilControl *TStencilControl::instance() {

  StencilControlManager *instance = StencilControlManager::instance();

  return instance->getCurrentStencilControl();

}

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

TStencilControl::TStencilControl() : m_imp(new Imp) {}

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

TStencilControl::~TStencilControl() {}

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

void TStencilControl::Imp::updateOpenGlState() {

  if (m_currentWriting >= 0) {  // writing on stencil buffer

    unsigned char currentWritingMask = 1 << m_currentWriting;

    bool drawOnlyOnce = (currentWritingMask & m_drawOnlyOnceMask) != 0;

    if (currentWritingMask & m_drawOnScreenMask) {

      unsigned char lastWritingMask;

      int lastWriting = m_currentWriting - 1;

      for (; lastWriting >= 0; lastWriting--) {

        lastWritingMask = 1 << lastWriting;

        if ((lastWritingMask & m_writingMask) == lastWritingMask) break;

      }

      if (lastWriting < 0) {

        // glColorMask(1,1,1,1);

        if (drawOnlyOnce)

          m_enabledMask |= currentWritingMask;

        else

          m_enabledMask &= ~currentWritingMask;

      } else {

        tglMultColorMask(0, 0, 0, 0);

        // glDrawBuffer(GL_NONE);

        drawOnlyOnce = false;  // essendo solo un'effetto visivo, se sto

                               // scrivendo su una maschera e non a schermo, e'

                               // inutile

        currentWritingMask |= lastWritingMask;

      }

    } else

      tglMultColorMask(0, 0, 0, 0);

    // glDrawBuffer(GL_NONE);

    glStencilMask(currentWritingMask);

    if (drawOnlyOnce) {

      glStencilFunc(GL_EQUAL, m_inOrOutMask, m_enabledMask);

      glStencilOp(GL_KEEP, GL_INVERT, GL_INVERT);

    } else {

      glStencilFunc(GL_EQUAL, currentWritingMask | m_inOrOutMask,

                    m_enabledMask);

      glStencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);

    }

  } else {  // writing on screen buffer

    glStencilMask(0xFFFFFFFF);

    glStencilFunc(GL_EQUAL, m_inOrOutMask, m_enabledMask);

    glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);

    // glColorMask(1,1,1,1);

  }

  if (!m_enabledMask && m_currentWriting < 0)

    glDisable(GL_STENCIL_TEST);

  else

    glEnable(GL_STENCIL_TEST);

}

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

void TStencilControl::Imp::pushMask() { m_pushCount++; }

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

void TStencilControl::Imp::beginMask(DrawMode drawMode) {

  m_currentWriting          = m_pushCount - 1;

  unsigned char currentMask = 1 << m_currentWriting;

  m_writingMask |= currentMask;

  if (drawMode == DRAW_ALSO_ON_SCREEN) {

    m_drawOnScreenMask |= currentMask;

  } else if (drawMode == DRAW_ON_SCREEN_ONLY_ONCE) {

    m_drawOnScreenMask |= currentMask;

    m_drawOnlyOnceMask |= currentMask;

  } else {

    m_drawOnScreenMask &= ~currentMask;

    m_drawOnlyOnceMask &= ~currentMask;

  }

  glEnable(GL_STENCIL_TEST);

  glStencilMask(currentMask);      // enabled to modify only current bitPlane

  glClear(GL_STENCIL_BUFFER_BIT);  // and clear it

  updateOpenGlState();

}

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

void TStencilControl::Imp::endMask() {

  assert(m_pushCount - 1 == m_currentWriting);

  unsigned char currentMask = 1 << (m_pushCount - 1);

  m_writingMask &= ~currentMask;  // stop writing

  m_enabledMask &= ~currentMask;

  m_drawOnScreenMask &= ~currentMask;

  m_drawOnlyOnceMask &= ~currentMask;

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

  m_currentWriting--;

  for (; m_currentWriting >= 0; m_currentWriting--) {

    unsigned char currentWritingMask = 1 << m_currentWriting;

    if ((currentWritingMask & m_writingMask) == currentWritingMask) break;

  }

  updateOpenGlState();

}

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

void TStencilControl::Imp::enableMask(MaskType maskType) {

  unsigned char currentMask = 1 << (m_pushCount - 1);

  if ((m_enabledMask & currentMask) == 0) glPushAttrib(GL_ALL_ATTRIB_BITS);

  m_enabledMask |= currentMask;

  assert(maskType == SHOW_INSIDE || maskType == SHOW_OUTSIDE);

  if (maskType == SHOW_INSIDE)

    m_inOrOutMask |= currentMask;

  else

    m_inOrOutMask &= ~currentMask;

  updateOpenGlState();

}

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

void TStencilControl::Imp::disableMask() {

  unsigned char currentMask = 1 << (m_pushCount - 1);

  m_enabledMask &= ~currentMask;

  m_inOrOutMask &= ~currentMask;

  updateOpenGlState();

  glPopAttrib();

}

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

void TStencilControl::Imp::popMask() {

  --m_pushCount;

  assert(m_pushCount > 0);  // there is at least one mask in the stack

}

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

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

// questo forse e' un po' brutto:

// La maschera e' chiusa.

// Se e' abilitata,    open = push+open

// Se e' disabilitata, open =      open

void TStencilControl::beginMask(DrawMode drawMode) {

  glPushAttrib(GL_ALL_ATTRIB_BITS);

  if (m_imp->m_virtualState)  // opened or enabled

  {

#ifdef _DEBUG

    m_imp->fullState.push(m_imp->m_virtualState == 2);

#endif

    m_imp->pushMask();

  }

  m_imp->m_virtualState = 2;  // opened

  if (m_imp->m_pushCount <= m_imp->m_stencilBitCount)

    m_imp->beginMask(drawMode);

}

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

void TStencilControl::endMask() {

  if (!m_imp->m_virtualState)  // closed and disabled

  {

    m_imp->popMask();

#ifdef _DEBUG

    assert(m_imp->fullState.top());  // the state before last push must be

                                     // opened

    m_imp->fullState.pop();

#endif

  }

  assert(m_imp->m_virtualState != 1);  // yet closed

  m_imp->m_virtualState = 0;

  if (m_imp->m_pushCount <= m_imp->m_stencilBitCount) m_imp->endMask();

  glPopAttrib();

}

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

void TStencilControl::enableMask(MaskType maskType) {

  assert(m_imp->m_virtualState != 2);  // cannot enable an opened mask

  m_imp->m_virtualState = 1;  // enabled

  if (m_imp->m_pushCount <= m_imp->m_stencilBitCount)

    m_imp->enableMask(maskType);

}

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

void TStencilControl::disableMask() {

  assert(m_imp->m_virtualState != 2);  // cannot disable an opened mask

  if (!m_imp->m_virtualState)  // closed and disabled

  {

    m_imp->popMask();

#ifdef _DEBUG

    assert(

        !m_imp->fullState.top());  // the state before last push must be enabled

    m_imp->fullState.pop();

#endif

  }

  m_imp->m_virtualState = 0;  // close and disabled

  if (m_imp->m_pushCount <= m_imp->m_stencilBitCount) m_imp->disableMask();

}

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