Compare commits

..
Author SHA1 Message Date
alufolie91 926c1de52a software: make R_DrawWallColumn being able to render "holey" textures
not the most efficient but idk a better solution to this, and clipping code may cause some other undesired effects, but well were not supposed to be drawing textures with holes on single sided walls eitherways, but here we are
basically this copies columns into a buffer filled with cyan pixels, so the holes become cyan instead of nothing, which we can cut again using the twomultipatch drawers
fixes the "melt" effect on some things like spelunky or music plant (and well reading/writing oob)
2026-04-05 20:37:15 +02:00
indev 489a58f9fd Allocate all colormaps with PU_STATIC 2026-04-05 18:31:55 +02:00
alufolie91 b26effa241 Merge pull request #223 from Indev450/bluaopti2
Some optimizations and fixes for BLUA from LUA
2026-04-05 18:28:50 +02:00
alufolie91 efd8c20d26 enable lto by default on makefile builds
change flag to NOLTO to disable lto
at this point we shouldnt have any issues anymore since the utter crapton of bugfixes
2026-04-05 18:26:16 +02:00
alufolie91 03b85aa00e Merge pull request #225 from Indev450/optifindvar
Speed up CV_Findvar & CV_FindNetVar with hashtable
2026-04-04 17:05:25 +02:00
indev e6434c24ec Fix spelling in server addon info tooltip 2026-04-04 18:01:10 +03:00
indev 52e23e7b08 Merge pull request #224 from Indev450/addon-download-info
Addon download info
2026-04-04 14:49:38 +00:00
alufolie91 7fb21c35ba Experiment: speed up CV_FindVar and CV_FindNetVar
oftentimes lua scripts call CV_FindVar a fuckton of times during runtime, with many cvars this can actually tank performance more than one might think
ideally lua scripts should cache the result, but with so much stuff and servers we cant expect everyone to go through all scripts to do that
using a hashtable for CV_FindNetVar might improve join times aswell, but needs further testing to confirm
2026-03-25 19:35:20 +01:00
alufolie91 f6a0430a40 use constructor for W_Startup
never liked having this inside i_system
2026-03-25 19:35:17 +01:00
alufolie91 ab209448d1 Introduce GNU constructor and destructor attributes
The constructor attribute causes the function to be called automatically before execution enters main (). Similarly, the destructor attribute causes the function to be called automatically after main () has completed or exit () has been called. Functions with these attributes are useful for initializing data that will be used implicitly during the execution of the program.

added "used" attribute aswell so compiler does not omit non referenced functions (i hope)
gotta test this a bit but seems cool for stuff like verstable maps
2026-03-25 19:35:14 +01:00
Alug 7684e6aa07 Blua: opcode OP_SELF operate only with string keys, so they can use fast-track table access
https://github.com/lua/lua/commit/cb3d5dce30089512085f78a0bef79e30ef732e30
2026-03-15 18:19:06 +01:00
Alug 0fb752b745 Blua: OP_SELF can use 'luaV_fastget' specialized for strings, as it is applied only to string keys
https://github.com/lua/lua/commit/257961c601fdec1ea1f9640d460e0d31c39333a1
2026-03-15 18:19:03 +01:00
Alug c418fe3ef8 Blua: 'luaV_fastget' only treats the real fast case (table with a non-nil value at given key, so that it does not need to check metamethods)
https://github.com/lua/lua/commit/1a44e822009752513ce895b9eabc51a4ee4a195a
2026-03-15 18:18:59 +01:00
Alug fdccc80260 Blua: 'Protect' in table operations is not needed in the fast track
https://github.com/lua/lua/commit/df8b996bccd3830d6fe9d7ba80e8fccd6ac3cabf
2026-03-15 18:18:57 +01:00
Alug 84be9096b1 Blua: fast track for 'settable'
https://github.com/lua/lua/commit/3b795541c488c7e633567897c9112312007a20a0
https://github.com/lua/lua/commit/b91bc93fd33f2158745b37c9e091c6fa4d1a4fd5

had to adjust some things, hope this doesent explode lmao
2026-03-15 18:18:54 +01:00
Alug e4e51f0f80 Blua: implementation of fast track for gettable operations
https://github.com/lua/lua/commit/e247c3ada3ff47a1352927e797263137f4e02e0e

lets hope i converted this properly lul
2026-03-15 18:18:51 +01:00
alufolie91 fed7020da1 hash_sparse: change length checks
dont early return on 0 len, let it be the falltrough case, this seems to help branch prediction
2026-03-13 18:58:49 +01:00
alufolie91 1a4255d9df luaS_newlstr: use hash also for checking strings
taken from raptorjit
we can check the hash first to skip quite a bunch of memcmps which should be faster in most cases (hopefully but quick timedemo tests confirmed that)
2026-03-13 18:58:39 +01:00
alufolie91 f6ead71f0c blua: handle 0 length strings in hash_sparse 2026-03-13 18:58:31 +01:00
Alug 966f60f590 Experiment: replace lua´s string hash with luajits ARX hash
the string hashing was the most hit and most spent in part of the whole game in alot of cases
replacing it with luajits algo absolutely massively improves lua performance (10-15fps in my bench timedemos!)
however idk how all this stuff exactly works so this needs alot of testing to make sure nothing breaks
ive rewritten the unaligned ptr access slightly to use memcpy for safety with some platforms that require stricter alignment
2026-03-13 18:58:21 +01:00
alufolie91 9afc018a45 Avoid computing invalid addresses
luaV_execute should compute 'ra' only when the instruction uses it.
Computing an illegal address is undefined behavior even if the address
is never dereferenced.
2026-03-13 18:58:05 +01:00
Alug 43608810da lua branching hint stuff
rechecked against lua 5.4
2026-03-13 18:56:18 +01:00
Alug 90b5f9050a Blua: small optimization in luaL_addlstring (avoid adding chars one by one)
https://github.com/lua/lua/commit/f292760f12022a83cf01e788482a264aeeb3c276
2026-03-13 18:55:55 +01:00
Alug edc10a35a1 Blua: better names for metamethods in debug information
https://github.com/lua/lua/commit/becf19feeffeb0bf2297e163da4ccc7b4b5e6b5c
2026-03-13 18:55:49 +01:00
Alug 91435fe1b2 Blua: small optimization (reorder of BinOpr enum to unify some cases in switches)
https://github.com/lua/lua/commit/d7872dcf91eb2075312a03973a6cdb489610c796
2026-03-13 18:55:42 +01:00
Alug a7ebc7e745 Blua: micro-optimization: avoid one API call in 'read_chars'
https://github.com/lua/lua/commit/f86f4116c82654d24faa4a32a909d0c27f3d4746
2026-03-13 18:55:37 +01:00
26 changed files with 518 additions and 134 deletions

No files matched your search

