diff --git a/Makefile.linux b/Makefile.linux index 32edccae54..43ed51005e 100644 --- a/Makefile.linux +++ b/Makefile.linux @@ -1,6 +1,7 @@ # created on 4/12/2006 by James Bentler CXX ?= g++ CC ?= gcc +NASM ?= nasm ifndef DEBUG CFLAGS ?= -pipe -Wall -Wno-unused -O2 -fomit-frame-pointer else @@ -9,8 +10,6 @@ endif CFLAGS += -DHAVE_FILELENGTH -D__forceinline=inline -Izlib -IFLAC `sdl-config --cflags` CFLAGS += -Dstricmp=strcasecmp -Dstrnicmp=strncasecmp -DNEED_STRUPR LDFLAGS += -lFLAC++ -lFLAC -lz -lfmod `sdl-config --libs` - -NASM ?= nasm NASMFLAGS += -f elf -DM_TARGET_LINUX SRCDIRS = src/ $(addprefix src/,g_doom/ g_heretic/ g_hexen/ g_raven/ g_shared/ g_strife/ oplsynth/ sound/ sdl/) @@ -44,6 +43,7 @@ ifndef DEBUG else OBJDIR = $(DEBUGOBJ) CFLAGS += -D_DEBUG -g3 + NASMFLAGS += -g ZDOOMBIN = $(ZDOOMDEBUG) endif CXXFLAGS += $(CFLAGS) @@ -72,7 +72,7 @@ _obj_: _src_ $(CC) -c $(CFLAGS) -o _obj_ -c _src_ endef -all: $(ZDOOMBIN) zdoom.wad +all: $(ZDOOMBIN) toolsandpk3 zdoom.pk3 $(ZDOOMBIN): $(OBJDIR) $(if $(RESTART),deps) $(OBJS) ifndef RESTART @@ -110,10 +110,22 @@ endif $(OBJDIR): mkdir $(OBJDIR) -zdoom.wad: - make -C wadsrc/ -f Makefile +toolsandpk3: tools/makewad/makewad tools/dehsupp/dehsupp tools/xlatcc/xlatcc + make -C wadsrc/ -.PHONY : clean cleandeps cleanobjs distclean deps +zdoom.pk3: toolsandpk3 + ln -sf wadsrc/zdoom.pk3 ./ + +tools/makewad/makewad: + make -C tools/makewad/ + +tools/dehsupp/dehsupp: + make -C tools/dehsupp/ + +tools/xlatcc/xlatcc: + make -C tools/xlatcc/ + +.PHONY : clean cleandeps cleanobjs distclean deps toolsandpk3 clean: cleanobjs rm -f $(ZDOOMDEBUG) $(ZDOOM) $(ZDOOM).map diff --git a/docs/rh-log.txt b/docs/rh-log.txt index ed96483ad0..4761e8a190 100644 --- a/docs/rh-log.txt +++ b/docs/rh-log.txt @@ -1,3 +1,15 @@ +May 9, 2006 +- Updated Jim's Makefile.linux. +- Added support for wrapping midtextures vertically. +- Since zdoom.wad is now zdoom.pk3, the default mapinfos can use full pathnames. + So now they do. +- Fixed: The DSimpleCanvas constructor used a pitch too narrow on screens wider + than 640 pixels when using a non-AMD processor and the processor's L1 cache + line size could not be determined. I think this should fix the issue of + weirdly rendered 8 pixel wide borders on the left and right of the screen that + some people experienced. +- Fixed: The secnodes were never freed. + May 9, 2006 (Changes by Graf Zahl) - Fixed: The FSpecialFont constructor created the name string twice. - Fixed: The animated door parser was still leaking memory when it encountered diff --git a/src/a.nas b/src/a.nas index d2d6dae533..6ee89f362f 100644 --- a/src/a.nas +++ b/src/a.nas @@ -22,6 +22,10 @@ %define prevlineasm1 _prevlineasm1 %define vlineasm1 _vlineasm1 %define vlineasm4 _vlineasm4 + +%define setupmvlineasm _setupmvlineasm +%define mvlineasm1 _mvlineasm1 +%define mvlineasm4 _mvlineasm4 %endif EXTERN ylookup ; near @@ -38,14 +42,20 @@ EXTERN dc_dest EXTERN dc_source EXTERN dc_texturefrac +mvlineasm4_counter: + dd 0 + SECTION .text ALIGN 16 GLOBAL setvlinebpl_ setvlinebpl_: - mov dword [fixchain1a+2], eax - mov dword [fixchain1b+2], eax - mov dword [fixchain2a+2], eax + mov [fixchain1a+2], eax + mov [fixchain1b+2], eax + mov [fixchain2a+2], eax + mov [fixchain1m+2], eax + mov [fixchain2ma+2], eax + mov [fixchain2mb+2], eax ret ; pass it log2(texheight) @@ -242,9 +252,6 @@ machvsh12: rol ebx, 88h ;sh mov ecx, esi jmp short beginvlineasm4 ALIGN 16 - nop - nop - nop beginvlineasm4: machvsh1: shr ecx, 88h ;32-sh mov ebx, esi @@ -300,3 +307,226 @@ machvsh8: shl edx, 88h ;16-sh pop ebx pop ebp ret + +;************************************************************************* +;************************* Masked Vertical Lines ************************* +;************************************************************************* + +; pass it log2(texheight) + +ALIGN 16 +GLOBAL setupmvlineasm +setupmvlineasm: + mov ecx, dword [esp+4] + mov byte [maskmach3a+2], cl + mov byte [machmv13+2], cl + mov byte [machmv14+2], cl + mov byte [machmv15+2], cl + mov byte [machmv16+2], cl + ret + +ALIGN 16 +GLOBAL mvlineasm1 ;Masked vline +mvlineasm1: + push ebx + push edi + push esi + push ebp + mov ecx, [dc_count] + mov ebp, [dc_colormap] + mov edi, [dc_dest] + mov eax, [dc_iscale] + mov edx, [dc_texturefrac] + mov esi, [dc_source] +beginmvline: + mov ebx, edx +maskmach3a: shr ebx, 32 + mov bl, byte [esi+ebx] + cmp bl, 0 + je short skipmask1 +maskmach3c: mov bl, byte [ebp+ebx] + mov [edi], bl +skipmask1: add edx, eax +fixchain1m: add edi, 320 + dec ecx + jnz short beginmvline + + pop ebp + pop esi + pop edi + pop ebx + mov eax, edx + ret + +ALIGN 16 +GLOBAL mvlineasm4 +mvlineasm4: + push ebx + push esi + push edi + push ebp + + mov ecx,[dc_count] + mov edi,[dc_dest] + + mov eax, [bufplce+0] + mov ebx, [bufplce+4] + mov [machmv1+2], eax + mov [machmv4+2], ebx + mov eax, [bufplce+8] + mov ebx, [bufplce+12] + mov [machmv7+2], eax + mov [machmv10+2], ebx + + mov eax, [palookupoffse] + mov ebx, [palookupoffse+4] + mov [machmv2+2], eax + mov [machmv5+2], ebx + mov eax, [palookupoffse+8] + mov ebx, [palookupoffse+12] + mov [machmv8+2], eax + mov [machmv11+2], ebx + + mov eax, [vince] ;vince + mov ebx, [vince+4] + xor al, al + xor bl, bl + mov [machmv3+2], eax + mov [machmv6+2], ebx + mov eax, [vince+8] + mov ebx, [vince+12] + mov [machmv9+2], eax + mov [machmv12+2], ebx + + inc ecx + push ecx + mov ecx, [vplce+0] + mov edx, [vplce+4] + mov esi, [vplce+8] + mov ebp, [vplce+12] +fixchain2ma: sub edi, 320 + + jmp short beginmvlineasm4 +ALIGN 16 +beginmvlineasm4: + dec dword [esp] + jz near endmvlineasm4 + + mov eax, ebp + mov ebx, esi +machmv16: shr eax, 32 +machmv15: shr ebx, 32 +machmv12: add ebp, 0x88888888 ;vince[3] +machmv9: add esi, 0x88888888 ;vince[2] +machmv10: mov al, [eax+0x88888888] ;bufplce[3] +machmv7: mov bl, [ebx+0x88888888] ;bufplce[2] + cmp al, 1 + adc dl, dl + cmp bl, 1 + adc dl, dl +machmv8: mov bl, [ebx+0x88888888] ;palookupoffs[2] +machmv11: mov bh, [eax+0x88888888] ;palookupoffs[3] + + mov eax, edx +machmv14: shr eax, 32 + shl ebx, 16 +machmv4: mov al, [eax+0x88888888] ;bufplce[1] + cmp al, 1 + adc dl, dl +machmv6: add edx, 0x88888888 ;vince[1] +machmv5: mov bh, [eax+0x88888888] ;palookupoffs[1] + + mov eax, ecx +machmv13: shr eax, 32 +machmv3: add ecx, 0x88888888 ;vince[0] +machmv1: mov al, [eax+0x88888888] ;bufplce[0] + cmp al, 1 + adc dl, dl +machmv2: mov bl, [eax+0x88888888] ;palookupoffs[0] + + shl dl, 4 + xor eax, eax +fixchain2mb: add edi, 320 + mov al, dl + add eax, mvcase15 + jmp eax ;16 byte cases + +ALIGN 16 +endmvlineasm4: + mov [_vplce], ecx + mov [_vplce+4], edx + mov [_vplce+8], esi + mov [_vplce+12], ebp + pop ecx + pop ebp + pop edi + pop esi + pop ebx + ret + + ;5,7,8,8,11,13,12,14,11,13,14,14,12,14,15,7 +ALIGN 16 +mvcase15: mov [edi], ebx + jmp beginmvlineasm4 +ALIGN 16 +mvcase14: mov [edi+1], bh + shr ebx, 16 + mov [edi+2], bx + jmp beginmvlineasm4 +ALIGN 16 +mvcase13: mov [edi], bl + shr ebx, 16 + mov [edi+2], bx + jmp beginmvlineasm4 +ALIGN 16 +mvcase12: shr ebx, 16 + mov [edi+2], bx + jmp beginmvlineasm4 +ALIGN 16 +mvcase11: mov [edi], bx + shr ebx, 16 + mov [edi+3], bh + jmp beginmvlineasm4 +ALIGN 16 +mvcase10: mov [edi+1], bh + shr ebx, 16 + mov [edi+3], bh + jmp beginmvlineasm4 +ALIGN 16 +mvcase9: mov [edi], bl + shr ebx, 16 + mov [edi+3], bh + jmp beginmvlineasm4 +ALIGN 16 +mvcase8: shr ebx, 16 + mov [edi+3], bh + jmp beginmvlineasm4 +ALIGN 16 +mvcase7: mov [edi], bx + shr ebx, 16 + mov [edi+2], bl + jmp beginmvlineasm4 +ALIGN 16 +mvcase6: shr ebx, 8 + mov [edi+1], bx + jmp beginmvlineasm4 +ALIGN 16 +mvcase5: mov [edi], bl + shr ebx, 16 + mov [edi+2], bl + jmp beginmvlineasm4 +ALIGN 16 +mvcase4: shr ebx, 16 + mov [edi+2], bl + jmp beginmvlineasm4 +ALIGN 16 +mvcase3: mov [edi], bx + jmp beginmvlineasm4 +ALIGN 16 +mvcase2: mov [edi+1], bh + jmp beginmvlineasm4 +ALIGN 16 +mvcase1: mov [edi], bl + jmp beginmvlineasm4 +ALIGN 16 +mvcase0: jmp beginmvlineasm4 diff --git a/src/doomdata.h b/src/doomdata.h index a77e76108f..683daa2366 100644 --- a/src/doomdata.h +++ b/src/doomdata.h @@ -170,6 +170,7 @@ static inline int GET_SPAC (int flags) #define ML_RAILING 0x20000 #define ML_BLOCK_FLOATERS 0x40000 #define ML_CLIP_MIDTEX 0x80000 // Automatic for every Strife line +#define ML_WRAP_MIDTEX 0x100000 // Sector definition, from editing typedef struct diff --git a/src/g_level.cpp b/src/g_level.cpp index 2fdf713346..111dbbe3d0 100644 --- a/src/g_level.cpp +++ b/src/g_level.cpp @@ -267,6 +267,7 @@ static const char *MapInfoMapLevel[] = "sndinfo", "soundinfo", "clipmidtextures", + "wrapmidtextures", NULL }; @@ -379,6 +380,7 @@ MapHandlers[] = { MITYPE_LUMPNAME, lioffset(soundinfo), 0 }, { MITYPE_LUMPNAME, lioffset(soundinfo), 0 }, { MITYPE_SETFLAG, LEVEL_CLIPMIDTEX, 0 }, + { MITYPE_SETFLAG, LEVEL_WRAPMIDTEX, 0 }, }; static const char *MapInfoClusterLevel[] = @@ -474,30 +476,30 @@ void G_ParseMapInfo () switch (gamemission) { case doom: - G_DoParseMapInfo (Wads.GetNumForName ("D1INFO")); + G_DoParseMapInfo (Wads.GetNumForFullName ("mapinfo/doom1.txt")); break; case pack_plut: - G_DoParseMapInfo (Wads.GetNumForName ("PLUTINFO")); + G_DoParseMapInfo (Wads.GetNumForFullName ("mapinfo/plutonia.txt")); break; case pack_tnt: - G_DoParseMapInfo (Wads.GetNumForName ("TNTINFO")); + G_DoParseMapInfo (Wads.GetNumForFullName ("mapinfo/tnt.txt")); break; default: - G_DoParseMapInfo (Wads.GetNumForName ("D2INFO")); + G_DoParseMapInfo (Wads.GetNumForFullName ("mapinfo/doom2.txt")); break; } break; case GAME_Heretic: - G_DoParseMapInfo (Wads.GetNumForName ("HERINFO")); + G_DoParseMapInfo (Wads.GetNumForFullName ("mapinfo/heretic.txt")); break; case GAME_Hexen: - G_DoParseMapInfo (Wads.GetNumForName ("HEXNINFO")); + G_DoParseMapInfo (Wads.GetNumForFullName ("mapinfo/hexen.txt")); break; case GAME_Strife: - G_DoParseMapInfo (Wads.GetNumForName ("STRFINFO")); + G_DoParseMapInfo (Wads.GetNumForFullName ("mapinfo/strife.txt")); break; default: diff --git a/src/g_level.h b/src/g_level.h index 1ca4335578..80b9722959 100644 --- a/src/g_level.h +++ b/src/g_level.h @@ -101,6 +101,7 @@ #define LEVEL_MUSICDEFINED UCONST64(0x8000000000) // a marker to disable the $map command in SNDINFO for this map #define LEVEL_MONSTERFALLINGDAMAGE UCONST64(0x10000000000) #define LEVEL_CLIPMIDTEX UCONST64(0x20000000000) +#define LEVEL_WRAPMIDTEX UCONST64(0x40000000000) struct acsdefered_s; class FBehavior; diff --git a/src/p_buildmap.cpp b/src/p_buildmap.cpp index 37a304c360..36519a8136 100644 --- a/src/p_buildmap.cpp +++ b/src/p_buildmap.cpp @@ -509,6 +509,7 @@ static void LoadWalls (walltype *walls, int numwalls, sectortype *bsec) lines[j].v1 = FindVertex (walls[i].x, walls[i].y); lines[j].v2 = FindVertex (walls[walls[i].point2].x, walls[walls[i].point2].y); lines[j].frontsector = sides[i].sector; + lines[j].flags |= ML_WRAP_MIDTEX; if (walls[i].nextsector >= 0) { lines[j].backsector = sectors + walls[i].nextsector; diff --git a/src/p_map.cpp b/src/p_map.cpp index 4f96a48a9a..733b26fc03 100644 --- a/src/p_map.cpp +++ b/src/p_map.cpp @@ -4240,6 +4240,22 @@ bool P_ChangeSector (sector_t *sector, int crunch, int amt, int floorOrCeil) msecnode_t *headsecnode = NULL; +struct SecnodeKiller +{ + ~SecnodeKiller() + { + msecnode_t *node = headsecnode; + + while (node != NULL) + { + msecnode_t *next = node->m_snext; + free (node); + node = next; + } + headsecnode = NULL; + } +} KillTheSecnodes; + //============================================================================= // // P_GetSecnode diff --git a/src/p_setup.cpp b/src/p_setup.cpp index b23b537770..195e95d3a7 100644 --- a/src/p_setup.cpp +++ b/src/p_setup.cpp @@ -1477,7 +1477,8 @@ void P_LoadLineDefs (int lump) P_AdjustLine (ld); P_SaveLineSpecial (ld); - if (level.flags&LEVEL_CLIPMIDTEX) ld->flags|=ML_CLIP_MIDTEX; + if (level.flags & LEVEL_CLIPMIDTEX) ld->flags |= ML_CLIP_MIDTEX; + if (level.flags & LEVEL_WRAPMIDTEX) ld->flags |= ML_WRAP_MIDTEX; } } @@ -1548,7 +1549,8 @@ void P_LoadLineDefs2 (int lump) P_AdjustLine (ld); P_SaveLineSpecial (ld); - if (level.flags&LEVEL_CLIPMIDTEX) ld->flags|=ML_CLIP_MIDTEX; + if (level.flags & LEVEL_CLIPMIDTEX) ld->flags |= ML_CLIP_MIDTEX; + if (level.flags & LEVEL_WRAPMIDTEX) ld->flags |= ML_WRAP_MIDTEX; } } diff --git a/src/p_xlat.cpp b/src/p_xlat.cpp index 12e6cbc9e8..d15ef599e1 100644 --- a/src/p_xlat.cpp +++ b/src/p_xlat.cpp @@ -88,7 +88,6 @@ void P_TranslateLineDef (line_t *ld, maplinedef_t *mld) { flags |= ML_BLOCK_FLOATERS; } - //flags |= ML_CLIP_MIDTEX; moved to MAPINFO passthrough = 0; } else diff --git a/src/r_draw.cpp b/src/r_draw.cpp index d7792aa6df..f99d7beb1d 100644 --- a/src/r_draw.cpp +++ b/src/r_draw.cpp @@ -988,6 +988,13 @@ DWORD (STACK_ARGS *dovline1)() = vlinec1; DWORD (STACK_ARGS *doprevline1)() = vlinec1; void (STACK_ARGS *dovline4)() = vlinec4; +static DWORD STACK_ARGS mvlinec1(); +static void STACK_ARGS mvlinec4(); +static int mvlinebits; + +DWORD (STACK_ARGS *domvline1)() = mvlinec1; +void (STACK_ARGS *domvline4)() = mvlinec4; + #else extern "C" @@ -1001,11 +1008,18 @@ void STACK_ARGS vlinetallasm4 (); void STACK_ARGS vlinetallasmathlon4 (); void STACK_ARGS setupvlineasm (int); void STACK_ARGS setupvlinetallasm (int); + +DWORD STACK_ARGS mvlineasm1(); +void STACK_ARGS mvlineasm4(); +void STACK_ARGS setupmvlineasm (int); } DWORD (STACK_ARGS *dovline1)() = vlinetallasm1; DWORD (STACK_ARGS *doprevline1)() = prevlinetallasm1; void (STACK_ARGS *dovline4)() = vlinetallasm4; + +DWORD (STACK_ARGS *domvline1)() = mvlineasm1; +void (STACK_ARGS *domvline4)() = mvlineasm4; #endif void setupvline (int fracbits) @@ -1081,6 +1095,63 @@ void STACK_ARGS vlinec4 () } #endif +void setupmvline (int fracbits) +{ +#if defined(USEASM) + setupmvlineasm (fracbits); + domvline1 = mvlineasm1; + domvline4 = mvlineasm4; +#else + mvlinebits = fracbits; +#endif +} + +#ifndef USEASM +DWORD STACK_ARGS mvlinec1 () +{ + DWORD fracstep = dc_iscale; + DWORD frac = dc_texturefrac; + BYTE *colormap = dc_colormap; + int count = dc_count; + const BYTE *source = dc_source; + BYTE *dest = dc_dest; + int bits = mvlinebits; + int pitch = dc_pitch; + + do + { + BYTE pix = source[frac>>bits]; + if (pix != 0) + { + *dest = colormap[pix]; + } + frac += fracstep; + dest += pitch; + } while (--count); + + return frac; +} + +void STACK_ARGS mvlinec4 () +{ + BYTE *dest = dc_dest; + int count = dc_count; + int bits = mvlinebits; + DWORD place; + + do + { + BYTE pix; + + pix = bufplce[0][(place=vplce[0])>>bits]; if(pix) dest[0] = palookupoffse[0][pix]; vplce[0] = place+vince[0]; + pix = bufplce[1][(place=vplce[1])>>bits]; if(pix) dest[1] = palookupoffse[1][pix]; vplce[1] = place+vince[1]; + pix = bufplce[2][(place=vplce[2])>>bits]; if(pix) dest[2] = palookupoffse[2][pix]; vplce[2] = place+vince[2]; + pix = bufplce[3][(place=vplce[3])>>bits]; if(pix) dest[3] = palookupoffse[3][pix]; vplce[3] = place+vince[3]; + dest += dc_pitch; + } while (--count); +} +#endif + extern "C" short spanend[MAXHEIGHT]; extern fixed_t rw_light; extern fixed_t rw_lightstep; @@ -1202,6 +1273,139 @@ void R_DrawFogBoundary (int x1, int x2, short *uclip, short *dclip) } } +int tmvlinebits; + +void setuptmvline (int bits) +{ + tmvlinebits = bits; +} + +fixed_t tmvline1_add () +{ + DWORD fracstep = dc_iscale; + DWORD frac = dc_texturefrac; + BYTE *colormap = dc_colormap; + int count = dc_count; + const BYTE *source = dc_source; + BYTE *dest = dc_dest; + int bits = tmvlinebits; + int pitch = dc_pitch; + + DWORD *fg2rgb = dc_srcblend; + DWORD *bg2rgb = dc_destblend; + + do + { + BYTE pix = source[frac>>bits]; + if (pix != 0) + { + DWORD fg = fg2rgb[colormap[pix]]; + DWORD bg = bg2rgb[*dest]; + fg = (fg+bg) | 0x1f07c1f; + *dest = RGB32k[0][0][fg & (fg>>15)]; + } + frac += fracstep; + dest += pitch; + } while (--count); + + return frac; +} + +void tmvline4_add () +{ + BYTE *dest = dc_dest; + int count = dc_count; + int bits = tmvlinebits; + + DWORD *fg2rgb = dc_srcblend; + DWORD *bg2rgb = dc_destblend; + + do + { + for (int i = 0; i < 4; ++i) + { + BYTE pix = bufplce[i][vplce[i] >> bits]; + if (pix != 0) + { + DWORD fg = fg2rgb[palookupoffse[i][pix]]; + DWORD bg = bg2rgb[dest[i]]; + fg = (fg+bg) | 0x1f07c1f; + dest[i] = RGB32k[0][0][fg & (fg>>15)]; + } + vplce[i] += vince[i]; + } + dest += dc_pitch; + } while (--count); +} + +fixed_t tmvline1_addclamp () +{ + DWORD fracstep = dc_iscale; + DWORD frac = dc_texturefrac; + BYTE *colormap = dc_colormap; + int count = dc_count; + const BYTE *source = dc_source; + BYTE *dest = dc_dest; + int bits = tmvlinebits; + int pitch = dc_pitch; + + DWORD *fg2rgb = dc_srcblend; + DWORD *bg2rgb = dc_destblend; + + do + { + BYTE pix = source[frac>>bits]; + if (pix != 0) + { + DWORD a = fg2rgb[colormap[pix]] + bg2rgb[*dest]; + DWORD b = a; + + a |= 0x01f07c1f; + b &= 0x40100400; + a &= 0x3fffffff; + b = b - (b >> 5); + a |= b; + *dest = RGB32k[0][0][a & (a>>15)]; + } + frac += fracstep; + dest += pitch; + } while (--count); + + return frac; +} + +void tmvline4_addclamp () +{ + BYTE *dest = dc_dest; + int count = dc_count; + int bits = tmvlinebits; + + DWORD *fg2rgb = dc_srcblend; + DWORD *bg2rgb = dc_destblend; + + do + { + for (int i = 0; i < 4; ++i) + { + BYTE pix = bufplce[i][vplce[i] >> bits]; + if (pix != 0) + { + DWORD a = fg2rgb[palookupoffse[i][pix]] + bg2rgb[dest[i]]; + DWORD b = a; + + a |= 0x01f07c1f; + b &= 0x40100400; + a &= 0x3fffffff; + b = b - (b >> 5); + a |= b; + dest[i] = RGB32k[0][0][a & (a>>15)]; + } + vplce[i] += vince[i]; + } + dest += dc_pitch; + } while (--count); +} + /****************************************************/ /****************************************************/ @@ -1968,3 +2172,20 @@ void R_FinishSetPatchStyle () { basecolormap = basecolormapsave; } + +bool R_GetTransMaskDrawers (fixed_t (**tmvline1)(), void (**tmvline4)()) +{ + if (colfunc == R_DrawAddColumnP_C) + { + *tmvline1 = tmvline1_add; + *tmvline4 = tmvline4_add; + return true; + } + if (colfunc == R_DrawAddClampColumnP_C) + { + *tmvline1 = tmvline1_addclamp; + *tmvline4 = tmvline4_addclamp; + return true; + } + return false; +} diff --git a/src/r_draw.h b/src/r_draw.h index 04f31ce8c1..a72d127254 100644 --- a/src/r_draw.h +++ b/src/r_draw.h @@ -70,6 +70,12 @@ extern DWORD (STACK_ARGS *doprevline1) (); extern void (STACK_ARGS *dovline4) (); extern void setupvline (int); +extern DWORD (STACK_ARGS *domvline1) (); +extern void (STACK_ARGS *domvline4) (); +extern void setupmvline (int); + +extern void setuptmvline (int); + // The Spectre/Invisibility effect. extern void (*R_DrawFuzzColumn)(void); @@ -261,10 +267,19 @@ ESPSResult R_SetPatchStyle (int style, fixed_t alpha, int translation, DWORD col // style was STYLE_Shade void R_FinishSetPatchStyle (); +// transmaskwallscan calls this to find out what column drawers to use +bool R_GetTransMaskDrawers (fixed_t (**tmvline1)(), void (**tmvline4)()); + // Retrieve column data for wallscan. Should probably be removed // to just use the texture's GetColumn() method. It just exists // for double-layer skies. const BYTE *R_GetColumn (FTexture *tex, int col); void wallscan (int x1, int x2, short *uwal, short *dwal, fixed_t *swal, fixed_t *lwal, const byte *(*getcol)(FTexture *tex, int col)=R_GetColumn); +// maskwallscan is exactly like wallscan but does not draw anything where the texture is color 0. +void maskwallscan (int x1, int x2, short *uwal, short *dwal, fixed_t *swal, fixed_t *lwal, const byte *(*getcol)(FTexture *tex, int col)=R_GetColumn); + +// transmaskwallscan is like maskwallscan, but it can also blend to the background +void transmaskwallscan (int x1, int x2, short *uwal, short *dwal, fixed_t *swal, fixed_t *lwal, const byte *(*getcol)(FTexture *tex, int col)=R_GetColumn); + #endif diff --git a/src/r_segs.cpp b/src/r_segs.cpp index 03807547a2..b0f0202020 100644 --- a/src/r_segs.cpp +++ b/src/r_segs.cpp @@ -121,7 +121,7 @@ static fixed_t rw_bottomtexturemid; FTexture *rw_pic; -static short *maskedtexturecol; +static fixed_t *maskedtexturecol; static FTexture *WallSpriteTile; static void R_RenderDecal (side_t *wall, DBaseDecal *first, drawseg_t *clipper, int pass); @@ -157,10 +157,11 @@ CVAR(Bool, r_drawmirrors, true, 0) // R_RenderMaskedSegRange // fixed_t *MaskedSWall; +fixed_t MaskedScaleY; static void BlastMaskedColumn (void (*blastfunc)(const BYTE *pixels, const FTexture::Span *spans), FTexture *tex) { - if (maskedtexturecol[dc_x] != SHRT_MAX) + if (maskedtexturecol[dc_x] != FIXED_MAX) { // calculate lighting if (!fixedcolormap) @@ -168,7 +169,7 @@ static void BlastMaskedColumn (void (*blastfunc)(const BYTE *pixels, const FText dc_colormap = basecolormap + (GETPALOOKUP (rw_light, wallshade) << COLORMAPSHIFT); } - dc_iscale = MaskedSWall[dc_x]; + dc_iscale = MulScale5 (MaskedSWall[dc_x], MaskedScaleY); sprtopscreen = centeryfrac - FixedMul (dc_texturemid, spryscale); // killough 1/25/98: here's where Medusa came in, because @@ -181,9 +182,9 @@ static void BlastMaskedColumn (void (*blastfunc)(const BYTE *pixels, const FText // draw the texture const FTexture::Span *spans; - const BYTE *pixels = tex->GetColumn (maskedtexturecol[dc_x], &spans); + const BYTE *pixels = tex->GetColumn (maskedtexturecol[dc_x] >> FRACBITS, &spans); blastfunc (pixels, spans); - maskedtexturecol[dc_x] = SHRT_MAX; + maskedtexturecol[dc_x] = FIXED_MAX; } rw_light += rw_lightstep; spryscale += rw_scalestep; @@ -243,7 +244,8 @@ void R_RenderMaskedSegRange (drawseg_t *ds, int x1, int x2) } MaskedSWall = (fixed_t *)(openings + ds->swall) - ds->x1; - maskedtexturecol = openings + ds->maskedtexturecol - ds->x1; + MaskedScaleY = tex->ScaleY ? tex->ScaleY : ty; + maskedtexturecol = (fixed_t *)(openings + ds->maskedtexturecol) - ds->x1; spryscale = ds->iscale + ds->iscalestep * (x1 - ds->x1); rw_scalestep = ds->iscalestep; @@ -274,84 +276,102 @@ void R_RenderMaskedSegRange (drawseg_t *ds, int x1, int x2) dc_texturemid = MulScale3 (dc_texturemid - viewz, scaley) + curline->sidedef->rowoffset; } - // [RH] Don't bother drawing segs that are completely offscreen - if (MulScale12 (globaldclip, ds->sz1) < -textop && - MulScale12 (globaldclip, ds->sz2) < -textop) - { // Texture top is below the bottom of the screen - goto clearfog; - } - - if (MulScale12 (globaluclip, ds->sz1) > texheight - textop && - MulScale12 (globaluclip, ds->sz2) > texheight - textop) - { // Texture bottom is above the top of the screen - goto clearfog; - } - - WallSZ1 = ds->sz1; - WallSZ2 = ds->sz2; - WallSX1 = ds->sx1; - WallSX2 = ds->sx2; - - OWallMost (wallupper, textop); - OWallMost (walllower, textop - texheight); - - for (i = x1; i <= x2; i++) - { - if (wallupper[i] < mceilingclip[i]) - wallupper[i] = mceilingclip[i]; - } - for (i = x1; i <= x2; i++) - { - if (walllower[i] > mfloorclip[i]) - walllower[i] = mfloorclip[i]; - } - mfloorclip = walllower; - mceilingclip = wallupper; - if (fixedlightlev) dc_colormap = basecolormap + fixedlightlev; else if (fixedcolormap) dc_colormap = fixedcolormap; - // draw the columns one at a time - if (drawmode == DoDraw0) - { - for (dc_x = x1; dc_x <= x2; ++dc_x) + if (!(curline->linedef->flags & ML_WRAP_MIDTEX)) + { // Texture does not wrap vertically. + + // [RH] Don't bother drawing segs that are completely offscreen + if (MulScale12 (globaldclip, ds->sz1) < -textop && + MulScale12 (globaldclip, ds->sz2) < -textop) + { // Texture top is below the bottom of the screen + goto clearfog; + } + + if (MulScale12 (globaluclip, ds->sz1) > texheight - textop && + MulScale12 (globaluclip, ds->sz2) > texheight - textop) + { // Texture bottom is above the top of the screen + goto clearfog; + } + + WallSZ1 = ds->sz1; + WallSZ2 = ds->sz2; + WallSX1 = ds->sx1; + WallSX2 = ds->sx2; + + OWallMost (wallupper, textop); + OWallMost (walllower, textop - texheight); + + for (i = x1; i <= x2; i++) { - BlastMaskedColumn (R_DrawMaskedColumn, tex); + if (wallupper[i] < mceilingclip[i]) + wallupper[i] = mceilingclip[i]; + } + for (i = x1; i <= x2; i++) + { + if (walllower[i] > mfloorclip[i]) + walllower[i] = mfloorclip[i]; + } + mfloorclip = walllower; + mceilingclip = wallupper; + + // draw the columns one at a time + if (drawmode == DoDraw0) + { + for (dc_x = x1; dc_x <= x2; ++dc_x) + { + BlastMaskedColumn (R_DrawMaskedColumn, tex); + } + } + else + { + // [RH] Draw up to four columns at once + int stop = (x2+1) & ~3; + + if (x1 > x2) + goto clearfog; + + dc_x = x1; + + while ((dc_x < stop) && (dc_x & 3)) + { + BlastMaskedColumn (R_DrawMaskedColumn, tex); + dc_x++; + } + + while (dc_x < stop) + { + rt_initcols(); + BlastMaskedColumn (R_DrawMaskedColumnHoriz, tex); dc_x++; + BlastMaskedColumn (R_DrawMaskedColumnHoriz, tex); dc_x++; + BlastMaskedColumn (R_DrawMaskedColumnHoriz, tex); dc_x++; + BlastMaskedColumn (R_DrawMaskedColumnHoriz, tex); + rt_draw4cols (dc_x - 3); + dc_x++; + } + + while (dc_x <= x2) + { + BlastMaskedColumn (R_DrawMaskedColumn, tex); + dc_x++; + } } } else - { - // [RH] Draw up to four columns at once - int stop = (x2+1) & ~3; + { // Texture does wrap vertically. - if (x1 > x2) - goto clearfog; - - dc_x = x1; - - while ((dc_x < stop) && (dc_x & 3)) + rw_offset = 0; + rw_pic = tex; + if (colfunc == basecolfunc) { - BlastMaskedColumn (R_DrawMaskedColumn, tex); - dc_x++; + maskwallscan(x1, x2, mceilingclip, mfloorclip, MaskedSWall, maskedtexturecol); } - - while (dc_x < stop) + else { - rt_initcols(); - BlastMaskedColumn (R_DrawMaskedColumnHoriz, tex); dc_x++; - BlastMaskedColumn (R_DrawMaskedColumnHoriz, tex); dc_x++; - BlastMaskedColumn (R_DrawMaskedColumnHoriz, tex); dc_x++; - BlastMaskedColumn (R_DrawMaskedColumnHoriz, tex); - rt_draw4cols (dc_x - 3); - dc_x++; - } - - while (dc_x <= x2) - { - BlastMaskedColumn (R_DrawMaskedColumn, tex); - dc_x++; + transmaskwallscan(x1, x2, mceilingclip, mfloorclip, MaskedSWall, maskedtexturecol); } } @@ -411,8 +431,8 @@ ebp = x2 void wallscan (int x1, int x2, short *uwal, short *dwal, fixed_t *swal, fixed_t *lwal, const BYTE *(*getcol)(FTexture *tex, int x)) { - long x, shiftval; - long y1ve[4], y2ve[4], u4, d4, z; + int x, shiftval; + int y1ve[4], y2ve[4], u4, d4, z; char bad; fixed_t light = rw_light - rw_lightstep; SDWORD yrepeat, texturemid, xoffset; @@ -636,6 +656,347 @@ void wallscan_striped (int x1, int x2, short *uwal, short *dwal, fixed_t *swal, wallshade = startshade; } +inline fixed_t mvline1 (fixed_t vince, byte *colormap, int count, fixed_t vplce, const byte *bufplce, byte *dest) +{ + dc_iscale = vince; + dc_colormap = colormap; + dc_count = count; + dc_texturefrac = vplce; + dc_source = bufplce; + dc_dest = dest; + return domvline1 (); +} + +void maskwallscan (int x1, int x2, short *uwal, short *dwal, fixed_t *swal, fixed_t *lwal, + const BYTE *(*getcol)(FTexture *tex, int x)) +{ + int x, shiftval; + BYTE *p; + int y1ve[4], y2ve[4], u4, d4, startx, dax, z; + char bad; + fixed_t light = rw_light - rw_lightstep; + SDWORD yrepeat, texturemid, xoffset; + + if (rw_pic->UseType == FTexture::TEX_Null) + { + return; + } + + if (!rw_pic->bMasked) + { // Textures that aren't masked can use the faster wallscan. + wallscan (x1, x2, uwal, dwal, swal, lwal, getcol); + return; + } + +//extern cycle_t WallScanCycles; +//clock (WallScanCycles); + + rw_pic->GetHeight(); // Make sure texture size is loaded + shiftval = rw_pic->HeightBits; + setupmvline (32-shiftval); + yrepeat = (rw_pic->ScaleY ? rw_pic->ScaleY : ty) << (11 - shiftval); + texturemid = dc_texturemid << (16 - shiftval); + xoffset = rw_offset; + + x = startx = x1; + p = x + dc_destorg; + + if (fixedcolormap) + { + palookupoffse[0] = dc_colormap; + palookupoffse[1] = dc_colormap; + palookupoffse[2] = dc_colormap; + palookupoffse[3] = dc_colormap; + } + + for(; (x <= x2) && ((size_t)p & 3); ++x, ++p) + { + light += rw_lightstep; + y1ve[0] = uwal[x];//max(uwal[x],umost[x]); + y2ve[0] = dwal[x];//min(dwal[x],dmost[x]); + if (y2ve[0] <= y1ve[0]) continue; + + if (!fixedcolormap) + { // calculate lighting + dc_colormap = basecolormap + (GETPALOOKUP (light, wallshade) << COLORMAPSHIFT); + } + + dc_source = getcol (rw_pic, (lwal[x] + xoffset) >> FRACBITS); + dc_dest = ylookup[y1ve[0]] + p; + dc_iscale = swal[x] * yrepeat; + dc_count = y2ve[0] - y1ve[0]; + dc_texturefrac = texturemid + FixedMul (dc_iscale, (y1ve[0]<= 0; --z, --dax) + { + y1ve[z] = uwal[dax]; + y2ve[z] = dwal[dax]; + if (y2ve[z] <= y1ve[z]) { bad += 1<> FRACBITS); + vince[z] = swal[dax] * yrepeat; + vplce[z] = texturemid + FixedMul (vince[z], (y1ve[z]<= d4)) + { + for (z = 0; z < 4; ++z) + { + if (!(bad & 1)) + { + mvline1(vince[z],palookupoffse[z],y2ve[z]-y1ve[z],vplce[z],bufplce[z],ylookup[y1ve[z]]+p+z); + } + bad >>= 1; + } + continue; + } + + for (z = 0; z < 4; ++z) + { + if (u4 > y1ve[z]) + { + vplce[z] = mvline1(vince[z],palookupoffse[z],u4-y1ve[z],vplce[z],bufplce[z],ylookup[y1ve[z]]+p+z); + } + } + + if (d4 > u4) + { + dc_count = d4-u4; + dc_dest = ylookup[u4]+p; + domvline4(); + } + + BYTE *i = p+ylookup[d4]; + for (z = 0; z < 4; ++z) + { + if (y2ve[z] > d4) + { + mvline1(vince[z],palookupoffse[0],y2ve[z]-d4,vplce[z],bufplce[z],i+z); + } + } + } + for(; x <= x2; ++x, ++p) + { + light += rw_lightstep; + y1ve[0] = uwal[x]; + y2ve[0] = dwal[x]; + if (y2ve[0] <= y1ve[0]) continue; + + if (!fixedcolormap) + { // calculate lighting + dc_colormap = basecolormap + (GETPALOOKUP (light, wallshade) << COLORMAPSHIFT); + } + + dc_source = getcol (rw_pic, (lwal[x] + xoffset) >> FRACBITS); + dc_dest = ylookup[y1ve[0]] + p; + dc_iscale = swal[x] * yrepeat; + dc_count = y2ve[0] - y1ve[0]; + dc_texturefrac = texturemid + FixedMul (dc_iscale, (y1ve[0]<UseType == FTexture::TEX_Null) + { + return; + } + + if (!R_GetTransMaskDrawers (&tmvline1, &tmvline4)) + { + // The current translucency is unsupported, so draw with regular maskwallscan instead. + maskwallscan (x1, x2, uwal, dwal, swal, lwal, getcol); + return; + } + +//extern cycle_t WallScanCycles; +//clock (WallScanCycles); + + rw_pic->GetHeight(); // Make sure texture size is loaded + shiftval = rw_pic->HeightBits; + setuptmvline (32-shiftval); + yrepeat = (rw_pic->ScaleY ? rw_pic->ScaleY : ty) << (11 - shiftval); + texturemid = dc_texturemid << (16 - shiftval); + xoffset = rw_offset; + + x = startx = x1; + p = x + dc_destorg; + + if (fixedcolormap) + { + palookupoffse[0] = dc_colormap; + palookupoffse[1] = dc_colormap; + palookupoffse[2] = dc_colormap; + palookupoffse[3] = dc_colormap; + } + + for(; (x <= x2) && ((size_t)p & 3); ++x, ++p) + { + light += rw_lightstep; + y1ve[0] = uwal[x];//max(uwal[x],umost[x]); + y2ve[0] = dwal[x];//min(dwal[x],dmost[x]); + if (y2ve[0] <= y1ve[0]) continue; + + if (!fixedcolormap) + { // calculate lighting + dc_colormap = basecolormap + (GETPALOOKUP (light, wallshade) << COLORMAPSHIFT); + } + + dc_source = getcol (rw_pic, (lwal[x] + xoffset) >> FRACBITS); + dc_dest = ylookup[y1ve[0]] + p; + dc_iscale = swal[x] * yrepeat; + dc_count = y2ve[0] - y1ve[0]; + dc_texturefrac = texturemid + FixedMul (dc_iscale, (y1ve[0]<= 0; --z, --dax) + { + y1ve[z] = uwal[dax]; + y2ve[z] = dwal[dax]; + if (y2ve[z] <= y1ve[z]) { bad += 1<> FRACBITS); + vince[z] = swal[dax] * yrepeat; + vplce[z] = texturemid + FixedMul (vince[z], (y1ve[z]<= d4)) + { + for (z = 0; z < 4; ++z) + { + if (!(bad & 1)) + { + preptmvline1(vince[z],palookupoffse[z],y2ve[z]-y1ve[z],vplce[z],bufplce[z],ylookup[y1ve[z]]+p+z); + tmvline1(); + } + bad >>= 1; + } + continue; + } + + for (z = 0; z < 4; ++z) + { + if (u4 > y1ve[z]) + { + preptmvline1(vince[z],palookupoffse[z],u4-y1ve[z],vplce[z],bufplce[z],ylookup[y1ve[z]]+p+z); + vplce[z] = tmvline1(); + } + } + + if (d4 > u4) + { + dc_count = d4-u4; + dc_dest = ylookup[u4]+p; + tmvline4(); + } + + BYTE *i = p+ylookup[d4]; + for (z = 0; z < 4; ++z) + { + if (y2ve[z] > d4) + { + preptmvline1(vince[z],palookupoffse[0],y2ve[z]-d4,vplce[z],bufplce[z],i+z); + tmvline1(); + } + } + } + for(; x <= x2; ++x, ++p) + { + light += rw_lightstep; + y1ve[0] = uwal[x]; + y2ve[0] = dwal[x]; + if (y2ve[0] <= y1ve[0]) continue; + + if (!fixedcolormap) + { // calculate lighting + dc_colormap = basecolormap + (GETPALOOKUP (light, wallshade) << COLORMAPSHIFT); + } + + dc_source = getcol (rw_pic, (lwal[x] + xoffset) >> FRACBITS); + dc_dest = ylookup[y1ve[0]] + p; + dc_iscale = swal[x] * yrepeat; + dc_count = y2ve[0] - y1ve[0]; + dc_texturefrac = texturemid + FixedMul (dc_iscale, (y1ve[0]<floor_angle + backsector->base_floor_angle) != (frontsector->floor_angle + frontsector->base_floor_angle) - || (sidedef->midtexture && linedef->flags & ML_CLIP_MIDTEX) + || (sidedef->midtexture && linedef->flags & (ML_CLIP_MIDTEX|ML_WRAP_MIDTEX)) ; markceiling = (frontsector->ceilingpic != skyflatnum || @@ -958,7 +1319,7 @@ void R_NewWall (bool needlights) || (backsector->ceiling_angle + backsector->base_ceiling_angle) != (frontsector->ceiling_angle + frontsector->base_ceiling_angle) - || (sidedef->midtexture && linedef->flags & ML_CLIP_MIDTEX) + || (sidedef->midtexture && linedef->flags & (ML_CLIP_MIDTEX|ML_WRAP_MIDTEX)) ); } @@ -1235,7 +1596,7 @@ void R_StoreWallRange (int start, int stop) (WallSZ1 >= TOO_CLOSE_Z && WallSZ2 >= TOO_CLOSE_Z)) { fixed_t *swal; - short *lwal; + fixed_t *lwal; int i; maskedtexture = true; @@ -1243,22 +1604,22 @@ void R_StoreWallRange (int start, int stop) ds_p->bFogBoundary = IsFogBoundary (frontsector, backsector); if (sidedef->midtexture != 0) { - ds_p->maskedtexturecol = R_NewOpening (stop - start); + ds_p->maskedtexturecol = R_NewOpening ((stop - start) * 2); ds_p->swall = R_NewOpening ((stop - start) * 2); - lwal = openings + ds_p->maskedtexturecol; + lwal = (fixed_t *)(openings + ds_p->maskedtexturecol); swal = (fixed_t *)(openings + ds_p->swall); int scaley = TexMan(sidedef->midtexture)->ScaleY ? TexMan(sidedef->midtexture)->ScaleY : ty; int xoffset = rw_offset; for (i = start; i < stop; i++) { - *lwal++ = (short)((lwall[i] + xoffset) >> FRACBITS); - *swal++ = MulScale5 (swall[i], scaley); + *lwal++ = lwall[i] + xoffset; + *swal++ = swall[i]; } - fixed_t istart = *((fixed_t *)(openings + ds_p->swall)); - fixed_t iend = *(swal - 1); + fixed_t istart = MulScale5 (*((fixed_t *)(openings + ds_p->swall)), scaley); + fixed_t iend = MulScale5 (*(swal - 1), scaley); if (istart < 3 && istart >= 0) istart = 3; if (istart > -3 && istart < 0) istart = -3; diff --git a/src/v_video.cpp b/src/v_video.cpp index 68791a2b1d..653e7b64bd 100644 --- a/src/v_video.cpp +++ b/src/v_video.cpp @@ -542,6 +542,12 @@ DSimpleCanvas::DSimpleCanvas (int width, int height) } else { + // If we couldn't figure out the CPU's L1 cache line size, assume + // it's 32 bytes wide. + if (CPU.DataL1LineSize == 0) + { + CPU.DataL1LineSize = 32; + } // The Athlon and P3 have very different caches, apparently. // I am going to generalize the Athlon's performance to all AMD // processors and the P3's to all non-AMD processors. I don't know @@ -553,7 +559,7 @@ DSimpleCanvas::DSimpleCanvas (int width, int height) } else { - Pitch = width + CPU.DataL1LineSize - 8; + Pitch = width + MAX(0, CPU.DataL1LineSize - 8); } } MemBuffer = new BYTE[Pitch * height]; diff --git a/tools/dehsupp/Makefile.mgw b/tools/dehsupp/Makefile similarity index 51% rename from tools/dehsupp/Makefile.mgw rename to tools/dehsupp/Makefile index 0ed9ffa8a5..d7bd68cb98 100644 --- a/tools/dehsupp/Makefile.mgw +++ b/tools/dehsupp/Makefile @@ -1,8 +1,14 @@ -EXE = dehsupp.exe +ifeq (Windows_NT,$(OS)) + EXE = dehsupp.exe + CCDV = @../../ccdv + CFLAGS = $(LOC) -Os -Wall -fomit-frame-pointer +else + EXE = dehsupp + CCDV = + CFLAGS = -Dstricmp=strcasecmp -Dstrnicmp=strncasecmp -Os -Wall -fomit-frame-pointer +endif -CCDV = @../../ccdv CC = gcc -CFLAGS = $(LOC) -Os -Wall -fomit-frame-pointer BISON = bison BISONFLAGS = @@ -17,8 +23,13 @@ $(EXE): $(OBJS) .PHONY: clean clean: +ifeq (Windows_NT,$(OS)) -del /q /f $(EXE) 2>nul -del /q /f *.o 2>nul +else + rm -f $(EXE) + rm -f *.o +endif parse.tab.o: parse.tab.c $(CCDV) $(CC) $(CFLAGS) -c -o $@ $< diff --git a/tools/makewad/Makefile.mgw b/tools/makewad/Makefile similarity index 100% rename from tools/makewad/Makefile.mgw rename to tools/makewad/Makefile diff --git a/tools/xlatcc/Makefile.mgw b/tools/xlatcc/Makefile similarity index 58% rename from tools/xlatcc/Makefile.mgw rename to tools/xlatcc/Makefile index dad84a0c0b..fb3b2a6f61 100644 --- a/tools/xlatcc/Makefile.mgw +++ b/tools/xlatcc/Makefile @@ -1,8 +1,14 @@ -EXE = xlatcc.exe +ifeq (Windows_NT,$(OS)) + EXE = xlatcc.exe + CCDV = @../../ccdv + CFLAGS = $(LOC) -Os -Wall -fomit-frame-pointer +else + EXE = xlatcc + CCDV = + CFLAGS = -Dstricmp=strcasecmp -Dstrnicmp=strncasecmp $(LOC) -Os -Wall -fomit-frame-pointer +endif -CCDV = @../../ccdv CC = gcc -CFLAGS = $(LOC) -Os -Wall -fomit-frame-pointer BISON = bison BISONFLAGS = @@ -17,8 +23,13 @@ $(EXE): $(OBJS) .PHONY: clean clean: +ifeq (Windows_NT,$(OS)) -del /q /f $(EXE) 2>nul -del /q /f *.o 2>nul +else + rm -f $(EXE) + rm -f *.o +endif xlat-parse.tab.o: xlat-parse.tab.c xlat.h $(CCDV) $(CC) $(CFLAGS) -c -o $@ $< diff --git a/wadsrc/zdoom.lst b/wadsrc/zdoom.lst index cc82335aed..ad2047c085 100644 --- a/wadsrc/zdoom.lst +++ b/wadsrc/zdoom.lst @@ -165,17 +165,17 @@ sounds/railgf1.flac railgunfire.flac ======== # Mapinfos -d1info.txt mapinfo/doom1.txt -d2info.txt mapinfo/doom2.txt -plutinfo.txt mapinfo/plutonia.txt -tntinfo.txt mapinfo/tnt.txt -herinfo.txt mapinfo/heretic.txt -hexninfo.txt mapinfo/hexen.txt -strfinfo.txt mapinfo/strife.txt +mapinfo/doom1.txt mapinfo/doom1.txt +mapinfo/doom2.txt mapinfo/doom2.txt +mapinfo/plutonia.txt mapinfo/plutonia.txt +mapinfo/tnt.txt mapinfo/tnt.txt +mapinfo/heretic.txt mapinfo/heretic.txt +mapinfo/hexen.txt mapinfo/hexen.txt +mapinfo/strife.txt mapinfo/strife.txt ======== # Strife's helper script -acs/strfhelp.o strfhelp.o +acs/strfhelp.o strfhelp.o ========