apply all of VorteX's changes except deviance (that one sucks :P)
authordivverent <divverent@61c419a2-8eb2-4b30-bcec-8cead039b335>
Sun, 29 Mar 2009 18:08:19 +0000 (18:08 +0000)
committerdivverent <divverent@61c419a2-8eb2-4b30-bcec-8cead039b335>
Sun, 29 Mar 2009 18:08:19 +0000 (18:08 +0000)
git-svn-id: svn://svn.icculus.org/netradiant/trunk@237 61c419a2-8eb2-4b30-bcec-8cead039b335

30 files changed:
tools/quake3/q3map2/game_darkplaces.h [new file with mode: 0644]
tools/quake3/q3map2/game_dq.h [new file with mode: 0644]
tools/quake3/q3map2/game_ef.h
tools/quake3/q3map2/game_etut.h
tools/quake3/q3map2/game_ja.h
tools/quake3/q3map2/game_jk2.h
tools/quake3/q3map2/game_nexuiz.h
tools/quake3/q3map2/game_prophecy.h [new file with mode: 0644]
tools/quake3/q3map2/game_qfusion.h
tools/quake3/q3map2/game_quake3.h
tools/quake3/q3map2/game_quakelive.h
tools/quake3/q3map2/game_sof2.h
tools/quake3/q3map2/game_tenebrae.h
tools/quake3/q3map2/game_tremulous.h
tools/quake3/q3map2/game_wolf.h
tools/quake3/q3map2/game_wolfet.h
tools/quake3/q3map2/light.c
tools/quake3/q3map2/light_trace.c
tools/quake3/q3map2/light_ydnar.c
tools/quake3/q3map2/lightmaps_ydnar.c
tools/quake3/q3map2/main.c
tools/quake3/q3map2/q3map2.h
tools/quake3/q3map2/q3map2_fsr_newfiles/game_darkplaces.h [deleted file]
tools/quake3/q3map2/q3map2_fsr_newfiles/game_dq.h [deleted file]
tools/quake3/q3map2/q3map2_fsr_newfiles/game_prophecy.h [deleted file]
tools/quake3/q3map2/q3map2_fsr_newfiles/q3map2_fsr_svn158.patch
tools/quake3/q3map2/shaders.c
tools/quake3/q3map2/surface.c
tools/quake3/q3map2/surface_meta.c
tools/quake3/q3map2/writebsp.c

diff --git a/tools/quake3/q3map2/game_darkplaces.h b/tools/quake3/q3map2/game_darkplaces.h
new file mode 100644 (file)
index 0000000..ad0334a
--- /dev/null
@@ -0,0 +1,143 @@
+/* -------------------------------------------------------------------------------\r
+\r
+Copyright (C) 1999-2006 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
+----------------------------------------------------------------------------------\r
+\r
+This code has been altered significantly from its original form, to support\r
+several games based on the Quake III Arena engine, in the form of "Q3Map2."\r
+\r
+------------------------------------------------------------------------------- */\r
+\r
+\r
+\r
+/* marker */\r
+#ifndef GAME_DARKPLACES_H\r
+#define GAME_DARKPLACES_H\r
+\r
+/* content and surface flags get form quake3 */\r
+\r
+/* -------------------------------------------------------------------------------\r
+\r
+game_t struct\r
+\r
+------------------------------------------------------------------------------- */\r
+\r
+{\r
+       "darkplaces",           /* -game x */\r
+       "id1",                          /* default base game data dir */\r
+       ".darkplaces ",         /* unix home sub-dir */\r
+       "darkplaces",           /* magic path word */\r
+       "scripts",                      /* shader directory */\r
+       999,                            /* max lightmapped surface verts */\r
+       999,                            /* max surface verts */\r
+       6000,                           /* max surface indexes */\r
+       qfalse,                         /* flares */\r
+       "flareshader",          /* default flare shader */\r
+       qfalse,                         /* wolf lighting model? */\r
+       128,                            /* lightmap width/height */\r
+       1.0f,                           /* lightmap gamma */\r
+       200.0f,                         /* lightmap exposure */\r
+       1.0f,                           /* lightmap compensate */\r
+       0.3f,                           /* lightgrid scale */\r
+       0.6f,                           /* lightgrid ambient scale */\r
+       qtrue,                          /* disable shader lightstyles hack */\r
+       qtrue,                          /* keep light entities on bsp */\r
+       4,                                      /* default patchMeta subdivisions tolerance */\r
+       qfalse,                         /* patch casting enabled */\r
+       qfalse,                         /* compile deluxemaps */\r
+       0,                                      /* deluxemaps default mode */\r
+       "IBSP",                         /* bsp file prefix */\r
+       46,                                     /* bsp file version */\r
+       qfalse,                         /* cod-style lump len/ofs order */\r
+       LoadIBSPFile,           /* bsp load function */\r
+       WriteIBSPFile,          /* bsp write function */\r
+\r
+       {\r
+               /* name                         contentFlags                            contentFlagsClear                       surfaceFlags                            surfaceFlagsClear                       compileFlags                            compileFlagsClear */\r
+               \r
+               /* default */\r
+               { "default",            Q_CONT_SOLID,                           -1,                                                     0,                                                      -1,                                                     C_SOLID,                                        -1 },\r
+               \r
+               \r
+               /* ydnar */\r
+               { "lightgrid",          0,                                                      0,                                                      0,                                                      0,                                                      C_LIGHTGRID,                            0 },\r
+               { "antiportal",         0,                                                      0,                                                      0,                                                      0,                                                      C_ANTIPORTAL,                           0 },\r
+               { "skip",                       0,                                                      0,                                                      0,                                                      0,                                                      C_SKIP,                                         0 },\r
+               \r
+               \r
+               /* compiler */\r
+               { "origin",                     Q_CONT_ORIGIN,                          Q_CONT_SOLID,                           0,                                                      0,                                                      C_ORIGIN | C_TRANSLUCENT,       C_SOLID },\r
+               { "areaportal",         Q_CONT_AREAPORTAL,                      Q_CONT_SOLID,                           0,                                                      0,                                                      C_AREAPORTAL | C_TRANSLUCENT,   C_SOLID },\r
+               { "trans",                      Q_CONT_TRANSLUCENT,                     0,                                                      0,                                                      0,                                                      C_TRANSLUCENT,                          0 },\r
+               { "detail",                     Q_CONT_DETAIL,                          0,                                                      0,                                                      0,                                                      C_DETAIL,                                       0 },\r
+               { "structural",         Q_CONT_STRUCTURAL,                      0,                                                      0,                                                      0,                                                      C_STRUCTURAL,                           0 },\r
+               { "hint",                       0,                                                      0,                                                      Q_SURF_HINT,                            0,                                                      C_HINT,                                         0 },\r
+               { "nodraw",                     0,                                                      0,                                                      Q_SURF_NODRAW,                          0,                                                      C_NODRAW,                                       0 },\r
+               \r
+               { "alphashadow",        0,                                                      0,                                                      Q_SURF_ALPHASHADOW,                     0,                                                      C_ALPHASHADOW | C_TRANSLUCENT,  0 },\r
+               { "lightfilter",        0,                                                      0,                                                      Q_SURF_LIGHTFILTER,                     0,                                                      C_LIGHTFILTER | C_TRANSLUCENT,  0 },\r
+               { "nolightmap",         0,                                                      0,                                                      Q_SURF_VERTEXLIT,                       0,                                                      C_VERTEXLIT,                            0 },\r
+               { "pointlight",         0,                                                      0,                                                      Q_SURF_VERTEXLIT,                       0,                                                      C_VERTEXLIT,                            0 },\r
+               \r
+               \r
+               /* game */\r
+               { "nonsolid",           0,                                                      Q_CONT_SOLID,                           Q_SURF_NONSOLID,                        0,                                                      0,                                                      C_SOLID },\r
+               \r
+               { "trigger",            Q_CONT_TRIGGER,                         Q_CONT_SOLID,                           0,                                                      0,                                                      C_TRANSLUCENT,                          C_SOLID },\r
+               \r
+               { "water",                      Q_CONT_WATER,                           Q_CONT_SOLID,                           0,                                                      0,                                                      C_LIQUID | C_TRANSLUCENT,       C_SOLID },\r
+               { "slime",                      Q_CONT_SLIME,                           Q_CONT_SOLID,                           0,                                                      0,                                                      C_LIQUID | C_TRANSLUCENT,       C_SOLID },\r
+               { "lava",                       Q_CONT_LAVA,                            Q_CONT_SOLID,                           0,                                                      0,                                                      C_LIQUID | C_TRANSLUCENT,       C_SOLID },\r
+               \r
+               { "playerclip",         Q_CONT_PLAYERCLIP,                      Q_CONT_SOLID,                           0,                                                      0,                                                      C_DETAIL | C_TRANSLUCENT,       C_SOLID },\r
+               { "monsterclip",        Q_CONT_MONSTERCLIP,                     Q_CONT_SOLID,                           0,                                                      0,                                                      C_DETAIL | C_TRANSLUCENT,       C_SOLID },\r
+               { "nodrop",                     Q_CONT_NODROP,                          Q_CONT_SOLID,                           0,                                                      0,                                                      C_TRANSLUCENT,                          C_SOLID },\r
+               \r
+               { "clusterportal",      Q_CONT_CLUSTERPORTAL,           Q_CONT_SOLID,                           0,                                                      0,                                                      C_TRANSLUCENT,                          C_SOLID },\r
+               { "donotenter",         Q_CONT_DONOTENTER,                      Q_CONT_SOLID,                           0,                                                      0,                                                      C_TRANSLUCENT,                          C_SOLID },\r
+               { "botclip",            Q_CONT_BOTCLIP,                         Q_CONT_SOLID,                           0,                                                      0,                                                      C_TRANSLUCENT,                          C_SOLID },\r
+               \r
+               { "fog",                        Q_CONT_FOG,                                     Q_CONT_SOLID,                           0,                                                      0,                                                      C_FOG,                                          C_SOLID },\r
+               { "sky",                        0,                                                      0,                                                      Q_SURF_SKY,                                     0,                                                      C_SKY,                                          0 },\r
+               \r
+               { "slick",                      0,                                                      0,                                                      Q_SURF_SLICK,                           0,                                                      0,                                                      0 },\r
+               \r
+               { "noimpact",           0,                                                      0,                                                      Q_SURF_NOIMPACT,                        0,                                                      0,                                                      0 },\r
+               { "nomarks",            0,                                                      0,                                                      Q_SURF_NOMARKS,                         0,                                                      C_NOMARKS,                                      0 },\r
+               { "ladder",                     0,                                                      0,                                                      Q_SURF_LADDER,                          0,                                                      0,                                                      0 },\r
+               { "nodamage",           0,                                                      0,                                                      Q_SURF_NODAMAGE,                        0,                                                      0,                                                      0 },\r
+               { "metalsteps",         0,                                                      0,                                                      Q_SURF_METALSTEPS,                      0,                                                      0,                                                      0 },\r
+               { "flesh",                      0,                                                      0,                                                      Q_SURF_FLESH,                           0,                                                      0,                                                      0 },\r
+               { "nosteps",            0,                                                      0,                                                      Q_SURF_NOSTEPS,                         0,                                                      0,                                                      0 },\r
+               { "nodlight",           0,                                                      0,                                                      Q_SURF_NODLIGHT,                        0,                                                      0,                                                      0 },\r
+               { "dust",                       0,                                                      0,                                                      Q_SURF_DUST,                            0,                                                      0,                                                      0 },\r
+               \r
+               \r
+               /* null */\r
+               { NULL, 0, 0, 0, 0, 0, 0 }\r
+       }\r
+}\r
+\r
+\r
+\r
+/* end marker */\r
+#endif\r
+\r
diff --git a/tools/quake3/q3map2/game_dq.h b/tools/quake3/q3map2/game_dq.h
new file mode 100644 (file)
index 0000000..f08fa2e
--- /dev/null
@@ -0,0 +1,143 @@
+/* -------------------------------------------------------------------------------\r
+\r
+Copyright (C) 1999-2006 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
+----------------------------------------------------------------------------------\r
+\r
+This code has been altered significantly from its original form, to support\r
+several games based on the Quake III Arena engine, in the form of "Q3Map2."\r
+\r
+------------------------------------------------------------------------------- */\r
+\r
+\r
+\r
+/* marker */\r
+#ifndef GAME_DQ_H\r
+#define GAME_DQ_H\r
+\r
+/* content and surface flags get form quake3 */\r
+\r
+/* -------------------------------------------------------------------------------\r
+\r
+game_t struct\r
+\r
+------------------------------------------------------------------------------- */\r
+\r
+{\r
+       "dq",                           /* -game x */\r
+       "basedq",                       /* default base game data dir */\r
+       ".dq",                          /* unix home sub-dir */\r
+       "dq",                           /* magic path word */\r
+       "scripts",                      /* shader directory */\r
+       64,                                     /* max lightmapped surface verts */\r
+       999,                            /* max surface verts */\r
+       6000,                           /* max surface indexes */\r
+       qfalse,                         /* flares */\r
+       "flareshader",          /* default flare shader */\r
+       qfalse,                         /* wolf lighting model? */\r
+       128,                            /* lightmap width/height */\r
+       1.2f,                           /* lightmap gamma */\r
+       200.0f,                         /* lightmap exposure */\r
+       1.0f,                           /* lightmap compensate */\r
+       0.3f,                           /* lightgrid scale */\r
+       0.6f,                           /* lightgrid ambient scale */\r
+       qtrue,                          /* disable shader lightstyles hack */\r
+       qtrue,                          /* keep light entities on bsp */\r
+       4,                                      /* default patchMeta subdivisions tolerance */\r
+       qtrue,                          /* patch casting enabled */\r
+       qtrue,                          /* compile deluxemaps */\r
+       1,                                      /* deluxemaps default mode */\r
+       "IBSP",                         /* bsp file prefix */\r
+       46,                                     /* bsp file version */\r
+       qfalse,                         /* cod-style lump len/ofs order */\r
+       LoadIBSPFile,           /* bsp load function */\r
+       WriteIBSPFile,          /* bsp write function */\r
+\r
+       {\r
+               /* name                         contentFlags                            contentFlagsClear                       surfaceFlags                            surfaceFlagsClear                       compileFlags                            compileFlagsClear */\r
+               \r
+               /* default */\r
+               { "default",            Q_CONT_SOLID,                           -1,                                                     0,                                                      -1,                                                     C_SOLID,                                        -1 },\r
+               \r
+               \r
+               /* ydnar */\r
+               { "lightgrid",          0,                                                      0,                                                      0,                                                      0,                                                      C_LIGHTGRID,                            0 },\r
+               { "antiportal",         0,                                                      0,                                                      0,                                                      0,                                                      C_ANTIPORTAL,                           0 },\r
+               { "skip",                       0,                                                      0,                                                      0,                                                      0,                                                      C_SKIP,                                         0 },\r
+               \r
+               \r
+               /* compiler */\r
+               { "origin",                     Q_CONT_ORIGIN,                          Q_CONT_SOLID,                           0,                                                      0,                                                      C_ORIGIN | C_TRANSLUCENT,       C_SOLID },\r
+               { "areaportal",         Q_CONT_AREAPORTAL,                      Q_CONT_SOLID,                           0,                                                      0,                                                      C_AREAPORTAL | C_TRANSLUCENT,   C_SOLID },\r
+               { "trans",                      Q_CONT_TRANSLUCENT,                     0,                                                      0,                                                      0,                                                      C_TRANSLUCENT,                          0 },\r
+               { "detail",                     Q_CONT_DETAIL,                          0,                                                      0,                                                      0,                                                      C_DETAIL,                                       0 },\r
+               { "structural",         Q_CONT_STRUCTURAL,                      0,                                                      0,                                                      0,                                                      C_STRUCTURAL,                           0 },\r
+               { "hint",                       0,                                                      0,                                                      Q_SURF_HINT,                            0,                                                      C_HINT,                                         0 },\r
+               { "nodraw",                     0,                                                      0,                                                      Q_SURF_NODRAW,                          0,                                                      C_NODRAW,                                       0 },\r
+               \r
+               { "alphashadow",        0,                                                      0,                                                      Q_SURF_ALPHASHADOW,                     0,                                                      C_ALPHASHADOW | C_TRANSLUCENT,  0 },\r
+               { "lightfilter",        0,                                                      0,                                                      Q_SURF_LIGHTFILTER,                     0,                                                      C_LIGHTFILTER | C_TRANSLUCENT,  0 },\r
+               { "nolightmap",         0,                                                      0,                                                      Q_SURF_VERTEXLIT,                       0,                                                      C_VERTEXLIT,                            0 },\r
+               { "pointlight",         0,                                                      0,                                                      Q_SURF_VERTEXLIT,                       0,                                                      C_VERTEXLIT,                            0 },\r
+               \r
+               \r
+               /* game */\r
+               { "nonsolid",           0,                                                      Q_CONT_SOLID,                           Q_SURF_NONSOLID,                        0,                                                      0,                                                      C_SOLID },\r
+               \r
+               { "trigger",            Q_CONT_TRIGGER,                         Q_CONT_SOLID,                           0,                                                      0,                                                      C_TRANSLUCENT,                          C_SOLID },\r
+               \r
+               { "water",                      Q_CONT_WATER,                           Q_CONT_SOLID,                           0,                                                      0,                                                      C_LIQUID | C_TRANSLUCENT,       C_SOLID },\r
+               { "slime",                      Q_CONT_SLIME,                           Q_CONT_SOLID,                           0,                                                      0,                                                      C_LIQUID | C_TRANSLUCENT,       C_SOLID },\r
+               { "lava",                       Q_CONT_LAVA,                            Q_CONT_SOLID,                           0,                                                      0,                                                      C_LIQUID | C_TRANSLUCENT,       C_SOLID },\r
+               \r
+               { "playerclip",         Q_CONT_PLAYERCLIP,                      Q_CONT_SOLID,                           0,                                                      0,                                                      C_DETAIL | C_TRANSLUCENT,       C_SOLID },\r
+               { "monsterclip",        Q_CONT_MONSTERCLIP,                     Q_CONT_SOLID,                           0,                                                      0,                                                      C_DETAIL | C_TRANSLUCENT,       C_SOLID },\r
+               { "nodrop",                     Q_CONT_NODROP,                          Q_CONT_SOLID,                           0,                                                      0,                                                      C_TRANSLUCENT,                          C_SOLID },\r
+               \r
+               { "clusterportal",      Q_CONT_CLUSTERPORTAL,           Q_CONT_SOLID,                           0,                                                      0,                                                      C_TRANSLUCENT,                          C_SOLID },\r
+               { "donotenter",         Q_CONT_DONOTENTER,                      Q_CONT_SOLID,                           0,                                                      0,                                                      C_TRANSLUCENT,                          C_SOLID },\r
+               { "botclip",            Q_CONT_BOTCLIP,                         Q_CONT_SOLID,                           0,                                                      0,                                                      C_TRANSLUCENT,                          C_SOLID },\r
+               \r
+               { "fog",                        Q_CONT_FOG,                                     Q_CONT_SOLID,                           0,                                                      0,                                                      C_FOG,                                          C_SOLID },\r
+               { "sky",                        0,                                                      0,                                                      Q_SURF_SKY,                                     0,                                                      C_SKY,                                          0 },\r
+               \r
+               { "slick",                      0,                                                      0,                                                      Q_SURF_SLICK,                           0,                                                      0,                                                      0 },\r
+               \r
+               { "noimpact",           0,                                                      0,                                                      Q_SURF_NOIMPACT,                        0,                                                      0,                                                      0 },\r
+               { "nomarks",            0,                                                      0,                                                      Q_SURF_NOMARKS,                         0,                                                      C_NOMARKS,                                      0 },\r
+               { "ladder",                     0,                                                      0,                                                      Q_SURF_LADDER,                          0,                                                      0,                                                      0 },\r
+               { "nodamage",           0,                                                      0,                                                      Q_SURF_NODAMAGE,                        0,                                                      0,                                                      0 },\r
+               { "metalsteps",         0,                                                      0,                                                      Q_SURF_METALSTEPS,                      0,                                                      0,                                                      0 },\r
+               { "flesh",                      0,                                                      0,                                                      Q_SURF_FLESH,                           0,                                                      0,                                                      0 },\r
+               { "nosteps",            0,                                                      0,                                                      Q_SURF_NOSTEPS,                         0,                                                      0,                                                      0 },\r
+               { "nodlight",           0,                                                      0,                                                      Q_SURF_NODLIGHT,                        0,                                                      0,                                                      0 },\r
+               { "dust",                       0,                                                      0,                                                      Q_SURF_DUST,                            0,                                                      0,                                                      0 },\r
+               \r
+               \r
+               /* null */\r
+               { NULL, 0, 0, 0, 0, 0, 0 }\r
+       }\r
+}\r
+\r
+\r
+\r
+/* end marker */\r
+#endif\r
+\r
index 7cf5a157293e2ea3ae9f6cf88527ed362ffe4b2a..4d06e37b5c04c742c35a4bcfffad9ba0ff8a3873 100644 (file)
@@ -115,6 +115,14 @@ game_t struct
        1.0f,                           /* lightmap gamma */
        1.0f,                           /* lightmap exposure */
        1.0f,                           /* lightmap compensate */
