Iskhodnyy_kod_Doom

start->last = next->last; goto crunch;

}

}

// There is a fragment after *next. R_StoreWallRange (next->last + 1, last);

//Adjust the clip size. start->last = last;

//Remove start+1 to next from the clip list,

//because start now covers their area. crunch:

if (next == start)

{

// Post just extended past the bottom of one post. return;

}

while (next++ != newend)

{

// Remove a post. *++start = *next;

}

newend = start+1;

}

//

//R_ClipPassWallSegment

//Clips the given range of columns,

//but does not includes it in the clip list.

//Does handle windows,

//e.g. LineDefs with upper and lower texture.

void R_ClipPassWallSegment

( int first,

int last )

{

cliprange_t* start;

//Find the first range that touches the range

//(adjacent pixels are touching).

start = solidsegs;

while (start->last < first-1) start++;

if (first < start->first)

{

if (last < start->first-1)

{

// Post is entirely visible (above start). R_StoreWallRange (first, last);

return;

}

// There is a fragment above *start. R_StoreWallRange (first, start->first - 1);

}

// Bottom contained in start?

601

if (last <= start->last) return;

while (last >= (start+1)->first-1)

{

// There is a fragment between two posts. R_StoreWallRange (start->last + 1, (start+1)->first - 1); start++;

if (last <= start->last) return;

}

// There is a fragment after *next. R_StoreWallRange (start->last + 1, last);

}

//

// R_ClearClipSegs

//

void R_ClearClipSegs (void)

{

solidsegs[0].first = -0x7fffffff; solidsegs[0].last = -1; solidsegs[1].first = viewwidth; solidsegs[1].last = 0x7fffffff; newend = solidsegs+2;

}

//

//R_AddLine

//Clips the given segment

//and adds any visible pieces to the line list.

//OPTIMIZE: quickly reject orthogonal back sides. angle1 = R_PointToAngle (line->v1->x, line->v1->y); angle2 = R_PointToAngle (line->v2->x, line->v2->y);

//Clip to view edges.

//OPTIMIZE: make constant out of 2*clipangle (FIELDOFVIEW). span = angle1 - angle2;

//Back side? I.e. backface culling?

if (span >= ANG180) return;

// Global angle needed by segcalc. rw_angle1 = angle1;

angle1 -= viewangle; angle2 -= viewangle;

tspan = angle1 + clipangle;

602

if (tspan > 2*clipangle)

{

tspan -= 2*clipangle;

// Totally off the left edge? if (tspan >= span)

return;

angle1 = clipangle;

}

tspan = clipangle - angle2; if (tspan > 2*clipangle)

{

tspan -= 2*clipangle;

// Totally off the left edge? if (tspan >= span)

return;

angle2 = -clipangle;

}

//The seg is in the view range,

//but not necessarily visible.

angle1 = (angle1+ANG90)>>ANGLETOFINESHIFT; angle2 = (angle2+ANG90)>>ANGLETOFINESHIFT; x1 = viewangletox[angle1];

x2 = viewangletox[angle2];

// Does not cross a pixel? if (x1 == x2)

return;

backsector = line->backsector;

//Single sided line? if (!backsector)

goto clipsolid;

//Closed door.

if (backsector->ceilingheight <= frontsector->floorheight

|| backsector->floorheight >= frontsector->ceilingheight) goto clipsolid;

// Window.

if (backsector->ceilingheight != frontsector->ceilingheight || backsector->floorheight != frontsector->floorheight) goto clippass;

//Reject empty lines used for triggers

//and special events.

//Identical floor and ceiling on both sides,

//identical light levels on both sides,

//and no middle texture.

if (backsector->ceilingpic == frontsector->ceilingpic

&&backsector->floorpic == frontsector->floorpic

&&backsector->lightlevel == frontsector->lightlevel

&&curline->sidedef->midtexture == 0)

{

return;

}

clippass:

R_ClipPassWallSegment (x1, x2-1); return;

603

clipsolid:

R_ClipSolidWallSegment (x1, x2-1);

}

//

//R_CheckBBox

//Checks BSP node/subtree bounding box.

//Returns true

//if some part of the bbox might be visible.

//Find the corners of the box

//that define the edges from current viewpoint. if (viewx <= bspcoord[BOXLEFT])

boxx = 0;

else if (viewx < bspcoord[BOXRIGHT]) boxx = 1;

else

boxx = 2;

if (viewy >= bspcoord[BOXTOP]) boxy = 0;

else if (viewy > bspcoord[BOXBOTTOM]) boxy = 1;

else

boxy = 2;

604

boxpos = (boxy<<2)+boxx; if (boxpos == 5)

return true;

x1 = bspcoord[checkcoord[boxpos][0]];

y1 = bspcoord[checkcoord[boxpos][1]];

x2 = bspcoord[checkcoord[boxpos][2]];

y2 = bspcoord[checkcoord[boxpos][3]];

span = angle1 - angle2;

// Sitting on a line? if (span >= ANG180) return true;

tspan = angle1 + clipangle;

if (tspan > 2*clipangle)

{

tspan -= 2*clipangle;

// Totally off the left edge? if (tspan >= span)

return false;

angle1 = clipangle;

}

tspan = clipangle - angle2; if (tspan > 2*clipangle)

{

tspan -= 2*clipangle;

// Totally off the left edge? if (tspan >= span)

return false;

angle2 = -clipangle;

}

//Find the first clippost

//that touches the source post

//(adjacent pixels are touching).

