void glDrawVolume(DrawVolumeFunc drawFunc, const void* data)
{
glDepthMask(GL_FALSE);
glEnable(GL_DEPTH_TEST);
glEnable(GL_DEPTH_CLAMP_NV);
glEnable(GL_STENCIL_TEST);
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
// using zfail method to avoid doing the inside check
if (GLEW_EXT_stencil_two_side && GL_EXT_stencil_wrap) {
glDisable(GL_CULL_FACE);
glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT);
glActiveStencilFaceEXT(GL_BACK);
glStencilMask(~0);
glStencilOp(GL_KEEP, GL_DECR_WRAP, GL_KEEP);
glStencilFunc(GL_ALWAYS, 0, ~0);
glActiveStencilFaceEXT(GL_FRONT);
glStencilMask(~0);
glStencilOp(GL_KEEP, GL_INCR_WRAP, GL_KEEP);
glStencilFunc(GL_ALWAYS, 0, ~0);
drawFunc(data); // draw
glDisable(GL_STENCIL_TEST_TWO_SIDE_EXT);
} else {
glEnable(GL_CULL_FACE);
glStencilMask(~0);
glStencilFunc(GL_ALWAYS, 0, ~0);
glCullFace(GL_FRONT);
glStencilOp(GL_KEEP, GL_INCR, GL_KEEP);
drawFunc(data); // draw
glCullFace(GL_BACK);
glStencilOp(GL_KEEP, GL_DECR, GL_KEEP);
drawFunc(data); // draw
glDisable(GL_CULL_FACE);
}
glDisable(GL_DEPTH_TEST);
glStencilFunc(GL_NOTEQUAL, 0, ~0);
glStencilOp(GL_ZERO, GL_ZERO, GL_ZERO); // clear as we go
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
drawFunc(data); // draw
glDisable(GL_DEPTH_CLAMP_NV);
glDisable(GL_STENCIL_TEST);
glEnable(GL_DEPTH_TEST);
}
// generic 1-pass version
static void ss_EXT_1pass()
{
glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT);
glDisable(GL_CULL_FACE);
glStencilMask(~0);
glActiveStencilFaceEXT(GL_BACK);
glStencilOp(GL_KEEP, GL_KEEP, ss_op_depth_pass_back);
glStencilFunc(GL_ALWAYS, 0, ~0);
glActiveStencilFaceEXT(GL_FRONT);
glStencilOp(GL_KEEP, GL_KEEP, ss_op_depth_pass_front);
glStencilFunc(GL_ALWAYS, 0, ~0);
pie_ShadowDrawLoop();
glDisable(GL_STENCIL_TEST_TWO_SIDE_EXT);
}
void e_endpass(e_device_t* device,unsigned int pass)
{
glPopAttrib();
switch(pass)
{
case E_RENDER_MESHES:
glDisable(GL_VERTEX_PROGRAM_ARB);
glDisable(GL_FRAGMENT_PROGRAM_ARB);
break;
case E_RENDER_SHADOWS:
//Disable those extensions manually
glDisable(GL_VERTEX_PROGRAM_ARB);
if(glActiveStencilFaceEXT)
{
glActiveStencilFaceEXT(GL_FRONT_AND_BACK);
glDisable(GL_STENCIL_TEST_TWO_SIDE_EXT);
}
glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE);
glDepthMask(GL_TRUE);
break;
case E_RENDER_SHADING:
glDisable(GL_VERTEX_PROGRAM_ARB);
glDisable(GL_FRAGMENT_PROGRAM_ARB);
glDepthFunc(GL_LESS);
break;
case E_RENDER_OUTLINES:
glColor3ub(255,255,255);
glLineWidth(1.0f);
break;
}
}
static void render_shadow(asset_t a, renderer_t r, light_t l)
{
#if 1
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
glDepthMask(GL_FALSE);
if ( GLEW_EXT_stencil_two_side ) {
glDisable(GL_CULL_FACE);
glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT);
}else{
glEnable(GL_CULL_FACE);
}
glEnable(GL_STENCIL_TEST);
glEnable(GL_POLYGON_OFFSET_FILL);
glPolygonOffset(0.0f, 100.0f);
if ( GLEW_EXT_stencil_two_side ) {
glActiveStencilFaceEXT(GL_BACK);
glStencilFunc(GL_ALWAYS, 0, ~0);
glStencilOp(GL_KEEP, GL_KEEP, GL_INCR_WRAP_EXT);
}else{
glCullFace(GL_BACK);
glStencilFunc(GL_ALWAYS, 0x0, ~0);
glStencilOp(GL_KEEP, GL_KEEP, GL_DECR_WRAP_EXT);
render_vol(a);
}
if ( GLEW_EXT_stencil_two_side ) {
glActiveStencilFaceEXT(GL_FRONT);
glStencilFunc(GL_ALWAYS, 0, ~0);
glStencilOp(GL_KEEP, GL_KEEP, GL_DECR_WRAP_EXT);
}else{
glCullFace(GL_FRONT);
glStencilFunc(GL_ALWAYS, 0x0, ~0);
glStencilOp(GL_KEEP, GL_KEEP, GL_INCR_WRAP_EXT);
}
#endif
render_vol(a);
glDisable(GL_POLYGON_OFFSET_FILL);
glDisable(GL_CULL_FACE);
glDisable(GL_STENCIL_TEST);
glDisable(GL_STENCIL_TEST_TWO_SIDE_EXT);
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
}
void enable_shadow_stencil() {
assert(have_EXT_stencil_wrap());
if (have_EXT_stencil_two_side()) {
glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT);
glActiveStencilFaceEXT(GL_BACK);
glStencilFunc(GL_ALWAYS, 1, ~0U);
glStencilOp(GL_KEEP, GL_KEEP, GL_INCR_WRAP);
glActiveStencilFaceEXT(GL_FRONT);
glStencilFunc(GL_ALWAYS, 1, ~0U);
glStencilOp(GL_KEEP, GL_KEEP, GL_DECR_WRAP);
} else if (have_ATI_separate_stencil()) {
glStencilFuncSeparateATI( GL_ALWAYS, GL_ALWAYS, 1, ~0U );
glStencilOpSeparateATI( GL_BACK, GL_KEEP, GL_KEEP, GL_INCR_WRAP );
glStencilOpSeparateATI( GL_FRONT, GL_KEEP, GL_KEEP, GL_DECR_WRAP );
} else {
assert(0);
}
}
std::string getOpenGLState(bool showDisabled) {
{
debugAssertGLOk();
glGetInteger(GL_BLEND);
debugAssertM(glGetError() != GL_INVALID_OPERATION,
"Can't call getOpenGLState between glBegin() and glEnd()");
}
// The implementation has to be careful not to disrupt any OpenGL state and
// to produce output code that sets values that interact (e.g. lighting and modelview matrix) in an order
// so they produce the same results as currently in memory.
std::string result;
result += "///////////////////////////////////////////////////////////////////\n";
result += "// Matrices //\n\n";
result += getMatrixState();
result += "///////////////////////////////////////////////////////////////////\n";
result += "// Lighting //\n\n";
result += getLightingState(showDisabled);
result += "///////////////////////////////////////////////////////////////////\n";
result += "// Clipping //\n\n";
result += getClippingState();
result += "///////////////////////////////////////////////////////////////////\n";
result += "// Textures //\n\n";
result += getTextureState(showDisabled);
result += "///////////////////////////////////////////////////////////////////\n";
result += "// Other //\n\n";
GLdouble d[4];
GLboolean b[4];
// Viewport
glGetDoublev(GL_VIEWPORT, d);
result += format("glViewport(%g, %g, %g, %g);\n\n", d[0], d[1], d[2], d[3]);
//color
result += enableEntry(GL_COLOR_ARRAY);
result += enableEntry(GL_COLOR_LOGIC_OP);
result += enableEntry(GL_COLOR_MATERIAL);
glGetDoublev(GL_COLOR_CLEAR_VALUE, d);
result += format("glClearColor(%g, %g, %g, %g);\n", d[0], d[1], d[2], d[3]);
glGetDoublev(GL_CURRENT_COLOR, d);
result += format("glColor4d(%g, %g, %g, %g);\n", d[0], d[1], d[2], d[3]);
glGetBooleanv(GL_COLOR_WRITEMASK, b);
result += format("glColorMask(%d, %d, %d, %d);\n", b[0], b[1], b[2], b[3]);
result += format("\n");
//blend
result += enableEntry(GL_BLEND);
if (showDisabled || glGetBoolean(GL_BLEND)) {
result += format("glBlendFunc(%s, %s);\n",
GLenumToString(glGetInteger(GL_BLEND_DST)),
GLenumToString(glGetInteger(GL_BLEND_SRC)));
result += format("\n");
}
//alpha
result += enableEntry(GL_ALPHA_TEST);
if (showDisabled || glGetBoolean(GL_ALPHA_TEST)) {
result += format("glAlphaFunc(%s, %g);\n",
GLenumToString(glGetInteger(GL_ALPHA_TEST_FUNC)),
glGetDouble(GL_ALPHA_TEST_REF));
result += format("\n");
}
//depth stuff
result += "///////////////////////////////////////////////////////////////////\n";
result += "// Depth Buffer //\n\n";
result += enableEntry(GL_DEPTH_TEST);
if (showDisabled || glGetBoolean(GL_DEPTH_TEST)) {
result += format("glDepthFunc(%s);\n",
GLenumToString(glGetInteger(GL_DEPTH_FUNC)));
}
result += format("glClearDepth(%g);\n", glGetDouble(GL_DEPTH_CLEAR_VALUE));
result += format("glDepthMask(%d);\n", glGetBoolean(GL_DEPTH_WRITEMASK));
{
Vector2 range = glGetVector2(GL_DEPTH_RANGE);
result += format("glDepthRange(%g, %g);\n", range.x, range.y);
}
result += format("\n");
//stencil stuff
result += "///////////////////////////////////////////////////////////////////////\n";
result += "// Stencil\n\n";
result += enableEntry(GL_STENCIL_TEST);
result += format("glClearStencil(0x%x);\n", glGetInteger(GL_STENCIL_CLEAR_VALUE));
if (GLCaps::supports_GL_EXT_stencil_two_side()) {
result += "glActiveStencilFaceEXT(GL_BACK);\n";
glActiveStencilFaceEXT(GL_BACK);
}
if (showDisabled || glGetBoolean(GL_STENCIL_TEST))
result += format(
"glStencilFunc(%s, %d, %d);\n",
GLenumToString(glGetInteger(GL_STENCIL_FUNC)),
glGetInteger(GL_STENCIL_REF),
glGetInteger(GL_STENCIL_VALUE_MASK));
result += format(
"glStencilOp(%s, %s, %s);\n",
GLenumToString(glGetInteger(GL_STENCIL_FAIL)),
GLenumToString(glGetInteger(GL_STENCIL_PASS_DEPTH_FAIL)),
GLenumToString(glGetInteger(GL_STENCIL_PASS_DEPTH_PASS)));
result += format("glStencilMask(0x%x);\n", glGetInteger(GL_STENCIL_WRITEMASK));
if (GLCaps::supports_GL_EXT_stencil_two_side()) {
result += "\nglActiveStencilFaceEXT(GL_FRONT);\n";
glActiveStencilFaceEXT(GL_FRONT);
if (showDisabled || glGetBoolean(GL_STENCIL_TEST))
result += format(
"glStencilFunc(%s, %d, %d);\n",
GLenumToString(glGetInteger(GL_STENCIL_FUNC)),
glGetInteger(GL_STENCIL_REF),
glGetInteger(GL_STENCIL_VALUE_MASK));
result += format(
"glStencilOp(%s, %s, %s);\n",
GLenumToString(glGetInteger(GL_STENCIL_FAIL)),
GLenumToString(glGetInteger(GL_STENCIL_PASS_DEPTH_FAIL)),
GLenumToString(glGetInteger(GL_STENCIL_PASS_DEPTH_PASS)));
result += format("glStencilMask(0x%x);\n", glGetInteger(GL_STENCIL_WRITEMASK));
}
result += ("\n");
//misc
result += enableEntry(GL_NORMAL_ARRAY);
result += enableEntry(GL_NORMALIZE);
glGetDoublev(GL_CURRENT_NORMAL, d);
result += format("glNormal3d(%g, %g, %g);\n", d[0], d[1], d[2]);
result += ("\n");
result += format("glPixelZoom(%g, %g);\n", glGetDouble(GL_ZOOM_X),
glGetDouble(GL_ZOOM_Y));
result += format("glReadBuffer(%s);\n",
GLenumToString(glGetInteger(GL_READ_BUFFER)));
result += enableEntry(GL_POLYGON_SMOOTH);
result += enableEntry(GL_POLYGON_STIPPLE);
result += enableEntry(GL_LINE_SMOOTH);
result += enableEntry(GL_LINE_STIPPLE);
result += enableEntry(GL_POINT_SMOOTH);
result += enableEntry(GL_AUTO_NORMAL);
result += enableEntry(GL_CULL_FACE);
result += enableEntry(GL_POLYGON_OFFSET_FILL);
result += enableEntry(GL_POLYGON_OFFSET_LINE);
result += enableEntry(GL_POLYGON_OFFSET_POINT);
result += ("\n");
result += enableEntry(GL_DITHER);
result += enableEntry(GL_FOG);
result += enableEntry(GL_VERTEX_ARRAY);
result += enableEntry(GL_INDEX_ARRAY);
result += enableEntry(GL_INDEX_LOGIC_OP);
result += format("\n");
result += enableEntry(GL_MAP1_COLOR_4);
result += enableEntry(GL_MAP1_INDEX);
result += enableEntry(GL_MAP1_NORMAL);
result += enableEntry(GL_MAP1_TEXTURE_COORD_1);
result += enableEntry(GL_MAP1_TEXTURE_COORD_2);
result += enableEntry(GL_MAP1_TEXTURE_COORD_3);
result += enableEntry(GL_MAP1_TEXTURE_COORD_4);
result += enableEntry(GL_MAP1_VERTEX_3);
result += enableEntry(GL_MAP1_VERTEX_4);
result += enableEntry(GL_MAP2_COLOR_4);
result += enableEntry(GL_MAP2_INDEX);
result += enableEntry(GL_MAP2_NORMAL);
result += enableEntry(GL_MAP2_TEXTURE_COORD_1);
result += enableEntry(GL_MAP2_TEXTURE_COORD_2);
result += enableEntry(GL_MAP2_TEXTURE_COORD_3);
result += enableEntry(GL_MAP2_TEXTURE_COORD_4);
result += enableEntry(GL_MAP2_VERTEX_3);
result += enableEntry(GL_MAP2_VERTEX_4);
result += format("\n");
result += enableEntry(GL_SCISSOR_TEST);
return result;
}
void OglStartFrame (int bFlat, int bResetColorBuf)
{
GLint nError = glGetError ();
if (!gameStates.render.cameras.bActive)
OglDrawBuffer (GL_BACK, 1);
#if SHADOWS
if (gameStates.render.nShadowPass) {
#if GL_INFINITY
float infProj [4][4]; //projection to infinity
#endif
if (gameStates.render.nShadowPass == 1) { //render unlit/final scene
if (!gameStates.render.bShadowMaps) {
#if GL_INFINITY
glMatrixMode (GL_PROJECTION);
memset (infProj, 0, sizeof (infProj));
infProj [1][1] = 1.0f / (float) tan (gameStates.render.glFOV);
infProj [0][0] = infProj [1][1] / (float) gameStates.render.glAspect;
infProj [3][2] = -0.02f; // -2 * near
infProj [2][2] =
infProj [2][3] = -1.0f;
glLoadMatrixf ((float *) infProj);
#endif
#if 0
glMatrixMode (GL_MODELVIEW);
glLoadIdentity ();
#endif
glEnable (GL_DEPTH_TEST);
glDisable (GL_STENCIL_TEST);
glDepthFunc (GL_LESS);
glEnable (GL_CULL_FACE);
glCullFace (GL_BACK);
if (!FAST_SHADOWS)
glColorMask (0,0,0,0);
}
}
else if (gameStates.render.nShadowPass == 2) { //render occluders / shadow maps
if (gameStates.render.bShadowMaps) {
glColorMask (0,0,0,0);
glEnable (GL_POLYGON_OFFSET_FILL);
glPolygonOffset (1.0f, 2.0f);
}
else {
# if DBG_SHADOWS
if (bShadowTest) {
glColorMask (1,1,1,1);
glDepthMask (0);
glEnable (GL_BLEND);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisable (GL_STENCIL_TEST);
}
else
# endif
{
glColorMask (0,0,0,0);
glDepthMask (0);
glEnable (GL_STENCIL_TEST);
if (!glIsEnabled (GL_STENCIL_TEST))
extraGameInfo [0].bShadows =
extraGameInfo [1].bShadows = 0;
glClearStencil (0);
glClear (GL_STENCIL_BUFFER_BIT);
#if 0
if (!glActiveStencilFaceEXT)
#endif
bSingleStencil = 1;
# if DBG_SHADOWS
if (bSingleStencil || bShadowTest) {
# else
if (bSingleStencil) {
# endif
glStencilMask (~0);
glStencilFunc (GL_ALWAYS, 0, ~0);
}
#if 0
else {
glEnable (GL_STENCIL_TEST_TWO_SIDE_EXT);
glActiveStencilFaceEXT (GL_BACK);
if (bZPass)
glStencilOp (GL_KEEP, GL_KEEP, GL_DECR_WRAP);
else
glStencilOp (GL_KEEP, GL_DECR_WRAP, GL_KEEP);
glStencilOp (GL_KEEP, GL_DECR_WRAP, GL_KEEP);
glStencilMask (~0);
glStencilFunc (GL_ALWAYS, 0, ~0);
glActiveStencilFaceEXT (GL_FRONT);
if (bZPass)
glStencilOp (GL_KEEP, GL_KEEP, GL_INCR_WRAP);
else
glStencilOp (GL_KEEP, GL_INCR_WRAP, GL_KEEP);
glStencilMask (~0);
glStencilFunc (GL_ALWAYS, 0, ~0);
}
#endif
#if 0
glEnable (GL_POLYGON_OFFSET_FILL);
glPolygonOffset (1.0f, 1.0f);
#endif
}
}
}
else if (gameStates.render.nShadowPass == 3) { //render final lit scene
if (gameStates.render.bShadowMaps) {
glDisable (GL_POLYGON_OFFSET_FILL);
glDepthFunc (GL_LESS);
}
else {
#if 0
glDisable (GL_POLYGON_OFFSET_FILL);
#endif
if (gameStates.render.nShadowBlurPass == 2)
glDisable (GL_STENCIL_TEST);
else if (FAST_SHADOWS) {
glStencilFunc (GL_NOTEQUAL, 0, ~0);
glStencilOp (GL_REPLACE, GL_KEEP, GL_KEEP);
}
else
{
glStencilFunc (GL_EQUAL, 0, ~0);
#if 0
glStencilOp (GL_KEEP, GL_KEEP, GL_INCR); //problem: layered texturing fails
#else
glStencilOp (GL_KEEP, GL_KEEP, GL_KEEP);
#endif
}
glCullFace (GL_BACK);
glDepthFunc (GL_LESS);
glColorMask (1,1,1,1);
}
}
else if (gameStates.render.nShadowPass == 4) { //render unlit/final scene
glEnable (GL_DEPTH_TEST);
glDepthFunc (GL_LESS);
glEnable (GL_CULL_FACE);
glCullFace (GL_BACK);
}
#if GL_INFINITY
glMatrixMode (GL_MODELVIEW);
glLoadIdentity ();
#endif
}
static void pie_DrawShadows(void)
{
const float width = pie_GetVideoBufferWidth();
const float height = pie_GetVideoBufferHeight();
GLenum op_depth_pass_front = GL_INCR, op_depth_pass_back = GL_DECR;
pie_SetTexturePage(TEXPAGE_NONE);
glPushMatrix();
pie_SetAlphaTest(false);
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
glDepthFunc(GL_LESS);
glDepthMask(GL_FALSE);
glEnable(GL_STENCIL_TEST);
// Check if we have the required extensions
if (GLEE_EXT_stencil_wrap)
{
op_depth_pass_front = GL_INCR_WRAP_EXT;
op_depth_pass_back = GL_DECR_WRAP_EXT;
}
// generic 1-pass version
if (GLEE_EXT_stencil_two_side)
{
glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT);
glDisable(GL_CULL_FACE);
glStencilMask(~0);
glActiveStencilFaceEXT(GL_BACK);
glStencilOp(GL_KEEP, GL_KEEP, op_depth_pass_back);
glStencilFunc(GL_ALWAYS, 0, ~0);
glActiveStencilFaceEXT(GL_FRONT);
glStencilOp(GL_KEEP, GL_KEEP, op_depth_pass_front);
glStencilFunc(GL_ALWAYS, 0, ~0);
pie_ShadowDrawLoop();
glDisable(GL_STENCIL_TEST_TWO_SIDE_EXT);
}
// check for ATI-specific 1-pass version
else if (GLEE_ATI_separate_stencil)
{
glDisable(GL_CULL_FACE);
glStencilMask(~0);
glStencilOpSeparateATI(GL_BACK, GL_KEEP, GL_KEEP, op_depth_pass_back);
glStencilOpSeparateATI(GL_FRONT, GL_KEEP, GL_KEEP, op_depth_pass_front);
glStencilFunc(GL_ALWAYS, 0, ~0);
pie_ShadowDrawLoop();
}
// fall back to default 2-pass version
else
{
glStencilMask(~0);
glStencilFunc(GL_ALWAYS, 0, ~0);
glEnable(GL_CULL_FACE);
// Setup stencil for front-facing polygons
glCullFace(GL_BACK);
glStencilOp(GL_KEEP, GL_KEEP, op_depth_pass_front);
pie_ShadowDrawLoop();
// Setup stencil for back-facing polygons
glCullFace(GL_FRONT);
glStencilOp(GL_KEEP, GL_KEEP, op_depth_pass_back);
pie_ShadowDrawLoop();
}
pie_SetRendMode(REND_ALPHA);
glEnable(GL_CULL_FACE);
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
glStencilMask(~0);
glStencilFunc(GL_LESS, 0, ~0);
glColor4f(0, 0, 0, 0.5);
pie_PerspectiveEnd();
glLoadIdentity();
glDisable(GL_DEPTH_TEST);
glBegin(GL_TRIANGLE_STRIP);
glVertex2f(0, 0);
glVertex2f(width, 0);
glVertex2f(0, height);
glVertex2f(width, height);
glEnd();
pie_PerspectiveBegin();
pie_SetRendMode(REND_OPAQUE);
glDisable(GL_STENCIL_TEST);
glEnable(GL_DEPTH_TEST);
glDepthMask(GL_TRUE);
glPopMatrix();
nb_scshapes = 0;
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTStencilTwoSide_nglActiveStencilFaceEXT(JNIEnv *env, jclass clazz, jint face, jlong function_pointer) {
glActiveStencilFaceEXTPROC glActiveStencilFaceEXT = (glActiveStencilFaceEXTPROC)((intptr_t)function_pointer);
glActiveStencilFaceEXT(face);
}
void e_beginpass(e_device_t* device,unsigned int pass)
{
glPushAttrib(GL_ENABLE_BIT|GL_STENCIL_BUFFER_BIT|GL_POLYGON_BIT);
switch(pass)
{
case E_RENDER_MESHES:
glBindProgramARB(GL_VERTEX_PROGRAM_ARB,e_programids[E_PROGRAM_PASSTOFRAGMENT]);
glEnable(GL_VERTEX_PROGRAM_ARB);
glEnable(GL_FRAGMENT_PROGRAM_ARB);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
break;
case E_RENDER_SHADOWS:
//The support of this extension depends on the 3D card
if(glActiveStencilFaceEXT)
{
glActiveStencilFaceEXT(GL_BACK);
glStencilOp(GL_KEEP,GL_INCR_WRAP_EXT,GL_KEEP);
glActiveStencilFaceEXT(GL_FRONT);
glStencilOp(GL_KEEP,GL_DECR_WRAP_EXT,GL_KEEP);
glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT);
}
else
glEnable(GL_CULL_FACE);
glBindProgramARB(GL_VERTEX_PROGRAM_ARB,e_programids[E_PROGRAM_SHADOW]);
glEnable(GL_VERTEX_PROGRAM_ARB);
glColorMask(GL_FALSE,GL_FALSE,GL_FALSE,GL_FALSE);
glDepthMask(GL_FALSE);
glEnable(GL_STENCIL_TEST);
glStencilFunc(GL_ALWAYS,0,~0);
glEnable(GL_DEPTH_TEST);
break;
case E_RENDER_SHADING:
glBindProgramARB(GL_VERTEX_PROGRAM_ARB,e_programids[E_PROGRAM_PASSTOFRAGMENT]);
glEnable(GL_VERTEX_PROGRAM_ARB);
glEnable(GL_FRAGMENT_PROGRAM_ARB);
glBlendFunc(GL_ONE,GL_ONE);
glEnable(GL_BLEND);
glEnable(GL_STENCIL_TEST);
glStencilFunc(GL_EQUAL,0,~0);
glStencilOp(GL_KEEP,GL_KEEP,GL_KEEP);
glDepthFunc(GL_LEQUAL);
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
break;
case E_RENDER_OUTLINES:
glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
#ifdef E_OUTLINES_SMOOTH
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_LINE_SMOOTH);
glEnable(GL_BLEND);
#endif
glLineWidth(E_OUTLINES_WIDTH);
glPolygonOffset(1.0f,1.0f);
glEnable(GL_POLYGON_OFFSET_LINE);
glColor3ub(0,0,0);
glEnable(GL_CULL_FACE);
glCullFace(GL_FRONT);
glEnable(GL_DEPTH_TEST);
break;
}
}
void __glXDisp_ActiveStencilFaceEXT(GLbyte *pc)
{
glActiveStencilFaceEXT(
*(GLenum *)(pc + 0)
);
}