static void S_SpatializeOrigin( const vec3_t origin, float master_vol, float dist_mult, int *left_vol, int *right_vol )
{
vec_t dot;
vec_t dist;
vec_t lscale, rscale, scale;
vec3_t source_vec;
// calculate stereo separation and distance attenuation
VectorSubtract( origin, listenerOrigin, source_vec );
dist = VectorNormalize( source_vec );
if( dma.channels == 1 || !dist_mult )
{ // no attenuation = no spatialization
rscale = 1.0f;
lscale = 1.0f;
}
else
{
#ifdef Q3STEREODIRECTION
vec3_t vec;
Matrix3_TransformVector( listenerAxis, source_vec, vec );
dot = vec[1];
#else
dot = DotProduct( source_vec, listenerAxis[RIGHT] );
#endif
rscale = 0.5 * ( 1.0 + dot );
lscale = 0.5 * ( 1.0 - dot );
if( rscale < 0 )
{
rscale = 0;
}
if( lscale < 0 )
{
lscale = 0;
}
}
dist = S_GainForAttenuation( dist, dist_mult );
// add in distance effect
scale = dist * rscale;
*right_vol = (int) ( master_vol * scale );
if( *right_vol < 0 )
*right_vol = 0;
scale = dist * lscale;
*left_vol = (int) ( master_vol * scale );
if( *left_vol < 0 )
*left_vol = 0;
}
/*
* CG_OrientPolygon
*/
static void CG_OrientPolygon( const vec3_t origin, const vec3_t angles, poly_t *poly )
{
int i;
vec3_t perp;
mat3_t ax, localAxis;
AnglesToAxis( angles, ax );
Matrix3_Transpose( ax, localAxis );
for( i = 0; i < poly->numverts; i++ )
{
Matrix3_TransformVector( localAxis, poly->verts[i], perp );
VectorAdd( perp, origin, poly->verts[i] );
}
}
/*
* R_TraceLine
*/
static msurface_t *R_TransformedTraceLine( rtrace_t *tr, const vec3_t start, const vec3_t end,
entity_t *test, int surfumask ) {
model_t *model;
r_traceframecount++; // for multi-check avoidance
// fill in a default trace
memset( tr, 0, sizeof( *tr ) );
trace_surface = NULL;
trace_umask = surfumask;
trace_fraction = 1;
VectorCopy( end, trace_impact );
memset( &trace_plane, 0, sizeof( trace_plane ) );
ClearBounds( trace_absmins, trace_absmaxs );
AddPointToBounds( start, trace_absmins, trace_absmaxs );
AddPointToBounds( end, trace_absmins, trace_absmaxs );
model = test->model;
if( model ) {
if( model->type == mod_brush ) {
mbrushmodel_t *bmodel = ( mbrushmodel_t * )model->extradata;
vec3_t temp, start_l, end_l;
mat3_t axis;
bool rotated = !Matrix3_Compare( test->axis, axis_identity );
// transform
VectorSubtract( start, test->origin, start_l );
VectorSubtract( end, test->origin, end_l );
if( rotated ) {
VectorCopy( start_l, temp );
Matrix3_TransformVector( test->axis, temp, start_l );
VectorCopy( end_l, temp );
Matrix3_TransformVector( test->axis, temp, end_l );
}
VectorCopy( start_l, trace_start );
VectorCopy( end_l, trace_end );
// world uses a recursive approach using BSP tree, submodels
// just walk the list of surfaces linearly
if( test->model == rsh.worldModel ) {
R_RecursiveHullCheck( bmodel->nodes, start_l, end_l );
} else if( BoundsIntersect( model->mins, model->maxs, trace_absmins, trace_absmaxs ) ) {
R_TraceAgainstBmodel( bmodel );
}
// transform back
if( rotated && trace_fraction != 1 ) {
Matrix3_Transpose( test->axis, axis );
VectorCopy( tr->plane.normal, temp );
Matrix3_TransformVector( axis, temp, trace_plane.normal );
}
}
}
// calculate the impact plane, if any
if( trace_fraction < 1 && trace_surface != NULL ) {
VectorNormalize( trace_plane.normal );
trace_plane.dist = DotProduct( trace_plane.normal, trace_impact );
CategorizePlane( &trace_plane );
tr->shader = trace_surface->shader;
tr->plane = trace_plane;
tr->surfFlags = trace_surface->flags;
tr->ent = R_ENT2NUM( test );
}
tr->fraction = trace_fraction;
VectorCopy( trace_impact, tr->endpos );
return trace_surface;
}
/*
* R_AddPortalSurface
*/
portalSurface_t *R_AddPortalSurface( const entity_t *ent, const mesh_t *mesh,
const vec3_t mins, const vec3_t maxs, const shader_t *shader )
{
unsigned int i;
float dist;
cplane_t plane, untransformed_plane;
vec3_t v[3];
portalSurface_t *portalSurface;
if( !mesh ) {
return NULL;
}
if( R_FASTSKY() && !( shader->flags & (SHADER_PORTAL_CAPTURE|SHADER_PORTAL_CAPTURE2) ) ) {
// r_fastsky doesn't affect portalmaps
return NULL;
}
for( i = 0; i < 3; i++ ) {
VectorCopy( mesh->xyzArray[mesh->elems[i]], v[i] );
}
PlaneFromPoints( v, &untransformed_plane );
untransformed_plane.dist += DotProduct( ent->origin, untransformed_plane.normal );
CategorizePlane( &untransformed_plane );
if( shader->flags & SHADER_AUTOSPRITE )
{
vec3_t centre;
// autosprites are quads, facing the viewer
if( mesh->numVerts < 4 ) {
return NULL;
}
// compute centre as average of 4 vertices
VectorCopy( mesh->xyzArray[mesh->elems[3]], centre );
for( i = 0; i < 3; i++ )
VectorAdd( centre, v[i], centre );
VectorMA( ent->origin, 0.25, centre, centre );
VectorNegate( &rn.viewAxis[AXIS_FORWARD], plane.normal );
plane.dist = DotProduct( plane.normal, centre );
CategorizePlane( &plane );
}
else
{
vec3_t temp;
mat3_t entity_rotation;
// regular surfaces
if( !Matrix3_Compare( ent->axis, axis_identity ) )
{
Matrix3_Transpose( ent->axis, entity_rotation );
for( i = 0; i < 3; i++ ) {
VectorCopy( v[i], temp );
Matrix3_TransformVector( entity_rotation, temp, v[i] );
VectorMA( ent->origin, ent->scale, v[i], v[i] );
}
PlaneFromPoints( v, &plane );
CategorizePlane( &plane );
}
else
{
plane = untransformed_plane;
}
}
if( ( dist = PlaneDiff( rn.viewOrigin, &plane ) ) <= BACKFACE_EPSILON )
{
// behind the portal plane
if( !( shader->flags & SHADER_PORTAL_CAPTURE2 ) ) {
return NULL;
}
// we need to render the backplane view
}
// check if portal view is opaque due to alphagen portal
if( shader->portalDistance && dist > shader->portalDistance ) {
return NULL;
}
// find the matching portal plane
for( i = 0; i < rn.numPortalSurfaces; i++ ) {
portalSurface = &rn.portalSurfaces[i];
if( portalSurface->entity == ent &&
portalSurface->shader == shader &&
DotProduct( portalSurface->plane.normal, plane.normal ) > 0.99f &&
fabs( portalSurface->plane.dist - plane.dist ) < 0.1f ) {
goto addsurface;
}
}
if( i == MAX_PORTAL_SURFACES ) {
// not enough space
return NULL;
}
portalSurface = &rn.portalSurfaces[rn.numPortalSurfaces++];
portalSurface->entity = ent;
portalSurface->plane = plane;
portalSurface->shader = shader;
portalSurface->untransformed_plane = untransformed_plane;
ClearBounds( portalSurface->mins, portalSurface->maxs );
memset( portalSurface->texures, 0, sizeof( portalSurface->texures ) );
addsurface:
AddPointToBounds( mins, portalSurface->mins, portalSurface->maxs );
AddPointToBounds( maxs, portalSurface->mins, portalSurface->maxs );
VectorAdd( portalSurface->mins, portalSurface->maxs, portalSurface->centre );
VectorScale( portalSurface->centre, 0.5, portalSurface->centre );
return portalSurface;
}
/*
* R_DrawPortalSurface
*
* Renders the portal view and captures the results from framebuffer if
* we need to do a $portalmap stage. Note that for $portalmaps we must
* use a different viewport.
*/
static void R_DrawPortalSurface( portalSurface_t *portalSurface )
{
unsigned int i;
int x, y, w, h;
float dist, d, best_d;
vec3_t viewerOrigin;
vec3_t origin;
mat3_t axis;
entity_t *ent, *best;
const entity_t *portal_ent = portalSurface->entity;
cplane_t *portal_plane = &portalSurface->plane, *untransformed_plane = &portalSurface->untransformed_plane;
const shader_t *shader = portalSurface->shader;
vec_t *portal_mins = portalSurface->mins, *portal_maxs = portalSurface->maxs;
vec_t *portal_centre = portalSurface->centre;
qboolean mirror, refraction = qfalse;
image_t *captureTexture;
int captureTextureId = -1;
int prevRenderFlags = 0;
qboolean doReflection, doRefraction;
image_t *portalTexures[2] = { NULL, NULL };
doReflection = doRefraction = qtrue;
if( shader->flags & SHADER_PORTAL_CAPTURE )
{
shaderpass_t *pass;
captureTexture = NULL;
captureTextureId = 0;
for( i = 0, pass = shader->passes; i < shader->numpasses; i++, pass++ )
{
if( pass->program_type == GLSL_PROGRAM_TYPE_DISTORTION )
{
if( ( pass->alphagen.type == ALPHA_GEN_CONST && pass->alphagen.args[0] == 1 ) )
doRefraction = qfalse;
else if( ( pass->alphagen.type == ALPHA_GEN_CONST && pass->alphagen.args[0] == 0 ) )
doReflection = qfalse;
break;
}
}
}
else
{
captureTexture = NULL;
captureTextureId = -1;
}
x = y = 0;
w = rn.refdef.width;
h = rn.refdef.height;
dist = PlaneDiff( rn.viewOrigin, portal_plane );
if( dist <= BACKFACE_EPSILON || !doReflection )
{
if( !( shader->flags & SHADER_PORTAL_CAPTURE2 ) || !doRefraction )
return;
// even if we're behind the portal, we still need to capture
// the second portal image for refraction
refraction = qtrue;
captureTexture = NULL;
captureTextureId = 1;
if( dist < 0 )
{
VectorInverse( portal_plane->normal );
portal_plane->dist = -portal_plane->dist;
}
}
if( !(rn.renderFlags & RF_NOVIS) && !R_ScissorForEntity( portal_ent, portal_mins, portal_maxs, &x, &y, &w, &h ) )
return;
mirror = qtrue; // default to mirror view
// it is stupid IMO that mirrors require a RT_PORTALSURFACE entity
best = NULL;
best_d = 100000000;
for( i = 1; i < rsc.numEntities; i++ )
{
ent = R_NUM2ENT(i);
if( ent->rtype != RT_PORTALSURFACE )
continue;
d = PlaneDiff( ent->origin, untransformed_plane );
if( ( d >= -64 ) && ( d <= 64 ) )
{
d = Distance( ent->origin, portal_centre );
if( d < best_d )
{
best = ent;
best_d = d;
}
}
}
if( best == NULL )
{
if( captureTextureId < 0 )
return;
}
else
{
if( !VectorCompare( best->origin, best->origin2 ) ) // portal
mirror = qfalse;
best->rtype = NUM_RTYPES;
}
prevRenderFlags = rn.renderFlags;
if( !R_PushRefInst() ) {
return;
}
VectorCopy( rn.viewOrigin, viewerOrigin );
setup_and_render:
if( refraction )
{
VectorInverse( portal_plane->normal );
portal_plane->dist = -portal_plane->dist - 1;
CategorizePlane( portal_plane );
VectorCopy( rn.viewOrigin, origin );
Matrix3_Copy( rn.refdef.viewaxis, axis );
VectorCopy( viewerOrigin, rn.pvsOrigin );
rn.renderFlags = RF_PORTALVIEW;
if( !mirror )
rn.renderFlags |= RF_PVSCULL;
}
else if( mirror )
{
VectorReflect( rn.viewOrigin, portal_plane->normal, portal_plane->dist, origin );
VectorReflect( &rn.viewAxis[AXIS_FORWARD], portal_plane->normal, 0, &axis[AXIS_FORWARD] );
VectorReflect( &rn.viewAxis[AXIS_RIGHT], portal_plane->normal, 0, &axis[AXIS_RIGHT] );
VectorReflect( &rn.viewAxis[AXIS_UP], portal_plane->normal, 0, &axis[AXIS_UP] );
Matrix3_Normalize( axis );
VectorCopy( viewerOrigin, rn.pvsOrigin );
rn.renderFlags = RF_MIRRORVIEW|RF_FLIPFRONTFACE;
}
else
{
vec3_t tvec;
mat3_t A, B, C, rot;
// build world-to-portal rotation matrix
VectorNegate( portal_plane->normal, tvec );
NormalVectorToAxis( tvec, A );
// build portal_dest-to-world rotation matrix
ByteToDir( best->frame, tvec );
NormalVectorToAxis( tvec, B );
Matrix3_Transpose( B, C );
// multiply to get world-to-world rotation matrix
Matrix3_Multiply( C, A, rot );
// translate view origin
VectorSubtract( rn.viewOrigin, best->origin, tvec );
Matrix3_TransformVector( rot, tvec, origin );
VectorAdd( origin, best->origin2, origin );
Matrix3_Transpose( A, B );
Matrix3_Multiply( rn.viewAxis, B, rot );
Matrix3_Multiply( best->axis, rot, B );
Matrix3_Transpose( C, A );
Matrix3_Multiply( B, A, axis );
// set up portal_plane
VectorCopy( &axis[AXIS_FORWARD], portal_plane->normal );
portal_plane->dist = DotProduct( best->origin2, portal_plane->normal );
CategorizePlane( portal_plane );
// for portals, vis data is taken from portal origin, not
// view origin, because the view point moves around and
// might fly into (or behind) a wall
rn.renderFlags = RF_PORTALVIEW|RF_PVSCULL;
VectorCopy( best->origin2, rn.pvsOrigin );
VectorCopy( best->origin2, rn.lodOrigin );
// ignore entities, if asked politely
if( best->renderfx & RF_NOPORTALENTS )
rn.renderFlags |= RF_NOENTS;
}
rn.renderFlags |= (prevRenderFlags & RF_SOFT_PARTICLES);
rn.refdef.rdflags &= ~( RDF_UNDERWATER|RDF_CROSSINGWATER );
rn.shadowGroup = NULL;
rn.meshlist = &r_portallist;
rn.renderFlags |= RF_CLIPPLANE;
rn.clipPlane = *portal_plane;
rn.farClip = R_DefaultFarClip();
rn.clipFlags |= ( 1<<5 );
rn.frustum[5] = *portal_plane;
CategorizePlane( &rn.frustum[5] );
// if we want to render to a texture, initialize texture
// but do not try to render to it more than once
if( captureTextureId >= 0 )
{
int texFlags = shader->flags & SHADER_NO_TEX_FILTERING ? IT_NOFILTERING : 0;
captureTexture = R_GetPortalTexture( rsc.refdef.width, rsc.refdef.height, texFlags,
rsc.frameCount );
portalTexures[captureTextureId] = captureTexture;
if( !captureTexture ) {
// couldn't register a slot for this plane
goto done;
}
x = y = 0;
w = captureTexture->upload_width;
h = captureTexture->upload_height;
rn.refdef.width = w;
rn.refdef.height = h;
rn.refdef.x = 0;
rn.refdef.y = 0;
rn.fbColorAttachment = captureTexture;
// no point in capturing the depth buffer due to oblique frustum messing up
// the far plane and depth values
rn.fbDepthAttachment = NULL;
Vector4Set( rn.viewport, rn.refdef.x + x, rn.refdef.y + y, w, h );
Vector4Set( rn.scissor, rn.refdef.x + x, rn.refdef.y + y, w, h );
}
else {
// no point in capturing the depth buffer due to oblique frustum messing up
// the far plane and depth values
rn.fbDepthAttachment = NULL;
Vector4Set( rn.scissor, rn.refdef.x + x, rn.refdef.y + y, w, h );
}
VectorCopy( origin, rn.refdef.vieworg );
Matrix3_Copy( axis, rn.refdef.viewaxis );
R_RenderView( &rn.refdef );
if( doRefraction && !refraction && ( shader->flags & SHADER_PORTAL_CAPTURE2 ) )
{
refraction = qtrue;
captureTexture = NULL;
captureTextureId = 1;
goto setup_and_render;
}
done:
portalSurface->texures[0] = portalTexures[0];
portalSurface->texures[1] = portalTexures[1];
R_PopRefInst( rn.fbDepthAttachment != NULL ? 0 : GL_DEPTH_BUFFER_BIT );
}
/*
* SV_Push
*
* Objects need to be moved back on a failed push,
* otherwise riders would continue to slide.
*/
static bool SV_Push( edict_t *pusher, vec3_t move, vec3_t amove ) {
int i, e;
edict_t *check, *block;
vec3_t mins, maxs;
pushed_t *p;
mat3_t axis;
vec3_t org, org2, move2;
// find the bounding box
for( i = 0; i < 3; i++ ) {
mins[i] = pusher->r.absmin[i] + move[i];
maxs[i] = pusher->r.absmax[i] + move[i];
}
// we need this for pushing things later
VectorNegate( amove, org );
AnglesToAxis( org, axis );
// save the pusher's original position
pushed_p->ent = pusher;
VectorCopy( pusher->s.origin, pushed_p->origin );
VectorCopy( pusher->s.angles, pushed_p->angles );
if( pusher->r.client ) {
VectorCopy( pusher->r.client->ps.pmove.velocity, pushed_p->pmove_origin );
pushed_p->yaw = pusher->r.client->ps.viewangles[YAW];
}
pushed_p++;
// move the pusher to its final position
VectorAdd( pusher->s.origin, move, pusher->s.origin );
VectorAdd( pusher->s.angles, amove, pusher->s.angles );
GClip_LinkEntity( pusher );
// see if any solid entities are inside the final position
check = game.edicts + 1;
for( e = 1; e < game.numentities; e++, check++ ) {
if( !check->r.inuse ) {
continue;
}
if( check->movetype == MOVETYPE_PUSH
|| check->movetype == MOVETYPE_STOP
|| check->movetype == MOVETYPE_NONE
|| check->movetype == MOVETYPE_NOCLIP ) {
continue;
}
if( !check->areagrid[0].prev ) {
continue; // not linked in anywhere
}
// if the entity is standing on the pusher, it will definitely be moved
if( check->groundentity != pusher ) {
// see if the ent needs to be tested
if( check->r.absmin[0] >= maxs[0]
|| check->r.absmin[1] >= maxs[1]
|| check->r.absmin[2] >= maxs[2]
|| check->r.absmax[0] <= mins[0]
|| check->r.absmax[1] <= mins[1]
|| check->r.absmax[2] <= mins[2] ) {
continue;
}
// see if the ent's bbox is inside the pusher's final position
if( !SV_TestEntityPosition( check ) ) {
continue;
}
}
if( ( pusher->movetype == MOVETYPE_PUSH ) || ( check->groundentity == pusher ) ) {
// move this entity
pushed_p->ent = check;
VectorCopy( check->s.origin, pushed_p->origin );
VectorCopy( check->s.angles, pushed_p->angles );
pushed_p++;
// try moving the contacted entity
VectorAdd( check->s.origin, move, check->s.origin );
if( check->r.client ) {
// FIXME: doesn't rotate monsters?
VectorAdd( check->r.client->ps.pmove.origin, move, check->r.client->ps.pmove.origin );
check->r.client->ps.viewangles[YAW] += amove[YAW];
}
// figure movement due to the pusher's amove
VectorSubtract( check->s.origin, pusher->s.origin, org );
Matrix3_TransformVector( axis, org, org2 );
VectorSubtract( org2, org, move2 );
VectorAdd( check->s.origin, move2, check->s.origin );
if( check->movetype != MOVETYPE_BOUNCEGRENADE ) {
// may have pushed them off an edge
if( check->groundentity != pusher ) {
check->groundentity = NULL;
}
}
block = SV_TestEntityPosition( check );
if( !block ) {
// pushed ok
GClip_LinkEntity( check );
// impact?
continue;
} else {
// try to fix block
// if it is ok to leave in the old position, do it
// this is only relevant for riding entities, not pushed
VectorSubtract( check->s.origin, move, check->s.origin );
VectorSubtract( check->s.origin, move2, check->s.origin );
block = SV_TestEntityPosition( check );
if( !block ) {
pushed_p--;
continue;
}
}
}
// save off the obstacle so we can call the block function
obstacle = check;
// move back any entities we already moved
// go backwards, so if the same entity was pushed
// twice, it goes back to the original position
for( p = pushed_p - 1; p >= pushed; p-- ) {
VectorCopy( p->origin, p->ent->s.origin );
VectorCopy( p->angles, p->ent->s.angles );
if( p->ent->r.client ) {
VectorCopy( p->pmove_origin, p->ent->r.client->ps.pmove.origin );
p->ent->r.client->ps.viewangles[YAW] = p->yaw;
}
GClip_LinkEntity( p->ent );
}
return false;
}
//FIXME: is there a better way to handle this?
// see if anything we moved has touched a trigger
for( p = pushed_p - 1; p >= pushed; p-- )
GClip_TouchTriggers( p->ent );
return true;
}
/*
* R_UpdatePortalSurface
*/
void R_UpdatePortalSurface( portalSurface_t *portalSurface, const mesh_t *mesh,
const vec3_t mins, const vec3_t maxs, const shader_t *shader ) {
unsigned int i;
float dist;
cplane_t plane, untransformed_plane;
vec3_t v[3];
const entity_t *ent;
if( !mesh || !portalSurface ) {
return;
}
ent = portalSurface->entity;
for( i = 0; i < 3; i++ ) {
VectorCopy( mesh->xyzArray[mesh->elems[i]], v[i] );
}
PlaneFromPoints( v, &untransformed_plane );
untransformed_plane.dist += DotProduct( ent->origin, untransformed_plane.normal );
untransformed_plane.dist += 1; // nudge along the normal a bit
CategorizePlane( &untransformed_plane );
if( shader->flags & SHADER_AUTOSPRITE ) {
vec3_t centre;
// autosprites are quads, facing the viewer
if( mesh->numVerts < 4 ) {
return;
}
// compute centre as average of 4 vertices
VectorCopy( mesh->xyzArray[mesh->elems[3]], centre );
for( i = 0; i < 3; i++ )
VectorAdd( centre, v[i], centre );
VectorMA( ent->origin, 0.25, centre, centre );
VectorNegate( &rn.viewAxis[AXIS_FORWARD], plane.normal );
plane.dist = DotProduct( plane.normal, centre );
CategorizePlane( &plane );
} else {
vec3_t temp;
mat3_t entity_rotation;
// regular surfaces
if( !Matrix3_Compare( ent->axis, axis_identity ) ) {
Matrix3_Transpose( ent->axis, entity_rotation );
for( i = 0; i < 3; i++ ) {
VectorCopy( v[i], temp );
Matrix3_TransformVector( entity_rotation, temp, v[i] );
VectorMA( ent->origin, ent->scale, v[i], v[i] );
}
PlaneFromPoints( v, &plane );
CategorizePlane( &plane );
} else {
plane = untransformed_plane;
}
}
if( ( dist = PlaneDiff( rn.viewOrigin, &plane ) ) <= BACKFACE_EPSILON ) {
// behind the portal plane
if( !( shader->flags & SHADER_PORTAL_CAPTURE2 ) ) {
return;
}
// we need to render the backplane view
}
// check if portal view is opaque due to alphagen portal
if( shader->portalDistance && dist > shader->portalDistance ) {
return;
}
portalSurface->plane = plane;
portalSurface->untransformed_plane = untransformed_plane;
AddPointToBounds( mins, portalSurface->mins, portalSurface->maxs );
AddPointToBounds( maxs, portalSurface->mins, portalSurface->maxs );
VectorAdd( portalSurface->mins, portalSurface->maxs, portalSurface->centre );
VectorScale( portalSurface->centre, 0.5, portalSurface->centre );
}
/*
* R_DrawPortalSurface
*
* Renders the portal view and captures the results from framebuffer if
* we need to do a $portalmap stage. Note that for $portalmaps we must
* use a different viewport.
*/
static void R_DrawPortalSurface( portalSurface_t *portalSurface ) {
unsigned int i;
int x, y, w, h;
float dist, d, best_d;
vec3_t viewerOrigin;
vec3_t origin;
mat3_t axis;
entity_t *ent, *best;
cplane_t *portal_plane = &portalSurface->plane, *untransformed_plane = &portalSurface->untransformed_plane;
const shader_t *shader = portalSurface->shader;
vec_t *portal_centre = portalSurface->centre;
bool mirror, refraction = false;
image_t *captureTexture;
int captureTextureId = -1;
int prevRenderFlags = 0;
bool prevFlipped;
bool doReflection, doRefraction;
image_t *portalTexures[2] = { NULL, NULL };
doReflection = doRefraction = true;
if( shader->flags & SHADER_PORTAL_CAPTURE ) {
shaderpass_t *pass;
captureTexture = NULL;
captureTextureId = 0;
for( i = 0, pass = shader->passes; i < shader->numpasses; i++, pass++ ) {
if( pass->program_type == GLSL_PROGRAM_TYPE_DISTORTION ) {
if( ( pass->alphagen.type == ALPHA_GEN_CONST && pass->alphagen.args[0] == 1 ) ) {
doRefraction = false;
} else if( ( pass->alphagen.type == ALPHA_GEN_CONST && pass->alphagen.args[0] == 0 ) ) {
doReflection = false;
}
break;
}
}
} else {
captureTexture = NULL;
captureTextureId = -1;
}
x = y = 0;
w = rn.refdef.width;
h = rn.refdef.height;
dist = PlaneDiff( rn.viewOrigin, portal_plane );
if( dist <= BACKFACE_EPSILON || !doReflection ) {
if( !( shader->flags & SHADER_PORTAL_CAPTURE2 ) || !doRefraction ) {
return;
}
// even if we're behind the portal, we still need to capture
// the second portal image for refraction
refraction = true;
captureTexture = NULL;
captureTextureId = 1;
if( dist < 0 ) {
VectorInverse( portal_plane->normal );
portal_plane->dist = -portal_plane->dist;
}
}
mirror = true; // default to mirror view
// it is stupid IMO that mirrors require a RT_PORTALSURFACE entity
best = NULL;
best_d = 100000000;
for( i = 0; i < rn.numEntities; i++ ) {
ent = R_NUM2ENT( rn.entities[i] );
if( ent->rtype != RT_PORTALSURFACE ) {
continue;
}
d = PlaneDiff( ent->origin, untransformed_plane );
if( ( d >= -64 ) && ( d <= 64 ) ) {
d = Distance( ent->origin, portal_centre );
if( d < best_d ) {
best = ent;
best_d = d;
}
}
}
if( best == NULL ) {
if( captureTextureId < 0 ) {
// still do a push&pop because to ensure the clean state
if( R_PushRefInst() ) {
R_PopRefInst();
}
return;
}
} else {
if( !VectorCompare( best->origin, best->origin2 ) ) { // portal
mirror = false;
}
best->rtype = NUM_RTYPES;
}
prevRenderFlags = rn.renderFlags;
prevFlipped = ( rn.refdef.rdflags & RDF_FLIPPED ) != 0;
if( !R_PushRefInst() ) {
return;
}
VectorCopy( rn.viewOrigin, viewerOrigin );
if( prevFlipped ) {
VectorInverse( &rn.viewAxis[AXIS_RIGHT] );
}
setup_and_render:
if( refraction ) {
VectorInverse( portal_plane->normal );
portal_plane->dist = -portal_plane->dist;
CategorizePlane( portal_plane );
VectorCopy( rn.viewOrigin, origin );
Matrix3_Copy( rn.refdef.viewaxis, axis );
VectorCopy( viewerOrigin, rn.pvsOrigin );
rn.renderFlags |= RF_PORTALVIEW;
if( prevFlipped ) {
rn.renderFlags |= RF_FLIPFRONTFACE;
}
} else if( mirror ) {
VectorReflect( rn.viewOrigin, portal_plane->normal, portal_plane->dist, origin );
VectorReflect( &rn.viewAxis[AXIS_FORWARD], portal_plane->normal, 0, &axis[AXIS_FORWARD] );
VectorReflect( &rn.viewAxis[AXIS_RIGHT], portal_plane->normal, 0, &axis[AXIS_RIGHT] );
VectorReflect( &rn.viewAxis[AXIS_UP], portal_plane->normal, 0, &axis[AXIS_UP] );
Matrix3_Normalize( axis );
VectorCopy( viewerOrigin, rn.pvsOrigin );
rn.renderFlags = ( prevRenderFlags ^ RF_FLIPFRONTFACE ) | RF_MIRRORVIEW;
} else {
vec3_t tvec;
mat3_t A, B, C, rot;
// build world-to-portal rotation matrix
VectorNegate( portal_plane->normal, tvec );
NormalVectorToAxis( tvec, A );
// build portal_dest-to-world rotation matrix
ByteToDir( best->frame, tvec );
NormalVectorToAxis( tvec, B );
Matrix3_Transpose( B, C );
// multiply to get world-to-world rotation matrix
Matrix3_Multiply( C, A, rot );
// translate view origin
VectorSubtract( rn.viewOrigin, best->origin, tvec );
Matrix3_TransformVector( rot, tvec, origin );
VectorAdd( origin, best->origin2, origin );
Matrix3_Transpose( A, B );
Matrix3_Multiply( rn.viewAxis, B, rot );
Matrix3_Multiply( best->axis, rot, B );
Matrix3_Transpose( C, A );
Matrix3_Multiply( B, A, axis );
// set up portal_plane
VectorCopy( &axis[AXIS_FORWARD], portal_plane->normal );
portal_plane->dist = DotProduct( best->origin2, portal_plane->normal );
CategorizePlane( portal_plane );
// for portals, vis data is taken from portal origin, not
// view origin, because the view point moves around and
// might fly into (or behind) a wall
VectorCopy( best->origin2, rn.pvsOrigin );
VectorCopy( best->origin2, rn.lodOrigin );
rn.renderFlags |= RF_PORTALVIEW;
// ignore entities, if asked politely
if( best->renderfx & RF_NOPORTALENTS ) {
rn.renderFlags |= RF_ENVVIEW;
}
if( prevFlipped ) {
rn.renderFlags |= RF_FLIPFRONTFACE;
}
}
rn.refdef.rdflags &= ~( RDF_UNDERWATER | RDF_CROSSINGWATER | RDF_FLIPPED );
rn.meshlist = &r_portallist;
rn.portalmasklist = NULL;
rn.renderFlags |= RF_CLIPPLANE;
rn.renderFlags &= ~RF_SOFT_PARTICLES;
rn.clipPlane = *portal_plane;
rn.nearClip = Z_NEAR;
rn.farClip = R_DefaultFarClip();
rn.polygonFactor = POLYOFFSET_FACTOR;
rn.polygonUnits = POLYOFFSET_UNITS;
rn.clipFlags |= 16;
rn.frustum[4] = *portal_plane; // nearclip
CategorizePlane( &rn.frustum[4] );
// if we want to render to a texture, initialize texture
// but do not try to render to it more than once
if( captureTextureId >= 0 ) {
int texFlags = shader->flags & SHADER_NO_TEX_FILTERING ? IT_NOFILTERING : 0;
captureTexture = R_GetPortalTexture( rsc.refdef.width, rsc.refdef.height, texFlags,
rsc.frameCount );
portalTexures[captureTextureId] = captureTexture;
if( !captureTexture ) {
// couldn't register a slot for this plane
goto done;
}
x = y = 0;
w = captureTexture->upload_width;
h = captureTexture->upload_height;
rn.refdef.width = w;
rn.refdef.height = h;
rn.refdef.x = 0;
rn.refdef.y = 0;
rn.renderTarget = captureTexture->fbo;
rn.renderFlags |= RF_PORTAL_CAPTURE;
Vector4Set( rn.viewport, rn.refdef.x + x, rn.refdef.y + y, w, h );
Vector4Set( rn.scissor, rn.refdef.x + x, rn.refdef.y + y, w, h );
} else {
rn.renderFlags &= ~RF_PORTAL_CAPTURE;
}
VectorCopy( origin, rn.refdef.vieworg );
Matrix3_Copy( axis, rn.refdef.viewaxis );
R_SetupViewMatrices( &rn.refdef );
R_SetupFrustum( &rn.refdef, rn.nearClip, rn.farClip, rn.frustum, rn.frustumCorners );
R_SetupPVS( &rn.refdef );
R_RenderView( &rn.refdef );
if( doRefraction && !refraction && ( shader->flags & SHADER_PORTAL_CAPTURE2 ) ) {
rn.renderFlags = prevRenderFlags;
refraction = true;
captureTexture = NULL;
captureTextureId = 1;
goto setup_and_render;
}
done:
portalSurface->texures[0] = portalTexures[0];
portalSurface->texures[1] = portalTexures[1];
R_PopRefInst();
}
/*
* S_SpatializeOriginHF
*/
static void S_SpatializeOriginHQ( const vec3_t origin, float master_vol, float dist_mult,
int *left_vol, int *right_vol, int *lcoeff, int *rcoeff, unsigned int *ldelay, unsigned int *rdelay )
{
vec_t dot;
vec_t dist;
vec_t lscale, rscale, scale;
vec3_t vec, source_vec;
vec_t lgainhf, rgainhf;
// calculate stereo separation and distance attenuation
VectorSubtract( origin, listenerOrigin, vec );
Matrix3_TransformVector( listenerAxis, vec, source_vec );
dist = VectorNormalize( source_vec );
if( dma.channels == 1 || !dist_mult )
{ // no attenuation = no spatialization
rscale = 1.0f;
lscale = 1.0f;
lgainhf = 1.0f;
rgainhf = 1.0f;
if( ldelay && rdelay )
*ldelay = *rdelay = 0;
}
else
{
// legacy panning
// correlate some of the stereo-separation that hf dampening
// causes (HQ_HF_DAMP * 0.5)
dot = source_vec[1];
rscale = 0.5 * ( 1.0 + (dot * (1.0 - HQ_HF_DAMP * 0.25)) );
lscale = 0.5 * ( 1.0 - (dot * (1.0 - HQ_HF_DAMP * 0.25)) );
if( rscale < 0 )
{
rscale = 0;
}
if( lscale < 0 )
{
lscale = 0;
}
// pseudo acoustics, apply delay to opposite ear of where the
// sound originates based on the angle
if( ldelay && rdelay )
{
// HQ_EAR_DELAY ~ 1/(0.15/340.0)
float max_delay = dma.speed * s_separationDelay->value / HQ_EAR_DELAY;
if( dot < 0.0 )
{
// delay right ear (sound from left side)
*rdelay = (int)(max_delay * -dot);
*ldelay = 0;
}
else
{
// delay left ear (sound from right side)
*ldelay = (int)(max_delay * dot);
*rdelay = 0;
}
}
// pseudo acoustics, apply high-frequency damping based on
// the angle, separately for both ears and then for
// sound source behind the listener
rgainhf = lgainhf = 1.0;
// right ear, left ear
if( dot < 0 )
{
rgainhf = 1.0 + dot * HQ_HF_DAMP * 0.5;
}
else if( dot > 0 )
{
lgainhf = 1.0 - dot * HQ_HF_DAMP * 0.5;
}
// behind head for both ears
dot = source_vec[0];
if( dot < 0.0 )
{
float g = 1.0 + dot * HQ_HF_DAMP;
rgainhf *= g;
lgainhf *= g;
}
}
dist = S_GainForAttenuation( dist, dist_mult );
// add in distance effect
scale = dist * rscale;
*right_vol = (int) ( master_vol * scale );
if( *right_vol < 0 )
*right_vol = 0;
scale = dist * lscale;
*left_vol = (int) ( master_vol * scale );
if( *left_vol < 0 )
*left_vol = 0;
// highfrequency coefficients
if( lcoeff && rcoeff )
{
*lcoeff = (int)(S_LowpassCoeff( lgainhf, s_lpf_cw ) * 65535.0f);
*rcoeff = (int)(S_LowpassCoeff( rgainhf, s_lpf_cw ) * 65535.0f);
}
}