/***********************************************************************************************************************
*
* Copyright (c) 2010 - 2025 by Tech Soft 3D, Inc.
* The information contained herein is confidential and proprietary to Tech Soft 3D, Inc., and considered a trade secret
* as defined under civil and criminal statutes. Tech Soft 3D shall pursue its civil and criminal remedies in the event
* of unauthorized use or misappropriation of its trade secrets. Use of this information by anyone other than authorized 
* employees of Tech Soft 3D, Inc. is granted only under a written non-disclosure agreement, expressly prescribing the 
* scope and manner of such use.
*
***********************************************************************************************************************/
/**
\file  callback_opengl.cpp

This file demonstrates how to programmatically visualize a PRC file from a basic OpenGL program using HOOPS Exchange.

***********************************************************************************************************************/

#define A3DAPI_DEPRECATED
#include <A3DSDKIncludes.h>
#include "callback_opengl.h"

#if !defined _MSC_VER && !defined CALLBACK
#define CALLBACK
#endif

#define _USE_MATH_DEFINES
#include <math.h>
#include <float.h>

#define IS_EQUAL(A, B) (fabs(A-B) < 1e-12 * (1 + (fabs(A) > fabs(B) ? fabs(A) : fabs(B))))



//######################################################################################################################
static int stiDisplayTriangles = 1;
static int stiDisplayTriangleNormals = 0;
static double stdDisplayTriangleNormalLength = 1;

//######################################################################################################################
int& DisplayTriangles() { return stiDisplayTriangles; }

//######################################################################################################################
int& DisplayTriangleNormals() { return stiDisplayTriangleNormals; }

//######################################################################################################################
double& DisplayTriangleNormalLength() { return stdDisplayTriangleNormalLength; }

//######################################################################################################################
A3DStatus DrawInitCallbacks(deprecated_A3DDrawCallbacksData* psCallbacks);

//######################################################################################################################
static double stDeterminant4x4(double const m[16])
{
	return m[12]*m[9]*m[6]*m[3] - m[8]*m[13]*m[6]*m[3] - m[12]*m[5]*m[10]*m[3] + m[4]*m[13]*m[10]*m[3]
	+ m[8]*m[5]*m[14]*m[3] - m[4]*m[9]*m[14]*m[3] - m[12]*m[9]*m[2]*m[7] + m[8]*m[13]*m[2]*m[7]
	+ m[12]*m[1]*m[10]*m[7] - m[0]*m[13]*m[10]*m[7] - m[8]*m[1]*m[14]*m[7] + m[0]*m[9]*m[14]*m[7]
	+ m[12]*m[5]*m[2]*m[11] - m[4]*m[13]*m[2]*m[11] - m[12]*m[1]*m[6]*m[11] + m[0]*m[13]*m[6]*m[11]
	+ m[4]*m[1]*m[14]*m[11] - m[0]*m[5]*m[14]*m[11] - m[8]*m[5]*m[2]*m[15] + m[4]*m[9]*m[2]*m[15]
	+ m[8]*m[1]*m[6]*m[15] - m[0]*m[9]*m[6]*m[15] - m[4]*m[1]*m[10]*m[15] + m[0]*m[5]*m[10]*m[15];
}

//######################################################################################################################
static bool stGenerateInverseMatrix4x4(const double m[16], double r[16])
{
	double d = stDeterminant4x4(m);
	if(d == 0.)
		return false;

	r[0] = (-m[13]*m[10]*m[7] +m[9]*m[14]*m[7] +m[13]*m[6]*m[11]-m[5]*m[14]*m[11] -m[9]*m[6]*m[15] +m[5]*m[10]*m[15])/d;
	r[4] = (m[12]*m[10]*m[7] -m[8]*m[14]*m[7] -m[12]*m[6]*m[11]+m[4]*m[14]*m[11] +m[8]*m[6]*m[15] -m[4]*m[10]*m[15])/d;
	r[8] = (-m[12]*m[9]*m[7] +m[8]*m[13]*m[7] +m[12]*m[5]*m[11]-m[4]*m[13]*m[11] -m[8]*m[5]*m[15] +m[4]*m[9]* m[15])/d;
	r[12] = (m[12]*m[9]*m[6] -m[8]*m[13]*m[6] -m[12]*m[5]*m[10]+m[4]*m[13]*m[10] +m[8]*m[5]*m[14] -m[4]*m[9]* m[14])/d;
	r[1] = (m[13]*m[10]*m[3] -m[9]*m[14]*m[3] -m[13]*m[2]*m[11]+m[1]*m[14]*m[11] +m[9]*m[2]*m[15] -m[1]*m[10]*m[15])/d;
	r[5] = (-m[12]*m[10]*m[3] +m[8]*m[14]*m[3] +m[12]*m[2]*m[11]-m[0]*m[14]*m[11] -m[8]*m[2]*m[15] +m[0]*m[10]*m[15])/d;
	r[9] = (m[12]*m[9]*m[3] -m[8]*m[13]*m[3] -m[12]*m[1]*m[11]+m[0]*m[13]*m[11] +m[8]*m[1]*m[15] -m[0]*m[9]* m[15])/d;
	r[13] = (-m[12]*m[9]*m[2] +m[8]*m[13]*m[2] +m[12]*m[1]*m[10]-m[0]*m[13]*m[10] -m[8]*m[1]*m[14] +m[0]*m[9]*m[14])/d;
	r[2] = (-m[13]*m[6]*m[3] +m[5]*m[14]*m[3] +m[13]*m[2]*m[7]-m[1]*m[14]*m[7] -m[5]*m[2]*m[15] +m[1]*m[6]*m[15])/d;
	r[6] = (m[12]*m[6]*m[3] -m[4]*m[14]*m[3] -m[12]*m[2]*m[7]+m[0]*m[14]*m[7] +m[4]*m[2]*m[15] -m[0]*m[6]*m[15])/d;
	r[10] = (-m[12]*m[5]*m[3] +m[4]*m[13]*m[3] +m[12]*m[1]*m[7]-m[0]*m[13]*m[7] -m[4]*m[1]*m[15] +m[0]*m[5]*m[15])/d;
	r[14] = (m[12]*m[5]*m[2] -m[4]*m[13]*m[2] -m[12]*m[1]*m[6]+m[0]*m[13]*m[6] +m[4]*m[1]*m[14] -m[0]*m[5]*m[14])/d;
	r[3] = (m[9]*m[6]*m[3] -m[5]*m[10]*m[3] -m[9]*m[2]*m[7]+m[1]*m[10]*m[7] +m[5]*m[2]*m[11] -m[1]*m[6]*m[11])/d;
	r[7] = (-m[8]*m[6]*m[3] +m[4]*m[10]*m[3] +m[8]*m[2]*m[7]-m[0]*m[10]*m[7] -m[4]*m[2]*m[11] +m[0]*m[6]*m[11])/d;
	r[11] = (m[8]*m[5]*m[3] -m[4]*m[9]*m[3] -m[8]*m[1]*m[7]+m[0]*m[9]*m[7] +m[4]*m[1]*m[11] -m[0]*m[5]*m[11])/d;
	r[15] = (-m[8]*m[5]*m[2] +m[4]*m[9]*m[2] +m[8]*m[1]*m[6]-m[0]*m[9]*m[6] -m[4]*m[1]*m[10] +m[0]*m[5]*m[10])/d;

	return true;
}

