Esempio n. 1
0
void RenderSoftGlare (CFloatVector *sprite, CFloatVector *vCenter, int nTexture, float fIntensity, int bAdditive, int bColored)
{
	tRgbaColorf color;
	tTexCoord2f	tcGlare [4] = {{{0,0}},{{1,0}},{{1,1}},{{0,1}}};
	int 			i;
	CBitmap*		bmP = NULL;

if (gameStates.render.bQueryCoronas) {
	glDisable (GL_TEXTURE_2D);
	glBlendFunc (GL_ONE, GL_ZERO);
	}
else {
	glEnable (GL_TEXTURE_2D);
	glDepthFunc (GL_ALWAYS);
	if (bAdditive)
		glBlendFunc (GL_ONE, GL_ONE);
	if (!(bmP = bAdditive ? bmpGlare : bmpCorona))
		return;
	}
if (gameStates.render.bAmbientColor)
	color = gameData.render.color.textures [nTexture].color;
else
	color.red = color.green = color.blue = X2F (IsLight (nTexture)) / 2;
if (!bColored)
	color.red = color.green = color.blue = (color.red + color.green + color.blue) / 4;
if (gameOptions [0].render.coronas.nStyle == 1)
	fIntensity = float (sqrt (fIntensity));
if (bAdditive)
	glColor4f (fIntensity * color.red, fIntensity * color.green, fIntensity * color.blue, 1);
else
	glColor4f (color.red, color.green, color.blue, fIntensity);
if (ogl.EnableClientStates (gameStates.render.bQueryCoronas == 0, 0, 0, GL_TEXTURE0)) {
	if (!gameStates.render.bQueryCoronas) {
		bmP->Bind (1);
		OglTexCoordPointer (2, GL_FLOAT, 0, tcGlare);
		}
	OglVertexPointer (3, GL_FLOAT, sizeof (CFloatVector), sprite);
	OglDrawArrays (GL_QUADS, 0, 4);
	ogl.DisableClientStates (gameStates.render.bQueryCoronas == 0, 0, 0, GL_TEXTURE0);
	}
else {
	if (gameStates.render.bQueryCoronas == 0)
		bmP->Bind (1);
	glBegin (GL_QUADS);
	for  (i = 0; i < 4; i++) {
		glTexCoord2fv (reinterpret_cast<GLfloat*> (tcGlare + i));
		glVertex3fv (reinterpret_cast<GLfloat*> (sprite + i));
		}
	glEnd ();
	}
if (!gameStates.render.bQueryCoronas && bAdditive)
	glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
RenderCoronaOutline (sprite, vCenter);
if (gameStates.render.bQueryCoronas != 2) {
	glEnable (GL_DEPTH_TEST);
	if (gameStates.render.bQueryCoronas == 1)
		glDepthFunc (GL_LEQUAL);
	}
}
Esempio n. 2
0
void RenderHardGlare (CFloatVector *sprite, CFloatVector *vCenter, int nTexture, float fLight,
							 float fIntensity, tIntervalf *zRangeP, int bAdditive, int bColored)
{
	tTexCoord2f	tcGlare [4] = {{{0,0}},{{1,0}},{{1,1}},{{0,1}}};
	tRgbaColorf	color;
	CBitmap*		bmP;
	int			i;

fLight /= 4;
if (fLight < 0.01f)
	return;
color.alpha = vCenter->Mag ();
if (color.alpha < zRangeP->fRad)
	fIntensity *= color.alpha / zRangeP->fRad;

if (gameStates.render.bAmbientColor) {
	color = gameData.render.color.textures [nTexture].color;
	color.alpha = (float) (color.red * 3 + color.green * 5 + color.blue * 2) / 30 * 2;
	}
else {
	color.alpha = X2F (IsLight (nTexture));
	color.red = color.green = color.blue = color.alpha / 2;
	color.alpha *= 2.0f / 3.0f;
	}
if (!bColored)
	color.red = color.green = color.blue = (color.red + color.green + color.blue) / 4;
color.alpha *= fIntensity * fIntensity;
if (color.alpha < 0.01f)
	return;
glEnable (GL_TEXTURE_2D);
if (!(bmP = bAdditive ? bmpGlare : bmpCorona))
	return;
bmP->SetTranspType (-1);
if (bmP->Bind (1))
	return;
bmP->Texture ()->Wrap (GL_CLAMP);
glDisable (GL_CULL_FACE);
if (bAdditive) {
	fLight *= color.alpha;
	glBlendFunc (GL_ONE, GL_ONE);
	}
glColor4fv (reinterpret_cast<GLfloat*> (&color));
glBegin (GL_QUADS);
for (i = 0; i < 4; i++) {
	glTexCoord2fv (reinterpret_cast<GLfloat*> (tcGlare + i));
	glVertex3fv (reinterpret_cast<GLfloat*> (sprite + i));
	}
glEnd ();
if (bAdditive)
	glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable (GL_CULL_FACE);
RenderCoronaOutline (sprite, vCenter);
}
Esempio n. 3
0
void RenderShadowTexture (void)
{
if (!(shadowProg ||
	   (CreateShaderProg (&shadowProg) &&
	    CreateShaderFunc (&shadowProg, &shadowFS, &shadowVS, pszShadowFS, pszShadowVS, 1) &&
	    LinkShaderProg (&shadowProg))))
	return;
glMatrixMode (GL_MODELVIEW);
glPushMatrix ();
glLoadIdentity ();
glMatrixMode (GL_PROJECTION);
glPushMatrix ();
glLoadIdentity ();
glOrtho (0, 1, 1, 0, 0, 1);
glDisable (GL_DEPTH_TEST);
glDepthMask (0);
#if 1
glDisable (GL_BLEND);
#else
glEnable (GL_BLEND);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
#endif
glEnable (GL_TEXTURE_2D);
ogl.SelectTMU (GL_TEXTURE0);
shadowBuf.SetTranspType (0);
if (shadowBuf.Bind (0))
	return;
glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
#if 0
glUseProgramObject (shadowProg);
glUniform1i (glGetUniformLocation (shadowProg, "shadowTex"), 0);
#endif
glBegin (GL_QUADS);
glTexCoord2d (0,0);
glVertex2d (0,0);
glTexCoord2d (1,0);
glVertex2d (0.5,0);
glTexCoord2d (1,-1);
glVertex2d (0.5,0.5);
glTexCoord2d (0,-1);
glVertex2d (0,0.5);
glEnd ();
if (ogl.m_states.bShadersOk)
	glUseProgramObject (0);
glEnable (GL_DEPTH_TEST);
glDepthMask (1);
glPopMatrix ();
glMatrixMode (GL_MODELVIEW);
glPopMatrix ();
}
Esempio n. 4
0
int LoadAddonBitmap (CBitmap **bmPP, const char *pszName, int *bHaveP)
{
if (!*bHaveP) {
	char	szFilename [FILENAME_LEN];
	CFile	cf;

	sprintf (szFilename, "%s/d2x-xl/%s", gameFolders.szTextureDir [2], pszName);
	if (!cf.Exist (szFilename, "", 0))
		sprintf (szFilename, "%s/d2x-xl/%s", gameFolders.szTextureDir [0], pszName);
	CBitmap *bmP = CreateAndReadTGA (szFilename);
	if (!bmP)
		*bHaveP = -1;
	else {
		*bHaveP = 1;
		bmP->SetFrameCount ();
		bmP->SetTranspType (-1);
		bmP->Bind (1);
		}
	*bmPP = bmP;
	}
return *bHaveP > 0;
}
Esempio n. 5
0
CBitmap* CBackgroundManager::LoadBackground (char* filename)
{
	int width, height;

if (PCXGetDimensions (filename, &width, &height) != PCX_ERROR_NONE) {
	Error ("Could not open menu background file <%s>\n", filename);
	return NULL;
	}
CBitmap* bmP;
if (!(bmP = CBitmap::Create (0, width, height, 1))) {
	Error ("Not enough memory for menu backgroun\n");
	return NULL;
	}
if (PCXReadBitmap (filename, bmP, bmP->Mode (), 0) != PCX_ERROR_NONE) {
	Error ("Could not read menu background file <%s>\n", filename);
	return NULL;
	}
bmP->SetName (filename);
bmP->SetTranspType (3);
bmP->Bind (0);
return bmP;
}
Esempio n. 6
0
int CParticle::Render (float brightness)
{
	CFixVector				hp;
	GLfloat					d, u, v;
	CBitmap*					bmP;
	tRgbaColorf				pc;
	tParticleVertex*		pb;
	CFloatVector			vOffset, vCenter;
	int						i, nFrame, nType = m_nType, bEmissive = m_bEmissive;
	float						decay = (nType == BUBBLE_PARTICLES) ? 1.0f : (float) m_nLife / (float) m_nTTL;

	static int				nFrames = 1;
	static float			deltaUV = 1.0f;
	static tSinCosf		sinCosPart [PARTICLE_POSITIONS];
	static int				bInitSinCos = 1;
	static CFloatMatrix	mRot;

if (m_nDelay > 0)
	return 0;
if ((nType < 0) || (nType >= PARTICLE_TYPES))
	return 0;
if (!(bmP = bmpParticle [0][nType]))
	return 0;
if (bmP->CurFrame ())
	bmP = bmP->CurFrame ();
if (gameOpts->render.bDepthSort > 0) {
	hp = m_vTransPos;
	if ((particleManager.LastType () != nType) || (brightness != bufferBrightness) || (bBufferEmissive != bEmissive)) {
		particleManager.FlushBuffer (brightness);
		particleManager.SetLastType (nType);
		bBufferEmissive = bEmissive;
		ogl.SelectTMU (GL_TEXTURE0, true);
		if (bmP->Bind (0))
			return 0;
		nFrames = nParticleFrames [0][nType];
		deltaUV = 1.0f / (float) nFrames;
		if (m_bEmissive)
			//glBlendFunc (GL_ONE, GL_ONE);
			glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_COLOR);
		else
			glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
		}
	}