angle1 = (angle1+ANG90)>>ANGLETOFINESHIFT; angle2 = (angle2+ANG90)>>ANGLETOFINESHIFT; sx1 = viewangletox[angle1];

sx2 = viewangletox[angle2];

// Does not cross a pixel. if (sx1 == sx2)

return false; sx2--;

start = solidsegs;

while (start->last < sx2) start++;

if (sx1 >= start->first

&& sx2 <= start->last)

{

// The clippost contains the new span.

605

return false;

}

return true;

}

//

//R_Subsector

//Determine floor/ceiling planes.

//Add sprites of things in sector.

//Draw one or more line segments.

void R_Subsector (int num)

{

#ifdef RANGECHECK

if (num>=numsubsectors)

I_Error ("R_Subsector: ss %i with numss = %i",

num,

numsubsectors);

#endif

sscount++;

sub = &subsectors[num]; frontsector = sub->sector; count = sub->numlines;

line = &segs[sub->firstline];

if (frontsector->floorheight < viewz)

{

floorplane = R_FindPlane (frontsector->floorheight, frontsector->floorpic, frontsector->lightlevel);

}

else

floorplane = NULL;

if (frontsector->ceilingheight > viewz

|| frontsector->ceilingpic == skyflatnum)

{

ceilingplane = R_FindPlane (frontsector->ceilingheight, frontsector->ceilingpic, frontsector->lightlevel);

}

else

ceilingplane = NULL;

R_AddSprites (frontsector);

while (count--)

{

R_AddLine (line);

line++;

}

}

//

606

//RenderBSPNode

//Renders all subsectors below a given node,

//traversing subtree recursively.

//Just call with BSP root.

void R_RenderBSPNode (int bspnum)

{

if (bspnum == -1) R_Subsector (0);

else

R_Subsector (bspnum&(~NF_SUBSECTOR)); return;

}

bsp = &nodes[bspnum];

//Decide which side the view point is on. side = R_PointOnSide (viewx, viewy, bsp);

//Recursively divide front space.

R_RenderBSPNode (bsp->children[side]);

// Possibly divide back space.

if (R_CheckBBox (bsp->bbox[side^1])) R_RenderBSPNode (bsp->children[side^1]);

}

10.2r bsp.h

// Emacs style mode select -*- C++ -*- //-----------------------------------------------------------------------------

//

//$Id:$

//Copyright (C) 1993-1996 by id Software, Inc.

//This program is free software; you can redistribute it and/or

//modify it under the terms of the GNU General Public License

//as published by the Free Software Foundation; either version 2

//of the License, or (at your option) any later version.

//

//This program is distributed in the hope that it will be useful,

//but WITHOUT ANY WARRANTY; without even the implied warranty of

//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

//GNU General Public License for more details.

//

//DESCRIPTION:

//Refresh module, BSP traversal and handling.

//-----------------------------------------------------------------------------

#ifndef __R_BSP__ #define __R_BSP__

#ifdef __GNUG__ #pragma interface #endif

607

typedef void (*drawfunc_t) (int start, int stop);

// BSP?

void R_ClearClipSegs (void); void R_ClearDrawSegs (void);

void R_RenderBSPNode (int bspnum);

#endif //-----------------------------------------------------------------------------

//

// $Log:$

//

//-----------------------------------------------------------------------------

10.3 r data.c

// Emacs style mode select -*- C++ -*- //-----------------------------------------------------------------------------

//

//$Id:$

//Copyright (C) 1993-1996 by id Software, Inc.

//This program is free software; you can redistribute it and/or

//modify it under the terms of the GNU General Public License

//as published by the Free Software Foundation; either version 2

//of the License, or (at your option) any later version.

//

//This program is distributed in the hope that it will be useful,

//but WITHOUT ANY WARRANTY; without even the implied warranty of

//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

//GNU General Public License for more details.

//

// $Log:$

608

//

//Revision 1.3 1997/01/29 20:10

//DESCRIPTION:

//Preparation of data for rendering,

//generation of lookups, caching, retrieval by name.

//-----------------------------------------------------------------------------

static const char

rcsid[] = "$Id: r_data.c,v 1.4 1997/02/03 16:47:55 b1 Exp $";

#include "i_system.h" #include "z_zone.h"

#include "m_swap.h"

#include "w_wad.h"

#include "doomdef.h" #include "r_local.h" #include "p_local.h"

#include "doomstat.h" #include "r_sky.h"

#ifdef LINUX #include <alloca.h> #endif

#include "r_data.h"

//

//Graphics.

//DOOM graphics for walls and sprites

//is stored in vertical runs of opaque pixels (posts).

//A column is composed of zero or more posts,

//a patch or sprite is composed of zero or more columns.

//

//Texture definition.

//Each texture is composed of one or more patches,

//with patches being lumps stored in the WAD.

//The lumps are referenced by number, and patched

//into the rectangular texture space using origin

//and possibly other attributes.

//

//Texture definition.

//A DOOM wall texture is a list of patches

//which are to be combined in a predefined order.

609

//A single patch from a texture definition,

//basically a rectangular area within

//the texture rectangle.

typedef struct

{

//Block origin (allways UL),

//which has allready accounted

//for the internal origin of the patch.

//A maptexturedef_t describes a rectangular texture,

//which is composed of one or more mappatch_t structures

//that arrange graphic patches.

typedef struct

{

// Keep name for switch changing, etc.

//All the patches[patchcount]

//are drawn back to front into the cached texture. short patchcount;

texpatch_t patches[1];

} texture_t;

610