gl_program.cpp File Reference

#include "gl_globals.h"
#include "vs_globals.h"
#include "vegastrike.h"
#include "config_xml.h"
#include "gfxlib.h"
#include "lin_time.h"
#include <map>
#include <set>
#include <boost/algorithm/string/predicate.hpp>

Go to the source code of this file.

Macros
#define	NUMFRAMESLOOK   128

Typedefs
typedef std::pair< unsigned int, std::pair< std::string, std::string > >	ProgramCacheKey
typedef std::map < ProgramCacheKey, int >	ProgramCache
typedef std::map< int, ProgramCacheKey >	ProgramICache

Enumerations
enum	GameSpeed { JUSTRIGHT, TOOSLOW, TOOFAST }

Functions
static ProgramCache::key_type	cacheKey (const std::string &vp, const std::string &fp, const char *defines)
static bool	validateLog (GLuint obj, bool shader, bool allowSoftwareEmulation=false)
void	printLog (GLuint obj, bool shader)
static VSFileSystem::VSError	getProgramSource (const std::string &path, std::vector< std::string > &lines, std::set< std::string > &processed_includes, char *buf, size_t buflen)
static VSFileSystem::VSError	getProgramSource (const std::string &path, std::string &source)
static std::string	appendDefines (const std::string &prog, const char *extra_defines)
static int	GFXCreateProgramNoCache (const char *vprogram, const char *fprogram, const char *extra_defines)
int	GFXCreateProgram (const char *vprogram, const char *fprogram, const char *extra_defines)
int	GFXCreateProgram (char *vprogram, char *fprogram, char *extra_defines)
void	GFXDestroyProgram (int program)
int	getDefaultProgram ()
void	GFXReloadDefaultShader ()
GameSpeed	GFXGetFramerate ()
bool	GFXShaderReloaded ()
bool	GFXDefaultShaderSupported ()
int	GFXActivateShader (int program)
int	GFXActivateShader (const char *program)
void	GFXDeactivateShader ()
int	GFXShaderConstant (int name, float v1, float v2, float v3, float v4)
int	GFXShaderConstant (int name, const float *values)
int	GFXShaderConstant (int name, GFXColor v)
int	GFXShaderConstant (int name, Vector v)
int	GFXShaderConstant (int name, float v1)
int	GFXShaderConstantv (int name, unsigned int count, const float *values)
int	GFXShaderConstant4v (int name, unsigned int count, const float *values)
int	GFXShaderConstanti (int name, int value)
int	GFXShaderConstantv (int name, unsigned int count, const int *value)
int	GFXNamedShaderConstant (int progID, const char *name)
int	GFXNamedShaderConstant (char *progID, const char *name)
int	GFXGetProgramVersion ()

Variables
static ProgramCache	programCache
static ProgramICache	programICache
static int	programChanged = false
static int	programVersion = 0
static int	defaultprog = 0
static int	lowfiprog = 0
static int	hifiprog = 0
std::string	hifiProgramName = "default"
std::string	lowfiProgramName = "lite"
unsigned int	gpdcounter = (1<<30)
GameSpeed	gameplaydata [NUMFRAMESLOOK] = {JUSTRIGHT}

Macro Definition Documentation

#define NUMFRAMESLOOK   128

Definition at line 409 of file gl_program.cpp.

Referenced by GFXGetFramerate().

Typedef Documentation

typedef std::map< ProgramCacheKey, int > ProgramCache

Definition at line 20 of file gl_program.cpp.

typedef std::pair< unsigned int , std::pair< std::string, std::string > > ProgramCacheKey

Definition at line 19 of file gl_program.cpp.

typedef std::map< int, ProgramCacheKey > ProgramICache

Definition at line 21 of file gl_program.cpp.

Enumeration Type Documentation

enum GameSpeed

Enumerator
JUSTRIGHT
TOOSLOW
TOOFAST

Definition at line 401 of file gl_program.cpp.

{
    JUSTRIGHT,
    TOOSLOW,
    TOOFAST
};

Function Documentation

static std::string appendDefines ( const std::string &  prog, const char *  extra_defines  )

static

