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

1. include < stdlib.h>

1. include " i_system.h"
2. include " z_zone.h"
3. include " w_wad.h"

1. include " doomdef.h"
2. include " doomstat.h"

1. include " r_local.h"
2. include " r_sky.h"

planefunction_t floorfunc;
planefunction_t ceilingfunc;

//
// opening
//

// Here comes the obnoxious " visplane".

1. define MAXVISPLANES 128

visplane_t visplanes[MAXVISPLANES];
visplane_t* lastvisplane;
visplane_t* floorplane;
visplane_t* ceilingplane;

// ?

1. define MAXOPENINGS SCREENWIDTH*64

short openings[MAXOPENINGS];
short* lastopening;

//
// Clip values are the solid pixel bounding the range.
// floorclip starts out SCREENHEIGHT
// ceilingclip starts out -1
//
short floorclip[SCREENWIDTH];
short ceilingclip[SCREENWIDTH];

//
// spanstart holds the start of a plane span
// initialized to 0 at start
//
int spanstart[SCREENHEIGHT];
int spanstop[SCREENHEIGHT];

//
// texture mapping
//
lighttable_t** planezlight;
fixed_t planeheight;

fixed_t yslope[SCREENHEIGHT];
fixed_t distscale[SCREENWIDTH];
fixed_t basexscale;
fixed_t baseyscale;

fixed_t cachedheight[SCREENHEIGHT];
fixed_t cacheddistance[SCREENHEIGHT];
fixed_t cachedxstep[SCREENHEIGHT];
fixed_t cachedystep[SCREENHEIGHT];

//
// R_InitPlanes
// Only at game startup.
//
void R_InitPlanes ( void)
{
// Doh!
}

//
// R_MapPlane
//
// Uses global vars:
// planeheight
// ds_source
// basexscale
// baseyscale
// viewx
// viewy
//
// BASIC PRIMITIVE
//
void
R_MapPlane
( int y,
int x1,
int x2 )
{
angle_t angle;
fixed_t distance;
fixed_t length;
unsigned index;

1. ifdef RANGECHECK

if ( x2 < x1
|| x1<0
|| x2>=viewwidth
|| ( unsigned)y>viewheight)
{
I_Error ( "R_MapPlane: %i, %i at %i",x1,x2,y);
}

1. endif

if ( planeheight ! = cachedheight[y])
{
cachedheight[y] = planeheight;
distance = cacheddistance[y] = FixedMul ( planeheight, yslope[y]);
ds_xstep = cachedxstep[y] = FixedMul ( distance,basexscale);
ds_ystep = cachedystep[y] = FixedMul ( distance,baseyscale);
}
else
{
distance = cacheddistance[y];
ds_xstep = cachedxstep[y];
ds_ystep = cachedystep[y];
}

length = FixedMul ( distance,distscale[x1]);
angle = ( viewangle + xtoviewangle[x1])>>ANGLETOFINESHIFT;
ds_xfrac = viewx + FixedMul(finecosine[angle], length);
ds_yfrac = -viewy - FixedMul(finesine[angle], length);

if ( fixedcolormap)
ds_colormap = fixedcolormap;
else
{
index = distance > > LIGHTZSHIFT;

if ( index > = MAXLIGHTZ )
index = MAXLIGHTZ-1;

ds_colormap = planezlight[index];
}

ds_y = y;
ds_x1 = x1;
ds_x2 = x2;

// high or low detail
spanfunc ( );
}

//
// R_ClearPlanes
// At begining of frame.
//
void R_ClearPlanes ( void)
{
int i;
angle_t angle;

// opening / clipping determination
for ( i=0 ; i<viewwidth ; i++)
{
floorclip[i] = viewheight;
ceilingclip[i] = -1;
}

lastvisplane = visplanes;
lastopening = openings;

// texture calculation
memset ( cachedheight, 0, sizeof(cachedheight));

// left to right mapping
angle = ( viewangle-ANG90)>>ANGLETOFINESHIFT;

// scale will be unit scale at SCREENWIDTH/2 distance
basexscale = FixedDiv ( finecosine[angle],centerxfrac);
baseyscale = -FixedDiv ( finesine[angle],centerxfrac);
}

//
// R_FindPlane
//
visplane_t*
R_FindPlane
( fixed_t height,
int picnum,
int lightlevel )
{
visplane_t* check;

if ( picnum == skyflatnum)
{
height = 0; // all skys map together
lightlevel = 0;
}

for ( check=visplanes; check<lastvisplane; check++)
{
if ( height == check->height
&& picnum == check->picnum
&& lightlevel == check->lightlevel)
{
break;
}
}

if ( check < lastvisplane)
return check;

if ( lastvisplane - visplanes == MAXVISPLANES)
I_Error ( "R_FindPlane: no more visplanes");

lastvisplane++;

check->height = height;
check->picnum = picnum;
check->lightlevel = lightlevel;
check->minx = SCREENWIDTH;
check->maxx = -1;

memset ( check->top,0xff,sizeof(check->top));

return check;
}

