#include "tstencilcontrol.h"
#include "tgl.h"
#include "tthreadmessage.h"
#include <stack>
 
#include <QThreadStorage>
 
//-----------------------------------------------------------------------------------------
 
namespace
{
 
//singleton
class StencilControlManager
{
 
	QThreadStorage<TStencilControl *> m_storage;
 
	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;
// 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();
}
 
//---------------------------------------------------------