Definition at line 166 of file gl_program.cpp.

Referenced by GFXCreateProgramNoCache().

{
    std::string::size_type nlpos = prog.find_first_of('\n');
    
    if (nlpos == std::string::npos)
        nlpos = 0;
    
    std::string firstline = prog.substr(0, nlpos);
    
    if (firstline.find("#version") != std::string::npos)
        return firstline 
               + "\n" + std::string(extra_defines) 
               + "\n#line 1"
               + prog.substr(nlpos);
    else
        return std::string(extra_defines) 
               + "\n#line 0\n" 
               + prog;
}

static ProgramCache::key_type cacheKey ( const std::string &  vp, const std::string &  fp, const char *  defines  )

static

Definition at line 26 of file gl_program.cpp.

Referenced by GFXCreateProgram(), and GFXNamedShaderConstant().

{
    unsigned int defhash = 0;
    if (defines != NULL) {
        defhash = 0xBA0BAB00;
        while (*defines) 
            defhash ^= (defhash * 127) | *(defines++);
    }
    return std::pair< unsigned int , std::pair< std::string, std::string > > (defhash, std::pair< std::string, std::string > ( vp, fp ));
}

int getDefaultProgram

(

)

Definition at line 349 of file gl_program.cpp.

References defaultprog, VegaConfig::getVariable(), GFXCreateProgram(), hifiprog, hifiProgramName, lowfiprog, lowfiProgramName, programChanged, and vs_config.

Referenced by GFXActivateShader(), and GFXDefaultShaderSupported().

{
    static bool initted = false;
    if (!initted) {
#ifdef __APPLE__
        hifiProgramName = vs_config->getVariable( "graphics", "mac_shader_name", "mac" );
#else
        hifiProgramName = vs_config->getVariable( "graphics", "shader_name", "default" );
#endif
        if (hifiProgramName.length() == 0) {
            lowfiprog = hifiprog = 0;
        } else {
            lowfiprog = GFXCreateProgram( lowfiProgramName.c_str(), lowfiProgramName.c_str(), NULL );
            if (lowfiprog == 0) lowfiprog = GFXCreateProgram( hifiProgramName.c_str(), hifiProgramName.c_str(), NULL );
            hifiprog  = GFXCreateProgram( hifiProgramName.c_str(), hifiProgramName.c_str(), NULL );
            if (hifiprog == 0) hifiprog = GFXCreateProgram( lowfiProgramName.c_str(), lowfiProgramName.c_str(), NULL );
        }
        defaultprog    = hifiprog;
        programChanged = true;
        initted = true;
    }
    return defaultprog;
}

static VSFileSystem::VSError getProgramSource ( const std::string &  path, std::vector< std::string > &  lines, std::set< std::string > &  processed_includes, char *  buf, size_t  buflen  )

static

Definition at line 87 of file gl_program.cpp.

References VSFileSystem::VSFile::Close(), f, VSFileSystem::Ok, VSFileSystem::VSFile::OpenReadOnly(), VSFileSystem::VSFile::ReadLine(), VSFileSystem::UnknownFile, and VSFileSystem::vs_fprintf().

Referenced by getProgramSource(), and GFXCreateProgramNoCache().

