-/*\r
-Copyright (C) 1999-2007 id Software, Inc. and contributors.\r
-For a list of contributors, see the accompanying CONTRIBUTORS file.\r
-\r
-This file is part of GtkRadiant.\r
-\r
-GtkRadiant is free software; you can redistribute it and/or modify\r
-it under the terms of the GNU General Public License as published by\r
-the Free Software Foundation; either version 2 of the License, or\r
-(at your option) any later version.\r
-\r
-GtkRadiant is distributed in the hope that it will be useful,\r
-but WITHOUT ANY WARRANTY; without even the implied warranty of\r
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r
-GNU General Public License for more details.\r
-\r
-You should have received a copy of the GNU General Public License\r
-along with GtkRadiant; if not, write to the Free Software\r
-Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\r
-*/\r
-// qrad.c\r
-\r
-#include "qrad.h"\r
-\r
-\r
-\r
-/*\r
-\r
-NOTES\r
------\r
-\r
-every surface must be divided into at least two patches each axis\r
-\r
-*/\r
-\r
-patch_t *face_patches[MAX_MAP_FACES];\r
-entity_t *face_entity[MAX_MAP_FACES];\r
-patch_t patches[MAX_PATCHES];\r
-unsigned num_patches;\r
-\r
-vec3_t radiosity[MAX_PATCHES]; // light leaving a patch\r
-vec3_t illumination[MAX_PATCHES]; // light arriving at a patch\r
-\r
-vec3_t face_offset[MAX_MAP_FACES]; // for rotating bmodels\r
-dplane_t backplanes[MAX_MAP_PLANES];\r
-\r
-char inbase[32], outbase[32];\r
-\r
-int fakeplanes; // created planes for origin offset \r
-\r
-int numbounce = 8;\r
-qboolean extrasamples;\r
-\r
-float subdiv = 64;\r
-qboolean dumppatches;\r
-\r
-void BuildLightmaps (void);\r
-int TestLine (vec3_t start, vec3_t stop);\r
-\r
-int junk;\r
-\r
-float ambient = 0;\r
-float maxlight = 196;\r
-\r
-float lightscale = 1.0;\r
-\r
-qboolean glview;\r
-\r
-qboolean nopvs;\r
-\r
-char source[1024];\r
-\r
-float direct_scale = 0.4;\r
-float entity_scale = 1.0;\r
-\r
-/*\r
-===================================================================\r
-\r
-MISC\r
-\r
-===================================================================\r
-*/\r
-\r
-\r
-/*\r
-=============\r
-MakeBackplanes\r
-=============\r
-*/\r
-void MakeBackplanes (void)\r
-{\r
- int i;\r
-\r
- for (i=0 ; i<numplanes ; i++)\r
- {\r
- backplanes[i].dist = -dplanes[i].dist;\r
- VectorSubtract (vec3_origin, dplanes[i].normal, backplanes[i].normal);\r
- }\r
-}\r
-\r
-int leafparents[MAX_MAP_LEAFS];\r
-int nodeparents[MAX_MAP_NODES];\r
-\r
-/*\r
-=============\r
-MakeParents\r
-=============\r
-*/\r
-void MakeParents (int nodenum, int parent)\r
-{\r
- int i, j;\r
- dnode_t *node;\r
-\r
- nodeparents[nodenum] = parent;\r
- node = &dnodes[nodenum];\r
-\r
- for (i=0 ; i<2 ; i++)\r
- {\r
- j = node->children[i];\r
- if (j < 0)\r
- leafparents[-j - 1] = nodenum;\r
- else\r
- MakeParents (j, nodenum);\r
- }\r
-}\r
-\r
-\r
-/*\r
-===================================================================\r
-\r
-TRANSFER SCALES\r
-\r
-===================================================================\r
-*/\r
-\r
-int PointInLeafnum (vec3_t point)\r
-{\r
- int nodenum;\r
- vec_t dist;\r
- dnode_t *node;\r
- dplane_t *plane;\r
-\r
- nodenum = 0;\r
- while (nodenum >= 0)\r
- {\r
- node = &dnodes[nodenum];\r
- plane = &dplanes[node->planenum];\r
- dist = DotProduct (point, plane->normal) - plane->dist;\r
- if (dist > 0)\r
- nodenum = node->children[0];\r
- else\r
- nodenum = node->children[1];\r
- }\r
-\r
- return -nodenum - 1;\r
-}\r
-\r
-\r
-dleaf_t *Rad_PointInLeaf (vec3_t point)\r
-{\r
- int num;\r
-\r
- num = PointInLeafnum (point);\r
- return &dleafs[num];\r
-}\r
-\r
-\r
-qboolean PvsForOrigin (vec3_t org, byte *pvs)\r
-{\r
- dleaf_t *leaf;\r
-\r
- if (!visdatasize)\r
- {\r
- memset (pvs, 255, (numleafs+7)/8 );\r
- return true;\r
- }\r
-\r
- leaf = Rad_PointInLeaf (org);\r
- if (leaf->cluster == -1)\r
- return false; // in solid leaf\r
-\r
- DecompressVis (dvisdata + dvis->bitofs[leaf->cluster][DVIS_PVS], pvs);\r
- return true;\r
-}\r
-\r
-\r
-/*\r
-=============\r
-MakeTransfers\r
-\r
-=============\r
-*/\r
-int total_transfer;\r
-\r
-void MakeTransfers (int i)\r
-{\r
- int j;\r
- vec3_t delta;\r
- vec_t dist, scale;\r
- float trans;\r
- int itrans;\r
- patch_t *patch, *patch2;\r
- float total;\r
- dplane_t plane;\r
- vec3_t origin;\r
- float transfers[MAX_PATCHES], *all_transfers;\r
- int s;\r
- int itotal;\r
- byte pvs[(MAX_MAP_LEAFS+7)/8];\r
- int cluster;\r
-\r
- patch = patches + i;\r
- total = 0;\r
-\r
- VectorCopy (patch->origin, origin);\r
- plane = *patch->plane;\r
-\r
- if (!PvsForOrigin (patch->origin, pvs))\r
- return;\r
-\r
- // find out which patch2s will collect light\r
- // from patch\r
-\r
- all_transfers = transfers;\r
- patch->numtransfers = 0;\r
- for (j=0, patch2 = patches ; j<num_patches ; j++, patch2++)\r
- {\r
- transfers[j] = 0;\r
-\r
- if (j == i)\r
- continue;\r
-\r
- // check pvs bit\r
- if (!nopvs)\r
- {\r
- cluster = patch2->cluster;\r
- if (cluster == -1)\r
- continue;\r
- if ( ! ( pvs[cluster>>3] & (1<<(cluster&7)) ) )\r
- continue; // not in pvs\r
- }\r
-\r
- // calculate vector\r
- VectorSubtract (patch2->origin, origin, delta);\r
- dist = VectorNormalize (delta, delta);\r
- if (!dist)\r
- continue; // should never happen\r
-\r
- // reletive angles\r
- scale = DotProduct (delta, plane.normal);\r
- scale *= -DotProduct (delta, patch2->plane->normal);\r
- if (scale <= 0)\r
- continue;\r
-\r
- // check exact tramsfer\r
- if (TestLine_r (0, patch->origin, patch2->origin) )\r
- continue;\r
-\r
- trans = scale * patch2->area / (dist*dist);\r
-\r
- if (trans < 0)\r
- trans = 0; // rounding errors...\r
-\r
- transfers[j] = trans;\r
- if (trans > 0)\r
- {\r
- total += trans;\r
- patch->numtransfers++;\r
- }\r
- }\r
-\r
- // copy the transfers out and normalize\r
- // total should be somewhere near PI if everything went right\r
- // because partial occlusion isn't accounted for, and nearby\r
- // patches have underestimated form factors, it will usually\r
- // be higher than PI\r
- if (patch->numtransfers)\r
- {\r
- transfer_t *t;\r
- \r
- if (patch->numtransfers < 0 || patch->numtransfers > MAX_PATCHES)\r
- Error ("Weird numtransfers");\r
- s = patch->numtransfers * sizeof(transfer_t);\r
- patch->transfers = malloc (s);\r
- if (!patch->transfers)\r
- Error ("Memory allocation failure");\r
-\r
- //\r
- // normalize all transfers so all of the light\r
- // is transfered to the surroundings\r
- //\r
- t = patch->transfers;\r
- itotal = 0;\r
- for (j=0 ; j<num_patches ; j++)\r
- {\r
- if (transfers[j] <= 0)\r
- continue;\r
- itrans = transfers[j]*0x10000 / total;\r
- itotal += itrans;\r
- t->transfer = itrans;\r
- t->patch = j;\r
- t++;\r
- }\r
- }\r
-\r
- // don't bother locking around this. not that important.\r
- total_transfer += patch->numtransfers;\r
-}\r
-\r
-\r
-/*\r
-=============\r
-FreeTransfers\r
-=============\r
-*/\r
-void FreeTransfers (void)\r
-{\r
- int i;\r
-\r
- for (i=0 ; i<num_patches ; i++)\r
- {\r
- free (patches[i].transfers);\r
- patches[i].transfers = NULL;\r
- }\r
-}\r
-\r
-\r
-//===================================================================\r
-\r
-/*\r
-=============\r
-WriteWorld\r
-=============\r
-*/\r
-void WriteWorld (char *name)\r
-{\r
- int i, j;\r
- FILE *out;\r
- patch_t *patch;\r
- winding_t *w;\r
-\r
- out = fopen (name, "w");\r
- if (!out)\r
- Error ("Couldn't open %s", name);\r
-\r
- for (j=0, patch=patches ; j<num_patches ; j++, patch++)\r
- {\r
- w = patch->winding;\r
- fprintf (out, "%i\n", w->numpoints);\r
- for (i=0 ; i<w->numpoints ; i++)\r
- {\r
- fprintf (out, "%5.2f %5.2f %5.2f %5.3f %5.3f %5.3f\n",\r
- w->p[i][0],\r
- w->p[i][1],\r
- w->p[i][2],\r
- patch->totallight[0],\r
- patch->totallight[1],\r
- patch->totallight[2]);\r
- }\r
- fprintf (out, "\n");\r
- }\r
-\r
- fclose (out);\r
-}\r
-\r
-/*\r
-=============\r
-WriteGlView\r
-=============\r
-*/\r
-void WriteGlView (void)\r
-{\r
- char name[1024];\r
- FILE *f;\r
- int i, j;\r
- patch_t *p;\r
- winding_t *w;\r
-\r
- strcpy (name, source);\r
- StripExtension (name);\r
- strcat (name, ".glr");\r
-\r
- f = fopen (name, "w");\r
- if (!f)\r
- Error ("Couldn't open %s", f);\r
-\r
- for (j=0 ; j<num_patches ; j++)\r
- {\r
- p = &patches[j];\r
- w = p->winding;\r
- fprintf (f, "%i\n", w->numpoints);\r
- for (i=0 ; i<w->numpoints ; i++)\r
- {\r
- fprintf (f, "%5.2f %5.2f %5.2f %5.3f %5.3f %5.3f\n",\r
- w->p[i][0],\r
- w->p[i][1],\r
- w->p[i][2],\r
- p->totallight[0]/128,\r
- p->totallight[1]/128,\r
- p->totallight[2]/128);\r
- }\r
- fprintf (f, "\n");\r
- }\r
-\r
- fclose (f);\r
-}\r
-\r
-\r
-//==============================================================\r
-\r
-/*\r
-=============\r
-CollectLight\r
-=============\r
-*/\r
-float CollectLight (void)\r
-{\r
- int i, j;\r
- patch_t *patch;\r
- vec_t total;\r
-\r
- total = 0;\r
-\r
- for (i=0, patch=patches ; i<num_patches ; i++, patch++)\r
- {\r
- // skys never collect light, it is just dropped\r
- if (patch->sky)\r
- {\r
- VectorClear (radiosity[i]);\r
- VectorClear (illumination[i]);\r
- continue;\r
- }\r
-\r
- for (j=0 ; j<3 ; j++)\r
- {\r
- patch->totallight[j] += illumination[i][j] / patch->area;\r
- radiosity[i][j] = illumination[i][j] * patch->reflectivity[j];\r
- }\r
-\r
- total += radiosity[i][0] + radiosity[i][1] + radiosity[i][2];\r
- VectorClear (illumination[i]);\r
- }\r
-\r
- return total;\r
-}\r
-\r
-\r
-/*\r
-=============\r
-ShootLight\r
-\r
-Send light out to other patches\r
- Run multi-threaded\r
-=============\r
-*/\r
-void ShootLight (int patchnum)\r
-{\r
- int k, l;\r
- transfer_t *trans;\r
- int num;\r
- patch_t *patch;\r
- vec3_t send;\r
-\r
- // this is the amount of light we are distributing\r
- // prescale it so that multiplying by the 16 bit\r
- // transfer values gives a proper output value\r
- for (k=0 ; k<3 ; k++)\r
- send[k] = radiosity[patchnum][k] / 0x10000;\r
- patch = &patches[patchnum];\r
-\r
- trans = patch->transfers;\r
- num = patch->numtransfers;\r
-\r
- for (k=0 ; k<num ; k++, trans++)\r
- {\r
- for (l=0 ; l<3 ; l++)\r
- illumination[trans->patch][l] += send[l]*trans->transfer;\r
- }\r
-}\r
-\r
-/*\r
-=============\r
-BounceLight\r
-=============\r
-*/\r
-void BounceLight (void)\r
-{\r
- int i, j;\r
- float added;\r
- char name[64];\r
- patch_t *p;\r
-\r
- for (i=0 ; i<num_patches ; i++)\r
- {\r
- p = &patches[i];\r
- for (j=0 ; j<3 ; j++)\r
- {\r
-// p->totallight[j] = p->samplelight[j];\r
- radiosity[i][j] = p->samplelight[j] * p->reflectivity[j] * p->area;\r
- }\r
- }\r
-\r
- for (i=0 ; i<numbounce ; i++)\r
- {\r
- RunThreadsOnIndividual (num_patches, false, ShootLight);\r
- added = CollectLight ();\r
-\r
- Sys_FPrintf( SYS_VRB, "bounce:%i added:%f\n", i, added);\r
- if ( dumppatches && (i==0 || i == numbounce-1) )\r
- {\r
- sprintf (name, "bounce%i.txt", i);\r
- WriteWorld (name);\r
- }\r
- }\r
-}\r
-\r
-\r
-\r
-//==============================================================\r
-\r
-void CheckPatches (void)\r
-{\r
- int i;\r
- patch_t *patch;\r
-\r
- for (i=0 ; i<num_patches ; i++)\r
- {\r
- patch = &patches[i];\r
- if (patch->totallight[0] < 0 || patch->totallight[1] < 0 || patch->totallight[2] < 0)\r
- Error ("negative patch totallight\n");\r
- }\r
-}\r
-\r
-/*\r
-=============\r
-RadWorld\r
-=============\r
-*/\r
-void RadWorld (void)\r
-{\r
- if (numnodes == 0 || numfaces == 0)\r
- Error ("Empty map");\r
- MakeBackplanes ();\r
- MakeParents (0, -1);\r
- MakeTnodes (&dmodels[0]);\r
-\r
- // turn each face into a single patch\r
- MakePatches ();\r
-\r
- // subdivide patches to a maximum dimension\r
- SubdividePatches ();\r
-\r
- // create directlights out of patches and lights\r
- CreateDirectLights ();\r
-\r
- // build initial facelights\r
- RunThreadsOnIndividual (numfaces, true, BuildFacelights);\r
-\r
- if (numbounce > 0)\r
- {\r
- // build transfer lists\r
- RunThreadsOnIndividual (num_patches, true, MakeTransfers);\r
- Sys_FPrintf( SYS_VRB, "transfer lists: %5.1f megs\n"\r
- , (float)total_transfer * sizeof(transfer_t) / (1024*1024));\r
-\r
- // spread light around\r
- BounceLight ();\r
- \r
- FreeTransfers ();\r
-\r
- CheckPatches ();\r
- }\r
-\r
- if (glview)\r
- WriteGlView ();\r
-\r
- // blend bounced light into direct light and save\r
- PairEdges ();\r
- LinkPlaneFaces ();\r
-\r
- lightdatasize = 0;\r
- RunThreadsOnIndividual (numfaces, true, FinalLightFace);\r
-}\r
-\r
-\r
-/*\r
-========\r
-main\r
-\r
-light modelfile\r
-========\r
-*/\r
-int RAD_Main ()\r
-{\r
- double start, end;\r
- char name[1024];\r
- int total_rad_time;\r
-\r
- Sys_Printf ("\n----- RAD ----\n\n");\r
-\r
- if (maxlight > 255)\r
- maxlight = 255;\r
-\r
- start = I_FloatTime ();\r
-\r
- if ( !strcmp( game, "heretic2" ) )\r
- CalcTextureReflectivity = &CalcTextureReflectivity_Heretic2;\r
- else\r
- CalcTextureReflectivity = &CalcTextureReflectivity_Quake2;\r
- \r
- SetQdirFromPath (mapname); \r
- strcpy (source, ExpandArg(mapname));\r
- StripExtension (source);\r
- DefaultExtension (source, ".bsp");\r
-\r
-// ReadLightFile ();\r
-\r
- sprintf (name, "%s%s", inbase, source);\r
- Sys_Printf ("reading %s\n", name);\r
- LoadBSPFile (name);\r
- ParseEntities ();\r
- (*CalcTextureReflectivity) ();\r
-\r
- if (!visdatasize)\r
- {\r
- Sys_Printf ("No vis information, direct lighting only.\n");\r
- numbounce = 0;\r
- ambient = 0.1;\r
- }\r
-\r
- RadWorld ();\r
-\r
- sprintf (name, "%s%s", outbase, source);\r
- Sys_Printf ("writing %s\n", name);\r
- WriteBSPFile (name);\r
-\r
- end = I_FloatTime ();\r
- total_rad_time = (int) (end-start);\r
- Sys_Printf("\nRAD Time: ");\r
- if ( total_rad_time > 59 )\r
- Sys_Printf("%d Minutes ", total_rad_time/60 );\r
- Sys_Printf( "%d Seconds\n", total_rad_time%60 );\r
- \r
- \r
- return 0;\r
-}\r
-\r
+/*
+Copyright (C) 1999-2007 id Software, Inc. and contributors.
+For a list of contributors, see the accompanying CONTRIBUTORS file.
+
+This file is part of GtkRadiant.
+
+GtkRadiant is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+GtkRadiant is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GtkRadiant; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+*/
+// qrad.c
+
+#include "qrad.h"
+
+
+
+/*
+
+NOTES
+-----
+
+every surface must be divided into at least two patches each axis
+
+*/
+
+patch_t *face_patches[MAX_MAP_FACES];
+entity_t *face_entity[MAX_MAP_FACES];
+patch_t patches[MAX_PATCHES];
+unsigned num_patches;
+
+vec3_t radiosity[MAX_PATCHES]; // light leaving a patch
+vec3_t illumination[MAX_PATCHES]; // light arriving at a patch
+
+vec3_t face_offset[MAX_MAP_FACES]; // for rotating bmodels
+dplane_t backplanes[MAX_MAP_PLANES];
+
+char inbase[32], outbase[32];
+
+int fakeplanes; // created planes for origin offset
+
+int numbounce = 8;
+qboolean extrasamples;
+
+float subdiv = 64;
+qboolean dumppatches;
+
+void BuildLightmaps (void);
+int TestLine (vec3_t start, vec3_t stop);
+
+int junk;
+
+float ambient = 0;
+float maxlight = 196;
+
+float lightscale = 1.0;
+
+qboolean glview;
+
+qboolean nopvs;
+
+char source[1024];
+
+float direct_scale = 0.4;
+float entity_scale = 1.0;
+
+/*
+===================================================================
+
+MISC
+
+===================================================================
+*/
+
+
+/*
+=============
+MakeBackplanes
+=============
+*/
+void MakeBackplanes (void)
+{
+ int i;
+
+ for (i=0 ; i<numplanes ; i++)
+ {
+ backplanes[i].dist = -dplanes[i].dist;
+ VectorSubtract (vec3_origin, dplanes[i].normal, backplanes[i].normal);
+ }
+}
+
+int leafparents[MAX_MAP_LEAFS];
+int nodeparents[MAX_MAP_NODES];
+
+/*
+=============
+MakeParents
+=============
+*/
+void MakeParents (int nodenum, int parent)
+{
+ int i, j;
+ dnode_t *node;
+
+ nodeparents[nodenum] = parent;
+ node = &dnodes[nodenum];
+
+ for (i=0 ; i<2 ; i++)
+ {
+ j = node->children[i];
+ if (j < 0)
+ leafparents[-j - 1] = nodenum;
+ else
+ MakeParents (j, nodenum);
+ }
+}
+
+
+/*
+===================================================================
+
+TRANSFER SCALES
+
+===================================================================
+*/
+
+int PointInLeafnum (vec3_t point)
+{
+ int nodenum;
+ vec_t dist;
+ dnode_t *node;
+ dplane_t *plane;
+
+ nodenum = 0;
+ while (nodenum >= 0)
+ {
+ node = &dnodes[nodenum];
+ plane = &dplanes[node->planenum];
+ dist = DotProduct (point, plane->normal) - plane->dist;
+ if (dist > 0)
+ nodenum = node->children[0];
+ else
+ nodenum = node->children[1];
+ }
+
+ return -nodenum - 1;
+}
+
+
+dleaf_t *Rad_PointInLeaf (vec3_t point)
+{
+ int num;
+
+ num = PointInLeafnum (point);
+ return &dleafs[num];
+}
+
+
+qboolean PvsForOrigin (vec3_t org, byte *pvs)
+{
+ dleaf_t *leaf;
+
+ if (!visdatasize)
+ {
+ memset (pvs, 255, (numleafs+7)/8 );
+ return true;
+ }
+
+ leaf = Rad_PointInLeaf (org);
+ if (leaf->cluster == -1)
+ return false; // in solid leaf
+
+ DecompressVis (dvisdata + dvis->bitofs[leaf->cluster][DVIS_PVS], pvs);
+ return true;
+}
+
+
+/*
+=============
+MakeTransfers
+
+=============
+*/
+int total_transfer;
+
+void MakeTransfers (int i)
+{
+ int j;
+ vec3_t delta;
+ vec_t dist, scale;
+ float trans;
+ int itrans;
+ patch_t *patch, *patch2;
+ float total;
+ dplane_t plane;
+ vec3_t origin;
+ float transfers[MAX_PATCHES], *all_transfers;
+ int s;
+ int itotal;
+ byte pvs[(MAX_MAP_LEAFS+7)/8];
+ int cluster;
+
+ patch = patches + i;
+ total = 0;
+
+ VectorCopy (patch->origin, origin);
+ plane = *patch->plane;
+
+ if (!PvsForOrigin (patch->origin, pvs))
+ return;
+
+ // find out which patch2s will collect light
+ // from patch
+
+ all_transfers = transfers;
+ patch->numtransfers = 0;
+ for (j=0, patch2 = patches ; j<num_patches ; j++, patch2++)
+ {
+ transfers[j] = 0;
+
+ if (j == i)
+ continue;
+
+ // check pvs bit
+ if (!nopvs)
+ {
+ cluster = patch2->cluster;
+ if (cluster == -1)
+ continue;
+ if ( ! ( pvs[cluster>>3] & (1<<(cluster&7)) ) )
+ continue; // not in pvs
+ }
+
+ // calculate vector
+ VectorSubtract (patch2->origin, origin, delta);
+ dist = VectorNormalize (delta, delta);
+ if (!dist)
+ continue; // should never happen
+
+ // reletive angles
+ scale = DotProduct (delta, plane.normal);
+ scale *= -DotProduct (delta, patch2->plane->normal);
+ if (scale <= 0)
+ continue;
+
+ // check exact tramsfer
+ if (TestLine_r (0, patch->origin, patch2->origin) )
+ continue;
+
+ trans = scale * patch2->area / (dist*dist);
+
+ if (trans < 0)
+ trans = 0; // rounding errors...
+
+ transfers[j] = trans;
+ if (trans > 0)
+ {
+ total += trans;
+ patch->numtransfers++;
+ }
+ }
+
+ // copy the transfers out and normalize
+ // total should be somewhere near PI if everything went right
+ // because partial occlusion isn't accounted for, and nearby
+ // patches have underestimated form factors, it will usually
+ // be higher than PI
+ if (patch->numtransfers)
+ {
+ transfer_t *t;
+
+ if (patch->numtransfers < 0 || patch->numtransfers > MAX_PATCHES)
+ Error ("Weird numtransfers");
+ s = patch->numtransfers * sizeof(transfer_t);
+ patch->transfers = malloc (s);
+ if (!patch->transfers)
+ Error ("Memory allocation failure");
+
+ //
+ // normalize all transfers so all of the light
+ // is transfered to the surroundings
+ //
+ t = patch->transfers;
+ itotal = 0;
+ for (j=0 ; j<num_patches ; j++)
+ {
+ if (transfers[j] <= 0)
+ continue;
+ itrans = transfers[j]*0x10000 / total;
+ itotal += itrans;
+ t->transfer = itrans;
+ t->patch = j;
+ t++;
+ }
+ }
+
+ // don't bother locking around this. not that important.
+ total_transfer += patch->numtransfers;
+}
+
+
+/*
+=============
+FreeTransfers
+=============
+*/
+void FreeTransfers (void)
+{
+ int i;
+
+ for (i=0 ; i<num_patches ; i++)
+ {
+ free (patches[i].transfers);
+ patches[i].transfers = NULL;
+ }
+}
+
+
+//===================================================================
+
+/*
+=============
+WriteWorld
+=============
+*/
+void WriteWorld (char *name)
+{
+ int i, j;
+ FILE *out;
+ patch_t *patch;
+ winding_t *w;
+
+ out = fopen (name, "w");
+ if (!out)
+ Error ("Couldn't open %s", name);
+
+ for (j=0, patch=patches ; j<num_patches ; j++, patch++)
+ {
+ w = patch->winding;
+ fprintf (out, "%i\n", w->numpoints);
+ for (i=0 ; i<w->numpoints ; i++)
+ {
+ fprintf (out, "%5.2f %5.2f %5.2f %5.3f %5.3f %5.3f\n",
+ w->p[i][0],
+ w->p[i][1],
+ w->p[i][2],
+ patch->totallight[0],
+ patch->totallight[1],
+ patch->totallight[2]);
+ }
+ fprintf (out, "\n");
+ }
+
+ fclose (out);
+}
+
+/*
+=============
+WriteGlView
+=============
+*/
+void WriteGlView (void)
+{
+ char name[1024];
+ FILE *f;
+ int i, j;
+ patch_t *p;
+ winding_t *w;
+
+ strcpy (name, source);
+ StripExtension (name);
+ strcat (name, ".glr");
+
+ f = fopen (name, "w");
+ if (!f)
+ Error ("Couldn't open %s", f);
+
+ for (j=0 ; j<num_patches ; j++)
+ {
+ p = &patches[j];
+ w = p->winding;
+ fprintf (f, "%i\n", w->numpoints);
+ for (i=0 ; i<w->numpoints ; i++)
+ {
+ fprintf (f, "%5.2f %5.2f %5.2f %5.3f %5.3f %5.3f\n",
+ w->p[i][0],
+ w->p[i][1],
+ w->p[i][2],
+ p->totallight[0]/128,
+ p->totallight[1]/128,
+ p->totallight[2]/128);
+ }
+ fprintf (f, "\n");
+ }
+
+ fclose (f);
+}
+
+
+//==============================================================
+
+/*
+=============
+CollectLight
+=============
+*/
+float CollectLight (void)
+{
+ int i, j;
+ patch_t *patch;
+ vec_t total;
+
+ total = 0;
+
+ for (i=0, patch=patches ; i<num_patches ; i++, patch++)
+ {
+ // skys never collect light, it is just dropped
+ if (patch->sky)
+ {
+ VectorClear (radiosity[i]);
+ VectorClear (illumination[i]);
+ continue;
+ }
+
+ for (j=0 ; j<3 ; j++)
+ {
+ patch->totallight[j] += illumination[i][j] / patch->area;
+ radiosity[i][j] = illumination[i][j] * patch->reflectivity[j];
+ }
+
+ total += radiosity[i][0] + radiosity[i][1] + radiosity[i][2];
+ VectorClear (illumination[i]);
+ }
+
+ return total;
+}
+
+
+/*
+=============
+ShootLight
+
+Send light out to other patches
+ Run multi-threaded
+=============
+*/
+void ShootLight (int patchnum)
+{
+ int k, l;
+ transfer_t *trans;
+ int num;
+ patch_t *patch;
+ vec3_t send;
+
+ // this is the amount of light we are distributing
+ // prescale it so that multiplying by the 16 bit
+ // transfer values gives a proper output value
+ for (k=0 ; k<3 ; k++)
+ send[k] = radiosity[patchnum][k] / 0x10000;
+ patch = &patches[patchnum];
+
+ trans = patch->transfers;
+ num = patch->numtransfers;
+
+ for (k=0 ; k<num ; k++, trans++)
+ {
+ for (l=0 ; l<3 ; l++)
+ illumination[trans->patch][l] += send[l]*trans->transfer;
+ }
+}
+
+/*
+=============
+BounceLight
+=============
+*/
+void BounceLight (void)
+{
+ int i, j;
+ float added;
+ char name[64];
+ patch_t *p;
+
+ for (i=0 ; i<num_patches ; i++)
+ {
+ p = &patches[i];
+ for (j=0 ; j<3 ; j++)
+ {
+// p->totallight[j] = p->samplelight[j];
+ radiosity[i][j] = p->samplelight[j] * p->reflectivity[j] * p->area;
+ }
+ }
+
+ for (i=0 ; i<numbounce ; i++)
+ {
+ RunThreadsOnIndividual (num_patches, false, ShootLight);
+ added = CollectLight ();
+
+ Sys_FPrintf( SYS_VRB, "bounce:%i added:%f\n", i, added);
+ if ( dumppatches && (i==0 || i == numbounce-1) )
+ {
+ sprintf (name, "bounce%i.txt", i);
+ WriteWorld (name);
+ }
+ }
+}
+
+
+
+//==============================================================
+
+void CheckPatches (void)
+{
+ int i;
+ patch_t *patch;
+
+ for (i=0 ; i<num_patches ; i++)
+ {
+ patch = &patches[i];
+ if (patch->totallight[0] < 0 || patch->totallight[1] < 0 || patch->totallight[2] < 0)
+ Error ("negative patch totallight\n");
+ }
+}
+
+/*
+=============
+RadWorld
+=============
+*/
+void RadWorld (void)
+{
+ if (numnodes == 0 || numfaces == 0)
+ Error ("Empty map");
+ MakeBackplanes ();
+ MakeParents (0, -1);
+ MakeTnodes (&dmodels[0]);
+
+ // turn each face into a single patch
+ MakePatches ();
+
+ // subdivide patches to a maximum dimension
+ SubdividePatches ();
+
+ // create directlights out of patches and lights
+ CreateDirectLights ();
+
+ // build initial facelights
+ RunThreadsOnIndividual (numfaces, true, BuildFacelights);
+
+ if (numbounce > 0)
+ {
+ // build transfer lists
+ RunThreadsOnIndividual (num_patches, true, MakeTransfers);
+ Sys_FPrintf( SYS_VRB, "transfer lists: %5.1f megs\n"
+ , (float)total_transfer * sizeof(transfer_t) / (1024*1024));
+
+ // spread light around
+ BounceLight ();
+
+ FreeTransfers ();
+
+ CheckPatches ();
+ }
+
+ if (glview)
+ WriteGlView ();
+
+ // blend bounced light into direct light and save
+ PairEdges ();
+ LinkPlaneFaces ();
+
+ lightdatasize = 0;
+ RunThreadsOnIndividual (numfaces, true, FinalLightFace);
+}
+
+
+/*
+========
+main
+
+light modelfile
+========
+*/
+int RAD_Main ()
+{
+ double start, end;
+ char name[1024];
+ int total_rad_time;
+
+ Sys_Printf ("\n----- RAD ----\n\n");
+
+ if (maxlight > 255)
+ maxlight = 255;
+
+ start = I_FloatTime ();
+
+ if ( !strcmp( game, "heretic2" ) )
+ CalcTextureReflectivity = &CalcTextureReflectivity_Heretic2;
+ else
+ CalcTextureReflectivity = &CalcTextureReflectivity_Quake2;
+
+ SetQdirFromPath (mapname);
+ strcpy (source, ExpandArg(mapname));
+ StripExtension (source);
+ DefaultExtension (source, ".bsp");
+
+// ReadLightFile ();
+
+ sprintf (name, "%s%s", inbase, source);
+ Sys_Printf ("reading %s\n", name);
+ LoadBSPFile (name);
+ ParseEntities ();
+ (*CalcTextureReflectivity) ();
+
+ if (!visdatasize)
+ {
+ Sys_Printf ("No vis information, direct lighting only.\n");
+ numbounce = 0;
+ ambient = 0.1;
+ }
+
+ RadWorld ();
+
+ sprintf (name, "%s%s", outbase, source);
+ Sys_Printf ("writing %s\n", name);
+ WriteBSPFile (name);
+
+ end = I_FloatTime ();
+ total_rad_time = (int) (end-start);
+ Sys_Printf("\nRAD Time: ");
+ if ( total_rad_time > 59 )
+ Sys_Printf("%d Minutes ", total_rad_time/60 );
+ Sys_Printf( "%d Seconds\n", total_rad_time%60 );
+
+
+ return 0;
+}
+
projects / xonotic / netradiant.git / blobdiff