+       1.0f,                           /* lightgrid scale */
+       1.0f,                           /* lightgrid ambient scale */
+       qfalse,                         /* disable shader lightstyles hack */
+       qfalse,                         /* keep light entities on bsp */
+       8,                                      /* default patchMeta subdivisions tolerance */
+       qfalse,                         /* patch casting enabled */
+       qfalse,                         /* compile deluxemaps */
+       0,                                      /* deluxemaps default mode */
        "IBSP",                         /* bsp file prefix */
        46,                                     /* bsp file version */
        qfalse,                         /* cod-style lump len/ofs order */
index db7ec467973dd27088fcba57c664650e7a7fa6c6..9b7d55cd45b363c8888962fa43b584063f7f9f79 100644 (file)
@@ -150,6 +150,14 @@ game_t struct
        2.2f,                           /* lightmap gamma */
        1.0f,                           /* lightmap exposure */
        1.0f,                           /* lightmap compensate */
+       1.0f,                           /* lightgrid scale */
+       1.0f,                           /* lightgrid ambient scale */
+       qfalse,                         /* disable shader lightstyles hack */
+       qfalse,                         /* keep light entities on bsp */
+       8,                                      /* default patchMeta subdivisions tolerance */
+       qfalse,                         /* patch casting enabled */
+       qfalse,                         /* compile deluxemaps */
+       0,                                      /* deluxemaps default mode */
        "IBSP",                         /* bsp file prefix */
        46,                                     /* bsp file version */
        qfalse,                         /* cod-style lump len/ofs order */
index f1b9c3daac77047fc8ecb19c0a256f4780717646..d81b7f1719d90747e8cde909ac7bccbffedbb918 100644 (file)
@@ -69,6 +69,14 @@ game_t struct
        1.0f,                           /* lightmap gamma */
        1.0f,                           /* lightmap exposure */
        1.0f,                           /* lightmap compensate */
+       1.0f,                           /* lightgrid scale */
+       1.0f,                           /* lightgrid ambient scale */
+       qfalse,                         /* disable shader lightstyles hack */
+       qfalse,                         /* keep light entities on bsp */
+       8,                                      /* default patchMeta subdivisions tolerance */
+       qfalse,                         /* patch casting enabled */
+       qfalse,                         /* compile deluxemaps */
+       0,                                      /* deluxemaps default mode */
        "RBSP",                         /* bsp file prefix */
        1,                                      /* bsp file version */
        qfalse,                         /* cod-style lump len/ofs order */
index 3a28c7bb9b3f7a37a5e2e015232af15172e1da46..5f5b81de32ade2d9e8e6e12d0b97b1c7b729d0a6 100644 (file)
@@ -66,6 +66,14 @@ game_t struct
        1.0f,                           /* lightmap gamma */
        1.0f,                           /* lightmap exposure */
        1.0f,                           /* lightmap compensate */
+       1.0f,                           /* lightgrid scale */
+       1.0f,                           /* lightgrid ambient scale */
+       qfalse,                         /* disable shader lightstyles hack */
+       qfalse,                         /* keep light entities on bsp */
+       8,                                      /* default patchMeta subdivisions tolerance */
+       qfalse,                         /* patch casting enabled */
+       qfalse,                         /* compile deluxemaps */
+       0,                                      /* deluxemaps default mode */
        "RBSP",                         /* bsp file prefix */
        1,                                      /* bsp file version */
        qfalse,                         /* cod-style lump len/ofs order */
index 8ceab6113936bf1205873732afdb40b30bf11119..59a0bc9476094eb01fcb7e01a1fd3d0eeb03f034 100644 (file)
@@ -65,6 +65,14 @@ game_t struct
        1.0f,                           /* lightmap gamma */
        1.0f,                           /* lightmap exposure */
        1.0f,                           /* lightmap compensate */
+       1.0f,                           /* lightgrid scale */
+       1.0f,                           /* lightgrid ambient scale */
+       qtrue,                          /* disable shader lightstyles hack */
+       qtrue,                          /* keep light entities on bsp */
+       8,                                      /* default patchMeta subdivisions tolerance */
+       qfalse,                         /* patch casting enabled */
+       qfalse,                         /* compile deluxemaps */
+       0,                                      /* deluxemaps default mode */
        "IBSP",                         /* bsp file prefix */
        46,                                     /* bsp file version */
        qfalse,                         /* cod-style lump len/ofs order */
@@ -131,6 +139,7 @@ game_t struct
                { "nodlight",           0,                                                      0,                                                      Q_SURF_NODLIGHT,                        0,                                                      0,                                                      0 },
                { "dust",                       0,                                                      0,                                                      Q_SURF_DUST,                            0,                                                      0,                                                      0 },
                
+               
                /* null */
                { NULL, 0, 0, 0, 0, 0, 0 }
        }
diff --git a/tools/quake3/q3map2/game_prophecy.h b/tools/quake3/q3map2/game_prophecy.h
new file mode 100644 (file)
index 0000000..cd82649
--- /dev/null
@@ -0,0 +1,143 @@
+/* -------------------------------------------------------------------------------\r
+\r
+Copyright (C) 1999-2006 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
+----------------------------------------------------------------------------------\r
+\r
+This code has been altered significantly from its original form, to support\r
+several games based on the Quake III Arena engine, in the form of "Q3Map2."\r
+\r
+------------------------------------------------------------------------------- */\r
+\r
+\r
+\r
+/* marker */\r
+#ifndef GAME_PROPHECY_H\r
+#define GAME_PROPHECY_H\r
+\r
+/* content and surface flags get form quake3 */\r
+\r
+/* -------------------------------------------------------------------------------\r
+\r
+game_t struct\r
+\r
+------------------------------------------------------------------------------- */\r
+\r
+{\r
+       "prophecy",                     /* -game x */\r
+       "base",                         /* default base game data dir */\r
+       ".prophecy",            /* unix home sub-dir */\r
+       "prophecy",                     /* magic path word */\r
+       "scripts",                      /* shader directory */\r
+       64,                                     /* max lightmapped surface verts */\r
+       999,                            /* max surface verts */\r
+       6000,                           /* max surface indexes */\r
+       qfalse,                         /* flares */\r
+       "flareshader",          /* default flare shader */\r
+       qfalse,                         /* wolf lighting model? */\r
+       128,                            /* lightmap width/height */\r
+       1.0f,                           /* lightmap gamma */\r
+       200.0f,                         /* lightmap exposure */\r
+       1.0f,                           /* lightmap compensate */\r
+       0.4f,                           /* lightgrid scale */\r
+       0.6f,                           /* lightgrid ambient scale */\r
+       qtrue,                          /* disable shader lightstyles hack */\r
+       qtrue,                          /* keep light entities on bsp */\r
+       4,                                      /* default patchMeta subdivisions tolerance */\r
+       qtrue,                          /* patch casting enabled */\r
+       qtrue,                          /* compile deluxemaps */\r
+       0,                                      /* deluxemaps default mode */\r
+       "IBSP",                         /* bsp file prefix */\r
+       46,                                     /* bsp file version */\r
+       qfalse,                         /* cod-style lump len/ofs order */\r
+       LoadIBSPFile,           /* bsp load function */\r
+       WriteIBSPFile,          /* bsp write function */\r
+\r
+       {\r
+               /* name                         contentFlags                            contentFlagsClear                       surfaceFlags                            surfaceFlagsClear                       compileFlags                            compileFlagsClear */\r
+               \r
+               /* default */\r
+               { "default",            Q_CONT_SOLID,                           -1,                                                     0,                                                      -1,                                                     C_SOLID,                                        -1 },\r
+               \r
+               \r
+               /* ydnar */\r
+               { "lightgrid",          0,                                                      0,                                                      0,                                                      0,                                                      C_LIGHTGRID,                            0 },\r
+               { "antiportal",         0,                                                      0,                                                      0,                                                      0,                                                      C_ANTIPORTAL,                           0 },\r
+               { "skip",                       0,                                                      0,                                                      0,                                                      0,                                                      C_SKIP,                                         0 },\r
+               \r
+               \r
+               /* compiler */\r
+               { "origin",                     Q_CONT_ORIGIN,                          Q_CONT_SOLID,                           0,                                                      0,                                                      C_ORIGIN | C_TRANSLUCENT,       C_SOLID },\r
+               { "areaportal",         Q_CONT_AREAPORTAL,                      Q_CONT_SOLID,                           0,                                                      0,                                                      C_AREAPORTAL | C_TRANSLUCENT,   C_SOLID },\r
+               { "trans",                      Q_CONT_TRANSLUCENT,                     0,                                                      0,                                                      0,                                                      C_TRANSLUCENT,                          0 },\r
+               { "detail",                     Q_CONT_DETAIL,                          0,                                                      0,                                                      0,                                                      C_DETAIL,                                       0 },\r
+               { "structural",         Q_CONT_STRUCTURAL,                      0,                                                      0,                                                      0,                                                      C_STRUCTURAL,                           0 },\r
+               { "hint",                       0,                                                      0,                                                      Q_SURF_HINT,                            0,                                                      C_HINT,                                         0 },\r
+               { "nodraw",                     0,                                                      0,                                                      Q_SURF_NODRAW,                          0,                                                      C_NODRAW,                                       0 },\r
+               \r
+               { "alphashadow",        0,                                                      0,                                                      Q_SURF_ALPHASHADOW,                     0,                                                      C_ALPHASHADOW | C_TRANSLUCENT,  0 },\r
+               { "lightfilter",        0,                                                      0,                                                      Q_SURF_LIGHTFILTER,                     0,                                                      C_LIGHTFILTER | C_TRANSLUCENT,  0 },\r
+               { "nolightmap",         0,                                                      0,                                                      Q_SURF_VERTEXLIT,                       0,                                                      C_VERTEXLIT,                            0 },\r
+               { "pointlight",         0,                                                      0,                                                      Q_SURF_VERTEXLIT,                       0,                                                      C_VERTEXLIT,                            0 },\r
+               \r
+               \r
+               /* game */\r
+               { "nonsolid",           0,                                                      Q_CONT_SOLID,                           Q_SURF_NONSOLID,                        0,                                                      0,                                                      C_SOLID },\r
+               \r
+               { "trigger",            Q_CONT_TRIGGER,                         Q_CONT_SOLID,                           0,                                                      0,                                                      C_TRANSLUCENT,                          C_SOLID },\r
+               \r
+               { "water",                      Q_CONT_WATER,                           Q_CONT_SOLID,                           0,                                                      0,                                                      C_LIQUID | C_TRANSLUCENT,       C_SOLID },\r
+               { "slime",                      Q_CONT_SLIME,                           Q_CONT_SOLID,                           0,                                                      0,                                                      C_LIQUID | C_TRANSLUCENT,       C_SOLID },\r
+               { "lava",                       Q_CONT_LAVA,                            Q_CONT_SOLID,                           0,                                                      0,                                                      C_LIQUID | C_TRANSLUCENT,       C_SOLID },\r
+               \r
+               { "playerclip",         Q_CONT_PLAYERCLIP,                      Q_CONT_SOLID,                           0,                                                      0,                                                      C_DETAIL | C_TRANSLUCENT,       C_SOLID },\r
+               { "monsterclip",        Q_CONT_MONSTERCLIP,                     Q_CONT_SOLID,                           0,                                                      0,                                                      C_DETAIL | C_TRANSLUCENT,       C_SOLID },\r
+               { "nodrop",                     Q_CONT_NODROP,                          Q_CONT_SOLID,                           0,                                                      0,                                                      C_TRANSLUCENT,                          C_SOLID },\r
+               \r
+               { "clusterportal",      Q_CONT_CLUSTERPORTAL,           Q_CONT_SOLID,                           0,                                                      0,                                                      C_TRANSLUCENT,                          C_SOLID },\r
+               { "donotenter",         Q_CONT_DONOTENTER,                      Q_CONT_SOLID,                           0,                                                      0,                                                      C_TRANSLUCENT,                          C_SOLID },\r
+               { "botclip",            Q_CONT_BOTCLIP,                         Q_CONT_SOLID,                           0,                                                      0,                                                      C_TRANSLUCENT,                          C_SOLID },\r
+               \r
+               { "fog",                        Q_CONT_FOG,                                     Q_CONT_SOLID,                           0,                                                      0,                                                      C_FOG,                                          C_SOLID },\r
+               { "sky",                        0,                                                      0,                                                      Q_SURF_SKY,                                     0,                                                      C_SKY,                                          0 },\r
+               \r
+               { "slick",                      0,                                                      0,                                                      Q_SURF_SLICK,                           0,                                                      0,                                                      0 },\r
+               \r
+               { "noimpact",           0,                                                      0,                                                      Q_SURF_NOIMPACT,                        0,                                                      0,                                                      0 },\r
+               { "nomarks",            0,                                                      0,                                                      Q_SURF_NOMARKS,                         0,                                                      C_NOMARKS,                                      0 },\r
+               { "ladder",                     0,                                                      0,                                                      Q_SURF_LADDER,                          0,                                                      0,                                                      0 },\r
+               { "nodamage",           0,                                                      0,                                                      Q_SURF_NODAMAGE,                        0,                                                      0,                                                      0 },\r
+               { "metalsteps",         0,                                                      0,                                                      Q_SURF_METALSTEPS,                      0,                                                      0,                                                      0 },\r
+               { "flesh",                      0,                                                      0,                                                      Q_SURF_FLESH,                           0,                                                      0,                                                      0 },\r
+               { "nosteps",            0,                                                      0,                                                      Q_SURF_NOSTEPS,                         0,                                                      0,                                                      0 },\r
+               { "nodlight",           0,                                                      0,                                                      Q_SURF_NODLIGHT,                        0,                                                      0,                                                      0 },\r
+               { "dust",                       0,                                                      0,                                                      Q_SURF_DUST,                            0,                                                      0,                                                      0 },\r
+               \r
+               \r
+               /* null */\r
+               { NULL, 0, 0, 0, 0, 0, 0 }\r
+       }\r
+}\r
+\r
+\r
+\r
+/* end marker */\r
+#endif\r
+\r
index 25118ef10d0d516b3e844956dcd31cad2162b31e..6930552514643080fc88711439f10efd178e3060 100644 (file)
@@ -117,6 +117,14 @@ game_t struct
        1.0f,                           /* lightmap gamma */
        1.0f,                           /* lightmap exposure */
        1.0f,                           /* lightmap compensate */
+       1.0f,                           /* lightgrid scale */
+       1.0f,                           /* lightgrid ambient scale */
+       qfalse,                         /* disable shader lightstyles hack */
+       qfalse,                         /* keep light entities on bsp */
+       8,                                      /* default patchMeta subdivisions tolerance */
+       qfalse,                         /* patch casting enabled */
+       qfalse,                         /* compile deluxemaps */
+       0,                                      /* deluxemaps default mode */
        "FBSP",                         /* bsp file prefix */
        1,                                      /* bsp file version */
        qfalse,                         /* cod-style lump len/ofs order */
index b8d48fcecd8dad237195562ae6f13872ec2c0c51..76db0f8bf5e329e22f3ec767df4a83dfb33d0147 100644 (file)
@@ -114,6 +114,14 @@ game_t struct
        1.0f,                           /* lightmap gamma */
        1.0f,                           /* lightmap exposure */
        1.0f,                           /* lightmap compensate */
+       1.0f,                           /* lightgrid scale */
+       1.0f,                           /* lightgrid ambient scale */
+       qfalse,                         /* disable shader lightstyles hack */
+       qfalse,                         /* keep light entities on bsp */
+       8,                                      /* default patchMeta subdivisions tolerance */
+       qfalse,                         /* patch casting enabled */
+       qfalse,                         /* compile deluxemaps */
+       0,                                      /* deluxemaps default mode */
        "IBSP",                         /* bsp file prefix */
        46,                                     /* bsp file version */
        qfalse,                         /* cod-style lump len/ofs order */
index 26e1cb8023082e70cbd47bdbb6ca71ec9bdd46c2..f6c0647f8cf3a725ba5682d3f82564ee983d0e25 100644 (file)
@@ -66,6 +66,14 @@ game_t struct
        1.0f,                           /* lightmap gamma */
        1.0f,                           /* lightmap exposure */
        1.0f,                           /* lightmap compensate */
+       1.0f,                           /* lightgrid scale */
+       1.0f,                           /* lightgrid ambient scale */
+       qfalse,                         /* disable shader lightstyles hack */
+       qfalse,                         /* keep light entities on bsp */
+       8,                                      /* default patchMeta subdivisions tolerance */
+       qfalse,                         /* patch casting enabled */
+       qfalse,                         /* compile deluxemaps */
+       0,                                      /* deluxemaps default mode */
        "IBSP",                         /* bsp file prefix */
        47,                                     /* bsp file version */
        qfalse,                         /* cod-style lump len/ofs order */
index 6836e2869629cb944844cbd84cfb7dafb0527aa1..fafa7084b998001bc558223522004d77baafe202 100644 (file)
@@ -141,6 +141,14 @@ game_t struct
        1.0f,                                   /* lightmap gamma */
        1.0f,                                   /* lightmap exposure */
        1.0f,                                   /* lightmap compensate */
+       1.0f,                           /* lightgrid scale */
+       1.0f,                           /* lightgrid ambient scale */
+       qfalse,                         /* disable shader lightstyles hack */
+       qfalse,                         /* keep light entities on bsp */
+       8,                                      /* default patchMeta subdivisions tolerance */
+       qfalse,                         /* patch casting enabled */
+       qfalse,                         /* compile deluxemaps */
+       0,                                      /* deluxemaps default mode */
        "RBSP",                                 /* bsp file prefix */
        1,                                              /* bsp file version */
        qfalse,                                 /* cod-style lump len/ofs order */