{
    std::string dirname = path.substr(0,path.find_last_of('/'));
    
    VSFileSystem::VSFile f;
    VSFileSystem::VSError err = f.OpenReadOnly( path.c_str(), UnknownFile );
    
    const char *include_directive = "#include \"";
    const size_t include_directive_len = 10;
    size_t lineno = 0;
    
    if (err <= Ok) {
        processed_includes.insert(path);
        
        while (Ok == f.ReadLine(buf, buflen)) {
            ++lineno;
            if (strncmp(buf, include_directive, include_directive_len) == 0) {
                // Process include directives
                char *eos = strchr(buf+include_directive_len, '\"');
                if (eos != NULL) {
                    *eos = 0;
                    std::string includepath = dirname + "/" + std::string(buf+include_directive_len);
                    if (processed_includes.count(includepath) == 0) {
                        // Set up line numbers for include file
                        lines.push_back("#line 0\n");
                        
                        VSFileSystem::VSError ierr = getProgramSource(includepath, lines, processed_includes, buf, buflen);
                        if (ierr > Ok) {
                            f.Close();
                            VSFileSystem::vs_fprintf(stderr, "ERROR: included from %s\n", path.c_str());
                            return ierr;
                        } else {
                            // Append a blank line to avoid issues and restore line numbers
                            lines.push_back("\n");
                            snprintf(buf, buflen, "#line %lu\n", lineno);
                            lines.push_back(buf);
                        }
                    } else {
                        // Insert blank line to keep line numbers consistent
                        lines.push_back("\n");
                    }
                } else {
                    VSFileSystem::vs_fprintf(stderr, "WARNING: broken include directive at file %s, line %d - skipping\n",
                        path.c_str(), lineno);
                }
            } else {
                // Append a line to the list
                lines.push_back(buf);
            }
        }
        
        f.Close();
    } else {
        VSFileSystem::vs_fprintf(stderr, "ERROR: at %s\n", path.c_str());
    }
    return err;
}

static VSFileSystem::VSError getProgramSource ( const std::string &  path, std::string &  source  )

static

Definition at line 145 of file gl_program.cpp.

References getProgramSource(), and VSFileSystem::Ok.

{
    std::set<std::string> processed_includes;
    std::vector<std::string> lines;
    char buf[16384];
    
    source.clear();
    
    VSFileSystem::VSError err = getProgramSource(path, lines, processed_includes, buf, sizeof(buf));
    
    if (err <= Ok) {
        size_t sourcelen=0;
        for (std::vector<std::string>::const_iterator it = lines.begin(); it != lines.end(); ++it)
            sourcelen += it->length();
        source.reserve(sourcelen);
        for (std::vector<std::string>::const_iterator it = lines.begin(); it != lines.end(); ++it)
            source += *it;
    }
    return err;
}

int GFXActivateShader

(

int

program)

Definition at line 504 of file gl_program.cpp.

References glUseProgram_p, and programChanged.

{
    static int lastprogram = 0;
    if (program != lastprogram)
        programChanged = true;
    if (program != lastprogram
#ifndef __APPLE__
        && glUseProgram_p
#endif
       ) {
        glUseProgram_p( program );
        lastprogram = program;
    } else {return 0; } return program;
}

int GFXActivateShader

(

const char *

program)

Definition at line 519 of file gl_program.cpp.

References getDefaultProgram(), GFXActivateShader(), and GFXCreateProgram().

Referenced by GFXActivateShader(), GFXDeactivateShader(), and GFXShaderReloaded().

{
    int defaultprogram = getDefaultProgram();
    int curprogram     = defaultprogram;
    if (program)
        curprogram = GFXCreateProgram( program, program, NULL );
    return GFXActivateShader( curprogram );
}

int GFXCreateProgram	(	const char *	vprogram,
		const char *	fprogram,
		const char *	extra_defines
	)

Definition at line 302 of file gl_program.cpp.

References cacheKey(), GFXCreateProgramNoCache(), programCache, and programICache.

Referenced by Technique::Pass::compile(), getDefaultProgram(), GFXActivateShader(), GFXCreateProgram(), and GFXReloadDefaultShader().

{
    ProgramCache::key_type key = cacheKey( vprogram, fprogram, extra_defines );
    ProgramCache::const_iterator it = programCache.find( key );
    if ( it != programCache.end() )
        return it->second;
    int rv = programCache[key] = GFXCreateProgramNoCache( vprogram, fprogram, extra_defines );
    programICache[rv] = key;
    return rv;
}

int GFXCreateProgram	(	char *	vprogram,
		char *	fprogram,
		char *	extra_defines
	)

Definition at line 313 of file gl_program.cpp.

References GFXCreateProgram().

{
    return GFXCreateProgram( (const char*) vprogram, (const char*) fprogram, (const char*) extra_defines );
}

static int GFXCreateProgramNoCache ( const char *  vprogram, const char *  fprogram, const char *  extra_defines  )

static

Definition at line 186 of file gl_program.cpp.

