raven/jedioutcast
0
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
jedioutcast/CODE-mp/renderer/tr_surfacesprites.cpp

1463 lines
42 KiB
C++
Raw Normal View History

Jedi Outcast v055
2013-04-04 18:01:17 +00:00
// tr_shade.c
#include "tr_local.h"
Jedi Outcast Release v1.0
2013-04-04 18:24:26 +00:00
#include "tr_QuickSprite.h"
#include "tr_WorldEffects.h"
Jedi Outcast v055
2013-04-04 18:01:17 +00:00
/////===== Part of the VERTIGON system =====/////
// The surfacesprites are a simple system. When a polygon with this shader stage on it is drawn,
// there are randomly distributed images (defined by the shader stage) placed on the surface.
// these are capable of doing effects, grass, or simple oriented sprites.
// They usually stick vertically off the surface, hence the term vertigons.
// The vertigons are applied as part of the renderer backend. That is, they access OpenGL calls directly.
unsigned char randomindex, randominterval;
const float randomchart[256] = {
0.6554f, 0.6909f, 0.4806f, 0.6218f, 0.5717f, 0.3896f, 0.0677f, 0.7356f,
0.8333f, 0.1105f, 0.4445f, 0.8161f, 0.4689f, 0.0433f, 0.7152f, 0.0336f,
0.0186f, 0.9140f, 0.1626f, 0.6553f, 0.8340f, 0.7094f, 0.2020f, 0.8087f,
0.9119f, 0.8009f, 0.1339f, 0.8492f, 0.9173f, 0.5003f, 0.6012f, 0.6117f,
0.5525f, 0.5787f, 0.1586f, 0.3293f, 0.9273f, 0.7791f, 0.8589f, 0.4985f,
0.0883f, 0.8545f, 0.2634f, 0.4727f, 0.3624f, 0.1631f, 0.7825f, 0.0662f,
0.6704f, 0.3510f, 0.7525f, 0.9486f, 0.4685f, 0.1535f, 0.1545f, 0.1121f,
0.4724f, 0.8483f, 0.3833f, 0.1917f, 0.8207f, 0.3885f, 0.9702f, 0.9200f,
0.8348f, 0.7501f, 0.6675f, 0.4994f, 0.0301f, 0.5225f, 0.8011f, 0.1696f,
0.5351f, 0.2752f, 0.2962f, 0.7550f, 0.5762f, 0.7303f, 0.2835f, 0.4717f,
0.1818f, 0.2739f, 0.6914f, 0.7748f, 0.7640f, 0.8355f, 0.7314f, 0.5288f,
0.7340f, 0.6692f, 0.6813f, 0.2810f, 0.8057f, 0.0648f, 0.8749f, 0.9199f,
0.1462f, 0.5237f, 0.3014f, 0.4994f, 0.0278f, 0.4268f, 0.7238f, 0.5107f,
0.1378f, 0.7303f, 0.7200f, 0.3819f, 0.2034f, 0.7157f, 0.5552f, 0.4887f,
0.0871f, 0.3293f, 0.2892f, 0.4545f, 0.0088f, 0.1404f, 0.0275f, 0.0238f,
0.0515f, 0.4494f, 0.7206f, 0.2893f, 0.6060f, 0.5785f, 0.4182f, 0.5528f,
0.9118f, 0.8742f, 0.3859f, 0.6030f, 0.3495f, 0.4550f, 0.9875f, 0.6900f,
0.6416f, 0.2337f, 0.7431f, 0.9788f, 0.6181f, 0.2464f, 0.4661f, 0.7621f,
0.7020f, 0.8203f, 0.8869f, 0.2145f, 0.7724f, 0.6093f, 0.6692f, 0.9686f,
0.5609f, 0.0310f, 0.2248f, 0.2950f, 0.2365f, 0.1347f, 0.2342f, 0.1668f,
0.3378f, 0.4330f, 0.2775f, 0.9901f, 0.7053f, 0.7266f, 0.4840f, 0.2820f,
0.5733f, 0.4555f, 0.6049f, 0.0770f, 0.4760f, 0.6060f, 0.4159f, 0.3427f,
0.1234f, 0.7062f, 0.8569f, 0.1878f, 0.9057f, 0.9399f, 0.8139f, 0.1407f,
0.1794f, 0.9123f, 0.9493f, 0.2827f, 0.9934f, 0.0952f, 0.4879f, 0.5160f,
0.4118f, 0.4873f, 0.3642f, 0.7470f, 0.0866f, 0.5172f, 0.6365f, 0.2676f,
0.2407f, 0.7223f, 0.5761f, 0.1143f, 0.7137f, 0.2342f, 0.3353f, 0.6880f,
0.2296f, 0.6023f, 0.6027f, 0.4138f, 0.5408f, 0.9859f, 0.1503f, 0.7238f,
0.6054f, 0.2477f, 0.6804f, 0.1432f, 0.4540f, 0.9776f, 0.8762f, 0.7607f,
0.9025f, 0.9807f, 0.0652f, 0.8661f, 0.7663f, 0.2586f, 0.3994f, 0.0335f,
0.7328f, 0.0166f, 0.9589f, 0.4348f, 0.5493f, 0.7269f, 0.6867f, 0.6614f,
0.6800f, 0.7804f, 0.5591f, 0.8381f, 0.0910f, 0.7573f, 0.8985f, 0.3083f,
0.3188f, 0.8481f, 0.2356f, 0.6736f, 0.4770f, 0.4560f, 0.6266f, 0.4677f
};
#define WIND_DAMP_INTERVAL 50
#define WIND_GUST_TIME 2500.0
#define WIND_GUST_DECAY (1.0 / WIND_GUST_TIME)
int lastSSUpdateTime = 0;
float curWindSpeed=0;
float curWindGust=5;
float curWeatherAmount=1;
vec3_t curWindBlowVect={0,0,0}, targetWindBlowVect={0,0,0};
vec3_t curWindGrassDir={0,0,0}, targetWindGrassDir={0,0,0};
int totalsurfsprites=0, sssurfaces=0;
qboolean curWindPointActive=qfalse;
float curWindPointForce = 0;
vec3_t curWindPoint;
int nextGustTime=0;
float gustLeft=0;
qboolean standardfovinitialized=qfalse;
float standardfovx = 90, standardscalex = 1.0;
float rangescalefactor=1.0;
vec3_t ssrightvectors[4];
vec3_t ssfwdvector;
int rightvectorcount;
trRefEntity_t *ssLastEntityDrawn=NULL;
vec3_t ssViewOrigin, ssViewRight, ssViewUp;
static void R_SurfaceSpriteFrameUpdate(void)
{
float dtime, dampfactor; // Time since last update and damping time for wind changes
float ratio;
vec3_t ang, diff, retwindvec;
float targetspeed;
vec3_t up={0,0,1};
if (backEnd.refdef.time == lastSSUpdateTime)
return;
if (backEnd.refdef.time < lastSSUpdateTime)
{ // Time is BEFORE the last update time, so reset everything.
curWindGust = 5;
curWindSpeed = r_windSpeed->value;
nextGustTime = 0;
gustLeft = 0;
}
// Reset the last entity drawn, since this is a new frame.
ssLastEntityDrawn = NULL;
// Adjust for an FOV. If things look twice as wide on the screen, pretend the shaders have twice the range.
// ASSUMPTION HERE IS THAT "standard" fov is the first one rendered.
if (!standardfovinitialized)
{ // This isn't initialized yet.
if (backEnd.refdef.fov_x > 50 && backEnd.refdef.fov_x < 135) // I don't consider anything below 50 or above 135 to be "normal".
{
standardfovx = backEnd.refdef.fov_x;
standardscalex = tan(standardfovx * 0.5 * (M_PI/180.0f));
standardfovinitialized = qtrue;
}
else
{
standardfovx = 90;
standardscalex = tan(standardfovx * 0.5 * (M_PI/180.0f));
}
rangescalefactor = 1.0; // Don't multiply the shader range by anything.
}
else if (standardfovx == backEnd.refdef.fov_x)
{ // This is the standard FOV (or higher), don't multiply the shader range.
rangescalefactor = 1.0;
}
else
{ // We are using a non-standard FOV. We need to multiply the range of the shader by a scale factor.
if (backEnd.refdef.fov_x > 135)
{
rangescalefactor = standardscalex / tan(135.0f * 0.5f * (M_PI/180.0f));
}
else
{
rangescalefactor = standardscalex / tan(backEnd.refdef.fov_x * 0.5 * (M_PI/180.0f));
}
}
// Create a set of four right vectors so that vertical sprites aren't always facing the same way.
// First generate a HORIZONTAL forward vector (important).
CrossProduct(ssViewRight, up, ssfwdvector);
// Right Zero has a nudge forward (10 degrees).
VectorScale(ssViewRight, 0.985f, ssrightvectors[0]);
VectorMA(ssrightvectors[0], 0.174f, ssfwdvector, ssrightvectors[0]);
// Right One has a big nudge back (30 degrees).
VectorScale(ssViewRight, 0.866f, ssrightvectors[1]);
VectorMA(ssrightvectors[1], -0.5f, ssfwdvector, ssrightvectors[1]);
// Right two has a big nudge forward (30 degrees).
VectorScale(ssViewRight, 0.866f, ssrightvectors[2]);
VectorMA(ssrightvectors[2], 0.5f, ssfwdvector, ssrightvectors[2]);
// Right three has a nudge back (10 degrees).
VectorScale(ssViewRight, 0.985f, ssrightvectors[3]);
VectorMA(ssrightvectors[3], -0.174f, ssfwdvector, ssrightvectors[3]);
// Update the wind.
// If it is raining, get the windspeed from the rain system rather than the cvar
if (R_IsRaining() || R_IsSnowing())
{
curWeatherAmount = 1.0;
}
else
{
curWeatherAmount = r_surfaceWeather->value;
}
if (R_GetWindSpeed(targetspeed))
{ // We successfully got a speed from the rain system.
// Set the windgust to 5, since that looks pretty good.
targetspeed *= 0.3f;
if (targetspeed >= 1.0)
{
curWindGust = 300/targetspeed;
}
else
{
curWindGust = 0;
}
}
else
{ // Use the cvar.
targetspeed = r_windSpeed->value; // Minimum gust delay, in seconds.
curWindGust = r_windGust->value;
}
if (targetspeed > 0 && curWindGust)
{
if (gustLeft > 0)
{ // We are gusting
// Add an amount to the target wind speed
targetspeed *= 1.0 + gustLeft;
gustLeft -= (float)(backEnd.refdef.time - lastSSUpdateTime)*WIND_GUST_DECAY;
if (gustLeft <= 0)
{
nextGustTime = backEnd.refdef.time + (curWindGust*1000)*flrand(1.0f,4.0f);
}
}
else if (backEnd.refdef.time >= nextGustTime)
{ // See if there is another right now
// Gust next time, mano
gustLeft = flrand(0.75f,1.5f);
}
}
// See if there is a weather system that will tell us a windspeed.
if (R_GetWindVector(retwindvec))
{
retwindvec[2]=0;
VectorScale(retwindvec, -1.0f, retwindvec);
vectoangles(retwindvec, ang);
}
else
{ // Calculate the target wind vector based off cvars
ang[YAW] = r_windAngle->value;
}
ang[PITCH] = -90.0 + targetspeed;
if (ang[PITCH]>-45.0)
{
ang[PITCH] = -45.0;
}
ang[ROLL] = 0;
if (targetspeed>0)
{
// ang[YAW] += cos(tr.refdef.time*0.01+flrand(-1.0,1.0))*targetspeed*0.5;
// ang[PITCH] += sin(tr.refdef.time*0.01+flrand(-1.0,1.0))*targetspeed*0.5;
}
// Get the grass wind vector first
AngleVectors(ang, targetWindGrassDir, NULL, NULL);
targetWindGrassDir[2]-=1.0;
// VectorScale(targetWindGrassDir, targetspeed, targetWindGrassDir);
// Now get the general wind vector (no pitch)
ang[PITCH]=0;
AngleVectors(ang, targetWindBlowVect, NULL, NULL);
// Start calculating a smoothing factor so wind doesn't change abruptly between speeds.
dampfactor = 1.0-r_windDampFactor->value; // We must exponent the amount LEFT rather than the amount bled off
dtime = (float)(backEnd.refdef.time - lastSSUpdateTime) * (1.0/(float)WIND_DAMP_INTERVAL); // Our dampfactor is geared towards a time interval equal to "1".
// Note that since there are a finite number of "practical" delta millisecond values possible,
// the ratio should be initialized into a chart ultimately.
ratio = pow(dampfactor, dtime);
// Apply this ratio to the windspeed...
curWindSpeed = targetspeed - (ratio * (targetspeed-curWindSpeed));
// Use the curWindSpeed to calculate the final target wind vector (with speed)
VectorScale(targetWindBlowVect, curWindSpeed, targetWindBlowVect);
VectorSubtract(targetWindBlowVect, curWindBlowVect, diff);
VectorMA(targetWindBlowVect, -ratio, diff, curWindBlowVect);
// Update the grass vector now
VectorSubtract(targetWindGrassDir, curWindGrassDir, diff);
VectorMA(targetWindGrassDir, -ratio, diff, curWindGrassDir);
lastSSUpdateTime = backEnd.refdef.time;
curWindPointForce = r_windPointForce->value - (ratio * (r_windPointForce->value - curWindPointForce));
if (curWindPointForce < 0.01)
{
curWindPointActive = qfalse;
}
else
{
curWindPointActive = qtrue;
curWindPoint[0] = r_windPointX->value;
curWindPoint[1] = r_windPointY->value;
curWindPoint[2] = 0;
}
if (r_surfaceSprites->integer >= 2)
{
Com_Printf("Surfacesprites Drawn: %d, on %d surfaces\n", totalsurfsprites, sssurfaces);
}
totalsurfsprites=0;
sssurfaces=0;
}
/////////////////////////////////////////////
// Surface sprite calculation and drawing.
/////////////////////////////////////////////
#define FADE_RANGE 250.0
#define WINDPOINT_RADIUS 750.0
float SSVertAlpha[SHADER_MAX_VERTEXES];
float SSVertWindForce[SHADER_MAX_VERTEXES];
vec2_t SSVertWindDir[SHADER_MAX_VERTEXES];
qboolean SSAdditiveTransparency=qfalse;
qboolean SSUsingFog=qfalse;
/////////////////////////////////////////////
// Vertical surface sprites
static void RB_VerticalSurfaceSprite(vec3_t loc, float width, float height, byte light,
byte alpha, float wind, float windidle, vec2_t fog, int hangdown, vec2_t skew)
{
vec3_t loc2, right;
float angle;
float windsway;
float points[16];
color4ub_t color;
angle = ((loc[0]+loc[1])*0.02+(tr.refdef.time*0.0015));
if (windidle>0.0)
{
windsway = (height*windidle*0.075);
loc2[0] = loc[0]+skew[0]+cos(angle)*windsway;
loc2[1] = loc[1]+skew[1]+sin(angle)*windsway;
if (hangdown)
{
loc2[2] = loc[2]-height;
}
else
{
loc2[2] = loc[2]+height;
}
}
else
{
loc2[0] = loc[0]+skew[0];
loc2[1] = loc[1]+skew[1];
if (hangdown)
{
loc2[2] = loc[2]-height;
}
else
{
loc2[2] = loc[2]+height;
}
}
if (wind>0.0 && curWindSpeed > 0.001)
{
windsway = (height*wind*0.075);
// Add the angle
VectorMA(loc2, height*wind, curWindGrassDir, loc2);
// Bob up and down
if (curWindSpeed < 40.0)
{
windsway *= curWindSpeed*(1.0/100.0);
}
else
{
windsway *= 0.4f;
}
loc2[2] += sin(angle*2.5)*windsway;
}
VectorScale(ssrightvectors[rightvectorcount], width*0.5, right);
color[0]=light;
color[1]=light;
color[2]=light;
color[3]=alpha;
// Bottom right
// VectorAdd(loc, right, point);
points[0] = loc[0] + right[0];
points[1] = loc[1] + right[1];
points[2] = loc[2] + right[2];
points[3] = 0;
// Top right
// VectorAdd(loc2, right, point);
points[4] = loc2[0] + right[0];
points[5] = loc2[1] + right[1];
points[6] = loc2[2] + right[2];
points[7] = 0;
// Top left
// VectorSubtract(loc2, right, point);
points[8] = loc2[0] - right[0] + ssfwdvector[0] * width * 0.2;
points[9] = loc2[1] - right[1] + ssfwdvector[1] * width * 0.2;
points[10] = loc2[2] - right[2];
points[11] = 0;
// Bottom left
// VectorSubtract(loc, right, point);
points[12] = loc[0] - right[0];
points[13] = loc[1] - right[1];
points[14] = loc[2] - right[2];
points[15] = 0;
// Add the sprite to the render list.
SQuickSprite.Add(points, color, fog);
}
static void RB_VerticalSurfaceSpriteWindPoint(vec3_t loc, float width, float height, byte light,
byte alpha, float wind, float windidle, vec2_t fog,
int hangdown, vec2_t skew, vec2_t winddiff, float windforce)
{
vec3_t loc2, right;
float angle;
float windsway;
float points[16];
color4ub_t color;
if (windforce > 1)
windforce = 1;
// wind += 1.0-windforce;
angle = (loc[0]+loc[1])*0.02+(tr.refdef.time*0.0015);
if (curWindSpeed <80.0)
{
windsway = (height*windidle*0.1)*(1.0+windforce);
loc2[0] = loc[0]+skew[0]+cos(angle)*windsway;
loc2[1] = loc[1]+skew[1]+sin(angle)*windsway;
}
else
{
loc2[0] = loc[0]+skew[0];
loc2[1] = loc[1]+skew[1];
}
if (hangdown)
{
loc2[2] = loc[2]-height;
}
else
{
loc2[2] = loc[2]+height;
}
if (curWindSpeed > 0.001)
{
// Add the angle
VectorMA(loc2, height*wind, curWindGrassDir, loc2);
}
loc2[0] += height*winddiff[0]*windforce;
loc2[1] += height*winddiff[1]*windforce;
loc2[2] -= height*windforce*(0.75 + 0.15*sin((tr.refdef.time + 500*windforce)*0.01));
VectorScale(ssrightvectors[rightvectorcount], width*0.5, right);
color[0]=light;
color[1]=light;
color[2]=light;
color[3]=alpha;
// Bottom right
// VectorAdd(loc, right, point);
points[0] = loc[0] + right[0];
points[1] = loc[1] + right[1];
points[2] = loc[2] + right[2];
points[3] = 0;
// Top right
// VectorAdd(loc2, right, point);
points[4] = loc2[0] + right[0];
points[5] = loc2[1] + right[1];
points[6] = loc2[2] + right[2];
points[7] = 0;
// Top left
// VectorSubtract(loc2, right, point);
points[8] = loc2[0] - right[0] + ssfwdvector[0] * width * 0.15;
points[9] = loc2[1] - right[1] + ssfwdvector[1] * width * 0.15;
points[10] = loc2[2] - right[2];
points[11] = 0;
// Bottom left
// VectorSubtract(loc, right, point);
points[12] = loc[0] - right[0];
points[13] = loc[1] - right[1];
points[14] = loc[2] - right[2];
points[15] = 0;
// Add the sprite to the render list.
SQuickSprite.Add(points, color, fog);
}
static void RB_DrawVerticalSurfaceSprites( shaderStage_t *stage, shaderCommands_t *input)
{
int curindex, curvert;
vec3_t dist;
float triarea;
vec2_t vec1to2, vec1to3;
vec3_t v1,v2,v3;
float a1,a2,a3;
float l1,l2,l3;
vec2_t fog1, fog2, fog3;
vec2_t winddiff1, winddiff2, winddiff3;
float windforce1, windforce2, windforce3;
float posi, posj;
float step;
float fa,fb,fc;
vec3_t curpoint;
float width, height;
float alpha, alphapos, thisspritesfadestart, light;
byte randomindex2;
vec2_t skew={0,0};
vec2_t fogv;
vec2_t winddiffv;
float windforce=0;
qboolean usewindpoint = (qboolean) !! (curWindPointActive && stage->ss.wind > 0);
float cutdist=stage->ss.fadeMax*rangescalefactor, cutdist2=cutdist*cutdist;
float fadedist=stage->ss.fadeDist*rangescalefactor, fadedist2=fadedist*fadedist;
assert(cutdist2 != fadedist2);
float inv_fadediff = 1.0/(cutdist2-fadedist2);
// The faderange is the fraction amount it takes for these sprites to fade out, assuming an ideal fade range of 250
float faderange = FADE_RANGE/(cutdist-fadedist);
if (faderange > 1.0)
{ // Don't want to force a new fade_rand
faderange = 1.0;
}
// Quickly calc all the alphas and windstuff for each vertex
for (curvert=0; curvert<input->numVertexes; curvert++)
{
VectorSubtract(ssViewOrigin, input->xyz[curvert], dist);
SSVertAlpha[curvert] = 1.0 - (VectorLengthSquared(dist) - fadedist2) * inv_fadediff;
}
// Wind only needs initialization once per tess.
if (usewindpoint && !tess.SSInitializedWind)
{
for (curvert=0; curvert<input->numVertexes;curvert++)
{ // Calc wind at each point
dist[0]=input->xyz[curvert][0] - curWindPoint[0];
dist[1]=input->xyz[curvert][1] - curWindPoint[1];
step = (dist[0]*dist[0] + dist[1]*dist[1]); // dist squared
if (step >= (float)(WINDPOINT_RADIUS*WINDPOINT_RADIUS))
{ // No wind
SSVertWindDir[curvert][0] = 0;
SSVertWindDir[curvert][1] = 0;
SSVertWindForce[curvert]=0; // Should be < 1
}
else
{
if (step<1)
{ // Don't want to divide by zero
SSVertWindDir[curvert][0] = 0;
SSVertWindDir[curvert][1] = 0;
SSVertWindForce[curvert] = curWindPointForce * stage->ss.wind;
}
else
{
step = Q_rsqrt(step); // Equals 1 over the distance.
SSVertWindDir[curvert][0] = dist[0] * step;
SSVertWindDir[curvert][1] = dist[1] * step;
step = 1.0 - (1.0 / (step * WINDPOINT_RADIUS)); // 1- (dist/maxradius) = a scale from 0 to 1 linearly dropping off
SSVertWindForce[curvert] = curWindPointForce * stage->ss.wind * step; // *step means divide by the distance.
}
}
}
tess.SSInitializedWind = qtrue;
}
for (curindex=0; curindex<input->numIndexes-2; curindex+=3)
{
curvert = input->indexes[curindex];
VectorCopy(input->xyz[curvert], v1);
if (stage->ss.facing)
{ // Hang down
if (input->normal[curvert][2] > -0.5)
{
continue;
}
}
else
{ // Point up
if (input->normal[curvert][2] < 0.5)
{
continue;
}
}
l1 = input->vertexColors[curvert][2];
a1 = SSVertAlpha[curvert];
fog1[0] = *((float *)(tess.svars.texcoords[0])+(curvert<<1));
fog1[1] = *((float *)(tess.svars.texcoords[0])+(curvert<<1)+1);
winddiff1[0] = SSVertWindDir[curvert][0];
winddiff1[1] = SSVertWindDir[curvert][1];
windforce1 = SSVertWindForce[curvert];
curvert = input->indexes[curindex+1];
VectorCopy(input->xyz[curvert], v2);
if (stage->ss.facing)
{ // Hang down
if (input->normal[curvert][2] > -0.5)
{
continue;
}
}
else
{ // Point up
if (input->normal[curvert][2] < 0.5)
{
continue;
}
}
l2 = input->vertexColors[curvert][2];
a2 = SSVertAlpha[curvert];
fog2[0] = *((float *)(tess.svars.texcoords[0])+(curvert<<1));
fog2[1] = *((float *)(tess.svars.texcoords[0])+(curvert<<1)+1);
winddiff2[0] = SSVertWindDir[curvert][0];
winddiff2[1] = SSVertWindDir[curvert][1];
windforce2 = SSVertWindForce[curvert];
curvert = input->indexes[curindex+2];
VectorCopy(input->xyz[curvert], v3);
if (stage->ss.facing)
{ // Hang down
if (input->normal[curvert][2] > -0.5)
{
continue;
}
}
else
{ // Point up
if (input->normal[curvert][2] < 0.5)
{
continue;
}
}
l3 = input->vertexColors[curvert][2];
a3 = SSVertAlpha[curvert];
fog3[0] = *((float *)(tess.svars.texcoords[0])+(curvert<<1));
fog3[1] = *((float *)(tess.svars.texcoords[0])+(curvert<<1)+1);
winddiff3[0] = SSVertWindDir[curvert][0];
winddiff3[1] = SSVertWindDir[curvert][1];
windforce3 = SSVertWindForce[curvert];
if (a1 <= 0.0 && a2 <= 0.0 && a3 <= 0.0)
{
continue;
}
// Find the area in order to calculate the stepsize
vec1to2[0] = v2[0] - v1[0];
vec1to2[1] = v2[1] - v1[1];
vec1to3[0] = v3[0] - v1[0];
vec1to3[1] = v3[1] - v1[1];
// Now get the cross product of this sum.
triarea = vec1to3[0]*vec1to2[1] - vec1to3[1]*vec1to2[0];
triarea=fabs(triarea);
if (triarea <= 1.0)
{ // Insanely small abhorrent triangle.
continue;
}
step = stage->ss.density * Q_rsqrt(triarea);
randomindex = (byte)(v1[0]+v1[1]+v2[0]+v2[1]+v3[0]+v3[1]);
randominterval = (byte)(v1[0]+v2[1]+v3[2])|0x03; // Make sure the interval is at least 3, and always odd
rightvectorcount = 0;
for (posi=0; posi<1.0; posi+=step)
{
for (posj=0; posj<(1.0-posi); posj+=step)
{
fa=posi+randomchart[randomindex]*step;
randomindex += randominterval;
fb=posj+randomchart[randomindex]*step;
randomindex += randominterval;
rightvectorcount=(rightvectorcount+1)&3;
if (fa>1.0)
continue;
if (fb>(1.0-fa))
continue;
fc = 1.0-fa-fb;
// total alpha, minus random factor so some things fade out sooner.
alphapos = a1*fa + a2*fb + a3*fc;
// Note that the alpha at this point is a value from 1.0 to 0.0, but represents when to START fading
thisspritesfadestart = faderange + (1.0-faderange) * randomchart[randomindex];
randomindex += randominterval;
// Find where the alpha is relative to the fadestart, and calc the real alpha to draw at.
alpha = 1.0 - ((thisspritesfadestart-alphapos)/faderange);
if (alpha > 0.0)
{
if (alpha > 1.0)
alpha=1.0;
if (SSUsingFog)
{
fogv[0] = fog1[0]*fa + fog2[0]*fb + fog3[0]*fc;
fogv[1] = fog1[1]*fa + fog2[1]*fb + fog3[1]*fc;
}
if (usewindpoint)
{
winddiffv[0] = winddiff1[0]*fa + winddiff2[0]*fb + winddiff3[0]*fc;
winddiffv[1] = winddiff1[1]*fa + winddiff2[1]*fb + winddiff3[1]*fc;
windforce = windforce1*fa + windforce2*fb + windforce3*fc;
}
VectorScale(v1, fa, curpoint);
VectorMA(curpoint, fb, v2, curpoint);
VectorMA(curpoint, fc, v3, curpoint);
light = l1*fa + l2*fb + l3*fc;
if (SSAdditiveTransparency)
{ // Additive transparency, scale light value
// light *= alpha;
light = (128 + (light*0.5))*alpha;
alpha = 1.0;
}
randomindex2 = randomindex;
width = stage->ss.width*(1.0 + (stage->ss.variance[0]*randomchart[randomindex2]));
height = stage->ss.height*(1.0 + (stage->ss.variance[1]*randomchart[randomindex2++]));
if (randomchart[randomindex2++]>0.5)
{
width = -width;
}
if (stage->ss.fadeScale!=0 && alphapos < 1.0)
{
width *= 1.0 + (stage->ss.fadeScale*(1.0-alphapos));
}
if (stage->ss.vertSkew != 0)
{ // flrand(-vertskew, vertskew)
skew[0] = height * ((stage->ss.vertSkew*2.0f*randomchart[randomindex2++])-stage->ss.vertSkew);
skew[1] = height * ((stage->ss.vertSkew*2.0f*randomchart[randomindex2++])-stage->ss.vertSkew);
}
if (usewindpoint && windforce > 0 && stage->ss.wind > 0.0)
{
if (SSUsingFog)
{
RB_VerticalSurfaceSpriteWindPoint(curpoint, width, height, (byte)light, (byte)(alpha*255.0),
stage->ss.wind, stage->ss.windIdle, fogv, stage->ss.facing, skew,
winddiffv, windforce);
}
else
{
RB_VerticalSurfaceSpriteWindPoint(curpoint, width, height, (byte)light, (byte)(alpha*255.0),
stage->ss.wind, stage->ss.windIdle, NULL, stage->ss.facing, skew,
winddiffv, windforce);
}
}
else
{
if (SSUsingFog)
{
RB_VerticalSurfaceSprite(curpoint, width, height, (byte)light, (byte)(alpha*255.0),
stage->ss.wind, stage->ss.windIdle, fogv, stage->ss.facing, skew);
}
else
{
RB_VerticalSurfaceSprite(curpoint, width, height, (byte)light, (byte)(alpha*255.0),
stage->ss.wind, stage->ss.windIdle, NULL, stage->ss.facing, skew);
}
}
totalsurfsprites++;
}
}
}
}
}
/////////////////////////////////////////////
// Oriented surface sprites
static void RB_OrientedSurfaceSprite(vec3_t loc, float width, float height, byte light, byte alpha, vec2_t fog, int faceup)
{
vec3_t loc2, right;
float points[16];
color4ub_t color;
color[0]=light;
color[1]=light;
color[2]=light;
color[3]=alpha;
if (faceup)
{
width *= 0.5;
height *= 0.5;
// Bottom right
// VectorAdd(loc, right, point);
points[0] = loc[0] + width;
points[1] = loc[1] - width;
points[2] = loc[2] + 1.0;
points[3] = 0;
// Top right
// VectorAdd(loc, right, point);
points[4] = loc[0] + width;
points[5] = loc[1] + width;
points[6] = loc[2] + 1.0;
points[7] = 0;
// Top left
// VectorSubtract(loc, right, point);
points[8] = loc[0] - width;
points[9] = loc[1] + width;
points[10] = loc[2] + 1.0;
points[11] = 0;
// Bottom left
// VectorSubtract(loc, right, point);
points[12] = loc[0] - width;
points[13] = loc[1] - width;
points[14] = loc[2] + 1.0;
points[15] = 0;
}
else
{
VectorMA(loc, height, ssViewUp, loc2);
VectorScale(ssViewRight, width*0.5, right);
// Bottom right
// VectorAdd(loc, right, point);
points[0] = loc[0] + right[0];
points[1] = loc[1] + right[1];
points[2] = loc[2] + right[2];
points[3] = 0;
// Top right
// VectorAdd(loc2, right, point);
points[4] = loc2[0] + right[0];
points[5] = loc2[1] + right[1];
points[6] = loc2[2] + right[2];
points[7] = 0;
// Top left
// VectorSubtract(loc2, right, point);
points[8] = loc2[0] - right[0];
points[9] = loc2[1] - right[1];
points[10] = loc2[2] - right[2];
points[11] = 0;
// Bottom left
// VectorSubtract(loc, right, point);
points[12] = loc[0] - right[0];
points[13] = loc[1] - right[1];
points[14] = loc[2] - right[2];
points[15] = 0;
}
// Add the sprite to the render list.
SQuickSprite.Add(points, color, fog);
}
static void RB_DrawOrientedSurfaceSprites( shaderStage_t *stage, shaderCommands_t *input)
{
int curindex, curvert;
vec3_t dist;
float triarea, minnormal;
vec2_t vec1to2, vec1to3;
vec3_t v1,v2,v3;
float a1,a2,a3;
float l1,l2,l3;
vec2_t fog1, fog2, fog3;
float posi, posj;
float step;
float fa,fb,fc;
vec3_t curpoint;
float width, height;
float alpha, alphapos, thisspritesfadestart, light;
byte randomindex2;
vec2_t fogv;
float cutdist=stage->ss.fadeMax*rangescalefactor, cutdist2=cutdist*cutdist;
float fadedist=stage->ss.fadeDist*rangescalefactor, fadedist2=fadedist*fadedist;
assert(cutdist2 != fadedist2);
float inv_fadediff = 1.0/(cutdist2-fadedist2);
// The faderange is the fraction amount it takes for these sprites to fade out, assuming an ideal fade range of 250
float faderange = FADE_RANGE/(cutdist-fadedist);
if (faderange > 1.0)
{ // Don't want to force a new fade_rand
faderange = 1.0;
}
if (stage->ss.facing)
{ // Faceup sprite.
minnormal = 0.99f;
}
else
{ // Normal oriented sprite
minnormal = 0.5f;
}
// Quickly calc all the alphas for each vertex
for (curvert=0; curvert<input->numVertexes; curvert++)
{
// Calc alpha at each point
VectorSubtract(ssViewOrigin, input->xyz[curvert], dist);
SSVertAlpha[curvert] = 1.0 - (VectorLengthSquared(dist) - fadedist2) * inv_fadediff;
}
for (curindex=0; curindex<input->numIndexes-2; curindex+=3)
{
curvert = input->indexes[curindex];
VectorCopy(input->xyz[curvert], v1);
if (input->normal[curvert][2] < minnormal)
{
continue;
}
l1 = input->vertexColors[curvert][2];
a1 = SSVertAlpha[curvert];
fog1[0] = *((float *)(tess.svars.texcoords[0])+(curvert<<1));
fog1[1] = *((float *)(tess.svars.texcoords[0])+(curvert<<1)+1);
curvert = input->indexes[curindex+1];
VectorCopy(input->xyz[curvert], v2);
if (input->normal[curvert][2] < minnormal)
{
continue;
}
l2 = input->vertexColors[curvert][2];
a2 = SSVertAlpha[curvert];
fog2[0] = *((float *)(tess.svars.texcoords[0])+(curvert<<1));
fog2[1] = *((float *)(tess.svars.texcoords[0])+(curvert<<1)+1);
curvert = input->indexes[curindex+2];
VectorCopy(input->xyz[curvert], v3);
if (input->normal[curvert][2] < minnormal)
{
continue;
}
l3 = input->vertexColors[curvert][2];
a3 = SSVertAlpha[curvert];
fog3[0] = *((float *)(tess.svars.texcoords[0])+(curvert<<1));
fog3[1] = *((float *)(tess.svars.texcoords[0])+(curvert<<1)+1);
if (a1 <= 0.0 && a2 <= 0.0 && a3 <= 0.0)
{
continue;
}
// Find the area in order to calculate the stepsize
vec1to2[0] = v2[0] - v1[0];
vec1to2[1] = v2[1] - v1[1];
vec1to3[0] = v3[0] - v1[0];
vec1to3[1] = v3[1] - v1[1];
// Now get the cross product of this sum.
triarea = vec1to3[0]*vec1to2[1] - vec1to3[1]*vec1to2[0];
triarea=fabs(triarea);
if (triarea <= 1.0)
{ // Insanely small abhorrent triangle.
continue;
}
step = stage->ss.density * Q_rsqrt(triarea);
randomindex = (byte)(v1[0]+v1[1]+v2[0]+v2[1]+v3[0]+v3[1]);
randominterval = (byte)(v1[0]+v2[1]+v3[2])|0x03; // Make sure the interval is at least 3, and always odd
for (posi=0; posi<1.0; posi+=step)
{
for (posj=0; posj<(1.0-posi); posj+=step)
{
fa=posi+randomchart[randomindex]*step;
randomindex += randominterval;
if (fa>1.0)
continue;
fb=posj+randomchart[randomindex]*step;
randomindex += randominterval;
if (fb>(1.0-fa))
continue;
fc = 1.0-fa-fb;
// total alpha, minus random factor so some things fade out sooner.
alphapos = a1*fa + a2*fb + a3*fc;
// Note that the alpha at this point is a value from 1.0 to 0.0, but represents when to START fading
thisspritesfadestart = faderange + (1.0-faderange) * randomchart[randomindex];
randomindex += randominterval;
// Find where the alpha is relative to the fadestart, and calc the real alpha to draw at.
alpha = 1.0 - ((thisspritesfadestart-alphapos)/faderange);
randomindex += randominterval;
if (alpha > 0.0)
{
if (alpha > 1.0)
alpha=1.0;
if (SSUsingFog)
{
fogv[0] = fog1[0]*fa + fog2[0]*fb + fog3[0]*fc;
fogv[1] = fog1[1]*fa + fog2[1]*fb + fog3[1]*fc;
}
VectorScale(v1, fa, curpoint);
VectorMA(curpoint, fb, v2, curpoint);
VectorMA(curpoint, fc, v3, curpoint);
light = l1*fa + l2*fb + l3*fc;
if (SSAdditiveTransparency)
{ // Additive transparency, scale light value
// light *= alpha;
light = (128 + (light*0.5))*alpha;
alpha = 1.0;
}
randomindex2 = randomindex;
width = stage->ss.width*(1.0 + (stage->ss.variance[0]*randomchart[randomindex2]));
height = stage->ss.height*(1.0 + (stage->ss.variance[1]*randomchart[randomindex2++]));
if (randomchart[randomindex2++]>0.5)
{
width = -width;
}
if (stage->ss.fadeScale!=0 && alphapos < 1.0)
{
width *= 1.0 + (stage->ss.fadeScale*(1.0-alphapos));
}
if (SSUsingFog)
{
RB_OrientedSurfaceSprite(curpoint, width, height, (byte)light, (byte)(alpha*255.0), fogv, stage->ss.facing);
}
else
{
RB_OrientedSurfaceSprite(curpoint, width, height, (byte)light, (byte)(alpha*255.0), NULL, stage->ss.facing);
}
totalsurfsprites++;
}
}
}
}
}
/////////////////////////////////////////////
// Effect surface sprites
static void RB_EffectSurfaceSprite(vec3_t loc, float width, float height, byte light, byte alpha, float life, int faceup)
{
vec3_t loc2, right;
float points[16];
color4ub_t color;
color[0]=light; //light;
color[1]=light; //light;
color[2]=light; //light;
color[3]=alpha; //alpha;
if (faceup)
{
width *= 0.5;
height *= 0.5;
// Bottom right
// VectorAdd(loc, right, point);
points[0] = loc[0] + width;
points[1] = loc[1] - width;
points[2] = loc[2] + 1.0;
points[3] = 0;
// Top right
// VectorAdd(loc, right, point);
points[4] = loc[0] + width;
points[5] = loc[1] + width;
points[6] = loc[2] + 1.0;
points[7] = 0;
// Top left
// VectorSubtract(loc, right, point);
points[8] = loc[0] - width;
points[9] = loc[1] + width;
points[10] = loc[2] + 1.0;
points[11] = 0;
// Bottom left
// VectorSubtract(loc, right, point);
points[12] = loc[0] - width;
points[13] = loc[1] - width;
points[14] = loc[2] + 1.0;
points[15] = 0;
}
else
{
VectorMA(loc, height, ssViewUp, loc2);
VectorScale(ssViewRight, width*0.5, right);
// Bottom right
// VectorAdd(loc, right, point);
points[0] = loc[0] + right[0];
points[1] = loc[1] + right[1];
points[2] = loc[2] + right[2];
points[3] = 0;
// Top right
// VectorAdd(loc2, right, point);
points[4] = loc2[0] + right[0];
points[5] = loc2[1] + right[1];
points[6] = loc2[2] + right[2];
points[7] = 0;
// Top left
// VectorSubtract(loc2, right, point);
points[8] = loc2[0] - right[0];
points[9] = loc2[1] - right[1];
points[10] = loc2[2] - right[2];
points[11] = 0;
// Bottom left
// VectorSubtract(loc, right, point);
points[12] = loc[0] - right[0];
points[13] = loc[1] - right[1];
points[14] = loc[2] - right[2];
points[15] = 0;
}
// Add the sprite to the render list.
SQuickSprite.Add(points, color, NULL);
}
static void RB_DrawEffectSurfaceSprites( shaderStage_t *stage, shaderCommands_t *input)
{
int curindex, curvert;
vec3_t dist;
float triarea, minnormal;
vec2_t vec1to2, vec1to3;
vec3_t v1,v2,v3;
float a1,a2,a3;
float l1,l2,l3;
float posi, posj;
float step;
float fa,fb,fc;
float effecttime, effectpos;
float density;
vec3_t curpoint;
float width, height;
float alpha, alphapos, thisspritesfadestart, light;
byte randomindex2;
float cutdist=stage->ss.fadeMax*rangescalefactor, cutdist2=cutdist*cutdist;
float fadedist=stage->ss.fadeDist*rangescalefactor, fadedist2=fadedist*fadedist;
float fxalpha = stage->ss.fxAlphaEnd - stage->ss.fxAlphaStart;
qboolean fadeinout=qfalse;
assert(cutdist2 != fadedist2);
float inv_fadediff = 1.0/(cutdist2-fadedist2);
// The faderange is the fraction amount it takes for these sprites to fade out, assuming an ideal fade range of 250
float faderange = FADE_RANGE/(cutdist-fadedist);
if (faderange > 1.0f)
{ // Don't want to force a new fade_rand
faderange = 1.0f;
}
if (stage->ss.facing)
{ // Faceup sprite.
minnormal = 0.99f;
}
else
{ // Normal oriented sprite
minnormal = 0.5f;
}
// Make the object fade in.
if (stage->ss.fxAlphaEnd < 0.05 && stage->ss.height >= 0.1 && stage->ss.width >= 0.1)
{ // The sprite fades out, and it doesn't start at a pinpoint. Let's fade it in.
fadeinout=qtrue;
}
if (stage->ss.surfaceSpriteType == SURFSPRITE_WEATHERFX)
{ // This effect is affected by weather settings.
if (curWeatherAmount < 0.01)
{ // Don't show these effects
return;
}
else
{
density = stage->ss.density / curWeatherAmount;
}
}
else
{
density = stage->ss.density;
}
// Quickly calc all the alphas for each vertex
for (curvert=0; curvert<input->numVertexes; curvert++)
{
// Calc alpha at each point
VectorSubtract(ssViewOrigin, input->xyz[curvert], dist);
SSVertAlpha[curvert] = 1.0f - (VectorLengthSquared(dist) - fadedist2) * inv_fadediff;
// Note this is the proper equation, but isn't used right now because it would be just a tad slower.
// Formula for alpha is 1.0f - ((len-fade)/(cut-fade))
// Which is equal to (1.0+fade/(cut-fade)) - (len/(cut-fade))
// So mult=1/(cut-fade), and base=(1+fade*mult).
// SSVertAlpha[curvert] = fadebase - (VectorLength(dist) * fademult);
}
for (curindex=0; curindex<input->numIndexes-2; curindex+=3)
{
curvert = input->indexes[curindex];
VectorCopy(input->xyz[curvert], v1);
if (input->normal[curvert][2] < minnormal)
{
continue;
}
l1 = input->vertexColors[curvert][2];
a1 = SSVertAlpha[curvert];
curvert = input->indexes[curindex+1];
VectorCopy(input->xyz[curvert], v2);
if (input->normal[curvert][2] < minnormal)
{
continue;
}
l2 = input->vertexColors[curvert][2];
a2 = SSVertAlpha[curvert];
curvert = input->indexes[curindex+2];
VectorCopy(input->xyz[curvert], v3);
if (input->normal[curvert][2] < minnormal)
{
continue;
}
l3 = input->vertexColors[curvert][2];
a3 = SSVertAlpha[curvert];
if (a1 <= 0.0f && a2 <= 0.0f && a3 <= 0.0f)
{
continue;
}
// Find the area in order to calculate the stepsize
vec1to2[0] = v2[0] - v1[0];
vec1to2[1] = v2[1] - v1[1];
vec1to3[0] = v3[0] - v1[0];
vec1to3[1] = v3[1] - v1[1];
// Now get the cross product of this sum.
triarea = vec1to3[0]*vec1to2[1] - vec1to3[1]*vec1to2[0];
triarea=fabs(triarea);
if (triarea <= 1.0f)
{ // Insanely small abhorrent triangle.
continue;
}
step = density * Q_rsqrt(triarea);
randomindex = (byte)(v1[0]+v1[1]+v2[0]+v2[1]+v3[0]+v3[1]);
randominterval = (byte)(v1[0]+v2[1]+v3[2])|0x03; // Make sure the interval is at least 3, and always odd
for (posi=0; posi<1.0f; posi+=step)
{
for (posj=0; posj<(1.0-posi); posj+=step)
{
effecttime = (tr.refdef.time+10000.0*randomchart[randomindex])/stage->ss.fxDuration;
effectpos = (float)effecttime - (int)effecttime;
randomindex2 = randomindex+effecttime;
randomindex += randominterval;
fa=posi+randomchart[randomindex2++]*step;
if (fa>1.0f)
continue;
fb=posj+randomchart[randomindex2++]*step;
if (fb>(1.0-fa))
continue;
fc = 1.0-fa-fb;
// total alpha, minus random factor so some things fade out sooner.
alphapos = a1*fa + a2*fb + a3*fc;
// Note that the alpha at this point is a value from 1.0f to 0.0, but represents when to START fading
thisspritesfadestart = faderange + (1.0-faderange) * randomchart[randomindex2];
randomindex2 += randominterval;
// Find where the alpha is relative to the fadestart, and calc the real alpha to draw at.
alpha = 1.0f - ((thisspritesfadestart-alphapos)/faderange);
if (alpha > 0.0f)
{
if (alpha > 1.0f)
alpha=1.0f;
VectorScale(v1, fa, curpoint);
VectorMA(curpoint, fb, v2, curpoint);
VectorMA(curpoint, fc, v3, curpoint);
light = l1*fa + l2*fb + l3*fc;
randomindex2 = randomindex;
width = stage->ss.width*(1.0f + (stage->ss.variance[0]*randomchart[randomindex2]));
height = stage->ss.height*(1.0f + (stage->ss.variance[1]*randomchart[randomindex2++]));
width = width + (effectpos*stage->ss.fxGrow[0]*width);
height = height + (effectpos*stage->ss.fxGrow[1]*height);
// If we want to fade in and out, that's different than a straight fade.
if (fadeinout)
{
if (effectpos > 0.5)
{ // Fade out
alpha = alpha*(stage->ss.fxAlphaStart+(fxalpha*(effectpos-0.5)*2.0));
}
else
{ // Fade in
alpha = alpha*(stage->ss.fxAlphaStart+(fxalpha*(0.5-effectpos)*2.0));
}
}
else
{ // Normal fade
alpha = alpha*(stage->ss.fxAlphaStart+(fxalpha*effectpos));
}
if (SSAdditiveTransparency)
{ // Additive transparency, scale light value
// light *= alpha;
light = (128 + (light*0.5))*alpha;
alpha = 1.0;
}
if (randomchart[randomindex2]>0.5f)
{
width = -width;
}
if (stage->ss.fadeScale!=0 && alphapos < 1.0f)
{
width *= 1.0f + (stage->ss.fadeScale*(1.0-alphapos));
}
if (stage->ss.wind>0.0f && curWindSpeed > 0.001)
{
vec3_t drawpoint;
VectorMA(curpoint, effectpos*stage->ss.wind, curWindBlowVect, drawpoint);
RB_EffectSurfaceSprite(drawpoint, width, height, (byte)light, (byte)(alpha*255.0f), stage->ss.fxDuration, stage->ss.facing);
}
else
{
RB_EffectSurfaceSprite(curpoint, width, height, (byte)light, (byte)(alpha*255.0f), stage->ss.fxDuration, stage->ss.facing);
}
totalsurfsprites++;
}
}
}
}
}
extern void R_WorldToLocal (vec3_t world, vec3_t localVec) ;
extern float preTransEntMatrix[16], invEntMatrix[16];
extern void R_InvertMatrix(float *sourcemat, float *destmat);
void RB_DrawSurfaceSprites( shaderStage_t *stage, shaderCommands_t *input)
{
fog_t *fog;
unsigned long glbits=stage->stateBits;
R_SurfaceSpriteFrameUpdate();
//
// Check fog
//
if ( tess.fogNum && tess.shader->fogPass) // && r_drawfog->value)
{
fog = tr.world->fogs + tess.fogNum;
SSUsingFog = qtrue;
SQuickSprite.StartGroup(&stage->bundle[0], glbits, fog->colorInt);
}
else
{
SSUsingFog = qfalse;
SQuickSprite.StartGroup(&stage->bundle[0], glbits);
}
// Special provision in case the transparency is additive.
if ((glbits & (GLS_SRCBLEND_BITS|GLS_DSTBLEND_BITS)) == (GLS_SRCBLEND_ONE|GLS_DSTBLEND_ONE))
{ // Additive transparency, scale light value
SSAdditiveTransparency=qtrue;
}
else
{
SSAdditiveTransparency=qfalse;
}
//Check if this is a new entity transformation (incl. world entity), and update the appropriate vectors if so.
if (backEnd.currentEntity != ssLastEntityDrawn)
{
if (backEnd.currentEntity == &tr.worldEntity)
{ // Drawing the world, so our job is dead-easy, in the viewparms
Jedi Outcast Release v1.0
2013-04-04 18:24:26 +00:00
VectorCopy(backEnd.viewParms.ori.origin, ssViewOrigin);
VectorCopy(backEnd.viewParms.ori.axis[1], ssViewRight);
VectorCopy(backEnd.viewParms.ori.axis[2], ssViewUp);
Jedi Outcast v055
2013-04-04 18:01:17 +00:00
}
else
{ // Drawing an entity, so we need to transform the viewparms to the model's coordinate system
Jedi Outcast Release v1.0
2013-04-04 18:24:26 +00:00
// R_WorldPointToEntity (backEnd.viewParms.ori.origin, ssViewOrigin);
R_WorldNormalToEntity (backEnd.viewParms.ori.axis[1], ssViewRight);
R_WorldNormalToEntity (backEnd.viewParms.ori.axis[2], ssViewUp);
VectorCopy(backEnd.ori.viewOrigin, ssViewOrigin);
// R_WorldToLocal(backEnd.viewParms.ori.axis[1], ssViewRight);
// R_WorldToLocal(backEnd.viewParms.ori.axis[2], ssViewUp);
Jedi Outcast v055
2013-04-04 18:01:17 +00:00
}
ssLastEntityDrawn = backEnd.currentEntity;
}
switch(stage->ss.surfaceSpriteType)
{
case SURFSPRITE_VERTICAL:
RB_DrawVerticalSurfaceSprites(stage, input);
break;
case SURFSPRITE_ORIENTED:
RB_DrawOrientedSurfaceSprites(stage, input);
break;
case SURFSPRITE_EFFECT:
case SURFSPRITE_WEATHERFX:
RB_DrawEffectSurfaceSprites(stage, input);
break;
}
SQuickSprite.EndGroup();
sssurfaces++;
}
Reference in a new issue Copy permalink