/*
===============
R_BeginFrame
===============
*/
void R_BeginFrame( qboolean clearScene )
{
glConfig.softwareGammaUpdate = false; // in case of possible fails
if(( gl_clear->integer || gl_overview->integer ) && clearScene && cls.state != ca_cinematic )
{
pglClear( GL_COLOR_BUFFER_BIT );
}
// update gamma
if( vid_gamma->modified )
{
glConfig.softwareGammaUpdate = true;
BuildGammaTable( vid_gamma->value, vid_texgamma->value );
GL_RebuildLightmaps();
glConfig.softwareGammaUpdate = false;
vid_gamma->modified = false;
}
R_Set2DMode( true );
// draw buffer stuff
pglDrawBuffer( GL_BACK );
// texturemode stuff
// update texture parameters
if( gl_texturemode->modified || gl_texture_anisotropy->modified || gl_texture_lodbias ->modified )
R_SetTextureParameters();
// swapinterval stuff
GL_UpdateSwapInterval();
CL_ExtraUpdate ();
}
/*
=================
V_CheckGamma
=================
*/
qboolean V_CheckGamma (void)
{
static float oldgammavalue;
if (v_gamma.value == oldgammavalue)
return FALSE;
oldgammavalue = v_gamma.value;
BuildGammaTable (v_gamma.value);
vid.recalc_refdef = 1; // force a surface cache flush
return TRUE;
}
void VID_StartupGamma( void )
{
// Device supports gamma anyway, but cannot do anything with it.
fs_offset_t gamma_size;
byte *savedGamma;
size_t gammaTypeSize = sizeof(glState.stateRamp);
// init gamma ramp
Q_memset( glState.stateRamp, 0, gammaTypeSize);
// force to set cvar
Cvar_FullSet( "gl_ignorehwgamma", "1", CVAR_GLCONFIG );
glConfig.deviceSupportsGamma = false; // even if supported!
BuildGammaTable( vid_gamma->value, vid_texgamma->value );
MsgDev( D_NOTE, "VID_StartupGamma: software gamma initialized\n" );
}
void CRender::DrawSceneBegin( void )
{
UpdateStudioRenderConfig();
UpdateMaterialSystemConfig();
if( MaterialConfigLightingChanged() || UpdateLightmapColorScale() )
{
ClearMaterialConfigLightingChanged();
Con_Printf( "Redownloading all lightmaps\n" );
float overbright = 1.0f;
if (g_pMaterialSystemHardwareConfig->SupportsOverbright())
{
overbright = mat_overbright.GetFloat();
}
BuildGammaTable( 2.2f, 2.2f, 0.0f, overbright );
R_RedownloadAllLightmaps( vec3_origin );
materialSystemInterface->FlushLightmaps();
StaticPropMgr()->RecomputeStaticLighting();
}
}
/*
=============
V_Init
=============
*/
void
V_Init(void)
{
Cmd_AddCommand("v_cshift", V_cshift_f);
Cmd_AddCommand("bf", V_BonusFlash_f);
Cmd_AddCommand("centerview", V_StartPitchDrift);
Cvar_RegisterVariable(&v_centermove);
Cvar_RegisterVariable(&v_centerspeed);
Cvar_RegisterVariable(&v_iyaw_cycle);
Cvar_RegisterVariable(&v_iroll_cycle);
Cvar_RegisterVariable(&v_ipitch_cycle);
Cvar_RegisterVariable(&v_iyaw_level);
Cvar_RegisterVariable(&v_iroll_level);
Cvar_RegisterVariable(&v_ipitch_level);
Cvar_RegisterVariable(&v_idlescale);
Cvar_RegisterVariable(&crosshair);
Cvar_RegisterVariable(&crosshaircolor);
Cvar_RegisterVariable(&cl_crossx);
Cvar_RegisterVariable(&cl_crossy);
#ifdef GLQUAKE
Cvar_RegisterVariable(&gl_cshiftpercent);
#endif
Cvar_RegisterVariable(&scr_ofsx);
Cvar_RegisterVariable(&scr_ofsy);
Cvar_RegisterVariable(&scr_ofsz);
Cvar_RegisterVariable(&cl_rollspeed);
Cvar_RegisterVariable(&cl_rollangle);
Cvar_RegisterVariable(&cl_bob);
Cvar_RegisterVariable(&cl_bobcycle);
Cvar_RegisterVariable(&cl_bobup);
Cvar_RegisterVariable(&v_kicktime);
Cvar_RegisterVariable(&v_kickroll);
Cvar_RegisterVariable(&v_kickpitch);
BuildGammaTable(1.0); // no gamma yet
Cvar_RegisterVariable(&v_gamma);
}
void VID_StartupGamma( void )
{
// Device supports gamma anyway, but cannot do anything with it.
fs_offset_t gamma_size;
byte *savedGamma;
size_t gammaTypeSize = sizeof(glState.stateRamp);
// init gamma ramp
Q_memset( glState.stateRamp, 0, gammaTypeSize);
#if defined(XASH_SDL)
glConfig.deviceSupportsGamma = !SDL_GetWindowGammaRamp( host.hWnd, NULL, NULL, NULL);
#endif
if( !glConfig.deviceSupportsGamma )
{
// force to set cvar
Cvar_FullSet( "gl_ignorehwgamma", "1", CVAR_GLCONFIG );
MsgDev( D_ERROR, "VID_StartupGamma: hardware gamma unsupported\n");
}
if( gl_ignorehwgamma->integer )
{
glConfig.deviceSupportsGamma = false; // even if supported!
BuildGammaTable( vid_gamma->value, vid_texgamma->value );
MsgDev( D_NOTE, "VID_StartupGamma: software gamma initialized\n" );
return;
}
// share this extension so engine can grab them
GL_SetExtension( GL_HARDWARE_GAMMA_CONTROL, glConfig.deviceSupportsGamma );
savedGamma = FS_LoadFile( "gamma.dat", &gamma_size, false );
if( !savedGamma || gamma_size != (fs_offset_t)gammaTypeSize)
{
// saved gamma not found or corrupted file
FS_WriteFile( "gamma.dat", glState.stateRamp, gammaTypeSize);
MsgDev( D_NOTE, "VID_StartupGamma: gamma.dat initialized\n" );
if( savedGamma ) Mem_Free( savedGamma );
}
else
{
GL_BuildGammaTable();
// validate base gamma
if( !Q_memcmp( savedGamma, glState.stateRamp, gammaTypeSize))
{
// all ok, previous gamma is valid
MsgDev( D_NOTE, "VID_StartupGamma: validate screen gamma - ok\n" );
}
else if( !Q_memcmp( glState.gammaRamp, glState.stateRamp, gammaTypeSize))
{
// screen gamma is equal to render gamma (probably previous instance crashed)
// run additional check to make sure for it
if( Q_memcmp( savedGamma, glState.stateRamp, gammaTypeSize))
{
// yes, current gamma it's totally wrong, restore it from gamma.dat
MsgDev( D_NOTE, "VID_StartupGamma: restore original gamma after crash\n" );
Q_memcpy( glState.stateRamp, savedGamma, gammaTypeSize);
}
else
{
// oops, savedGamma == glState.stateRamp == glState.gammaRamp
// probably r_gamma set as default
MsgDev( D_NOTE, "VID_StartupGamma: validate screen gamma - disabled\n" );
}
}
else if( !Q_memcmp( glState.gammaRamp, savedGamma, gammaTypeSize))
{
// saved gamma is equal render gamma, probably gamma.dat wroted after crash
// run additional check to make sure it
if( Q_memcmp( savedGamma, glState.stateRamp, gammaTypeSize))
{
// yes, saved gamma it's totally wrong, get origianl gamma from screen
MsgDev( D_NOTE, "VID_StartupGamma: merge gamma.dat after crash\n" );
FS_WriteFile( "gamma.dat", glState.stateRamp, gammaTypeSize);
}
else
{
// oops, savedGamma == glState.stateRamp == glState.gammaRamp
// probably r_gamma set as default
MsgDev( D_NOTE, "VID_StartupGamma: validate screen gamma - disabled\n" );
}
}
else
{
// current gamma unset by other application, so we can restore it here
MsgDev( D_NOTE, "VID_StartupGamma: restore original gamma after crash\n" );
Q_memcpy( glState.stateRamp, savedGamma, gammaTypeSize);
}
Mem_Free( savedGamma );
}
vid_gamma->modified = true;
}
int MpImage::GammaCorrection (double red_gamma,
double green_gamma,
double blue_gamma,
int minval, int maxval)
{
int retval = true;
const int MCV = int(MaxChannelValue);
// nothing to do
if (red_gamma == 1.0 &&
green_gamma == 1.0 &&
blue_gamma == 1.0) return true;
// check for valid input
if (red_gamma == 0.0 ||
green_gamma == 0.0 ||
blue_gamma == 0.0) return false;
// defaults to maximal channel value
if (maxval < 0) maxval = MCV;
// enforce valid range
MpForceRange(maxval,0,MCV);
MpForceRange(minval,0,MCV);
// allocate the gamma tables
ImageChannelT *rtable = 0, *gtable = 0, *btable = 0;
rtable = new ImageChannelT [MCV+1];
if (! rtable) return false;
BuildGammaTable (rtable,minval,maxval,red_gamma);
if (green_gamma == red_gamma)
gtable = rtable;
else {
gtable = new ImageChannelT [MCV+1];
BuildGammaTable (gtable,minval,maxval,green_gamma);
if (! gtable) retval = false;
}
if (retval) {
if (blue_gamma == red_gamma)
btable = rtable;
else if (blue_gamma == green_gamma) {
btable = gtable;
} else {
btable = new ImageChannelT [MCV+1];
BuildGammaTable (btable,minval,maxval,blue_gamma);
if (! btable) retval = false;
}
if (retval) {
// do gamma correction
ImageChannelT *data = GetData();
int N = GetWidth() * GetLength();
for (int i = 0; i < N; i++, data += 3) {
data[0] = rtable[data[0]];
data[1] = gtable[data[1]];
data[2] = btable[data[2]];
}
}
}
// free tables
if (rtable) delete rtable;
if (gtable && green_gamma != red_gamma) delete gtable;
if (btable && blue_gamma != red_gamma && blue_gamma != green_gamma) delete btable;
return retval;
}
int main (int argc, char ** argv)
{
int i = 0;
int dir = 1;
//Open port
int fd = open(kPortName, O_RDWR | O_SYNC);
//Amt of memory for the strip
int stripBuffSize = sizeof(char) * 3 * STRIP_SIZE + 1;
char* strip = (char*)malloc(stripBuffSize);
printf("Port id is %i. Building gamma table\n", fd);
//Build gamma table
BuildGammaTable();
printf("Gamma table generation complete\n");
//Clear the strip
memset(strip, 0, stripBuffSize);
if (fd != -1)
{
int j = 0;
int k = 0;
for (;;)
{
//Write the colour buffer to the SPI port
write(fd, strip, stripBuffSize);
//Control direction of cosine wave. Pause at extrema
if (j == STRIP_SIZE - 1)
{
dir = -1;
usleep(100000);
}
else if (j == 0)
{
dir = 1;
usleep(100000);
}
j += dir;
usleep(16000);
//RandomizeStrip(strip);
//Update the colour buffer
for (i = 0; i < STRIP_SIZE; ++i)
{
float val = cos(((float)(j % STRIP_SIZE) - (float)i) / (float)(STRIP_SIZE / 2.0f) * PI / 2.0f);
if (val < 0.0f)
{
val = 0.0f;
}
SetPixel(strip, (char)round(pow(val, 3.0f) * 255.0f), 0, 0, i);
}
}
//Close port
close(fd);
}
else
{
printf("%s isn't a valid SPI port", kPortName);
}
//Free memory
if (kGammaTable != 0)
{
free(kGammaTable);
}
free(strip);
return 0;
}
