nzp-team/vhlt
0
0
Fork 0
mirror of https://github.com/nzp-team/vhlt.git synced 2024-11-28 23:02:07 +00:00
Code Issues Projects Releases Packages Wiki Activity
vhlt/hlrad/qrad.cpp

5920 lines
171 KiB
C++
Raw Normal View History

Vluzacn's ZHLT v34
2016-09-20 21:07:53 +00:00
/*
R A D I O S I T Y -aka- R A D
Code based on original code from Valve Software,
Modified by Sean "Zoner" Cavanaugh (seanc@gearboxsoftware.com) with permission.
Modified by Tony "Merl" Moore (merlinis@bigpond.net.au) [AJM]
*/
#ifdef SYSTEM_WIN32
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#endif
#include <vector>
#include <string>
#include "qrad.h"
/*
* NOTES
* -----
* every surface must be divided into at least two g_patches each axis
*/
#ifdef ZHLT_XASH
int g_dlitdatasize = 0;
int g_max_map_dlitdata = 0;
byte *g_ddlitdata = NULL;
char g_dlitfile[_MAX_PATH] = "";
bool g_drawdirection = false;
vec_t g_directionscale = 0.0;
#endif
#ifdef HLRAD_FASTMODE
bool g_fastmode = DEFAULT_FASTMODE;
#endif
typedef enum
{
eMethodVismatrix,
eMethodSparseVismatrix,
eMethodNoVismatrix
}
eVisMethods;
#ifdef HLRAD_ARG_MISC
eVisMethods g_method = DEFAULT_METHOD;
#else
eVisMethods g_method = eMethodVismatrix;
#endif
vec_t g_fade = DEFAULT_FADE;
#ifndef HLRAD_ARG_MISC
int g_falloff = DEFAULT_FALLOFF;
#endif
patch_t* g_face_patches[MAX_MAP_FACES];
entity_t* g_face_entity[MAX_MAP_FACES];
eModelLightmodes g_face_lightmode[MAX_MAP_FACES];
#ifdef HLRAD_MORE_PATCHES
patch_t* g_patches;
#else
patch_t g_patches[MAX_PATCHES];
#endif
#ifdef HLRAD_CUSTOMTEXLIGHT
entity_t* g_face_texlights[MAX_MAP_FACES];
#endif
unsigned g_num_patches;
#ifdef ZHLT_TEXLIGHT
#ifdef HLRAD_MORE_PATCHES
static vec3_t (*emitlight)[MAXLIGHTMAPS]; //LRC
static vec3_t (*addlight)[MAXLIGHTMAPS]; //LRC
#else
static vec3_t emitlight[MAX_PATCHES][MAXLIGHTMAPS]; //LRC
static vec3_t addlight[MAX_PATCHES][MAXLIGHTMAPS]; //LRC
#endif
#ifdef ZHLT_XASH
#ifdef HLRAD_MORE_PATCHES
static vec3_t (*emitlight_direction)[MAXLIGHTMAPS];
static vec3_t (*addlight_direction)[MAXLIGHTMAPS];
#else
static vec3_t emitlight_direction[MAX_PATCHES][MAXLIGHTMAPS];
static vec3_t addlight_direction[MAX_PATCHES][MAXLIGHTMAPS];
#endif
#endif
#ifdef HLRAD_AUTOCORING
#ifdef HLRAD_MORE_PATCHES
static unsigned char (*newstyles)[MAXLIGHTMAPS];
#else
static unsigned char newstyles[MAX_PATCHES][MAXLIGHTMAPS];
#endif
#endif
#else
#ifdef HLRAD_MORE_PATCHES
static vec3_t (*emitlight);
static vec3_t (*addlight);
#else
static vec3_t emitlight[MAX_PATCHES];
static vec3_t addlight[MAX_PATCHES];
#endif
#endif
vec3_t g_face_offset[MAX_MAP_FACES]; // for rotating bmodels
vec_t g_direct_scale = DEFAULT_DLIGHT_SCALE;
unsigned g_numbounce = DEFAULT_BOUNCE; // 3; /* Originally this was 8 */
static bool g_dumppatches = DEFAULT_DUMPPATCHES;
vec3_t g_ambient = { DEFAULT_AMBIENT_RED, DEFAULT_AMBIENT_GREEN, DEFAULT_AMBIENT_BLUE };
#ifndef HLRAD_FinalLightFace_VL
float g_maxlight = DEFAULT_MAXLIGHT; // 196 /* Originally this was 196 */
#endif
#ifdef HLRAD_PRESERVELIGHTMAPCOLOR
vec_t g_limitthreshold = DEFAULT_LIMITTHRESHOLD;
bool g_drawoverload = false;
#endif
float g_lightscale = DEFAULT_LIGHTSCALE;
float g_dlight_threshold = DEFAULT_DLIGHT_THRESHOLD; // was DIRECT_LIGHT constant
char g_source[_MAX_PATH] = "";
char g_vismatfile[_MAX_PATH] = "";
bool g_incremental = DEFAULT_INCREMENTAL;
#ifndef HLRAD_WHOME
float g_qgamma = DEFAULT_GAMMA;
#endif
float g_indirect_sun = DEFAULT_INDIRECT_SUN;
bool g_extra = DEFAULT_EXTRA;
bool g_texscale = DEFAULT_TEXSCALE;
float g_smoothing_threshold;
float g_smoothing_value = DEFAULT_SMOOTHING_VALUE;
#ifdef HLRAD_CUSTOMSMOOTH
float g_smoothing_threshold_2;
float g_smoothing_value_2 = DEFAULT_SMOOTHING2_VALUE;
#endif
bool g_circus = DEFAULT_CIRCUS;
bool g_allow_opaques = DEFAULT_ALLOW_OPAQUES;
#ifdef HLRAD_SUNSPREAD
bool g_allow_spread = DEFAULT_ALLOW_SPREAD;
#endif
// --------------------------------------------------------------------------
// Changes by Adam Foster - afoster@compsoc.man.ac.uk
#ifdef HLRAD_WHOME
vec3_t g_colour_qgamma = { DEFAULT_COLOUR_GAMMA_RED, DEFAULT_COLOUR_GAMMA_GREEN, DEFAULT_COLOUR_GAMMA_BLUE };
vec3_t g_colour_lightscale = { DEFAULT_COLOUR_LIGHTSCALE_RED, DEFAULT_COLOUR_LIGHTSCALE_GREEN, DEFAULT_COLOUR_LIGHTSCALE_BLUE };
vec3_t g_colour_jitter_hack = { DEFAULT_COLOUR_JITTER_HACK_RED, DEFAULT_COLOUR_JITTER_HACK_GREEN, DEFAULT_COLOUR_JITTER_HACK_BLUE };
vec3_t g_jitter_hack = { DEFAULT_JITTER_HACK_RED, DEFAULT_JITTER_HACK_GREEN, DEFAULT_JITTER_HACK_BLUE };
#ifndef HLRAD_ARG_MISC
bool g_diffuse_hack = DEFAULT_DIFFUSE_HACK;
bool g_spotlight_hack = DEFAULT_SPOTLIGHT_HACK;
#endif
#ifndef HLRAD_CUSTOMTEXLIGHT // no softlight hack
vec3_t g_softlight_hack = { DEFAULT_SOFTLIGHT_HACK_RED, DEFAULT_SOFTLIGHT_HACK_GREEN, DEFAULT_SOFTLIGHT_HACK_BLUE };
float g_softlight_hack_distance = DEFAULT_SOFTLIGHT_HACK_DISTANCE;
#endif
#endif
// --------------------------------------------------------------------------
#ifdef HLRAD_HULLU
bool g_customshadow_with_bouncelight = DEFAULT_CUSTOMSHADOW_WITH_BOUNCELIGHT;
bool g_rgb_transfers = DEFAULT_RGB_TRANSFERS;
#endif
#ifdef HLRAD_TRANSTOTAL_HACK
float g_transtotal_hack = DEFAULT_TRANSTOTAL_HACK;
#endif
#ifdef HLRAD_MINLIGHT
unsigned char g_minlight = DEFAULT_MINLIGHT;
#endif
#ifdef HLRAD_TRANSFERDATA_COMPRESS
float_type g_transfer_compress_type = DEFAULT_TRANSFER_COMPRESS_TYPE;
vector_type g_rgbtransfer_compress_type = DEFAULT_RGBTRANSFER_COMPRESS_TYPE;
#endif
#ifdef HLRAD_SOFTSKY
bool g_softsky = DEFAULT_SOFTSKY;
#endif
#ifdef HLRAD_OPAQUE_BLOCK
int g_blockopaque = DEFAULT_BLOCKOPAQUE;
#endif
#ifdef HLRAD_TEXTURE
bool g_notextures = DEFAULT_NOTEXTURES;
#endif
#ifdef HLRAD_REFLECTIVITY
vec_t g_texreflectgamma = DEFAULT_TEXREFLECTGAMMA;
vec_t g_texreflectscale = DEFAULT_TEXREFLECTSCALE;
#endif
#ifdef HLRAD_AVOIDWALLBLEED
bool g_bleedfix = DEFAULT_BLEEDFIX;
#endif
#ifdef HLRAD_DEBUG_DRAWPOINTS
bool g_drawpatch = false;
bool g_drawsample = false;
vec3_t g_drawsample_origin = {0,0,0};
vec_t g_drawsample_radius = 0;
bool g_drawedge = false;
bool g_drawlerp = false;
#endif
#ifdef HLRAD_AVOIDWALLBLEED
bool g_drawnudge = false;
#endif
// Cosine of smoothing angle(in radians)
float g_coring = DEFAULT_CORING; // Light threshold to force to blackness(minimizes lightmaps)
bool g_chart = DEFAULT_CHART;
bool g_estimate = DEFAULT_ESTIMATE;
bool g_info = DEFAULT_INFO;
#ifdef ZHLT_PROGRESSFILE // AJM
char* g_progressfile = DEFAULT_PROGRESSFILE; // "-progressfile path"
#endif
// Patch creation and subdivision criteria
bool g_subdivide = DEFAULT_SUBDIVIDE;
vec_t g_chop = DEFAULT_CHOP;
vec_t g_texchop = DEFAULT_TEXCHOP;
// Opaque faces
opaqueList_t* g_opaque_face_list = NULL;
unsigned g_opaque_face_count = 0;
unsigned g_max_opaque_face_count = 0; // Current array maximum (used for reallocs)
#ifndef HLRAD_OPAQUE_NODE
#ifdef HLRAD_OPAQUE_GROUP
opaqueGroup_t g_opaque_group_list[MAX_OPAQUE_GROUP_COUNT];
unsigned g_opaque_group_count = 0;
#endif
#endif
#ifdef HLRAD_STYLE_CORING
vec_t g_corings[ALLSTYLES];
#endif
#ifdef HLRAD_TRANSLUCENT
vec3_t* g_translucenttextures = NULL;
vec_t g_translucentdepth = DEFAULT_TRANSLUCENTDEPTH;
#endif
#ifdef HLRAD_BLUR
vec_t g_blur = DEFAULT_BLUR;
#endif
#ifdef HLRAD_ACCURATEBOUNCE
bool g_noemitterrange = DEFAULT_NOEMITTERRANGE;
#endif
#ifdef HLRAD_TEXLIGHTGAP
vec_t g_texlightgap = DEFAULT_TEXLIGHTGAP;
#endif
// Misc
int leafparents[MAX_MAP_LEAFS];
int nodeparents[MAX_MAP_NODES];
#ifdef HLRAD_READABLE_EXCEEDSTYLEWARNING
int stylewarningcount = 0;
int stylewarningnext = 1;
#endif
#ifdef HLRAD_AUTOCORING
vec_t g_maxdiscardedlight = 0;
vec3_t g_maxdiscardedpos = {0, 0, 0};
#endif
#ifdef ZHLT_INFO_COMPILE_PARAMETERS
// =====================================================================================
// GetParamsFromEnt
// this function is called from parseentity when it encounters the
// info_compile_parameters entity. each tool should have its own version of this
// to handle its own specific settings.
// =====================================================================================
void GetParamsFromEnt(entity_t* mapent)
{
int iTmp;
float flTmp;
char szTmp[256]; //lightdata
const char* pszTmp;
Log("\nCompile Settings detected from info_compile_parameters entity\n");
// lightdata(string) : "Lighting Data Memory" : "8192"
iTmp = IntForKey(mapent, "lightdata") * 1024; //lightdata
if (iTmp > g_max_map_lightdata) //--vluzacn
{
g_max_map_lightdata = iTmp;
sprintf_s(szTmp, "%i", g_max_map_lightdata);
Log("%30s [ %-9s ]\n", "Lighting Data Memory", szTmp);
}
// verbose(choices) : "Verbose compile messages" : 0 = [ 0 : "Off" 1 : "On" ]
iTmp = IntForKey(mapent, "verbose");
if (iTmp == 1)
{
g_verbose = true;
}
else if (iTmp == 0)
{
g_verbose = false;
}
Log("%30s [ %-9s ]\n", "Compile Option", "setting");
Log("%30s [ %-9s ]\n", "Verbose Compile Messages", g_verbose ? "on" : "off");
// estimate(choices) :"Estimate Compile Times?" : 0 = [ 0: "Yes" 1: "No" ]
if (IntForKey(mapent, "estimate"))
{
g_estimate = true;
}
else
{
g_estimate = false;
}
Log("%30s [ %-9s ]\n", "Estimate Compile Times", g_estimate ? "on" : "off");
// priority(choices) : "Priority Level" : 0 = [ 0 : "Normal" 1 : "High" -1 : "Low" ]
if (!strcmp(ValueForKey(mapent, "priority"), "1"))
{
g_threadpriority = eThreadPriorityHigh;
Log("%30s [ %-9s ]\n", "Thread Priority", "high");
}
else if (!strcmp(ValueForKey(mapent, "priority"), "-1"))
{
g_threadpriority = eThreadPriorityLow;
Log("%30s [ %-9s ]\n", "Thread Priority", "low");
}
// bounce(integer) : "Number of radiosity bounces" : 0
iTmp = IntForKey(mapent, "bounce");
if (iTmp)
{
g_numbounce = abs(iTmp);
Log("%30s [ %-9s ]\n", "Number of radiosity bounces", ValueForKey(mapent, "bounce"));
}
#ifdef HLRAD_HULLU
iTmp = IntForKey(mapent, "customshadowwithbounce");
if (iTmp)
{
g_customshadow_with_bouncelight = true;
Log("%30s [ %-9s ]\n", "Custom Shadow with Bounce Light", ValueForKey(mapent, "customshadowwithbounce"));
}
iTmp = IntForKey(mapent, "rgbtransfers");
if (iTmp)
{
g_rgb_transfers = true;
Log("%30s [ %-9s ]\n", "RGB Transfers", ValueForKey(mapent, "rgbtransfers"));
}
#endif
// ambient(string) : "Ambient world light (0.0 to 1.0, R G B)" : "0 0 0"
//vec3_t g_ambient = { DEFAULT_AMBIENT_RED, DEFAULT_AMBIENT_GREEN, DEFAULT_AMBIENT_BLUE };
pszTmp = ValueForKey(mapent, "ambient");
if (pszTmp)
{
float red = 0, green = 0, blue = 0;
if (sscanf(pszTmp, "%f %f %f", &red, &green, &blue))
{
if (red < 0 || red > 1 || green < 0 || green > 1 || blue < 0 || blue > 1)
{
Error("info_compile_parameters: Ambient World Light (ambient) all 3 values must be within the range of 0.0 to 1.0\n"
"Parsed values:\n"
" red [ %1.3f ] %s\n"
" green [ %1.3f ] %s\n"
" blue [ %1.3f ] %s\n"
, red, (red < 0 || red > 1) ? "OUT OF RANGE" : ""
, green, (green < 0 || green > 1) ? "OUT OF RANGE" : ""
, blue, (blue < 0 || blue > 1) ? "OUT OF RANGE" : "" );
}
if (red == 0 && green == 0 && blue == 0)
{} // dont bother setting null values
else
{
g_ambient[0] = red * 128;
g_ambient[1] = green * 128;
g_ambient[2] = blue * 128;
Log("%30s [ %1.3f %1.3f %1.3f ]\n", "Ambient world light (R G B)", red, green, blue);
}
}
else
{
Error("info_compile_parameters: Ambient World Light (ambient) has unrecognised value\n"
"This keyvalue accepts 3 numeric values from 0.000 to 1.000, use \"0 0 0\" if in doubt");
}
}
// smooth(integer) : "Smoothing threshold (in degrees)" : 0
flTmp = FloatForKey(mapent, "smooth");
if (flTmp)
{
/*g_smoothing_threshold = flTmp;*/
g_smoothing_threshold = cos(g_smoothing_value * (Q_PI / 180.0)); // --vluzacn
Log("%30s [ %-9s ]\n", "Smoothing threshold", ValueForKey(mapent, "smooth"));
}
// dscale(integer) : "Direct Lighting Scale" : 1
flTmp = FloatForKey(mapent, "dscale");
if (flTmp)
{
g_direct_scale = flTmp;
Log("%30s [ %-9s ]\n", "Direct Lighting Scale", ValueForKey(mapent, "dscale"));
}
// chop(integer) : "Chop Size" : 64
iTmp = IntForKey(mapent, "chop");
if (iTmp)
{
g_chop = iTmp;
Log("%30s [ %-9s ]\n", "Chop Size", ValueForKey(mapent, "chop"));
}
// texchop(integer) : "Texture Light Chop Size" : 32
flTmp = FloatForKey(mapent, "texchop");
if (flTmp)
{
g_texchop = flTmp;
Log("%30s [ %-9s ]\n", "Texture Light Chop Size", ValueForKey(mapent, "texchop"));
}
/*
hlrad(choices) : "HLRAD" : 0 =
[
0 : "Off"
1 : "Normal"
2 : "Extra"
]
*/
iTmp = IntForKey(mapent, "hlrad");
if (iTmp == 0)
{
Fatal(assume_TOOL_CANCEL,
"%s flag was not checked in info_compile_parameters entity, execution of %s cancelled", g_Program, g_Program);
CheckFatal();
}
else if (iTmp == 1)
{
g_extra = false;
}
else if (iTmp == 2)
{
g_extra = true;
}
Log("%30s [ %-9s ]\n", "Extra RAD", g_extra ? "on" : "off");
/*
sparse(choices) : "Vismatrix Method" : 2 =
[
0 : "No Vismatrix"
1 : "Sparse Vismatrix"
2 : "Normal"
]
*/
iTmp = IntForKey(mapent, "sparse");
if (iTmp == 1)
{
g_method = eMethodSparseVismatrix;
}
else if (iTmp == 0)
{
g_method = eMethodNoVismatrix;
}
else if (iTmp == 2)
{
g_method = eMethodVismatrix;
}
Log("%30s [ %-9s ]\n", "Sparse Vismatrix", g_method == eMethodSparseVismatrix ? "on" : "off");
Log("%30s [ %-9s ]\n", "NoVismatrix", g_method == eMethodNoVismatrix ? "on" : "off");
/*
circus(choices) : "Circus RAD lighting" : 0 =
[
0 : "Off"
1 : "On"
]
*/
iTmp = IntForKey(mapent, "circus");
if (iTmp == 0)
{
g_circus = false;
}
else if (iTmp == 1)
{
g_circus = true;
}
Log("%30s [ %-9s ]\n", "Circus Lighting Mode", g_circus ? "on" : "off");
////////////////////
Log("\n");
}
#endif
// =====================================================================================
// MakeParents
// blah
// =====================================================================================
static void MakeParents(const int nodenum, const int parent)
{
int i;
int j;
dnode_t* node;
nodeparents[nodenum] = parent;
node = g_dnodes + nodenum;
for (i = 0; i < 2; i++)
{
j = node->children[i];
if (j < 0)
{
leafparents[-j - 1] = nodenum;
}
else
{
MakeParents(j, nodenum);
}
}
}
// =====================================================================================
//
// TEXTURE LIGHT VALUES
//
// =====================================================================================
// misc
typedef struct
{
std::string name;
vec3_t value;
const char* filename;
}
texlight_t;
static std::vector< texlight_t > s_texlights;
typedef std::vector< texlight_t >::iterator texlight_i;
// =====================================================================================
// ReadLightFile
// =====================================================================================
static void ReadLightFile(const char* const filename)
{
FILE* f;
char scan[MAXTOKEN];
short argCnt;
unsigned int file_texlights = 0;
f = fopen(filename, "r");
if (!f)
{
Warning("Could not open texlight file %s", filename);
return;
}
else
{
#ifdef HLRAD_CUSTOMTEXLIGHT
Log("Reading texlights from '%s'\n", filename);
#else
Log("[Reading texlights from '%s']\n", filename);
#endif
}
while (fgets(scan, sizeof(scan), f))
{
char* comment;
char szTexlight[_MAX_PATH];
vec_t r, g, b, i = 1;
comment = strstr(scan, "//");
if (comment)
{
// Newline and Null terminate the string early if there is a c++ style single line comment
comment[0] = '\n';
comment[1] = 0;
}
argCnt = sscanf(scan, "%s %f %f %f %f", szTexlight, &r, &g, &b, &i);
if (argCnt == 2)
{
// With 1+1 args, the R,G,B values are all equal to the first value
g = b = r;
}
else if (argCnt == 5)
{
// With 1+4 args, the R,G,B values are "scaled" by the fourth numeric value i;
r *= i / 255.0;
g *= i / 255.0;
b *= i / 255.0;
}
else if (argCnt != 4)
{
if (strlen(scan) > 4)
{
Warning("ignoring bad texlight '%s' in %s", scan, filename);
}
continue;
}
texlight_i it;
for (it = s_texlights.begin(); it != s_texlights.end(); it++)
{
if (strcmp(it->name.c_str(), szTexlight) == 0)
{
if (strcmp(it->filename, filename) == 0)
{
Warning("Duplication of texlight '%s' in file '%s'!", it->name.c_str(), it->filename);
}
else if (it->value[0] != r || it->value[1] != g || it->value[2] != b)
{
Warning("Overriding '%s' from '%s' with '%s'!", it->name.c_str(), it->filename, filename);
}
else
{
Warning("Redundant '%s' def in '%s' AND '%s'!", it->name.c_str(), it->filename, filename);
}
s_texlights.erase(it);
break;
}
}
texlight_t texlight;
texlight.name = szTexlight;
texlight.value[0] = r;
texlight.value[1] = g;
texlight.value[2] = b;
texlight.filename = filename;
file_texlights++;
s_texlights.push_back(texlight);
}
fclose (f); //--vluzacn
#ifndef HLRAD_CUSTOMTEXLIGHT
Log("[%u texlights parsed from '%s']\n\n", file_texlights, filename);
#endif
}
// =====================================================================================
// LightForTexture
// =====================================================================================
static void LightForTexture(const char* const name, vec3_t result)
{
texlight_i it;
for (it = s_texlights.begin(); it != s_texlights.end(); it++)
{
if (!strcasecmp(name, it->name.c_str()))
{
VectorCopy(it->value, result);
return;
}
}
VectorClear(result);
}
// =====================================================================================
//
// MAKE FACES
//
// =====================================================================================
// =====================================================================================
// BaseLightForFace
// =====================================================================================
static void BaseLightForFace(const dface_t* const f, vec3_t light)
{
#ifdef HLRAD_CUSTOMTEXLIGHT
int fn = f - g_dfaces;
if (g_face_texlights[fn])
{
double r, g, b, scaler;
switch (sscanf (ValueForKey (g_face_texlights[fn], "_light"), "%lf %lf %lf %lf", &r, &g, &b, &scaler))
{
case -1:
case 0:
r = 0.0;
case 1:
g = b = r;
case 3:
break;
case 4:
r *= scaler / 255.0;
g *= scaler / 255.0;
b *= scaler / 255.0;
break;
default:
vec3_t origin;
GetVectorForKey (g_face_texlights[fn], "origin", origin);
Log("light at (%f,%f,%f) has bad or missing '_light' value : '%s'\n",
origin[0], origin[1], origin[2], ValueForKey (g_face_texlights[fn], "_light"));
r = g = b = 0;
break;
}
light[0] = r > 0? r: 0;
light[1] = g > 0? g: 0;
light[2] = b > 0? b: 0;
return;
}
#endif
texinfo_t* tx;
miptex_t* mt;
int ofs;
//
// check for light emited by texture
//
tx = &g_texinfo[f->texinfo];
ofs = ((dmiptexlump_t*)g_dtexdata)->dataofs[tx->miptex];
mt = (miptex_t*)((byte*) g_dtexdata + ofs);
LightForTexture(mt->name, light);
}
// =====================================================================================
// IsSpecial
// =====================================================================================
static bool IsSpecial(const dface_t* const f)
{
return g_texinfo[f->texinfo].flags & TEX_SPECIAL;
}
// =====================================================================================
// PlacePatchInside
// =====================================================================================
static bool PlacePatchInside(patch_t* patch)
{
const dplane_t* plane;
const vec_t* face_offset = g_face_offset[patch->faceNumber];
plane = getPlaneFromFaceNumber(patch->faceNumber);
#ifdef HLRAD_PATCHBLACK_FIX
#ifdef HLRAD_ACCURATEBOUNCE_REDUCEAREA
vec_t pointsfound;
vec_t pointstested;
pointsfound = pointstested = 0;
#endif
vec3_t center;
bool found;
vec3_t bestpoint;
vec_t bestdist = -1.0;
vec3_t point;
vec_t dist;
vec3_t v;
patch->winding->getCenter (center);
found = false;
VectorMA (center, PATCH_HUNT_OFFSET, plane->normal, point);
#ifdef HLRAD_ACCURATEBOUNCE_REDUCEAREA
pointstested++;
#endif
if (HuntForWorld (point, face_offset, plane, 4, 0.2, PATCH_HUNT_OFFSET) ||
HuntForWorld (point, face_offset, plane, 4, 0.8, PATCH_HUNT_OFFSET))
{
#ifdef HLRAD_ACCURATEBOUNCE_REDUCEAREA
pointsfound++;
#endif
VectorSubtract (point, center, v);
dist = VectorLength (v);
if (!found || dist < bestdist)
{
found = true;
VectorCopy (point, bestpoint);
bestdist = dist;
}
}
#ifndef HLRAD_ACCURATEBOUNCE_REDUCEAREA
if (!found)
#endif
{
for (int i = 0; i < patch->winding->m_NumPoints; i++)
{
const vec_t *p1;
const vec_t *p2;
p1 = patch->winding->m_Points[i];
p2 = patch->winding->m_Points[(i+1)%patch->winding->m_NumPoints];
VectorAdd (p1, p2, point);
VectorAdd (point, center, point);
VectorScale (point, 1.0/3.0, point);
VectorMA (point, PATCH_HUNT_OFFSET, plane->normal, point);
#ifdef HLRAD_ACCURATEBOUNCE_REDUCEAREA
pointstested++;
#endif
if (HuntForWorld (point, face_offset, plane, 4, 0.2, PATCH_HUNT_OFFSET) ||
HuntForWorld (point, face_offset, plane, 4, 0.8, PATCH_HUNT_OFFSET))
{
#ifdef HLRAD_ACCURATEBOUNCE_REDUCEAREA
pointsfound++;
#endif
VectorSubtract (point, center, v);
dist = VectorLength (v);
if (!found || dist < bestdist)
{
found = true;
VectorCopy (point, bestpoint);
bestdist = dist;
}
}
}
}
#ifdef HLRAD_ACCURATEBOUNCE_REDUCEAREA
patch->exposure = pointsfound / pointstested;
#endif
if (found)
{
VectorCopy (bestpoint, patch->origin);
patch->flags = ePatchFlagNull;
return true;
}
else
{
VectorMA (center, PATCH_HUNT_OFFSET, plane->normal, patch->origin);
patch->flags = ePatchFlagOutside;
Developer(DEVELOPER_LEVEL_FLUFF, "Patch @ (%4.3f %4.3f %4.3f) outside world\n",
patch->origin[0], patch->origin[1], patch->origin[2]);
return false;
}
#else // obviously who wrote these code misunderstood the function of HuntForWorld
if (!HuntForWorld(patch->origin, face_offset, plane, 11, 0.1, 0.01) &&
!HuntForWorld(patch->origin, face_offset, plane, 11, 0.1, 0.1) &&
!HuntForWorld(patch->origin, face_offset, plane, 11, 0.1, 0.5) &&
!HuntForWorld(patch->origin, face_offset, plane, 11, 0.1, -0.01) &&
!HuntForWorld(patch->origin, face_offset, plane, 11, 0.1, -0.1))
{
// Try offsetting it by the plane normal (1 unit away) and try again
VectorAdd(plane->normal, patch->origin, patch->origin); // Original offset-into-world method
if (PointInLeaf(patch->origin) == g_dleafs)
{
if (!HuntForWorld(patch->origin, face_offset, plane, 11, 0.1, 0.01) &&
!HuntForWorld(patch->origin, face_offset, plane, 11, 0.1, 0.1) &&
!HuntForWorld(patch->origin, face_offset, plane, 11, 0.1, 0.5) &&
!HuntForWorld(patch->origin, face_offset, plane, 11, 0.1, -0.01) &&
!HuntForWorld(patch->origin, face_offset, plane, 11, 0.1, -0.1))
{
patch->flags = (ePatchFlags)(patch->flags | ePatchFlagOutside);
Developer(DEVELOPER_LEVEL_MESSAGE, "Patch @ (%4.3f %4.3f %4.3f) outside world\n",
patch->origin[0], patch->origin[1], patch->origin[2]);
return false;
}
}
}
return true;
#endif
}
#ifdef HLRAD_ACCURATEBOUNCE
static void UpdateEmitterInfo (patch_t *patch)
{
#if ACCURATEBOUNCE_DEFAULT_SKYLEVEL + 3 > SKYLEVELMAX
#error "please raise SKYLEVELMAX"
#endif
const vec_t *origin = patch->origin;
const Winding *winding = patch->winding;
vec_t radius = ON_EPSILON;
for (int x = 0; x < winding->m_NumPoints; x++)
{
vec3_t delta;
vec_t dist;
VectorSubtract (winding->m_Points[x], origin, delta);
dist = VectorLength (delta);
if (dist > radius)
{
radius = dist;
}
}
int skylevel = ACCURATEBOUNCE_DEFAULT_SKYLEVEL;
vec_t area = winding->getArea ();
vec_t size = 0.8f;
if (area < size * radius * radius) // the shape is too thin
{
skylevel++;
size *= 0.25f;
if (area < size * radius * radius)
{
skylevel++;
size *= 0.25f;
if (area < size * radius * radius)
{
// stop here
radius = sqrt (area / size);
// just decrease the range to limit the use of the new method. because when the area is small, the new method becomes randomized and unstable.
}
}
}
patch->emitter_range = ACCURATEBOUNCE_THRESHOLD * radius;
if (g_noemitterrange)
{
patch->emitter_range = 0.0;
}
patch->emitter_skylevel = skylevel;
}
#endif
// =====================================================================================
//
// SUBDIVIDE PATCHES
//
// =====================================================================================
// misc
#define MAX_SUBDIVIDE 16384
static Winding* windingArray[MAX_SUBDIVIDE];
static unsigned g_numwindings = 0;
#ifdef HLRAD_SUBDIVIDEPATCH_NEW
// =====================================================================================
// cutWindingWithGrid
// Caller must free this returned value at some point
// =====================================================================================
static void cutWindingWithGrid (patch_t *patch, const dplane_t *plA, const dplane_t *plB)
// This function has been rewritten because the original one is not totally correct and may fail to do what it claims.
{
// patch->winding->m_NumPoints must > 0
// plA->dist and plB->dist will not be used
Winding *winding = NULL;
vec_t chop;
vec_t epsilon;
const int max_gridsize = 64;
vec_t gridstartA;
vec_t gridstartB;
int gridsizeA;
int gridsizeB;
vec_t gridchopA;
vec_t gridchopB;
int numstrips;
winding = new Winding (*patch->winding); // perform all the operations on the copy
chop = patch->chop;
chop = qmax (1.0, chop);
epsilon = 0.6;
// optimize the grid
{
vec_t minA;
vec_t maxA;
vec_t minB;
vec_t maxB;
minA = minB = BOGUS_RANGE;
maxA = maxB = -BOGUS_RANGE;
for (int x = 0; x < winding->m_NumPoints; x++)
{
vec_t *point;
vec_t dotA;
vec_t dotB;
point = winding->m_Points[x];
dotA = DotProduct (point, plA->normal);
minA = qmin (minA, dotA);
maxA = qmax (maxA, dotA);
dotB = DotProduct (point, plB->normal);
minB = qmin (minB, dotB);
maxB = qmax (maxB, dotB);
}
gridchopA = chop;
gridsizeA = (int)ceil ((maxA - minA - 2 * epsilon) / gridchopA);
gridsizeA = qmax (1, gridsizeA);
if (gridsizeA > max_gridsize)
{
gridsizeA = max_gridsize;
gridchopA = (maxA - minA) / (vec_t)gridsizeA;
}
gridstartA = (minA + maxA) / 2.0 - (gridsizeA / 2.0) * gridchopA;
gridchopB = chop;
gridsizeB = (int)ceil ((maxB - minB - 2 * epsilon) / gridchopB);
gridsizeB = qmax (1, gridsizeB);
if (gridsizeB > max_gridsize)
{
gridsizeB = max_gridsize;
gridchopB = (maxB - minB) / (vec_t)gridsizeB;
}
gridstartB = (minB + maxB) / 2.0 - (gridsizeB / 2.0) * gridchopB;
}
// cut the winding by the direction of plane A and save into windingArray
{
g_numwindings = 0;
for (int i = 1; i < gridsizeA; i++)
{
vec_t dist;
Winding *front = NULL;
Winding *back = NULL;
dist = gridstartA + i * gridchopA;
winding->Clip (plA->normal, dist, &front, &back);
if (!front || front->WindingOnPlaneSide (plA->normal, dist, epsilon) == SIDE_ON) // ended
{
if (front)
{
delete front;
front = NULL;
}
if (back)
{
delete back;
back = NULL;
}
break;
}
if (!back || back->WindingOnPlaneSide (plA->normal, dist, epsilon) == SIDE_ON) // didn't begin
{
if (front)
{
delete front;
front = NULL;
}
if (back)
{
delete back;
back = NULL;
}
continue;
}
delete winding;
winding = NULL;
windingArray[g_numwindings] = back;
g_numwindings++;
back = NULL;
winding = front;
front = NULL;
}
windingArray[g_numwindings] = winding;
g_numwindings++;
winding = NULL;
}
// cut by the direction of plane B
{
numstrips = g_numwindings;
for (int i = 0; i < numstrips; i++)
{
Winding *strip = windingArray[i];
windingArray[i] = NULL;
for (int j = 1; j < gridsizeB; j++)
{
vec_t dist;
Winding *front = NULL;
Winding *back = NULL;
dist = gridstartB + j * gridchopB;
strip->Clip (plB->normal, dist, &front, &back);
if (!front || front->WindingOnPlaneSide (plB->normal, dist, epsilon) == SIDE_ON) // ended
{
if (front)
{
delete front;
front = NULL;
}
if (back)
{
delete back;
back = NULL;
}
break;
}
if (!back || back->WindingOnPlaneSide (plB->normal, dist, epsilon) == SIDE_ON) // didn't begin
{
if (front)
{
delete front;
front = NULL;
}
if (back)
{
delete back;
back = NULL;
}
continue;
}
delete strip;
strip = NULL;
windingArray[g_numwindings] = back;
g_numwindings++;
back = NULL;
strip = front;
front = NULL;
}
windingArray[g_numwindings] = strip;
g_numwindings++;
strip = NULL;
}
}
delete patch->winding;
patch->winding = NULL;
}
#else
// =====================================================================================
// AddWindingToArray
// =====================================================================================
static void AddWindingToArray(Winding* winding)
{
unsigned x;
Winding** wA = windingArray;
for (x = 0; x < g_numwindings; x++, wA++)
{
if (*wA == winding)
{
return;
}
}
windingArray[g_numwindings++] = winding;
}
static void CreateStrips_r(Winding* winding, const vec3_t plane_normal, const vec_t plane_dist, vec_t step)
{
Winding* A;
Winding* B;
vec_t areaA;
vec_t areaB;
winding->Clip(plane_normal, plane_dist + step, &A, &B);
if (A && B)
{
areaA = A->getArea();
areaB = B->getArea();
if ((areaA > 1.0) && (areaB > 1.0))
{
delete winding;
CreateStrips_r(A, plane_normal, plane_dist + step, step);
CreateStrips_r(B, plane_normal, plane_dist + step, step);
return;
}
}
else
{ // Try the other direction
if (A)
{
delete A;
}
if (B)
{
delete B;
}
winding->Clip(plane_normal, plane_dist - step, &A, &B);
if (A && B)
{
areaA = A->getArea();
areaB = B->getArea();
if ((areaA > 1.0) && (areaB > 1.0))
{
delete winding;
CreateStrips_r(A, plane_normal, plane_dist - step, step);
CreateStrips_r(B, plane_normal, plane_dist - step, step);
return;
}
}
}
// Last recursion, save it into the list
if (A)
{
delete A;
}
if (B)
{
delete B;
}
AddWindingToArray(winding);
hlassume(g_numwindings < MAX_SUBDIVIDE, assume_GENERIC);
}
// =====================================================================================
// CreateStrips
// =====================================================================================
static bool CreateStrips(Winding* winding, const dplane_t* plane, vec_t step)
{
Winding* A;
Winding* B;
vec_t areaA;
vec_t areaB;
winding->Clip(plane->normal, plane->dist, &A, &B);
if (A && B)
{
areaA = A->getArea();
areaB = B->getArea();
if ((areaA > 1.0) && (areaB > 1.0))
{
CreateStrips_r(A, (vec_t*)plane->normal, plane->dist, step);
CreateStrips_r(B, (vec_t*)plane->normal, plane->dist, step);
return true;
}
}
if (A)
{
delete A;
}
if (B)
{
delete B;
}
AddWindingToArray(winding);
hlassume(g_numwindings < MAX_SUBDIVIDE, assume_GENERIC);
return false;
}
// =====================================================================================
// cutWindingWithGrid
// Caller must free this returned value at some point
// =====================================================================================
static void cutWindingWithGrid(patch_t* patch, const dplane_t* const plA, const dplane_t* const plB)
{
Winding** winding;
unsigned int count;
unsigned int x;
#ifdef HLRAD_SubdividePatch_NOTMIDDLE
dplane_t plA_adjusted = *plA;
dplane_t plB_adjusted = *plB;
vec_t Amin, Amax, Bmin, Bmax;
vec_t Ashift, Ashiftmin, Ashiftmax;
vec_t Bshift, Bshiftmin, Bshiftmax;
Amin = Bmin = BOGUS_RANGE;
Amax = Bmax = -BOGUS_RANGE;
for (x = 0; x < patch->winding->m_NumPoints; x++)
{
vec_t A, B;
const vec3_t &p = patch->winding->m_Points[x];
A = DotProduct (plA->normal, p) - plA->dist;
B = DotProduct (plB->normal, p) - plB->dist;
if (A < Amin) Amin = A;
if (A > Amax) Amax = A;
if (B < Bmin) Bmin = B;
if (B > Bmax) Bmax = B;
}
Amin /= patch->chop;
Amax /= patch->chop;
Ashiftmin = Amax - floor (Amax - NORMAL_EPSILON);
Ashiftmax = Amin - floor (Amin + NORMAL_EPSILON);
Ashift = Ashiftmin <= Ashiftmax + NORMAL_EPSILON? (Ashiftmin + Ashiftmax) / 2: 0;
if (Ashift > 0.5) Ashift -= 1;
plA_adjusted.dist += Ashift * patch->chop;
Bmin /= patch->chop;
Bmax /= patch->chop;
Bshiftmin = Bmax - floor (Bmax - NORMAL_EPSILON);
Bshiftmax = Bmin - floor (Bmin + NORMAL_EPSILON);
Bshift = Bshiftmin <= Bshiftmax + NORMAL_EPSILON? (Bshiftmin + Bshiftmax) / 2: 0;
if (Bshift > 0.5) Bshift -= 1;
plB_adjusted.dist += Bshift * patch->chop;
#endif
g_numwindings = 0;
#ifdef HLRAD_SubdividePatch_NOTMIDDLE
if (CreateStrips(patch->winding, &plA_adjusted, patch->chop))
#else
if (CreateStrips(patch->winding, plA, patch->chop))
#endif
{
delete patch->winding;
patch->winding = NULL; // Invalidated by CreateStrips routine
}
count = g_numwindings;
for (x = 0, winding = windingArray; x < count; x++, winding++)
{
#ifdef HLRAD_SubdividePatch_NOTMIDDLE
if (CreateStrips(*winding, &plB_adjusted, patch->chop))
#else
if (CreateStrips(*winding, plB, patch->chop))
#endif
{
delete *winding;
*winding = NULL;
}
}
}
#endif
// =====================================================================================
// getGridPlanes
// From patch, determine perpindicular grid planes to subdivide with (returned in planeA and planeB)
// assume S and T is perpindicular (they SHOULD be in worldcraft 3.3 but aren't always . . .)
// =====================================================================================
static void getGridPlanes(const patch_t* const p, dplane_t* const pl)
{
const patch_t* patch = p;
dplane_t* planes = pl;
const dface_t* f = g_dfaces + patch->faceNumber;
texinfo_t* tx = &g_texinfo[f->texinfo];
dplane_t* plane = planes;
const dplane_t* faceplane = getPlaneFromFaceNumber(patch->faceNumber);
int x;
for (x = 0; x < 2; x++, plane++)
{
#ifdef ZHLT_FREETEXTUREAXIS
// cut the patch along texel grid planes
vec_t val;
val = DotProduct (faceplane->normal, tx->vecs[!x]);
VectorMA (tx->vecs[!x], -val, faceplane->normal, plane->normal);
#else
vec3_t a, b, c;
vec3_t delta1, delta2;
VectorCopy(patch->origin, a);
VectorAdd(patch->origin, faceplane->normal, b);
VectorAdd(patch->origin, tx->vecs[x], c);
VectorSubtract(b, a, delta1);
VectorSubtract(c, a, delta2);
CrossProduct(delta1, delta2, plane->normal);
#endif
VectorNormalize(plane->normal);
plane->dist = DotProduct(plane->normal, patch->origin);
}
}
// =====================================================================================
// SubdividePatch
// =====================================================================================
static void SubdividePatch(patch_t* patch)
{
dplane_t planes[2];
dplane_t* plA = &planes[0];
dplane_t* plB = &planes[1];
Winding** winding;
unsigned x;
patch_t* new_patch;
memset(windingArray, 0, sizeof(windingArray));
g_numwindings = 0;
getGridPlanes(patch, planes);
cutWindingWithGrid(patch, plA, plB);
x = 0;
patch->next = NULL;
winding = windingArray;
while (*winding == NULL)
{
winding++;
x++;
}
patch->winding = *winding;
winding++;
x++;
patch->area = patch->winding->getArea();
patch->winding->getCenter(patch->origin);
PlacePatchInside(patch);
#ifdef HLRAD_ACCURATEBOUNCE
UpdateEmitterInfo (patch);
#endif
new_patch = g_patches + g_num_patches;
for (; x < g_numwindings; x++, winding++)
{
if (*winding)
{
memcpy(new_patch, patch, sizeof(patch_t));
new_patch->winding = *winding;
new_patch->area = new_patch->winding->getArea();
new_patch->winding->getCenter(new_patch->origin);
PlacePatchInside(new_patch);
#ifdef HLRAD_ACCURATEBOUNCE
UpdateEmitterInfo (new_patch);
#endif
new_patch++;
g_num_patches++;
hlassume(g_num_patches < MAX_PATCHES, assume_MAX_PATCHES);
}
}
// ATTENTION: We let SortPatches relink all the ->next correctly! instead of doing it here too which is somewhat complicated
}
// =====================================================================================
// MakePatchForFace
static float totalarea = 0;
// =====================================================================================
#ifdef HLRAD_CUSTOMCHOP
vec_t *chopscales; //[nummiptex]
void ReadCustomChopValue()
{
int num;
int i, k;
entity_t *mapent;
epair_t *ep;
num = ((dmiptexlump_t *)g_dtexdata)->nummiptex;
chopscales = (vec_t *)malloc (num * sizeof(vec_t));
for (i = 0; i < num; i++)
{
chopscales[i] = 1.0;
}
for (k = 0; k < g_numentities; k++)
{
mapent = &g_entities[k];
if (strcmp(ValueForKey(mapent, "classname"), "info_chopscale"))
continue;
Developer (DEVELOPER_LEVEL_MESSAGE, "info_chopscale entity detected.\n");
for (i = 0; i < num; i++)
{
const char *texname = ((miptex_t*)(g_dtexdata+((dmiptexlump_t*)g_dtexdata)->dataofs[i]))->name;
for (ep = mapent->epairs; ep; ep = ep->next)
{
if (strcasecmp (ep->key, texname))
continue;
if (!strcasecmp (ep->key, "origin"))
continue;
if (atof (ep->value) <= 0)
continue;
chopscales[i] = atof (ep->value);
Developer (DEVELOPER_LEVEL_MESSAGE, "info_chopscale: %s = %f\n", texname, chopscales[i]);
}
}
}
}
vec_t ChopScaleForTexture (int facenum)
{
return chopscales[g_texinfo[g_dfaces[facenum].texinfo].miptex];
}
#endif
#ifdef HLRAD_CUSTOMSMOOTH
vec_t *g_smoothvalues; //[nummiptex]
void ReadCustomSmoothValue()
{
int num;
int i, k;
entity_t *mapent;
epair_t *ep;
num = ((dmiptexlump_t *)g_dtexdata)->nummiptex;
g_smoothvalues = (vec_t *)malloc (num * sizeof(vec_t));
for (i = 0; i < num; i++)
{
g_smoothvalues[i] = g_smoothing_threshold;
}
for (k = 0; k < g_numentities; k++)
{
mapent = &g_entities[k];
if (strcmp(ValueForKey(mapent, "classname"), "info_smoothvalue"))
continue;
Developer (DEVELOPER_LEVEL_MESSAGE, "info_smoothvalue entity detected.\n");
for (i = 0; i < num; i++)
{
const char *texname = ((miptex_t*)(g_dtexdata+((dmiptexlump_t*)g_dtexdata)->dataofs[i]))->name;
for (ep = mapent->epairs; ep; ep = ep->next)
{
if (strcasecmp (ep->key, texname))
continue;
if (!strcasecmp (ep->key, "origin"))
continue;
g_smoothvalues[i] = cos(atof (ep->value) * (Q_PI / 180.0));
Developer (DEVELOPER_LEVEL_MESSAGE, "info_smoothvalue: %s = %f\n", texname, atof (ep->value));
}
}
}
}
#endif
#ifdef HLRAD_TRANSLUCENT
void ReadTranslucentTextures()
{
int num;
int i, k;
entity_t *mapent;
epair_t *ep;
num = ((dmiptexlump_t *)g_dtexdata)->nummiptex;
g_translucenttextures = (vec3_t *)malloc (num * sizeof(vec3_t));
for (i = 0; i < num; i++)
{
VectorClear (g_translucenttextures[i]);
}
for (k = 0; k < g_numentities; k++)
{
mapent = &g_entities[k];
if (strcmp(ValueForKey(mapent, "classname"), "info_translucent"))
continue;
Developer (DEVELOPER_LEVEL_MESSAGE, "info_translucent entity detected.\n");
for (i = 0; i < num; i++)
{
const char *texname = ((miptex_t*)(g_dtexdata+((dmiptexlump_t*)g_dtexdata)->dataofs[i]))->name;
for (ep = mapent->epairs; ep; ep = ep->next)
{
if (strcasecmp (ep->key, texname))
continue;
if (!strcasecmp (ep->key, "origin"))
continue;
double r, g, b;
int count;
count = sscanf (ep->value, "%lf %lf %lf", &r, &g, &b);
if (count == 1)
{
g = b = r;
}
else if (count != 3)
{
Warning ("ignore bad translucent value '%s'", ep->value);
continue;
}
if (r < 0.0 || r > 1.0 || g < 0.0 || g > 1.0 || b < 0.0 || b > 1.0)
{
Warning ("translucent value should be 0.0-1.0");
continue;
}
g_translucenttextures[i][0] = r;
g_translucenttextures[i][1] = g;
g_translucenttextures[i][2] = b;
Developer (DEVELOPER_LEVEL_MESSAGE, "info_translucent: %s = %f %f %f\n", texname, r, g, b);
}
}
}
}
#endif
#ifdef HLRAD_DIVERSE_LIGHTING
vec3_t *g_lightingconeinfo;//[nummiptex]
static vec_t DefaultScaleForPower (vec_t power)
{
vec_t scale;
// scale = Pi / Integrate [2 Pi * Sin [x] * Cos[x] ^ power, {x, 0, Pi / 2}]
scale = (1 + power) / 2.0;
return scale;
}
void ReadLightingCone ()
{
int num;
int i, k;
entity_t *mapent;
epair_t *ep;
num = ((dmiptexlump_t *)g_dtexdata)->nummiptex;
g_lightingconeinfo = (vec3_t *)malloc (num * sizeof(vec3_t));
for (i = 0; i < num; i++)
{
g_lightingconeinfo[i][0] = 1.0; // default power
g_lightingconeinfo[i][1] = 1.0; // default scale
}
for (k = 0; k < g_numentities; k++)
{
mapent = &g_entities[k];
if (strcmp(ValueForKey(mapent, "classname"), "info_angularfade"))
continue;
Developer (DEVELOPER_LEVEL_MESSAGE, "info_angularfade entity detected.\n");
for (i = 0; i < num; i++)
{
const char *texname = ((miptex_t*)(g_dtexdata+((dmiptexlump_t*)g_dtexdata)->dataofs[i]))->name;
for (ep = mapent->epairs; ep; ep = ep->next)
{
if (strcasecmp (ep->key, texname))
continue;
if (!strcasecmp (ep->key, "origin"))
continue;
double power, scale;
int count;
count = sscanf (ep->value, "%lf %lf", &power, &scale);
if (count == 1)
{
scale = 1.0;
}
else if (count != 2)
{
Warning ("ignore bad angular fade value '%s'", ep->value);
continue;
}
if (power < 0.0 || scale < 0.0)
{
Warning ("ignore disallowed angular fade value '%s'", ep->value);
continue;
}
scale *= DefaultScaleForPower (power);
g_lightingconeinfo[i][0] = power;
g_lightingconeinfo[i][1] = scale;
Developer (DEVELOPER_LEVEL_MESSAGE, "info_angularfade: %s = %f %f\n", texname, power, scale);
}
}
}
}
#endif
static vec_t getScale(const patch_t* const patch)
{
dface_t* f = g_dfaces + patch->faceNumber;
texinfo_t* tx = &g_texinfo[f->texinfo];
if (g_texscale)
{
#ifdef ZHLT_FREETEXTUREAXIS
const dplane_t* faceplane = getPlaneFromFace (f);
vec3_t vecs_perpendicular[2];
vec_t scale[2];
vec_t dot;
// snap texture "vecs" to faceplane without affecting texture alignment
for (int x = 0; x < 2; x++)
{
dot = DotProduct (faceplane->normal, tx->vecs[x]);
VectorMA (tx->vecs[x], -dot, faceplane->normal, vecs_perpendicular[x]);
}
scale[0] = 1 / qmax (NORMAL_EPSILON, VectorLength (vecs_perpendicular[0]));
scale[1] = 1 / qmax (NORMAL_EPSILON, VectorLength (vecs_perpendicular[1]));
// don't care about the angle between vecs[0] and vecs[1] (given the length of "vecs", smaller angle = larger texel area), because gridplanes will have the same angle (also smaller angle = larger patch area)
return sqrt (scale[0] * scale[1]);
#else
vec_t scale[2];
scale[0] = 0.0;
scale[1] = 0.0;
scale[0] += tx->vecs[0][0] * tx->vecs[0][0];
scale[0] += tx->vecs[0][1] * tx->vecs[0][1];
scale[0] += tx->vecs[0][2] * tx->vecs[0][2];
scale[1] += tx->vecs[1][0] * tx->vecs[1][0];
scale[1] += tx->vecs[1][1] * tx->vecs[1][1];
scale[1] += tx->vecs[1][2] * tx->vecs[1][2];
scale[0] = sqrt(scale[0]);
scale[1] = sqrt(scale[1]);
return 2.0 / ((scale[0] + scale[1]));
#endif
}
else
{
return 1.0;
}
}
// =====================================================================================
// getChop
// =====================================================================================
#ifdef HLRAD_TEXLIGHTTHRESHOLD_FIX
static bool getEmitMode (const patch_t *patch)
{
bool emitmode = false;
vec_t value =
#ifdef HLRAD_REFLECTIVITY
DotProduct (patch->baselight, patch->texturereflectivity) / 3
#else
VectorAvg (patch->baselight)
#endif
;
#ifdef HLRAD_CUSTOMTEXLIGHT
if (g_face_texlights[patch->faceNumber])
{
if (*ValueForKey (g_face_texlights[patch->faceNumber], "_scale"))
{
value *= FloatForKey (g_face_texlights[patch->faceNumber], "_scale");
}
}
#endif
if (value > 0.0)
{
emitmode = true;
}
if (value < g_dlight_threshold)
{
emitmode = false;
}
#ifdef HLRAD_CUSTOMTEXLIGHT
if (g_face_texlights[patch->faceNumber])
{
switch (IntForKey (g_face_texlights[patch->faceNumber], "_fast"))
{
case 1:
emitmode = false;
break;
case 2:
emitmode = true;
break;
}
}
#endif
return emitmode;
}
#endif
static vec_t getChop(const patch_t* const patch)
{
vec_t rval;
#ifdef HLRAD_CUSTOMTEXLIGHT
if (g_face_texlights[patch->faceNumber])
{
if (*ValueForKey (g_face_texlights[patch->faceNumber], "_chop"))
{
rval = FloatForKey (g_face_texlights[patch->faceNumber], "_chop");
if (rval < 1.0)
{
rval = 1.0;
}
return rval;
}
}
#endif
#ifdef HLRAD_TEXLIGHTTHRESHOLD_FIX
if (!patch->emitmode)
#else
if (VectorCompare(patch->baselight, vec3_origin))
#endif
{
rval = g_chop * getScale(patch);
}
else
{
rval = g_texchop * getScale(patch);
#ifdef HLRAD_ACCURATEBOUNCE_TEXLIGHT
// we needn't do this now, so let's save our compile time.
#else
if (g_extra)
{
rval *= 0.5;
}
#endif
}
#ifdef HLRAD_CUSTOMCHOP
rval *= ChopScaleForTexture (patch->faceNumber);
#endif
return rval;
}
// =====================================================================================
// MakePatchForFace
// =====================================================================================
#ifdef ZHLT_TEXLIGHT
static void MakePatchForFace(const int fn, Winding* w, int style
#ifdef HLRAD_BOUNCE_STYLE
, int bouncestyle
#endif
) //LRC
#else
static void MakePatchForFace(const int fn, Winding* w
#ifdef HLRAD_BOUNCE_STYLE
, int bouncestyle
#endif
)
#endif
{
const dface_t* f = g_dfaces + fn;
// No g_patches at all for the sky!
if (!IsSpecial(f))
{
#ifdef HLRAD_CUSTOMTEXLIGHT
#ifdef ZHLT_TEXLIGHT
if (g_face_texlights[fn])
{
style = IntForKey (g_face_texlights[fn], "style");
#ifdef ZHLT_TEXLIGHT
if (style < 0)
style = -style;
#endif
#ifdef HLRAD_STYLE_CORING
style = (unsigned char)style;
if (style >= ALLSTYLES)
{
Error ("invalid light style: style (%d) >= ALLSTYLES (%d)", style, ALLSTYLES);
}
#endif
}
#endif
#endif
patch_t* patch;
vec3_t light;
vec3_t centroid = { 0, 0, 0 };
int numpoints = w->m_NumPoints;
if (numpoints < 3) // WTF! (Actually happens in real-world maps too)
{
Developer(DEVELOPER_LEVEL_WARNING, "Face %d only has %d points on winding\n", fn, numpoints);
return;
}
if (numpoints > MAX_POINTS_ON_WINDING)
{
Error("numpoints %d > MAX_POINTS_ON_WINDING", numpoints);
return;
}
patch = &g_patches[g_num_patches];
hlassume(g_num_patches < MAX_PATCHES, assume_MAX_PATCHES);
memset(patch, 0, sizeof(patch_t));
patch->winding = w;
patch->area = patch->winding->getArea();
patch->winding->getCenter(patch->origin);
patch->faceNumber = fn;
totalarea += patch->area;
#ifndef HLRAD_PATCHBLACK_FIX
PlacePatchInside(patch);
#ifdef HLRAD_ACCURATEBOUNCE
UpdateEmitterInfo (patch);
#endif
#endif
BaseLightForFace(f, light);
#ifdef ZHLT_TEXLIGHT
//LRC VectorCopy(light, patch->totallight);
#else
VectorCopy(light, patch->totallight);
#endif
VectorCopy(light, patch->baselight);
#ifdef ZHLT_TEXLIGHT
#ifdef HLRAD_AUTOCORING
patch->emitstyle = style;
#else
//LRC
int i;
patch->totalstyle[0] = 0;
for (i = 1; i < MAXLIGHTMAPS; i++)
{
patch->totalstyle[i] = 255;
}
if (style)
{
patch->emitstyle = patch->totalstyle[1] = style;
}
//LRC (ends)
#endif
#endif
#ifdef HLRAD_REFLECTIVITY
VectorCopy (g_textures[g_texinfo[f->texinfo].miptex].reflectivity, patch->texturereflectivity);
#ifdef HLRAD_CUSTOMTEXLIGHT_COLOR
if (g_face_texlights[fn] && *ValueForKey (g_face_texlights[fn], "_texcolor"))
{
vec3_t texturecolor;
vec3_t texturereflectivity;
GetVectorForKey (g_face_texlights[fn], "_texcolor", texturecolor);
for (int k = 0; k < 3; k++)
{
texturecolor[k] = floor (texturecolor[k] + 0.001);
}
if (VectorMinimum (texturecolor) < -0.001 || VectorMaximum (texturecolor) > 255.001)
{
vec3_t origin;
GetVectorForKey (g_face_texlights[fn], "origin", origin);
Error ("light_surface entity at (%g,%g,%g): texture color (%g,%g,%g) must be numbers between 0 and 255.", origin[0], origin[1], origin[2], texturecolor[0], texturecolor[1], texturecolor[2]);
}
VectorScale (texturecolor, 1.0 / 255.0, texturereflectivity);
for (int k = 0; k < 3; k++)
{
texturereflectivity[k] = pow (texturereflectivity[k], g_texreflectgamma);
}
VectorScale (texturereflectivity, g_texreflectscale, texturereflectivity);
if (VectorMaximum (texturereflectivity) > 1.0 + NORMAL_EPSILON)
{
Warning ("Texture '%s': reflectivity (%f,%f,%f) greater than 1.0.", g_textures[g_texinfo[f->texinfo].miptex].name, texturereflectivity[0], texturereflectivity[1], texturereflectivity[2]);
}
VectorCopy (texturereflectivity, patch->texturereflectivity);
}
#endif
{
vec_t opacity = 0.0;
if (g_face_entity[fn] - g_entities == 0)
{
opacity = 1.0;
}
else
{
int x;
for (x = 0; x < g_opaque_face_count; x++)
{
opaqueList_t *op = &g_opaque_face_list[x];
#ifdef HLRAD_OPAQUE_NODE
if (op->entitynum == g_face_entity[fn] - g_entities)
#else
if (op->facenum == fn)
#endif
{
opacity = 1.0;
#ifdef HLRAD_HULLU
if (op->transparency)
{
opacity = 1.0 - VectorAvg (op->transparency_scale);
opacity = opacity > 1.0? 1.0: opacity < 0.0? 0.0: opacity;
}
#endif
#ifdef HLRAD_BOUNCE_STYLE
if (op->style != -1)
{ // toggleable opaque entity
if (bouncestyle == -1)
{ // by default
opacity = 0.0; // doesn't reflect light
}
}
#endif
break;
}
}
#ifdef HLRAD_BOUNCE_STYLE
if (x == g_opaque_face_count)
{ // not opaque
if (bouncestyle != -1)
{ // with light_bounce
opacity = 1.0; // reflects light
}
}
#endif
}
#ifdef ZHLT_HIDDENSOUNDTEXTURE
// if the face is a world face and it's not referenced by any leaf, it must be a hidden face, and shouldn't reflect light
if (g_dmodels[0].firstface <= fn && fn < g_dmodels[0].firstface + g_dmodels[0].numfaces)
{
bool found = false;
for (int x = 0; x < g_nummarksurfaces; x++)
{
if (g_dmarksurfaces[x] == fn)
{
found = true;
break;
}
}
if (!found)
{
opacity = 0.0;
}
}
#endif
VectorScale (patch->texturereflectivity, opacity, patch->bouncereflectivity);
}
#ifdef HLRAD_BOUNCE_STYLE
patch->bouncestyle = bouncestyle;
if (bouncestyle == 0)
{ // there is an unnamed light_bounce
patch->bouncestyle = -1; // reflects light normally
}
#endif
#endif
#ifdef HLRAD_TEXLIGHTTHRESHOLD_FIX
patch->emitmode = getEmitMode (patch);
#endif
patch->scale = getScale(patch);
patch->chop = getChop(patch);
#ifdef HLRAD_TRANSLUCENT
VectorCopy (g_translucenttextures[g_texinfo[f->texinfo].miptex], patch->translucent_v);
patch->translucent_b = !VectorCompare (patch->translucent_v, vec3_origin);
#endif
#ifdef HLRAD_PATCHBLACK_FIX
PlacePatchInside(patch);
#ifdef HLRAD_ACCURATEBOUNCE
UpdateEmitterInfo (patch);
#endif
#endif
g_face_patches[fn] = patch;
g_num_patches++;
// Per-face data
{
int j;
// Centroid of face for nudging samples in direct lighting pass
for (j = 0; j < f->numedges; j++)
{
int edge = g_dsurfedges[f->firstedge + j];
if (edge > 0)
{
VectorAdd(g_dvertexes[g_dedges[edge].v[0]].point, centroid, centroid);
VectorAdd(g_dvertexes[g_dedges[edge].v[1]].point, centroid, centroid);
}
else
{
VectorAdd(g_dvertexes[g_dedges[-edge].v[1]].point, centroid, centroid);
VectorAdd(g_dvertexes[g_dedges[-edge].v[0]].point, centroid, centroid);
}
}
// Fixup centroid for anything with an altered origin (rotating models/turrets mostly)
// Save them for moving direct lighting points towards the face center
VectorScale(centroid, 1.0 / (f->numedges * 2), centroid);
VectorAdd(centroid, g_face_offset[fn], g_face_centroids[fn]);
}
{
vec3_t mins;
vec3_t maxs;
patch->winding->getBounds(mins, maxs);
if (g_subdivide)
{
vec_t amt;
vec_t length;
vec3_t delta;
VectorSubtract(maxs, mins, delta);
length = VectorLength(delta);
#ifdef HLRAD_CHOP_FIX
amt = patch->chop;
#else // loss patches on faces where texture scale < 1 and range < g_chop
if (VectorCompare(patch->baselight, vec3_origin))
{
amt = g_chop;
}
else
{
amt = g_texchop;
}
#endif
if (length > amt)
{
if (patch->area < 1.0)
{
Developer(DEVELOPER_LEVEL_WARNING,
"Patch at (%4.3f %4.3f %4.3f) (face %d) tiny area (%4.3f) not subdividing \n",
patch->origin[0], patch->origin[1], patch->origin[2], patch->faceNumber, patch->area);
}
else
{
SubdividePatch(patch);
}
}
}
}
}
}
// =====================================================================================
// AddFaceToOpaqueList
// =====================================================================================
static void AddFaceToOpaqueList(
#ifdef HLRAD_OPAQUE_NODE
int entitynum, int modelnum, const vec3_t origin
#else
const unsigned facenum, const Winding* const winding
#endif
#ifdef HLRAD_HULLU
, const vec3_t &transparency_scale, const bool transparency
#endif
#ifndef HLRAD_OPAQUE_NODE
#ifdef HLRAD_OPAQUE_GROUP
, const dmodel_t* mod
#endif
#endif
#ifdef HLRAD_OPAQUE_STYLE
, int style
#endif
#ifdef HLRAD_OPAQUE_BLOCK
, bool block
#endif
)
{
if (g_opaque_face_count == g_max_opaque_face_count)
{
g_max_opaque_face_count += OPAQUE_ARRAY_GROWTH_SIZE;
g_opaque_face_list = (opaqueList_t*)realloc(g_opaque_face_list, sizeof(opaqueList_t) * g_max_opaque_face_count);
#ifdef HLRAD_HLASSUMENOMEMORY
hlassume (g_opaque_face_list != NULL, assume_NoMemory);
#endif
}
{
opaqueList_t* opaque = &g_opaque_face_list[g_opaque_face_count];
g_opaque_face_count++;
#ifdef HLRAD_OPAQUE_STYLE
if (transparency && style != -1)
{
Warning ("Dynamic shadow is not allowed in entity with custom shadow.\n");
style = -1;
}
#endif
#ifdef HLRAD_HULLU
VectorCopy(transparency_scale, opaque->transparency_scale);
opaque->transparency = transparency;
#endif
#ifdef HLRAD_OPAQUE_NODE
opaque->entitynum = entitynum;
opaque->modelnum = modelnum;
VectorCopy (origin, opaque->origin);
#else
opaque->facenum = facenum;
getAdjustedPlaneFromFaceNumber(facenum, &opaque->plane);
opaque->winding = new Winding(*winding);
#endif
#ifndef HLRAD_OPAQUE_NODE
#ifdef HLRAD_OPAQUE_GROUP
{
int ig;
for (ig=0; ig<g_opaque_group_count; ++ig)
if (mod==g_opaque_group_list[ig].mod)
break;
if (ig==g_opaque_group_count) //new opaque group
{
if (g_opaque_group_count>=MAX_OPAQUE_GROUP_COUNT)
Error ("too many opaque models");
g_opaque_group_list[ig].mod=mod;
#ifdef HLRAD_OPAQUE_RANGE
for (int i=0; i<3; ++i)
{
g_opaque_group_list[ig].mins[i]=mod->mins[i]+g_face_offset[facenum][i]-1;
g_opaque_group_list[ig].maxs[i]=mod->maxs[i]+g_face_offset[facenum][i]+1;
}
#endif
g_opaque_group_count++;
}
opaque->groupnum=ig;
}
#endif
#endif
#ifdef HLRAD_OPAQUE_STYLE
opaque->style = style;
#endif
#ifdef HLRAD_OPAQUE_BLOCK
opaque->block = block;
#endif
}
}
// =====================================================================================
// FreeOpaqueFaceList
// =====================================================================================
static void FreeOpaqueFaceList()
{
unsigned x;
opaqueList_t* opaque = g_opaque_face_list;
for (x = 0; x < g_opaque_face_count; x++, opaque++)
{
#ifndef HLRAD_OPAQUE_NODE
delete opaque->winding;
opaque->winding = NULL;
#endif
}
free(g_opaque_face_list);
g_opaque_face_list = NULL;
g_opaque_face_count = 0;
g_max_opaque_face_count = 0;
}
#ifdef HLRAD_OPAQUE_NODE
static void LoadOpaqueEntities()
{
int modelnum, entnum;
for (modelnum = 0; modelnum < g_nummodels; modelnum++)
{
dmodel_t *model = &g_dmodels[modelnum];
char stringmodel[16];
sprintf (stringmodel, "*%i", modelnum);
for (entnum = 0; entnum < g_numentities; entnum++)
{
entity_t *ent = &g_entities[entnum];
if (strcmp (ValueForKey (ent, "model"), stringmodel))
continue;
vec3_t origin;
{
GetVectorForKey (ent, "origin", origin);
if (*ValueForKey (ent, "light_origin") && *ValueForKey (ent, "model_center"))
{
entity_t *ent2 = FindTargetEntity (ValueForKey (ent, "light_origin"));
if (ent2)
{
vec3_t light_origin, model_center;
GetVectorForKey (ent2, "origin", light_origin);
GetVectorForKey (ent, "model_center", model_center);
VectorSubtract (light_origin, model_center, origin);
}
}
}
bool opaque = false;
{
if (g_allow_opaques && (IntForKey (ent, "zhlt_lightflags") & eModelLightmodeOpaque))
opaque = true;
}
#ifdef HLRAD_HULLU
vec3_t d_transparency;
VectorFill (d_transparency, 0.0);
bool b_transparency = false;
{
const char *s;
if (*(s = ValueForKey(ent, "zhlt_customshadow")))
{
double r1 = 1.0, g1 = 1.0, b1 = 1.0, tmp = 1.0;
if (sscanf(s, "%lf %lf %lf", &r1, &g1, &b1) == 3) //RGB version
{
if(r1<0.0) r1 = 0.0;
if(g1<0.0) g1 = 0.0;
if(b1<0.0) b1 = 0.0;
d_transparency[0] = r1;
d_transparency[1] = g1;
d_transparency[2] = b1;
}
else if (sscanf(s, "%lf", &tmp) == 1) //Greyscale version
{
if(tmp<0.0) tmp = 0.0;
VectorFill(d_transparency, tmp);
}
}
if (!VectorCompare (d_transparency, vec3_origin))
b_transparency = true;
}
#endif
#ifdef HLRAD_OPAQUE_STYLE
int opaquestyle = -1;
{
int j;
for (j = 0; j < g_numentities; j++)
{
entity_t *lightent = &g_entities[j];
if (!strcmp (ValueForKey (lightent, "classname"), "light_shadow")
&& *ValueForKey (lightent, "target")
&& !strcmp (ValueForKey (lightent, "target"), ValueForKey (ent, "targetname")))
{
opaquestyle = IntForKey (lightent, "style");
#ifdef ZHLT_TEXLIGHT
if (opaquestyle < 0)
opaquestyle = -opaquestyle;
#endif
#ifdef HLRAD_STYLE_CORING
opaquestyle = (unsigned char)opaquestyle;
if (opaquestyle >= ALLSTYLES)
{
Error ("invalid light style: style (%d) >= ALLSTYLES (%d)", opaquestyle, ALLSTYLES);
}
#endif
break;
}
}
}
#endif
#ifdef HLRAD_OPAQUE_BLOCK
bool block = false;
{
if (g_blockopaque)
{
block = true;
if (IntForKey (ent, "zhlt_lightflags") & eModelLightmodeNonsolid)
block = false;
if (b_transparency)
block = false;
#ifdef HLRAD_OPAQUE_STYLE
if (opaquestyle != -1)
block = false;
#endif
}
}
#endif
if (opaque)
{
AddFaceToOpaqueList (entnum, modelnum, origin
#ifdef HLRAD_HULLU
, d_transparency, b_transparency
#endif
#ifdef HLRAD_OPAQUE_STYLE
, opaquestyle
#endif
#ifdef HLRAD_OPAQUE_BLOCK
, block
#endif
);
}
}
}
{
Log("%i opaque models\n", g_opaque_face_count);
int i, facecount;
for (facecount = 0, i = 0; i < g_opaque_face_count; i++)
{
facecount += CountOpaqueFaces (g_opaque_face_list[i].modelnum);
}
Log("%i opaque faces\n", facecount);
}
}
#endif
// =====================================================================================
// MakePatches
// =====================================================================================
#ifdef HLRAD_CUSTOMTEXLIGHT
static entity_t *FindTexlightEntity (int facenum)
{
dface_t *face = &g_dfaces[facenum];
const dplane_t *dplane = getPlaneFromFace (face);
const char *texname = GetTextureByNumber (face->texinfo);
entity_t *faceent = g_face_entity[facenum];
vec3_t centroid;
Winding *w = new Winding (*face);
w->getCenter (centroid);
delete w;
VectorAdd (centroid, g_face_offset[facenum], centroid);
entity_t *found = NULL;
vec_t bestdist = -1;
for (int i = 0; i < g_numentities; i++)
{
entity_t *ent = &g_entities[i];
if (strcmp (ValueForKey (ent, "classname"), "light_surface"))
continue;
if (strcasecmp (ValueForKey (ent, "_tex"), texname))
continue;
vec3_t delta;
GetVectorForKey (ent, "origin", delta);
VectorSubtract (delta, centroid, delta);
vec_t dist = VectorLength (delta);
if (*ValueForKey (ent, "_frange"))
{
if (dist > FloatForKey (ent, "_frange"))
continue;
}
if (*ValueForKey (ent, "_fdist"))
{
if (fabs (DotProduct (delta, dplane->normal)) > FloatForKey (ent, "_fdist"))
continue;
}
if (*ValueForKey (ent, "_fclass"))
{
if (strcmp (ValueForKey (faceent, "classname"), ValueForKey (ent, "_fclass")))
continue;
}
if (*ValueForKey (ent, "_fname"))
{
if (strcmp (ValueForKey (faceent, "targetname"), ValueForKey (ent, "_fname")))
continue;
}
if (bestdist >= 0 && dist > bestdist)
continue;
found = ent;
bestdist = dist;
}
return found;
}
#endif
static void MakePatches()
{
int i;
int j;
unsigned int k;
dface_t* f;
int fn;
Winding* w;
dmodel_t* mod;
vec3_t origin;
entity_t* ent;
const char* s;
vec3_t light_origin;
vec3_t model_center;
bool b_light_origin;
bool b_model_center;
eModelLightmodes lightmode;
#ifdef ZHLT_TEXLIGHT
int style; //LRC
#endif
#ifndef HLRAD_OPAQUE_NODE
#ifdef HLRAD_HULLU
vec3_t d_transparency;
bool b_transparency;
#endif
#endif
Log("%i faces\n", g_numfaces);
Log("Create Patches : ");
#ifdef HLRAD_MORE_PATCHES
g_patches = (patch_t *)AllocBlock (MAX_PATCHES * sizeof (patch_t));
#endif
for (i = 0; i < g_nummodels; i++)
{
b_light_origin = false;
b_model_center = false;
lightmode = eModelLightmodeNull;
#ifndef HLRAD_OPAQUE_NODE
#ifdef HLRAD_OPACITY // AJM
float l_opacity = 0.0f; // decimal percentage
#endif
#endif
mod = g_dmodels + i;
ent = EntityForModel(i);
VectorCopy(vec3_origin, origin);
if (*(s = ValueForKey(ent, "zhlt_lightflags")))
{
lightmode = (eModelLightmodes)atoi(s);
}
// models with origin brushes need to be offset into their in-use position
if (*(s = ValueForKey(ent, "origin")))
{
double v1, v2, v3;
if (sscanf(s, "%lf %lf %lf", &v1, &v2, &v3) == 3)
{
origin[0] = v1;
origin[1] = v2;
origin[2] = v3;
}
}
// Allow models to be lit in an alternate location (pt1)
if (*(s = ValueForKey(ent, "light_origin")))
{
entity_t* e = FindTargetEntity(s);
if (e)
{
if (*(s = ValueForKey(e, "origin")))
{
double v1, v2, v3;
if (sscanf(s, "%lf %lf %lf", &v1, &v2, &v3) == 3)
{
light_origin[0] = v1;
light_origin[1] = v2;
light_origin[2] = v3;
b_light_origin = true;
}
}
}
}
// Allow models to be lit in an alternate location (pt2)
if (*(s = ValueForKey(ent, "model_center")))
{
double v1, v2, v3;
if (sscanf(s, "%lf %lf %lf", &v1, &v2, &v3) == 3)
{
model_center[0] = v1;
model_center[1] = v2;
model_center[2] = v3;
b_model_center = true;
}
}
#ifndef HLRAD_OPAQUE_NODE
#ifdef HLRAD_HULLU
// Check for colored transparency/custom shadows
VectorFill(d_transparency, 1.0);
b_transparency = false;
if (*(s = ValueForKey(ent, "zhlt_customshadow")))
{
double r1 = 1.0, g1 = 1.0, b1 = 1.0, tmp = 1.0;
if (sscanf(s, "%lf %lf %lf", &r1, &g1, &b1) == 3) //RGB version
{
if(r1<0.0) r1 = 0.0;
if(g1<0.0) g1 = 0.0;
if(b1<0.0) b1 = 0.0;
d_transparency[0] = r1;
d_transparency[1] = g1;
d_transparency[2] = b1;
b_transparency = true;
}
else if (sscanf(s, "%lf", &tmp) == 1) //Greyscale version
{
if(tmp<0.0) tmp = 0.0;
VectorFill(d_transparency, tmp);
b_transparency = true;
}
}
#endif
#endif
// Allow models to be lit in an alternate location (pt3)
if (b_light_origin && b_model_center)
{
VectorSubtract(light_origin, model_center, origin);
}
#ifdef ZHLT_TEXLIGHT
//LRC:
if (*(s = ValueForKey(ent, "style")))
{
style = atoi(s);
if (style < 0)
style = -style;
}
else
{
style = 0;
}
//LRC (ends)
#ifdef HLRAD_STYLE_CORING
style = (unsigned char)style;
if (style >= ALLSTYLES)
{
Error ("invalid light style: style (%d) >= ALLSTYLES (%d)", style, ALLSTYLES);
}
#endif
#endif
#ifndef HLRAD_OPAQUE_NODE
#ifdef HLRAD_OPAQUE_STYLE
int opaquestyle = -1;
for (j = 0; j < g_numentities; j++)
{
entity_t *lightent = &g_entities[j];
if (!strcmp (ValueForKey (lightent, "classname"), "light_shadow")
&& *ValueForKey (lightent, "target")
&& !strcmp (ValueForKey (lightent, "target"), ValueForKey (ent, "targetname")))
{
opaquestyle = IntForKey (lightent, "style");
#ifdef ZHLT_TEXLIGHT
if (opaquestyle < 0)
opaquestyle = -opaquestyle;
#endif
#ifdef HLRAD_STYLE_CORING
opaquestyle = (unsigned char)opaquestyle;
if (opaquestyle >= ALLSTYLES)
{
Error ("invalid light style: style (%d) >= ALLSTYLES (%d)", opaquestyle, ALLSTYLES);
}
#endif
break;
}
}
#endif
#endif
#ifdef HLRAD_BOUNCE_STYLE
int bouncestyle = -1;
{
int j;
for (j = 0; j < g_numentities; j++)
{
entity_t *lightent = &g_entities[j];
if (!strcmp (ValueForKey (lightent, "classname"), "light_bounce")
&& *ValueForKey (lightent, "target")
&& !strcmp (ValueForKey (lightent, "target"), ValueForKey (ent, "targetname")))
{
bouncestyle = IntForKey (lightent, "style");
#ifdef ZHLT_TEXLIGHT
if (bouncestyle < 0)
bouncestyle = -bouncestyle;
#endif
#ifdef HLRAD_STYLE_CORING
bouncestyle = (unsigned char)bouncestyle;
if (bouncestyle >= ALLSTYLES)
{
Error ("invalid light style: style (%d) >= ALLSTYLES (%d)", bouncestyle, ALLSTYLES);
}
#endif
break;
}
}
}
#endif
for (j = 0; j < mod->numfaces; j++)
{
fn = mod->firstface + j;
g_face_entity[fn] = ent;
VectorCopy(origin, g_face_offset[fn]);
#ifdef HLRAD_CUSTOMTEXLIGHT
g_face_texlights[fn] = FindTexlightEntity (fn);
#endif
g_face_lightmode[fn] = lightmode;
f = g_dfaces + fn;
w = new Winding(*f);
for (k = 0; k < w->m_NumPoints; k++)
{
VectorAdd(w->m_Points[k], origin, w->m_Points[k]);
}
#ifndef HLRAD_OPAQUE_NODE
if (g_allow_opaques)
{
if (lightmode & eModelLightmodeOpaque)
{
AddFaceToOpaqueList(fn, w
#ifdef HLRAD_HULLU
, d_transparency, b_transparency
#endif
#ifdef HLRAD_OPAQUE_GROUP
, mod
#endif
#ifdef HLRAD_OPAQUE_STYLE
, opaquestyle
#endif
);
}
}
#endif
#ifdef ZHLT_TEXLIGHT
MakePatchForFace(fn, w, style
#ifdef HLRAD_BOUNCE_STYLE
, bouncestyle
#endif
); //LRC
#else
MakePatchForFace(fn, w
#ifdef HLRAD_BOUNCE_STYLE
, bouncestyle
#endif
);
#endif
}
}
Log("%i base patches\n", g_num_patches);
#ifndef HLRAD_OPAQUE_NODE
#ifdef HLRAD_OPAQUE_GROUP
Log("%i opaque models\n", g_opaque_group_count);
#endif
Log("%i opaque faces\n", g_opaque_face_count);
#endif
Log("%i square feet [%.2f square inches]\n", (int)(totalarea / 144), totalarea);
}
// =====================================================================================
// patch_sorter
// =====================================================================================
static int CDECL patch_sorter(const void* p1, const void* p2)
{
patch_t* patch1 = (patch_t*)p1;
patch_t* patch2 = (patch_t*)p2;
if (patch1->faceNumber < patch2->faceNumber)
{
return -1;
}
else if (patch1->faceNumber > patch2->faceNumber)
{
return 1;
}
else
{
return 0;
}
}
// =====================================================================================
// patch_sorter
// This sorts the patches by facenumber, which makes their runs compress even better
// =====================================================================================
static void SortPatches()
{
#ifdef HLRAD_MORE_PATCHES
// SortPatches is the ideal place to do this, because the address of the patches are going to be invalidated.
patch_t *old_patches = g_patches;
g_patches = (patch_t *)AllocBlock ((g_num_patches + 1) * sizeof (patch_t)); // allocate one extra slot considering how terribly the code were written
memcpy (g_patches, old_patches, g_num_patches * sizeof (patch_t));
FreeBlock (old_patches);
#endif
qsort((void*)g_patches, (size_t) g_num_patches, sizeof(patch_t), patch_sorter);
// Fixup g_face_patches & Fixup patch->next
memset(g_face_patches, 0, sizeof(g_face_patches));
{
unsigned x;
patch_t* patch = g_patches + 1;
patch_t* prev = g_patches;
#ifdef HLRAD_SortPatches_FIX
g_face_patches[prev->faceNumber] = prev;
#else
g_face_patches[0] = g_patches;
#endif
for (x = 1; x < g_num_patches; x++, patch++)
{
if (patch->faceNumber != prev->faceNumber)
{
prev->next = NULL;
g_face_patches[patch->faceNumber] = patch;
}
else
{
prev->next = patch;
}
prev = patch;
}
}
#ifdef HLRAD_ENTITYBOUNCE_FIX
for (unsigned x = 0; x < g_num_patches; x++)
{
patch_t *patch = &g_patches[x];
patch->leafnum = PointInLeaf (patch->origin) - g_dleafs;
}
#endif
}
// =====================================================================================
// FreePatches
// =====================================================================================
static void FreePatches()
{
unsigned x;
patch_t* patch = g_patches;
// AJM EX
//Log("patches: %i of %i (%2.2lf percent)\n", g_num_patches, MAX_PATCHES, (double)((double)g_num_patches / (double)MAX_PATCHES));
for (x = 0; x < g_num_patches; x++, patch++)
{
delete patch->winding;
}
memset(g_patches, 0, sizeof(patch_t) * g_num_patches);
#ifdef HLRAD_MORE_PATCHES
FreeBlock (g_patches);
g_patches = NULL;
#endif
}
//=====================================================================
// =====================================================================================
// WriteWorld
// =====================================================================================
static void WriteWorld(const char* const name)
{
unsigned i;
unsigned j;
FILE* out;
patch_t* patch;
Winding* w;
out = fopen(name, "w");
if (!out)
Error("Couldn't open %s", name);
for (j = 0, patch = g_patches; j < g_num_patches; j++, patch++)
{
w = patch->winding;
Log("%i\n", w->m_NumPoints);
for (i = 0; i < w->m_NumPoints; i++)
{
#ifdef ZHLT_TEXLIGHT
Log("%5.2f %5.2f %5.2f %5.3f %5.3f %5.3f\n",
w->m_Points[i][0],
w->m_Points[i][1],
w->m_Points[i][2], patch->totallight[0][0] / 256, patch->totallight[0][1] / 256, patch->totallight[0][2] / 256); //LRC
#else
Log("%5.2f %5.2f %5.2f %5.3f %5.3f %5.3f\n",
w->m_Points[i][0],
w->m_Points[i][1],
w->m_Points[i][2], patch->totallight[0] / 256, patch->totallight[1] / 256, patch->totallight[2] / 256);
#endif
}
Log("\n");
}
fclose(out);
}
// =====================================================================================
// CollectLight
// =====================================================================================
static void CollectLight()
{
#ifdef ZHLT_TEXLIGHT
unsigned j; //LRC
#endif
unsigned i;
patch_t* patch;
for (i = 0, patch = g_patches; i < g_num_patches; i++, patch++)
{
#ifdef HLRAD_AUTOCORING
vec3_t newtotallight[MAXLIGHTMAPS];
#ifdef ZHLT_XASH
vec3_t newtotallight_direction[MAXLIGHTMAPS];
#endif
for (j = 0; j < MAXLIGHTMAPS && newstyles[i][j] != 255; j++)
{
VectorClear (newtotallight[j]);
#ifdef ZHLT_XASH
VectorClear (newtotallight_direction[j]);
#endif
int k;
for (k = 0; k < MAXLIGHTMAPS && patch->totalstyle[k] != 255; k++)
{
if (patch->totalstyle[k] == newstyles[i][j])
{
VectorCopy (patch->totallight[k], newtotallight[j]);
#ifdef ZHLT_XASH
VectorCopy (patch->totallight_direction[k], newtotallight_direction[k]);
#endif
break;
}
}
}
for (j = 0; j < MAXLIGHTMAPS; j++)
{
if (newstyles[i][j] != 255)
{
patch->totalstyle[j] = newstyles[i][j];
VectorCopy (newtotallight[j], patch->totallight[j]);
VectorCopy (addlight[i][j], emitlight[i][j]);
#ifdef ZHLT_XASH
VectorCopy (newtotallight_direction[j], patch->totallight_direction[j]);
VectorCopy (addlight_direction[i][j], emitlight_direction[i][j]);
#endif
}
else
{
patch->totalstyle[j] = 255;
}
}
#else
#ifdef ZHLT_TEXLIGHT
//LRC
for (j = 0; j < MAXLIGHTMAPS && patch->totalstyle[j] != 255; j++)
{
VectorAdd(patch->totallight[j], addlight[i][j], patch->totallight[j]);
#ifdef HLRAD_TRANSFERDATA_COMPRESS
VectorCopy(addlight[i][j], emitlight[i][j]);
#else
VectorScale(addlight[i][j], TRANSFER_SCALE, emitlight[i][j]);
#endif
VectorClear(addlight[i][j]);
}
#else
VectorAdd(patch->totallight, addlight[i], patch->totallight);
#ifdef HLRAD_TRANSFERDATA_COMPRESS
VectorCopy(addlight[i], emitlight[i]);
#else
VectorScale(addlight[i], TRANSFER_SCALE, emitlight[i]);
#endif
VectorClear(addlight[i]);
#endif
#endif
}
}
// =====================================================================================
// GatherLight
// Get light from other g_patches
// Run multi-threaded
// =====================================================================================
#ifdef SYSTEM_WIN32
#pragma warning(push)
#pragma warning(disable: 4100) // unreferenced formal parameter
#endif
static void GatherLight(int threadnum)
{
int j;
patch_t* patch;
#ifdef ZHLT_TEXLIGHT
unsigned k,m; //LRC
//LRC vec3_t sum;
#else
unsigned k;
vec3_t sum;
#endif
unsigned iIndex;
transfer_data_t* tData;
transfer_index_t* tIndex;
#ifdef HLRAD_TRANSFERDATA_COMPRESS
float f;
#endif
#ifdef HLRAD_STYLE_CORING
#ifdef ZHLT_TEXLIGHT
#ifndef HLRAD_AUTOCORING
int style_index;
#endif
vec3_t adds[ALLSTYLES];
#ifdef ZHLT_XASH
vec3_t adds_direction[ALLSTYLES];
#endif
int style;
#endif
#endif
#ifdef HLRAD_OPAQUE_STYLE_BOUNCE
unsigned int fastfind_index = 0;
#endif
while (1)
{
j = GetThreadWork();
if (j == -1)
{
break;
}
#ifdef HLRAD_STYLE_CORING
#ifdef ZHLT_TEXLIGHT
memset (adds, 0, ALLSTYLES * sizeof(vec3_t));
#ifdef ZHLT_XASH
memset (adds_direction, 0, ALLSTYLES * sizeof (vec3_t));
#endif
#endif
#endif
patch = &g_patches[j];
tData = patch->tData;
tIndex = patch->tIndex;
iIndex = patch->iIndex;
#ifdef ZHLT_TEXLIGHT
#ifndef HLRAD_AUTOCORING
//LRC
for (m = 0; m < MAXLIGHTMAPS && patch->totalstyle[m] != 255; m++)
{
VectorClear(addlight[j][m]);
}
#endif
#else
VectorClear(sum);
#endif
#ifdef HLRAD_AUTOCORING
for (m = 0; m < MAXLIGHTMAPS && patch->totalstyle[m] != 255; m++)
{
VectorAdd (adds[patch->totalstyle[m]], patch->totallight[m], adds[patch->totalstyle[m]]);
#ifdef ZHLT_XASH
VectorAdd (adds_direction[patch->totalstyle[m]], patch->totallight_direction[m], adds_direction[patch->totalstyle[m]]);
#endif
}
#endif
#ifdef ZHLT_XASH
#ifdef HLRAD_TRANSLUCENT
const vec3_t &patchnormal = getPlaneFromFaceNumber (patch->faceNumber)->normal;
#endif
#endif
for (k = 0; k < iIndex; k++, tIndex++)
{
unsigned l;
unsigned size = (tIndex->size + 1);
unsigned patchnum = tIndex->index;
#ifdef HLRAD_TRANSFERDATA_COMPRESS
for (l = 0; l < size; l++, tData+=float_size[g_transfer_compress_type], patchnum++)
#else
for (l = 0; l < size; l++, tData++, patchnum++)
#endif
{
vec3_t v;
#ifdef ZHLT_TEXLIGHT
//LRC:
patch_t* emitpatch = &g_patches[patchnum];
unsigned emitstyle;
#ifdef HLRAD_OPAQUE_STYLE_BOUNCE
int opaquestyle = -1;
GetStyle (j, patchnum, opaquestyle, fastfind_index);
#endif
#ifdef HLRAD_TRANSFERDATA_COMPRESS
float_decompress (g_transfer_compress_type, tData, &f);
#endif
#ifdef ZHLT_XASH
vec3_t direction;
VectorSubtract (patch->origin, emitpatch->origin, direction);
VectorNormalize (direction);
#ifdef HLRAD_TRANSLUCENT
vec_t dot = DotProduct (direction, patchnormal);
if (dot > 0)
{
// reflect the direction back
VectorMA (direction, -dot * 2, patchnormal, direction);
}
#endif
#endif
// for each style on the emitting patch
#ifdef HLRAD_AUTOCORING
for (emitstyle = 0; emitstyle < MAXLIGHTMAPS && emitpatch->directstyle[emitstyle] != 255; emitstyle++)
{
#ifdef HLRAD_TRANSFERDATA_COMPRESS
VectorScale(emitpatch->directlight[emitstyle], f, v);
#else
VectorScale(emitpatch->directlight[emitstyle], (*tData) * TRANSFER_SCALE, v);
#endif
#ifdef HLRAD_REFLECTIVITY
VectorMultiply(v, emitpatch->bouncereflectivity, v);
#endif
if (isPointFinite (v))
{
#ifdef HLRAD_OPAQUE_STYLE_BOUNCE
int addstyle = emitpatch->directstyle[emitstyle];
#ifdef HLRAD_BOUNCE_STYLE
if (emitpatch->bouncestyle != -1)
{
if (addstyle == 0 || addstyle == emitpatch->bouncestyle)
addstyle = emitpatch->bouncestyle;
else
continue;
}
#endif
if (opaquestyle != -1)
{
if (addstyle == 0 || addstyle == opaquestyle)
addstyle = opaquestyle;
else
continue;
}
VectorAdd(adds[addstyle], v, adds[addstyle]);
#ifdef ZHLT_XASH
vec_t brightness = VectorAvg (v);
VectorMA (adds_direction[addstyle], brightness, direction, adds_direction[addstyle]);
#endif
#else
VectorAdd(adds[emitpatch->directstyle[emitstyle]], v, adds[emitpatch->directstyle[emitstyle]]);
#ifdef ZHLT_XASH
vec_t brightness = VectorAvg (v);
VectorMA (adds_direction[emitpatch->directstyle[emitstyle]], brightness, direction, adds_direction[emitpatch->directstyle[emitstyle]]);
#endif
#endif
}
}
#endif
for (emitstyle = 0; emitstyle < MAXLIGHTMAPS && emitpatch->totalstyle[emitstyle] != 255; emitstyle++)
{
#ifdef HLRAD_STYLE_CORING
#ifdef HLRAD_TRANSFERDATA_COMPRESS
VectorScale(emitlight[patchnum][emitstyle], f, v);
#else
#ifdef HLRAD_AUTOCORING
VectorScale(emitlight[patchnum][emitstyle], (*tData) * TRANSFER_SCALE, v);
#else
VectorScale(emitlight[patchnum][emitstyle], (*tData), v);
#endif
#endif
#ifdef HLRAD_REFLECTIVITY
VectorMultiply(v, emitpatch->bouncereflectivity, v);
#endif
if (isPointFinite(v))
{
#ifdef HLRAD_OPAQUE_STYLE_BOUNCE
int addstyle = emitpatch->totalstyle[emitstyle];
#ifdef HLRAD_BOUNCE_STYLE
if (emitpatch->bouncestyle != -1)
{
if (addstyle == 0 || addstyle == emitpatch->bouncestyle)
addstyle = emitpatch->bouncestyle;
else
continue;
}
#endif
if (opaquestyle != -1)
{
if (addstyle == 0 || addstyle == opaquestyle)
addstyle = opaquestyle;
else
continue;
}
VectorAdd(adds[addstyle], v, adds[addstyle]);
#ifdef ZHLT_XASH
vec_t brightness = VectorAvg (v);
VectorMA (adds_direction[addstyle], brightness, direction, adds_direction[addstyle]);
#endif
#else
VectorAdd(adds[emitpatch->totalstyle[emitstyle]], v, adds[emitpatch->totalstyle[emitstyle]]);
#ifdef ZHLT_XASH
vec_t brightness = VectorAvg (v);
VectorMA (adds_direction[emitpatch->totalstyle[emitstyle]], brightness, direction, adds_direction[emitpatch->totalstyle[emitstyle]]);
#endif
#endif
}
else
{
Verbose("GatherLight, v (%4.3f %4.3f %4.3f)@(%4.3f %4.3f %4.3f)\n",
v[0], v[1], v[2], patch->origin[0], patch->origin[1], patch->origin[2]);
}
#else
// find the matching style on this (destination) patch
for (m = 0; m < MAXLIGHTMAPS && patch->totalstyle[m] != 255; m++)
{
if (patch->totalstyle[m] == emitpatch->totalstyle[emitstyle])
{
break;
}
}
if (m == MAXLIGHTMAPS)
{
#ifdef HLRAD_READABLE_EXCEEDSTYLEWARNING
if (++stylewarningcount >= stylewarningnext)
{
stylewarningnext = stylewarningcount * 2;
Warning("Too many direct light styles on a face(?,?,?)");
Warning(" total %d warnings for too many styles", stylewarningcount);
}
#else
Warning("Too many direct light styles on a face(?,?,?)");
#endif
}
else
{
if (patch->totalstyle[m] == 255)
{
patch->totalstyle[m] = emitpatch->totalstyle[emitstyle];
// Log("Granting new style %d to patch at idx %d\n", patch->totalstyle[m], m);
}
#ifdef HLRAD_TRANSFERDATA_COMPRESS
float_decompress (g_transfer_compress_type, tData, &f);
VectorScale(emitlight[patchnum][emitstyle], f, v);
#else
VectorScale(emitlight[patchnum][emitstyle], (*tData), v);
#endif
#ifdef HLRAD_REFLECTIVITY
VectorMultiply(v, emitpatch->bouncereflectivity, v);
#endif
if (isPointFinite(v))
{
VectorAdd(addlight[j][m], v, addlight[j][m]);
}
else
{
Verbose("GatherLight, v (%4.3f %4.3f %4.3f)@(%4.3f %4.3f %4.3f)\n",
v[0], v[1], v[2], patch->origin[0], patch->origin[1], patch->origin[2]);
}
}
#endif
}
//LRC (ends)
#else
#ifdef HLRAD_TRANSFERDATA_COMPRESS
float_decompress (g_transfer_compress_type, tData, &f);
VectorScale(emitlight[patchnum], f, v);
#else
VectorScale(emitlight[patchnum], (*tData), v);
#endif
#ifdef HLRAD_REFLECTIVITY
VectorMultiply(v, emitpatch->bouncereflectivity, v);
#endif
if (isPointFinite(v))
{
VectorAdd(sum, v, sum);
}
else
{
Verbose("GatherLight, v (%4.3f %4.3f %4.3f)@(%4.3f %4.3f %4.3f)\n",
v[0], v[1], v[2], patch->origin[0], patch->origin[1], patch->origin[2]);
}
#endif
}
}
#ifdef HLRAD_AUTOCORING
vec_t maxlights[ALLSTYLES];
for (style = 0; style < ALLSTYLES; style++)
{
maxlights[style] = VectorMaximum (adds[style]);
}
for (m = 0; m < MAXLIGHTMAPS; m++)
{
unsigned char beststyle = 255;
if (m == 0)
{
beststyle = 0;
}
else
{
vec_t bestmaxlight = 0;
for (style = 1; style < ALLSTYLES; style++)
{
if (maxlights[style] > bestmaxlight + NORMAL_EPSILON)
{
bestmaxlight = maxlights[style];
beststyle = style;
}
}
}
if (beststyle != 255)
{
maxlights[beststyle] = 0;
newstyles[j][m] = beststyle;
VectorCopy (adds[beststyle], addlight[j][m]);
#ifdef ZHLT_XASH
VectorCopy (adds_direction[beststyle], addlight_direction[j][m]);
#endif
}
else
{
newstyles[j][m] = 255;
}
}
for (style = 1; style < ALLSTYLES; style++)
{
if (maxlights[style] > g_maxdiscardedlight + NORMAL_EPSILON)
{
ThreadLock ();
if (maxlights[style] > g_maxdiscardedlight + NORMAL_EPSILON)
{
g_maxdiscardedlight = maxlights[style];
VectorCopy (patch->origin, g_maxdiscardedpos);
}
ThreadUnlock ();
}
}
#else
#ifdef ZHLT_TEXLIGHT
//LRC VectorCopy(sum, addlight[j]);
#ifdef HLRAD_STYLE_CORING
for (style = 0; style < ALLSTYLES; ++style)
{
if (VectorMaximum(adds[style]) > g_corings[style] * BOUNCE_CORING_SCALE)
{
for (style_index = 0; style_index < MAXLIGHTMAPS; style_index++)
{
if (patch->totalstyle[style_index] == style || patch->totalstyle[style_index] == 255)
{
break;
}
}
if (style_index == MAXLIGHTMAPS)
{
#ifdef HLRAD_READABLE_EXCEEDSTYLEWARNING
if (++stylewarningcount >= stylewarningnext)
{
stylewarningnext = stylewarningcount * 2;
Warning("Too many indirect light styles on a face(%f,%f,%f)", patch->origin[0], patch->origin[1], patch->origin[2]);
Warning(" total %d warnings for too many styles", stylewarningcount);
}
#else
Warning("Too many indirect light styles on a face(%f,%f,%f)", patch->origin[0], patch->origin[1], patch->origin[2]);
#endif
}
else
{
if (patch->totalstyle[style_index] == 255)
{
patch->totalstyle[style_index] = style;
}
VectorAdd(addlight[j][style_index], adds[style], addlight[j][style_index]);
}
}
}
#endif
#else
VectorCopy(sum, addlight[j]);
#endif
#endif
}
}
// RGB Transfer version
#ifdef HLRAD_HULLU
static void GatherRGBLight(int threadnum)
{
int j;
patch_t* patch;
#ifdef ZHLT_TEXLIGHT
unsigned k,m; //LRC
//LRC vec3_t sum;
#else
unsigned k;
vec3_t sum;
#endif
unsigned iIndex;
rgb_transfer_data_t* tRGBData;
transfer_index_t* tIndex;
#ifdef HLRAD_TRANSFERDATA_COMPRESS
float f[3];
#endif
#ifdef HLRAD_STYLE_CORING
#ifdef ZHLT_TEXLIGHT
#ifndef HLRAD_AUTOCORING
int style_index;
#endif
vec3_t adds[ALLSTYLES];
#ifdef ZHLT_XASH
vec3_t adds_direction[ALLSTYLES];
#endif
int style;
#endif
#endif
#ifdef HLRAD_OPAQUE_STYLE_BOUNCE
unsigned int fastfind_index = 0;
#endif
while (1)
{
j = GetThreadWork();
if (j == -1)
{
break;
}
#ifdef HLRAD_STYLE_CORING
#ifdef ZHLT_TEXLIGHT
memset (adds, 0, ALLSTYLES * sizeof(vec3_t));
#ifdef ZHLT_XASH
memset (adds_direction, 0, ALLSTYLES * sizeof (vec3_t));
#endif
#endif
#endif
patch = &g_patches[j];
tRGBData = patch->tRGBData;
tIndex = patch->tIndex;
iIndex = patch->iIndex;
#ifdef ZHLT_TEXLIGHT
#ifndef HLRAD_AUTOCORING
//LRC
for (m = 0; m < MAXLIGHTMAPS && patch->totalstyle[m] != 255; m++)
{
VectorClear(addlight[j][m]);
}
#endif
#else
VectorClear(sum);
#endif
#ifdef HLRAD_AUTOCORING
for (m = 0; m < MAXLIGHTMAPS && patch->totalstyle[m] != 255; m++)
{
VectorAdd (adds[patch->totalstyle[m]], patch->totallight[m], adds[patch->totalstyle[m]]);
#ifdef ZHLT_XASH
VectorAdd (adds_direction[patch->totalstyle[m]], patch->totallight_direction[m], adds_direction[patch->totalstyle[m]]);
#endif
}
#endif
#ifdef ZHLT_XASH
#ifdef HLRAD_TRANSLUCENT
const vec3_t &patchnormal = getPlaneFromFaceNumber (patch->faceNumber)->normal;
#endif
#endif
for (k = 0; k < iIndex; k++, tIndex++)
{
unsigned l;
unsigned size = (tIndex->size + 1);
unsigned patchnum = tIndex->index;
#ifdef HLRAD_TRANSFERDATA_COMPRESS
for (l = 0; l < size; l++, tRGBData+=vector_size[g_rgbtransfer_compress_type], patchnum++)
#else
for (l = 0; l < size; l++, tRGBData++, patchnum++)
#endif
{
vec3_t v;
#ifdef ZHLT_TEXLIGHT
//LRC:
patch_t* emitpatch = &g_patches[patchnum];
unsigned emitstyle;
#ifdef HLRAD_OPAQUE_STYLE_BOUNCE
int opaquestyle = -1;
GetStyle (j, patchnum, opaquestyle, fastfind_index);
#endif
#ifdef HLRAD_TRANSFERDATA_COMPRESS
vector_decompress (g_rgbtransfer_compress_type, tRGBData, &f[0], &f[1], &f[2]);
#endif
#ifdef ZHLT_XASH
vec3_t direction;
VectorSubtract (patch->origin, emitpatch->origin, direction);
VectorNormalize (direction);
#ifdef HLRAD_TRANSLUCENT
vec_t dot = DotProduct (direction, patchnormal);
if (dot > 0)
{
// reflect the direction back
VectorMA (direction, -dot * 2, patchnormal, direction);
}
#endif
#endif
// for each style on the emitting patch
#ifdef HLRAD_AUTOCORING
for (emitstyle = 0; emitstyle < MAXLIGHTMAPS && emitpatch->directstyle[emitstyle] != 255; emitstyle++)
{
#ifdef HLRAD_TRANSFERDATA_COMPRESS
VectorMultiply(emitpatch->directlight[emitstyle], f, v);
#else
VectorMultiply(emitpatch->directlight[emitstyle], (*tRGBData), v);
VectorScale(v, TRANSFER_SCALE, v);
#endif
#ifdef HLRAD_REFLECTIVITY
VectorMultiply(v, emitpatch->bouncereflectivity, v);
#endif
if (isPointFinite (v))
{
#ifdef HLRAD_OPAQUE_STYLE_BOUNCE
int addstyle = emitpatch->directstyle[emitstyle];
#ifdef HLRAD_BOUNCE_STYLE
if (emitpatch->bouncestyle != -1)
{
if (addstyle == 0 || addstyle == emitpatch->bouncestyle)
addstyle = emitpatch->bouncestyle;
else
continue;
}
#endif
if (opaquestyle != -1)
{
if (addstyle == 0 || addstyle == opaquestyle)
addstyle = opaquestyle;
else
continue;
}
VectorAdd(adds[addstyle], v, adds[addstyle]);
#ifdef ZHLT_XASH
vec_t brightness = VectorAvg (v);
VectorMA (adds_direction[addstyle], brightness, direction, adds_direction[addstyle]);
#endif
#else
VectorAdd(adds[emitpatch->directstyle[emitstyle]], v, adds[emitpatch->directstyle[emitstyle]]);
#ifdef ZHLT_XASH
vec_t brightness = VectorAvg (v);
VectorMA (adds_direction[emitpatch->directstyle[emitstyle]], brightness, direction, adds_direction[emitpatch->directstyle[emitstyle]]);
#endif
#endif
}
}
#endif
for (emitstyle = 0; emitstyle < MAXLIGHTMAPS && emitpatch->totalstyle[emitstyle] != 255; emitstyle++)
{
#ifdef HLRAD_STYLE_CORING
#ifdef HLRAD_TRANSFERDATA_COMPRESS
VectorMultiply(emitlight[patchnum][emitstyle], f, v);
#else
#ifdef HLRAD_AUTOCORING
VectorMultiply(emitlight[patchnum][emitstyle], (*tRGBData), v);
VectorScale(v, TRANSFER_SCALE, v);
#else
VectorMultiply(emitlight[patchnum][emitstyle], (*tRGBData), v);
#endif
#endif
#ifdef HLRAD_REFLECTIVITY
VectorMultiply(v, emitpatch->bouncereflectivity, v);
#endif
if (isPointFinite(v))
{
#ifdef HLRAD_OPAQUE_STYLE_BOUNCE
int addstyle = emitpatch->totalstyle[emitstyle];
#ifdef HLRAD_BOUNCE_STYLE
if (emitpatch->bouncestyle != -1)
{
if (addstyle == 0 || addstyle == emitpatch->bouncestyle)
addstyle = emitpatch->bouncestyle;
else
continue;
}
#endif
if (opaquestyle != -1)
{
if (addstyle == 0 || addstyle == opaquestyle)
addstyle = opaquestyle;
else
continue;
}
VectorAdd(adds[addstyle], v, adds[addstyle]);
#ifdef ZHLT_XASH
vec_t brightness = VectorAvg (v);
VectorMA (adds_direction[addstyle], brightness, direction, adds_direction[addstyle]);
#endif
#else
VectorAdd(adds[emitpatch->totalstyle[emitstyle]], v, adds[emitpatch->totalstyle[emitstyle]]);
#ifdef ZHLT_XASH
vec_t brightness = VectorAvg (v);
VectorMA (adds_direction[emitpatch->totalstyle[emitstyle]], brightness, direction, adds_direction[emitpatch->totalstyle[emitstyle]]);
#endif
#endif
}
else
{
Verbose("GatherLight, v (%4.3f %4.3f %4.3f)@(%4.3f %4.3f %4.3f)\n",
v[0], v[1], v[2], patch->origin[0], patch->origin[1], patch->origin[2]);
}
#else
// find the matching style on this (destination) patch
for (m = 0; m < MAXLIGHTMAPS && patch->totalstyle[m] != 255; m++)
{
if (patch->totalstyle[m] == emitpatch->totalstyle[emitstyle])
{
break;
}
}
if (m == MAXLIGHTMAPS)
{
#ifdef HLRAD_READABLE_EXCEEDSTYLEWARNING
if (++stylewarningcount >= stylewarningnext)
{
stylewarningnext = stylewarningcount * 2;
Warning("Too many direct light styles on a face(?,?,?)");
Warning(" total %d warnings for too many styles", stylewarningcount);
}
#else
Warning("Too many direct light styles on a face(?,?,?)");
#endif
}
else
{
if (patch->totalstyle[m] == 255)
{
patch->totalstyle[m] = emitpatch->totalstyle[emitstyle];
// Log("Granting new style %d to patch at idx %d\n", patch->totalstyle[m], m);
}
#ifdef HLRAD_TRANSFERDATA_COMPRESS
vector_decompress (g_rgbtransfer_compress_type, tRGBData, &f[0], &f[1], &f[2]);
VectorMultiply(emitlight[patchnum][emitstyle], f, v);
#else
VectorMultiply(emitlight[patchnum][emitstyle], (*tRGBData), v);
#endif
#ifdef HLRAD_REFLECTIVITY
VectorMultiply(v, emitpatch->bouncereflectivity, v);
#endif
if (isPointFinite(v))
{
VectorAdd(addlight[j][m], v, addlight[j][m]);
}
else
{
Verbose("GatherLight, v (%4.3f %4.3f %4.3f)@(%4.3f %4.3f %4.3f)\n",
v[0], v[1], v[2], patch->origin[0], patch->origin[1], patch->origin[2]);
}
}
#endif
}
//LRC (ends)
#else
#ifdef HLRAD_TRANSFERDATA_COMPRESS
vector_decompress (g_rgbtransfer_compress_type, tRGBData, &f[0], &f[1], &f[2]);
VectorMultiply(emitlight[patchnum], (*tRGBData), v);
#else
VectorMultiply(emitlight[patchnum], (*tRGBData), v);
#endif
#ifdef HLRAD_REFLECTIVITY
VectorMultiply(v, emitpatch->bouncereflectivity, v);
#endif
if (isPointFinite(v))
{
VectorAdd(sum, v, sum);
}
else
{
Verbose("GatherLight, v (%4.3f %4.3f %4.3f)@(%4.3f %4.3f %4.3f)\n",
v[0], v[1], v[2], patch->origin[0], patch->origin[1], patch->origin[2]);
}
#endif
}
}
#ifdef HLRAD_AUTOCORING
vec_t maxlights[ALLSTYLES];
for (style = 0; style < ALLSTYLES; style++)
{
maxlights[style] = VectorMaximum (adds[style]);
}
for (m = 0; m < MAXLIGHTMAPS; m++)
{
unsigned char beststyle = 255;
if (m == 0)
{
beststyle = 0;
}
else
{
vec_t bestmaxlight = 0;
for (style = 1; style < ALLSTYLES; style++)
{
if (maxlights[style] > bestmaxlight + NORMAL_EPSILON)
{
bestmaxlight = maxlights[style];
beststyle = style;
}
}
}
if (beststyle != 255)
{
maxlights[beststyle] = 0;
newstyles[j][m] = beststyle;
VectorCopy (adds[beststyle], addlight[j][m]);
#ifdef ZHLT_XASH
VectorCopy (adds_direction[beststyle], addlight_direction[j][m]);
#endif
}
else
{
newstyles[j][m] = 255;
}
}
for (style = 1; style < ALLSTYLES; style++)
{
if (maxlights[style] > g_maxdiscardedlight + NORMAL_EPSILON)
{
ThreadLock ();
if (maxlights[style] > g_maxdiscardedlight + NORMAL_EPSILON)
{
g_maxdiscardedlight = maxlights[style];
VectorCopy (patch->origin, g_maxdiscardedpos);
}
ThreadUnlock ();
}
}
#else
#ifdef ZHLT_TEXLIGHT
//LRC VectorCopy(sum, addlight[j]);
#ifdef HLRAD_STYLE_CORING
for (style = 0; style < ALLSTYLES; ++style)
{
if (VectorMaximum(adds[style]) > g_corings[style] * BOUNCE_CORING_SCALE)
{
for (style_index = 0; style_index < MAXLIGHTMAPS; style_index++)
{
if (patch->totalstyle[style_index] == style || patch->totalstyle[style_index] == 255)
{
break;
}
}
if (style_index == MAXLIGHTMAPS)
{
#ifdef HLRAD_READABLE_EXCEEDSTYLEWARNING
if (++stylewarningcount >= stylewarningnext)
{
stylewarningnext = stylewarningcount * 2;
Warning("Too many indirect light styles on a face(%f,%f,%f)", patch->origin[0], patch->origin[1], patch->origin[2]);
Warning(" total %d warnings for too many styles", stylewarningcount);
}
#else
Warning("Too many indirect light styles on a face(%f,%f,%f)", patch->origin[0], patch->origin[1], patch->origin[2]);
#endif
}
else
{
if (patch->totalstyle[style_index] == 255)
{
patch->totalstyle[style_index] = style;
}
VectorAdd(addlight[j][style_index], adds[style], addlight[j][style_index]);
}
}
}
#endif
#else
VectorCopy(sum, addlight[j]);
#endif
#endif
}
}
#endif
#ifdef SYSTEM_WIN32
#pragma warning(pop)
#endif
// =====================================================================================
// BounceLight
// =====================================================================================
static void BounceLight()
{
unsigned i;
char name[64];
#ifdef ZHLT_TEXLIGHT
unsigned j; //LRC
#endif
for (i = 0; i < g_num_patches; i++)
{
#ifdef HLRAD_AUTOCORING
patch_t *patch = &g_patches[i];
for (j = 0; j < MAXLIGHTMAPS && patch->totalstyle[j] != 255; j++)
{
VectorCopy (patch->totallight[j], emitlight[i][j]);
#ifdef ZHLT_XASH
VectorCopy (patch->totallight_direction[j], emitlight_direction[i][j]);
#endif
}
#else
#ifdef ZHLT_TEXLIGHT
//LRC
for (j = 0; j < MAXLIGHTMAPS && g_patches[i].totalstyle[j] != 255; j++)
{
#ifdef HLRAD_TRANSFERDATA_COMPRESS
VectorCopy(g_patches[i].totallight[j], emitlight[i][j]);
#else
VectorScale(g_patches[i].totallight[j], TRANSFER_SCALE, emitlight[i][j]);
#endif
}
#else
#ifdef HLRAD_TRANSFERDATA_COMPRESS
VectorCopy(g_patches[i].totallight, emitlight[i]);
#else
VectorScale(g_patches[i].totallight, TRANSFER_SCALE, emitlight[i]);
#endif
#endif
#endif
}
for (i = 0; i < g_numbounce; i++)
{
#ifdef ZHLT_CONSOLE
Log("Bounce %u ", i + 1);
#else
printf("Bounce %u ", i + 1);
#endif
#ifdef HLRAD_HULLU
if(g_rgb_transfers)
{NamedRunThreadsOn(g_num_patches, g_estimate, GatherRGBLight);}
else
{NamedRunThreadsOn(g_num_patches, g_estimate, GatherLight);}
#else
NamedRunThreadsOn(g_num_patches, g_estimate, GatherLight);
#endif
CollectLight();
if (g_dumppatches)
{
sprintf(name, "bounce%u.txt", i);
WriteWorld(name);
}
}
#ifdef HLRAD_AUTOCORING
for (i = 0; i < g_num_patches; i++)
{
patch_t *patch = &g_patches[i];
for (j = 0; j < MAXLIGHTMAPS && patch->totalstyle[j] != 255; j++)
{
VectorCopy (emitlight[i][j], patch->totallight[j]);
#ifdef ZHLT_XASH
VectorCopy (emitlight_direction[i][j], patch->totallight_direction[j]);
#endif
}
}
#endif
}
// =====================================================================================
// CheckMaxPatches
// =====================================================================================
static void CheckMaxPatches()
{
switch (g_method)
{
case eMethodVismatrix:
hlassume(g_num_patches < MAX_VISMATRIX_PATCHES, assume_MAX_PATCHES); // should use "<=" instead. --vluzacn
break;
case eMethodSparseVismatrix:
hlassume(g_num_patches < MAX_SPARSE_VISMATRIX_PATCHES, assume_MAX_PATCHES);
break;
case eMethodNoVismatrix:
hlassume(g_num_patches < MAX_PATCHES, assume_MAX_PATCHES);
break;
}
}
// =====================================================================================
// MakeScalesStub
// =====================================================================================
static void MakeScalesStub()
{
switch (g_method)
{
case eMethodVismatrix:
MakeScalesVismatrix();
break;
case eMethodSparseVismatrix:
MakeScalesSparseVismatrix();
break;
case eMethodNoVismatrix:
MakeScalesNoVismatrix();
break;
}
}
// =====================================================================================
// FreeTransfers
// =====================================================================================
static void FreeTransfers()
{
unsigned x;
patch_t* patch = g_patches;
for (x = 0; x < g_num_patches; x++, patch++)
{
if (patch->tData)
{
FreeBlock(patch->tData);
patch->tData = NULL;
}
#ifdef HLRAD_HULLU
if (patch->tRGBData)
{
FreeBlock(patch->tRGBData);
patch->tRGBData = NULL;
}
#endif
if (patch->tIndex)
{
FreeBlock(patch->tIndex);
patch->tIndex = NULL;
}
}
}
#ifdef ZHLT_XASH
vec_t FindDirectionScale (vec_t gamma)
// gamma 0.55(default) 0.6 0.7 0.8 0.9 1.0 0.5 0.4 0.3 0.2 0.1
// returned value 0.266 0.313 0.424 0.565 0.751 1.000 0.225 0.155 0.099 0.055 0.023
{
if (gamma >= 1.0 - NORMAL_EPSILON)
{
return 1.0;
}
if (gamma < NORMAL_EPSILON)
{
return 0.0;
}
int numsteps = 200;
vec_t testmax = 2.0;
vec3_t staticlight;
vec3_t dynamiclight;
vec_t maxlength = 1;
int maxlength_i = -1;
int maxlength_j = -1;
int i, j;
for (i = 0; i < numsteps; i++)
{
for (j = 0; j < numsteps; j++)
{
vec_t directionlength;
staticlight[0] = 1.0;
staticlight[2] = staticlight[1] = testmax * (vec_t)i / (vec_t)numsteps;
dynamiclight[0] = testmax * (vec_t)j / (vec_t)numsteps;
dynamiclight[2] = dynamiclight[1] = 0.0;
{
vec3_t finalstaticlight, finaldynamiclight;
directionlength = (VectorAvg (staticlight) * 1.0 + VectorAvg (dynamiclight) * (-1.0)) / (VectorAvg (staticlight) + VectorAvg (dynamiclight));
for (int k = 0; k < 3; k++)
{
finalstaticlight[k] = pow (staticlight[k], gamma);
finaldynamiclight[k] = pow (staticlight[k] + dynamiclight[k], gamma) - finalstaticlight[k];
}
if (VectorAvg (finaldynamiclight) < NORMAL_EPSILON)
{
continue;
}
directionlength = (VectorAvg (finalstaticlight) + VectorAvg (finaldynamiclight)) * directionlength;
directionlength = fabs ((directionlength - VectorAvg (finalstaticlight) * 1.0) / VectorAvg (finaldynamiclight));
}
if (directionlength > maxlength)
{
maxlength = directionlength;
maxlength_i = i;
maxlength_j = j;
}
}
}
Developer (DEVELOPER_LEVEL_MESSAGE, "maxlength = %f i = %d j = %d\n", maxlength, maxlength_i, maxlength_j);
return 1 / maxlength;
}
#endif
#ifdef ZHLT_EMBEDLIGHTMAP
static void ExtendLightmapBuffer ()
{
int maxsize;
int i;
int j;
int ofs;
dface_t *f;
maxsize = 0;
for (i = 0; i < g_numfaces; i++)
{
f = &g_dfaces[i];
if (f->lightofs >= 0)
{
ofs = f->lightofs;
for (j = 0; j < MAXLIGHTMAPS && f->styles[j] != 255; j++)
{
ofs += (MAX_SURFACE_EXTENT + 1) * (MAX_SURFACE_EXTENT + 1) * 3;
}
if (ofs > maxsize)
{
maxsize = ofs;
}
}
}
if (maxsize >= g_lightdatasize)
{
hlassume (maxsize <= g_max_map_lightdata, assume_MAX_MAP_LIGHTING);
memset (&g_dlightdata[g_lightdatasize], 0, maxsize - g_lightdatasize);
g_lightdatasize = maxsize;
#ifdef ZHLT_XASH
hlassume (maxsize < g_max_map_dlitdata, assume_MAX_MAP_LIGHTING);
memset (&g_ddlitdata[g_dlitdatasize], 0, maxsize - g_dlitdatasize);
g_dlitdatasize = maxsize;
#endif
}
}
#endif
// =====================================================================================
// RadWorld
// =====================================================================================
static void RadWorld()
{
unsigned i;
#ifdef ZHLT_TEXLIGHT
unsigned j;
#endif
MakeBackplanes();
MakeParents(0, -1);
MakeTnodes(&g_dmodels[0]);
#ifdef HLRAD_OPAQUE_NODE
CreateOpaqueNodes();
LoadOpaqueEntities();
#endif
// turn each face into a single patch
MakePatches();
#ifdef HLRAD_DEBUG_DRAWPOINTS
if (g_drawpatch)
{
char name[_MAX_PATH+20];
sprintf (name, "%s_patch.pts", g_Mapname);
Log ("Writing '%s' ...\n", name);
FILE *f;
f = fopen(name, "w");
if (f)
{
const int pos_count = 15;
const vec3_t pos[pos_count] = {{0,0,0},{1,0,0},{0,1,0},{-1,0,0},{0,-1,0},{1,0,0},{0,0,1},{-1,0,0},{0,0,-1},{0,-1,0},{0,0,1},{0,1,0},{0,0,-1},{1,0,0},{0,0,0}};
int j, k;
patch_t *patch;
vec3_t v;
for (j = 0, patch = g_patches; j < g_num_patches; j++, patch++)
{
if (patch->flags == ePatchFlagOutside)
continue;
VectorCopy (patch->origin, v);
for (k = 0; k < pos_count; ++k)
fprintf (f, "%g %g %g\n", v[0]+pos[k][0], v[1]+pos[k][1], v[2]+pos[k][2]);
}
fclose(f);
Log ("OK.\n");
}
else
Log ("Error.\n");
}
#endif
CheckMaxPatches(); // Check here for exceeding max patches, to prevent a lot of work from occuring before an error occurs
SortPatches(); // Makes the runs in the Transfer Compression really good
PairEdges();
#ifdef HLRAD_DEBUG_DRAWPOINTS
if (g_drawedge)
{
char name[_MAX_PATH+20];
sprintf (name, "%s_edge.pts", g_Mapname);
Log ("Writing '%s' ...\n", name);
FILE *f;
f = fopen(name, "w");
if (f)
{
const int pos_count = 15;
const vec3_t pos[pos_count] = {{0,0,0},{1,0,0},{0,1,0},{-1,0,0},{0,-1,0},{1,0,0},{0,0,1},{-1,0,0},{0,0,-1},{0,-1,0},{0,0,1},{0,1,0},{0,0,-1},{1,0,0},{0,0,0}};
int j, k;
edgeshare_t *es;
vec3_t v;
for (j = 0, es = g_edgeshare; j < MAX_MAP_EDGES; j++, es++)
{
#ifdef HLRAD_GetPhongNormal_VL
if (es->smooth)
#else
if (es->coplanar || !VectorCompare (es->interface_normal, vec3_origin))
#endif
{
int v0 = g_dedges[j].v[0], v1 = g_dedges[j].v[1];
VectorAdd (g_dvertexes[v0].point, g_dvertexes[v1].point, v);
VectorScale (v, 0.5, v);
VectorAdd (v, es->interface_normal, v);
VectorAdd (v, g_face_offset[es->faces[0] - g_dfaces], v);
for (k = 0; k < pos_count; ++k)
fprintf (f, "%g %g %g\n", v[0]+pos[k][0], v[1]+pos[k][1], v[2]+pos[k][2]);
}
}
fclose(f);
Log ("OK.\n");
}
else
Log ("Error.\n");
}
#endif
#ifdef HLRAD_SOFTSKY
BuildDiffuseNormals ();
#endif
// create directlights out of g_patches and lights
CreateDirectLights();
Log("\n");
#ifdef HLRAD_GROWSAMPLE
// generate a position map for each face
NamedRunThreadsOnIndividual(g_numfaces, g_estimate, FindFacePositions);
#endif
// build initial facelights
NamedRunThreadsOnIndividual(g_numfaces, g_estimate, BuildFacelights);
#ifdef HLRAD_GROWSAMPLE
FreePositionMaps ();
#endif
// free up the direct lights now that we have facelights
DeleteDirectLights();
if (g_numbounce > 0)
{
// build transfer lists
MakeScalesStub();
#ifdef HLRAD_MORE_PATCHES
// these arrays are only used in CollectLight, GatherLight and BounceLight
#ifdef ZHLT_TEXLIGHT
emitlight = (vec3_t (*)[MAXLIGHTMAPS])AllocBlock ((g_num_patches + 1) * sizeof (vec3_t [MAXLIGHTMAPS]));
addlight = (vec3_t (*)[MAXLIGHTMAPS])AllocBlock ((g_num_patches + 1) * sizeof (vec3_t [MAXLIGHTMAPS]));
#ifdef ZHLT_XASH
emitlight_direction = (vec3_t (*)[MAXLIGHTMAPS])AllocBlock ((g_num_patches + 1) * sizeof (vec3_t [MAXLIGHTMAPS]));
addlight_direction = (vec3_t (*)[MAXLIGHTMAPS])AllocBlock ((g_num_patches + 1) * sizeof (vec3_t [MAXLIGHTMAPS]));
#endif
#ifdef HLRAD_AUTOCORING
newstyles = (unsigned char (*)[MAXLIGHTMAPS])AllocBlock ((g_num_patches + 1) * sizeof (unsigned char [MAXLIGHTMAPS]));
#endif
#else
emitlight = (vec3_t *)AllocBlock ((g_num_patches + 1) * sizeof (vec3_t));
addlight = (vec3_t *)AllocBlock ((g_num_patches + 1) * sizeof (vec3_t));
#endif
#endif
// spread light around
BounceLight();
#ifndef HLRAD_AUTOCORING
for (i = 0; i < g_num_patches; i++)
{
#ifdef ZHLT_TEXLIGHT// AJM
for (j = 0; j < MAXLIGHTMAPS && g_patches[i].totalstyle[j] != 255; j++)
{
VectorSubtract(g_patches[i].totallight[j], g_patches[i].directlight[j], g_patches[i].totallight[j]);
}
#else
VectorSubtract(g_patches[i].totallight, g_patches[i].directlight, g_patches[i].totallight);
#endif
}
#endif
#ifdef HLRAD_MORE_PATCHES
#ifdef ZHLT_TEXLIGHT
FreeBlock (emitlight);
emitlight = NULL;
FreeBlock (addlight);
addlight = NULL;
#ifdef ZHLT_XASH
FreeBlock (emitlight_direction);
emitlight_direction = NULL;
FreeBlock (addlight_direction);
addlight_direction = NULL;
#endif
#ifdef HLRAD_AUTOCORING
FreeBlock (newstyles);
newstyles = NULL;
#endif
#else
FreeBlock (emitlight);
emitlight = NULL;
FreeBlock (addlight);
addlight = NULL;
#endif
#endif
}
#ifndef HLRAD_AUTOCORING
#ifdef HLRAD_GatherPatchLight
if (g_numbounce <= 0)
{
for (i = 0; i < g_num_patches; i++)
{
#ifdef ZHLT_TEXLIGHT// AJM
for (j = 0; j < MAXLIGHTMAPS && g_patches[i].totalstyle[j] != 255; j++)
{
VectorSubtract(g_patches[i].totallight[j], g_patches[i].directlight[j], g_patches[i].totallight[j]);
}
#else
VectorSubtract(g_patches[i].totallight, g_patches[i].directlight, g_patches[i].totallight);
#endif
}
}
#endif
#endif
FreeTransfers();
#ifdef HLRAD_OPAQUE_STYLE_BOUNCE
FreeStyleArrays ();
#endif
#ifdef HLRAD_LOCALTRIANGULATION
NamedRunThreadsOnIndividual (g_numfaces, g_estimate, CreateTriangulations);
#endif
// blend bounced light into direct light and save
PrecompLightmapOffsets();
#ifdef ZHLT_XASH
#ifdef HLRAD_WHOME
g_directionscale = FindDirectionScale (VectorAvg (g_colour_qgamma));
#else
g_directionscale = FindDirectionScale (g_qgamma);
#endif
#endif
#ifdef HLRAD_GROWSAMPLE
ScaleDirectLights ();
#ifndef HLRAD_GatherPatchLight
if (g_numbounce)
#endif
{
CreateFacelightDependencyList ();
NamedRunThreadsOnIndividual (g_numfaces, g_estimate, AddPatchLights);
FreeFacelightDependencyList ();
}
#endif
#ifdef HLRAD_LOCALTRIANGULATION
FreeTriangulations ();
#endif
NamedRunThreadsOnIndividual(g_numfaces, g_estimate, FinalLightFace);
#ifdef HLRAD_AUTOCORING
if (g_maxdiscardedlight > 0.01)
{
Verbose ("Maximum brightness loss (too many light styles on a face) = %f @(%f, %f, %f)\n", g_maxdiscardedlight, g_maxdiscardedpos[0], g_maxdiscardedpos[1], g_maxdiscardedpos[2]);
}
#endif
#ifdef HLRAD_MDL_LIGHT_HACK
MdlLightHack ();
#endif
#ifdef HLRAD_REDUCELIGHTMAP
ReduceLightmap();
if (g_lightdatasize == 0)
{
g_lightdatasize = 1;
g_dlightdata[0] = 0;
#ifdef ZHLT_XASH
g_dlitdatasize = 1;
g_ddlitdata[0] = 0;
#endif
}
#endif
#ifdef ZHLT_EMBEDLIGHTMAP
ExtendLightmapBuffer (); // expand the size of lightdata array (for a few KB) to ensure that game engine reads within its valid range
#endif
}
// =====================================================================================
// Usage
// =====================================================================================
static void Usage()
{
Banner();
Log("\n-= %s Options =-\n\n", g_Program);
#ifdef ZHLT_CONSOLE
Log(" -console # : Set to 0 to turn off the pop-up console (default is 1)\n");
#endif
#ifdef ZHLT_LANGFILE
Log(" -lang file : localization file\n");
#endif
#ifdef HLRAD_TEXTURE
Log(" -waddir folder : Search this folder for wad files.\n");
#endif
#ifdef HLRAD_FASTMODE
Log(" -fast : Fast rad\n");
#endif
#ifdef HLRAD_ARG_MISC
Log(" -vismatrix value: Set vismatrix method to normal, sparse or off .\n");
#else
Log(" -sparse : Enable low memory vismatrix algorithm\n");
Log(" -nomatrix : Disable usage of vismatrix entirely\n\n");
#endif
Log(" -extra : Improve lighting quality by doing 9 point oversampling\n");
Log(" -bounce # : Set number of radiosity bounces\n");
Log(" -ambient r g b : Set ambient world light (0.0 to 1.0, r g b)\n");
#ifndef HLRAD_FinalLightFace_VL
Log(" -maxlight # : Set maximum light intensity value\n");
#endif
#ifdef HLRAD_PRESERVELIGHTMAPCOLOR
Log(" -limiter # : Set light clipping threshold (-1=None)\n");
#endif
Log(" -circus : Enable 'circus' mode for locating unlit lightmaps\n");
#ifdef HLRAD_SUNSPREAD
Log(" -nospread : Disable sunlight spread angles for this compile\n");
#endif
Log(" -nopaque : Disable the opaque zhlt_lightflags for this compile\n\n");
Log(" -smooth # : Set smoothing threshold for blending (in degrees)\n");
#ifdef HLRAD_CUSTOMSMOOTH
Log(" -smooth2 # : Set smoothing threshold between different textures\n");
#endif
Log(" -chop # : Set radiosity patch size for normal textures\n");
Log(" -texchop # : Set radiosity patch size for texture light faces\n\n");
Log(" -notexscale : Do not scale radiosity patches with texture scale\n");
Log(" -coring # : Set lighting threshold before blackness\n");
Log(" -dlight # : Set direct lighting threshold\n");
Log(" -nolerp : Disable radiosity interpolation, nearest point instead\n\n");
Log(" -fade # : Set global fade (larger values = shorter lights)\n");
#ifndef HLRAD_ARG_MISC
Log(" -falloff # : Set global falloff mode (1 = inv linear, 2 = inv square)\n");
#endif
#ifdef HLRAD_TEXLIGHTGAP
Log(" -texlightgap # : Set global gap distance for texlights\n");
#endif
Log(" -scale # : Set global light scaling value\n");
Log(" -gamma # : Set global gamma value\n\n");
Log(" -sky # : Set ambient sunlight contribution in the shade outside\n");
Log(" -lights file : Manually specify a lights.rad file to use\n");
Log(" -noskyfix : Disable light_environment being global\n");
Log(" -incremental : Use or create an incremental transfer list file\n\n");
Log(" -dump : Dumps light patches to a file for hlrad debugging info\n\n");
Log(" -texdata # : Alter maximum texture memory limit (in kb)\n");
Log(" -lightdata # : Alter maximum lighting memory limit (in kb)\n"); //lightdata
Log(" -chart : display bsp statitics\n");
Log(" -low | -high : run program an altered priority level\n");
Log(" -nolog : Do not generate the compile logfiles\n");
Log(" -threads # : manually specify the number of threads to run\n");
#ifdef SYSTEM_WIN32
Log(" -estimate : display estimated time during compile\n");
#endif
#ifdef ZHLT_PROGRESSFILE // AJM
Log(" -progressfile path : specify the path to a file for progress estimate output\n");
#endif
#ifdef SYSTEM_POSIX
Log(" -noestimate : Do not display continuous compile time estimates\n");
#endif
Log(" -verbose : compile with verbose messages\n");
Log(" -noinfo : Do not show tool configuration information\n");
Log(" -dev # : compile with developer message\n\n");
// ------------------------------------------------------------------------
// Changes by Adam Foster - afoster@compsoc.man.ac.uk
#ifdef HLRAD_WHOME
// AJM: we dont need this extra crap
//Log("-= Unofficial features added by Adam Foster (afoster@compsoc.man.ac.uk) =-\n\n");
Log(" -colourgamma r g b : Sets different gamma values for r, g, b\n" );
Log(" -colourscale r g b : Sets different lightscale values for r, g ,b\n" );
Log(" -colourjitter r g b : Adds noise, independent colours, for dithering\n");
Log(" -jitter r g b : Adds noise, monochromatic, for dithering\n");
#ifndef HLRAD_ARG_MISC
Log(" -nodiffuse : Disables light_environment diffuse hack\n");
Log(" -nospotpoints : Disables light_spot spherical point sources\n");
#endif
#ifndef HLRAD_CUSTOMTEXLIGHT // no softlight hack
Log(" -softlight r g b d : Scaling values for backwards-light hack\n\n");
#endif
//Log("-= End of unofficial features! =-\n\n" );
#endif
// ------------------------------------------------------------------------
#ifdef HLRAD_HULLU
Log(" -customshadowwithbounce : Enables custom shadows with bounce light\n");
Log(" -rgbtransfers : Enables RGB Transfers (for custom shadows)\n\n");
#endif
#ifdef HLRAD_TRANSTOTAL_HACK
#ifndef HLRAD_REFLECTIVITY
Log(" -bscale : Scaling light on every bounce\n\n");
#endif
#endif
#ifdef HLRAD_MINLIGHT
Log(" -minlight # : Minimum final light (integer from 0 to 255)\n");
#endif
#ifdef HLRAD_TRANSFERDATA_COMPRESS
{
int i;
Log(" -compress # : compress tranfer (");
for (i=0; i<float_type_count; i++)
Log (" %d=%s", i, float_type_string[i]);
Log(" )\n");
Log(" -rgbcompress # : compress rgbtranfer (");
for (i=0; i<vector_type_count; i++)
Log (" %d=%s", i, vector_type_string[i]);
Log(" )\n");
}
#endif
#ifdef HLRAD_SOFTSKY
Log(" -softsky # : Smooth skylight.(0=off 1=on)\n");
#endif
#ifdef HLRAD_TRANSLUCENT
Log(" -depth # : Thickness of translucent objects.\n");
#endif
#ifdef HLRAD_OPAQUE_BLOCK
Log(" -blockopaque # : Remove the black areas around opaque entities.(0=off 1=on)\n");
#endif
#ifdef HLRAD_TEXTURE
Log(" -notextures : Don't load textures.\n");
#endif
#ifdef HLRAD_REFLECTIVITY
Log(" -texreflectgamma # : Gamma that relates reflectivity to texture color bits.\n");
Log(" -texreflectscale # : Reflectivity for 255-white texture.\n");
#endif
#ifdef HLRAD_BLUR
Log(" -blur # : Enlarge lightmap sample to blur the lightmap.\n");
#endif
#ifdef HLRAD_ACCURATEBOUNCE
Log(" -noemitterrange: Don't fix pointy texlights.\n");
#endif
#ifdef HLRAD_AVOIDWALLBLEED
Log(" -nobleedfix : Don't fix wall bleeding problem for large blur value.\n");
#endif
#ifdef HLRAD_DEBUG_DRAWPOINTS
Log(" -drawpatch : Export light patch positions to file 'mapname_patch.pts'.\n");
Log(" -drawsample x y z r : Export light sample positions in an area to file 'mapname_sample.pts'.\n");
Log(" -drawedge : Export smooth edge positions to file 'mapname_edge.pts'.\n");
Log(" -drawlerp : Show bounce light triangulation status.\n");
#endif
#ifdef HLRAD_AVOIDWALLBLEED
Log(" -drawnudge : Show nudged samples.\n");
#endif
#ifdef HLRAD_PRESERVELIGHTMAPCOLOR
Log(" -drawoverload : Highlight fullbright spots\n");
#endif
Log(" mapfile : The mapfile to compile\n\n");
exit(1);
}
// =====================================================================================
// Settings
// =====================================================================================
static void Settings()
{
char* tmp;
char buf1[1024];
char buf2[1024];
if (!g_info)
{
return;
}
Log("\n-= Current %s Settings =-\n", g_Program);
Log("Name | Setting | Default\n"
"--------------------|---------------------|-------------------------\n");
// ZHLT Common Settings
if (DEFAULT_NUMTHREADS == -1)
{
Log("threads [ %17d ] [ Varies ]\n", g_numthreads);
}
else
{
Log("threads [ %17d ] [ %17d ]\n", g_numthreads, DEFAULT_NUMTHREADS);
}
Log("verbose [ %17s ] [ %17s ]\n", g_verbose ? "on" : "off", DEFAULT_VERBOSE ? "on" : "off");
Log("log [ %17s ] [ %17s ]\n", g_log ? "on" : "off", DEFAULT_LOG ? "on" : "off");
Log("developer [ %17d ] [ %17d ]\n", g_developer, DEFAULT_DEVELOPER);
Log("chart [ %17s ] [ %17s ]\n", g_chart ? "on" : "off", DEFAULT_CHART ? "on" : "off");
Log("estimate [ %17s ] [ %17s ]\n", g_estimate ? "on" : "off", DEFAULT_ESTIMATE ? "on" : "off");
Log("max texture memory [ %17d ] [ %17d ]\n", g_max_map_miptex, DEFAULT_MAX_MAP_MIPTEX);
Log("max lighting memory [ %17d ] [ %17d ]\n", g_max_map_lightdata, DEFAULT_MAX_MAP_LIGHTDATA); //lightdata
switch (g_threadpriority)
{
case eThreadPriorityNormal:
default:
tmp = "Normal";
break;
case eThreadPriorityLow:
tmp = "Low";
break;
case eThreadPriorityHigh:
tmp = "High";
break;
}
Log("priority [ %17s ] [ %17s ]\n", tmp, "Normal");
Log("\n");
#ifdef HLRAD_FASTMODE
Log("fast rad [ %17s ] [ %17s ]\n", g_fastmode? "on": "off", DEFAULT_FASTMODE? "on": "off");
#endif
#ifdef HLRAD_ARG_MISC
Log("vismatrix algorithm [ %17s ] [ %17s ]\n",
g_method == eMethodVismatrix? "Original": g_method == eMethodSparseVismatrix? "Sparse": g_method == eMethodNoVismatrix? "NoMatrix": "Unknown",
DEFAULT_METHOD == eMethodVismatrix? "Original": DEFAULT_METHOD == eMethodSparseVismatrix? "Sparse": DEFAULT_METHOD == eMethodNoVismatrix? "NoMatrix": "Unknown"
);
#else
// HLRAD Specific Settings
switch (g_method)
{
default:
tmp = "Unknown";
break;
case eMethodVismatrix:
tmp = "Original";
break;
case eMethodSparseVismatrix:
tmp = "Sparse";
break;
case eMethodNoVismatrix:
tmp = "NoMatrix";
break;
}
Log("vismatrix algorithm [ %17s ] [ %17s ]\n", tmp, "Original");
#endif
Log("oversampling (-extra)[ %17s ] [ %17s ]\n", g_extra ? "on" : "off", DEFAULT_EXTRA ? "on" : "off");
Log("bounces [ %17d ] [ %17d ]\n", g_numbounce, DEFAULT_BOUNCE);
safe_snprintf(buf1, sizeof(buf1), "%1.3f %1.3f %1.3f", g_ambient[0], g_ambient[1], g_ambient[2]);
safe_snprintf(buf2, sizeof(buf2), "%1.3f %1.3f %1.3f", DEFAULT_AMBIENT_RED, DEFAULT_AMBIENT_GREEN, DEFAULT_AMBIENT_BLUE);
Log("ambient light [ %17s ] [ %17s ]\n", buf1, buf2);
#ifndef HLRAD_FinalLightFace_VL
safe_snprintf(buf1, sizeof(buf1), "%3.3f", g_maxlight);
safe_snprintf(buf2, sizeof(buf2), "%3.3f", DEFAULT_MAXLIGHT);
Log("maximum light [ %17s ] [ %17s ]\n", buf1, buf2);
#endif
#ifdef HLRAD_PRESERVELIGHTMAPCOLOR
safe_snprintf(buf1, sizeof(buf1), "%3.3f", g_limitthreshold);
safe_snprintf(buf2, sizeof(buf2), "%3.3f", DEFAULT_LIMITTHRESHOLD);
Log("light limit threshold[ %17s ] [ %17s ]\n", g_limitthreshold >= 0 ? buf1 : "None", buf2);
#endif
Log("circus mode [ %17s ] [ %17s ]\n", g_circus ? "on" : "off", DEFAULT_CIRCUS ? "on" : "off");
Log("\n");
safe_snprintf(buf1, sizeof(buf1), "%3.3f", g_smoothing_value);
safe_snprintf(buf2, sizeof(buf2), "%3.3f", DEFAULT_SMOOTHING_VALUE);
Log("smoothing threshold [ %17s ] [ %17s ]\n", buf1, buf2);
#ifdef HLRAD_CUSTOMSMOOTH
safe_snprintf(buf1, sizeof(buf1), g_smoothing_value_2<0? "no change": "%3.3f", g_smoothing_value_2);
safe_snprintf(buf2, sizeof(buf2), DEFAULT_SMOOTHING2_VALUE<0? "no change": "%3.3f", DEFAULT_SMOOTHING2_VALUE);
Log("smoothing threshold 2[ %17s ] [ %17s ]\n", buf1, buf2);
#endif
safe_snprintf(buf1, sizeof(buf1), "%3.3f", g_dlight_threshold);
safe_snprintf(buf2, sizeof(buf2), "%3.3f", DEFAULT_DLIGHT_THRESHOLD);
Log("direct threshold [ %17s ] [ %17s ]\n", buf1, buf2);
safe_snprintf(buf1, sizeof(buf1), "%3.3f", g_direct_scale);
safe_snprintf(buf2, sizeof(buf2), "%3.3f", DEFAULT_DLIGHT_SCALE);
Log("direct light scale [ %17s ] [ %17s ]\n", buf1, buf2);
safe_snprintf(buf1, sizeof(buf1), "%3.3f", g_coring);
safe_snprintf(buf2, sizeof(buf2), "%3.3f", DEFAULT_CORING);
Log("coring threshold [ %17s ] [ %17s ]\n", buf1, buf2);
Log("patch interpolation [ %17s ] [ %17s ]\n", g_lerp_enabled ? "on" : "off", DEFAULT_LERP_ENABLED ? "on" : "off");
Log("\n");
Log("texscale [ %17s ] [ %17s ]\n", g_texscale ? "on" : "off", DEFAULT_TEXSCALE ? "on" : "off");
Log("patch subdividing [ %17s ] [ %17s ]\n", g_subdivide ? "on" : "off", DEFAULT_SUBDIVIDE ? "on" : "off");
safe_snprintf(buf1, sizeof(buf1), "%3.3f", g_chop);
safe_snprintf(buf2, sizeof(buf2), "%3.3f", DEFAULT_CHOP);
Log("chop value [ %17s ] [ %17s ]\n", buf1, buf2);
safe_snprintf(buf1, sizeof(buf1), "%3.3f", g_texchop);
safe_snprintf(buf2, sizeof(buf2), "%3.3f", DEFAULT_TEXCHOP);
Log("texchop value [ %17s ] [ %17s ]\n", buf1, buf2);
Log("\n");
safe_snprintf(buf1, sizeof(buf1), "%3.3f", g_fade);
safe_snprintf(buf2, sizeof(buf2), "%3.3f", DEFAULT_FADE);
Log("global fade [ %17s ] [ %17s ]\n", buf1, buf2);
#ifndef HLRAD_ARG_MISC
Log("global falloff [ %17d ] [ %17d ]\n", g_falloff, DEFAULT_FALLOFF);
#endif
#ifdef HLRAD_TEXLIGHTGAP
safe_snprintf(buf1, sizeof(buf1), "%3.3f", g_texlightgap);
safe_snprintf(buf2, sizeof(buf2), "%3.3f", DEFAULT_TEXLIGHTGAP);
Log("global texlight gap [ %17s ] [ %17s ]\n", buf1, buf2);
#endif
// ------------------------------------------------------------------------
// Changes by Adam Foster - afoster@compsoc.man.ac.uk
// replaces the old stuff for displaying current values for gamma and lightscale
#ifdef HLRAD_WHOME
safe_snprintf(buf1, sizeof(buf1), "%1.3f %1.3f %1.3f", g_colour_lightscale[0], g_colour_lightscale[1], g_colour_lightscale[2]);
safe_snprintf(buf2, sizeof(buf2), "%1.3f %1.3f %1.3f", DEFAULT_COLOUR_LIGHTSCALE_RED, DEFAULT_COLOUR_LIGHTSCALE_GREEN, DEFAULT_COLOUR_LIGHTSCALE_BLUE);
Log("global light scale [ %17s ] [ %17s ]\n", buf1, buf2);
safe_snprintf(buf1, sizeof(buf1), "%1.3f %1.3f %1.3f", g_colour_qgamma[0], g_colour_qgamma[1], g_colour_qgamma[2]);
safe_snprintf(buf2, sizeof(buf2), "%1.3f %1.3f %1.3f", DEFAULT_COLOUR_GAMMA_RED, DEFAULT_COLOUR_GAMMA_GREEN, DEFAULT_COLOUR_GAMMA_BLUE);
Log("global gamma [ %17s ] [ %17s ]\n", buf1, buf2);
#endif
// ------------------------------------------------------------------------
safe_snprintf(buf1, sizeof(buf1), "%3.3f", g_lightscale);
safe_snprintf(buf2, sizeof(buf2), "%3.3f", DEFAULT_LIGHTSCALE);
Log("global light scale [ %17s ] [ %17s ]\n", buf1, buf2);
#ifndef HLRAD_WHOME
safe_snprintf(buf1, sizeof(buf1), "%3.3f", g_qgamma);
safe_snprintf(buf2, sizeof(buf2), "%3.3f", DEFAULT_GAMMA);
Log("global gamma amount [ %17s ] [ %17s ]\n", buf1, buf2);
#endif
safe_snprintf(buf1, sizeof(buf1), "%3.3f", g_indirect_sun);
safe_snprintf(buf2, sizeof(buf2), "%3.3f", DEFAULT_INDIRECT_SUN);
Log("global sky diffusion [ %17s ] [ %17s ]\n", buf1, buf2);
Log("\n");
#ifdef HLRAD_SUNSPREAD
Log("spread angles [ %17s ] [ %17s ]\n", g_allow_spread ? "on" : "off", DEFAULT_ALLOW_SPREAD ? "on" : "off");
#endif
Log("opaque entities [ %17s ] [ %17s ]\n", g_allow_opaques ? "on" : "off", DEFAULT_ALLOW_OPAQUES ? "on" : "off");
Log("sky lighting fix [ %17s ] [ %17s ]\n", g_sky_lighting_fix ? "on" : "off", DEFAULT_SKY_LIGHTING_FIX ? "on" : "off");
Log("incremental [ %17s ] [ %17s ]\n", g_incremental ? "on" : "off", DEFAULT_INCREMENTAL ? "on" : "off");
Log("dump [ %17s ] [ %17s ]\n", g_dumppatches ? "on" : "off", DEFAULT_DUMPPATCHES ? "on" : "off");
// ------------------------------------------------------------------------
// Changes by Adam Foster - afoster@compsoc.man.ac.uk
// displays information on all the brand-new features :)
#ifdef HLRAD_WHOME
Log("\n");
safe_snprintf(buf1, sizeof(buf1), "%3.1f %3.1f %3.1f", g_colour_jitter_hack[0], g_colour_jitter_hack[1], g_colour_jitter_hack[2]);
safe_snprintf(buf2, sizeof(buf2), "%3.1f %3.1f %3.1f", DEFAULT_COLOUR_JITTER_HACK_RED, DEFAULT_COLOUR_JITTER_HACK_GREEN, DEFAULT_COLOUR_JITTER_HACK_BLUE);
Log("colour jitter [ %17s ] [ %17s ]\n", buf1, buf2);
safe_snprintf(buf1, sizeof(buf1), "%3.1f %3.1f %3.1f", g_jitter_hack[0], g_jitter_hack[1], g_jitter_hack[2]);
safe_snprintf(buf2, sizeof(buf2), "%3.1f %3.1f %3.1f", DEFAULT_JITTER_HACK_RED, DEFAULT_JITTER_HACK_GREEN, DEFAULT_JITTER_HACK_BLUE);
Log("monochromatic jitter [ %17s ] [ %17s ]\n", buf1, buf2);
#ifndef HLRAD_CUSTOMTEXLIGHT // no softlight hack
safe_snprintf(buf1, sizeof(buf1), "%2.1f %2.1f %2.1f %2.1f", g_softlight_hack[0], g_softlight_hack[1], g_softlight_hack[2], g_softlight_hack_distance);
safe_snprintf(buf2, sizeof(buf2), "%2.1f %2.1f %2.1f %2.1f", DEFAULT_SOFTLIGHT_HACK_RED, DEFAULT_SOFTLIGHT_HACK_GREEN, DEFAULT_SOFTLIGHT_HACK_BLUE, DEFAULT_SOFTLIGHT_HACK_DISTANCE);
Log("softlight hack [ %17s ] [ %17s ]\n", buf1, buf2);
#endif
#ifndef HLRAD_ARG_MISC
Log("diffuse hack [ %17s ] [ %17s ]\n", g_diffuse_hack ? "on" : "off", DEFAULT_DIFFUSE_HACK ? "on" : "off");
Log("spotlight points [ %17s ] [ %17s ]\n", g_spotlight_hack ? "on" : "off", DEFAULT_SPOTLIGHT_HACK ? "on" : "off");
#endif
#endif
// ------------------------------------------------------------------------
#ifdef HLRAD_HULLU
Log("\n");
Log("custom shadows with bounce light\n"
" [ %17s ] [ %17s ]\n", g_customshadow_with_bouncelight ? "on" : "off", DEFAULT_CUSTOMSHADOW_WITH_BOUNCELIGHT ? "on" : "off");
Log("rgb transfers [ %17s ] [ %17s ]\n", g_rgb_transfers ? "on" : "off", DEFAULT_RGB_TRANSFERS ? "on" : "off");
#endif
#ifdef HLRAD_TRANSTOTAL_HACK
#ifndef HLRAD_REFLECTIVITY
safe_snprintf(buf1, sizeof(buf1), "%3.3f", g_transtotal_hack);
safe_snprintf(buf2, sizeof(buf2), "%3.3f", DEFAULT_TRANSTOTAL_HACK);
Log("bounce scale [ %17s ] [ %17s ]\n", buf1, buf2);
#endif
#endif
#ifdef HLRAD_MINLIGHT
Log("minimum final light [ %17d ] [ %17d ]\n", (int)g_minlight, (int)DEFAULT_MINLIGHT);
#endif
#ifdef HLRAD_TRANSFERDATA_COMPRESS
sprintf (buf1, "%d (%s)", g_transfer_compress_type, float_type_string[g_transfer_compress_type]);
sprintf (buf2, "%d (%s)", DEFAULT_TRANSFER_COMPRESS_TYPE, float_type_string[DEFAULT_TRANSFER_COMPRESS_TYPE]);
Log("size of transfer [ %17s ] [ %17s ]\n", buf1, buf2);
sprintf (buf1, "%d (%s)", g_rgbtransfer_compress_type, vector_type_string[g_rgbtransfer_compress_type]);
sprintf (buf2, "%d (%s)", DEFAULT_RGBTRANSFER_COMPRESS_TYPE, vector_type_string[DEFAULT_RGBTRANSFER_COMPRESS_TYPE]);
Log("size of rgbtransfer [ %17s ] [ %17s ]\n", buf1, buf2);
#endif
#ifdef HLRAD_SOFTSKY
Log("soft sky [ %17s ] [ %17s ]\n", g_softsky ? "on" : "off", DEFAULT_SOFTSKY ? "on" : "off");
#endif
#ifdef HLRAD_TRANSLUCENT
safe_snprintf(buf1, sizeof(buf1), "%3.3f", g_translucentdepth);
safe_snprintf(buf2, sizeof(buf2), "%3.3f", DEFAULT_TRANSLUCENTDEPTH);
Log("translucent depth [ %17s ] [ %17s ]\n", buf1, buf2);
#endif
#ifdef HLRAD_OPAQUE_BLOCK
Log("block opaque [ %17s ] [ %17s ]\n", g_blockopaque ? "on" : "off", DEFAULT_BLOCKOPAQUE ? "on" : "off");
#endif
#ifdef HLRAD_TEXTURE
Log("ignore textures [ %17s ] [ %17s ]\n", g_notextures ? "on" : "off", DEFAULT_NOTEXTURES ? "on" : "off");
#endif
#ifdef HLRAD_REFLECTIVITY
safe_snprintf(buf1, sizeof(buf1), "%3.3f", g_texreflectgamma);
safe_snprintf(buf2, sizeof(buf2), "%3.3f", DEFAULT_TEXREFLECTGAMMA);
Log("reflectivity gamma [ %17s ] [ %17s ]\n", buf1, buf2);
safe_snprintf(buf1, sizeof(buf1), "%3.3f", g_texreflectscale);
safe_snprintf(buf2, sizeof(buf2), "%3.3f", DEFAULT_TEXREFLECTSCALE);
Log("reflectivity scale [ %17s ] [ %17s ]\n", buf1, buf2);
#endif
#ifdef HLRAD_BLUR
safe_snprintf(buf1, sizeof(buf1), "%3.3f", g_blur);
safe_snprintf(buf2, sizeof(buf2), "%3.3f", DEFAULT_BLUR);
Log("blur size [ %17s ] [ %17s ]\n", buf1, buf2);
#endif
#ifdef HLRAD_ACCURATEBOUNCE
Log("no emitter range [ %17s ] [ %17s ]\n", g_noemitterrange ? "on" : "off", DEFAULT_NOEMITTERRANGE ? "on" : "off");
#endif
#ifdef HLRAD_AVOIDWALLBLEED
Log("wall bleeding fix [ %17s ] [ %17s ]\n", g_bleedfix ? "on" : "off", DEFAULT_BLEEDFIX ? "on" : "off");
#endif
Log("\n\n");
}
#ifdef HLRAD_INFO_TEXLIGHTS
// AJM: added in
// =====================================================================================
// ReadInfoTexlights
// try and parse texlight info from the info_texlights entity
// =====================================================================================
void ReadInfoTexlights()
{
int k;
int values;
int numtexlights = 0;
float r, g, b, i;
entity_t* mapent;
epair_t* ep;
texlight_t texlight;
for (k = 0; k < g_numentities; k++)
{
mapent = &g_entities[k];
if (strcmp(ValueForKey(mapent, "classname"), "info_texlights"))
continue;
#ifdef HLRAD_CUSTOMTEXLIGHT
Log("Reading texlights from info_texlights map entity\n");
#else
Log("[Reading texlights from info_texlights map entity]\n");
#endif
for (ep = mapent->epairs; ep; ep = ep->next)
{
if ( !strcmp(ep->key, "classname")
|| !strcmp(ep->key, "origin")
)
continue; // we dont care about these keyvalues
values = sscanf(ep->value, "%f %f %f %f", &r, &g, &b, &i);
if (values == 1)
{
g = b = r;
}
else if (values == 4) // use brightness value.
{
r *= i / 255.0;
g *= i / 255.0;
b *= i / 255.0;
}
else if (values != 3)
{
Warning("ignoring bad texlight '%s' in info_texlights entity", ep->key);
continue;
}
texlight.name = ep->key;
texlight.value[0] = r;
texlight.value[1] = g;
texlight.value[2] = b;
texlight.filename = "info_texlights";
s_texlights.push_back(texlight);
numtexlights++;
}
#ifndef HLRAD_CUSTOMTEXLIGHT
Log("[%i texlights parsed from info_texlights map entity]\n\n", numtexlights);
#endif
}
}
#endif
const char* lights_rad = "lights.rad";
const char* ext_rad = ".rad";
// =====================================================================================
// LoadRadFiles
// =====================================================================================
void LoadRadFiles(const char* const mapname, const char* const user_rad, const char* argv0)
{
char global_lights[_MAX_PATH];
char mapname_lights[_MAX_PATH];
char mapfile[_MAX_PATH];
char mapdir[_MAX_PATH];
char appdir[_MAX_PATH];
// Get application directory (only an approximation on posix systems)
// try looking in the directory we were run from
{
char tmp[_MAX_PATH];
memset(tmp, 0, sizeof(tmp));
#ifdef SYSTEM_WIN32
GetModuleFileName(NULL, tmp, _MAX_PATH);
#else
safe_strncpy(tmp, argv0, _MAX_PATH);
#endif
ExtractFilePath(tmp, appdir);
}
// Get map directory
ExtractFilePath(mapname, mapdir);
#ifdef ZHLT_DEFAULTEXTENSION_FIX
ExtractFile(mapname, mapfile);
#else
ExtractFileBase(mapname, mapfile);
#endif
// Look for lights.rad in mapdir
safe_strncpy(global_lights, mapdir, _MAX_PATH);
safe_strncat(global_lights, lights_rad, _MAX_PATH);
if (q_exists(global_lights))
{
ReadLightFile(global_lights);
}
else
{
// Look for lights.rad in appdir
safe_strncpy(global_lights, appdir, _MAX_PATH);
safe_strncat(global_lights, lights_rad, _MAX_PATH);
if (q_exists(global_lights))
{
ReadLightFile(global_lights);
}
else
{
// Look for lights.rad in current working directory
safe_strncpy(global_lights, lights_rad, _MAX_PATH);
if (q_exists(global_lights))
{
ReadLightFile(global_lights);
}
}
}
// Look for mapname.rad in mapdir
safe_strncpy(mapname_lights, mapdir, _MAX_PATH);
safe_strncat(mapname_lights, mapfile, _MAX_PATH);
#ifdef ZHLT_DEFAULTEXTENSION_FIX
safe_strncat(mapname_lights, ext_rad, _MAX_PATH);
#else
DefaultExtension(mapname_lights, ext_rad);
#endif
if (q_exists(mapname_lights))
{
ReadLightFile(mapname_lights);
}
if (user_rad)
{
char user_lights[_MAX_PATH];
char userfile[_MAX_PATH];
ExtractFile(user_rad, userfile);
// Look for user.rad from command line (raw)
safe_strncpy(user_lights, user_rad, _MAX_PATH);
if (q_exists(user_lights))
{
ReadLightFile(user_lights);
}
else
{
// Try again with .rad enforced as extension
DefaultExtension(user_lights, ext_rad);
if (q_exists(user_lights))
{
ReadLightFile(user_lights);
}
else
{
// Look for user.rad in mapdir
safe_strncpy(user_lights, mapdir, _MAX_PATH);
safe_strncat(user_lights, userfile, _MAX_PATH);
DefaultExtension(user_lights, ext_rad);
if (q_exists(user_lights))
{
ReadLightFile(user_lights);
}
else
{
// Look for user.rad in appdir
safe_strncpy(user_lights, appdir, _MAX_PATH);
safe_strncat(user_lights, userfile, _MAX_PATH);
DefaultExtension(user_lights, ext_rad);
if (q_exists(user_lights))
{
ReadLightFile(user_lights);
}
else
{
// Look for user.rad in current working directory
safe_strncpy(user_lights, userfile, _MAX_PATH);
DefaultExtension(user_lights, ext_rad);
if (q_exists(user_lights))
{
ReadLightFile(user_lights);
}
}
}
}
}
}
#ifdef HLRAD_INFO_TEXLIGHTS
ReadInfoTexlights(); // AJM
#endif
}
#ifdef ZHLT_XASH
void WriteDlitData (const char *filename)
{
FILE *f;
if (g_drawdirection)
{
if (g_dlitdatasize != g_lightdatasize)
{
Error ("g_dlitdatasize != g_lightdatasize");
}
memcpy (g_dlightdata, g_ddlitdata, g_lightdatasize);
}
f = SafeOpenWrite (filename);
fputc ('Q', f);
fputc ('L', f);
fputc ('I', f);
fputc ('T', f);
fputc (1, f);
fputc (0, f);
fputc (0, f);
fputc (0, f);
SafeWrite (f, g_ddlitdata, g_dlitdatasize);
fclose (f);
}
#endif
// =====================================================================================
// main
// =====================================================================================
int main(const int argc, char** argv)
{
int i;
double start, end;
const char* mapname_from_arg = NULL;
const char* user_lights = NULL;
g_Program = "hlrad";
#ifdef ZHLT_PARAMFILE
int argcold = argc;
char ** argvold = argv;
{
int argc;
char ** argv;
ParseParamFile (argcold, argvold, argc, argv);
{
#endif
#ifdef ZHLT_CONSOLE
if (InitConsole (argc, argv) < 0)
Usage();
#endif
if (argc == 1)
Usage();
for (i = 1; i < argc; i++)
{
if (!strcasecmp(argv[i], "-dump"))
{
g_dumppatches = true;
}
#ifdef ZHLT_CONSOLE
else if (!strcasecmp(argv[i], "-console"))
{
#ifndef SYSTEM_WIN32
Warning("The option '-console #' is only valid for Windows.");
#endif
if (i + 1 < argc)
++i;
else
Usage();
}
#endif
else if (!strcasecmp(argv[i], "-bounce"))
{
if (i + 1 < argc) //added "1" .--vluzacn
{
g_numbounce = atoi(argv[++i]);
if (g_numbounce > 1000)
{
Log("Unexpectedly large value (>1000) for '-bounce'\n");
Usage();
}
}
else
{
Usage();
}
}
else if (!strcasecmp(argv[i], "-dev"))
{
if (i + 1 < argc) //added "1" .--vluzacn
{
g_developer = (developer_level_t)atoi(argv[++i]);
}
else
{
Usage();
}
}
else if (!strcasecmp(argv[i], "-verbose"))
{
g_verbose = true;
}
else if (!strcasecmp(argv[i], "-noinfo"))
{
g_info = false;
}
else if (!strcasecmp(argv[i], "-threads"))
{
if (i + 1 < argc) //added "1" .--vluzacn
{
g_numthreads = atoi(argv[++i]);
if (g_numthreads < 1)
{
Log("Expected value of at least 1 for '-threads'\n");
Usage();
}
}
else
{
Usage();
}
}
#ifdef SYSTEM_WIN32
else if (!strcasecmp(argv[i], "-estimate"))
{
g_estimate = true;
}
#endif
#ifdef SYSTEM_POSIX
else if (!strcasecmp(argv[i], "-noestimate"))
{
g_estimate = false;
}
#endif
#ifdef ZHLT_NETVIS
else if (!strcasecmp(argv[i], "-client"))
{
if (i + 1 < argc) //added "1" .--vluzacn
{
g_clientid = atoi(argv[++i]);
}
else
{
Usage();
}
}
#endif
#ifdef HLRAD_FASTMODE
else if (!strcasecmp (argv[i], "-fast"))
{
g_fastmode = true;
}
#endif
else if (!strcasecmp(argv[i], "-nolerp"))
{
g_lerp_enabled = false;
}
else if (!strcasecmp(argv[i], "-chop"))
{
if (i + 1 < argc) //added "1" .--vluzacn
{
g_chop = atof(argv[++i]);
if (g_chop < 1)
{
Log("expected value greater than 1 for '-chop'\n");
Usage();
}
if (g_chop < 32)
{
Log("Warning: Chop values below 32 are not recommended.");
}
}
else
{
Usage();
}
}
else if (!strcasecmp(argv[i], "-texchop"))
{
if (i + 1 < argc) //added "1" .--vluzacn
{
g_texchop = atof(argv[++i]);
if (g_texchop < 1)
{
Log("expected value greater than 1 for '-texchop'\n");
Usage();
}
if (g_texchop < 32)
{
Log("Warning: texchop values below 16 are not recommended.");
}
}
else
{
Usage();
}
}
else if (!strcasecmp(argv[i], "-notexscale"))
{
g_texscale = false;
}
else if (!strcasecmp(argv[i], "-nosubdivide"))
{
if (i < argc)
{
g_subdivide = false;
}
else
{
Usage();
}
}
else if (!strcasecmp(argv[i], "-scale"))
{
if (i + 1 < argc) //added "1" .--vluzacn
{
// ------------------------------------------------------------------------
// Changes by Adam Foster - afoster@compsoc.man.ac.uk
// Munge monochrome lightscale into colour one
#ifdef HLRAD_WHOME
i++;
g_colour_lightscale[0] = (float)atof(argv[i]);
g_colour_lightscale[1] = (float)atof(argv[i]);
g_colour_lightscale[2] = (float)atof(argv[i]);
#else
g_lightscale = (float)atof(argv[++i]);
#endif
// ------------------------------------------------------------------------
}
else
{
Usage();
}
}
#ifndef HLRAD_ARG_MISC
else if (!strcasecmp(argv[i], "-falloff"))
{
if (i + 1 < argc) //added "1" .--vluzacn
{
g_falloff = (float)atoi(argv[++i]);
if ((g_falloff != 1) && (g_falloff != 2))
{
Log("-falloff must be 1 or 2\n");
Usage();
}
}
else
{
Usage();
}
}
#endif
else if (!strcasecmp(argv[i], "-fade"))
{
if (i + 1 < argc) //added "1" .--vluzacn
{
g_fade = (float)atof(argv[++i]);
if (g_fade < 0.0)
{
Log("-fade must be a positive number\n");
Usage();
}
}
else
{
Usage();
}
}
else if (!strcasecmp(argv[i], "-ambient"))
{
if (i + 3 < argc)
{
g_ambient[0] = (float)atof(argv[++i]) * 128;
g_ambient[1] = (float)atof(argv[++i]) * 128;
g_ambient[2] = (float)atof(argv[++i]) * 128;
}
else
{
Error("expected three color values after '-ambient'\n");
}
}
#ifndef HLRAD_FinalLightFace_VL
else if (!strcasecmp(argv[i], "-maxlight"))
{
if (i + 1 < argc) //added "1" .--vluzacn
{
g_maxlight = (float)atof(argv[++i]) * 128;
if (g_maxlight <= 0)
{
Log("expected positive value after '-maxlight'\n");
Usage();
}
}
else
{
Usage();
}
}
#endif
#ifdef HLRAD_PRESERVELIGHTMAPCOLOR
else if (!strcasecmp(argv[i], "-limiter"))
{
if (i + 1 < argc) //added "1" .--vluzacn
{
g_limitthreshold = atof(argv[++i]);
}
else
{
Usage();
}
}
else if (!strcasecmp(argv[i], "-drawoverload"))
{
g_drawoverload = true;
}
#endif
else if (!strcasecmp(argv[i], "-lights"))
{
if (i + 1 < argc) //added "1" .--vluzacn
{
user_lights = argv[++i];
}
else
{
Usage();
}
}
else if (!strcasecmp(argv[i], "-circus"))
{
g_circus = true;
}
else if (!strcasecmp(argv[i], "-noskyfix"))
{
g_sky_lighting_fix = false;
}
else if (!strcasecmp(argv[i], "-incremental"))
{
g_incremental = true;
}
else if (!strcasecmp(argv[i], "-chart"))
{
g_chart = true;
}
else if (!strcasecmp(argv[i], "-low"))
{
g_threadpriority = eThreadPriorityLow;
}
else if (!strcasecmp(argv[i], "-high"))
{
g_threadpriority = eThreadPriorityHigh;
}
else if (!strcasecmp(argv[i], "-nolog"))
{
g_log = false;
}
else if (!strcasecmp(argv[i], "-gamma"))
{
if (i + 1 < argc) //added "1" .--vluzacn
{
// ------------------------------------------------------------------------
// Changes by Adam Foster - afoster@compsoc.man.ac.uk
// Munge values from original, monochrome gamma into colour gamma
#ifdef HLRAD_WHOME
i++;
g_colour_qgamma[0] = (float)atof(argv[i]);
g_colour_qgamma[1] = (float)atof(argv[i]);
g_colour_qgamma[2] = (float)atof(argv[i]);
#else
g_qgamma = (float)atof(argv[++i]);
#endif
// ------------------------------------------------------------------------
}
else
{
Usage();
}
}
else if (!strcasecmp(argv[i], "-dlight"))
{
if (i + 1 < argc) //added "1" .--vluzacn
{
g_dlight_threshold = (float)atof(argv[++i]);
}
else
{
Usage();
}
}
else if (!strcasecmp(argv[i], "-extra"))
{
g_extra = true;
}
else if (!strcasecmp(argv[i], "-sky"))
{
if (i + 1 < argc) //added "1" .--vluzacn
{
g_indirect_sun = (float)atof(argv[++i]);
}
else
{
Usage();
}
}
else if (!strcasecmp(argv[i], "-smooth"))
{
if (i + 1 < argc) //added "1" .--vluzacn
{
g_smoothing_value = atof(argv[++i]);
}
else
{
Usage();
}
}
#ifdef HLRAD_CUSTOMSMOOTH
else if (!strcasecmp(argv[i], "-smooth2"))
{
if (i + 1 < argc)
{
g_smoothing_value_2 = atof(argv[++i]);
}
else
{
Usage();
}
}
#endif
else if (!strcasecmp(argv[i], "-coring"))
{
if (i + 1 < argc) //added "1" .--vluzacn
{
g_coring = (float)atof(argv[++i]);
}
else
{
Usage();
}
}
else if (!strcasecmp(argv[i], "-texdata"))
{
if (i + 1 < argc) //added "1" .--vluzacn
{
int x = atoi(argv[++i]) * 1024;
//if (x > g_max_map_miptex) //--vluzacn
{
g_max_map_miptex = x;
}
}
else
{
Usage();
}
}
else if (!strcasecmp(argv[i], "-lightdata")) //lightdata
{
if (i + 1 < argc) //--vluzacn
{
int x = atoi(argv[++i]) * 1024;
//if (x > g_max_map_lightdata) //--vluzacn
{
g_max_map_lightdata = x;
}
}
else
{
Usage();
}
}
#ifdef HLRAD_ARG_MISC
else if (!strcasecmp (argv[i], "-vismatrix"))
{
if (i + 1 < argc)
{
const char *value = argv[++i];
if (!strcasecmp (value, "normal"))
{
g_method = eMethodVismatrix;
}
else if (!strcasecmp (value, "sparse"))
{
g_method = eMethodSparseVismatrix;
}
else if (!strcasecmp (value, "off"))
{
g_method = eMethodNoVismatrix;
}
else
{
Error ("Unknown vismatrix type: '%s'", value);
}
}
else
{
Usage ();
}
}
#else
else if (!strcasecmp(argv[i], "-sparse"))
{
g_method = eMethodSparseVismatrix;
}
else if (!strcasecmp(argv[i], "-nomatrix"))
{
g_method = eMethodNoVismatrix;
}
#endif
#ifdef HLRAD_SUNSPREAD
else if (!strcasecmp (argv[i], "-nospread"))
{
g_allow_spread = false;
}
#endif
else if (!strcasecmp(argv[i], "-nopaque")
|| !strcasecmp(argv[i], "-noopaque")) //--vluzacn
{
g_allow_opaques = false;
}
else if (!strcasecmp(argv[i], "-dscale"))
{
if (i + 1 < argc) //added "1" .--vluzacn
{
g_direct_scale = (float)atof(argv[++i]);
}
else
{
Usage();
}
}
// ------------------------------------------------------------------------
// Changes by Adam Foster - afoster@compsoc.man.ac.uk
#ifdef HLRAD_WHOME
else if (!strcasecmp(argv[i], "-colourgamma"))
{
if (i + 3 < argc)
{
g_colour_qgamma[0] = (float)atof(argv[++i]);
g_colour_qgamma[1] = (float)atof(argv[++i]);
g_colour_qgamma[2] = (float)atof(argv[++i]);
}
else
{
Error("expected three color values after '-colourgamma'\n");
}
}
else if (!strcasecmp(argv[i], "-colourscale"))
{
if (i + 3 < argc)
{
g_colour_lightscale[0] = (float)atof(argv[++i]);
g_colour_lightscale[1] = (float)atof(argv[++i]);
g_colour_lightscale[2] = (float)atof(argv[++i]);
}
else
{
Error("expected three color values after '-colourscale'\n");
}
}
else if (!strcasecmp(argv[i], "-colourjitter"))
{
if (i + 3 < argc)
{
g_colour_jitter_hack[0] = (float)atof(argv[++i]);
g_colour_jitter_hack[1] = (float)atof(argv[++i]);
g_colour_jitter_hack[2] = (float)atof(argv[++i]);
}
else
{
Error("expected three color values after '-colourjitter'\n");
}
}
else if (!strcasecmp(argv[i], "-jitter"))
{
if (i + 3 < argc)
{
g_jitter_hack[0] = (float)atof(argv[++i]);
g_jitter_hack[1] = (float)atof(argv[++i]);
g_jitter_hack[2] = (float)atof(argv[++i]);
}
else
{
Error("expected three color values after '-jitter'\n");
}
}
#ifndef HLRAD_ARG_MISC
else if (!strcasecmp(argv[i], "-nodiffuse"))
{
g_diffuse_hack = false;
}
else if (!strcasecmp(argv[i], "-nospotpoints"))
{
g_spotlight_hack = false;
}
#endif
#ifndef HLRAD_CUSTOMTEXLIGHT // no softlight hack
else if (!strcasecmp(argv[i], "-softlight"))
{
if (i + 4 < argc)
{
g_softlight_hack[0] = (float)atof(argv[++i]);
g_softlight_hack[1] = (float)atof(argv[++i]);
g_softlight_hack[2] = (float)atof(argv[++i]);
g_softlight_hack_distance = (float)atof(argv[++i]);
}
else
{
Error("expected three color scalers and a distance after '-softlight'\n");
}
}
#endif
#endif
// ------------------------------------------------------------------------
#ifdef HLRAD_HULLU
else if (!strcasecmp(argv[i], "-customshadowwithbounce"))
{
g_customshadow_with_bouncelight = true;
}
else if (!strcasecmp(argv[i], "-rgbtransfers"))
{
g_rgb_transfers = true;
}
#endif
#ifdef ZHLT_PROGRESSFILE // AJM
else if (!strcasecmp(argv[i], "-progressfile"))
{
if (i + 1 < argc) //added "1" .--vluzacn
{
g_progressfile = argv[++i];
}
else
{
Log("Error: -progressfile: expected path to progress file following parameter\n");
Usage();
}
}
#endif
#ifdef HLRAD_TRANSTOTAL_HACK
else if (!strcasecmp(argv[i], "-bscale"))
{
#ifdef HLRAD_REFLECTIVITY
Error ("'-bscale' is obsolete.");
#endif
if (i + 1 < argc)
{
g_transtotal_hack = (float)atof(argv[++i]);
}
else
{
Usage();
}
}
#endif
#ifdef HLRAD_MINLIGHT
else if (!strcasecmp(argv[i], "-minlight"))
{
if (i + 1 < argc)
{
int v = atoi(argv[++i]);
v = qmax (0, qmin (v, 255));
g_minlight = (unsigned char)v;
}
else
{
Usage();
}
}
#endif
#ifdef HLRAD_SOFTSKY
else if (!strcasecmp(argv[i], "-softsky"))
{
if (i + 1 < argc)
{
g_softsky = (bool)atoi(argv[++i]);
}
else
{
Usage();
}
}
#endif
#ifdef HLRAD_DEBUG_DRAWPOINTS
else if (!strcasecmp(argv[i], "-drawpatch"))
{
g_drawpatch = true;
}
else if (!strcasecmp(argv[i], "-drawsample"))
{
g_drawsample = true;
if (i + 4 < argc)
{
g_drawsample_origin[0] = atof(argv[++i]);
g_drawsample_origin[1] = atof(argv[++i]);
g_drawsample_origin[2] = atof(argv[++i]);
g_drawsample_radius = atof(argv[++i]);
}
else
{
Usage();
}
}
else if (!strcasecmp(argv[i], "-drawedge"))
{
g_drawedge = true;
}
else if (!strcasecmp(argv[i], "-drawlerp"))
{
g_drawlerp = true;
}
#endif
#ifdef HLRAD_AVOIDWALLBLEED
else if (!strcasecmp(argv[i], "-drawnudge"))
{
g_drawnudge = true;
}
#endif
#ifdef ZHLT_XASH
else if (!strcasecmp (argv[i], "-drawdirection"))
{
g_drawdirection = true;
}
#endif
#ifdef HLRAD_TRANSFERDATA_COMPRESS
else if (!strcasecmp(argv[i], "-compress"))
{
if (i + 1 < argc)
{
g_transfer_compress_type = (float_type)atoi(argv[++i]);
if (g_transfer_compress_type < 0 || g_transfer_compress_type >= float_type_count)
Usage();
}
else
{
Usage();
}
}
else if (!strcasecmp(argv[i], "-rgbcompress"))
{
if (i + 1 < argc)
{
g_rgbtransfer_compress_type = (vector_type)atoi(argv[++i]);
if (g_rgbtransfer_compress_type < 0 || g_rgbtransfer_compress_type >= vector_type_count)
Usage();
}
else
{
Usage();
}
}
#endif
#ifdef HLRAD_TRANSLUCENT
else if (!strcasecmp (argv[i], "-depth"))
{
if (i + 1 < argc)
{
g_translucentdepth = atof(argv[++i]);
}
else
{
Usage ();
}
}
#endif
#ifdef HLRAD_OPAQUE_BLOCK
else if (!strcasecmp (argv[i], "-blockopaque"))
{
if (i + 1 < argc)
{
g_blockopaque = atoi(argv[++i]);
}
else
{
Usage ();
}
}
#endif
#ifdef HLRAD_TEXTURE
else if (!strcasecmp (argv[i], "-waddir"))
{
if (i + 1 < argc)
{
AddWadFolder (argv[++i]);
}
else
{
Usage ();
}
}
else if (!strcasecmp (argv[i], "-notextures"))
{
g_notextures = true;
}
#endif
#ifdef HLRAD_REFLECTIVITY
else if (!strcasecmp (argv[i], "-texreflectgamma"))
{
if (i + 1 < argc)
{
g_texreflectgamma = atof (argv[++i]);
}
else
{
Usage ();
}
}
else if (!strcasecmp (argv[i], "-texreflectscale"))
{
if (i + 1 < argc)
{
g_texreflectscale = atof (argv[++i]);
}
else
{
Usage ();
}
}
#endif
#ifdef HLRAD_BLUR
else if (!strcasecmp (argv[i], "-blur"))
{
if (i + 1 < argc)
{
g_blur = atof (argv[++i]);
}
else
{
Usage ();
}
}
#endif
#ifdef HLRAD_ACCURATEBOUNCE
else if (!strcasecmp (argv[i], "-noemitterrange"))
{
g_noemitterrange = true;
}
#endif
#ifdef HLRAD_AVOIDWALLBLEED
else if (!strcasecmp (argv[i], "-nobleedfix"))
{
g_bleedfix = false;
}
#endif
#ifdef HLRAD_TEXLIGHTGAP
else if (!strcasecmp (argv[i], "-texlightgap"))
{
if (i + 1 < argc)
{
g_texlightgap = atof (argv[++i]);
}
else
{
Usage ();
}
}
#endif
#ifdef ZHLT_LANGFILE
else if (!strcasecmp (argv[i], "-lang"))
{
if (i + 1 < argc)
{
char tmp[_MAX_PATH];
#ifdef SYSTEM_WIN32
GetModuleFileName (NULL, tmp, _MAX_PATH);
#else
safe_strncpy (tmp, argv[0], _MAX_PATH);
#endif
LoadLangFile (argv[++i], tmp);
}
else
{
Usage();
}
}
#endif
else if (argv[i][0] == '-')
{
Log("Unknown option \"%s\"\n", argv[i]);
Usage();
}
else if (!mapname_from_arg)
{
mapname_from_arg = argv[i];
}
else
{
Log("Unknown option \"%s\"\n", argv[i]);
Usage();
}
}
if (!mapname_from_arg)
{
Log("No mapname specified\n");
Usage();
}
g_smoothing_threshold = (float)cos(g_smoothing_value * (Q_PI / 180.0));
safe_strncpy(g_Mapname, mapname_from_arg, _MAX_PATH);
FlipSlashes(g_Mapname);
StripExtension(g_Mapname);
OpenLog(g_clientid);
atexit(CloseLog);
ThreadSetDefault();
ThreadSetPriority(g_threadpriority);
#ifdef ZHLT_PARAMFILE
LogStart(argcold, argvold);
{
int i;
Log("Arguments: ");
for (i = 1; i < argc; i++)
{
if (strchr(argv[i], ' '))
{
Log("\"%s\" ", argv[i]);
}
else
{
Log("%s ", argv[i]);
}
}
Log("\n");
}
#else
LogStart(argc, argv);
#endif
CheckForErrorLog();
#ifdef HLRAD_TRANSFERDATA_COMPRESS
compress_compatability_test ();
#endif
#ifdef ZHLT_64BIT_FIX
#ifdef PLATFORM_CAN_CALC_EXTENT
hlassume (CalcFaceExtents_test (), assume_first);
#endif
#endif
dtexdata_init();
atexit(dtexdata_free);
#ifdef ZHLT_XASH
g_max_map_dlitdata = g_max_map_lightdata;
g_ddlitdata = (byte *)malloc (g_max_map_dlitdata);
hlassume (g_ddlitdata != NULL, assume_NoMemory);
safe_snprintf (g_dlitfile, _MAX_PATH, "%s.dlit", g_Mapname);
#endif
// END INIT
// BEGIN RAD
start = I_FloatTime();
// normalise maxlight
#ifndef HLRAD_FinalLightFace_VL
if (g_maxlight > 255)
g_maxlight = 255;
#endif
#ifdef ZHLT_DEFAULTEXTENSION_FIX
safe_snprintf(g_source, _MAX_PATH, "%s.bsp", g_Mapname);
#else
strcpy(g_source, mapname_from_arg);
StripExtension(g_source);
DefaultExtension(g_source, ".bsp");
#endif
LoadBSPFile(g_source);
#ifdef ZHLT_64BIT_FIX
#ifndef PLATFORM_CAN_CALC_EXTENT
char extentfilename[_MAX_PATH];
safe_snprintf (extentfilename, _MAX_PATH, "%s.ext", g_Mapname);
Log ("Loading extent file '%s'\n", extentfilename);
if (!q_exists (extentfilename))
{
hlassume (false, assume_NO_EXTENT_FILE);
}
LoadExtentFile (extentfilename);
#endif
#endif
ParseEntities();
#ifdef HLRAD_FASTMODE
if (g_fastmode)
{
g_numbounce = 0;
#ifdef HLRAD_SOFTSKY
g_softsky = false;
#endif
}
#endif
Settings();
#ifdef ZHLT_EMBEDLIGHTMAP
DeleteEmbeddedLightmaps ();
#endif
#ifdef HLRAD_TEXTURE
LoadTextures ();
#endif
LoadRadFiles(g_Mapname, user_lights, argv[0]);
#ifdef HLRAD_CUSTOMCHOP
ReadCustomChopValue ();
#endif
#ifdef HLRAD_CUSTOMSMOOTH
ReadCustomSmoothValue ();
#endif
#ifdef HLRAD_TRANSLUCENT
ReadTranslucentTextures ();
#endif
#ifdef HLRAD_DIVERSE_LIGHTING
ReadLightingCone ();
#endif
#ifdef HLRAD_CUSTOMSMOOTH
g_smoothing_threshold_2 = g_smoothing_value_2 < 0 ? g_smoothing_threshold : (float)cos(g_smoothing_value_2 * (Q_PI / 180.0));
#endif
#ifdef HLRAD_STYLE_CORING
{
int style;
for (style = 0; style < ALLSTYLES; ++style)
{
g_corings[style] = style? g_coring: 0;
}
}
#endif
#ifdef HLRAD_ARG_MISC
if (g_direct_scale != 1.0)
{
Warning ("dscale value should be 1.0 for final compile.\nIf you need to adjust the bounced light, use the '-texreflectscale' and '-texreflectgamma' options instead.");
}
#ifdef HLRAD_WHOME
if (g_colour_lightscale[0] != 2.0 || g_colour_lightscale[1] != 2.0 || g_colour_lightscale[2] != 2.0)
#else
if (g_lightscale != 2.0)
#endif
{
Warning ("light scale value should be 2.0 for final compile.\nValues other than 2.0 will result in incorrect interpretation of light_environment's brightness when the engine loads the map.");
}
#endif
#ifdef HLRAD_DEBUG_DRAWPOINTS
if (g_drawlerp)
{
g_direct_scale = 0.0;
}
#endif
if (!g_visdatasize)
{
#ifdef HLRAD_WITHOUTVIS
Warning("No vis information.");
#else
Warning("No vis information, direct lighting only.");
g_numbounce = 0;
g_ambient[0] = g_ambient[1] = g_ambient[2] = 0.1f;
#endif
}
#ifdef HLRAD_BLUR
if (g_blur < 1.0)
{
g_blur = 1.0;
}
#endif
RadWorld();
FreeOpaqueFaceList();
FreePatches();
#ifdef HLRAD_OPAQUE_NODE
DeleteOpaqueNodes ();
#endif
#ifdef ZHLT_EMBEDLIGHTMAP
#ifdef HLRAD_TEXTURE
EmbedLightmapInTextures ();
#endif
#endif
if (g_chart)
PrintBSPFileSizes();
#ifdef ZHLT_XASH
WriteDlitData (g_dlitfile);
free (g_ddlitdata);
g_ddlitdata = NULL;
#endif
WriteBSPFile(g_source);
end = I_FloatTime();
LogTimeElapsed(end - start);
// END RAD
#ifdef ZHLT_PARAMFILE
}
}
#endif
return 0;
}
Reference in a new issue Copy permalink