eukara/fteqw
1
0
Fork 0
forked from fte/fteqw
Code Pull requests Activity
fteqw/engine/gl/gl_rlight.c
Shpoike 8dadfb4878 Added sys_openfile console command(and menu option) to web and flatpak(via cmake+dbus) builds, to 'install' packages on sandboxed systems a bit more easily. 
Cmake: Add FTE_WERROR option, defaults to true in debug builds and off in release builds (in case future compilers have issues).
Cmake: Pull in libXscreensaver so we don't get interrupted by screensavers when playing demos.
Make: Added `make webcl-rel` for a web build without server bloat (eg for sites focused on demo playback. Yes, this means you XantoM).
fteqcc: Include the decompiler in fteqcc (non-gui) builds ('-d' arg).
fteqcc: Decompiler can now mostly handle hexen2 mods without any unknown opcodes.
Allow ezHud and OpenSSL to be compiled as in-engine plugins, potentially for web and windows ports respectively.
Web: Fix support for ogg vorbis. Add support for voip.
Web: Added basic support for WebXR.
QTV: Don't try seeking on unseekable qtv streams. Don't spam when developer 1 is set.
QTV: add support for some eztv extensions.
MVD: added hack to use ktx's vweps in mvd where mvdsv doesn't bother to record the info.
qwfwd: hack around a hack in qwfwd, allowing it to work again.
recording: favour qwd in single player, instead of mvd.
Protocol: reduce client memory used for precache names. Bump maximum precache counts - some people are just abusive, yes you Orl.
hexen2: add enough clientside protocol compat to play the demo included with h2mp. lacks effects.
in_xflip: restored this setting.
fs_hidesyspaths: new cvar, defaults to enabled so you won't find your username or whatever turning up in screenshots or the like. change it to 0 before debuging stuff eg via 'path'.
gl_overbright_models: Added cvar to match QS.
netchan: Added MTU determination, we'll no longer fail to connect when routers stupidly drop icmp packets.
Win: try a few other versions of xinput too.
CSQC: Added a CSQC_GenerateMaterial function, to give the csqc a chance to generate custom materials.
MenuQC: Added support for the skeletal objects API.
2024-07-14 19:58:24 +01:00

3281 lines
94 KiB
C
Raw Blame History