index 83991350ae1d3c27e2a7bc734f7c60cd5fa35f54..2ab4205e921a308b44251086eb44c01c4e97a027 100644 (file)
@@ -114,6 +114,14 @@ game_t struct
        2.0f,                           /* lightmap gamma */
        1.0f,                           /* lightmap exposure */
        1.0f,                           /* lightmap compensate */
+       1.0f,                           /* lightgrid scale */
+       1.0f,                           /* lightgrid ambient scale */
+       qtrue,                          /* disable shader lightstyles hack */
+       qfalse,                         /* keep light entities on bsp */
+       8,                                      /* default patchMeta subdivisions tolerance */
+       qfalse,                         /* patch casting enabled */
+       qtrue,                          /* compile deluxemaps */
+       0,                                      /* deluxemaps default mode */
        "IBSP",                         /* bsp file prefix */
        46,                                     /* bsp file version */
        qfalse,                         /* cod-style lump len/ofs order */
index 958dd81d1d1910574292eff2987d12d815ced97d..d37e71273b42ba105949044969ef6069b0187cea 100644 (file)
@@ -72,6 +72,14 @@ game_t struct
        1.0f,                           /* lightmap gamma */
        1.0f,                           /* lightmap exposure */
        1.0f,                           /* lightmap compensate */
+       1.0f,                           /* lightgrid scale */
+       1.0f,                           /* lightgrid ambient scale */
+       qfalse,                         /* disable shader lightstyles hack */
+       qfalse,                         /* keep light entities on bsp */
+       8,                                      /* default patchMeta subdivisions tolerance */
+       qfalse,                         /* patch casting enabled */
+       qfalse,                         /* compile deluxemaps */
+       0,                                      /* deluxemaps default mode */
        "IBSP",                         /* bsp file prefix */
        46,                                     /* bsp file version */
        qfalse,                         /* cod-style lump len/ofs order */
index e029255deb978577b01459eafe7d75b75bab2658..a78bdc1a0641419fade88e21e27c1f87df8a889c 100644 (file)
@@ -131,6 +131,14 @@ game_t struct
        1.0f,                           /* lightmap gamma */
        1.0f,                           /* lightmap exposure */
        1.0f,                           /* lightmap compensate */
+       1.0f,                           /* lightgrid scale */
+       1.0f,                           /* lightgrid ambient scale */
+       qfalse,                         /* disable shader lightstyles hack */
+       qfalse,                         /* keep light entities on bsp */
+       8,                                      /* default patchMeta subdivisions tolerance */
+       qfalse,                         /* patch casting enabled */
+       qfalse,                         /* compile deluxemaps */
+       0,                                      /* deluxemaps default mode */
        "IBSP",                         /* bsp file prefix */
        46,                                     /* bsp file version */
        qfalse,                         /* cod-style lump len/ofs order */
index 077be85cd877c28f53103bcb6ccded0f054eddff..8c927d88d5c482e61a2de21aad2a3ee6f4b390b6 100644 (file)
@@ -68,6 +68,14 @@ game_t struct
        1.0f,                           /* lightmap gamma */
        1.0f,                           /* lightmap exposure */
        1.0f,                           /* lightmap compensate */
+       1.0f,                           /* lightgrid scale */
+       1.0f,                           /* lightgrid ambient scale */
+       qfalse,                         /* disable shader lightstyles hack */
+       qfalse,                         /* keep light entities on bsp */
+       8,                                      /* default patchMeta subdivisions tolerance */
+       qfalse,                         /* patch casting enabled */
+       qfalse,                         /* compile deluxemaps */
+       0,                                      /* deluxemaps default mode */
        "IBSP",                         /* bsp file prefix */
        46,                                     /* bsp file version */
        qfalse,                         /* cod-style lump len/ofs order */
index 811d6a7ee072d3974aee63c7edcde3d7120f505d..79ebf77fe4ea11d62933455e0a5da3549db84edb 100644 (file)
@@ -313,7 +313,15 @@ void CreateEntityLights( void )
                        flags |= LIGHT_GRID;
                        flags &= ~LIGHT_SURFACES;
                }
-               
+
+               /* vortex: unnormalized? */
+               if (spawnflags & 32)
+                       flags |= LIGHT_UNNORMALIZED;
+
+               /* vortex: distance atten? */
+               if (spawnflags & 64)
+                       flags |= LIGHT_ATTEN_DISTANCE;
+
                /* store the flags */
                light->flags = flags;
                
@@ -385,14 +393,16 @@ void CreateEntityLights( void )
                if( _color && _color[ 0 ] )
                {
                        sscanf( _color, "%f %f %f", &light->color[ 0 ], &light->color[ 1 ], &light->color[ 2 ] );
-                       ColorNormalize( light->color, light->color );
+                       if (!(light->flags & LIGHT_UNNORMALIZED))
+                       {
+                               ColorNormalize( light->color, light->color );
+                       }
                }
                else
                        light->color[ 0 ] = light->color[ 1 ] = light->color[ 2 ] = 1.0f;
-               
+
                intensity = intensity * pointScale;
                light->photons = intensity;
-               
                light->type = EMIT_POINT;
                
                /* set falloff threshold */
@@ -741,6 +751,7 @@ int LightContributionToSample( trace_t *trace )
        
        /* clear color */
        VectorClear( trace->color );
+       VectorClear( trace->colorNoShadow );
        
        /* ydnar: early out */
        if( !(light->flags & LIGHT_SURFACES) || light->envelope <= 0.0f )
@@ -766,7 +777,6 @@ int LightContributionToSample( trace_t *trace )
                float           d;
                vec3_t          pushedOrigin;
                
-               
                /* project sample point into light plane */
                d = DotProduct( trace->origin, light->normal ) - light->dist;
                if( d < 3.0f )
@@ -881,8 +891,7 @@ int LightContributionToSample( trace_t *trace )
                {
                        float   distByNormal, radiusAtDist, sampleRadius;
                        vec3_t  pointAtDist, distToSample;
-                       
-                       
+       
                        /* do cone calculation */
                        distByNormal = -DotProduct( trace->displacement, light->normal );
                        if( distByNormal < 0.0f )
@@ -922,6 +931,9 @@ int LightContributionToSample( trace_t *trace )
                add = light->photons * angle;
                if( add <= 0.0f )
                        return 0;
+
+               /* VorteX: set noShadow color */
+               VectorScale(light->color, add, trace->colorNoShadow);
                
                /* setup trace */
                trace->testAll = qtrue;
@@ -942,6 +954,9 @@ int LightContributionToSample( trace_t *trace )
                /* return to sender */
                return 1;
        }
+
+       /* VorteX: set noShadow color */
+       VectorScale(light->color, add, trace->colorNoShadow);
        
        /* ydnar: changed to a variable number */
        if( add <= 0.0f || (add <= light->falloffTolerance && (light->flags & LIGHT_FAST_ACTUAL)) )
@@ -1409,7 +1424,7 @@ void TraceGrid( int num )
                                trace.normal[2]=-1;
                        }
 
-                       f = FloodLightForSample(&trace);
+                       f = FloodLightForSample(&trace, floodlightDistance, floodlight_lowquality);
 
                        contributions[ numCon ].color[0]=col[0]*f;
                        contributions[ numCon ].color[1]=col[1]*f;
@@ -1470,6 +1485,9 @@ void TraceGrid( int num )
                
                /* ambient light will be at 1/4 the value of directed light */
                /* (ydnar: nuke this in favor of more dramatic lighting?) */
+               /* (PM: how about actually making it work? d=1 when it got here for single lights/sun :P */
+//             d = 0.25f;
+               /* (Hobbes: always setting it to .25 is hardly any better) */
                d = 0.25f * (1.0f - d);
                VectorMA( gp->ambient[ j ], d, contributions[ i ].color, gp->ambient[ j ] );
        }
@@ -1487,8 +1505,10 @@ void TraceGrid( int num )
                for( j = 0; j < 3; j++ )
                        if( color[ j ] < minGridLight[ j ] )
                                color[ j ] = minGridLight[ j ];
-               ColorToBytes( color, bgp->ambient[ i ], 1.0f );
-               ColorToBytes( gp->directed[ i ], bgp->directed[ i ], 1.0f );
+
+               /* vortex: apply gridscale and gridambientscale here */
+               ColorToBytes( color, bgp->ambient[ i ], gridScale*gridAmbientScale );
+               ColorToBytes( gp->directed[ i ], bgp->directed[ i ], gridScale );
        }
        
        /* debug code */
@@ -1711,12 +1731,8 @@ void LightWorld( void )
                RunThreadsOnIndividual( numRawLightmaps, qtrue, DirtyRawLightmap );
        }
        
-       /* floodlight them up */
-       if( floodlighty )
-       {
-               Sys_Printf( "--- FloodlightRawLightmap ---\n" );
-               RunThreadsOnIndividual( numRawLightmaps, qtrue, FloodLightRawLightmap );
-       }
+       /* floodlight pass */
+       FloodlightRawLightmaps();
 
        /* ydnar: set up light envelopes */
        SetupEnvelopes( qfalse, fast );
@@ -1832,12 +1848,64 @@ int LightMain( int argc, char **argv )
        
        /* note it */
        Sys_Printf( "--- Light ---\n" );
-       
+       Sys_Printf( "--- ProcessGameSpecific ---\n" );
+
        /* set standard game flags */
        wolfLight = game->wolfLight;
+       if (wolfLight == qtrue)
+               Sys_Printf( " lightning model: wolf\n" );
+       else
+               Sys_Printf( " lightning model: quake3\n" );
+
        lmCustomSize = game->lightmapSize;
+       Sys_Printf( " lightmap size: %d x %d pixels\n", lmCustomSize, lmCustomSize );
+
        lightmapGamma = game->lightmapGamma;
+       Sys_Printf( " lightning gamma: %f\n", lightmapGamma );
+
        lightmapCompensate = game->lightmapCompensate;
+       Sys_Printf( " lightning compensation: %f\n", lightmapCompensate );
+
+       lightmapExposure = game->lightmapExposure;
+       Sys_Printf( " lightning exposure: %f\n", lightmapExposure );
+
+       gridScale = game->gridScale;
+       Sys_Printf( " lightgrid scale: %f\n", gridScale );
+
+       gridAmbientScale = game->gridAmbientScale;
+       Sys_Printf( " lightgrid ambient scale: %f\n", gridAmbientScale );
+
+       noStyles = game->noStyles;
+       if (noStyles == qtrue)
+               Sys_Printf( " shader lightstyles hack: disabled\n" );
+       else
+               Sys_Printf( " shader lightstyles hack: enabled\n" );
+
+       keepLights = game->keepLights;
+       if (keepLights == qtrue)
+               Sys_Printf( " keep lights: enabled\n" );
+       else
+               Sys_Printf( " keep lights: disabled\n" );
+
+       patchShadows = game->patchShadows;
+       if (patchShadows == qtrue)
+               Sys_Printf( " patch shadows: enabled\n" );
+       else
+               Sys_Printf( " patch shadows: disabled\n" );
+
+       deluxemap = game->deluxeMap;
+       deluxemode = game->deluxeMode;
+       if (deluxemap == qtrue)
+       {
+               if (deluxemode)
+                       Sys_Printf( " deluxemapping: enabled with tangentspace deluxemaps\n" );
+               else
+                       Sys_Printf( " deluxemapping: enabled with modelspace deluxemaps\n" );
+       }
+       else
+               Sys_Printf( " deluxemapping: disabled\n" );
+
+       Sys_Printf( "--- ProcessCommandLine ---\n" );
        
        /* process commandline arguments */
        for( i = 1; i < (argc - 1); i++ )
@@ -1885,6 +1953,22 @@ int LightMain( int argc, char **argv )
                        Sys_Printf( "All light scaled by %f\n", f );
                        i++;
                }
+
+               else if( !strcmp( argv[ i ], "-gridscale" ) )
+               {
+                       f = atof( argv[ i + 1 ] );
+                       Sys_Printf( "Grid lightning scaled by %f\n", f );
+                       gridScale *= f;
+                       i++;
+               }
+
+               else if( !strcmp( argv[ i ], "-gridambientscale" ) )
+               {
+                       f = atof( argv[ i + 1 ] );
+                       Sys_Printf( "Grid ambient lightning scaled by %f\n", f );
+                       gridAmbientScale *= f;
+                       i++;
+               }
                
                else if( !strcmp( argv[ i ], "-gamma" ) )
                {
@@ -1955,12 +2039,6 @@ int LightMain( int argc, char **argv )
                        Sys_Printf( "Dark lightmap seams enabled\n" );
                }
                
-
-
-
-
-
-
                else if( !strcmp( argv[ i ], "-shadeangle" ) )
                {
                        shadeAngleDegrees = atof( argv[ i + 1 ] );
@@ -1993,13 +2071,28 @@ int LightMain( int argc, char **argv )
                                Sys_Printf( "Approximating lightmaps within a byte tolerance of %d\n", approximateTolerance );
                        i++;
                }
-               
                else if( !strcmp( argv[ i ], "-deluxe" ) || !strcmp( argv[ i ], "-deluxemap" ) )
                {
                        deluxemap = qtrue;
                        Sys_Printf( "Generating deluxemaps for average light direction\n" );
                }
-               
+               else if( !strcmp( argv[ i ], "-deluxemode" ))
+               {
+                       deluxemode = atoi( argv[ i + 1 ] );
+                       if (deluxemode == 0 || deluxemode > 1 || deluxemode < 0)
+                       {
+                               Sys_Printf( "Generating modelspace deluxemaps\n" );
+                               deluxemode = 0;
+                       }
+                       else 
+                               Sys_Printf( "Generating tangentspace deluxemaps\n" );
+                       i++;
+               }
+               else if( !strcmp( argv[ i ], "-nodeluxe" ) || !strcmp( argv[ i ], "-nodeluxemap" ) )
+               {
+                       deluxemap = qfalse;
+                       Sys_Printf( "Disabling generating of deluxemaps for average light direction\n" );
+               }
                else if( !strcmp( argv[ i ], "-external" ) )
                {
                        externalLightmaps = qtrue;
@@ -2234,6 +2327,12 @@ int LightMain( int argc, char **argv )
                        i++;
                        Sys_Printf( "Minimum lightmap sample size set to %dx%d units\n", minSampleSize, minSampleSize );
                }
+               else if( !strcmp( argv[ i ],  "-samplescale" ) )
+               {
+                       sampleScale = atoi( argv[ i + 1 ] );
+                       i++;
+                       Sys_Printf( "Lightmaps sample scale set to %d\n", sampleScale);
+               }
                else if( !strcmp( argv[ i ], "-novertex" ) )
                {
                        noVertexLighting = qtrue;
@@ -2269,6 +2368,16 @@ int LightMain( int argc, char **argv )
                        noStyles = qtrue;
                        Sys_Printf( "Disabling lightstyles\n" );
                }
+               else if( !strcmp( argv[ i ], "-style" ) || !strcmp( argv[ i ], "-styles" ) )
+               {
+                       noStyles = qfalse;
+                       Sys_Printf( "Enabling lightstyles\n" );
+               }
+               else if( !strcmp( argv[ i ], "-keeplights" ))
+               {
+                       keepLights = qtrue;
+                       Sys_Printf( "Leaving light entities on map after compile\n" );
+               }
                else if( !strcmp( argv[ i ], "-cpma" ) )
                {
                        cpmaHack = qtrue;
index 2a4e7e464b9fe84706f122940058a94f32ba2f41..42613bea0f90c132e5ea460117b99b4328b1c010 100644 (file)
@@ -56,7 +56,7 @@ several games based on the Quake III Arena engine, in the form of "Q3Map2."
 #define GROW_TRACE_NODES               16384           //%     16384
 #define GROW_NODE_ITEMS                        16                      //%     256
 
-#define MAX_TW_VERTS                   12
+#define MAX_TW_VERTS                   24 // vortex: increased from 12 to 24 for ability co compile some insane maps with large curve count
 
 #define        TRACE_ON_EPSILON                0.1f
 
index af1516dd6407a50a7b5526c8878707b29ceb3fe2..254a8c97bd1c60d596777d8d8870a60f5f3a0962 100644 (file)
@@ -2107,7 +2107,7 @@ void IlluminateRawLightmap( int rawLightmapNum )
                                                if(DotProduct(normal, trace.direction) > 0) // do not take light from the back side
                                                {
                                                        /* color to grayscale (photoshop rgb weighting) */
-                                                       brightness = trace.color[ 0 ] * 0.3f + trace.color[ 1 ] * 0.59f + trace.color[ 2 ] * 0.11f;
+                                                       brightness = trace.colorNoShadow[ 0 ] * 0.3f + trace.colorNoShadow[ 1 ] * 0.59f + trace.colorNoShadow[ 2 ] * 0.11f;
                                                        brightness *= (1.0 / 255.0);
                                                        VectorScale( trace.direction, brightness, trace.direction );
                                                        VectorAdd( deluxel, trace.direction, deluxel );
@@ -2346,56 +2346,8 @@ void IlluminateRawLightmap( int rawLightmapNum )
        /* free light list */
        FreeTraceLights( &trace );
        
-       /*      -----------------------------------------------------------------
-               floodlight pass
-               ----------------------------------------------------------------- */
-
-       if( floodlighty )
-       {
-               /* walk lightmaps */
-               for( lightmapNum = 0; lightmapNum < MAX_LIGHTMAPS; lightmapNum++ )
-               {
-                       /* early out */
-                       if( lm->superLuxels[ lightmapNum ] == NULL )
-                               continue;
-
-                       /* apply floodlight to each luxel */
-                       for( y = 0; y < lm->sh; y++ )
-                       {
-                               for( x = 0; x < lm->sw; x++ )
-                               {
-                                       /* get cluster */
-                                       cluster = SUPER_CLUSTER( x, y );
-                                       if( *cluster < 0 )
-                                               continue;
-
-                                       /* get particulars */
-                                       luxel = SUPER_LUXEL( lightmapNum, x, y );
-                                       floodlight = SUPER_FLOODLIGHT( x, y );
-
-                                       flood[0]=floodlightRGB[0]*floodlightIntensity;
-                                       flood[1]=floodlightRGB[1]*floodlightIntensity;
-                                       flood[2]=floodlightRGB[2]*floodlightIntensity;
-
-                                       /* scale light value */
-                                       VectorScale( flood, *floodlight, flood );
-                                       luxel[0]+=flood[0];
-                                       luxel[1]+=flood[1];
-                                       luxel[2]+=flood[2];
-
-                                       if (luxel[3]==0) luxel[3]=1;
-
-                                       if(deluxemap)
-                                       {
-                                               brightness = flood[ 0 ] * 0.3f + flood[ 1 ] * 0.59f + flood[ 2 ] * 0.11f;
-                                               brightness *= (1.0 / 255.0);
-                                               VectorScale( normal, brightness, temp );
-                                               VectorAdd( deluxel, temp, deluxel );
-                                       }
-                               }
-                       }
-               }
-       }
+       /* floodlight pass */
+       FloodlightIlluminateLightmap(lm);
 
        if (debugnormals)
        {
@@ -2404,7 +2356,7 @@ void IlluminateRawLightmap( int rawLightmapNum )
                        /* early out */
                        if( lm->superLuxels[ lightmapNum ] == NULL )
                                continue;
-
+                       
                        for( y = 0; y < lm->sh; y++ )
                        {
                                for( x = 0; x < lm->sw; x++ )
@@ -2413,11 +2365,11 @@ void IlluminateRawLightmap( int rawLightmapNum )
                                        cluster = SUPER_CLUSTER( x, y );
                                        //%     if( *cluster < 0 )
                                        //%             continue;
-
+                                       
                                        /* get particulars */
                                        luxel = SUPER_LUXEL( lightmapNum, x, y );
                                        normal = SUPER_NORMAL (  x, y );
-
+               
                                        luxel[0]=(normal[0]*127)+127;
                                        luxel[1]=(normal[1]*127)+127;
                                        luxel[2]=(normal[2]*127)+127;
@@ -2425,7 +2377,7 @@ void IlluminateRawLightmap( int rawLightmapNum )
                        }
                }
        }
-
+       
        /*      -----------------------------------------------------------------
                dirt pass
                ----------------------------------------------------------------- */
@@ -3908,24 +3860,145 @@ void SetupFloodLight( void )
        VectorNormalize(floodlightRGB,floodlightRGB);
 }
 
