/*
Copyright (C) 2003-2006 Andrey Nazarov

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

#include "gl_local.h"
#include "gl_arbfp.h"

glState_t gls;

void GL_BindTexture( int texnum ) {
#ifdef _DEBUG
    if( gl_nobind->integer && !gls.tmu ) {
        texnum = TEXNUM_DEFAULT;
    }
#endif

    if( gls.texnum[gls.tmu] == texnum ) {
        return;
    }

    qglBindTexture( GL_TEXTURE_2D, texnum );
    gls.texnum[gls.tmu] = texnum;

    c.texSwitches++;
}

void GL_SelectTMU( int tmu ) {
    if( gls.tmu == tmu ) {
        return;
    }

    if( tmu < 0 || tmu >= gl_config.numTextureUnits ) {
        Com_Error( ERR_FATAL, "GL_SelectTMU: bad tmu %d", tmu );
    }

    qglActiveTextureARB( GL_TEXTURE0_ARB + tmu );
    qglClientActiveTextureARB( GL_TEXTURE0_ARB + tmu );

    gls.tmu = tmu;
}

void GL_TexEnv( GLenum texenv ) {
    if( gls.texenv[gls.tmu] == texenv ) {
        return;
    }

    switch( texenv ) {
    case GL_REPLACE:
    case GL_MODULATE:
    case GL_BLEND:
    case GL_ADD:
        qglTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, texenv );
        break;
    default:
        Com_Error( ERR_FATAL, "GL_TexEnv: bad texenv" );
        break;
    }

    gls.texenv[gls.tmu] = texenv;
}

void GL_CullFace( glCullFace_t cull ) {
    if( gls.cull == cull ) {
        return;
    }
    switch( cull ) {
    case GLS_CULL_DISABLE:
        qglDisable( GL_CULL_FACE );
        break;
    case GLS_CULL_FRONT:
        qglEnable( GL_CULL_FACE );
        qglCullFace( GL_FRONT );
        break;
    case GLS_CULL_BACK:
        qglEnable( GL_CULL_FACE );
        qglCullFace( GL_BACK );
        break;
    default:
        Com_Error( ERR_FATAL, "GL_CullFace: bad cull" );
        break;
    }

    gls.cull = cull;
}

void GL_Bits( glStateBits_t bits ) {
    glStateBits_t diff = bits ^ gls.bits;

    if( !diff ) {
        return;
    }

    if( diff & GLS_BLEND_MASK ) {
        if( bits & GLS_BLEND_MASK ) {
            qglEnable( GL_BLEND );
            if( bits & GLS_BLEND_BLEND ) {
                qglBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
            } else if( bits & GLS_BLEND_ADD ) {
                qglBlendFunc( GL_SRC_ALPHA, GL_ONE );
            } else if( bits & GLS_BLEND_MODULATE ) {
                qglBlendFunc( GL_DST_COLOR, GL_ONE );
            }
        } else {
            qglDisable( GL_BLEND );
        }
    }
    
    if( diff & GLS_DEPTHMASK_FALSE ) {
        if( bits & GLS_DEPTHMASK_FALSE ) {
            qglDepthMask( GL_FALSE );
        } else {
            qglDepthMask( GL_TRUE );
        }
    }
    
    if( diff & GLS_DEPTHTEST_DISABLE ) {
        if( bits & GLS_DEPTHTEST_DISABLE ) {
            qglDisable( GL_DEPTH_TEST );
        } else {
            qglEnable( GL_DEPTH_TEST );
        }
    }

    if( diff & GLS_ALPHATEST_ENABLE ) {
        if( bits & GLS_ALPHATEST_ENABLE ) {
            qglEnable( GL_ALPHA_TEST );
        } else {
            qglDisable( GL_ALPHA_TEST );
        }
    }
    
    gls.bits = bits;
}

void GL_Setup2D( void ) {
    qglViewport( 0, 0, r_config.width, r_config.height );

    qglMatrixMode( GL_PROJECTION );
    qglLoadIdentity();

    qglOrtho( 0, r_config.width, r_config.height, 0, -1, 1 );
    draw.scale = 1;

    draw.colors[0].u32 = U32_WHITE;
    draw.colors[1].u32 = U32_WHITE;

    if( draw.flags & DRAW_CLIP_MASK ) {
        qglDisable( GL_SCISSOR_TEST );
    }

    draw.flags = 0;

    qglMatrixMode( GL_MODELVIEW );
    qglLoadIdentity();

    GL_Bits( GLS_DEPTHTEST_DISABLE );
    GL_CullFace( GLS_CULL_DISABLE );
}

void GL_Setup3D( void ) {
    GLdouble xmin, xmax, ymin, ymax;
    int yb = glr.fd.y + glr.fd.height;

    qglViewport( glr.fd.x, r_config.height - yb,
        glr.fd.width, glr.fd.height );

    qglMatrixMode( GL_PROJECTION );
    qglLoadIdentity();

    ymax = gl_znear->value * tan( glr.fd.fov_y * M_PI / 360.0 );
    ymin = -ymax;

    xmax = gl_znear->value * tan( glr.fd.fov_x * M_PI / 360.0 );
    xmin = -xmax;

    qglFrustum( xmin, xmax, ymin, ymax, gl_znear->value, gl_zfar->value );
    
    qglMatrixMode( GL_MODELVIEW );
    qglLoadIdentity();

    qglRotatef( -90, 1, 0, 0 ); /* put z axis up */
    qglRotatef(  90, 0, 0, 1 ); /* put y axis west, x axis north */
    qglRotatef( -glr.fd.viewangles[ROLL],  1, 0, 0 );
    qglRotatef( -glr.fd.viewangles[PITCH], 0, 1, 0 );
    qglRotatef( -glr.fd.viewangles[YAW],   0, 0, 1 );
    qglTranslatef( -glr.fd.vieworg[0], -glr.fd.vieworg[1], -glr.fd.vieworg[2] );

    AngleVectors( glr.fd.viewangles,
        glr.viewaxis[0], glr.viewaxis[1], glr.viewaxis[2] );
    VectorInverse( glr.viewaxis[1] );

    GL_Bits( GLS_DEFAULT );
    GL_CullFace( GLS_CULL_FRONT );

    qglClear( GL_DEPTH_BUFFER_BIT );
}

