grguDepth.cpp

//**************************************************************
//*            OpenGLide - Glide to OpenGL Wrapper
//*             http://openglide.sourceforge.net
//*
//*               Depth (Z/W-Buffer) Functions
//*
//*         OpenGLide is OpenSource under LGPL license
//*              Originally made by Fabio Barros
//*      Modified by Paul for Glidos (http://www.glidos.net)
//*               Linux version by Simon White
//**************************************************************

#include "OpenGlide.h"
#include "GLRender.h"
#include "OGLShaders.h"

//*************************************************
//* Changes Depth Buffer Mode
//*************************************************
FX_ENTRY void FX_CALL
grDepthBufferMode( GrDepthBufferMode_t mode )
{
    /*
    * In AddTriangle etc.  Use of z or w for
    * depth buffering is determined by the
    * value of OpenGL.DepthBufferType.  So
    * I set it here.
    */
    switch ( mode )
    {
    case GR_DEPTHBUFFER_DISABLE:
        OpenGL.DepthBufferType = 0;
        OpenGL.ZNear = ZBUFFERNEAR;
        OpenGL.ZFar = ZBUFFERFAR;
        break;

    case GR_DEPTHBUFFER_ZBUFFER:
    case GR_DEPTHBUFFER_ZBUFFER_COMPARE_TO_BIAS:
        OpenGL.DepthBufferType = 1;
        OpenGL.ZNear = ZBUFFERNEAR;
        OpenGL.ZFar = ZBUFFERFAR;
        break;

    case GR_DEPTHBUFFER_WBUFFER:
    case GR_DEPTHBUFFER_WBUFFER_COMPARE_TO_BIAS:
        OpenGL.DepthBufferType = 2;
        OpenGL.ZNear = WBUFFERNEAR;
        OpenGL.ZFar = WBUFFERFAR;
        break;
    }

    if(!OpenGL.DepthBufferType.changed())
        return;
    
    RenderDrawPrimitives( );

    LOGD(DONE|DEPTH, "grDepthBufferMode( %d )\n", mode );

    Glide.State.DepthBufferMode = mode;

    OGLShaders_UpdateUniform(SU_ZBUFFER_MODE);

    if(mode == GR_DEPTHBUFFER_DISABLE)
    {
        glDisable( GL_DEPTH_TEST );
        return;
    }

    glEnable( GL_DEPTH_TEST );
    
    UpdateProjectionViewport(false);

    if(Glide.State.DepthBiasLevel)
    {
        FxI16 dbl = Glide.State.DepthBiasLevel;
        Glide.State.DepthBiasLevel = 0;
        OpenGL.DepthBiasLevel = dbl ? (float)-dbl : 0.0f;
        OpenGL.DepthBiasLevel.apply_change();
        grDepthBiasLevel(dbl);
    }
    
    LOGD(GLIDE_DEBUG, "grDepthBufferMode" );
}

//*************************************************
//* Enables or Disables Depth Buffer Writting
//*************************************************
FX_ENTRY void FX_CALL
grDepthMask( FxBool enable )
{
    OpenGL.DepthBufferWritting = enable;

    if(!OpenGL.DepthBufferWritting.changed())
        return;

    RenderDrawPrimitives( );

    LOGD(DONE|DEPTH, "grDepthMask( %d )\n", enable );

    Glide.State.DepthBufferWritting = enable;

    glDepthMask( OpenGL.DepthBufferWritting );

    LOGD(GLIDE_DEBUG,  "grDepthMask" );
}

//*************************************************
//* Sets the Depth Function to use
//*************************************************
FX_ENTRY void FX_CALL
grDepthBufferFunction( GrCmpFnc_t func )
{
    // We can do this just because we know the constant values for both OpenGL and Glide
    // To port it to anything else than OpenGL we NEED to change this code
    OpenGL.DepthFunction = GL_NEVER + func;

    if(!OpenGL.DepthFunction.changed())
        return;

    RenderDrawPrimitives( );

    LOGD(DONE|DEPTH, "grDepthBufferFunction( %d )\n", func );
    Glide.State.DepthFunction = func;

    glDepthFunc( OpenGL.DepthFunction );

    LOGD(GLIDE_DEBUG, "grDepthBufferFunction" );
}

//*************************************************
//* Set the depth bias level
//*************************************************
FX_ENTRY void FX_CALL
grDepthBiasLevel( FxI16 level )
{   
    OpenGL.DepthBiasLevel = (float)level;

    if(!OpenGL.DepthBiasLevel.changed())
        return;

    RenderDrawPrimitives( );

    LOGD(PARTDONE|DEPTH, "grDepthBiasLevel( %d )\n", level );
    
    Glide.State.DepthBiasLevel = level;

    glPolygonOffset( OpenGL.DepthBiasLevel*OG_SLOPE_BIAS, OpenGL.DepthBiasLevel*OG_BIAS_SCALE );

    if ( level != 0 )
    {
        glEnable( GL_POLYGON_OFFSET_FILL );
    }
    else
    {
        glDisable( GL_POLYGON_OFFSET_FILL );
    }

    LOGD(GLIDE_DEBUG, "grDepthBiasLevel" );
}

#ifdef GLIDE3

FX_ENTRY void FX_CALL 
grDepthRange( FxFloat n, FxFloat f )
{
    if(Glide.State.v3.depth_range[0] == n && Glide.State.v3.depth_range[1] == f)
        return;

    RenderDrawPrimitives( );

    LOGD(DONE|DEPTH, "grDepthRange( %f %f )\n", n, f );

    Glide.State.v3.depth_range[0] = n;
    Glide.State.v3.depth_range[1] = f;
    glDepthRange(Glide.State.v3.depth_range[0] , Glide.State.v3.depth_range[1]);
}

#endif