-//27 - lighttracer style ambient occlusion light hack.
-//Kudos to the dirtmapping author for most of this source.
-void FloodLightRawLightmap( int rawLightmapNum )
+/*
+FloodLightForSample()
+calculates floodlight value for a given sample
+once again, kudos to the dirtmapping coder
+*/
+
+float FloodLightForSample( trace_t *trace , float floodLightDistance, qboolean floodLightLowQuality)
 {
-       int                                     i, x, y, sx, sy, *cluster;
-       float                           *origin, *normal, *floodlight, *floodlight2, average, samples;
-       rawLightmap_t           *lm;
-       surfaceInfo_t           *info;
-       trace_t                         trace;
+       int             i;
+       float   d;
+       float   contribution;
+       int     sub = 0;
+       float   gatherLight, outLight;
+       vec3_t  normal, worldUp, myUp, myRt, direction, displacement;
+       float   dd;
+       int     vecs = 0;
+       gatherLight=0;
+       /* dummy check */
+       //if( !dirty )
+       //      return 1.0f;
+       if( trace == NULL || trace->cluster < 0 )
+               return 0.0f;
+       
 
-       /* bail if this number exceeds the number of raw lightmaps */
-       if( rawLightmapNum >= numRawLightmaps )
-               return;
+       /* setup */
+       dd = floodLightDistance;
+       VectorCopy( trace->normal, normal );
+       
+       /* check if the normal is aligned to the world-up */
+       if( normal[ 0 ] == 0.0f && normal[ 1 ] == 0.0f )
+       {
+               if( normal[ 2 ] == 1.0f )               
+               {
+                       VectorSet( myRt, 1.0f, 0.0f, 0.0f );
+                       VectorSet( myUp, 0.0f, 1.0f, 0.0f );
+               }
+               else if( normal[ 2 ] == -1.0f )
+               {
+                       VectorSet( myRt, -1.0f, 0.0f, 0.0f );
+                       VectorSet( myUp,  0.0f, 1.0f, 0.0f );
+               }
+       }
+       else
+       {
+               VectorSet( worldUp, 0.0f, 0.0f, 1.0f );
+               CrossProduct( normal, worldUp, myRt );
+               VectorNormalize( myRt, myRt );
+               CrossProduct( myRt, normal, myUp );
+               VectorNormalize( myUp, myUp );
+       }
 
-       /* get lightmap */
-       lm = &rawLightmaps[ rawLightmapNum ];
+       /* vortex: optimise floodLightLowQuality a bit */
+       if ( floodLightLowQuality == qtrue )
+    {
+               /* iterate through ordered vectors */
+               for( i = 0; i < numFloodVectors; i++ )
+                       if (rand()%10 != 0 ) continue;
+       }
+       else
+       {
+               /* iterate through ordered vectors */
+               for( i = 0; i < numFloodVectors; i++ )
+               {
+                       vecs++;
+                
+                       /* transform vector into tangent space */
+                       direction[ 0 ] = myRt[ 0 ] * floodVectors[ i ][ 0 ] + myUp[ 0 ] * floodVectors[ i ][ 1 ] + normal[ 0 ] * floodVectors[ i ][ 2 ];
+                       direction[ 1 ] = myRt[ 1 ] * floodVectors[ i ][ 0 ] + myUp[ 1 ] * floodVectors[ i ][ 1 ] + normal[ 1 ] * floodVectors[ i ][ 2 ];
+                       direction[ 2 ] = myRt[ 2 ] * floodVectors[ i ][ 0 ] + myUp[ 2 ] * floodVectors[ i ][ 1 ] + normal[ 2 ] * floodVectors[ i ][ 2 ];
+
+                       /* set endpoint */
+                       VectorMA( trace->origin, dd, direction, trace->end );
 
+                       //VectorMA( trace->origin, 1, direction, trace->origin );
+                               
+                       SetupTrace( trace );
+                       /* trace */
+                       TraceLine( trace );
+                       contribution=1;
+
+                       if (trace->compileFlags & C_SKY )
+                       {
+                               contribution=1.0f;
+                       }
+                       else if ( trace->opaque )
+                       {
+                               VectorSubtract( trace->hit, trace->origin, displacement );
+                               d=VectorLength( displacement );
+
+                               // d=trace->distance;            
+                               //if (d>256) gatherDirt+=1;
+                               contribution=d/dd;
+                               if (contribution>1) contribution=1.0f; 
+                    
+                               //gatherDirt += 1.0f - ooDepth * VectorLength( displacement );
+                       }
+                
+                       gatherLight+=contribution;
+               }
+       }
+   
+       /* early out */
+       if( gatherLight <= 0.0f )
+               return 0.0f;
+       
+       sub=vecs;
+
+       if (sub<1) sub=1;
+       gatherLight/=(sub);
+
+       outLight=gatherLight;
+       if( outLight > 1.0f )
+               outLight = 1.0f;
+       
+       /* return to sender */
+       return outLight;
+}
+
+/*
+FloodLightRawLightmap
+lighttracer style ambient occlusion light hack.
+Kudos to the dirtmapping author for most of this source.
+VorteX: modified to floodlight up custom surfaces (q3map_floodLight)
+VorteX: fixed problems with deluxemapping
+*/
+
+// floodlight pass on a lightmap
+void FloodLightRawLightmapPass( rawLightmap_t *lm , vec3_t lmFloodLightRGB, float lmFloodLightIntensity, float lmFloodLightDistance, qboolean lmFloodLightLowQuality, float floodlightDirectionScale)
+{
+       int                                     i, x, y, *cluster;
+       float                           *origin, *normal, *floodlight, floodLightAmount;
+       surfaceInfo_t           *info;
+       trace_t                         trace;
+       // int sx, sy;
+       // float samples, average, *floodlight2;
+       
        memset(&trace,0,sizeof(trace_t));
+
        /* setup trace */
        trace.testOcclusion = qtrue;
        trace.forceSunlight = qfalse;
@@ -3936,14 +4009,14 @@ void FloodLightRawLightmap( int rawLightmapNum )
        trace.inhibitRadius = DEFAULT_INHIBIT_RADIUS;
        trace.testAll = qfalse;
        trace.distance = 1024;
-
+       
        /* twosided lighting (may or may not be a good idea for lightmapped stuff) */
        //trace.twoSided = qfalse;
        for( i = 0; i < trace.numSurfaces; i++ )
        {
                /* get surface */
                info = &surfaceInfos[ trace.surfaces[ i ] ];
-
+               
                /* check twosidedness */
                if( info->si->twoSided )
                {
@@ -3951,8 +4024,8 @@ void FloodLightRawLightmap( int rawLightmapNum )
                        break;
                }
        }
-
-       /* gather dirt */
+       
+       /* gather floodlight */
        for( y = 0; y < lm->sh; y++ )
        {
                for( x = 0; x < lm->sw; x++ )
@@ -3962,29 +4035,35 @@ void FloodLightRawLightmap( int rawLightmapNum )
                        origin = SUPER_ORIGIN( x, y );
                        normal = SUPER_NORMAL( x, y );
                        floodlight = SUPER_FLOODLIGHT( x, y );
-
+                       
                        /* set default dirt */
                        *floodlight = 0.0f;
-
+                       
                        /* only look at mapped luxels */
                        if( *cluster < 0 )
                                continue;
-
+                       
                        /* copy to trace */
                        trace.cluster = *cluster;
                        VectorCopy( origin, trace.origin );
                        VectorCopy( normal, trace.normal );
-
-
-
-                       /* get dirt */
-                       *floodlight = FloodLightForSample( &trace );
+   
+                       /* get floodlight */
+                       floodLightAmount = FloodLightForSample( &trace , lmFloodLightDistance, lmFloodLightLowQuality)*lmFloodLightIntensity;
+                       
+                       /* add floodlight */
+                       floodlight[0] += lmFloodLightRGB[0]*floodLightAmount;
+                       floodlight[1] += lmFloodLightRGB[1]*floodLightAmount;
+                       floodlight[2] += lmFloodLightRGB[2]*floodLightAmount;
+                       floodlight[3] += floodlightDirectionScale;
                }
        }
-
+       
        /* testing no filtering */
        return;
 
+#if 0
+       
        /* filter "dirt" */
        for( y = 0; y < lm->sh; y++ )
        {
@@ -3992,8 +4071,8 @@ void FloodLightRawLightmap( int rawLightmapNum )
                {
                        /* get luxel */
                        cluster = SUPER_CLUSTER( x, y );
-                       floodlight = SUPER_FLOODLIGHT( x, y );
-
+                       floodlight = SUPER_FLOODLIGHT(x, y );
+                       
                        /* filter dirt by adjacency to unmapped luxels */
                        average = *floodlight;
                        samples = 1.0f;
@@ -4001,148 +4080,127 @@ void FloodLightRawLightmap( int rawLightmapNum )
                        {
                                if( sy < 0 || sy >= lm->sh )
                                        continue;
-
+                               
                                for( sx = (x - 1); sx <= (x + 1); sx++ )
                                {
                                        if( sx < 0 || sx >= lm->sw || (sx == x && sy == y) )
                                                continue;
-
+                                       
                                        /* get neighboring luxel */
                                        cluster = SUPER_CLUSTER( sx, sy );
                                        floodlight2 = SUPER_FLOODLIGHT( sx, sy );
                                        if( *cluster < 0 || *floodlight2 <= 0.0f )
                                                continue;
-
+                                       
                                        /* add it */
                                        average += *floodlight2;
                                        samples += 1.0f;
                                }
-
+                               
                                /* bail */
                                if( samples <= 0.0f )
                                        break;
                        }
-
+                       
                        /* bail */
                        if( samples <= 0.0f )
                                continue;
-
+                       
                        /* scale dirt */
                        *floodlight = average / samples;
                }
        }
+#endif
 }
 
-/*
-FloodLightForSample()
-calculates floodlight value for a given sample
-once again, kudos to the dirtmapping coder
-*/
-float FloodLightForSample( trace_t *trace )
+void FloodLightRawLightmap( int rawLightmapNum )
 {
-       int             i;
-       float   d;
-       float   contribution;
-       int     sub = 0;
-       float   gatherLight, outLight;
-       vec3_t  normal, worldUp, myUp, myRt, direction, displacement;
-       float   dd;
-       int     vecs = 0;
-
-       gatherLight=0;
-       /* dummy check */
-       //if( !dirty )
-       //      return 1.0f;
-       if( trace == NULL || trace->cluster < 0 )
-               return 0.0f;
+       rawLightmap_t           *lm;
 
+       /* bail if this number exceeds the number of raw lightmaps */
+       if( rawLightmapNum >= numRawLightmaps )
+               return;
+       /* get lightmap */
+       lm = &rawLightmaps[ rawLightmapNum ];
 
-       /* setup */
-       dd = floodlightDistance;
-       VectorCopy( trace->normal, normal );
+       /* global pass */
+       if (floodlighty && floodlightIntensity)
+               FloodLightRawLightmapPass(lm, floodlightRGB, floodlightIntensity, floodlightDistance, floodlight_lowquality, 0);
 
-       /* check if the normal is aligned to the world-up */
-       if( normal[ 0 ] == 0.0f && normal[ 1 ] == 0.0f )
+       /* custom pass */
+       if (lm->floodlightIntensity)
        {
-               if( normal[ 2 ] == 1.0f )
-               {
-                       VectorSet( myRt, 1.0f, 0.0f, 0.0f );
-                       VectorSet( myUp, 0.0f, 1.0f, 0.0f );
-               }
-               else if( normal[ 2 ] == -1.0f )
-               {
-                       VectorSet( myRt, -1.0f, 0.0f, 0.0f );
-                       VectorSet( myUp,  0.0f, 1.0f, 0.0f );
-               }
-       }
-       else
-       {
-               VectorSet( worldUp, 0.0f, 0.0f, 1.0f );
-               CrossProduct( normal, worldUp, myRt );
-               VectorNormalize( myRt, myRt );
-               CrossProduct( myRt, normal, myUp );
-               VectorNormalize( myUp, myUp );
+               FloodLightRawLightmapPass(lm, lm->floodlightRGB, lm->floodlightIntensity, lm->floodlightDistance, qfalse, lm->floodlightDirectionScale);
+               numSurfacesFloodlighten += 1;
        }
+}
 
-       /* iterate through ordered vectors */
-       for( i = 0; i < numFloodVectors; i++ )
-       {
-               if (floodlight_lowquality==qtrue)
-        {
-                       if (rand()%10 != 0 ) continue;
-               }
-
-               vecs++;
-
-               /* transform vector into tangent space */
-               direction[ 0 ] = myRt[ 0 ] * floodVectors[ i ][ 0 ] + myUp[ 0 ] * floodVectors[ i ][ 1 ] + normal[ 0 ] * floodVectors[ i ][ 2 ];
-               direction[ 1 ] = myRt[ 1 ] * floodVectors[ i ][ 0 ] + myUp[ 1 ] * floodVectors[ i ][ 1 ] + normal[ 1 ] * floodVectors[ i ][ 2 ];
-               direction[ 2 ] = myRt[ 2 ] * floodVectors[ i ][ 0 ] + myUp[ 2 ] * floodVectors[ i ][ 1 ] + normal[ 2 ] * floodVectors[ i ][ 2 ];
+void FloodlightRawLightmaps()
+{
+       Sys_Printf( "--- FloodlightRawLightmap ---\n" );
+       numSurfacesFloodlighten = 0;
+       RunThreadsOnIndividual( numRawLightmaps, qtrue, FloodLightRawLightmap );
+       Sys_Printf( "%9d custom lightmaps floodlighted\n", numSurfacesFloodlighten );
+}
 
-               /* set endpoint */
-               VectorMA( trace->origin, dd, direction, trace->end );
+/*
+FloodLightIlluminate()
+illuminate floodlight into lightmap luxels
+*/
 
-               //VectorMA( trace->origin, 1, direction, trace->origin );
+void FloodlightIlluminateLightmap( rawLightmap_t *lm )
+{
+       float                           *luxel, *floodlight, *deluxel, *normal;
+       int                                     *cluster;
+       float                           brightness;
+       vec3_t                          lightvector;
+       int                                     x, y, lightmapNum;
 
-               SetupTrace( trace );
-               /* trace */
-               TraceLine( trace );
-               contribution=1;
+       /* walk lightmaps */
+       for( lightmapNum = 0; lightmapNum < MAX_LIGHTMAPS; lightmapNum++ )
+       {
+               /* early out */
+               if( lm->superLuxels[ lightmapNum ] == NULL )
+                       continue;
 
-               if (trace->compileFlags & C_SKY )
-               {
-                       contribution=1.0f;
-               }
-               else if ( trace->opaque )
+               /* apply floodlight to each luxel */
+               for( y = 0; y < lm->sh; y++ )
                {
-                       VectorSubtract( trace->hit, trace->origin, displacement );
-                       d=VectorLength( displacement );
-
-                       // d=trace->distance;
-                       //if (d>256) gatherDirt+=1;
-                       contribution=d/dd;
-                       if (contribution>1) contribution=1.0f;
-
-                       //gatherDirt += 1.0f - ooDepth * VectorLength( displacement );
-               }
-
-               gatherLight+=contribution;
-       }
+                       for( x = 0; x < lm->sw; x++ )
+                       {
+                               /* get floodlight */
+                               floodlight = SUPER_FLOODLIGHT( x, y );
+                               if (!floodlight[0] && !floodlight[1] && !floodlight[2])
+                                       continue;
+                                               
+                               /* get cluster */
+                               cluster = SUPER_CLUSTER( x, y );
 
-       /* early out */
-       if( gatherLight <= 0.0f )
-               return 0.0f;
+                               /* only process mapped luxels */
+                               if( *cluster < 0 )
+                                       continue;
 
-       sub=vecs;
+                               /* get particulars */
+                               luxel = SUPER_LUXEL( lightmapNum, x, y );
+                               deluxel = SUPER_DELUXEL( x, y );
 
-       if (sub<1) sub=1;
-       gatherLight/=(sub);
+                               /* add to lightmap */
+                               luxel[0]+=floodlight[0];
+                               luxel[1]+=floodlight[1];
+                               luxel[2]+=floodlight[2];
 
-       outLight=gatherLight;
-       if( outLight > 1.0f )
-               outLight = 1.0f;
+                               if (luxel[3]==0) luxel[3]=1;
 
-       /* return to sender */
-       return outLight;
+                               /* add to deluxemap */
+                               if (deluxemap && floodlight[3] > 0)
+                               {
+                                       normal = SUPER_NORMAL( x, y );
+                                       brightness = floodlight[ 0 ] * 0.3f + floodlight[ 1 ] * 0.59f + floodlight[ 2 ] * 0.11f;
+                                       brightness *= ( 1.0f / 255.0f ) * floodlight[3];
+                                       VectorScale( normal, brightness, lightvector );
+                                       VectorAdd( deluxel, lightvector, deluxel );
+                               }
+                       }
+               }
+       }
 }
-
index 57375b601e2b7c984d59b1afd9bcbee45b244fc0..1c994ebf50f037be909c82543b935c063306704d 100644 (file)
@@ -1111,12 +1111,20 @@ void SetupSurfaceLightmaps( void )
                lm->splotchFix = info->si->splotchFix;
                lm->firstLightSurface = numLightSurfaces;
                lm->numLightSurfaces = 0;
-               lm->sampleSize = info->sampleSize;
-               lm->actualSampleSize = info->sampleSize;
+               /* vortex: multiply lightmap sample size by -samplescale */
+               if (sampleScale > 0)
+                       lm->sampleSize = info->sampleSize*sampleScale;
+               else
+                       lm->sampleSize = info->sampleSize;
+               lm->actualSampleSize = lm->sampleSize;
                lm->entityNum = info->entityNum;
                lm->recvShadows = info->recvShadows;
                lm->brightness = info->si->lmBrightness;
                lm->filterRadius = info->si->lmFilterRadius;
+               VectorCopy(info->si->floodlightRGB, lm->floodlightRGB);
+               lm->floodlightDistance = info->si->floodlightDistance;
+               lm->floodlightIntensity = info->si->floodlightIntensity;
+               lm->floodlightDirectionScale = info->si->floodlightDirectionScale;
                VectorCopy( info->axis, lm->axis );
                lm->plane = info->plane;        
                VectorCopy( info->mins, lm->mins );
@@ -2295,7 +2303,7 @@ void StoreSurfaceLightmaps( void )
           ----------------------------------------------------------------- */
        
        /* note it */
-       Sys_FPrintf( SYS_VRB, "Subsampling..." );
+       Sys_Printf( "Subsampling..." );
        
        /* walk the list of raw lightmaps */
        numUsed = 0;