void GL_SetDefaultState( void ) {
    qglClearColor( 0, 0, 0, 1 );
    qglClearDepth( 1 );
    qglClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
    qglEnable( GL_DEPTH_TEST );
    qglDepthFunc( GL_LEQUAL );
    qglDepthRange( 0, 1 );
    qglDepthMask( GL_TRUE );
    qglDisable( GL_BLEND );
    qglDisable( GL_ALPHA_TEST ); 
    qglAlphaFunc( GL_GREATER, 0.666f );
    qglHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST );
    qglPolygonMode( GL_FRONT_AND_BACK, GL_FILL );

    qglEnableClientState( GL_VERTEX_ARRAY );
    qglEnableClientState( GL_TEXTURE_COORD_ARRAY );
    
    GL_SelectTMU( 0 );
    GL_BindTexture( 0 );
    qglEnable( GL_TEXTURE_2D );
    GL_Bits( GLS_DEFAULT );
}

// for screenshots
byte *IMG_ReadPixels( qboolean reverse, int *width, int *height ) {
    byte *pixels;

    pixels = FS_AllocTempMem( r_config.width * r_config.height * 3 );

    qglReadPixels( 0, 0, r_config.width, r_config.height,
        reverse ? GL_BGR : GL_RGB, GL_UNSIGNED_BYTE, pixels );

    *width = r_config.width;
    *height = r_config.height;

    return pixels;
}

void GL_EnableOutlines( void ) {
    if( gls.fp_enabled ) {
        qglDisable( GL_FRAGMENT_PROGRAM_ARB );
    }
    qglDisable( GL_TEXTURE_2D );
    qglDisableClientState( GL_TEXTURE_COORD_ARRAY );
    qglPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
    qglDepthRange( 0, 0 );
    qglColor4f( 1, 1, 1, 1 );
}

void GL_DisableOutlines( void ) {
    qglDepthRange( 0, 1 );
    qglPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
    qglEnableClientState( GL_TEXTURE_COORD_ARRAY );
    qglEnable( GL_TEXTURE_2D );
    if( gls.fp_enabled ) {
        qglEnable( GL_FRAGMENT_PROGRAM_ARB );
    }
}

void GL_EnableWarp( void ) {
    vec4_t param;

    qglEnable( GL_FRAGMENT_PROGRAM_ARB );
    qglBindProgramARB( GL_FRAGMENT_PROGRAM_ARB, gl_static.prognum_warp );
    param[0] = glr.fd.time;
    param[1] = glr.fd.time;
    param[2] = param[3] = 0;
    qglProgramLocalParameter4fvARB( GL_FRAGMENT_PROGRAM_ARB, 0, param );
    gls.fp_enabled = qtrue;
}

void GL_DisableWarp( void ) {
    qglBindProgramARB( GL_FRAGMENT_PROGRAM_ARB, 0 );
    qglDisable( GL_FRAGMENT_PROGRAM_ARB );
    gls.fp_enabled = qfalse;
}

void GL_InitPrograms( void ) {
    GLuint prog;

    if( gl_config.ext_supported & QGL_ARB_fragment_program ) {
        if( gl_fragment_program->integer ) {
            Com_Printf( "...enabling GL_ARB_fragment_program\n" );
            QGL_InitExtensions( QGL_ARB_fragment_program );
            gl_config.ext_enabled |= QGL_ARB_fragment_program;
        } else {
            Com_Printf( "...ignoring GL_ARB_fragment_program\n" );
        }
    } else if( gl_fragment_program->integer ) {
        Com_Printf( "GL_ARB_fragment_program not found\n" );
        Cvar_Set( "gl_fragment_program", "0" );
    }

    if( !qglProgramStringARB ) {
        return;
    }

    GL_ClearErrors();
    qglGenProgramsARB( 1, &prog );
    qglBindProgramARB( GL_FRAGMENT_PROGRAM_ARB, prog );
    qglProgramStringARB( GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
        sizeof( gl_prog_warp ) - 1, gl_prog_warp );

    if( GL_ShowErrors( "Failed to initialize fragment program" ) ) {
        qglBindProgramARB( GL_FRAGMENT_PROGRAM_ARB, 0 );
        qglDeleteProgramsARB( 1, &prog );
        return;
    }

    qglBindProgramARB( GL_FRAGMENT_PROGRAM_ARB, 0 );
    gl_static.prognum_warp = prog;
}

void GL_ShutdownPrograms( void ) {
    if( !qglDeleteProgramsARB ) {
        return;
    }

    if( gl_static.prognum_warp ) {
        qglDeleteProgramsARB( 1, &gl_static.prognum_warp );
        gl_static.prognum_warp = 0;
    }

    QGL_ShutdownExtensions( QGL_ARB_fragment_program );
    gl_config.ext_enabled &= ~QGL_ARB_fragment_program;
}