//######################################################################################################################
static void stTranfoPt(A3DDouble adMatrix[16], A3DDouble* adPt)
{
	A3DDouble adTmp[4];
	adTmp[0] = adPt[0] * adMatrix[0] + adPt[1] * adMatrix[4] + adPt[2] * adMatrix[8] + adMatrix[12];
	adTmp[1] = adPt[0] * adMatrix[1] + adPt[1] * adMatrix[5] + adPt[2] * adMatrix[9] + adMatrix[13];
	adTmp[2] = adPt[0] * adMatrix[2] + adPt[1] * adMatrix[6] + adPt[2] * adMatrix[10] + adMatrix[14];
	adTmp[3] =      1. * adMatrix[3] +      1. * adMatrix[7] +      1. * adMatrix[11] + adMatrix[15];
	adTmp[0] /= adTmp[3];
	adTmp[1] /= adTmp[3];
	adTmp[2] /= adTmp[3];

	memcpy(adPt, adTmp, 3*sizeof(A3DDouble));
}

//######################################################################################################################
void OpenGL_PushMatrix()
{
	glPushMatrix();

}

//######################################################################################################################
void OpenGL_PopMatrix()
{
	glPopMatrix();
}

//######################################################################################################################
void OpenGL_MultMatrix(const A3DDouble adMatrix[16])
{
	glMultMatrixd(adMatrix);
}

//######################################################################################################################
void OpenGL_GetMatrix(A3DDouble adMatrix[16])
{
	glGetDoublev(GL_MODELVIEW_MATRIX, adMatrix);
}

//######################################################################################################################
static void stOpenGL_TreatColorIndex(A3DUns32 uiRgbColorIndex, A3DBool* pbPush)
{
	if(uiRgbColorIndex != A3D_DEFAULT_COLOR_INDEX)
	{
		if(pbPush != NULL)
		{
			OpenGL_BeginMaterial();
			*pbPush = TRUE;
		}

		A3DGraphRgbColorData sRgbColorData;
		A3D_INITIALIZE_DATA(A3DGraphRgbColorData, sRgbColorData);
		if(A3DGlobalGetGraphRgbColorData(uiRgbColorIndex,&sRgbColorData) == A3D_SUCCESS)
		{
			A3DDouble adColor[3] = { sRgbColorData.m_dRed, sRgbColorData.m_dGreen, sRgbColorData.m_dBlue };
			OpenGL_Material(kA3DDrawMaterialDiffuse, adColor, 3);
		}

		A3DGlobalGetGraphRgbColorData(A3D_DEFAULT_COLOR_INDEX, &sRgbColorData);
	}
	else if(pbPush != NULL)
		*pbPush = FALSE;
}

//######################################################################################################################
static void stOpenGL_TreatLinePattern(A3DUns32 uiLinePatternIndex)
{
	if(uiLinePatternIndex != A3D_DEFAULT_LINEPATTERN_INDEX)
	{
		A3DGraphLinePatternData sPatternData;
		A3D_INITIALIZE_DATA(A3DGraphLinePatternData, sPatternData);
		if(A3DGlobalGetGraphLinePatternData(uiLinePatternIndex,&sPatternData) == A3D_SUCCESS)
		{
			glEnable(GL_LINE_STIPPLE);

			A3DDouble dLength = 0.;
			A3DUns32 i, j, p = 0;
			for(i=0; i < sPatternData.m_uiNumberOfLengths; ++i)
			{
				dLength += sPatternData.m_pdLengths[i];
			}

			//std::vector<A3DUns8> asByte;
			unsigned short usLineStipple = 0;
			for(i=0; i < sPatternData.m_uiNumberOfLengths; ++i)
			{
				A3DUns8 ucValue = (A3DUns8) floor(sPatternData.m_pdLengths[i]*16/dLength + 0.5);
				if(!(i%2))
				{
					for(j=0;j<ucValue;j++)
					{
						usLineStipple |= 1<<p;
						p++;
					}
				}
				else
				{
					p += ucValue;
				}
			}

			glLineStipple(2, usLineStipple);
		}
		A3DGlobalGetGraphLinePatternData(A3D_DEFAULT_LINEPATTERN_INDEX, &sPatternData);
	}
}

//######################################################################################################################
void OpenGL_Begin(A3DEDrawBeginEndType eType, const A3DUTF8Char* /* pcName */, A3DUns32 /* uiTrianglesCount */)
{
	switch(eType)
	{
	case kA3DDrawBeginEndMarkup :
		glPushAttrib(GL_LIGHTING_BIT | GL_COLOR_BUFFER_BIT );
		glDisable(GL_LIGHTING);
		break;
	default:
		break;
	}
}

//######################################################################################################################
void OpenGL_End(A3DEDrawBeginEndType eType)
{
	switch(eType)
	{
	case kA3DDrawBeginEndMarkup :
		glPopAttrib();
		break;
	default:
		break;
	}
}

//######################################################################################################################
inline void glVertex3d(const A3DVector3dData& aPoint)
{
	glVertex3d(aPoint.m_dX, aPoint.m_dY, aPoint.m_dZ);
}

//######################################################################################################################
inline void glNormal3d(const A3DVector3dData& aNormal)
{
	glNormal3d(aNormal.m_dX, aNormal.m_dY, aNormal.m_dZ);
}

//######################################################################################################################
// compute and call glNormal3d with a triangle normal
inline void glNormal3d_Triangle(const A3DVector3dData& sP1, const A3DVector3dData& sP2, const A3DVector3dData& sP3)
{
	A3DVector3dData sNormal;
	sNormal.m_dX = (sP2.m_dY - sP1.m_dY) * (sP3.m_dZ - sP2.m_dZ) - (sP2.m_dZ - sP1.m_dZ) * (sP3.m_dY - sP2.m_dY);
	sNormal.m_dY = (sP2.m_dZ - sP1.m_dZ) * (sP3.m_dX - sP2.m_dX) - (sP2.m_dX - sP1.m_dX) * (sP3.m_dZ - sP2.m_dZ);
	sNormal.m_dZ = (sP2.m_dX - sP1.m_dX) * (sP3.m_dY - sP2.m_dY) - (sP2.m_dY - sP1.m_dY) * (sP3.m_dX - sP2.m_dX);
	A3DDouble dLength = sqrt(sNormal.m_dX*sNormal.m_dX + sNormal.m_dY*sNormal.m_dY + sNormal.m_dZ*sNormal.m_dZ);

	sNormal.m_dX /= dLength;
	sNormal.m_dY /= dLength;
	sNormal.m_dZ /= dLength;

	glNormal3d(sNormal);
}