/*
Copyright (C) 1996-1997 Id Software, Inc.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
// r_light.c
#include "quakedef.h"
#ifndef SERVERONLY
#include "glquake.h"
#include "shader.h"
extern cvar_t r_shadow_realtime_world, r_shadow_realtime_world_lightmaps;
extern cvar_t r_hdr_irisadaptation, r_hdr_irisadaptation_multiplier, r_hdr_irisadaptation_minvalue, r_hdr_irisadaptation_maxvalue, r_hdr_irisadaptation_fade_down, r_hdr_irisadaptation_fade_up;
extern cvar_t mod_lightpoint_distance;
int r_dlightframecount;
int d_lightstylevalue[MAX_NET_LIGHTSTYLES]; // 8.8 fraction of base light value
void R_BumpLightstyles(unsigned int maxstyle)
{
int style = cl_max_lightstyles;
if (maxstyle >= style)
{
Z_ReallocElements((void**)&cl_lightstyle, &cl_max_lightstyles, maxstyle+1, sizeof(*cl_lightstyle));
for (; style < cl_max_lightstyles; style++)
VectorSet(cl_lightstyle[style].colours, 1,1,1);
}
}
void R_UpdateLightStyle(unsigned int style, const char *stylestring, float r, float g, float b)
{
if (style >= MAX_NET_LIGHTSTYLES)
return;
R_BumpLightstyles(style);
if (!stylestring)
stylestring = "";
Q_strncpyz (cl_lightstyle[style].map, stylestring, sizeof(cl_lightstyle[style].map));
cl_lightstyle[style].length = Q_strlen(cl_lightstyle[style].map);
if (!cl_lightstyle[style].length)
{
d_lightstylevalue[style] = 256;
VectorSet(cl_lightstyle[style].colours, 1,1,1);
}
else
VectorSet(cl_lightstyle[style].colours, r,g,b);
cl_lightstyle[style].colourkey = (int)(cl_lightstyle[style].colours[0]*0x400) ^ (int)(cl_lightstyle[style].colours[1]*0x100000) ^ (int)(cl_lightstyle[style].colours[2]*0x40000000);
}
void Sh_CalcPointLight(vec3_t point, vec3_t light);
void R_UpdateHDR(vec3_t org)
{
if (r_hdr_irisadaptation.ival && cl.worldmodel && !(r_refdef.flags & RDF_NOWORLDMODEL))
{
//fake and lame, but whatever.
vec3_t ambient, diffuse, dir;
float lev = 0;
#ifdef RTLIGHTS
Sh_CalcPointLight(org, ambient);
lev += VectorLength(ambient);
if (!r_shadow_realtime_world.ival || r_shadow_realtime_world_lightmaps.value)
#endif
{
cl.worldmodel->funcs.LightPointValues(cl.worldmodel, org, ambient, diffuse, dir);
lev += (VectorLength(ambient) + VectorLength(diffuse))/256;
}
lev += 0.001; //no division by 0!
lev = r_hdr_irisadaptation_multiplier.value / lev;
lev = bound(r_hdr_irisadaptation_minvalue.value, lev, r_hdr_irisadaptation_maxvalue.value);
if (lev > r_refdef.playerview->hdr_last + r_hdr_irisadaptation_fade_up.value*host_frametime)
lev = r_refdef.playerview->hdr_last + r_hdr_irisadaptation_fade_up.value*host_frametime;
else if (lev < r_refdef.playerview->hdr_last - r_hdr_irisadaptation_fade_down.value*host_frametime)
lev = r_refdef.playerview->hdr_last - r_hdr_irisadaptation_fade_down.value*host_frametime;
lev = bound(r_hdr_irisadaptation_minvalue.value, lev, r_hdr_irisadaptation_maxvalue.value);
r_refdef.playerview->hdr_last = lev;
r_refdef.hdr_value = lev;
}
else
r_refdef.hdr_value = 1;
}
/*
==================
R_AnimateLight
==================
*/
void R_AnimateLight (void)
{
int i,j;
float f;
static int fbmodcount;
//if (r_lightstylescale.value > 2)
//r_lightstylescale.value = 2;
//
// light animations
// 'm' is normal light, 'a' is no light, 'z' is double bright
f = (cl.time*r_lightstylespeed.value);
if (f < 0)
f = 0;
i = (int)f;
f -= i; //this can require updates at 1000 times a second.. Depends on your framerate of course
if (r_fullbright.value)
{
for (j=0 ; j<cl_max_lightstyles ; j++)
d_lightstylevalue[j] = r_fullbright.value*255;
}
else for (j=0 ; j<cl_max_lightstyles ; j++)
{
int v1, v2, vd;
if (!cl_lightstyle[j].length)
{
d_lightstylevalue[j] = ('m'-'a')*22 * r_lightstylescale.value;
continue;
}
if (cl_lightstyle[j].map[0] == '=')
{
d_lightstylevalue[j] = atof(cl_lightstyle[j].map+1)*256*r_lightstylescale.value;
continue;
}
v1 = i % cl_lightstyle[j].length;
v1 = cl_lightstyle[j].map[v1] - 'a';
v2 = (i+1) % cl_lightstyle[j].length;
v2 = cl_lightstyle[j].map[v2] - 'a';
vd = v1 - v2;
if (!r_lightstylesmooth.ival || vd < -r_lightstylesmooth_limit.ival || vd > r_lightstylesmooth_limit.ival)
d_lightstylevalue[j] = v1*22*r_lightstylescale.value;
else
d_lightstylevalue[j] = (v1*(1-f) + v2*(f))*22*r_lightstylescale.value;
}
if (r_fullbright.modified != fbmodcount)
{
fbmodcount = r_fullbright.modified;
for (j=0 ; j<cl_max_lightstyles ; j++)
{
if (r_fullbright.value)
cl_lightstyle[j].colourkey = 0xff;
else
cl_lightstyle[j].colourkey = (int)(cl_lightstyle[j].colours[0]*0x400) ^ (int)(cl_lightstyle[j].colours[1]*0x100000) ^ (int)(cl_lightstyle[j].colours[2]*0x40000000);
}
}
}
/*
=============================================================================
DYNAMIC LIGHTS BLEND RENDERING
=============================================================================
*/
void AddLightBlend (float r, float g, float b, float a2)
{
float a;
float *sw_blend = r_refdef.playerview->screentint;
r = bound(0, r, 1);
g = bound(0, g, 1);
b = bound(0, b, 1);
sw_blend[3] = a = sw_blend[3] + a2*(1-sw_blend[3]);
a2 = a2/a;
sw_blend[0] = sw_blend[0]*(1-a2) + r*a2;
sw_blend[1] = sw_blend[1]*(1-a2) + g*a2;
sw_blend[2] = sw_blend[2]*(1-a2) + b*a2;
//Con_Printf("AddLightBlend(): %4.2f %4.2f %4.2f %4.6f\n", v_blend[0], v_blend[1], v_blend[2], v_blend[3]);
}
#define FLASHBLEND_VERTS 16
static float bubble_sintable[FLASHBLEND_VERTS+1], bubble_costable[FLASHBLEND_VERTS+1];
static void R_InitBubble(void)
{
float a;
int i;
float *bub_sin, *bub_cos;
bub_sin = bubble_sintable;
bub_cos = bubble_costable;
for (i=FLASHBLEND_VERTS ; i>=0 ; i--)
{
a = i/(float)FLASHBLEND_VERTS * M_PI*2;
*bub_sin++ = sin(a);
*bub_cos++ = cos(a);
}
}
avec4_t flashblend_colours[FLASHBLEND_VERTS+1];
vecV_t flashblend_vcoords[FLASHBLEND_VERTS+1];
vec2_t flashblend_tccoords[FLASHBLEND_VERTS+1];
index_t flashblend_indexes[FLASHBLEND_VERTS*3];
index_t flashblend_fsindexes[6] = {0, 1, 2, 0, 2, 3};
mesh_t flashblend_mesh;
mesh_t flashblend_fsmesh;
shader_t *occluded_shader;
shader_t *flashblend_shader;
shader_t *deferredlight_shader[LSHADER_MODES];
void R_GenerateFlashblendTexture(void)
{
float dx, dy;
int x, y, a;
unsigned char pixels[32][32][4];
for (y = 0;y < 32;y++)
{
dy = (y - 15.5f) * (1.0f / 16.0f);
for (x = 0;x < 32;x++)
{
dx = (x - 15.5f) * (1.0f / 16.0f);
a = (int)(((1.0f / (dx * dx + dy * dy + 0.2f)) - (1.0f / (1.0f + 0.2))) * 32.0f / (1.0f / (1.0f + 0.2)));
a = bound(0, a, 255);
pixels[y][x][0] = a;
pixels[y][x][1] = a;
pixels[y][x][2] = a;
pixels[y][x][3] = 255;
}
}
R_LoadReplacementTexture("***flashblend***", NULL, IF_LINEAR, pixels, 32, 32, TF_RGBA32);
}
void R_InitFlashblends(void)
{
int i;
R_InitBubble();
for (i = 0; i < FLASHBLEND_VERTS; i++)
{
flashblend_indexes[i*3+0] = 0;
if (i+1 == FLASHBLEND_VERTS)
flashblend_indexes[i*3+1] = 1;
else
flashblend_indexes[i*3+1] = i+2;
flashblend_indexes[i*3+2] = i+1;
flashblend_tccoords[i+1][0] = 0.5 + bubble_sintable[i]*0.5;
flashblend_tccoords[i+1][1] = 0.5 + bubble_costable[i]*0.5;
}
flashblend_tccoords[0][0] = 0.5;
flashblend_tccoords[0][1] = 0.5;
flashblend_mesh.numvertexes = FLASHBLEND_VERTS+1;
flashblend_mesh.xyz_array = flashblend_vcoords;
flashblend_mesh.st_array = flashblend_tccoords;
flashblend_mesh.colors4f_array[0] = flashblend_colours;
flashblend_mesh.indexes = flashblend_indexes;
flashblend_mesh.numindexes = FLASHBLEND_VERTS*3;
flashblend_mesh.istrifan = true;
flashblend_fsmesh.numvertexes = 4;
flashblend_fsmesh.xyz_array = flashblend_vcoords;
flashblend_fsmesh.st_array = flashblend_tccoords;
flashblend_fsmesh.colors4f_array[0] = flashblend_colours;
flashblend_fsmesh.indexes = flashblend_fsindexes;
flashblend_fsmesh.numindexes = 6;
flashblend_fsmesh.istrifan = true;
R_GenerateFlashblendTexture();
flashblend_shader = R_RegisterShader("flashblend", SUF_NONE,
"{\n"
"program defaultadditivesprite\n"
"{\n"
"map ***flashblend***\n"
"blendfunc gl_one gl_one\n"
"rgbgen vertex\n"
"alphagen vertex\n"
"nodepth\n"
"}\n"
"}\n"
);
occluded_shader = R_RegisterShader("flashblend_occlusiontest", SUF_NONE,
"{\n"
"program defaultadditivesprite\n"
"{\n"
"maskcolor\n"
"maskalpha\n"
"}\n"
"}\n"
);
memset(deferredlight_shader, 0, sizeof(deferredlight_shader));
}
static qboolean R_BuildDlightMesh(dlight_t *light, float colscale, float radscale, int dtype)
{
int i, j;
// float a;
vec3_t v;
float rad;
float *bub_sin, *bub_cos;
vec3_t colour;
bub_sin = bubble_sintable;
bub_cos = bubble_costable;
rad = light->radius * radscale;
VectorCopy(light->color, colour);
if (light->fov)
{
float a = -DotProduct(light->axis[0], vpn);
colour[0] *= a;
colour[1] *= a;
colour[2] *= a;
rad *= a;
rad *= 0.33;
}
if (light->style>=0 && light->style < countof(d_lightstylevalue))
{
colscale *= d_lightstylevalue[light->style]/255.0f;
}
VectorSubtract (light->origin, r_origin, v);
if (dtype != 1 && Length (v) < rad + r_refdef.mindist*2)
{ // view is inside the dlight
return false;
}
flashblend_colours[0][0] = colour[0]*colscale;
flashblend_colours[0][1] = colour[1]*colscale;
flashblend_colours[0][2] = colour[2]*colscale;
flashblend_colours[0][3] = 1;
VectorCopy(light->origin, flashblend_vcoords[0]);
for (i=FLASHBLEND_VERTS ; i>0 ; i--)
{
for (j=0 ; j<3 ; j++)
flashblend_vcoords[i][j] = light->origin[j] + (vright[j]*(*bub_cos) +
+ vup[j]*(*bub_sin)) * rad;
bub_sin++;
bub_cos++;
}
if (dtype == 0)
{
//flashblend 3d-ish
VectorMA(flashblend_vcoords[0], -rad/1.5, vpn, flashblend_vcoords[0]);
}
else if (dtype != 1)
{
//prepass lights needs to be fully infront of the light. the glsl is a fullscreen-style effect, but we can benefit from early-z and scissoring
vec3_t diff;
VectorSubtract(r_origin, light->origin, diff);
VectorNormalize(diff);
for (i=0 ; i<=FLASHBLEND_VERTS ; i++)
VectorMA(flashblend_vcoords[i], rad, diff, flashblend_vcoords[i]);
}
return true;
}
/*
=============
R_RenderDlights
=============
*/
void R_RenderDlights (void)
{
int i;
dlight_t *l;
vec3_t waste1, waste2;
unsigned int beflags = 0;
float intensity, cscale;
qboolean coronastyle;
qboolean flashstyle;
float dist;
if (!r_coronas.value && !r_flashblend.value)
return;
l = cl_dlights+rtlights_first;
for (i=rtlights_first; i<rtlights_max; i++, l++)
{
if (!l->radius)
continue;
if (l->corona <= 0)
continue;
//dlights emitting from the local player are not visible as flashblends
if (l->key == r_refdef.playerview->viewentity)
continue; //was a glow
if (l->key == -(r_refdef.playerview->viewentity))
continue; //was a muzzleflash
coronastyle = (l->flags & (LFLAG_NORMALMODE|LFLAG_REALTIMEMODE)) && r_coronas.value;
flashstyle = ((l->flags & LFLAG_FLASHBLEND) && r_flashblend.value);
if (!coronastyle && !flashstyle)
continue;
if (coronastyle && flashstyle)
flashstyle = false;
cscale = l->coronascale;
intensity = l->corona;// * 0.25;
if (coronastyle)
intensity *= r_coronas.value * r_coronas_intensity.value;
else
intensity *= r_flashblend.value;
if (intensity <= 0 || cscale <= 0)
continue;
//prevent the corona from intersecting with the near clip plane by just fading it away if its too close
VectorSubtract(l->origin, r_refdef.vieworg, waste1);
dist = VectorLength(waste1);
if (dist < r_coronas_mindist.value+r_coronas_fadedist.value)
{
if (dist <= r_coronas_mindist.value)
continue;
intensity *= (dist-r_coronas_mindist.value) / r_coronas_fadedist.value;
}
/*coronas use depth testing to compute visibility*/
if (coronastyle)
{
int method;
if (r_refdef.recurse)
method = 1; //don't confuse queries... FIXME: splitscreen/PIP will still have issues.
else if (!*r_coronas_occlusion.string)
method = 4; //default to using hardware queries where possible.
else
method = r_coronas_occlusion.ival;
switch(method)
{
case 0:
break;
case 3:
#ifdef GLQUAKE
if (qrenderer == QR_OPENGL)
{
float depth;
vec3_t out;
float v[4], tempv[4];
float mvp[16];
v[0] = l->origin[0];
v[1] = l->origin[1];
v[2] = l->origin[2];
v[3] = 1;
Matrix4_Multiply(r_refdef.m_projection_std, r_refdef.m_view, mvp);
Matrix4x4_CM_Transform4(mvp, v, tempv);
tempv[0] /= tempv[3];
tempv[1] /= tempv[3];
tempv[2] /= tempv[3];
out[0] = (1+tempv[0])/2;
out[1] = (1+tempv[1])/2;
out[2] = (1+tempv[2])/2;
out[0] = out[0]*r_refdef.pxrect.width + r_refdef.pxrect.x;
out[1] = out[1]*r_refdef.pxrect.height + r_refdef.pxrect.y;
if (tempv[3] < 0)
out[2] *= -1;
if (out[2] < 0)
continue;
//FIXME: in terms of performance, mixing reads+draws is BAD BAD BAD. SERIOUSLY BAD
//it would be an improvement to calculate all of these at once.
qglReadPixels(out[0], out[1], 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &depth);
if (depth < out[2])
continue;
break;
}
#endif
//other renderers fall through
case 4:
#ifdef GLQUAKE
if (qrenderer == QR_OPENGL && qglGenQueriesARB)
{
GLuint res;
qboolean requery = true;
if (r_refdef.recurse)
requery = false;
else if (l->coronaocclusionquery)
{
qglGetQueryObjectuivARB(l->coronaocclusionquery, GL_QUERY_RESULT_AVAILABLE_ARB, &res);
if (res)
qglGetQueryObjectuivARB(l->coronaocclusionquery, GL_QUERY_RESULT_ARB, &l->coronaocclusionresult);
else if (!l->coronaocclusionresult)
continue; //query still running, nor currently visible.
else
requery = false;
}
else
{
qglGenQueriesARB(1, &l->coronaocclusionquery);
}
if (requery)
{
qglBeginQueryARB(GL_SAMPLES_PASSED_ARB, l->coronaocclusionquery);
R_BuildDlightMesh (l, intensity*10, cscale*.1, coronastyle);
BE_DrawMesh_Single(occluded_shader, &flashblend_mesh, NULL, beflags);
qglEndQueryARB(GL_SAMPLES_PASSED_ARB);
}
if (!l->coronaocclusionresult)
continue;
break;
}
#endif
//other renderers fall through
default:
case 1: //bsp-only
case 2: //non-bsp too
if (TraceLineR(r_refdef.vieworg, l->origin, waste1, waste2, method!=2))
continue;
break;
}
}
if (!R_BuildDlightMesh (l, intensity, cscale, coronastyle) && !coronastyle)
AddLightBlend (l->color[0], l->color[1], l->color[2], l->radius * 0.0003);
else
BE_DrawMesh_Single(flashblend_shader, &flashblend_mesh, NULL, (coronastyle?BEF_FORCENODEPTH|BEF_FORCEADDITIVE:0)|beflags);
}
}
qboolean Sh_GenerateShadowMap(dlight_t *l, int lightflags);
qboolean Sh_CullLight(dlight_t *dl, qbyte *vvis);
void R_GenDlightMesh(struct batch_s *batch)
{
static mesh_t *meshptr;
dlight_t *l = cl_dlights + batch->user.dlight.lightidx;
vec3_t colour;
int lightflags = batch->user.dlight.lightmode;
VectorCopy(l->color, colour);
if (l->style>=0 && l->style < cl_max_lightstyles)
{
colour[0] *= cl_lightstyle[l->style].colours[0] * d_lightstylevalue[l->style]/255.0f;
colour[1] *= cl_lightstyle[l->style].colours[1] * d_lightstylevalue[l->style]/255.0f;
colour[2] *= cl_lightstyle[l->style].colours[2] * d_lightstylevalue[l->style]/255.0f;
}
else
{
colour[0] *= r_lightstylescale.value;
colour[1] *= r_lightstylescale.value;
colour[2] *= r_lightstylescale.value;
}
if (colour[0] < 0.001 && colour[1] < 0.001 && colour[2] < 0.001)
{ //just switch these off.
batch->meshes = 0;
return;
}
BE_SelectDLight(l, colour, l->axis, lightflags);
#ifdef RTLIGHTS
if (lightflags & LSHADER_SMAP)
{
if (!Sh_GenerateShadowMap(l, lightflags))
{
batch->meshes = 0;
return;
}
BE_SelectEntity(&r_worldentity);
BE_SelectMode(BEM_STANDARD);
}
else if (Sh_CullLight(l, r_refdef.scenevis))
{
batch->meshes = 0;
return;
}
#endif
if (!R_BuildDlightMesh (l, 2, 1, 2))
{
int i;
static vec2_t s[4] = {{1, -1}, {-1, -1}, {-1, 1}, {1, 1}};
for (i = 0; i < 4; i++)
{
VectorMA(r_origin, 32, vpn, flashblend_vcoords[i]);
VectorMA(flashblend_vcoords[i], s[i][0]*320, vright, flashblend_vcoords[i]);
VectorMA(flashblend_vcoords[i], s[i][1]*320, vup, flashblend_vcoords[i]);
}
meshptr = &flashblend_fsmesh;
}
else
{
meshptr = &flashblend_mesh;
}
batch->mesh = &meshptr;
RQuantAdd(RQUANT_RTLIGHT_DRAWN, 1);
}
void R_GenDlightBatches(batch_t *batches[])
{
#ifdef RTLIGHTS
int i, j, sort;
dlight_t *l;
batch_t *b;
int lmode;
unsigned modes;
extern cvar_t r_shadow_realtime_dlight;
extern cvar_t r_shadow_realtime_world;
if (!r_lightprepass)
return;
modes = 0;
if (r_shadow_realtime_dlight.ival)
modes |= LFLAG_NORMALMODE;
if (r_shadow_realtime_world.ival)
modes |= LFLAG_REALTIMEMODE;
if (!modes)
return;
if (!deferredlight_shader[0])
{
const char *deferredlight_shader_code =
"{\n"
"deferredlight\n"
"surfaceparm nodlight\n"
"{\n"
"program lpp_light\n"
"blendfunc gl_one gl_one\n"
"nodepthtest\n"
"map $gbuffer0\n" //depth
"map $gbuffer1\n" //normals.rgb specexp.a
"}\n"
"}\n"
;
deferredlight_shader[0] = R_RegisterShader("deferredlight", SUF_NONE, deferredlight_shader_code);
#ifdef RTLIGHTS
deferredlight_shader[LSHADER_SMAP] = R_RegisterShader("deferredlight#PCF", SUF_NONE, deferredlight_shader_code);
#endif
}
l = cl_dlights+rtlights_first;
for (i=rtlights_first; i<rtlights_max; i++, l++)
{
if (!l->radius)
continue;
if (!(modes & l->flags))
continue;
if (R_CullSphere(l->origin, l->radius))
{
RQuantAdd(RQUANT_RTLIGHT_CULL_FRUSTUM, 1);
continue;
}
lmode = 0;
#ifdef RTLIGHTS
if (!(((i >= RTL_FIRST)?!r_shadow_realtime_world_shadows.ival:!r_shadow_realtime_dlight_shadows.ival) || l->flags & LFLAG_NOSHADOWS))
lmode |= LSHADER_SMAP;
#endif
// if (TEXLOADED(l->cubetexture))
// lmode |= LSHADER_CUBE;
b = BE_GetTempBatch();
if (!b)
return;
b->flags = 0;
b->shader = deferredlight_shader[lmode];
sort = b->shader->sort;
b->buildmeshes = R_GenDlightMesh;
b->ent = &r_worldentity;
b->mesh = NULL;
b->firstmesh = 0;
b->meshes = 1;
b->skin = NULL;
b->texture = NULL;
for (j = 0; j < MAXRLIGHTMAPS; j++)
b->lightmap[j] = -1;
b->user.dlight.lightidx = i;
b->user.dlight.lightmode = lmode;
b->flags |= BEF_NOSHADOWS|BEF_NODLIGHT; //that would be weeird
b->vbo = NULL;
b->next = batches[sort];
batches[sort] = b;
}
#endif
}
/*
=============================================================================
DYNAMIC LIGHTS
=============================================================================
*/
/*
=============
R_PushDlights
=============
*/
void R_PushDlights (void)
{
int i;
dlight_t *l;
r_dlightframecount++; // because the count hasn't
// advanced yet for this frame
#ifdef RTLIGHTS
/*if we're doing full rtlighting only, then don't bother calculating old-style dlights as they won't be visible anyway*/
if (r_shadow_realtime_world.ival && r_shadow_realtime_world_lightmaps.value < 0.1)
return;
#endif
if (r_dynamic.ival <= 0|| !r_worldentity.model)
return;
if (r_worldentity.model->loadstate != MLS_LOADED)
return;
if (!r_worldentity.model->nodes)
return;
currentmodel = r_worldentity.model;
if (!currentmodel->funcs.MarkLights)
return;
l = cl_dlights+rtlights_first;
for (i=rtlights_first ; i <= DL_LAST ; i++, l++)
{
if (!l->radius || !(l->flags & LFLAG_LIGHTMAP))
continue;
if ((l->flags & LFLAG_NORMALMODE) && r_shadow_realtime_dlight.ival)
continue; //don't draw both. its redundant and a waste of cpu.
if ((l->flags & LFLAG_REALTIMEMODE) && r_shadow_realtime_world.ival)
continue; //also don't draw both.
currentmodel->funcs.MarkLights( l, (dlightbitmask_t)1u<<i, currentmodel->nodes );
}
}
/////////////////////////////////////////////////////////////
//rtlight loading
#ifdef RTLIGHTS
//These affect importing
static cvar_t r_editlights_import_radius = CVARAD ("r_editlights_import_radius", "1", "r_editlights_quakelightsizescale", "changes size of light entities loaded from a map");
static cvar_t r_editlights_import_ambient = CVARD ("r_editlights_import_ambient", "0", "ambient light scaler for imported lights");
static cvar_t r_editlights_import_diffuse = CVARD ("r_editlights_import_diffuse", "1", "diffuse light scaler for imported lights");
static cvar_t r_editlights_import_specular = CVARD ("r_editlights_import_specular", "1", "specular light scaler for imported lights"); //excessive, but noticable. its called stylized, okay? shiesh, some people
//these are just for the crappy editor
static cvar_t r_editlights = CVARD ("r_editlights", "0", "enables .rtlights file editing mode. Consider using csaddon/equivelent instead.");
static cvar_t r_editlights_cursordistance = CVARD ("r_editlights_cursordistance", "1024", "maximum distance of cursor from eye");
static cvar_t r_editlights_cursorpushoff = CVARD ("r_editlights_cursorpushoff", "4", "how far to push the cursor off the impacted surface");
static cvar_t r_editlights_cursorpushback = CVARD ("r_editlights_cursorpushback", "0", "how far to pull the cursor back toward the eye, for some reason");
static cvar_t r_editlights_cursorgrid = CVARD ("r_editlights_cursorgrid", "1", "snaps cursor to this grid size");
//internal settings
static qboolean r_editlights_locked = false; //don't change the selected light
static int r_editlights_selected = -1; //the light closest to the cursor
static vec3_t r_editlights_cursor; //the position of the crosshair/cursor (new lights will be spawned here)
static dlight_t r_editlights_copybuffer; //written by r_editlights_copyinfo, read by r_editlights_pasteinfo. FIXME: use system clipboard?
qboolean R_ImportRTLights(const char *entlump, int importmode)
{
typedef enum lighttype_e {LIGHTTYPE_MINUSX, LIGHTTYPE_RECIPX, LIGHTTYPE_RECIPXX, LIGHTTYPE_INFINITE, LIGHTTYPE_LOCALMIN, LIGHTTYPE_RECIPXX2, LIGHTTYPE_SUN} lighttype_t;
/*I'm using the DP code so I know I'll get the DP results*/
int entnum, style, islight, skin, pflags, n;
lighttype_t type;
float origin[3], angles[3], mangle[3], radius, color[3], light[4], fadescale, lightscale, originhack[3], overridecolor[3], colourscales[3], vec[4];
char key[256], value[8192];
char targetname[256], target[256];
int nest;
qboolean okay = false;
infobuf_t targets;
const char *lmp;
qboolean rerelease = false;
float fade[2];
memset(&targets, 0, sizeof(targets));
//a quick note about tenebrae:
//by default, tenebrae's rtlights come from the server via static entities, which is all fancy and posh and actually fairly nice... if all servers actually did it.
//(the tenebrae gamecode uses spawnflag 2048 for static lights. note the pflags_fulldynamic fte/dp vs tenebrae difference)
//failing that, it will insert lights with some crappy fixed radius around only all 'classname light' entities, without any colours or anything, vanilla only.
//such lights are ONLY created if they're not near some other existing light (like a static entity one).
//this can result in FTE having noticably more and bigger lights than tenebrae. shadowmapping doesn't help performance either.
//handle doom3's header
COM_Parse(entlump);
if (!strcmp(com_token, "Version"))
{
entlump = COM_Parse(entlump);
entlump = COM_Parse(entlump);
}
//find targetnames, and store their origins so that we can deal with spotlights.
for (lmp = entlump; ;)
{
lmp = COM_Parse(lmp);
if (com_token[0] != '{')
break;
*targetname = 0;
VectorClear(origin);
nest = 1;
while (1)
{
lmp = COM_ParseOut(lmp, key, sizeof(key));
if (!lmp)
break; // error
if (key[0] == '{')
{
nest++;
continue;
}
if (key[0] == '}')
{
nest--;
if (!nest)
break; // end of entity
continue;
}
if (nest!=1)
continue;
if (key[0] == '_')
{
if (!strcmp(key+1, "shadowlight"))
rerelease = true;
memmove(key, key+1, strlen(key));
}
while (key[strlen(key)-1] == ' ') // remove trailing spaces
key[strlen(key)-1] = 0;
lmp = COM_ParseOut(lmp, value, sizeof(value));
if (!lmp)
break; // error
// now that we have the key pair worked out...
if (!strcmp("targetname", key))
Q_strncpyz(targetname, value, sizeof(targetname));
else if (!strcmp("origin", key))
sscanf(value, "%f %f %f", &origin[0], &origin[1], &origin[2]);
}
//if we found an ent with a targetname and an origin, then record where it was.
if (*targetname && (origin[0] || origin[1] || origin[2]))
InfoBuf_SetStarKey(&targets, targetname, va("%f %f %f", origin[0], origin[1], origin[2]));
}
if (!importmode && !rerelease)
{
InfoBuf_Clear(&targets, true);
return false; //don't make it up from legacy ents.
}
for (entnum = 0; ;entnum++)
{
entlump = COM_Parse(entlump);
if (com_token[0] != '{')
break;
type = LIGHTTYPE_MINUSX;
origin[0] = origin[1] = origin[2] = 0;
originhack[0] = originhack[1] = originhack[2] = 0;
angles[0] = angles[1] = angles[2] = 0;
mangle[0] = mangle[1] = mangle[2] = 0;
color[0] = color[1] = color[2] = 1;
light[0] = light[1] = light[2] = 1;light[3] = 300;
overridecolor[0] = overridecolor[1] = overridecolor[2] = 1;
fadescale = 1;
lightscale = 1;
*target = 0;
style = 0;
skin = 0;
pflags = 0;
fade[0] = fade[1] = 0;
VectorSet(colourscales, r_editlights_import_ambient.value, r_editlights_import_diffuse.value, r_editlights_import_specular.value);
//effects = 0;
islight = false;
nest = 1;
while (1)
{
entlump = COM_Parse(entlump);
if (!entlump)
break; // error
if (com_token[0] == '{')
{
nest++;
continue;
}
if (com_token[0] == '}')
{
nest--;
if (!nest)
break; // end of entity
continue;
}
if (nest!=1)
continue;
if (com_token[0] == '_')
Q_strncpyz(key, com_token + 1, sizeof(key));
else
Q_strncpyz(key, com_token, sizeof(key));
while (key[strlen(key)-1] == ' ') // remove trailing spaces
key[strlen(key)-1] = 0;
entlump = COM_Parse(entlump);
if (!entlump)
break; // error
Q_strncpyz(value, com_token, sizeof(value));
if (rerelease)
{
if (!strcmp("color", key))
sscanf(value, "%f %f %f", &light[0], &light[1], &light[2]);
else if (!strcmp("shadowlightcull", key))
;//sscanf(value, "%f %f %f", &color[0], &color[1], &color[2]);
else if (!strcmp("shadowlightresolution", key))
;//sscanf(value, "%f %f %f", &color[0], &color[1], &color[2]);
else if (!strcmp("shadowlightradius", key))
light[3] = atof(value);
else if (!strcmp("shadowlightstartfadedistance", key))
fade[0] = atof(value);
else if (!strcmp("shadowlightendfadedistance", key))
fade[1] = atof(value);
else if (!strcmp("shadowlightintensity", key))
{
colourscales[0] *= atof(value);
colourscales[1] *= atof(value);
colourscales[2] *= atof(value);
}
else if (!strcmp("shadowlight", key))
islight = atoi(value);
else if (!strcmp("shadowlightstyle", key))
style = atoi(value);
else if (!strcmp("shadowlightconeangle", key))
angles[1] = atof(value)*2;
else if (!strcmp("origin", key))
sscanf(value, "%f %f %f", &origin[0], &origin[1], &origin[2]);
else if (!strcmp("target", key))
Q_strncpyz(target, value, sizeof(target));
}
else
{
// now that we have the key pair worked out...
if (!strcmp("light", key))
{
n = sscanf(value, "%f %f %f %f", &vec[0], &vec[1], &vec[2], &vec[3]);
if (n == 1)
{
// quake
light[0] = vec[0] * (1.0f / 256.0f);
light[1] = vec[0] * (1.0f / 256.0f);
light[2] = vec[0] * (1.0f / 256.0f);
light[3] = vec[0];
}
else if (n == 4)
{
// halflife
light[0] = vec[0] * (1.0f / 255.0f);
light[1] = vec[1] * (1.0f / 255.0f);
light[2] = vec[2] * (1.0f / 255.0f);
light[3] = vec[3];
}
}
else if (!strcmp("delay", key))
type = atoi(value);
else if (!strcmp("origin", key))
sscanf(value, "%f %f %f", &origin[0], &origin[1], &origin[2]);
else if (!strcmp("angle", key)) //orientation for cubemaps (or angle of spot lights)
angles[0] = 0, angles[1] = atof(value), angles[2] = 0;
else if (!strcmp("mangle", key)) //orientation for cubemaps (or angle of spot lights)
{
sscanf(value, "%f %f %f", &mangle[1], &mangle[0], &mangle[2]); //FIXME: order is fucked.
mangle[0] = 360-mangle[0]; //FIXME: pitch is fucked too.
}
//_softangle -- the inner cone angle of a spotlight.
else if (!strcmp("angles", key)) //richer cubemap orientation.
sscanf(value, "%f %f %f", &angles[0], &angles[1], &angles[2]);
else if (!strcmp("color", key))
sscanf(value, "%f %f %f", &color[0], &color[1], &color[2]);
else if (!strcmp("wait", key))
fadescale = atof(value);
else if (!strcmp("target", key))
Q_strncpyz(target, value, sizeof(target));
else if (!strcmp("classname", key))
{
if (!strncmp(value, "light", 5))
{
islight = true;
if (!strcmp(value, "light_fluoro"))
{
originhack[0] = 0;
originhack[1] = 0;
originhack[2] = 0;
overridecolor[0] = 1;
overridecolor[1] = 1;
overridecolor[2] = 1;
}
if (!strcmp(value, "light_fluorospark"))
{
originhack[0] = 0;
originhack[1] = 0;
originhack[2] = 0;
overridecolor[0] = 1;
overridecolor[1] = 1;
overridecolor[2] = 1;
}
if (!strcmp(value, "light_globe"))
{
originhack[0] = 0;
originhack[1] = 0;
originhack[2] = 0;
overridecolor[0] = 1;
overridecolor[1] = 0.8;
overridecolor[2] = 0.4;
}
if (!strcmp(value, "light_flame_large_yellow"))
{
originhack[0] = 0;
originhack[1] = 0;
originhack[2] = 0;
overridecolor[0] = 1;
overridecolor[1] = 0.5;
overridecolor[2] = 0.1;
}
if (!strcmp(value, "light_flame_small_yellow"))
{
originhack[0] = 0;
originhack[1] = 0;
originhack[2] = 0;
overridecolor[0] = 1;
overridecolor[1] = 0.5;
overridecolor[2] = 0.1;
}
if (!strcmp(value, "light_torch_small_white"))
{
originhack[0] = 0;
originhack[1] = 0;
originhack[2] = 0;
overridecolor[0] = 1;
overridecolor[1] = 0.5;
overridecolor[2] = 0.1;
}
if (!strcmp(value, "light_torch_small_walltorch"))
{
originhack[0] = 0;
originhack[1] = 0;
originhack[2] = 0;
overridecolor[0] = 1;
overridecolor[1] = 0.5;
overridecolor[2] = 0.1;
}
}
}
else if (!strcmp("style", key))
style = atoi(value);
else if (!strcmp("skin", key))
skin = (int)atof(value);
else if (!strcmp("pflags", key))
pflags = (int)atof(value);
//else if (!strcmp("effects", key))
//effects = (int)atof(value);
else if (!strcmp("scale", key))
lightscale = atof(value);
else if (!strcmp("fade", key))
fadescale = atof(value);
#ifdef MAP_PROC
else if (!strcmp("nodynamicshadows", key)) //doom3
;
else if (!strcmp("noshadows", key)) //doom3
{
if (atof(value))
pflags |= PFLAGS_NOSHADOW;
}
else if (!strcmp("nospecular", key))//doom3
{
if (atof(value))
colourscales[2] = 0;
}
else if (!strcmp("nodiffuse", key)) //doom3
{
if (atof(value))
colourscales[1] = 0;
}
#endif
else if (!strcmp("light_radius", key))
{
light[0] = 1;
light[1] = 1;
light[2] = 1;
light[3] = atof(value);
}
else if (entnum == 0 && !strcmp("noautolight", key))
{
//tenebrae compat. don't generate rtlights automagically if the world entity specifies this.
if (atoi(value))
{
okay = true;
InfoBuf_Clear(&targets, true);
return okay;
}
}
else if (entnum == 0 && !strcmp("lightmapbright", key))
{
//tenebrae compat. this overrides r_shadow_realtime_world_lightmap
r_shadow_realtime_world_lightmaps_force = atof(value);
}
}
}
if (!islight)
continue;
if (lightscale <= 0)
lightscale = 1;
if (fadescale <= 0)
fadescale = 1;
if (color[0] >= 16 || color[1] >= 16 || color[2] >= 16) //_color 255 255 255 should be identity, not super-oversaturated.
VectorScale(color, 1/255.0, color); //if only there were standards for this sort of thing.
if (color[0] == color[1] && color[0] == color[2])
{
color[0] *= overridecolor[0];
color[1] *= overridecolor[1];
color[2] *= overridecolor[2];
}
radius = light[3] * r_editlights_import_radius.value * lightscale / fadescale;
color[0] = color[0] * light[0];
color[1] = color[1] * light[1];
color[2] = color[2] * light[2];
#define CUTOFF (128.0/255)
switch (type)
{
case LIGHTTYPE_MINUSX:
break;
case LIGHTTYPE_RECIPX:
#if 1
radius *= 2;
// VectorScale(color, (1.0f / 16.0f), color);
#else
//light util uses something like: cutoff == light/((scaledist*fadescale*radius)/128)
//radius = light/(cutoff*128*scaledist*fadescale)
radius = lightscale*r_editlights_import_radius.value*256/(1*fadescale);
radius = min(radius, 300);
VectorScale(color, 255/light[3], color);
#endif
break;
case LIGHTTYPE_RECIPXX:
case LIGHTTYPE_RECIPXX2:
#if 1
radius *= 2;
// VectorScale(color, (1.0f / 16.0f), color);
#else
//light util uses something like: cutoff == light/((scaledist*scaledist*fadescale*fadescale*radius*radius)/(128*128))
radius = lightscale*r_editlights_import_radius.value*sqrt(1/CUTOFF*128*128*1*1*fadescale*fadescale);
radius = min(radius, 300);
VectorScale(color, 255/light[3], color);
#endif
break;
default:
case LIGHTTYPE_INFINITE:
radius = FLT_MAX; //close enough
break;
case LIGHTTYPE_LOCALMIN: //can't support, treat like LIGHTTYPE_MINUSX
break;
case LIGHTTYPE_SUN:
break;
}
if (rerelease)
{
if (r_shadow_realtime_world_lightmaps_force < 0)
r_shadow_realtime_world_lightmaps_force = 1;
}
else if (radius < 50) //some mappers insist on many tiny lights. such lights can usually get away with no shadows..
pflags |= PFLAGS_NOSHADOW;
VectorAdd(origin, originhack, origin);
if (radius >= 1 && !(cl.worldmodel->funcs.PointContents(cl.worldmodel, NULL, origin) & FTECONTENTS_SOLID))
{
dlight_t *dl = CL_AllocSlight();
if (!dl)
break;
VectorCopy(origin, dl->origin);
VectorCopy(angles, dl->angles);
AngleVectors(dl->angles, dl->axis[0], dl->axis[1], dl->axis[2]);
VectorInverse(dl->axis[1]);
dl->radius = radius;
VectorCopy(color, dl->color);
dl->flags = 0;
dl->flags |= rerelease?LFLAG_REALTIMEMODE|LFLAG_NORMALMODE:LFLAG_REALTIMEMODE;
dl->flags |= (pflags & PFLAGS_CORONA)?LFLAG_FLASHBLEND:0;
dl->flags |= (pflags & PFLAGS_NOSHADOW)?LFLAG_NOSHADOWS:0;
dl->style = style;
dl->fade[0] = fade[0];
dl->fade[1] = fade[1];
VectorCopy(colourscales, dl->lightcolourscales);
//handle spotlights.
if (mangle[0] || mangle[1] || mangle[2])
{
dl->fov = angles[1];
if (!dl->fov) //default is 40, supposedly
dl->fov = 40;
VectorCopy(mangle, dl->angles);
AngleVectors(dl->angles, dl->axis[0], dl->axis[1], dl->axis[2]);
VectorInverse(dl->axis[1]);
}
else if (*target)
{
lmp = InfoBuf_ValueForKey(&targets, target);
if (*lmp)
{
dl->fov = angles[1];
if (!dl->fov) //default is 40, supposedly
dl->fov = 40;
sscanf(lmp, "%f %f %f", &angles[0], &angles[1], &angles[2]);
VectorSubtract(angles, origin, dl->axis[0]);
VectorNormalize(dl->axis[0]);
VectorVectors(dl->axis[0], dl->axis[1], dl->axis[2]);
VectorInverse(dl->axis[1]);
//we don't have any control over the inner cone.
//so queries work properly
VectorAngles(dl->axis[0], dl->axis[2], dl->angles, false);
dl->angles[0] = anglemod(dl->angles[0]);
}
}
if (skin >= 16)
R_LoadNumberedLightTexture(dl, skin);
okay = true;
}
}
InfoBuf_Clear(&targets, true);
return okay;
}
qboolean R_LoadRTLights(void)
{
dlight_t *dl;
char fname[MAX_QPATH];
char cubename[MAX_QPATH];
char customstyle[1024];
char *file;
char *end;
int style;
vec3_t org;
float radius;
vec3_t rgb;
vec3_t avel;
float fov, nearclip;
unsigned int flags;
float coronascale;
float corona;
float ambientscale, diffusescale, specularscale;
vec3_t angles;
float fade[2];
//delete all old lights, even dynamic ones
rtlights_first = RTL_FIRST;
rtlights_max = RTL_FIRST;
COM_StripExtension(cl.worldmodel->name, fname, sizeof(fname));
strncat(fname, ".rtlights", MAX_QPATH-1);
file = COM_LoadTempFile(fname, 0, NULL);
if (file)
while(1)
{
end = strchr(file, '\n');
if (!end)
end = file + strlen(file);
if (end == file)
break;
*end = '\0';
while(*file == ' ' || *file == '\t')
file++;
if (*file == '#')
{
file++;
while(*file == ' ' || *file == '\t')
file++;
file = COM_Parse(file);
if (!Q_strcasecmp(com_token, "lightmaps"))
{
file = COM_Parse(file);
//foo = atoi(com_token);
}
else
Con_DPrintf("Unknown directive: %s\n", com_token);
file = end+1;
continue;
}
else if (*file == '!')
{
flags = LFLAG_NOSHADOWS;
file++;
}
else
flags = 0;
file = COM_Parse(file);
org[0] = atof(com_token);
file = COM_Parse(file);
org[1] = atof(com_token);
file = COM_Parse(file);
org[2] = atof(com_token);
file = COM_Parse(file);
radius = atof(com_token);
file = COM_Parse(file);
rgb[0] = file?atof(com_token):1;
file = COM_Parse(file);
rgb[1] = file?atof(com_token):1;
file = COM_Parse(file);
rgb[2] = file?atof(com_token):1;
file = COM_Parse(file);
style = file?atof(com_token):0;
file = COM_Parse(file);
//cubemap
Q_strncpyz(cubename, com_token, sizeof(cubename));
file = COM_Parse(file);
//corona
corona = file?atof(com_token):0;
file = COM_Parse(file);
angles[0] = file?atof(com_token):0;
file = COM_Parse(file);
angles[1] = file?atof(com_token):0;
file = COM_Parse(file);
angles[2] = file?atof(com_token):0;
file = COM_Parse(file);
//corona scale
coronascale = file?atof(com_token):0.25;
file = COM_Parse(file);
//ambient
ambientscale = file?atof(com_token):0;
file = COM_Parse(file);
//diffuse
diffusescale = file?atof(com_token):1;
file = COM_Parse(file);
//specular
specularscale = file?atof(com_token):1;
file = COM_Parse(file);
flags |= file?atoi(com_token):LFLAG_REALTIMEMODE;
nearclip = fov = avel[0] = avel[1] = avel[2] = fade[0] = fade[1] = 0;
*customstyle = 0;
while(file)
{
file = COM_Parse(file);
if (!strncmp(com_token, "rotx=", 5))
avel[0] = file?atof(com_token+5):0;
else if (!strncmp(com_token, "roty=", 5))
avel[1] = file?atof(com_token+5):0;
else if (!strncmp(com_token, "rotz=", 5))
avel[2] = file?atof(com_token+5):0;
else if (!strncmp(com_token, "fov=", 4))
fov = file?atof(com_token+4):0;
else if (!strncmp(com_token, "fademin=", 8))
fade[0] = file?atof(com_token+8):0;
else if (!strncmp(com_token, "fademax=", 8))
fade[1] = file?atof(com_token+4):0;
else if (!strncmp(com_token, "nearclip=", 9))
nearclip = file?atof(com_token+9):0;
else if (!strncmp(com_token, "nostencil=", 10))
flags |= atoi(com_token+10)?LFLAG_SHADOWMAP:0;
else if (!strncmp(com_token, "crepuscular=", 12))
flags |= atoi(com_token+12)?LFLAG_CREPUSCULAR:0;
else if (!strncmp(com_token, "ortho=", 6))
flags |= atoi(com_token+6)?LFLAG_ORTHO:0;
else if (!strncmp(com_token, "stylestring=", 12))
Q_strncpyz(customstyle, com_token+12, sizeof(customstyle));
else if (file)
Con_DPrintf("Unknown .rtlights arg \"%s\"\n", com_token);
}
if (radius)
{
dl = CL_AllocSlight();
if (!dl)
break;
VectorCopy(org, dl->origin);
dl->radius = radius;
VectorCopy(rgb, dl->color);
dl->corona = corona;
dl->coronascale = coronascale;
dl->die = 0;
dl->flags = flags;
dl->fov = fov;
dl->nearclip = nearclip;
dl->lightcolourscales[0] = ambientscale;
dl->lightcolourscales[1] = diffusescale;
dl->lightcolourscales[2] = specularscale;
dl->fade[0] = fade[0];
dl->fade[1] = fade[1];
VectorCopy(angles, dl->angles);
AngleVectorsFLU(angles, dl->axis[0], dl->axis[1], dl->axis[2]);
VectorCopy(avel, dl->rotation);
Q_strncpyz(dl->cubemapname, cubename, sizeof(dl->cubemapname));
if (*dl->cubemapname)
dl->cubetexture = R_LoadReplacementTexture(dl->cubemapname, "", IF_TEXTYPE_CUBE, NULL, 0, 0, TF_INVALID);
else
dl->cubetexture = r_nulltex;
dl->style = style;
dl->customstyle = (*customstyle)?Z_StrDup(customstyle):NULL;
}
file = end+1;
}
return !!file;
}
static void R_SaveRTLights_f(void)
{
dlight_t *light;
vfsfile_t *f;
unsigned int i;
char fname[MAX_QPATH];
char displayname[MAX_OSPATH];
vec3_t ang;
int ver = 0;
COM_StripExtension(cl.worldmodel->name, fname, sizeof(fname));
strncat(fname, ".rtlights", MAX_QPATH-1);
FS_CreatePath(fname, FS_GAMEONLY);
f = FS_OpenVFS(fname, "wb", FS_GAMEONLY);
if (!f)
{
Con_Printf("couldn't open %s\n", fname);
return;
}
// VFS_PUTS(f, va("#lightmap %f\n", foo));
for (light = cl_dlights+rtlights_first, i=rtlights_first; i<rtlights_max; i++, light++)
{
if (light->die)
continue;
if (!light->radius)
continue;
VectorAngles(light->axis[0], light->axis[2], ang, false);
//the .rtlights format is defined by DP, the first few parts cannot be changed without breaking wider compat.
//it got extended a few times. only write what we need for greater compat, just in case.
if ((light->flags & (LFLAG_SHADOWMAP|LFLAG_CREPUSCULAR|LFLAG_ORTHO)) || light->rotation[0] || light->rotation[1] || light->rotation[2] || light->fov || light->customstyle)
ver = 2; //one of our own flags. always spew the full DP stuff to try to avoid confusion
else if (light->coronascale!=0.25 || light->lightcolourscales[0]!=0 || light->lightcolourscales[1]!=1 || light->lightcolourscales[2]!=1 || (light->flags&~LFLAG_NOSHADOWS) != LFLAG_REALTIMEMODE)
ver = 2;
else if (*light->cubemapname || light->corona || ang[0] || ang[1] || ang[2])
ver = 1;
else
ver = 0;
VFS_PRINTF(f,
"%s%f %f %f "
"%f %f %f %f "
"%i",
(light->flags & LFLAG_NOSHADOWS)?"!":"", light->origin[0], light->origin[1], light->origin[2],
light->radius, light->color[0], light->color[1], light->color[2],
light->style);
if (ver > 0)
VFS_PRINTF(f, " \"%s\" %f %f %f %f", light->cubemapname, light->corona, ang[0], ang[1], ang[2]);
if (ver > 1)
VFS_PRINTF(f, " %f %f %f %f %i", light->coronascale, light->lightcolourscales[0], light->lightcolourscales[1], light->lightcolourscales[2], light->flags&(LFLAG_NORMALMODE|LFLAG_REALTIMEMODE));
//our weird flags
if (light->flags&LFLAG_SHADOWMAP)
VFS_PRINTF(f, " nostencil=1");
if (light->flags&LFLAG_CREPUSCULAR)
VFS_PRINTF(f, " crepuscular=1");
if (light->flags&LFLAG_ORTHO)
VFS_PRINTF(f, " ortho=1");
//spinning lights (for cubemaps)
if (light->rotation[0] || light->rotation[1] || light->rotation[2])
VFS_PRINTF(f, " rotx=%g roty=%g rotz=%g", light->rotation[0],light->rotation[1],light->rotation[2]);
//spotlights
if (light->fov)
VFS_PRINTF(f, " fov=%g", light->fov); //aka: outer cone
if (light->nearclip)
VFS_PRINTF(f, " nearclip=%g", light->nearclip); //aka: distance into a wall, for lights that are meant to appear to come from a texture
if (light->customstyle)
VFS_PRINTF(f, " \"stylestring=%s\"", light->customstyle); //aka: outer cone
if (light->fade[1]>0)
VFS_PRINTF(f, " \"fademin=%g\" \"fademax=%g\"", light->fade[0], light->fade[1]);
VFS_PUTS(f, "\n");
}
VFS_CLOSE(f);
FS_DisplayPath(fname, FS_GAMEONLY, displayname, sizeof(displayname));
Con_Printf("rtlights saved to %s\n", displayname);
}
void R_StaticEntityToRTLight(int i)
{
entity_state_t *state = &cl_static_entities[i].state;
dlight_t *dl;
if (!(state->lightpflags&(PFLAGS_FULLDYNAMIC|PFLAGS_CORONA)))
return;
dl = CL_AllocSlight();
if (!dl)
return;
VectorCopy(state->origin, dl->origin);
AngleVectors(state->angles, dl->axis[0], dl->axis[1], dl->axis[2]);
VectorInverse(dl->axis[1]);
dl->radius = state->light[3];
if (!dl->radius)
dl->radius = 350;
VectorScale(state->light, 1.0/1024, dl->color);
if (!state->light[0] && !state->light[1] && !state->light[2])
VectorSet(dl->color, 1, 1, 1);
dl->flags = 0;
dl->flags |= LFLAG_NORMALMODE|LFLAG_REALTIMEMODE;
dl->flags |= (state->lightpflags & PFLAGS_NOSHADOW)?LFLAG_NOSHADOWS:0;
if (state->lightpflags & PFLAGS_CORONA)
dl->corona = 1;
dl->style = state->lightstyle;
if (state->lightpflags & PFLAGS_FULLDYNAMIC)
{
dl->lightcolourscales[0] = r_editlights_import_ambient.value;
dl->lightcolourscales[1] = r_editlights_import_diffuse.value;
dl->lightcolourscales[2] = r_editlights_import_specular.value;
}
else
{ //corona-only light
dl->lightcolourscales[0] = 0;
dl->lightcolourscales[1] = 0;
dl->lightcolourscales[2] = 0;
}
if (state->skinnum >= 16)
R_LoadNumberedLightTexture(dl, state->skinnum);
}
static void R_ReloadRTLights_f(void)
{
int i;
if (!cl.worldmodel)
{
Con_Printf("Cannot reload lights at this time\n");
return;
}
rtlights_first = RTL_FIRST;
rtlights_max = RTL_FIRST;
r_shadow_realtime_world_lightmaps_force = -1;
if (!strcmp(Cmd_Argv(1), "bsp"))
R_ImportRTLights(Mod_GetEntitiesString(cl.worldmodel), 1);
else if (!strcmp(Cmd_Argv(1), "rtlights"))
R_LoadRTLights();
else if (!strcmp(Cmd_Argv(1), "statics"))
{
for (i = 0; i < cl.num_statics; i++)
R_StaticEntityToRTLight(i);
}
else if (!strcmp(Cmd_Argv(1), "none"))
;
else
{
//try to load .rtlights file
if (rtlights_first == rtlights_max)
R_LoadRTLights();
//if there's a static entity with rtlights set, then assume the mod is taking care of it for us.
if (rtlights_first == rtlights_max)
for (i = 0; i < cl.num_statics; i++)
R_StaticEntityToRTLight(i);
//otherwise try to import.
if (rtlights_first == rtlights_max)
R_ImportRTLights(Mod_GetEntitiesString(cl.worldmodel), r_shadow_realtime_world_importlightentitiesfrommap.ival);
}
if (r_shadow_realtime_world_lightmaps_force >= 0)
r_shadow_realtime_world_lightmaps.value = r_shadow_realtime_world_lightmaps_force;
else
r_shadow_realtime_world_lightmaps.value = atof(r_shadow_realtime_world_lightmaps.string);
}
//-1 for arg error
static int R_EditLight(dlight_t *dl, const char *cmd, int argc, const char *x, const char *y, const char *z)
{
if (argc == 1)
{
y = x;
z = x;
}
if (!strcmp(cmd, "origin"))
{
dl->origin[0] = atof(x);
dl->origin[1] = atof(y);
dl->origin[2] = atof(z);
}
else if (!strcmp(cmd, "originscale"))
{
dl->origin[0] *= atof(x);
dl->origin[1] *= atof(y);
dl->origin[2] *= atof(z);
}
else if (!strcmp(cmd, "originx"))
dl->origin[0] = atof(x);
else if (!strcmp(cmd, "originy"))
dl->origin[1] = atof(x);
else if (!strcmp(cmd, "originz"))
dl->origin[2] = atof(x);
else if (!strcmp(cmd, "move"))
{
dl->origin[0] += atof(x);
dl->origin[1] += atof(y);
dl->origin[2] += atof(z);
}
else if (!strcmp(cmd, "movex"))
dl->origin[0] += atof(x);
else if (!strcmp(cmd, "movey"))
dl->origin[1] += atof(x);
else if (!strcmp(cmd, "movez"))
dl->origin[2] += atof(x);
else if (!strcmp(cmd, "angles"))
{
dl->angles[0] = atof(x);
dl->angles[1] = atof(y);
dl->angles[2] = atof(z);
AngleVectors(dl->angles, dl->axis[0], dl->axis[1], dl->axis[2]);
VectorInverse(dl->axis[1]);
}
else if (!strcmp(cmd, "anglesx"))
{
dl->angles[0] = atof(x);
AngleVectors(dl->angles, dl->axis[0], dl->axis[1], dl->axis[2]);
VectorInverse(dl->axis[1]);
}
else if (!strcmp(cmd, "anglesy"))
{
dl->angles[1] = atof(x);
AngleVectors(dl->angles, dl->axis[0], dl->axis[1], dl->axis[2]);
VectorInverse(dl->axis[1]);
}
else if (!strcmp(cmd, "anglesz"))
{
dl->angles[2] = atof(x);
AngleVectors(dl->angles, dl->axis[0], dl->axis[1], dl->axis[2]);
VectorInverse(dl->axis[1]);
}
else if (!strcmp(cmd, "avel") || !strcmp(cmd, "spin"))
{
dl->rotation[0] = atof(x);
dl->rotation[1] = atof(y);
dl->rotation[2] = atof(z);
}
else if (!strcmp(cmd, "avelx"))
dl->rotation[0] = atof(x);
else if (!strcmp(cmd, "avey"))
dl->rotation[1] = atof(x);
else if (!strcmp(cmd, "avelz"))
dl->rotation[2] = atof(x);
else if (!strcmp(cmd, "outercone") || !strcmp(cmd, "fov") || !strcmp(cmd, "cone"))
dl->fov = atof(x);
else if (!strcmp(cmd, "nearclip"))
dl->nearclip = atof(x);
else if (!strcmp(cmd, "color") || !strcmp(cmd, "colour"))
{
dl->color[0] = atof(x);
dl->color[1] = atof(y);
dl->color[2] = atof(z);
}
else if (!strcmp(cmd, "colorscale") || !strcmp(cmd, "colourscale"))
{
dl->color[0] *= atof(x);
dl->color[1] *= atof(y);
dl->color[2] *= atof(z);
}
else if (!strcmp(cmd, "radius"))
dl->radius = atof(x);
else if (!strcmp(cmd, "radiusscale") || !strcmp(cmd, "sizescale"))
dl->radius *= atof(x);
else if (!strcmp(cmd, "style"))
dl->style = atoi(x);
else if (!strcmp(cmd, "stylestring"))
{
Z_Free(dl->customstyle);
dl->customstyle = x?Z_StrDup(x):NULL;
}
else if (!strcmp(cmd, "cubemap"))
{
Q_strncpyz(dl->cubemapname, x, sizeof(dl->cubemapname));
if (*dl->cubemapname)
dl->cubetexture = R_LoadReplacementTexture(dl->cubemapname, "", IF_TEXTYPE_CUBE, NULL, 0, 0, TF_INVALID);
else
dl->cubetexture = r_nulltex;
}
else if (!strcmp(cmd, "shadows"))
dl->flags = (dl->flags&~LFLAG_NOSHADOWS) | ((*x=='y'||*x=='Y'||*x=='t'||atoi(x))?0:LFLAG_NOSHADOWS);
else if (!strcmp(cmd, "nostencil"))
dl->flags = (dl->flags&~LFLAG_SHADOWMAP) | ((*x=='y'||*x=='Y'||*x=='t'||atoi(x))?0:LFLAG_SHADOWMAP);
else if (!strcmp(cmd, "crepuscular"))
dl->flags = (dl->flags&~LFLAG_CREPUSCULAR) | ((*x=='y'||*x=='Y'||*x=='t'||atoi(x))?LFLAG_CREPUSCULAR:0);
else if (!strcmp(cmd, "ortho"))
dl->flags = (dl->flags&~LFLAG_ORTHO) | ((*x=='y'||*x=='Y'||*x=='t'||atoi(x))?LFLAG_ORTHO:0);
else if (!strcmp(cmd, "corona"))
dl->corona = atof(x);
else if (!strcmp(cmd, "coronasize"))
dl->coronascale = atof(x);
else if (!strcmp(cmd, "ambient"))
dl->lightcolourscales[0] = atof(x);
else if (!strcmp(cmd, "diffuse"))
dl->lightcolourscales[1] = atof(x);
else if (!strcmp(cmd, "specular"))
dl->lightcolourscales[2] = atof(x);
else if (!strcmp(cmd, "normalmode"))
dl->flags = (dl->flags&~LFLAG_NORMALMODE) | ((*x=='y'||*x=='Y'||*x=='t'||atoi(x))?LFLAG_NORMALMODE:0);
else if (!strcmp(cmd, "realtimemode"))
dl->flags = (dl->flags&~LFLAG_REALTIMEMODE) | ((*x=='y'||*x=='Y'||*x=='t'||atoi(x))?LFLAG_REALTIMEMODE:0);
else
return -2;
dl->rebuildcache = true; //mneh, lets just flag it for everything.
return 1;
}
void R_EditLights_DrawInfo(void)
{
float fontscale[2] = {8,8};
float x = vid.width - 320;
float y = 0;
const char *s;
if (!r_editlights.ival)
return;
if (r_editlights_selected >= RTL_FIRST && r_editlights_selected < rtlights_max)
{
dlight_t *dl = &cl_dlights[r_editlights_selected];
s = va( " Origin : %.0f %.0f %.0f\n"
" Angles : %.0f %.0f %.0f\n"
" Colour : %.2f %.2f %.2f\n"
" Radius : %.0f\n"
" Corona : %.0f\n"
" Style : %i\n"
"Style String : %s\n"
" Shadows : %s\n"
" Cubemap : \"%s\"\n"
" CoronaSize : %.2f\n"
" Ambient : %.2f\n"
" Diffuse : %.2f\n"
" Specular : %.2f\n"
" NormalMode : %s\n"
"RealTimeMode : %s\n"
" FadeDist : %.0f-%.0f\n"
" Spin : %.0f %.0f %.0f\n"
" Cone : %.0f\n"
" Nearclip : %.0f\n"
//"NoStencil : %s\n"
//"Crepuscular : %s\n"
//"Ortho : %s\n"
,dl->origin[0],dl->origin[1],dl->origin[2]
,dl->angles[0],dl->angles[1],dl->angles[2]
,dl->color[0],dl->color[1],dl->color[2]
,dl->radius, dl->corona, dl->style, dl->customstyle?dl->customstyle:"---"
,((dl->flags&LFLAG_NOSHADOWS)?"no":"yes"), dl->cubemapname, dl->coronascale
,dl->lightcolourscales[0], dl->lightcolourscales[1], dl->lightcolourscales[2]
,((dl->flags&LFLAG_NORMALMODE)?"yes":"no"), ((dl->flags&LFLAG_REALTIMEMODE)?"yes":"no")
,dl->fade[0], dl->fade[1]
,dl->rotation[0],dl->rotation[1],dl->rotation[2], dl->fov, dl->nearclip
//,((dl->flags&LFLAG_SHADOWMAP)?"no":"yes"),((dl->flags&LFLAG_CREPUSCULAR)?"yes":"no"),((dl->flags&LFLAG_ORTHO)?"yes":"no")
);
}
else
s = "No light selected";
R2D_ImageColours(0,0,0,.35);
R2D_FillBlock(x-4, y, 320+4, 16*8+4);
R2D_ImageColours(1,1,1,1);
R_DrawTextField(x, y, 320, 19*8, s, CON_WHITEMASK, CPRINT_LALIGN|CPRINT_TALIGN|CPRINT_NOWRAP, font_default, fontscale);
}
void R_EditLights_DrawLights(void)
{
const float SPRITE_SIZE = 8;
int i;
dlight_t *l;
enum
{
// ELS_CURSOR,
ELS_SELECTED,
ELS_LIGHT,
ELS_NOSHADOW,
ELS_MAX
};
char *lightshaderinfo[] =
{
/* "gfx/editlights/cursor",
".59..95."
"59....95"
"9.9..9.9"
"...99..."
"...99..."
"9.9..9.9"
"59....95"
".59..95.",
*/
"gfx/editlights/selected",
"999..999"
"99....99"
"9......9"
"........"
"........"
"9......9"
"99....99"
"999..999",
"gfx/editlights/light",
"..1221.."
".245542."
"14677641"
"25799752"
"25799752"
"14677641"
".245542."
"..1221..",
"gfx/editlights/noshadow",
"..1221.."
".245542."
"14644641"
"274..472" //mmm, donuts.
"274..472"
"14644641"
".247742."
"..1221..",
};
shader_t *shaders[ELS_MAX], *s;
unsigned int asciipalette[256];
asciipalette['.'] = 0;
for (i = 0; i < 10; i++)
asciipalette['0'+i] = 0xff000000 | ((int)(255/9.0*i)*0x010101);
if (!r_editlights.ival)
return;
for (i = 0; i < ELS_MAX; i++)
{
shaders[i] = R_RegisterShader(lightshaderinfo[i*2+0], SUF_NONE, va(
"{\n"
"program defaultadditivesprite\n"
"{\n"
"map $diffuse\n"
"blendfunc gl_one gl_one\n"
"rgbgen vertex\n"
"alphagen vertex\n"
"%s"
"}\n"
"}\n"
,(i==ELS_SELECTED)?"nodepth\n":"")
);
if (!shaders[i]->defaulttextures->base)
shaders[i]->defaulttextures->base = Image_GetTexture(shaders[i]->name, NULL, IF_LINEAR|IF_NOMIPMAP|IF_NOPICMIP|IF_CLAMP, lightshaderinfo[i*2+1], asciipalette, 8, 8, TF_8PAL32);
}
if (!r_editlights_locked)
{
vec3_t targ, norm;
int ent;
int best = -1;
float bestscore = 0, score;
VectorMA(r_refdef.vieworg, r_editlights_cursordistance.value, vpn, targ); //try to aim about 1024qu infront of the camera
CL_TraceLine(r_refdef.vieworg, targ, r_editlights_cursor, norm, &ent); //figure out where the cursor ends up
VectorMA(r_editlights_cursor, r_editlights_cursorpushoff.value, norm, r_editlights_cursor); //push off from the surface by 4qu.
VectorMA(r_editlights_cursor, -r_editlights_cursorpushback.value, vpn, r_editlights_cursor);//move it back towards the camera, for no apparent reason
if (r_editlights_cursorgrid.value)
{ //snap to a grid, if set
for (i =0; i < 3; i++)
r_editlights_cursor[i] = floor(r_editlights_cursor[i] / r_editlights_cursorgrid.value + 0.5) * r_editlights_cursorgrid.value;
}
// CLQ1_AddSpriteQuad(shaders[ELS_CURSOR], r_editlights_cursor, SPRITE_SIZE);
for (i=RTL_FIRST; i<rtlights_max; i++)
{
l = &cl_dlights[i];
if (!l->radius) //dead light is dead.
continue;
VectorSubtract(l->origin, r_refdef.vieworg, targ);
score = DotProduct(vpn, targ) / sqrt(DotProduct(targ,targ));
if (score >= .95) //there's a threshhold required for a light to be selectable.
{
//trace from the light to the view (so startsolid doesn't cause so many problems)
if (score > bestscore && CL_TraceLine(l->origin, r_refdef.vieworg, r_editlights_cursor, norm, &ent) == 1.0)
{
bestscore = score;
best = i;
}
}
}
r_editlights_selected = best;
}
for (i=RTL_FIRST; i<rtlights_max; i++)
{
l = &cl_dlights[i];
if (!l->radius) //dead light is dead.
continue;
//we should probably show spotlights with a special icon or something
//dp has alternate icons for cubemaps.
if (l->flags & LFLAG_NOSHADOWS)
s = shaders[ELS_NOSHADOW];
else
s = shaders[ELS_LIGHT];
CLQ1_AddSpriteQuad(s, l->origin, SPRITE_SIZE);
}
if (r_editlights_selected >= RTL_FIRST && r_editlights_selected < rtlights_max)
{
l = &cl_dlights[r_editlights_selected];
CLQ1_AddSpriteQuad(shaders[ELS_SELECTED], l->origin, SPRITE_SIZE);
}
}
static void R_EditLights_Edit_f(void)
{
int i = r_editlights_selected;
const char *cmd = Cmd_Argv(1);
const char *x = Cmd_Argv(2);
const char *y = Cmd_Argv(3);
const char *z = Cmd_Argv(4);
int argc = Cmd_Argc()-2;
dlight_t *dl;
if (!r_editlights.ival)
{
Con_Printf("Toggle r_editlights first\n");
return;
}
if (i < RTL_FIRST || i >= rtlights_max)
{
Con_Printf("No light selected\n");
return;
}
dl = &cl_dlights[i];
if (!*cmd)
{
Con_Print("Selected light's properties:\n");
Con_Printf("Origin : ^[%f %f %f\\type\\r_editlights_edit origin %g %g %g^]\n", dl->origin[0],dl->origin[1],dl->origin[2], dl->origin[0],dl->origin[1],dl->origin[2]);
Con_Printf("Angles : ^[%f %f %f\\type\\r_editlights_edit angles %g %g %g^]\n", dl->angles[0],dl->angles[1],dl->angles[2], dl->angles[0],dl->angles[1],dl->angles[2]);
Con_Printf("Colour : ^[%f %f %f\\type\\r_editlights_edit avel %g %g %g^]\n", dl->color[0],dl->color[1],dl->color[2], dl->color[0],dl->color[1],dl->color[2]);
Con_Printf("Radius : ^[%f\\type\\r_editlights_edit radius %g^]\n", dl->radius, dl->radius);
Con_Printf("Corona : ^[%f\\type\\r_editlights_edit corona %g^]\n", dl->corona, dl->corona);
Con_Printf("Style : ^[%i\\type\\r_editlights_edit style %i^]\n", dl->style, dl->style);
Con_Printf("Style String : ^[%s\\type\\r_editlights_edit stylestring %s^]\n", dl->customstyle?dl->customstyle:"---", dl->customstyle?dl->customstyle:"");
Con_Printf("Shadows : ^[%s\\type\\r_editlights_edit shadows %s^]\n", ((dl->flags&LFLAG_NOSHADOWS)?"no":"yes"), ((dl->flags&LFLAG_NOSHADOWS)?"no":"yes"));
Con_Printf("Cubemap : ^[\"%s\"\\type\\r_editlights_edit cubemap \"%s\"^]\n", dl->cubemapname, dl->cubemapname);
Con_Printf("CoronaSize : ^[%f\\type\\r_editlights_edit coronasize %g^]\n", dl->coronascale, dl->coronascale);
Con_Printf("Ambient : ^[%f\\type\\r_editlights_edit ambient %g^]\n", dl->lightcolourscales[0], dl->lightcolourscales[0]);
Con_Printf("Diffuse : ^[%f\\type\\r_editlights_edit diffuse %g^]\n", dl->lightcolourscales[1], dl->lightcolourscales[1]);
Con_Printf("Specular : ^[%f\\type\\r_editlights_edit specular %g^]\n", dl->lightcolourscales[2], dl->lightcolourscales[2]);
Con_Printf("NormalMode : ^[%s\\type\\r_editlights_edit normalmode %s^]\n", ((dl->flags&LFLAG_NORMALMODE)?"yes":"no"), ((dl->flags&LFLAG_NORMALMODE)?"yes":"no"));
Con_Printf("RealTimeMode : ^[%s\\type\\r_editlights_edit realtimemode %s^]\n", ((dl->flags&LFLAG_REALTIMEMODE)?"yes":"no"), ((dl->flags&LFLAG_REALTIMEMODE)?"yes":"no"));
Con_Printf("Spin : ^[%f %f %f\\type\\r_editlights_edit avel %g %g %g^]\n", dl->rotation[0],dl->rotation[1],dl->rotation[2], dl->origin[0],dl->origin[1],dl->origin[2]);
Con_Printf("Cone : ^[%f\\type\\r_editlights_edit outercone %g^]\n", dl->fov, dl->fov);
Con_Printf("NearClip : ^[%f\\type\\r_editlights_edit nearclip %g^]\n", dl->nearclip, dl->nearclip);
// Con_Printf("NoStencil : ^[%s\\type\\r_editlights_edit nostencil %s^]\n", ((dl->flags&LFLAG_SHADOWMAP)?"no":"yes"), ((dl->flags&LFLAG_SHADOWMAP)?"no":"yes"));
// Con_Printf("Crepuscular : ^[%s\\type\\r_editlights_edit crepuscular %s^]\n", ((dl->flags&LFLAG_CREPUSCULAR)?"yes":"no"), ((dl->flags&LFLAG_CREPUSCULAR)?"yes":"no"));
// Con_Printf("Ortho : ^[%s\\type\\r_editlights_edit ortho %s^]\n", ((dl->flags&LFLAG_ORTHO)?"yes":"no"), ((dl->flags&LFLAG_ORTHO)?"yes":"no"));
return;
}
switch(R_EditLight(dl, cmd, argc, x,y,z))
{
case -1:
Con_Printf("Not enough args for %s\n", cmd);
return;
case -2:
Con_Printf("Argument not known: %s\n", cmd);
return;
}
}
static void R_EditLights_Remove_f(void)
{
int i = r_editlights_selected;
dlight_t *dl;
if (!r_editlights.ival)
{
Con_Printf("Toggle r_editlights first\n");
return;
}
if (i < RTL_FIRST || i >= rtlights_max)
{
Con_Printf("No light selected\n");
return;
}
dl = &cl_dlights[i];
dl->radius = 0;
r_editlights_selected = -1;
}
static void R_EditLights_EditAll_f(void)
{
int i = 0;
const char *cmd = Cmd_Argv(1);
const char *x = Cmd_Argv(2);
const char *y = Cmd_Argv(3);
const char *z = Cmd_Argv(4);
int argc = Cmd_Argc()-2;
dlight_t *dl;
if (!r_editlights.ival)
{
Con_Printf("No light selected\n");
return;
}
for (i = RTL_FIRST; i < rtlights_max; i++)
{
dl = &cl_dlights[i];
if (dl->radius <= 0)
continue; //don't edit dead lights back to life
switch(R_EditLight(dl, cmd, argc, x,y,z))
{
case -1:
Con_Printf("Not enough args for %s\n", cmd);
return;
case -2:
Con_Printf("Argument not known: %s\n", cmd);
return;
}
}
}
static void R_EditLights_Spawn_f(void)
{
dlight_t *dl;
if (!r_editlights.ival)
{
Con_Printf("Toggle r_editlights first\n");
return;
}
dl = CL_AllocSlight();
r_editlights_selected = dl - cl_dlights;
VectorCopy(r_editlights_cursor, dl->origin);
dl->radius = 200;
dl->style = 0; //styled, but mostly static (we could use -1, but mneh).
dl->lightcolourscales[0] = 0;
dl->lightcolourscales[1] = 1;
dl->lightcolourscales[2] = 1;
}
static void R_EditLights_Clone_f(void)
{
int i = r_editlights_selected;
dlight_t *dl;
dlight_t *src;
if (!r_editlights.ival)
{
Con_Printf("Toggle r_editlights first\n");
return;
}
if (i < RTL_FIRST || i >= rtlights_max)
{
Con_Printf("No light selected\n");
return;
}
src = &cl_dlights[i];
dl = CL_AllocSlight();
r_editlights_selected = dl - cl_dlights;
CL_CloneDlight(dl, src);
VectorCopy(r_editlights_cursor, dl->origin);
}
static void R_EditLights_ToggleShadow_f(void)
{
int i = r_editlights_selected;
dlight_t *dl;
if (!r_editlights.ival)
{
Con_Printf("Toggle r_editlights first\n");
return;
}
if (i < RTL_FIRST || i >= rtlights_max)
{
Con_Printf("No light selected\n");
return;
}
dl = &cl_dlights[i];
dl->flags ^= LFLAG_NOSHADOWS;
}
static void R_EditLights_ToggleCorona_f(void)
{
int i = r_editlights_selected;
dlight_t *dl;
if (!r_editlights.ival)
{
Con_Printf("Toggle r_editlights first\n");
return;
}
if (i < RTL_FIRST || i >= rtlights_max)
{
Con_Printf("No light selected\n");
return;
}
dl = &cl_dlights[i];
dl->corona = !dl->corona;
}
static void R_EditLights_CopyInfo_f(void)
{
int i = r_editlights_selected;
dlight_t *dl;
if (!r_editlights.ival)
{
Con_Printf("Toggle r_editlights first\n");
return;
}
if (i < RTL_FIRST || i >= rtlights_max)
return;
dl = &cl_dlights[i];
CL_CloneDlight(&r_editlights_copybuffer, dl);
}
static void R_EditLights_PasteInfo_f(void)
{
int i = r_editlights_selected;
dlight_t *dl;
vec3_t org;
if (!r_editlights.ival)
{
Con_Printf("Toggle r_editlights first\n");
return;
}
if (i < RTL_FIRST || i >= rtlights_max)
{
Con_Printf("No light selected\n");
return;
}
dl = &cl_dlights[i];
VectorCopy(dl->origin, org);
CL_CloneDlight(dl, &r_editlights_copybuffer);
VectorCopy(org, dl->origin); //undo the origin's copy.
//just in case its from a different map...
if (*dl->cubemapname)
dl->cubetexture = R_LoadReplacementTexture(dl->cubemapname, "", IF_TEXTYPE_CUBE, NULL, 0, 0, TF_INVALID);
else
dl->cubetexture = r_nulltex;
}
static void R_EditLights_Lock_f(void)
{
if (!r_editlights.ival)
{
Con_Printf("Toggle r_editlights first\n");
return;
}
if ((r_editlights_selected < RTL_FIRST || r_editlights_selected >= rtlights_max) && !r_editlights_locked)
{
Con_Printf("No light selected\n");
return;
}
r_editlights_locked = !r_editlights_locked;
}
static char macro_buf[256] = "";
static char *r_editlights_current_origin(void)
{
int i = r_editlights_selected;
dlight_t *dl;
if (i < RTL_FIRST || i >= rtlights_max)
return "";
dl = &cl_dlights[i];
Q_snprintfz (macro_buf, sizeof(macro_buf), "%g %g %g", dl->origin[0], dl->origin[1], dl->origin[2]);
return macro_buf;
}
static char *r_editlights_current_angles(void)
{
int i = r_editlights_selected;
dlight_t *dl;
if (i < RTL_FIRST || i >= rtlights_max)
return "";
dl = &cl_dlights[i];
Q_snprintfz (macro_buf, sizeof(macro_buf), "%g %g %g", dl->angles[0], dl->angles[1], dl->angles[2]);
return macro_buf;
}
static char *r_editlights_current_color(void)
{
int i = r_editlights_selected;
dlight_t *dl;
if (i < RTL_FIRST || i >= rtlights_max)
return "";
dl = &cl_dlights[i];
Q_snprintfz (macro_buf, sizeof(macro_buf), "%g %g %g", dl->color[0], dl->color[1], dl->color[2]);
return macro_buf;
}
static char *r_editlights_current_radius(void)
{
int i = r_editlights_selected;
dlight_t *dl;
if (i < RTL_FIRST || i >= rtlights_max)
return "";
dl = &cl_dlights[i];
Q_snprintfz (macro_buf, sizeof(macro_buf), "%g", dl->radius);
return macro_buf;
}
static char *r_editlights_current_corona(void)
{
int i = r_editlights_selected;
dlight_t *dl;
if (i < RTL_FIRST || i >= rtlights_max)
return "";
dl = &cl_dlights[i];
Q_snprintfz (macro_buf, sizeof(macro_buf), "%g", dl->corona);
return macro_buf;
}
static char *r_editlights_current_coronasize(void)
{
int i = r_editlights_selected;
dlight_t *dl;
if (i < RTL_FIRST || i >= rtlights_max)
return "";
dl = &cl_dlights[i];
Q_snprintfz (macro_buf, sizeof(macro_buf), "%g", dl->coronascale);
return macro_buf;
}
static char *r_editlights_current_style(void)
{
int i = r_editlights_selected;
dlight_t *dl;
if (i < RTL_FIRST || i >= rtlights_max)
return "";
dl = &cl_dlights[i];
Q_snprintfz (macro_buf, sizeof(macro_buf), "%i", dl->style);
return macro_buf;
}
static char *r_editlights_current_shadows(void)
{
int i = r_editlights_selected;
dlight_t *dl;
if (i < RTL_FIRST || i >= rtlights_max)
return "";
dl = &cl_dlights[i];
if (dl->flags & LFLAG_NOSHADOWS)
return "0";
return "1";
}
static char *r_editlights_current_cubemap(void)
{
int i = r_editlights_selected;
dlight_t *dl;
if (i < RTL_FIRST || i >= rtlights_max)
return "";
dl = &cl_dlights[i];
Q_snprintfz (macro_buf, sizeof(macro_buf), "\"%s\"", dl->cubemapname);
return macro_buf;
}
static char *r_editlights_current_ambient(void)
{
int i = r_editlights_selected;
dlight_t *dl;
if (i < RTL_FIRST || i >= rtlights_max)
return "";
dl = &cl_dlights[i];
Q_snprintfz (macro_buf, sizeof(macro_buf), "%g", dl->lightcolourscales[0]);
return macro_buf;
}
static char *r_editlights_current_diffuse(void)
{
int i = r_editlights_selected;
dlight_t *dl;
if (i < RTL_FIRST || i >= rtlights_max)
return "";
dl = &cl_dlights[i];
Q_snprintfz (macro_buf, sizeof(macro_buf), "%g", dl->lightcolourscales[1]);
return macro_buf;
}
static char *r_editlights_current_specular(void)
{
int i = r_editlights_selected;
dlight_t *dl;
if (i < RTL_FIRST || i >= rtlights_max)
return "";
dl = &cl_dlights[i];
Q_snprintfz (macro_buf, sizeof(macro_buf), "%g", dl->lightcolourscales[2]);
return macro_buf;
}
static char *r_editlights_current_normalmode(void)
{
int i = r_editlights_selected;
dlight_t *dl;
if (i < RTL_FIRST || i >= rtlights_max)
return "";
dl = &cl_dlights[i];
if (dl->flags & LFLAG_NORMALMODE)
return "1";
return "0";
}
static char *r_editlights_current_realtimemode(void)
{
int i = r_editlights_selected;
dlight_t *dl;
if (i < RTL_FIRST || i >= rtlights_max)
return "";
dl = &cl_dlights[i];
if (dl->flags & LFLAG_REALTIMEMODE)
return "1";
return "0";
}
void R_EditLights_RegisterCommands(void)
{
Cmd_AddCommandD ("r_editlights_reload", R_ReloadRTLights_f, "Reload static rtlights. Argument can be rtlights|statics|bsp|none to override the source.");
Cmd_AddCommandD ("r_editlights_save", R_SaveRTLights_f, "Saves rtlights to maps/FOO.rtlights");
Cvar_Register (&r_editlights_import_radius, "Realtime Light editing/importing");
Cvar_Register (&r_editlights_import_ambient, "Realtime Light editing/importing");
Cvar_Register (&r_editlights_import_diffuse, "Realtime Light editing/importing");
Cvar_Register (&r_editlights_import_specular, "Realtime Light editing/importing");
Cvar_Register (&r_shadow_realtime_world_importlightentitiesfrommap, "Realtime Light editing/importing");
Cvar_Register (&r_editlights, "Realtime Light editing/importing");
Cvar_Register (&r_editlights_cursordistance, "Realtime Light editing/importing");
Cvar_Register (&r_editlights_cursorpushoff, "Realtime Light editing/importing");
Cvar_Register (&r_editlights_cursorpushback, "Realtime Light editing/importing");
Cvar_Register (&r_editlights_cursorgrid, "Realtime Light editing/importing");
//the rest is optional stuff that should normally be handled via csqc instead, but hurrah for dp compat...
Cmd_AddCommandD("r_editlights_spawn", R_EditLights_Spawn_f, "Spawn a new light with default properties");
Cmd_AddCommandD("r_editlights_clone", R_EditLights_Clone_f, "Duplicate the current light (with a new origin)");
Cmd_AddCommandD("r_editlights_remove", R_EditLights_Remove_f, "Removes the current light.");
Cmd_AddCommandD("r_editlights_edit", R_EditLights_Edit_f, "Changes named properties on the current light.");
Cmd_AddCommandD("r_editlights_editall", R_EditLights_EditAll_f, "Like r_editlights_edit, but affects all lights instead of just the selected one.");
Cmd_AddCommandD("r_editlights_toggleshadow", R_EditLights_ToggleShadow_f, "Toggles the shadow flag on the current light.");
Cmd_AddCommandD("r_editlights_togglecorona", R_EditLights_ToggleCorona_f, "Toggles the current light's corona field.");
Cmd_AddCommandD("r_editlights_copyinfo", R_EditLights_CopyInfo_f, "store a copy of all properties (except origin) of the selected light");
Cmd_AddCommandD("r_editlights_pasteinfo", R_EditLights_PasteInfo_f, "apply the stored properties onto the selected light (making it exactly identical except for origin)");
Cmd_AddCommandD("r_editlights_lock", R_EditLights_Lock_f, "Blocks changing the current light according the crosshair.");
//DP has these as cvars. mneh.
Cmd_AddMacroD("r_editlights_current_origin", r_editlights_current_origin, false, "origin of selected light");
Cmd_AddMacroD("r_editlights_current_angles", r_editlights_current_angles, false, "angles of selected light");
Cmd_AddMacroD("r_editlights_current_color", r_editlights_current_color, false, "color of selected light");
Cmd_AddMacroD("r_editlights_current_radius", r_editlights_current_radius, false, "radius of selected light");
Cmd_AddMacroD("r_editlights_current_corona", r_editlights_current_corona, false, "corona intensity of selected light");
Cmd_AddMacroD("r_editlights_current_coronasize",r_editlights_current_coronasize,false, "corona size of selected light");
Cmd_AddMacroD("r_editlights_current_style", r_editlights_current_style, false, "style of selected light");
Cmd_AddMacroD("r_editlights_current_shadows", r_editlights_current_shadows, false, "shadows flag of selected light");
Cmd_AddMacroD("r_editlights_current_cubemap", r_editlights_current_cubemap, false, "cubemap of selected light");
Cmd_AddMacroD("r_editlights_current_ambient", r_editlights_current_ambient, false, "ambient intensity of selected light");
Cmd_AddMacroD("r_editlights_current_diffuse", r_editlights_current_diffuse, false, "diffuse intensity of selected light");
Cmd_AddMacroD("r_editlights_current_specular", r_editlights_current_specular, false, "specular intensity of selected light");
Cmd_AddMacroD("r_editlights_current_normalmode",r_editlights_current_normalmode,false, "normalmode flag of selected light");
Cmd_AddMacroD("r_editlights_current_realtimemode", r_editlights_current_realtimemode, false, "realtimemode flag of selected light");
}
#endif
/*
=============================================================================
LIGHT SAMPLING
=============================================================================
*/
mplane_t *lightplane;
vec3_t lightspot;
static void GLQ3_AddLatLong(const qbyte latlong[2], vec3_t dir, float mag)
{
float lat = (float)latlong[0] * (2 * M_PI)*(1.0 / 255.0);
float lng = (float)latlong[1] * (2 * M_PI)*(1.0 / 255.0);
dir[0] += mag * cos ( lng ) * sin ( lat );
dir[1] += mag * sin ( lng ) * sin ( lat );
dir[2] += mag * cos ( lat );
}
void GLQ3_LightGrid(model_t *mod, const vec3_t point, vec3_t res_diffuse, vec3_t res_ambient, vec3_t res_dir)
{
q3lightgridinfo_t *lg = (q3lightgridinfo_t *)mod->lightgrid;
int index[8];
int vi[3];
int i, j;
float t[8];
vec3_t vf, vf2;
vec3_t ambient, diffuse, direction;
if (!lg || (!lg->lightgrid && !lg->rbspelements) || lg->numlightgridelems < 1)
{
if(res_ambient)
{
res_ambient[0] = 64;
res_ambient[1] = 64;
res_ambient[2] = 64;
}
if (res_diffuse)
{
res_diffuse[0] = 192;
res_diffuse[1] = 192;
res_diffuse[2] = 192;
}
if (res_dir)
{
res_dir[0] = 1;
res_dir[1] = 1;
res_dir[2] = 0.1;
}
return;
}
//If in doubt, steal someone else's code...
//Thanks QFusion.
for ( i = 0; i < 3; i++ )
{
vf[i] = (point[i] - lg->gridMins[i]) / lg->gridSize[i];
vi[i] = (int)(vf[i]);
vf[i] = vf[i] - floor(vf[i]);
vf2[i] = 1.0f - vf[i];
}
for ( i = 0; i < 8; i++ )
{
//bound it properly
index[i] = bound(0, vi[0]+((i&1)?1:0), lg->gridBounds[0]-1) * 1 +
bound(0, vi[1]+((i&2)?1:0), lg->gridBounds[1]-1) * lg->gridBounds[0] +
bound(0, vi[2]+((i&4)?1:0), lg->gridBounds[2]-1) * lg->gridBounds[3] ;
t[i] = ((i&1)?vf[0]:vf2[0]) *
((i&2)?vf[1]:vf2[1]) *
((i&4)?vf[2]:vf2[2]) ;
}
//rbsp has a separate grid->index lookup for compression.
if (lg->rbspindexes)
{
for (i = 0; i < 8; i++)
index[i] = lg->rbspindexes[index[i]];
}
VectorClear(ambient);
VectorClear(diffuse);
VectorClear(direction);
if (lg->rbspelements)
{
for (i = 0; i < 8; i++)
{ //rbsp has up to 4 styles per grid element, which needs to be scaled by that style's current value
float tot = 0;
for (j = 0; j < countof(lg->rbspelements[index[i]].styles); j++)
{
qbyte st = lg->rbspelements[index[i]].styles[j];
if (st != 255)
{
float mag = d_lightstylevalue[st] * 1.0/255 * t[i];
//FIXME: cl_lightstyle[st].colours[rgb]
VectorMA (ambient, mag, lg->rbspelements[index[i]].ambient[j], ambient);
VectorMA (diffuse, mag, lg->rbspelements[index[i]].diffuse[j], diffuse);
tot += mag;
}
}
GLQ3_AddLatLong(lg->rbspelements[index[i]].direction, direction, tot);
}
}
else
{
for (i = 0; i < 8; i++)
{
VectorMA (ambient, t[i], lg->lightgrid[index[i]].ambient, ambient);
VectorMA (diffuse, t[i], lg->lightgrid[index[i]].diffuse, diffuse);
GLQ3_AddLatLong(lg->lightgrid[index[i]].direction, direction, t[i]);
}
VectorScale(ambient, d_lightstylevalue[0]/255.0, ambient);
VectorScale(diffuse, d_lightstylevalue[0]/255.0, diffuse);
//FIXME: cl_lightstyle[0].colours[rgb]
}
//q3bsp has *4 overbrighting.
// VectorScale(ambient, 4, ambient);
// VectorScale(diffuse, 4, diffuse);
/*ambient is the min level*/
/*diffuse is the max level*/
VectorCopy(ambient, res_ambient);
if (res_diffuse)
VectorAdd(diffuse, ambient, res_diffuse);
if (res_dir)
VectorCopy(direction, res_dir);
}
static int GLRecursiveLightPoint (mnode_t *node, vec3_t start, vec3_t end)
{
int r;
float front, back, frac;
int side;
mplane_t *plane;
vec3_t mid;
msurface_t *surf;
int s, t, ds, dt;
int i;
mtexinfo_t *tex;
qbyte *lightmap;
unsigned scale;
int maps;
if (cl.worldmodel->fromgame == fg_quake2)
{
if (node->contents != -1)
return -1; // solid
}
else if (node->contents < 0)
return -1; // didn't hit anything
// calculate mid point
// FIXME: optimize for axial
plane = node->plane;
front = DotProduct (start, plane->normal) - plane->dist;
back = DotProduct (end, plane->normal) - plane->dist;
side = front < 0;
if ( (back < 0) == side)
return GLRecursiveLightPoint (node->children[side], start, end);
frac = front / (front-back);
mid[0] = start[0] + (end[0] - start[0])*frac;
mid[1] = start[1] + (end[1] - start[1])*frac;
mid[2] = start[2] + (end[2] - start[2])*frac;
// go down front side
r = GLRecursiveLightPoint (node->children[side], start, mid);
if (r >= 0)
return r; // hit something
if ( (back < 0) == side )
return -1; // didn't hit anuthing
// check for impact on this node
VectorCopy (mid, lightspot);
lightplane = plane;
surf = cl.worldmodel->surfaces + node->firstsurface;
for (i=0 ; i<node->numsurfaces ; i++, surf++)
{
if (surf->flags & SURF_DRAWTILED)
continue; // no lightmaps
tex = surf->texinfo;
s = DotProduct (mid, tex->vecs[0]) + tex->vecs[0][3];
t = DotProduct (mid, tex->vecs[1]) + tex->vecs[1][3];;
if (s < surf->texturemins[0] || t < surf->texturemins[1])
continue;
ds = s - surf->texturemins[0];
dt = t - surf->texturemins[1];
if ( ds > surf->extents[0] || dt > surf->extents[1] )
continue;
if (!surf->samples)
return 0;
ds >>= surf->lmshift;
dt >>= surf->lmshift;
lightmap = surf->samples;
r = 0;
if (lightmap)
{
switch(cl.worldmodel->lightmaps.fmt)
{
case LM_E5BGR9:
lightmap += (dt * ((surf->extents[0]>>surf->lmshift)+1) + ds)<<2;
for (maps = 0 ; maps < MAXCPULIGHTMAPS && surf->styles[maps] != INVALID_LIGHTSTYLE ; maps++)
{
unsigned int l = *(unsigned int*)lightmap;
scale = d_lightstylevalue[surf->styles[maps]];
scale *= pow(2, (int)(l>>27)-15-9+7);
r += max3(((l>> 0)&0x1ff), ((l>> 9)&0x1ff), ((l>>18)&0x1ff)) * scale;
lightmap += ((surf->extents[0]>>surf->lmshift)+1) * ((surf->extents[1]>>surf->lmshift)+1)<<2;
}
break;
case LM_RGB8:
lightmap += (dt * ((surf->extents[0]>>surf->lmshift)+1) + ds)*3;
for (maps = 0 ; maps < MAXCPULIGHTMAPS && surf->styles[maps] != INVALID_LIGHTSTYLE ; maps++)
{
scale = d_lightstylevalue[surf->styles[maps]];
r += max3(lightmap[0],lightmap[1],lightmap[2]) * scale;
lightmap += ((surf->extents[0]>>surf->lmshift)+1) * ((surf->extents[1]>>surf->lmshift)+1)*3;
}
break;
case LM_L8:
lightmap += dt * ((surf->extents[0]>>surf->lmshift)+1) + ds;
for (maps = 0 ; maps < MAXCPULIGHTMAPS && surf->styles[maps] != INVALID_LIGHTSTYLE ; maps++)
{
scale = d_lightstylevalue[surf->styles[maps]];
r += *lightmap * scale;
lightmap += ((surf->extents[0]>>surf->lmshift)+1) * ((surf->extents[1]>>surf->lmshift)+1);
}
break;
}
r >>= 8;
}
return r;
}
// go down back side
return GLRecursiveLightPoint (node->children[!side], mid, end);
}
int R_LightPoint (vec3_t p)
{
vec3_t end;
int r;
if (r_refdef.flags & 1)
return 255;
if (!cl.worldmodel || cl.worldmodel->loadstate != MLS_LOADED || !cl.worldmodel->lightdata)
return 255;
if (cl.worldmodel->fromgame == fg_quake3)
{
GLQ3_LightGrid(cl.worldmodel, p, NULL, end, NULL);
return (end[0] + end[1] + end[2])/3;
}
end[0] = p[0];
end[1] = p[1];
end[2] = p[2] - mod_lightpoint_distance.value;
r = GLRecursiveLightPoint (cl.worldmodel->rootnode, p, end);
if (r == -1)
r = 0;
return r;
}
#ifdef PEXT_LIGHTSTYLECOL
static float *GLRecursiveLightPoint3C (model_t *mod, mnode_t *node, const vec3_t start, const vec3_t end)
{
static float l[6];
float *r;
float front, back, frac;
int side;
mplane_t *plane;
vec3_t mid;
msurface_t *surf;
int s, t, ds, dt;
int i;
vec4_t *lmvecs;
qbyte *lightmap, *deluxmap;
float scale, overbright;
int maps;
if (mod->fromgame == fg_quake2)
{
if (node->contents != -1)
return NULL; // solid
}
else if (node->contents < 0)
return NULL; // didn't hit anything
// calculate mid point
// FIXME: optimize for axial
plane = node->plane;
front = DotProduct (start, plane->normal) - plane->dist;
back = DotProduct (end, plane->normal) - plane->dist;
side = front < 0;
if ( (back < 0) == side)
return GLRecursiveLightPoint3C (mod, node->children[side], start, end);
frac = front / (front-back);
mid[0] = start[0] + (end[0] - start[0])*frac;
mid[1] = start[1] + (end[1] - start[1])*frac;
mid[2] = start[2] + (end[2] - start[2])*frac;
// go down front side
r = GLRecursiveLightPoint3C (mod, node->children[side], start, mid);
if (r && r[0]+r[1]+r[2] >= 0)
return r; // hit something
if ( (back < 0) == side )
return NULL; // didn't hit anuthing
// check for impact on this node
VectorCopy (mid, lightspot);
lightplane = plane;
surf = mod->surfaces + node->firstsurface;
for (i=0 ; i<node->numsurfaces ; i++, surf++)
{
if (surf->flags & SURF_DRAWTILED)
continue; // no lightmaps
if (mod->facelmvecs)
lmvecs = mod->facelmvecs[surf-mod->surfaces].lmvecs;
else
lmvecs = surf->texinfo->vecs;
s = DotProduct (mid, lmvecs[0]) + lmvecs[0][3];
t = DotProduct (mid, lmvecs[1]) + lmvecs[1][3];
if (s < surf->texturemins[0] ||
t < surf->texturemins[1])
continue;
ds = s - surf->texturemins[0];
dt = t - surf->texturemins[1];
if ( ds > surf->extents[0] || dt > surf->extents[1] )
continue;
if (!surf->samples)
{
l[0]=0;l[1]=0;l[2]=0;
l[3]=0;l[4]=1;l[5]=1;
return l;
}
ds >>= surf->lmshift;
dt >>= surf->lmshift;
lightmap = surf->samples;
l[0]=0;l[1]=0;l[2]=0;
l[3]=0;l[4]=0;l[5]=0;
if (lightmap)
{
overbright = 1/255.0f;
if (mod->deluxdata)
{
switch(mod->lightmaps.fmt)
{
case LM_E5BGR9:
deluxmap = ((surf->samples - mod->lightdata)>>2)*3 + mod->deluxdata;
lightmap += (dt * ((surf->extents[0]>>surf->lmshift)+1) + ds)<<2;
deluxmap += (dt * ((surf->extents[0]>>surf->lmshift)+1) + ds)<<4;
for (maps = 0 ; maps < MAXCPULIGHTMAPS && surf->styles[maps] != INVALID_LIGHTSTYLE ; maps++)
{
unsigned int lm = *(unsigned int*)lightmap;
scale = d_lightstylevalue[surf->styles[maps]]*overbright;
scale *= pow(2, (int)(lm>>27)-15-9+8);
l[0] += ((lm>> 0)&0x1ff) * scale * cl_lightstyle[surf->styles[maps]].colours[0];
l[1] += ((lm>> 9)&0x1ff) * scale * cl_lightstyle[surf->styles[maps]].colours[1];
l[2] += ((lm>>18)&0x1ff) * scale * cl_lightstyle[surf->styles[maps]].colours[2];
l[3] += (deluxmap[0]-127)*scale;
l[4] += (deluxmap[1]-127)*scale;
l[5] += (deluxmap[2]-127)*scale;
lightmap += ((surf->extents[0]>>surf->lmshift)+1) *
((surf->extents[1]>>surf->lmshift)+1)<<2;
deluxmap += ((surf->extents[0]>>surf->lmshift)+1) *
((surf->extents[1]>>surf->lmshift)+1) * 3;
}
break;
case LM_RGB8:
deluxmap = surf->samples - mod->lightdata + mod->deluxdata;
lightmap += (dt * ((surf->extents[0]>>surf->lmshift)+1) + ds)*3;
deluxmap += (dt * ((surf->extents[0]>>surf->lmshift)+1) + ds)*3;
for (maps = 0 ; maps < MAXCPULIGHTMAPS && surf->styles[maps] != INVALID_LIGHTSTYLE ; maps++)
{
scale = d_lightstylevalue[surf->styles[maps]]*overbright;
l[0] += lightmap[0] * scale * cl_lightstyle[surf->styles[maps]].colours[0];
l[1] += lightmap[1] * scale * cl_lightstyle[surf->styles[maps]].colours[1];
l[2] += lightmap[2] * scale * cl_lightstyle[surf->styles[maps]].colours[2];
l[3] += (deluxmap[0]-127)*scale;
l[4] += (deluxmap[1]-127)*scale;
l[5] += (deluxmap[2]-127)*scale;
lightmap += ((surf->extents[0]>>surf->lmshift)+1) *
((surf->extents[1]>>surf->lmshift)+1) * 3;
deluxmap += ((surf->extents[0]>>surf->lmshift)+1) *
((surf->extents[1]>>surf->lmshift)+1) * 3;
}
break;
case LM_L8:
deluxmap = (surf->samples - mod->lightdata)*3 + mod->deluxdata;
lightmap += (dt * ((surf->extents[0]>>surf->lmshift)+1) + ds);
deluxmap += (dt * ((surf->extents[0]>>surf->lmshift)+1) + ds)*3;
for (maps = 0 ; maps < MAXCPULIGHTMAPS && surf->styles[maps] != INVALID_LIGHTSTYLE ; maps++)
{
scale = d_lightstylevalue[surf->styles[maps]]*overbright;
l[0] += *lightmap * scale * cl_lightstyle[surf->styles[maps]].colours[0];
l[1] += *lightmap * scale * cl_lightstyle[surf->styles[maps]].colours[1];
l[2] += *lightmap * scale * cl_lightstyle[surf->styles[maps]].colours[2];
l[3] += deluxmap[0]*scale;
l[4] += deluxmap[1]*scale;
l[5] += deluxmap[2]*scale;
lightmap += ((surf->extents[0]>>surf->lmshift)+1) *
((surf->extents[1]>>surf->lmshift)+1);
deluxmap += ((surf->extents[0]>>surf->lmshift)+1) *
((surf->extents[1]>>surf->lmshift)+1) * 3;
}
break;
}
}
else
{
switch(mod->lightmaps.fmt)
{
case LM_E5BGR9:
lightmap += (dt * ((surf->extents[0]>>surf->lmshift)+1) + ds)<<2;
for (maps = 0 ; maps < MAXCPULIGHTMAPS && surf->styles[maps] != INVALID_LIGHTSTYLE ; maps++)
{
unsigned int lm = *(unsigned int*)lightmap;
scale = d_lightstylevalue[surf->styles[maps]]*overbright;
scale *= pow(2, (int)(lm>>27)-15-9+8);
l[0] += ((lm>> 0)&0x1ff) * scale * cl_lightstyle[surf->styles[maps]].colours[0];
l[1] += ((lm>> 9)&0x1ff) * scale * cl_lightstyle[surf->styles[maps]].colours[1];
l[2] += ((lm>>18)&0x1ff) * scale * cl_lightstyle[surf->styles[maps]].colours[2];
lightmap += ((surf->extents[0]>>surf->lmshift)+1) *
((surf->extents[1]>>surf->lmshift)+1)<<2;
}
break;
case LM_RGB8:
lightmap += (dt * ((surf->extents[0]>>surf->lmshift)+1) + ds)*3;
for (maps = 0 ; maps < MAXCPULIGHTMAPS && surf->styles[maps] != INVALID_LIGHTSTYLE ; maps++)
{
scale = d_lightstylevalue[surf->styles[maps]]*overbright;
l[0] += lightmap[0] * scale * cl_lightstyle[surf->styles[maps]].colours[0];
l[1] += lightmap[1] * scale * cl_lightstyle[surf->styles[maps]].colours[1];
l[2] += lightmap[2] * scale * cl_lightstyle[surf->styles[maps]].colours[2];
lightmap += ((surf->extents[0]>>surf->lmshift)+1) *
((surf->extents[1]>>surf->lmshift)+1) * 3;
}
break;
case LM_L8:
lightmap += (dt * ((surf->extents[0]>>surf->lmshift)+1) + ds);
for (maps = 0 ; maps < MAXCPULIGHTMAPS && surf->styles[maps] != INVALID_LIGHTSTYLE ; maps++)
{
scale = d_lightstylevalue[surf->styles[maps]]*overbright;
l[0] += *lightmap * scale * cl_lightstyle[surf->styles[maps]].colours[0];
l[1] += *lightmap * scale * cl_lightstyle[surf->styles[maps]].colours[1];
l[2] += *lightmap * scale * cl_lightstyle[surf->styles[maps]].colours[2];
lightmap += ((surf->extents[0]>>surf->lmshift)+1) *
((surf->extents[1]>>surf->lmshift)+1);
}
break;
}
}
}
return l;
}
// go down back side
return GLRecursiveLightPoint3C (mod, node->children[!side], mid, end);
}
#endif
typedef struct
{
vec3_t gridscale;
unsigned int count[3];
vec3_t mins;
unsigned int styles;
unsigned int rootnode;
unsigned int numnodes;
struct bspxlgnode_s
{ //this uses an octtree to trim samples.
int mid[3];
unsigned int child[8];
#define LGNODE_LEAF (1u<<31)
#define LGNODE_MISSING (1u<<30)
} *nodes;
unsigned int numleafs;
struct bspxlgleaf_s
{
int mins[3];
int size[3];
unsigned char numstyles;
struct bspxlgsamp_s
{
qbyte style;
qbyte rgb[3];
} *rgbvalues; //size[x*y*z]*numstyles
} *leafs;
} bspxlightgrid_t;
struct rctx_s {qbyte *data; size_t ofs, size;};
static qbyte ReadByte(struct rctx_s *ctx)
{
if (ctx->ofs >= ctx->size)
{
ctx->ofs++;
return 0;
}
return ctx->data[ctx->ofs++];
}
static int ReadInt(struct rctx_s *ctx)
{
int r = (int)ReadByte(ctx)<<0;
r|= (int)ReadByte(ctx)<<8;
r|= (int)ReadByte(ctx)<<16;
r|= (int)ReadByte(ctx)<<24;
return r;
}
static float ReadFloat(struct rctx_s *ctx)
{
union {float f; int i;} u;
u.i = ReadInt(ctx);
return u.f;
}
void BSPX_LightGridLoad(model_t *model, bspx_header_t *bspx, qbyte *mod_base)
{
vec3_t step, mins;
int size[3];
bspxlightgrid_t *grid;
unsigned int numstyles, numnodes, numleafs, rootnode;
unsigned int nodestart, leafsamps = 0, i, j, k, s;
struct bspxlgsamp_s *samp;
struct rctx_s ctx = {0};
ctx.data = BSPX_FindLump(bspx, mod_base, "LIGHTGRID_OCTREE", &ctx.size);
model->lightgrid = NULL;
if (!ctx.data)
return;
for (j = 0; j < 3; j++)
step[j] = ReadFloat(&ctx);
for (j = 0; j < 3; j++)
size[j] = ReadInt(&ctx);
for (j = 0; j < 3; j++)
mins[j] = ReadFloat(&ctx);
numstyles = ReadByte(&ctx); //urgh, misaligned the entire thing
rootnode = ReadInt(&ctx);
numnodes = ReadInt(&ctx);
nodestart = ctx.ofs;
ctx.ofs += (3+8)*4*numnodes;
numleafs = ReadInt(&ctx);
for (i = 0; i < numleafs; i++)
{
unsigned int ms = 1;
unsigned int lsz[3];
ctx.ofs += 3*4;
for (j = 0; j < 3; j++)
lsz[j] = ReadInt(&ctx);
j = lsz[0]*lsz[1]*lsz[2];
while (j --> 0)
{ //this loop is annonying, memcpy dreams...
s = ReadByte(&ctx);
if (s == 255)
continue;
if (ms < s)
ms = s;
ctx.ofs += s*4;
}
j = lsz[0]*lsz[1]*lsz[2];
leafsamps += j*ms;
}
grid = ZG_Malloc(&model->memgroup, sizeof(*grid) + sizeof(*grid->leafs)*numleafs + sizeof(*grid->nodes)*numnodes + sizeof(struct bspxlgsamp_s)*leafsamps);
// memset(grid, 0xcc, sizeof(*grid) + sizeof(*grid->leafs)*numleafs + sizeof(*grid->nodes)*numnodes + sizeof(struct bspxlgsamp_s)*leafsamps);
grid->leafs = (void*)(grid+1);
grid->nodes = (void*)(grid->leafs + numleafs);
samp = (void*)(grid->nodes+numnodes);
for (j = 0; j < 3; j++)
grid->gridscale[j] = 1/step[j]; //prefer it as a multiply
VectorCopy(mins, grid->mins);
VectorCopy(size, grid->count);
grid->numnodes = numnodes;
grid->numleafs = numleafs;
grid->rootnode = rootnode;
(void)numstyles;
//rewind to the nodes. *sigh*
ctx.ofs = nodestart;
for (i = 0; i < numnodes; i++)
{
for (j = 0; j < 3; j++)
grid->nodes[i].mid[j] = ReadInt(&ctx);
for (j = 0; j < 8; j++)
grid->nodes[i].child[j] = ReadInt(&ctx);
}
ctx.ofs += 4;
for (i = 0; i < numleafs; i++)
{
unsigned int leafdataofs;
unsigned int ms = 1;
for (j = 0; j < 3; j++)
grid->leafs[i].mins[j] = ReadInt(&ctx);
for (j = 0; j < 3; j++)
grid->leafs[i].size[j] = ReadInt(&ctx);
grid->leafs[i].rgbvalues = samp;
j = grid->leafs[i].size[0]*grid->leafs[i].size[1]*grid->leafs[i].size[2];
//Count the maximum styles needed for this leaf.
leafdataofs = ctx.ofs;
for (k = 0; k < j; k++)
{
s = ReadByte(&ctx);
if (s == 255)
continue;
if (ms < s)
ms = s;
ctx.ofs += s*4;
}
ctx.ofs = leafdataofs;
grid->leafs[i].numstyles = ms;
while (j --> 0)
{
s = ReadByte(&ctx);
if (s == 0xff)
memset(samp, 0xff, sizeof(*samp));
else
{
for (k = 0; k < s; k++)
{
if (k >= ms)
ReadInt(&ctx); //shouldn't be possible...
else
{
samp[k].style = ReadByte(&ctx);
samp[k].rgb[0] = ReadByte(&ctx);
samp[k].rgb[1] = ReadByte(&ctx);
samp[k].rgb[2] = ReadByte(&ctx);
}
}
for (; k < ms; k++)
{
samp[k].style = k?(qbyte)~0u:0;
samp[k].rgb[0] =
samp[k].rgb[1] =
samp[k].rgb[2] = 0;
}
}
samp+=ms;
}
}
if (ctx.ofs != ctx.size)
grid = NULL;
model->lightgrid = (void*)grid;
}
static float BSPX_LightGridSingleValue(bspxlightgrid_t *grid, int x, int y, int z, float w, vec3_t res_diffuse)
{
int i;
unsigned int node;
struct bspxlgsamp_s *samp;
float lev;
node = grid->rootnode;
while (!(node & LGNODE_LEAF))
{
struct bspxlgnode_s *n;
if (node >= grid->numnodes) // also node&LGNODE_MISSING
return 0; //failure
n = grid->nodes + node;
node = n->child[
((x>=n->mid[0])<<2)|
((y>=n->mid[1])<<1)|
((z>=n->mid[2])<<0)];
}
{
struct bspxlgleaf_s *leaf = &grid->leafs[node & ~LGNODE_LEAF];
x -= leaf->mins[0];
y -= leaf->mins[1];
z -= leaf->mins[2];
if (x >= leaf->size[0] ||
y >= leaf->size[1] ||
z >= leaf->size[2])
return 0; //sample we're after is out of bounds...
i = x + leaf->size[0]*(y + leaf->size[1]*z);
samp = leaf->rgbvalues + i*leaf->numstyles;
//no hdr support
for (i = 0; i < leaf->numstyles; i++)
{
if (samp[i].style == ((qbyte)(~0u)))
break; //no more
if (samp[i].style < cl_max_lightstyles)
{
lev = d_lightstylevalue[samp[i].style]*w;
res_diffuse[0] += samp[i].rgb[0] * lev * cl_lightstyle[samp[i].style].colours[0];
res_diffuse[1] += samp[i].rgb[1] * lev * cl_lightstyle[samp[i].style].colours[1];
res_diffuse[2] += samp[i].rgb[2] * lev * cl_lightstyle[samp[i].style].colours[2];
}
}
if (i == 0)
w = 0;
}
return w;
}
static void BSPX_LightGridValue(void *lightgridinfo, const vec3_t point, vec3_t res_diffuse, vec3_t res_ambient, vec3_t res_dir)
{
bspxlightgrid_t *grid = lightgridinfo;
int i, tile[3];
float w, s, frac[3];
VectorSet(res_diffuse, 0, 0, 0); //assume worst
VectorSet(res_ambient, 0, 0, 0); //assume worst
VectorSet(res_dir, 1, 0, 1); //super lame
for (i = 0; i < 3; i++)
{
tile[i] = floor((point[i] - grid->mins[i]) * grid->gridscale[i]);
frac[i] = (point[i] - grid->mins[i]) * grid->gridscale[i] - tile[i];
}
for (i = 0, s = 0; i < 8; i++)
{
w = ((i&1)?frac[0]:1-frac[0]) //keep the lerping vaugely smooth.
* ((i&2)?frac[1]:1-frac[1])
* ((i&4)?frac[2]:1-frac[2]);
s += w*BSPX_LightGridSingleValue(grid, tile[0]+!!(i&1),
tile[1]+!!(i&2),
tile[2]+!!(i&4), w, res_diffuse);
}
if (s)
VectorScale(res_diffuse, 1.0/(s*255), res_diffuse); //average the successful ones
VectorScale(res_diffuse, 0.5, res_ambient); //and fix up ambients.
}
void GLQ1BSP_LightPointValues(model_t *model, const vec3_t point, vec3_t res_diffuse, vec3_t res_ambient, vec3_t res_dir)
{
vec3_t end;
float *r;
#ifdef RTLIGHTS
extern cvar_t r_shadow_realtime_world, r_shadow_realtime_world_lightmaps;
#endif
if (!model->lightdata || r_fullbright.ival || model->loadstate != MLS_LOADED)
{
if (model->loadstate != MLS_LOADED)
Sys_Error("GLQ1BSP_LightPointValues: model not loaded...\n");
res_diffuse[0] = 0;
res_diffuse[1] = 0;
res_diffuse[2] = 0;
res_ambient[0] = 255;
res_ambient[1] = 255;
res_ambient[2] = 255;
res_dir[0] = 1;
res_dir[1] = 1;
res_dir[2] = 0.1;
VectorNormalize(res_dir);
return;
}
if (model->lightgrid)
return BSPX_LightGridValue(model->lightgrid, point, res_diffuse, res_ambient, res_dir);
end[0] = point[0];
end[1] = point[1];
end[2] = point[2] - mod_lightpoint_distance.value;
r = GLRecursiveLightPoint3C(model, model->rootnode, point, end);
if (r == NULL)
{
res_diffuse[0] = 0;
res_diffuse[1] = 0;
res_diffuse[2] = 0;
res_ambient[0] = 0;
res_ambient[1] = 0;
res_ambient[2] = 0;
res_dir[0] = 0;
res_dir[1] = 1;
res_dir[2] = 1;
}
else
{
res_diffuse[0] = r[0];
res_diffuse[1] = r[1];
res_diffuse[2] = r[2];
/*bright on one side, dark on the other, but not too dark*/
res_ambient[0] = r[0];
res_ambient[1] = r[1];
res_ambient[2] = r[2];
res_dir[0] = r[3];
res_dir[1] = r[4];
res_dir[2] = -r[5];
if (!res_dir[0] && !res_dir[1] && !res_dir[2])
res_dir[0] = res_dir[2] = 1;
VectorNormalize(res_dir);
}
#ifdef RTLIGHTS
if (r_shadow_realtime_world.ival)
{
float lm = r_shadow_realtime_world_lightmaps.value;
if (lm < 0) lm = 0;
if (lm > 1) lm = 1;
VectorScale(res_diffuse, lm, res_diffuse);
VectorScale(res_ambient, lm, res_ambient);
}
#endif
}
#endif
View git blame Copy permalink