References appendDefines(), fprintf, getProgramSource(), glAttachShader_p, glCompileShader_p, glCreateProgram_p, glCreateShader_p, glDeleteProgram_p, glDeleteShader_p, glGetProgramInfoLog_p, glGetProgramiv_p, glGetShaderiv_p, glLinkProgram_p, glShaderSource_p, VSFileSystem::Ok, printLog(), validateLog(), and vf.

Referenced by GFXCreateProgram().

{
    if (vprogram[0] == '\0' && fprogram[0] == '\0') return 0;
#ifndef __APPLE__
    if (glGetProgramInfoLog_p == NULL || glCreateShader_p == NULL || glShaderSource_p == NULL || glCompileShader_p == NULL
        || glAttachShader_p == NULL || glLinkProgram_p == NULL || glGetShaderiv_p == NULL || glGetProgramiv_p == NULL)
        return 0;
#else
#ifdef OSX_LOWER_THAN_10_4
    return 0;
#endif
#endif
    GLenum errCode;
    while ( ( errCode = glGetError() ) != GL_NO_ERROR )
        printf( "Error code %s\n", gluErrorString( errCode ) );
    VSFileSystem::VSFile vf, ff;
    std::string vpfilename = std::string("programs/") + vprogram + ".vp";
    std::string fpfilename = std::string("programs/") + fprogram + ".fp";
    
    std::string vertexprg, fragprg;
    VSFileSystem::VSError vperr = getProgramSource(vpfilename, vertexprg);
    VSFileSystem::VSError fperr = getProgramSource(fpfilename, fragprg);
    if ( (vperr > Ok) || (fperr > Ok) ) {
        if (vperr > Ok)
            fprintf( stderr, "Vertex Program Error: Failed to open file %s\n", vpfilename.c_str() );
        if (fperr > Ok)
            fprintf( stderr, "Fragment Program Error: Failed to open file %s\n", fpfilename.c_str() );
        return 0;
    }
    
    if (extra_defines != NULL) {
        vertexprg = appendDefines( vertexprg, extra_defines );
        fragprg   = appendDefines( fragprg, extra_defines );
    }
    
    GLint vproghandle = 0;
    GLint fproghandle = 0;
    GLint sp = 0;
    if (vperr <= Ok) {
        vproghandle = glCreateShader_p( GL_VERTEX_SHADER );
        const char *tmp = vertexprg.c_str();
        glShaderSource_p( vproghandle, 1, &tmp, NULL );
        glCompileShader_p( vproghandle );
        GLint successp  = 0;
        glGetShaderiv_p( vproghandle, GL_COMPILE_STATUS, &successp );
        if (successp == 0) {
            printLog( vproghandle, true );
            fprintf( stderr, "Vertex Program Error: Failed to compile %s\n", vprogram );
            glDeleteShader_p( vproghandle );
            return 0;
        } else if (!validateLog( vproghandle, true )) {
            printLog( vproghandle, true );
            fprintf( stderr, "Vertex Program Error: Failed log validation for %s. Inspect log above for details.\n", vprogram );
            glDeleteShader_p( vproghandle );
            return 0;
        }
        printLog( vproghandle, true );
    }
    if (fperr <= Ok) {
        fproghandle = glCreateShader_p( GL_FRAGMENT_SHADER );
        const char *tmp = fragprg.c_str();
        glShaderSource_p( fproghandle, 1, &tmp, NULL );
        glCompileShader_p( fproghandle );
        GLint successp  = 0;
        glGetShaderiv_p( fproghandle, GL_COMPILE_STATUS, &successp );
        if (successp == 0) {
            printLog( fproghandle, true );
            fprintf( stderr, "Fragment Program Error: Failed to compile %s\n", fprogram );
            glDeleteShader_p( vproghandle );
            glDeleteShader_p( fproghandle );
            return 0;
        } else if (!validateLog( fproghandle, true )) {
            printLog( vproghandle, true );
            fprintf( stderr, "Vertex Program Error: Failed log validation for %s. Inspect log above for details.\n", vprogram );
            glDeleteShader_p( vproghandle );
            glDeleteShader_p( fproghandle );
            return 0;
        }
        printLog( fproghandle, true );
    }
    
    sp = glCreateProgram_p();
    glAttachShader_p( sp, vproghandle );
    glAttachShader_p( sp, fproghandle );
    glLinkProgram_p( sp );
    
    GLint successp = 0;
    glGetProgramiv_p( sp, GL_LINK_STATUS, &successp );
    if (successp == 0) {
        printLog( sp, false );
        fprintf( stderr, "Shader Program Error: Failed to link %s to %s\n", vprogram, fprogram );
        return 0;
    } else if (!validateLog( sp, false )) {
        printLog( sp, false );
        fprintf( stderr, "Shader Program Error: Failed log validation for vp:%s fp:%s. Inspect log above for details.\n", vprogram, fprogram );
        glDeleteShader_p( vproghandle );
        glDeleteShader_p( fproghandle );
        glDeleteProgram_p( sp );
        return 0;
    }
    printLog( sp, false );
    
    /* only for dev work
     *  glGetProgramiv_p(sp,GL_VALIDATE_STATUS,&successp);
     *  if (successp==0) {
     *  fprintf(stderr,"Shader Program Error: Failed to validate %s linking to %s\n",vprogram,fprogram);
     *  return 0;
     *  }
     */
    while ( ( errCode = glGetError() ) != GL_NO_ERROR ) {
        printf( "Error code %s\n", gluErrorString( errCode ) );
        sp = 0;         //no proper vertex prog support
    }
    return sp;
}