else if (gameOpts->render.particles.bSort) {
	hp = m_vTransPos;
	if ((particleManager.LastType () != nType) || (brightness != bufferBrightness)) {
		particleManager.FlushBuffer (brightness);
		particleManager.SetLastType (nType);
		if (bmP->Bind (0))
			return 0;
		nFrames = nParticleFrames [0][nType];
		deltaUV = 1.0f / (float) nFrames;
		if (m_bEmissive)
			glBlendFunc (GL_ONE, GL_ONE);
		else
			glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
		}
	}
else
	transformation.Transform(hp, m_vPos, 0);
if (m_bBright)
	brightness = (float) sqrt (brightness);
if (nType == SMOKE_PARTICLES) {
	if (m_nFade > 0) {
		if (m_color [0].green < m_color [1].green) {
#if SMOKE_SLOWMO
			m_color [0].green += 1.0f / 20.0f / (float) gameStates.gameplay.slowmo [0].fSpeed;
#else
			m_color [0].green += 1.0f / 20.0f;
#endif
			if (m_color [0].green > m_color [1].green) {
				m_color [0].green = m_color [1].green;
				m_nFade--;
				}
			}
		if (m_color [0].blue < m_color [1].blue) {
#if SMOKE_SLOWMO
			m_color [0].blue += 1.0f / 10.0f / (float) gameStates.gameplay.slowmo [0].fSpeed;
#else
			m_color [0].blue += 1.0f / 10.0f;
#endif
			if (m_color [0].blue > m_color [1].blue) {
				m_color [0].blue = m_color [1].blue;
				m_nFade--;
				}
			}
		}
	else if (m_nFade == 0) {
		m_color [0].red = m_color [1].red * RANDOM_FADE;
		m_color [0].green = m_color [1].green * RANDOM_FADE;
		m_color [0].blue = m_color [1].blue * RANDOM_FADE;
		m_nFade = -1;
		}
	}
