mirror of
https://github.com/ZDoom/Raze.git
synced 2024-11-15 17:01:28 +00:00
Function names
git-svn-id: https://svn.eduke32.com/eduke32@6831 1a8010ca-5511-0410-912e-c29ae57300e0
This commit is contained in:
terminx
parent
e5bcc1cf81
commit
19c43b84b3
31 changed files with 375 additions and 394 deletions
|
|
@ -772,7 +772,7 @@ static FORCE_INLINE int32_t getpskyidx(int32_t picnum)
|
|||
return j;
|
||||
}
|
||||
|
||||
EXTERN psky_t * E_DefinePsky(int32_t tilenum);
|
||||
EXTERN psky_t * tileSetupSky(int32_t tilenum);
|
||||
|
||||
EXTERN char parallaxtype;
|
||||
EXTERN int32_t parallaxyoffs_override, parallaxyscale_override;
|
||||
|
|
@ -1017,37 +1017,37 @@ typedef struct artheader_t {
|
|||
} artheader_t;
|
||||
#define ARTv1_UNITOFFSET ((signed)(4*sizeof(int32_t) + 2*sizeof(int16_t) + sizeof(picanm_t)))
|
||||
|
||||
int32_t preinitengine(void); // a partial setup of the engine used for launch windows
|
||||
int32_t initengine(void);
|
||||
int32_t E_PostInit(void);
|
||||
void uninitengine(void);
|
||||
int32_t enginePreInit(void); // a partial setup of the engine used for launch windows
|
||||
int32_t engineInit(void);
|
||||
int32_t enginePostInit(void);
|
||||
void engineUnInit(void);
|
||||
void initspritelists(void);
|
||||
int32_t E_FatalError(char const * const msg);
|
||||
int32_t engineFatalError(char const * const msg);
|
||||
|
||||
int32_t loadboard(const char *filename, char flags, vec3_t *dapos, int16_t *daang, int16_t *dacursectnum);
|
||||
int32_t loadmaphack(const char *filename);
|
||||
void delete_maphack_lights();
|
||||
int32_t engineLoadBoard(const char *filename, char flags, vec3_t *dapos, int16_t *daang, int16_t *dacursectnum);
|
||||
int32_t engineLoadMHK(const char *filename);
|
||||
void engineClearLightsFromMHK();
|
||||
#ifdef HAVE_CLIPSHAPE_FEATURE
|
||||
int32_t clipmapinfo_load(void);
|
||||
int32_t engineLoadClipMaps(void);
|
||||
#endif
|
||||
int32_t saveboard(const char *filename, const vec3_t *dapos, int16_t daang, int16_t dacursectnum);
|
||||
|
||||
void tileSetupDummy(int32_t const tile);
|
||||
void tileSetData(int32_t const tile, int32_t tsiz, char const * const buffer);
|
||||
void tileDelete(int32_t const tile);
|
||||
void tileSetSize(int32_t picnum, int16_t dasizx, int16_t dasizy);
|
||||
int32_t artReadHeader(int32_t const fil, char const * const fn, artheader_t * const local);
|
||||
int32_t artReadHeaderFromBuffer(uint8_t const * const buf, artheader_t * const local);
|
||||
int32_t artCheckUnitFileHeader(uint8_t const * const buf, int32_t length);
|
||||
void tileConvertAnimFormat(int32_t const picnum);
|
||||
void artReadManifest(int32_t const fil, artheader_t const * const local);
|
||||
void artPreloadFile(int32_t const fil, artheader_t const * const local);
|
||||
int32_t artLoadFiles(const char *filename, int32_t askedsize);
|
||||
void artClearMapArt(void);
|
||||
void artSetupMapArt(const char *filename);
|
||||
bool tileLoad(int16_t tilenume);
|
||||
void tileLoadData(int16_t tilenume, int32_t dasiz, char *buffer);
|
||||
void artConvertRGB(palette_t * pic, uint8_t const * buf, int32_t bufsizx, int32_t sizx, int32_t sizy);
|
||||
void tileSetupDummy(int32_t const tile);
|
||||
void tileSetData(int32_t const tile, int32_t tsiz, char const *const buffer);
|
||||
void tileDelete(int32_t const tile);
|
||||
void tileSetSize(int32_t picnum, int16_t dasizx, int16_t dasizy);
|
||||
int32_t artReadHeader(int32_t const fil, char const *const fn, artheader_t *const local);
|
||||
int32_t artReadHeaderFromBuffer(uint8_t const *const buf, artheader_t *const local);
|
||||
int32_t artCheckUnitFileHeader(uint8_t const *const buf, int32_t length);
|
||||
void tileConvertAnimFormat(int32_t const picnum);
|
||||
void artReadManifest(int32_t const fil, artheader_t const *const local);
|
||||
void artPreloadFile(int32_t const fil, artheader_t const *const local);
|
||||
int32_t artLoadFiles(const char *filename, int32_t askedsize);
|
||||
void artClearMapArt(void);
|
||||
void artSetupMapArt(const char *filename);
|
||||
bool tileLoad(int16_t tilenume);
|
||||
void tileLoadData(int16_t tilenume, int32_t dasiz, char *buffer);
|
||||
void artConvertRGB(palette_t *pic, uint8_t const *buf, int32_t bufsizx, int32_t sizx, int32_t sizy);
|
||||
|
||||
int32_t qloadkvx(int32_t voxindex, const char *filename);
|
||||
void vox_undefine(int32_t const);
|
||||
|
|
@ -1059,30 +1059,29 @@ int32_t videoSetGameMode(char davidoption, int32_t daxdim, int32_t daydim, int
|
|||
void videoNextPage(void);
|
||||
void videoSetCorrectedAspect();
|
||||
void videoSetViewableArea(int32_t x1, int32_t y1, int32_t x2, int32_t y2);
|
||||
void videoSetAspect(int32_t daxrange, int32_t daaspect);
|
||||
void renderSetAspect(int32_t daxrange, int32_t daaspect);
|
||||
void flushperms(void);
|
||||
|
||||
void plotlines2d(const int32_t *xx, const int32_t *yy, int32_t numpoints, int col) ATTRIBUTE((nonnull(1,2)));
|
||||
|
||||
void plotpixel(int32_t x, int32_t y, char col);
|
||||
char getpixel(int32_t x, int32_t y);
|
||||
void videoSetTarget(int16_t tilenume, int32_t xsiz, int32_t ysiz);
|
||||
void videoRestoreTarget(void);
|
||||
void preparemirror(int32_t dax, int32_t day, fix16_t daang, int16_t dawall,
|
||||
void renderSetTarget(int16_t tilenume, int32_t xsiz, int32_t ysiz);
|
||||
void renderRestoreTarget(void);
|
||||
void renderPrepareMirror(int32_t dax, int32_t day, fix16_t daang, int16_t dawall,
|
||||
int32_t *tposx, int32_t *tposy, fix16_t *tang);
|
||||
void completemirror(void);
|
||||
void renderCompleteMirror(void);
|
||||
|
||||
int32_t drawrooms_q16(int32_t daposx, int32_t daposy, int32_t daposz, fix16_t daang, fix16_t dahoriz, int16_t dacursectnum);
|
||||
int32_t renderDrawRoomsQ16(int32_t daposx, int32_t daposy, int32_t daposz, fix16_t daang, fix16_t dahoriz, int16_t dacursectnum);
|
||||
|
||||
static FORCE_INLINE int32_t drawrooms(int32_t daposx, int32_t daposy, int32_t daposz, int16_t daang, int16_t dahoriz, int16_t dacursectnum)
|
||||
{
|
||||
return drawrooms_q16(daposx, daposy, daposz, fix16_from_int(daang), fix16_from_int(dahoriz), dacursectnum);
|
||||
return renderDrawRoomsQ16(daposx, daposy, daposz, fix16_from_int(daang), fix16_from_int(dahoriz), dacursectnum);
|
||||
}
|
||||
|
||||
void drawmasks(void);
|
||||
void renderDrawMasks(void);
|
||||
void videoClearViewableArea(int32_t dacol);
|
||||
void videoClearScreen(int32_t dacol);
|
||||
void drawmapview(int32_t dax, int32_t day, int32_t zoome, int16_t ang);
|
||||
void renderDrawMapView(int32_t dax, int32_t day, int32_t zoome, int16_t ang);
|
||||
void rotatesprite_(int32_t sx, int32_t sy, int32_t z, int16_t a, int16_t picnum,
|
||||
int8_t dashade, char dapalnum, int32_t dastat, uint8_t daalpha, uint8_t dablend,
|
||||
int32_t cx1, int32_t cy1, int32_t cx2, int32_t cy2);
|
||||
|
|
@ -1145,7 +1144,7 @@ void setfirstwall(int16_t sectnum, int16_t newfirstwall);
|
|||
extern const int16_t *chsecptr_onextwall;
|
||||
int32_t checksectorpointer(int16_t i, int16_t sectnum);
|
||||
|
||||
void getmousevalues(int32_t *mousx, int32_t *mousy, int32_t *bstatus) ATTRIBUTE((nonnull(1,2,3)));
|
||||
void mouseGetValues(int32_t *mousx, int32_t *mousy, int32_t *bstatus) ATTRIBUTE((nonnull(1,2,3)));
|
||||
|
||||
#if !KRANDDEBUG && !defined LUNATIC
|
||||
static FORCE_INLINE int32_t krand(void)
|
||||
|
|
@ -1241,8 +1240,8 @@ static FORCE_INLINE int32_t spriteheightofs(int16_t i, int32_t *height, int32_t
|
|||
return spriteheightofsptr((uspritetype *)&sprite[i], height, alsotileyofs);
|
||||
}
|
||||
|
||||
int screencapture(const char *filename, char inverseit) ATTRIBUTE((nonnull(1)));
|
||||
int screencapture_tga(const char *filename, char inverseit) ATTRIBUTE((nonnull(1)));
|
||||
int videoCaptureScreen(const char *filename, char inverseit) ATTRIBUTE((nonnull(1)));
|
||||
int videoCaptureScreenTGA(const char *filename, char inverseit) ATTRIBUTE((nonnull(1)));
|
||||
|
||||
struct OutputFileCounter {
|
||||
uint16_t count = 0;
|
||||
|
|
@ -1263,17 +1262,17 @@ int32_t wallvisible(int32_t x, int32_t y, int16_t wallnum);
|
|||
//void qsetmode640480(void);
|
||||
void videoSet2dMode(int32_t,int32_t);
|
||||
void clear2dscreen(void);
|
||||
void draw2dgrid(int32_t posxe, int32_t posye, int32_t posze, int16_t cursectnum,
|
||||
void editorDraw2dGrid(int32_t posxe, int32_t posye, int32_t posze, int16_t cursectnum,
|
||||
int16_t ange, int32_t zoome, int16_t gride);
|
||||
void draw2dscreen(const vec3_t *pos, int16_t cursectnum,
|
||||
void editorDraw2dScreen(const vec3_t *pos, int16_t cursectnum,
|
||||
int16_t ange, int32_t zoome, int16_t gride) ATTRIBUTE((nonnull(1)));
|
||||
int32_t drawline16(int32_t x1, int32_t y1, int32_t x2, int32_t y2, int col);
|
||||
void drawcircle16(int32_t x1, int32_t y1, int32_t r, int32_t eccen, char col);
|
||||
int32_t editorDraw2dLine(int32_t x1, int32_t y1, int32_t x2, int32_t y2, int col);
|
||||
void editorDraw2dCircle(int32_t x1, int32_t y1, int32_t r, int32_t eccen, char col);
|
||||
|
||||
int32_t setrendermode(int32_t renderer);
|
||||
int32_t videoSetRenderMode(int32_t renderer);
|
||||
|
||||
#ifdef USE_OPENGL
|
||||
void setrollangle(int32_t rolla);
|
||||
void renderSetRollAngle(int32_t rolla);
|
||||
#endif
|
||||
|
||||
// pal: pass -1 to invalidate all palettes for the tile, or >=0 for a particular palette
|
||||
|
|
@ -1287,9 +1286,9 @@ void setrollangle(int32_t rolla);
|
|||
// bit 6: 33% translucence, using clamping
|
||||
// bit 7: 67% translucence, using clamping
|
||||
// clamping is for sprites, repeating is for walls
|
||||
void invalidatetile(int16_t tilenume, int32_t pal, int32_t how);
|
||||
void tileInvalidate(int16_t tilenume, int32_t pal, int32_t how);
|
||||
|
||||
void setpolymost2dview(void); // sets up GL for 2D drawing
|
||||
void polymostSet2dView(void); // sets up GL for 2D drawing
|
||||
|
||||
int32_t polymost_drawtilescreen(int32_t tilex, int32_t tiley, int32_t wallnum, int32_t dimen, int32_t tilezoom,
|
||||
int32_t usehitile, uint8_t *loadedhitile);
|
||||
|
|
@ -1408,7 +1407,7 @@ int32_t loaddefinitionsfile(const char *fn);
|
|||
|
||||
// if loadboard() fails with -2 return, try loadoldboard(). if it fails with
|
||||
// -2, board is dodgy
|
||||
int32_t loadoldboard(const char *filename, char fromwhere, vec3_t *dapos, int16_t *daang, int16_t *dacursectnum);
|
||||
int32_t engineLoadBoardV5V6(const char *filename, char fromwhere, vec3_t *dapos, int16_t *daang, int16_t *dacursectnum);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
|
|
|||
|
|
@ -55,12 +55,12 @@ typedef struct
|
|||
|
||||
extern mapinfo_t origmapinfo, clipmapinfo;
|
||||
|
||||
extern void clipmapinfo_init();
|
||||
extern void engineInitClipMaps();
|
||||
extern int32_t quickloadboard;
|
||||
extern int16_t *sectq;
|
||||
extern int16_t pictoidx[MAXTILES]; // maps tile num to clipinfo[] index
|
||||
extern int16_t clipspritelist[MAXCLIPNUM];
|
||||
extern void mapinfo_set(mapinfo_t *bak, mapinfo_t *newmap);
|
||||
extern void engineSetClipMap(mapinfo_t *bak, mapinfo_t *newmap);
|
||||
extern int32_t clipsprite_try(uspritetype const * const spr, int32_t xmin, int32_t ymin, int32_t xmax, int32_t ymax);
|
||||
extern int32_t clipsprite_initindex(int32_t curidx, uspritetype const * const curspr, int32_t *clipsectcnt, const vec3_t *vect);
|
||||
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@ extern int32_t getclosestcol_lim(int32_t r, int32_t g, int32_t b, int32_t lastok
|
|||
extern int32_t getclosestcol_nocache_lim(int32_t r, int32_t g, int32_t b, int32_t lastokcol);
|
||||
extern void getclosestcol_flush(void);
|
||||
|
||||
static FORCE_INLINE int32_t getclosestcol(int32_t r, int32_t g, int32_t b)
|
||||
static FORCE_INLINE int32_t paletteGetClosestColor(int32_t r, int32_t g, int32_t b)
|
||||
{
|
||||
return getclosestcol_lim(r, g, b, 255);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -168,11 +168,11 @@ extern int32_t m32_wallscreenxy[MAXWALLS][2];
|
|||
extern int16_t m32_wallsprite[MAXWALLS+MAXSPRITES];
|
||||
extern int8_t sideview_reversehrot;
|
||||
extern int32_t scalescreeny(int32_t sy);
|
||||
extern void screencoords(int32_t *xres, int32_t *yres, int32_t x, int32_t y, int32_t zoome) ATTRIBUTE((nonnull));
|
||||
extern void editorGet2dScreenCoordinates(int32_t *xres, int32_t *yres, int32_t x, int32_t y, int32_t zoome) ATTRIBUTE((nonnull));
|
||||
//extern void invscreencoords(int32_t *dx, int32_t *dy, int32_t sx, int32_t sy, int32_t zoome);
|
||||
extern int32_t getinvdisplacement(int32_t *dx, int32_t *dy, int32_t dz) ATTRIBUTE((nonnull));
|
||||
extern int32_t getscreenvdisp(int32_t bz, int32_t zoome);
|
||||
extern void setup_sideview_sincos(void);
|
||||
extern void editorSetup2dSideView(void);
|
||||
|
||||
extern int8_t keeptexturestretch;
|
||||
extern int16_t pointhighlightdist, linehighlightdist;
|
||||
|
|
@ -395,7 +395,7 @@ static inline int32_t m32_is2d3dmode(void)
|
|||
searchy > m32_2d3d.y && searchy < (m32_2d3d.y + YSIZE_2D3D);
|
||||
}
|
||||
|
||||
extern int32_t getspritecol(int32_t spr);
|
||||
extern int32_t editorGet2dSpriteColor(int32_t spr);
|
||||
|
||||
#define NEXTWALL(i) (wall[wall[i].nextwall])
|
||||
#define POINT2(i) (wall[wall[i].point2])
|
||||
|
|
|
|||
|
|
@ -94,7 +94,7 @@ void plotlines2d(const int32_t *xx, const int32_t *yy, int32_t numpoints, int co
|
|||
|
||||
videoBeginDrawing();
|
||||
for (i=0; i<numpoints-1; i++)
|
||||
drawline16(xx[i], yy[i], xx[i+1], yy[i+1], col);
|
||||
editorDraw2dLine(xx[i], yy[i], xx[i+1], yy[i+1], col);
|
||||
videoEndDrawing();
|
||||
|
||||
drawlinepat = odrawlinepat;
|
||||
|
|
@ -102,24 +102,6 @@ void plotlines2d(const int32_t *xx, const int32_t *yy, int32_t numpoints, int co
|
|||
}
|
||||
|
||||
|
||||
//
|
||||
// getpixel
|
||||
//
|
||||
char getpixel(int32_t x, int32_t y)
|
||||
{
|
||||
char r;
|
||||
|
||||
#ifdef USE_OPENGL
|
||||
if (videoGetRenderMode() >= REND_POLYMOST && in3dmode()) return 0;
|
||||
#endif
|
||||
|
||||
videoBeginDrawing(); //{{{
|
||||
r = readpixel((void *) (ylookup[y]+x+frameplace));
|
||||
videoEndDrawing(); //}}}
|
||||
return r;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// drawline256
|
||||
//
|
||||
|
|
@ -276,7 +258,7 @@ void drawline256(int32_t x1, int32_t y1, int32_t x2, int32_t y2, char col)
|
|||
// 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 editorDraw2dLine(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;
|
||||
|
|
@ -432,16 +414,16 @@ int32_t drawline16(int32_t x1, int32_t y1, int32_t x2, int32_t y2, int col)
|
|||
return 1;
|
||||
}
|
||||
|
||||
static FORCE_INLINE void drawline16mid(int32_t x1, int32_t y1, int32_t x2, int32_t y2, char col)
|
||||
static FORCE_INLINE void editorDraw2dLineMiddle(int32_t x1, int32_t y1, int32_t x2, int32_t y2, char col)
|
||||
{
|
||||
drawline16(halfxdim16+x1, midydim16+y1, halfxdim16+x2, midydim16+y2, col);
|
||||
editorDraw2dLine(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)
|
||||
void editorDraw2dCircle(int32_t x1, int32_t y1, int32_t r, int32_t eccen, char col)
|
||||
{
|
||||
if (eccen != 16384)
|
||||
{
|
||||
|
|
@ -456,13 +438,13 @@ void drawcircle16(int32_t x1, int32_t y1, int32_t r, int32_t eccen, char col)
|
|||
px = x1 + mulscale14(r, sintable[l]);
|
||||
py = y1 + mulscale14(eccen, mulscale14(r, sintable[(l+512)&2047]));
|
||||
|
||||
drawline16(lpx, lpy, px, py, col);
|
||||
editorDraw2dLine(lpx, lpy, px, py, col);
|
||||
|
||||
lpx = px;
|
||||
lpy = py;
|
||||
}
|
||||
|
||||
drawline16(lpx, lpy, spx, spy, col);
|
||||
editorDraw2dLine(lpx, lpy, spx, spy, col);
|
||||
|
||||
return;
|
||||
}
|
||||
|
|
@ -609,7 +591,7 @@ void clear2dscreen(void)
|
|||
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)
|
||||
void editorGet2dScreenCoordinates(int32_t *xres, int32_t *yres, int32_t x, int32_t y, int32_t zoome)
|
||||
{
|
||||
vec2_t coord = { x, y };
|
||||
|
||||
|
|
@ -656,7 +638,7 @@ int32_t getscreenvdisp(int32_t bz, int32_t zoome)
|
|||
return mulscale32(bz, zoome*m32_sidecos);
|
||||
}
|
||||
|
||||
void setup_sideview_sincos(void)
|
||||
void editorSetup2dSideView(void)
|
||||
{
|
||||
if (m32_sideview)
|
||||
{
|
||||
|
|
@ -673,7 +655,7 @@ void setup_sideview_sincos(void)
|
|||
}
|
||||
}
|
||||
|
||||
static void sideview_getdist(int16_t sw, int16_t sect)
|
||||
static void editorGet2dSideViewDistance(int16_t sw, int16_t sect)
|
||||
{
|
||||
vec3_t *p;
|
||||
vec3_t v;
|
||||
|
|
@ -691,7 +673,7 @@ static void sideview_getdist(int16_t sw, int16_t sect)
|
|||
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)
|
||||
static int editorCompare2dSideViewPoints(const void *sw1, const void *sw2)
|
||||
{
|
||||
int32_t dist1 = m32_sidedist[B_UNBUF16(sw1)];
|
||||
int32_t dist2 = m32_sidedist[B_UNBUF16(sw2)];
|
||||
|
|
@ -710,7 +692,7 @@ static int sideview_cmppoints(const void *sw1, const void *sw2)
|
|||
//
|
||||
// draw2dgrid
|
||||
//
|
||||
void draw2dgrid(int32_t posxe, int32_t posye, int32_t posze, int16_t cursectnum, int16_t ange, int32_t zoome, int16_t gride)
|
||||
void editorDraw2dGrid(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;
|
||||
|
||||
|
|
@ -745,10 +727,10 @@ void draw2dgrid(int32_t posxe, int32_t posye, int32_t posze, int16_t cursectnum,
|
|||
{
|
||||
if (xinc==0)
|
||||
{
|
||||
screencoords(&sx1, &sy1, -editorgridextent-posxe, yp2-posye, zoome);
|
||||
editorGet2dScreenCoordinates(&sx1, &sy1, -editorgridextent-posxe, yp2-posye, zoome);
|
||||
if (yp2 == yp1)
|
||||
{
|
||||
screencoords(&sx2, &sy2, editorgridextent-posxe, yp2-posye, zoome);
|
||||
editorGet2dScreenCoordinates(&sx2, &sy2, editorgridextent-posxe, yp2-posye, zoome);
|
||||
dx = sx2-sx1;
|
||||
dy = sy2-sy1;
|
||||
}
|
||||
|
|
@ -756,17 +738,17 @@ void draw2dgrid(int32_t posxe, int32_t posye, int32_t posze, int16_t cursectnum,
|
|||
}
|
||||
else // if (yinc==0)
|
||||
{
|
||||
screencoords(&sx1, &sy1, xp2-posxe, -editorgridextent-posye, zoome);
|
||||
editorGet2dScreenCoordinates(&sx1, &sy1, xp2-posxe, -editorgridextent-posye, zoome);
|
||||
if (xp2 == xp1)
|
||||
{
|
||||
screencoords(&sx2, &sy2, xp2-posxe, editorgridextent-posye, zoome);
|
||||
editorGet2dScreenCoordinates(&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]);
|
||||
i = editorDraw2dLine(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))
|
||||
{
|
||||
|
|
@ -813,13 +795,13 @@ void draw2dgrid(int32_t posxe, int32_t posye, int32_t posze, int16_t cursectnum,
|
|||
if (xp1 >= 0)
|
||||
{
|
||||
if (xp1 != xp2)
|
||||
drawline16(xp1, yp1, xp1, yp2, editorcolors[25]);
|
||||
editorDraw2dLine(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]);
|
||||
editorDraw2dLine(xp2, yp1, xp2, yp2, editorcolors[25]);
|
||||
}
|
||||
|
||||
// horizontal lines
|
||||
|
|
@ -834,7 +816,7 @@ void draw2dgrid(int32_t posxe, int32_t posye, int32_t posze, int16_t cursectnum,
|
|||
{
|
||||
if ((yp1 > midydim16-ydim16) && (yp1 <= midydim16))
|
||||
{
|
||||
drawline16mid(-xp1, -yp1, -xp2, -yp1, editorcolors[25]);
|
||||
editorDraw2dLineMiddle(-xp1, -yp1, -xp2, -yp1, editorcolors[25]);
|
||||
tempy = yp1;
|
||||
}
|
||||
}
|
||||
|
|
@ -845,7 +827,7 @@ void draw2dgrid(int32_t posxe, int32_t posye, int32_t posze, int16_t cursectnum,
|
|||
}
|
||||
|
||||
|
||||
static void drawscreen_drawwall(int32_t i, int32_t posxe, int32_t posye, int32_t posze, int32_t zoome, int32_t grayp)
|
||||
static void editorDraw2dWall(int32_t i, int32_t posxe, int32_t posye, int32_t posze, int32_t zoome, int32_t grayp)
|
||||
{
|
||||
const walltype *const wal = &wall[i];
|
||||
|
||||
|
|
@ -884,8 +866,8 @@ static void drawscreen_drawwall(int32_t i, int32_t posxe, int32_t posye, int32_t
|
|||
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);
|
||||
editorGet2dScreenCoordinates(&x1, &y1, wal->x-posxe, wal->y-posye, zoome);
|
||||
editorGet2dScreenCoordinates(&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;
|
||||
|
|
@ -930,7 +912,7 @@ static void drawscreen_drawwall(int32_t i, int32_t posxe, int32_t posye, int32_t
|
|||
{
|
||||
fzn = getflorzofslope(wal->nextsector, wal->x, wal->y);
|
||||
// if (i < wall[j].point2)
|
||||
drawline16mid(x1, y1, x1, y1+getscreenvdisp(fzn-fz, zoome), col);
|
||||
editorDraw2dLineMiddle(x1, y1, x1, y1+getscreenvdisp(fzn-fz, zoome), col);
|
||||
}
|
||||
#ifdef YAX_ENABLE
|
||||
{
|
||||
|
|
@ -941,7 +923,7 @@ static void drawscreen_drawwall(int32_t i, int32_t posxe, int32_t posye, int32_t
|
|||
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);
|
||||
editorDraw2dLineMiddle(x1, y1, x1, y1+getscreenvdisp(fz2-fz, zoome), col);
|
||||
drawlinepat = odrawlinepat;
|
||||
}
|
||||
}
|
||||
|
|
@ -955,11 +937,11 @@ static void drawscreen_drawwall(int32_t i, int32_t posxe, int32_t posye, int32_t
|
|||
{
|
||||
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);
|
||||
editorDraw2dLineMiddle(x1+no, y1+one, x2+no, y2+one, col);
|
||||
editorDraw2dLineMiddle(x1-no, y1-one, x2-no, y2-one, col);
|
||||
}
|
||||
|
||||
drawline16mid(x1, y1, x2, y2, col);
|
||||
editorDraw2dLineMiddle(x1, y1, x2, y2, col);
|
||||
|
||||
// Draw height indicators at center of walls if requested and if not in
|
||||
// side-view mode.
|
||||
|
|
@ -969,7 +951,7 @@ static void drawscreen_drawwall(int32_t i, int32_t posxe, int32_t posye, int32_t
|
|||
int32_t dax, day;
|
||||
int32_t const k = getangle(x1-x2, y1-y2);
|
||||
|
||||
screencoords(&dax, &day,
|
||||
editorGet2dScreenCoordinates(&dax, &day,
|
||||
((wal->x+wall[wal->point2].x)>>1)-posxe,
|
||||
((wal->y+wall[wal->point2].y)>>1)-posye, zoome);
|
||||
|
||||
|
|
@ -985,7 +967,7 @@ static void drawscreen_drawwall(int32_t i, int32_t posxe, int32_t posye, int32_t
|
|||
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);
|
||||
editorDraw2dLineMiddle(dax, day, dax+dx, day+dy, col);
|
||||
}
|
||||
}
|
||||
else if (showheightindicators == 2)
|
||||
|
|
@ -994,7 +976,7 @@ static void drawscreen_drawwall(int32_t i, int32_t posxe, int32_t posye, int32_t
|
|||
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);
|
||||
editorDraw2dLineMiddle(dax, day, dax+dx, day+dy, col);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1029,11 +1011,11 @@ static void drawscreen_drawwall(int32_t i, int32_t posxe, int32_t posye, int32_t
|
|||
}
|
||||
}
|
||||
|
||||
drawcircle16(halfxdim16+x1, midydim16+y1, pointsize, 16384, col);
|
||||
editorDraw2dCircle(halfxdim16+x1, midydim16+y1, pointsize, 16384, col);
|
||||
}
|
||||
}
|
||||
|
||||
int32_t getspritecol(int32_t spr)
|
||||
int32_t editorGet2dSpriteColor(int32_t spr)
|
||||
{
|
||||
int const picnum = sprite[spr].picnum;
|
||||
int pal = sprite[spr].pal;
|
||||
|
|
@ -1072,7 +1054,7 @@ int32_t getspritecol(int32_t spr)
|
|||
return palookup[pal][tilecols[picnum]];
|
||||
}
|
||||
|
||||
static void drawscreen_drawsprite(int32_t j, int32_t posxe, int32_t posye, int32_t posze, int32_t zoome)
|
||||
static void editorDraw2dSprite(int32_t j, int32_t posxe, int32_t posye, int32_t posze, int32_t zoome)
|
||||
{
|
||||
int32_t x1, y1, x2, y2;
|
||||
int col;
|
||||
|
|
@ -1088,7 +1070,7 @@ static void drawscreen_drawsprite(int32_t j, int32_t posxe, int32_t posye, int32
|
|||
if (spr->sectnum<0)
|
||||
col = editorcolors[4]; // red
|
||||
else
|
||||
col = spritecol ? editorcolors[spritecol] : blocking ? editorcolors[5] : getspritecol(j);
|
||||
col = spritecol ? editorcolors[spritecol] : blocking ? editorcolors[5] : editorGet2dSpriteColor(j);
|
||||
|
||||
if (editstatus == 1)
|
||||
{
|
||||
|
|
@ -1108,7 +1090,7 @@ static void drawscreen_drawsprite(int32_t j, int32_t posxe, int32_t posye, int32
|
|||
}
|
||||
}
|
||||
|
||||
screencoords(&x1, &y1, spr->x-posxe, spr->y-posye, zoome);
|
||||
editorGet2dScreenCoordinates(&x1, &y1, spr->x-posxe, spr->y-posye, zoome);
|
||||
// tempint = ((midydim16+y1)*bytesperline)+(halfxdim16+x1)+frameplace;
|
||||
|
||||
if (m32_sideview)
|
||||
|
|
@ -1120,22 +1102,22 @@ static void drawscreen_drawsprite(int32_t j, int32_t posxe, int32_t posye, int32
|
|||
(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);
|
||||
editorDraw2dCircle(halfxdim16+x1, midydim16+y1, mulscale14(spr->clipdist<<2, zoome), 16384, col);
|
||||
|
||||
drawcircle16(halfxdim16+x1, midydim16+y1, 4, 16384, col);
|
||||
editorDraw2dCircle(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);
|
||||
editorDraw2dLineMiddle(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);
|
||||
editorDraw2dLineMiddle(x1, y1+1, x1+x2, y1+y2+1, col);
|
||||
editorDraw2dLineMiddle(x1, y1-1, x1+x2, y1+y2-1, col);
|
||||
editorDraw2dLineMiddle(x1-1, y1, x1+x2-1, y1+y2, col);
|
||||
editorDraw2dLineMiddle(x1+1, y1, x1+x2+1, y1+y2, col);
|
||||
}
|
||||
|
||||
if (flooraligned)
|
||||
|
|
@ -1164,15 +1146,15 @@ static void drawscreen_drawsprite(int32_t j, int32_t posxe, int32_t posye, int32
|
|||
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);
|
||||
editorDraw2dLineMiddle(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);
|
||||
editorDraw2dLineMiddle(x1+co[ii][0], y1-co[ii][1]+1, x1+co[in][0], y1-co[in][1]+1, col);
|
||||
editorDraw2dLineMiddle(x1+co[ii][0], y1-co[ii][1]-1, x1+co[in][0], y1-co[in][1]-1, col);
|
||||
editorDraw2dLineMiddle(x1+co[ii][0]+1, y1-co[ii][1], x1+co[in][0]+1, y1-co[in][1], col);
|
||||
editorDraw2dLineMiddle(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);
|
||||
editorDraw2dLineMiddle(x1, y1, x1 + co[in][0], y1 - co[in][1], col);
|
||||
}
|
||||
drawlinepat = 0xffffffff;
|
||||
}
|
||||
|
|
@ -1185,21 +1167,21 @@ static void drawscreen_drawsprite(int32_t j, int32_t posxe, int32_t posye, int32
|
|||
y2 = mulscale11(sintable[(spr->ang+angofs+2048)&2047], zoome) / 6144;
|
||||
y2 = scalescreeny(y2);
|
||||
|
||||
drawline16mid(x1, y1, x1+x2, y1+y2, col);
|
||||
editorDraw2dLineMiddle(x1, y1, x1+x2, y1+y2, col);
|
||||
if (!(spr->cstat&64)) // not 1-sided
|
||||
{
|
||||
drawline16mid(x1, y1, x1-x2, y1-y2, col);
|
||||
editorDraw2dLineMiddle(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);
|
||||
editorDraw2dLineMiddle(x1-no, y1-one, x1-x2-no, y1-y2-one, col);
|
||||
editorDraw2dLineMiddle(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);
|
||||
editorDraw2dLineMiddle(x1-no, y1-one, x1+x2-no, y1+y2-one, col);
|
||||
editorDraw2dLineMiddle(x1+no, y1+one, x1+x2+no, y1+y2+one, col);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -1207,20 +1189,20 @@ static void drawscreen_drawsprite(int32_t j, int32_t posxe, int32_t posye, int32
|
|||
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);
|
||||
editorDraw2dLineMiddle(x1, y1, x1-x2, y1-y2, col);
|
||||
editorDraw2dLineMiddle(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);
|
||||
editorDraw2dLineMiddle(x1+1, y1, x1+x2+1, y1+y2, col);
|
||||
editorDraw2dLineMiddle(x1-1, y1, x1-x2-1, y1-y2, col);
|
||||
editorDraw2dLineMiddle(x1-1, y1, x1+x2-1, y1+y2, col);
|
||||
editorDraw2dLineMiddle(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);
|
||||
editorDraw2dLineMiddle(x1, y1-1, x1+x2, y1+y2-1, col);
|
||||
editorDraw2dLineMiddle(x1, y1+1, x1-x2, y1-y2+1, col);
|
||||
editorDraw2dLineMiddle(x1, y1+1, x1+x2, y1+y2+1, col);
|
||||
editorDraw2dLineMiddle(x1, y1-1, x1-x2, y1-y2-1, col);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1232,7 +1214,7 @@ static void drawscreen_drawsprite(int32_t j, int32_t posxe, int32_t posye, int32
|
|||
|
||||
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)
|
||||
void editorDraw2dScreen(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;
|
||||
|
|
@ -1243,7 +1225,7 @@ void draw2dscreen(const vec3_t *pos, int16_t cursectnum, int16_t ange, int32_t z
|
|||
|
||||
if (in3dmode()) return;
|
||||
|
||||
setup_sideview_sincos();
|
||||
editorSetup2dSideView();
|
||||
|
||||
videoBeginDrawing(); //{{{
|
||||
|
||||
|
|
@ -1254,7 +1236,7 @@ void draw2dscreen(const vec3_t *pos, int16_t cursectnum, int16_t ange, int32_t z
|
|||
clear2dscreen();
|
||||
|
||||
// faketimerhandler();
|
||||
draw2dgrid(posxe, posye, posze, cursectnum, ange, zoome, gride);
|
||||
editorDraw2dGrid(posxe, posye, posze, cursectnum, ange, zoome, gride);
|
||||
}
|
||||
|
||||
faketimerhandler();
|
||||
|
|
@ -1279,16 +1261,16 @@ void draw2dscreen(const vec3_t *pos, int16_t cursectnum, int16_t ange, int32_t z
|
|||
{
|
||||
#ifndef YAX_ENABLE
|
||||
for (i=numwalls-1; i>=0; i--)
|
||||
drawscreen_drawwall(i, posxe, posye, posze, zoome, 0);
|
||||
editorDraw2dWall(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);
|
||||
editorDraw2dWall(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);
|
||||
editorDraw2dWall(i, posxe, posye, posze, zoome, 2);
|
||||
#endif
|
||||
}
|
||||
else
|
||||
|
|
@ -1299,14 +1281,14 @@ void draw2dscreen(const vec3_t *pos, int16_t cursectnum, int16_t ange, int32_t z
|
|||
for (j=sector[i].wallptr; j<sector[i].wallptr+sector[i].wallnum; j++)
|
||||
{
|
||||
m32_wallsprite[m32_swcnt++] = j;
|
||||
sideview_getdist(j, i);
|
||||
editorGet2dSideViewDistance(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);
|
||||
editorGet2dSideViewDistance(j, 0);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1327,11 +1309,11 @@ void draw2dscreen(const vec3_t *pos, int16_t cursectnum, int16_t ange, int32_t z
|
|||
}
|
||||
|
||||
if (!m32_sideview)
|
||||
drawscreen_drawsprite(j, posxe, posye, posze, zoome);
|
||||
editorDraw2dSprite(j, posxe, posye, posze, zoome);
|
||||
else
|
||||
{
|
||||
m32_wallsprite[m32_swcnt++] = MAXWALLS+j;
|
||||
sideview_getdist(MAXWALLS+j, -1);
|
||||
editorGet2dSideViewDistance(MAXWALLS+j, -1);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1339,7 +1321,7 @@ void draw2dscreen(const vec3_t *pos, int16_t cursectnum, int16_t ange, int32_t z
|
|||
|
||||
if (m32_sideview)
|
||||
{
|
||||
qsort(m32_wallsprite, m32_swcnt, sizeof(int16_t), &sideview_cmppoints);
|
||||
qsort(m32_wallsprite, m32_swcnt, sizeof(int16_t), &editorCompare2dSideViewPoints);
|
||||
|
||||
for (i=0; i<m32_swcnt; i++) // shouldn't it go the other way around?
|
||||
{
|
||||
|
|
@ -1347,14 +1329,14 @@ void draw2dscreen(const vec3_t *pos, int16_t cursectnum, int16_t ange, int32_t z
|
|||
if (j<MAXWALLS)
|
||||
{
|
||||
if (alwaysshowgray || !(graybitmap[j>>3]&(1<<(j&7))))
|
||||
drawscreen_drawwall(j, posxe, posye, posze, zoome, !!(graybitmap[j>>3]&(1<<(j&7))));
|
||||
editorDraw2dWall(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);
|
||||
editorDraw2dSprite(j-MAXWALLS, posxe, posye, posze, zoome);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1381,9 +1363,9 @@ void draw2dscreen(const vec3_t *pos, int16_t cursectnum, int16_t ange, int32_t z
|
|||
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]);
|
||||
editorDraw2dLineMiddle(x1, j, -x1, -j, editorcolors[15]);
|
||||
editorDraw2dLineMiddle(x1, j, +y1, -i, editorcolors[15]);
|
||||
editorDraw2dLineMiddle(x1, j, -y1, +i, editorcolors[15]);
|
||||
|
||||
|
||||
videoEndDrawing(); //}}}
|
||||
|
|
@ -1393,7 +1375,7 @@ void draw2dscreen(const vec3_t *pos, int16_t cursectnum, int16_t ange, int32_t z
|
|||
// setpolymost2dview
|
||||
// Sets OpenGL for 2D drawing
|
||||
//
|
||||
void setpolymost2dview(void)
|
||||
void polymostSet2dView(void)
|
||||
{
|
||||
#ifdef USE_OPENGL
|
||||
if (videoGetRenderMode() < REND_POLYMOST) return;
|
||||
|
|
|
|||
|
|
@ -319,7 +319,7 @@ static int32_t osdfunc_setrendermode(osdfuncparm_t const * const parm)
|
|||
baselayer_osdcmd_vidmode_func(&parm);
|
||||
}
|
||||
|
||||
setrendermode(m);
|
||||
videoSetRenderMode(m);
|
||||
|
||||
char const *renderer;
|
||||
|
||||
|
|
|
|||
|
|
@ -531,7 +531,7 @@ void M32_DrawRoomsAndMasks(void)
|
|||
CallExtAnalyzeSprites(0,0,0,0);
|
||||
searchwall = osearchwall, searchstat=osearchstat;
|
||||
|
||||
drawmasks();
|
||||
renderDrawMasks();
|
||||
srchwall = (searchstat == 3) ? searchwall : -1;
|
||||
M32_ResetFakeRORTiles();
|
||||
|
||||
|
|
@ -541,7 +541,7 @@ void M32_DrawRoomsAndMasks(void)
|
|||
polymer_editorpick();
|
||||
drawrooms(pos.x,pos.y,pos.z,ang,horiz,cursectnum);
|
||||
CallExtAnalyzeSprites(0,0,0,0);
|
||||
drawmasks();
|
||||
renderDrawMasks();
|
||||
M32_ResetFakeRORTiles();
|
||||
}
|
||||
#endif
|
||||
|
|
@ -550,14 +550,14 @@ void M32_DrawRoomsAndMasks(void)
|
|||
|
||||
if (g_doScreenShot)
|
||||
{
|
||||
screencapture("mcapxxxx.tga", 0);
|
||||
videoCaptureScreen("mcapxxxx.tga", 0);
|
||||
g_doScreenShot = 0;
|
||||
}
|
||||
|
||||
if (r_usenewaspect)
|
||||
{
|
||||
newaspect_enable = 0;
|
||||
videoSetAspect(tmpvr, tmpyx);
|
||||
renderSetAspect(tmpvr, tmpyx);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -650,7 +650,7 @@ int app_main(int argc, char const * const * argv)
|
|||
|
||||
Bstrncpy(game_executable, DefaultGameLocalExec, sizeof(game_executable));
|
||||
|
||||
if (preinitengine())
|
||||
if (enginePreInit())
|
||||
M32_FatalEngineError();
|
||||
|
||||
if ((i = CallExtInit()) < 0) return -1;
|
||||
|
|
@ -660,7 +660,7 @@ int app_main(int argc, char const * const * argv)
|
|||
{
|
||||
if (quitevent || !startwin_run())
|
||||
{
|
||||
uninitengine();
|
||||
engineUnInit();
|
||||
Bexit(0);
|
||||
}
|
||||
}
|
||||
|
|
@ -691,7 +691,7 @@ int app_main(int argc, char const * const * argv)
|
|||
free(m);
|
||||
g_defModules.clear();
|
||||
|
||||
if (E_PostInit())
|
||||
if (enginePostInit())
|
||||
M32_FatalEngineError();
|
||||
|
||||
CallExtPostInit();
|
||||
|
|
@ -722,7 +722,7 @@ int app_main(int argc, char const * const * argv)
|
|||
cacheAllocateBlock(&waloff[i], sx*sy, &walock[i]);
|
||||
newtile = (char *)waloff[i];
|
||||
|
||||
col = getclosestcol(128, 128, 0);
|
||||
col = paletteGetClosestColor(128, 128, 0);
|
||||
for (j=0; j<(signed)sizeof(R); j++)
|
||||
R[j] *= col;
|
||||
|
||||
|
|
@ -733,7 +733,7 @@ int app_main(int argc, char const * const * argv)
|
|||
#endif
|
||||
|
||||
#ifdef HAVE_CLIPSHAPE_FEATURE
|
||||
int k = clipmapinfo_load();
|
||||
int k = engineLoadClipMaps();
|
||||
if (k>0)
|
||||
initprintf("There was an error loading the sprite clipping map (status %d).\n", k);
|
||||
|
||||
|
|
@ -772,7 +772,7 @@ int app_main(int argc, char const * const * argv)
|
|||
if (videoSetGameMode(fullscreen, xdim2d, ydim2d, 8) < 0)
|
||||
{
|
||||
CallExtUnInit();
|
||||
uninitengine();
|
||||
engineUnInit();
|
||||
Bprintf("%d * %d not supported in this graphics mode\n",xdim2d,ydim2d);
|
||||
Bexit(0);
|
||||
}
|
||||
|
|
@ -795,7 +795,7 @@ int app_main(int argc, char const * const * argv)
|
|||
if (videoSetGameMode(fullscreen, xdimgame, ydimgame, bppgame) < 0)
|
||||
{
|
||||
CallExtUnInit();
|
||||
uninitengine();
|
||||
engineUnInit();
|
||||
Bprintf("%d * %d not supported in this graphics mode\n",xdim,ydim);
|
||||
Bexit(0);
|
||||
}
|
||||
|
|
@ -913,7 +913,7 @@ CANCEL:
|
|||
|
||||
CallExtUnInit();
|
||||
// clearfilenames();
|
||||
uninitengine();
|
||||
engineUnInit();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -929,7 +929,7 @@ static void loadmhk(int32_t domessage)
|
|||
Bstrcpy(levname, boardfilename);
|
||||
append_ext_UNSAFE(levname, ".mhk");
|
||||
|
||||
if (!loadmaphack(levname))
|
||||
if (!engineLoadMHK(levname))
|
||||
{
|
||||
if (domessage)
|
||||
message("Loaded map hack file \"%s\"",levname);
|
||||
|
|
@ -1092,7 +1092,7 @@ void editinput(void)
|
|||
// F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 SCROLL
|
||||
|
||||
mousz = 0;
|
||||
getmousevalues(&mousx,&mousy,&bstatus);
|
||||
mouseGetValues(&mousx,&mousy,&bstatus);
|
||||
mousx = (mousx<<16) + mousexsurp;
|
||||
mousy = (mousy<<16) + mouseysurp;
|
||||
|
||||
|
|
@ -1228,7 +1228,7 @@ void editinput(void)
|
|||
{
|
||||
Bmemset(spriteext, 0, sizeof(spriteext_t) * MAXSPRITES);
|
||||
Bmemset(spritesmooth, 0, sizeof(spritesmooth_t) * (MAXSPRITES+MAXUNIQHUDID));
|
||||
delete_maphack_lights();
|
||||
engineClearLightsFromMHK();
|
||||
mhk = 0;
|
||||
message("Maphacks disabled");
|
||||
}
|
||||
|
|
@ -1562,7 +1562,7 @@ static int32_t inside_editor(const vec3_t *pos, int32_t searchx, int32_t searchy
|
|||
{
|
||||
wall[i].point2 += dstw-srcw;
|
||||
|
||||
screencoords(&wall[i].x, &wall[i].y, wall[i].x-pos->x, wall[i].y-pos->y, zoom);
|
||||
editorGet2dScreenCoordinates(&wall[i].x, &wall[i].y, wall[i].x-pos->x, wall[i].y-pos->y, zoom);
|
||||
wall[i].y += getscreenvdisp(getflorzofslope(sectnum,wall[oi].x,wall[oi].y)-pos->z, zoom);
|
||||
wall[i].x += halfxdim16;
|
||||
wall[i].y += midydim16;
|
||||
|
|
@ -1585,12 +1585,12 @@ int32_t inside_editor_curpos(int16_t sectnum)
|
|||
|
||||
static inline void drawline16base(int32_t bx, int32_t by, int32_t x1, int32_t y1, int32_t x2, int32_t y2, char col)
|
||||
{
|
||||
drawline16(bx+x1, by+y1, bx+x2, by+y2, col);
|
||||
editorDraw2dLine(bx+x1, by+y1, bx+x2, by+y2, col);
|
||||
}
|
||||
|
||||
void drawsmallabel(const char *text, char col, char backcol, char border, int32_t dax, int32_t day, int32_t daz)
|
||||
{
|
||||
screencoords(&dax,&day, dax-pos.x,day-pos.y, zoom);
|
||||
editorGet2dScreenCoordinates(&dax,&day, dax-pos.x,day-pos.y, zoom);
|
||||
|
||||
if (m32_sideview)
|
||||
day += getscreenvdisp(daz-pos.z, zoom);
|
||||
|
|
@ -1607,18 +1607,18 @@ void drawsmallabel(const char *text, char col, char backcol, char border, int32_
|
|||
|
||||
printext16(x1,y1, col,backcol, text,1);
|
||||
|
||||
drawline16(x1-2, y1-2, x2-2, y1-2, border);
|
||||
drawline16(x1-2, y2+1, x2-2, y2+1, border);
|
||||
editorDraw2dLine(x1-2, y1-2, x2-2, y1-2, border);
|
||||
editorDraw2dLine(x1-2, y2+1, x2-2, y2+1, border);
|
||||
|
||||
drawline16(x1-3, y1-1, x1-3, y2+0, border);
|
||||
drawline16(x2-1, y1-1, x2-1, y2+0, border);
|
||||
editorDraw2dLine(x1-3, y1-1, x1-3, y2+0, border);
|
||||
editorDraw2dLine(x2-1, y1-1, x2-1, y2+0, border);
|
||||
|
||||
drawline16(x1-1,y1-1, x2-3,y1-1, backcol);
|
||||
drawline16(x1-1,y2+0, x2-3,y2+0, backcol);
|
||||
editorDraw2dLine(x1-1,y1-1, x2-3,y1-1, backcol);
|
||||
editorDraw2dLine(x1-1,y2+0, x2-3,y2+0, backcol);
|
||||
|
||||
drawline16(x1-2,y1+0, x1-2,y2-1, backcol);
|
||||
drawline16(x2-2,y1+0, x2-2,y2-1, backcol);
|
||||
drawline16(x2-3,y1+0, x2-3,y2+0, backcol);
|
||||
editorDraw2dLine(x1-2,y1+0, x1-2,y2-1, backcol);
|
||||
editorDraw2dLine(x2-2,y1+0, x2-2,y2-1, backcol);
|
||||
editorDraw2dLine(x2-3,y1+0, x2-3,y2+0, backcol);
|
||||
|
||||
videoBeginDrawing(); //{{{
|
||||
|
||||
|
|
@ -3230,8 +3230,8 @@ static void drawlinebetween(const vec3_t *v1, const vec3_t *v2, int32_t col, uin
|
|||
|
||||
int32_t x1, x2, y1, y2;
|
||||
|
||||
screencoords(&x1,&y1, v1->x-pos.x,v1->y-pos.y, zoom);
|
||||
screencoords(&x2,&y2, v2->x-pos.x,v2->y-pos.y, zoom);
|
||||
editorGet2dScreenCoordinates(&x1,&y1, v1->x-pos.x,v1->y-pos.y, zoom);
|
||||
editorGet2dScreenCoordinates(&x2,&y2, v2->x-pos.x,v2->y-pos.y, zoom);
|
||||
|
||||
if (m32_sideview)
|
||||
{
|
||||
|
|
@ -3240,7 +3240,7 @@ static void drawlinebetween(const vec3_t *v1, const vec3_t *v2, int32_t col, uin
|
|||
}
|
||||
|
||||
drawlinepat = pat;
|
||||
drawline16(xofs+x1,yofs+y1, xofs+x2,yofs+y2, col);
|
||||
editorDraw2dLine(xofs+x1,yofs+y1, xofs+x2,yofs+y2, col);
|
||||
drawlinepat = opat;
|
||||
}
|
||||
|
||||
|
|
@ -3307,7 +3307,7 @@ static void drawspritelabel(int i)
|
|||
// KEEPINSYNC drawscreen_drawsprite()
|
||||
uspritetype const * s = (uspritetype *)&sprite[i];
|
||||
uint8_t const spritecol = spritecol2d[s->picnum][(s->cstat&1)];
|
||||
int col = spritecol ? editorcolors[spritecol] : getspritecol(i);
|
||||
int col = spritecol ? editorcolors[spritecol] : editorGet2dSpriteColor(i);
|
||||
int const blocking = s->cstat & 1;
|
||||
int bordercol = blocking ? editorcolors[5] : col;
|
||||
|
||||
|
|
@ -3459,7 +3459,7 @@ void overheadeditor(void)
|
|||
if (!m32_is2d3dmode())
|
||||
{
|
||||
oldmousebstatus = bstatus;
|
||||
getmousevalues(&mousx, &mousy, &bstatus);
|
||||
mouseGetValues(&mousx, &mousy, &bstatus);
|
||||
|
||||
{
|
||||
int32_t bs = bstatus;
|
||||
|
|
@ -3513,7 +3513,7 @@ void overheadeditor(void)
|
|||
|
||||
clear2dscreen();
|
||||
|
||||
setup_sideview_sincos();
|
||||
editorSetup2dSideView();
|
||||
|
||||
VM_OnEvent(EVENT_PREDRAW2DSCREEN, -1);
|
||||
|
||||
|
|
@ -3531,15 +3531,15 @@ void overheadeditor(void)
|
|||
if (graphicsmode == 2)
|
||||
totalclocklock = totalclock;
|
||||
|
||||
drawmapview(pos.x, pos.y, zoom, m32_sideview ? (3584 - m32_sideang) & 2047: 1536);
|
||||
renderDrawMapView(pos.x, pos.y, zoom, m32_sideview ? (3584 - m32_sideang) & 2047: 1536);
|
||||
}
|
||||
|
||||
draw2dgrid(pos.x,pos.y,pos.z,cursectnum,ang,zoom,grid);
|
||||
editorDraw2dGrid(pos.x,pos.y,pos.z,cursectnum,ang,zoom,grid);
|
||||
CallExtPreCheckKeys();
|
||||
draw2dscreen(&pos,cursectnum,ang,zoom,grid);
|
||||
editorDraw2dScreen(&pos,cursectnum,ang,zoom,grid);
|
||||
|
||||
// Draw brown arrow (start)
|
||||
screencoords(&x2, &y2, startpos.x-pos.x,startpos.y-pos.y, zoom);
|
||||
editorGet2dScreenCoordinates(&x2, &y2, startpos.x-pos.x,startpos.y-pos.y, zoom);
|
||||
if (m32_sideview)
|
||||
y2 += getscreenvdisp(startpos.z-pos.z, zoom);
|
||||
|
||||
|
|
@ -3684,8 +3684,8 @@ void overheadeditor(void)
|
|||
if (!m32_is2d3dmode() && (m32_sideview || highlightcnt <= 0))
|
||||
{
|
||||
drawlinepat = 0x00ff00ff;
|
||||
drawline16(searchx,0, searchx,ydim2d-1, editorcolors[15]);
|
||||
drawline16(0,searchy, xdim2d-1,searchy, editorcolors[15]);
|
||||
editorDraw2dLine(searchx,0, searchx,ydim2d-1, editorcolors[15]);
|
||||
editorDraw2dLine(0,searchy, xdim2d-1,searchy, editorcolors[15]);
|
||||
drawlinepat = 0xffffffff;
|
||||
|
||||
_printmessage16("(%d,%d)",mousxplc,mousyplc);
|
||||
|
|
@ -3840,8 +3840,8 @@ void overheadeditor(void)
|
|||
}
|
||||
}
|
||||
|
||||
drawline16(searchx,0, searchx,8, editorcolors[15]);
|
||||
drawline16(0,searchy, 8,searchy, editorcolors[15]);
|
||||
editorDraw2dLine(searchx,0, searchx,8, editorcolors[15]);
|
||||
editorDraw2dLine(0,searchy, 8,searchy, editorcolors[15]);
|
||||
|
||||
// 2d3d mode
|
||||
if (m32_2d3dmode && m32_2d3d_resolutions_match())
|
||||
|
|
@ -3897,10 +3897,10 @@ void overheadeditor(void)
|
|||
searchy = osearch.y;
|
||||
|
||||
videoBeginDrawing();
|
||||
drawline16(m32_2d3d.x, m32_2d3d.y, m32_2d3d.x + XSIZE_2D3D, m32_2d3d.y, editorcolors[15]);
|
||||
drawline16(m32_2d3d.x + XSIZE_2D3D, m32_2d3d.y, m32_2d3d.x + XSIZE_2D3D, m32_2d3d.y + YSIZE_2D3D, editorcolors[15]);
|
||||
drawline16(m32_2d3d.x, m32_2d3d.y, m32_2d3d.x, m32_2d3d.y + YSIZE_2D3D, editorcolors[15]);
|
||||
drawline16(m32_2d3d.x, m32_2d3d.y + YSIZE_2D3D, m32_2d3d.x + XSIZE_2D3D, m32_2d3d.y + YSIZE_2D3D, editorcolors[15]);
|
||||
editorDraw2dLine(m32_2d3d.x, m32_2d3d.y, m32_2d3d.x + XSIZE_2D3D, m32_2d3d.y, editorcolors[15]);
|
||||
editorDraw2dLine(m32_2d3d.x + XSIZE_2D3D, m32_2d3d.y, m32_2d3d.x + XSIZE_2D3D, m32_2d3d.y + YSIZE_2D3D, editorcolors[15]);
|
||||
editorDraw2dLine(m32_2d3d.x, m32_2d3d.y, m32_2d3d.x, m32_2d3d.y + YSIZE_2D3D, editorcolors[15]);
|
||||
editorDraw2dLine(m32_2d3d.x, m32_2d3d.y + YSIZE_2D3D, m32_2d3d.x + XSIZE_2D3D, m32_2d3d.y + YSIZE_2D3D, editorcolors[15]);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -4168,7 +4168,7 @@ void overheadeditor(void)
|
|||
{
|
||||
keystatus[88] = 0;
|
||||
//__clearscreen_beforecapture__
|
||||
screencapture("captxxxx.tga", eitherSHIFT);
|
||||
videoCaptureScreen("captxxxx.tga", eitherSHIFT);
|
||||
|
||||
videoShowFrame(1);
|
||||
}
|
||||
|
|
@ -5071,7 +5071,7 @@ end_yax: ;
|
|||
}
|
||||
else
|
||||
{
|
||||
screencoords(&tx,&ty, wall[i].x-pos.x,wall[i].y-pos.y, zoom);
|
||||
editorGet2dScreenCoordinates(&tx,&ty, wall[i].x-pos.x,wall[i].y-pos.y, zoom);
|
||||
ty += getscreenvdisp(
|
||||
getflorzofslope(sectorofwall(i), wall[i].x,wall[i].y)-pos.z, zoom);
|
||||
tx += halfxdim16;
|
||||
|
|
@ -5120,7 +5120,7 @@ end_yax: ;
|
|||
}
|
||||
else
|
||||
{
|
||||
screencoords(&tx,&ty, sprite[i].x-pos.x,sprite[i].y-pos.y, zoom);
|
||||
editorGet2dScreenCoordinates(&tx,&ty, sprite[i].x-pos.x,sprite[i].y-pos.y, zoom);
|
||||
ty += getscreenvdisp(sprite[i].z-pos.z, zoom);
|
||||
tx += halfxdim16;
|
||||
ty += midydim16;
|
||||
|
|
@ -5439,7 +5439,7 @@ end_autoredwall:
|
|||
}
|
||||
else
|
||||
{
|
||||
screencoords(&tx,&ty, wall[j].x-pos.x,wall[j].y-pos.y, zoom);
|
||||
editorGet2dScreenCoordinates(&tx,&ty, wall[j].x-pos.x,wall[j].y-pos.y, zoom);
|
||||
ty += getscreenvdisp(getflorzofslope(i, wall[j].x,wall[j].y)-pos.z, zoom);
|
||||
tx += halfxdim16;
|
||||
ty += midydim16;
|
||||
|
|
@ -8230,7 +8230,7 @@ CANCEL:
|
|||
|
||||
CallExtUnInit();
|
||||
// clearfilenames();
|
||||
uninitengine();
|
||||
engineUnInit();
|
||||
|
||||
Bexit(0);
|
||||
}
|
||||
|
|
@ -8266,7 +8266,7 @@ CANCEL:
|
|||
initprintf("%d * %d not supported in this graphics mode\n",xdim,ydim);
|
||||
CallExtUnInit();
|
||||
// clearfilenames();
|
||||
uninitengine();
|
||||
engineUnInit();
|
||||
Bexit(1);
|
||||
}
|
||||
|
||||
|
|
@ -8464,9 +8464,9 @@ int32_t LoadBoard(const char *filename, uint32_t flags)
|
|||
editorzrange[1] = INT32_MAX;
|
||||
|
||||
CallExtPreLoadMap();
|
||||
i = loadboard(filename, (flags&4)|loadingflags, &pos, &ang, &cursectnum);
|
||||
i = engineLoadBoard(filename, (flags&4)|loadingflags, &pos, &ang, &cursectnum);
|
||||
if (i == -2)
|
||||
i = loadoldboard(filename,loadingflags, &pos, &ang, &cursectnum);
|
||||
i = engineLoadBoardV5V6(filename,loadingflags, &pos, &ang, &cursectnum);
|
||||
|
||||
if (i < 0)
|
||||
{
|
||||
|
|
@ -8641,7 +8641,7 @@ int32_t getpointhighlight(int32_t xplc, int32_t yplc, int32_t point)
|
|||
dst = klabs(xplc-wall[j].x) + klabs(yplc-wall[j].y);
|
||||
else
|
||||
{
|
||||
screencoords(&dax,&day, wall[j].x-pos.x,wall[j].y-pos.y, zoom);
|
||||
editorGet2dScreenCoordinates(&dax,&day, wall[j].x-pos.x,wall[j].y-pos.y, zoom);
|
||||
day += getscreenvdisp(getflorzofslope(i, wall[j].x,wall[j].y)-pos.z, zoom);
|
||||
|
||||
if (halfxdim16+dax < 0 || halfxdim16+dax >= xdim || midydim16+day < 0 || midydim16+day >= ydim)
|
||||
|
|
@ -8672,7 +8672,7 @@ int32_t getpointhighlight(int32_t xplc, int32_t yplc, int32_t point)
|
|||
}
|
||||
else
|
||||
{
|
||||
screencoords(&dax,&day, sprite[i].x-pos.x,sprite[i].y-pos.y, zoom);
|
||||
editorGet2dScreenCoordinates(&dax,&day, sprite[i].x-pos.x,sprite[i].y-pos.y, zoom);
|
||||
day += getscreenvdisp(sprite[i].z-pos.z, zoom);
|
||||
|
||||
if (halfxdim16+dax < 0 || halfxdim16+dax >= xdim || midydim16+day < 0 || midydim16+day >= ydim)
|
||||
|
|
@ -10033,7 +10033,7 @@ int32_t fillsector_maybetrans(int16_t sectnum, int32_t fillcolor, uint8_t dotran
|
|||
endwall = startwall + sector[sectnum].wallnum - 1;
|
||||
for (z=startwall; z<=endwall; z++)
|
||||
{
|
||||
screencoords(&x1,&y1, wall[z].x-pos.x,wall[z].y-pos.y, zoom);
|
||||
editorGet2dScreenCoordinates(&x1,&y1, wall[z].x-pos.x,wall[z].y-pos.y, zoom);
|
||||
if (m32_sideview)
|
||||
y1 += getscreenvdisp(getflorzofslope(sectnum,wall[z].x,wall[z].y)-pos.z, zoom);
|
||||
|
||||
|
|
@ -10128,7 +10128,7 @@ int32_t fillsector_maybetrans(int16_t sectnum, int32_t fillcolor, uint8_t dotran
|
|||
if (fillist[z+1] > rborder)
|
||||
fillist[z+1] = rborder;
|
||||
|
||||
drawline16(fillist[z]+1,sy, fillist[z+1]-1,sy, dotrans ? -col : col); //editorcolors[fillcolor]
|
||||
editorDraw2dLine(fillist[z]+1,sy, fillist[z+1]-1,sy, dotrans ? -col : col); //editorcolors[fillcolor]
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@ static int16_t clipobjectval[MAXCLIPNUM];
|
|||
|
||||
////// sector-like clipping for sprites //////
|
||||
#ifdef HAVE_CLIPSHAPE_FEATURE
|
||||
void mapinfo_set(mapinfo_t *bak, mapinfo_t *newmap)
|
||||
void engineSetClipMap(mapinfo_t *bak, mapinfo_t *newmap)
|
||||
{
|
||||
if (bak)
|
||||
{
|
||||
|
|
@ -49,7 +49,7 @@ static uwalltype *loadwall, *loadwallinv;
|
|||
static uspritetype *loadsprite;
|
||||
|
||||
|
||||
void clipmapinfo_init()
|
||||
void engineInitClipMaps()
|
||||
{
|
||||
numclipmaps = 0;
|
||||
numclipsects = 0;
|
||||
|
|
@ -72,7 +72,7 @@ void clipmapinfo_init()
|
|||
|
||||
// loads the clip maps.
|
||||
// this should be called before any real map is loaded.
|
||||
int32_t clipmapinfo_load(void)
|
||||
int32_t engineLoadClipMaps(void)
|
||||
{
|
||||
int32_t i, k, w;
|
||||
|
||||
|
|
@ -85,7 +85,7 @@ int32_t clipmapinfo_load(void)
|
|||
|
||||
int32_t ournumsectors=0, ournumwalls=0, ournumsprites=0;
|
||||
|
||||
clipmapinfo_init();
|
||||
engineInitClipMaps();
|
||||
|
||||
loadsector = (usectortype *) Xmalloc(MAXSECTORS * sizeof(sectortype));
|
||||
loadwall = (uwalltype *) Xmalloc(MAXWALLS * sizeof(walltype));
|
||||
|
|
@ -105,7 +105,7 @@ int32_t clipmapinfo_load(void)
|
|||
fisec[fi] = ournumsectors;
|
||||
fispr[fi] = ournumsprites;
|
||||
|
||||
i = loadboard(g_clipMapFiles[fi], 8, &tmppos, &ang, &cs);
|
||||
i = engineLoadBoard(g_clipMapFiles[fi], 8, &tmppos, &ang, &cs);
|
||||
if (i<0)
|
||||
continue;
|
||||
// Numsprites will now be set!
|
||||
|
|
@ -148,7 +148,7 @@ int32_t clipmapinfo_load(void)
|
|||
|
||||
if (ournumsectors==0 || ournumwalls==0 || ournumsprites==0) // nothing loaded
|
||||
{
|
||||
clipmapinfo_init();
|
||||
engineInitClipMaps();
|
||||
|
||||
Bfree(fisec);
|
||||
Bfree(fispr);
|
||||
|
|
@ -234,7 +234,7 @@ int32_t clipmapinfo_load(void)
|
|||
initprintf("clip map \"%s\": error: tried to chain picnum %d (sprite %d) in sector %d which"
|
||||
" already belongs to picnum %d.\n", g_clipMapFiles[fi], pn, i-fispr[fi], k-fisec[fi],
|
||||
clipinfo[sectoidx[k]].picnum);
|
||||
clipmapinfo_init();
|
||||
engineInitClipMaps();
|
||||
|
||||
Bfree(fisec);
|
||||
Bfree(fispr);
|
||||
|
|
@ -298,7 +298,7 @@ int32_t clipmapinfo_load(void)
|
|||
break;
|
||||
initprintf("clip map \"%s\": error: encountered more than one outer sector (%d and %d)"
|
||||
" for sprite %d.\n", g_clipMapFiles[fi], outersect-fisec[fi], ns-fisec[fi], i-fispr[fi]);
|
||||
clipmapinfo_init();
|
||||
engineInitClipMaps();
|
||||
|
||||
Bfree(fisec);
|
||||
Bfree(fispr);
|
||||
|
|
@ -317,7 +317,7 @@ int32_t clipmapinfo_load(void)
|
|||
initprintf("clip map \"%s\": error: encountered sector %d belonging to index %d"
|
||||
" while collecting sectors for sprite %d (index %d).\n",
|
||||
g_clipMapFiles[fi], ns-fisec[fi], sectoidx[ns], i-fispr[fi], numclipmaps);
|
||||
clipmapinfo_init();
|
||||
engineInitClipMaps();
|
||||
|
||||
Bfree(fisec);
|
||||
Bfree(fispr);
|
||||
|
|
@ -331,7 +331,7 @@ int32_t clipmapinfo_load(void)
|
|||
if (outersect==-1)
|
||||
{
|
||||
initprintf("clip map: INTERNAL ERROR: outersect==-1!\n");
|
||||
clipmapinfo_init();
|
||||
engineInitClipMaps();
|
||||
|
||||
Bfree(fisec);
|
||||
Bfree(fispr);
|
||||
|
|
@ -916,7 +916,7 @@ int32_t clipmove(vec3_t *pos, int16_t *sectnum,
|
|||
Bmemcpy(origclipsectorlist, clipsectorlist, clipsectnum*sizeof(clipsectorlist[0]));
|
||||
|
||||
// replace sector and wall with clip map
|
||||
mapinfo_set(&origmapinfo, &clipmapinfo);
|
||||
engineSetClipMap(&origmapinfo, &clipmapinfo);
|
||||
}
|
||||
|
||||
curspr = (uspritetype *)&sprite[clipspritelist[clipspritecnt]];
|
||||
|
|
@ -1175,7 +1175,7 @@ int32_t clipmove(vec3_t *pos, int16_t *sectnum,
|
|||
if (curspr)
|
||||
{
|
||||
// restore original map
|
||||
mapinfo_set(NULL, &origmapinfo);
|
||||
engineSetClipMap(NULL, &origmapinfo);
|
||||
|
||||
clipsectnum = origclipsectnum;
|
||||
Bmemcpy(clipsectorlist, origclipsectorlist, clipsectnum*sizeof(clipsectorlist[0]));
|
||||
|
|
|
|||
|
|
@ -250,7 +250,7 @@ void COMMON_clearbackground(int32_t numcols, int32_t numrows)
|
|||
polymost_setFogEnabled(false);
|
||||
polymost_useColorOnly(true);
|
||||
|
||||
setpolymost2dview();
|
||||
polymostSet2dView();
|
||||
glColor4f(0.f, 0.f, 0.f, 0.67f);
|
||||
glEnable(GL_BLEND);
|
||||
glRecti(0, 0, xdim, 8*numrows+8);
|
||||
|
|
|
|||
|
|
@ -2679,7 +2679,7 @@ static int32_t defsparser(scriptfile *script)
|
|||
break;
|
||||
}
|
||||
|
||||
psky_t * const newpsky = E_DefinePsky(tile);
|
||||
psky_t * const newpsky = tileSetupSky(tile);
|
||||
|
||||
while (script->textptr < blockend)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -195,9 +195,9 @@ int32_t circlewall=-1;
|
|||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
void setup_sideview_sincos(void);
|
||||
void editorSetup2dSideView(void);
|
||||
int32_t getscreenvdisp(int32_t bz, int32_t zoome);
|
||||
void screencoords(int32_t *xres, int32_t *yres, int32_t x, int32_t y, int32_t zoome);
|
||||
void editorGet2dScreenCoordinates(int32_t *xres, int32_t *yres, int32_t x, int32_t y, int32_t zoome);
|
||||
int32_t scalescreeny(int32_t sy);
|
||||
#ifdef YAX_ENABLE
|
||||
void yax_tweakpicnums(int32_t bunchnum, int32_t cf, int32_t restore);
|
||||
|
|
@ -977,7 +977,7 @@ void yax_drawrooms(void (*SpriteAnimFunc)(int32_t,int32_t,int32_t,int32_t),
|
|||
int32_t odsprcnt = yax_spritesortcnt[yax_globallev];
|
||||
#endif
|
||||
// +MAXSECTORS: force
|
||||
drawrooms_q16(globalposx,globalposy,globalposz,qglobalang,horiz,k+MAXSECTORS);
|
||||
renderDrawRoomsQ16(globalposx,globalposy,globalposz,qglobalang,horiz,k+MAXSECTORS);
|
||||
if (numhere > 1)
|
||||
for (i=0; i<(numsectors+7)>>3; i++)
|
||||
lgotsector[i] |= gotsector[i];
|
||||
|
|
@ -1055,7 +1055,7 @@ void yax_drawrooms(void (*SpriteAnimFunc)(int32_t,int32_t,int32_t,int32_t),
|
|||
for (nmp=r_tror_nomaskpass; nmp>=0; nmp--)
|
||||
{
|
||||
yax_nomaskpass = nmp;
|
||||
drawrooms_q16(globalposx,globalposy,globalposz,qglobalang,horiz,k+MAXSECTORS); // +MAXSECTORS: force
|
||||
renderDrawRoomsQ16(globalposx,globalposy,globalposz,qglobalang,horiz,k+MAXSECTORS); // +MAXSECTORS: force
|
||||
|
||||
if (nmp==1)
|
||||
{
|
||||
|
|
@ -1080,7 +1080,7 @@ void yax_drawrooms(void (*SpriteAnimFunc)(int32_t,int32_t,int32_t,int32_t),
|
|||
(double)(1000*(timerGetTicksU64()-t))/u64tickspersec);
|
||||
|
||||
SpriteAnimFunc(globalposx, globalposy, globalang, smoothr);
|
||||
drawmasks();
|
||||
renderDrawMasks();
|
||||
}
|
||||
|
||||
if (lev < maxlev[cf])
|
||||
|
|
@ -1098,7 +1098,7 @@ void yax_drawrooms(void (*SpriteAnimFunc)(int32_t,int32_t,int32_t,int32_t),
|
|||
scansector_collectsprites = 0;
|
||||
|
||||
// draw base level
|
||||
drawrooms_q16(globalposx,globalposy,globalposz,qglobalang,horiz,
|
||||
renderDrawRoomsQ16(globalposx,globalposy,globalposz,qglobalang,horiz,
|
||||
osectnum + MAXSECTORS*didmirror);
|
||||
// if (scansector_collectsprites)
|
||||
// spritesortcnt = 0;
|
||||
|
|
@ -1119,8 +1119,8 @@ void yax_drawrooms(void (*SpriteAnimFunc)(int32_t,int32_t,int32_t,int32_t),
|
|||
#ifdef YAX_DEBUG_YMOSTS
|
||||
if (videoGetRenderMode() == REND_CLASSIC && numyaxbunches>0)
|
||||
{
|
||||
char purple = getclosestcol(255, 0, 255);
|
||||
char yellow = getclosestcol(255, 255, 0);
|
||||
char purple = paletteGetClosestColor(255, 0, 255);
|
||||
char yellow = paletteGetClosestColor(255, 255, 0);
|
||||
|
||||
videoBeginDrawing();
|
||||
for (i=0; i<numyaxbunches; i++)
|
||||
|
|
@ -4315,8 +4315,8 @@ static void drawalls(int32_t bunch)
|
|||
# endif
|
||||
{
|
||||
static char fn[32], tmpbuf[80];
|
||||
char purple = getclosestcol(255, 0, 255);
|
||||
char yellow = getclosestcol(255, 255, 0);
|
||||
char purple = paletteGetClosestColor(255, 0, 255);
|
||||
char yellow = paletteGetClosestColor(255, 255, 0);
|
||||
char *bakframe = (char *)Xaligned_alloc(16, xdim*ydim);
|
||||
|
||||
videoBeginDrawing(); //{{{
|
||||
|
|
@ -4342,7 +4342,7 @@ static void drawalls(int32_t bunch)
|
|||
printext256(8,8, whitecol,0, tmpbuf, 0);
|
||||
|
||||
Bsprintf(fn, "engshot%04d.png", engine_screenshot);
|
||||
screencapture(fn, 0);
|
||||
videoCaptureScreen(fn, 0);
|
||||
engine_screenshot++;
|
||||
|
||||
Bmemcpy((char *)frameplace, bakframe, xdim*ydim);
|
||||
|
|
@ -7151,7 +7151,7 @@ static inline void calcbritable(void)
|
|||
|
||||
#define BANG2RAD (fPI * (1.f/1024.f))
|
||||
|
||||
static int32_t loadtables(void)
|
||||
static int32_t engineLoadTables(void)
|
||||
{
|
||||
static char tablesloaded = 0;
|
||||
|
||||
|
|
@ -7501,7 +7501,7 @@ int32_t rayintersect(int32_t x1, int32_t y1, int32_t z1, int32_t vx, int32_t vy,
|
|||
// multi-pskies
|
||||
//
|
||||
|
||||
psky_t * E_DefinePsky(int32_t const tilenum)
|
||||
psky_t * tileSetupSky(int32_t const tilenum)
|
||||
{
|
||||
for (bssize_t i = 0; i < pskynummultis; i++)
|
||||
if (multipskytile[i] == tilenum)
|
||||
|
|
@ -7569,7 +7569,7 @@ static void sighandler(int sig, siginfo_t *info, void *ctx)
|
|||
//
|
||||
// E_FatalError
|
||||
//
|
||||
int32_t E_FatalError(char const * const msg)
|
||||
int32_t engineFatalError(char const * const msg)
|
||||
{
|
||||
engineerrstr = msg;
|
||||
initprintf("ERROR: %s\n", engineerrstr);
|
||||
|
|
@ -7597,7 +7597,7 @@ static spritetype sprite_s[MAXSPRITES];
|
|||
static uspritetype tsprite_s[MAXSPRITESONSCREEN];
|
||||
#endif
|
||||
|
||||
int32_t preinitengine(void)
|
||||
int32_t enginePreInit(void)
|
||||
{
|
||||
baselayer_init();
|
||||
initdivtables();
|
||||
|
|
@ -7680,7 +7680,7 @@ int32_t preinitengine(void)
|
|||
initcrc32table();
|
||||
|
||||
#ifdef HAVE_CLIPSHAPE_FEATURE
|
||||
clipmapinfo_init();
|
||||
engineInitClipMaps();
|
||||
#endif
|
||||
preinitcalled = 1;
|
||||
return 0;
|
||||
|
|
@ -7690,7 +7690,7 @@ int32_t preinitengine(void)
|
|||
//
|
||||
// initengine
|
||||
//
|
||||
int32_t initengine(void)
|
||||
int32_t engineInit(void)
|
||||
{
|
||||
int32_t i, j;
|
||||
|
||||
|
|
@ -7704,7 +7704,7 @@ int32_t initengine(void)
|
|||
|
||||
if (!preinitcalled)
|
||||
{
|
||||
i = preinitengine();
|
||||
i = enginePreInit();
|
||||
if (i) return i;
|
||||
}
|
||||
|
||||
|
|
@ -7714,7 +7714,7 @@ int32_t initengine(void)
|
|||
u64tickspersec = 1.0;
|
||||
#endif
|
||||
|
||||
if (loadtables())
|
||||
if (engineLoadTables())
|
||||
return 1;
|
||||
|
||||
xyaspect = -1;
|
||||
|
|
@ -7753,13 +7753,13 @@ int32_t initengine(void)
|
|||
|
||||
#ifdef LUNATIC
|
||||
if (L_CreateState(&g_engState, "eng", NULL))
|
||||
return E_FatalError("Failed creating engine Lua state!");
|
||||
return engineFatalError("Failed creating engine Lua state!");
|
||||
|
||||
{
|
||||
static char const * const luastr = "_LUNATIC_AUX=true; decl=require('ffi').cdef; require'defs_common'";
|
||||
|
||||
if (L_RunString(&g_engState, luastr, -1, "eng"))
|
||||
return E_FatalError("Failed setting up engine Lua state");
|
||||
return engineFatalError("Failed setting up engine Lua state");
|
||||
}
|
||||
#endif
|
||||
|
||||
|
|
@ -7769,14 +7769,14 @@ int32_t initengine(void)
|
|||
//
|
||||
// E_PostInit
|
||||
//
|
||||
int32_t E_PostInit(void)
|
||||
int32_t enginePostInit(void)
|
||||
{
|
||||
if (!(paletteloaded & PALETTE_MAIN))
|
||||
return E_FatalError("No palette found.");
|
||||
return engineFatalError("No palette found.");
|
||||
if (!(paletteloaded & PALETTE_SHADE))
|
||||
return E_FatalError("No shade table found.");
|
||||
return engineFatalError("No shade table found.");
|
||||
if (!(paletteloaded & PALETTE_TRANSLUC))
|
||||
return E_FatalError("No translucency table found.");
|
||||
return engineFatalError("No translucency table found.");
|
||||
|
||||
palettePostLoadTables();
|
||||
|
||||
|
|
@ -7786,7 +7786,7 @@ int32_t E_PostInit(void)
|
|||
//
|
||||
// uninitengine
|
||||
//
|
||||
void uninitengine(void)
|
||||
void engineUnInit(void)
|
||||
{
|
||||
#ifdef USE_OPENGL
|
||||
polymost_glreset();
|
||||
|
|
@ -7917,8 +7917,8 @@ void set_globalang(fix16_t ang)
|
|||
//
|
||||
// drawrooms
|
||||
//
|
||||
int32_t drawrooms_q16(int32_t daposx, int32_t daposy, int32_t daposz,
|
||||
fix16_t daang, fix16_t dahoriz, int16_t dacursectnum)
|
||||
int32_t renderDrawRoomsQ16(int32_t daposx, int32_t daposy, int32_t daposz,
|
||||
fix16_t daang, fix16_t dahoriz, int16_t dacursectnum)
|
||||
{
|
||||
int32_t i, j, /*cz, fz,*/ closest;
|
||||
int16_t *shortptr1, *shortptr2;
|
||||
|
|
@ -8310,7 +8310,7 @@ int32_t g_maskDrawMode = 0;
|
|||
//
|
||||
// drawmasks
|
||||
//
|
||||
void drawmasks(void)
|
||||
void renderDrawMasks(void)
|
||||
{
|
||||
#ifdef DEBUG_MASK_DRAWING
|
||||
static struct {
|
||||
|
|
@ -8659,7 +8659,7 @@ killsprite:
|
|||
//
|
||||
// drawmapview
|
||||
//
|
||||
void drawmapview(int32_t dax, int32_t day, int32_t zoome, int16_t ang)
|
||||
void renderDrawMapView(int32_t dax, int32_t day, int32_t zoome, int16_t ang)
|
||||
{
|
||||
int32_t i, j, k, l;
|
||||
int32_t x, y;
|
||||
|
|
@ -8667,7 +8667,7 @@ void drawmapview(int32_t dax, int32_t day, int32_t zoome, int16_t ang)
|
|||
|
||||
int32_t const oyxaspect = yxaspect, oviewingrange = viewingrange;
|
||||
|
||||
videoSetAspect(65536, divscale16((320*5)/8, 200));
|
||||
renderSetAspect(65536, divscale16((320*5)/8, 200));
|
||||
|
||||
beforedrawrooms = 0;
|
||||
|
||||
|
|
@ -8957,9 +8957,9 @@ void drawmapview(int32_t dax, int32_t day, int32_t zoome, int16_t ang)
|
|||
videoEndDrawing(); //}}}
|
||||
|
||||
if (r_usenewaspect)
|
||||
videoSetAspect(oviewingrange, oyxaspect);
|
||||
renderSetAspect(oviewingrange, oyxaspect);
|
||||
else
|
||||
videoSetAspect(65536, divscale16(ydim*320, xdim*200));
|
||||
renderSetAspect(65536, divscale16(ydim*320, xdim*200));
|
||||
}
|
||||
|
||||
//////////////////// LOADING AND SAVING ROUTINES ////////////////////
|
||||
|
|
@ -8969,7 +8969,7 @@ static FORCE_INLINE int32_t have_maptext(void)
|
|||
return (mapversion >= 10);
|
||||
}
|
||||
|
||||
static void prepare_loadboard(int32_t fil, vec3_t *dapos, int16_t *daang, int16_t *dacursectnum)
|
||||
static void enginePrepareLoadBoard(int32_t fil, vec3_t *dapos, int16_t *daang, int16_t *dacursectnum)
|
||||
{
|
||||
initspritelists();
|
||||
|
||||
|
|
@ -8996,7 +8996,7 @@ static void prepare_loadboard(int32_t fil, vec3_t *dapos, int16_t *daang, int16_
|
|||
}
|
||||
}
|
||||
|
||||
static int32_t finish_loadboard(const vec3_t *dapos, int16_t *dacursectnum, int16_t numsprites, char myflags)
|
||||
static int32_t engineFinishLoadBoard(const vec3_t *dapos, int16_t *dacursectnum, int16_t numsprites, char myflags)
|
||||
{
|
||||
int32_t i, realnumsprites=numsprites, numremoved;
|
||||
|
||||
|
|
@ -9140,7 +9140,7 @@ LUNATIC_CB int32_t (*loadboard_maptext)(int32_t fil, vec3_t *dapos, int16_t *daa
|
|||
// -2: invalid version
|
||||
// -3: invalid number of sectors, walls or sprites
|
||||
// <= -4: map-text error
|
||||
int32_t loadboard(const char *filename, char flags, vec3_t *dapos, int16_t *daang, int16_t *dacursectnum)
|
||||
int32_t engineLoadBoard(const char *filename, char flags, vec3_t *dapos, int16_t *daang, int16_t *dacursectnum)
|
||||
{
|
||||
int32_t fil, i;
|
||||
int16_t numsprites;
|
||||
|
|
@ -9189,7 +9189,7 @@ int32_t loadboard(const char *filename, char flags, vec3_t *dapos, int16_t *daan
|
|||
}
|
||||
}
|
||||
|
||||
prepare_loadboard(fil, dapos, daang, dacursectnum);
|
||||
enginePrepareLoadBoard(fil, dapos, daang, dacursectnum);
|
||||
|
||||
#ifdef NEW_MAP_FORMAT
|
||||
if (have_maptext())
|
||||
|
|
@ -9342,7 +9342,7 @@ skip_reading_mapbin:
|
|||
|
||||
// initprintf("Loaded map \"%s\" (md4sum: %08x%08x%08x%08x)\n", filename, B_BIG32(*((int32_t*)&md4out[0])), B_BIG32(*((int32_t*)&md4out[4])), B_BIG32(*((int32_t*)&md4out[8])), B_BIG32(*((int32_t*)&md4out[12])));
|
||||
|
||||
return finish_loadboard(dapos, dacursectnum, numsprites, myflags);
|
||||
return engineFinishLoadBoard(dapos, dacursectnum, numsprites, myflags);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -9353,7 +9353,7 @@ skip_reading_mapbin:
|
|||
|
||||
// Powerslave uses v6
|
||||
// Witchaven 1 and TekWar and LameDuke use v5
|
||||
int32_t loadoldboard(const char *filename, char fromwhere, vec3_t *dapos, int16_t *daang, int16_t *dacursectnum)
|
||||
int32_t engineLoadBoardV5V6(const char *filename, char fromwhere, vec3_t *dapos, int16_t *daang, int16_t *dacursectnum)
|
||||
{
|
||||
int32_t fil, i;
|
||||
int16_t numsprites;
|
||||
|
|
@ -9371,7 +9371,7 @@ int32_t loadoldboard(const char *filename, char fromwhere, vec3_t *dapos, int16_
|
|||
kread(fil,&mapversion,4); mapversion = B_LITTLE32(mapversion);
|
||||
if (mapversion != 5L && mapversion != 6L) { kclose(fil); return -2; }
|
||||
|
||||
prepare_loadboard(fil, dapos, daang, dacursectnum);
|
||||
enginePrepareLoadBoard(fil, dapos, daang, dacursectnum);
|
||||
|
||||
kread(fil,&numsectors,2); numsectors = B_LITTLE16(numsectors);
|
||||
if (numsectors > MAXSECTORS) { kclose(fil); return -1; }
|
||||
|
|
@ -9528,7 +9528,7 @@ int32_t loadoldboard(const char *filename, char fromwhere, vec3_t *dapos, int16_
|
|||
kclose(fil);
|
||||
// Done reading file.
|
||||
|
||||
return finish_loadboard(dapos, dacursectnum, numsprites, 0);
|
||||
return engineFinishLoadBoard(dapos, dacursectnum, numsprites, 0);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -10734,7 +10734,7 @@ restart_grand:
|
|||
{
|
||||
// one bunch of sectors completed, prepare the next
|
||||
if (!curspr)
|
||||
mapinfo_set(&origmapinfo, &clipmapinfo); // replace sector and wall with clip map
|
||||
engineSetClipMap(&origmapinfo, &clipmapinfo); // replace sector and wall with clip map
|
||||
|
||||
curspr = (uspritetype *)&sprite[clipspritelist[clipspritecnt]];
|
||||
curidx = clipshape_idx_for_sprite(curspr, curidx);
|
||||
|
|
@ -10965,7 +10965,7 @@ restart_grand:
|
|||
|
||||
#ifdef HAVE_CLIPSHAPE_FEATURE
|
||||
if (curspr)
|
||||
mapinfo_set(NULL, &origmapinfo);
|
||||
engineSetClipMap(NULL, &origmapinfo);
|
||||
#endif
|
||||
|
||||
#ifdef YAX_ENABLE
|
||||
|
|
@ -11513,7 +11513,7 @@ void rotatepoint(vec2_t const pivot, vec2_t p, int16_t daang, vec2_t *p2)
|
|||
// getmousevalues
|
||||
//
|
||||
|
||||
void getmousevalues(int32_t *mousx, int32_t *mousy, int32_t *bstatus)
|
||||
void mouseGetValues(int32_t *mousx, int32_t *mousy, int32_t *bstatus)
|
||||
{
|
||||
mouseReadPos(mousx,mousy);
|
||||
mouseReadButtons(bstatus);
|
||||
|
|
@ -11635,7 +11635,7 @@ void getzrange(const vec3_t *pos, int16_t sectnum,
|
|||
{
|
||||
beginagain:
|
||||
// replace sector and wall with clip map
|
||||
mapinfo_set(&origmapinfo, &clipmapinfo);
|
||||
engineSetClipMap(&origmapinfo, &clipmapinfo);
|
||||
clipsectcnt = clipsectnum; // should be a nop, "safety"...
|
||||
}
|
||||
#endif
|
||||
|
|
@ -11804,7 +11804,7 @@ restart_grand:
|
|||
#ifdef HAVE_CLIPSHAPE_FEATURE
|
||||
if (curspr)
|
||||
{
|
||||
mapinfo_set(NULL, &origmapinfo); // restore original map
|
||||
engineSetClipMap(NULL, &origmapinfo); // restore original map
|
||||
clipsectnum = clipspritenum = 0; // skip the next for loop and check afterwards
|
||||
}
|
||||
#endif
|
||||
|
|
@ -12048,10 +12048,10 @@ void videoSetCorrectedAspect()
|
|||
|
||||
vr = divscale16(x*3, y*4);
|
||||
|
||||
videoSetAspect(vr, yx);
|
||||
renderSetAspect(vr, yx);
|
||||
}
|
||||
else
|
||||
videoSetAspect(65536, divscale16(ydim*320, xdim*200));
|
||||
renderSetAspect(65536, divscale16(ydim*320, xdim*200));
|
||||
}
|
||||
|
||||
//
|
||||
|
|
@ -12085,7 +12085,7 @@ void videoSetViewableArea(int32_t x1, int32_t y1, int32_t x2, int32_t y2)
|
|||
//
|
||||
// setaspect
|
||||
//
|
||||
void videoSetAspect(int32_t daxrange, int32_t daaspect)
|
||||
void renderSetAspect(int32_t daxrange, int32_t daaspect)
|
||||
{
|
||||
viewingrange = daxrange;
|
||||
viewingrangerecip = divscale32(1,daxrange);
|
||||
|
|
@ -12282,7 +12282,7 @@ void videoClearScreen(int32_t dacol)
|
|||
//
|
||||
// setviewtotile
|
||||
//
|
||||
void videoSetTarget(int16_t tilenume, int32_t xsiz, int32_t ysiz)
|
||||
void renderSetTarget(int16_t tilenume, int32_t xsiz, int32_t ysiz)
|
||||
{
|
||||
//DRAWROOMS TO TILE BACKUP&SET CODE
|
||||
tilesiz[tilenume].x = xsiz; tilesiz[tilenume].y = ysiz;
|
||||
|
|
@ -12309,7 +12309,7 @@ void videoSetTarget(int16_t tilenume, int32_t xsiz, int32_t ysiz)
|
|||
|
||||
offscreenrendering = 1;
|
||||
videoSetViewableArea(0,0,ysiz-1,xsiz-1);
|
||||
videoSetAspect(65536,65536);
|
||||
renderSetAspect(65536,65536);
|
||||
|
||||
calc_ylookup(ysiz, xsiz);
|
||||
}
|
||||
|
|
@ -12318,7 +12318,7 @@ void videoSetTarget(int16_t tilenume, int32_t xsiz, int32_t ysiz)
|
|||
//
|
||||
// setviewback
|
||||
//
|
||||
void videoRestoreTarget(void)
|
||||
void renderRestoreTarget(void)
|
||||
{
|
||||
if (setviewcnt <= 0) return;
|
||||
setviewcnt--;
|
||||
|
|
@ -12328,7 +12328,7 @@ void videoRestoreTarget(void)
|
|||
if (setviewcnt == 0)
|
||||
{
|
||||
rendmode = bakrendmode;
|
||||
invalidatetile(baktile,-1,-1);
|
||||
tileInvalidate(baktile,-1,-1);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
|
@ -12384,8 +12384,8 @@ void squarerotatetile(int16_t tilenume)
|
|||
//
|
||||
// preparemirror
|
||||
//
|
||||
void preparemirror(int32_t dax, int32_t day, fix16_t daang, int16_t dawall,
|
||||
int32_t *tposx, int32_t *tposy, fix16_t *tang)
|
||||
void renderPrepareMirror(int32_t dax, int32_t day, fix16_t daang, int16_t dawall,
|
||||
int32_t *tposx, int32_t *tposy, fix16_t *tang)
|
||||
{
|
||||
const int32_t x = wall[dawall].x, dx = wall[wall[dawall].point2].x-x;
|
||||
const int32_t y = wall[dawall].y, dy = wall[wall[dawall].point2].y-y;
|
||||
|
|
@ -12407,7 +12407,7 @@ void preparemirror(int32_t dax, int32_t day, fix16_t daang, int16_t dawall,
|
|||
//
|
||||
// completemirror
|
||||
//
|
||||
void completemirror(void)
|
||||
void renderCompleteMirror(void)
|
||||
{
|
||||
#ifdef USE_OPENGL
|
||||
if (videoGetRenderMode() != REND_CLASSIC)
|
||||
|
|
@ -13084,7 +13084,7 @@ static void PolymerProcessModels(void)
|
|||
//
|
||||
// setrendermode
|
||||
//
|
||||
int32_t setrendermode(int32_t renderer)
|
||||
int32_t videoSetRenderMode(int32_t renderer)
|
||||
{
|
||||
UNREFERENCED_PARAMETER(renderer);
|
||||
|
||||
|
|
@ -13104,7 +13104,7 @@ int32_t setrendermode(int32_t renderer)
|
|||
}
|
||||
else if (videoGetRenderMode() == REND_POLYMER) // going from Polymer to another renderer
|
||||
{
|
||||
delete_maphack_lights();
|
||||
engineClearLightsFromMHK();
|
||||
G_Polymer_UnInit();
|
||||
polymer_uninit();
|
||||
}
|
||||
|
|
@ -13131,7 +13131,7 @@ int32_t setrendermode(int32_t renderer)
|
|||
// setrollangle
|
||||
//
|
||||
#ifdef USE_OPENGL
|
||||
void setrollangle(int32_t rolla)
|
||||
void renderSetRollAngle(int32_t rolla)
|
||||
{
|
||||
gtang = (float)rolla * (fPI * (1.f/1024.f));
|
||||
}
|
||||
|
|
@ -13152,7 +13152,7 @@ void setrollangle(int32_t rolla)
|
|||
// bit 7: ignored (67% translucence, using clamping)
|
||||
// clamping is for sprites, repeating is for walls
|
||||
//
|
||||
void invalidatetile(int16_t tilenume, int32_t pal, int32_t how)
|
||||
void tileInvalidate(int16_t tilenume, int32_t pal, int32_t how)
|
||||
{
|
||||
#if !defined USE_OPENGL
|
||||
UNREFERENCED_PARAMETER(tilenume);
|
||||
|
|
|
|||
|
|
@ -142,7 +142,7 @@ void L_DestroyState(L_State *estate)
|
|||
static void L_OnOutOfMem(void)
|
||||
{
|
||||
OSD_Printf("Out of memory in Lunatic.\n");
|
||||
uninitengine();
|
||||
engineUnInit();
|
||||
exit(127);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@ int32_t num_usermaphacks;
|
|||
static int16_t maphacklightcnt=0;
|
||||
static int16_t maphacklight[PR_MAXLIGHTS];
|
||||
|
||||
void delete_maphack_lights()
|
||||
void engineClearLightsFromMHK()
|
||||
{
|
||||
int32_t i;
|
||||
for (i=0; i<maphacklightcnt; i++)
|
||||
|
|
@ -30,13 +30,13 @@ void delete_maphack_lights()
|
|||
maphacklightcnt = 0;
|
||||
}
|
||||
#else
|
||||
void delete_maphack_lights() {}
|
||||
void engineClearLightsFromMHK() {}
|
||||
#endif
|
||||
|
||||
//
|
||||
// loadmaphack
|
||||
//
|
||||
int32_t loadmaphack(const char *filename)
|
||||
int32_t engineLoadMHK(const char *filename)
|
||||
{
|
||||
enum
|
||||
{
|
||||
|
|
@ -85,7 +85,7 @@ int32_t loadmaphack(const char *filename)
|
|||
#ifdef POLYMER
|
||||
int32_t toomanylights = 0;
|
||||
|
||||
delete_maphack_lights();
|
||||
engineClearLightsFromMHK();
|
||||
#endif
|
||||
|
||||
if (filename)
|
||||
|
|
|
|||
|
|
@ -316,9 +316,9 @@ void palettePostLoadTables(void)
|
|||
palookup0[i] = palookup0[i+(16<<8)];
|
||||
#endif
|
||||
|
||||
blackcol = getclosestcol(0, 0, 0);
|
||||
whitecol = getclosestcol(255, 255, 255);
|
||||
redcol = getclosestcol(255, 0, 0);
|
||||
blackcol = paletteGetClosestColor(0, 0, 0);
|
||||
whitecol = paletteGetClosestColor(255, 255, 255);
|
||||
redcol = paletteGetClosestColor(255, 0, 0);
|
||||
|
||||
for (size_t i = 0; i<16; i++)
|
||||
{
|
||||
|
|
@ -631,7 +631,7 @@ void paletteMakeLookupTable(int32_t palnum, const char *remapbuf, uint8_t r, uin
|
|||
for (j=0; j<256; j++)
|
||||
{
|
||||
const char *ptr = (const char *) &palette[remapbuf[j]*3];
|
||||
*ptr2++ = getclosestcol(ptr[0] + mulscale16(r-ptr[0], palscale),
|
||||
*ptr2++ = paletteGetClosestColor(ptr[0] + mulscale16(r-ptr[0], palscale),
|
||||
ptr[1] + mulscale16(g-ptr[1], palscale),
|
||||
ptr[2] + mulscale16(b-ptr[2], palscale));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1005,7 +1005,7 @@ void polymer_resetlights(void)
|
|||
|
||||
lightcount = 0;
|
||||
|
||||
if (!loadmaphack(NULL))
|
||||
if (!engineLoadMHK(NULL))
|
||||
OSD_Printf("polymer_resetlights: reloaded maphack\n");
|
||||
}
|
||||
|
||||
|
|
@ -2050,7 +2050,7 @@ static void polymer_displayrooms(const int16_t dacursectnum)
|
|||
//glEnable(GL_CLIP_PLANE0);
|
||||
|
||||
if (mirrorlist[i].wallnum >= 0)
|
||||
preparemirror(globalposx, globalposy, qglobalang,
|
||||
renderPrepareMirror(globalposx, globalposy, qglobalang,
|
||||
mirrorlist[i].wallnum, &gx, &gy, &viewangle);
|
||||
|
||||
gx = globalposx;
|
||||
|
|
@ -2120,7 +2120,7 @@ static void polymer_displayrooms(const int16_t dacursectnum)
|
|||
display_mirror = 0;
|
||||
|
||||
glDisable(GL_CULL_FACE);
|
||||
drawmasks();
|
||||
renderDrawMasks();
|
||||
glEnable(GL_CULL_FACE);
|
||||
}
|
||||
return;
|
||||
|
|
|
|||
|
|
@ -7321,7 +7321,7 @@ void polymost_fillpolygon(int32_t npoints)
|
|||
((float *)ry1)[i] = ((float)ry1[i])*(1.0f/4096.f);
|
||||
}
|
||||
|
||||
if (gloy1 != -1) setpolymost2dview(); //disables blending, texturing, and depth testing
|
||||
if (gloy1 != -1) polymostSet2dView(); //disables blending, texturing, and depth testing
|
||||
glEnable(GL_ALPHA_TEST);
|
||||
glEnable(GL_TEXTURE_2D);
|
||||
pthtyp *pth = our_texcache_fetch(DAMETH_NOMASK | (videoGetRenderMode() == REND_POLYMOST && r_useindexedcolortextures ? PTH_INDEXED : 0));
|
||||
|
|
@ -7537,7 +7537,7 @@ int32_t polymost_printext256(int32_t xpos, int32_t ypos, int16_t col, int16_t ba
|
|||
|
||||
polymost_usePaletteIndexing(false);
|
||||
|
||||
setpolymost2dview(); // disables blending, texturing, and depth testing
|
||||
polymostSet2dView(); // disables blending, texturing, and depth testing
|
||||
|
||||
glDisable(GL_ALPHA_TEST);
|
||||
glDepthMask(GL_FALSE); // disable writing to the z-buffer
|
||||
|
|
|
|||
|
|
@ -52,7 +52,7 @@ static void screencapture_end(char *fn, BFILE** filptr)
|
|||
# define HICOLOR 0
|
||||
# endif
|
||||
|
||||
int screencapture(const char *filename, char inverseit)
|
||||
int videoCaptureScreen(const char *filename, char inverseit)
|
||||
{
|
||||
char *fn = Xstrdup(filename);
|
||||
FILE *fp = capturecounter.opennextfile_withext(fn, "png");
|
||||
|
|
@ -129,7 +129,7 @@ int screencapture(const char *filename, char inverseit)
|
|||
return 0;
|
||||
}
|
||||
|
||||
int screencapture_tga(const char *filename, char inverseit)
|
||||
int videoCaptureScreenTGA(const char *filename, char inverseit)
|
||||
{
|
||||
int32_t i;
|
||||
char head[18] = { 0,1,1,0,0,0,1,24,0,0,0,0,0/*wlo*/,0/*whi*/,0/*hlo*/,0/*hhi*/,8,0 };
|
||||
|
|
|
|||
|
|
@ -635,7 +635,7 @@ void tileLoadData(int16_t tilenume, int32_t dasiz, char *buffer)
|
|||
if (artfil == -1)
|
||||
{
|
||||
initprintf("Failed opening ART file \"%s\"!\n", fn);
|
||||
uninitengine();
|
||||
engineUnInit();
|
||||
Bexit(11);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -497,7 +497,7 @@ int32_t Anim_Play(const char *fn)
|
|||
i = VM_OnEventWithReturn(EVENT_PRECUTSCENE, g_player[screenpeek].ps->i, screenpeek, i);
|
||||
|
||||
waloff[TILE_ANIM] = (intptr_t)ANIM_DrawFrame(i);
|
||||
invalidatetile(TILE_ANIM, 0, 1 << 4); // JBF 20031228
|
||||
tileInvalidate(TILE_ANIM, 0, 1 << 4); // JBF 20031228
|
||||
|
||||
if (VM_OnEventWithReturn(EVENT_SKIPCUTSCENE, g_player[screenpeek].ps->i, screenpeek, I_CheckAllInput()))
|
||||
{
|
||||
|
|
@ -524,9 +524,9 @@ int32_t Anim_Play(const char *fn)
|
|||
else
|
||||
z = divscale16(lrint(320 * ydim * anim->frameaspect1), lrint(tilesiz[TILE_ANIM].y * xdim * anim->frameaspect2));
|
||||
int32_t aspect = divscale16(lrint(tilesiz[TILE_ANIM].y * anim->frameaspect2), lrint(tilesiz[TILE_ANIM].x * anim->frameaspect1));
|
||||
videoSetAspect(viewingrange, aspect);
|
||||
renderSetAspect(viewingrange, aspect);
|
||||
rotatesprite_fs(160<<16, 100<<16, z, 512, TILE_ANIM, 0, 0, 2|4|8|64|1024);
|
||||
videoSetAspect(viewingrange, oyxaspect);
|
||||
renderSetAspect(viewingrange, oyxaspect);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
|
|||
|
|
@ -2228,7 +2228,7 @@ static void ExtSE40Draw(int32_t spnum,int32_t x,int32_t y,int32_t z,int16_t a,in
|
|||
|
||||
drawrooms(x+offx,y+offy,z+offz,a,h,sprite[floor2].sectnum);
|
||||
ExtAnalyzeSprites(0,0,0,0);
|
||||
drawmasks();
|
||||
renderDrawMasks();
|
||||
M32_ResetFakeRORTiles();
|
||||
|
||||
if (draw_both)
|
||||
|
|
@ -2254,7 +2254,7 @@ static void ExtSE40Draw(int32_t spnum,int32_t x,int32_t y,int32_t z,int16_t a,in
|
|||
// Now re-draw
|
||||
drawrooms(x+offx,y+offy,z+offz,a,h,sprite[floor2].sectnum);
|
||||
ExtAnalyzeSprites(0,0,0,0);
|
||||
drawmasks();
|
||||
renderDrawMasks();
|
||||
M32_ResetFakeRORTiles();
|
||||
}
|
||||
|
||||
|
|
@ -2703,7 +2703,7 @@ static int32_t m32gettile(int32_t idInitialTile)
|
|||
if (handleevents())
|
||||
quitevent = 0;
|
||||
}
|
||||
getmousevalues(&mousedx,&mousedy,&bstatus);
|
||||
mouseGetValues(&mousedx,&mousedy,&bstatus);
|
||||
|
||||
iLastTile = tileNum;
|
||||
|
||||
|
|
@ -3271,7 +3271,7 @@ static int32_t OnSelectTile(int32_t tileNum)
|
|||
|
||||
keyFlushChars();
|
||||
|
||||
setpolymost2dview();
|
||||
polymostSet2dView();
|
||||
#ifdef USE_OPENGL
|
||||
if (videoGetRenderMode() >= REND_POLYMOST)
|
||||
{
|
||||
|
|
@ -3409,7 +3409,7 @@ static void tilescreen_drawbox(int32_t iTopLeft, int32_t iSelected, int32_t nXTi
|
|||
|
||||
char markedcol = editorcolors[14];
|
||||
|
||||
setpolymost2dview();
|
||||
polymostSet2dView();
|
||||
|
||||
y1=max(y1, 0);
|
||||
y2=min(y2, ydim-1);
|
||||
|
|
@ -3505,7 +3505,7 @@ static int32_t DrawTiles(int32_t iTopLeft, int32_t iSelected, int32_t nXTiles, i
|
|||
static uint8_t loadedhitile[(MAXTILES+7)>>3];
|
||||
|
||||
#ifdef USE_OPENGL
|
||||
setpolymost2dview();
|
||||
polymostSet2dView();
|
||||
|
||||
if (videoGetRenderMode() >= REND_POLYMOST)
|
||||
{
|
||||
|
|
@ -3670,10 +3670,10 @@ static void drawtileinfo(const char *title,int32_t x,int32_t y,int32_t picnum,in
|
|||
const int32_t scale = (int32_t)(65536.0/scalediv);
|
||||
|
||||
const int32_t oviewingrange=viewingrange, oyxaspect=yxaspect;
|
||||
videoSetAspect(65536, divscale16(ydim*320, xdim*200));
|
||||
renderSetAspect(65536, divscale16(ydim*320, xdim*200));
|
||||
// +1024: prevents rotatesprite from setting aspect itself
|
||||
rotatesprite_fs((x1+13)<<16,(y+11)<<16,scale,0, picnum,shade,pal, 2+1024);
|
||||
videoSetAspect(oviewingrange, oyxaspect);
|
||||
renderSetAspect(oviewingrange, oyxaspect);
|
||||
}
|
||||
|
||||
x = (int32_t)(x * xdimgame/320.0);
|
||||
|
|
@ -8481,7 +8481,7 @@ static int32_t osdcmd_quit(osdfuncparm_t const * const UNUSED(parm))
|
|||
OSD_ShowDisplay(0);
|
||||
|
||||
ExtUnInit();
|
||||
uninitengine();
|
||||
engineUnInit();
|
||||
|
||||
Bfflush(NULL);
|
||||
|
||||
|
|
@ -10031,7 +10031,7 @@ int32_t ExtPostStartupWindow(void)
|
|||
if (!g_useCwd)
|
||||
G_CleanupSearchPaths();
|
||||
|
||||
if (initengine())
|
||||
if (engineInit())
|
||||
{
|
||||
initprintf("There was a problem initializing the engine.\n");
|
||||
return -1;
|
||||
|
|
@ -10393,7 +10393,7 @@ void ExtPreCheckKeys(void) // just before drawrooms
|
|||
|
||||
if (m32_sideview)
|
||||
{
|
||||
screencoords(&xp1, &yp1, sprite[i].x-pos.x, sprite[i].y-pos.y, zoom);
|
||||
editorGet2dScreenCoordinates(&xp1, &yp1, sprite[i].x-pos.x, sprite[i].y-pos.y, zoom);
|
||||
yp1 += midydim16 + getscreenvdisp(sprite[i].z-pos.z, zoom);
|
||||
yp1 -= mulscale14(tilesiz[picnum].y<<2, zoom);
|
||||
xp1 += halfxdim16;
|
||||
|
|
@ -10409,10 +10409,10 @@ void ExtPreCheckKeys(void) // just before drawrooms
|
|||
continue;
|
||||
|
||||
const int32_t oviewingrange=viewingrange, oyxaspect=yxaspect;
|
||||
videoSetAspect(yxaspect, divscale16(sprite[i].yrepeat, sprite[i].xrepeat));
|
||||
renderSetAspect(yxaspect, divscale16(sprite[i].yrepeat, sprite[i].xrepeat));
|
||||
rotatesprite(xp1<<16,yp1<<16,zoom<<5,daang,picnum,
|
||||
shade,sprite[i].pal,flags|1024,0,0,xdim-1,ydim16-1);
|
||||
videoSetAspect(oviewingrange, oyxaspect);
|
||||
renderSetAspect(oviewingrange, oyxaspect);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -10430,7 +10430,7 @@ void ExtPreCheckKeys(void) // just before drawrooms
|
|||
if (showambiencesounds==1 && sprite[i].sectnum!=cursectnum)
|
||||
continue;
|
||||
|
||||
screencoords(&xp1,&yp1, sprite[i].x-pos.x,sprite[i].y-pos.y, zoom);
|
||||
editorGet2dScreenCoordinates(&xp1,&yp1, sprite[i].x-pos.x,sprite[i].y-pos.y, zoom);
|
||||
if (m32_sideview)
|
||||
yp1 += getscreenvdisp(sprite[i].z-pos.z, zoom);
|
||||
|
||||
|
|
@ -10444,7 +10444,7 @@ void ExtPreCheckKeys(void) // just before drawrooms
|
|||
}
|
||||
else radius = mulscale14(sprite[i].hitag, zoom);
|
||||
|
||||
drawcircle16(halfxdim16+xp1, midydim16+yp1, radius, scalescreeny(16384), col);
|
||||
editorDraw2dCircle(halfxdim16+xp1, midydim16+yp1, radius, scalescreeny(16384), col);
|
||||
drawlinepat = 0xffffffff;
|
||||
}
|
||||
}
|
||||
|
|
@ -10941,7 +10941,7 @@ void ExtCheckKeys(void)
|
|||
extern int32_t engine_screenshot;
|
||||
engine_screenshot = 1;
|
||||
#else
|
||||
screencapture("captxxxx.tga", eitherSHIFT);
|
||||
videoCaptureScreen("captxxxx.tga", eitherSHIFT);
|
||||
silentmessage("Saved screenshot");
|
||||
#endif
|
||||
}
|
||||
|
|
|
|||
|
|
@ -163,19 +163,19 @@ void G_InitMultiPsky(int CLOUDYOCEAN__DYN, int MOONSKY1__DYN, int BIGORBIT1__DYN
|
|||
// set as tight as possible.)
|
||||
|
||||
// The default sky properties (all others are implicitly zero):
|
||||
psky_t *sky = E_DefinePsky(DEFAULTPSKY);
|
||||
psky_t *sky = tileSetupSky(DEFAULTPSKY);
|
||||
sky->lognumtiles = 3;
|
||||
sky->horizfrac = 32768;
|
||||
|
||||
// CLOUDYOCEAN
|
||||
// Aligns with the drawn scene horizon because it has one itself.
|
||||
sky = E_DefinePsky(CLOUDYOCEAN__DYN);
|
||||
sky = tileSetupSky(CLOUDYOCEAN__DYN);
|
||||
sky->lognumtiles = 3;
|
||||
sky->horizfrac = 65536;
|
||||
|
||||
// MOONSKY1
|
||||
// earth mountain mountain sun
|
||||
sky = E_DefinePsky(MOONSKY1__DYN);
|
||||
sky = tileSetupSky(MOONSKY1__DYN);
|
||||
sky->lognumtiles = 3;
|
||||
sky->horizfrac = 32768;
|
||||
sky->tileofs[6] = 1;
|
||||
|
|
@ -185,7 +185,7 @@ void G_InitMultiPsky(int CLOUDYOCEAN__DYN, int MOONSKY1__DYN, int BIGORBIT1__DYN
|
|||
|
||||
// BIGORBIT1 // orbit
|
||||
// earth1 2 3 moon/sun
|
||||
sky = E_DefinePsky(BIGORBIT1__DYN);
|
||||
sky = tileSetupSky(BIGORBIT1__DYN);
|
||||
sky->lognumtiles = 3;
|
||||
sky->horizfrac = 32768;
|
||||
sky->tileofs[5] = 1;
|
||||
|
|
@ -195,7 +195,7 @@ void G_InitMultiPsky(int CLOUDYOCEAN__DYN, int MOONSKY1__DYN, int BIGORBIT1__DYN
|
|||
|
||||
// LA // la city
|
||||
// earth1 2 3 moon/sun
|
||||
sky = E_DefinePsky(LA__DYN);
|
||||
sky = tileSetupSky(LA__DYN);
|
||||
sky->lognumtiles = 3;
|
||||
sky->horizfrac = 16384 + 1024;
|
||||
sky->tileofs[0] = 1;
|
||||
|
|
|
|||
|
|
@ -203,7 +203,7 @@ void G_HandleSpecialKeys(void)
|
|||
if (KB_UnBoundKeyPressed(sc_F12))
|
||||
{
|
||||
KB_ClearKeyDown(sc_F12);
|
||||
screencapture(
|
||||
videoCaptureScreen(
|
||||
#ifndef EDUKE32_STANDALONE
|
||||
"duke0000.tga"
|
||||
#else
|
||||
|
|
@ -319,7 +319,7 @@ int32_t m32_numdebuglines=0;
|
|||
|
||||
static void M32_drawdebug(void)
|
||||
{
|
||||
int i, col=getclosestcol(255,255,255);
|
||||
int i, col=paletteGetClosestColor(255,255,255);
|
||||
int x=4, y=8;
|
||||
|
||||
if (m32_numdebuglines>0)
|
||||
|
|
@ -521,7 +521,7 @@ static void G_SE40(int32_t smoothratio)
|
|||
if (videoGetRenderMode() == REND_POLYMER)
|
||||
polymer_setanimatesprites(G_DoSpriteAnimations, CAMERA(pos.x), CAMERA(pos.y), fix16_to_int(CAMERA(q16ang)), smoothratio);
|
||||
#endif
|
||||
drawrooms_q16(sprite[sprite2].x + x, sprite[sprite2].y + y,
|
||||
renderDrawRoomsQ16(sprite[sprite2].x + x, sprite[sprite2].y + y,
|
||||
z + renderz, CAMERA(q16ang), CAMERA(q16horiz), sect);
|
||||
drawing_ror = 1 + level;
|
||||
|
||||
|
|
@ -529,7 +529,7 @@ static void G_SE40(int32_t smoothratio)
|
|||
G_OROR_DupeSprites(sp);
|
||||
|
||||
G_DoSpriteAnimations(CAMERA(pos.x),CAMERA(pos.y),fix16_to_int(CAMERA(q16ang)),smoothratio);
|
||||
drawmasks();
|
||||
renderDrawMasks();
|
||||
|
||||
if (level)
|
||||
{
|
||||
|
|
@ -606,7 +606,7 @@ void G_HandleMirror(int32_t x, int32_t y, int32_t z, fix16_t a, fix16_t q16horiz
|
|||
int32_t tposx, tposy;
|
||||
fix16_t tang;
|
||||
|
||||
preparemirror(x, y, a, g_mirrorWall[i], &tposx, &tposy, &tang);
|
||||
renderPrepareMirror(x, y, a, g_mirrorWall[i], &tposx, &tposy, &tang);
|
||||
|
||||
int32_t j = g_visibility;
|
||||
g_visibility = (j>>1) + (j>>2);
|
||||
|
|
@ -616,20 +616,20 @@ void G_HandleMirror(int32_t x, int32_t y, int32_t z, fix16_t a, fix16_t q16horiz
|
|||
int32_t didmirror;
|
||||
|
||||
yax_preparedrawrooms();
|
||||
didmirror = drawrooms_q16(tposx,tposy,z,tang,q16horiz,g_mirrorSector[i]+MAXSECTORS);
|
||||
didmirror = renderDrawRoomsQ16(tposx,tposy,z,tang,q16horiz,g_mirrorSector[i]+MAXSECTORS);
|
||||
yax_drawrooms(G_DoSpriteAnimations, g_mirrorSector[i], didmirror, smoothratio);
|
||||
}
|
||||
#ifdef USE_OPENGL
|
||||
else
|
||||
drawrooms_q16(tposx,tposy,z,tang,q16horiz,g_mirrorSector[i]+MAXSECTORS);
|
||||
renderDrawRoomsQ16(tposx,tposy,z,tang,q16horiz,g_mirrorSector[i]+MAXSECTORS);
|
||||
// XXX: Sprites don't get drawn with TROR/Polymost
|
||||
#endif
|
||||
display_mirror = 1;
|
||||
G_DoSpriteAnimations(tposx,tposy,fix16_to_int(tang),smoothratio);
|
||||
display_mirror = 0;
|
||||
|
||||
drawmasks();
|
||||
completemirror(); //Reverse screen x-wise in this function
|
||||
renderDrawMasks();
|
||||
renderCompleteMirror(); //Reverse screen x-wise in this function
|
||||
g_visibility = j;
|
||||
}
|
||||
|
||||
|
|
@ -680,7 +680,7 @@ static void G_ReadGLFrame(void)
|
|||
for (x = 0; x < 320; x++)
|
||||
{
|
||||
const palette_t *pix = &frame[base + mulscale16(x, xf) + (xdim-(ydim*4/3))/2];
|
||||
pic[320 * y + x] = getclosestcol(pix->r, pix->g, pix->b);
|
||||
pic[320 * y + x] = paletteGetClosestColor(pix->r, pix->g, pix->b);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -759,10 +759,10 @@ void G_DrawRooms(int32_t playerNum, int32_t smoothRatio)
|
|||
polymer_setanimatesprites(G_DoSpriteAnimations, pSprite->x, pSprite->y, fix16_to_int(CAMERA(q16ang)), smoothRatio);
|
||||
#endif
|
||||
yax_preparedrawrooms();
|
||||
drawrooms_q16(pSprite->x, pSprite->y, pSprite->z - ZOFFSET6, CAMERA(q16ang), fix16_from_int(pSprite->yvel), pSprite->sectnum);
|
||||
renderDrawRoomsQ16(pSprite->x, pSprite->y, pSprite->z - ZOFFSET6, CAMERA(q16ang), fix16_from_int(pSprite->yvel), pSprite->sectnum);
|
||||
yax_drawrooms(G_DoSpriteAnimations, pSprite->sectnum, 0, smoothRatio);
|
||||
G_DoSpriteAnimations(pSprite->x, pSprite->y, fix16_to_int(CAMERA(q16ang)), smoothRatio);
|
||||
drawmasks();
|
||||
renderDrawMasks();
|
||||
}
|
||||
}
|
||||
else
|
||||
|
|
@ -779,13 +779,13 @@ void G_DrawRooms(int32_t playerNum, int32_t smoothRatio)
|
|||
)));
|
||||
|
||||
if (!r_usenewaspect)
|
||||
videoSetAspect(vr, yxaspect);
|
||||
renderSetAspect(vr, yxaspect);
|
||||
else
|
||||
{
|
||||
viewingRange = vr;
|
||||
yxAspect = tabledivide32_noinline(65536 * ydim * 8, xdim * 5);
|
||||
|
||||
videoSetAspect(mulscale16(viewingRange,viewingrange), yxaspect);
|
||||
renderSetAspect(mulscale16(viewingRange,viewingrange), yxaspect);
|
||||
}
|
||||
|
||||
if (g_screenCapture)
|
||||
|
|
@ -795,7 +795,7 @@ void G_DrawRooms(int32_t playerNum, int32_t smoothRatio)
|
|||
cacheAllocateBlock(&waloff[TILE_SAVESHOT],200*320,&walock[TILE_SAVESHOT]);
|
||||
|
||||
if (videoGetRenderMode() == REND_CLASSIC)
|
||||
videoSetTarget(TILE_SAVESHOT, 200, 320);
|
||||
renderSetTarget(TILE_SAVESHOT, 200, 320);
|
||||
}
|
||||
else if (screenTilting)
|
||||
{
|
||||
|
|
@ -854,7 +854,7 @@ void G_DrawRooms(int32_t playerNum, int32_t smoothRatio)
|
|||
if (waloff[TILE_TILT] == 0)
|
||||
cacheAllocateBlock(&waloff[TILE_TILT], maxTiltSize, &walock[TILE_TILT]);
|
||||
|
||||
videoSetTarget(TILE_TILT, viewtilexsiz, viewtileysiz);
|
||||
renderSetTarget(TILE_TILT, viewtilexsiz, viewtileysiz);
|
||||
|
||||
if ((tang&1023) == 512)
|
||||
{
|
||||
|
|
@ -877,7 +877,7 @@ void G_DrawRooms(int32_t playerNum, int32_t smoothRatio)
|
|||
vRange = sintable[vRange + 512] * 8 + sintable[vRange] * 5;
|
||||
|
||||
// setaspect(i>>1, yxaspect);
|
||||
videoSetAspect(mulscale16(oviewingrange, vRange >> 1), yxaspect);
|
||||
renderSetAspect(mulscale16(oviewingrange, vRange >> 1), yxaspect);
|
||||
|
||||
viewingRange = vRange >> 1;
|
||||
yxAspect = tabledivide32_noinline(65536 * ydim * 8, xdim * 5);
|
||||
|
|
@ -890,7 +890,7 @@ void G_DrawRooms(int32_t playerNum, int32_t smoothRatio)
|
|||
))
|
||||
{
|
||||
#ifdef USE_OPENGL
|
||||
setrollangle(pPlayer->orotscrnang + mulscale16(((pPlayer->rotscrnang - pPlayer->orotscrnang + 1024)&2047)-1024, smoothRatio));
|
||||
renderSetRollAngle(pPlayer->orotscrnang + mulscale16(((pPlayer->rotscrnang - pPlayer->orotscrnang + 1024)&2047)-1024, smoothRatio));
|
||||
#endif
|
||||
pPlayer->orotscrnang = pPlayer->rotscrnang;
|
||||
}
|
||||
|
|
@ -1031,7 +1031,7 @@ void G_DrawRooms(int32_t playerNum, int32_t smoothRatio)
|
|||
gotpic[MIRROR>>3] |= (1<<(MIRROR&7));
|
||||
#else
|
||||
yax_preparedrawrooms();
|
||||
drawrooms_q16(CAMERA(pos.x),CAMERA(pos.y),CAMERA(pos.z),CAMERA(q16ang),CAMERA(q16horiz),CAMERA(sect));
|
||||
renderDrawRoomsQ16(CAMERA(pos.x),CAMERA(pos.y),CAMERA(pos.z),CAMERA(q16ang),CAMERA(q16horiz),CAMERA(sect));
|
||||
yax_drawrooms(G_DoSpriteAnimations, CAMERA(sect), 0, smoothRatio);
|
||||
#ifdef LEGACY_ROR
|
||||
if ((unsigned)ror_sprite < MAXSPRITES && drawing_ror == 1) // viewing from bottom
|
||||
|
|
@ -1041,7 +1041,7 @@ void G_DrawRooms(int32_t playerNum, int32_t smoothRatio)
|
|||
#ifdef LEGACY_ROR
|
||||
drawing_ror = 0;
|
||||
#endif
|
||||
drawmasks();
|
||||
renderDrawMasks();
|
||||
#endif
|
||||
}
|
||||
|
||||
|
|
@ -1049,11 +1049,11 @@ void G_DrawRooms(int32_t playerNum, int32_t smoothRatio)
|
|||
{
|
||||
g_screenCapture = 0;
|
||||
|
||||
invalidatetile(TILE_SAVESHOT, 0, 255);
|
||||
tileInvalidate(TILE_SAVESHOT, 0, 255);
|
||||
|
||||
if (videoGetRenderMode() == REND_CLASSIC)
|
||||
{
|
||||
videoRestoreTarget();
|
||||
renderRestoreTarget();
|
||||
// walock[TILE_SAVESHOT] = 1;
|
||||
}
|
||||
#ifdef USE_OPENGL
|
||||
|
|
@ -1090,7 +1090,7 @@ void G_DrawRooms(int32_t playerNum, int32_t smoothRatio)
|
|||
}
|
||||
else
|
||||
{
|
||||
videoRestoreTarget();
|
||||
renderRestoreTarget();
|
||||
picanm[TILE_TILT].xofs = picanm[TILE_TILT].yofs = 0;
|
||||
|
||||
int tiltZoom = (tang&511);
|
||||
|
|
@ -1173,7 +1173,7 @@ void G_DrawRooms(int32_t playerNum, int32_t smoothRatio)
|
|||
if (r_usenewaspect)
|
||||
{
|
||||
newaspect_enable = 0;
|
||||
videoSetAspect(viewingRange, yxAspect);
|
||||
renderSetAspect(viewingRange, yxAspect);
|
||||
}
|
||||
|
||||
VM_OnEvent(EVENT_DISPLAYROOMSEND, g_player[screenpeek].ps->i, screenpeek);
|
||||
|
|
@ -5621,7 +5621,7 @@ void G_Shutdown(void)
|
|||
S_MusicShutdown();
|
||||
CONTROL_Shutdown();
|
||||
KB_Shutdown();
|
||||
uninitengine();
|
||||
engineUnInit();
|
||||
G_Cleanup();
|
||||
FreeGroups();
|
||||
OSD_Cleanup();
|
||||
|
|
@ -5845,7 +5845,7 @@ static void G_Startup(void)
|
|||
|
||||
G_CompileScripts();
|
||||
|
||||
if (initengine())
|
||||
if (engineInit())
|
||||
G_FatalEngineError();
|
||||
|
||||
#ifdef LUNATIC
|
||||
|
|
@ -6332,7 +6332,7 @@ int app_main(int argc, char const * const * argv)
|
|||
}
|
||||
#endif
|
||||
|
||||
if (preinitengine())
|
||||
if (enginePreInit())
|
||||
{
|
||||
wm_msgbox("Build Engine Initialization Error",
|
||||
"There was a problem initializing the Build engine: %s", engineerrstr);
|
||||
|
|
@ -6350,7 +6350,7 @@ int app_main(int argc, char const * const * argv)
|
|||
{
|
||||
if (quitevent || !startwin_run())
|
||||
{
|
||||
uninitengine();
|
||||
engineUnInit();
|
||||
Bexit(0);
|
||||
}
|
||||
}
|
||||
|
|
@ -6454,7 +6454,7 @@ int app_main(int argc, char const * const * argv)
|
|||
free(m);
|
||||
g_defModules.clear();
|
||||
|
||||
if (E_PostInit())
|
||||
if (enginePostInit())
|
||||
G_FatalEngineError();
|
||||
|
||||
G_PostLoadPalette();
|
||||
|
|
@ -6503,7 +6503,7 @@ int app_main(int argc, char const * const * argv)
|
|||
if (CONTROL_Startup(controltype_keyboardandmouse, &BGetTime, TICRATE))
|
||||
{
|
||||
ERRprintf("There was an error initializing the CONTROL system.\n");
|
||||
uninitengine();
|
||||
engineUnInit();
|
||||
Bexit(5);
|
||||
}
|
||||
|
||||
|
|
@ -6520,7 +6520,7 @@ int app_main(int argc, char const * const * argv)
|
|||
}
|
||||
|
||||
#ifdef HAVE_CLIPSHAPE_FEATURE
|
||||
int const clipMapError = clipmapinfo_load();
|
||||
int const clipMapError = engineLoadClipMaps();
|
||||
if (clipMapError > 0)
|
||||
initprintf("There was an error loading the sprite clipping map (status %d).\n", clipMapError);
|
||||
|
||||
|
|
|
|||
|
|
@ -1244,13 +1244,13 @@ LUNATIC_EXTERN void G_ShowView(vec3_t vec, fix16_t a, fix16_t horiz, int32_t sec
|
|||
polymer_setanimatesprites(G_DoSpriteAnimations, vec.x, vec.y, fix16_to_int(a), smoothratio);
|
||||
#endif
|
||||
yax_preparedrawrooms();
|
||||
drawrooms_q16(vec.x, vec.y, vec.z, a, horiz, sect);
|
||||
renderDrawRoomsQ16(vec.x, vec.y, vec.z, a, horiz, sect);
|
||||
yax_drawrooms(G_DoSpriteAnimations, sect, 0, smoothratio);
|
||||
|
||||
display_mirror = 2;
|
||||
G_DoSpriteAnimations(vec.x, vec.y, fix16_to_int(a), smoothratio);
|
||||
display_mirror = 0;
|
||||
drawmasks();
|
||||
renderDrawMasks();
|
||||
G_RestoreInterpolations();
|
||||
G_UpdateScreenArea();
|
||||
}
|
||||
|
|
@ -1975,7 +1975,7 @@ skip_check:
|
|||
insptr++;
|
||||
{
|
||||
int const xRange = Gv_GetVarX(*insptr++);
|
||||
videoSetAspect(xRange, Gv_GetVarX(*insptr++));
|
||||
renderSetAspect(xRange, Gv_GetVarX(*insptr++));
|
||||
break;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -2277,7 +2277,7 @@ badindex:
|
|||
insptr++;
|
||||
{
|
||||
int32_t r = Gv_GetVarX(*insptr++), g = Gv_GetVarX(*insptr++), b = Gv_GetVarX(*insptr++);
|
||||
Gv_SetVarX(*insptr++, getclosestcol(r, g, b));
|
||||
Gv_SetVarX(*insptr++, paletteGetClosestColor(r, g, b));
|
||||
continue;
|
||||
}
|
||||
|
||||
|
|
@ -2899,7 +2899,7 @@ dodefault:
|
|||
if (daxrange > (1<<20)) daxrange = (1<<20);
|
||||
if (dayxaspect < (1<<12)) dayxaspect = (1<<12);
|
||||
if (dayxaspect > (1<<20)) dayxaspect = (1<<20);
|
||||
videoSetAspect(daxrange, dayxaspect);
|
||||
renderSetAspect(daxrange, dayxaspect);
|
||||
continue;
|
||||
}
|
||||
|
||||
|
|
@ -3021,8 +3021,8 @@ dodefault:
|
|||
|
||||
if (tw==CON_DRAWLINE16B || tw==CON_DRAWLINE16Z)
|
||||
{
|
||||
screencoords(&x1,&y1, x1-pos.x,y1-pos.y, zoom);
|
||||
screencoords(&x2,&y2, x2-pos.x,y2-pos.y, zoom);
|
||||
editorGet2dScreenCoordinates(&x1,&y1, x1-pos.x,y1-pos.y, zoom);
|
||||
editorGet2dScreenCoordinates(&x2,&y2, x2-pos.x,y2-pos.y, zoom);
|
||||
|
||||
if (tw==CON_DRAWLINE16Z && m32_sideview)
|
||||
{
|
||||
|
|
@ -3035,7 +3035,7 @@ dodefault:
|
|||
}
|
||||
|
||||
drawlinepat = m32_drawlinepat;
|
||||
drawline16(xofs+x1,yofs+y1, xofs+x2,yofs+y2, col>=0?editorcolors[col&15]:((-col)&255));
|
||||
editorDraw2dLine(xofs+x1,yofs+y1, xofs+x2,yofs+y2, col>=0?editorcolors[col&15]:((-col)&255));
|
||||
drawlinepat = odrawlinepat;
|
||||
continue;
|
||||
}
|
||||
|
|
@ -3053,7 +3053,7 @@ dodefault:
|
|||
|
||||
if (tw==CON_DRAWCIRCLE16B || tw==CON_DRAWCIRCLE16Z)
|
||||
{
|
||||
screencoords(&x1,&y1, x1-pos.x,y1-pos.y, zoom);
|
||||
editorGet2dScreenCoordinates(&x1,&y1, x1-pos.x,y1-pos.y, zoom);
|
||||
if (m32_sideview)
|
||||
y1 += getscreenvdisp(z1-pos.z, zoom);
|
||||
r = mulscale14(r,zoom);
|
||||
|
|
@ -3063,7 +3063,7 @@ dodefault:
|
|||
}
|
||||
|
||||
drawlinepat = m32_drawlinepat;
|
||||
drawcircle16(xofs+x1, yofs+y1, r, eccen, col>=0?editorcolors[col&15]:((-col)&255));
|
||||
editorDraw2dCircle(xofs+x1, yofs+y1, r, eccen, col>=0?editorcolors[col&15]:((-col)&255));
|
||||
drawlinepat = odrawlinepat;
|
||||
continue;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3045,7 +3045,7 @@ static void Menu_EntryLinkActivate(MenuEntry_t *entry)
|
|||
{
|
||||
if (videoSetGameMode(p.flags, p.xdim, p.ydim, p.bppmax) < 0)
|
||||
{
|
||||
setrendermode(prend);
|
||||
videoSetRenderMode(prend);
|
||||
G_GameExit("Failed restoring old video mode.");
|
||||
}
|
||||
else
|
||||
|
|
@ -3058,7 +3058,7 @@ static void Menu_EntryLinkActivate(MenuEntry_t *entry)
|
|||
|
||||
g_restorePalette = -1;
|
||||
G_UpdateScreenArea();
|
||||
setrendermode(nrend);
|
||||
videoSetRenderMode(nrend);
|
||||
vsync = videoSetVsync(nvsync);
|
||||
ud.config.ScreenMode = fullscreen;
|
||||
ud.config.ScreenWidth = xdim;
|
||||
|
|
@ -6964,7 +6964,7 @@ void M_DisplayMenus(void)
|
|||
int32_t alpha;
|
||||
if (KXDWN)
|
||||
{
|
||||
videoSetAspect(viewingrange, 65536);
|
||||
renderSetAspect(viewingrange, 65536);
|
||||
cursorpos.x = scale(cursorpos.x - (320<<15), ydim << 2, xdim * 3) + (320<<15);
|
||||
cursorpos.y = scale(cursorpos.y - (200<<15), (ydim << 2) * 6, (xdim * 3) * 5) + (200<<15);
|
||||
z = scale(32768, ydim << 2, xdim * 3);
|
||||
|
|
@ -6980,7 +6980,7 @@ void M_DisplayMenus(void)
|
|||
rotatesprite_fs_alpha(cursorpos.x, cursorpos.y, z, 0, a, 0, p, o, alpha);
|
||||
|
||||
if (KXDWN)
|
||||
videoSetAspect(viewingrange, oyxaspect);
|
||||
renderSetAspect(viewingrange, oyxaspect);
|
||||
}
|
||||
}
|
||||
else
|
||||
|
|
|
|||
|
|
@ -1229,8 +1229,8 @@ static int32_t osdcmd_screenshot(osdfuncparm_t const * const parm)
|
|||
#endif
|
||||
|
||||
if (parm->numparms == 1 && !Bstrcasecmp(parm->parms[0], "tga"))
|
||||
screencapture_tga(fn, 0);
|
||||
else screencapture(fn, 0);
|
||||
videoCaptureScreenTGA(fn, 0);
|
||||
else videoCaptureScreen(fn, 0);
|
||||
|
||||
return OSDCMD_OK;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -149,7 +149,7 @@ void GAME_clearbackground(int32_t numcols, int32_t numrows)
|
|||
polymost_setFogEnabled(false);
|
||||
polymost_useColorOnly(true);
|
||||
|
||||
setpolymost2dview();
|
||||
polymostSet2dView();
|
||||
glColor4f(0.f, 0.f, 0.f, 0.67f);
|
||||
glEnable(GL_BLEND);
|
||||
glRecti(0, 0, xdim, i8n8+OSDCHAR_HEIGHT);
|
||||
|
|
|
|||
|
|
@ -1676,7 +1676,7 @@ static void G_FadeLoad(int32_t r, int32_t g, int32_t b, int32_t start, int32_t e
|
|||
|
||||
static int G_TryMapHack(const char *mhkfile)
|
||||
{
|
||||
int32_t failure = loadmaphack(mhkfile);
|
||||
int32_t failure = engineLoadMHK(mhkfile);
|
||||
|
||||
if (!failure)
|
||||
initprintf("Loaded map hack file \"%s\"\n", mhkfile);
|
||||
|
|
@ -1852,7 +1852,7 @@ int G_EnterLevel(int gameMode)
|
|||
|
||||
if (!VOLUMEONE && Menu_HaveUserMap())
|
||||
{
|
||||
if (loadboard(boardfilename, 0, &pPlayer->pos, &lbang, &pPlayer->cursectnum) < 0)
|
||||
if (engineLoadBoard(boardfilename, 0, &pPlayer->pos, &lbang, &pPlayer->cursectnum) < 0)
|
||||
{
|
||||
OSD_Printf(OSD_ERROR "Map \"%s\" not found or invalid map version!\n", boardfilename);
|
||||
return 1;
|
||||
|
|
@ -1861,7 +1861,7 @@ int G_EnterLevel(int gameMode)
|
|||
G_LoadMapHack(levelName, boardfilename);
|
||||
G_SetupFilenameBasedMusic(levelName, boardfilename, ud.m_level_number);
|
||||
}
|
||||
else if (loadboard(g_mapInfo[mii].filename, VOLUMEONE, &pPlayer->pos, &lbang, &pPlayer->cursectnum) < 0)
|
||||
else if (engineLoadBoard(g_mapInfo[mii].filename, VOLUMEONE, &pPlayer->pos, &lbang, &pPlayer->cursectnum) < 0)
|
||||
{
|
||||
OSD_Printf(OSD_ERROR "Map \"%s\" not found or invalid map version!\n", g_mapInfo[mii].filename);
|
||||
return 1;
|
||||
|
|
|
|||
|
|
@ -309,7 +309,7 @@ int32_t G_LoadSaveHeaderNew(char const *fn, savehead_t *saveh)
|
|||
{
|
||||
Bmemset((char *)waloff[TILE_LOADSHOT], 0, 320*200);
|
||||
}
|
||||
invalidatetile(TILE_LOADSHOT, 0, 255);
|
||||
tileInvalidate(TILE_LOADSHOT, 0, 255);
|
||||
|
||||
kclose(fil);
|
||||
return 0;
|
||||
|
|
@ -392,7 +392,7 @@ int32_t G_LoadPlayer(savebrief_t & sv)
|
|||
{
|
||||
artSetupMapArt(currentboardfilename);
|
||||
append_ext_UNSAFE(currentboardfilename, ".mhk");
|
||||
loadmaphack(currentboardfilename);
|
||||
engineLoadMHK(currentboardfilename);
|
||||
}
|
||||
|
||||
Bmemcpy(currentboardfilename, boardfilename, BMAX_PATH);
|
||||
|
|
|
|||
|
|
@ -158,8 +158,8 @@ void G_SetCrosshairColor(int32_t r, int32_t g, int32_t b)
|
|||
if (ii <= 0) return;
|
||||
|
||||
if (videoGetRenderMode() == REND_CLASSIC)
|
||||
i = getclosestcol(CrosshairColors.r, CrosshairColors.g, CrosshairColors.b);
|
||||
else i = getclosestcol(255, 255, 255); // use white in GL so we can tint it to the right color
|
||||
i = paletteGetClosestColor(CrosshairColors.r, CrosshairColors.g, CrosshairColors.b);
|
||||
else i = paletteGetClosestColor(255, 255, 255); // use white in GL so we can tint it to the right color
|
||||
|
||||
do
|
||||
{
|
||||
|
|
@ -178,7 +178,7 @@ void G_SetCrosshairColor(int32_t r, int32_t g, int32_t b)
|
|||
crosshairtint.b = CrosshairColors.b;
|
||||
crosshairtint.f = HICTINT_USEONART | HICTINT_GRAYSCALE;
|
||||
#endif
|
||||
invalidatetile(CROSSHAIR, -1, -1);
|
||||
tileInvalidate(CROSSHAIR, -1, -1);
|
||||
}
|
||||
|
||||
#define SCORESHEETOFFSET -20
|
||||
|
|
@ -329,7 +329,7 @@ static void G_DrawOverheadMap(int32_t cposx, int32_t cposy, int32_t czoom, int16
|
|||
|
||||
int32_t tmpydim = (xdim*5)/8;
|
||||
|
||||
videoSetAspect(65536, divscale16(tmpydim*320, xdim*200));
|
||||
renderSetAspect(65536, divscale16(tmpydim*320, xdim*200));
|
||||
|
||||
xvect = sintable[(-cang)&2047] * czoom;
|
||||
yvect = sintable[(1536-cang)&2047] * czoom;
|
||||
|
|
@ -1068,7 +1068,7 @@ void G_DisplayRest(int32_t smoothratio)
|
|||
if (ud.overhead_on == 2)
|
||||
{
|
||||
videoClearViewableArea(0L);
|
||||
drawmapview(cposx, cposy, pp->zoom, cang);
|
||||
renderDrawMapView(cposx, cposy, pp->zoom, cang);
|
||||
}
|
||||
G_DrawOverheadMap(cposx, cposy, pp->zoom, cang);
|
||||
|
||||
|
|
@ -1173,13 +1173,13 @@ void G_DisplayRest(int32_t smoothratio)
|
|||
crosshair_scale = scale(crosshair_scale, ydim << 2, xdim * 3) >> 1;
|
||||
crosshair_pal = 0;
|
||||
crosshair_o |= 1024;
|
||||
videoSetAspect(viewingrange, 65536);
|
||||
renderSetAspect(viewingrange, 65536);
|
||||
}
|
||||
|
||||
rotatesprite_win(crosshairpos.x, crosshairpos.y, crosshair_scale, 0, a, 0, crosshair_pal, crosshair_o);
|
||||
|
||||
if (KXDWN)
|
||||
videoSetAspect(viewingrange, oyxaspect);
|
||||
renderSetAspect(viewingrange, oyxaspect);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1204,13 +1204,13 @@ void G_DisplayRest(int32_t smoothratio)
|
|||
pointer_scale = scale(pointer_scale, ydim << 2, xdim * 3) >> 1;
|
||||
pointer_pal = 0;
|
||||
pointer_o |= 1024;
|
||||
videoSetAspect(viewingrange, 65536);
|
||||
renderSetAspect(viewingrange, 65536);
|
||||
}
|
||||
|
||||
rotatesprite_win(pointerpos.x, pointerpos.y, pointer_scale, 0, a, 0, pointer_pal, pointer_o);
|
||||
|
||||
if (KXDWN)
|
||||
videoSetAspect(viewingrange, oyxaspect);
|
||||
renderSetAspect(viewingrange, oyxaspect);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
|
@ -1233,7 +1233,7 @@ void G_DisplayRest(int32_t smoothratio)
|
|||
{
|
||||
int32_t vr=viewingrange, asp=yxaspect;
|
||||
VM_OnEvent_(EVENT_DISPLAYREST, g_player[screenpeek].ps->i, screenpeek);
|
||||
videoSetAspect(vr, asp);
|
||||
renderSetAspect(vr, asp);
|
||||
}
|
||||
|
||||
if (ud.pause_on==1 && (g_player[myconnectindex].ps->gm&MODE_MENU) == 0)
|
||||
|
|
|
|||
|
|
@ -380,7 +380,7 @@ static void G_SetupCamTile(int spriteNum, int tileNum, int smoothRatio)
|
|||
int const saveMirror = display_mirror;
|
||||
|
||||
//if (waloff[wn] == 0) loadtile(wn);
|
||||
videoSetTarget(tileNum, tilesiz[tileNum].y, tilesiz[tileNum].x);
|
||||
renderSetTarget(tileNum, tilesiz[tileNum].y, tilesiz[tileNum].x);
|
||||
|
||||
yax_preparedrawrooms();
|
||||
drawrooms(camera.x, camera.y, camera.z, SA(spriteNum), 100 + sprite[spriteNum].shade, SECT(spriteNum));
|
||||
|
|
@ -389,11 +389,11 @@ static void G_SetupCamTile(int spriteNum, int tileNum, int smoothRatio)
|
|||
display_mirror = 3;
|
||||
G_DoSpriteAnimations(camera.x, camera.y, SA(spriteNum), smoothRatio);
|
||||
display_mirror = saveMirror;
|
||||
drawmasks();
|
||||
renderDrawMasks();
|
||||
|
||||
videoRestoreTarget();
|
||||
renderRestoreTarget();
|
||||
squarerotatetile(tileNum);
|
||||
invalidatetile(tileNum, -1, 255);
|
||||
tileInvalidate(tileNum, -1, 255);
|
||||
}
|
||||
|
||||
void G_AnimateCamSprite(int smoothRatio)
|
||||
|
|
|
|||
Loading…
Reference in a new issue