zdoom/raze
0
0
Fork 0
mirror of https://github.com/ZDoom/Raze.git synced 2024-12-14 22:51:11 +00:00
Code Issues Projects Releases Packages Wiki Activity
raze/polymer/eduke32/build/src/2d.c

1389 lines
40 KiB
C
Raw Normal View History

Split 2d mode editor stuff that remained in engine.c into 2d.c. git-svn-id: https://svn.eduke32.com/eduke32@5790 1a8010ca-5511-0410-912e-c29ae57300e0
2016-06-21 00:33:14 +00:00
#include "build.h"
#include "editor.h"
int32_t editorgridextent = 131072;
////////// editor side view //////////
int32_t m32_sideview = 0;
int32_t m32_sideelev = 256; // elevation in BUILD degrees, 0..512
int16_t m32_sideang = 200; // azimuth, 0..2047
int32_t m32_sidecos, m32_sidesin;
int32_t m32_swcnt;
int32_t m32_wallscreenxy[MAXWALLS][2];
int16_t m32_wallsprite[MAXWALLS+MAXSPRITES];
static int32_t m32_sidedist[MAXWALLS+MAXSPRITES];
static vec3_t m32_viewplane;
static void drawpixel_safe(void *s, char a)
{
#if defined __GNUC__
if (__builtin_expect((intptr_t) s >= frameplace && (intptr_t) s < frameplace+bytesperline*ydim, 1))
#else
if ((intptr_t) s >= frameplace && (intptr_t) s < frameplace+bytesperline*ydim)
#endif
drawpixel(s, a);
#ifdef DEBUGGINGAIDS
else
{
const char c = editorcolors[15];
drawpixel((intptr_t *) frameplace, c);
drawpixel((intptr_t *) frameplace+1, c);
drawpixel((intptr_t *) frameplace+2, c);
drawpixel((intptr_t *) frameplace+bytesperline, c);
drawpixel((intptr_t *) frameplace+bytesperline+1, c);
drawpixel((intptr_t *) frameplace+bytesperline+2, c);
drawpixel((intptr_t *) frameplace+2*bytesperline, c);
drawpixel((intptr_t *) frameplace+2*bytesperline+1, c);
drawpixel((intptr_t *) frameplace+2*bytesperline+2, c);
}
#endif
}
//
// plotpixel
//
void plotpixel(int32_t x, int32_t y, char col)
{
// XXX: if we ever want the editor to work under GL ES, find a replacement for the raster functions
#if defined USE_OPENGL && !defined EDUKE32_GLES
if (getrendermode() >= REND_POLYMOST && in3dmode())
{
palette_t p = getpal(col);
bglRasterPos4i(x, y, 0, 1);
bglDrawPixels(1, 1, GL_RGB, GL_UNSIGNED_BYTE, &p);
bglRasterPos4i(0, 0, 0, 1);
return;
}
#endif
begindrawing(); //{{{
drawpixel_safe((void *) (ylookup[y]+x+frameplace), col);
enddrawing(); //}}}
}
void plotlines2d(const int32_t *xx, const int32_t *yy, int32_t numpoints, int col)
{
int32_t i;
#ifdef USE_OPENGL
if (getrendermode() >= REND_POLYMOST && in3dmode())
{
palette_t p = getpal(col);
bglBegin(GL_LINE_STRIP);
bglColor4ub(p.r, p.g, p.b, 1);
for (i=0; i<numpoints; i++)
bglVertex2i(xx[i], yy[i]);
bglEnd();
return;
}
#endif
{
int32_t odrawlinepat = drawlinepat;
drawlinepat = 0xffffffff;
begindrawing();
for (i=0; i<numpoints-1; i++)
drawline16(xx[i], yy[i], xx[i+1], yy[i+1], col);
enddrawing();
drawlinepat = odrawlinepat;
}
}
//
// getpixel
//
char getpixel(int32_t x, int32_t y)
{
char r;
#ifdef USE_OPENGL
if (getrendermode() >= REND_POLYMOST && in3dmode()) return 0;
#endif
begindrawing(); //{{{
r = readpixel((void *) (ylookup[y]+x+frameplace));
enddrawing(); //}}}
return(r);
}
//
// drawline256
//
void drawline256(int32_t x1, int32_t y1, int32_t x2, int32_t y2, char col)
{
int32_t dx, dy, i, j, inc, plc, daend;
intptr_t p;
col = palookup[0][col];
#ifdef USE_OPENGL
if (getrendermode() >= REND_POLYMOST)
{
palette_t p = getpal(col);
// setpolymost2dview(); // JBF 20040205: more efficient setup
bglViewport(0, 0, xres, yres);
bglMatrixMode(GL_PROJECTION);
bglLoadIdentity();
bglOrtho(0, xres, yres, 0, -1, 1);
if (getrendermode() == REND_POLYMER)
{
bglMatrixMode(GL_MODELVIEW);
bglLoadIdentity();
}
gloy1 = -1;
bglDisable(GL_ALPHA_TEST);
bglDisable(GL_DEPTH_TEST);
bglDisable(GL_TEXTURE_2D);
bglEnable(GL_BLEND); // When using line antialiasing, this is needed
bglBegin(GL_LINES);
bglColor4ub(p.r, p.g, p.b, 255);
bglVertex2f((float) x1 * (1.f/4096.f), (float) y1 * (1.f/4096.f));
bglVertex2f((float) x2 * (1.f/4096.f), (float) y2 * (1.f/4096.f));
bglEnd();
return;
}
#endif
dx = x2-x1; dy = y2-y1;
if (dx >= 0)
{
if ((x1 >= wx2) || (x2 < wx1)) return;
if (x1 < wx1) y1 += scale(wx1-x1, dy, dx), x1 = wx1;
if (x2 > wx2) y2 += scale(wx2-x2, dy, dx), x2 = wx2;
}
else
{
if ((x2 >= wx2) || (x1 < wx1)) return;
if (x2 < wx1) y2 += scale(wx1-x2, dy, dx), x2 = wx1;
if (x1 > wx2) y1 += scale(wx2-x1, dy, dx), x1 = wx2;
}
if (dy >= 0)
{
if ((y1 >= wy2) || (y2 < wy1)) return;
if (y1 < wy1) x1 += scale(wy1-y1, dx, dy), y1 = wy1;
if (y2 > wy2) x2 += scale(wy2-y2, dx, dy), y2 = wy2;
}
else
{
if ((y2 >= wy2) || (y1 < wy1)) return;
if (y2 < wy1) x2 += scale(wy1-y2, dx, dy), y2 = wy1;
if (y1 > wy2) x1 += scale(wy2-y1, dx, dy), y1 = wy2;
}
if (klabs(dx) >= klabs(dy))
{
if (dx == 0) return;
if (dx < 0)
{
i = x1; x1 = x2; x2 = i;
i = y1; y1 = y2; y2 = i;
}
inc = divscale12(dy, dx);
plc = y1+mulscale12((2047-x1)&4095, inc);
i = ((x1+2048)>>12); daend = ((x2+2048)>>12);
begindrawing(); //{{{
for (; i<daend; i++)
{
j = (plc>>12);
if ((j >= startumost[i]) && (j < startdmost[i]))
drawpixel_safe((void *) (frameplace+ylookup[j]+i), col);
plc += inc;
}
enddrawing(); //}}}
}
else
{
if (dy < 0)
{
i = x1; x1 = x2; x2 = i;
i = y1; y1 = y2; y2 = i;
}
inc = divscale12(dx, dy);
plc = x1+mulscale12((2047-y1)&4095, inc);
i = ((y1+2048)>>12); daend = ((y2+2048)>>12);
begindrawing(); //{{{
p = ylookup[i]+frameplace;
for (; i<daend; i++)
{
j = (plc>>12);
if ((i >= startumost[j]) && (i < startdmost[j]))
drawpixel_safe((void *) (j+p), col);
plc += inc; p += ylookup[1];
}
enddrawing(); //}}}
}
}
//static void attach_here() {}
//
// drawline16
//
// JBF: Had to add extra tests to make sure x-coordinates weren't winding up -'ve
// after clipping or crashes would ensue
uint32_t drawlinepat = 0xffffffff;
int32_t drawline16(int32_t x1, int32_t y1, int32_t x2, int32_t y2, int col)
{
//int32_t odx,ody;
//int32_t ox1=x1,oy1=y1, ox2=x2,oy2=y2;
vec2_t d ={ x2-x1, y2-y1 };
//odx=dx;
//ody=dy;
if (d.x < 0)
{
swaplong(&x1, &x2);
swaplong(&y1, &y2);
}
if (x1 >= xres || x2 < 0)
return 0;
if (x1 < 0)
{
if (d.y) y1 += scale(0-x1, d.y, d.x);
x1 = 0;
}
if (x2 >= xres)
{
if (d.y) y2 += scale(xres-1-x2, d.y, d.x);
x2 = xres-1;
}
if ((d.x < 0 && d.y >= 0) || (d.y < 0 && d.x >= 0))
{
swaplong(&x1, &x2);
swaplong(&y1, &y2);
}
if (y1 >= ydim16 || y2 < 0)
return 0;
if (y1 < 0)
{
if (d.x)
x1 = clamp(x1 + scale(0 - y1, d.x, d.y), 0, xres - 1);
y1 = 0;
}
if (y2 >= ydim16)
{
if (d.x)
x2 = clamp(x2 + scale(ydim16-1-y2, d.x, d.y), 0, xres-1);
y2 = ydim16-1;
}
if (d.y < 0)
{
swaplong(&x1, &x2);
swaplong(&y1, &y2);
}
//if (ox1||ox2||oy1||oy2)
// if (x1<0||x1>=xres || y2<0||y2>=yres)
// attach_here();
d.x = klabs(x2-x1)+1;
d.y = klabs(y2-y1)+1;
if ((d.x >= d.y && x2 < x1) || (d.x < d.y && y2 < y1))
{
swaplong(&x1, &x2);
swaplong(&y1, &y2);
}
int pinc, inc = 1;
begindrawing(); //{{{
intptr_t p = (y1*bytesperline)+x1+frameplace;
if (d.x >= d.y)
{
pinc = (y2 > y1) ? bytesperline : -bytesperline;
}
else
{
pinc = (x2 > x1) ? 1 : -1;
swaplong(&d.x, &d.y);
inc = bytesperline;
}
int const trans = (col < 0);
if (trans)
{
col = -col;
if (drawlinepat == 0xffffffff)
{
for (int i=d.x, df=0; i>0; i--)
{
drawtranspixel((char *) p, col);
df += d.y;
if (df >= d.x) { df -= d.x; p += pinc; }
p += inc;
}
}
else
{
uint32_t patc = UINT_MAX;
for (int i=d.x, df=0; i>0; i--)
{
if (drawlinepat & pow2long[(++patc)&31])
drawtranspixel((char *) p, col);
df += d.y;
if (df >= d.x) { df -= d.x; p += pinc; }
p += inc;
}
}
enddrawing(); //}}}
return 1;
}
if (inc == 1 && d.y == 1 && drawlinepat == 0xffffffff)
clearbufbyte((void *) p, d.x, ((int32_t) col<<24)|((int32_t) col<<16)|((int32_t) col<<8)|col);
else if (drawlinepat == 0xffffffff)
{
for (int i=d.x, df=0; i>0; i--)
{
drawpixel((char *) p, col);
df += d.y;
if (df >= d.x) { df -= d.x; p += pinc; }
p += inc;
}
}
else
{
uint32_t patc = UINT_MAX;
for (int i=d.x, df=0; i>0; i--)
{
if (drawlinepat & pow2long[(++patc)&31])
drawpixel((char *) p, col);
df += d.y;
if (df >= d.x) { df -= d.x; p += pinc; }
p += inc;
}
}
enddrawing(); //}}}
return 1;
}
FORCE_INLINE void drawline16mid(int32_t x1, int32_t y1, int32_t x2, int32_t y2, char col)
{
drawline16(halfxdim16+x1, midydim16+y1, halfxdim16+x2, midydim16+y2, col);
}
// eccen: eccentricity of the ellipse,
// 16384: circle
// <16384: shrink in y
// >16384: grow in y
void drawcircle16(int32_t x1, int32_t y1, int32_t r, int32_t eccen, char col)
{
if (eccen != 16384)
{
// JonoF's rough approximation of a circle
int32_t l, spx, spy, lpx, lpy, px, py;
spx = lpx = x1 + mulscale14(r, sintable[0]);
spy = lpy = y1 + mulscale14(eccen, mulscale14(r, sintable[512]));
for (l=64; l<2048; l+=64)
{
px = x1 + mulscale14(r, sintable[l]);
py = y1 + mulscale14(eccen, mulscale14(r, sintable[(l+512)&2047]));
drawline16(lpx, lpy, px, py, col);
lpx = px;
lpy = py;
}
drawline16(lpx, lpy, spx, spy, col);
return;
}
if (r < 0) r = -r;
if (x1+r < 0 || y1+r < 0 || x1-r >= xres || y1-r >= ydim16) return;
uint32_t const uxres = xres, uydim16 = ydim16;
/*
* d
* 6 | 7
* \ | /
* 5 \|/ 8
* c----+----a
* 4 /|\ 1
* / | \
* 3 | 2
* b
*/
begindrawing();
intptr_t const p = (y1*bytesperline)+x1+frameplace;
uint32_t patc = UINT_MAX;
if (drawlinepat == 0xffffffff || drawlinepat & pow2long[(++patc)&31])
{
if ((uint32_t) y1 < uydim16 && (uint32_t) (x1+r) < uxres)
drawpixel((char *) (p+r), col); // a
if ((uint32_t) x1 < uxres && (uint32_t) (y1+r) < uydim16)
drawpixel((char *) (p+(r*bytesperline)), col); // b
if ((uint32_t) y1 < uydim16 && (uint32_t) (x1-r) < uxres)
drawpixel((char *) (p-r), col); // c
if ((uint32_t) x1 < uxres && (uint32_t) (y1-r) < uydim16)
drawpixel((char *) (p-(r*bytesperline)), col); // d
}
int32_t xp = 0, yp = r;
int32_t d = 1 - r, de = 2, dse = 5 - (r << 1);
if (drawlinepat != 0xffffffff)
{
do
{
if (d < 0)
{
d += de;
dse += 2;
}
else
{
d += dse;
dse += 4;
yp--;
}
xp++;
de += 2;
int32_t const ypbpl = yp*bytesperline;
int32_t const xpbpl = xp*bytesperline;
if (drawlinepat & pow2long[(++patc) & 31])
{
if ((uint32_t) (x1 + yp) < uxres && (uint32_t) (y1 + xp) < uydim16)
drawpixel_safe((char *) (p + yp + xpbpl), col); // 1
if ((uint32_t) (x1 + xp) < uxres && (uint32_t) (y1 + yp) < uydim16)
drawpixel_safe((char *) (p + xp + ypbpl), col); // 2
if ((uint32_t) (x1 - xp) < uxres && (uint32_t) (y1 + yp) < uydim16)
drawpixel_safe((char *) (p - xp + ypbpl), col); // 3
if ((uint32_t) (x1 - yp) < uxres && (uint32_t) (y1 + xp) < uydim16)
drawpixel_safe((char *) (p - yp + xpbpl), col); // 4
if ((uint32_t) (x1 - yp) < uxres && (uint32_t) (y1 - xp) < uydim16)
drawpixel_safe((char *) (p - yp - xpbpl), col); // 5
if ((uint32_t) (x1 - xp) < uxres && (uint32_t) (y1 - yp) < uydim16)
drawpixel_safe((char *) (p - xp - ypbpl), col); // 6
if ((uint32_t) (x1 + xp) < uxres && (uint32_t) (y1 - yp) < uydim16)
drawpixel_safe((char *) (p + xp - ypbpl), col); // 7
if ((uint32_t) (x1 + yp) < uxres && (uint32_t) (y1 - xp) < uydim16)
drawpixel_safe((char *) (p + yp - xpbpl), col); // 8
}
} while (yp > xp);
enddrawing();
return;
}
do
{
if (d < 0)
{
d += de;
dse += 2;
}
else
{
d += dse;
dse += 4;
yp--;
}
xp++;
de += 2;
int32_t const ypbpl = yp*bytesperline;
int32_t const xpbpl = xp*bytesperline;
if ((uint32_t) (x1 + yp) < uxres && (uint32_t) (y1 + xp) < uydim16)
drawpixel_safe((char *) (p + yp + xpbpl), col); // 1
if ((uint32_t) (x1 + xp) < uxres && (uint32_t) (y1 + yp) < uydim16)
drawpixel_safe((char *) (p + xp + ypbpl), col); // 2
if ((uint32_t) (x1 - xp) < uxres && (uint32_t) (y1 + yp) < uydim16)
drawpixel_safe((char *) (p - xp + ypbpl), col); // 3
if ((uint32_t) (x1 - yp) < uxres && (uint32_t) (y1 + xp) < uydim16)
drawpixel_safe((char *) (p - yp + xpbpl), col); // 4
if ((uint32_t) (x1 - yp) < uxres && (uint32_t) (y1 - xp) < uydim16)
drawpixel_safe((char *) (p - yp - xpbpl), col); // 5
if ((uint32_t) (x1 - xp) < uxres && (uint32_t) (y1 - yp) < uydim16)
drawpixel_safe((char *) (p - xp - ypbpl), col); // 6
if ((uint32_t) (x1 + xp) < uxres && (uint32_t) (y1 - yp) < uydim16)
drawpixel_safe((char *) (p + xp - ypbpl), col); // 7
if ((uint32_t) (x1 + yp) < uxres && (uint32_t) (y1 - xp) < uydim16)
drawpixel_safe((char *) (p + yp - xpbpl), col); // 8
} while (yp > xp);
enddrawing();
}
//
// clear2dscreen
//
void clear2dscreen(void)
{
int32_t const clearsz = (ydim16 <= yres - STATUS2DSIZ2) ? yres - STATUS2DSIZ2 : yres;
begindrawing(); //{{{
Bmemset((char *) frameplace, 0, bytesperline*clearsz);
enddrawing(); //}}}
}
////////// editor side view //////////
int32_t scalescreeny(int32_t sy) { return (m32_sideview) ? mulscale14(sy, m32_sidesin) : sy; }
// return screen coordinates for BUILD coords x and y (relative to current position)
void screencoords(int32_t *xres, int32_t *yres, int32_t x, int32_t y, int32_t zoome)
{
vec2_t coord ={ x, y };
if (m32_sideview)
rotatepoint(zerovec, coord, m32_sideang, &coord);
*xres = mulscale14(coord.x, zoome);
*yres = scalescreeny(mulscale14(coord.y, zoome));
}
#if 0
void invscreencoords(int32_t *dx, int32_t *dy, int32_t sx, int32_t sy, int32_t zoome)
{
if (m32_sidesin==0 || zoome==0) { *dx=0; *dy=0; return; }
sy = divscale14(divscale14(sy, m32_sidesin), zoome);
sx = divscale14(sx, zoome);
rotatepoint(0, 0, sx, sy, -m32_sideang, dx, dy);
}
#endif
// invscreencoords with sx==0 and sy==getscreenvdisp(dz, zoom)
int32_t getinvdisplacement(int32_t *dx, int32_t *dy, int32_t dz)
{
if (m32_sidesin==0)
return 1;
dz = (((int64_t) dz * (int64_t) m32_sidecos)/(int64_t) m32_sidesin)>>4;
vec2_t v[2] ={ { 0, dz },{ *dx, *dy } };
rotatepoint(zerovec, v[0], -m32_sideang, &v[1]);
*dx = v[1].x;
*dy = v[1].y;
return 0;
}
// return vertical screen coordinate displacement for BUILD z coord
int32_t getscreenvdisp(int32_t bz, int32_t zoome)
{
return mulscale32(bz, zoome*m32_sidecos);
}
void setup_sideview_sincos(void)
{
if (m32_sideview)
{
m32_viewplane.x = 0;
m32_viewplane.y = -512;
m32_sidesin = sintable[m32_sideelev&2047];
m32_sidecos = sintable[(m32_sideelev+512)&2047];
rotatepoint(zerovec, *(vec2_t *) &m32_viewplane, -m32_sideang, (vec2_t *) &m32_viewplane);
m32_viewplane.x = mulscale14(m32_viewplane.x, m32_sidecos);
m32_viewplane.y = mulscale14(m32_viewplane.y, m32_sidecos);
m32_viewplane.z = m32_sidesin>>5;
}
}
static void sideview_getdist(int16_t sw, int16_t sect)
{
vec3_t *p;
vec3_t v;
if (sw<MAXWALLS)
{
v.x = (wall[sw].x + wall[wall[sw].point2].x)>>1;
v.y = (wall[sw].y + wall[wall[sw].point2].y)>>1;
v.z = getflorzofslope(sect, v.x, v.y);
p = &v;
}
else
p = (vec3_t *) &sprite[sw-MAXWALLS];
m32_sidedist[sw] = p->x*m32_viewplane.x + p->y*m32_viewplane.y + (p->z>>4)*m32_viewplane.z;
}
static int sideview_cmppoints(const void *sw1, const void *sw2)
{
int32_t dist1 = m32_sidedist[B_UNBUF16(sw1)];
int32_t dist2 = m32_sidedist[B_UNBUF16(sw2)];
if (dist2>dist1)
return 1;
else if (dist1>dist2)
return -1;
// if (*sw1<MAXWALLS && *sw2<MAXWALLS)
// return (wall[*sw2].nextwall>=0) - (wall[*sw1].nextwall>=0);
return 0;
}
//
// draw2dgrid
//
void draw2dgrid(int32_t posxe, int32_t posye, int32_t posze, int16_t cursectnum, int16_t ange, int32_t zoome, int16_t gride)
{
int64_t i, xp1, yp1, xp2=0, yp2, tempy;
UNREFERENCED_PARAMETER(ange);
if (gride <= 0)
return;
begindrawing(); //{{{
if (m32_sideview)
{
int32_t sx1, sy1, sx2, sy2, dx=0, dy=0;
int32_t xinc=0, yinc=2048>>gride, yofs;
// yofs = getscreenvdisp((yinc-posze)&((yinc<<4)-1), zoome);
if (cursectnum<0 || cursectnum>=numsectors)
yofs = getscreenvdisp(-posze, zoome);
else
yofs = getscreenvdisp(getflorzofslope(cursectnum, posxe, posye)-posze, zoome);
while (scalescreeny(mulscale14(yinc, zoome))==0 && gride>2)
{
gride--;
yinc = 2048>>gride;
}
xp2 = xp1 = ((posxe+(1024>>gride))&(((int64_t) (-1))<<(11-gride)));
yp2 = yp1 = ((posye+(1024>>gride))&(((int64_t) (-1))<<(11-gride)));
do
{
if (xinc==0)
{
screencoords(&sx1, &sy1, -editorgridextent-posxe, yp2-posye, zoome);
if (yp2 == yp1)
{
screencoords(&sx2, &sy2, editorgridextent-posxe, yp2-posye, zoome);
dx = sx2-sx1;
dy = sy2-sy1;
}
yp2 += yinc;
}
else // if (yinc==0)
{
screencoords(&sx1, &sy1, xp2-posxe, -editorgridextent-posye, zoome);
if (xp2 == xp1)
{
screencoords(&sx2, &sy2, xp2-posxe, editorgridextent-posye, zoome);
dx = sx2-sx1;
dy = sy2-sy1;
}
xp2 += xinc;
}
i = drawline16(halfxdim16+sx1, midydim16+sy1+yofs, halfxdim16+sx1+dx, midydim16+sy1+dy+yofs, editorcolors[25]);
if (i==0 || (xp2<-editorgridextent || xp2>editorgridextent ||
yp2<-editorgridextent || yp2>editorgridextent))
{
xp2 = xp1;
yp2 = yp1;
i = 1;
if (yinc>0)
yinc *= -1;
else if (yinc<0)
{
xinc = -yinc;
yinc = 0;
}
else if (xinc>0)
xinc *= -1;
else // if (xinc<0)
i = 0;
}
} while (i);
}
else
{
// vertical lines
yp1 = midydim16-mulscale14(posye+editorgridextent, zoome);
if (yp1 < 0) yp1 = 0;
yp2 = midydim16-mulscale14(posye-editorgridextent, zoome);
if (yp2 >= ydim16) yp2 = ydim16-1;
if ((yp1 < ydim16) && (yp2 >= 0) && (yp2 >= yp1))
{
xp1 = halfxdim16-mulscale14(posxe+editorgridextent, zoome);
for (i=-editorgridextent; i<=editorgridextent; i+=(2048>>gride))
{
xp2 = xp1;
xp1 = halfxdim16-mulscale14(posxe-i, zoome);
if (xp1 >= xdim)
break;
if (xp1 >= 0)
{
if (xp1 != xp2)
drawline16(xp1, yp1, xp1, yp2, editorcolors[25]);
}
}
if (i >= editorgridextent && xp1 < xdim)
xp2 = xp1;
if (xp2 >= 0 && xp2 < xdim)
drawline16(xp2, yp1, xp2, yp2, editorcolors[25]);
}
// horizontal lines
xp1 = mulscale14(posxe+editorgridextent, zoome);
xp2 = mulscale14(posxe-editorgridextent, zoome);
tempy = 0x80000000l;
for (i=-editorgridextent; i<=editorgridextent; i+=(2048>>gride))
{
yp1 = ((posye-i)*zoome)>>14;
if (yp1 != tempy)
{
if ((yp1 > midydim16-ydim16) && (yp1 <= midydim16))
{
drawline16mid(-xp1, -yp1, -xp2, -yp1, editorcolors[25]);
tempy = yp1;
}
}
}
}
enddrawing(); //}}}
}
static void drawscreen_drawwall(int32_t i, int32_t posxe, int32_t posye, int32_t posze, int32_t zoome, int32_t grayp)
{
const walltype *const wal = &wall[i];
int32_t j = wal->nextwall;
#if 0
if (editstatus == 0)
{
if ((show2dwall[i>>3]&pow2char[i&7]) == 0) return;
if ((j >= 0) && (i > j))
if ((show2dwall[j>>3]&pow2char[j&7]) > 0) return;
}
else
#endif
{
if (!m32_sideview && !(grayp&2) && (j >= 0) && (i > j)) return;
}
char col;
if (grayp&1)
col = editorcolors[8];
else if (j < 0)
col = (i == linehighlight) ? editorcolors[15] - M32_THROB : editorcolors[15];
else
{
if ((unsigned) wal->nextwall < MAXWALLS && ((wal->cstat^wall[j].cstat)&1))
col = editorcolors[2];
else if ((wal->cstat&1) != 0)
col = editorcolors[5];
else col = editorcolors[4];
if (i == linehighlight || (linehighlight >= 0 && i == wall[linehighlight].nextwall))
col += M32_THROB>>2;
}
int const p2 = wal->point2;
int32_t x1, y1, x2, y2;
screencoords(&x1, &y1, wal->x-posxe, wal->y-posye, zoome);
screencoords(&x2, &y2, wall[p2].x-posxe, wall[p2].y-posye, zoome);
int64_t const dx = wal->x-wall[p2].x;
int64_t const dy = wal->y-wall[p2].y;
int64_t const dist = dx*dx + dy*dy;
int const bothSidesHighlighted = ((show2dwall[i>>3]&pow2char[i&7]) && (show2dwall[p2>>3]&pow2char[p2&7]));
if (dist > INT32_MAX)
{
col=editorcolors[9];
if (i == linehighlight || (linehighlight >= 0 && i == wall[linehighlight].nextwall))
col -= M32_THROB>>3;
}
else if ((showfirstwall && searchsector>=0 && (sector[searchsector].wallptr == i ||
sector[searchsector].wallptr == wal->nextwall)) ||
bothSidesHighlighted)
{
col = editorcolors[14];
if (i == linehighlight || (linehighlight >= 0 && i == wall[linehighlight].nextwall) || bothSidesHighlighted)
col -= M32_THROB>>1;
}
else if (circlewall >= 0 && (i == circlewall || wal->nextwall == circlewall))
col = editorcolors[14];
int32_t fz=0, fzn=0;
if (m32_sideview)
{
// draw vertical line to neighboring wall
int32_t const sect = sectorofwall(i);
fz = getflorzofslope(sect, wal->x, wal->y);
int32_t fz2 = getflorzofslope(sect, wall[p2].x, wall[p2].y);
int32_t const dz = getscreenvdisp(fz-posze, zoome);
int32_t const dz2 = getscreenvdisp(fz2-posze, zoome);
y1 += dz;
y2 += dz2;
if (wal->nextwall>=0)
{
fzn = getflorzofslope(wal->nextsector, wal->x, wal->y);
// if (i < wall[j].point2)
drawline16mid(x1, y1, x1, y1+getscreenvdisp(fzn-fz, zoome), col);
}
#ifdef YAX_ENABLE
{
int16_t const nw = yax_getnextwall(i, YAX_CEILING);
if (nw >= 0)
{
int32_t const odrawlinepat = drawlinepat;
fz2 = getflorzofslope(sectorofwall(nw), wall[nw].x, wall[nw].y);
drawlinepat = 0x11111111;
drawline16mid(x1, y1, x1, y1+getscreenvdisp(fz2-fz, zoome), col);
drawlinepat = odrawlinepat;
}
}
#endif
m32_wallscreenxy[i][0] = halfxdim16+x1;
m32_wallscreenxy[i][1] = midydim16+y1;
}
if (wal->cstat&64) // if hitscan bit set
{
int32_t const one=(klabs(x2-x1) >= klabs(y2-y1)), no=!one;
drawline16mid(x1+no, y1+one, x2+no, y2+one, col);
drawline16mid(x1-no, y1-one, x2-no, y2-one, col);
}
drawline16mid(x1, y1, x2, y2, col);
// Draw height indicators at center of walls if requested and if not in
// side-view mode.
// XXX: This does not take sloping into account.
if (showheightindicators && !m32_sideview)
{
int32_t dax, day;
int32_t const k = getangle(x1-x2, y1-y2);
screencoords(&dax, &day,
((wal->x+wall[wal->point2].x)>>1)-posxe,
((wal->y+wall[wal->point2].y)>>1)-posye, zoome);
if (wal->nextsector >= 0)
{
int32_t const z1 = sector[sectorofwall(i)].floorz;
int32_t const z2 = sector[wal->nextsector].floorz;
if (z1 != z2 || showheightindicators == 2)
{
// Red walls. Show them on equal-height walls ONLY with setting 2.
int32_t const bb = (z2 < z1);
int32_t const dx = mulscale11(sintable[(k+1024 + 1024*bb)&2047], min(4096, zoome)) / 2560;
int32_t const dy = scalescreeny(mulscale11(sintable[(k+512 + 1024*bb)&2047], min(4096, zoome)) / 2560);
drawline16mid(dax, day, dax+dx, day+dy, col);
}
}
else if (showheightindicators == 2)
{
// Show them on white walls ONLY with setting 2.
int32_t const dx = mulscale11(sintable[(k+2048)&2047], min(4096, zoome)) / 2560;
int32_t const dy = scalescreeny(mulscale11(sintable[(k+1536)&2047], min(4096, zoome)) / 2560);
drawline16mid(dax, day, dax+dx, day+dy, col);
}
}
if ((zoome >= 256 && editstatus == 1) || show2dwall[i>>3]&pow2char[i&7])
if ((halfxdim16+x1 >= 2) && (halfxdim16+x1 <= xdim-3) &&
(midydim16+y1 >= 2) && (midydim16+y1 <= ydim16-3))
{
int32_t pointsize = 2;
col = editorcolors[15];
if (i == pointhighlight || ((unsigned) pointhighlight < MAXWALLS &&
(wal->x == wall[pointhighlight].x) && (wal->y == wall[pointhighlight].y)))
{
col = editorcolors[15] - (M32_THROB>>1);
if (totalclock & 16)
pointsize++;
}
if (show2dwall[i>>3]&pow2char[i&7])
col = editorcolors[14] - (M32_THROB>>1);
if (m32_sideview)
{
if (wal->nextwall >= 0)
{
if (fz < fzn)
col = editorcolors[7];
else if (fz == fzn)
col = editorcolors[4];
}
}
drawcircle16(halfxdim16+x1, midydim16+y1, pointsize, 16384, col);
}
}
int32_t getspritecol(int32_t spr)
{
int const picnum = sprite[spr].picnum;
int pal = sprite[spr].pal;
int const tilecol = tilecols[picnum];
if (palookup[pal] == NULL || (tilecol && palookup[pal][tilecol] == 0))
pal = 0;
if (tilecol) return palookup[pal][tilecol];
if (!waloff[picnum]) loadtile(picnum);
if (!waloff[picnum]) return editorcolors[3];
// Calculate 2D mode tile color.
uint32_t cols[256];
Bmemset(cols, 0, sizeof(cols));
const uint8_t *const texbuf = (const uint8_t *) waloff[picnum];
for (int i = 0; i < tilesiz[picnum].x * tilesiz[picnum].y; i++)
cols[texbuf[i]]++;
unsigned col = 0, cnt = 0;
for (int i = 0; i < 240; i++)
if (cols[i] > cnt)
col = i, cnt = cols[i];
while (col < 240 && curpalette[col+1].r > curpalette[col].r)
col++;
tilecols[picnum] = col - 4;
return palookup[pal][tilecols[picnum]];
}
static void drawscreen_drawsprite(int32_t j, int32_t posxe, int32_t posye, int32_t posze, int32_t zoome)
{
int32_t x1, y1, x2, y2;
int col;
const spritetype *const spr = &sprite[j];
int16_t const blocking = (spr->cstat&1), hitblocking = (spr->cstat&256);
int16_t const flooraligned = (spr->cstat&32), wallaligned = (spr->cstat&16);
int16_t const angofs = m32_sideview ? m32_sideang : 0;
uint8_t const spritecol = spritecol2d[spr->picnum][blocking];
// KEEPINSYNC build.c: drawspritelabel()
if (spr->sectnum<0)
col = editorcolors[4]; // red
else
col = spritecol ? editorcolors[spritecol] : blocking ? editorcolors[5] : getspritecol(j);
if (editstatus == 1)
{
if (pointhighlight >= 16384 &&
(j+16384 == pointhighlight ||
(!m32_sideview && (spr->x == sprite[pointhighlight-16384].x &&
spr->y == sprite[pointhighlight-16384].y))))
{
if (spritecol >= 8 && spritecol <= 15)
col -= M32_THROB>>1;
else col += M32_THROB>>2;
}
else // if (highlightcnt > 0)
{
if (show2dsprite[j>>3]&pow2char[j&7])
col = editorcolors[14] - (M32_THROB>>1);
}
}
screencoords(&x1, &y1, spr->x-posxe, spr->y-posye, zoome);
// tempint = ((midydim16+y1)*bytesperline)+(halfxdim16+x1)+frameplace;
if (m32_sideview)
y1 += getscreenvdisp(spr->z-posze, zoome);
int f = mulscale12(128, zoome);
if ((halfxdim16+x1 >= -f) && (halfxdim16+x1 < xdim+f) &&
(midydim16+y1 >= -f) && (midydim16+y1 < ydim16+f))
{
if (zoome > 512 && spr->clipdist > 32)
drawcircle16(halfxdim16+x1, midydim16+y1, mulscale14(spr->clipdist<<2, zoome), 16384, col);
drawcircle16(halfxdim16+x1, midydim16+y1, 4, 16384, col);
x2 = mulscale11(sintable[(spr->ang+angofs+2560)&2047], zoome) / 768;
y2 = mulscale11(sintable[(spr->ang+angofs+2048)&2047], zoome) / 768;
y2 = scalescreeny(y2);
drawline16mid(x1, y1, x1+x2, y1+y2, col);
if (hitblocking)
{
drawline16mid(x1, y1+1, x1+x2, y1+y2+1, col);
drawline16mid(x1, y1-1, x1+x2, y1+y2-1, col);
drawline16mid(x1-1, y1, x1+x2-1, y1+y2, col);
drawline16mid(x1+1, y1, x1+x2+1, y1+y2, col);
}
if (flooraligned)
{
int32_t fx = mulscale10(mulscale6(tilesiz[spr->picnum].x, spr->xrepeat), zoome) >> 1;
int32_t fy = mulscale10(mulscale6(tilesiz[spr->picnum].y, spr->yrepeat), zoome) >> 1;
int32_t co[4][2], ii, in;
int32_t sinang = sintable[(spr->ang+angofs+1536)&2047];
int32_t cosang = sintable[(spr->ang+angofs+1024)&2047];
int32_t r, s;
co[0][0] = co[3][0] = -fx;
co[0][1] = co[1][1] = -fy;
co[1][0] = co[2][0] = fx;
co[2][1] = co[3][1] = fy;
for (ii=3; ii>=0; ii--)
{
r = mulscale14(cosang, co[ii][0]) - mulscale14(sinang, co[ii][1]);
s = mulscale14(sinang, co[ii][0]) + mulscale14(cosang, co[ii][1]);
s = scalescreeny(s);
co[ii][0] = r;
co[ii][1] = s;
}
drawlinepat = 0xcfcfcfcf;
for (ii=3; ii>=0; ii--)
{
in = (ii+1)&3;
drawline16mid(x1+co[ii][0], y1-co[ii][1], x1+co[in][0], y1-co[in][1], col);
if (hitblocking)
{
drawline16mid(x1+co[ii][0], y1-co[ii][1]+1, x1+co[in][0], y1-co[in][1]+1, col);
drawline16mid(x1+co[ii][0], y1-co[ii][1]-1, x1+co[in][0], y1-co[in][1]-1, col);
drawline16mid(x1+co[ii][0]+1, y1-co[ii][1], x1+co[in][0]+1, y1-co[in][1], col);
drawline16mid(x1+co[ii][0]-1, y1-co[ii][1], x1+co[in][0]-1, y1-co[in][1], col);
}
drawline16mid(x1, y1, x1 + co[in][0], y1 - co[in][1], col);
}
drawlinepat = 0xffffffff;
}
else if (wallaligned)
{
int32_t fx = mulscale6(tilesiz[spr->picnum].x, spr->xrepeat);
int32_t one=(((spr->ang+angofs+256)&512) == 0), no=!one;
x2 = mulscale11(sintable[(spr->ang+angofs+2560)&2047], zoome) / 6144;
y2 = mulscale11(sintable[(spr->ang+angofs+2048)&2047], zoome) / 6144;
y2 = scalescreeny(y2);
drawline16mid(x1, y1, x1+x2, y1+y2, col);
if (!(spr->cstat&64)) // not 1-sided
{
drawline16mid(x1, y1, x1-x2, y1-y2, col);
if (hitblocking)
{
drawline16mid(x1-no, y1-one, x1-x2-no, y1-y2-one, col);
drawline16mid(x1+no, y1+one, x1-x2+no, y1-y2+one, col);
}
}
if (hitblocking)
{
drawline16mid(x1-no, y1-one, x1+x2-no, y1+y2-one, col);
drawline16mid(x1+no, y1+one, x1+x2+no, y1+y2+one, col);
}
x2 = mulscale13(sintable[(spr->ang+angofs+1024)&2047], zoome) * fx / 4096;
y2 = mulscale13(sintable[(spr->ang+angofs+512)&2047], zoome) * fx / 4096;
y2 = scalescreeny(y2);
drawline16mid(x1, y1, x1-x2, y1-y2, col);
drawline16mid(x1, y1, x1+x2, y1+y2, col);
if (hitblocking)
{
drawline16mid(x1+1, y1, x1+x2+1, y1+y2, col);
drawline16mid(x1-1, y1, x1-x2-1, y1-y2, col);
drawline16mid(x1-1, y1, x1+x2-1, y1+y2, col);
drawline16mid(x1+1, y1, x1-x2+1, y1-y2, col);
drawline16mid(x1, y1-1, x1+x2, y1+y2-1, col);
drawline16mid(x1, y1+1, x1-x2, y1-y2+1, col);
drawline16mid(x1, y1+1, x1+x2, y1+y2+1, col);
drawline16mid(x1, y1-1, x1-x2, y1-y2-1, col);
}
}
}
}
//
// draw2dscreen
//
static int8_t tempbuf[(MAXWALLS+7)>>3];
void draw2dscreen(const vec3_t *pos, int16_t cursectnum, int16_t ange, int32_t zoome, int16_t gride)
{
int32_t i, x1, y1;
int16_t angofs = m32_sideview ? m32_sideang : 0;
int32_t posxe=pos->x, posye=pos->y, posze=pos->z;
uint8_t *graybitmap = (uint8_t *) tempbuf;
int32_t alwaysshowgray = get_alwaysshowgray();
if (in3dmode()) return;
setup_sideview_sincos();
begindrawing(); //{{{
if (editstatus == 0)
{
// faketimerhandler();
clear2dscreen();
// faketimerhandler();
draw2dgrid(posxe, posye, posze, cursectnum, ange, zoome, gride);
}
faketimerhandler();
m32_swcnt = 0;
if (numgraysects==0)
Bmemset(graybitmap, 0, (numwalls+7)>>3);
else
{
for (i=0; i<numwalls; i++)
{
int32_t j = wall[i].nextwall;
if ((graywallbitmap[i>>3]&(1<<(i&7))) && (j < 0 || (graywallbitmap[j>>3]&(1<<(j&7)))))
graybitmap[i>>3] |= (1<<(i&7));
else
graybitmap[i>>3] &= ~(1<<(i&7));
}
}
if (!m32_sideview)
{
#ifndef YAX_ENABLE
for (i=numwalls-1; i>=0; i--)
drawscreen_drawwall(i, posxe, posye, posze, zoome, 0);
#else
if (alwaysshowgray)
for (i=numwalls-1; i>=0; i--)
if (graybitmap[i>>3]&(1<<(i&7)))
drawscreen_drawwall(i, posxe, posye, posze, zoome, 1+2);
for (i=numwalls-1; i>=0; i--)
if ((graybitmap[i>>3]&(1<<(i&7)))==0)
drawscreen_drawwall(i, posxe, posye, posze, zoome, 2);
#endif
}
else
{
int32_t j = 0;
for (i=0; i<numsectors; i++)
for (j=sector[i].wallptr; j<sector[i].wallptr+sector[i].wallnum; j++)
{
m32_wallsprite[m32_swcnt++] = j;
sideview_getdist(j, i);
}
// j = sector[numsectors-1].wallptr + sector[numsectors-1].wallnum
for (; j < numwalls; j++) // new walls ...
{
m32_wallsprite[m32_swcnt++] = j;
sideview_getdist(j, 0);
}
}
faketimerhandler();
if (zoome >= 256 || highlightcnt>0)
for (int32_t j=0; j<MAXSPRITES; j++)
if (sprite[j].statnum<MAXSTATUS)
{
// if sprite is highlighted, always draw it
if ((show2dsprite[j>>3]&pow2char[j&7])==0)
{
if (!m32_sideview && sprite[j].sectnum >= 0)
YAX_SKIPSECTOR(sprite[j].sectnum);
if (zoome<256)
continue;
}
if (!m32_sideview)
drawscreen_drawsprite(j, posxe, posye, posze, zoome);
else
{
m32_wallsprite[m32_swcnt++] = MAXWALLS+j;
sideview_getdist(MAXWALLS+j, -1);
}
}
faketimerhandler();
if (m32_sideview)
{
qsort(m32_wallsprite, m32_swcnt, sizeof(int16_t), &sideview_cmppoints);
for (i=0; i<m32_swcnt; i++) // shouldn't it go the other way around?
{
int32_t j = m32_wallsprite[i];
if (j<MAXWALLS)
{
if (alwaysshowgray || !(graybitmap[j>>3]&(1<<(j&7))))
drawscreen_drawwall(j, posxe, posye, posze, zoome, !!(graybitmap[j>>3]&(1<<(j&7))));
}
else
{
if (!alwaysshowgray && sprite[j-MAXWALLS].sectnum>=0)
YAX_SKIPSECTOR(sprite[j-MAXWALLS].sectnum);
drawscreen_drawsprite(j-MAXWALLS, posxe, posye, posze, zoome);
}
}
faketimerhandler();
}
#if 0
{
int32_t xx, yy, xx2, yy2;
screencoords(&xx, &yy, -posxe, -posye, zoome);
screencoords(&xx2, &yy2, (m32_viewplane.x)-posxe, (m32_viewplane.y)-posye, zoome);
if (m32_sideview)
yy2 += getscreenvdisp((m32_viewplane.z<<4)-posze, zoome);
drawcircle16(halfxdim16+xx, midydim16+yy, 2, 16384, editorcolors[4]); //red
drawcircle16(halfxdim16+xx2, midydim16+yy2, 2, 16384, editorcolors[14]); //yellow
drawline16mid(xx, yy, xx2, yy2, editorcolors[15]);
}
#endif
x1 = mulscale11(sintable[(ange+angofs+2560)&2047], zoome) / 768; //Draw white arrow
y1 = mulscale11(sintable[(ange+angofs+2048)&2047], zoome) / 768;
i = scalescreeny(x1);
int32_t j = scalescreeny(y1);
drawline16mid(x1, j, -x1, -j, editorcolors[15]);
drawline16mid(x1, j, +y1, -i, editorcolors[15]);
drawline16mid(x1, j, -y1, +i, editorcolors[15]);
enddrawing(); //}}}
}
//
// setpolymost2dview
// Sets OpenGL for 2D drawing
//
void setpolymost2dview(void)
{
#ifdef USE_OPENGL
if (getrendermode() < REND_POLYMOST) return;
bglViewport(0, 0, xres, yres);
bglMatrixMode(GL_PROJECTION);
bglLoadIdentity();
bglOrtho(0, xres, yres, 0, -1, 1);
if (getrendermode() == REND_POLYMER)
{
bglMatrixMode(GL_MODELVIEW);
bglLoadIdentity();
}
gloy1 = -1;
bglDisable(GL_DEPTH_TEST);
bglDisable(GL_TEXTURE_2D);
bglDisable(GL_BLEND);
#endif
}
Reference in a new issue Copy permalink