//######################################################################################################################
// call glNormal3d or compute the triangle normal if normal is null
inline void glNormal3d_OrTriangleNormalIfNull(const A3DVector3dData& aNormal, const A3DVector3dData& sP1,
											  const A3DVector3dData& sP2, const A3DVector3dData& sP3)
{
	if(aNormal.m_dX == 0 && aNormal.m_dY == 0 && aNormal.m_dZ == 0)
		glNormal3d_Triangle(sP1, sP2, sP3);
	else
		glNormal3d(aNormal);
}

//######################################################################################################################
inline void glTriangleNormal(const A3DVector3dData& sP1, const A3DVector3dData& sP2, const A3DVector3dData& sP3,
							 const A3DVector3dData* pN = NULL)
{
	A3DVector3dData sCenter;
	sCenter.m_dX = (sP1.m_dX+sP2.m_dX+sP3.m_dX)/3.;
	sCenter.m_dY = (sP1.m_dY+sP2.m_dY+sP3.m_dY)/3.;
	sCenter.m_dZ = (sP1.m_dZ+sP2.m_dZ+sP3.m_dZ)/3.;

	A3DVector3dData sNormal;

	if(pN)
	{
		sNormal.m_dX = (*pN).m_dX;
		sNormal.m_dY = (*pN).m_dY;
		sNormal.m_dZ = (*pN).m_dZ;
	}
	else
	{
		sNormal.m_dX = (sP2.m_dY - sP1.m_dY) * (sP3.m_dZ - sP2.m_dZ) - (sP2.m_dZ - sP1.m_dZ) * (sP3.m_dY - sP2.m_dY);
		sNormal.m_dY = (sP2.m_dZ - sP1.m_dZ) * (sP3.m_dX - sP2.m_dX) - (sP2.m_dX - sP1.m_dX) * (sP3.m_dZ - sP2.m_dZ);
		sNormal.m_dZ = (sP2.m_dX - sP1.m_dX) * (sP3.m_dY - sP2.m_dY) - (sP2.m_dY - sP1.m_dY) * (sP3.m_dX - sP2.m_dX);
		A3DDouble dLength = sqrt(sNormal.m_dX*sNormal.m_dX + sNormal.m_dY*sNormal.m_dY + sNormal.m_dZ*sNormal.m_dZ);

		sNormal.m_dX /= dLength;
		sNormal.m_dY /= dLength;
		sNormal.m_dZ /= dLength;
	}

	glVertex3d(sCenter.m_dX, sCenter.m_dY, sCenter.m_dZ);
	glVertex3d(sCenter.m_dX + sNormal.m_dX * stdDisplayTriangleNormalLength,
		sCenter.m_dY + sNormal.m_dY * stdDisplayTriangleNormalLength,
		sCenter.m_dZ + sNormal.m_dZ * stdDisplayTriangleNormalLength);

}

//######################################################################################################################
inline void glNormal(const A3DVector3dData& sP, const A3DVector3dData& sN)
{
	A3DVector3dData sPPlusN;
	sPPlusN.m_dX = sP.m_dX + sN.m_dX * stdDisplayTriangleNormalLength;
	sPPlusN.m_dY = sP.m_dY + sN.m_dY * stdDisplayTriangleNormalLength;
	sPPlusN.m_dZ = sP.m_dZ + sN.m_dZ * stdDisplayTriangleNormalLength;
	glVertex3d(sP);
	glVertex3d(sPPlusN);
}

//######################################################################################################################
inline void glTriangleNormals(const A3DVector3dData& sP1, const A3DVector3dData& sP2, const A3DVector3dData& sP3,
							  const A3DVector3dData& sN1, const A3DVector3dData& sN2, const A3DVector3dData& sN3)
{
	glNormal(sP1, sN1);
	glNormal(sP2, sN2);
	glNormal(sP3, sN3);
}

//######################################################################################################################
inline void glTriangleAndNormalDisplay(const A3DVector3dData& sP1, const A3DVector3dData& sP2,
									   const A3DVector3dData& sP3, const A3DVector3dData& sN1,
									   const A3DVector3dData& sN2, const A3DVector3dData& sN3,
									   bool bOneNormal = false)
{
	if(stiDisplayTriangles&2)
	{
		glColor3d(0, 0, 0);

		glVertex3d(sP1);
		glVertex3d(sP2);

		glVertex3d(sP2);
		glVertex3d(sP3);

		glVertex3d(sP3);
		glVertex3d(sP1);
	}

	if(stiDisplayTriangleNormals&1)
	{		
		glColor3d(0, 0, 1);
		glTriangleNormal(sP1, sP2, sP3);
	}

	if(stiDisplayTriangleNormals&2)
	{	
		glColor3d(0, 1, 0);
		if(bOneNormal)
			glTriangleNormal(sP1, sP2, sP3, &sN1);
		else
			glTriangleNormals(sP1, sP2, sP3, sN1, sN2, sN3);
	}
}

//######################################################################################################################
inline void glStartLineDrawing()
{
	glPushAttrib(GL_LIGHTING_BIT | GL_LINE_BIT | GL_TEXTURE_BIT);
	glDisable(GL_TEXTURE); 
	glDisable(GL_LIGHTING); 
	glLineWidth(2);
	glBegin(GL_LINES);
}

//######################################################################################################################
inline void glEndLineDrawing()
{
	glEnd();
	glPopAttrib();
}

//######################################################################################################################
void OpenGL_Triangle(const A3DVector3dData* pasNormals, const A3DVector3dData* pasPoints, A3DUns32 uiPointSize)
{
	if(stiDisplayTriangles&1)
	{
		glBegin(GL_TRIANGLES);
		for(A3DUns32 ui = 0; ui < uiPointSize; ++ui)
		{
			unsigned int uiTriangle = 3*(ui/3);
			glNormal3d_OrTriangleNormalIfNull(pasNormals[ui], pasPoints[uiTriangle], pasPoints[uiTriangle+1],
				pasPoints[uiTriangle+2]);
			glVertex3d(pasPoints[ui]);
		}
		glEnd();
	}

	glStartLineDrawing();
	for(A3DUns32 ui = 0; ui < uiPointSize/3; ++ui)
	{
		glTriangleAndNormalDisplay(pasPoints[ui*3], pasPoints[ui*3+1], pasPoints[ui*3+2], pasNormals[ui*3],
			pasNormals[ui*3+1], pasNormals[ui*3+2]);
	}
	glEndLineDrawing();
}

//######################################################################################################################
void OpenGL_TriangleFan(const A3DVector3dData* pasNormals, const A3DVector3dData* pasPoints, A3DUns32 uiPointSize)
{
	if(stiDisplayTriangles&1)
	{
		glBegin(GL_TRIANGLE_FAN);
		for(A3DUns32 ui = 0; ui < uiPointSize; ++ui)
		{
			glNormal3d(pasNormals[ui].m_dX, pasNormals[ui].m_dY, pasNormals[ui].m_dZ);
			glVertex3d(pasPoints[ui].m_dX, pasPoints[ui].m_dY, pasPoints[ui].m_dZ);
		}
		glEnd();
	}

	glStartLineDrawing();
	for(A3DUns32 ui = 2; ui < uiPointSize; ++ui)
	{
		glTriangleAndNormalDisplay(pasPoints[ui-1], pasPoints[ui], pasPoints[0], pasNormals[ui-1], pasNormals[ui],
			pasNormals[0]);
	}
	glEndLineDrawing();
}