@@ -2631,6 +2639,135 @@ void StoreSurfaceLightmaps( void )
                }
        }
        
+       /* -----------------------------------------------------------------
+          convert modelspace deluxemaps to tangentspace
+          ----------------------------------------------------------------- */
+       /* note it */
+       if( !bouncing )
+       {
+               if( deluxemap && deluxemode == 1)
+               {
+                       vec3_t  worldUp, myNormal, myTangent, myBinormal;
+                       float dist;
+
+                       Sys_Printf( "converting..." );
+
+                       for( i = 0; i < numRawLightmaps; i++ )
+                       {
+                               /* get lightmap */
+                               lm = &rawLightmaps[ i ];
+
+                               /* walk lightmap samples */
+                               for( y = 0; y < lm->sh; y++ )
+                               {
+                                       for( x = 0; x < lm->sw; x++ )
+                                       {
+                                               /* get normal and deluxel */
+                                               normal = SUPER_NORMAL(x, y);
+                                               cluster = SUPER_CLUSTER(x, y);
+                                               bspDeluxel = BSP_DELUXEL( x, y );
+                                               deluxel = SUPER_DELUXEL( x, y ); 
+
+                                               /* get normal */
+                                               VectorSet( myNormal, normal[0], normal[1], normal[2] );
+               
+                                               /* get tangent vectors */
+                                               if( myNormal[ 0 ] == 0.0f && myNormal[ 1 ] == 0.0f )
+                                               {
+                                                       if( myNormal[ 2 ] == 1.0f )             
+                                                       {
+                                                               VectorSet( myTangent, 1.0f, 0.0f, 0.0f );
+                                                               VectorSet( myBinormal, 0.0f, 1.0f, 0.0f );
+                                                       }
+                                                       else if( myNormal[ 2 ] == -1.0f )
+                                                       {
+                                                               VectorSet( myTangent, -1.0f, 0.0f, 0.0f );
+                                                               VectorSet( myBinormal,  0.0f, 1.0f, 0.0f );
+                                                       }
+                                               }
+                                               else
+                                               {
+                                                       VectorSet( worldUp, 0.0f, 0.0f, 1.0f );
+                                                       CrossProduct( myNormal, worldUp, myTangent );
+                                                       VectorNormalize( myTangent, myTangent );
+                                                       CrossProduct( myTangent, myNormal, myBinormal );
+                                                       VectorNormalize( myBinormal, myBinormal );
+                                               }
+
+                                               /* project onto plane */
+                                               dist = -DotProduct(myTangent, myNormal); 
+                                               VectorMA(myTangent, dist, myNormal, myTangent);
+                                               dist = -DotProduct(myBinormal, myNormal); 
+                                               VectorMA(myBinormal, dist, myNormal, myBinormal);
+
+                                               /* renormalize */
+                                               VectorNormalize( myTangent, myTangent );
+                                               VectorNormalize( myBinormal, myBinormal );
+
+                                               /* convert modelspace deluxel to tangentspace */
+                                               dirSample[0] = bspDeluxel[0];
+                                               dirSample[1] = bspDeluxel[1];
+                                               dirSample[2] = bspDeluxel[2];
+                                               VectorNormalize(dirSample, dirSample);
+
+                                               /* fix tangents to world matrix */
+                                               if (myNormal[0] > 0 || myNormal[1] < 0 || myNormal[2] < 0)
+                                                       VectorNegate(myTangent, myTangent);
+
+                                               /* build tangentspace vectors */
+                                               bspDeluxel[0] = DotProduct(dirSample, myTangent);
+                                               bspDeluxel[1] = DotProduct(dirSample, myBinormal);
+                                               bspDeluxel[2] = DotProduct(dirSample, myNormal);
+                                       }
+                               }
+                       }
+               }
+       }
+
+       /* -----------------------------------------------------------------
+          blend lightmaps
+          ----------------------------------------------------------------- */
+
+#ifdef sdfsdfwq312323
+       /* note it */
+       Sys_Printf( "blending..." );
+
+       for( i = 0; i < numRawLightmaps; i++ )
+       {
+               vec3_t  myColor;
+               float myBrightness;
+
+               /* get lightmap */
+               lm = &rawLightmaps[ i ];
+
+               /* walk individual lightmaps */
+               for( lightmapNum = 0; lightmapNum < MAX_LIGHTMAPS; lightmapNum++ )
+               {
+                       /* early outs */
+                       if( lm->superLuxels[ lightmapNum ] == NULL )
+                               continue;
+
+                       /* walk lightmap samples */
+                       for( y = 0; y < lm->sh; y++ )
+                       {
+                               for( x = 0; x < lm->sw; x++ )
+                               {
+                                       /* get luxel */
+                                       bspLuxel = BSP_LUXEL( lightmapNum, x, y );
+
+                                       /* get color */
+                                       VectorNormalize(bspLuxel, myColor);
+                                       myBrightness = VectorLength(bspLuxel);
+                                       myBrightness *= (1 / 127.0f);
+                                       myBrightness = myBrightness*myBrightness;
+                                       myBrightness *= 127.0f;
+                                       VectorScale(myColor, myBrightness, bspLuxel);
+                               }
+                       }
+               }
+       }
+#endif
+
        /* -----------------------------------------------------------------
           collapse non-unique lightmaps
           ----------------------------------------------------------------- */
@@ -2638,7 +2775,7 @@ void StoreSurfaceLightmaps( void )
        if( noCollapse == qfalse && deluxemap == qfalse )
        {
                /* note it */
-               Sys_FPrintf( SYS_VRB, "collapsing..." );
+               Sys_Printf( "collapsing..." );
                
                /* set all twin refs to null */
                for( i = 0; i < numRawLightmaps; i++ )
@@ -2706,7 +2843,7 @@ void StoreSurfaceLightmaps( void )
           ----------------------------------------------------------------- */
        
        /* note it */
-       Sys_FPrintf( SYS_VRB, "sorting..." );
+       Sys_Printf( "sorting..." );
        
        /* allocate a new sorted list */
        if( sortLightmaps == NULL )
@@ -2722,7 +2859,7 @@ void StoreSurfaceLightmaps( void )
           ----------------------------------------------------------------- */
        
        /* note it */
-       Sys_FPrintf( SYS_VRB, "allocating..." );
+       Sys_Printf( "allocating..." );
        
        /* kill all existing output lightmaps */
        if( outLightmaps != NULL )
@@ -2775,7 +2912,7 @@ void StoreSurfaceLightmaps( void )
           ----------------------------------------------------------------- */
        
        /* note it */
-       Sys_FPrintf( SYS_VRB, "storing..." );
+       Sys_Printf( "storing..." );
        
        /* count the bsp lightmaps and allocate space */
        if( bspLightBytes != NULL )
@@ -2843,7 +2980,7 @@ void StoreSurfaceLightmaps( void )
        }
        
        if( numExtLightmaps > 0 )
-               Sys_FPrintf( SYS_VRB, "\n" );
+               Sys_Printf( "\n" );
        
        /* delete unused external lightmaps */
        for( i = numExtLightmaps; i; i++ )
@@ -2862,7 +2999,7 @@ void StoreSurfaceLightmaps( void )
           ----------------------------------------------------------------- */
        
        /* note it */
-       Sys_FPrintf( SYS_VRB, "projecting..." );
+       Sys_Printf( "projecting..." );
        
        /* walk the list of surfaces */
        for( i = 0; i < numBSPDrawSurfaces; i++ )
@@ -3134,7 +3271,7 @@ void StoreSurfaceLightmaps( void )
        }
        
        /* finish */
-       Sys_FPrintf( SYS_VRB, "done.\n" );
+       Sys_Printf( "done.\n" );
        
        /* calc num stored */
        numStored = numBSPLightBytes / 3;
index 0229ad03f792ebd18094e3f758fc6c7ddd3fb1cf..02d2fb630b4cfea39d3bb4c4802e9f606b5463db 100644 (file)
@@ -795,7 +795,7 @@ int main( int argc, char **argv )
        
        /* set exit call */
        atexit( ExitQ3Map );
-       
+
        /* read general options first */
        for( i = 1; i < argc; i++ )
        {
@@ -871,6 +871,10 @@ int main( int argc, char **argv )
        
        /* ydnar: new path initialization */
        InitPaths( &argc, argv );
+
+       /* set game options */
+       if (!patchSubdivisions)
+               patchSubdivisions = game->patchSubdivisions;
        
        /* check if we have enough options left to attempt something */
        if( argc < 2 )
index ddc5b0a96eefd89021590c29ebeb2b302b25a5ef..b9521a85d3134a3544799021243491caf62903dd 100644 (file)
@@ -237,6 +237,7 @@ constants
 #define LIGHT_FAST_TEMP                        512
 #define LIGHT_FAST_ACTUAL              (LIGHT_FAST | LIGHT_FAST_TEMP)
 #define LIGHT_NEGATIVE                 1024
+#define LIGHT_UNNORMALIZED             2048    /* vortex: do not normalize _color */
 
 #define LIGHT_SUN_DEFAULT              (LIGHT_ATTEN_ANGLE | LIGHT_GRID | LIGHT_SURFACES)
 #define LIGHT_AREA_DEFAULT             (LIGHT_ATTEN_ANGLE | LIGHT_ATTEN_DISTANCE | LIGHT_GRID | LIGHT_SURFACES)        /* q3a and wolf are the same */
@@ -270,7 +271,7 @@ constants
 #define SUPER_NORMAL_SIZE              4
 #define SUPER_DELUXEL_SIZE             3
 #define BSP_DELUXEL_SIZE               3
-#define SUPER_FLOODLIGHT_SIZE  1
+#define SUPER_FLOODLIGHT_SIZE  4
 
 #define VERTEX_LUXEL( s, v )   (vertexLuxels[ s ] + ((v) * VERTEX_LUXEL_SIZE))
 #define RAD_VERTEX_LUXEL( s, v )(radVertexLuxels[ s ] + ((v) * VERTEX_LUXEL_SIZE))
@@ -550,6 +551,14 @@ typedef struct game_s
        float                           lightmapGamma;                                  /* default lightmap gamma */
        float                           lightmapExposure;                               /* default lightmap exposure */
        float                           lightmapCompensate;                             /* default lightmap compensate value */
+       float                           gridScale;                                              /* vortex: default lightgrid scale (affects both directional and ambient spectres) */
+       float                           gridAmbientScale;                               /* vortex: default lightgrid ambient spectre scale */
+       qboolean                        noStyles;                                               /* use lightstyles hack or not */
+       qboolean                        keepLights;                                             /* keep light entities on bsp */
+       int                                     patchSubdivisions;                              /* default patch subdivisions tolerance */
+       qboolean                        patchShadows;                                   /* patch casting enabled */
+       qboolean                        deluxeMap;                                              /* compile deluxemaps */
+       int                                     deluxeMode;                                             /* deluxemap mode (0 - modelspace, 1 - tangentspace with renormalization, 2 - tangentspace without renormalization) */
        char                            *bspIdent;                                              /* 4-letter bsp file prefix */
        int                                     bspVersion;                                             /* bsp version to use */
        qboolean                        lumpSwap;                                               /* cod-style len/ofs order */
@@ -672,6 +681,7 @@ typedef struct shaderInfo_s
        char                            *backShader;                                    /* for surfaces that generate different front and back passes */
        char                            *cloneShader;                                   /* ydnar: for cloning of a surface */
        char                            *remapShader;                                   /* ydnar: remap a shader in final stage */
+       char                            *deprecateShader;                               /* vortex: shader is deprecated and replaced by this on use */
 
        surfaceModel_t          *surfaceModel;                                  /* ydnar: for distribution of models */
        foliage_t                       *foliage;                                               /* ydnar/splash damage: wolf et foliage */
@@ -747,7 +757,13 @@ typedef struct shaderInfo_s
        
        vec3_t                          color;                                                  /* normalized color */
        vec3_t                          averageColor;
-       byte                            lightStyle;
+       byte                            lightStyle;                                     
+
+       /* vortex: per-surface floodlight */
+       float                           floodlightDirectionScale;
+       vec3_t                          floodlightRGB; 
+       float                           floodlightIntensity;
+       float                           floodlightDistance;
        
        qb_t                            lmMergable;                                             /* ydnar */
        int                                     lmCustomWidth, lmCustomHeight;  /* ydnar */
@@ -1023,7 +1039,7 @@ typedef struct mapDrawSurface_s
        int                                     maxIterations;
        int                                     patchWidth, patchHeight;
        vec3_t                          bounds[ 2 ];
-       
+
        /* ydnar/sd: for foliage */
        int                                     numFoliageInstances;
        
@@ -1072,6 +1088,7 @@ typedef struct
        int                                     firstBrush, numBrushes;         /* only valid during BSP compile */
        epair_t                         *epairs;
        vec3_t                          originbrush_origin;
+       qboolean                        forceNormalSmoothing; /* vortex: true if entity has _smoothnormals/_sn/_smooth key */
 }
 entity_t;
 
@@ -1307,7 +1324,8 @@ typedef struct
        
        /* input and output */
        vec3_t                          color;                  /* starts out at full color, may be reduced if transparent surfaces are crossed */
-       
+       vec3_t                          colorNoShadow;  /* result color with no shadow casting */
+
        /* output */
        vec3_t                          hit;
        int                                     compileFlags;   /* for determining surface compile flags traced through */
@@ -1378,6 +1396,13 @@ typedef struct rawLightmap_s
        int                                             numLightClusters, *lightClusters;
        
        int                                             sampleSize, actualSampleSize, axisNum;
+
+       /* vortex: per-surface floodlight */
+       float                                   floodlightDirectionScale;
+       vec3_t                                  floodlightRGB; 
+       float                                   floodlightIntensity;
+       float                                   floodlightDistance;
+
        int                                             entityNum;
        int                                             recvShadows;
        vec3_t                                  mins, maxs, axis, origin, *vecs;
@@ -1433,8 +1458,6 @@ typedef struct surfaceInfo_s
 }
 surfaceInfo_t;
 
-
-
 /* -------------------------------------------------------------------------------
 
 prototypes
@@ -1568,6 +1591,7 @@ void                                              FreeTreePortals_r( node_t *node );
 void                                           ParsePatch( qboolean onlyLights );
 mesh_t                                         *SubdivideMesh( mesh_t in, float maxError, float minLength );
 void                                           PatchMapDrawSurfs( entity_t *e );
+void                                           TriangulatePatchSurface( entity_t *e , mapDrawSurface_t *ds );
 
 
 /* tjunction.c */
@@ -1622,6 +1646,8 @@ void                                              SubdivideFaceSurfaces( entity_t *e, tree_t *tree );
 void                                           AddEntitySurfaceModels( entity_t *e );
 int                                                    AddSurfaceModels( mapDrawSurface_t *ds );
 void                                           FilterDrawsurfsIntoTree( entity_t *e, tree_t *tree );
+void                                           EmitPatchSurface( entity_t *e, mapDrawSurface_t *ds );
+void                                           EmitTriangleSurface( mapDrawSurface_t *ds );
 
 
 /* surface_fur.c */
@@ -1719,7 +1745,9 @@ float                                             DirtForSample( trace_t *trace );
 void                                           DirtyRawLightmap( int num );
 
 void                                           SetupFloodLight();
-float                                          FloodLightForSample( trace_t *trace );
+void                                           FloodlightRawLightmaps();
+void                                           FloodlightIlluminateLightmap( rawLightmap_t *lm );
+float                                          FloodLightForSample( trace_t *trace , float floodLightDistance, qboolean floodLightLowQuality);
 void                                           FloodLightRawLightmap( int num );
 
 void                                           IlluminateRawLightmap( int num );
@@ -1871,6 +1899,12 @@ Q_EXTERN game_t                          games[]
                                                                ,
                                                                #include "game_qfusion.h"       /* qfusion game */
                                                                ,
+                                                               #include "game_darkplaces.h"    /* vortex: darkplaces q1 engine */
+                                                               ,
+                                                               #include "game_dq.h"    /* vortex: deluxe quake game ( darkplaces q1 engine) */
+                                                               ,
+                                                               #include "game_prophecy.h"      /* vortex: prophecy game ( darkplaces q1 engine) */
+                                                               ,
                                                                { NULL }        /* null game */
                                                        };
 #endif
@@ -1957,6 +1991,7 @@ Q_EXTERN char                             outbase[ 32 ];
 
 Q_EXTERN int                           sampleSize;                                             /* lightmap sample size in units */
 Q_EXTERN int                           minSampleSize;                  /* minimum sample size to use at all */
+Q_EXTERN int                           sampleScale;                                    /* vortex: lightmap sample scale (ie quality)*/
 
 Q_EXTERN int                           mapEntityNum Q_ASSIGN( 0 );
 
@@ -2083,6 +2118,7 @@ light global variables
 Q_EXTERN qboolean                      wolfLight Q_ASSIGN( qfalse );
 Q_EXTERN qboolean                      loMem Q_ASSIGN( qfalse );
 Q_EXTERN qboolean                      noStyles Q_ASSIGN( qfalse );
+Q_EXTERN qboolean                      keepLights Q_ASSIGN( qfalse );
 
 Q_EXTERN int                           sampleSize Q_ASSIGN( DEFAULT_LIGHTMAP_SAMPLE_SIZE );
 Q_EXTERN int                           minSampleSize Q_ASSIGN( DEFAULT_LIGHTMAP_MIN_SAMPLE_SIZE );
@@ -2096,6 +2132,7 @@ Q_EXTERN qboolean                 cpmaHack Q_ASSIGN( qfalse );
 
 Q_EXTERN qboolean                      deluxemap Q_ASSIGN( qfalse );
 Q_EXTERN qboolean                      debugDeluxemap Q_ASSIGN( qfalse );
+Q_EXTERN int                           deluxemode Q_ASSIGN( 0 );       /* deluxemap format (0 - modelspace, 1 - tangentspace with renormalization, 2 - tangentspace without renormalization) */
 
 Q_EXTERN qboolean                      fast Q_ASSIGN( qfalse );
 Q_EXTERN qboolean                      faster Q_ASSIGN( qfalse );
@@ -2130,12 +2167,13 @@ Q_EXTERN float                          dirtDepth Q_ASSIGN( 128.0f );
 Q_EXTERN float                         dirtScale Q_ASSIGN( 1.0f );
 Q_EXTERN float                         dirtGain Q_ASSIGN( 1.0f );
 
-Q_EXTERN qboolean                      debugnormals Q_ASSIGN( qfalse );
-Q_EXTERN qboolean                      floodlighty Q_ASSIGN( qfalse );
-Q_EXTERN qboolean                      floodlight_lowquality Q_ASSIGN( qfalse );
-Q_EXTERN vec3_t                                floodlightRGB;
-Q_EXTERN float                         floodlightIntensity Q_ASSIGN( 512 );
-Q_EXTERN float                         floodlightDistance Q_ASSIGN( 1024 );
+/* 27: floodlighting */
+Q_EXTERN qboolean                                      debugnormals Q_ASSIGN( qfalse );
+Q_EXTERN qboolean                                      floodlighty Q_ASSIGN( qfalse );
+Q_EXTERN qboolean                                      floodlight_lowquality Q_ASSIGN( qfalse );
+Q_EXTERN vec3_t                                                floodlightRGB;
+Q_EXTERN float                                         floodlightIntensity Q_ASSIGN( 512.0f );
+Q_EXTERN float                                         floodlightDistance Q_ASSIGN( 1024.0f );
 
 Q_EXTERN qboolean                      dump Q_ASSIGN( qfalse );
 Q_EXTERN qboolean                      debug Q_ASSIGN( qfalse );
