mirror of
https://github.com/UberGames/RPG-X2.git
synced 2024-11-25 05:42:18 +00:00
434 lines
10 KiB
C
434 lines
10 KiB
C
#include "cg_local.h"
|
|
#include "cg_screenfx.h"
|
|
|
|
// this is the list of currently drawing fx and their start times and end times
|
|
screenFX_t theScreenFX;
|
|
|
|
int CG_GetScreenEffectEndTime(int event)
|
|
{
|
|
switch (event)
|
|
{
|
|
case SCREENFX_TRANSPORTER:
|
|
return cg.time + 1000;
|
|
case SCREENFX_SP_TRANSPORTER_IN:
|
|
return cg.time + 4000;
|
|
case SCREENFX_SP_TRANSPORTER_OUT:
|
|
return cg.time + 8000;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
// maybe play a sound or something?
|
|
void CG_BeginScreenEffect(int event)
|
|
{
|
|
switch (event)
|
|
{
|
|
case SCREENFX_TRANSPORTER:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
// when adding a new effect, we'll either take an empty slot in theScreenFX or
|
|
//overwrite the oldest effect
|
|
void CG_AddFullScreenEffect(int screenfx, int clientNum)
|
|
{
|
|
int i = 0, oldestTime = cg.time, oldestEffect = 0;
|
|
|
|
if (clientNum != cg.predictedPlayerState.clientNum)
|
|
{ // only add screen effects for our client
|
|
return;
|
|
}
|
|
for (i = 0; i < MAX_SCREENFX; i++)
|
|
{
|
|
// if we already have one of these effects going, just add to the duration of
|
|
//the existing one...don't create a new instance of the same effect
|
|
if (theScreenFX.events[i] == screenfx)
|
|
{
|
|
theScreenFX.cgStartTimes[i] = cg.time;
|
|
theScreenFX.cgEndTimes[i] = CG_GetScreenEffectEndTime(screenfx);
|
|
return;
|
|
}
|
|
else if (theScreenFX.cgStartTimes[i])
|
|
{
|
|
if (theScreenFX.cgStartTimes[i] < oldestTime)
|
|
{
|
|
oldestTime = theScreenFX.cgStartTimes[i];
|
|
oldestEffect = i;
|
|
}
|
|
}
|
|
//Hack-didily-ack - TiM: If were already one powerup, switch to the next
|
|
else if ( screenfx == SCREENFX_SP_TRANSPORTER_OUT ) {
|
|
if ( theScreenFX.events[i] == SCREENFX_SP_TRANSPORTER_IN ) {
|
|
theScreenFX.events[i] = 0;
|
|
theScreenFX.cgStartTimes[i] = 0;
|
|
theScreenFX.cgEndTimes[i] = 0;
|
|
}
|
|
}
|
|
else if ( screenfx == SCREENFX_SP_TRANSPORTER_IN ) {
|
|
if ( theScreenFX.events[i] == SCREENFX_SP_TRANSPORTER_OUT ) {
|
|
theScreenFX.events[i] = 0;
|
|
theScreenFX.cgStartTimes[i] = 0;
|
|
theScreenFX.cgEndTimes[i] = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
oldestTime = theScreenFX.cgStartTimes[i];
|
|
oldestEffect = i;
|
|
}
|
|
}
|
|
theScreenFX.events[oldestEffect] = screenfx;
|
|
theScreenFX.cgStartTimes[oldestEffect] = cg.time;
|
|
theScreenFX.cgEndTimes[oldestEffect] = CG_GetScreenEffectEndTime(screenfx);
|
|
CG_BeginScreenEffect(screenfx);
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
===============
|
|
CG_DrawScreenQuad
|
|
|
|
===============
|
|
*/
|
|
|
|
|
|
static void CG_DrawScreenQuad(float alpha, qhandle_t screenshader)
|
|
{
|
|
refEntity_t ent;
|
|
float radius;
|
|
|
|
// ragePro systems can't fade blends, so don't obscure the screen
|
|
if ( cgs.glconfig.hardwareType == GLHW_RAGEPRO ) {
|
|
return;
|
|
}
|
|
|
|
if (cg.refdef.fov_x > 120)
|
|
{
|
|
return; // Too wide to show this.
|
|
}
|
|
else if (cg.refdef.fov_x > 80)
|
|
{
|
|
radius = 8.0 + (cg.refdef.fov_x - 80)*0.2;
|
|
}
|
|
else
|
|
{
|
|
radius = 8.0;
|
|
}
|
|
|
|
memset( &ent, 0, sizeof( ent ) );
|
|
ent.reType = RT_SPRITE;
|
|
ent.renderfx = RF_FIRST_PERSON;
|
|
|
|
VectorMA( cg.refdef.vieworg, 8, cg.refdef.viewaxis[0], ent.origin );
|
|
|
|
ent.data.sprite.radius = radius;
|
|
ent.customShader = screenshader;
|
|
ent.shaderRGBA[0] = alpha * 255;
|
|
ent.shaderRGBA[1] = alpha * 255;
|
|
ent.shaderRGBA[2] = alpha * 255;
|
|
ent.shaderRGBA[3] = 255;
|
|
trap_R_AddRefEntityToScene( &ent );
|
|
}
|
|
|
|
/*
|
|
static void CG_DrawDirectionalScreenQuad(float alpha, qhandle_t screenshader)
|
|
{
|
|
refEntity_t ent;
|
|
vec3_t screencenter;
|
|
byte topleft, topright, lowleft, lowright, top, low, left, right;
|
|
float val;
|
|
|
|
// ragePro systems can't fade blends, so don't obscure the screen
|
|
if ( cgs.glconfig.hardwareType == GLHW_RAGEPRO ) {
|
|
return;
|
|
}
|
|
|
|
// Set up all the basic info about this refentity
|
|
VectorMA( cg.refdef.vieworg, 8, cg.refdef.viewaxis[0], screencenter);
|
|
|
|
memset( &ent, 0, sizeof( ent ) );
|
|
ent.reType = RT_ALPHAVERTPOLY;
|
|
ent.renderfx = RF_FIRST_PERSON;
|
|
|
|
ent.data.sprite.radius = 4;
|
|
ent.customShader = screenshader;
|
|
* (unsigned int *) ent.shaderRGBA = 0xffffffff;
|
|
* (unsigned int *) ent.data.sprite.vertRGBA[0] = 0xffffffff;
|
|
* (unsigned int *) ent.data.sprite.vertRGBA[1] = 0xffffffff;
|
|
* (unsigned int *) ent.data.sprite.vertRGBA[2] = 0xffffffff;
|
|
* (unsigned int *) ent.data.sprite.vertRGBA[3] = 0xffffffff;
|
|
|
|
// left
|
|
val = alpha*(0.5 + 0.5*(cg.damageX - fabs(cg.damageY)));
|
|
if (val<0)
|
|
left=0;
|
|
else if (val>1.0)
|
|
left=255;
|
|
else
|
|
left=255.0*val;
|
|
|
|
// upper left
|
|
val = alpha*(0.5*(cg.damageX + cg.damageY));
|
|
if (val<0)
|
|
topleft=0;
|
|
else if (val>1.0)
|
|
topleft=255;
|
|
else
|
|
topleft=255.0*val;
|
|
|
|
// top
|
|
val = alpha*(0.5 + 0.5*(-fabs(cg.damageX) + cg.damageY));
|
|
if (val<0)
|
|
top=0;
|
|
else if (val>1.0)
|
|
top=255;
|
|
else
|
|
top=255.0*val;
|
|
|
|
// upper right
|
|
val = alpha*(0.5*(-cg.damageX + cg.damageY));
|
|
if (val<0)
|
|
topright=0;
|
|
else if (val>1.0)
|
|
topright=255;
|
|
else
|
|
topright=255.0*val;
|
|
|
|
// right
|
|
val = alpha*(0.5 + 0.5*(-cg.damageX - fabs(cg.damageY)));
|
|
if (val<0)
|
|
right=0;
|
|
else if (val>1.0)
|
|
right=255;
|
|
else
|
|
right=255.0*val;
|
|
|
|
// lower right
|
|
val = alpha*(0.5*(-cg.damageX - cg.damageY));
|
|
if (val<0)
|
|
lowright=0;
|
|
else if (val>1.0)
|
|
lowright=255;
|
|
else
|
|
lowright=255.0*val;
|
|
|
|
// bottom
|
|
val = alpha*(0.5 + 0.5*(-fabs(cg.damageX) - cg.damageY));
|
|
if (val<0)
|
|
low=0;
|
|
else if (val>1.0)
|
|
low=255;
|
|
else
|
|
low=255.0*val;
|
|
|
|
// lower left
|
|
val = alpha*(0.5*(cg.damageX - cg.damageY));
|
|
if (val<0)
|
|
lowleft=0;
|
|
else if (val>1.0)
|
|
lowleft=255;
|
|
else
|
|
lowleft=255.0*val;
|
|
|
|
|
|
// Draw the upper left corner
|
|
VectorMA(screencenter, 4, cg.refdef.viewaxis[1], ent.origin);
|
|
VectorMA(ent.origin, 4, cg.refdef.viewaxis[2], ent.origin);
|
|
ent.data.sprite.vertRGBA[0][3] = topleft;
|
|
ent.data.sprite.vertRGBA[1][3] = top;
|
|
ent.data.sprite.vertRGBA[2][3] = 0;
|
|
ent.data.sprite.vertRGBA[3][3] = left;
|
|
trap_R_AddRefEntityToScene( &ent );
|
|
|
|
|
|
// Draw topper right corner
|
|
VectorMA(screencenter, -4, cg.refdef.viewaxis[1], ent.origin);
|
|
VectorMA(ent.origin, 4, cg.refdef.viewaxis[2], ent.origin);
|
|
ent.data.sprite.vertRGBA[0][3] = top;
|
|
ent.data.sprite.vertRGBA[1][3] = topright;
|
|
ent.data.sprite.vertRGBA[2][3] = right;
|
|
ent.data.sprite.vertRGBA[3][3] = 0;
|
|
trap_R_AddRefEntityToScene( &ent );
|
|
|
|
|
|
// Draw lower right corner
|
|
VectorMA(screencenter, -4, cg.refdef.viewaxis[1], ent.origin);
|
|
VectorMA(ent.origin, -4, cg.refdef.viewaxis[2], ent.origin);
|
|
ent.data.sprite.vertRGBA[0][3] = 0;
|
|
ent.data.sprite.vertRGBA[1][3] = right;
|
|
ent.data.sprite.vertRGBA[2][3] = lowright;
|
|
ent.data.sprite.vertRGBA[3][3] = low;
|
|
trap_R_AddRefEntityToScene( &ent );
|
|
|
|
|
|
// Draw lower left corner
|
|
VectorMA(screencenter, 4, cg.refdef.viewaxis[1], ent.origin);
|
|
VectorMA(ent.origin, -4, cg.refdef.viewaxis[2], ent.origin);
|
|
ent.data.sprite.vertRGBA[0][3] = left;
|
|
ent.data.sprite.vertRGBA[1][3] = 0;
|
|
ent.data.sprite.vertRGBA[2][3] = low;
|
|
ent.data.sprite.vertRGBA[3][3] = lowleft;
|
|
trap_R_AddRefEntityToScene( &ent );
|
|
|
|
}
|
|
*/
|
|
|
|
static void CG_DrawScreenBlob(float redalpha, float greenalpha)
|
|
{
|
|
refEntity_t ent;
|
|
float alphascale;
|
|
float bluealpha = 0;
|
|
|
|
// ragePro systems can't fade blends, so don't obscure the screen
|
|
if ( cgs.glconfig.hardwareType == GLHW_RAGEPRO ) {
|
|
return;
|
|
}
|
|
|
|
memset( &ent, 0, sizeof( ent ) );
|
|
ent.reType = RT_SPRITE;
|
|
ent.renderfx = RF_FIRST_PERSON;
|
|
|
|
// Available input:
|
|
// cg.damageValue: Range from 0 to 1, indicating the amount of damage.
|
|
// cg.damageX and cg_damageY: Range from -1 to 1, indicating the location of the damage.
|
|
|
|
VectorMA( cg.refdef.vieworg, 8, cg.refdef.viewaxis[0], ent.origin );
|
|
VectorMA( ent.origin, cg.damageX * -8, cg.refdef.viewaxis[1], ent.origin );
|
|
VectorMA( ent.origin, cg.damageY * 8, cg.refdef.viewaxis[2], ent.origin );
|
|
|
|
// Here's the scoop: The closer we are to the center, the more transparent this blob is.
|
|
alphascale = (2*fabs(cg.damageX)+fabs(cg.damageY))/3.0;
|
|
redalpha *= alphascale;
|
|
greenalpha *= alphascale;
|
|
|
|
if (redalpha > greenalpha)
|
|
{
|
|
ent.data.sprite.radius = cg.damageValue * 15 * redalpha;
|
|
}
|
|
else
|
|
{
|
|
ent.data.sprite.radius = cg.damageShieldValue * 15 * greenalpha;
|
|
}
|
|
|
|
/* if (redalpha < 0.01)
|
|
{ // Just shield damage
|
|
ent.customShader = cgs.media.shieldBlobShader;
|
|
// Set all colors to the same as green, since the shader is green
|
|
redalpha = bluealpha = greenalpha;
|
|
}
|
|
else*/ if (greenalpha < 0.01)
|
|
{ // Just pain damage
|
|
ent.customShader = cgs.media.painBlobShader;
|
|
// Set all colors to the same as red, since the shader is red
|
|
greenalpha = bluealpha = redalpha;
|
|
}
|
|
else
|
|
{ // Both
|
|
ent.customShader = cgs.media.painShieldBlobShader;
|
|
}
|
|
|
|
ent.shaderRGBA[0] = 0xff * redalpha;
|
|
ent.shaderRGBA[1] = 0xff * greenalpha;
|
|
ent.shaderRGBA[2] = 0xff * bluealpha;
|
|
ent.shaderRGBA[3] = 0xff;
|
|
trap_R_AddRefEntityToScene( &ent );
|
|
}
|
|
|
|
|
|
|
|
void CG_DrawFullScreenEffect(int screenfx, int start, int end)
|
|
{
|
|
float alpha, alpha2 = 0.0; //TiM - second alpha
|
|
int end2, start2;
|
|
|
|
alpha = (float)(end-cg.time)/(float)(end-start);
|
|
|
|
switch (screenfx)
|
|
{
|
|
case SCREENFX_TRANSPORTER:
|
|
CG_DrawScreenQuad(alpha, cgs.media.teleportEffectShader);
|
|
break;
|
|
case SCREENFX_SP_TRANSPORTER_IN:
|
|
end2=end - 2500;
|
|
|
|
CG_DrawScreenQuad( alpha, cgs.media.teleportEffectShader);
|
|
//Fade in a white quad a little later
|
|
if (cg.time <= end2 ) {
|
|
alpha2 = (float)(end2-cg.time)/(float)(end2-start);
|
|
CG_DrawScreenQuad( alpha2, cgs.media.white2Shader);
|
|
}
|
|
break;
|
|
case SCREENFX_SP_TRANSPORTER_OUT:
|
|
start2=start+2500;
|
|
end2=end - 4000;
|
|
|
|
alpha = (float)(end2-cg.time)/(float)(end2-start);
|
|
CG_DrawScreenQuad(( 1.0f - alpha), cgs.media.teleportEffectShader);
|
|
if ( cg.time >= start2 ) {
|
|
alpha2 = (float)(end2-cg.time)/(float)(end2-start2);
|
|
if ( cg.time >= end2 )
|
|
alpha2=0.0f;
|
|
|
|
CG_DrawScreenQuad( ( 1.0f - alpha2), cgs.media.white2Shader);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
void CG_DrawFullScreenFX( void )
|
|
{
|
|
int i = 0, t;
|
|
float alpha, redalpha, greenalpha;
|
|
|
|
if ( (cg.snap->ps.clientNum != cg.predictedPlayerState.clientNum) || cg.renderingThirdPerson )
|
|
{
|
|
return;
|
|
}
|
|
|
|
t = cg.time - cg.damageTime;
|
|
if ( t > 0 && t < DAMAGE_TIME)
|
|
{ // Draw the blobs.
|
|
alpha = 1.0 - ((float)t / (float)DAMAGE_TIME);
|
|
|
|
redalpha = alpha*cg.damageValue*1.5;
|
|
if (redalpha > 1.0)
|
|
{
|
|
redalpha = 1.0;
|
|
}
|
|
|
|
greenalpha = alpha*cg.damageShieldValue*1.5;
|
|
if (greenalpha > 1.0)
|
|
{
|
|
greenalpha = 1.0;
|
|
}
|
|
|
|
CG_DrawScreenBlob(redalpha, greenalpha);
|
|
}
|
|
|
|
for (i = 0; i < MAX_SCREENFX; i++)
|
|
{
|
|
if (theScreenFX.cgEndTimes[i])
|
|
{
|
|
if (theScreenFX.cgEndTimes[i] <= cg.time)
|
|
{
|
|
// remove this effect
|
|
theScreenFX.events[i] = 0;
|
|
theScreenFX.cgStartTimes[i] = 0;
|
|
theScreenFX.cgEndTimes[i] = 0;
|
|
}
|
|
else
|
|
{
|
|
// still drawing this effect
|
|
CG_DrawFullScreenEffect(theScreenFX.events[i],theScreenFX.cgStartTimes[i],theScreenFX.cgEndTimes[i]);
|
|
}
|
|
}
|
|
}
|
|
}
|