pc = m_color [0];
//pc.alpha *= /*gameOpts->render.particles.bDisperse ? decay2 :*/ decay;
if ((nType == SMOKE_PARTICLES) || (nType == BUBBLE_PARTICLES)) {
	char nFrame = ((nType == BUBBLE_PARTICLES) && !gameOpts->render.particles.bWobbleBubbles) ? 0 : m_nFrame;
	u = (float) (nFrame % nFrames) * deltaUV;
	v = (float) (nFrame / nFrames) * deltaUV;
	d = deltaUV;
	}
else {
	u = v = 0.0f;
	d = 1.0f;
	}
if (nType == SMOKE_PARTICLES) {
#if 0
	if (SHOW_DYN_LIGHT) {
		tFaceColor *psc = AvgSgmColor (m_nSegment, NULL);
		pc.red *= (float) psc->color.red;
		pc.green *= (float) psc->color.green;
		pc.blue *= (float) psc->color.blue;
		}
#endif
	brightness *= 0.9f + (float) (rand () % 1000) / 5000.0f;
	pc.red *= brightness;
	pc.green *= brightness;
	pc.blue *= brightness;
	}
vCenter.Assign (hp);
i = m_nOrient;
if (bEmissive) { //scale light trail particle color to reduce saturation
	pc.red /= 50.0f;
	pc.green /= 50.0f;
	pc.blue /= 50.0f;
	}