+2 -2
View File
@@ -93,7 +93,7 @@
# NOLDWARNING=1 - ?
# NOSDLMAIN=1 - ?
# SDLMAIN=1 - ?
# USELTO=1 - Enable building with LTO.
# NOLTO=1 - Disable link time optimizations
#
# Library configuration flags:
# Everything here is an override.
@@ -260,7 +260,7 @@ debug_opts=-D_DEBUG
else # build a normal optimized version
debug_opts=-DNDEBUG
opts+=-O3
ifdef USELTO
ifndef NOLTO
# compile with LTO
opts+=-flto=auto
libs+=-flto=auto
+38 -17
View File
@@ -519,6 +519,23 @@ LUA_API int lua_pushthread (lua_State *L) {
** get functions (Lua -> stack)
*/
static void auxgetstr (lua_State *L, TValue *t, const char *k) {
TValue *slot;
TValue key;
TString *str = luaS_new(L, k);
api_checkvalidindex(L, t);
if (luaV_fastget(L, t, str, slot, luaH_getstr)) {
setobj2s(L, L->top, slot);
api_incr_top(L);
}
else {
setsvalue(L, &key, str);
luaV_finishget(L, t, L->top, L->top, slot);
api_incr_top(L);
}
lua_unlock(L);
}
LUA_API void lua_gettable (lua_State *L, int idx) {
StkId t;
@@ -531,15 +548,8 @@ LUA_API void lua_gettable (lua_State *L, int idx) {
LUA_API void lua_getfield (lua_State *L, int idx, const char *k) {
StkId t;
TValue key;
lua_lock(L);
t = index2adr(L, idx);
api_checkvalidindex(L, t);
setsvalue(L, &key, luaS_new(L, k));
luaV_gettable(L, t, &key, L->top);
api_incr_top(L);
lua_unlock(L);
auxgetstr(L, index2adr(L, idx), k);
}
@@ -631,6 +641,25 @@ LUA_API void lua_getfenv (lua_State *L, int idx) {
*/
static void auxsetstr (lua_State *L, TValue *t, const char *k) {
TValue key;
TValue *slot;
TString *str = luaS_new(L, k);
api_checknelems(L, 1);
api_checkvalidindex(L, t);
if (luaV_fastset(L, t, str, slot, luaH_setstr, L->top)) {
setobj2t(L, cast(TValue *, slot), L->top - 1);
L->top--; /* pop value */
}
else {
setsvalue2s(L, &key, str);
luaV_finishset(L, t, &key, L->top - 1, slot);
L->top--; /* pop value */
}
lua_unlock(L);
}
LUA_API void lua_settable (lua_State *L, int idx) {
StkId t;
lua_lock(L);
@@ -644,16 +673,8 @@ LUA_API void lua_settable (lua_State *L, int idx) {
LUA_API void lua_setfield (lua_State *L, int idx, const char *k) {
StkId t;
TValue key;
lua_lock(L);
api_checknelems(L, 1);
t = index2adr(L, idx);
api_checkvalidindex(L, t);
setsvalue(L, &key, luaS_new(L, k));
luaV_settable(L, t, &key, L->top - 1);
L->top--; /* pop value */
lua_unlock(L);
auxsetstr(L, index2adr(L, idx), k);
}
+15 -3
View File
@@ -20,6 +20,7 @@
#define lauxlib_c
#define LUA_LIB
#include "ldebug.h"
#include "lua.h"
#include "lauxlib.h"
@@ -468,8 +469,19 @@ LUALIB_API char *luaL_prepbuffer (luaL_Buffer *B) {
LUALIB_API void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l) {
while (l--)
luaL_addchar(B, *s++);
while (l) {
size_t space = bufffree(B);
if (space == 0) {
luaL_prepbuffer(B);
lua_assert(bufffree(B) == LUAL_BUFFERSIZE);
space = LUAL_BUFFERSIZE;
}
if (space > l) space = l;
memcpy(B->p, s, space);
B->p += space;
s += space;
l -= space;
}
}
@@ -686,6 +698,6 @@ static int panic (lua_State *L) {
LUALIB_API lua_State *luaL_newstate (void) {
lua_State *L = lua_newstate(l_alloc, NULL);
if (L) lua_atpanic(L, &panic);
if (l_likely(L)) lua_atpanic(L, &panic);
return L;
}
+25 -12
View File
@@ -626,8 +626,20 @@ static void codenot (FuncState *fs, expdesc *e) {
removevalues(fs, e->t);
}
/*
** Check whether expression 'e' is a literal string
*/
static int isKstr (FuncState *fs, expdesc *e) {
return (e->k == VK && ttisstring(&fs->f->k[e->u.s.info]));
}
/*
** Create expression 't[k]'. 't' must have its final result already in a
** register or upvalue. Upvalues can only be indexed by literal strings.
*/
void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k) {
if (t->k == VUPVAL && !isKstr(fs, k)) /* upvalue indexed by non string? */
luaK_exp2anyreg(fs, t); /* put it in a register */
t->u.s.aux = luaK_exp2RK(fs, k);
t->k = VINDEXED;
}
@@ -790,18 +802,19 @@ void luaK_posfix (FuncState *fs, BinOpr op, expdesc *e1, expdesc *e2) {
case OPR_BXOR: codearith(fs, OP_BXOR, e1, e2); break;
case OPR_BSHL: codearith(fs, OP_BSHL, e1, e2); break;
case OPR_BSHR: codearith(fs, OP_BSHR, e1, e2); break;
case OPR_ADD: codearith(fs, OP_ADD, e1, e2); break;
case OPR_SUB: codearith(fs, OP_SUB, e1, e2); break;
case OPR_MUL: codearith(fs, OP_MUL, e1, e2); break;
case OPR_DIV: codearith(fs, OP_DIV, e1, e2); break;
case OPR_MOD: codearith(fs, OP_MOD, e1, e2); break;
case OPR_POW: codearith(fs, OP_POW, e1, e2); break;
case OPR_EQ: codecomp(fs, OP_EQ, 1, e1, e2); break;
case OPR_NE: codecomp(fs, OP_EQ, 0, e1, e2); break;
case OPR_LT: codecomp(fs, OP_LT, 1, e1, e2); break;
case OPR_LE: codecomp(fs, OP_LE, 1, e1, e2); break;
case OPR_GT: codecomp(fs, OP_LT, 0, e1, e2); break;
case OPR_GE: codecomp(fs, OP_LE, 0, e1, e2); break;
case OPR_ADD: case OPR_SUB: case OPR_MUL: case OPR_DIV:
case OPR_MOD: case OPR_POW: {
codearith(fs, op - OPR_ADD + OP_ADD, e1, e2);
break;
}
case OPR_EQ: case OPR_LT: case OPR_LE: {
codecomp(fs, op - OPR_EQ + OP_EQ, 1, e1, e2);
break;
}
case OPR_NE: case OPR_GT: case OPR_GE: {
codecomp(fs, op - OPR_NE + OP_EQ, 0, e1, e2);
break;
}
default: lua_assert(0);
}
}
+3 -3
View File
@@ -21,13 +21,13 @@
/*
** grep "ORDER OPR" if you change these enums
** grep "ORDER OPR" if you change these enums (ORDER OP)
*/
typedef enum BinOpr {
OPR_ADD, OPR_SUB, OPR_MUL, OPR_DIV, OPR_MOD, OPR_POW,
OPR_CONCAT,
OPR_NE, OPR_EQ,
OPR_LT, OPR_LE, OPR_GT, OPR_GE,
OPR_EQ, OPR_LT, OPR_LE,
OPR_NE, OPR_GT, OPR_GE,
OPR_AND, OPR_OR,
OPR_BAND, OPR_BOR, OPR_BXOR,
OPR_BSHL, OPR_BSHR,
+28 -5
View File
@@ -542,16 +542,39 @@ static const char *getobjname (lua_State *L, CallInfo *ci, int stackpos,
static const char *getfuncname (lua_State *L, CallInfo *ci, const char **name) {
TMS tm = 0;
Instruction i;
if ((isLua(ci) && ci->tailcalls > 0) || !isLua(ci - 1))
return NULL; /* calling function is not Lua (or is unknown) */
ci--; /* calling function */
i = ci_func(ci)->l.p->code[currentpc(L, ci)];
if (GET_OPCODE(i) == OP_CALL || GET_OPCODE(i) == OP_TAILCALL ||
GET_OPCODE(i) == OP_TFORLOOP)
return getobjname(L, ci, GETARG_A(i), name);
else
return NULL; /* no useful name can be found */
switch (GET_OPCODE(i)) {
case OP_CALL:
case OP_TAILCALL:
case OP_TFORLOOP:
return getobjname(L, ci, GETARG_A(i), name);
case OP_GETGLOBAL:
case OP_SELF:
case OP_GETTABLE: tm = TM_INDEX; break;
case OP_SETGLOBAL:
case OP_SETTABLE: tm = TM_NEWINDEX; break;
case OP_EQ: tm = TM_EQ; break;
case OP_ADD: tm = TM_ADD; break;
case OP_SUB: tm = TM_SUB; break;
case OP_MUL: tm = TM_MUL; break;
case OP_DIV: tm = TM_DIV; break;
case OP_MOD: tm = TM_MOD; break;
case OP_POW: tm = TM_POW; break;
case OP_UNM: tm = TM_UNM; break;
case OP_LEN: tm = TM_LEN; break;
case OP_LT: tm = TM_LT; break;
case OP_LE: tm = TM_LE; break;
case OP_CONCAT: tm = TM_CONCAT; break;
default:
return NULL; /* else no useful name can be found */
}
*name = getstr(G(L)->tmname[tm]);
return "metamethod";
}
+2 -2
View File
@@ -164,7 +164,7 @@ void luaD_reallocCI (lua_State *L, int newsize) {
void luaD_growstack (lua_State *L, int n) {
if (l_likely(n <= L->stacksize)) /* double size is enough? */
if (n <= L->stacksize) /* double size is enough? */
luaD_reallocstack(L, 2*L->stacksize);
else
luaD_reallocstack(L, L->stacksize + n);
@@ -318,7 +318,7 @@ int luaD_precall (lua_State *L, StkId func, int nresults) {
ci->top = L->top + LUA_MINSTACK;
lua_assert(ci->top <= L->stack_last);
ci->nresults = nresults;
if (L->hookmask & LUA_MASKCALL)
if (l_unlikely(L->hookmask & LUA_MASKCALL))
luaD_callhook(L, LUA_HOOKCALL, -1);
lua_unlock(L);
n = (*curr_func(L)->c.f)(L); /* do the actual call */
+10 -9
View File
@@ -356,20 +356,21 @@ static int read_line (lua_State *L, FILE *f) {
static int read_chars (lua_State *L, FILE *f, size_t n) {
size_t rlen; /* how much to read */
size_t nr; /* number of chars actually read */
size_t tbr = n; /* number of chars to be read */
size_t rlen; /* how much to read in each cycle */
size_t nr; /* number of chars actually read in each cycle */
luaL_Buffer b;
luaL_buffinit(L, &b);
rlen = LUAL_BUFFERSIZE; /* try to read that much each time */
do {
char *p = luaL_prepbuffer(&b);
if (rlen > n) rlen = n; /* cannot read more than asked */
if (rlen > tbr) rlen = tbr; /* cannot read more than asked */
nr = fread(p, sizeof(char), rlen, f);
luaL_addsize(&b, nr);
n -= nr; /* still have to read `n' chars */
} while (n > 0 && nr == rlen); /* until end of count or eof */
tbr -= nr; /* still have to read 'tbr' chars */
} while (tbr > 0 && nr == rlen); /* until end of count or eof */
luaL_pushresult(&b); /* close buffer */
return (n == 0 || lua_objlen(L, -1) > 0);
return (tbr == 0 || tbr < n); /* true iff read something */
}
@@ -432,13 +433,13 @@ static int f_read (lua_State *L) {
static int io_readline (lua_State *L) {
FILE *f = *(FILE **)lua_touserdata(L, lua_upvalueindex(1));
int sucess;
int success;
if (f == NULL) /* file is already closed? */
luaL_error(L, "file is already closed");
sucess = read_line(L, f);
success = read_line(L, f);
if (ferror(f))
return luaL_error(L, "%s", strerror(errno));
if (sucess) return 1;
if (success) return 1;
else { /* EOF */
if (lua_toboolean(L, lua_upvalueindex(2))) { /* generator created file? */
lua_settop(L, 0);
+2
View File
@@ -232,6 +232,8 @@ OP_VARARG/* A B R(A), R(A+1), ..., R(A+B-1) = vararg */
(*) In OP_SETLIST, if (B == 0) then B = `top';
if (C == 0) then next `instruction' is real C
(*) In OP_SELF, the index must be a string.
(*) For comparisons, A specifies what condition the test should accept
(true or false).
+4 -4
View File
@@ -881,10 +881,10 @@ static const struct {
lu_byte right; /* right priority */
} priority[] = { /* ORDER OPR */
{6, 6}, {6, 6}, {7, 7}, {7, 7}, {7, 7}, /* `+' `-' `/' `%' */
{10, 9}, {5, 4}, /* power and concat (right associative) */
{3, 3}, {3, 3}, /* equality and inequality */
{3, 3}, {3, 3}, {3, 3}, {3, 3}, /* order */
{2, 2}, {1, 1} /* logical (and/or) */
{10, 9}, {5, 4}, /* ^, .. (right associative) */
{3, 3}, {3, 3}, {3, 3}, /* ==, <, <= */
{3, 3}, {3, 3}, {3, 3}, /* ~=, >, >= */
{2, 2}, {1, 1} /* and, or */
,{6, 6}, {6, 6}, {6, 6}, /* bit-wise (band/bor/bxor) */
{7, 7}, {7, 7} /* shl/shr */
};
+58 -4
View File
@@ -51,7 +51,7 @@ static TString *newlstr (lua_State *L, const char *str, size_t l,
unsigned int h) {
TString *ts;
stringtable *tb;
if (l+1 > (MAX_SIZET - sizeof(TString))/sizeof(char))
if (l_unlikely(l+1 > (MAX_SIZET - sizeof(TString))/sizeof(char)))
luaM_toobig(L);
ts = cast(TString *, luaM_malloc(L, (l+1)*sizeof(char)+sizeof(TString)));
ts->tsv.len = l;
@@ -72,18 +72,72 @@ static TString *newlstr (lua_State *L, const char *str, size_t l,
}
TString *luaS_newlstr (lua_State *L, const char *str, size_t l) {
GCObject *o;
// string hash taken from luaJIT
/* Unaligned load of uint32_t. */
static inline __attribute__((always_inline)) uint32_t getu32(const void* ptr)
{
uint32_t result;
memcpy(&result, ptr, 4);
return result;
}
// smol macro to look a little less messy lul
#define getu8(p) *cast(const uint8_t *, p)
/* Keyed sparse ARX string hash. Constant time. */
static unsigned hash_sparse(const char *str, size_t len)
{
/* Constants taken from lookup3 hash by Bob Jenkins. */
unsigned int a, b, h = cast(unsigned int, len);
#define rol(x, n) (((x)<<(n)) | ((x)>>(-cast(int, n)&(8*sizeof(x)-1))))
if (len >= 4) { /* Caveat: unaligned access! */
a = getu32(str);
h ^= getu32(str+len-4);
b = getu32(str+(len>>1)-2);
h ^= b; h -= rol(b, 14);
b += getu32(str+(len>>2)-1);
} else if (len > 0) {
a = getu8(str);
h ^= getu8(str+len-1);
b = getu8(str+(len>>1));
h ^= b; h -= rol(b, 14);
} else {
return 0;
}
a ^= h; a -= rol(h, 11);
b ^= a; b -= rol(a, 25);
h ^= b; h -= rol(b, 16);
#undef rol
return h;
}
#undef getu8
static inline __attribute__((always_inline)) unsigned luaS_hash (const char *str, size_t l) {
#if 0
unsigned int h = cast(unsigned int, l); /* seed */
size_t step = (l>>5)+1; /* if string is too long, don't hash all its chars */
size_t l1;
for (l1=l; l1>=step; l1-=step) /* compute hash */
h = h ^ ((h<<5)+(h>>2)+cast(unsigned char, str[l1-1]));
return h;
#else
return hash_sparse(str, l);
#endif
}
TString *luaS_newlstr (lua_State *L, const char *str, size_t l) {
GCObject *o;
unsigned int h = luaS_hash(str, l);
for (o = G(L)->strt.hash[lmod(h, G(L)->strt.size)];
o != NULL;
o = o->gch.next) {
TString *ts = rawgco2ts(o);
if (l_unlikely(ts->tsv.len == l && (memcmp(str, getstr(ts), l) == 0))) {
if (ts->tsv.hash == h &&
ts->tsv.len == l &&
(memcmp(str, getstr(ts), l) == 0)) {
/* string may be dead */
if (isdead(G(L), o)) changewhite(o);
return ts;
+135 -51
View File
@@ -28,7 +28,7 @@
/* limit for table tag-method chains (to avoid loops) */
/* limit for table tag-method chains (to avoid infinite loops) */
#define MAXTAGLOOP 100
@@ -105,57 +105,88 @@ static void callTM (lua_State *L, const TValue *f, const TValue *p1,
}
void luaV_gettable (lua_State *L, TValue *t, TValue *key, StkId val) {
int loop;
/*
** Finish the table access 'val = t[key]'.
** if 'slot' is NULL, 't' is not a table; otherwise, 'slot' points to
** t[k] entry (which must be nil).
*/
void luaV_finishget (lua_State *L, TValue *t, TValue *key, StkId val,
TValue *slot) {
int loop; /* counter to avoid infinite loops */
TValue *tm; /* metamethod */
for (loop = 0; loop < MAXTAGLOOP; loop++) {
TValue *tm;
if (ttistable(t)) { /* `t' is a table? */
Table *h = hvalue(t);
const TValue *res = luaH_get(h, key); /* do a primitive get */
if (!ttisnil(res) || /* result is no nil? */
(tm = fasttm(L, h->metatable, TM_INDEX)) == NULL) { /* or no TM? */
setobj2s(L, val, res);
if (slot == NULL) { /* 't' is not a table? */
lua_assert(!ttistable(t));
tm = luaT_gettmbyobj(L, t, TM_INDEX);
if (l_unlikely(ttisnil(tm)))
luaG_typeerror(L, t, "index"); /* no metamethod */
/* else will try the metamethod */
}
else { /* 't' is a table */
lua_assert(ttisnil(slot));
tm = fasttm(L, hvalue(t)->metatable, TM_INDEX); /* table's metamethod */
if (tm == NULL) { /* no metamethod? */
setnilvalue(val); /* result is nil */
return;
}
/* else will try the tag method */
/* else will try the metamethod */
}
else if (l_unlikely(ttisnil(tm = luaT_gettmbyobj(L, t, TM_INDEX))))
luaG_typeerror(L, t, "index");
if (ttisfunction(tm)) {
callTMres(L, val, tm, t, key);
if (ttisfunction(tm)) { /* is metamethod a function? */
callTMres(L, val, tm, t, key); /* call it */
return;
}
t = tm; /* else repeat with `tm' */
t = tm; /* else try to access 'tm[key]' */
if (luaV_fastget(L,t,key,slot,luaH_get)) { /* fast track? */
setobj2s(L, val, slot); /* done */
return;
}
/* else repeat (tail call 'luaV_finishget') */
}
luaG_runerror(L, "loop in gettable");
luaG_runerror(L, "'__index' chain too long; possible loop");
}
void luaV_settable (lua_State *L, TValue *t, TValue *key, StkId val) {
int loop;
/*
** Finish a table assignment 't[key] = val'.
** If 'slot' is NULL, 't' is not a table. Otherwise, 'slot' points
** to the entry 't[key]', or to 'luaO_nilobject' if there is no such
** entry. (The value at 'slot' must be nil, otherwise 'luaV_fastset'
** would have done the job.)
*/
void luaV_finishset (lua_State *L, TValue *t, TValue *key,
StkId val, TValue *slot) {
int loop; /* counter to avoid infinite loops */
for (loop = 0; loop < MAXTAGLOOP; loop++) {
TValue *tm = NULL;
if (ttistable(t)) { /* `t' is a table? */
TValue *tm;
if (slot != NULL) {
lua_assert(ttistable(t) && ttisnil(slot));
Table *h = hvalue(t);
TValue *oldval = luaH_set(L, h, key); /* do a primitive set */
/* oldval is nil=> look for newindex, oldval is not nil => look for usedindex */
if (!((ttisnil(oldval) && ((tm = fasttm(L, h->metatable, TM_NEWINDEX)) != NULL)) ||
((!ttisnil(oldval)) && ((tm = fasttm(L, h->metatable, TM_USEDINDEX)) != NULL)))) {
setobj2t(L, oldval, val);
/* must check the metamethod */
/* slot is nil=> look for newindex, slot is not nil => look for usedindex */
if (!((ttisnil(slot) && ((tm = fasttm(L, h->metatable, TM_NEWINDEX)) != NULL)) ||
((!ttisnil(slot)) && ((tm = fasttm(L, h->metatable, TM_USEDINDEX)) != NULL)))) {
/* no metamethod and (now) there is an entry with given key */
setobj2t(L, cast(TValue *, slot), val);
luaC_barriert(L, h, val);
return;
}
/* else will try the tag method */
/* else will try the metamethod */
}
else if (l_unlikely(ttisnil(tm = luaT_gettmbyobj(L, t, TM_NEWINDEX))))
luaG_typeerror(L, t, "index");
else { /* not a table; check metamethod */
if (l_unlikely(ttisnil(tm = luaT_gettmbyobj(L, t, TM_NEWINDEX))))
luaG_typeerror(L, t, "index");
}
/* try the metamethod */
if (ttisfunction(tm)) {
callTM(L, tm, t, key, val);
return;
}
t = tm; /* else repeat with `tm' */
t = tm; /* else repeat assignment over 'tm' */
if (luaV_fastset(L, t, key, slot, luaH_set, val))
return; /* done */
/* else loop */
}
luaG_runerror(L, "loop in settable");
luaG_runerror(L, "settable chain too long; possible loop");
}
@@ -366,6 +397,7 @@ static void Arith (lua_State *L, StkId ra, TValue *rb,
#define arith_op(op,tm) { \
StkId ra = RA(i); \
TValue *rb = RKB(i); \
TValue *rc = RKC(i); \
if (ttisnumber(rb) && ttisnumber(rc)) { \
@@ -377,6 +409,21 @@ static void Arith (lua_State *L, StkId ra, TValue *rb,
}
/*
** copy of 'luaV_gettable', but protecting call to potential metamethod
** (which can reallocate the stack)
*/
#define gettableProtected(L,t,k,v) { TValue *slot; \
if (luaV_fastget(L,t,k,slot,luaH_get)) { setobj2s(L, v, slot); } \
else Protect(luaV_finishget(L,t,k,v,slot)); }
/* same for 'luaV_settable' */
#define settableProtected(L,t,k,v) { TValue *slot; \
if (!luaV_fastset(L,t,k,slot,luaH_set,v)) \
Protect(luaV_finishset(L,t,k,v,slot)); }
void luaV_execute (lua_State *L, int nexeccalls) {
LClosure *cl;
@@ -386,13 +433,12 @@ void luaV_execute (lua_State *L, int nexeccalls) {
reentry: /* entry point */
lua_assert(isLua(L->ci));
pc = L->savedpc;
cl = &clvalue(L->ci->func)->l;
base = L->base;
k = cl->p->k;
cl = &clvalue(L->ci->func)->l; /* local reference to function's closure */
k = cl->p->k; /* local reference to function's constant table */
base = L->base; /* local copy of function's base */
/* main loop of interpreter */
for (;;) {
const Instruction i = *pc++;
StkId ra;
if ((L->hookmask & (LUA_MASKLINE | LUA_MASKCOUNT)) &&
(--L->hookcount == 0 || L->hookmask & LUA_MASKLINE)) {
traceexec(L, pc);
@@ -402,26 +448,28 @@ void luaV_execute (lua_State *L, int nexeccalls) {
}
base = L->base;
}
/* warning!! several calls may realloc the stack and invalidate `ra' */
ra = RA(i);
lua_assert(base == L->base && L->base == L->ci->base);
lua_assert(base <= L->top && L->top <= L->stack + L->stacksize);
lua_assert(L->top == L->ci->top || luaG_checkopenop(i));
switch (GET_OPCODE(i)) {
case OP_MOVE: {
StkId ra = RA(i);
setobjs2s(L, ra, RB(i));
continue;
}
case OP_LOADK: {
StkId ra = RA(i);
setobj2s(L, ra, KBx(i));
continue;
}
case OP_LOADBOOL: {
StkId ra = RA(i);
setbvalue(ra, GETARG_B(i));
if (GETARG_C(i)) pc++; /* skip next instruction (if C) */
continue;
}
case OP_LOADNIL: {
StkId ra = RA(i);
TValue *rb = RB(i);
do {
setnilvalue(rb--);
@@ -429,11 +477,13 @@ void luaV_execute (lua_State *L, int nexeccalls) {
continue;
}
case OP_GETUPVAL: {
StkId ra = RA(i);
int b = GETARG_B(i);
setobj2s(L, ra, cl->upvals[b]->v);
continue;
}
case OP_GETGLOBAL: {
StkId ra = RA(i);
TValue g;
TValue *rb = KBx(i);
sethvalue(L, &g, cl->env);
@@ -442,10 +492,14 @@ void luaV_execute (lua_State *L, int nexeccalls) {
continue;
}
case OP_GETTABLE: {
Protect(luaV_gettable(L, RB(i), RKC(i), ra));
StkId ra = RA(i);
StkId rb = RB(i);
TValue *rc = RKC(i);
gettableProtected(L, rb, rc, ra);
continue;
}
case OP_SETGLOBAL: {
StkId ra = RA(i);
TValue g;
sethvalue(L, &g, cl->env);
lua_assert(ttisstring(KBx(i)));
@@ -453,16 +507,21 @@ void luaV_execute (lua_State *L, int nexeccalls) {
continue;
}
case OP_SETUPVAL: {
StkId ra = RA(i);
UpVal *uv = cl->upvals[GETARG_B(i)];
setobj(L, uv->v, ra);
luaC_barrier(L, uv, ra);
continue;
}
case OP_SETTABLE: {
Protect(luaV_settable(L, ra, RKB(i), RKC(i)));
StkId ra = RA(i);
TValue *rb = RKB(i);
TValue *rc = RKC(i);
settableProtected(L, ra, rb, rc);
continue;
}
case OP_NEWTABLE: {
StkId ra = RA(i);
int b = GETARG_B(i);
int c = GETARG_C(i);
sethvalue(L, ra, luaH_new(L, luaO_fb2int(b), luaO_fb2int(c)));
@@ -470,9 +529,16 @@ void luaV_execute (lua_State *L, int nexeccalls) {
continue;
}
case OP_SELF: {
TValue *slot;
StkId ra = RA(i);
StkId rb = RB(i);
setobjs2s(L, ra+1, rb);
Protect(luaV_gettable(L, rb, RKC(i), ra));
TValue *rc = RKC(i);
TString *key = rawtsvalue(rc); /* key must be a string */
setobjs2s(L, ra + 1, rb);
if (luaV_fastget(L, rb, key, slot, luaH_getstr)) {
setobj2s(L, ra, slot);
}
else Protect(luaV_finishget(L, rb, rc, ra, slot));
continue;
}
case OP_ADD: {
@@ -488,6 +554,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
continue;
}
case OP_DIV: {
StkId ra = RA(i);
TValue *rb = RKB(i);
TValue *rc = RKC(i);
if (ttisnumber(rb) && ttisnumber(rc)) {
@@ -503,6 +570,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
continue;
}
case OP_MOD: {
StkId ra = RA(i);
TValue *rb = RKB(i);
TValue *rc = RKC(i);
if (ttisnumber(rb) && ttisnumber(rc)) {
@@ -522,26 +590,27 @@ void luaV_execute (lua_State *L, int nexeccalls) {
continue;
}
case OP_BAND: {
arith_op(luai_numand, TM_AND);
continue;
arith_op(luai_numand, TM_AND);
continue;
}
case OP_BOR: {
arith_op(luai_numor, TM_OR);
continue;
arith_op(luai_numor, TM_OR);
continue;
}
case OP_BXOR: {
arith_op(luai_numxor, TM_XOR);
continue;
arith_op(luai_numxor, TM_XOR);
continue;
}
case OP_BSHL: {
arith_op(luai_numshl, TM_SHL);
continue;
arith_op(luai_numshl, TM_SHL);
continue;
}
case OP_BSHR: {
arith_op(luai_numshr, TM_SHR);
continue;
arith_op(luai_numshr, TM_SHR);
continue;
}
case OP_BNOT: {
StkId ra = RA(i);
TValue *rb = RB(i);
if (ttisnumber(rb)) {
lua_Number nb = nvalue(rb);
@@ -553,6 +622,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
continue;
}
case OP_UNM: {
StkId ra = RA(i);
TValue *rb = RB(i);
if (ttisnumber(rb)) {
lua_Number nb = nvalue(rb);
@@ -564,11 +634,13 @@ void luaV_execute (lua_State *L, int nexeccalls) {
continue;
}
case OP_NOT: {
StkId ra = RA(i);
int res = l_isfalse(RB(i)); /* next assignment may change this value */
setbvalue(ra, res);
continue;
}
case OP_LEN: {
StkId ra = RA(i);
TValue *rb = RB(i);
switch (ttype(rb)) {
case LUA_TTABLE: {
@@ -626,12 +698,14 @@ void luaV_execute (lua_State *L, int nexeccalls) {
continue;
}
case OP_TEST: {
StkId ra = RA(i);
if (l_isfalse(ra) != GETARG_C(i))
dojump(L, pc, GETARG_sBx(*pc));
pc++;
continue;
}
case OP_TESTSET: {
StkId ra = RA(i);
TValue *rb = RB(i);
if (l_isfalse(rb) != GETARG_C(i)) {
setobjs2s(L, ra, rb);
@@ -641,6 +715,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
continue;
}
case OP_CALL: {
StkId ra = RA(i);
int b = GETARG_B(i);
int nresults = GETARG_C(i) - 1;
if (b != 0) L->top = ra+b; /* else previous instruction set top */
@@ -662,6 +737,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
}
}
case OP_TAILCALL: {
StkId ra = RA(i);
int b = GETARG_B(i);
if (b != 0) L->top = ra+b; /* else previous instruction set top */
L->savedpc = pc;
@@ -694,6 +770,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
}
}
case OP_RETURN: {
StkId ra = RA(i);
int b = GETARG_B(i);
if (b != 0) L->top = ra+b-1;
if (L->openupval) luaF_close(L, base);
@@ -709,6 +786,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
}
}
case OP_FORLOOP: {
StkId ra = RA(i);
lua_Number step = nvalue(ra+2);
lua_Number idx = luai_numadd(nvalue(ra), step); /* increment index */
lua_Number limit = nvalue(ra+1);
@@ -721,6 +799,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
continue;
}
case OP_FORPREP: {
StkId ra = RA(i);
const TValue *init = ra;
const TValue *plimit = ra+1;
const TValue *pstep = ra+2;
@@ -737,6 +816,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
continue;
}
case OP_TFORLOOP: {
StkId ra = RA(i);
StkId cb = ra + 3; /* call base */
setobjs2s(L, cb+2, ra+2);
setobjs2s(L, cb+1, ra+1);
@@ -753,6 +833,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
continue;
}
case OP_SETLIST: {
StkId ra = RA(i);
int n = GETARG_B(i);
int c = GETARG_C(i);
int last;
@@ -775,10 +856,12 @@ void luaV_execute (lua_State *L, int nexeccalls) {
continue;
}
case OP_CLOSE: {
StkId ra = RA(i);
luaF_close(L, ra);
continue;
}
case OP_CLOSURE: {
StkId ra = RA(i);
Proto *p;
Closure *ncl;
int nup, j;
@@ -799,6 +882,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
continue;
}
case OP_VARARG: {
StkId ra = RA(i);
int b = GETARG_B(i) - 1;
int j;
CallInfo *ci = L->ci;
+52 -4
View File
@@ -22,14 +22,62 @@
(ttype(o1) == ttype(o2) && luaV_equalval(L, o1, o2))
/*
** fast track for 'gettable': if 't' is a table and 't[k]' is not nil,
** return 1 with 'slot' pointing to 't[k]' (final result). Otherwise,
** return 0 (meaning it will have to check metamethod) with 'slot'
** pointing to a nil 't[k]' (if 't' is a table) or NULL (otherwise).
** 'f' is the raw get function to use.
*/
#define luaV_fastget(L,t,k,slot,f) \
(!ttistable(t) \
? (slot = NULL, 0) /* not a table; 'slot' is NULL and result is 0 */ \
: (slot = f(hvalue(t), k), /* else, do raw access */ \
!ttisnil(slot))) /* result not nil? */
/*
** standard implementation for 'gettable'
*/
#define luaV_gettable(L,t,k,v) { TValue *slot; \
if (luaV_fastget(L,t,k,slot,luaH_get)) { setobj2s(L, v, slot); } \
else luaV_finishget(L,t,k,v,slot); }
/*
** Fast track for set table. If 't' is a table and 't[k]' is not nil,
** call GC barrier, do a raw 't[k]=v', and return true; otherwise,
** return false with 'slot' equal to NULL (if 't' is not a table) or
** 'nil'. (This is needed by 'luaV_finishget'.) Note that, if the macro
** returns true, there is no need to 'invalidateTMcache', because the
** call is not creating a new entry.
*/
#define luaV_fastset(L,t,k,slot,f,v) \
(!ttistable(t) \
? (slot = NULL, 0) \
: (slot = f(L, hvalue(t), k), \
ttisnil(slot) ? 0 \
: (__extension__ ({ \
if (valiswhite(v) && isblack(obj2gco(hvalue(t)))) \
luaC_barrierback(L, hvalue(t)); \
setobj2t(L, cast(TValue *,slot), v); \
1; \
}))))
#define luaV_settable(L,t,k,v) { TValue *slot; \
if (!luaV_fastset(L,t,k,slot,luaH_set,v)) \
luaV_finishset(L,t,k,v,slot); }
LUAI_FUNC int luaV_lessthan (lua_State *L, TValue *l, TValue *r);
LUAI_FUNC int luaV_equalval (lua_State *L, const TValue *t1, const TValue *t2);
LUAI_FUNC const TValue *luaV_tonumber (const TValue *obj, TValue *n);
LUAI_FUNC int luaV_tostring (lua_State *L, StkId obj);
LUAI_FUNC void luaV_gettable (lua_State *L, TValue *t, TValue *key,
StkId val);
LUAI_FUNC void luaV_settable (lua_State *L, TValue *t, TValue *key,
StkId val);
LUAI_FUNC void luaV_finishget (lua_State *L, TValue *t, TValue *key,
StkId val, TValue *tm);
LUAI_FUNC void luaV_finishset (lua_State *L, TValue *t, TValue *key,
StkId val, TValue *oldval);
LUAI_FUNC void luaV_execute (lua_State *L, int nexeccalls);
LUAI_FUNC void luaV_concat (lua_State *L, int total, int last);
+63 -1
View File
@@ -1165,6 +1165,39 @@ void VS_Print(vsbuf_t *buf, const char *data)
//
// =========================================================================
#define NAME cvar_map_t
#define KEY_TY const char *
#define VAL_TY consvar_t *
#define HASH_FN vt_hash_string
#define CMPR_FN vt_cmpr_string
#include "verstable.h"
#define NAME netvar_map_t
#define KEY_TY UINT16
#define VAL_TY consvar_t *
#define HASH_FN vt_hash_integer
#define CMPR_FN vt_cmpr_integer
#include "verstable.h"
static cvar_map_t cvar_map;
static netvar_map_t netvar_map;
CONSTRUCTOR static void CV_InitMap(void)
{
// ensure the map is initialized
cvar_map_t_init(&cvar_map);
cvar_map_t_reserve(&cvar_map, 512);
netvar_map_t_init(&netvar_map);
netvar_map_t_reserve(&netvar_map, 256);
}
DESTRUCTOR static void CV_DestroyMap(void)
{
cvar_map_t_cleanup(&cvar_map);
netvar_map_t_cleanup(&netvar_map);
}
static const char *cv_null_string = "";
/** Searches if a variable has been registered.
@@ -1175,11 +1208,17 @@ static const char *cv_null_string = "";
*/
consvar_t *CV_FindVar(const char *name)
{
consvar_t *cvar;
cvar_map_t_itr it = cvar_map_t_get(&cvar_map, name);
if (!cvar_map_t_is_end(it))
return it.data->val;
// fallback linear search
/*
consvar_t *cvar;
for (cvar = consvar_vars; cvar; cvar = cvar->next)
if (fasticmp(name, cvar->name))
return cvar;
*/
return NULL;
}
@@ -1213,11 +1252,17 @@ static inline UINT16 CV_ComputeNetid(const char *s)
*/
static consvar_t *CV_FindNetVar(UINT16 netid)
{
netvar_map_t_itr it = netvar_map_t_get(&netvar_map, netid);
if (!netvar_map_t_is_end(it))
return it.data->val;
/*
consvar_t *cvar;
for (cvar = consvar_vars; cvar; cvar = cvar->next)
if (cvar->netid == netid)
return cvar;
*/
if (netid == 44542) // ouch this hack
return &cv_karteliminatelast;
@@ -1283,6 +1328,11 @@ void CV_RegisterVar(consvar_t *variable)
// the SetValue will set this bit
variable->flags &= ~CV_MODIFIED;
cvar_map_t_insert(&cvar_map, variable->name, variable);
if (variable->flags & CV_NETVAR)
netvar_map_t_insert(&netvar_map, variable->netid, variable);
}
/** Finds the string value of a console variable.
@@ -1588,9 +1638,21 @@ size_t CV_LoadNetVars(const UINT8 *bufstart)
// prevent "invalid command received"
serverloading = true;
// we can use our netvar map instead of going through all cvars each time
netvar_map_t_itr it;
for (it = netvar_map_t_first(&netvar_map);
!netvar_map_t_is_end(it);
it = netvar_map_t_next(it))
{
cvar = it.data->val;
Setvalue(cvar, cvar->defaultvalue, true);
}
/*
for (cvar = consvar_vars; cvar; cvar = cvar->next)
if (cvar->flags & CV_NETVAR)
Setvalue(cvar, cvar->defaultvalue, true);
*/
count = READUINT16(p);
while (count--)
-1
View File
@@ -1396,7 +1396,6 @@ static void I_Fork(void)
INT32 I_StartupSystem(void)
{
W_Startup();
I_StartupConsole();
#ifdef NEWSIGNALHANDLER
// This is useful when debugging. It lets GDB attach to
+7
View File
@@ -573,6 +573,13 @@ INT32 I_GetKey(void);
// NOTE: you WILL have nasal troubles if the variable is not initialized
#define CLEANUP(f) __attribute__((__cleanup__(f)))
// the GNU constructor and destructor attributes
// The constructor attribute causes the function to be called automatically before execution enters main ().
// Similarly, the destructor attribute causes the function to be called automatically after main () has completed or exit () has been called.
// Functions with these attributes are useful for initializing data that will be used implicitly during the execution of the program.
#define CONSTRUCTOR __attribute__((constructor, used))
#define DESTRUCTOR __attribute__((destructor, used))
// An assert-type mechanism.
#ifdef PARANOIA
#define I_Assert(e) ((e) ? (void)0 : I_Error("assert failed: %s, file %s, line %d", #e, __FILE__, __LINE__))
+1 -1
View File
@@ -1727,7 +1727,7 @@ static const char* OP_SaturnTooltips[] =
"Practice for online play! 0 = instant response.",
"Simulate online input delay when hosting a server.\nValue choosen by Player with the lowest ping",
"Show a screen before joining a server displaying important information about it",
"Show a amount and types of addons loaded by server when joining",
"Show amount and types of addons that are loaded by server when joining",
"How much speen do you want?",
"Colourize the speedlines in your skincolor if you go fast enough!",
"Colourize the sneaker flame trails in your skincolor!",
+2 -1
View File
@@ -2586,7 +2586,8 @@ void P_FreeLevelState(void)
}
// Clear pointers that would be left dangling by the purge
R_FlushTranslationColormapCache();
// Pointers are now PU_STATIC so they won't be freed :)
//R_FlushTranslationColormapCache();
#ifdef HWRENDER
// Free GPU textures before freeing patches.
+6 -3
View File
@@ -419,7 +419,7 @@ static UINT8* RGetTranslationColormap(INT32 skinnum, skincolors_t color, UINT8 f
// Generate the colormap if necessary
if (!ret)
{
ret = static_cast<UINT8*>(Z_Malloc(NUM_PALETTE_ENTRIES, (flags & GTC_CACHE) ? PU_LEVEL : PU_STATIC, NULL));
ret = static_cast<UINT8*>(Z_Malloc(NUM_PALETTE_ENTRIES, PU_STATIC, NULL));
K_GenerateKartColormap(ret, skinnum, color, local); //R_GenerateTranslationColormap(ret, skinnum, color); // SRB2kart
// Cache the colormap if desired
@@ -487,6 +487,10 @@ patch_t* R_GetSkinFaceMini(player_t* ply)
\return void
*/
/* There seems to be no reason to free cached colormaps tho? Not like they can change :ChonkBunckle: */
/*
void R_FlushTranslationColormapCache(void)
{
INT32 i;
@@ -499,6 +503,7 @@ void R_FlushTranslationColormapCache(void)
if (localtranslationtablecache[i])
memset(localtranslationtablecache[i], 0, MAXTRANSLATIONS * sizeof(UINT8**));
}
*/
// ==========================================================================
// COMMON DRAWER FOR 8 AND 16 BIT COLOR MODES
@@ -510,8 +515,6 @@ void R_FlushTranslationColormapCache(void)
// in reality, the few routines that can work for either mode, are
// put here
enum columncontext_e columncontext = COLUMNCONTEXT_DIRECT;
enum ColumnFlushType
{
FLUSH_NONE = 0x0000,
+2 -1
View File
@@ -105,7 +105,6 @@ enum columncontext_e
COLUMNCONTEXT_FLUSH,
};
extern enum columncontext_e columncontext;
void R_SetColumnContext(enum columncontext_e _columncontext);
void R_ResetColumnBuffer(void);
@@ -124,6 +123,8 @@ enum
COLDRAWFUNC_TRANSTRANS,
COLDRAWFUNC_TWOSMULTIPATCH,
COLDRAWFUNC_TWOSMULTIPATCHTRANS,
COLDRAWFUNC_TWOSMULTIPATCH_DIRECT,
COLDRAWFUNC_TWOSMULTIPATCHTRANS_DIRECT,
COLDRAWFUNC_FOG,
COLDRAWFUNC_MAX
+56 -2
View File
@@ -16,6 +16,7 @@
#include "r_sky.h"
#include <algorithm>
#include <vector>
#include "r_portal.h"
#include "r_splats.h"
@@ -1166,6 +1167,37 @@ static inline void R_ExpandPlaneY(visplane_t *pl, INT32 x, INT16 top, INT16 bott
// CALLED: CORE LOOPING ROUTINE.
//
static std::vector<UINT8> holecol(256);
// used for R_DrawWallColumn
// convert "holey" columns into contigous columns
// filled with cyan in place of holes
static UINT8 *R_GetHoleColumn(drawcolumndata_t* dc)
{
column_t *col = (column_t *)(dc->source - 3);
const INT32 texheight = dc->texheight;
holecol.resize(texheight);
// fill in everything with cyan so we can skip it
memset(holecol.data(), TRANSPARENTPIXEL, texheight);
// shamelessly copy pasted from R_GenerateTexture
INT32 topdelta, prevdelta = -1;
while (col->topdelta != 0xff)
{
topdelta = col->topdelta;
if (topdelta <= prevdelta)
topdelta += prevdelta;
prevdelta = topdelta;
memcpy(holecol.data() + topdelta, (UINT8*)col + 4, col->length);
col = (column_t *)((UINT8*)col + col->length + 4);
}
return holecol.data();
}
static void R_DrawWallColumn(drawcolumndata_t* dc, INT32 yl, INT32 yh, fixed_t mid, fixed_t texturecolumn, INT32 texture, boolean remap)
{
const INT32 itexturecolumn = texturecolumn >> FRACBITS;
@@ -1175,13 +1207,35 @@ static void R_DrawWallColumn(drawcolumndata_t* dc, INT32 yl, INT32 yh, fixed_t m
dc->source = R_GetColumn(texture, itexturecolumn);
dc->texheight = textureheight[texture] >> FRACBITS;
dc->sourcelength = dc->texheight;
R_SetColumnFunc(colfunctype);
coldrawfunc_t* colfunccopy = colfunc;
if (textures[texture]->holes)
{
dc->source = R_GetHoleColumn(dc);
if (cv_softcyancut.value)
{
// need to use multipatch drawers to cut cyan pixels
if (R_CheckColumnFunc(COLDRAWFUNC_FUZZY) == true)
{
colfunccopy = colfuncs[COLDRAWFUNC_TWOSMULTIPATCHTRANS_DIRECT];
}
else
{
colfunccopy = colfuncs[COLDRAWFUNC_TWOSMULTIPATCH_DIRECT];
}
}
}
drawcolumndata_t dc_copy = *dc;
if (remap)
{
dc_copy.colormap += COLORMAP_REMAPOFFSET;
}
colfunccopy(const_cast<drawcolumndata_t*>(&dc_copy));
}
@@ -1390,7 +1444,7 @@ static void R_RenderSegLoop(drawcolumndata_t* dc)
// calculate lighting
pindex = FixedMul(rw_scale, LIGHTRESOLUTIONFIX)>>LIGHTSCALESHIFT;
if (pindex >= MAXLIGHTSCALE)
if (pindex >= MAXLIGHTSCALE)
pindex = MAXLIGHTSCALE-1;
dc->colormap = walllights[pindex];
@@ -1425,7 +1479,7 @@ static void R_RenderSegLoop(drawcolumndata_t* dc)
pindex = FixedMul(rw_scale, LIGHTRESOLUTIONFIX)>>LIGHTSCALESHIFT;
if (pindex >= MAXLIGHTSCALE)
if (pindex >= MAXLIGHTSCALE)
pindex = MAXLIGHTSCALE-1;
if (dc->lightlist[i].extra_colormap)
+1 -1
View File
@@ -774,7 +774,7 @@ void R_AddSkins(UINT16 wadnum, boolean local)
// So just let the function in the while loop take care of it for us.
}
R_FlushTranslationColormapCache();
//R_FlushTranslationColormapCache();
CONS_Printf(M_GetText("Added skin '%s'\n"), skin->name);
#ifdef SKINVALUES
+4 -1
View File
@@ -120,6 +120,10 @@ static void SCR_SetDrawFuncs(enum columncontext_e _columncontext)
colfuncs[COLDRAWFUNC_TWOSMULTIPATCHTRANS] = R_Draw2sMultiPatchTranslucentColumn;
}
// gotta keep a copy of those for R_DrawWallColumn.....
colfuncs[COLDRAWFUNC_TWOSMULTIPATCH_DIRECT] = R_Draw2sMultiPatchColumn;
colfuncs[COLDRAWFUNC_TWOSMULTIPATCHTRANS_DIRECT] = R_Draw2sMultiPatchTranslucentColumn;
colfuncs[COLDRAWFUNC_FOG] = R_DrawFogColumn;
R_SetColumnFunc(BASEDRAWFUNC);
@@ -154,7 +158,6 @@ void SCR_SetMode(void)
// effectively adding massive overhead due to excessive flushing, so we draw our masked thing directly to screen instead
void R_SetColumnContext(enum columncontext_e _columncontext)
{
columncontext = _columncontext;
SCR_SetDrawFuncs(_columncontext); // set our column drawers
}
-2
View File
@@ -1928,8 +1928,6 @@ INT32 I_StartupSystem(void)
SDL_VERSION(&SDLcompiled)
SDL_GetVersion(&SDLlinked);
W_Startup();
I_StartupConsole();
#ifdef NEWSIGNALHANDLER
// This is useful when debugging. It lets GDB attach to
+2 -3
View File
@@ -158,8 +158,7 @@ void W_Shutdown(void)
}
// the lumpnum cache needs to be initialized before use
// call this as early as possible!
void W_Startup(void)
CONSTRUCTOR static void W_Startup(void)
{
lumpnum_map_init(&lumpnumcache);
lumpnum_map_reserve(&lumpnumcache, LUMPNUMCACHESIZE);
@@ -367,7 +366,7 @@ static inline INT32 W_MakeFileMD5(const char *filename, void *resblock)
{
precise_t t = I_GetPreciseTime();
CONS_Debug(DBG_SETUP, "Making MD5 for %s\n",filename);
CONS_Debug(DBG_SETUP, "Making MD5 for %s\n", filename);
if (md5_stream(fhandle, resblock) == 1)
{
-1
View File
@@ -154,7 +154,6 @@ extern wadfile_t *wadfiles[MAX_WADFILES];
// =========================================================================
void W_Startup(void);
void W_Shutdown(void);
// Opens a WAD file. Returns the FILE * handle for the file, or NULL if not found or could not be opened