/*
================
G_InvulnerabilityEffect
================
*/
int G_InvulnerabilityEffect(gentity_t * targ, vec3_t dir, vec3_t point, vec3_t impactpoint, vec3_t bouncedir)
{
gentity_t *impact;
vec3_t intersections[2], vec;
int n;
if(!targ->client)
{
return qfalse;
}
VectorCopy(dir, vec);
VectorInverse(vec);
// sphere model radius = 42 units
n = RaySphereIntersections(targ->client->ps.origin, 42, point, vec, intersections);
if(n > 0)
{
impact = G_TempEntity(targ->client->ps.origin, EV_INVUL_IMPACT);
VectorSubtract(intersections[0], targ->client->ps.origin, vec);
VectorToAngles(vec, impact->s.angles);
impact->s.angles[0] += 90;
if(impact->s.angles[0] > 360)
impact->s.angles[0] -= 360;
if(impactpoint)
{
VectorCopy(intersections[0], impactpoint);
}
if(bouncedir)
{
VectorCopy(vec, bouncedir);
VectorNormalize(bouncedir);
}
return qtrue;
}
else
{
return qfalse;
}
}
/*
=================
CG_MissileHitEntity
=================
*/
void CG_MissileHitEntity( weapon_t weaponNum, weaponMode_t weaponMode,
vec3_t origin, vec3_t dir, int entityNum, int charge )
{
vec3_t normal;
weaponInfo_t *weapon = &cg_weapons[ weaponNum ];
VectorCopy( dir, normal );
VectorInverse( normal );
CG_Bleed( origin, normal, entityNum );
if( weaponMode <= WPM_NONE || weaponMode >= WPM_NUM_WEAPONMODES )
weaponMode = WPM_PRIMARY;
// always impact!
//if( weapon->wim[ weaponMode ].alwaysImpact )
{
int sound;
if( cg_entities[ entityNum ].currentState.eType == ET_PLAYER )
{
// Players
sound = IMPACTSOUND_FLESH;
}
else if( cg_entities[ entityNum ].currentState.eType == ET_BUILDABLE &&
BG_Buildable( cg_entities[ entityNum ].currentState.modelindex, NULL )->team == TEAM_ALIENS )
{
// Alien buildables
sound = IMPACTSOUND_FLESH;
}
else
sound = IMPACTSOUND_DEFAULT;
CG_MissileHitWall( weaponNum, weaponMode, 0, origin, dir, sound, charge );
}
}
/*
* R_TraceAgainstSurface
*/
static bool R_TraceAgainstSurface( msurface_t *surf ) {
int i;
mesh_t *mesh = &surf->mesh;
elem_t *elem = mesh->elems;
vec4_t *verts = mesh->xyzArray;
float old_frac = trace_fraction;
bool isPlanar = ( surf->facetype == FACETYPE_PLANAR ) ? true : false;
// clip each triangle individually
for( i = 0; i < mesh->numElems; i += 3, elem += 3 ) {
R_TraceAgainstTriangle( verts[elem[0]], verts[elem[1]], verts[elem[2]] );
if( old_frac > trace_fraction ) {
// flip normal is we are on the backside (does it really happen?)...
if( isPlanar ) {
if( DotProduct( trace_plane.normal, surf->plane ) < 0 ) {
VectorInverse( trace_plane.normal );
}
}
return true;
}
}
return false;
}
/*
================
R_AliasSetUpTransform
================
*/
void R_AliasSetUpTransform(int trivial_accept)
{
int i;
float rotationmatrix[3][4], t2matrix[3][4];
static float tmatrix[3][4];
static float viewmatrix[3][4];
vec3_t angles;
// TODO: should really be stored with the entity instead of being reconstructed
// TODO: should use a look-up table
// TODO: could cache lazily, stored in the entity
angles[ROLL] = currententity->angles[ROLL];
angles[PITCH] = -currententity->angles[PITCH];
angles[YAW] = currententity->angles[YAW];
AngleVectors(angles, alias_forward, alias_right, alias_up);
tmatrix[0][0] = pmdl->scale[0];
tmatrix[1][1] = pmdl->scale[1];
tmatrix[2][2] = pmdl->scale[2];
tmatrix[0][3] = pmdl->scale_origin[0];
tmatrix[1][3] = pmdl->scale_origin[1];
tmatrix[2][3] = pmdl->scale_origin[2];
// TODO: can do this with simple matrix rearrangement
for (i=0 ; i<3 ; i++)
{
t2matrix[i][0] = alias_forward[i];
t2matrix[i][1] = -alias_right[i];
t2matrix[i][2] = alias_up[i];
}
t2matrix[0][3] = -modelorg[0];
t2matrix[1][3] = -modelorg[1];
t2matrix[2][3] = -modelorg[2];
// FIXME: can do more efficiently than full concatenation
R_ConcatTransforms(t2matrix, tmatrix, rotationmatrix);
// TODO: should be global, set when vright, etc., set
VectorCopy(vright, viewmatrix[0]);
VectorCopy(vup, viewmatrix[1]);
VectorInverse(viewmatrix[1]);
VectorCopy(vpn, viewmatrix[2]);
// viewmatrix[0][3] = 0;
// viewmatrix[1][3] = 0;
// viewmatrix[2][3] = 0;
R_ConcatTransforms(viewmatrix, rotationmatrix, aliastransform);
// do the scaling up of x and y to screen coordinates as part of the transform
// for the unclipped case (it would mess up clipping in the clipped case).
// Also scale down z, so 1/z is scaled 31 bits for free, and scale down x and y
// correspondingly so the projected x and y come out right
// FIXME: make this work for clipped case too?
if (trivial_accept)
{
for (i=0 ; i<4 ; i++)
{
aliastransform[0][i] *= aliasxscale *
(1.0 / ((float)0x8000 * 0x10000));
aliastransform[1][i] *= aliasyscale *
(1.0 / ((float)0x8000 * 0x10000));
aliastransform[2][i] *= 1.0 / ((float)0x8000 * 0x10000);
}
}
}
/*
====================
StudioSetUpTransform
====================
*/
void CStudioModelRenderer::StudioSetUpTransform (int trivial_accept)
{
int i;
vec3_t angles;
vec3_t modelpos;
// tweek model origin
//for (i = 0; i < 3; i++)
// modelpos[i] = m_pCurrentEntity->origin[i];
VectorCopy( m_pCurrentEntity->origin, modelpos );
// TODO: should really be stored with the entity instead of being reconstructed
// TODO: should use a look-up table
// TODO: could cache lazily, stored in the entity
angles[ROLL] = m_pCurrentEntity->curstate.angles[ROLL];
angles[PITCH] = m_pCurrentEntity->curstate.angles[PITCH];
angles[YAW] = m_pCurrentEntity->curstate.angles[YAW];
//Con_DPrintf("Angles %4.2f prev %4.2f for %i\n", angles[PITCH], m_pCurrentEntity->index);
//Con_DPrintf("movetype %d %d\n", m_pCurrentEntity->movetype, m_pCurrentEntity->aiment );
if (m_pCurrentEntity->curstate.movetype == MOVETYPE_STEP)
{
float f = 0;
float d;
// don't do it if the goalstarttime hasn't updated in a while.
// NOTE: Because we need to interpolate multiplayer characters, the interpolation time limit
// was increased to 1.0 s., which is 2x the max lag we are accounting for.
if ( ( m_clTime < m_pCurrentEntity->curstate.animtime + 1.0f ) &&
( m_pCurrentEntity->curstate.animtime != m_pCurrentEntity->latched.prevanimtime ) )
{
f = (m_clTime - m_pCurrentEntity->curstate.animtime) / (m_pCurrentEntity->curstate.animtime - m_pCurrentEntity->latched.prevanimtime);
//Con_DPrintf("%4.2f %.2f %.2f\n", f, m_pCurrentEntity->curstate.animtime, m_clTime);
}
if (m_fDoInterp)
{
// ugly hack to interpolate angle, position. current is reached 0.1 seconds after being set
f = f - 1.0;
}
else
{
f = 0;
}
for (i = 0; i < 3; i++)
{
modelpos[i] += (m_pCurrentEntity->origin[i] - m_pCurrentEntity->latched.prevorigin[i]) * f;
}
// NOTE: Because multiplayer lag can be relatively large, we don't want to cap
// f at 1.5 anymore.
//if (f > -1.0 && f < 1.5) {}
// Con_DPrintf("%.0f %.0f\n",m_pCurrentEntity->msg_angles[0][YAW], m_pCurrentEntity->msg_angles[1][YAW] );
for (i = 0; i < 3; i++)
{
float ang1, ang2;
ang1 = m_pCurrentEntity->angles[i];
ang2 = m_pCurrentEntity->latched.prevangles[i];
d = ang1 - ang2;
if (d > 180)
{
d -= 360;
}
else if (d < -180)
{
d += 360;
}
angles[i] += d * f;
}
//Con_DPrintf("%.3f \n", f );
}
else if ( m_pCurrentEntity->curstate.movetype != MOVETYPE_NONE )
{
VectorCopy( m_pCurrentEntity->angles, angles );
}
//Con_DPrintf("%.0f %0.f %0.f\n", modelpos[0], modelpos[1], modelpos[2] );
//Con_DPrintf("%.0f %0.f %0.f\n", angles[0], angles[1], angles[2] );
angles[PITCH] = -angles[PITCH];
AngleMatrix (angles, (*m_protationmatrix));
if ( !IEngineStudio.IsHardware() )
{
static float viewmatrix[3][4];
VectorCopy (m_vRight, viewmatrix[0]);
VectorCopy (m_vUp, viewmatrix[1]);
VectorInverse (viewmatrix[1]);
VectorCopy (m_vNormal, viewmatrix[2]);
(*m_protationmatrix)[0][3] = modelpos[0] - m_vRenderOrigin[0];
(*m_protationmatrix)[1][3] = modelpos[1] - m_vRenderOrigin[1];
(*m_protationmatrix)[2][3] = modelpos[2] - m_vRenderOrigin[2];
ConcatTransforms (viewmatrix, (*m_protationmatrix), (*m_paliastransform));
// do the scaling up of x and y to screen coordinates as part of the transform
// for the unclipped case (it would mess up clipping in the clipped case).
// Also scale down z, so 1/z is scaled 31 bits for free, and scale down x and y
// correspondingly so the projected x and y come out right
// FIXME: make this work for clipped case too?
if (trivial_accept)
{
for (i=0 ; i<4 ; i++)
{
(*m_paliastransform)[0][i] *= m_fSoftwareXScale *
(1.0 / (ZISCALE * 0x10000));
(*m_paliastransform)[1][i] *= m_fSoftwareYScale *
(1.0 / (ZISCALE * 0x10000));
(*m_paliastransform)[2][i] *= 1.0 / (ZISCALE * 0x10000);
}
}
}
(*m_protationmatrix)[0][3] = modelpos[0];
(*m_protationmatrix)[1][3] = modelpos[1];
(*m_protationmatrix)[2][3] = modelpos[2];
}
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
int AAS_FindBestAreaSplitPlane( tmp_area_t *tmparea, vec3_t normal, float *dist ) {
int side1, side2;
int foundsplitter, facesplits, groundsplits, epsilonfaces, bestepsilonfaces;
float bestvalue, value;
tmp_face_t *face1, *face2;
vec3_t tmpnormal, invgravity;
float tmpdist;
vec3_t points[4];
//get inverse of gravity direction
VectorCopy( cfg.phys_gravitydirection, invgravity );
VectorInverse( invgravity );
foundsplitter = false;
bestvalue = -999999;
bestepsilonfaces = 0;
//
#ifdef AW_DEBUG
Log_Print( "finding split plane for area %d\n", tmparea->areanum );
#endif //AW_DEBUG
for ( face1 = tmparea->tmpfaces; face1; face1 = face1->next[side1] ) {
//side of the face the area is on
side1 = face1->frontarea != tmparea;
if ( WindingIsTiny( face1->winding ) ) {
Log_Write( "gsubdiv: area %d has a tiny winding\r\n", tmparea->areanum );
continue;
}
//if the face isn't a gap or ground there's no split edge
if ( !( face1->faceflags & FACE_GROUND ) && !AAS_GapFace( face1, side1 ) ) {
continue;
}
for ( face2 = face1->next[side1]; face2; face2 = face2->next[side2] ) {
//side of the face the area is on
side2 = face2->frontarea != tmparea;
if ( WindingIsTiny( face1->winding ) ) {
Log_Write( "gsubdiv: area %d has a tiny winding\r\n", tmparea->areanum );
continue;
}
//if the face isn't a gap or ground there's no split edge
if ( !( face2->faceflags & FACE_GROUND ) && !AAS_GapFace( face2, side2 ) ) {
continue;
}
//only split between gaps and ground
if ( !( ( ( face1->faceflags & FACE_GROUND ) && AAS_GapFace( face2, side2 ) ) || ( ( face2->faceflags & FACE_GROUND ) && AAS_GapFace( face1, side1 ) ) ) ) {
continue;
}
//find a plane seperating the windings of the faces
if ( !FindPlaneSeperatingWindings( face1->winding, face2->winding, invgravity, tmpnormal, &tmpdist, points ) ) {
continue;
}
#ifdef AW_DEBUG
Log_Print( "normal = \'%f %f %f\', dist = %f\n", tmpnormal[0], tmpnormal[1], tmpnormal[2], tmpdist );
#endif //AW_DEBUG
//get metrics for this vertical plane
if ( !AAS_TestSplitPlane( tmparea, tmpnormal, tmpdist, &facesplits, &groundsplits, &epsilonfaces, points ) ) {
continue;
} //end if
#ifdef AW_DEBUG
Log_Print( "face splits = %d\nground splits = %d\n", facesplits, groundsplits );
#endif //AW_DEBUG
value = 100 - facesplits - 2 * groundsplits;
//avoid epsilon faces
value += epsilonfaces * -1000;
if ( value > bestvalue ) {
VectorCopy( tmpnormal, normal );
*dist = tmpdist;
bestvalue = value;
bestepsilonfaces = epsilonfaces;
foundsplitter = true;
}
}
}
if ( bestepsilonfaces ) {
Log_Write( "found %d epsilon faces trying to split area %d\r\n", epsilonfaces, tmparea->areanum );
}
return foundsplitter;
} //end of the function AAS_FindBestAreaSplitPlane
/*
================
CG_AddClientCritter
================
*/
void CG_AddClientCritter( localEntity_t *le ) {
vec3_t newOrigin;
trace_t trace;
int time, step = 25, i;
vec3_t v, ang, v2, oDelta;
localEntity_t backup;
float oldSpeed, enemyDist, of;
vec3_t enemyPos;
float alpha;
if (cg_entities[le->ownerNum].currentState.otherEntityNum2 == cg.snap->ps.clientNum) {
VectorCopy( cg.snap->ps.origin, enemyPos );
enemyPos[2] += cg.snap->ps.viewheight;
} else {
VectorCopy( cg_entities[le->ownerNum].currentState.origin2, enemyPos );
}
VectorCopy( le->pos.trDelta, oDelta );
// vary the enemyPos to create a psuedo-randomness
of = (float)cg.time + le->startTime;
enemyPos[0] += 12 * (sin(of/100) * cos(of/78));
enemyPos[1] += 12 * (sin(of/70) * cos(of/82));
enemyPos[2] += 12 * (sin(of/67) * cos(of/98));
time = le->lastTrailTime+step;
while (time <= cg.time) {
if (time > le->refEntity.fadeStartTime) {
alpha = (float)(time - le->refEntity.fadeStartTime)/(float)(le->refEntity.fadeEndTime - le->refEntity.fadeStartTime);
if (alpha < 0) alpha = 0;
else if (alpha > 1) alpha = 1;
} else {
alpha = 1.0;
}
// calculate new position
BG_EvaluateTrajectory( &le->pos, time, newOrigin );
VectorSubtract( enemyPos, le->refEntity.origin, v );
enemyDist = VectorNormalize( v );
// trace a line from previous position to new position
CG_Trace( &trace, le->refEntity.origin, NULL, NULL, newOrigin, le->ownerNum, MASK_SHOT );
// if stuck, kill it
if (trace.startsolid || (trace.fraction < 1.0)) {
// kill it
CG_FreeLocalEntity( le );
return;
}
// moved some distance
VectorCopy( trace.endpos, le->refEntity.origin );
if (le->leType == LE_ZOMBIE_SPIRIT) {
le->headJuncIndex = CG_AddTrailJunc( le->headJuncIndex,
cgs.media.zombieSpiritTrailShader,
time,
STYPE_STRETCH,
le->refEntity.origin,
(int)le->effectWidth, // trail life
0.3 * alpha,
0.0,
le->radius,
0,
0,//TJFL_FIXDISTORT,
colorWhite,
colorWhite,
1.0, 1 );
}
// tracking factor
if (le->leType == LE_ZOMBIE_BAT)
le->bounceFactor = 3.0*(float)step/1000.0;
else
le->bounceFactor = 5.0*(float)step/1000.0;
oldSpeed = VectorLength( le->pos.trDelta );
// track the enemy
backup = *le;
VectorSubtract( enemyPos, le->refEntity.origin, v );
enemyDist = VectorNormalize( v );
if (alpha > 0.5 && (le->lastSpiritDmgTime < time - 100) && enemyDist < 24) {
// inflict the damage!
CG_ClientDamage( cg_entities[le->ownerNum].currentState.otherEntityNum2, le->ownerNum, CLDMG_SPIRIT );
le->lastSpiritDmgTime = time;
}
VectorMA( le->pos.trDelta, le->bounceFactor*oldSpeed, v, le->pos.trDelta );
//VectorCopy( v, le->pos.trDelta );
if (VectorLength(le->pos.trDelta) < 1) {
CG_FreeLocalEntity( le );
return;
}
le->bounceFactor = 5.0*(float)step/1000.0; // avoidance factor
// the intersection is a fraction of the frametime
le->pos.trTime = time;
VectorCopy( le->refEntity.origin, le->pos.trBase );
VectorNormalize( le->pos.trDelta );
VectorScale( le->pos.trDelta, oldSpeed, le->pos.trDelta );
// now trace ahead of time, if we're going to hit something, then avoid it
// only avoid dangers if we don't have direct sight to the enemy
trap_CM_BoxTrace( &trace, le->refEntity.origin, enemyPos, NULL, NULL, 0, MASK_SOLID );
if (trace.fraction < 1.0) {
BG_EvaluateTrajectory( &le->pos, time+1000, newOrigin );
// if we would go passed the enemy, don't bother
if (VectorDistance( le->refEntity.origin, enemyPos) > VectorDistance( le->refEntity.origin, newOrigin )) {
trap_CM_BoxTrace( &trace, le->refEntity.origin, newOrigin, NULL, NULL, 0, MASK_SOLID );
if (trace.fraction < 1.0) {
// make sure we are not heading away from the enemy too much
VectorNormalize2( le->pos.trDelta, v2 );
if (DotProduct( v, v2 ) > 0.7) {
// avoid world geometry
backup = *le;
le->bounceFactor = (1.0 - trace.fraction)*10.0*(float)step/1000.0; // tracking and avoidance factor
// reflect the velocity on the trace plane
VectorMA( le->pos.trDelta, le->bounceFactor*oldSpeed, trace.plane.normal, le->pos.trDelta );
if (VectorLength(le->pos.trDelta) < 1) {
CG_FreeLocalEntity( le );
return;
}
// the intersection is a fraction of the frametime
le->pos.trTime = time;
VectorCopy( le->refEntity.origin, le->pos.trBase );
VectorNormalize( le->pos.trDelta );
VectorScale( le->pos.trDelta, oldSpeed, le->pos.trDelta );
//
// double check end velocity
VectorNormalize2( le->pos.trDelta, v2 );
if (DotProduct( v, v2 ) <= 0.2) {
// restore
*le = backup;
}
}
}
}
}
// set the angles
VectorNormalize2( le->pos.trDelta, v );
// HACK!!! skull model is back-to-front, need to fix
if (le->leType == LE_ZOMBIE_SPIRIT)
VectorInverse( v );
vectoangles( v, ang );
AnglesToAxis( ang, le->refEntity.axis );
// lean when turning
if (le->leType == LE_ZOMBIE_BAT) {
VectorSubtract( le->pos.trDelta, oDelta, v2 );
ang[ROLL] = -5.0 * DotProduct( le->refEntity.axis[1], v2 );
if (fabs(ang[ROLL]) > 80) {
if (ang[ROLL] > 80) ang[ROLL] = 80;
else ang[ROLL] = -80;
}
}
AnglesToAxis( ang, le->refEntity.axis );
// HACK: the skull is slightly higher than the origin
if (le->leType == LE_ZOMBIE_SPIRIT) {
// set the size scale
for (i=0; i<3; i++)
VectorScale( le->refEntity.axis[i], 0.35, le->refEntity.axis[i] );
VectorMA( le->refEntity.origin, -10, le->refEntity.axis[2], le->refEntity.origin );
}
le->lastTrailTime = time;
time += step;
}
// Bats, set the frame
if (le->leType == LE_ZOMBIE_BAT) {
#define BAT_ANIM_FRAMETIME 30
le->refEntity.frame = (cg.time/BAT_ANIM_FRAMETIME+1)%19;
le->refEntity.oldframe = (cg.time/BAT_ANIM_FRAMETIME)%19;
le->refEntity.backlerp = 1.0 - ((float)(cg.time%BAT_ANIM_FRAMETIME)/(float)BAT_ANIM_FRAMETIME);
}
// add the sound
if (le->loopingSound) {
if (cg.time > le->refEntity.fadeStartTime)
trap_S_AddLoopingSound( 0, le->refEntity.origin, vec3_origin, le->loopingSound, 255 - (int)(255.0 * (float)(cg.time - le->refEntity.fadeStartTime) / (float)(le->refEntity.fadeEndTime - le->refEntity.fadeStartTime)) );
else if (le->startTime + 1000 > cg.time)
trap_S_AddLoopingSound( 0, le->refEntity.origin, vec3_origin, le->loopingSound, (int)(255.0 * (float)(cg.time - le->startTime) / 1000.0) );
else
trap_S_AddLoopingSound( 0, le->refEntity.origin, vec3_origin, le->loopingSound, 255);
}
trap_R_AddRefEntityToScene( &le->refEntity );
/*
// HACK: the skull is slightly higher than the origin
if (le->leType == LE_ZOMBIE_SPIRIT) {
// set the size scale
for (i=0; i<3; i++)
VectorScale( le->refEntity.axis[i], 1.0/0.35, le->refEntity.axis[i] );
VectorMA( le->refEntity.origin, 10, le->refEntity.axis[2], le->refEntity.origin );
}
*/
// Bats, add the flame
if (le->leType == LE_ZOMBIE_BAT) {
// float lightSize, alpha;
//
le->refEntity.shaderRGBA[3] = 255;
VectorNormalize2( le->pos.trDelta, v );
VectorInverse( v );
v[2] += 1;
VectorNormalize2( v, le->refEntity.fireRiseDir );
le->refEntity.customShader = cgs.media.onFireShader2;
trap_R_AddRefEntityToScene( &le->refEntity );
le->refEntity.shaderTime = 1434;
trap_R_AddRefEntityToScene( &le->refEntity );
// le->refEntity.customShader = cgs.media.onFireShader;
// le->refEntity.shaderTime = 0;
// trap_R_AddRefEntityToScene( &le->refEntity );
le->refEntity.customShader = 0;
le->refEntity.shaderTime = 0;
/*
// drop a dlight
lightSize = 1.0 + 0.2*(sin(1.0*cg.time/50.0) * cos(1.0*cg.time/43.0));
alpha = 0.2 * (lightSize / 1.2);
trap_R_AddLightToScene( le->refEntity.origin, 150.0 + 80.0*lightSize, 1.000000*alpha, 0.603922*alpha, 0.207843*alpha, 0 );
// add some sound
trap_S_AddLoopingSound( -1, le->refEntity.origin, vec3_origin, cgs.media.flameSound, 100 );
trap_S_AddLoopingSound( -1, le->refEntity.origin, vec3_origin, cgs.media.flameBlowSound, 100 );
*/
}
}
/*
** R_DrawSprite
**
** Draw currententity / currentmodel as a single texture
** mapped polygon
*/
void R_DrawSprite (void)
{
vec5_t *pverts;
vec3_t left, up, right, down;
dsprite_t *s_psprite;
dsprframe_t *s_psprframe;
s_psprite = (dsprite_t *)currentmodel->extradata;
#if 0
if (currententity->frame >= s_psprite->numframes
|| currententity->frame < 0)
{
Com_Printf ("No such sprite frame %i\n",
currententity->frame);
currententity->frame = 0;
}
#endif
currententity->frame %= s_psprite->numframes;
s_psprframe = &s_psprite->frames[currententity->frame];
r_polydesc.pixels = currentmodel->skins[currententity->frame]->pixels[0];
r_polydesc.pixel_width = s_psprframe->width;
r_polydesc.pixel_height = s_psprframe->height;
r_polydesc.dist = 0;
// generate the sprite's axes, completely parallel to the viewplane.
VectorCopy (vup, r_polydesc.vup);
VectorCopy (vright, r_polydesc.vright);
VectorCopy (vpn, r_polydesc.vpn);
// build the sprite poster in worldspace
VectorScale (r_polydesc.vright,
s_psprframe->width - s_psprframe->origin_x, right);
VectorScale (r_polydesc.vup,
s_psprframe->height - s_psprframe->origin_y, up);
VectorScale (r_polydesc.vright,
-s_psprframe->origin_x, left);
VectorScale (r_polydesc.vup,
-s_psprframe->origin_y, down);
// invert UP vector for sprites
VectorInverse( r_polydesc.vup );
pverts = r_clip_verts[0];
pverts[0][0] = r_entorigin[0] + up[0] + left[0];
pverts[0][1] = r_entorigin[1] + up[1] + left[1];
pverts[0][2] = r_entorigin[2] + up[2] + left[2];
pverts[0][3] = 0;
pverts[0][4] = 0;
pverts[1][0] = r_entorigin[0] + up[0] + right[0];
pverts[1][1] = r_entorigin[1] + up[1] + right[1];
pverts[1][2] = r_entorigin[2] + up[2] + right[2];
pverts[1][3] = s_psprframe->width;
pverts[1][4] = 0;
pverts[2][0] = r_entorigin[0] + down[0] + right[0];
pverts[2][1] = r_entorigin[1] + down[1] + right[1];
pverts[2][2] = r_entorigin[2] + down[2] + right[2];
pverts[2][3] = s_psprframe->width;
pverts[2][4] = s_psprframe->height;
pverts[3][0] = r_entorigin[0] + down[0] + left[0];
pverts[3][1] = r_entorigin[1] + down[1] + left[1];
pverts[3][2] = r_entorigin[2] + down[2] + left[2];
pverts[3][3] = 0;
pverts[3][4] = s_psprframe->height;
r_polydesc.nump = 4;
r_polydesc.s_offset = ( r_polydesc.pixel_width >> 1);
r_polydesc.t_offset = ( r_polydesc.pixel_height >> 1);
VectorCopy( modelorg, r_polydesc.viewer_position );
r_polydesc.stipple_parity = 1;
if ( currententity->flags & RF_TRANSLUCENT )
R_ClipAndDrawPoly ( currententity->alpha, false, true );
else
R_ClipAndDrawPoly ( 1.0F, false, true );
r_polydesc.stipple_parity = 0;
}
static void R_PlantGrass (Clump& clump)
{
if (clumpTriangleCount + TRIS_PER_CLUMP >= MAX_CLUMP_TRIS) {
clump.firstTriangle = clumpTriangleCount;
clump.numTriangles = 0;
return;
}
clump.firstTriangle = clumpTriangleCount;
clump.numTriangles = 0; /* safeguard */
vec3_t rot[3]; /* rotation matrix for the plant */
#define xt (rot[0])
#define yt (rot[1])
#define zt (rot[2])
#if 0
/* horisontal planting */
VectorSet(xt, 1, 0, 0);
VectorSet(zt, 0, 0, 1);
#else
/* normal-based planting */
/* we can calculate the downslope vector and use it instead;
* a bit more of math, but call allow us to create plants that interact with the slope in various ways */
VectorCopy(clump.normal, zt);
VectorSet(xt, zt[2], 0.0, -zt[0]); /* short-circuit CrossProduct(yaxis, normal, xt) since it degenerates to a simple shuffle */
VectorNormalizeFast(xt);
#endif
/* generate geometry */
#if 0
/* prebuilt mesh or debug grass marker */
/* randomly rotate plant around the base */
RotatePointAroundVector(yt, zt, xt, frand() * 360);
CrossProduct(yt, zt, xt);
/* randomly mirror the plant, too */
if (rand() & 1)
VectorInverse(yt);
/* marker */
vec_t* ptr = gfv_pos[clumpTriangleCount * 3];
VectorMA(clump.position, 1, zt, ptr);
VectorMA(ptr, 16, yt, ptr + 3);
VectorMA(ptr, 16, xt, ptr + 6);
vec_t* texc = gfv_texcoord[clumpTriangleCount * 3];
Vector2Set(texc, 0, 0);
Vector2Set(texc + 2, 1, 0);
Vector2Set(texc + 4, 0, 1);
clumpTriangleCount++;
#else
/* programmatically generated clump */
CrossProduct(zt, xt, yt);
for (int i = 0; i < TRIS_PER_CLUMP; i += 2) {
vec3_t sdir, tdir;
vec2_t sprrot;
vec3_t tmp;
sprrot[0] = frand() * 360;
sprrot[1] = frand() * 60 + 15;
PolarToVec(sprrot, tmp);
VectorRotate(rot, tmp, tdir);
sprrot[0] += 90;
sprrot[1] = 0;
PolarToVec(sprrot, tmp);
VectorRotate(rot, tmp, sdir);
#if 0
/* debug marker */
vec_t* ptr = gfv_pos[clumpTriangleCount * 3];
VectorCopy(clump.position, ptr);
VectorMA(ptr, 16, sdir, ptr + 3);
VectorMA(ptr, 16, tdir, ptr + 6);
vec_t* texc = gfv_texcoord[clumpTriangleCount * 3];
Vector2Set(texc, 0, 0);
Vector2Set(texc + 2, 1, 0);
Vector2Set(texc + 4, 0, 1);
clumpTriangleCount++;
#else
/* billboard sprite */
vec_t* ptr = gfv_pos[clumpTriangleCount * 3];
VectorCopy(clump.position, ptr);
/** @todo use UNIT_SIZE and co defines here */
VectorMA(clump.position, -24, sdir, ptr); /* quad vertex 0 */
VectorMA(ptr, 32, tdir, ptr + 3); /* quad vertex 1 */
VectorMA(ptr + 3, 48, sdir, ptr + 6); /* quad vertex 2 */
VectorCopy(ptr, ptr + 9); /* quad vertex 0 */
VectorCopy(ptr + 6, ptr + 12); /* quad vertex 2 */
VectorMA(ptr + 6, -32, tdir, ptr + 15); /* quad vertex 3 */
vec_t* texc = gfv_texcoord[clumpTriangleCount * 3];
Vector2Set(texc, 0, 1);
Vector2Set(texc + 2, 0, 0);
Vector2Set(texc + 4, 1, 0);
Vector2Set(texc + 6, 0, 1);
Vector2Set(texc + 8, 1, 0);
Vector2Set(texc + 12, 1, 1);
clumpTriangleCount += 2;
#endif
}
#endif
#undef xt
#undef yt
#undef zt
clump.numTriangles = clumpTriangleCount - clump.firstTriangle;
}
int R_MarkFragments( int numPoints, const vec3_t* points, const vec3_t projection,
int maxPoints, vec3_t pointBuffer, int maxFragments, markFragment_t* fragmentBuffer ) {
//increment view count for double check prevention
tr.viewCount++;
vec3_t projectionDir;
VectorNormalize2( projection, projectionDir );
// find all the brushes that are to be considered
vec3_t mins, maxs;
ClearBounds( mins, maxs );
for ( int i = 0; i < numPoints; i++ ) {
AddPointToBounds( points[ i ], mins, maxs );
vec3_t temp;
VectorAdd( points[ i ], projection, temp );
AddPointToBounds( temp, mins, maxs );
// make sure we get all the leafs (also the one(s) in front of the hit surface)
VectorMA( points[ i ], -20, projectionDir, temp );
AddPointToBounds( temp, mins, maxs );
}
if ( numPoints > MAX_VERTS_ON_POLY ) {
numPoints = MAX_VERTS_ON_POLY;
}
// create the bounding planes for the to be projected polygon
vec3_t normals[ MAX_VERTS_ON_POLY + 2 ];
float dists[ MAX_VERTS_ON_POLY + 2 ];
for ( int i = 0; i < numPoints; i++ ) {
vec3_t v1, v2;
VectorSubtract( points[ ( i + 1 ) % numPoints ], points[ i ], v1 );
VectorAdd( points[ i ], projection, v2 );
VectorSubtract( points[ i ], v2, v2 );
CrossProduct( v1, v2, normals[ i ] );
VectorNormalizeFast( normals[ i ] );
dists[ i ] = DotProduct( normals[ i ], points[ i ] );
}
// add near and far clipping planes for projection
VectorCopy( projectionDir, normals[ numPoints ] );
dists[ numPoints ] = DotProduct( normals[ numPoints ], points[ 0 ] ) - 32;
VectorCopy( projectionDir, normals[ numPoints + 1 ] );
VectorInverse( normals[ numPoints + 1 ] );
dists[ numPoints + 1 ] = DotProduct( normals[ numPoints + 1 ], points[ 0 ] ) - 20;
int numPlanes = numPoints + 2;
int numsurfaces = 0;
idWorldSurface* surfaces[ 64 ];
R_BoxSurfaces_r( tr.world->nodes, mins, maxs, surfaces, 64, &numsurfaces, projectionDir );
//assert(numsurfaces <= 64);
//assert(numsurfaces != 64);
int returnedPoints = 0;
int returnedFragments = 0;
for ( int i = 0; i < numsurfaces; i++ ) {
surfaces[ i ]->MarkFragments( projectionDir,
numPlanes, normals, dists,
maxPoints, pointBuffer,
maxFragments, fragmentBuffer,
&returnedPoints, &returnedFragments, mins, maxs );
if ( returnedFragments == maxFragments ) {
break; // not enough space for more fragments
}
}
return returnedFragments;
}
int CHudRadar::Draw(float flTime)
{ if ( (gHUD.m_iHideHUDDisplay & HIDEHUD_HEALTH) || gEngfuncs.IsSpectateOnly() || !(gHUD.m_iWeaponBits & (1<<(WEAPON_SUIT))))
{ return 1;
}
cl_entity_t *pLocal = gEngfuncs.GetLocalPlayer();
if(!pLocal)
{ return 1;
}
float flPlayerAngles, flLength, flAngle, flRadians, pos_x, pos_y;
vec3_t vecViewAngles, v_right, vecPlayerOrigin, vecOtherOrigin, vecDifference, vecAngles;
/*
* Draw Background radar
*/
// Get origin for radar
int x = ScreenWidth;
int y = 0;
int iRadarWidth = gHUD.GetSpriteRect(m_HUD_radar).right - gHUD.GetSpriteRect(m_HUD_radar).left;
int iRadarHeight = gHUD.GetSpriteRect(m_HUD_radar).bottom - gHUD.GetSpriteRect(m_HUD_radar).top;
int infox = ScreenWidth - INFO_WIDTH;
int infoy = iRadarHeight;
int infoheight = gHUD.GetSpriteRect(m_HUD_radar_info).bottom - gHUD.GetSpriteRect(m_HUD_radar_info).top;
x -= iRadarWidth;
// Slide radar + info bar in/out when we enable/disable
if(m_blPrevRadar != m_blRadar && !m_blSliding)
{ m_blSliding = true;
m_flSlideTime = flTime;
}
// We switched the radar on/off while in the middle of sliding
else if(m_blPrevRadar == m_blRadar && m_blSliding)
{ m_blPrevRadar = !m_blPrevRadar;
// Invert time
float flSlideTime = flTime - m_flSlideTime;
flSlideTime = SLIDETIME - flSlideTime;
m_flSlideTime = flTime - flSlideTime;
}
if(m_blSliding)
{ // Sliding is done, disable
if((m_flSlideTime + SLIDETIME) < flTime)
{ m_blSliding = false;
m_flSlideTime = 0;
m_blPrevRadar = m_blRadar;
// Done sliding and radar is off, disable
if(!m_blRadar)
{ return 1;
}
}
// we're still sliding
else
{ float flPercent;
if(m_blRadar)
flPercent = (SLIDETIME-(flTime - m_flSlideTime))/SLIDETIME;
else
flPercent = (flTime - m_flSlideTime)/SLIDETIME;
// Slide Radar
y = -iRadarHeight * flPercent;
// Slide Infobox
infox += INFO_WIDTH * flPercent;
}
}
// Done sliding and radar is off, disable
if(!m_blRadar && !m_blSliding)
{ return 1;
}
// Draw Radar
SPR_Set(gHUD.GetSprite(m_HUD_radar), 255, 255, 255);
SPR_DrawHoles(0, x,y, &gHUD.GetSpriteRect(m_HUD_radar));
// Draw info box
SPR_Set(gHUD.GetSprite(m_HUD_radar_info), 255,255,255);
SPR_DrawHoles(0, infox,infoy, &gHUD.GetSpriteRect(m_HUD_radar_info));
if(m_blSliding)
m_iyBottomRadar = y + iRadarHeight;
else
m_iyBottomRadar = infoy + infoheight;
// Sliding or radar is just off, dont display information
if(m_blSliding || !m_blRadar)
{ return 1;
}
/*
* Get Player Angles
*/
// Setting player angles
gEngfuncs.GetViewAngles((float *)vecViewAngles);
AngleVectors(vecViewAngles, NULL, v_right, NULL );
// Inverse vector
VectorInverse(v_right);
v_right.z = 0;
// Get angles
VectorAngles(v_right,vecAngles);
flPlayerAngles = vecAngles.y;
// strictly 0 to 360
if(flPlayerAngles < 0)
flPlayerAngles += 360;
// Move x and y to the middle of the radar
x += OFFSET_RAD_WIDTH;
y += OFFSET_RAD_HEIGHT;
/*
* Loop and draw dots
*/
for(int i=0; i<MAX_PLAYERS; i++)
{ int r=255,g=255,b=255;
bool blDrawInfo = false;
cl_entity_t *pPlayer = gEngfuncs.GetEntityByIndex(i);
// Invalid
if(!pPlayer)
{ continue;
}
// Not player
if(!pPlayer->player)
{ continue;
}
// Render check, make sure player is being rendered
if(!g_RenderCheck[i].blRendered)
{ continue;
}
// Draw yourself as a orange dot
if(pPlayer == pLocal)
{ r=255;
g=255;
b=0;
}
// Get Origins
vecPlayerOrigin = pLocal->origin;
vecOtherOrigin = pPlayer->origin;
vecPlayerOrigin.z = 0;
vecOtherOrigin.z = 0;
vecDifference = vecPlayerOrigin - vecOtherOrigin;
flLength = vecDifference.Length();
// Player is too far away, dont draw
if(flLength > MAX_RADAR_DIST)
continue;
vecDifference = vecDifference.Normalize();
// Set 0 to 360
VectorAngles(vecDifference, vecAngles);
flAngle = vecAngles.y;
if(flAngle < 0)
flAngle += 360;
// Subtract Angles
flAngle = flPlayerAngles - flAngle;
// Set length according to the size of the radar
flLength = (flLength/(float)MAX_RADAR_DIST) * RAD_DIAM;
// Angles to radians
flRadians = flAngle * PI_180;
pos_x = int(cos(flRadians)*flLength);
pos_y = int(sin(flRadians)*flLength);
// Set positions + draw radar
pos_x += x;
pos_y += y;
// Shift dot over so it's drawn in the correct position
int iDotWidth = (gHUD.GetSpriteRect(m_HUD_radardot).right - gHUD.GetSpriteRect(m_HUD_radardot).left)/2;
int iDotHeight = (gHUD.GetSpriteRect(m_HUD_radardot).bottom - gHUD.GetSpriteRect(m_HUD_radardot).top)/2;
pos_x -= iDotWidth;
pos_y -= iDotHeight;
// Person is targeted by our missles, color them red
if( gHUD.m_Lockon.FindLock( pPlayer->index ) != -1 )
{ r=255;
g=0;
b=0;
}
// Yellow if our crosshair is/was over the player
if( gHUD.m_Crosshair.m_iMouseOverEnt == pPlayer->index && ((flTime - gHUD.m_Crosshair.m_flMouseOverTime) < 3) )
{ UnpackRGB(r,g,b, RGB_YELLOWISH);
blDrawInfo = true;
}
// Draw
SPR_Set(gHUD.GetSprite(m_HUD_radardot), r,g,b);
SPR_DrawAdditive(0, pos_x,pos_y, &gHUD.GetSpriteRect(m_HUD_radardot));
// Draw information if specified
if(blDrawInfo)
{ int line_height=0,line_width=0;
pos_x = ScreenWidth - INFO_WIDTH + INFO_OFFSET_WIDTH;
pos_y = iRadarHeight + INFO_OFFSET_HEIGHT;
hud_player_info_t *pl_info = &g_PlayerInfoList[i];
char szName[128];
// Get colors
float flTeamR,flTeamG,flTeamB;
if((g_PlayerExtraInfo[i].teamnumber == g_PlayerExtraInfo[pLocal->index].teamnumber) && gHUD.m_Teamplay)
{ flTeamR=0;
flTeamG=0.9;
flTeamB=0;
}
else
{ flTeamR=1.0;
flTeamG=0.2;
flTeamB=0.2;
}
// Draw player name
strcpy(szName,"Name: ");
int iNameX = DrawConsoleString( pos_x, pos_y, szName );
// Draw name in color, depending if player is on your team
strcpy(szName, pl_info->name);
// Set color
gEngfuncs.pfnDrawSetTextColor(flTeamR,flTeamG,flTeamB);
// Draw
DrawConsoleString( iNameX, pos_y, szName );
// Adjust offset
GetConsoleStringSize( szName, &line_width, &line_height );
pos_y += line_height + INFO_OFFSET_LINE;
// Draw Label
strcpy(szName,"Mech: ");
iNameX = DrawConsoleString( pos_x, pos_y, szName );
// Get Mech Name
int iClass = g_PlayerExtraInfo[i].playerclass;
if(iClass < 0)
iClass = 0;
else if(iClass >= PC_LASTCLASS)
iClass = PC_LASTCLASS-1;
strcpy(szName, szClassNames[iClass] );
// Set Color
gEngfuncs.pfnDrawSetTextColor(flTeamR,flTeamG,flTeamB);
// Draw Mech Name
DrawConsoleString( iNameX, pos_y, szName );
}
}
return 1;
}
/*
==================
CG_BuildableHealthBar
==================
*/
static void CG_BuildableHealthBar( centity_t *cent )
{
vec3_t origin, origin2, down, right, back, downLength, rightLength;
float rimWidth = HEALTH_BAR_HEIGHT / 15.0f;
float doneWidth, leftWidth, progress;
int health;
qhandle_t shader;
entityState_t *es;
vec3_t mins, maxs;
es = ¢->currentState;
health = es->generic1 & ~( B_POWERED_TOGGLEBIT | B_DCCED_TOGGLEBIT | B_SPAWNED_TOGGLEBIT );
progress = (float)health / B_HEALTH_SCALE;
if( progress < 0.0f )
progress = 0.0f;
else if( progress > 1.0f )
progress = 1.0f;
if( progress < 0.33f )
shader = cgs.media.redBuildShader;
else
shader = cgs.media.greenBuildShader;
doneWidth = ( HEALTH_BAR_WIDTH - 2 * rimWidth ) * progress;
leftWidth = ( HEALTH_BAR_WIDTH - 2 * rimWidth ) - doneWidth;
VectorCopy( cg.refdef.viewaxis[ 2 ], down );
VectorInverse( down );
VectorCopy( cg.refdef.viewaxis[ 1 ], right );
VectorInverse( right );
VectorSubtract( cg.refdef.vieworg, cent->lerpOrigin, back );
VectorNormalize( back );
VectorCopy( cent->lerpOrigin, origin );
BG_FindBBoxForBuildable( es->modelindex, mins, maxs );
VectorMA( origin, 48.0f, es->origin2, origin );
VectorMA( origin, -HEALTH_BAR_WIDTH / 2.0f, right, origin );
VectorMA( origin, maxs[ 0 ] + 8.0f, back, origin );
VectorCopy( origin, origin2 );
VectorScale( right, rimWidth + doneWidth, rightLength );
VectorScale( down, HEALTH_BAR_HEIGHT, downLength );
CG_DrawPlane( origin2, downLength, rightLength, shader );
VectorMA( origin, rimWidth + doneWidth, right, origin2 );
VectorScale( right, leftWidth, rightLength );
VectorScale( down, rimWidth, downLength );
CG_DrawPlane( origin2, downLength, rightLength, shader );
VectorMA( origin, rimWidth + doneWidth, right, origin2 );
VectorMA( origin2, HEALTH_BAR_HEIGHT - rimWidth, down, origin2 );
VectorScale( right, leftWidth, rightLength );
VectorScale( down, rimWidth, downLength );
CG_DrawPlane( origin2, downLength, rightLength, shader );
VectorMA( origin, HEALTH_BAR_WIDTH - rimWidth, right, origin2 );
VectorScale( right, rimWidth, rightLength );
VectorScale( down, HEALTH_BAR_HEIGHT, downLength );
CG_DrawPlane( origin2, downLength, rightLength, shader );
if( !( es->generic1 & B_POWERED_TOGGLEBIT ) &&
BG_FindTeamForBuildable( es->modelindex ) == BIT_HUMANS )
{
VectorMA( origin, 15.0f, right, origin2 );
VectorMA( origin2, HEALTH_BAR_HEIGHT + 5.0f, down, origin2 );
VectorScale( right, HEALTH_BAR_WIDTH / 2.0f - 5.0f, rightLength );
VectorScale( down, HEALTH_BAR_WIDTH / 2.0f - 5.0f, downLength );
CG_DrawPlane( origin2, downLength, rightLength, cgs.media.noPowerShader );
}
}
//======================================================================
//aim決定
//ent entity
//aim aimスキル
//yaw dist
//wep weapon
void Get_AimAngle(edict_t *ent,float aim,float dist,int weapon)
{
edict_t *target;
vec3_t targaim,v;
trace_t rs_trace;
target = ent->client->zc.first_target;
switch(weapon)
{
//即判定
case WEAP_SHOTGUN:
case WEAP_SUPERSHOTGUN:
case WEAP_RAILGUN:
if(target != ent->client->zc.last_target)
{
if(target->bot_client)
{
VectorSubtract(target->s.old_origin,target->s.origin,targaim);
}
else
{
VectorCopy(target->velocity,targaim);
VectorInverse (targaim);
}
VectorNormalize(targaim);
VectorMA(target->s.origin,random() * aim * AIMING_POSGAP * random(),targaim,targaim);
}
else
{
VectorSubtract(ent->client->zc.last_pos,target->s.origin,targaim);
// VectorScale (targaim, vec_t scale, vec3_t out)
VectorMA(target->s.origin,aim * /*VectorLength(targaim)**/ random(),targaim,targaim);
}
VectorSubtract(targaim,ent->s.origin,targaim);
ent->s.angles[YAW] = Get_yaw(targaim);
ent->s.angles[PITCH] = Get_pitch(targaim);
ent->s.angles[YAW] += aim * AIMING_ANGLEGAP_S * (random() - 0.5) *2;
if(ent->s.angles[YAW] > 180) ent->s.angles[YAW] -= 360;
else if(ent->s.angles[YAW] < -180) ent->s.angles[YAW] += 360;
ent->s.angles[PITCH] += (aim * AIMING_ANGLEGAP_S * (random() - 0.5) * 2);
if(ent->s.angles[PITCH] > 90) ent->s.angles[PITCH] = 90;
else if(ent->s.angles[PITCH] < -90) ent->s.angles[PITCH] = -90;
break;
case WEAP_MACHINEGUN:
case WEAP_CHAINGUN:
if(target != ent->client->zc.last_target)
{
if(target->bot_client)
{
VectorSubtract(target->s.old_origin,target->s.origin,targaim);
}
else
{
VectorCopy(target->velocity,targaim);
VectorInverse (targaim);
}
VectorNormalize(targaim);
VectorMA(target->s.origin,random() * aim * AIMING_POSGAP,targaim,targaim);
}
else
{
VectorSubtract(ent->client->zc.last_pos,target->s.origin,targaim);
VectorMA(target->s.origin,random() * aim /** VectorLength(targaim)*/,targaim,targaim);
}
VectorSubtract(targaim,ent->s.origin,targaim);
ent->s.angles[YAW] = Get_yaw(targaim);
ent->s.angles[PITCH] = Get_pitch(targaim);
ent->s.angles[YAW] += aim * AIMING_ANGLEGAP_M * (random() - 0.5) *2;
if(ent->s.angles[YAW] > 180) ent->s.angles[YAW] -= 360;
else if(ent->s.angles[YAW] < -180) ent->s.angles[YAW] += 360;
ent->s.angles[PITCH] += (aim * AIMING_ANGLEGAP_M * (random() - 0.5) * 2);
if(ent->s.angles[PITCH] > 90) ent->s.angles[PITCH] = 90;
else if(ent->s.angles[PITCH] < -90) ent->s.angles[PITCH] = -90;
break;
case WEAP_BLASTER:
case WEAP_GRENADES:
case WEAP_GRENADELAUNCHER:
case WEAP_ROCKETLAUNCHER:
if(target != ent->client->zc.last_target)
{
if(target->bot_client)
{
VectorSubtract(target->s.origin,target->s.old_origin,targaim);
}
else
{
VectorCopy(target->velocity,targaim);
targaim[0] *= 32;
targaim[1] *= 32;
targaim[2] *= 32;
}
VectorNormalize(targaim);
VectorMA(target->s.origin,(11 - aim) * dist/25,targaim,targaim);
}
else
{
VectorSubtract(target->s.origin,ent->client->zc.last_pos,targaim);
targaim[2] /= 2;
VectorMA(target->s.origin,- aim * random() + dist/75,targaim,targaim);
}
rs_trace = gi.trace(target->s.origin,NULL,NULL,targaim,target,MASK_SHOT);
VectorCopy(rs_trace.endpos,targaim);
if(weapon == WEAP_GRENADELAUNCHER
|| weapon == WEAP_ROCKETLAUNCHER)
{
if(targaim[2] < (ent->s.origin[2] + JumpMax))
{
targaim[2] -= 24;
VectorCopy(ent->s.origin,v);
v[2] += ent->viewheight - 8;
rs_trace = gi.trace(v,NULL,NULL,targaim,ent,MASK_SHOT);
if(rs_trace.fraction != 1.0) targaim[2] += 24;
}
else if(targaim[2] > (ent->s.origin[2] + JumpMax)) targaim[2] += 5;
}
VectorSubtract(targaim,ent->s.origin,targaim);
ent->s.angles[YAW] = Get_yaw(targaim);
ent->s.angles[PITCH] = Get_pitch(targaim);
ent->s.angles[YAW] += aim * AIMING_ANGLEGAP_M * (random() - 0.5) *2;
if(ent->s.angles[YAW] > 180) ent->s.angles[YAW] -= 360;
else if(ent->s.angles[YAW] < -180) ent->s.angles[YAW] += 360;
ent->s.angles[PITCH] += (aim * AIMING_ANGLEGAP_M * (random() - 0.5) * 2);
if(ent->s.angles[PITCH] > 90) ent->s.angles[PITCH] = 90;
else if(ent->s.angles[PITCH] < -90) ent->s.angles[PITCH] = -90;
break;
case WEAP_HYPERBLASTER:
if(target != ent->client->zc.last_target)
{
if(target->bot_client)
{
VectorSubtract(target->s.origin,target->s.old_origin,targaim);
}
else
{
VectorCopy(target->velocity,targaim);
targaim[0] *= 32;
targaim[1] *= 32;
targaim[2] *= 32;
}
VectorNormalize(targaim);
VectorMA(target->s.origin,(11 - aim) * dist/100,targaim,targaim);
}
else
{
VectorSubtract(target->s.origin,ent->client->zc.last_pos,targaim);
targaim[2] /= 2;
VectorMA(target->s.origin,- aim + dist/115,targaim,targaim);
}
rs_trace = gi.trace(target->s.origin,NULL,NULL,targaim,target,MASK_SHOT);
VectorCopy(rs_trace.endpos,targaim);
VectorSubtract(targaim,ent->s.origin,targaim);
ent->s.angles[YAW] = Get_yaw(targaim);
ent->s.angles[PITCH] = Get_pitch(targaim);
ent->s.angles[YAW] += aim * AIMING_ANGLEGAP_M * (random() - 0.5) *2;
if(ent->s.angles[YAW] > 180) ent->s.angles[YAW] -= 360;
else if(ent->s.angles[YAW] < -180) ent->s.angles[YAW] += 360;
ent->s.angles[PITCH] += (aim * AIMING_ANGLEGAP_M * (random() - 0.5) * 2);
if(ent->s.angles[PITCH] > 90) ent->s.angles[PITCH] = 90;
else if(ent->s.angles[PITCH] < -90) ent->s.angles[PITCH] = -90;
break;
case WEAP_BFG:
VectorCopy(ent->client->zc.vtemp,targaim);
VectorSubtract(targaim,ent->s.origin,targaim);
ent->s.angles[YAW] = Get_yaw(targaim);
ent->s.angles[PITCH] = Get_pitch(targaim);
break;
default:
break;
}
}
qboolean R_LoadMD5(model_t *mod, void *buffer, int bufferSize, const char *modName)
{
int i, j, k;
md5Model_t *md5;
md5Bone_t *bone;
md5Surface_t *surf;
srfTriangle_t *tri;
md5Vertex_t *v;
md5Weight_t *weight;
int version;
shader_t *sh;
char *buf_p = ( char * ) buffer;
char *token;
vec3_t boneOrigin;
quat_t boneQuat;
matrix_t boneMat;
int numRemaining;
growList_t sortedTriangles;
growList_t vboTriangles;
growList_t vboSurfaces;
int numBoneReferences;
int boneReferences[MAX_BONES];
// skip MD5Version indent string
COM_ParseExt2(&buf_p, qfalse);
// check version
token = COM_ParseExt2(&buf_p, qfalse);
version = atoi(token);
if (version != MD5_VERSION)
{
Ren_Warning("R_LoadMD5: %s has wrong version (%i should be %i)\n", modName, version, MD5_VERSION);
return qfalse;
}
mod->type = MOD_MD5;
mod->dataSize += sizeof(md5Model_t);
md5 = mod->md5 = ri.Hunk_Alloc(sizeof(md5Model_t), h_low);
// skip commandline <arguments string>
token = COM_ParseExt2(&buf_p, qtrue);
token = COM_ParseExt2(&buf_p, qtrue);
// Ren_Print("%s\n", token);
// parse numJoints <number>
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "numJoints"))
{
Ren_Warning("R_LoadMD5: expected 'numJoints' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
token = COM_ParseExt2(&buf_p, qfalse);
md5->numBones = atoi(token);
// parse numMeshes <number>
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "numMeshes"))
{
Ren_Warning("R_LoadMD5: expected 'numMeshes' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
token = COM_ParseExt2(&buf_p, qfalse);
md5->numSurfaces = atoi(token);
//Ren_Print("R_LoadMD5: '%s' has %i surfaces\n", modName, md5->numSurfaces);
if (md5->numBones < 1)
{
Ren_Warning("R_LoadMD5: '%s' has no bones\n", modName);
return qfalse;
}
if (md5->numBones > MAX_BONES)
{
Ren_Warning("R_LoadMD5: '%s' has more than %i bones (%i)\n", modName, MAX_BONES, md5->numBones);
return qfalse;
}
//Ren_Print("R_LoadMD5: '%s' has %i bones\n", modName, md5->numBones);
// parse all the bones
md5->bones = ri.Hunk_Alloc(sizeof(*bone) * md5->numBones, h_low);
// parse joints {
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "joints"))
{
Ren_Warning("R_LoadMD5: expected 'joints' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
token = COM_ParseExt2(&buf_p, qfalse);
if (Q_stricmp(token, "{"))
{
Ren_Warning("R_LoadMD5: expected '{' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
for (i = 0, bone = md5->bones; i < md5->numBones; i++, bone++)
{
token = COM_ParseExt2(&buf_p, qtrue);
Q_strncpyz(bone->name, token, sizeof(bone->name));
//Ren_Print("R_LoadMD5: '%s' has bone '%s'\n", modName, bone->name);
token = COM_ParseExt2(&buf_p, qfalse);
bone->parentIndex = atoi(token);
//Ren_Print("R_LoadMD5: '%s' has bone '%s' with parent index %i\n", modName, bone->name, bone->parentIndex);
if (bone->parentIndex >= md5->numBones)
{
Ren_Drop("R_LoadMD5: '%s' has bone '%s' with bad parent index %i while numBones is %i", modName,
bone->name, bone->parentIndex, md5->numBones);
}
// skip (
token = COM_ParseExt2(&buf_p, qfalse);
if (Q_stricmp(token, "("))
{
Ren_Warning("R_LoadMD5: expected '(' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
for (j = 0; j < 3; j++)
{
token = COM_ParseExt2(&buf_p, qfalse);
boneOrigin[j] = atof(token);
}
// skip )
token = COM_ParseExt2(&buf_p, qfalse);
if (Q_stricmp(token, ")"))
{
Ren_Warning("R_LoadMD5: expected ')' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
// skip (
token = COM_ParseExt2(&buf_p, qfalse);
if (Q_stricmp(token, "("))
{
Ren_Warning("R_LoadMD5: expected '(' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
for (j = 0; j < 3; j++)
{
token = COM_ParseExt2(&buf_p, qfalse);
boneQuat[j] = atof(token);
}
QuatCalcW(boneQuat);
MatrixFromQuat(boneMat, boneQuat);
VectorCopy(boneOrigin, bone->origin);
QuatCopy(boneQuat, bone->rotation);
MatrixSetupTransformFromQuat(bone->inverseTransform, boneQuat, boneOrigin);
MatrixInverse(bone->inverseTransform);
// skip )
token = COM_ParseExt2(&buf_p, qfalse);
if (Q_stricmp(token, ")"))
{
Ren_Warning("R_LoadMD5: expected '(' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
}
// parse }
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "}"))
{
Ren_Warning("R_LoadMD5: expected '}' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
// parse all the surfaces
if (md5->numSurfaces < 1)
{
Ren_Warning("R_LoadMD5: '%s' has no surfaces\n", modName);
return qfalse;
}
//Ren_Print("R_LoadMD5: '%s' has %i surfaces\n", modName, md5->numSurfaces);
md5->surfaces = ri.Hunk_Alloc(sizeof(*surf) * md5->numSurfaces, h_low);
for (i = 0, surf = md5->surfaces; i < md5->numSurfaces; i++, surf++)
{
// parse mesh {
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "mesh"))
{
Ren_Warning("R_LoadMD5: expected 'mesh' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
token = COM_ParseExt2(&buf_p, qfalse);
if (Q_stricmp(token, "{"))
{
Ren_Warning("R_LoadMD5: expected '{' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
// change to surface identifier
surf->surfaceType = SF_MD5;
// give pointer to model for Tess_SurfaceMD5
surf->model = md5;
// parse shader <name>
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "shader"))
{
Ren_Warning("R_LoadMD5: expected 'shader' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
token = COM_ParseExt2(&buf_p, qfalse);
Q_strncpyz(surf->shader, token, sizeof(surf->shader));
//Ren_Print("R_LoadMD5: '%s' uses shader '%s'\n", modName, surf->shader);
// FIXME .md5mesh meshes don't have surface names
// lowercase the surface name so skin compares are faster
//Q_strlwr(surf->name);
//Ren_Print("R_LoadMD5: '%s' has surface '%s'\n", modName, surf->name);
// register the shaders
sh = R_FindShader(surf->shader, SHADER_3D_DYNAMIC, qtrue);
if (sh->defaultShader)
{
surf->shaderIndex = 0;
}
else
{
surf->shaderIndex = sh->index;
}
// parse numVerts <number>
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "numVerts"))
{
Ren_Warning("R_LoadMD5: expected 'numVerts' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
token = COM_ParseExt2(&buf_p, qfalse);
surf->numVerts = atoi(token);
if (surf->numVerts > SHADER_MAX_VERTEXES)
{
Ren_Drop("R_LoadMD5: '%s' has more than %i verts on a surface (%i)",
modName, SHADER_MAX_VERTEXES, surf->numVerts);
}
surf->verts = ri.Hunk_Alloc(sizeof(*v) * surf->numVerts, h_low);
for (j = 0, v = surf->verts; j < surf->numVerts; j++, v++)
{
// skip vert <number>
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "vert"))
{
Ren_Warning("R_LoadMD5: expected 'vert' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
COM_ParseExt2(&buf_p, qfalse);
// skip (
token = COM_ParseExt2(&buf_p, qfalse);
if (Q_stricmp(token, "("))
{
Ren_Warning("R_LoadMD5: expected '(' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
for (k = 0; k < 2; k++)
{
token = COM_ParseExt2(&buf_p, qfalse);
v->texCoords[k] = atof(token);
}
// skip )
token = COM_ParseExt2(&buf_p, qfalse);
if (Q_stricmp(token, ")"))
{
Ren_Warning("R_LoadMD5: expected ')' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
token = COM_ParseExt2(&buf_p, qfalse);
v->firstWeight = atoi(token);
token = COM_ParseExt2(&buf_p, qfalse);
v->numWeights = atoi(token);
if (v->numWeights > MAX_WEIGHTS)
{
Ren_Drop("R_LoadMD5: vertex %i requires more than %i weights on surface (%i) in model '%s'",
j, MAX_WEIGHTS, i, modName);
}
}
// parse numTris <number>
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "numTris"))
{
Ren_Warning("R_LoadMD5: expected 'numTris' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
token = COM_ParseExt2(&buf_p, qfalse);
surf->numTriangles = atoi(token);
if (surf->numTriangles > SHADER_MAX_TRIANGLES)
{
Ren_Drop("R_LoadMD5: '%s' has more than %i triangles on a surface (%i)",
modName, SHADER_MAX_TRIANGLES, surf->numTriangles);
}
surf->triangles = ri.Hunk_Alloc(sizeof(*tri) * surf->numTriangles, h_low);
for (j = 0, tri = surf->triangles; j < surf->numTriangles; j++, tri++)
{
// skip tri <number>
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "tri"))
{
Ren_Warning("R_LoadMD5: expected 'tri' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
COM_ParseExt2(&buf_p, qfalse);
for (k = 0; k < 3; k++)
{
token = COM_ParseExt2(&buf_p, qfalse);
tri->indexes[k] = atoi(token);
}
}
// parse numWeights <number>
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "numWeights"))
{
Ren_Warning("R_LoadMD5: expected 'numWeights' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
token = COM_ParseExt2(&buf_p, qfalse);
surf->numWeights = atoi(token);
surf->weights = ri.Hunk_Alloc(sizeof(*weight) * surf->numWeights, h_low);
for (j = 0, weight = surf->weights; j < surf->numWeights; j++, weight++)
{
// skip weight <number>
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "weight"))
{
Ren_Warning("R_LoadMD5: expected 'weight' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
COM_ParseExt2(&buf_p, qfalse);
token = COM_ParseExt2(&buf_p, qfalse);
weight->boneIndex = atoi(token);
token = COM_ParseExt2(&buf_p, qfalse);
weight->boneWeight = atof(token);
// skip (
token = COM_ParseExt2(&buf_p, qfalse);
if (Q_stricmp(token, "("))
{
Ren_Warning("R_LoadMD5: expected '(' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
for (k = 0; k < 3; k++)
{
token = COM_ParseExt2(&buf_p, qfalse);
weight->offset[k] = atof(token);
}
// skip )
token = COM_ParseExt2(&buf_p, qfalse);
if (Q_stricmp(token, ")"))
{
Ren_Warning("R_LoadMD5: expected ')' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
}
// parse }
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "}"))
{
Ren_Warning("R_LoadMD5: expected '}' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
// loop trough all vertices and set up the vertex weights
for (j = 0, v = surf->verts; j < surf->numVerts; j++, v++)
{
v->weights = ri.Hunk_Alloc(sizeof(*v->weights) * v->numWeights, h_low);
for (k = 0; k < v->numWeights; k++)
{
v->weights[k] = surf->weights + (v->firstWeight + k);
}
}
}
// loading is done now calculate the bounding box and tangent spaces
ClearBounds(md5->bounds[0], md5->bounds[1]);
for (i = 0, surf = md5->surfaces; i < md5->numSurfaces; i++, surf++)
{
for (j = 0, v = surf->verts; j < surf->numVerts; j++, v++)
{
vec3_t tmpVert;
md5Weight_t *w;
VectorClear(tmpVert);
for (k = 0, w = v->weights[0]; k < v->numWeights; k++, w++)
{
vec3_t offsetVec;
bone = &md5->bones[w->boneIndex];
QuatTransformVector(bone->rotation, w->offset, offsetVec);
VectorAdd(bone->origin, offsetVec, offsetVec);
VectorMA(tmpVert, w->boneWeight, offsetVec, tmpVert);
}
VectorCopy(tmpVert, v->position);
AddPointToBounds(tmpVert, md5->bounds[0], md5->bounds[1]);
}
// calc tangent spaces
#if 1
{
const float *v0, *v1, *v2;
const float *t0, *t1, *t2;
vec3_t tangent;
vec3_t binormal;
vec3_t normal;
for (j = 0, v = surf->verts; j < surf->numVerts; j++, v++)
{
VectorClear(v->tangent);
VectorClear(v->binormal);
VectorClear(v->normal);
}
for (j = 0, tri = surf->triangles; j < surf->numTriangles; j++, tri++)
{
v0 = surf->verts[tri->indexes[0]].position;
v1 = surf->verts[tri->indexes[1]].position;
v2 = surf->verts[tri->indexes[2]].position;
t0 = surf->verts[tri->indexes[0]].texCoords;
t1 = surf->verts[tri->indexes[1]].texCoords;
t2 = surf->verts[tri->indexes[2]].texCoords;
#if 1
R_CalcTangentSpace(tangent, binormal, normal, v0, v1, v2, t0, t1, t2);
#else
R_CalcNormalForTriangle(normal, v0, v1, v2);
R_CalcTangentsForTriangle(tangent, binormal, v0, v1, v2, t0, t1, t2);
#endif
for (k = 0; k < 3; k++)
{
float *v;
v = surf->verts[tri->indexes[k]].tangent;
VectorAdd(v, tangent, v);
v = surf->verts[tri->indexes[k]].binormal;
VectorAdd(v, binormal, v);
v = surf->verts[tri->indexes[k]].normal;
VectorAdd(v, normal, v);
}
}
for (j = 0, v = surf->verts; j < surf->numVerts; j++, v++)
{
VectorNormalize(v->tangent);
VectorNormalize(v->binormal);
VectorNormalize(v->normal);
}
}
#else
{
int k;
float bb, s, t;
vec3_t bary;
vec3_t faceNormal;
md5Vertex_t *dv[3];
for (j = 0, tri = surf->triangles; j < surf->numTriangles; j++, tri++)
{
dv[0] = &surf->verts[tri->indexes[0]];
dv[1] = &surf->verts[tri->indexes[1]];
dv[2] = &surf->verts[tri->indexes[2]];
R_CalcNormalForTriangle(faceNormal, dv[0]->position, dv[1]->position, dv[2]->position);
// calculate barycentric basis for the triangle
bb = (dv[1]->texCoords[0] - dv[0]->texCoords[0]) * (dv[2]->texCoords[1] - dv[0]->texCoords[1]) - (dv[2]->texCoords[0] - dv[0]->texCoords[0]) * (dv[1]->texCoords[1] -
dv[0]->texCoords[1]);
if (fabs(bb) < 0.00000001f)
{
continue;
}
// do each vertex
for (k = 0; k < 3; k++)
{
// calculate s tangent vector
s = dv[k]->texCoords[0] + 10.0f;
t = dv[k]->texCoords[1];
bary[0] = ((dv[1]->texCoords[0] - s) * (dv[2]->texCoords[1] - t) - (dv[2]->texCoords[0] - s) * (dv[1]->texCoords[1] - t)) / bb;
bary[1] = ((dv[2]->texCoords[0] - s) * (dv[0]->texCoords[1] - t) - (dv[0]->texCoords[0] - s) * (dv[2]->texCoords[1] - t)) / bb;
bary[2] = ((dv[0]->texCoords[0] - s) * (dv[1]->texCoords[1] - t) - (dv[1]->texCoords[0] - s) * (dv[0]->texCoords[1] - t)) / bb;
dv[k]->tangent[0] = bary[0] * dv[0]->position[0] + bary[1] * dv[1]->position[0] + bary[2] * dv[2]->position[0];
dv[k]->tangent[1] = bary[0] * dv[0]->position[1] + bary[1] * dv[1]->position[1] + bary[2] * dv[2]->position[1];
dv[k]->tangent[2] = bary[0] * dv[0]->position[2] + bary[1] * dv[1]->position[2] + bary[2] * dv[2]->position[2];
VectorSubtract(dv[k]->tangent, dv[k]->position, dv[k]->tangent);
VectorNormalize(dv[k]->tangent);
// calculate t tangent vector (binormal)
s = dv[k]->texCoords[0];
t = dv[k]->texCoords[1] + 10.0f;
bary[0] = ((dv[1]->texCoords[0] - s) * (dv[2]->texCoords[1] - t) - (dv[2]->texCoords[0] - s) * (dv[1]->texCoords[1] - t)) / bb;
bary[1] = ((dv[2]->texCoords[0] - s) * (dv[0]->texCoords[1] - t) - (dv[0]->texCoords[0] - s) * (dv[2]->texCoords[1] - t)) / bb;
bary[2] = ((dv[0]->texCoords[0] - s) * (dv[1]->texCoords[1] - t) - (dv[1]->texCoords[0] - s) * (dv[0]->texCoords[1] - t)) / bb;
dv[k]->binormal[0] = bary[0] * dv[0]->position[0] + bary[1] * dv[1]->position[0] + bary[2] * dv[2]->position[0];
dv[k]->binormal[1] = bary[0] * dv[0]->position[1] + bary[1] * dv[1]->position[1] + bary[2] * dv[2]->position[1];
dv[k]->binormal[2] = bary[0] * dv[0]->position[2] + bary[1] * dv[1]->position[2] + bary[2] * dv[2]->position[2];
VectorSubtract(dv[k]->binormal, dv[k]->position, dv[k]->binormal);
VectorNormalize(dv[k]->binormal);
// calculate the normal as cross product N=TxB
#if 0
CrossProduct(dv[k]->tangent, dv[k]->binormal, dv[k]->normal);
VectorNormalize(dv[k]->normal);
// Gram-Schmidt orthogonalization process for B
// compute the cross product B=NxT to obtain
// an orthogonal basis
CrossProduct(dv[k]->normal, dv[k]->tangent, dv[k]->binormal);
if (DotProduct(dv[k]->normal, faceNormal) < 0)
{
VectorInverse(dv[k]->normal);
//VectorInverse(dv[k]->tangent);
//VectorInverse(dv[k]->binormal);
}
#else
VectorAdd(dv[k]->normal, faceNormal, dv[k]->normal);
#endif
}
}
#if 1
for (j = 0, v = surf->verts; j < surf->numVerts; j++, v++)
{
//VectorNormalize(v->tangent);
//VectorNormalize(v->binormal);
VectorNormalize(v->normal);
}
#endif
}
#endif
#if 0
// do another extra smoothing for normals to avoid flat shading
for (j = 0; j < surf->numVerts; j++)
{
for (k = 0; k < surf->numVerts; k++)
{
if (j == k)
{
continue;
}
if (VectorCompare(surf->verts[j].position, surf->verts[k].position))
{
VectorAdd(surf->verts[j].normal, surf->verts[k].normal, surf->verts[j].normal);
}
}
VectorNormalize(surf->verts[j].normal);
}
#endif
}
// split the surfaces into VBO surfaces by the maximum number of GPU vertex skinning bones
Com_InitGrowList(&vboSurfaces, 10);
for (i = 0, surf = md5->surfaces; i < md5->numSurfaces; i++, surf++)
{
// sort triangles
Com_InitGrowList(&sortedTriangles, 1000);
for (j = 0, tri = surf->triangles; j < surf->numTriangles; j++, tri++)
{
skelTriangle_t *sortTri = Com_Allocate(sizeof(*sortTri));
for (k = 0; k < 3; k++)
{
sortTri->indexes[k] = tri->indexes[k];
sortTri->vertexes[k] = &surf->verts[tri->indexes[k]];
}
sortTri->referenced = qfalse;
Com_AddToGrowList(&sortedTriangles, sortTri);
}
//qsort(sortedTriangles.elements, sortedTriangles.currentElements, sizeof(void *), CompareTrianglesByBoneReferences);
#if 0
for (j = 0; j < sortedTriangles.currentElements; j++)
{
int b[MAX_WEIGHTS * 3];
skelTriangle_t *sortTri = Com_GrowListElement(&sortedTriangles, j);
for (k = 0; k < 3; k++)
{
v = sortTri->vertexes[k];
for (l = 0; l < MAX_WEIGHTS; l++)
{
b[k * 3 + l] = (l < v->numWeights) ? v->weights[l]->boneIndex : 9999;
}
qsort(b, MAX_WEIGHTS * 3, sizeof(int), CompareBoneIndices);
//Ren_Print("bone indices: %i %i %i %i\n", b[k * 3 + 0], b[k * 3 + 1], b[k * 3 + 2], b[k * 3 + 3]);
}
}
#endif
numRemaining = sortedTriangles.currentElements;
while (numRemaining)
{
numBoneReferences = 0;
Com_Memset(boneReferences, 0, sizeof(boneReferences));
Com_InitGrowList(&vboTriangles, 1000);
for (j = 0; j < sortedTriangles.currentElements; j++)
{
skelTriangle_t *sortTri = Com_GrowListElement(&sortedTriangles, j);
if (sortTri->referenced)
{
continue;
}
if (AddTriangleToVBOTriangleList(&vboTriangles, sortTri, &numBoneReferences, boneReferences))
{
sortTri->referenced = qtrue;
}
}
if (!vboTriangles.currentElements)
{
Ren_Warning("R_LoadMD5: could not add triangles to a remaining VBO surfaces for model '%s'\n", modName);
Com_DestroyGrowList(&vboTriangles);
break;
}
AddSurfaceToVBOSurfacesList(&vboSurfaces, &vboTriangles, md5, surf, i, numBoneReferences, boneReferences);
numRemaining -= vboTriangles.currentElements;
Com_DestroyGrowList(&vboTriangles);
}
for (j = 0; j < sortedTriangles.currentElements; j++)
{
skelTriangle_t *sortTri = Com_GrowListElement(&sortedTriangles, j);
Com_Dealloc(sortTri);
}
Com_DestroyGrowList(&sortedTriangles);
}
// move VBO surfaces list to hunk
md5->numVBOSurfaces = vboSurfaces.currentElements;
md5->vboSurfaces = ri.Hunk_Alloc(md5->numVBOSurfaces * sizeof(*md5->vboSurfaces), h_low);
for (i = 0; i < md5->numVBOSurfaces; i++)
{
md5->vboSurfaces[i] = ( srfVBOMD5Mesh_t * ) Com_GrowListElement(&vboSurfaces, i);
}
Com_DestroyGrowList(&vboSurfaces);
return qtrue;
}
/*
================
CreateRotationMatrix
================
*/
void CreateRotationMatrix(const vec3_t angles, matrix3_t matrix) {
AngleVectors(angles, matrix[0], matrix[1], matrix[2]);
VectorInverse(matrix[1]);
}
void CStudioModelRenderer::StudioSetUpTransform(int trivial_accept)
{
int i;
vec3_t angles;
vec3_t modelpos;
VectorCopy(m_pCurrentEntity->origin, modelpos);
angles[ROLL] = m_pCurrentEntity->curstate.angles[ROLL];
angles[PITCH] = m_pCurrentEntity->curstate.angles[PITCH];
angles[YAW] = m_pCurrentEntity->curstate.angles[YAW];
if (m_pCurrentEntity->curstate.movetype == MOVETYPE_STEP)
{
float f = 0;
float d;
if ((m_clTime < m_pCurrentEntity->curstate.animtime + 1.0f) && (m_pCurrentEntity->curstate.animtime != m_pCurrentEntity->latched.prevanimtime))
f = (m_clTime - m_pCurrentEntity->curstate.animtime) / (m_pCurrentEntity->curstate.animtime - m_pCurrentEntity->latched.prevanimtime);
if (m_fDoInterp)
f = f - 1.0;
else
f = 0;
for (i = 0; i < 3; i++)
modelpos[i] += (m_pCurrentEntity->origin[i] - m_pCurrentEntity->latched.prevorigin[i]) * f;
for (i = 0; i < 3; i++)
{
float ang1, ang2;
ang1 = m_pCurrentEntity->angles[i];
ang2 = m_pCurrentEntity->latched.prevangles[i];
d = ang1 - ang2;
if (d > 180)
d -= 360;
else if (d < -180)
d += 360;
angles[i] += d * f;
}
}
else if (m_pCurrentEntity->curstate.movetype != MOVETYPE_NONE)
{
VectorCopy(m_pCurrentEntity->angles, angles);
}
angles[PITCH] = -angles[PITCH];
AngleMatrix(angles, (*m_protationmatrix));
if (!IEngineStudio.IsHardware())
{
static float viewmatrix[3][4];
VectorCopy(m_vRight, viewmatrix[0]);
VectorCopy(m_vUp, viewmatrix[1]);
VectorInverse(viewmatrix[1]);
VectorCopy(m_vNormal, viewmatrix[2]);
(*m_protationmatrix)[0][3] = modelpos[0] - m_vRenderOrigin[0];
(*m_protationmatrix)[1][3] = modelpos[1] - m_vRenderOrigin[1];
(*m_protationmatrix)[2][3] = modelpos[2] - m_vRenderOrigin[2];
ConcatTransforms(viewmatrix, (*m_protationmatrix), (*m_paliastransform));
if (trivial_accept)
{
for (i = 0; i < 4; i++)
{
(*m_paliastransform)[0][i] *= m_fSoftwareXScale * (1.0 / (ZISCALE * 0x10000));
(*m_paliastransform)[1][i] *= m_fSoftwareYScale * (1.0 / (ZISCALE * 0x10000));
(*m_paliastransform)[2][i] *= 1.0 / (ZISCALE * 0x10000);
}
}
}
(*m_protationmatrix)[0][3] = modelpos[0];
(*m_protationmatrix)[1][3] = modelpos[1];
(*m_protationmatrix)[2][3] = modelpos[2];
}
qboolean R_LoadPSK(model_t *mod, void *buffer, int bufferSize, const char *modName)
{
int i, j, k;
memStream_t *stream = NULL;
axChunkHeader_t chunkHeader;
int numPoints;
axPoint_t *point;
axPoint_t *points = NULL;
int numVertexes;
axVertex_t *vertex;
axVertex_t *vertexes = NULL;
//int numSmoothGroups;
int numTriangles;
axTriangle_t *triangle;
axTriangle_t *triangles = NULL;
int numMaterials;
axMaterial_t *material;
axMaterial_t *materials = NULL;
int numReferenceBones;
axReferenceBone_t *refBone;
axReferenceBone_t *refBones = NULL;
int numWeights;
axBoneWeight_t *axWeight;
axBoneWeight_t *axWeights = NULL;
md5Model_t *md5;
md5Bone_t *md5Bone;
md5Weight_t *weight;
vec3_t boneOrigin;
quat_t boneQuat;
//mat4_t boneMat;
int materialIndex, oldMaterialIndex;
int numRemaining;
growList_t sortedTriangles;
growList_t vboVertexes;
growList_t vboTriangles;
growList_t vboSurfaces;
int numBoneReferences;
int boneReferences[MAX_BONES];
mat4_t unrealToQuake;
#define DeallocAll() Com_Dealloc(materials); \
Com_Dealloc(points); \
Com_Dealloc(vertexes); \
Com_Dealloc(triangles); \
Com_Dealloc(refBones); \
Com_Dealloc(axWeights); \
FreeMemStream(stream);
//MatrixSetupScale(unrealToQuake, 1, -1, 1);
mat4_from_angles(unrealToQuake, 0, 90, 0);
stream = AllocMemStream(buffer, bufferSize);
GetChunkHeader(stream, &chunkHeader);
// check indent again
if (Q_stricmpn(chunkHeader.ident, "ACTRHEAD", 8))
{
Ren_Warning("R_LoadPSK: '%s' has wrong chunk indent ('%s' should be '%s')\n", modName, chunkHeader.ident, "ACTRHEAD");
DeallocAll();
return qfalse;
}
PrintChunkHeader(&chunkHeader);
mod->type = MOD_MD5;
mod->dataSize += sizeof(md5Model_t);
md5 = mod->md5 = ri.Hunk_Alloc(sizeof(md5Model_t), h_low);
// read points
GetChunkHeader(stream, &chunkHeader);
if (Q_stricmpn(chunkHeader.ident, "PNTS0000", 8))
{
Ren_Warning("R_LoadPSK: '%s' has wrong chunk indent ('%s' should be '%s')\n", modName, chunkHeader.ident, "PNTS0000");
DeallocAll();
return qfalse;
}
if (chunkHeader.dataSize != sizeof(axPoint_t))
{
Ren_Warning("R_LoadPSK: '%s' has wrong chunk dataSize ('%i' should be '%i')\n", modName, chunkHeader.dataSize, ( int ) sizeof(axPoint_t));
DeallocAll();
return qfalse;
}
PrintChunkHeader(&chunkHeader);
numPoints = chunkHeader.numData;
points = Com_Allocate(numPoints * sizeof(axPoint_t));
for (i = 0, point = points; i < numPoints; i++, point++)
{
point->point[0] = MemStreamGetFloat(stream);
point->point[1] = MemStreamGetFloat(stream);
point->point[2] = MemStreamGetFloat(stream);
#if 0
// HACK convert from Unreal coordinate system to the Quake one
MatrixTransformPoint2(unrealToQuake, point->point);
#endif
}
// read vertices
GetChunkHeader(stream, &chunkHeader);
if (Q_stricmpn(chunkHeader.ident, "VTXW0000", 8))
{
Ren_Warning("R_LoadPSK: '%s' has wrong chunk indent ('%s' should be '%s')\n", modName, chunkHeader.ident, "VTXW0000");
DeallocAll();
return qfalse;
}
if (chunkHeader.dataSize != sizeof(axVertex_t))
{
Ren_Warning("R_LoadPSK: '%s' has wrong chunk dataSize ('%i' should be '%i')\n", modName, chunkHeader.dataSize, ( int ) sizeof(axVertex_t));
DeallocAll();
return qfalse;
}
PrintChunkHeader(&chunkHeader);
numVertexes = chunkHeader.numData;
vertexes = Com_Allocate(numVertexes * sizeof(axVertex_t));
{
int tmpVertexInt = -1; // tmp vertex member values - MemStreamGet functions return -1 if they fail
// now we print a warning if they do or abort if pointIndex is invalid
for (i = 0, vertex = vertexes; i < numVertexes; i++, vertex++)
{
tmpVertexInt = MemStreamGetShort(stream);
if (tmpVertexInt < 0 || tmpVertexInt >= numPoints)
{
ri.Printf(PRINT_ERROR, "R_LoadPSK: '%s' has vertex with point index out of range (%i while max %i)\n", modName, tmpVertexInt, numPoints);
DeallocAll();
return qfalse;
}
vertex->pointIndex = tmpVertexInt;
tmpVertexInt = MemStreamGetShort(stream);
if (tmpVertexInt < 0)
{
Ren_Warning("R_LoadPSK: MemStream NULL or empty (vertex->unknownA)\n");
}
vertex->unknownA = tmpVertexInt;
vertex->st[0] = MemStreamGetFloat(stream);
if (vertex->st[0] == -1)
{
Ren_Warning("R_LoadPSK: MemStream possibly NULL or empty (vertex->st[0])\n");
}
vertex->st[1] = MemStreamGetFloat(stream);
if (vertex->st[1] == -1)
{
Ren_Warning("R_LoadPSK: MemStream possibly NULL or empty (vertex->st[1])\n");
}
tmpVertexInt = MemStreamGetC(stream);
if (tmpVertexInt < 0)
{
Ren_Warning("R_LoadPSK: MemStream NULL or empty (vertex->materialIndex)\n");
}
vertex->materialIndex = tmpVertexInt;
tmpVertexInt = MemStreamGetC(stream);
if (tmpVertexInt < 0)
{
Ren_Warning("R_LoadPSK: MemStream NULL or empty (vertex->materialIndex)\n");
}
vertex->reserved = tmpVertexInt;
tmpVertexInt = MemStreamGetShort(stream);
if (tmpVertexInt < 0)
{
Ren_Warning("R_LoadPSK: MemStream NULL or empty (vertex->materialIndex)\n");
}
vertex->unknownB = tmpVertexInt;
#if 0
Ren_Print("R_LoadPSK: axVertex_t(%i):\n"
"axVertex:pointIndex: %i\n"
"axVertex:unknownA: %i\n"
"axVertex::st: %f %f\n"
"axVertex:materialIndex: %i\n"
"axVertex:reserved: %d\n"
"axVertex:unknownB: %d\n",
i,
vertex->pointIndex,
vertex->unknownA,
vertex->st[0], vertex->st[1],
vertex->materialIndex,
vertex->reserved,
vertex->unknownB);
#endif
}
// read triangles
GetChunkHeader(stream, &chunkHeader);
if (Q_stricmpn(chunkHeader.ident, "FACE0000", 8))
{
Ren_Warning("R_LoadPSK: '%s' has wrong chunk indent ('%s' should be '%s')\n", modName, chunkHeader.ident, "FACE0000");
DeallocAll();
return qfalse;
}
if (chunkHeader.dataSize != sizeof(axTriangle_t))
{
Ren_Warning("R_LoadPSK: '%s' has wrong chunk dataSize ('%i' should be '%i')\n", modName, chunkHeader.dataSize, ( int ) sizeof(axTriangle_t));
DeallocAll();
return qfalse;
}
PrintChunkHeader(&chunkHeader);
numTriangles = chunkHeader.numData;
triangles = Com_Allocate(numTriangles * sizeof(axTriangle_t));
for (i = 0, triangle = triangles; i < numTriangles; i++, triangle++)
{
for (j = 0; j < 3; j++)
//for(j = 2; j >= 0; j--)
{
tmpVertexInt = MemStreamGetShort(stream);
if (tmpVertexInt < 0)
{
Ren_Warning("R_LoadPSK: '%s' MemStream NULL or empty (triangle->indexes[%i])\n", modName, j);
DeallocAll();
return qfalse;
}
if (tmpVertexInt >= numVertexes)
{
Ren_Warning("R_LoadPSK: '%s' has triangle with vertex index out of range (%i while max %i)\n", modName, tmpVertexInt, numVertexes);
DeallocAll();
return qfalse;
}
triangle->indexes[j] = tmpVertexInt;
}
triangle->materialIndex = MemStreamGetC(stream);
triangle->materialIndex2 = MemStreamGetC(stream);
triangle->smoothingGroups = MemStreamGetLong(stream);
}
}
// read materials
GetChunkHeader(stream, &chunkHeader);
if (Q_stricmpn(chunkHeader.ident, "MATT0000", 8))
{
Ren_Warning("R_LoadPSK: '%s' has wrong chunk indent ('%s' should be '%s')\n", modName, chunkHeader.ident, "MATT0000");
DeallocAll();
return qfalse;
}
if (chunkHeader.dataSize != sizeof(axMaterial_t))
{
Ren_Warning("R_LoadPSK: '%s' has wrong chunk dataSize ('%i' should be '%i')\n", modName, chunkHeader.dataSize, ( int ) sizeof(axMaterial_t));
DeallocAll();
return qfalse;
}
PrintChunkHeader(&chunkHeader);
numMaterials = chunkHeader.numData;
materials = Com_Allocate(numMaterials * sizeof(axMaterial_t));
for (i = 0, material = materials; i < numMaterials; i++, material++)
{
MemStreamRead(stream, material->name, sizeof(material->name));
Ren_Print("R_LoadPSK: material name: '%s'\n", material->name);
material->shaderIndex = MemStreamGetLong(stream);
material->polyFlags = MemStreamGetLong(stream);
material->auxMaterial = MemStreamGetLong(stream);
material->auxFlags = MemStreamGetLong(stream);
material->lodBias = MemStreamGetLong(stream);
material->lodStyle = MemStreamGetLong(stream);
}
for (i = 0, vertex = vertexes; i < numVertexes; i++, vertex++)
{
if (vertex->materialIndex < 0 || vertex->materialIndex >= numMaterials)
{
Ren_Warning("R_LoadPSK: '%s' has vertex with material index out of range (%i while max %i)\n", modName, vertex->materialIndex, numMaterials);
DeallocAll();
return qfalse;
}
}
for (i = 0, triangle = triangles; i < numTriangles; i++, triangle++)
{
if (triangle->materialIndex < 0 || triangle->materialIndex >= numMaterials)
{
Ren_Warning("R_LoadPSK: '%s' has triangle with material index out of range (%i while max %i)\n", modName, triangle->materialIndex, numMaterials);
DeallocAll();
return qfalse;
}
}
// read reference bones
GetChunkHeader(stream, &chunkHeader);
if (Q_stricmpn(chunkHeader.ident, "REFSKELT", 8))
{
Ren_Warning("R_LoadPSK: '%s' has wrong chunk indent ('%s' should be '%s')\n", modName, chunkHeader.ident, "REFSKELT");
DeallocAll();
return qfalse;
}
if (chunkHeader.dataSize != sizeof(axReferenceBone_t))
{
Ren_Warning("R_LoadPSK: '%s' has wrong chunk dataSize ('%i' should be '%i')\n", modName, chunkHeader.dataSize, ( int ) sizeof(axReferenceBone_t));
DeallocAll();
return qfalse;
}
PrintChunkHeader(&chunkHeader);
numReferenceBones = chunkHeader.numData;
refBones = Com_Allocate(numReferenceBones * sizeof(axReferenceBone_t));
for (i = 0, refBone = refBones; i < numReferenceBones; i++, refBone++)
{
MemStreamRead(stream, refBone->name, sizeof(refBone->name));
//Ren_Print("R_LoadPSK: reference bone name: '%s'\n", refBone->name);
refBone->flags = MemStreamGetLong(stream);
refBone->numChildren = MemStreamGetLong(stream);
refBone->parentIndex = MemStreamGetLong(stream);
GetBone(stream, &refBone->bone);
#if 0
Ren_Print("R_LoadPSK: axReferenceBone_t(%i):\n"
"axReferenceBone_t::name: '%s'\n"
"axReferenceBone_t::flags: %i\n"
"axReferenceBone_t::numChildren %i\n"
"axReferenceBone_t::parentIndex: %i\n"
"axReferenceBone_t::quat: %f %f %f %f\n"
"axReferenceBone_t::position: %f %f %f\n"
"axReferenceBone_t::length: %f\n"
"axReferenceBone_t::xSize: %f\n"
"axReferenceBone_t::ySize: %f\n"
"axReferenceBone_t::zSize: %f\n",
i,
refBone->name,
refBone->flags,
refBone->numChildren,
refBone->parentIndex,
refBone->bone.quat[0], refBone->bone.quat[1], refBone->bone.quat[2], refBone->bone.quat[3],
refBone->bone.position[0], refBone->bone.position[1], refBone->bone.position[2],
refBone->bone.length,
refBone->bone.xSize,
refBone->bone.ySize,
refBone->bone.zSize);
#endif
}
// read bone weights
GetChunkHeader(stream, &chunkHeader);
if (Q_stricmpn(chunkHeader.ident, "RAWWEIGHTS", 10))
{
Ren_Warning("R_LoadPSK: '%s' has wrong chunk indent ('%s' should be '%s')\n", modName, chunkHeader.ident, "RAWWEIGHTS");
DeallocAll();
return qfalse;
}
if (chunkHeader.dataSize != sizeof(axBoneWeight_t))
{
Ren_Warning("R_LoadPSK: '%s' has wrong chunk dataSize ('%i' should be '%i')\n", modName, chunkHeader.dataSize, ( int ) sizeof(axBoneWeight_t));
DeallocAll();
return qfalse;
}
PrintChunkHeader(&chunkHeader);
numWeights = chunkHeader.numData;
axWeights = Com_Allocate(numWeights * sizeof(axBoneWeight_t));
for (i = 0, axWeight = axWeights; i < numWeights; i++, axWeight++)
{
axWeight->weight = MemStreamGetFloat(stream);
axWeight->pointIndex = MemStreamGetLong(stream);
axWeight->boneIndex = MemStreamGetLong(stream);
#if 0
Ren_Print("R_LoadPSK: axBoneWeight_t(%i):\n"
"axBoneWeight_t::weight: %f\n"
"axBoneWeight_t::pointIndex %i\n"
"axBoneWeight_t::boneIndex: %i\n",
i,
axWeight->weight,
axWeight->pointIndex,
axWeight->boneIndex);
#endif
}
//
// convert the model to an internal MD5 representation
//
md5->numBones = numReferenceBones;
// calc numMeshes <number>
/*
numSmoothGroups = 0;
for(i = 0, triangle = triangles; i < numTriangles; i++, triangle++)
{
if(triangle->smoothingGroups)
{
}
}
*/
if (md5->numBones < 1)
{
Ren_Warning("R_LoadPSK: '%s' has no bones\n", modName);
DeallocAll();
return qfalse;
}
if (md5->numBones > MAX_BONES)
{
Ren_Warning("R_LoadPSK: '%s' has more than %i bones (%i)\n", modName, MAX_BONES, md5->numBones);
DeallocAll();
return qfalse;
}
//Ren_Print("R_LoadPSK: '%s' has %i bones\n", modName, md5->numBones);
// copy all reference bones
md5->bones = ri.Hunk_Alloc(sizeof(*md5Bone) * md5->numBones, h_low);
for (i = 0, md5Bone = md5->bones, refBone = refBones; i < md5->numBones; i++, md5Bone++, refBone++)
{
Q_strncpyz(md5Bone->name, refBone->name, sizeof(md5Bone->name));
if (i == 0)
{
md5Bone->parentIndex = refBone->parentIndex - 1;
}
else
{
md5Bone->parentIndex = refBone->parentIndex;
}
//Ren_Print("R_LoadPSK: '%s' has bone '%s' with parent index %i\n", modName, md5Bone->name, md5Bone->parentIndex);
if (md5Bone->parentIndex >= md5->numBones)
{
DeallocAll();
Ren_Drop("R_LoadPSK: '%s' has bone '%s' with bad parent index %i while numBones is %i", modName,
md5Bone->name, md5Bone->parentIndex, md5->numBones);
}
for (j = 0; j < 3; j++)
{
boneOrigin[j] = refBone->bone.position[j];
}
// I have really no idea why the .psk format stores the first quaternion with inverted quats.
// Furthermore only the X and Z components of the first quat are inverted ?!?!
if (i == 0)
{
boneQuat[0] = refBone->bone.quat[0];
boneQuat[1] = -refBone->bone.quat[1];
boneQuat[2] = refBone->bone.quat[2];
boneQuat[3] = refBone->bone.quat[3];
}
else
{
boneQuat[0] = -refBone->bone.quat[0];
boneQuat[1] = -refBone->bone.quat[1];
boneQuat[2] = -refBone->bone.quat[2];
boneQuat[3] = refBone->bone.quat[3];
}
VectorCopy(boneOrigin, md5Bone->origin);
//MatrixTransformPoint(unrealToQuake, boneOrigin, md5Bone->origin);
quat_copy(boneQuat, md5Bone->rotation);
//QuatClear(md5Bone->rotation);
#if 0
Ren_Print("R_LoadPSK: md5Bone_t(%i):\n"
"md5Bone_t::name: '%s'\n"
"md5Bone_t::parentIndex: %i\n"
"md5Bone_t::quat: %f %f %f %f\n"
"md5bone_t::position: %f %f %f\n",
i,
md5Bone->name,
md5Bone->parentIndex,
md5Bone->rotation[0], md5Bone->rotation[1], md5Bone->rotation[2], md5Bone->rotation[3],
md5Bone->origin[0], md5Bone->origin[1], md5Bone->origin[2]);
#endif
if (md5Bone->parentIndex >= 0)
{
vec3_t rotated;
quat_t quat;
md5Bone_t *parent;
parent = &md5->bones[md5Bone->parentIndex];
QuatTransformVector(parent->rotation, md5Bone->origin, rotated);
//QuatTransformVector(md5Bone->rotation, md5Bone->origin, rotated);
VectorAdd(parent->origin, rotated, md5Bone->origin);
QuatMultiply1(parent->rotation, md5Bone->rotation, quat);
quat_copy(quat, md5Bone->rotation);
}
MatrixSetupTransformFromQuat(md5Bone->inverseTransform, md5Bone->rotation, md5Bone->origin);
mat4_inverse_self(md5Bone->inverseTransform);
#if 0
Ren_Print("R_LoadPSK: md5Bone_t(%i):\n"
"md5Bone_t::name: '%s'\n"
"md5Bone_t::parentIndex: %i\n"
"md5Bone_t::quat: %f %f %f %f\n"
"md5bone_t::position: %f %f %f\n",
i,
md5Bone->name,
md5Bone->parentIndex,
md5Bone->rotation[0], md5Bone->rotation[1], md5Bone->rotation[2], md5Bone->rotation[3],
md5Bone->origin[0], md5Bone->origin[1], md5Bone->origin[2]);
#endif
}
Com_InitGrowList(&vboVertexes, 10000);
for (i = 0, vertex = vertexes; i < numVertexes; i++, vertex++)
{
md5Vertex_t *vboVert = Com_Allocate(sizeof(*vboVert));
for (j = 0; j < 3; j++)
{
vboVert->position[j] = points[vertex->pointIndex].point[j];
}
vboVert->texCoords[0] = vertex->st[0];
vboVert->texCoords[1] = vertex->st[1];
// find number of associated weights
vboVert->numWeights = 0;
for (j = 0, axWeight = axWeights; j < numWeights; j++, axWeight++)
{
if (axWeight->pointIndex == vertex->pointIndex && axWeight->weight > 0.0f)
{
vboVert->numWeights++;
}
}
if (vboVert->numWeights > MAX_WEIGHTS)
{
DeallocAll();
Ren_Drop("R_LoadPSK: vertex %i requires more weights %i than the maximum of %i in model '%s'", i, vboVert->numWeights, MAX_WEIGHTS, modName);
//Ren_Warning( "R_LoadPSK: vertex %i requires more weights %i than the maximum of %i in model '%s'\n", i, vboVert->numWeights, MAX_WEIGHTS, modName);
}
vboVert->weights = ri.Hunk_Alloc(sizeof(*vboVert->weights) * vboVert->numWeights, h_low);
for (j = 0, axWeight = axWeights, k = 0; j < numWeights; j++, axWeight++)
{
if (axWeight->pointIndex == vertex->pointIndex && axWeight->weight > 0.0f)
{
weight = ri.Hunk_Alloc(sizeof(*weight), h_low);
weight->boneIndex = axWeight->boneIndex;
weight->boneWeight = axWeight->weight;
// FIXME?
weight->offset[0] = refBones[axWeight->boneIndex].bone.xSize;
weight->offset[1] = refBones[axWeight->boneIndex].bone.ySize;
weight->offset[2] = refBones[axWeight->boneIndex].bone.zSize;
vboVert->weights[k++] = weight;
}
}
Com_AddToGrowList(&vboVertexes, vboVert);
}
ClearBounds(md5->bounds[0], md5->bounds[1]);
for (i = 0, vertex = vertexes; i < numVertexes; i++, vertex++)
{
AddPointToBounds(points[vertex->pointIndex].point, md5->bounds[0], md5->bounds[1]);
}
#if 0
Ren_Print("R_LoadPSK: AABB (%i %i %i) (%i %i %i)\n",
( int ) md5->bounds[0][0],
( int ) md5->bounds[0][1],
( int ) md5->bounds[0][2],
( int ) md5->bounds[1][0],
( int ) md5->bounds[1][1],
( int ) md5->bounds[1][2]);
#endif
// sort triangles
qsort(triangles, numTriangles, sizeof(axTriangle_t), CompareTrianglesByMaterialIndex);
Com_InitGrowList(&sortedTriangles, 1000);
for (i = 0, triangle = triangles; i < numTriangles; i++, triangle++)
{
skelTriangle_t *sortTri = Com_Allocate(sizeof(*sortTri));
for (j = 0; j < 3; j++)
{
sortTri->indexes[j] = triangle->indexes[j];
sortTri->vertexes[j] = Com_GrowListElement(&vboVertexes, triangle->indexes[j]);
}
sortTri->referenced = qfalse;
Com_AddToGrowList(&sortedTriangles, sortTri);
}
// calc tangent spaces
#if 1
{
md5Vertex_t *v0, *v1, *v2;
const float *p0, *p1, *p2;
const float *t0, *t1, *t2;
vec3_t tangent = { 0, 0, 0 };
vec3_t binormal;
vec3_t normal;
for (j = 0; j < vboVertexes.currentElements; j++)
{
v0 = Com_GrowListElement(&vboVertexes, j);
VectorClear(v0->tangent);
VectorClear(v0->binormal);
VectorClear(v0->normal);
}
for (j = 0; j < sortedTriangles.currentElements; j++)
{
skelTriangle_t *tri = Com_GrowListElement(&sortedTriangles, j);
v0 = Com_GrowListElement(&vboVertexes, tri->indexes[0]);
v1 = Com_GrowListElement(&vboVertexes, tri->indexes[1]);
v2 = Com_GrowListElement(&vboVertexes, tri->indexes[2]);
p0 = v0->position;
p1 = v1->position;
p2 = v2->position;
t0 = v0->texCoords;
t1 = v1->texCoords;
t2 = v2->texCoords;
#if 1
R_CalcTangentSpace(tangent, binormal, normal, p0, p1, p2, t0, t1, t2);
#else
R_CalcNormalForTriangle(normal, p0, p1, p2);
R_CalcTangentsForTriangle(tangent, binormal, p0, p1, p2, t0, t1, t2);
#endif
for (k = 0; k < 3; k++)
{
float *v;
v0 = Com_GrowListElement(&vboVertexes, tri->indexes[k]);
v = v0->tangent;
VectorAdd(v, tangent, v);
v = v0->binormal;
VectorAdd(v, binormal, v);
v = v0->normal;
VectorAdd(v, normal, v);
}
}
for (j = 0; j < vboVertexes.currentElements; j++)
{
v0 = Com_GrowListElement(&vboVertexes, j);
VectorNormalize(v0->tangent);
VectorNormalize(v0->binormal);
VectorNormalize(v0->normal);
}
}
#else
{
float bb, s, t;
vec3_t bary;
vec3_t faceNormal;
md5Vertex_t *dv[3];
for (j = 0; j < sortedTriangles.currentElements; j++)
{
skelTriangle_t *tri = Com_GrowListElement(&sortedTriangles, j);
dv[0] = Com_GrowListElement(&vboVertexes, tri->indexes[0]);
dv[1] = Com_GrowListElement(&vboVertexes, tri->indexes[1]);
dv[2] = Com_GrowListElement(&vboVertexes, tri->indexes[2]);
R_CalcNormalForTriangle(faceNormal, dv[0]->position, dv[1]->position, dv[2]->position);
// calculate barycentric basis for the triangle
bb = (dv[1]->texCoords[0] - dv[0]->texCoords[0]) * (dv[2]->texCoords[1] - dv[0]->texCoords[1]) - (dv[2]->texCoords[0] - dv[0]->texCoords[0]) * (dv[1]->texCoords[1] -
dv[0]->texCoords[1]);
if (fabs(bb) < 0.00000001f)
{
continue;
}
// do each vertex
for (k = 0; k < 3; k++)
{
// calculate s tangent vector
s = dv[k]->texCoords[0] + 10.0f;
t = dv[k]->texCoords[1];
bary[0] = ((dv[1]->texCoords[0] - s) * (dv[2]->texCoords[1] - t) - (dv[2]->texCoords[0] - s) * (dv[1]->texCoords[1] - t)) / bb;
bary[1] = ((dv[2]->texCoords[0] - s) * (dv[0]->texCoords[1] - t) - (dv[0]->texCoords[0] - s) * (dv[2]->texCoords[1] - t)) / bb;
bary[2] = ((dv[0]->texCoords[0] - s) * (dv[1]->texCoords[1] - t) - (dv[1]->texCoords[0] - s) * (dv[0]->texCoords[1] - t)) / bb;
dv[k]->tangent[0] = bary[0] * dv[0]->position[0] + bary[1] * dv[1]->position[0] + bary[2] * dv[2]->position[0];
dv[k]->tangent[1] = bary[0] * dv[0]->position[1] + bary[1] * dv[1]->position[1] + bary[2] * dv[2]->position[1];
dv[k]->tangent[2] = bary[0] * dv[0]->position[2] + bary[1] * dv[1]->position[2] + bary[2] * dv[2]->position[2];
VectorSubtract(dv[k]->tangent, dv[k]->position, dv[k]->tangent);
VectorNormalize(dv[k]->tangent);
// calculate t tangent vector (binormal)
s = dv[k]->texCoords[0];
t = dv[k]->texCoords[1] + 10.0f;
bary[0] = ((dv[1]->texCoords[0] - s) * (dv[2]->texCoords[1] - t) - (dv[2]->texCoords[0] - s) * (dv[1]->texCoords[1] - t)) / bb;
bary[1] = ((dv[2]->texCoords[0] - s) * (dv[0]->texCoords[1] - t) - (dv[0]->texCoords[0] - s) * (dv[2]->texCoords[1] - t)) / bb;
bary[2] = ((dv[0]->texCoords[0] - s) * (dv[1]->texCoords[1] - t) - (dv[1]->texCoords[0] - s) * (dv[0]->texCoords[1] - t)) / bb;
dv[k]->binormal[0] = bary[0] * dv[0]->position[0] + bary[1] * dv[1]->position[0] + bary[2] * dv[2]->position[0];
dv[k]->binormal[1] = bary[0] * dv[0]->position[1] + bary[1] * dv[1]->position[1] + bary[2] * dv[2]->position[1];
dv[k]->binormal[2] = bary[0] * dv[0]->position[2] + bary[1] * dv[1]->position[2] + bary[2] * dv[2]->position[2];
VectorSubtract(dv[k]->binormal, dv[k]->position, dv[k]->binormal);
VectorNormalize(dv[k]->binormal);
// calculate the normal as cross product N=TxB
#if 0
CrossProduct(dv[k]->tangent, dv[k]->binormal, dv[k]->normal);
VectorNormalize(dv[k]->normal);
// Gram-Schmidt orthogonalization process for B
// compute the cross product B=NxT to obtain
// an orthogonal basis
CrossProduct(dv[k]->normal, dv[k]->tangent, dv[k]->binormal);
if (DotProduct(dv[k]->normal, faceNormal) < 0)
{
VectorInverse(dv[k]->normal);
//VectorInverse(dv[k]->tangent);
//VectorInverse(dv[k]->binormal);
}
#else
VectorAdd(dv[k]->normal, faceNormal, dv[k]->normal);
#endif
}
}
#if 1
for (j = 0; j < vboVertexes.currentElements; j++)
{
dv[0] = Com_GrowListElement(&vboVertexes, j);
//VectorNormalize(dv[0]->tangent);
//VectorNormalize(dv[0]->binormal);
VectorNormalize(dv[0]->normal);
}
#endif
}
#endif
#if 0
{
md5Vertex_t *v0, *v1;
// do another extra smoothing for normals to avoid flat shading
for (j = 0; j < vboVertexes.currentElements; j++)
{
v0 = Com_GrowListElement(&vboVertexes, j);
for (k = 0; k < vboVertexes.currentElements; k++)
{
if (j == k)
{
continue;
}
v1 = Com_GrowListElement(&vboVertexes, k);
if (VectorCompare(v0->position, v1->position))
{
VectorAdd(v0->position, v1->normal, v0->normal);
}
}
VectorNormalize(v0->normal);
}
}
#endif
// split the surfaces into VBO surfaces by the maximum number of GPU vertex skinning bones
Com_InitGrowList(&vboSurfaces, 10);
materialIndex = oldMaterialIndex = -1;
for (i = 0; i < numTriangles; i++)
{
triangle = &triangles[i];
materialIndex = triangle->materialIndex;
if (materialIndex != oldMaterialIndex)
{
oldMaterialIndex = materialIndex;
numRemaining = sortedTriangles.currentElements - i;
while (numRemaining)
{
numBoneReferences = 0;
Com_Memset(boneReferences, 0, sizeof(boneReferences));
Com_InitGrowList(&vboTriangles, 1000);
for (j = i; j < sortedTriangles.currentElements; j++)
{
skelTriangle_t *sortTri;
triangle = &triangles[j];
materialIndex = triangle->materialIndex;
if (materialIndex != oldMaterialIndex)
{
continue;
}
sortTri = Com_GrowListElement(&sortedTriangles, j);
if (sortTri->referenced)
{
continue;
}
if (AddTriangleToVBOTriangleList(&vboTriangles, sortTri, &numBoneReferences, boneReferences))
{
sortTri->referenced = qtrue;
}
}
for (j = 0; j < MAX_BONES; j++)
{
if (boneReferences[j] > 0)
{
Ren_Print("R_LoadPSK: referenced bone: '%s'\n", (j < numReferenceBones) ? refBones[j].name : NULL);
}
}
if (!vboTriangles.currentElements)
{
Ren_Warning("R_LoadPSK: could not add triangles to a remaining VBO surface for model '%s'\n", modName);
break;
}
// FIXME skinIndex
AddSurfaceToVBOSurfacesList2(&vboSurfaces, &vboTriangles, &vboVertexes, md5, vboSurfaces.currentElements, materials[oldMaterialIndex].name, numBoneReferences, boneReferences);
numRemaining -= vboTriangles.currentElements;
Com_DestroyGrowList(&vboTriangles);
}
}
}
for (j = 0; j < sortedTriangles.currentElements; j++)
{
skelTriangle_t *sortTri = Com_GrowListElement(&sortedTriangles, j);
Com_Dealloc(sortTri);
}
Com_DestroyGrowList(&sortedTriangles);
for (j = 0; j < vboVertexes.currentElements; j++)
{
md5Vertex_t *v = Com_GrowListElement(&vboVertexes, j);
Com_Dealloc(v);
}
Com_DestroyGrowList(&vboVertexes);
// move VBO surfaces list to hunk
md5->numVBOSurfaces = vboSurfaces.currentElements;
md5->vboSurfaces = ri.Hunk_Alloc(md5->numVBOSurfaces * sizeof(*md5->vboSurfaces), h_low);
for (i = 0; i < md5->numVBOSurfaces; i++)
{
md5->vboSurfaces[i] = ( srfVBOMD5Mesh_t * ) Com_GrowListElement(&vboSurfaces, i);
}
Com_DestroyGrowList(&vboSurfaces);
FreeMemStream(stream);
Com_Dealloc(points);
Com_Dealloc(vertexes);
Com_Dealloc(triangles);
Com_Dealloc(materials);
Ren_Developer("%i VBO surfaces created for PSK model '%s'\n", md5->numVBOSurfaces, modName);
return qtrue;
}
int R_MarkFragmentsWolf( int orientation, const vec3_t* points, const vec3_t projection,
int maxPoints, vec3_t pointBuffer, int maxFragments, markFragment_t* fragmentBuffer ) {
int numPlanes;
int i;
vec3_t mins, maxs;
int returnedFragments;
int returnedPoints;
vec3_t normals[ MAX_VERTS_ON_POLY + 2 ];
float dists[ MAX_VERTS_ON_POLY + 2 ];
vec3_t projectionDir;
vec3_t v1, v2;
float radius;
vec3_t center; // center of original mark
int numPoints = 4; // Ridah, we were only ever passing in 4, so I made this local and used the parameter for the orientation
qboolean oldMapping = false;
//increment view count for double check prevention
tr.viewCount++;
// RF, negative maxFragments means we want original mapping
if ( maxFragments < 0 ) {
maxFragments = -maxFragments;
oldMapping = true;
}
VectorClear( center );
for ( i = 0; i < numPoints; i++ ) {
VectorAdd( points[ i ], center, center );
}
VectorScale( center, 1.0 / numPoints, center );
//
radius = VectorNormalize2( projection, projectionDir ) / 2.0;
vec3_t bestnormal;
VectorNegate( projectionDir, bestnormal );
// find all the brushes that are to be considered
ClearBounds( mins, maxs );
for ( i = 0; i < numPoints; i++ ) {
vec3_t temp;
AddPointToBounds( points[ i ], mins, maxs );
VectorMA( points[ i ], 1 * ( 1 + oldMapping * radius * 4 ), projection, temp );
AddPointToBounds( temp, mins, maxs );
// make sure we get all the leafs (also the one(s) in front of the hit surface)
VectorMA( points[ i ], -20 * ( 1.0 + ( float )oldMapping * ( radius / 20.0 ) * 4 ), projectionDir, temp );
AddPointToBounds( temp, mins, maxs );
}
if ( numPoints > MAX_VERTS_ON_POLY ) {
numPoints = MAX_VERTS_ON_POLY;
}
// create the bounding planes for the to be projected polygon
for ( i = 0; i < numPoints; i++ ) {
VectorSubtract( points[ ( i + 1 ) % numPoints ], points[ i ], v1 );
VectorAdd( points[ i ], projection, v2 );
VectorSubtract( points[ i ], v2, v2 );
CrossProduct( v1, v2, normals[ i ] );
VectorNormalize( normals[ i ] );
dists[ i ] = DotProduct( normals[ i ], points[ i ] );
}
// add near and far clipping planes for projection
VectorCopy( projectionDir, normals[ numPoints ] );
dists[ numPoints ] = DotProduct( normals[ numPoints ], points[ 0 ] ) - radius * ( 1 + oldMapping * 10 );
VectorCopy( projectionDir, normals[ numPoints + 1 ] );
VectorInverse( normals[ numPoints + 1 ] );
dists[ numPoints + 1 ] = DotProduct( normals[ numPoints + 1 ], points[ 0 ] ) - radius * ( 1 + oldMapping * 10 );
numPlanes = numPoints + 2;
int numsurfaces = 0;
idWorldSurface* surfaces[ 4096 ];
R_BoxSurfaces_r( tr.world->nodes, mins, maxs, surfaces, 4096, &numsurfaces, projectionDir );
returnedPoints = 0;
returnedFragments = 0;
// find the closest surface to center the decal there, and wrap around other surfaces
if ( !oldMapping ) {
VectorNegate( bestnormal, bestnormal );
}
for ( i = 0; i < numsurfaces; i++ ) {
surfaces[ i ]->MarkFragmentsWolf( projectionDir,
numPlanes, normals, dists,
maxPoints, pointBuffer,
maxFragments, fragmentBuffer,
&returnedPoints, &returnedFragments, mins, maxs,
oldMapping, center, radius, bestnormal, orientation, numPoints );
if ( returnedFragments == maxFragments ) {
break; // not enough space for more fragments
}
}
return returnedFragments;
}
void G_CreateRotationMatrix(vector3 *angles, matrix3 matrix) {
AngleVectors(angles, &matrix[0], &matrix[1], &matrix[2]);
VectorInverse(&matrix[1]);
}
/*
==================
CM_AddFacetBevels
==================
*/
static void CM_AddFacetBevels(cFacet_t * facet) {
int i, j, k, l, axis, dir, order, flipped;
float plane[4], d, newplane[4];
winding_t *w, *w2;
vec3_t mins, maxs, vec, vec2;
Vector4Copy(planes[facet->surfacePlane].plane, plane);
w = BaseWindingForPlane(plane, plane[3]);
for(j = 0; j < facet->numBorders && w; j++) {
if(facet->borderPlanes[j] == facet->surfacePlane) {
continue;
}
Vector4Copy(planes[facet->borderPlanes[j]].plane, plane);
if(!facet->borderInward[j]) {
VectorInverse(plane);
plane[3] = -plane[3];
}
ChopWindingInPlace(&w, plane, plane[3], 0.1f);
}
if(!w) {
return;
}
WindingBounds(w, mins, maxs);
//
// add the axial planes
//
order = 0;
for(axis = 0; axis < 3; axis++) {
for(dir = -1; dir <= 1; dir += 2, order++) {
VectorClear(plane);
plane[axis] = dir;
if(dir == 1) {
plane[3] = maxs[axis];
} else {
plane[3] = -mins[axis];
}
// if it's the surface plane
if(CM_PlaneEqual(&planes[facet->surfacePlane], plane, &flipped)) {
continue;
}
// see if the plane is allready present
for(i = 0; i < facet->numBorders; i++) {
if(CM_PlaneEqual(&planes[facet->borderPlanes[i]], plane, &flipped)) {
break;
}
}
if(i == facet->numBorders) {
if(facet->numBorders > MAX_FACET_BEVELS) {
Com_Printf("ERROR: too many bevels\n");
}
facet->borderPlanes[facet->numBorders] = CM_FindPlane2(plane, &flipped);
facet->borderNoAdjust[facet->numBorders] = false;
facet->borderInward[facet->numBorders] = flipped;
facet->numBorders++;
}
}
}
//
// add the edge bevels
//
// test the non-axial plane edges
for(j = 0; j < w->numpoints; j++) {
k = (j + 1) % w->numpoints;
VectorSubtract(w->p[j], w->p[k], vec);
//if it's a degenerate edge
if(VectorNormalize(vec) < 0.5) {
continue;
}
CM_SnapVector(vec);
for(k = 0; k < 3; k++) {
if(vec[k] == -1 || vec[k] == 1) {
break; // axial
}
}
if(k < 3) {
continue; // only test non-axial edges
}
// try the six possible slanted axials from this edge
for(axis = 0; axis < 3; axis++) {
for(dir = -1; dir <= 1; dir += 2) {
// construct a plane
VectorClear(vec2);
vec2[axis] = dir;
CrossProduct(vec, vec2, plane);
if(VectorNormalize(plane) < 0.5) {
continue;
}
plane[3] = DotProduct(w->p[j], plane);
// if all the points of the facet winding are
// behind this plane, it is a proper edge bevel
for(l = 0; l < w->numpoints; l++) {
d = DotProduct(w->p[l], plane) - plane[3];
if(d > 0.1) {
break; // point in front
}
}
if(l < w->numpoints) {
continue;
}
// if it's the surface plane
if(CM_PlaneEqual(&planes[facet->surfacePlane], plane, &flipped)) {
continue;
}
// see if the plane is allready present
for(i = 0; i < facet->numBorders; i++) {
if(CM_PlaneEqual(&planes[facet->borderPlanes[i]], plane, &flipped)) {
break;
}
}
if(i == facet->numBorders) {
if(facet->numBorders > MAX_FACET_BEVELS) {
Com_Printf("ERROR: too many bevels\n");
}
facet->borderPlanes[facet->numBorders] = CM_FindPlane2(plane, &flipped);
for(k = 0; k < facet->numBorders; k++) {
if(facet->borderPlanes[facet->numBorders] == facet->borderPlanes[k]) {
Com_Printf("WARNING: bevel plane already used\n");
}
}
facet->borderNoAdjust[facet->numBorders] = false;
facet->borderInward[facet->numBorders] = flipped;
//
w2 = CopyWinding(w);
Vector4Copy(planes[facet->borderPlanes[facet->numBorders]].plane, newplane);
if(!facet->borderInward[facet->numBorders]) {
VectorNegate(newplane, newplane);
newplane[3] = -newplane[3];
}
ChopWindingInPlace(&w2, newplane, newplane[3], 0.1f);
if(!w2) {
Com_DPrintf("WARNING: CM_AddFacetBevels... invalid bevel\n");
continue;
} else {
FreeWinding(w2);
}
//
facet->numBorders++;
//already got a bevel
// break;
}
}
}
}
FreeWinding(w);
//add opposite plane
facet->borderPlanes[facet->numBorders] = facet->surfacePlane;
facet->borderNoAdjust[facet->numBorders] = false;
facet->borderInward[facet->numBorders] = true;
facet->numBorders++;
}
/*
=================
R_MarkFragments
=================
*/
int R_MarkFragments(int orientation, const vec3_t *points, const vec3_t projection,
int maxPoints, vec3_t pointBuffer, int maxFragments, markFragment_t *fragmentBuffer)
{
int numsurfaces, numPlanes;
int i, j, k, m, n;
surfaceType_t *surfaces[4096];
vec3_t mins, maxs;
int returnedFragments;
int returnedPoints;
vec3_t normals[MAX_VERTS_ON_POLY + 2];
float dists[MAX_VERTS_ON_POLY + 2];
vec3_t clipPoints[2][MAX_VERTS_ON_POLY];
int numClipPoints;
float *v;
srfGridMesh_t *cv;
srfTriangle_t *tri;
srfVert_t *dv;
vec3_t normal;
vec3_t projectionDir;
vec3_t v1, v2;
float radius;
vec3_t center; // center of original mark
//vec3_t bestCenter; // center point projected onto the closest surface
float texCoordScale;
//float dot;
int numPoints = 4; // Ridah, we were only ever passing in 4, so I made this local and used the parameter for the orientation
qboolean oldMapping = qfalse;
if (numPoints <= 0)
{
return 0;
}
//increment view count for double check prevention
tr.viewCount++;
// RF, negative maxFragments means we want original mapping
if (maxFragments < 0)
{
maxFragments = -maxFragments;
//return R_OldMarkFragments( numPoints, points, projection, maxPoints, pointBuffer, maxFragments, fragmentBuffer );
oldMapping = qtrue;
}
VectorClear(center);
for (i = 0 ; i < numPoints ; i++)
{
VectorAdd(points[i], center, center);
}
VectorScale(center, 1.0 / numPoints, center);
//
radius = VectorNormalize2(projection, projectionDir) / 2.0;
bestdist = 0;
VectorNegate(projectionDir, bestnormal);
// find all the brushes that are to be considered
ClearBounds(mins, maxs);
for (i = 0 ; i < numPoints ; i++)
{
vec3_t temp;
AddPointToBounds(points[i], mins, maxs);
VectorMA(points[i], 1 * (1 + oldMapping * radius * 4), projection, temp);
AddPointToBounds(temp, mins, maxs);
// make sure we get all the leafs (also the one(s) in front of the hit surface)
VectorMA(points[i], -20 * (1.0 + (float)oldMapping * (radius / 20.0) * 4), projectionDir, temp);
AddPointToBounds(temp, mins, maxs);
}
if (numPoints > MAX_VERTS_ON_POLY)
{
numPoints = MAX_VERTS_ON_POLY;
}
// create the bounding planes for the to be projected polygon
for (i = 0 ; i < numPoints ; i++)
{
VectorSubtract(points[(i + 1) % numPoints], points[i], v1);
VectorAdd(points[i], projection, v2);
VectorSubtract(points[i], v2, v2);
CrossProduct(v1, v2, normals[i]);
VectorNormalize(normals[i]);
dists[i] = DotProduct(normals[i], points[i]);
}
// add near and far clipping planes for projection
VectorCopy(projectionDir, normals[numPoints]);
dists[numPoints] = DotProduct(normals[numPoints], points[0]) - radius * (1 + oldMapping * 10);
VectorCopy(projectionDir, normals[numPoints + 1]);
VectorInverse(normals[numPoints + 1]);
dists[numPoints + 1] = DotProduct(normals[numPoints + 1], points[0]) - radius * (1 + oldMapping * 10);
numPlanes = numPoints + 2;
numsurfaces = 0;
R_BoxSurfaces_r(tr.world->nodes, mins, maxs, surfaces, 4096, &numsurfaces, projectionDir);
//assert(numsurfaces <= 64);
//assert(numsurfaces != 64);
texCoordScale = 0.5 * 1.0 / radius;
returnedPoints = 0;
returnedFragments = 0;
// find the closest surface to center the decal there, and wrap around other surfaces
if (!oldMapping)
{
/*
for ( i = 0 ; i < numsurfaces ; i++ ) {
if (*surfaces[i] == SF_FACE) {
surf = ( srfSurfaceFace_t * ) surfaces[i];
// Ridah, check if this is the closest surface
dot = DotProduct( center, surf->plane.normal );
dot -= surf->plane.dist;
if (!bestdist) {
if (dot < 0)
bestdist = fabs(dot) + 1000; // avoid this surface, since the point is behind it
else
bestdist = dot;
VectorCopy( surf->plane.normal, bestnormal );
VectorMA( center, -dot, surf->plane.normal, bestCenter );
} else if (dot >= 0 && dot < bestdist) {
bestdist = dot;
VectorCopy( surf->plane.normal, bestnormal );
VectorMA( center, -dot, surf->plane.normal, bestCenter );
}
}
}
// bestCenter is now the real center
VectorCopy( bestCenter, center );
Com_Printf("bestnormal: %1.1f %1.1f %1.1f \n", bestnormal[0], bestnormal[1], bestnormal[2] );
*/
VectorNegate(bestnormal, bestnormal);
}
for (i = 0 ; i < numsurfaces ; i++)
{
if (*surfaces[i] == SF_GRID)
{
cv = (srfGridMesh_t *) surfaces[i];
for (m = 0 ; m < cv->height - 1 ; m++)
{
for (n = 0 ; n < cv->width - 1 ; n++)
{
// We triangulate the grid and chop all triangles within
// the bounding planes of the to be projected polygon.
// LOD is not taken into account, not such a big deal though.
//
// It's probably much nicer to chop the grid itself and deal
// with this grid as a normal SF_GRID surface so LOD will
// be applied. However the LOD of that chopped grid must
// be synced with the LOD of the original curve.
// One way to do this; the chopped grid shares vertices with
// the original curve. When LOD is applied to the original
// curve the unused vertices are flagged. Now the chopped curve
// should skip the flagged vertices. This still leaves the
// problems with the vertices at the chopped grid edges.
//
// To avoid issues when LOD applied to "hollow curves" (like
// the ones around many jump pads) we now just add a 2 unit
// offset to the triangle vertices.
// The offset is added in the vertex normal vector direction
// so all triangles will still fit together.
// The 2 unit offset should avoid pretty much all LOD problems.
numClipPoints = 3;
dv = cv->verts + m * cv->width + n;
VectorCopy(dv[0].xyz, clipPoints[0][0]);
VectorMA(clipPoints[0][0], MARKER_OFFSET, dv[0].normal, clipPoints[0][0]);
VectorCopy(dv[cv->width].xyz, clipPoints[0][1]);
VectorMA(clipPoints[0][1], MARKER_OFFSET, dv[cv->width].normal, clipPoints[0][1]);
VectorCopy(dv[1].xyz, clipPoints[0][2]);
VectorMA(clipPoints[0][2], MARKER_OFFSET, dv[1].normal, clipPoints[0][2]);
// check the normal of this triangle
VectorSubtract(clipPoints[0][0], clipPoints[0][1], v1);
VectorSubtract(clipPoints[0][2], clipPoints[0][1], v2);
CrossProduct(v1, v2, normal);
VectorNormalize(normal);
if (DotProduct(normal, projectionDir) < -0.1)
{
// add the fragments of this triangle
R_AddMarkFragments(numClipPoints, clipPoints,
numPlanes, normals, dists,
maxPoints, pointBuffer,
maxFragments, fragmentBuffer,
&returnedPoints, &returnedFragments, mins, maxs);
if (returnedFragments == maxFragments)
{
return returnedFragments; // not enough space for more fragments
}
}
VectorCopy(dv[1].xyz, clipPoints[0][0]);
VectorMA(clipPoints[0][0], MARKER_OFFSET, dv[1].normal, clipPoints[0][0]);
VectorCopy(dv[cv->width].xyz, clipPoints[0][1]);
VectorMA(clipPoints[0][1], MARKER_OFFSET, dv[cv->width].normal, clipPoints[0][1]);
VectorCopy(dv[cv->width + 1].xyz, clipPoints[0][2]);
VectorMA(clipPoints[0][2], MARKER_OFFSET, dv[cv->width + 1].normal, clipPoints[0][2]);
// check the normal of this triangle
VectorSubtract(clipPoints[0][0], clipPoints[0][1], v1);
VectorSubtract(clipPoints[0][2], clipPoints[0][1], v2);
CrossProduct(v1, v2, normal);
VectorNormalize(normal);
if (DotProduct(normal, projectionDir) < -0.05)
{
// add the fragments of this triangle
R_AddMarkFragments(numClipPoints, clipPoints,
numPlanes, normals, dists,
maxPoints, pointBuffer,
maxFragments, fragmentBuffer,
&returnedPoints, &returnedFragments, mins, maxs);
if (returnedFragments == maxFragments)
{
return returnedFragments; // not enough space for more fragments
}
}
}
}
}
else if (*surfaces[i] == SF_FACE)
{
extern float VectorDistance(vec3_t v1, vec3_t v2);
vec3_t axis[3];
float texCoordScale, dot;
vec3_t originalPoints[4];
vec3_t newCenter, delta;
int oldNumPoints;
float epsilon = 0.5;
// duplicated so we don't mess with the original clips for the curved surfaces
vec3_t lnormals[MAX_VERTS_ON_POLY + 2];
float ldists[MAX_VERTS_ON_POLY + 2];
vec3_t lmins, lmaxs;
srfSurfaceFace_t *surf = ( srfSurfaceFace_t * ) surfaces[i];
if (!oldMapping)
{
// Ridah, create a new clip box such that this decal surface is mapped onto
// the current surface without distortion. To find the center of the new clip box,
// we project the center of the original impact center out along the projection vector,
// onto the current surface
// find the center of the new decal
dot = DotProduct(center, surf->plane.normal);
dot -= surf->plane.dist;
// check the normal of this face
if (dot < -epsilon && DotProduct(surf->plane.normal, projectionDir) >= 0.01)
{
continue;
}
else if (fabs(dot) > radius)
{
continue;
}
// if the impact point is behind the surface, subtract the projection, otherwise add it
VectorMA(center, -dot, bestnormal, newCenter);
// recalc dot from the offset position
dot = DotProduct(newCenter, surf->plane.normal);
dot -= surf->plane.dist;
VectorMA(newCenter, -dot, surf->plane.normal, newCenter);
VectorMA(newCenter, MARKER_OFFSET, surf->plane.normal, newCenter);
// create the texture axis
VectorNormalize2(surf->plane.normal, axis[0]);
PerpendicularVector(axis[1], axis[0]);
RotatePointAroundVector(axis[2], axis[0], axis[1], (float)orientation);
CrossProduct(axis[0], axis[2], axis[1]);
texCoordScale = 0.5 * 1.0 / radius;
// create the full polygon
for (j = 0 ; j < 3 ; j++)
{
originalPoints[0][j] = newCenter[j] - radius * axis[1][j] - radius * axis[2][j];
originalPoints[1][j] = newCenter[j] + radius * axis[1][j] - radius * axis[2][j];
originalPoints[2][j] = newCenter[j] + radius * axis[1][j] + radius * axis[2][j];
originalPoints[3][j] = newCenter[j] - radius * axis[1][j] + radius * axis[2][j];
}
ClearBounds(lmins, lmaxs);
// create the bounding planes for the to be projected polygon
for (j = 0 ; j < 4 ; j++)
{
AddPointToBounds(originalPoints[j], lmins, lmaxs);
VectorSubtract(originalPoints[(j + 1) % numPoints], originalPoints[j], v1);
VectorSubtract(originalPoints[j], surf->plane.normal, v2);
VectorSubtract(originalPoints[j], v2, v2);
CrossProduct(v1, v2, lnormals[j]);
VectorNormalize(lnormals[j]);
ldists[j] = DotProduct(lnormals[j], originalPoints[j]);
}
numPlanes = numPoints;
// done.
for (k = 0, tri = surf->triangles; k < surf->numTriangles; k++, tri++)
{
for (j = 0; j < 3; j++)
{
v = surf->verts[tri->indexes[j]].xyz;
VectorMA(v, MARKER_OFFSET, surf->plane.normal, clipPoints[0][j]);
}
oldNumPoints = returnedPoints;
// add the fragments of this face
R_AddMarkFragments(3, clipPoints,
numPlanes, lnormals, ldists,
maxPoints, pointBuffer,
maxFragments, fragmentBuffer,
&returnedPoints, &returnedFragments, lmins, lmaxs);
if (oldNumPoints != returnedPoints)
{
// flag this surface as already having computed ST's
fragmentBuffer[returnedFragments - 1].numPoints *= -1;
// Ridah, calculate ST's
for (j = 0 ; j < (returnedPoints - oldNumPoints) ; j++)
{
VectorSubtract((float *)pointBuffer + 5 * (oldNumPoints + j), newCenter, delta);
*((float *)pointBuffer + 5 * (oldNumPoints + j) + 3) = 0.5 + DotProduct(delta, axis[1]) * texCoordScale;
*((float *)pointBuffer + 5 * (oldNumPoints + j) + 4) = 0.5 + DotProduct(delta, axis[2]) * texCoordScale;
}
}
if (returnedFragments == maxFragments)
{
return returnedFragments; // not enough space for more fragments
}
}
}
else // old mapping
{ // check the normal of this face
//if (DotProduct(surf->plane.normal, projectionDir) > 0.0) {
// continue;
//}
for (k = 0, tri = surf->triangles; k < surf->numTriangles; k++, tri++)
{
for (j = 0; j < 3; j++)
{
v = surf->verts[tri->indexes[j]].xyz;
VectorMA(v, MARKER_OFFSET, surf->plane.normal, clipPoints[0][j]);
}
// add the fragments of this face
R_AddMarkFragments(3, clipPoints,
numPlanes, normals, dists,
maxPoints, pointBuffer,
maxFragments, fragmentBuffer,
&returnedPoints, &returnedFragments, mins, maxs);
if (returnedFragments == maxFragments)
{
return returnedFragments; // not enough space for more fragments
}
}
}
}
else if (*surfaces[i] == SF_TRIANGLES && r_marksOnTriangleMeshes->integer)
{
srfTriangles_t *surf = (srfTriangles_t *) surfaces[i];
for (k = 0, tri = surf->triangles; k < surf->numTriangles; k++, tri++)
{
for (j = 0; j < 3; j++)
{
v = surf->verts[tri->indexes[j]].xyz;
VectorMA(v, MARKER_OFFSET, surf->verts[tri->indexes[j]].normal, clipPoints[0][j]);
}
// add the fragments of this face
R_AddMarkFragments(3, clipPoints,
numPlanes, normals, dists,
maxPoints, pointBuffer,
maxFragments, fragmentBuffer, &returnedPoints, &returnedFragments, mins, maxs);
if (returnedFragments == maxFragments)
{
return returnedFragments; // not enough space for more fragments
}
}
}
}
return returnedFragments;
}
/*
=================
R_LoadMDM
=================
*/
qboolean R_LoadMDM( model_t *mod, void *buffer, const char *modName )
{
int i, j, k;
mdmHeader_t *mdm;
// mdmFrame_t *frame;
mdmSurface_t *mdmSurf;
mdmTriangle_t *mdmTri;
mdmVertex_t *mdmVertex;
mdmTag_t *mdmTag;
int version;
// int size;
shader_t *sh;
int32_t *collapseMap, *collapseMapOut, *boneref, *bonerefOut;
mdmModel_t *mdmModel;
mdmTagIntern_t *tag;
mdmSurfaceIntern_t *surf;
srfTriangle_t *tri;
md5Vertex_t *v;
mdm = ( mdmHeader_t * ) buffer;
version = LittleLong( mdm->version );
if ( version != MDM_VERSION )
{
ri.Printf( PRINT_WARNING, "R_LoadMDM: %s has wrong version (%i should be %i)\n", modName, version, MDM_VERSION );
return qfalse;
}
mod->type = MOD_MDM;
// size = LittleLong(mdm->ofsEnd);
mod->dataSize += sizeof( mdmModel_t );
//mdm = mod->mdm = ri.Hunk_Alloc(size, h_low);
//memcpy(mdm, buffer, LittleLong(pinmodel->ofsEnd));
mdmModel = mod->mdm = ri.Hunk_Alloc( sizeof( mdmModel_t ), h_low );
LL( mdm->ident );
LL( mdm->version );
// LL(mdm->numFrames);
LL( mdm->numTags );
LL( mdm->numSurfaces );
// LL(mdm->ofsFrames);
LL( mdm->ofsTags );
LL( mdm->ofsEnd );
LL( mdm->ofsSurfaces );
mdmModel->lodBias = LittleFloat( mdm->lodBias );
mdmModel->lodScale = LittleFloat( mdm->lodScale );
/* mdm->skel = RE_RegisterModel(mdm->bonesfile);
if ( !mdm->skel ) {
ri.Error (ERR_DROP, "R_LoadMDM: %s skeleton not found", mdm->bonesfile );
}
if ( mdm->numFrames < 1 ) {
ri.Printf( PRINT_WARNING, "R_LoadMDM: %s has no frames\n", modName );
return qfalse;
}*/
// swap all the frames
/*frameSize = (int) ( sizeof( mdmFrame_t ) );
for ( i = 0 ; i < mdm->numFrames ; i++, frame++) {
frame = (mdmFrame_t *) ( (byte *)mdm + mdm->ofsFrames + i * frameSize );
frame->radius = LittleFloat( frame->radius );
for ( j = 0 ; j < 3 ; j++ ) {
frame->bounds[0][j] = LittleFloat( frame->bounds[0][j] );
frame->bounds[1][j] = LittleFloat( frame->bounds[1][j] );
frame->localOrigin[j] = LittleFloat( frame->localOrigin[j] );
frame->parentOffset[j] = LittleFloat( frame->parentOffset[j] );
}
} */
// swap all the tags
mdmModel->numTags = mdm->numTags;
mdmModel->tags = tag = ri.Hunk_Alloc( sizeof( *tag ) * mdm->numTags, h_low );
mdmTag = ( mdmTag_t * )( ( byte * ) mdm + mdm->ofsTags );
for ( i = 0; i < mdm->numTags; i++, tag++ )
{
int ii;
Q_strncpyz( tag->name, mdmTag->name, sizeof( tag->name ) );
for ( ii = 0; ii < 3; ii++ )
{
tag->axis[ ii ][ 0 ] = LittleFloat( mdmTag->axis[ ii ][ 0 ] );
tag->axis[ ii ][ 1 ] = LittleFloat( mdmTag->axis[ ii ][ 1 ] );
tag->axis[ ii ][ 2 ] = LittleFloat( mdmTag->axis[ ii ][ 2 ] );
}
tag->boneIndex = LittleLong( mdmTag->boneIndex );
//tag->torsoWeight = LittleFloat( tag->torsoWeight );
tag->offset[ 0 ] = LittleFloat( mdmTag->offset[ 0 ] );
tag->offset[ 1 ] = LittleFloat( mdmTag->offset[ 1 ] );
tag->offset[ 2 ] = LittleFloat( mdmTag->offset[ 2 ] );
LL( mdmTag->numBoneReferences );
LL( mdmTag->ofsBoneReferences );
LL( mdmTag->ofsEnd );
tag->numBoneReferences = mdmTag->numBoneReferences;
tag->boneReferences = ri.Hunk_Alloc( sizeof( *bonerefOut ) * mdmTag->numBoneReferences, h_low );
// swap the bone references
boneref = ( int32_t * )( ( byte * ) mdmTag + mdmTag->ofsBoneReferences );
for ( j = 0, bonerefOut = tag->boneReferences; j < mdmTag->numBoneReferences; j++, boneref++, bonerefOut++ )
{
*bonerefOut = LittleLong( *boneref );
}
// find the next tag
mdmTag = ( mdmTag_t * )( ( byte * ) mdmTag + mdmTag->ofsEnd );
}
// swap all the surfaces
mdmModel->numSurfaces = mdm->numSurfaces;
mdmModel->surfaces = ri.Hunk_Alloc( sizeof( *surf ) * mdmModel->numSurfaces, h_low );
mdmSurf = ( mdmSurface_t * )( ( byte * ) mdm + mdm->ofsSurfaces );
for ( i = 0, surf = mdmModel->surfaces; i < mdm->numSurfaces; i++, surf++ )
{
LL( mdmSurf->shaderIndex );
LL( mdmSurf->ofsHeader );
LL( mdmSurf->ofsCollapseMap );
LL( mdmSurf->numTriangles );
LL( mdmSurf->ofsTriangles );
LL( mdmSurf->numVerts );
LL( mdmSurf->ofsVerts );
LL( mdmSurf->numBoneReferences );
LL( mdmSurf->ofsBoneReferences );
LL( mdmSurf->ofsEnd );
surf->minLod = LittleLong( mdmSurf->minLod );
// change to surface identifier
surf->surfaceType = SF_MDM;
surf->model = mdmModel;
Q_strncpyz( surf->name, mdmSurf->name, sizeof( surf->name ) );
if ( mdmSurf->numVerts > SHADER_MAX_VERTEXES )
{
ri.Error( ERR_DROP, "R_LoadMDM: %s has more than %i verts on a surface (%i)",
modName, SHADER_MAX_VERTEXES, mdmSurf->numVerts );
}
if ( mdmSurf->numTriangles > SHADER_MAX_TRIANGLES )
{
ri.Error( ERR_DROP, "R_LoadMDM: %s has more than %i triangles on a surface (%i)",
modName, SHADER_MAX_TRIANGLES, mdmSurf->numTriangles );
}
// register the shaders
if ( mdmSurf->shader[ 0 ] )
{
Q_strncpyz( surf->shader, mdmSurf->shader, sizeof( surf->shader ) );
sh = R_FindShader( surf->shader, SHADER_3D_DYNAMIC, qtrue );
if ( sh->defaultShader )
{
surf->shaderIndex = 0;
}
else
{
surf->shaderIndex = sh->index;
}
}
else
{
surf->shaderIndex = 0;
}
// swap all the triangles
surf->numTriangles = mdmSurf->numTriangles;
surf->triangles = ri.Hunk_Alloc( sizeof( *tri ) * surf->numTriangles, h_low );
mdmTri = ( mdmTriangle_t * )( ( byte * ) mdmSurf + mdmSurf->ofsTriangles );
for ( j = 0, tri = surf->triangles; j < surf->numTriangles; j++, mdmTri++, tri++ )
{
tri->indexes[ 0 ] = LittleLong( mdmTri->indexes[ 0 ] );
tri->indexes[ 1 ] = LittleLong( mdmTri->indexes[ 1 ] );
tri->indexes[ 2 ] = LittleLong( mdmTri->indexes[ 2 ] );
}
// swap all the vertexes
surf->numVerts = mdmSurf->numVerts;
surf->verts = ri.Hunk_Alloc( sizeof( *v ) * surf->numVerts, h_low );
mdmVertex = ( mdmVertex_t * )( ( byte * ) mdmSurf + mdmSurf->ofsVerts );
for ( j = 0, v = surf->verts; j < mdmSurf->numVerts; j++, v++ )
{
v->normal[ 0 ] = LittleFloat( mdmVertex->normal[ 0 ] );
v->normal[ 1 ] = LittleFloat( mdmVertex->normal[ 1 ] );
v->normal[ 2 ] = LittleFloat( mdmVertex->normal[ 2 ] );
v->texCoords[ 0 ] = LittleFloat( mdmVertex->texCoords[ 0 ] );
v->texCoords[ 1 ] = LittleFloat( mdmVertex->texCoords[ 1 ] );
v->numWeights = LittleLong( mdmVertex->numWeights );
if ( v->numWeights > MAX_WEIGHTS )
{
#if 0
ri.Error( ERR_DROP, "R_LoadMDM: vertex %i requires %i instead of maximum %i weights on surface (%i) in model '%s'",
j, v->numWeights, MAX_WEIGHTS, i, modName );
#else
ri.Printf( PRINT_WARNING, "WARNING: R_LoadMDM: vertex %i requires %i instead of maximum %i weights on surface (%i) in model '%s'\n",
j, v->numWeights, MAX_WEIGHTS, i, modName );
#endif
}
v->weights = ri.Hunk_Alloc( sizeof( *v->weights ) * v->numWeights, h_low );
for ( k = 0; k < v->numWeights; k++ )
{
md5Weight_t *weight = ri.Hunk_Alloc( sizeof( *weight ), h_low );
weight->boneIndex = LittleLong( mdmVertex->weights[ k ].boneIndex );
weight->boneWeight = LittleFloat( mdmVertex->weights[ k ].boneWeight );
weight->offset[ 0 ] = LittleFloat( mdmVertex->weights[ k ].offset[ 0 ] );
weight->offset[ 1 ] = LittleFloat( mdmVertex->weights[ k ].offset[ 1 ] );
weight->offset[ 2 ] = LittleFloat( mdmVertex->weights[ k ].offset[ 2 ] );
v->weights[ k ] = weight;
}
mdmVertex = ( mdmVertex_t * ) &mdmVertex->weights[ v->numWeights ];
}
// swap the collapse map
surf->collapseMap = ri.Hunk_Alloc( sizeof( *collapseMapOut ) * mdmSurf->numVerts, h_low );
collapseMap = ( int32_t * )( ( byte * ) mdmSurf + mdmSurf->ofsCollapseMap );
//ri.Printf(PRINT_ALL, "collapse map for mdm surface '%s': ", surf->name);
for ( j = 0, collapseMapOut = surf->collapseMap; j < mdmSurf->numVerts; j++, collapseMap++, collapseMapOut++ )
{
int32_t value = LittleLong( *collapseMap );
//surf->collapseMap[j] = value;
*collapseMapOut = value;
//ri.Printf(PRINT_ALL, "(%i -> %i) ", j, value);
}
//ri.Printf(PRINT_ALL, "\n");
#if 0
ri.Printf( PRINT_ALL, "collapse map for mdm surface '%s': ", surf->name );
for ( j = 0, collapseMap = surf->collapseMap; j < mdmSurf->numVerts; j++, collapseMap++ )
{
ri.Printf( PRINT_ALL, "(%i -> %i) ", j, *collapseMap );
}
ri.Printf( PRINT_ALL, "\n" );
#endif
// swap the bone references
surf->numBoneReferences = mdmSurf->numBoneReferences;
surf->boneReferences = ri.Hunk_Alloc( sizeof( *bonerefOut ) * mdmSurf->numBoneReferences, h_low );
boneref = ( int32_t * )( ( byte * ) mdmSurf + mdmSurf->ofsBoneReferences );
for ( j = 0, bonerefOut = surf->boneReferences; j < surf->numBoneReferences; j++, boneref++, bonerefOut++ )
{
*bonerefOut = LittleLong( *boneref );
}
// find the next surface
mdmSurf = ( mdmSurface_t * )( ( byte * ) mdmSurf + mdmSurf->ofsEnd );
}
// loading is done now calculate the bounding box and tangent spaces
ClearBounds( mdmModel->bounds[ 0 ], mdmModel->bounds[ 1 ] );
for ( i = 0, surf = mdmModel->surfaces; i < mdmModel->numSurfaces; i++, surf++ )
{
for ( j = 0, v = surf->verts; j < surf->numVerts; j++, v++ )
{
vec3_t tmpVert;
md5Weight_t *w;
VectorClear( tmpVert );
for ( k = 0, w = v->weights[ 0 ]; k < v->numWeights; k++, w++ )
{
//vec3_t offsetVec;
//VectorClear(offsetVec);
//bone = &md5->bones[w->boneIndex];
//QuatTransformVector(bone->rotation, w->offset, offsetVec);
//VectorAdd(bone->origin, offsetVec, offsetVec);
VectorMA( tmpVert, w->boneWeight, w->offset, tmpVert );
}
VectorCopy( tmpVert, v->position );
AddPointToBounds( tmpVert, mdmModel->bounds[ 0 ], mdmModel->bounds[ 1 ] );
}
// calc tangent spaces
#if 0
{
const float *v0, *v1, *v2;
const float *t0, *t1, *t2;
vec3_t tangent;
vec3_t binormal;
vec3_t normal;
for ( j = 0, v = surf->verts; j < surf->numVerts; j++, v++ )
{
VectorClear( v->tangent );
VectorClear( v->binormal );
VectorClear( v->normal );
}
for ( j = 0, tri = surf->triangles; j < surf->numTriangles; j++, tri++ )
{
v0 = surf->verts[ tri->indexes[ 0 ] ].position;
v1 = surf->verts[ tri->indexes[ 1 ] ].position;
v2 = surf->verts[ tri->indexes[ 2 ] ].position;
t0 = surf->verts[ tri->indexes[ 0 ] ].texCoords;
t1 = surf->verts[ tri->indexes[ 1 ] ].texCoords;
t2 = surf->verts[ tri->indexes[ 2 ] ].texCoords;
#if 1
R_CalcTangentSpace( tangent, binormal, normal, v0, v1, v2, t0, t1, t2 );
#else
R_CalcNormalForTriangle( normal, v0, v1, v2 );
R_CalcTangentsForTriangle( tangent, binormal, v0, v1, v2, t0, t1, t2 );
#endif
for ( k = 0; k < 3; k++ )
{
float *v;
v = surf->verts[ tri->indexes[ k ] ].tangent;
VectorAdd( v, tangent, v );
v = surf->verts[ tri->indexes[ k ] ].binormal;
VectorAdd( v, binormal, v );
v = surf->verts[ tri->indexes[ k ] ].normal;
VectorAdd( v, normal, v );
}
}
for ( j = 0, v = surf->verts; j < surf->numVerts; j++, v++ )
{
VectorNormalize( v->tangent );
VectorNormalize( v->binormal );
VectorNormalize( v->normal );
}
}
#else
{
int k;
float bb, s, t;
vec3_t bary;
vec3_t faceNormal;
md5Vertex_t *dv[ 3 ];
for ( j = 0, tri = surf->triangles; j < surf->numTriangles; j++, tri++ )
{
dv[ 0 ] = &surf->verts[ tri->indexes[ 0 ] ];
dv[ 1 ] = &surf->verts[ tri->indexes[ 1 ] ];
dv[ 2 ] = &surf->verts[ tri->indexes[ 2 ] ];
R_CalcNormalForTriangle( faceNormal, dv[ 0 ]->position, dv[ 1 ]->position, dv[ 2 ]->position );
// calculate barycentric basis for the triangle
bb = ( dv[ 1 ]->texCoords[ 0 ] - dv[ 0 ]->texCoords[ 0 ] ) * ( dv[ 2 ]->texCoords[ 1 ] - dv[ 0 ]->texCoords[ 1 ] ) - ( dv[ 2 ]->texCoords[ 0 ] - dv[ 0 ]->texCoords[ 0 ] ) * ( dv[ 1 ]->texCoords[ 1 ] -
dv[ 0 ]->texCoords[ 1 ] );
if ( fabs( bb ) < 0.00000001f )
{
continue;
}
// do each vertex
for ( k = 0; k < 3; k++ )
{
// calculate s tangent vector
s = dv[ k ]->texCoords[ 0 ] + 10.0f;
t = dv[ k ]->texCoords[ 1 ];
bary[ 0 ] = ( ( dv[ 1 ]->texCoords[ 0 ] - s ) * ( dv[ 2 ]->texCoords[ 1 ] - t ) - ( dv[ 2 ]->texCoords[ 0 ] - s ) * ( dv[ 1 ]->texCoords[ 1 ] - t ) ) / bb;
bary[ 1 ] = ( ( dv[ 2 ]->texCoords[ 0 ] - s ) * ( dv[ 0 ]->texCoords[ 1 ] - t ) - ( dv[ 0 ]->texCoords[ 0 ] - s ) * ( dv[ 2 ]->texCoords[ 1 ] - t ) ) / bb;
bary[ 2 ] = ( ( dv[ 0 ]->texCoords[ 0 ] - s ) * ( dv[ 1 ]->texCoords[ 1 ] - t ) - ( dv[ 1 ]->texCoords[ 0 ] - s ) * ( dv[ 0 ]->texCoords[ 1 ] - t ) ) / bb;
dv[ k ]->tangent[ 0 ] = bary[ 0 ] * dv[ 0 ]->position[ 0 ] + bary[ 1 ] * dv[ 1 ]->position[ 0 ] + bary[ 2 ] * dv[ 2 ]->position[ 0 ];
dv[ k ]->tangent[ 1 ] = bary[ 0 ] * dv[ 0 ]->position[ 1 ] + bary[ 1 ] * dv[ 1 ]->position[ 1 ] + bary[ 2 ] * dv[ 2 ]->position[ 1 ];
dv[ k ]->tangent[ 2 ] = bary[ 0 ] * dv[ 0 ]->position[ 2 ] + bary[ 1 ] * dv[ 1 ]->position[ 2 ] + bary[ 2 ] * dv[ 2 ]->position[ 2 ];
VectorSubtract( dv[ k ]->tangent, dv[ k ]->position, dv[ k ]->tangent );
VectorNormalize( dv[ k ]->tangent );
// calculate t tangent vector (binormal)
s = dv[ k ]->texCoords[ 0 ];
t = dv[ k ]->texCoords[ 1 ] + 10.0f;
bary[ 0 ] = ( ( dv[ 1 ]->texCoords[ 0 ] - s ) * ( dv[ 2 ]->texCoords[ 1 ] - t ) - ( dv[ 2 ]->texCoords[ 0 ] - s ) * ( dv[ 1 ]->texCoords[ 1 ] - t ) ) / bb;
bary[ 1 ] = ( ( dv[ 2 ]->texCoords[ 0 ] - s ) * ( dv[ 0 ]->texCoords[ 1 ] - t ) - ( dv[ 0 ]->texCoords[ 0 ] - s ) * ( dv[ 2 ]->texCoords[ 1 ] - t ) ) / bb;
bary[ 2 ] = ( ( dv[ 0 ]->texCoords[ 0 ] - s ) * ( dv[ 1 ]->texCoords[ 1 ] - t ) - ( dv[ 1 ]->texCoords[ 0 ] - s ) * ( dv[ 0 ]->texCoords[ 1 ] - t ) ) / bb;
dv[ k ]->binormal[ 0 ] = bary[ 0 ] * dv[ 0 ]->position[ 0 ] + bary[ 1 ] * dv[ 1 ]->position[ 0 ] + bary[ 2 ] * dv[ 2 ]->position[ 0 ];
dv[ k ]->binormal[ 1 ] = bary[ 0 ] * dv[ 0 ]->position[ 1 ] + bary[ 1 ] * dv[ 1 ]->position[ 1 ] + bary[ 2 ] * dv[ 2 ]->position[ 1 ];
dv[ k ]->binormal[ 2 ] = bary[ 0 ] * dv[ 0 ]->position[ 2 ] + bary[ 1 ] * dv[ 1 ]->position[ 2 ] + bary[ 2 ] * dv[ 2 ]->position[ 2 ];
VectorSubtract( dv[ k ]->binormal, dv[ k ]->position, dv[ k ]->binormal );
VectorNormalize( dv[ k ]->binormal );
// calculate the normal as cross product N=TxB
#if 0
CrossProduct( dv[ k ]->tangent, dv[ k ]->binormal, dv[ k ]->normal );
VectorNormalize( dv[ k ]->normal );
// Gram-Schmidt orthogonalization process for B
// compute the cross product B=NxT to obtain
// an orthogonal basis
CrossProduct( dv[ k ]->normal, dv[ k ]->tangent, dv[ k ]->binormal );
if ( DotProduct( dv[ k ]->normal, faceNormal ) < 0 )
{
VectorInverse( dv[ k ]->normal );
//VectorInverse(dv[k]->tangent);
//VectorInverse(dv[k]->binormal);
}
#else
//VectorAdd(dv[k]->normal, faceNormal, dv[k]->normal);
#endif
}
}
#if 1
for ( j = 0, v = surf->verts; j < surf->numVerts; j++, v++ )
{
//VectorNormalize(v->tangent);
//VectorNormalize(v->binormal);
//VectorNormalize(v->normal);
}
#endif
}
#endif
#if 0
// do another extra smoothing for normals to avoid flat shading
for ( j = 0; j < surf->numVerts; j++ )
{
for ( k = 0; k < surf->numVerts; k++ )
{
if ( j == k )
{
continue;
}
if ( VectorCompare( surf->verts[ j ].position, surf->verts[ k ].position ) )
{
VectorAdd( surf->verts[ j ].normal, surf->verts[ k ].normal, surf->verts[ j ].normal );
}
}
VectorNormalize( surf->verts[ j ].normal );
}
#endif
}
// split the surfaces into VBO surfaces by the maximum number of GPU vertex skinning bones
{
int numRemaining;
growList_t sortedTriangles;
growList_t vboTriangles;
growList_t vboSurfaces;
int numBoneReferences;
int boneReferences[ MAX_BONES ];
Com_InitGrowList( &vboSurfaces, 10 );
for ( i = 0, surf = mdmModel->surfaces; i < mdmModel->numSurfaces; i++, surf++ )
{
// sort triangles
Com_InitGrowList( &sortedTriangles, 1000 );
for ( j = 0, tri = surf->triangles; j < surf->numTriangles; j++, tri++ )
{
skelTriangle_t *sortTri = Com_Allocate( sizeof( *sortTri ) );
for ( k = 0; k < 3; k++ )
{
sortTri->indexes[ k ] = tri->indexes[ k ];
sortTri->vertexes[ k ] = &surf->verts[ tri->indexes[ k ] ];
}
sortTri->referenced = qfalse;
Com_AddToGrowList( &sortedTriangles, sortTri );
}
//qsort(sortedTriangles.elements, sortedTriangles.currentElements, sizeof(void *), CompareTrianglesByBoneReferences);
#if 0
for ( j = 0; j < sortedTriangles.currentElements; j++ )
{
int b[ MAX_WEIGHTS * 3 ];
skelTriangle_t *sortTri = Com_GrowListElement( &sortedTriangles, j );
for ( k = 0; k < 3; k++ )
{
v = sortTri->vertexes[ k ];
for ( l = 0; l < MAX_WEIGHTS; l++ )
{
b[ k * 3 + l ] = ( l < v->numWeights ) ? v->weights[ l ]->boneIndex : 9999;
}
qsort( b, MAX_WEIGHTS * 3, sizeof( int ), CompareBoneIndices );
//ri.Printf(PRINT_ALL, "bone indices: %i %i %i %i\n", b[k * 3 + 0], b[k * 3 + 1], b[k * 3 + 2], b[k * 3 + 3]);
}
}
#endif
numRemaining = sortedTriangles.currentElements;
while ( numRemaining )
{
numBoneReferences = 0;
Com_Memset( boneReferences, 0, sizeof( boneReferences ) );
Com_InitGrowList( &vboTriangles, 1000 );
for ( j = 0; j < sortedTriangles.currentElements; j++ )
{
skelTriangle_t *sortTri = Com_GrowListElement( &sortedTriangles, j );
if ( sortTri->referenced )
{
continue;
}
if ( AddTriangleToVBOTriangleList( &vboTriangles, sortTri, &numBoneReferences, boneReferences ) )
{
sortTri->referenced = qtrue;
}
}
if ( !vboTriangles.currentElements )
{
ri.Printf( PRINT_WARNING, "R_LoadMDM: could not add triangles to a remaining VBO surface for model '%s'\n", modName );
break;
}
AddSurfaceToVBOSurfacesListMDM( &vboSurfaces, &vboTriangles, mdmModel, surf, i, numBoneReferences, boneReferences );
numRemaining -= vboTriangles.currentElements;
Com_DestroyGrowList( &vboTriangles );
}
for ( j = 0; j < sortedTriangles.currentElements; j++ )
{
skelTriangle_t *sortTri = Com_GrowListElement( &sortedTriangles, j );
Com_Dealloc( sortTri );
}
Com_DestroyGrowList( &sortedTriangles );
}
// move VBO surfaces list to hunk
mdmModel->numVBOSurfaces = vboSurfaces.currentElements;
mdmModel->vboSurfaces = ri.Hunk_Alloc( mdmModel->numVBOSurfaces * sizeof( *mdmModel->vboSurfaces ), h_low );
for ( i = 0; i < mdmModel->numVBOSurfaces; i++ )
{
mdmModel->vboSurfaces[ i ] = ( srfVBOMDMMesh_t * ) Com_GrowListElement( &vboSurfaces, i );
}
Com_DestroyGrowList( &vboSurfaces );
}
return qtrue;
}
void ParsePatch( qboolean onlyLights )
{
vec_t info[ 5 ];
int i, j, k;
parseMesh_t *pm;
char texture[ MAX_QPATH ];
char shader[ MAX_QPATH ];
mesh_t m;
bspDrawVert_t *verts;
epair_t *ep;
vec4_t delta, delta2, delta3;
qboolean degenerate;
float longestCurve;
int maxIterations;
MatchToken( "{" );
/* get texture */
GetToken( qtrue );
strcpy( texture, token );
Parse1DMatrix( 5, info );
m.width = info[0];
m.height = info[1];
m.verts = verts = safe_malloc( m.width * m.height * sizeof( m.verts[0] ) );
if( m.width < 0 || m.width > MAX_PATCH_SIZE || m.height < 0 || m.height > MAX_PATCH_SIZE )
Error( "ParsePatch: bad size" );
MatchToken( "(" );
for( j = 0; j < m.width ; j++ )
{
MatchToken( "(" );
for( i = 0; i < m.height ; i++ )
{
Parse1DMatrix( 5, verts[ i * m.width + j ].xyz );
/* ydnar: fix colors */
for( k = 0; k < MAX_LIGHTMAPS; k++ )
{
verts[ i * m.width + j ].color[ k ][ 0 ] = 255;
verts[ i * m.width + j ].color[ k ][ 1 ] = 255;
verts[ i * m.width + j ].color[ k ][ 2 ] = 255;
verts[ i * m.width + j ].color[ k ][ 3 ] = 255;
}
}
MatchToken( ")" );
}
MatchToken( ")" );
// if brush primitives format, we may have some epairs to ignore here
GetToken(qtrue);
if (g_bBrushPrimit!=BPRIMIT_OLDBRUSHES && strcmp(token,"}"))
{
ep = ParseEPair();
free(ep->key);
free(ep->value);
free(ep);
}
else
UnGetToken();
MatchToken( "}" );
MatchToken( "}" );
/* short circuit */
if( noCurveBrushes || onlyLights )
return;
/* ydnar: delete and warn about degenerate patches */
j = (m.width * m.height);
VectorClear( delta );
delta[ 3 ] = 0;
degenerate = qtrue;
/* find first valid vector */
for( i = 1; i < j && delta[ 3 ] == 0; i++ )
{
VectorSubtract( m.verts[ 0 ].xyz, m.verts[ i ].xyz, delta );
delta[ 3 ] = VectorNormalize( delta, delta );
}
/* secondary degenerate test */
if( delta[ 3 ] == 0 )
degenerate = qtrue;
else
{
/* if all vectors match this or are zero, then this is a degenerate patch */
for( i = 1; i < j && degenerate == qtrue; i++ )
{
VectorSubtract( m.verts[ 0 ].xyz, m.verts[ i ].xyz, delta2 );
delta2[ 3 ] = VectorNormalize( delta2, delta2 );
if( delta2[ 3 ] != 0 )
{
/* create inverse vector */
VectorCopy( delta2, delta3 );
delta3[ 3 ] = delta2[ 3 ];
VectorInverse( delta3 );
/* compare */
if( VectorCompare( delta, delta2 ) == qfalse && VectorCompare( delta, delta3 ) == qfalse )
degenerate = qfalse;
}
}
}
/* warn and select degenerate patch */
if( degenerate )
{
xml_Select( "degenerate patch", mapEnt->mapEntityNum, entitySourceBrushes, qfalse );
free( m.verts );
return;
}
/* find longest curve on the mesh */
longestCurve = 0.0f;
maxIterations = 0;
for( j = 0; j + 2 < m.width; j += 2 )
{
for( i = 0; i + 2 < m.height; i += 2 )
{
ExpandLongestCurve( &longestCurve, verts[ i * m.width + j ].xyz, verts[ i * m.width + (j + 1) ].xyz, verts[ i * m.width + (j + 2) ].xyz ); /* row */
ExpandLongestCurve( &longestCurve, verts[ i * m.width + j ].xyz, verts[ (i + 1) * m.width + j ].xyz, verts[ (i + 2) * m.width + j ].xyz ); /* col */
ExpandMaxIterations( &maxIterations, patchSubdivisions, verts[ i * m.width + j ].xyz, verts[ i * m.width + (j + 1) ].xyz, verts[ i * m.width + (j + 2) ].xyz ); /* row */
ExpandMaxIterations( &maxIterations, patchSubdivisions, verts[ i * m.width + j ].xyz, verts[ (i + 1) * m.width + j ].xyz, verts[ (i + 2) * m.width + j ].xyz ); /* col */
}
}
/* allocate patch mesh */
pm = safe_malloc( sizeof( *pm ) );
memset( pm, 0, sizeof( *pm ) );
/* ydnar: add entity/brush numbering */
pm->entityNum = mapEnt->mapEntityNum;
pm->brushNum = entitySourceBrushes;
/* set shader */
sprintf( shader, "textures/%s", texture );
pm->shaderInfo = ShaderInfoForShader( shader );
/* set mesh */
pm->mesh = m;
/* set longest curve */
pm->longestCurve = longestCurve;
pm->maxIterations = maxIterations;
/* link to the entity */
pm->next = mapEnt->patches;
mapEnt->patches = pm;
}
/*
* CG_Democam_CalcView
*/
static int CG_Democam_CalcView( void ) {
int i, viewType;
float lerpfrac;
vec3_t v;
viewType = VIEWDEF_PLAYERVIEW;
VectorClear( cam_velocity );
if( currentcam ) {
if( !nextcam ) {
lerpfrac = 0;
} else {
lerpfrac = (float)( demo_time - currentcam->timeStamp ) / (float)( nextcam->timeStamp - currentcam->timeStamp );
}
switch( currentcam->type ) {
case DEMOCAM_FIRSTPERSON:
VectorCopy( cg.view.origin, cam_origin );
VectorCopy( cg.view.angles, cam_angles );
VectorCopy( cg.view.velocity, cam_velocity );
cam_fov = cg.view.fov_y;
break;
case DEMOCAM_THIRDPERSON:
VectorCopy( cg.view.origin, cam_origin );
VectorCopy( cg.view.angles, cam_angles );
VectorCopy( cg.view.velocity, cam_velocity );
cam_fov = cg.view.fov_y;
cam_3dPerson = true;
break;
case DEMOCAM_POSITIONAL:
viewType = VIEWDEF_DEMOCAM;
cam_POVent = 0;
VectorCopy( currentcam->origin, cam_origin );
if( !CG_DemoCam_LookAt( currentcam->trackEnt, cam_origin, cam_angles ) ) {
VectorCopy( currentcam->angles, cam_angles );
}
cam_fov = currentcam->fov;
break;
case DEMOCAM_PATH_LINEAR:
viewType = VIEWDEF_DEMOCAM;
cam_POVent = 0;
VectorCopy( cam_origin, v );
if( !nextcam || nextcam->type == DEMOCAM_FIRSTPERSON || nextcam->type == DEMOCAM_THIRDPERSON ) {
CG_Printf( "Warning: CG_DemoCam: path_linear cam without a valid next cam\n" );
VectorCopy( currentcam->origin, cam_origin );
if( !CG_DemoCam_LookAt( currentcam->trackEnt, cam_origin, cam_angles ) ) {
VectorCopy( currentcam->angles, cam_angles );
}
cam_fov = currentcam->fov;
} else {
VectorLerp( currentcam->origin, lerpfrac, nextcam->origin, cam_origin );
if( !CG_DemoCam_LookAt( currentcam->trackEnt, cam_origin, cam_angles ) ) {
for( i = 0; i < 3; i++ ) cam_angles[i] = LerpAngle( currentcam->angles[i], nextcam->angles[i], lerpfrac );
}
cam_fov = (float)currentcam->fov + (float)( nextcam->fov - currentcam->fov ) * lerpfrac;
}
// set velocity
VectorSubtract( cam_origin, v, cam_velocity );
VectorScale( cam_velocity, 1.0f / (float)cg.frameTime, cam_velocity );
break;
case DEMOCAM_PATH_SPLINE:
viewType = VIEWDEF_DEMOCAM;
cam_POVent = 0;
clamp( lerpfrac, 0, 1 );
VectorCopy( cam_origin, v );
if( !nextcam || nextcam->type == DEMOCAM_FIRSTPERSON || nextcam->type == DEMOCAM_THIRDPERSON ) {
CG_Printf( "Warning: CG_DemoCam: path_spline cam without a valid next cam\n" );
VectorCopy( currentcam->origin, cam_origin );
if( !CG_DemoCam_LookAt( currentcam->trackEnt, cam_origin, cam_angles ) ) {
VectorCopy( currentcam->angles, cam_angles );
}
cam_fov = currentcam->fov;
} else { // valid spline path
#define VectorHermiteInterp( a, at, b, bt, c, v ) ( ( v )[0] = ( 2 * pow( c, 3 ) - 3 * pow( c, 2 ) + 1 ) * a[0] + ( pow( c, 3 ) - 2 * pow( c, 2 ) + c ) * 2 * at[0] + ( -2 * pow( c, 3 ) + 3 * pow( c, 2 ) ) * b[0] + ( pow( c, 3 ) - pow( c, 2 ) ) * 2 * bt[0], ( v )[1] = ( 2 * pow( c, 3 ) - 3 * pow( c, 2 ) + 1 ) * a[1] + ( pow( c, 3 ) - 2 * pow( c, 2 ) + c ) * 2 * at[1] + ( -2 * pow( c, 3 ) + 3 * pow( c, 2 ) ) * b[1] + ( pow( c, 3 ) - pow( c, 2 ) ) * 2 * bt[1], ( v )[2] = ( 2 * pow( c, 3 ) - 3 * pow( c, 2 ) + 1 ) * a[2] + ( pow( c, 3 ) - 2 * pow( c, 2 ) + c ) * 2 * at[2] + ( -2 * pow( c, 3 ) + 3 * pow( c, 2 ) ) * b[2] + ( pow( c, 3 ) - pow( c, 2 ) ) * 2 * bt[2] )
float lerpspline, A, B, C, n1, n2, n3;
cg_democam_t *previouscam = NULL;
cg_democam_t *secondnextcam = NULL;
if( nextcam ) {
secondnextcam = CG_Democam_FindNext( nextcam->timeStamp );
}
if( currentcam->timeStamp > 0 ) {
previouscam = CG_Democam_FindCurrent( currentcam->timeStamp - 1 );
}
if( !previouscam && nextcam && !secondnextcam ) {
lerpfrac = (float)( demo_time - currentcam->timeStamp ) / (float)( nextcam->timeStamp - currentcam->timeStamp );
lerpspline = lerpfrac;
} else if( !previouscam && nextcam && secondnextcam ) {
n1 = nextcam->timeStamp - currentcam->timeStamp;
n2 = secondnextcam->timeStamp - nextcam->timeStamp;
A = n1 * ( n1 - n2 ) / ( pow( n1, 2 ) + n1 * n2 - n1 - n2 );
B = ( 2 * n1 * n2 - n1 - n2 ) / ( pow( n1, 2 ) + n1 * n2 - n1 - n2 );
lerpfrac = (float)( demo_time - currentcam->timeStamp ) / (float)( nextcam->timeStamp - currentcam->timeStamp );
lerpspline = A * pow( lerpfrac, 2 ) + B * lerpfrac;
} else if( previouscam && nextcam && !secondnextcam ) {
n2 = currentcam->timeStamp - previouscam->timeStamp;
n3 = nextcam->timeStamp - currentcam->timeStamp;
A = n3 * ( n2 - n3 ) / ( -n2 - n3 + n2 * n3 + pow( n3, 2 ) );
B = -1 / ( -n2 - n3 + n2 * n3 + pow( n3, 2 ) ) * ( n2 + n3 - 2 * pow( n3, 2 ) );
lerpfrac = (float)( demo_time - currentcam->timeStamp ) / (float)( nextcam->timeStamp - currentcam->timeStamp );
lerpspline = A * pow( lerpfrac, 2 ) + B * lerpfrac;
} else if( previouscam && nextcam && secondnextcam ) {
n1 = currentcam->timeStamp - previouscam->timeStamp;
n2 = nextcam->timeStamp - currentcam->timeStamp;
n3 = secondnextcam->timeStamp - nextcam->timeStamp;
A = -2 * pow( n2, 2 ) * ( -pow( n2, 2 ) + n1 * n3 ) / ( 2 * n2 * n3 + pow( n2, 3 ) * n3 - 3 * pow( n2, 2 ) * n1 + n1 * pow( n2, 3 ) + 2 * n1 * n2 - 3 * pow( n2, 2 ) * n3 - 3 * pow( n2, 3 ) + 2 * pow( n2, 2 ) + pow( n2, 4 ) + n1 * pow( n2, 2 ) * n3 - 3 * n1 * n2 * n3 + 2 * n1 * n3 );
B = pow( n2, 2 ) * ( -2 * n1 - 3 * pow( n2, 2 ) - n2 * n3 + 2 * n3 + 3 * n1 * n3 + n1 * n2 ) / ( 2 * n2 * n3 + pow( n2, 3 ) * n3 - 3 * pow( n2, 2 ) * n1 + n1 * pow( n2, 3 ) + 2 * n1 * n2 - 3 * pow( n2, 2 ) * n3 - 3 * pow( n2, 3 ) + 2 * pow( n2, 2 ) + pow( n2, 4 ) + n1 * pow( n2, 2 ) * n3 - 3 * n1 * n2 * n3 + 2 * n1 * n3 );
C = -( pow( n2, 2 ) * n1 - 2 * n1 * n2 + 3 * n1 * n2 * n3 - 2 * n1 * n3 - 2 * pow( n2, 4 ) + 3 * pow( n2, 3 ) - 2 * pow( n2, 3 ) * n3 + 5 * pow( n2, 2 ) * n3 - 2 * pow( n2, 2 ) - 2 * n2 * n3 ) / ( 2 * n2 * n3 + pow( n2, 3 ) * n3 - 3 * pow( n2, 2 ) * n1 + n1 * pow( n2, 3 ) + 2 * n1 * n2 - 3 * pow( n2, 2 ) * n3 - 3 * pow( n2, 3 ) + 2 * pow( n2, 2 ) + pow( n2, 4 ) + n1 * pow( n2, 2 ) * n3 - 3 * n1 * n2 * n3 + 2 * n1 * n3 );
lerpfrac = (float)( demo_time - currentcam->timeStamp ) / (float)( nextcam->timeStamp - currentcam->timeStamp );
lerpspline = A * pow( lerpfrac, 3 ) + B * pow( lerpfrac, 2 ) + C * lerpfrac;
} else {
lerpfrac = 0;
lerpspline = 0;
}
VectorHermiteInterp( currentcam->origin, currentcam->tangent, nextcam->origin, nextcam->tangent, lerpspline, cam_origin );
if( !CG_DemoCam_LookAt( currentcam->trackEnt, cam_origin, cam_angles ) ) {
VectorHermiteInterp( currentcam->angles, currentcam->angles_tangent, nextcam->angles, nextcam->angles_tangent, lerpspline, cam_angles );
}
cam_fov = (float)currentcam->fov + (float)( nextcam->fov - currentcam->fov ) * lerpfrac;
#undef VectorHermiteInterp
}
// set velocity
VectorSubtract( cam_origin, v, cam_velocity );
VectorScale( cam_velocity, 1.0f / (float)cg.frameTime, cam_velocity );
break;
case DEMOCAM_ORBITAL:
viewType = VIEWDEF_DEMOCAM;
cam_POVent = 0;
cam_fov = currentcam->fov;
VectorCopy( cam_origin, v );
if( !currentcam->trackEnt || currentcam->trackEnt >= MAX_EDICTS ) {
CG_Printf( "Warning: CG_DemoCam: orbital cam needs a track entity set\n" );
VectorCopy( currentcam->origin, cam_origin );
VectorClear( cam_angles );
VectorClear( cam_velocity );
} else {
vec3_t center, forward;
struct cmodel_s *cmodel;
const float ft = (float)cg.frameTime * 0.001f;
// find the trackEnt origin
VectorLerp( cg_entities[currentcam->trackEnt].prev.origin, cg.lerpfrac, cg_entities[currentcam->trackEnt].current.origin, center );
// if having a bounding box, look to its center
if( ( cmodel = CG_CModelForEntity( currentcam->trackEnt ) ) != NULL ) {
vec3_t mins, maxs;
trap_CM_InlineModelBounds( cmodel, mins, maxs );
for( i = 0; i < 3; i++ )
center[i] += ( mins[i] + maxs[i] );
}
if( !cam_orbital_radius ) {
// cam is just started, find distance from cam to trackEnt and keep it as radius
VectorSubtract( currentcam->origin, center, forward );
cam_orbital_radius = VectorNormalize( forward );
VecToAngles( forward, cam_orbital_angles );
}
for( i = 0; i < 3; i++ ) {
cam_orbital_angles[i] += currentcam->angles[i] * ft;
cam_orbital_angles[i] = AngleNormalize360( cam_orbital_angles[i] );
}
AngleVectors( cam_orbital_angles, forward, NULL, NULL );
VectorMA( center, cam_orbital_radius, forward, cam_origin );
// lookat
VectorInverse( forward );
VecToAngles( forward, cam_angles );
}
// set velocity
VectorSubtract( cam_origin, v, cam_velocity );
VectorScale( cam_velocity, 1.0f / ( cg.frameTime * 1000.0f ), cam_velocity );
break;
default:
break;
}
if( currentcam->type != DEMOCAM_ORBITAL ) {
VectorClear( cam_orbital_angles );
cam_orbital_radius = 0;
}
}
return viewType;
}
/*
=================
R_MarkFragments
=================
*/
int R_MarkFragments( int numPoints, const vec3_t *points, const vec3_t projection,
int maxPoints, vec3_t pointBuffer, int maxFragments, markFragment_t *fragmentBuffer ) {
int numsurfaces, numPlanes;
int i, j, k, m, n;
surfaceType_t *surfaces[64];
int surfacesBmodel[64];
int lastBmodel;
vec3_t mins, maxs;
int returnedFragments;
int returnedPoints;
vec3_t normals[MAX_VERTS_ON_POLY+2], localNormals[MAX_VERTS_ON_POLY+2];
float dists[MAX_VERTS_ON_POLY+2], localDists[MAX_VERTS_ON_POLY+2];
vec3_t clipPoints[2][MAX_VERTS_ON_POLY];
int numClipPoints;
float *v;
srfBspSurface_t *cv;
glIndex_t *tri;
srfVert_t *dv;
vec3_t normal;
vec3_t projectionDir, localProjectionDir;
vec3_t v1, v2;
if (numPoints <= 0) {
return 0;
}
//increment view count for double check prevention
tr.viewCount++;
//
VectorNormalize2( projection, projectionDir );
// find all the brushes that are to be considered
ClearBounds( mins, maxs );
for ( i = 0 ; i < numPoints ; i++ ) {
vec3_t temp;
AddPointToBounds( points[i], mins, maxs );
VectorAdd( points[i], projection, temp );
AddPointToBounds( temp, mins, maxs );
// make sure we get all the leafs (also the one(s) in front of the hit surface)
VectorMA( points[i], -20, projectionDir, temp );
AddPointToBounds( temp, mins, maxs );
}
if (numPoints > MAX_VERTS_ON_POLY) numPoints = MAX_VERTS_ON_POLY;
// create the bounding planes for the to be projected polygon
for ( i = 0 ; i < numPoints ; i++ ) {
VectorSubtract(points[(i+1)%numPoints], points[i], v1);
VectorAdd(points[i], projection, v2);
VectorSubtract(points[i], v2, v2);
CrossProduct(v1, v2, normals[i]);
VectorNormalizeFast(normals[i]);
dists[i] = DotProduct(normals[i], points[i]);
}
// add near and far clipping planes for projection
VectorCopy(projectionDir, normals[numPoints]);
dists[numPoints] = DotProduct(normals[numPoints], points[0]) - 32;
VectorCopy(projectionDir, normals[numPoints+1]);
VectorInverse(normals[numPoints+1]);
dists[numPoints+1] = DotProduct(normals[numPoints+1], points[0]) - 20;
numPlanes = numPoints + 2;
numsurfaces = 0;
R_BoxSurfaces_r(tr.world->nodes, mins, maxs, surfaces, surfacesBmodel, 64, &numsurfaces, projectionDir);
//assert(numsurfaces <= 64);
//assert(numsurfaces != 64);
// add bmodel surfaces
for ( j = 1; j < tr.world->numBModels; j++ ) {
vec3_t localProjection, bmodelOrigin, bmodelAxis[3];
R_TransformMarkProjection( j, projection, localProjection, 0, NULL, NULL, NULL, NULL );
R_GetBmodelInfo( j, NULL, bmodelOrigin, bmodelAxis );
VectorNormalize2( localProjection, localProjectionDir );
// find all the brushes that are to be considered
ClearBounds( mins, maxs );
for ( i = 0 ; i < numPoints ; i++ ) {
vec3_t temp;
vec3_t delta;
vec3_t localPoint;
// convert point to bmodel local space
VectorSubtract( points[i], bmodelOrigin, delta );
localPoint[0] = DotProduct( delta, bmodelAxis[0] );
localPoint[1] = DotProduct( delta, bmodelAxis[1] );
localPoint[2] = DotProduct( delta, bmodelAxis[2] );
AddPointToBounds( localPoint, mins, maxs );
VectorAdd( localPoint, localProjection, temp );
AddPointToBounds( temp, mins, maxs );
// make sure we get all the leafs (also the one(s) in front of the hit surface)
VectorMA( localPoint, -20, localProjectionDir, temp );
AddPointToBounds( temp, mins, maxs );
}
R_BmodelSurfaces( j, mins, maxs, surfaces, surfacesBmodel, 64, &numsurfaces, localProjectionDir);
}
returnedPoints = 0;
returnedFragments = 0;
lastBmodel = -1;
for ( i = 0 ; i < numsurfaces ; i++ ) {
if (i == 0 || surfacesBmodel[i] != lastBmodel) {
R_TransformMarkProjection( surfacesBmodel[i], projectionDir, localProjectionDir, numPlanes, normals, dists, localNormals, localDists );
lastBmodel = surfacesBmodel[i];
// don't use projectionDir, normals, or dists beyond this point !!!
// mins and maxs are not setup, so they are not valid !!!
}
if (*surfaces[i] == SF_GRID) {
cv = (srfBspSurface_t *) surfaces[i];
for ( m = 0 ; m < cv->height - 1 ; m++ ) {
for ( n = 0 ; n < cv->width - 1 ; n++ ) {
// We triangulate the grid and chop all triangles within
// the bounding planes of the to be projected polygon.
// LOD is not taken into account, not such a big deal though.
//
// It's probably much nicer to chop the grid itself and deal
// with this grid as a normal SF_GRID surface so LOD will
// be applied. However the LOD of that chopped grid must
// be synced with the LOD of the original curve.
// One way to do this; the chopped grid shares vertices with
// the original curve. When LOD is applied to the original
// curve the unused vertices are flagged. Now the chopped curve
// should skip the flagged vertices. This still leaves the
// problems with the vertices at the chopped grid edges.
//
// To avoid issues when LOD applied to "hollow curves" (like
// the ones around many jump pads) we now just add a 2 unit
// offset to the triangle vertices.
// The offset is added in the vertex normal vector direction
// so all triangles will still fit together.
// The 2 unit offset should avoid pretty much all LOD problems.
numClipPoints = 3;
dv = cv->verts + m * cv->width + n;
VectorCopy(dv[0].xyz, clipPoints[0][0]);
VectorMA(clipPoints[0][0], MARKER_OFFSET, dv[0].normal, clipPoints[0][0]);
VectorCopy(dv[cv->width].xyz, clipPoints[0][1]);
VectorMA(clipPoints[0][1], MARKER_OFFSET, dv[cv->width].normal, clipPoints[0][1]);
VectorCopy(dv[1].xyz, clipPoints[0][2]);
VectorMA(clipPoints[0][2], MARKER_OFFSET, dv[1].normal, clipPoints[0][2]);
// check the normal of this triangle
VectorSubtract(clipPoints[0][0], clipPoints[0][1], v1);
VectorSubtract(clipPoints[0][2], clipPoints[0][1], v2);
CrossProduct(v1, v2, normal);
VectorNormalizeFast(normal);
if (DotProduct(normal, localProjectionDir) < -0.1) {
// add the fragments of this triangle
R_AddMarkFragments(numClipPoints, clipPoints,
numPlanes, localNormals, localDists,
maxPoints, pointBuffer,
maxFragments, fragmentBuffer,
&returnedPoints, &returnedFragments, mins, maxs, lastBmodel, localProjectionDir);
if ( returnedFragments == maxFragments ) {
return returnedFragments; // not enough space for more fragments
}
}
VectorCopy(dv[1].xyz, clipPoints[0][0]);
VectorMA(clipPoints[0][0], MARKER_OFFSET, dv[1].normal, clipPoints[0][0]);
VectorCopy(dv[cv->width].xyz, clipPoints[0][1]);
VectorMA(clipPoints[0][1], MARKER_OFFSET, dv[cv->width].normal, clipPoints[0][1]);
VectorCopy(dv[cv->width+1].xyz, clipPoints[0][2]);
VectorMA(clipPoints[0][2], MARKER_OFFSET, dv[cv->width+1].normal, clipPoints[0][2]);
// check the normal of this triangle
VectorSubtract(clipPoints[0][0], clipPoints[0][1], v1);
VectorSubtract(clipPoints[0][2], clipPoints[0][1], v2);
CrossProduct(v1, v2, normal);
VectorNormalizeFast(normal);
if (DotProduct(normal, localProjectionDir) < -0.05) {
// add the fragments of this triangle
R_AddMarkFragments(numClipPoints, clipPoints,
numPlanes, localNormals, localDists,
maxPoints, pointBuffer,
maxFragments, fragmentBuffer,
&returnedPoints, &returnedFragments, mins, maxs, lastBmodel, localProjectionDir);
if ( returnedFragments == maxFragments ) {
return returnedFragments; // not enough space for more fragments
}
}
}
}
}
else if (*surfaces[i] == SF_FACE) {
srfBspSurface_t *surf = ( srfBspSurface_t * ) surfaces[i];
// check the normal of this face
if (DotProduct(surf->cullPlane.normal, localProjectionDir) > -0.5) {
continue;
}
for(k = 0, tri = surf->indexes; k < surf->numIndexes; k += 3, tri += 3)
{
for(j = 0; j < 3; j++)
{
v = surf->verts[tri[j]].xyz;
VectorMA(v, MARKER_OFFSET, surf->cullPlane.normal, clipPoints[0][j]);
}
// add the fragments of this face
R_AddMarkFragments( 3 , clipPoints,
numPlanes, localNormals, localDists,
maxPoints, pointBuffer,
maxFragments, fragmentBuffer,
&returnedPoints, &returnedFragments, mins, maxs, lastBmodel, localProjectionDir);
if ( returnedFragments == maxFragments ) {
return returnedFragments; // not enough space for more fragments
}
}
}
else if(*surfaces[i] == SF_TRIANGLES && r_marksOnTriangleMeshes->integer) {
srfBspSurface_t *surf = (srfBspSurface_t *) surfaces[i];
for(k = 0, tri = surf->indexes; k < surf->numIndexes; k += 3, tri += 3)
{
for(j = 0; j < 3; j++)
{
v = surf->verts[tri[j]].xyz;
VectorMA(v, MARKER_OFFSET, surf->verts[tri[j]].normal, clipPoints[0][j]);
}
// add the fragments of this face
R_AddMarkFragments(3, clipPoints,
numPlanes, localNormals, localDists,
maxPoints, pointBuffer,
maxFragments, fragmentBuffer, &returnedPoints, &returnedFragments, mins, maxs, lastBmodel, localProjectionDir);
if(returnedFragments == maxFragments)
{
return returnedFragments; // not enough space for more fragments
}
}
}
}
return returnedFragments;
}
/*
================
R_AliasSetUpTransform
================
*/
static void R_AliasSetUpTransform (int trivial_accept)
{
int i;
float rotationmatrix[3][4], t2matrix[3][4];
static float tmatrix[3][4];
static float viewmatrix[3][4];
vec3_t angles;
float entScale;
float xyfact = 1.0, zfact = 1.0; // avoid compiler warning
float forward;
float yaw, pitch;
// TODO: should really be stored with the entity instead of being reconstructed
// TODO: should use a look-up table
// TODO: could cache lazily, stored in the entity
if (currententity->model->flags & EF_FACE_VIEW)
{
VectorSubtract(currententity->origin,r_origin,angles);
VectorSubtract(r_origin,currententity->origin,angles);
VectorNormalize(angles);
if (angles[1] == 0 && angles[0] == 0)
{
yaw = 0;
if (angles[2] > 0)
pitch = 90;
else
pitch = 270;
}
else
{
yaw = (int) (atan2(angles[1], angles[0]) * 180 / M_PI);
if (yaw < 0)
yaw += 360;
forward = sqrt (angles[0]*angles[0] + angles[1]*angles[1]);
pitch = (int) (atan2(angles[2], forward) * 180 / M_PI);
if (pitch < 0)
pitch += 360;
}
angles[0] = -pitch;
angles[1] = yaw;
// angles[2] = 0;
angles[2] = currententity->angles[ROLL];
}
else
{
angles[ROLL] = currententity->angles[ROLL];
angles[PITCH] = -currententity->angles[PITCH];
if (currententity->model->flags & EF_ROTATE)
{
angles[YAW] = anglemod( (currententity->origin[0] + currententity->origin[1])*0.8
+ (108*cl.time) );
}
else
{
angles[YAW] = currententity->angles[YAW];
}
}
// For clientside rotation stuff
angles[0] += currententity->angleAdd[0];
angles[1] += currententity->angleAdd[1];
angles[2] += currententity->angleAdd[2];
AngleVectors (angles, alias_forward, alias_right, alias_up);
if (currententity->scale != 0 && currententity->scale != 100)
{
entScale = (float)currententity->scale/100.0;
switch (currententity->drawflags & SCALE_TYPE_MASKIN)
{
case SCALE_TYPE_UNIFORM:
tmatrix[0][0] = pmdl->scale[0]*entScale;
tmatrix[1][1] = pmdl->scale[1]*entScale;
tmatrix[2][2] = pmdl->scale[2]*entScale;
xyfact = zfact = (entScale-1.0)*127.95;
break;
case SCALE_TYPE_XYONLY:
tmatrix[0][0] = pmdl->scale[0]*entScale;
tmatrix[1][1] = pmdl->scale[1]*entScale;
tmatrix[2][2] = pmdl->scale[2];
xyfact = (entScale-1.0)*127.95;
zfact = 1.0;
break;
case SCALE_TYPE_ZONLY:
tmatrix[0][0] = pmdl->scale[0];
tmatrix[1][1] = pmdl->scale[1];
tmatrix[2][2] = pmdl->scale[2]*entScale;
xyfact = 1.0;
zfact = (entScale-1.0)*127.95;
break;
}
switch (currententity->drawflags & SCALE_ORIGIN_MASKIN)
{
case SCALE_ORIGIN_CENTER:
tmatrix[0][3] = pmdl->scale_origin[0]-pmdl->scale[0]*xyfact;
tmatrix[1][3] = pmdl->scale_origin[1]-pmdl->scale[1]*xyfact;
tmatrix[2][3] = pmdl->scale_origin[2]-pmdl->scale[2]*zfact;
break;
case SCALE_ORIGIN_BOTTOM:
tmatrix[0][3] = pmdl->scale_origin[0]-pmdl->scale[0]*xyfact;
tmatrix[1][3] = pmdl->scale_origin[1]-pmdl->scale[1]*xyfact;
tmatrix[2][3] = pmdl->scale_origin[2];
break;
case SCALE_ORIGIN_TOP:
tmatrix[0][3] = pmdl->scale_origin[0]-pmdl->scale[0]*xyfact;
tmatrix[1][3] = pmdl->scale_origin[1]-pmdl->scale[1]*xyfact;
tmatrix[2][3] = pmdl->scale_origin[2]-pmdl->scale[2]*zfact*2.0;
break;
}
}
else
{
tmatrix[0][0] = pmdl->scale[0];
tmatrix[1][1] = pmdl->scale[1];
tmatrix[2][2] = pmdl->scale[2];
tmatrix[0][3] = pmdl->scale_origin[0];
tmatrix[1][3] = pmdl->scale_origin[1];
tmatrix[2][3] = pmdl->scale_origin[2];
}
if (currententity->model->flags & EF_ROTATE)
{
// Floating motion
tmatrix[2][3] += sin(currententity->origin[0]
+ currententity->origin[1]
+ (cl.time*3)) * 5.5;
}
// TODO: can do this with simple matrix rearrangement
for (i = 0 ; i < 3 ; i++)
{
t2matrix[i][0] = alias_forward[i];
t2matrix[i][1] = -alias_right[i];
t2matrix[i][2] = alias_up[i];
}
t2matrix[0][3] = -modelorg[0];
t2matrix[1][3] = -modelorg[1];
t2matrix[2][3] = -modelorg[2];
// FIXME: can do more efficiently than full concatenation
R_ConcatTransforms (t2matrix, tmatrix, rotationmatrix);
// TODO: should be global, set when vright, etc., set
VectorCopy (vright, viewmatrix[0]);
VectorCopy (vup, viewmatrix[1]);
VectorInverse (viewmatrix[1]);
VectorCopy (vpn, viewmatrix[2]);
// viewmatrix[0][3] = 0;
// viewmatrix[1][3] = 0;
// viewmatrix[2][3] = 0;
R_ConcatTransforms (viewmatrix, rotationmatrix, aliastransform);
// do the scaling up of x and y to screen coordinates as part of the transform
// for the unclipped case (it would mess up clipping in the clipped case).
// Also scale down z, so 1/z is scaled 31 bits for free, and scale down x and y
// correspondingly so the projected x and y come out right
// FIXME: make this work for clipped case too?
if (trivial_accept)
{
for (i = 0 ; i < 4 ; i++)
{
aliastransform[0][i] *= aliasxscale * (1.0 / ((float)0x8000 * 0x10000));
aliastransform[1][i] *= aliasyscale * (1.0 / ((float)0x8000 * 0x10000));
aliastransform[2][i] *= 1.0 / ((float)0x8000 * 0x10000);
}
}
}
/*
=================
R_MarkFragments
=================
*/
int R_MarkFragments( int numPoints, const vec3_t *points, const vec3_t projection,
int maxPoints, vec3_t pointBuffer, int maxFragments, markFragment_t *fragmentBuffer ) {
int numsurfaces, numPlanes;
int i, j, k, m, n;
surfaceType_t *surfaces[64];
vec3_t mins, maxs;
int returnedFragments;
int returnedPoints;
vec3_t normals[MAX_VERTS_ON_POLY+2];
float dists[MAX_VERTS_ON_POLY+2];
vec3_t clipPoints[2][MAX_VERTS_ON_POLY];
int numClipPoints;
float *v;
srfSurfaceFace_t *surf;
srfGridMesh_t *cv;
drawVert_t *dv;
vec3_t normal;
vec3_t projectionDir;
vec3_t v1, v2;
int *indexes;
//increment view count for double check prevention
tr.viewCount++;
//
VectorNormalize2( projection, projectionDir );
// find all the brushes that are to be considered
ClearBounds( mins, maxs );
for ( i = 0 ; i < numPoints ; i++ ) {
vec3_t temp;
AddPointToBounds( points[i], mins, maxs );
VectorAdd( points[i], projection, temp );
AddPointToBounds( temp, mins, maxs );
// make sure we get all the leafs (also the one(s) in front of the hit surface)
VectorMA( points[i], -20, projectionDir, temp );
AddPointToBounds( temp, mins, maxs );
}
if (numPoints > MAX_VERTS_ON_POLY) numPoints = MAX_VERTS_ON_POLY;
// create the bounding planes for the to be projected polygon
for ( i = 0 ; i < numPoints ; i++ ) {
VectorSubtract(points[(i+1)%numPoints], points[i], v1);
VectorAdd(points[i], projection, v2);
VectorSubtract(points[i], v2, v2);
CrossProduct(v1, v2, normals[i]);
VectorNormalizeFast(normals[i]);
dists[i] = DotProduct(normals[i], points[i]);
}
// add near and far clipping planes for projection
VectorCopy(projectionDir, normals[numPoints]);
dists[numPoints] = DotProduct(normals[numPoints], points[0]) - 32;
VectorCopy(projectionDir, normals[numPoints+1]);
VectorInverse(normals[numPoints+1]);
dists[numPoints+1] = DotProduct(normals[numPoints+1], points[0]) - 20;
numPlanes = numPoints + 2;
numsurfaces = 0;
R_BoxSurfaces_r(tr.world->nodes, mins, maxs, surfaces, 64, &numsurfaces, projectionDir);
//assert(numsurfaces <= 64);
//assert(numsurfaces != 64);
returnedPoints = 0;
returnedFragments = 0;
for ( i = 0 ; i < numsurfaces ; i++ ) {
if (*surfaces[i] == SF_GRID) {
cv = (srfGridMesh_t *) surfaces[i];
for ( m = 0 ; m < cv->height - 1 ; m++ ) {
for ( n = 0 ; n < cv->width - 1 ; n++ ) {
// We triangulate the grid and chop all triangles within
// the bounding planes of the to be projected polygon.
// LOD is not taken into account, not such a big deal though.
//
// It's probably much nicer to chop the grid itself and deal
// with this grid as a normal SF_GRID surface so LOD will
// be applied. However the LOD of that chopped grid must
// be synced with the LOD of the original curve.
// One way to do this; the chopped grid shares vertices with
// the original curve. When LOD is applied to the original
// curve the unused vertices are flagged. Now the chopped curve
// should skip the flagged vertices. This still leaves the
// problems with the vertices at the chopped grid edges.
//
// To avoid issues when LOD applied to "hollow curves" (like
// the ones around many jump pads) we now just add a 2 unit
// offset to the triangle vertices.
// The offset is added in the vertex normal vector direction
// so all triangles will still fit together.
// The 2 unit offset should avoid pretty much all LOD problems.
numClipPoints = 3;
dv = cv->verts + m * cv->width + n;
VectorCopy(dv[0].xyz, clipPoints[0][0]);
VectorMA(clipPoints[0][0], MARKER_OFFSET, dv[0].normal, clipPoints[0][0]);
VectorCopy(dv[cv->width].xyz, clipPoints[0][1]);
VectorMA(clipPoints[0][1], MARKER_OFFSET, dv[cv->width].normal, clipPoints[0][1]);
VectorCopy(dv[1].xyz, clipPoints[0][2]);
VectorMA(clipPoints[0][2], MARKER_OFFSET, dv[1].normal, clipPoints[0][2]);
// check the normal of this triangle
VectorSubtract(clipPoints[0][0], clipPoints[0][1], v1);
VectorSubtract(clipPoints[0][2], clipPoints[0][1], v2);
CrossProduct(v1, v2, normal);
VectorNormalizeFast(normal);
if (DotProduct(normal, projectionDir) < -0.1) {
// add the fragments of this triangle
R_AddMarkFragments(numClipPoints, clipPoints,
numPlanes, normals, dists,
maxPoints, pointBuffer,
maxFragments, fragmentBuffer,
&returnedPoints, &returnedFragments, mins, maxs);
if ( returnedFragments == maxFragments ) {
return returnedFragments; // not enough space for more fragments
}
}
VectorCopy(dv[1].xyz, clipPoints[0][0]);
VectorMA(clipPoints[0][0], MARKER_OFFSET, dv[1].normal, clipPoints[0][0]);
VectorCopy(dv[cv->width].xyz, clipPoints[0][1]);
VectorMA(clipPoints[0][1], MARKER_OFFSET, dv[cv->width].normal, clipPoints[0][1]);
VectorCopy(dv[cv->width+1].xyz, clipPoints[0][2]);
VectorMA(clipPoints[0][2], MARKER_OFFSET, dv[cv->width+1].normal, clipPoints[0][2]);
// check the normal of this triangle
VectorSubtract(clipPoints[0][0], clipPoints[0][1], v1);
VectorSubtract(clipPoints[0][2], clipPoints[0][1], v2);
CrossProduct(v1, v2, normal);
VectorNormalizeFast(normal);
if (DotProduct(normal, projectionDir) < -0.05) {
// add the fragments of this triangle
R_AddMarkFragments(numClipPoints, clipPoints,
numPlanes, normals, dists,
maxPoints, pointBuffer,
maxFragments, fragmentBuffer,
&returnedPoints, &returnedFragments, mins, maxs);
if ( returnedFragments == maxFragments ) {
return returnedFragments; // not enough space for more fragments
}
}
}
}
}
else if (*surfaces[i] == SF_FACE) {
surf = ( srfSurfaceFace_t * ) surfaces[i];
// check the normal of this face
if (DotProduct(surf->plane.normal, projectionDir) > -0.5) {
continue;
}
/*
VectorSubtract(clipPoints[0][0], clipPoints[0][1], v1);
VectorSubtract(clipPoints[0][2], clipPoints[0][1], v2);
CrossProduct(v1, v2, normal);
VectorNormalize(normal);
if (DotProduct(normal, projectionDir) > -0.5) continue;
*/
indexes = (int *)( (byte *)surf + surf->ofsIndices );
for ( k = 0 ; k < surf->numIndices ; k += 3 ) {
for ( j = 0 ; j < 3 ; j++ ) {
v = surf->points[0] + VERTEXSIZE * indexes[k+j];;
VectorMA( v, MARKER_OFFSET, surf->plane.normal, clipPoints[0][j] );
}
// add the fragments of this face
R_AddMarkFragments( 3 , clipPoints,
numPlanes, normals, dists,
maxPoints, pointBuffer,
maxFragments, fragmentBuffer,
&returnedPoints, &returnedFragments, mins, maxs);
if ( returnedFragments == maxFragments ) {
return returnedFragments; // not enough space for more fragments
}
}
continue;
}
else {
// ignore all other world surfaces
// might be cool to also project polygons on a triangle soup
// however this will probably create huge amounts of extra polys
// even more than the projection onto curves
continue;
}
}
return returnedFragments;
}
/*
* 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 );
}
/*
================
G_CreateRotationMatrix
================
*/
void G_CreateRotationMatrix(vec3_t angles, vec3_t matrix[3]) {
AngleVectors(angles, matrix[0], matrix[1], matrix[2]);
VectorInverse(matrix[1]);
}
/*
* R_DrawSkyPortal
*/
void R_DrawSkyPortal( const entity_t *e, skyportal_t *skyportal, vec3_t mins, vec3_t maxs )
{
int x, y, w, h;
if( !R_ScissorForEntity( e, mins, maxs, &x, &y, &w, &h ) ) {
return;
}
if( !R_PushRefInst() ) {
return;
}
rn.renderFlags = ( rn.renderFlags|RF_SKYPORTALVIEW|RF_SOFT_PARTICLES );
VectorCopy( skyportal->vieworg, rn.pvsOrigin );
rn.farClip = R_DefaultFarClip();
rn.clipFlags = 15;
rn.shadowGroup = NULL;
rn.meshlist = &r_skyportallist;
//Vector4Set( rn.scissor, rn.refdef.x + x, rn.refdef.y + y, w, h );
if( skyportal->noEnts ) {
rn.renderFlags |= RF_NOENTS;
}
if( skyportal->scale )
{
vec3_t centre, diff;
VectorAdd( rsh.worldModel->mins, rsh.worldModel->maxs, centre );
VectorScale( centre, 0.5f, centre );
VectorSubtract( centre, rn.viewOrigin, diff );
VectorMA( skyportal->vieworg, -skyportal->scale, diff, rn.refdef.vieworg );
}
else
{
VectorCopy( skyportal->vieworg, rn.refdef.vieworg );
}
// FIXME
if( !VectorCompare( skyportal->viewanglesOffset, vec3_origin ) )
{
vec3_t angles;
mat3_t axis;
Matrix3_Copy( rn.refdef.viewaxis, axis );
VectorInverse( &axis[AXIS_RIGHT] );
Matrix3_ToAngles( axis, angles );
VectorAdd( angles, skyportal->viewanglesOffset, angles );
AnglesToAxis( angles, axis );
Matrix3_Copy( axis, rn.refdef.viewaxis );
}
rn.refdef.rdflags &= ~( RDF_UNDERWATER|RDF_CROSSINGWATER|RDF_SKYPORTALINVIEW );
if( skyportal->fov )
{
rn.refdef.fov_x = skyportal->fov;
rn.refdef.fov_y = CalcFov( rn.refdef.fov_x, rn.refdef.width, rn.refdef.height );
if( glConfig.wideScreen && !( rn.refdef.rdflags & RDF_NOFOVADJUSTMENT ) )
AdjustFov( &rn.refdef.fov_x, &rn.refdef.fov_y, glConfig.width, glConfig.height, qfalse );
}
R_RenderView( &rn.refdef );
// restore modelview and projection matrices, scissoring, etc for the main view
R_PopRefInst( ~GL_COLOR_BUFFER_BIT );
}