else if (m_nType != BUBBLE_PARTICLES) {
#if 0
	pc.alpha = (pc.alpha - 0.005f) * decay + 0.005f;
#	if 1
	pc.alpha = (float) pow (pc.alpha * pc.alpha, 1.0 / 3.0);
#	endif
#else
	float fFade = (float) cos ((double) sqr (1 - decay) * Pi) / 2.0f + 0.5f;
	pc.alpha *= fFade;
#endif
	pc.alpha *= 0.6f; //alphaScale [gameOpts->render.particles.nAlpha [gameOpts->render.particles.bSyncSizes ? 0 : m_nClass]];
	}
if (pc.alpha < 1.0 / 255.0) {
	m_nLife = 0;
	return 0;
	}
#if 0
if (!lightManager.Headlights ().nLights && (pc.red + pc.green + pc.blue < 0.001)) {
	m_nLife = 0;
	return 0;
	}
#endif
if ((nType == SMOKE_PARTICLES) && gameOpts->render.particles.bDisperse) {
#if 0
	decay = (float) sqrt (decay);
#else
	decay = (float) pow (decay * decay * decay, 1.0f / 5.0f);
#endif
	vOffset [X] = X2F (m_nWidth) / decay;
	vOffset [Y] = X2F (m_nHeight) / decay;
	}
else {
	vOffset [X] = X2F (m_nWidth) * decay;
	vOffset [Y] = X2F (m_nHeight) * decay;
	}
vOffset [Z] = 0;
pb = particleBuffer + iBuffer;
pb [i].texCoord.v.u =
pb [(i + 3) % 4].texCoord.v.u = u;
pb [i].texCoord.v.v =
pb [(i + 1) % 4].texCoord.v.v = v;
pb [(i + 1) % 4].texCoord.v.u =
pb [(i + 2) % 4].texCoord.v.u = u + d;
pb [(i + 2) % 4].texCoord.v.v =
pb [(i + 3) % 4].texCoord.v.v = v + d;
pb [0].color =
pb [1].color =
pb [2].color =
pb [3].color = pc;
if ((nType == BUBBLE_PARTICLES) && gameOpts->render.particles.bWiggleBubbles)
	vCenter [X] += (float) sin (m_nFrame / 4.0f * Pi) / (10 + rand () % 6);
if (!nType && gameOpts->render.particles.bRotate) {
	if (bInitSinCos) {
		ComputeSinCosTable (sizeofa (sinCosPart), sinCosPart);
		bInitSinCos = 0;
		mRot.RVec ()[Z] =
		mRot.UVec ()[Z] =
		mRot.FVec ()[X] =
		mRot.FVec ()[Y] = 0;
		mRot.FVec ()[Z] = 1;
		}
	nFrame = (m_nOrient & 1) ? 63 - m_nRotFrame : m_nRotFrame;
	mRot.RVec ()[X] =
	mRot.UVec ()[Y] = sinCosPart [nFrame].fCos;
	mRot.UVec ()[X] = sinCosPart [nFrame].fSin;
	mRot.RVec ()[Y] = -mRot.UVec ()[X];
	vOffset = mRot * vOffset;
	pb [0].vertex [X] = vCenter [X] - vOffset [X];
	pb [0].vertex [Y] = vCenter [Y] + vOffset [Y];
	pb [1].vertex [X] = vCenter [X] + vOffset [Y];
	pb [1].vertex [Y] = vCenter [Y] + vOffset [X];
	pb [2].vertex [X] = vCenter [X] + vOffset [X];
	pb [2].vertex [Y] = vCenter [Y] - vOffset [Y];
	pb [3].vertex [X] = vCenter [X] - vOffset [Y];
	pb [3].vertex [Y] = vCenter [Y] - vOffset [X];
	pb [0].vertex [Z] =
	pb [1].vertex [Z] =
	pb [2].vertex [Z] =
	pb [3].vertex [Z] = vCenter [Z];
	}
