diff options
Diffstat (limited to 'apps/plugins/sdl/progs/quake/r_main.c')
-rw-r--r-- | apps/plugins/sdl/progs/quake/r_main.c | 1089 |
1 files changed, 1089 insertions, 0 deletions
diff --git a/apps/plugins/sdl/progs/quake/r_main.c b/apps/plugins/sdl/progs/quake/r_main.c new file mode 100644 index 0000000000..dc785a850d --- /dev/null +++ b/apps/plugins/sdl/progs/quake/r_main.c | |||
@@ -0,0 +1,1089 @@ | |||
1 | /* | ||
2 | Copyright (C) 1996-1997 Id Software, Inc. | ||
3 | |||
4 | This program is free software; you can redistribute it and/or | ||
5 | modify it under the terms of the GNU General Public License | ||
6 | as published by the Free Software Foundation; either version 2 | ||
7 | of the License, or (at your option) any later version. | ||
8 | |||
9 | This program is distributed in the hope that it will be useful, | ||
10 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. | ||
12 | |||
13 | See the GNU General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU General Public License | ||
16 | along with this program; if not, write to the Free Software | ||
17 | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. | ||
18 | |||
19 | */ | ||
20 | // r_main.c | ||
21 | |||
22 | #include "quakedef.h" | ||
23 | #include "r_local.h" | ||
24 | |||
25 | //define PASSAGES | ||
26 | |||
27 | void *colormap; | ||
28 | vec3_t viewlightvec; | ||
29 | alight_t r_viewlighting = {128, 192, viewlightvec}; | ||
30 | float r_time1; | ||
31 | int r_numallocatededges; | ||
32 | qboolean r_drawpolys; | ||
33 | qboolean r_drawculledpolys; | ||
34 | qboolean r_worldpolysbacktofront; | ||
35 | qboolean r_recursiveaffinetriangles = true; | ||
36 | int r_pixbytes = 1; | ||
37 | float r_aliasuvscale = 1.0; | ||
38 | int r_outofsurfaces; | ||
39 | int r_outofedges; | ||
40 | |||
41 | qboolean r_dowarp, r_dowarpold, r_viewchanged; | ||
42 | |||
43 | int numbtofpolys; | ||
44 | btofpoly_t *pbtofpolys; | ||
45 | mvertex_t *r_pcurrentvertbase; | ||
46 | |||
47 | int c_surf; | ||
48 | int r_maxsurfsseen, r_maxedgesseen, r_cnumsurfs; | ||
49 | qboolean r_surfsonstack; | ||
50 | int r_clipflags; | ||
51 | |||
52 | byte *r_warpbuffer; | ||
53 | |||
54 | byte *r_stack_start; | ||
55 | |||
56 | qboolean r_fov_greater_than_90; | ||
57 | |||
58 | // | ||
59 | // view origin | ||
60 | // | ||
61 | vec3_t vup, base_vup; | ||
62 | vec3_t vpn, base_vpn; | ||
63 | vec3_t vright, base_vright; | ||
64 | vec3_t r_origin; | ||
65 | |||
66 | // | ||
67 | // screen size info | ||
68 | // | ||
69 | refdef_t r_refdef; | ||
70 | float xcenter, ycenter; | ||
71 | float xscale, yscale; | ||
72 | float xscaleinv, yscaleinv; | ||
73 | float xscaleshrink, yscaleshrink; | ||
74 | float aliasxscale, aliasyscale, aliasxcenter, aliasycenter; | ||
75 | |||
76 | int screenwidth; | ||
77 | |||
78 | float pixelAspect; | ||
79 | float screenAspect; | ||
80 | float verticalFieldOfView; | ||
81 | float xOrigin, yOrigin; | ||
82 | |||
83 | mplane_t screenedge[4]; | ||
84 | |||
85 | // | ||
86 | // refresh flags | ||
87 | // | ||
88 | int r_framecount = 1; // so frame counts initialized to 0 don't match | ||
89 | int r_visframecount; | ||
90 | int d_spanpixcount; | ||
91 | int r_polycount; | ||
92 | int r_drawnpolycount; | ||
93 | int r_wholepolycount; | ||
94 | |||
95 | #define VIEWMODNAME_LENGTH 256 | ||
96 | char viewmodname[VIEWMODNAME_LENGTH+1]; | ||
97 | int modcount; | ||
98 | |||
99 | int *pfrustum_indexes[4]; | ||
100 | int r_frustum_indexes[4*6]; | ||
101 | |||
102 | int reinit_surfcache = 1; // if 1, surface cache is currently empty and | ||
103 | // must be reinitialized for current cache size | ||
104 | |||
105 | mleaf_t *r_viewleaf, *r_oldviewleaf; | ||
106 | |||
107 | texture_t *r_notexture_mip; | ||
108 | |||
109 | float r_aliastransition, r_resfudge; | ||
110 | |||
111 | int d_lightstylevalue[256]; // 8.8 fraction of base light value | ||
112 | |||
113 | float dp_time1, dp_time2, db_time1, db_time2, rw_time1, rw_time2; | ||
114 | float se_time1, se_time2, de_time1, de_time2, dv_time1, dv_time2; | ||
115 | |||
116 | void R_MarkLeaves (void); | ||
117 | |||
118 | cvar_t r_draworder = {"r_draworder","0"}; | ||
119 | cvar_t r_speeds = {"r_speeds","0"}; | ||
120 | cvar_t r_timegraph = {"r_timegraph","0"}; | ||
121 | cvar_t r_graphheight = {"r_graphheight","10"}; | ||
122 | cvar_t r_clearcolor = {"r_clearcolor","2"}; | ||
123 | cvar_t r_waterwarp = {"r_waterwarp","1"}; | ||
124 | cvar_t r_fullbright = {"r_fullbright","0"}; | ||
125 | cvar_t r_drawentities = {"r_drawentities","1"}; | ||
126 | cvar_t r_drawviewmodel = {"r_drawviewmodel","1"}; | ||
127 | cvar_t r_aliasstats = {"r_polymodelstats","0"}; | ||
128 | cvar_t r_dspeeds = {"r_dspeeds","0"}; | ||
129 | cvar_t r_drawflat = {"r_drawflat", "0"}; | ||
130 | cvar_t r_ambient = {"r_ambient", "0"}; | ||
131 | cvar_t r_reportsurfout = {"r_reportsurfout", "0"}; | ||
132 | cvar_t r_maxsurfs = {"r_maxsurfs", "0"}; | ||
133 | cvar_t r_numsurfs = {"r_numsurfs", "0"}; | ||
134 | cvar_t r_reportedgeout = {"r_reportedgeout", "0"}; | ||
135 | cvar_t r_maxedges = {"r_maxedges", "0"}; | ||
136 | cvar_t r_numedges = {"r_numedges", "0"}; | ||
137 | cvar_t r_aliastransbase = {"r_aliastransbase", "200"}; | ||
138 | cvar_t r_aliastransadj = {"r_aliastransadj", "100"}; | ||
139 | |||
140 | extern cvar_t scr_fov; | ||
141 | |||
142 | void CreatePassages (void); | ||
143 | void SetVisibilityByPassages (void); | ||
144 | |||
145 | /* | ||
146 | ================== | ||
147 | R_InitTextures | ||
148 | ================== | ||
149 | */ | ||
150 | void R_InitTextures (void) | ||
151 | { | ||
152 | int x,y, m; | ||
153 | byte *dest; | ||
154 | |||
155 | // create a simple checkerboard texture for the default | ||
156 | r_notexture_mip = Hunk_AllocName (sizeof(texture_t) + 16*16+8*8+4*4+2*2, "notexture"); | ||
157 | |||
158 | r_notexture_mip->width = r_notexture_mip->height = 16; | ||
159 | r_notexture_mip->offsets[0] = sizeof(texture_t); | ||
160 | r_notexture_mip->offsets[1] = r_notexture_mip->offsets[0] + 16*16; | ||
161 | r_notexture_mip->offsets[2] = r_notexture_mip->offsets[1] + 8*8; | ||
162 | r_notexture_mip->offsets[3] = r_notexture_mip->offsets[2] + 4*4; | ||
163 | |||
164 | for (m=0 ; m<4 ; m++) | ||
165 | { | ||
166 | dest = (byte *)r_notexture_mip + r_notexture_mip->offsets[m]; | ||
167 | for (y=0 ; y< (16>>m) ; y++) | ||
168 | for (x=0 ; x< (16>>m) ; x++) | ||
169 | { | ||
170 | if ( (y< (8>>m) ) ^ (x< (8>>m) ) ) | ||
171 | *dest++ = 0; | ||
172 | else | ||
173 | *dest++ = 0xff; | ||
174 | } | ||
175 | } | ||
176 | } | ||
177 | |||
178 | /* | ||
179 | =============== | ||
180 | R_Init | ||
181 | =============== | ||
182 | */ | ||
183 | void R_Init (void) | ||
184 | { | ||
185 | int dummy; | ||
186 | |||
187 | // get stack position so we can guess if we are going to overflow | ||
188 | r_stack_start = (byte *)&dummy; | ||
189 | |||
190 | R_InitTurb (); | ||
191 | |||
192 | Cmd_AddCommand ("timerefresh", R_TimeRefresh_f); | ||
193 | Cmd_AddCommand ("pointfile", R_ReadPointFile_f); | ||
194 | |||
195 | Cvar_RegisterVariable (&r_draworder); | ||
196 | Cvar_RegisterVariable (&r_speeds); | ||
197 | Cvar_RegisterVariable (&r_timegraph); | ||
198 | Cvar_RegisterVariable (&r_graphheight); | ||
199 | Cvar_RegisterVariable (&r_drawflat); | ||
200 | Cvar_RegisterVariable (&r_ambient); | ||
201 | Cvar_RegisterVariable (&r_clearcolor); | ||
202 | Cvar_RegisterVariable (&r_waterwarp); | ||
203 | Cvar_RegisterVariable (&r_fullbright); | ||
204 | Cvar_RegisterVariable (&r_drawentities); | ||
205 | Cvar_RegisterVariable (&r_drawviewmodel); | ||
206 | Cvar_RegisterVariable (&r_aliasstats); | ||
207 | Cvar_RegisterVariable (&r_dspeeds); | ||
208 | Cvar_RegisterVariable (&r_reportsurfout); | ||
209 | Cvar_RegisterVariable (&r_maxsurfs); | ||
210 | Cvar_RegisterVariable (&r_numsurfs); | ||
211 | Cvar_RegisterVariable (&r_reportedgeout); | ||
212 | Cvar_RegisterVariable (&r_maxedges); | ||
213 | Cvar_RegisterVariable (&r_numedges); | ||
214 | Cvar_RegisterVariable (&r_aliastransbase); | ||
215 | Cvar_RegisterVariable (&r_aliastransadj); | ||
216 | |||
217 | Cvar_SetValue ("r_maxedges", (float)NUMSTACKEDGES); | ||
218 | Cvar_SetValue ("r_maxsurfs", (float)NUMSTACKSURFACES); | ||
219 | |||
220 | view_clipplanes[0].leftedge = true; | ||
221 | view_clipplanes[1].rightedge = true; | ||
222 | view_clipplanes[1].leftedge = view_clipplanes[2].leftedge = | ||
223 | view_clipplanes[3].leftedge = false; | ||
224 | view_clipplanes[0].rightedge = view_clipplanes[2].rightedge = | ||
225 | view_clipplanes[3].rightedge = false; | ||
226 | |||
227 | r_refdef.xOrigin = XCENTERING; | ||
228 | r_refdef.yOrigin = YCENTERING; | ||
229 | |||
230 | R_InitParticles (); | ||
231 | |||
232 | // TODO: collect 386-specific code in one place | ||
233 | #if id386 | ||
234 | Sys_MakeCodeWriteable ((long)R_EdgeCodeStart, | ||
235 | (long)R_EdgeCodeEnd - (long)R_EdgeCodeStart); | ||
236 | #endif // id386 | ||
237 | |||
238 | D_Init (); | ||
239 | } | ||
240 | |||
241 | /* | ||
242 | =============== | ||
243 | R_NewMap | ||
244 | =============== | ||
245 | */ | ||
246 | void R_NewMap (void) | ||
247 | { | ||
248 | int i; | ||
249 | |||
250 | // clear out efrags in case the level hasn't been reloaded | ||
251 | // FIXME: is this one short? | ||
252 | for (i=0 ; i<cl.worldmodel->numleafs ; i++) | ||
253 | cl.worldmodel->leafs[i].efrags = NULL; | ||
254 | |||
255 | r_viewleaf = NULL; | ||
256 | R_ClearParticles (); | ||
257 | |||
258 | r_cnumsurfs = r_maxsurfs.value; | ||
259 | |||
260 | if (r_cnumsurfs <= MINSURFACES) | ||
261 | r_cnumsurfs = MINSURFACES; | ||
262 | |||
263 | if (r_cnumsurfs > NUMSTACKSURFACES) | ||
264 | { | ||
265 | surfaces = Hunk_AllocName (r_cnumsurfs * sizeof(surf_t), "surfaces"); | ||
266 | surface_p = surfaces; | ||
267 | surf_max = &surfaces[r_cnumsurfs]; | ||
268 | r_surfsonstack = false; | ||
269 | // surface 0 doesn't really exist; it's just a dummy because index 0 | ||
270 | // is used to indicate no edge attached to surface | ||
271 | surfaces--; | ||
272 | R_SurfacePatch (); | ||
273 | } | ||
274 | else | ||
275 | { | ||
276 | r_surfsonstack = true; | ||
277 | } | ||
278 | |||
279 | r_maxedgesseen = 0; | ||
280 | r_maxsurfsseen = 0; | ||
281 | |||
282 | r_numallocatededges = r_maxedges.value; | ||
283 | |||
284 | if (r_numallocatededges < MINEDGES) | ||
285 | r_numallocatededges = MINEDGES; | ||
286 | |||
287 | if (r_numallocatededges <= NUMSTACKEDGES) | ||
288 | { | ||
289 | auxedges = NULL; | ||
290 | } | ||
291 | else | ||
292 | { | ||
293 | auxedges = Hunk_AllocName (r_numallocatededges * sizeof(edge_t), | ||
294 | "edges"); | ||
295 | } | ||
296 | |||
297 | r_dowarpold = false; | ||
298 | r_viewchanged = false; | ||
299 | #ifdef PASSAGES | ||
300 | CreatePassages (); | ||
301 | #endif | ||
302 | } | ||
303 | |||
304 | |||
305 | /* | ||
306 | =============== | ||
307 | R_SetVrect | ||
308 | =============== | ||
309 | */ | ||
310 | void R_SetVrect (vrect_t *pvrectin, vrect_t *pvrect, int lineadj) | ||
311 | { | ||
312 | int h; | ||
313 | float size; | ||
314 | |||
315 | size = scr_viewsize.value > 100 ? 100 : scr_viewsize.value; | ||
316 | if (cl.intermission) | ||
317 | { | ||
318 | size = 100; | ||
319 | lineadj = 0; | ||
320 | } | ||
321 | size /= 100; | ||
322 | |||
323 | h = pvrectin->height - lineadj; | ||
324 | pvrect->width = pvrectin->width * size; | ||
325 | if (pvrect->width < 96) | ||
326 | { | ||
327 | size = 96.0 / pvrectin->width; | ||
328 | pvrect->width = 96; // min for icons | ||
329 | } | ||
330 | pvrect->width &= ~7; | ||
331 | pvrect->height = pvrectin->height * size; | ||
332 | if (pvrect->height > pvrectin->height - lineadj) | ||
333 | pvrect->height = pvrectin->height - lineadj; | ||
334 | |||
335 | pvrect->height &= ~1; | ||
336 | |||
337 | pvrect->x = (pvrectin->width - pvrect->width)/2; | ||
338 | pvrect->y = (h - pvrect->height)/2; | ||
339 | |||
340 | { | ||
341 | if (lcd_x.value) | ||
342 | { | ||
343 | pvrect->y >>= 1; | ||
344 | pvrect->height >>= 1; | ||
345 | } | ||
346 | } | ||
347 | } | ||
348 | |||
349 | |||
350 | /* | ||
351 | =============== | ||
352 | R_ViewChanged | ||
353 | |||
354 | Called every time the vid structure or r_refdef changes. | ||
355 | Guaranteed to be called before the first refresh | ||
356 | =============== | ||
357 | */ | ||
358 | void R_ViewChanged (vrect_t *pvrect, int lineadj, float aspect) | ||
359 | { | ||
360 | int i; | ||
361 | float res_scale; | ||
362 | |||
363 | r_viewchanged = true; | ||
364 | |||
365 | R_SetVrect (pvrect, &r_refdef.vrect, lineadj); | ||
366 | |||
367 | r_refdef.horizontalFieldOfView = 2.0 * tan (r_refdef.fov_x/360*M_PI); | ||
368 | r_refdef.fvrectx = (float)r_refdef.vrect.x; | ||
369 | r_refdef.fvrectx_adj = (float)r_refdef.vrect.x - 0.5; | ||
370 | r_refdef.vrect_x_adj_shift20 = (r_refdef.vrect.x<<20) + (1<<19) - 1; | ||
371 | r_refdef.fvrecty = (float)r_refdef.vrect.y; | ||
372 | r_refdef.fvrecty_adj = (float)r_refdef.vrect.y - 0.5; | ||
373 | r_refdef.vrectright = r_refdef.vrect.x + r_refdef.vrect.width; | ||
374 | r_refdef.vrectright_adj_shift20 = (r_refdef.vrectright<<20) + (1<<19) - 1; | ||
375 | r_refdef.fvrectright = (float)r_refdef.vrectright; | ||
376 | r_refdef.fvrectright_adj = (float)r_refdef.vrectright - 0.5; | ||
377 | r_refdef.vrectrightedge = (float)r_refdef.vrectright - 0.99; | ||
378 | r_refdef.vrectbottom = r_refdef.vrect.y + r_refdef.vrect.height; | ||
379 | r_refdef.fvrectbottom = (float)r_refdef.vrectbottom; | ||
380 | r_refdef.fvrectbottom_adj = (float)r_refdef.vrectbottom - 0.5; | ||
381 | |||
382 | r_refdef.aliasvrect.x = (int)(r_refdef.vrect.x * r_aliasuvscale); | ||
383 | r_refdef.aliasvrect.y = (int)(r_refdef.vrect.y * r_aliasuvscale); | ||
384 | r_refdef.aliasvrect.width = (int)(r_refdef.vrect.width * r_aliasuvscale); | ||
385 | r_refdef.aliasvrect.height = (int)(r_refdef.vrect.height * r_aliasuvscale); | ||
386 | r_refdef.aliasvrectright = r_refdef.aliasvrect.x + | ||
387 | r_refdef.aliasvrect.width; | ||
388 | r_refdef.aliasvrectbottom = r_refdef.aliasvrect.y + | ||
389 | r_refdef.aliasvrect.height; | ||
390 | |||
391 | pixelAspect = aspect; | ||
392 | xOrigin = r_refdef.xOrigin; | ||
393 | yOrigin = r_refdef.yOrigin; | ||
394 | |||
395 | screenAspect = r_refdef.vrect.width*pixelAspect / | ||
396 | r_refdef.vrect.height; | ||
397 | // 320*200 1.0 pixelAspect = 1.6 screenAspect | ||
398 | // 320*240 1.0 pixelAspect = 1.3333 screenAspect | ||
399 | // proper 320*200 pixelAspect = 0.8333333 | ||
400 | |||
401 | verticalFieldOfView = r_refdef.horizontalFieldOfView / screenAspect; | ||
402 | |||
403 | // values for perspective projection | ||
404 | // if math were exact, the values would range from 0.5 to to range+0.5 | ||
405 | // hopefully they wll be in the 0.000001 to range+.999999 and truncate | ||
406 | // the polygon rasterization will never render in the first row or column | ||
407 | // but will definately render in the [range] row and column, so adjust the | ||
408 | // buffer origin to get an exact edge to edge fill | ||
409 | xcenter = ((float)r_refdef.vrect.width * XCENTERING) + | ||
410 | r_refdef.vrect.x - 0.5; | ||
411 | aliasxcenter = xcenter * r_aliasuvscale; | ||
412 | ycenter = ((float)r_refdef.vrect.height * YCENTERING) + | ||
413 | r_refdef.vrect.y - 0.5; | ||
414 | aliasycenter = ycenter * r_aliasuvscale; | ||
415 | |||
416 | xscale = r_refdef.vrect.width / r_refdef.horizontalFieldOfView; | ||
417 | aliasxscale = xscale * r_aliasuvscale; | ||
418 | xscaleinv = 1.0 / xscale; | ||
419 | yscale = xscale * pixelAspect; | ||
420 | aliasyscale = yscale * r_aliasuvscale; | ||
421 | yscaleinv = 1.0 / yscale; | ||
422 | xscaleshrink = (r_refdef.vrect.width-6)/r_refdef.horizontalFieldOfView; | ||
423 | yscaleshrink = xscaleshrink*pixelAspect; | ||
424 | |||
425 | // left side clip | ||
426 | screenedge[0].normal[0] = -1.0 / (xOrigin*r_refdef.horizontalFieldOfView); | ||
427 | screenedge[0].normal[1] = 0; | ||
428 | screenedge[0].normal[2] = 1; | ||
429 | screenedge[0].type = PLANE_ANYZ; | ||
430 | |||
431 | // right side clip | ||
432 | screenedge[1].normal[0] = | ||
433 | 1.0 / ((1.0-xOrigin)*r_refdef.horizontalFieldOfView); | ||
434 | screenedge[1].normal[1] = 0; | ||
435 | screenedge[1].normal[2] = 1; | ||
436 | screenedge[1].type = PLANE_ANYZ; | ||
437 | |||
438 | // top side clip | ||
439 | screenedge[2].normal[0] = 0; | ||
440 | screenedge[2].normal[1] = -1.0 / (yOrigin*verticalFieldOfView); | ||
441 | screenedge[2].normal[2] = 1; | ||
442 | screenedge[2].type = PLANE_ANYZ; | ||
443 | |||
444 | // bottom side clip | ||
445 | screenedge[3].normal[0] = 0; | ||
446 | screenedge[3].normal[1] = 1.0 / ((1.0-yOrigin)*verticalFieldOfView); | ||
447 | screenedge[3].normal[2] = 1; | ||
448 | screenedge[3].type = PLANE_ANYZ; | ||
449 | |||
450 | for (i=0 ; i<4 ; i++) | ||
451 | VectorNormalizeNoRet (screenedge[i].normal); | ||
452 | |||
453 | res_scale = sqrt ((double)(r_refdef.vrect.width * r_refdef.vrect.height) / | ||
454 | (320.0 * 152.0)) * | ||
455 | (2.0 / r_refdef.horizontalFieldOfView); | ||
456 | r_aliastransition = r_aliastransbase.value * res_scale; | ||
457 | r_resfudge = r_aliastransadj.value * res_scale; | ||
458 | |||
459 | if (scr_fov.value <= 90.0) | ||
460 | r_fov_greater_than_90 = false; | ||
461 | else | ||
462 | r_fov_greater_than_90 = true; | ||
463 | |||
464 | // TODO: collect 386-specific code in one place | ||
465 | #if id386 | ||
466 | if (r_pixbytes == 1) | ||
467 | { | ||
468 | Sys_MakeCodeWriteable ((long)R_Surf8Start, | ||
469 | (long)R_Surf8End - (long)R_Surf8Start); | ||
470 | colormap = vid.colormap; | ||
471 | R_Surf8Patch (); | ||
472 | } | ||
473 | else | ||
474 | { | ||
475 | Sys_MakeCodeWriteable ((long)R_Surf16Start, | ||
476 | (long)R_Surf16End - (long)R_Surf16Start); | ||
477 | colormap = vid.colormap16; | ||
478 | R_Surf16Patch (); | ||
479 | } | ||
480 | #endif // id386 | ||
481 | |||
482 | D_ViewChanged (); | ||
483 | } | ||
484 | |||
485 | |||
486 | /* | ||
487 | =============== | ||
488 | R_MarkLeaves | ||
489 | =============== | ||
490 | */ | ||
491 | void R_MarkLeaves (void) | ||
492 | { | ||
493 | byte *vis; | ||
494 | mnode_t *node; | ||
495 | int i; | ||
496 | |||
497 | if (r_oldviewleaf == r_viewleaf) | ||
498 | return; | ||
499 | |||
500 | r_visframecount++; | ||
501 | r_oldviewleaf = r_viewleaf; | ||
502 | |||
503 | vis = Mod_LeafPVS (r_viewleaf, cl.worldmodel); | ||
504 | |||
505 | for (i=0 ; i<cl.worldmodel->numleafs ; i++) | ||
506 | { | ||
507 | if (vis[i>>3] & (1<<(i&7))) | ||
508 | { | ||
509 | node = (mnode_t *)&cl.worldmodel->leafs[i+1]; | ||
510 | do | ||
511 | { | ||
512 | if (node->visframe == r_visframecount) | ||
513 | break; | ||
514 | node->visframe = r_visframecount; | ||
515 | node = node->parent; | ||
516 | } while (node); | ||
517 | } | ||
518 | } | ||
519 | } | ||
520 | |||
521 | |||
522 | /* | ||
523 | ============= | ||
524 | R_DrawEntitiesOnList | ||
525 | ============= | ||
526 | */ | ||
527 | void R_DrawEntitiesOnList (void) | ||
528 | { | ||
529 | int i, j; | ||
530 | int lnum; | ||
531 | alight_t lighting; | ||
532 | // FIXME: remove and do real lighting | ||
533 | float lightvec[3] = {-1, 0, 0}; | ||
534 | vec3_t dist; | ||
535 | float add; | ||
536 | |||
537 | if (!r_drawentities.value) | ||
538 | return; | ||
539 | |||
540 | for (i=0 ; i<cl_numvisedicts ; i++) | ||
541 | { | ||
542 | currententity = cl_visedicts[i]; | ||
543 | |||
544 | if (currententity == &cl_entities[cl.viewentity]) | ||
545 | continue; // don't draw the player | ||
546 | |||
547 | switch (currententity->model->type) | ||
548 | { | ||
549 | case mod_sprite: | ||
550 | VectorCopy (currententity->origin, r_entorigin); | ||
551 | VectorSubtract (r_origin, r_entorigin, modelorg); | ||
552 | R_DrawSprite (); | ||
553 | break; | ||
554 | |||
555 | case mod_alias: | ||
556 | VectorCopy (currententity->origin, r_entorigin); | ||
557 | VectorSubtract (r_origin, r_entorigin, modelorg); | ||
558 | |||
559 | // see if the bounding box lets us trivially reject, also sets | ||
560 | // trivial accept status | ||
561 | if (R_AliasCheckBBox ()) | ||
562 | { | ||
563 | j = R_LightPoint (currententity->origin); | ||
564 | |||
565 | lighting.ambientlight = j; | ||
566 | lighting.shadelight = j; | ||
567 | |||
568 | lighting.plightvec = lightvec; | ||
569 | |||
570 | for (lnum=0 ; lnum<MAX_DLIGHTS ; lnum++) | ||
571 | { | ||
572 | if (cl_dlights[lnum].die >= cl.time) | ||
573 | { | ||
574 | VectorSubtract (currententity->origin, | ||
575 | cl_dlights[lnum].origin, | ||
576 | dist); | ||
577 | add = cl_dlights[lnum].radius - Length(dist); | ||
578 | |||
579 | if (add > 0) | ||
580 | lighting.ambientlight += add; | ||
581 | } | ||
582 | } | ||
583 | |||
584 | // clamp lighting so it doesn't overbright as much | ||
585 | if (lighting.ambientlight > 128) | ||
586 | lighting.ambientlight = 128; | ||
587 | if (lighting.ambientlight + lighting.shadelight > 192) | ||
588 | lighting.shadelight = 192 - lighting.ambientlight; | ||
589 | |||
590 | R_AliasDrawModel (&lighting); | ||
591 | } | ||
592 | |||
593 | break; | ||
594 | |||
595 | default: | ||
596 | break; | ||
597 | } | ||
598 | } | ||
599 | } | ||
600 | |||
601 | /* | ||
602 | ============= | ||
603 | R_DrawViewModel | ||
604 | ============= | ||
605 | */ | ||
606 | void R_DrawViewModel (void) | ||
607 | { | ||
608 | // FIXME: remove and do real lighting | ||
609 | float lightvec[3] = {-1, 0, 0}; | ||
610 | int j; | ||
611 | int lnum; | ||
612 | vec3_t dist; | ||
613 | float add; | ||
614 | dlight_t *dl; | ||
615 | |||
616 | if (!r_drawviewmodel.value || r_fov_greater_than_90) | ||
617 | return; | ||
618 | |||
619 | if (cl.items & IT_INVISIBILITY) | ||
620 | return; | ||
621 | |||
622 | if (cl.stats[STAT_HEALTH] <= 0) | ||
623 | return; | ||
624 | |||
625 | currententity = &cl.viewent; | ||
626 | if (!currententity->model) | ||
627 | return; | ||
628 | |||
629 | VectorCopy (currententity->origin, r_entorigin); | ||
630 | VectorSubtract (r_origin, r_entorigin, modelorg); | ||
631 | |||
632 | VectorCopy (vup, viewlightvec); | ||
633 | VectorInverse (viewlightvec); | ||
634 | |||
635 | j = R_LightPoint (currententity->origin); | ||
636 | |||
637 | if (j < 24) | ||
638 | j = 24; // allways give some light on gun | ||
639 | r_viewlighting.ambientlight = j; | ||
640 | r_viewlighting.shadelight = j; | ||
641 | |||
642 | // add dynamic lights | ||
643 | for (lnum=0 ; lnum<MAX_DLIGHTS ; lnum++) | ||
644 | { | ||
645 | dl = &cl_dlights[lnum]; | ||
646 | if (!dl->radius) | ||
647 | continue; | ||
648 | if (!dl->radius) | ||
649 | continue; | ||
650 | if (dl->die < cl.time) | ||
651 | continue; | ||
652 | |||
653 | VectorSubtract (currententity->origin, dl->origin, dist); | ||
654 | add = dl->radius - Length(dist); | ||
655 | if (add > 0) | ||
656 | r_viewlighting.ambientlight += add; | ||
657 | } | ||
658 | |||
659 | // clamp lighting so it doesn't overbright as much | ||
660 | if (r_viewlighting.ambientlight > 128) | ||
661 | r_viewlighting.ambientlight = 128; | ||
662 | if (r_viewlighting.ambientlight + r_viewlighting.shadelight > 192) | ||
663 | r_viewlighting.shadelight = 192 - r_viewlighting.ambientlight; | ||
664 | |||
665 | r_viewlighting.plightvec = lightvec; | ||
666 | |||
667 | #ifdef QUAKE2 | ||
668 | cl.light_level = r_viewlighting.ambientlight; | ||
669 | #endif | ||
670 | |||
671 | R_AliasDrawModel (&r_viewlighting); | ||
672 | } | ||
673 | |||
674 | |||
675 | /* | ||
676 | ============= | ||
677 | R_BmodelCheckBBox | ||
678 | ============= | ||
679 | */ | ||
680 | int R_BmodelCheckBBox (model_t *clmodel, float *minmaxs) | ||
681 | { | ||
682 | int i, *pindex, clipflags; | ||
683 | vec3_t acceptpt, rejectpt; | ||
684 | double d; | ||
685 | |||
686 | clipflags = 0; | ||
687 | |||
688 | if (currententity->angles[0] || currententity->angles[1] | ||
689 | || currententity->angles[2]) | ||
690 | { | ||
691 | for (i=0 ; i<4 ; i++) | ||
692 | { | ||
693 | d = DotProduct (currententity->origin, view_clipplanes[i].normal); | ||
694 | d -= view_clipplanes[i].dist; | ||
695 | |||
696 | if (d <= -clmodel->radius) | ||
697 | return BMODEL_FULLY_CLIPPED; | ||
698 | |||
699 | if (d <= clmodel->radius) | ||
700 | clipflags |= (1<<i); | ||
701 | } | ||
702 | } | ||
703 | else | ||
704 | { | ||
705 | for (i=0 ; i<4 ; i++) | ||
706 | { | ||
707 | // generate accept and reject points | ||
708 | // FIXME: do with fast look-ups or integer tests based on the sign bit | ||
709 | // of the floating point values | ||
710 | |||
711 | pindex = pfrustum_indexes[i]; | ||
712 | |||
713 | rejectpt[0] = minmaxs[pindex[0]]; | ||
714 | rejectpt[1] = minmaxs[pindex[1]]; | ||
715 | rejectpt[2] = minmaxs[pindex[2]]; | ||
716 | |||
717 | d = DotProduct (rejectpt, view_clipplanes[i].normal); | ||
718 | d -= view_clipplanes[i].dist; | ||
719 | |||
720 | if (d <= 0) | ||
721 | return BMODEL_FULLY_CLIPPED; | ||
722 | |||
723 | acceptpt[0] = minmaxs[pindex[3+0]]; | ||
724 | acceptpt[1] = minmaxs[pindex[3+1]]; | ||
725 | acceptpt[2] = minmaxs[pindex[3+2]]; | ||
726 | |||
727 | d = DotProduct (acceptpt, view_clipplanes[i].normal); | ||
728 | d -= view_clipplanes[i].dist; | ||
729 | |||
730 | if (d <= 0) | ||
731 | clipflags |= (1<<i); | ||
732 | } | ||
733 | } | ||
734 | |||
735 | return clipflags; | ||
736 | } | ||
737 | |||
738 | |||
739 | /* | ||
740 | ============= | ||
741 | R_DrawBEntitiesOnList | ||
742 | ============= | ||
743 | */ | ||
744 | void R_DrawBEntitiesOnList (void) | ||
745 | { | ||
746 | int i, j, k, clipflags; | ||
747 | vec3_t oldorigin; | ||
748 | model_t *clmodel; | ||
749 | float minmaxs[6]; | ||
750 | |||
751 | if (!r_drawentities.value) | ||
752 | return; | ||
753 | |||
754 | VectorCopy (modelorg, oldorigin); | ||
755 | insubmodel = true; | ||
756 | r_dlightframecount = r_framecount; | ||
757 | |||
758 | for (i=0 ; i<cl_numvisedicts ; i++) | ||
759 | { | ||
760 | currententity = cl_visedicts[i]; | ||
761 | |||
762 | switch (currententity->model->type) | ||
763 | { | ||
764 | case mod_brush: | ||
765 | |||
766 | clmodel = currententity->model; | ||
767 | |||
768 | // see if the bounding box lets us trivially reject, also sets | ||
769 | // trivial accept status | ||
770 | for (j=0 ; j<3 ; j++) | ||
771 | { | ||
772 | minmaxs[j] = currententity->origin[j] + | ||
773 | clmodel->mins[j]; | ||
774 | minmaxs[3+j] = currententity->origin[j] + | ||
775 | clmodel->maxs[j]; | ||
776 | } | ||
777 | |||
778 | clipflags = R_BmodelCheckBBox (clmodel, minmaxs); | ||
779 | |||
780 | if (clipflags != BMODEL_FULLY_CLIPPED) | ||
781 | { | ||
782 | VectorCopy (currententity->origin, r_entorigin); | ||
783 | VectorSubtract (r_origin, r_entorigin, modelorg); | ||
784 | // FIXME: is this needed? | ||
785 | VectorCopy (modelorg, r_worldmodelorg); | ||
786 | |||
787 | r_pcurrentvertbase = clmodel->vertexes; | ||
788 | |||
789 | // FIXME: stop transforming twice | ||
790 | R_RotateBmodel (); | ||
791 | |||
792 | // calculate dynamic lighting for bmodel if it's not an | ||
793 | // instanced model | ||
794 | if (clmodel->firstmodelsurface != 0) | ||
795 | { | ||
796 | for (k=0 ; k<MAX_DLIGHTS ; k++) | ||
797 | { | ||
798 | if ((cl_dlights[k].die < cl.time) || | ||
799 | (!cl_dlights[k].radius)) | ||
800 | { | ||
801 | continue; | ||
802 | } | ||
803 | |||
804 | R_MarkLights (&cl_dlights[k], 1<<k, | ||
805 | clmodel->nodes + clmodel->hulls[0].firstclipnode); | ||
806 | } | ||
807 | } | ||
808 | |||
809 | // if the driver wants polygons, deliver those. Z-buffering is on | ||
810 | // at this point, so no clipping to the world tree is needed, just | ||
811 | // frustum clipping | ||
812 | if (r_drawpolys | r_drawculledpolys) | ||
813 | { | ||
814 | R_ZDrawSubmodelPolys (clmodel); | ||
815 | } | ||
816 | else | ||
817 | { | ||
818 | r_pefragtopnode = NULL; | ||
819 | |||
820 | for (j=0 ; j<3 ; j++) | ||
821 | { | ||
822 | r_emins[j] = minmaxs[j]; | ||
823 | r_emaxs[j] = minmaxs[3+j]; | ||
824 | } | ||
825 | |||
826 | R_SplitEntityOnNode2 (cl.worldmodel->nodes); | ||
827 | |||
828 | if (r_pefragtopnode) | ||
829 | { | ||
830 | currententity->topnode = r_pefragtopnode; | ||
831 | |||
832 | if (r_pefragtopnode->contents >= 0) | ||
833 | { | ||
834 | // not a leaf; has to be clipped to the world BSP | ||
835 | r_clipflags = clipflags; | ||
836 | R_DrawSolidClippedSubmodelPolygons (clmodel); | ||
837 | } | ||
838 | else | ||
839 | { | ||
840 | // falls entirely in one leaf, so we just put all the | ||
841 | // edges in the edge list and let 1/z sorting handle | ||
842 | // drawing order | ||
843 | R_DrawSubmodelPolygons (clmodel, clipflags); | ||
844 | } | ||
845 | |||
846 | currententity->topnode = NULL; | ||
847 | } | ||
848 | } | ||
849 | |||
850 | // put back world rotation and frustum clipping | ||
851 | // FIXME: R_RotateBmodel should just work off base_vxx | ||
852 | VectorCopy (base_vpn, vpn); | ||
853 | VectorCopy (base_vup, vup); | ||
854 | VectorCopy (base_vright, vright); | ||
855 | VectorCopy (base_modelorg, modelorg); | ||
856 | VectorCopy (oldorigin, modelorg); | ||
857 | R_TransformFrustum (); | ||
858 | } | ||
859 | |||
860 | break; | ||
861 | |||
862 | default: | ||
863 | break; | ||
864 | } | ||
865 | } | ||
866 | |||
867 | insubmodel = false; | ||
868 | } | ||
869 | |||
870 | |||
871 | /* | ||
872 | ================ | ||
873 | R_EdgeDrawing | ||
874 | ================ | ||
875 | */ | ||
876 | void R_EdgeDrawing (void) | ||
877 | { | ||
878 | edge_t ledges[NUMSTACKEDGES + | ||
879 | ((CACHE_SIZE - 1) / sizeof(edge_t)) + 1]; | ||
880 | surf_t lsurfs[NUMSTACKSURFACES + | ||
881 | ((CACHE_SIZE - 1) / sizeof(surf_t)) + 1]; | ||
882 | |||
883 | if (auxedges) | ||
884 | { | ||
885 | r_edges = auxedges; | ||
886 | } | ||
887 | else | ||
888 | { | ||
889 | r_edges = (edge_t *) | ||
890 | (((long)&ledges[0] + CACHE_SIZE - 1) & ~(CACHE_SIZE - 1)); | ||
891 | } | ||
892 | |||
893 | if (r_surfsonstack) | ||
894 | { | ||
895 | surfaces = (surf_t *) | ||
896 | (((long)&lsurfs[0] + CACHE_SIZE - 1) & ~(CACHE_SIZE - 1)); | ||
897 | surf_max = &surfaces[r_cnumsurfs]; | ||
898 | // surface 0 doesn't really exist; it's just a dummy because index 0 | ||
899 | // is used to indicate no edge attached to surface | ||
900 | surfaces--; | ||
901 | R_SurfacePatch (); | ||
902 | } | ||
903 | |||
904 | R_BeginEdgeFrame (); | ||
905 | |||
906 | if (r_dspeeds.value) | ||
907 | { | ||
908 | rw_time1 = Sys_FloatTime (); | ||
909 | } | ||
910 | |||
911 | R_RenderWorld (); | ||
912 | |||
913 | if (r_drawculledpolys) | ||
914 | R_ScanEdges (); | ||
915 | |||
916 | // only the world can be drawn back to front with no z reads or compares, just | ||
917 | // z writes, so have the driver turn z compares on now | ||
918 | D_TurnZOn (); | ||
919 | |||
920 | if (r_dspeeds.value) | ||
921 | { | ||
922 | rw_time2 = Sys_FloatTime (); | ||
923 | db_time1 = rw_time2; | ||
924 | } | ||
925 | |||
926 | R_DrawBEntitiesOnList (); | ||
927 | |||
928 | if (r_dspeeds.value) | ||
929 | { | ||
930 | db_time2 = Sys_FloatTime (); | ||
931 | se_time1 = db_time2; | ||
932 | } | ||
933 | |||
934 | if (!r_dspeeds.value) | ||
935 | { | ||
936 | VID_UnlockBuffer (); | ||
937 | S_ExtraUpdate (); // don't let sound get messed up if going slow | ||
938 | VID_LockBuffer (); | ||
939 | } | ||
940 | |||
941 | if (!(r_drawpolys | r_drawculledpolys)) | ||
942 | R_ScanEdges (); | ||
943 | } | ||
944 | |||
945 | |||
946 | /* | ||
947 | ================ | ||
948 | R_RenderView | ||
949 | |||
950 | r_refdef must be set before the first call | ||
951 | ================ | ||
952 | */ | ||
953 | void R_RenderView_ (void) | ||
954 | { | ||
955 | byte warpbuffer[WARP_WIDTH * WARP_HEIGHT]; | ||
956 | |||
957 | r_warpbuffer = warpbuffer; | ||
958 | |||
959 | if (r_timegraph.value || r_speeds.value || r_dspeeds.value) | ||
960 | r_time1 = Sys_FloatTime (); | ||
961 | |||
962 | R_SetupFrame (); | ||
963 | |||
964 | #ifdef PASSAGES | ||
965 | SetVisibilityByPassages (); | ||
966 | #else | ||
967 | R_MarkLeaves (); // done here so we know if we're in water | ||
968 | #endif | ||
969 | |||
970 | // make FDIV fast. This reduces timing precision after we've been running for a | ||
971 | // while, so we don't do it globally. This also sets chop mode, and we do it | ||
972 | // here so that setup stuff like the refresh area calculations match what's | ||
973 | // done in screen.c | ||
974 | Sys_LowFPPrecision (); | ||
975 | |||
976 | if (!cl_entities[0].model || !cl.worldmodel) | ||
977 | Sys_Error ("R_RenderView: NULL worldmodel"); | ||
978 | |||
979 | if (!r_dspeeds.value) | ||
980 | { | ||
981 | VID_UnlockBuffer (); | ||
982 | S_ExtraUpdate (); // don't let sound get messed up if going slow | ||
983 | VID_LockBuffer (); | ||
984 | } | ||
985 | |||
986 | R_EdgeDrawing (); | ||
987 | |||
988 | rb->yield(); // let sound run | ||
989 | |||
990 | if (!r_dspeeds.value) | ||
991 | { | ||
992 | VID_UnlockBuffer (); | ||
993 | S_ExtraUpdate (); // don't let sound get messed up if going slow | ||
994 | VID_LockBuffer (); | ||
995 | } | ||
996 | |||
997 | if (r_dspeeds.value) | ||
998 | { | ||
999 | se_time2 = Sys_FloatTime (); | ||
1000 | de_time1 = se_time2; | ||
1001 | } | ||
1002 | |||
1003 | R_DrawEntitiesOnList (); | ||
1004 | |||
1005 | if (r_dspeeds.value) | ||
1006 | { | ||
1007 | de_time2 = Sys_FloatTime (); | ||
1008 | dv_time1 = de_time2; | ||
1009 | } | ||
1010 | |||
1011 | R_DrawViewModel (); | ||
1012 | |||
1013 | if (r_dspeeds.value) | ||
1014 | { | ||
1015 | dv_time2 = Sys_FloatTime (); | ||
1016 | dp_time1 = Sys_FloatTime (); | ||
1017 | } | ||
1018 | |||
1019 | R_DrawParticles (); | ||
1020 | |||
1021 | rb->yield(); // let sound run | ||
1022 | |||
1023 | if (r_dspeeds.value) | ||
1024 | dp_time2 = Sys_FloatTime (); | ||
1025 | |||
1026 | if (r_dowarp) | ||
1027 | D_WarpScreen (); | ||
1028 | |||
1029 | V_SetContentsColor (r_viewleaf->contents); | ||
1030 | |||
1031 | if (r_timegraph.value) | ||
1032 | R_TimeGraph (); | ||
1033 | |||
1034 | if (r_aliasstats.value) | ||
1035 | R_PrintAliasStats (); | ||
1036 | |||
1037 | if (r_speeds.value) | ||
1038 | R_PrintTimes (); | ||
1039 | |||
1040 | if (r_dspeeds.value) | ||
1041 | R_PrintDSpeeds (); | ||
1042 | |||
1043 | if (r_reportsurfout.value && r_outofsurfaces) | ||
1044 | Con_Printf ("Short %d surfaces\n", r_outofsurfaces); | ||
1045 | |||
1046 | if (r_reportedgeout.value && r_outofedges) | ||
1047 | Con_Printf ("Short roughly %d edges\n", r_outofedges * 2 / 3); | ||
1048 | |||
1049 | // back to high floating-point precision | ||
1050 | Sys_HighFPPrecision (); | ||
1051 | } | ||
1052 | |||
1053 | void R_RenderView (void) | ||
1054 | { | ||
1055 | int dummy; | ||
1056 | int delta; | ||
1057 | |||
1058 | delta = (byte *)&dummy - r_stack_start; | ||
1059 | if (delta < -10000 || delta > 10000) | ||
1060 | Sys_Error ("R_RenderView: called without enough stack"); | ||
1061 | |||
1062 | if ( Hunk_LowMark() & 3 ) | ||
1063 | Sys_Error ("Hunk is missaligned"); | ||
1064 | |||
1065 | if ( (long)(&dummy) & 3 ) | ||
1066 | Sys_Error ("Stack is missaligned"); | ||
1067 | |||
1068 | if ( (long)(&r_warpbuffer) & 3 ) | ||
1069 | Sys_Error ("Globals are missaligned"); | ||
1070 | |||
1071 | R_RenderView_ (); | ||
1072 | } | ||
1073 | |||
1074 | /* | ||
1075 | ================ | ||
1076 | R_InitTurb | ||
1077 | ================ | ||
1078 | */ | ||
1079 | void R_InitTurb (void) | ||
1080 | { | ||
1081 | int i; | ||
1082 | |||
1083 | for (i=0 ; i<(SIN_BUFFER_SIZE) ; i++) | ||
1084 | { | ||
1085 | sintable[i] = AMP + sin(i*3.14159*2/CYCLE)*AMP; | ||
1086 | intsintable[i] = AMP2 + sin(i*3.14159*2/CYCLE)*AMP2; // AMP2, not 20 | ||
1087 | } | ||
1088 | } | ||
1089 | |||