void GFXDeactivateShader

(

)

Definition at line 528 of file gl_program.cpp.

References GFXActivateShader().

Referenced by Mesh::ProcessUndrawnMeshes(), and Mesh::ProcessZFarMeshes().

{
    GFXActivateShader( (int) 0 );
}

bool GFXDefaultShaderSupported

(

)

Definition at line 499 of file gl_program.cpp.

References getDefaultProgram().

Referenced by init_opengl_extensions().

{
    return getDefaultProgram() != 0;
}

void GFXDestroyProgram

(

int

program)

Definition at line 318 of file gl_program.cpp.

References programCache, and programICache.

Referenced by Technique::Pass::compile().

{
    // Find program
    ProgramICache::iterator it = programICache.find( program );
    if (it != programICache.end()) {
        /*
        if (glDeleteProgram_p)
            glDeleteProgram_p( program );
        */
        // FIXME: Real problem here with program leakage, 
        //      but cannot destroy like this, brings all kind of issues
        //      since the caller may not hold the only reference.
        programCache.erase(it->second);
        programICache.erase(it);
    }
}

GameSpeed GFXGetFramerate

(

)

Definition at line 412 of file gl_program.cpp.

References defaultprog, gameplaydata, gpdcounter, hifiprog, i, int, j, JUSTRIGHT, lasttime, NUMFRAMESLOOK, queryTime(), TOOFAST, and TOOSLOW.

Referenced by GFXShaderReloaded().

{
    GameSpeed     retval    = JUSTRIGHT;
    static double lasttime  = queryTime();
    double thistime = queryTime();
    double framerate = 1./(thistime-lasttime);
    static double toofast   = 80;
    static double tooslow   = 29;
    static unsigned lim = 10;
    static int    penalty   = 10;
    static float  lowratio  = .125;
    static float  highratio = .75;
    GameSpeed     curframe;
    if (framerate > toofast) curframe = TOOFAST;
    else if (framerate > tooslow)
        curframe = JUSTRIGHT;
    else curframe = TOOSLOW;
    gameplaydata[( (unsigned int) gpdcounter++ )%NUMFRAMESLOOK] = curframe;
    unsigned int i = 0;
    if ( !( curframe == JUSTRIGHT
           || (curframe == TOOFAST && defaultprog == hifiprog) || (curframe == TOOSLOW && defaultprog == 0) ) ) {
        for (; i < lim; ++i)
            if (curframe != gameplaydata[( (unsigned int) (gpdcounter-i) )%NUMFRAMESLOOK])
                break;
        if (i == lim) {
            int correct   = 0;
            int incorrect = 0;
            for (unsigned int j = 0; j < NUMFRAMESLOOK; ++j) {
                if (gameplaydata[j] == curframe) correct++;
                if (gameplaydata[j] != curframe) incorrect++;
                if (curframe == TOOFAST && gameplaydata[j] == TOOSLOW)
                    incorrect += penalty;
            }
            double myratio = (double) correct/(double) (correct+incorrect);
            if (curframe == TOOFAST && myratio > highratio) {
                static int toomanyswitches = 3;
                toomanyswitches -= 1;
                if (toomanyswitches >= 0)
                    retval = curframe;                      //only switch back and forth so many times
            } else if (myratio > lowratio) {
                retval = curframe;
            }
        }
    }
    lasttime = thistime;
    if (retval != JUSTRIGHT)
        for (unsigned int i = 0; i < NUMFRAMESLOOK; ++i)
            gameplaydata[i] = JUSTRIGHT;
    return retval;
}