else {
	pb [0].vertex [X] =
	pb [3].vertex [X] = vCenter [X] - vOffset [X];
	pb [1].vertex [X] =
	pb [2].vertex [X] = vCenter [X] + vOffset [X];
	pb [0].vertex [Y] =
	pb [1].vertex [Y] = vCenter [Y] + vOffset [Y];
	pb [2].vertex [Y] =
	pb [3].vertex [Y] = vCenter [Y] - vOffset [Y];
	pb [0].vertex [Z] =
	pb [1].vertex [Z] =
	pb [2].vertex [Z] =
	pb [3].vertex [Z] = vCenter [Z];
	}
iBuffer += 4;
if (iBuffer >= VERT_BUF_SIZE)
	particleManager.FlushBuffer (brightness);
if (particleManager.Animate ()) {
	m_nFrame = (m_nFrame + 1) % (nFrames * nFrames);
	if (!(nType || (m_nFrame & 1)))
		m_nRotFrame = (m_nRotFrame + 1) % 64;
	}
if (gameOpts->render.bDepthSort > 0)
	glEnd ();
return 1;
}
Esempio n. 7
0
int CSubModel::Draw (CObject *objP, CModel *po, float *fLight)
{
	CFace*			pf;
	CFaceVert*		pfv;
	CFloatVector*	pv, * pvn, * phv;
	tFaceColor*		pvc, vc, sc = {{1,1,1,1}};
	CBitmap			*bmP;
	int				h, i, j;
	int				bBright = EGI_FLAG (bBrightObjects, 0, 1, 0);
	int				bDynLighting = gameStates.render.bApplyDynLight;
	float				fl, r, g, b, fAlpha = po->m_fAlpha;

#if DBG_SHADOWS
if (bShadowTest && (bShadowTest < 4))
	return 1;
#endif
pv = m_rotVerts.Buffer ();
pvn = m_normals.Buffer ();
pvc = m_vertColors.Buffer ();
//memset (pvc, 0, m_nVerts * sizeof (tFaceColor));
glEnable (GL_CULL_FACE);
OglCullFace (0);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
if (!bDynLighting) {
	sc = *lightManager.AvgSgmColor (objP->info.nSegment, &objP->info.position.vPos);
	if (sc.index != gameStates.render.nFrameFlipFlop + 1)
		sc.color.red = sc.color.green = sc.color.blue = 1;
	}
for (i = m_faces.m_nFaces, pf = m_faces.m_list.Buffer (); i; i--, pf++) {
	if (pf->m_bReverse)
		glFrontFace (GL_CCW);
	pfv = pf->m_verts;
#if 0
	if (!(gameStates.ogl.bUseTransform || OOF_FrontFace (pso, pf)))
		continue;
#endif
	if (pf->m_bTextured) {
#if DBG
		fl = pf->m_vNormal * mView.FVec();
		fl = 0.75f + 0.25f * fl;
		fl = fl * *fLight;
#else
		fl = *fLight * (0.75f - 0.25f * (pf->m_vNormal * mView.FVec ()));
#endif
		if (fl > 1)
			fl = 1;
//		fl = 1.0f;
		bmP = po->m_textures.m_bitmaps + pf->m_texProps.nTexId;
		if (bmP->Texture () && ((int) bmP->Texture ()->Handle () < 0))
			bmP->Texture ()->SetHandle (0);
		bmP->SetTranspType (0);
		if (bmP->Bind (1))
			return 0;
		bmP->Texture ()->Wrap (GL_REPEAT);
		if (m_nFlags & (bDynLighting ? OOF_SOF_THRUSTER : (OOF_SOF_GLOW | OOF_SOF_THRUSTER))) {
			glColor4f (fl * m_glowInfo.m_color.red, 
						  fl * m_glowInfo.m_color.green, 
						  fl * m_glowInfo.m_color.blue, 
						  m_pfAlpha [pfv->m_nIndex] * fAlpha);
			}
		else if (!bDynLighting) {
#if 0
			fl = (float) sqrt (fl);
#endif
			if (bBright)
#if 1
				fl += (1 - fl) / 2;
#else
				fl = (float) sqrt (fl);
#endif
			glColor4f (sc.color.red * fl, sc.color.green * fl, sc.color.blue * fl,
						  m_pfAlpha [pfv->m_nIndex] * fAlpha);
			}
		glBegin (GL_TRIANGLE_FAN);
		for (j = pf->m_nVerts; j; j--, pfv++) {
			phv = pv + (h = pfv->m_nIndex);
			if (bDynLighting) {
				if (pvc [h].index != gameStates.render.nFrameFlipFlop + 1)
					G3VertexColor (reinterpret_cast<CFloatVector3*> (pvn + h), reinterpret_cast<CFloatVector3*> (phv), -1, pvc + h, NULL, 1, 0, 0);
				vc.color.red = (float) sqrt (pvc [h].color.red);
				vc.color.green = (float) sqrt (pvc [h].color.green);
				vc.color.blue = (float) sqrt (pvc [h].color.blue);
				if (bBright) {
#if 1
					vc.color.red += (1 - vc.color.red) / 2;
					vc.color.green += (1 - vc.color.green) / 2;
					vc.color.blue += (1 - vc.color.blue) / 2;
#else
					vc.color.red = (float) sqrt (vc.color.red);
					vc.color.green = (float) sqrt (vc.color.green);
					vc.color.blue = (float) sqrt (vc.color.blue);
#endif
					}
				OglColor4sf (vc.color.red, vc.color.green, vc.color.blue, m_pfAlpha [pfv->m_nIndex] * fAlpha);
				}
			glTexCoord2f (pfv->m_fu, pfv->m_fv);
			glVertex3fv (reinterpret_cast<GLfloat*> (phv));
			//glVertex4f (phv->m_x, phv->m_y, phv->m_z, 0.5);
			}
		glEnd ();
#if DBG_SHADOWS
		if (pf->m_bFacingLight && (bShadowTest > 3)) {
				CFloatVector	fv0;

			glLineWidth (3);
			glColor4f (1.0f, 0.0f, 0.5f, 1.0f);
			glBegin (GL_LINES);
			fv0 = pf->m_vRotCenter;
			glVertex3fv (reinterpret_cast<GLfloat*> (&fv0));
			fv0 += pf->m_vRotNormal;
			glVertex3fv (reinterpret_cast<GLfloat*> (&fv0));
			glEnd ();
			glColor4f (0.0f, 1.0f, 0.5f, 1.0f);
			glBegin (GL_LINES);
			fv0 = pf->m_vRotCenter;
			glVertex3fv (reinterpret_cast<GLfloat*> (&fv0));
			fv0 = vrLightPos;
			glVertex3fv (reinterpret_cast<GLfloat*> (&fv0));
			glEnd ();
			glLineWidth (1);
			}
#endif
		}
	else {
		fl = fLight [1];
		r = fl * (float) pf->m_texProps.color.red / 255.0f;
		g = fl * (float) pf->m_texProps.color.green / 255.0f;
		b = fl * (float) pf->m_texProps.color.blue / 255.0f;
		glColor4f (r, g, b, m_pfAlpha [pfv->m_nIndex] * fAlpha);
		glBegin (GL_TRIANGLE_FAN);
		for (j = pf->m_nVerts, pfv = pf->m_verts; j; j--, pfv++) {
			glVertex3fv (reinterpret_cast<GLfloat*> (pv + pfv->m_nIndex));
			}
		glEnd ();
		}
	if (pf->m_bReverse)
		glFrontFace (GL_CW);
	}
return 1;
}