//
// R_CheckPlane
//
visplane_t*
R_CheckPlane
( visplane_t* pl,
int start,
int stop )
{
int intrl;
int intrh;
int unionl;
int unionh;
int x;

if ( start < pl->minx)
{
intrl = pl->minx;
unionl = start;
}
else
{
unionl = pl->minx;
intrl = start;
}

if ( stop > pl->maxx)
{
intrh = pl->maxx;
unionh = stop;
}
else
{
unionh = pl->maxx;
intrh = stop;
}

for ( x=intrl ; x<= intrh ; x++)
if ( pl->top[x] ! = 0xff)
break;

if ( x > intrh)
{
pl->minx = unionl;
pl->maxx = unionh;

// use the same one
return pl;
}

// make a new visplane
lastvisplane->height = pl->height;
lastvisplane->picnum = pl->picnum;
lastvisplane->lightlevel = pl->lightlevel;

pl = lastvisplane++;
pl->minx = start;
pl->maxx = stop;

memset ( pl->top,0xff,sizeof(pl->top));

return pl;
}

//
// R_MakeSpans
//
void
R_MakeSpans
( int x,
int t1,
int b1,
int t2,
int b2 )
{
while ( t1 < t2 && t1<=b1)
{
R_MapPlane ( t1,spanstart[t1],x-1);
t1++;
}
while ( b1 > b2 && b1>=t1)
{
R_MapPlane ( b1,spanstart[b1],x-1);
b1--;
}

while ( t2 < t1 && t2<=b2)
{
spanstart[t2] = x;
t2++;
}
while ( b2 > b1 && b2>=t2)
{
spanstart[b2] = x;
b2--;
}
}

//
// R_DrawPlanes
// At the end of each frame.
//
void R_DrawPlanes ( void)
{
visplane_t* pl;
int light;
int x;
int stop;
int angle;

1. ifdef RANGECHECK

if ( ds_p - drawsegs > MAXDRAWSEGS)
I_Error ( "R_DrawPlanes: drawsegs overflow ( %i)",
ds_p - drawsegs);

if ( lastvisplane - visplanes > MAXVISPLANES)
I_Error ( "R_DrawPlanes: visplane overflow ( %i)",
lastvisplane - visplanes);

if ( lastopening - openings > MAXOPENINGS)
I_Error ( "R_DrawPlanes: opening overflow ( %i)",
lastopening - openings);

1. endif

for ( pl = visplanes ; pl < lastvisplane ; pl++)
{
if ( pl->minx > pl->maxx)
continue;

// sky flat
if ( pl->picnum == skyflatnum)
{
dc_iscale = pspriteiscale>>detailshift;

// Sky is allways drawn full bright,
// i.e. colormaps[0] is used.
// Because of this hack, sky is not affected
// by INVUL inverse mapping.
dc_colormap = colormaps;
dc_texturemid = skytexturemid;
for ( x=pl->minx ; x < = pl->maxx ; x++)
{
dc_yl = pl->top[x];
dc_yh = pl->bottom[x];

if ( dc_yl < = dc_yh)
{
angle = ( viewangle + xtoviewangle[x])>>ANGLETOSKYSHIFT;
dc_x = x;
dc_source = R_GetColumn(skytexture, angle);
colfunc ( );
}
}
continue;
}

// regular flat
ds_source = W_CacheLumpNum(firstflat +
flattranslation[pl->picnum],
PU_STATIC);

planeheight = abs(pl->height-viewz);
light = ( pl->lightlevel > > LIGHTSEGSHIFT)+extralight;

if ( light > = LIGHTLEVELS)
light = LIGHTLEVELS-1;

if ( light < 0)
light = 0;

planezlight = zlight[light];

pl->top[pl->maxx+1] = 0xff;
pl->top[pl->minx-1] = 0xff;

stop = pl->maxx + 1;

for ( x=pl->minx ; x<= stop ; x++)
{
R_MakeSpans(x,pl->top[x-1],
pl->bottom[x-1],
pl->top[x],
pl->bottom[x]);
}

Z_ChangeTag ( ds_source, PU_CACHE);
}
}

Mais c´est bourré d´indices.
10 ans déjà, versons une larme.

doom : )

c´est meme le fichier r_plane.c

J´aurais voulu mettre draw, mais il était trop long ; ))

plus recent, il y a les sources de quake2 qui sont pas mal a regarder : )

Certes mais Doom reste Doom.
La belle époque sans DirectX ni OpenGL ou pour faire un jeu, t´avais ton compilateur et puis c´est tout.
John Carmack ce héro ; )

( Et bientôt les source de Quake 3 )

Mouarf !

10 CLS
20 PRINT " BONJOUR"
30 GOTO 20

Mon premier programme sur TO7! Ca c´est du programme, du vrai !

Deja tout petit tu floodais ; )

Mouarf, tout en subtilité ^^

1. include " doomdef.h"

10 lignes de code et tu nous donne déja la réponse...

Bien essayé ; P

Kelios
---------

Les sources du moteur de Q3 sont pas disponibles mais le shell l´est... c deja plus interessant =)

1987 = Final fantasy 1

+ vieu, + mieu ^^