//######################################################################################################################
void OpenGL_TriangleStripe(const A3DVector3dData* pasNormals, const A3DVector3dData* pasPoints, A3DUns32 uiPointSize)
{
	if(stiDisplayTriangles&1)
	{
		glBegin(GL_TRIANGLE_STRIP);
		for(A3DUns32 ui = 0; ui < uiPointSize; ++ui)
		{
			glNormal3d(pasNormals[ui].m_dX, pasNormals[ui].m_dY, pasNormals[ui].m_dZ);
			glVertex3d(pasPoints[ui].m_dX, pasPoints[ui].m_dY, pasPoints[ui].m_dZ);
		}
		glEnd();
	}

	glStartLineDrawing();
	for(A3DUns32 ui = 2; ui < uiPointSize; ++ui)
	{		
		if(ui%2 == 0)
		{
			glTriangleAndNormalDisplay(pasPoints[ui-2], pasPoints[ui-1], pasPoints[ui], pasNormals[ui-2],
				pasNormals[ui-1], pasNormals[ui]);
		}
		else
		{
			glTriangleAndNormalDisplay(pasPoints[ui-1], pasPoints[ui-2], pasPoints[ui], pasNormals[ui-1],
				pasNormals[ui-2], pasNormals[ui]);
		}
	}
	glEndLineDrawing();
}

//######################################################################################################################
void OpenGL_TriangleOneNormal(const A3DVector3dData* pasNormals, const A3DVector3dData* pasPoints, A3DUns32 uiPointSize)
{
	if(stiDisplayTriangles&1)
	{
		glBegin(GL_TRIANGLES);
		glNormal3d(pasNormals->m_dX, pasNormals->m_dY, pasNormals->m_dZ);
		for(A3DUns32 ui = 0; ui < uiPointSize; ++ui)
			glVertex3d(pasPoints[ui].m_dX, pasPoints[ui].m_dY, pasPoints[ui].m_dZ);
		glEnd();
	}

	glStartLineDrawing();
	for(A3DUns32 ui = 0; ui < uiPointSize/3; ++ui)
	{
		glTriangleAndNormalDisplay(pasPoints [ui*3  ],pasPoints [ui*3+1],pasPoints [ui*3+2], pasNormals[0],
			pasNormals[0], pasNormals[0], true);
	}
	glEndLineDrawing();
}

//######################################################################################################################
void OpenGL_TriangleFanOneNormal(const A3DVector3dData* psNormal, const A3DVector3dData* pasPoints,
								 A3DUns32 uiPointSize)
{
	if(stiDisplayTriangles&1)
	{
		glBegin(GL_TRIANGLE_FAN);
		glNormal3d(psNormal->m_dX, psNormal->m_dY, psNormal->m_dZ);
		for(A3DUns32 ui = 0; ui < uiPointSize; ++ui)
		{
			glVertex3d(pasPoints[ui].m_dX, pasPoints[ui].m_dY, pasPoints[ui].m_dZ);
		}
		glEnd();
	}

	glStartLineDrawing();
	for(A3DUns32 ui = 2; ui < uiPointSize; ++ui)
	{
		glTriangleAndNormalDisplay(pasPoints[ui-1], pasPoints[ui], pasPoints[0], psNormal[0], psNormal[0], psNormal[0],
			true);
	}
	glEndLineDrawing();
}

//######################################################################################################################
void OpenGL_TriangleStripeOneNormal(const A3DVector3dData* psNormal, const A3DVector3dData* pasPoints,
									A3DUns32 uiPointSize)
{
	if(stiDisplayTriangles&1)
	{
		glBegin(GL_TRIANGLE_STRIP);
		glNormal3d(psNormal->m_dX, psNormal->m_dY, psNormal->m_dZ);
		for(A3DUns32 ui = 0; ui < uiPointSize; ++ui)
		{
			glVertex3d(pasPoints[ui].m_dX, pasPoints[ui].m_dY, pasPoints[ui].m_dZ);
		}
		glEnd();
	}

	glStartLineDrawing();
	for(A3DUns32 ui = 2; ui < uiPointSize; ++ui)
	{		
		if(ui%2 == 0)
		{
			glTriangleAndNormalDisplay(pasPoints[ui-2], pasPoints[ui-1], pasPoints[ui], psNormal[0], psNormal[0],
				psNormal[0]);
		}
		else
		{
			glTriangleAndNormalDisplay(pasPoints[ui-1], pasPoints[ui-2], pasPoints[ui], psNormal[0], psNormal[0],
				psNormal[0]);
		}
	}
	glEndLineDrawing();
}

//######################################################################################################################
void OpenGL_TriangleTextured(const A3DVector3dData* pasNormals, const A3DVector3dData* pasPoints, A3DUns32 uiPointSize)
{
	OpenGL_Triangle(pasNormals, pasPoints, uiPointSize);
}

//######################################################################################################################
void OpenGL_TriangleFanTextured(const A3DVector3dData* pasNormals, const A3DVector3dData* pasPoints,
								A3DUns32 uiPointSize)
{
	OpenGL_TriangleFan(pasNormals, pasPoints, uiPointSize);
}

//######################################################################################################################
void OpenGL_TriangleStripeTextured(const A3DVector3dData* pasNormals, const A3DVector3dData* pasPoints,
								   A3DUns32 uiPointSize)
{
	OpenGL_TriangleStripe(pasNormals, pasPoints, uiPointSize);
}

//######################################################################################################################
void OpenGL_TriangleOneNormalTextured(const A3DVector3dData* pasNormals, const A3DVector3dData* pasPoints,
									  A3DUns32 uiPointSize)
{
	OpenGL_TriangleOneNormal(pasNormals, pasPoints, uiPointSize);
}

//######################################################################################################################
void OpenGL_TriangleFanOneNormalTextured(const A3DVector3dData* psNormal, const A3DVector3dData* pasPoints,
										 A3DUns32 uiPointSize)
{
	OpenGL_TriangleFanOneNormal(psNormal, pasPoints, uiPointSize);
}

//######################################################################################################################
void OpenGL_TriangleStripeOneNormalTextured(const A3DVector3dData* psNormal, const A3DVector3dData* pasPoints,
											A3DUns32 uiPointSize)
{
	OpenGL_TriangleStripeOneNormal(psNormal, pasPoints, uiPointSize);
}

//######################################################################################################################
void OpenGL_Color(const A3DDouble adValues[3])
{
	GLfloat afValues[3] = { static_cast<GLfloat>(adValues[0]), static_cast<GLfloat>(adValues[1]), static_cast<GLfloat>(adValues[2]) };
	glColor3fv(afValues);

}

