r_defs.h

// Emacs style mode select   -*- C++ -*- 
//-----------------------------------------------------------------------------
//
// Copyright(C) 1993-1996 Id Software, Inc.
// Copyright(C) 2005 Simon Howard
//
// 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.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
// 02111-1307, USA.
//
// DESCRIPTION:
//      Refresh/rendering module, shared data struct definitions.
//
//-----------------------------------------------------------------------------

#ifndef __R_DEFS__
#define __R_DEFS__

// Screenwidth.
#include "doomdef.h"

// Some more or less basic data types
// we depend on.
#include "m_fixed.h"

// We rely on the thinker data struct
// to handle sound origins in sectors.
#include "d_think.h"
// SECTORS do store MObjs anyway.
#include "p_mobj.h"

// Silhouette, needed for clipping Segs (mainly)
// and sprites representing things.
#define SIL_NONE		0
#define SIL_BOTTOM		1
#define SIL_TOP			2
#define SIL_BOTH		3

#define MAXDRAWSEGS		256

//
// INTERNAL MAP TYPES
//  used by play and refresh
//

//
// Your plain vanilla vertex.
// Note: transformed values not buffered locally,
//  like some DOOM-alikes ("wt", "WebView") did.
//
typedef struct {
	fixed_t x;
	fixed_t y;

} vertex_t;

// Forward of LineDefs, for Sectors.
struct line_s;

// Each sector has a degenmobj_t in its center
//  for sound origin purposes.
// I suppose this does not handle sound from
//  moving objects (doppler), because
//  position is prolly just buffered, not
//  updated.
typedef struct {
	thinker_t thinker;	// not used for anything
	fixed_t x;
	fixed_t y;
	fixed_t z;

} degenmobj_t;

//
// The SECTORS record, at runtime.
// Stores things/mobjs.
//
typedef struct {
	fixed_t floorheight;
	fixed_t ceilingheight;
	short floorpic;
	short ceilingpic;
	short lightlevel;
	short special;
	short tag;

	// 0 = untraversed, 1,2 = sndlines -1
	int soundtraversed;

	// thing that made a sound (or null)
	mobj_t *soundtarget;

	// mapblock bounding box for height changes
	int blockbox[4];

	// origin for any sounds played by the sector
	degenmobj_t soundorg;

	// if == validcount, already checked
	int validcount;

	// list of mobjs in sector
	mobj_t *thinglist;

	// thinker_t for reversable actions
	void *specialdata;

	int linecount;
	struct line_s **lines;	// [linecount] size

} sector_t;

//
// The SideDef.
//

typedef struct {
	// add this to the calculated texture column
	fixed_t textureoffset;

	// add this to the calculated texture top
	fixed_t rowoffset;

	// Texture indices.
	// We do not maintain names here. 
	short toptexture;
	short bottomtexture;
	short midtexture;

	// Sector the SideDef is facing.
	sector_t *sector;

} side_t;

//
// Move clipping aid for LineDefs.
//
typedef enum {
	ST_HORIZONTAL,
	ST_VERTICAL,
	ST_POSITIVE,
	ST_NEGATIVE
} slopetype_t;

typedef struct line_s {
	// Vertices, from v1 to v2.
	vertex_t *v1;
	vertex_t *v2;

	// Precalculated v2 - v1 for side checking.
	fixed_t dx;
	fixed_t dy;

	// Animation related.
	short flags;
	short special;
	short tag;

	// Visual appearance: SideDefs.
	//  sidenum[1] will be -1 if one sided
	short sidenum[2];

	// Neat. Another bounding box, for the extent
	//  of the LineDef.
	fixed_t bbox[4];

	// To aid move clipping.
	slopetype_t slopetype;

	// Front and back sector.
	// Note: redundant? Can be retrieved from SideDefs.
	sector_t *frontsector;
	sector_t *backsector;

	// if == validcount, already checked
	int validcount;

	// thinker_t for reversable actions
	void *specialdata;
} line_t;

//
// A SubSector.
// References a Sector.
// Basically, this is a list of LineSegs,
//  indicating the visible walls that define
//  (all or some) sides of a convex BSP leaf.
//
typedef struct subsector_s {
	sector_t *sector;
	short numlines;
	short firstline;

} subsector_t;

//
// The LineSeg.
//
typedef struct {
	vertex_t *v1;
	vertex_t *v2;

	fixed_t offset;

	angle_t angle;

	side_t *sidedef;
	line_t *linedef;

	// Sector references.
	// Could be retrieved from linedef, too.
	// backsector is NULL for one sided lines
	sector_t *frontsector;
	sector_t *backsector;

} seg_t;

