![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to r_plane.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [DOOM] / doom|
Return to r_plane.c CVS log | Up to [DOOM] / doom |
1.1 root 1: // R_planes.c
2:
3: #include "DoomDef.h"
4: #include "R_local.h"
5:
6: planefunction_t floorfunc, ceilingfunc;
7:
8: //
9: // sky mapping
10: //
11: int skyflatnum;
12: int skytexture;
13: int skytexturemid;
14: fixed_t skyiscale;
15:
16: //
17: // opening
18: //
19:
20: visplane_t visplanes[MAXVISPLANES], *lastvisplane;
21: visplane_t *floorplane, *ceilingplane;
22:
23: short openings[MAXOPENINGS], *lastopening;
24:
25: //
26: // clip values are the solid pixel bounding the range
27: // floorclip starts out SCREENHEIGHT
28: // ceilingclip starts out -1
29: //
30: short floorclip[SCREENWIDTH];
31: short ceilingclip[SCREENWIDTH];
32:
33: //
34: // spanstart holds the start of a plane span
35: // initialized to 0 at start
36: //
37: int spanstart[SCREENHEIGHT];
38: int spanstop[SCREENHEIGHT];
39:
40: //
41: // texture mapping
42: //
43: lighttable_t **planezlight;
44: fixed_t planeheight;
45:
46: fixed_t yslope[SCREENHEIGHT];
47: fixed_t distscale[SCREENWIDTH];
48: fixed_t basexscale, baseyscale;
49:
50: fixed_t cachedheight[SCREENHEIGHT];
51: fixed_t cacheddistance[SCREENHEIGHT];
52: fixed_t cachedxstep[SCREENHEIGHT];
53: fixed_t cachedystep[SCREENHEIGHT];
54:
55:
56: /*
57: ================
58: =
59: = R_InitSkyMap
60: =
61: = Called whenever the view size changes
62: =
63: ================
64: */
65:
66: void R_InitSkyMap (void)
67: {
68: skyflatnum = R_FlatNumForName ("F_SKY1");
69: skytexturemid = 200*FRACUNIT;
70: skyiscale = FRACUNIT;
71: }
72:
73:
74: /*
75: ====================
76: =
77: = R_InitPlanes
78: =
79: = Only at game startup
80: ====================
81: */
82:
83: void R_InitPlanes (void)
84: {
85: }
86:
87:
88: /*
89: ================
90: =
91: = R_MapPlane
92: =
93: global vars:
94:
95: planeheight
96: ds_source
97: basexscale
98: baseyscale
99: viewx
100: viewy
101:
102: BASIC PRIMITIVE
103: ================
104: */
105:
106: void R_MapPlane (int y, int x1, int x2)
107: {
108: angle_t angle;
109: fixed_t distance, length;
110: unsigned index;
111:
112: #ifdef RANGECHECK
113: if (x2 < x1 || x1<0 || x2>=viewwidth || (unsigned)y>viewheight)
114: I_Error ("R_MapPlane: %i, %i at %i",x1,x2,y);
115: #endif
116:
117: if (planeheight != cachedheight[y])
118: {
119: cachedheight[y] = planeheight;
120: distance = cacheddistance[y] = FixedMul (planeheight, yslope[y]);
121:
122: ds_xstep = cachedxstep[y] = FixedMul (distance,basexscale);
123: ds_ystep = cachedystep[y] = FixedMul (distance,baseyscale);
124: }
125: else
126: {
127: distance = cacheddistance[y];
128: ds_xstep = cachedxstep[y];
129: ds_ystep = cachedystep[y];
130: }
131:
132: length = FixedMul (distance,distscale[x1]);
133: angle = (viewangle + xtoviewangle[x1])>>ANGLETOFINESHIFT;
134: ds_xfrac = viewx + FixedMul(finecosine[angle], length);
135: ds_yfrac = -viewy - FixedMul(finesine[angle], length);
136:
137: if (fixedcolormap)
138: ds_colormap = fixedcolormap;
139: else
140: {
141: index = distance >> LIGHTZSHIFT;
142: if (index >= MAXLIGHTZ )
143: index = MAXLIGHTZ-1;
144: ds_colormap = planezlight[index];
145: }
146:
147: ds_y = y;
148: ds_x1 = x1;
149: ds_x2 = x2;
150:
151: spanfunc (); // high or low detail
152: }
153:
154: //=============================================================================
155:
156: /*
157: ====================
158: =
159: = R_ClearPlanes
160: =
161: = At begining of frame
162: ====================
163: */
164:
165: void R_ClearPlanes (void)
166: {
167: int i;
168: angle_t angle;
169:
170: //
171: // opening / clipping determination
172: //
173: for (i=0 ; i<viewwidth ; i++)
174: {
175: floorclip[i] = viewheight;
176: ceilingclip[i] = -1;
177: }
178:
179: lastvisplane = visplanes;
180: lastopening = openings;
181:
182: //
183: // texture calculation
184: //
185: memset (cachedheight, 0, sizeof(cachedheight));
186: angle = (viewangle-ANG90)>>ANGLETOFINESHIFT; // left to right mapping
187:
188: // scale will be unit scale at SCREENWIDTH/2 distance
189: basexscale = FixedDiv (finecosine[angle],centerxfrac);
190: baseyscale = -FixedDiv (finesine[angle],centerxfrac);
191: }
192:
193:
194:
195: /*
196: ===============
197: =
198: = R_FindPlane
199: =
200: ===============
201: */
202:
203: visplane_t *R_FindPlane(fixed_t height, int picnum,
204: int lightlevel, int special)
205: {
206: visplane_t *check;
207:
208: if(picnum == skyflatnum)
209: {
210: // all skies map together
211: height = 0;
212: lightlevel = 0;
213: }
214:
215: for(check = visplanes; check < lastvisplane; check++)
216: {
217: if(height == check->height
218: && picnum == check->picnum
219: && lightlevel == check->lightlevel
220: && special == check->special)
221: break;
222: }
223:
224: if(check < lastvisplane)
225: {
226: return(check);
227: }
228:
229: if(lastvisplane-visplanes == MAXVISPLANES)
230: {
231: I_Error("R_FindPlane: no more visplanes");
232: }
233:
234: lastvisplane++;
235: check->height = height;
236: check->picnum = picnum;
237: check->lightlevel = lightlevel;
238: check->special = special;
239: check->minx = SCREENWIDTH;
240: check->maxx = -1;
241: memset(check->top,0xff,sizeof(check->top));
242: return(check);
243: }
244:
245: /*
246: ===============
247: =
248: = R_CheckPlane
249: =
250: ===============
251: */
252:
253: visplane_t *R_CheckPlane (visplane_t *pl, int start, int stop)
254: {
255: int intrl, intrh;
256: int unionl, unionh;
257: int x;
258:
259: if (start < pl->minx)
260: {
261: intrl = pl->minx;
262: unionl = start;
263: }
264: else
265: {
266: unionl = pl->minx;
267: intrl = start;
268: }
269:
270: if (stop > pl->maxx)
271: {
272: intrh = pl->maxx;
273: unionh = stop;
274: }
275: else
276: {
277: unionh = pl->maxx;
278: intrh = stop;
279: }
280:
281: for (x=intrl ; x<= intrh ; x++)
282: if (pl->top[x] != 0xff)
283: break;
284:
285: if (x > intrh)
286: {
287: pl->minx = unionl;
288: pl->maxx = unionh;
289: return pl; // use the same one
290: }
291:
292: // make a new visplane
293:
294: lastvisplane->height = pl->height;
295: lastvisplane->picnum = pl->picnum;
296: lastvisplane->lightlevel = pl->lightlevel;
297: lastvisplane->special = pl->special;
298: pl = lastvisplane++;
299: pl->minx = start;
300: pl->maxx = stop;
301: memset (pl->top,0xff,sizeof(pl->top));
302:
303: return pl;
304: }
305:
306:
307:
308: //=============================================================================
309:
310: /*
311: ================
312: =
313: = R_MakeSpans
314: =
315: ================
316: */
317:
318: void R_MakeSpans (int x, int t1, int b1, int t2, int b2)
319: {
320: while (t1 < t2 && t1<=b1)
321: {
322: R_MapPlane (t1,spanstart[t1],x-1);
323: t1++;
324: }
325: while (b1 > b2 && b1>=t1)
326: {
327: R_MapPlane (b1,spanstart[b1],x-1);
328: b1--;
329: }
330:
331: while (t2 < t1 && t2<=b2)
332: {
333: spanstart[t2] = x;
334: t2++;
335: }
336: while (b2 > b1 && b2>=t2)
337: {
338: spanstart[b2] = x;
339: b2--;
340: }
341: }
342:
343:
344:
345: /*
346: ================
347: =
348: = R_DrawPlanes
349: =
350: = At the end of each frame
351: ================
352: */
353:
354: void R_DrawPlanes (void)
355: {
356: visplane_t *pl;
357: int light;
358: int x, stop;
359: int angle;
360: byte *tempSource;
361:
362: byte *dest;
363: int count;
364: fixed_t frac, fracstep;
365:
366: extern byte *ylookup[MAXHEIGHT];
367: extern int columnofs[MAXWIDTH];
368:
369: #ifdef RANGECHECK
370: if (ds_p - drawsegs > MAXDRAWSEGS)
371: I_Error ("R_DrawPlanes: drawsegs overflow (%i)", ds_p - drawsegs);
372: if (lastvisplane - visplanes > MAXVISPLANES)
373: I_Error ("R_DrawPlanes: visplane overflow (%i)", lastvisplane - visplanes);
374: if (lastopening - openings > MAXOPENINGS)
375: I_Error ("R_DrawPlanes: opening overflow (%i)", lastopening - openings);
376: #endif
377:
378: for (pl = visplanes ; pl < lastvisplane ; pl++)
379: {
380: if (pl->minx > pl->maxx)
381: continue;
382: //
383: // sky flat
384: //
385: if (pl->picnum == skyflatnum)
386: {
387: dc_iscale = skyiscale;
388: dc_colormap = colormaps;// sky is allways drawn full bright
389: dc_texturemid = skytexturemid;
390: for (x=pl->minx ; x <= pl->maxx ; x++)
391: {
392: dc_yl = pl->top[x];
393: dc_yh = pl->bottom[x];
394: if (dc_yl <= dc_yh)
395: {
396: angle = (viewangle + xtoviewangle[x])>>ANGLETOSKYSHIFT;
397: dc_x = x;
398: dc_source = R_GetColumn(skytexture, angle);
399:
400: count = dc_yh - dc_yl;
401: if (count < 0)
402: return;
403:
404: #ifdef RANGECHECK
405: if ((unsigned)dc_x >= SCREENWIDTH || dc_yl < 0 || dc_yh >= SCREENHEIGHT)
406: I_Error ("R_DrawColumn: %i to %i at %i", dc_yl, dc_yh, dc_x);
407: #endif
408:
409: dest = ylookup[dc_yl] + columnofs[dc_x];
410:
411: fracstep = 1;
412: frac = (dc_texturemid>>FRACBITS) + (dc_yl-centery);
413: do
414: {
415: *dest = dc_source[frac];
416: dest += SCREENWIDTH;
417: frac += fracstep;
418: } while (count--);
419:
420: // colfunc ();
421: }
422: }
423: continue;
424: }
425:
426: //
427: // regular flat
428: //
429: tempSource = W_CacheLumpNum(firstflat +
430: flattranslation[pl->picnum], PU_STATIC);
431:
432: switch(pl->special)
433: {
434: case 25: case 26: case 27: case 28: case 29: // Scroll_North
435: ds_source = tempSource;
436: break;
437: case 20: case 21: case 22: case 23: case 24: // Scroll_East
438: ds_source = tempSource+((63-((leveltime>>1)&63))<<
439: (pl->special-20)&63);
440: //ds_source = tempSource+((leveltime>>1)&63);
441: break;
442: case 30: case 31: case 32: case 33: case 34: // Scroll_South
443: ds_source = tempSource;
444: break;
445: case 35: case 36: case 37: case 38: case 39: // Scroll_West
446: ds_source = tempSource;
447: break;
448: case 4: // Scroll_EastLavaDamage
449: ds_source = tempSource+(((63-((leveltime>>1)&63))<<3)&63);
450: break;
451: default:
452: ds_source = tempSource;
453: }
454: planeheight = abs(pl->height-viewz);
455: light = (pl->lightlevel >> LIGHTSEGSHIFT)+extralight;
456: if (light >= LIGHTLEVELS)
457: light = LIGHTLEVELS-1;
458: if (light < 0)
459: light = 0;
460: planezlight = zlight[light];
461:
462: pl->top[pl->maxx+1] = 0xff;
463: pl->top[pl->minx-1] = 0xff;
464:
465: stop = pl->maxx + 1;
466: for (x=pl->minx ; x<= stop ; x++)
467: R_MakeSpans (x,pl->top[x-1],pl->bottom[x-1]
468: ,pl->top[x],pl->bottom[x]);
469:
470: Z_ChangeTag (tempSource, PU_CACHE);
471: }
472: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.