int GFXGetProgramVersion

(

)

Definition at line 647 of file gl_program.cpp.

References programVersion.

Referenced by Technique::Pass::compile(), and Technique::compile().

{
    return programVersion;
}

int GFXNamedShaderConstant	(	int	progID,
		const char *	name
	)

Definition at line 626 of file gl_program.cpp.

References glGetUniformLocation_p.

{
    if (1
#ifndef __APPLE__
        && glGetUniformLocation_p
#endif
       ) {
        int varloc = glGetUniformLocation_p( progID, name );
        return varloc;
    }
    return -1;     //varloc cound be 0
}

int GFXNamedShaderConstant	(	char *	progID,
		const char *	name
	)

Definition at line 639 of file gl_program.cpp.

References cacheKey(), defaultprog, GFXNamedShaderConstant(), and programCache.

Referenced by Technique::Pass::compile(), and GFXNamedShaderConstant().

{
    int programname = defaultprog;
    if (progID)
        programname = programCache[cacheKey( progID, progID, NULL )];
    return GFXNamedShaderConstant( programname, name );
}

void GFXReloadDefaultShader

(

)

Definition at line 373 of file gl_program.cpp.

References defaultprog, GFXCreateProgram(), glDeleteProgram_p, hifiprog, hifiProgramName, lowfiprog, lowfiProgramName, programChanged, programVersion, and VSFileSystem::vs_fprintf().

Referenced by doReloadShader().

{
    VSFileSystem::vs_fprintf(stderr, "Reloading all shaders\n");
    
    // Increasing the timestamp makes all programs elsewhere recompile
    ++programVersion;
    
    bool islow = (lowfiprog == defaultprog);
    if (glDeleteProgram_p && defaultprog) {
        glDeleteProgram_p( lowfiprog );
        glDeleteProgram_p( hifiprog );
    }
    programChanged = true;
    if (islow) {
        hifiprog    = GFXCreateProgram( hifiProgramName.c_str(), hifiProgramName.c_str(), NULL );
        if (hifiprog == 0) hifiprog = GFXCreateProgram( lowfiProgramName.c_str(), lowfiProgramName.c_str(), NULL );
        lowfiprog   = GFXCreateProgram( lowfiProgramName.c_str(), lowfiProgramName.c_str(), NULL );
        if (lowfiprog == 0) lowfiprog = GFXCreateProgram( hifiProgramName.c_str(), hifiProgramName.c_str(), NULL );
        defaultprog = lowfiprog;
    } else {
        lowfiprog   = GFXCreateProgram( lowfiProgramName.c_str(), lowfiProgramName.c_str(), NULL );
        if (lowfiprog == 0) lowfiprog = GFXCreateProgram( hifiProgramName.c_str(), hifiProgramName.c_str(), NULL );
        hifiprog    = GFXCreateProgram( hifiProgramName.c_str(), hifiProgramName.c_str(), NULL );
        if (hifiprog == 0) hifiprog = GFXCreateProgram( lowfiProgramName.c_str(), lowfiProgramName.c_str(), NULL );
        defaultprog = hifiprog;
    }
}

int GFXShaderConstant	(	int	name,
		float	v1,
		float	v2,
		float	v3,
		float	v4
	)

Definition at line 533 of file gl_program.cpp.