//
// BSP node.
//
typedef struct {
	// Partition line.
	fixed_t x;
	fixed_t y;
	fixed_t dx;
	fixed_t dy;

	// Bounding box for each child.
	fixed_t bbox[2][4];

	// If NF_SUBSECTOR its a subsector.
	unsigned short children[2];

} node_t;

// posts are runs of non masked source pixels
typedef struct {
	byte topdelta;		// -1 is the last post in a column
	byte length;		// length data bytes follows
} PACKEDATTR post_t;

// column_t is a list of 0 or more post_t, (byte)-1 terminated
typedef post_t column_t;

// PC direct to screen pointers
//B UNUSED - keep till detailshift in r_draw.c resolved
//extern byte*  destview;
//extern byte*  destscreen;

//
// OTHER TYPES
//

// This could be wider for >8 bit display.
// Indeed, true color support is posibble
//  precalculating 24bpp lightmap/colormap LUT.
//  from darkening PLAYPAL to all black.
// Could even us emore than 32 levels.
typedef byte lighttable_t;

//
// ?
//
typedef struct drawseg_s {
	seg_t *curline;
	int x1;
	int x2;

	fixed_t scale1;
	fixed_t scale2;
	fixed_t scalestep;

	// 0=none, 1=bottom, 2=top, 3=both
	int silhouette;

	// do not clip sprites above this
	fixed_t bsilheight;

	// do not clip sprites below this
	fixed_t tsilheight;

	// Pointers to lists for sprite clipping,
	//  all three adjusted so [x1] is first value.
	short *sprtopclip;
	short *sprbottomclip;
	short *maskedtexturecol;

} drawseg_t;

// Patches.
// A patch holds one or more columns.
// Patches are used for sprites and all masked pictures,
// and we compose textures from the TEXTURE1/2 lists
// of patches.
typedef struct {
	short width;		// bounding box size 
	short height;
	short leftoffset;	// pixels to the left of origin 
	short topoffset;	// pixels below the origin 
	int columnofs[8];	// only [width] used
	// the [0] is &columnofs[width] 
} PACKEDATTR patch_t;

// A vissprite_t is a thing
//  that will be drawn during a refresh.
// I.e. a sprite object that is partly visible.
typedef struct vissprite_s {
	// Doubly linked list.
	struct vissprite_s *prev;
	struct vissprite_s *next;

	int x1;
	int x2;

	// for line side calculation
	fixed_t gx;
	fixed_t gy;

	// global bottom / top for silhouette clipping
	fixed_t gz;
	fixed_t gzt;

	// horizontal position of x1
	fixed_t startfrac;

	fixed_t scale;

	// negative if flipped
	fixed_t xiscale;

	fixed_t texturemid;
	int patch;

	// for color translation and shadow draw,
	//  maxbright frames as well
	lighttable_t *colormap;

	int mobjflags;

} vissprite_t;

//      
// Sprites are patches with a special naming convention
//  so they can be recognized by R_InitSprites.
// The base name is NNNNFx or NNNNFxFx, with
//  x indicating the rotation, x = 0, 1-7.
// The sprite and frame specified by a thing_t
//  is range checked at run time.
// A sprite is a patch_t that is assumed to represent
//  a three dimensional object and may have multiple
//  rotations pre drawn.
// Horizontal flipping is used to save space,
//  thus NNNNF2F5 defines a mirrored patch.
// Some sprites will only have one picture used
// for all views: NNNNF0
//
typedef struct {
	// If false use 0 for any position.
	// Note: as eight entries are available,
	//  we might as well insert the same name eight times.
	boolean rotate;

	// Lump to use for view angles 0-7.
	short lump[8];

	// Flip bit (1 = flip) to use for view angles 0-7.
	byte flip[8];

} spriteframe_t;

//
// A sprite definition:
//  a number of animation frames.
//
typedef struct {
	int numframes;
	spriteframe_t *spriteframes;

} spritedef_t;

//
// Now what is a visplane, anyway?
// 
typedef struct {
	fixed_t height;
	int picnum;
	int lightlevel;
	int minx;
	int maxx;

	// leave pads for [minx-1]/[maxx+1]

	byte pad1;
	// Here lies the rub for all
	//  dynamic resize/change of resolution.
	byte top[SCREENWIDTH];
	byte pad2;
	byte pad3;
	// See above.
	byte bottom[SCREENWIDTH];
	byte pad4;

} visplane_t;

#endif