//######################################################################################################################
void OpenGL_Material(A3DEDrawMaterialType eType, const A3DDouble* pdValues, A3DUns32 uiSize)
{
	if(uiSize == 1 && eType == kA3DDrawMaterialShininess)
	{
		GLfloat afValues[] = { static_cast<GLfloat>(pdValues[0]) };
		glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, afValues);
	}
	else
	{
		GLfloat afValues[4] = { static_cast<GLfloat>(pdValues[0]), static_cast<GLfloat>(pdValues[1]), static_cast<GLfloat>(pdValues[2]), static_cast<GLfloat>((uiSize == 4) ? pdValues[3] : 1) };

		GLenum glMaterialType = GL_AMBIENT;
		switch(eType)
		{
		case kA3DDrawMaterialDiffuse: glMaterialType = GL_DIFFUSE; break;
		case kA3DDrawMaterialAmbient: glMaterialType = GL_AMBIENT; break;
		case kA3DDrawMaterialEmission: glMaterialType = GL_EMISSION; break;
		case kA3DDrawMaterialShininess: return;
		default:
		break;
		}

		glMaterialfv(GL_FRONT_AND_BACK, glMaterialType, afValues);
	}
}

//######################################################################################################################
void OpenGL_BeginMaterial(void)
{
	glPushAttrib(GL_LIGHTING_BIT | GL_CURRENT_BIT);
}

//######################################################################################################################
void OpenGL_EndMaterial(void)
{
	glPopAttrib();
}

//######################################################################################################################
void OpenGL_GetDrawContext(A3DDouble /*adProjection*/[16], A3DDouble /*adModelView*/[16], A3DInt32 /*aiViewport*/[4])
{
}

//######################################################################################################################
void OpenGL_MarkupTriangle(const A3DDouble* pdPoints, A3DUns32 uiPointSize)
{
	const A3DDouble* pdData = &pdPoints[0];
	glBegin(GL_TRIANGLES);
	for(A3DUns32 ui = 0; ui < uiPointSize/3; ++ui)
	{
		glVertex3dv(pdData);
		pdData += 3;
		glVertex3dv(pdData);
		pdData += 3;
		glVertex3dv(pdData);
		pdData += 3;
	}
	glEnd();
}

//######################################################################################################################
void OpenGL_UnProject(const A3DVector3dData* psPoint, A3DVector3dData* psResult)
{
	double adProjection[16], adModelView[16];
	int aiViewport[4];
	glGetDoublev(GL_MODELVIEW_MATRIX, adModelView);
	glGetDoublev(GL_PROJECTION_MATRIX, adProjection);
	glGetIntegerv(GL_VIEWPORT, aiViewport);
	gluUnProject(psPoint->m_dX, psPoint->m_dY, psPoint->m_dZ, adModelView, adProjection, aiViewport,
		&psResult->m_dX, &psResult->m_dY, &psResult->m_dZ);
}

//######################################################################################################################
void OpenGL_BeginFrameDraw(const A3DVector3dData* psPoint3d, A3DBool bIsZoomable, A3DDouble dFixedSize)
{
	double adProjection[16], adModelView[16];
	int aiViewport[4];
	glGetDoublev(GL_MODELVIEW_MATRIX, adModelView);
	glGetDoublev(GL_PROJECTION_MATRIX, adProjection);
	glGetIntegerv(GL_VIEWPORT, aiViewport);
	double dXProj, dYProj, dZProj;
	gluProject(psPoint3d->m_dX, psPoint3d->m_dY, psPoint3d->m_dZ, adModelView, adProjection, aiViewport,
		&dXProj, &dYProj, &dZProj);

	glPushAttrib(GL_TRANSFORM_BIT | GL_VIEWPORT_BIT);

	glMatrixMode(GL_PROJECTION);
	glPushMatrix();
	glLoadIdentity();
	gluOrtho2D(0.0, aiViewport[2], 0.0, aiViewport[3]);

	glTranslated(dXProj, dYProj, 0.0);

	glMatrixMode(GL_MODELVIEW);
	glPushMatrix();
	glLoadIdentity();

	if(bIsZoomable)
		glScaled(1.0/dFixedSize, 1.0/dFixedSize, 1.0/dFixedSize);
}

//######################################################################################################################
void OpenGL_EndFrameDraw(void)
{
	glMatrixMode(GL_PROJECTION);
	glPopMatrix();

	glMatrixMode(GL_MODELVIEW);
	glPopMatrix();

	glPopAttrib();
}

//######################################################################################################################
static double stGetFixedSize(double dPX, double dPY, double dPZ)
{
	double adMv[16], adPj[16];
	int aiVp[4];
	glGetDoublev(GL_MODELVIEW_MATRIX, adMv);
	glGetDoublev(GL_PROJECTION_MATRIX, adPj);
	glGetIntegerv(GL_VIEWPORT, aiVp);

	double xProj, yProj, zProj;
	gluProject(dPX, dPY, dPZ, adMv, adPj, aiVp, &xProj, &yProj, &zProj);

	double x0, y0, z0;
	double x1, y1, z1;
	gluUnProject(aiVp[0], aiVp[2], zProj, adMv, adPj, aiVp, &x0, &y0, &z0);
	gluUnProject(aiVp[1], aiVp[3], zProj, adMv, adPj, aiVp, &x1, &y1, &z1);

	double dL = sqrt((x1-x0) * (x1-x0) + (y1-y0) * (y1-y0) + (z1-z0) * (z1-z0));

	double dD = dL/500.0;

	return dD;
}

//######################################################################################################################
void OpenGL_BeginFixedSize(const A3DVector3dData* psPoint3d)
{
#define SIZE_ARROW 15.0
	double dFixedSize = stGetFixedSize(psPoint3d->m_dX, psPoint3d->m_dY, psPoint3d->m_dZ);
	double dFixedSizeArrow = dFixedSize * SIZE_ARROW;
	glPushMatrix();
	glTranslated(psPoint3d->m_dX, psPoint3d->m_dY, psPoint3d->m_dZ);
	glScaled(dFixedSizeArrow, dFixedSizeArrow, dFixedSizeArrow);
}

//######################################################################################################################
void OpenGL_EndFixedSize(void)
{
	glPopMatrix();
}

//######################################################################################################################
void OpenGL_Cylinder(A3DDouble dBaseRadius, A3DDouble dTopRadius, A3DDouble dHeight)
{
	GLUquadricObj* qCylinder = gluNewQuadric();
	gluQuadricDrawStyle(qCylinder, GLU_FILL);
	gluCylinder(qCylinder, dBaseRadius, dTopRadius, dHeight, 8, 8);
	gluDeleteQuadric(qCylinder);
}

//######################################################################################################################
void OpenGL_Polygon(const A3DDouble* pdPoints, A3DUns32 uiPointSize)
{
	const A3DDouble* pdData = &pdPoints[0];
	glBegin(GL_POLYGON);
	for(A3DUns32 ui = 0; ui < uiPointSize; ++ui)
	{
		glVertex3dv(pdData);
		pdData += 3;
	}
	glEnd();
}

//######################################################################################################################
void OpenGL_BeginLineWidth(A3DDouble dWidth)
{
	glPushAttrib(GL_LINE_BIT);
	glLineWidth((GLfloat)dWidth);
}

