OpenGL/state_tracker/state_fog.c

/* Copyright (c) 2001, Stanford University
 * All rights reserved
 *
 * See the file LICENSE.txt for information on redistributing this software.
 */

#include <stdio.h>
#include "state.h"
#include "state/cr_statetypes.h"
#include "state_internals.h"

void crStateFogInit (CRContext *ctx)
{
    CRFogState *f = &ctx->fog;
    CRStateBits *sb = GetCurrentBits();
    CRFogBits *fb = &(sb->fog);
    GLcolorf black = {0.0f, 0.0f, 0.0f, 0.0f};

    f->color = black;
    RESET(fb->color, ctx->bitid);
    f->density = 1.0f;
    RESET(fb->density, ctx->bitid);
    f->end = 1.0f;
    RESET(fb->end, ctx->bitid);
    f->start = 0.0f;
    RESET(fb->start, ctx->bitid);
    f->mode = GL_EXP;
    RESET(fb->mode, ctx->bitid);
    f->index = 0;
    RESET(fb->index, ctx->bitid);
    f->enable = GL_FALSE;
    RESET(fb->enable, ctx->bitid);

#ifdef CR_NV_fog_distance
    f->fogDistanceMode = GL_EYE_PLANE_ABSOLUTE_NV;
    RESET(fb->fogDistanceMode, ctx->bitid);
#endif
#ifdef CR_EXT_fog_coord
    f->fogCoordinateSource = GL_FRAGMENT_DEPTH_EXT;
    RESET(fb->fogCoordinateSource, ctx->bitid);
#endif
    RESET(fb->dirty, ctx->bitid);
}

void STATE_APIENTRY crStateFogf(GLenum pname, GLfloat param)
{
    crStateFogfv( pname, &param );
}

void STATE_APIENTRY crStateFogi(GLenum pname, GLint param)
{
    GLfloat f_param = (GLfloat) param;
    crStateFogfv( pname, &f_param );
}

void STATE_APIENTRY crStateFogiv(GLenum pname, const GLint *param)
{
    GLcolor f_color;
    GLfloat f_param;
    switch (pname)
    {
        case GL_FOG_MODE:
        case GL_FOG_DENSITY:
        case GL_FOG_START:
        case GL_FOG_END:
        case GL_FOG_INDEX:
            f_param = (GLfloat) (*param);
            crStateFogfv( pname, &f_param );
            break;
        case GL_FOG_COLOR:
            f_color.r = ((GLfloat) param[0]) / ((GLfloat) CR_MAXINT);
            f_color.g = ((GLfloat) param[1]) / ((GLfloat) CR_MAXINT);
            f_color.b = ((GLfloat) param[2]) / ((GLfloat) CR_MAXINT);
            f_color.a = ((GLfloat) param[3]) / ((GLfloat) CR_MAXINT);
            crStateFogfv( pname, (GLfloat *) &f_color );
            break;
#ifdef CR_NV_fog_distance
        case GL_FOG_DISTANCE_MODE_NV:
            f_param = (GLfloat) (*param);
            crStateFogfv( pname, &f_param );
            break;
#endif
#ifdef CR_EXT_fog_coord
        case GL_FOG_COORDINATE_SOURCE_EXT:
            f_param = (GLfloat) (*param);
            crStateFogfv( pname, &f_param );
            break;
#endif
        default:
            crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "Invalid glFog Param: %d", param);
            return;
    }
}

void STATE_APIENTRY crStateFogfv(GLenum pname, const GLfloat *param)
{
    CRContext *g = GetCurrentContext();
    CRFogState *f = &(g->fog);
    CRStateBits *sb = GetCurrentBits();
    CRFogBits *fb = &(sb->fog);

    if (g->current.inBeginEnd)
    {
        crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION, "glFogfv called in Begin/End");
        return;
    }

    FLUSH();

    switch (pname)
    {
        case GL_FOG_MODE:
            {
                GLenum e = (GLenum) *param;
                if (e != GL_LINEAR && e != GL_EXP && e != GL_EXP2)
                {
                    crStateError(__LINE__, __FILE__, GL_INVALID_ENUM, "Invalid param for glFog: %d", e);
                    return;
                }
                f->mode = e;
                DIRTY(fb->mode, g->neg_bitid);
            }
            break;
        case GL_FOG_DENSITY:
            f->density = *param;
            if (f->density < 0.0f)
            {
                f->density = 0.0f;
            }
            DIRTY(fb->density, g->neg_bitid);
            break;
        case GL_FOG_START:
            f->start = *param;
            DIRTY(fb->start, g->neg_bitid);
            break;
        case GL_FOG_END:
            f->end = *param;
            DIRTY(fb->end, g->neg_bitid);
            break;
        case GL_FOG_INDEX:
            f->index = (GLint) *param;
            DIRTY(fb->index, g->neg_bitid);
            break;
        case GL_FOG_COLOR:
            f->color.r = param[0];
            f->color.g = param[1];
            f->color.b = param[2];
            f->color.a = param[3];
            DIRTY(fb->color, g->neg_bitid);
            break;
#ifdef CR_NV_fog_distance
        case GL_FOG_DISTANCE_MODE_NV:
            if (g->extensions.NV_fog_distance)
            {
                if (param[0] != GL_EYE_RADIAL_NV &&
                    param[0] != GL_EYE_PLANE &&
                    param[0] != GL_EYE_PLANE_ABSOLUTE_NV )
                {
                    crStateError(__LINE__, __FILE__, GL_INVALID_ENUM,
                        "Fogfv: GL_FOG_DISTANCE_MODE_NV called with illegal parameter: 0x%x", (GLenum) param[0]);
                    return;
                }
                f->fogDistanceMode = (GLenum) param[0];
                DIRTY(fb->fogDistanceMode, g->neg_bitid);
            }
            else
            {
                crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "Invalid glFog Param: %d", param);
                return;
            }
            break;
#endif
#ifdef CR_EXT_fog_coord
        case GL_FOG_COORDINATE_SOURCE_EXT:
            if (g->extensions.EXT_fog_coord)
            {
                if ((GLenum) param[0] != GL_FOG_COORDINATE_EXT &&
                        (GLenum) param[0] != GL_FRAGMENT_DEPTH_EXT)
                {
                    crStateError(__LINE__, __FILE__, GL_INVALID_ENUM,
                        "Fogfv: GL_FOG_COORDINATE_SOURCE_EXT called with illegal parameter: 0x%x", (GLenum) param[0]);
                    return;
                }
                f->fogCoordinateSource = (GLenum) param[0];
                DIRTY(fb->fogCoordinateSource, g->neg_bitid);
            }
            else
            {
                crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "Invalid glFog Param: 0x%x", (GLint) param[0]);
                return;
            }
            break;
#endif
        default:
            crStateError(__LINE__, __FILE__, GL_INVALID_VALUE, "Invalid glFog Param: %d", param);
            return;
    }
    DIRTY(fb->dirty, g->neg_bitid);
}