References glUniform4f_p.

{
    if (1
#ifndef __APPLE__
        && glUniform4f_p
#endif
       ) {
        glUniform4f_p( name, v1, v2, v3, v4 );
        return 1;
    }
    return 0;
}

int GFXShaderConstant	(	int	name,
		const float *	values
	)

Definition at line 546 of file gl_program.cpp.

References GFXShaderConstant().

{
    return GFXShaderConstant( name, values[0], values[1], values[2], values[3] );
}

int GFXShaderConstant	(	int	name,
		GFXColor	v
	)

Definition at line 551 of file gl_program.cpp.

References GFXColor::a, GFXColor::b, GFXColor::g, GFXShaderConstant(), and GFXColor::r.

{
    return GFXShaderConstant( name, v.r, v.g, v.b, v.a );
}

int GFXShaderConstant	(	int	name,
		Vector	v
	)

Definition at line 556 of file gl_program.cpp.

References GFXShaderConstant().

Referenced by GFXShaderConstant().

{
    return GFXShaderConstant( name, v.i, v.j, v.k, 0 );
}

int GFXShaderConstant	(	int	name,
		float	v1
	)

Definition at line 561 of file gl_program.cpp.

References glUniform1f_p.

{
    if (1
#ifndef __APPLE__
        && glUniform1f_p
#endif
       ) {
        glUniform1f_p( name, v1 );
        return 1;
    }
    return 0;
}

int GFXShaderConstant4v	(	int	name,
		unsigned int	count,
		const float *	values
	)

Definition at line 587 of file gl_program.cpp.

References glUniform4fv_p.

Referenced by GFXUploadLightState().

{
    if (1
#ifndef __APPLE__
        && glUniform4fv_p
#endif
       ) {
        glUniform4fv_p( name, count, values );
        return 1;
    }
    return 0;
}

int GFXShaderConstanti	(	int	name,
		int	value
	)

Definition at line 600 of file gl_program.cpp.

References glUniform1i_p.

Referenced by GFXUploadLightState().

{
    if (1
#ifndef __APPLE__
        && glUniform1i_p
#endif
       ) {
        glUniform1i_p( name, value );
        return 1;
    }
    return 0;
}

int GFXShaderConstantv	(	int	name,
		unsigned int	count,
		const float *	values
	)

Definition at line 574 of file gl_program.cpp.

References glUniform1fv_p.

Referenced by GFXUploadLightState().

{
    if (1
#ifndef __APPLE__
        && glUniform1fv_p
#endif
       ) {
        glUniform1fv_p( name, count, values );
        return 1;
    }
    return 0;
}

int GFXShaderConstantv	(	int	name,
		unsigned int	count,
		const int *	value
	)

Definition at line 613 of file gl_program.cpp.

References glUniform1i_p, and glUniform1iv_p.

{
    if (1
#ifndef __APPLE__
        && glUniform1i_p
#endif
       ) {
        glUniform1iv_p( name, count, (GLint*) value );
        return 1;
    }
    return 0;
}

bool GFXShaderReloaded

(

)

Definition at line 463 of file gl_program.cpp.

References defaultprog, VegaConfig::getVariable(), GFXActivateShader(), GFXGetFramerate(), hifiprog, lowfiprog, XMLSupport::parse_bool(), programChanged, TOOFAST, TOOSLOW, and vs_config.

{
    bool retval = programChanged;
    static bool framerate_changes_shader =
        XMLSupport::parse_bool( vs_config->getVariable( "graphics", "framerate_changes_shader", "false" ) );
    if (framerate_changes_shader) {
        switch ( GFXGetFramerate() )
        {
        case TOOSLOW:
            if (defaultprog) {
                retval = true;
                if (defaultprog == hifiprog)
                    defaultprog = lowfiprog;
                else
                    defaultprog = 0;
                GFXActivateShader( (char*) NULL );
            }
            break;
        case TOOFAST:
            if (defaultprog != hifiprog) {
                retval = true;
                if (defaultprog == 0)
                    defaultprog = lowfiprog;
                else
                    defaultprog = hifiprog;
                GFXActivateShader( (char*) NULL );
            }
            break;
        default:
            break;
        }
    }
    programChanged = false;
    return retval;
}