//######################################################################################################################
void OpenGL_EndLineWidth(void)
{
	glPopAttrib();
}

//######################################################################################################################
void OpenGL_Point(const A3DDouble* pdPoints, A3DUns32 uiPointSize)
{
	const A3DDouble* pdData = &pdPoints[0];
	glBegin(GL_POINTS);
	for(A3DUns32 ui = 0; ui < uiPointSize; ++ui)
	{
		glVertex3dv(pdData);
		pdData += 3;
	}
	glEnd();
}


//######################################################################################################################
void OpenGL_Font(const A3DFontKeyData* /* psFontKeyData */)
{
}

//######################################################################################################################
void OpenGL_BeginLineStipple(const A3DGraphStyleData*  psGraphStyleData )
{
	glPushAttrib(GL_ENABLE_BIT | GL_LIGHTING_BIT | GL_CURRENT_BIT);
	glEnable(GL_LINE_STIPPLE);
	if(!psGraphStyleData->m_bVPicture)
	{
		stOpenGL_TreatLinePattern(psGraphStyleData->m_uiLinePatternIndex);
	}

}

//######################################################################################################################
void OpenGL_EndLineStipple(void)
{
	glDisable(GL_LINE_STIPPLE);
	glPopAttrib();
}

//######################################################################################################################
void OpenGL_Symbol(const A3DGraphVPicturePatternData* /* psPatternData */, const A3DVector3dData* /* psPosition */)
{
}

//######################################################################################################################
void OpenGL_PolyLine(const A3DDouble* pdPoints, A3DUns32 uiPointSize)
{
	const A3DDouble* pdData = &pdPoints[0];
	glBegin(GL_LINE_STRIP);
	for(A3DUns32 ui = 0; ui < uiPointSize; ++ui)
	{
		glVertex3dv(pdData);
		pdData += 3;
	}
	glEnd();
}

//######################################################################################################################
void OpenGL_Text(const A3DUTF8Char* /* pcBuffer */, A3DDouble dWidth, A3DDouble dHeight)
{
	// Draw only frame text
	if(dWidth > 0.0)
	{
		glBegin(GL_LINE_STRIP);
		glVertex2f(0.0f, 0.0f);
		glVertex2f((GLfloat) dWidth, 0.0f);
		glVertex2f((GLfloat) dWidth, (GLfloat) dHeight);
		glVertex2f(0.0f, (GLfloat) dHeight);
		glVertex2f(0.0f, 0.0f);
		glEnd();
	}
}

//######################################################################################################################
static void stOpenGL_Pattern_Start(A3DUns32 uiLoopsSize, const A3DDouble* pdPoints, const A3DUns32* puiLoopsPointSize,
								   A3DDouble* adMin, A3DDouble* adMax)
{
	adMin[0] = adMin[1] = adMin[2] = DBL_MAX;
	adMax[0] = adMax[1] = adMax[2] = -DBL_MAX;

	glPushAttrib(GL_STENCIL_BUFFER_BIT | GL_COLOR_BUFFER_BIT | GL_ENABLE_BIT | GL_CURRENT_BIT);
	glEnable(GL_STENCIL_TEST);
	glClearStencil(~2);
	glClear(GL_STENCIL_BUFFER_BIT);
	glStencilMask(2);

	glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
	glDisable(GL_DEPTH_TEST);
	glStencilFunc(GL_NOTEQUAL, 0x2, 0x2);
	glStencilOp(GL_ZERO, GL_REPLACE, GL_REPLACE);

	// Clipping
	glDisable(GL_CULL_FACE);
	A3DDouble const* psCurPt = pdPoints;
	A3DUns32 uiLoop;
	for(uiLoop = 0; uiLoop < uiLoopsSize; ++uiLoop)
	{
		A3DUns32 uiPt, uiNbPt = puiLoopsPointSize[uiLoop];
		if(uiNbPt > 0)
		{
			GLUtesselator* tobj = gluNewTess();
			gluTessCallback(tobj, GLU_TESS_BEGIN, (void (CALLBACK*) ()) glBegin);
			gluTessCallback(tobj, GLU_TESS_VERTEX, (void (CALLBACK*) ()) glVertex3dv);
			gluTessCallback(tobj, GLU_TESS_END, (void (CALLBACK*) ()) glEnd);

			gluTessEndPolygon(tobj);
			gluTessBeginContour(tobj);
			for(uiPt = 0; uiPt < uiNbPt; uiPt++, psCurPt += 3)
			{
				gluTessVertex(tobj, (GLdouble*) psCurPt, (void*) psCurPt);

				if(*psCurPt < adMin[0])
					adMin[0] = *psCurPt;
				else if(*psCurPt > adMax[0])
					adMax[0] = *psCurPt;

				if(*(psCurPt+1) < adMin[1])
					adMin[1] = *(psCurPt+1);
				else if(*(psCurPt+1) > adMax[1])
					adMax[1] = *(psCurPt+1);

				if(*(psCurPt+2) < adMin[2])
					adMin[2] = *(psCurPt+2);
				else if(*(psCurPt+2) > adMax[2])
					adMax[2] = *(psCurPt+2);
			}
			gluTessEndContour(tobj);
			gluTessEndPolygon(tobj);
			gluDeleteTess(tobj);
		}
	}

	glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);

	glStencilFunc(GL_EQUAL, 0x3, 0x3);
	glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
}

//######################################################################################################################
static void stOpenGL_Pattern_End()
{
	glPopAttrib();
}

//######################################################################################################################
static void stOpenGL_Pattern_HatchingLine_ComputeStep(A3DGraphHatchingPatternLineData const* psData,
													  A3DDouble& dStepX, A3DDouble& dStepY)
{
	double dTan = tan(psData->m_dAngle);

	if(!IS_EQUAL(psData->m_dAngle, 0.) && !IS_EQUAL(psData->m_dAngle, M_PI))
	{
		dStepX = psData->m_sOffset.m_dX;
		if(!IS_EQUAL(fabs(psData->m_dAngle), M_PI/2))
			dStepX -= psData->m_sOffset.m_dY / dTan;
	}
	else
	{
		dStepX = 0.f;
	}

	if(!IS_EQUAL(fabs(psData->m_dAngle), M_PI/2.))
	{
		dStepY = psData->m_sOffset.m_dY - psData->m_sOffset.m_dX * dTan;
	}
	else
	{
		dStepY = 0.f;
	}
}

