mirror of
https://github.com/ZDoom/Raze.git
synced 2024-12-14 22:51:11 +00:00
1420 lines
40 KiB
C++
1420 lines
40 KiB
C++
#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);
|
|
|
|
glRasterPos4i(x, y, 0, 1);
|
|
glDrawPixels(1, 1, GL_RGB, GL_UNSIGNED_BYTE, &p);
|
|
glRasterPos4i(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);
|
|
|
|
polymost_useColorOnly(true);
|
|
glBegin(GL_LINE_STRIP);
|
|
|
|
glColor4ub(p.r, p.g, p.b, 1);
|
|
|
|
for (i=0; i<numpoints; i++)
|
|
glVertex2i(xx[i], yy[i]);
|
|
|
|
glEnd();
|
|
polymost_useColorOnly(false);
|
|
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
|
|
//
|
|
#ifdef USE_OPENGL
|
|
static void drawlinegl(int32_t x1, int32_t y1, int32_t x2, int32_t y2, palette_t p)
|
|
{
|
|
// setpolymost2dview(); // JBF 20040205: more efficient setup
|
|
|
|
glViewport(0, 0, xres, yres);
|
|
glMatrixMode(GL_PROJECTION);
|
|
glLoadIdentity();
|
|
glOrtho(0, xres, yres, 0, -1, 1);
|
|
if (getrendermode() == REND_POLYMER)
|
|
{
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glLoadIdentity();
|
|
|
|
glDisable(GL_TEXTURE_2D);
|
|
}
|
|
|
|
gloy1 = -1;
|
|
glDisable(GL_ALPHA_TEST);
|
|
glDisable(GL_DEPTH_TEST);
|
|
glEnable(GL_BLEND); // When using line antialiasing, this is needed
|
|
|
|
polymost_useColorOnly(true);
|
|
glBegin(GL_LINES);
|
|
glColor4ub(p.r, p.g, p.b, 255);
|
|
glVertex2f((float) x1 * (1.f/4096.f), (float) y1 * (1.f/4096.f));
|
|
glVertex2f((float) x2 * (1.f/4096.f), (float) y2 * (1.f/4096.f));
|
|
|
|
glEnd();
|
|
polymost_useColorOnly(false);
|
|
}
|
|
#endif
|
|
|
|
static void drawlinepixels(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;
|
|
|
|
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(); //}}}
|
|
}
|
|
}
|
|
|
|
void drawlinergb(int32_t x1, int32_t y1, int32_t x2, int32_t y2, palette_t p)
|
|
{
|
|
#ifdef USE_OPENGL
|
|
if (getrendermode() >= REND_POLYMOST)
|
|
{
|
|
drawlinegl(x1, y1, x2, y2, p);
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
char const col = palookup[0][p.f];
|
|
drawlinepixels(x1, y1, x2, y2, col);
|
|
}
|
|
|
|
void drawline256(int32_t x1, int32_t y1, int32_t x2, int32_t y2, char col)
|
|
{
|
|
col = palookup[0][col];
|
|
|
|
#ifdef USE_OPENGL
|
|
if (getrendermode() >= REND_POLYMOST)
|
|
{
|
|
palette_t p = getpal(col);
|
|
p.f = col;
|
|
drawlinegl(x1, y1, x2, y2, p);
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
drawlinepixels(x1, y1, x2, y2, col);
|
|
}
|
|
|
|
|
|
//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 (bssize_t 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 (bssize_t 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 (bssize_t 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 (bssize_t 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;
|
|
}
|
|
|
|
static 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 (bssize_t i = 0; i < tilesiz[picnum].x * tilesiz[picnum].y; i++)
|
|
cols[texbuf[i]]++;
|
|
|
|
unsigned col = 0, cnt = 0;
|
|
|
|
for (bssize_t 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 (bssize_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;
|
|
|
|
glViewport(0, 0, xres, yres);
|
|
|
|
glMatrixMode(GL_PROJECTION);
|
|
glLoadIdentity();
|
|
glOrtho(0, xres, yres, 0, -1, 1);
|
|
|
|
if (getrendermode() == REND_POLYMER)
|
|
{
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glLoadIdentity();
|
|
|
|
glDisable(GL_TEXTURE_2D);
|
|
}
|
|
|
|
gloy1 = -1;
|
|
|
|
glDisable(GL_DEPTH_TEST);
|
|
glDisable(GL_BLEND);
|
|
#endif
|
|
}
|