@@ -2153,6 +2191,10 @@ Q_EXTERN float                           pointScale Q_ASSIGN( 7500.0f );
 Q_EXTERN float                         areaScale Q_ASSIGN( 0.25f );
 Q_EXTERN float                         skyScale Q_ASSIGN( 1.0f );
 Q_EXTERN float                         bounceScale Q_ASSIGN( 0.25f );
+/* vortex: gridscale and gridambientscale */
+Q_EXTERN float                         gridScale Q_ASSIGN( 1.0f );
+Q_EXTERN float                         gridAmbientScale Q_ASSIGN( 1.0f );
 
 /* ydnar: lightmap gamma/compensation */
 Q_EXTERN float                         lightmapGamma Q_ASSIGN( 1.0f );
@@ -2264,6 +2306,9 @@ Q_EXTERN int                              numBSPLightmaps Q_ASSIGN( 0 );
 Q_EXTERN int                           numExtLightmaps Q_ASSIGN( 0 );
 Q_EXTERN outLightmap_t         *outLightmaps Q_ASSIGN( NULL );
 
+/* vortex: per surface floodlight statictics */
+Q_EXTERN int                           numSurfacesFloodlighten Q_ASSIGN( 0 );
+
 /* grid points */
 Q_EXTERN int                           numRawGridPoints Q_ASSIGN( 0 );
 Q_EXTERN rawGridPoint_t                *rawGridPoints Q_ASSIGN( NULL );