//######################################################################################################################
static void stOpenGL_Pattern_HatchingLine_ComputeOccurrence(A3DGraphHatchingPatternLineData const* psData,
															A3DDouble const* adMin, A3DDouble const* adMax,
															A3DInt32& iOcLgMin, A3DInt32& iOcLgMax)
{
	A3DDouble dStepX, dStepY;
	stOpenGL_Pattern_HatchingLine_ComputeStep(psData, dStepX, dStepY);


	A3DInt32 iXMin = 0, iXMax = 0;
	if(fabs(dStepX) > 1e-12)
	{
		iXMax = -(int) ((psData->m_sStart.m_dX - adMin[0]) / dStepX);
		iXMin = -(int) ((psData->m_sStart.m_dX - adMax[0]) / dStepX);
		if(iXMin > iXMax)
		{
			int iTmp = iXMin;
			iXMin = iXMax;
			iXMax = iTmp;
		}
	}

	A3DInt32 iYMin = 0, iYMax = 0;
	if(fabs(dStepY) > 1e-12)
	{
		iYMax = -(int) ((psData->m_sStart.m_dY - adMin[1]) / dStepY);
		iYMin = -(int) ((psData->m_sStart.m_dY - adMax[1]) / dStepY);
		if(iYMin > iYMax)
		{
			int iTmp = iYMin;
			iYMin = iYMax;
			iYMax = iTmp;
		}
	}

	iOcLgMin = iXMin + iYMin - 1;
	iOcLgMax = iXMax + iYMax + 1;
}

//######################################################################################################################
static void stOpenGL_Pattern_HatchingLine(A3DGraphHatchingPatternLineData* psData, A3DUns32 /*uiBehavior*/,
										  A3DDouble const* adMin, A3DDouble const* adMax)
{
	bool bWithStipple = false;
	if(psData->m_uiStyleIndex != A3D_DEFAULT_STYLE_INDEX)
	{
		A3DGraphStyleData sStyleData;
		A3D_INITIALIZE_DATA(A3DGraphStyleData, sStyleData);

		if(A3DGlobalGetGraphStyleData(psData->m_uiStyleIndex, &sStyleData) == A3D_SUCCESS)
		{
			OpenGL_BeginLineStipple(&sStyleData);
			bWithStipple = true;
		}
	}

	A3DInt32 iOcLgMin, iOcLgMax, iOcLg;
	stOpenGL_Pattern_HatchingLine_ComputeOccurrence(psData, adMin, adMax, iOcLgMin, iOcLgMax);

	double dStartX = (psData->m_sStart.m_dX + iOcLgMin * psData->m_sOffset.m_dX);
	double dStartY = (psData->m_sStart.m_dY + iOcLgMin * psData->m_sOffset.m_dY);
	double dCos = cos(psData->m_dAngle);
	double dSin = sin(psData->m_dAngle);
	double dPatMin, dPatMax;
	bool bCosSupSin = fabs(dCos) > fabs(dSin);

	glBegin(GL_LINES);
	for(iOcLg = iOcLgMin; iOcLg < iOcLgMax; ++iOcLg)
	{
		if(bCosSupSin)
		{
			dPatMax = (adMin[0] - dStartX) / dCos;
			dPatMin = (adMax[0] - dStartX) / dCos;
		}
		else
		{
			dPatMax = (adMin[1] - dStartY) / dSin;
			dPatMin = (adMax[1] - dStartY) / dSin;
		}

		if(dPatMin>dPatMax)
		{
			double dTmp = dPatMin;
			dPatMin = dPatMax;
			dPatMax = dTmp;
		}

		glVertex2f(dStartX + dPatMin * dCos, dStartY + dPatMin * dSin);
		glVertex2f(dStartX + dPatMax * dCos, dStartY + dPatMax * dSin);

		dStartX += psData->m_sOffset.m_dX;
		dStartY += psData->m_sOffset.m_dY;
	}
	glEnd();

	if(bWithStipple)
	{
		OpenGL_EndLineStipple();
	}
}

//######################################################################################################################
static void stOpenGL_Pattern_Hatching(A3DUns32 uiPatternId, A3DUns32 uiBehavior, A3DDouble* adMin, A3DDouble* adMax)
{
	A3DGraphHatchingPatternData sData;
	A3D_INITIALIZE_DATA(A3DGraphHatchingPatternData, sData);

	if(A3DGlobalGetGraphHatchingPatternData(uiPatternId, &sData) != A3D_SUCCESS)
	{
		A3DGlobalGetGraphHatchingPatternData(A3D_DEFAULT_PATTERN_INDEX, &sData);
		return;
	}

	A3DUns32 uiLine;
	for(uiLine = 0; uiLine < sData.m_uiSize; ++uiLine)
	{
		stOpenGL_Pattern_HatchingLine(&sData.m_psHatchLines[uiLine], uiBehavior, adMin, adMax);
	}


	A3DGlobalGetGraphHatchingPatternData(A3D_DEFAULT_PATTERN_INDEX, &sData);
}

//######################################################################################################################
static void stOpenGL_Pattern_Solid(A3DUns32 uiPatternId, A3DUns32 /*uiBehavior*/, A3DDouble* adMin, A3DDouble* adMax)
{
	A3DGraphSolidPatternData sData;
	A3D_INITIALIZE_DATA(A3DGraphSolidPatternData, sData);

	if(A3DGlobalGetGraphSolidPatternData(uiPatternId, &sData) != A3D_SUCCESS)
		return;

	A3DBool bPush = FALSE;

	if(!sData.m_bMaterial)
	{
		stOpenGL_TreatColorIndex(sData.m_uiRgbColorIndex, &bPush);
	}
	else
	{
		// TODO ...
	}

	glBegin(GL_QUADS);
	glVertex3d(adMin[0], adMin[1], adMin[2]);
	glVertex3d(adMin[0], adMax[1], adMin[2]);
	glVertex3d(adMax[0], adMax[1], adMin[2]);
	glVertex3d(adMax[0], adMin[1], adMin[2]);
	glEnd();

	if(bPush)
		OpenGL_EndMaterial();
}

//######################################################################################################################
static void stOpenGL_Pattern_Dotting(A3DUns32 uiPatternId, A3DUns32 /*uiBehavior*/, A3DDouble* adMin, A3DDouble* adMax)
{
	A3DGraphDottingPatternData sData;
	A3D_INITIALIZE_DATA(A3DGraphDottingPatternData, sData);

	if(A3DGlobalGetGraphDottingPatternData(uiPatternId, &sData) != A3D_SUCCESS)
		return;

	A3DBool bPush;
	stOpenGL_TreatColorIndex(sData.m_uiColorIndex, &bPush);

	double dPitch = sData.m_dPitch;

	double dX, dY = adMin[1];
	double dXMax = adMax[0];
	double dYMax = adMax[1];

	glPointSize(0.5f);
	glBegin(GL_POINTS);
	if(sData.m_bZigZag)
	{
		double dPitch2 = dPitch * 2.f;
		double dXStart = adMin[0];

		for(; dY < dYMax; dY += dPitch2)
		{
			for(dX = dXStart; dX < dXMax; dX += dPitch)
			{
				glVertex2d(dX, dY);
			}
		}

		dXStart += dPitch/2.;
		dY = adMin[1] + dPitch;
		for(; dY < dYMax; dY += dPitch2)
		{
			for(dX = dXStart; dX < dXMax; dX += dPitch)
			{
				glVertex2d(dX, dY);
			}
		}
	}
	else
	{
		for(; dY < dYMax; dY += dPitch)
		{
			dX = adMin[0];
			for(; dX<dXMax; dX += dPitch)
			{
				glVertex2d(dX, dY);
			}
		}
	}

	glEnd();

	if(bPush)
		OpenGL_EndMaterial();
}