void printLog	(	GLuint	obj,
		bool	shader
	)

Definition at line 68 of file gl_program.cpp.

References fprintf, glGetProgramInfoLog_p, and glGetShaderInfoLog_p.

Referenced by GFXCreateProgramNoCache().

{
    const GLsizei LOGBUF = 1024;
    GLsizei infologLength = 0;
    char    infoLog[LOGBUF+1]; // +1 for null terminator
    
    if (shader)
        glGetShaderInfoLog_p( obj, 1024, &infologLength, infoLog );
    else
        glGetProgramInfoLog_p( obj, 1024, &infologLength, infoLog );
    
    // make sure infoLog is null-termiated;
    assert(infologLength <= LOGBUF);
    infoLog[infologLength] = 0;
    
    if (infologLength > 0)
        fprintf( stderr, "%s\n", infoLog );
}

static bool validateLog ( GLuint  obj, bool  shader, bool  allowSoftwareEmulation = false  )

static

Definition at line 37 of file gl_program.cpp.

References glGetProgramInfoLog_p, and glGetShaderInfoLog_p.

Referenced by GFXCreateProgramNoCache().

{
    // Retrieve compiler log
    const GLsizei LOGBUF = 1024;
    GLsizei infologLength = 0;
    char    infoLog[LOGBUF+1]; // +1 for null terminator
    
    if (shader)
        glGetShaderInfoLog_p( obj, LOGBUF, &infologLength, infoLog );
    else
        glGetProgramInfoLog_p( obj, LOGBUF, &infologLength, infoLog );
    
    if (infologLength > 0) {
        // make sure infoLog is null-termiated;
        assert(infologLength <= LOGBUF);
        infoLog[infologLength] = 0;
        
        // search for signs of emulated execution
        if (!allowSoftwareEmulation) {
            if (icontains(infoLog, "run in software"))
                return false;
            if (icontains(infoLog, "run on software"))
                return false;
        }
    }
    
    // No validation failed...
    return true;
}

Variable Documentation

int defaultprog = 0

static

Definition at line 337 of file gl_program.cpp.

Referenced by getDefaultProgram(), GFXGetFramerate(), GFXNamedShaderConstant(), GFXReloadDefaultShader(), and GFXShaderReloaded().

GameSpeed gameplaydata[NUMFRAMESLOOK] = {JUSTRIGHT}

Definition at line 410 of file gl_program.cpp.

Referenced by GFXGetFramerate().

unsigned int gpdcounter = (1<<30)

Definition at line 408 of file gl_program.cpp.

Referenced by GFXGetFramerate().

int hifiprog = 0

static

Definition at line 339 of file gl_program.cpp.

Referenced by getDefaultProgram(), GFXGetFramerate(), GFXReloadDefaultShader(), and GFXShaderReloaded().

std::string hifiProgramName = "default"

Definition at line 345 of file gl_program.cpp.

Referenced by getDefaultProgram(), and GFXReloadDefaultShader().

int lowfiprog = 0

static

Definition at line 338 of file gl_program.cpp.

Referenced by getDefaultProgram(), GFXReloadDefaultShader(), and GFXShaderReloaded().

std::string lowfiProgramName = "lite"

Definition at line 346 of file gl_program.cpp.

Referenced by getDefaultProgram(), and GFXReloadDefaultShader().

ProgramCache programCache

static

Definition at line 23 of file gl_program.cpp.

Referenced by GFXCreateProgram(), GFXDestroyProgram(), and GFXNamedShaderConstant().

int programChanged = false

static

Definition at line 335 of file gl_program.cpp.

Referenced by getDefaultProgram(), GFXActivateShader(), GFXReloadDefaultShader(), and GFXShaderReloaded().

ProgramICache programICache

static

Definition at line 24 of file gl_program.cpp.

Referenced by GFXCreateProgram(), and GFXDestroyProgram().

int programVersion = 0

static

Definition at line 336 of file gl_program.cpp.

Referenced by GFXGetProgramVersion(), and GFXReloadDefaultShader().