diff --git a/tools/quake3/q3map2/q3map2_fsr_newfiles/game_darkplaces.h b/tools/quake3/q3map2/q3map2_fsr_newfiles/game_darkplaces.h
deleted file mode 100644 (file)
index b227ce6..0000000
+++ /dev/null
@@ -1,143 +0,0 @@
-/* -------------------------------------------------------------------------------\r
-\r
-Copyright (C) 1999-2006 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
-----------------------------------------------------------------------------------\r
-\r
-This code has been altered significantly from its original form, to support\r
-several games based on the Quake III Arena engine, in the form of "Q3Map2."\r
-\r
-------------------------------------------------------------------------------- */\r
-\r
-\r
-\r
-/* marker */\r
-#ifndef GAME_DARKPLACES_H\r
-#define GAME_DARKPLACES_H\r
-\r
-/* content and surface flags get form quake3 */\r
-\r
-/* -------------------------------------------------------------------------------\r
-\r
-game_t struct\r
-\r
-------------------------------------------------------------------------------- */\r
-\r
-{\r
-       "darkplaces",           /* -game x */\r
-       "id1",                          /* default base game data dir */\r
-       ".darkplaces ",         /* unix home sub-dir */\r
-       "darkplaces",           /* magic path word */\r
-       "scripts",                      /* shader directory */\r
-       64,                                     /* max lightmapped surface verts */\r
-       999,                            /* max surface verts */\r
-       6000,                           /* max surface indexes */\r
-       qfalse,                         /* flares */\r
-       "flareshader",          /* default flare shader */\r
-       qfalse,                         /* wolf lighting model? */\r
-       128,                            /* lightmap width/height */\r
-       1.0f,                           /* lightmap gamma */\r
-       200.0f,                         /* lightmap exposure */\r
-       1.0f,                           /* lightmap compensate */\r
-       0.3f,                           /* lightgrid scale */\r
-       0.6f,                           /* lightgrid ambient scale */\r
-       qtrue,                          /* disable shader lightstyles hack */\r
-       qtrue,                          /* keep light entities on bsp */\r
-       4,                                      /* default patchMeta subdivisions tolerance */\r
-       qfalse,                         /* patch casting enabled */\r
-       qfalse,                         /* compile deluxemaps */\r
-       0,                                      /* deluxemaps default mode */\r
-       "IBSP",                         /* bsp file prefix */\r
-       46,                                     /* bsp file version */\r
-       qfalse,                         /* cod-style lump len/ofs order */\r
-       LoadIBSPFile,           /* bsp load function */\r
-       WriteIBSPFile,          /* bsp write function */\r
-\r
-       {\r
-               /* name                         contentFlags                            contentFlagsClear                       surfaceFlags                            surfaceFlagsClear                       compileFlags                            compileFlagsClear */\r
-               \r
-               /* default */\r
-               { "default",            Q_CONT_SOLID,                           -1,                                                     0,                                                      -1,                                                     C_SOLID,                                        -1 },\r
-               \r
-               \r
-               /* ydnar */\r
-               { "lightgrid",          0,                                                      0,                                                      0,                                                      0,                                                      C_LIGHTGRID,                            0 },\r
-               { "antiportal",         0,                                                      0,                                                      0,                                                      0,                                                      C_ANTIPORTAL,                           0 },\r
-               { "skip",                       0,                                                      0,                                                      0,                                                      0,                                                      C_SKIP,                                         0 },\r
-               \r
-               \r
-               /* compiler */\r
-               { "origin",                     Q_CONT_ORIGIN,                          Q_CONT_SOLID,                           0,                                                      0,                                                      C_ORIGIN | C_TRANSLUCENT,       C_SOLID },\r
-               { "areaportal",         Q_CONT_AREAPORTAL,                      Q_CONT_SOLID,                           0,                                                      0,                                                      C_AREAPORTAL | C_TRANSLUCENT,   C_SOLID },\r
-               { "trans",                      Q_CONT_TRANSLUCENT,                     0,                                                      0,                                                      0,                                                      C_TRANSLUCENT,                          0 },\r
-               { "detail",                     Q_CONT_DETAIL,                          0,                                                      0,                                                      0,                                                      C_DETAIL,                                       0 },\r
-               { "structural",         Q_CONT_STRUCTURAL,                      0,                                                      0,                                                      0,                                                      C_STRUCTURAL,                           0 },\r
-               { "hint",                       0,                                                      0,                                                      Q_SURF_HINT,                            0,                                                      C_HINT,                                         0 },\r
-               { "nodraw",                     0,                                                      0,                                                      Q_SURF_NODRAW,                          0,                                                      C_NODRAW,                                       0 },\r
-               \r
-               { "alphashadow",        0,                                                      0,                                                      Q_SURF_ALPHASHADOW,                     0,                                                      C_ALPHASHADOW | C_TRANSLUCENT,  0 },\r
-               { "lightfilter",        0,                                                      0,                                                      Q_SURF_LIGHTFILTER,                     0,                                                      C_LIGHTFILTER | C_TRANSLUCENT,  0 },\r
-               { "nolightmap",         0,                                                      0,                                                      Q_SURF_VERTEXLIT,                       0,                                                      C_VERTEXLIT,                            0 },\r
-               { "pointlight",         0,                                                      0,                                                      Q_SURF_VERTEXLIT,                       0,                                                      C_VERTEXLIT,                            0 },\r
-               \r
-               \r
-               /* game */\r
-               { "nonsolid",           0,                                                      Q_CONT_SOLID,                           Q_SURF_NONSOLID,                        0,                                                      0,                                                      C_SOLID },\r
-               \r
-               { "trigger",            Q_CONT_TRIGGER,                         Q_CONT_SOLID,                           0,                                                      0,                                                      C_TRANSLUCENT,                          C_SOLID },\r
-               \r
-               { "water",                      Q_CONT_WATER,                           Q_CONT_SOLID,                           0,                                                      0,                                                      C_LIQUID | C_TRANSLUCENT,       C_SOLID },\r
-               { "slime",                      Q_CONT_SLIME,                           Q_CONT_SOLID,                           0,                                                      0,                                                      C_LIQUID | C_TRANSLUCENT,       C_SOLID },\r
-               { "lava",                       Q_CONT_LAVA,                            Q_CONT_SOLID,                           0,                                                      0,                                                      C_LIQUID | C_TRANSLUCENT,       C_SOLID },\r
-               \r
-               { "playerclip",         Q_CONT_PLAYERCLIP,                      Q_CONT_SOLID,                           0,                                                      0,                                                      C_DETAIL | C_TRANSLUCENT,       C_SOLID },\r
-               { "monsterclip",        Q_CONT_MONSTERCLIP,                     Q_CONT_SOLID,                           0,                                                      0,                                                      C_DETAIL | C_TRANSLUCENT,       C_SOLID },\r
-               { "nodrop",                     Q_CONT_NODROP,                          Q_CONT_SOLID,                           0,                                                      0,                                                      C_TRANSLUCENT,                          C_SOLID },\r
-               \r
-               { "clusterportal",      Q_CONT_CLUSTERPORTAL,           Q_CONT_SOLID,                           0,                                                      0,                                                      C_TRANSLUCENT,                          C_SOLID },\r
-               { "donotenter",         Q_CONT_DONOTENTER,                      Q_CONT_SOLID,                           0,                                                      0,                                                      C_TRANSLUCENT,                          C_SOLID },\r
-               { "botclip",            Q_CONT_BOTCLIP,                         Q_CONT_SOLID,                           0,                                                      0,                                                      C_TRANSLUCENT,                          C_SOLID },\r
-               \r
-               { "fog",                        Q_CONT_FOG,                                     Q_CONT_SOLID,                           0,                                                      0,                                                      C_FOG,                                          C_SOLID },\r
-               { "sky",                        0,                                                      0,                                                      Q_SURF_SKY,                                     0,                                                      C_SKY,                                          0 },\r
-               \r
-               { "slick",                      0,                                                      0,                                                      Q_SURF_SLICK,                           0,                                                      0,                                                      0 },\r
-               \r
-               { "noimpact",           0,                                                      0,                                                      Q_SURF_NOIMPACT,                        0,                                                      0,                                                      0 },\r
-               { "nomarks",            0,                                                      0,                                                      Q_SURF_NOMARKS,                         0,                                                      C_NOMARKS,                                      0 },\r
-               { "ladder",                     0,                                                      0,                                                      Q_SURF_LADDER,                          0,                                                      0,                                                      0 },\r
-               { "nodamage",           0,                                                      0,                                                      Q_SURF_NODAMAGE,                        0,                                                      0,                                                      0 },\r
-               { "metalsteps",         0,                                                      0,                                                      Q_SURF_METALSTEPS,                      0,                                                      0,                                                      0 },\r
-               { "flesh",                      0,                                                      0,                                                      Q_SURF_FLESH,                           0,                                                      0,                                                      0 },\r
-               { "nosteps",            0,                                                      0,                                                      Q_SURF_NOSTEPS,                         0,                                                      0,                                                      0 },\r
-               { "nodlight",           0,                                                      0,                                                      Q_SURF_NODLIGHT,                        0,                                                      0,                                                      0 },\r
-               { "dust",                       0,                                                      0,                                                      Q_SURF_DUST,                            0,                                                      0,                                                      0 },\r
-               \r
-               \r
-               /* null */\r
-               { NULL, 0, 0, 0, 0, 0, 0 }\r
-       }\r
-}\r
-\r
-\r
-\r
-/* end marker */\r
-#endif\r
-\r
diff --git a/tools/quake3/q3map2/q3map2_fsr_newfiles/game_dq.h b/tools/quake3/q3map2/q3map2_fsr_newfiles/game_dq.h
deleted file mode 100644 (file)
index f08fa2e..0000000
+++ /dev/null
@@ -1,143 +0,0 @@
-/* -------------------------------------------------------------------------------\r
-\r
-Copyright (C) 1999-2006 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
-----------------------------------------------------------------------------------\r
-\r
-This code has been altered significantly from its original form, to support\r
-several games based on the Quake III Arena engine, in the form of "Q3Map2."\r
-\r
-------------------------------------------------------------------------------- */\r
-\r
-\r
-\r
-/* marker */\r
-#ifndef GAME_DQ_H\r
-#define GAME_DQ_H\r
-\r
-/* content and surface flags get form quake3 */\r
-\r
-/* -------------------------------------------------------------------------------\r
-\r
-game_t struct\r
-\r
-------------------------------------------------------------------------------- */\r
-\r
-{\r
-       "dq",                           /* -game x */\r
-       "basedq",                       /* default base game data dir */\r
-       ".dq",                          /* unix home sub-dir */\r
-       "dq",                           /* magic path word */\r
-       "scripts",                      /* shader directory */\r
-       64,                                     /* max lightmapped surface verts */\r
-       999,                            /* max surface verts */\r
-       6000,                           /* max surface indexes */\r
-       qfalse,                         /* flares */\r
-       "flareshader",          /* default flare shader */\r
-       qfalse,                         /* wolf lighting model? */\r
-       128,                            /* lightmap width/height */\r
-       1.2f,                           /* lightmap gamma */\r
-       200.0f,                         /* lightmap exposure */\r
-       1.0f,                           /* lightmap compensate */\r
-       0.3f,                           /* lightgrid scale */\r
-       0.6f,                           /* lightgrid ambient scale */\r
-       qtrue,                          /* disable shader lightstyles hack */\r
-       qtrue,                          /* keep light entities on bsp */\r
-       4,                                      /* default patchMeta subdivisions tolerance */\r
-       qtrue,                          /* patch casting enabled */\r
-       qtrue,                          /* compile deluxemaps */\r
-       1,                                      /* deluxemaps default mode */\r
-       "IBSP",                         /* bsp file prefix */\r
-       46,                                     /* bsp file version */\r
-       qfalse,                         /* cod-style lump len/ofs order */\r
-       LoadIBSPFile,           /* bsp load function */\r
-       WriteIBSPFile,          /* bsp write function */\r
-\r
-       {\r
-               /* name                         contentFlags                            contentFlagsClear                       surfaceFlags                            surfaceFlagsClear                       compileFlags                            compileFlagsClear */\r
-               \r
-               /* default */\r
-               { "default",            Q_CONT_SOLID,                           -1,                                                     0,                                                      -1,                                                     C_SOLID,                                        -1 },\r
-               \r
-               \r
-               /* ydnar */\r
-               { "lightgrid",          0,                                                      0,                                                      0,                                                      0,                                                      C_LIGHTGRID,                            0 },\r
-               { "antiportal",         0,                                                      0,                                                      0,                                                      0,                                                      C_ANTIPORTAL,                           0 },\r
-               { "skip",                       0,                                                      0,                                                      0,                                                      0,                                                      C_SKIP,                                         0 },\r
-               \r
-               \r
-               /* compiler */\r
-               { "origin",                     Q_CONT_ORIGIN,                          Q_CONT_SOLID,                           0,                                                      0,                                                      C_ORIGIN | C_TRANSLUCENT,       C_SOLID },\r
-               { "areaportal",         Q_CONT_AREAPORTAL,                      Q_CONT_SOLID,                           0,                                                      0,                                                      C_AREAPORTAL | C_TRANSLUCENT,   C_SOLID },\r
-               { "trans",                      Q_CONT_TRANSLUCENT,                     0,                                                      0,                                                      0,                                                      C_TRANSLUCENT,                          0 },\r
-               { "detail",                     Q_CONT_DETAIL,                          0,                                                      0,                                                      0,                                                      C_DETAIL,                                       0 },\r
-               { "structural",         Q_CONT_STRUCTURAL,                      0,                                                      0,                                                      0,                                                      C_STRUCTURAL,                           0 },\r
-               { "hint",                       0,                                                      0,                                                      Q_SURF_HINT,                            0,                                                      C_HINT,                                         0 },\r
-               { "nodraw",                     0,                                                      0,                                                      Q_SURF_NODRAW,                          0,                                                      C_NODRAW,                                       0 },\r
-               \r
-               { "alphashadow",        0,                                                      0,                                                      Q_SURF_ALPHASHADOW,                     0,                                                      C_ALPHASHADOW | C_TRANSLUCENT,  0 },\r
-               { "lightfilter",        0,                                                      0,                                                      Q_SURF_LIGHTFILTER,                     0,                                                      C_LIGHTFILTER | C_TRANSLUCENT,  0 },\r
-               { "nolightmap",         0,                                                      0,                                                      Q_SURF_VERTEXLIT,                       0,                                                      C_VERTEXLIT,                            0 },\r
-               { "pointlight",         0,                                                      0,                                                      Q_SURF_VERTEXLIT,                       0,                                                      C_VERTEXLIT,                            0 },\r
-               \r
-               \r
-               /* game */\r
-               { "nonsolid",           0,                                                      Q_CONT_SOLID,                           Q_SURF_NONSOLID,                        0,                                                      0,                                                      C_SOLID },\r
-               \r
-               { "trigger",            Q_CONT_TRIGGER,                         Q_CONT_SOLID,                           0,                                                      0,                                                      C_TRANSLUCENT,                          C_SOLID },\r
-               \r
-               { "water",                      Q_CONT_WATER,                           Q_CONT_SOLID,                           0,                                                      0,                                                      C_LIQUID | C_TRANSLUCENT,       C_SOLID },\r
-               { "slime",                      Q_CONT_SLIME,                           Q_CONT_SOLID,                           0,                                                      0,                                                      C_LIQUID | C_TRANSLUCENT,       C_SOLID },\r
-               { "lava",                       Q_CONT_LAVA,                            Q_CONT_SOLID,                           0,                                                      0,                                                      C_LIQUID | C_TRANSLUCENT,       C_SOLID },\r
-               \r
-               { "playerclip",         Q_CONT_PLAYERCLIP,                      Q_CONT_SOLID,                           0,                                                      0,                                                      C_DETAIL | C_TRANSLUCENT,       C_SOLID },\r
-               { "monsterclip",        Q_CONT_MONSTERCLIP,                     Q_CONT_SOLID,                           0,                                                      0,                                                      C_DETAIL | C_TRANSLUCENT,       C_SOLID },\r
-               { "nodrop",                     Q_CONT_NODROP,                          Q_CONT_SOLID,                           0,                                                      0,                                                      C_TRANSLUCENT,                          C_SOLID },\r
-               \r
-               { "clusterportal",      Q_CONT_CLUSTERPORTAL,           Q_CONT_SOLID,                           0,                                                      0,                                                      C_TRANSLUCENT,                          C_SOLID },\r
-               { "donotenter",         Q_CONT_DONOTENTER,                      Q_CONT_SOLID,                           0,                                                      0,                                                      C_TRANSLUCENT,                          C_SOLID },\r
-               { "botclip",            Q_CONT_BOTCLIP,                         Q_CONT_SOLID,                           0,                                                      0,                                                      C_TRANSLUCENT,                          C_SOLID },\r
-               \r
-               { "fog",                        Q_CONT_FOG,                                     Q_CONT_SOLID,                           0,                                                      0,                                                      C_FOG,                                          C_SOLID },\r
-               { "sky",                        0,                                                      0,                                                      Q_SURF_SKY,                                     0,                                                      C_SKY,                                          0 },\r
-               \r
-               { "slick",                      0,                                                      0,                                                      Q_SURF_SLICK,                           0,                                                      0,                                                      0 },\r
-               \r
-               { "noimpact",           0,                                                      0,                                                      Q_SURF_NOIMPACT,                        0,                                                      0,                                                      0 },\r
-               { "nomarks",            0,                                                      0,                                                      Q_SURF_NOMARKS,                         0,                                                      C_NOMARKS,                                      0 },\r
-               { "ladder",                     0,                                                      0,                                                      Q_SURF_LADDER,                          0,                                                      0,                                                      0 },\r
-               { "nodamage",           0,                                                      0,                                                      Q_SURF_NODAMAGE,                        0,                                                      0,                                                      0 },\r
-               { "metalsteps",         0,                                                      0,                                                      Q_SURF_METALSTEPS,                      0,                                                      0,                                                      0 },\r
-               { "flesh",                      0,                                                      0,                                                      Q_SURF_FLESH,                           0,                                                      0,                                                      0 },\r
-               { "nosteps",            0,                                                      0,                                                      Q_SURF_NOSTEPS,                         0,                                                      0,                                                      0 },\r
-               { "nodlight",           0,                                                      0,                                                      Q_SURF_NODLIGHT,                        0,                                                      0,                                                      0 },\r
-               { "dust",                       0,                                                      0,                                                      Q_SURF_DUST,                            0,                                                      0,                                                      0 },\r
-               \r
-               \r
-               /* null */\r
-               { NULL, 0, 0, 0, 0, 0, 0 }\r
-       }\r
-}\r
-\r
-\r
-\r
-/* end marker */\r
-#endif\r
-\r
diff --git a/tools/quake3/q3map2/q3map2_fsr_newfiles/game_prophecy.h b/tools/quake3/q3map2/q3map2_fsr_newfiles/game_prophecy.h
deleted file mode 100644 (file)
index cd82649..0000000
+++ /dev/null
@@ -1,143 +0,0 @@
-/* -------------------------------------------------------------------------------\r
-\r
-Copyright (C) 1999-2006 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
-----------------------------------------------------------------------------------\r
-\r
-This code has been altered significantly from its original form, to support\r
-several games based on the Quake III Arena engine, in the form of "Q3Map2."\r
-\r
-------------------------------------------------------------------------------- */\r
-\r
-\r
-\r
-/* marker */\r
-#ifndef GAME_PROPHECY_H\r
-#define GAME_PROPHECY_H\r
-\r
-/* content and surface flags get form quake3 */\r
-\r
-/* -------------------------------------------------------------------------------\r
-\r
-game_t struct\r
-\r
-------------------------------------------------------------------------------- */\r
-\r
-{\r
-       "prophecy",                     /* -game x */\r
-       "base",                         /* default base game data dir */\r
-       ".prophecy",            /* unix home sub-dir */\r
-       "prophecy",                     /* magic path word */\r
-       "scripts",                      /* shader directory */\r
-       64,                                     /* max lightmapped surface verts */\r
-       999,                            /* max surface verts */\r
-       6000,                           /* max surface indexes */\r
-       qfalse,                         /* flares */\r
-       "flareshader",          /* default flare shader */\r
-       qfalse,                         /* wolf lighting model? */\r
-       128,                            /* lightmap width/height */\r
-       1.0f,                           /* lightmap gamma */\r
-       200.0f,                         /* lightmap exposure */\r
-       1.0f,                           /* lightmap compensate */\r
-       0.4f,                           /* lightgrid scale */\r
-       0.6f,                           /* lightgrid ambient scale */\r
-       qtrue,                          /* disable shader lightstyles hack */\r
-       qtrue,                          /* keep light entities on bsp */\r
-       4,                                      /* default patchMeta subdivisions tolerance */\r
-       qtrue,                          /* patch casting enabled */\r
-       qtrue,                          /* compile deluxemaps */\r
-       0,                                      /* deluxemaps default mode */\r
-       "IBSP",                         /* bsp file prefix */\r
-       46,                                     /* bsp file version */\r
-       qfalse,                         /* cod-style lump len/ofs order */\r
-       LoadIBSPFile,           /* bsp load function */\r
-       WriteIBSPFile,          /* bsp write function */\r
-\r
-       {\r
-               /* name                         contentFlags                            contentFlagsClear                       surfaceFlags                            surfaceFlagsClear                       compileFlags                            compileFlagsClear */\r
-               \r
-               /* default */\r
-               { "default",            Q_CONT_SOLID,                           -1,                                                     0,                                                      -1,                                                     C_SOLID,                                        -1 },\r
-               \r
-               \r
-               /* ydnar */\r
-               { "lightgrid",          0,                                                      0,                                                      0,                                                      0,                                                      C_LIGHTGRID,                            0 },\r
-               { "antiportal",         0,                                                      0,                                                      0,                                                      0,                                                      C_ANTIPORTAL,                           0 },\r
-               { "skip",                       0,                                                      0,                                                      0,                                                      0,                                                      C_SKIP,                                         0 },\r
-               \r
-               \r
-               /* compiler */\r
-               { "origin",                     Q_CONT_ORIGIN,                          Q_CONT_SOLID,                           0,                                                      0,                                                      C_ORIGIN | C_TRANSLUCENT,       C_SOLID },\r
-               { "areaportal",         Q_CONT_AREAPORTAL,                      Q_CONT_SOLID,                           0,                                                      0,                                                      C_AREAPORTAL | C_TRANSLUCENT,   C_SOLID },\r
-               { "trans",                      Q_CONT_TRANSLUCENT,                     0,                                                      0,                                                      0,                                                      C_TRANSLUCENT,                          0 },\r
-               { "detail",                     Q_CONT_DETAIL,                          0,                                                      0,                                                      0,                                                      C_DETAIL,                                       0 },\r
-               { "structural",         Q_CONT_STRUCTURAL,                      0,                                                      0,                                                      0,                                                      C_STRUCTURAL,                           0 },\r
-               { "hint",                       0,                                                      0,                                                      Q_SURF_HINT,                            0,                                                      C_HINT,                                         0 },\r
-               { "nodraw",                     0,                                                      0,                                                      Q_SURF_NODRAW,                          0,                                                      C_NODRAW,                                       0 },\r
-               \r
-               { "alphashadow",        0,                                                      0,                                                      Q_SURF_ALPHASHADOW,                     0,                                                      C_ALPHASHADOW | C_TRANSLUCENT,  0 },\r
-               { "lightfilter",        0,                                                      0,                                                      Q_SURF_LIGHTFILTER,                     0,                                                      C_LIGHTFILTER | C_TRANSLUCENT,  0 },\r
-               { "nolightmap",         0,                                                      0,                                                      Q_SURF_VERTEXLIT,                       0,                                                      C_VERTEXLIT,                            0 },\r
-               { "pointlight",         0,                                                      0,                                                      Q_SURF_VERTEXLIT,                       0,                                                      C_VERTEXLIT,                            0 },\r
-               \r
-               \r
-               /* game */\r
-               { "nonsolid",           0,                                                      Q_CONT_SOLID,                           Q_SURF_NONSOLID,                        0,                                                      0,                                                      C_SOLID },\r
-               \r
-               { "trigger",            Q_CONT_TRIGGER,                         Q_CONT_SOLID,                           0,                                                      0,                                                      C_TRANSLUCENT,                          C_SOLID },\r
-               \r
-               { "water",                      Q_CONT_WATER,                           Q_CONT_SOLID,                           0,                                                      0,                                                      C_LIQUID | C_TRANSLUCENT,       C_SOLID },\r
-               { "slime",                      Q_CONT_SLIME,                           Q_CONT_SOLID,                           0,                                                      0,                                                      C_LIQUID | C_TRANSLUCENT,       C_SOLID },\r
-               { "lava",                       Q_CONT_LAVA,                            Q_CONT_SOLID,                           0,                                                      0,                                                      C_LIQUID | C_TRANSLUCENT,       C_SOLID },\r
-               \r
-               { "playerclip",         Q_CONT_PLAYERCLIP,                      Q_CONT_SOLID,                           0,                                                      0,                                                      C_DETAIL | C_TRANSLUCENT,       C_SOLID },\r
-               { "monsterclip",        Q_CONT_MONSTERCLIP,                     Q_CONT_SOLID,                           0,                                                      0,                                                      C_DETAIL | C_TRANSLUCENT,       C_SOLID },\r
-               { "nodrop",                     Q_CONT_NODROP,                          Q_CONT_SOLID,                           0,                                                      0,                                                      C_TRANSLUCENT,                          C_SOLID },\r
-               \r
-               { "clusterportal",      Q_CONT_CLUSTERPORTAL,           Q_CONT_SOLID,                           0,                                                      0,                                                      C_TRANSLUCENT,                          C_SOLID },\r
-               { "donotenter",         Q_CONT_DONOTENTER,                      Q_CONT_SOLID,                           0,                                                      0,                                                      C_TRANSLUCENT,                          C_SOLID },\r
-               { "botclip",            Q_CONT_BOTCLIP,                         Q_CONT_SOLID,                           0,                                                      0,                                                      C_TRANSLUCENT,                          C_SOLID },\r
-               \r
-               { "fog",                        Q_CONT_FOG,                                     Q_CONT_SOLID,                           0,                                                      0,                                                      C_FOG,                                          C_SOLID },\r
-               { "sky",                        0,                                                      0,                                                      Q_SURF_SKY,                                     0,                                                      C_SKY,                                          0 },\r
-               \r
-               { "slick",                      0,                                                      0,                                                      Q_SURF_SLICK,                           0,                                                      0,                                                      0 },\r
-               \r
-               { "noimpact",           0,                                                      0,                                                      Q_SURF_NOIMPACT,                        0,                                                      0,                                                      0 },\r
-               { "nomarks",            0,                                                      0,                                                      Q_SURF_NOMARKS,                         0,                                                      C_NOMARKS,                                      0 },\r
-               { "ladder",                     0,                                                      0,                                                      Q_SURF_LADDER,                          0,                                                      0,                                                      0 },\r
-               { "nodamage",           0,                                                      0,                                                      Q_SURF_NODAMAGE,                        0,                                                      0,                                                      0 },\r
-               { "metalsteps",         0,                                                      0,                                                      Q_SURF_METALSTEPS,                      0,                                                      0,                                                      0 },\r
-               { "flesh",                      0,                                                      0,                                                      Q_SURF_FLESH,                           0,                                                      0,                                                      0 },\r
-               { "nosteps",            0,                                                      0,                                                      Q_SURF_NOSTEPS,                         0,                                                      0,                                                      0 },\r
-               { "nodlight",           0,                                                      0,                                                      Q_SURF_NODLIGHT,                        0,                                                      0,                                                      0 },\r
-               { "dust",                       0,                                                      0,                                                      Q_SURF_DUST,                            0,                                                      0,                                                      0 },\r
-               \r
-               \r
-               /* null */\r
-               { NULL, 0, 0, 0, 0, 0, 0 }\r
-       }\r
-}\r
-\r
-\r
-\r
-/* end marker */\r
-#endif\r
-\r
index bcf9d93bde0ac56d22b49b563416ba3de68dc9cf..47b5197bf0c72108f833b0d8de3e8c57db60edc3 100644 (file)
@@ -1,951 +1,7 @@
-Index: game_ef.h\r
-===================================================================\r
---- game_ef.h  (revision 158)\r
-+++ game_ef.h  (working copy)\r
-@@ -113,7 +113,16 @@\r
-       qfalse,                         /* wolf lighting model? */
-       128,                            /* lightmap width/height */
-       1.0f,                           /* lightmap gamma */
-+      1.0f,                           /* lightmap exposure */
-       1.0f,                           /* lightmap compensate */
-+      1.0f,                           /* lightgrid scale */
-+      1.0f,                           /* lightgrid ambient scale */
-+      qfalse,                         /* disable shader lightstyles hack */
-+      qfalse,                         /* keep light entities on bsp */
-+      8,                                      /* default patchMeta subdivisions tolerance */
-+      qfalse,                         /* patch casting enabled */
-+      qfalse,                         /* compile deluxemaps */
-+      0,                                      /* deluxemaps default mode */
-       "IBSP",                         /* bsp file prefix */
-       46,                                     /* bsp file version */
-       qfalse,                         /* cod-style lump len/ofs order */
-Index: game_etut.h\r
-===================================================================\r
---- game_etut.h        (revision 158)\r
-+++ game_etut.h        (working copy)\r
-@@ -148,7 +148,16 @@\r
-       qfalse,                         /* wolf lighting model? */
-       128,                            /* lightmap width/height */
-       2.2f,                           /* lightmap gamma */
-+      1.0f,                           /* lightmap exposure */
-       1.0f,                           /* lightmap compensate */
-+      1.0f,                           /* lightgrid scale */
-+      1.0f,                           /* lightgrid ambient scale */
-+      qfalse,                         /* disable shader lightstyles hack */
-+      qfalse,                         /* keep light entities on bsp */
-+      8,                                      /* default patchMeta subdivisions tolerance */
-+      qfalse,                         /* patch casting enabled */
-+      qfalse,                         /* compile deluxemaps */
-+      0,                                      /* deluxemaps default mode */
-       "IBSP",                         /* bsp file prefix */
-       47,                                     /* bsp file version */
-       qfalse,                         /* cod-style lump len/ofs order */
-Index: game_ja.h\r
-===================================================================\r
---- game_ja.h  (revision 158)\r
-+++ game_ja.h  (working copy)\r
-@@ -67,7 +67,16 @@\r
-       qfalse,                         /* wolf lighting model? */
-       128,                            /* lightmap width/height */
-       1.0f,                           /* lightmap gamma */
-+      1.0f,                           /* lightmap exposure */
-       1.0f,                           /* lightmap compensate */
-+      1.0f,                           /* lightgrid scale */
-+      1.0f,                           /* lightgrid ambient scale */
-+      qfalse,                         /* disable shader lightstyles hack */
-+      qfalse,                         /* keep light entities on bsp */
-+      8,                                      /* default patchMeta subdivisions tolerance */
-+      qfalse,                         /* patch casting enabled */
-+      qfalse,                         /* compile deluxemaps */
-+      0,                                      /* deluxemaps default mode */
-       "RBSP",                         /* bsp file prefix */
-       1,                                      /* bsp file version */
-       qfalse,                         /* cod-style lump len/ofs order */
-Index: game_jk2.h\r
-===================================================================\r
---- game_jk2.h (revision 158)\r
-+++ game_jk2.h (working copy)\r
-@@ -64,7 +64,16 @@\r
-       qfalse,                         /* wolf lighting model? */
-       128,                            /* lightmap width/height */
-       1.0f,                           /* lightmap gamma */
-+      1.0f,                           /* lightmap exposure */
-       1.0f,                           /* lightmap compensate */
-+      1.0f,                           /* lightgrid scale */
-+      1.0f,                           /* lightgrid ambient scale */
-+      qfalse,                         /* disable shader lightstyles hack */
-+      qfalse,                         /* keep light entities on bsp */
-+      8,                                      /* default patchMeta subdivisions tolerance */
-+      qfalse,                         /* patch casting enabled */
-+      qfalse,                         /* compile deluxemaps */
-+      0,                                      /* deluxemaps default mode */
-       "RBSP",                         /* bsp file prefix */
-       1,                                      /* bsp file version */
-       qfalse,                         /* cod-style lump len/ofs order */
-Index: game_qfusion.h\r
-===================================================================\r
---- game_qfusion.h     (revision 158)\r
-+++ game_qfusion.h     (working copy)\r
-@@ -1,195 +1,204 @@\r
--/* -------------------------------------------------------------------------------
--
--This code is based on source provided under the terms of the Id Software 
--LIMITED USE SOFTWARE LICENSE AGREEMENT, a copy of which is included with the
--GtkRadiant sources (see LICENSE_ID). If you did not receive a copy of 
--LICENSE_ID, please contact Id Software immediately at info@idsoftware.com.
--
--All changes and additions to the original source which have been developed by
--other contributors (see CONTRIBUTORS) are provided under the terms of the
--license the contributors choose (see LICENSE), to the extent permitted by the
--LICENSE_ID. If you did not receive a copy of the contributor license,
--please contact the GtkRadiant maintainers at info@gtkradiant.com immediately.
--
--THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''
--AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
--IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
--DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
--DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
--(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
--LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
--ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
--(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
--SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--
------------------------------------------------------------------------------------
--
--This code has been altered significantly from its original form, to support
--several games based on the Quake III Arena engine, in the form of "Q3Map2."
--
--------------------------------------------------------------------------------- */
--
--
--
--/* marker */
--#ifndef GAME_QFUSION_H
--#define GAME_QFUSION_H
--
--
--
--/* -------------------------------------------------------------------------------
--
--content and surface flags
--
--------------------------------------------------------------------------------- */
--
--/* game flags */
--#define F_CONT_SOLID                          1                       /* an eye is never valid in a solid */
--#define F_CONT_LAVA                                   8
--#define F_CONT_SLIME                          16
--#define F_CONT_WATER                          32
--#define F_CONT_FOG                                    64
--
--#define F_CONT_AREAPORTAL                     0x8000
--
--#define F_CONT_PLAYERCLIP                     0x10000
--#define F_CONT_MONSTERCLIP                    0x20000
--#define F_CONT_TELEPORTER                     0x40000
--#define F_CONT_JUMPPAD                                0x80000
--#define F_CONT_CLUSTERPORTAL          0x100000
--#define F_CONT_DONOTENTER                     0x200000
--#define F_CONT_BOTCLIP                                0x400000
--
--#define F_CONT_ORIGIN                         0x1000000       /* removed before bsping an entity */
--
--#define F_CONT_BODY                                   0x2000000       /* should never be on a brush, only in game */
--#define F_CONT_CORPSE                         0x4000000
--#define F_CONT_DETAIL                         0x8000000       /* brushes not used for the bsp */
--#define F_CONT_STRUCTURAL                     0x10000000      /* brushes used for the bsp */
--#define F_CONT_TRANSLUCENT                    0x20000000      /* don't consume surface fragments inside */
--#define F_CONT_TRIGGER                                0x40000000
--#define F_CONT_NODROP                         0x80000000      /* don't leave bodies or items (death fog, lava) */
--
--#define F_SURF_NODAMAGE                               0x1                     /* never give falling damage */
--#define F_SURF_SLICK                          0x2                     /* effects game physics */
--#define F_SURF_SKY                                    0x4                     /* lighting from environment map */
--#define F_SURF_LADDER                         0x8
--#define F_SURF_NOIMPACT                               0x10            /* don't make missile explosions */
--#define F_SURF_NOMARKS                                0x20            /* don't leave missile marks */
--#define F_SURF_FLESH                          0x40            /* make flesh sounds and effects */
--#define F_SURF_NODRAW                         0x80            /* don't generate a drawsurface at all */
--#define F_SURF_HINT                                   0x100           /* make a primary bsp splitter */
--#define F_SURF_SKIP                                   0x200           /* completely ignore, allowing non-closed brushes */
--#define F_SURF_NOLIGHTMAP                     0x400           /* surface doesn't need a lightmap */
--#define F_SURF_POINTLIGHT                     0x800           /* generate lighting info at vertexes */
--#define F_SURF_METALSTEPS                     0x1000          /* clanking footsteps */
--#define F_SURF_NOSTEPS                                0x2000          /* no footstep sounds */
--#define F_SURF_NONSOLID                               0x4000          /* don't collide against curves with this set */
--#define F_SURF_LIGHTFILTER                    0x8000          /* act as a light filter during q3map -light */
--#define F_SURF_ALPHASHADOW                    0x10000         /* do per-pixel light shadow casting in q3map */
--#define F_SURF_NODLIGHT                               0x20000         /* don't dlight even if solid (solid lava, skies) */
--#define F_SURF_DUST                                   0x40000         /* leave a dust trail when walking on this surface */
--
--/* ydnar flags */
--#define F_SURF_VERTEXLIT                      (F_SURF_POINTLIGHT | F_SURF_NOLIGHTMAP)
--
--
--
--/* -------------------------------------------------------------------------------
--
--game_t struct
--
--------------------------------------------------------------------------------- */
--
--{
--      "qfusion",                      /* -game x */
--      "baseq3",                       /* default base game data dir */
--      ".q3a",                         /* unix home sub-dir */
--      "quake",                        /* magic path word */
--      "scripts",                      /* shader directory */
--      2048,                           /* max lightmapped surface verts */
--      2048,                           /* max surface verts */
--      12288,                          /* max surface indexes */
--      qtrue,                          /* flares */
--      "flareshader",          /* default flare shader */
--      qfalse,                         /* wolf lighting model? */
--      512,                            /* lightmap width/height */
--      1.0f,                           /* lightmap gamma */
--      1.0f,                           /* lightmap compensate */
--      "FBSP",                         /* bsp file prefix */
--      1,                                      /* bsp file version */
--      qfalse,                         /* cod-style lump len/ofs order */
--      LoadRBSPFile,           /* bsp load function */
--      WriteRBSPFile,          /* bsp write function */
--
--      {
--              /* name                         contentFlags                            contentFlagsClear                       surfaceFlags                            surfaceFlagsClear                       compileFlags                            compileFlagsClear */
--              
--              /* default */
--              { "default",            F_CONT_SOLID,                           -1,                                                     0,                                                      -1,                                                     C_SOLID,                                        -1 },
--              
--              
--              /* ydnar */
--              { "lightgrid",          0,                                                      0,                                                      0,                                                      0,                                                      C_LIGHTGRID,                            0 },
--              { "antiportal",         0,                                                      0,                                                      0,                                                      0,                                                      C_ANTIPORTAL,                           0 },
--              { "skip",                       0,                                                      0,                                                      0,                                                      0,                                                      C_SKIP,                                         0 },
--              
--              
--              /* compiler */
--              { "origin",                     F_CONT_ORIGIN,                          F_CONT_SOLID,                           0,                                                      0,                                                      C_ORIGIN | C_TRANSLUCENT,       C_SOLID },
--              { "areaportal",         F_CONT_AREAPORTAL,                      F_CONT_SOLID,                           0,                                                      0,                                                      C_AREAPORTAL | C_TRANSLUCENT,   C_SOLID },
--              { "trans",                      F_CONT_TRANSLUCENT,                     0,                                                      0,                                                      0,                                                      C_TRANSLUCENT,                          0 },
--              { "detail",                     F_CONT_DETAIL,                          0,                                                      0,                                                      0,                                                      C_DETAIL,                                       0 },
--              { "structural",         F_CONT_STRUCTURAL,                      0,                                                      0,                                                      0,                                                      C_STRUCTURAL,                           0 },
--              { "hint",                       0,                                                      0,                                                      F_SURF_HINT,                            0,                                                      C_HINT,                                         0 },
--              { "nodraw",                     0,                                                      0,                                                      F_SURF_NODRAW,                          0,                                                      C_NODRAW,                                       0 },
--              
--              { "alphashadow",        0,                                                      0,                                                      F_SURF_ALPHASHADOW,                     0,                                                      C_ALPHASHADOW | C_TRANSLUCENT,  0 },
--              { "lightfilter",        0,                                                      0,                                                      F_SURF_LIGHTFILTER,                     0,                                                      C_LIGHTFILTER | C_TRANSLUCENT,  0 },
--              { "nolightmap",         0,                                                      0,                                                      F_SURF_VERTEXLIT,                       0,                                                      C_VERTEXLIT,                            0 },
--              { "pointlight",         0,                                                      0,                                                      F_SURF_VERTEXLIT,                       0,                                                      C_VERTEXLIT,                            0 },
--              
--              
--              /* game */
--              { "nonsolid",           0,                                                      F_CONT_SOLID,                           F_SURF_NONSOLID,                        0,                                                      0,                                                      C_SOLID },
--              
--              { "trigger",            F_CONT_TRIGGER,                         F_CONT_SOLID,                           0,                                                      0,                                                      C_TRANSLUCENT,                          C_SOLID },
--              
--              { "water",                      F_CONT_WATER,                           F_CONT_SOLID,                           0,                                                      0,                                                      C_LIQUID | C_TRANSLUCENT,       C_SOLID },
--              { "slime",                      F_CONT_SLIME,                           F_CONT_SOLID,                           0,                                                      0,                                                      C_LIQUID | C_TRANSLUCENT,       C_SOLID },
--              { "lava",                       F_CONT_LAVA,                            F_CONT_SOLID,                           0,                                                      0,                                                      C_LIQUID | C_TRANSLUCENT,       C_SOLID },
--              
--              { "playerclip",         F_CONT_PLAYERCLIP,                      F_CONT_SOLID,                           0,                                                      0,                                                      C_DETAIL | C_TRANSLUCENT,       C_SOLID },
--              { "monsterclip",        F_CONT_MONSTERCLIP,                     F_CONT_SOLID,                           0,                                                      0,                                                      C_DETAIL | C_TRANSLUCENT,       C_SOLID },
--              { "nodrop",                     F_CONT_NODROP,                          F_CONT_SOLID,                           0,                                                      0,                                                      C_TRANSLUCENT,                          C_SOLID },
--              
--              { "clusterportal",      F_CONT_CLUSTERPORTAL,           F_CONT_SOLID,                           0,                                                      0,                                                      C_TRANSLUCENT,                          C_SOLID },
--              { "donotenter",         F_CONT_DONOTENTER,                      F_CONT_SOLID,                           0,                                                      0,                                                      C_TRANSLUCENT,                          C_SOLID },
--              { "botclip",            F_CONT_BOTCLIP,                         F_CONT_SOLID,                           0,                                                      0,                                                      C_TRANSLUCENT,                          C_SOLID },
--              
--              { "fog",                        F_CONT_FOG,                                     F_CONT_SOLID,                           0,                                                      0,                                                      C_FOG,                                          C_SOLID },
--              { "sky",                        0,                                                      0,                                                      F_SURF_SKY,                                     0,                                                      C_SKY,                                          0 },
--              
--              { "slick",                      0,                                                      0,                                                      F_SURF_SLICK,                           0,                                                      0,                                                      0 },
--              
--              { "noimpact",           0,                                                      0,                                                      F_SURF_NOIMPACT,                        0,                                                      0,                                                      0 },
--              { "nomarks",            0,                                                      0,                                                      F_SURF_NOMARKS,                         0,                                                      C_NOMARKS,                                      0 },
--              { "ladder",                     0,                                                      0,                                                      F_SURF_LADDER,                          0,                                                      0,                                                      0 },
--              { "nodamage",           0,                                                      0,                                                      F_SURF_NODAMAGE,                        0,                                                      0,                                                      0 },
--              { "metalsteps",         0,                                                      0,                                                      F_SURF_METALSTEPS,                      0,                                                      0,                                                      0 },
--              { "flesh",                      0,                                                      0,                                                      F_SURF_FLESH,                           0,                                                      0,                                                      0 },
--              { "nosteps",            0,                                                      0,                                                      F_SURF_NOSTEPS,                         0,                                                      0,                                                      0 },
--              { "nodlight",           0,                                                      0,                                                      F_SURF_NODLIGHT,                        0,                                                      0,                                                      0 },
--              { "dust",                       0,                                                      0,                                                      F_SURF_DUST,                            0,                                                      0,                                                      0 },
--              
--              
--              /* null */
--              { NULL, 0, 0, 0, 0, 0, 0 }
--      }
--}
--
--
--
--/* end marker */
--#endif
--
-+/* -------------------------------------------------------------------------------\r
-+\r
-+This code is based on source provided under the terms of the Id Software \r
-+LIMITED USE SOFTWARE LICENSE AGREEMENT, a copy of which is included with the\r
-+GtkRadiant sources (see LICENSE_ID). If you did not receive a copy of \r
-+LICENSE_ID, please contact Id Software immediately at info@idsoftware.com.\r
-+\r
-+All changes and additions to the original source which have been developed by\r
-+other contributors (see CONTRIBUTORS) are provided under the terms of the\r
-+license the contributors choose (see LICENSE), to the extent permitted by the\r
-+LICENSE_ID. If you did not receive a copy of the contributor license,\r
-+please contact the GtkRadiant maintainers at info@gtkradiant.com immediately.\r
-+\r
-+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''\r
-+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
-+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\r
-+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r
-+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r
-+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r
-+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON\r
-+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r
-+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r
-+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
-+\r
-+----------------------------------------------------------------------------------\r
-+\r
-+This code has been altered significantly from its original form, to support\r
-+several games based on the Quake III Arena engine, in the form of "Q3Map2."\r
-+\r
-+------------------------------------------------------------------------------- */\r
-+\r
-+\r
-+\r
-+/* marker */\r
-+#ifndef GAME_QFUSION_H\r
-+#define GAME_QFUSION_H\r
-+\r
-+\r
-+\r
-+/* -------------------------------------------------------------------------------\r
-+\r
-+content and surface flags\r
-+\r
-+------------------------------------------------------------------------------- */\r
-+\r
-+/* game flags */\r
-+#define F_CONT_SOLID                          1                       /* an eye is never valid in a solid */\r
-+#define F_CONT_LAVA                                   8\r
-+#define F_CONT_SLIME                          16\r
-+#define F_CONT_WATER                          32\r
-+#define F_CONT_FOG                                    64\r
-+\r
-+#define F_CONT_AREAPORTAL                     0x8000\r
-+\r
-+#define F_CONT_PLAYERCLIP                     0x10000\r
-+#define F_CONT_MONSTERCLIP                    0x20000\r
-+#define F_CONT_TELEPORTER                     0x40000\r
-+#define F_CONT_JUMPPAD                                0x80000\r
-+#define F_CONT_CLUSTERPORTAL          0x100000\r
-+#define F_CONT_DONOTENTER                     0x200000\r
-+#define F_CONT_BOTCLIP                                0x400000\r
-+\r
-+#define F_CONT_ORIGIN                         0x1000000       /* removed before bsping an entity */\r
-+\r
-+#define F_CONT_BODY                                   0x2000000       /* should never be on a brush, only in game */\r
-+#define F_CONT_CORPSE                         0x4000000\r
-+#define F_CONT_DETAIL                         0x8000000       /* brushes not used for the bsp */\r
-+#define F_CONT_STRUCTURAL                     0x10000000      /* brushes used for the bsp */\r
-+#define F_CONT_TRANSLUCENT                    0x20000000      /* don't consume surface fragments inside */\r
-+#define F_CONT_TRIGGER                                0x40000000\r
-+#define F_CONT_NODROP                         0x80000000      /* don't leave bodies or items (death fog, lava) */\r
-+\r
-+#define F_SURF_NODAMAGE                               0x1                     /* never give falling damage */\r
-+#define F_SURF_SLICK                          0x2                     /* effects game physics */\r
-+#define F_SURF_SKY                                    0x4                     /* lighting from environment map */\r
-+#define F_SURF_LADDER                         0x8\r
-+#define F_SURF_NOIMPACT                               0x10            /* don't make missile explosions */\r
-+#define F_SURF_NOMARKS                                0x20            /* don't leave missile marks */\r
-+#define F_SURF_FLESH                          0x40            /* make flesh sounds and effects */\r
-+#define F_SURF_NODRAW                         0x80            /* don't generate a drawsurface at all */\r
-+#define F_SURF_HINT                                   0x100           /* make a primary bsp splitter */\r
-+#define F_SURF_SKIP                                   0x200           /* completely ignore, allowing non-closed brushes */\r
-+#define F_SURF_NOLIGHTMAP                     0x400           /* surface doesn't need a lightmap */\r
-+#define F_SURF_POINTLIGHT                     0x800           /* generate lighting info at vertexes */\r
-+#define F_SURF_METALSTEPS                     0x1000          /* clanking footsteps */\r
-+#define F_SURF_NOSTEPS                                0x2000          /* no footstep sounds */\r
-+#define F_SURF_NONSOLID                               0x4000          /* don't collide against curves with this set */\r
-+#define F_SURF_LIGHTFILTER                    0x8000          /* act as a light filter during q3map -light */\r
-+#define F_SURF_ALPHASHADOW                    0x10000         /* do per-pixel light shadow casting in q3map */\r
-+#define F_SURF_NODLIGHT                               0x20000         /* don't dlight even if solid (solid lava, skies) */\r
-+#define F_SURF_DUST                                   0x40000         /* leave a dust trail when walking on this surface */\r
-+\r
-+/* ydnar flags */\r
-+#define F_SURF_VERTEXLIT                      (F_SURF_POINTLIGHT | F_SURF_NOLIGHTMAP)\r
-+\r
-+\r
-+\r
-+/* -------------------------------------------------------------------------------\r
-+\r
-+game_t struct\r
-+\r
-+------------------------------------------------------------------------------- */\r
-+\r
-+{\r
-+      "qfusion",                      /* -game x */\r
-+      "baseq3",                       /* default base game data dir */\r
-+      ".q3a",                         /* unix home sub-dir */\r
-+      "quake",                        /* magic path word */\r
-+      "scripts",                      /* shader directory */\r
-+      2048,                           /* max lightmapped surface verts */\r
-+      2048,                           /* max surface verts */\r
-+      12288,                          /* max surface indexes */\r
-+      qtrue,                          /* flares */\r
-+      "flareshader",          /* default flare shader */\r
-+      qfalse,                         /* wolf lighting model? */\r
-+      512,                            /* lightmap width/height */\r
-+      1.0f,                           /* lightmap gamma */\r
-+      1.0f,                           /* lightmap exposure */\r
-+      1.0f,                           /* lightmap compensate */\r
-+      1.0f,                           /* lightgrid scale */\r
-+      1.0f,                           /* lightgrid ambient scale */\r
-+      qfalse,                         /* disable shader lightstyles hack */\r
-+      qfalse,                         /* keep light entities on bsp */\r
-+      8,                                      /* default patchMeta subdivisions tolerance */\r
-+      qfalse,                         /* patch casting enabled */\r
-+      qfalse,                         /* compile deluxemaps */\r
-+      0,                                      /* deluxemaps default mode */\r
-+      "FBSP",                         /* bsp file prefix */\r
-+      1,                                      /* bsp file version */\r
-+      qfalse,                         /* cod-style lump len/ofs order */\r
-+      LoadRBSPFile,           /* bsp load function */\r
-+      WriteRBSPFile,          /* bsp write function */\r
-+\r
-+      {\r
-+              /* name                         contentFlags                            contentFlagsClear                       surfaceFlags                            surfaceFlagsClear                       compileFlags                            compileFlagsClear */\r
-+              \r
-+              /* default */\r
-+              { "default",            F_CONT_SOLID,                           -1,                                                     0,                                                      -1,                                                     C_SOLID,                                        -1 },\r
-+              \r
-+              \r
-+              /* ydnar */\r
-+              { "lightgrid",          0,                                                      0,                                                      0,                                                      0,                                                      C_LIGHTGRID,                            0 },\r
-+              { "antiportal",         0,                                                      0,                                                      0,                                                      0,                                                      C_ANTIPORTAL,                           0 },\r
-+              { "skip",                       0,                                                      0,                                                      0,                                                      0,                                                      C_SKIP,                                         0 },\r
-+              \r
-+              \r
-+              /* compiler */\r
-+              { "origin",                     F_CONT_ORIGIN,                          F_CONT_SOLID,                           0,                                                      0,                                                      C_ORIGIN | C_TRANSLUCENT,       C_SOLID },\r
-+              { "areaportal",         F_CONT_AREAPORTAL,                      F_CONT_SOLID,                           0,                                                      0,                                                      C_AREAPORTAL | C_TRANSLUCENT,   C_SOLID },\r
-+              { "trans",                      F_CONT_TRANSLUCENT,                     0,                                                      0,                                                      0,                                                      C_TRANSLUCENT,                          0 },\r
-+              { "detail",                     F_CONT_DETAIL,                          0,                                                      0,                                                      0,                                                      C_DETAIL,                                       0 },\r
-+              { "structural",         F_CONT_STRUCTURAL,                      0,                                                      0,                                                      0,                                                      C_STRUCTURAL,                           0 },\r
-+              { "hint",                       0,                                                      0,                                                      F_SURF_HINT,                            0,                                                      C_HINT,                                         0 },\r
-+              { "nodraw",                     0,                                                      0,                                                      F_SURF_NODRAW,                          0,                                                      C_NODRAW,                                       0 },\r
-+              \r
-+              { "alphashadow",        0,                                                      0,                                                      F_SURF_ALPHASHADOW,                     0,                                                      C_ALPHASHADOW | C_TRANSLUCENT,  0 },\r
-+              { "lightfilter",        0,                                                      0,                                                      F_SURF_LIGHTFILTER,                     0,                                                      C_LIGHTFILTER | C_TRANSLUCENT,  0 },\r
-+              { "nolightmap",         0,                                                      0,                                                      F_SURF_VERTEXLIT,                       0,                                                      C_VERTEXLIT,                            0 },\r
-+              { "pointlight",         0,                                                      0,                                                      F_SURF_VERTEXLIT,                       0,                                                      C_VERTEXLIT,                            0 },\r
-+              \r
-+              \r
-+              /* game */\r
-+              { "nonsolid",           0,                                                      F_CONT_SOLID,                           F_SURF_NONSOLID,                        0,                                                      0,                                                      C_SOLID },\r
-+              \r
-+              { "trigger",            F_CONT_TRIGGER,                         F_CONT_SOLID,                           0,                                                      0,                                                      C_TRANSLUCENT,                          C_SOLID },\r
-+              \r
-+              { "water",                      F_CONT_WATER,                           F_CONT_SOLID,                           0,                                                      0,                                                      C_LIQUID | C_TRANSLUCENT,       C_SOLID },\r
-+              { "slime",                      F_CONT_SLIME,                           F_CONT_SOLID,                           0,                                                      0,                                                      C_LIQUID | C_TRANSLUCENT,       C_SOLID },\r
-+              { "lava",                       F_CONT_LAVA,                            F_CONT_SOLID,                           0,                                                      0,                                                      C_LIQUID | C_TRANSLUCENT,       C_SOLID },\r
-+              \r
-+              { "playerclip",         F_CONT_PLAYERCLIP,                      F_CONT_SOLID,                           0,                                                      0,                                                      C_DETAIL | C_TRANSLUCENT,       C_SOLID },\r
-+              { "monsterclip",        F_CONT_MONSTERCLIP,                     F_CONT_SOLID,                           0,                                                      0,                                                      C_DETAIL | C_TRANSLUCENT,       C_SOLID },\r
-+              { "nodrop",                     F_CONT_NODROP,                          F_CONT_SOLID,                           0,                                                      0,                                                      C_TRANSLUCENT,                          C_SOLID },\r
-+              \r
-+              { "clusterportal",      F_CONT_CLUSTERPORTAL,           F_CONT_SOLID,                           0,                                                      0,                                                      C_TRANSLUCENT,                          C_SOLID },\r
-+              { "donotenter",         F_CONT_DONOTENTER,                      F_CONT_SOLID,                           0,                                                      0,                                                      C_TRANSLUCENT,                          C_SOLID },\r
-+              { "botclip",            F_CONT_BOTCLIP,                         F_CONT_SOLID,                           0,                                                      0,                                                      C_TRANSLUCENT,                          C_SOLID },\r
-+              \r
-+              { "fog",                        F_CONT_FOG,                                     F_CONT_SOLID,                           0,                                                      0,                                                      C_FOG,                                          C_SOLID },\r
-+              { "sky",                        0,                                                      0,                                                      F_SURF_SKY,                                     0,                                                      C_SKY,                                          0 },\r
-+              \r
-+              { "slick",                      0,                                                      0,                                                      F_SURF_SLICK,                           0,                                          &nbs