//######################################################################################################################
static void stOpenGL_Pattern_VPicture(A3DUns32 /*uiPatternId*/, A3DUns32 /*uiBehavior*/, A3DDouble* /*adMin*/, A3DDouble* /*adMax*/)
{
}

//######################################################################################################################
void OpenGL_Pattern(A3DUns32 uiLoopsSize, A3DUns32 uiPatternId, A3DUns32 /* uiFilledMode */, A3DUns32 uiBehavior,
					const A3DDouble* pdPoints, const A3DUns32* puiLoopsPointSize)
{
	A3DDouble adMin[3], adMax[3];
	stOpenGL_Pattern_Start(uiLoopsSize, pdPoints, puiLoopsPointSize, adMin, adMax);

	if(uiBehavior == 1)
	{
		A3DDouble adViewTransfo[16], adReverseViewTransfo[16];
		OpenGL_GetMatrix(adViewTransfo);
		adViewTransfo[12] = adViewTransfo[13] = adViewTransfo[14] = 0.;
		stGenerateInverseMatrix4x4(adViewTransfo, adReverseViewTransfo);

		OpenGL_PushMatrix();
		OpenGL_MultMatrix(adReverseViewTransfo);

		stTranfoPt(adViewTransfo, adMin);
		stTranfoPt(adViewTransfo, adMax);
	}

	A3DEEntityType ePatternType = kA3DTypeUnknown;
	A3DGlobalGetFillPatternType(uiPatternId, &ePatternType);
	switch(ePatternType)
	{
	case kA3DTypeGraphHatchingPattern:
		stOpenGL_Pattern_Hatching(uiPatternId, uiBehavior, adMin, adMax);
		break;
	case kA3DTypeGraphSolidPattern:
		stOpenGL_Pattern_Solid(uiPatternId, uiBehavior, adMin, adMax);
		break;
	case kA3DTypeGraphDottingPattern:
		stOpenGL_Pattern_Dotting(uiPatternId, uiBehavior, adMin, adMax);
		break;
	case kA3DTypeGraphVPicturePattern:
		stOpenGL_Pattern_VPicture(uiPatternId, uiBehavior, adMin, adMax);
		break;
	default:
		break;
	}


	if(uiBehavior == 1)
	{
		OpenGL_PopMatrix();
	}

	stOpenGL_Pattern_End();
}

//######################################################################################################################
void OpenGL_Picture(const A3DGraphPictureData* /* psPictureData */)
{
}

//######################################################################################################################
A3DStatus OpenGL_SetAndInitCallBack(deprecated_A3DDrawCallbacksData &sDrawCallbacksData)
{
	A3D_INITIALIZE_DATA(deprecated_A3DDrawCallbacksData, sDrawCallbacksData);

	sDrawCallbacksData.m_pfuncPushMatrix = OpenGL_PushMatrix;
	sDrawCallbacksData.m_pfuncPopMatrix = OpenGL_PopMatrix;
	sDrawCallbacksData.m_pfuncMultMatrix = OpenGL_MultMatrix;
	sDrawCallbacksData.m_pfuncBegin = OpenGL_Begin;
	sDrawCallbacksData.m_pfuncEnd = OpenGL_End;
	sDrawCallbacksData.m_pfuncTriangle = OpenGL_Triangle;
	sDrawCallbacksData.m_pfuncTriangleFan = OpenGL_TriangleFan;
	sDrawCallbacksData.m_pfuncTriangleStripe = OpenGL_TriangleStripe;
	sDrawCallbacksData.m_pfuncTriangleOneNormal = OpenGL_TriangleOneNormal;
	sDrawCallbacksData.m_pfuncTriangleFanOneNormal = OpenGL_TriangleFanOneNormal;
	sDrawCallbacksData.m_pfuncTriangleStripeOneNormal = OpenGL_TriangleStripeOneNormal;
	sDrawCallbacksData.m_pfuncTriangleTextured = OpenGL_TriangleTextured;
	sDrawCallbacksData.m_pfuncTriangleFanTextured = OpenGL_TriangleFanTextured;
	sDrawCallbacksData.m_pfuncTriangleStripeTextured = OpenGL_TriangleStripeTextured;
	sDrawCallbacksData.m_pfuncTriangleOneNormalTextured = OpenGL_TriangleOneNormal;
	sDrawCallbacksData.m_pfuncTriangleFanOneNormalTextured = OpenGL_TriangleFanOneNormalTextured;
	sDrawCallbacksData.m_pfuncTriangleStripeOneNormalTextured = OpenGL_TriangleStripeOneNormalTextured;
	sDrawCallbacksData.m_pfuncMaterial = OpenGL_Material;
	sDrawCallbacksData.m_pfuncColor = OpenGL_Color;
	sDrawCallbacksData.m_pfuncGetDrawContext = OpenGL_GetDrawContext;
	sDrawCallbacksData.m_pfuncMarkupTriangle = OpenGL_MarkupTriangle;
	sDrawCallbacksData.m_pfuncUnProject = OpenGL_UnProject;
	sDrawCallbacksData.m_pfuncBeginFrameDraw = OpenGL_BeginFrameDraw;
	sDrawCallbacksData.m_pfuncEndFrameDraw = OpenGL_EndFrameDraw;
	sDrawCallbacksData.m_pfuncBeginFixedSize = OpenGL_BeginFixedSize;
	sDrawCallbacksData.m_pfuncEndFixedSize = OpenGL_EndFixedSize;
	sDrawCallbacksData.m_pfuncCylinder = OpenGL_Cylinder;
	sDrawCallbacksData.m_pfuncPolygon = OpenGL_Polygon;
	sDrawCallbacksData.m_pfuncBeginLineWidth = OpenGL_BeginLineWidth;
	sDrawCallbacksData.m_pfuncEndLineWidth = OpenGL_EndLineWidth;
	sDrawCallbacksData.m_pfuncPoint = OpenGL_Point;
	sDrawCallbacksData.m_pfuncFont = OpenGL_Font;
	sDrawCallbacksData.m_pfuncBeginLineStipple = OpenGL_BeginLineStipple;
	sDrawCallbacksData.m_pfuncEndLineStipple = OpenGL_EndLineStipple;
	sDrawCallbacksData.m_pfuncSymbol = OpenGL_Symbol;
	sDrawCallbacksData.m_pfuncPolyLine = OpenGL_PolyLine;
	sDrawCallbacksData.m_pfuncText = OpenGL_Text;
	sDrawCallbacksData.m_pfuncPattern = OpenGL_Pattern;
	sDrawCallbacksData.m_pfuncPicture = OpenGL_Picture;
	sDrawCallbacksData.m_pfuncBeginMaterial = OpenGL_BeginMaterial;
	sDrawCallbacksData.m_pfuncEndMaterial = OpenGL_EndMaterial;

	return A3DORNOTDrawInitCallbacks(&sDrawCallbacksData);
}