// r_light.c
#include "quakedef.h"
+#include "cl_collision.h"
rdlight_t r_dlight[MAX_DLIGHTS];
int r_numdlights = 0;
cvar_t r_lightmodels = {CVAR_SAVE, "r_lightmodels", "1"};
cvar_t r_vismarklights = {0, "r_vismarklights", "1"};
-cvar_t r_lightmodelhardness = {CVAR_SAVE, "r_lightmodelhardness", "0.9"};
+//cvar_t r_lightmodelhardness = {CVAR_SAVE, "r_lightmodelhardness", "1"};
static rtexture_t *lightcorona;
static rtexturepool_t *lighttexturepool;
{
float dx, dy;
int x, y, a;
- byte pixels[32][32][4];
+ qbyte pixels[32][32][4];
lighttexturepool = R_AllocTexturePool();
for (y = 0;y < 32;y++)
{
for (x = 0;x < 32;x++)
{
dx = (x - 15.5f) * (1.0f / 16.0f);
- a = ((1.0f / (dx * dx + dy * dy + 0.2f)) - (1.0f / (1.0f + 0.2))) * 8.0f / (1.0f / (1.0f + 0.2));
+ a = ((1.0f / (dx * dx + dy * dy + 0.2f)) - (1.0f / (1.0f + 0.2))) * 64.0f / (1.0f / (1.0f + 0.2));
a = bound(0, a, 255);
pixels[y][x][0] = 255;
pixels[y][x][1] = 255;
pixels[y][x][2] = 255;
pixels[y][x][3] = a;
- /*
- // for testing the size of the corona textures
- if (a == 0)
- {
- pixels[y][x][0] = 255;
- pixels[y][x][1] = 0;
- pixels[y][x][2] = 0;
- pixels[y][x][3] = 255;
- }
- */
}
}
lightcorona = R_LoadTexture (lighttexturepool, "lightcorona", 32, 32, &pixels[0][0][0], TEXTYPE_RGBA, TEXF_PRECACHE | TEXF_ALPHA);
void R_Light_Init(void)
{
Cvar_RegisterVariable(&r_lightmodels);
- Cvar_RegisterVariable(&r_lightmodelhardness);
+ //Cvar_RegisterVariable(&r_lightmodelhardness);
Cvar_RegisterVariable(&r_vismarklights);
R_RegisterModule("R_Light", r_light_start, r_light_shutdown, r_light_newmap);
}
{
// trace to a point just barely closer to the eye
VectorSubtract(rd->origin, vpn, diff);
- if (TraceLine(r_origin, diff, NULL, NULL, 0) == 1)
+ if (CL_TraceLine(r_origin, diff, NULL, NULL, 0, true) == 1)
{
- scale = 1.0f / 65536.0f;//64.0f / (dist * dist + 1024.0f);
+ scale = 1.0f / 262144.0f;
+ //scale = 64.0f / (DotProduct(diff,diff) + 1024.0f);
m.cr = rd->light[0] * scale;
m.cg = rd->light[1] * scale;
m.cb = rd->light[2] * scale;
VectorSubtract(rd->origin, r_origin, diff);
m.ca *= 1 - exp(fogdensity/DotProduct(diff,diff));
}
- // make it larger in the distance to keep a consistent size
- //scale = 0.4f * dist;
- scale = 256.0f;
+ scale = rd->cullradius * 0.25f;
tvxyz[0][0] = rd->origin[0] - vright[0] * scale - vup[0] * scale;
tvxyz[0][1] = rd->origin[1] - vright[1] * scale - vup[1] * scale;
tvxyz[0][2] = rd->origin[2] - vright[2] * scale - vup[2] * scale;
tvxyz[3][0] = rd->origin[0] + vright[0] * scale - vup[0] * scale;
tvxyz[3][1] = rd->origin[1] + vright[1] * scale - vup[1] * scale;
tvxyz[3][2] = rd->origin[2] + vright[2] * scale - vup[2] * scale;
- R_Mesh_DrawDecal(&m);
+ R_Mesh_Draw(&m);
}
}
}
}
// mark the polygons
- surf = cl.worldmodel->surfaces + node->firstsurface;
+ surf = currentrenderentity->model->surfaces + node->firstsurface;
for (i=0 ; i<node->numsurfaces ; i++, surf++)
{
int d, impacts, impactt;
int i, k, m, c, leafnum;
msurface_t *surf, **mark;
mleaf_t *leaf;
- byte *in;
+ qbyte *in;
int row;
float low[3], high[3], dist, maxdist;
if (surf->samples)
{
- byte *lightmap;
+ qbyte *lightmap;
int maps, line3, size3, dsfrac = ds & 15, dtfrac = dt & 15, scale = 0, r00 = 0, g00 = 0, b00 = 0, r01 = 0, g01 = 0, b01 = 0, r10 = 0, g10 = 0, b10 = 0, r11 = 0, g11 = 0, b11 = 0;
line3 = ((surf->extents[0]>>4)+1)*3;
size3 = ((surf->extents[0]>>4)+1) * ((surf->extents[1]>>4)+1)*3; // LordHavoc: *3 for colored lighting
vec3_t dist;
float f;
rdlight_t *rd;
+ mlight_t *sl;
if (leaf == NULL)
leaf = Mod_PointInLeaf(p, cl.worldmodel);
}
color[0] = color[1] = color[2] = r_ambient.value * (2.0f / 128.0f);
- RecursiveLightPoint (color, cl.worldmodel->nodes, p[0], p[1], p[2], p[2] - 65536);
+ if (cl.worldmodel->numlights)
+ {
+ for (i = 0;i < cl.worldmodel->numlights;i++)
+ {
+ sl = cl.worldmodel->lights + i;
+ if (d_lightstylevalue[sl->style] > 0)
+ {
+ VectorSubtract (p, sl->origin, dist);
+ f = DotProduct(dist, dist) + sl->distbias;
+ f = (1.0f / f) - sl->subtract;
+ if (f > 0)
+ {
+ if (CL_TraceLine(p, sl->origin, NULL, NULL, 0, false) == 1)
+ {
+ f *= d_lightstylevalue[sl->style] * (1.0f / 32768.0f);
+ VectorMA(color, f, sl->light, color);
+ }
+ }
+ }
+
+ }
+ }
+ else
+ RecursiveLightPoint (color, cl.worldmodel->nodes, p[0], p[1], p[2], p[2] - 65536);
if (dynamic && leaf->dlightframe == r_framecount)
{
}
color[0] = color[1] = color[2] = r_ambient.value * (2.0f / 128.0f);
- RecursiveLightPoint (color, cl.worldmodel->nodes, p[0], p[1], p[2], p[2] - 65536);
+ if (!cl.worldmodel->numlights)
+ RecursiveLightPoint (color, cl.worldmodel->nodes, p[0], p[1], p[2], p[2] - 65536);
if (leaf->dlightframe == r_framecount)
{
dlightbits[0] = dlightbits[1] = dlightbits[2] = dlightbits[3] = dlightbits[4] = dlightbits[5] = dlightbits[6] = dlightbits[7] = 0;
}
-void R_LightModel(int numverts)
+void R_LightModel(int numverts, float colorr, float colorg, float colorb, int worldcoords)
{
int i, j, nearlights = 0;
- float color[3], basecolor[3], v[3], t, *av, *avn, *avc, a, number, f, hardness, hardnessoffset, dist2;
+ float color[3], basecolor[3], v[3], t, *av, *avn, *avc, a, number, f/*, hardness, hardnessoffset*/, dist2;
struct
{
vec3_t origin;
vec_t cullradius2;
vec3_t light;
vec_t lightsubtract;
+ vec_t falloff;
+ vec_t offset;
}
nearlight[MAX_DLIGHTS], *nl;
int modeldlightbits[8];
//staticlight_t *sl;
+ mlight_t *sl;
a = currentrenderentity->alpha;
if (currentrenderentity->effects & EF_FULLBRIGHT)
- basecolor[0] = basecolor[1] = basecolor[2] = 1;
+ {
+ basecolor[0] = colorr;
+ basecolor[1] = colorg;
+ basecolor[2] = colorb;
+ }
else
{
if (r_lightmodels.integer)
nl->fadetype = sl->fadetype;
nl->distancescale = sl->distancescale;
nl->radius = sl->radius;
- VectorCopy(sl->origin, nl->origin);
+ // transform the light into the model's coordinate system
+ if (worldcoords)
+ VectorCopy(sl->origin, nl->origin);
+ else
+ softwareuntransform(sl->origin, nl->origin);
VectorCopy(sl->color, nl->light);
nl->cullradius2 = 99999999;
nl->lightsubtract = 0;
}
}
*/
+ // this code is unused for now
+ for (i = 0, sl = cl.worldmodel->lights;i < cl.worldmodel->numlights && nearlights < MAX_DLIGHTS;i++, sl++)
+ {
+ if (CL_TraceLine(currentrenderentity->origin, sl->origin, NULL, NULL, 0, false) == 1)
+ {
+ nl->falloff = sl->falloff;
+ // transform the light into the model's coordinate system
+ if (worldcoords)
+ VectorCopy(sl->origin, nl->origin);
+ else
+ softwareuntransform(sl->origin, nl->origin);
+ f = d_lightstylevalue[sl->style] * (1.0f / 32768.0f);
+ VectorScale(sl->light, f, nl->light);
+ nl->cullradius2 = 99999999;
+ nl->lightsubtract = sl->subtract;
+ nl->offset = sl->distbias;
+ nl++;
+ nearlights++;
+ }
+ }
for (i = 0;i < r_numdlights && nearlights < MAX_DLIGHTS;i++)
{
if (!(modeldlightbits[i >> 5] & (1 << (i & 31))))
//if (TraceLine(currentrenderentity->origin, r_dlight[i].origin, NULL, NULL, 0) == 1)
{
// transform the light into the model's coordinate system
- //if (gl_transform.integer)
- // softwareuntransform(r_dlight[i].origin, nl->origin);
- //else
+ if (worldcoords)
VectorCopy(r_dlight[i].origin, nl->origin);
+ else
+ softwareuntransform(r_dlight[i].origin, nl->origin);
nl->cullradius2 = r_dlight[i].cullradius2;
- VectorCopy(r_dlight[i].light, nl->light);
+ nl->light[0] = r_dlight[i].light[0] * colorr;
+ nl->light[1] = r_dlight[i].light[1] * colorg;
+ nl->light[2] = r_dlight[i].light[2] * colorb;
nl->lightsubtract = r_dlight[i].lightsubtract;
+ nl->offset = LIGHTOFFSET;
nl++;
nearlights++;
}
else
R_CompleteLightPoint (basecolor, currentrenderentity->origin, true, NULL);
}
+ basecolor[0] *= colorr;
+ basecolor[1] *= colorg;
+ basecolor[2] *= colorb;
avc = aliasvertcolor;
if (nearlights)
{
av = aliasvert;
avn = aliasvertnorm;
- hardness = r_lightmodelhardness.value;
- hardnessoffset = (1.0f - hardness);
+ //hardness = r_lightmodelhardness.value;
+ //hardnessoffset = (1.0f - hardness);
for (i = 0;i < numverts;i++)
{
VectorCopy(basecolor, color);
dist2 = DotProduct(v,v);
if (dist2 < nl->cullradius2)
{
- f = (1.0f / (dist2 + LIGHTOFFSET)) - nl->lightsubtract;
+ f = (1.0f / (dist2 + nl->offset)) - nl->lightsubtract;
if (f > 0)
{
// directional shading
t = 1.0f / sqrt(dist2);
#else
number = DotProduct(v, v);
- *((long *)&t) = 0x5f3759df - ((* (long *) &number) >> 1);
+ *((int *)&t) = 0x5f3759df - ((* (int *) &number) >> 1);
t = t * (1.5f - (number * 0.5f * t * t));
#endif
// DotProduct(avn,v) * t is dotproduct with a normalized v,
// the hardness variables are for backlighting/shinyness
- f *= DotProduct(avn,v) * t * hardness + hardnessoffset;
+ f *= DotProduct(avn,v) * t;// * hardness + hardnessoffset;
if (f > 0)
VectorMA(color, f, nl->light, color);
}
VectorCopy(color, avc);
avc[3] = a;
avc += 4;
- av += 3;
+ av += 4;
avn += 3;
}
}
projects / xonotic / darkplaces.git / blobdiff