use nullptr
parent
dc27d1296d
commit
d68b813f44
|
@ -39,7 +39,7 @@ static void setuptqaa(int w, int h)
|
|||
if(!tqaatex[i]) glGenTextures(1, &tqaatex[i]);
|
||||
if(!tqaafbo[i]) glGenFramebuffers_(1, &tqaafbo[i]);
|
||||
glBindFramebuffer_(GL_FRAMEBUFFER, tqaafbo[i]);
|
||||
createtexture(tqaatex[i], w, h, NULL, 3, 1, GL_RGBA8, GL_TEXTURE_RECTANGLE);
|
||||
createtexture(tqaatex[i], w, h, nullptr, 3, 1, GL_RGBA8, GL_TEXTURE_RECTANGLE);
|
||||
glFramebufferTexture2D_(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE, tqaatex[i], 0);
|
||||
bindgdepth();
|
||||
if(glCheckFramebufferStatus_(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
|
||||
|
@ -129,12 +129,12 @@ static void dotqaa(GLuint outfbo = 0)
|
|||
static GLuint fxaafbo = 0, fxaatex = 0;
|
||||
|
||||
static int fxaatype = -1;
|
||||
static Shader *fxaashader = NULL;
|
||||
static Shader *fxaashader = nullptr;
|
||||
|
||||
static void clearfxaashaders()
|
||||
{
|
||||
fxaatype = -1;
|
||||
fxaashader = NULL;
|
||||
fxaashader = nullptr;
|
||||
}
|
||||
|
||||
static void cleanupfxaa()
|
||||
|
@ -168,7 +168,7 @@ static void setupfxaa(int w, int h)
|
|||
if(!fxaatex) glGenTextures(1, &fxaatex);
|
||||
if(!fxaafbo) glGenFramebuffers_(1, &fxaafbo);
|
||||
glBindFramebuffer_(GL_FRAMEBUFFER, fxaafbo);
|
||||
createtexture(fxaatex, w, h, NULL, 3, 1, tqaa || (!fxaagreenluma && !intel_texalpha_bug) ? GL_RGBA8 : GL_RGB, GL_TEXTURE_RECTANGLE);
|
||||
createtexture(fxaatex, w, h, nullptr, 3, 1, tqaa || (!fxaagreenluma && !intel_texalpha_bug) ? GL_RGBA8 : GL_RGB, GL_TEXTURE_RECTANGLE);
|
||||
glFramebufferTexture2D_(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE, fxaatex, 0);
|
||||
bindgdepth();
|
||||
if(glCheckFramebufferStatus_(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
|
||||
|
@ -196,7 +196,7 @@ static GLuint smaaareatex = 0, smaasearchtex = 0, smaafbo[4] = { 0, 0, 0, 0 }, s
|
|||
static int smaasubsampleorder = -1;
|
||||
|
||||
static int smaatype = -1;
|
||||
static Shader *smaalumaedgeshader = NULL, *smaacoloredgeshader = NULL, *smaablendweightshader = NULL, *smaaneighborhoodshader = NULL;
|
||||
static Shader *smaalumaedgeshader = nullptr, *smaacoloredgeshader = nullptr, *smaablendweightshader = nullptr, *smaaneighborhoodshader = nullptr;
|
||||
|
||||
VAR(smaat2x, 1, 0, 0);
|
||||
VAR(smaas2x, 1, 0, 0);
|
||||
|
@ -205,10 +205,10 @@ VAR(smaa4x, 1, 0, 0);
|
|||
static void clearsmaashaders()
|
||||
{
|
||||
smaatype = -1;
|
||||
smaalumaedgeshader = NULL;
|
||||
smaacoloredgeshader = NULL;
|
||||
smaablendweightshader = NULL;
|
||||
smaaneighborhoodshader = NULL;
|
||||
smaalumaedgeshader = nullptr;
|
||||
smaacoloredgeshader = nullptr;
|
||||
smaablendweightshader = nullptr;
|
||||
smaaneighborhoodshader = nullptr;
|
||||
}
|
||||
|
||||
static void cleanupsmaa()
|
||||
|
@ -258,7 +258,7 @@ static void loadsmaashaders(bool split = false)
|
|||
|
||||
if(smaalumaedgeshader && smaacoloredgeshader && smaablendweightshader && smaaneighborhoodshader) return;
|
||||
|
||||
generateshader(NULL, "smaashaders %d \"%s\"", smaaquality, opts);
|
||||
generateshader(nullptr, "smaashaders %d \"%s\"", smaaquality, opts);
|
||||
smaalumaedgeshader = lookupshaderbyname(lumaedgename);
|
||||
if(!smaalumaedgeshader) smaalumaedgeshader = nullshader;
|
||||
smaacoloredgeshader = lookupshaderbyname(coloredgename);
|
||||
|
@ -549,12 +549,12 @@ static void setupsmaa(int w, int h)
|
|||
case 1: format = hasTRG ? GL_RG8 : GL_RGBA8; break;
|
||||
case 2: case 3: format = GL_RGBA8; break;
|
||||
}
|
||||
createtexture(smaatex[i], w, h, NULL, 3, 1, format, GL_TEXTURE_RECTANGLE);
|
||||
createtexture(smaatex[i], w, h, nullptr, 3, 1, format, GL_TEXTURE_RECTANGLE);
|
||||
glFramebufferTexture2D_(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE, smaatex[i], 0);
|
||||
if(!i && split)
|
||||
{
|
||||
if(!smaatex[4]) glGenTextures(1, &smaatex[4]);
|
||||
createtexture(smaatex[4], w, h, NULL, 3, 1, format, GL_TEXTURE_RECTANGLE);
|
||||
createtexture(smaatex[4], w, h, nullptr, 3, 1, format, GL_TEXTURE_RECTANGLE);
|
||||
glFramebufferTexture2D_(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_TEXTURE_RECTANGLE, smaatex[4], 0);
|
||||
static const GLenum drawbufs[2] = { GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1 };
|
||||
glDrawBuffers_(2, drawbufs);
|
||||
|
|
|
@ -116,13 +116,13 @@ struct animmodel : model
|
|||
int cullface;
|
||||
shaderparamskey *key;
|
||||
|
||||
skin() : owner(0), tex(notexture), decal(NULL), masks(notexture), envmap(NULL), normalmap(NULL), shader(NULL), rsmshader(NULL), cullface(1), key(NULL) {}
|
||||
skin() : owner(0), tex(notexture), decal(nullptr), masks(notexture), envmap(nullptr), normalmap(nullptr), shader(nullptr), rsmshader(nullptr), cullface(1), key(nullptr) {}
|
||||
|
||||
bool masked() const { return masks != notexture; }
|
||||
bool envmapped() const { return envmapmax>0; }
|
||||
bool bumpmapped() const { return normalmap != NULL; }
|
||||
bool bumpmapped() const { return normalmap != nullptr; }
|
||||
bool alphatested() const { return alphatest > 0 && tex->type&Texture::ALPHA; }
|
||||
bool decaled() const { return decal != NULL; }
|
||||
bool decaled() const { return decal != nullptr; }
|
||||
|
||||
void setkey()
|
||||
{
|
||||
|
@ -161,7 +161,7 @@ struct animmodel : model
|
|||
{
|
||||
#define DOMODELSHADER(name, body) \
|
||||
do { \
|
||||
static Shader *name##shader = NULL; \
|
||||
static Shader *name##shader = nullptr; \
|
||||
if(!name##shader) name##shader = useshaderbyname(#name); \
|
||||
body; \
|
||||
} while(0)
|
||||
|
@ -202,7 +202,7 @@ struct animmodel : model
|
|||
|
||||
void cleanup()
|
||||
{
|
||||
if(shader && shader->standard) shader = NULL;
|
||||
if(shader && shader->standard) shader = nullptr;
|
||||
}
|
||||
|
||||
void preloadBIH()
|
||||
|
@ -300,7 +300,7 @@ struct animmodel : model
|
|||
char *name;
|
||||
bool cancollide, canrender, noclip;
|
||||
|
||||
mesh() : group(NULL), name(NULL), cancollide(true), canrender(true), noclip(false)
|
||||
mesh() : group(nullptr), name(nullptr), cancollide(true), canrender(true), noclip(false)
|
||||
{
|
||||
}
|
||||
|
||||
|
@ -506,7 +506,7 @@ struct animmodel : model
|
|||
char *name;
|
||||
vector<mesh *> meshes;
|
||||
|
||||
meshgroup() : next(NULL), shared(0), name(NULL)
|
||||
meshgroup() : next(nullptr), shared(0), name(nullptr)
|
||||
{
|
||||
}
|
||||
|
||||
|
@ -627,7 +627,7 @@ struct animmodel : model
|
|||
vec *pos;
|
||||
matrix4 matrix;
|
||||
|
||||
linkedpart() : p(NULL), tag(-1), anim(-1), basetime(0), translate(0, 0, 0), pos(NULL) {}
|
||||
linkedpart() : p(nullptr), tag(-1), anim(-1), basetime(0), translate(0, 0, 0), pos(nullptr) {}
|
||||
};
|
||||
|
||||
struct part
|
||||
|
@ -641,9 +641,9 @@ struct animmodel : model
|
|||
int numanimparts;
|
||||
float pitchscale, pitchoffset, pitchmin, pitchmax;
|
||||
|
||||
part(animmodel *model, int index = 0) : model(model), index(index), meshes(NULL), numanimparts(1), pitchscale(1), pitchoffset(0), pitchmin(0), pitchmax(0)
|
||||
part(animmodel *model, int index = 0) : model(model), index(index), meshes(nullptr), numanimparts(1), pitchscale(1), pitchoffset(0), pitchmin(0), pitchmax(0)
|
||||
{
|
||||
loopk(MAXANIMPARTS) anims[k] = NULL;
|
||||
loopk(MAXANIMPARTS) anims[k] = nullptr;
|
||||
}
|
||||
virtual ~part()
|
||||
{
|
||||
|
@ -703,7 +703,7 @@ struct animmodel : model
|
|||
}
|
||||
}
|
||||
|
||||
bool link(part *p, const char *tag, const vec &translate = vec(0, 0, 0), int anim = -1, int basetime = 0, vec *pos = NULL)
|
||||
bool link(part *p, const char *tag, const vec &translate = vec(0, 0, 0), int anim = -1, int basetime = 0, vec *pos = nullptr)
|
||||
{
|
||||
int i = meshes ? meshes->findtag(tag) : -1;
|
||||
if(i<0)
|
||||
|
@ -785,7 +785,7 @@ struct animmodel : model
|
|||
}
|
||||
else
|
||||
{
|
||||
animspec *spec = NULL;
|
||||
animspec *spec = nullptr;
|
||||
if(anims[animpart])
|
||||
{
|
||||
vector<animspec> &primary = anims[animpart][anim&ANIM_INDEX];
|
||||
|
@ -1222,7 +1222,7 @@ struct animmodel : model
|
|||
animmodel *m = (animmodel *)a[i].m;
|
||||
if(!m)
|
||||
{
|
||||
if(a[i].pos) link(NULL, a[i].tag, vec(0, 0, 0), 0, 0, a[i].pos);
|
||||
if(a[i].pos) link(nullptr, a[i].tag, vec(0, 0, 0), 0, 0, a[i].pos);
|
||||
continue;
|
||||
}
|
||||
part *p = m->parts[0];
|
||||
|
@ -1266,7 +1266,7 @@ struct animmodel : model
|
|||
animmodel *m = (animmodel *)a[i].m;
|
||||
if(!m)
|
||||
{
|
||||
if(a[i].pos) unlink(NULL);
|
||||
if(a[i].pos) unlink(nullptr);
|
||||
continue;
|
||||
}
|
||||
part *p = m->parts[0];
|
||||
|
@ -1444,7 +1444,7 @@ struct animmodel : model
|
|||
return bih;
|
||||
}
|
||||
|
||||
bool link(part *p, const char *tag, const vec &translate = vec(0, 0, 0), int anim = -1, int basetime = 0, vec *pos = NULL)
|
||||
bool link(part *p, const char *tag, const vec &translate = vec(0, 0, 0), int anim = -1, int basetime = 0, vec *pos = nullptr)
|
||||
{
|
||||
if(parts.empty()) return false;
|
||||
return parts[0]->link(p, tag, translate, anim, basetime, pos);
|
||||
|
@ -1631,7 +1631,7 @@ struct animmodel : model
|
|||
enabletc = enabletangents = enablebones = enabledepthoffset = false;
|
||||
enablecullface = true;
|
||||
lastvbuf = lasttcbuf = lastxbuf = lastbbuf = lastebuf = lastenvmaptex = closestenvmaptex = 0;
|
||||
lasttex = lastdecal = lastmasks = lastnormalmap = NULL;
|
||||
lasttex = lastdecal = lastmasks = lastnormalmap = nullptr;
|
||||
shaderparamskey::invalidate();
|
||||
}
|
||||
|
||||
|
@ -1685,7 +1685,7 @@ float animmodel::sizescale = 1;
|
|||
vec4 animmodel::colorscale(1, 1, 1, 1);
|
||||
GLuint animmodel::lastvbuf = 0, animmodel::lasttcbuf = 0, animmodel::lastxbuf = 0, animmodel::lastbbuf = 0, animmodel::lastebuf = 0,
|
||||
animmodel::lastenvmaptex = 0, animmodel::closestenvmaptex = 0;
|
||||
Texture *animmodel::lasttex = NULL, *animmodel::lastdecal = NULL, *animmodel::lastmasks = NULL, *animmodel::lastnormalmap = NULL;
|
||||
Texture *animmodel::lasttex = nullptr, *animmodel::lastdecal = nullptr, *animmodel::lastmasks = nullptr, *animmodel::lastnormalmap = nullptr;
|
||||
int animmodel::matrixpos = 0;
|
||||
matrix4 animmodel::matrixstack[64];
|
||||
|
||||
|
@ -1720,7 +1720,7 @@ template<class MDL, class BASE> struct modelloader : BASE
|
|||
|
||||
void endload()
|
||||
{
|
||||
loading = NULL;
|
||||
loading = nullptr;
|
||||
}
|
||||
|
||||
bool loadconfig()
|
||||
|
@ -1735,7 +1735,7 @@ template<class MDL, class BASE> struct modelloader : BASE
|
|||
}
|
||||
};
|
||||
|
||||
template<class MDL, class BASE> MDL *modelloader<MDL, BASE>::loading = NULL;
|
||||
template<class MDL, class BASE> MDL *modelloader<MDL, BASE>::loading = nullptr;
|
||||
template<class MDL, class BASE> string modelloader<MDL, BASE>::dir = {'\0'}; // crashes clang if "" is used here
|
||||
|
||||
template<class MDL, class MESH> struct modelcommands
|
||||
|
|
|
@ -236,7 +236,7 @@ void BIH::build(mesh &m, ushort *indices, int numindices, const ivec &vmin, cons
|
|||
}
|
||||
|
||||
BIH::BIH(vector<mesh> &buildmeshes)
|
||||
: meshes(NULL), nummeshes(0), nodes(NULL), numnodes(0), tribbs(NULL), numtris(0), bbmin(1e16f, 1e16f, 1e16f), bbmax(-1e16f, -1e16f, -1e16f), center(0, 0, 0), radius(0), entradius(0)
|
||||
: meshes(nullptr), nummeshes(0), nodes(nullptr), numnodes(0), tribbs(nullptr), numtris(0), bbmin(1e16f, 1e16f, 1e16f), bbmax(-1e16f, -1e16f, -1e16f), center(0, 0, 0), radius(0), entradius(0)
|
||||
{
|
||||
if(buildmeshes.empty()) return;
|
||||
loopv(buildmeshes) numtris += buildmeshes[i].numtris;
|
||||
|
|
|
@ -57,7 +57,7 @@ struct BIH
|
|||
int flags;
|
||||
vec bbmin, bbmax;
|
||||
|
||||
mesh() : numnodes(0), numtris(0), tex(NULL), flags(0) {}
|
||||
mesh() : numnodes(0), numtris(0), tex(nullptr), flags(0) {}
|
||||
|
||||
vec getpos(int i) const { return *(const vec *)(pos + i*posstride); }
|
||||
vec2 gettc(int i) const { return *(const vec2 *)(tc + i*tcstride); }
|
||||
|
|
|
@ -135,7 +135,7 @@ struct BlendMapCache
|
|||
|
||||
BlendMapCache *newblendmapcache() { return new BlendMapCache; }
|
||||
|
||||
void freeblendmapcache(BlendMapCache *&cache) { delete cache; cache = NULL; }
|
||||
void freeblendmapcache(BlendMapCache *&cache) { delete cache; cache = nullptr; }
|
||||
|
||||
bool setblendmaporigin(BlendMapCache *cache, const ivec &o, int size)
|
||||
{
|
||||
|
@ -648,7 +648,7 @@ struct BlendTexture
|
|||
GLenum format;
|
||||
bool valid;
|
||||
|
||||
BlendTexture() : x(0), y(0), size(0), data(NULL), tex(0), format(GL_FALSE), valid(false)
|
||||
BlendTexture() : x(0), y(0), size(0), data(nullptr), tex(0), format(GL_FALSE), valid(false)
|
||||
{}
|
||||
|
||||
~BlendTexture()
|
||||
|
@ -666,7 +666,7 @@ struct BlendTexture
|
|||
if(data) delete[] data;
|
||||
data = new uchar[size*size];
|
||||
format = hasTRG ? GL_RED : GL_LUMINANCE;
|
||||
createtexture(tex, size, size, NULL, 3, 1, hasTRG ? GL_R8 : GL_LUMINANCE8);
|
||||
createtexture(tex, size, size, nullptr, 3, 1, hasTRG ? GL_R8 : GL_LUMINANCE8);
|
||||
valid = false;
|
||||
return true;
|
||||
}
|
||||
|
@ -674,7 +674,7 @@ struct BlendTexture
|
|||
void cleanup()
|
||||
{
|
||||
if(tex) { glDeleteTextures(1, &tex); tex = 0; }
|
||||
if(data) { delete[] data; data = NULL; }
|
||||
if(data) { delete[] data; data = nullptr; }
|
||||
size = 0;
|
||||
valid = false;
|
||||
}
|
||||
|
@ -830,7 +830,7 @@ static void updateblendtextures(uchar &type, BlendMapNode &node, int bmx, int bm
|
|||
ty2 = (min(bmy+bmsize, uy+uh) + (0x1000>>BM_SCALE)-1)&~((0x1000>>BM_SCALE)-1);
|
||||
for(int ty = ty1; ty < ty2; ty += 0x1000>>BM_SCALE) for(int tx = tx1; tx < tx2; tx += 0x1000>>BM_SCALE)
|
||||
{
|
||||
BlendTexture *bt = NULL;
|
||||
BlendTexture *bt = nullptr;
|
||||
loopv(blendtexs) if(blendtexs[i].contains(tx<<BM_SCALE, ty<<BM_SCALE)) { bt = &blendtexs[i]; break; }
|
||||
if(!bt)
|
||||
{
|
||||
|
|
|
@ -10,7 +10,7 @@
|
|||
|
||||
hashnameset<ident> idents; // contains ALL vars/commands/aliases
|
||||
vector<ident *> identmap;
|
||||
ident *dummyident = NULL;
|
||||
ident *dummyident = nullptr;
|
||||
|
||||
int identflags = 0;
|
||||
|
||||
|
@ -112,7 +112,7 @@ static inline void cleancode(ident &id)
|
|||
{
|
||||
id.code[0] -= 0x100;
|
||||
if(int(id.code[0]) < 0x100) delete[] id.code;
|
||||
id.code = NULL;
|
||||
id.code = nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -173,7 +173,7 @@ void clearoverrides()
|
|||
}
|
||||
|
||||
static bool initedidents = false;
|
||||
static vector<ident> *identinits = NULL;
|
||||
static vector<ident> *identinits = nullptr;
|
||||
|
||||
static inline ident *addident(const ident &id)
|
||||
{
|
||||
|
@ -181,7 +181,7 @@ static inline ident *addident(const ident &id)
|
|||
{
|
||||
if(!identinits) identinits = new vector<ident>;
|
||||
identinits->add(id);
|
||||
return NULL;
|
||||
return nullptr;
|
||||
}
|
||||
ident &def = idents.access(id.name, id);
|
||||
def.index = identmap.length();
|
||||
|
@ -206,7 +206,7 @@ static bool initidents()
|
|||
}
|
||||
UNUSED static bool forceinitidents = initidents();
|
||||
|
||||
static const char *sourcefile = NULL, *sourcestr = NULL;
|
||||
static const char *sourcefile = nullptr, *sourcestr = nullptr;
|
||||
|
||||
static const char *debugline(const char *p, const char *fmt)
|
||||
{
|
||||
|
@ -237,7 +237,7 @@ static struct identlink
|
|||
identlink *next;
|
||||
int usedargs;
|
||||
identstack *argstack;
|
||||
} noalias = { NULL, NULL, (1<<MAXARGS)-1, NULL }, *aliasstack = &noalias;
|
||||
} noalias = { nullptr, nullptr, (1<<MAXARGS)-1, nullptr }, *aliasstack = &noalias;
|
||||
|
||||
VAR(dbgalias, 0, 4, 1000);
|
||||
|
||||
|
@ -463,7 +463,7 @@ ident *readident(const char *name)
|
|||
{
|
||||
ident *id = idents.access(name);
|
||||
if(id && id->index < MAXARGS && !(aliasstack->usedargs&(1<<id->index)))
|
||||
return NULL;
|
||||
return nullptr;
|
||||
return id;
|
||||
}
|
||||
|
||||
|
@ -579,7 +579,7 @@ struct defvar : identval
|
|||
char *name;
|
||||
uint *onchange;
|
||||
|
||||
defvar() : name(NULL), onchange(NULL) {}
|
||||
defvar() : name(nullptr), onchange(nullptr) {}
|
||||
|
||||
~defvar()
|
||||
{
|
||||
|
@ -603,18 +603,18 @@ hashnameset<defvar> defvars;
|
|||
name = newstring(name); \
|
||||
defvar &def = defvars[name]; \
|
||||
def.name = name; \
|
||||
def.onchange = onchange[0] ? compilecode(onchange) : NULL; \
|
||||
def.onchange = onchange[0] ? compilecode(onchange) : nullptr; \
|
||||
body; \
|
||||
});
|
||||
#define DEFIVAR(cmdname, flags) \
|
||||
DEFVAR(cmdname, "siiis", (char *name, int *min, int *cur, int *max, char *onchange), \
|
||||
def.i = variable(name, *min, *cur, *max, &def.i, def.onchange ? defvar::changed : NULL, flags))
|
||||
def.i = variable(name, *min, *cur, *max, &def.i, def.onchange ? defvar::changed : nullptr, flags))
|
||||
#define DEFFVAR(cmdname, flags) \
|
||||
DEFVAR(cmdname, "sfffs", (char *name, float *min, float *cur, float *max, char *onchange), \
|
||||
def.f = fvariable(name, *min, *cur, *max, &def.f, def.onchange ? defvar::changed : NULL, flags))
|
||||
def.f = fvariable(name, *min, *cur, *max, &def.f, def.onchange ? defvar::changed : nullptr, flags))
|
||||
#define DEFSVAR(cmdname, flags) \
|
||||
DEFVAR(cmdname, "sss", (char *name, char *cur, char *onchange), \
|
||||
def.s = svariable(name, cur, &def.s, def.onchange ? defvar::changed : NULL, flags))
|
||||
def.s = svariable(name, cur, &def.s, def.onchange ? defvar::changed : nullptr, flags))
|
||||
|
||||
DEFIVAR(defvar, 0);
|
||||
DEFIVAR(defvarp, IDF_PERSIST);
|
||||
|
@ -698,7 +698,7 @@ ICOMMAND(getvarmax, "s", (char *s), intret(getvarmax(s)));
|
|||
ICOMMAND(getfvarmin, "s", (char *s), floatret(getfvarmin(s)));
|
||||
ICOMMAND(getfvarmax, "s", (char *s), floatret(getfvarmax(s)));
|
||||
|
||||
bool identexists(const char *name) { return idents.access(name)!=NULL; }
|
||||
bool identexists(const char *name) { return idents.access(name)!=nullptr; }
|
||||
ICOMMAND(identexists, "s", (char *s), intret(identexists(s) ? 1 : 0));
|
||||
|
||||
ident *getident(const char *name) { return idents.access(name); }
|
||||
|
@ -869,7 +869,7 @@ int unescapestring(char *dst, const char *src, const char *end)
|
|||
return dst - start;
|
||||
}
|
||||
|
||||
static char *conc(vector<char> &buf, tagval *v, int n, bool space, const char *prefix = NULL, int prefixlen = 0)
|
||||
static char *conc(vector<char> &buf, tagval *v, int n, bool space, const char *prefix = nullptr, int prefixlen = 0)
|
||||
{
|
||||
if(prefix)
|
||||
{
|
||||
|
@ -952,7 +952,7 @@ overflow:
|
|||
|
||||
static inline char *conc(tagval *v, int n, bool space)
|
||||
{
|
||||
return conc(v, n, space, NULL, 0);
|
||||
return conc(v, n, space, nullptr, 0);
|
||||
}
|
||||
|
||||
static inline char *conc(tagval *v, int n, bool space, const char *prefix)
|
||||
|
@ -1031,7 +1031,7 @@ static inline char *cutword(const char *&p)
|
|||
{
|
||||
const char *word = p;
|
||||
p = parseword(p);
|
||||
return p!=word ? newstring(word, p-word) : NULL;
|
||||
return p!=word ? newstring(word, p-word) : nullptr;
|
||||
}
|
||||
|
||||
#define retcode(type, defaultret) ((type) >= VAL_ANY ? ((type) == VAL_CSTR ? RET_STR : (defaultret)) : (type) << CODE_RET)
|
||||
|
@ -1203,7 +1203,7 @@ static inline bool getbool(const tagval &v)
|
|||
}
|
||||
}
|
||||
|
||||
static inline void compileval(vector<uint> &code, int wordtype, const stringslice &word = stringslice(NULL, 0))
|
||||
static inline void compileval(vector<uint> &code, int wordtype, const stringslice &word = stringslice(nullptr, 0))
|
||||
{
|
||||
switch(wordtype)
|
||||
{
|
||||
|
@ -1220,7 +1220,7 @@ static inline void compileval(vector<uint> &code, int wordtype, const stringslic
|
|||
}
|
||||
}
|
||||
|
||||
static stringslice unusedword(NULL, 0);
|
||||
static stringslice unusedword(nullptr, 0);
|
||||
static bool compilearg(vector<uint> &code, const char *&p, int wordtype, int prevargs = MAXRESULTS, stringslice &word = unusedword);
|
||||
|
||||
static void compilelookup(vector<uint> &code, const char *&p, int ltype, int prevargs = MAXRESULTS)
|
||||
|
@ -1298,7 +1298,7 @@ static void compilelookup(vector<uint> &code, const char *&p, int ltype, int pre
|
|||
for(const char *fmt = id->args; *fmt; fmt++) switch(*fmt)
|
||||
{
|
||||
case 'S': compilestr(code); numargs++; break;
|
||||
case 's': compilestr(code, NULL, 0, true); numargs++; break;
|
||||
case 's': compilestr(code, nullptr, 0, true); numargs++; break;
|
||||
case 'i': compileint(code); numargs++; break;
|
||||
case 'b': compileint(code, INT_MIN); numargs++; break;
|
||||
case 'f': compilefloat(code); numargs++; break;
|
||||
|
@ -1536,7 +1536,7 @@ done:
|
|||
case VAL_CODE: if(!concs && p-1 <= start) compileblock(code); else code.add(CODE_COMPILE); break;
|
||||
case VAL_IDENT: if(!concs && p-1 <= start) compileident(code); else code.add(CODE_IDENTU); break;
|
||||
case VAL_CSTR: case VAL_CANY:
|
||||
if(!concs && p-1 <= start) compilestr(code, NULL, 0, true);
|
||||
if(!concs && p-1 <= start) compilestr(code, nullptr, 0, true);
|
||||
break;
|
||||
case VAL_STR: case VAL_NULL: case VAL_ANY: case VAL_WORD:
|
||||
if(!concs && p-1 <= start) compilestr(code);
|
||||
|
@ -1674,7 +1674,7 @@ static void compilestatements(vector<uint> &code, const char *&p, int rettype, i
|
|||
for(;;)
|
||||
{
|
||||
skipcomments(p);
|
||||
idname.str = NULL;
|
||||
idname.str = nullptr;
|
||||
bool more = compilearg(code, p, VAL_WORD, prevargs, idname);
|
||||
if(!more) goto endstatement;
|
||||
skipcomments(p);
|
||||
|
@ -1760,7 +1760,7 @@ static void compilestatements(vector<uint> &code, const char *&p, int rettype, i
|
|||
if(!more)
|
||||
{
|
||||
if(rep) break;
|
||||
compilestr(code, NULL, 0, *fmt=='s');
|
||||
compilestr(code, nullptr, 0, *fmt=='s');
|
||||
fakeargs++;
|
||||
}
|
||||
else if(!fmt[1])
|
||||
|
@ -2906,7 +2906,7 @@ char *executestr(const uint *code)
|
|||
{
|
||||
tagval result;
|
||||
runcode(code, result);
|
||||
if(result.type == VAL_NULL) return NULL;
|
||||
if(result.type == VAL_NULL) return nullptr;
|
||||
forcestr(result);
|
||||
return result.s;
|
||||
}
|
||||
|
@ -2915,7 +2915,7 @@ char *executestr(const char *p)
|
|||
{
|
||||
tagval result;
|
||||
executeret(p, result);
|
||||
if(result.type == VAL_NULL) return NULL;
|
||||
if(result.type == VAL_NULL) return nullptr;
|
||||
forcestr(result);
|
||||
return result.s;
|
||||
}
|
||||
|
@ -2924,7 +2924,7 @@ char *executestr(ident *id, tagval *args, int numargs, bool lookup)
|
|||
{
|
||||
tagval result;
|
||||
executeret(id, args, numargs, lookup, result);
|
||||
if(result.type == VAL_NULL) return NULL;
|
||||
if(result.type == VAL_NULL) return nullptr;
|
||||
forcestr(result);
|
||||
return result.s;
|
||||
}
|
||||
|
@ -2932,7 +2932,7 @@ char *executestr(ident *id, tagval *args, int numargs, bool lookup)
|
|||
char *execidentstr(const char *name, bool lookup)
|
||||
{
|
||||
ident *id = idents.access(name);
|
||||
return id ? executestr(id, NULL, 0, lookup) : NULL;
|
||||
return id ? executestr(id, nullptr, 0, lookup) : nullptr;
|
||||
}
|
||||
|
||||
int execute(const uint *code)
|
||||
|
@ -2969,7 +2969,7 @@ int execute(ident *id, tagval *args, int numargs, bool lookup)
|
|||
int execident(const char *name, int noid, bool lookup)
|
||||
{
|
||||
ident *id = idents.access(name);
|
||||
return id ? execute(id, NULL, 0, lookup) : noid;
|
||||
return id ? execute(id, nullptr, 0, lookup) : noid;
|
||||
}
|
||||
|
||||
float executefloat(const uint *code)
|
||||
|
@ -3002,7 +3002,7 @@ float executefloat(ident *id, tagval *args, int numargs, bool lookup)
|
|||
float execidentfloat(const char *name, float noid, bool lookup)
|
||||
{
|
||||
ident *id = idents.access(name);
|
||||
return id ? executefloat(id, NULL, 0, lookup) : noid;
|
||||
return id ? executefloat(id, nullptr, 0, lookup) : noid;
|
||||
}
|
||||
|
||||
bool executebool(const uint *code)
|
||||
|
@ -3035,14 +3035,14 @@ bool executebool(ident *id, tagval *args, int numargs, bool lookup)
|
|||
bool execidentbool(const char *name, bool noid, bool lookup)
|
||||
{
|
||||
ident *id = idents.access(name);
|
||||
return id ? executebool(id, NULL, 0, lookup) : noid;
|
||||
return id ? executebool(id, nullptr, 0, lookup) : noid;
|
||||
}
|
||||
|
||||
bool execfile(const char *cfgfile, bool msg)
|
||||
{
|
||||
string s;
|
||||
copystring(s, cfgfile);
|
||||
char *buf = loadfile(path(s), NULL);
|
||||
char *buf = loadfile(path(s), nullptr);
|
||||
if(!buf)
|
||||
{
|
||||
if(msg) conoutf(CON_ERROR, "could not read \"%s\"", cfgfile);
|
||||
|
@ -3420,7 +3420,7 @@ void format(tagval *args, int numargs)
|
|||
}
|
||||
COMMAND(format, "V");
|
||||
|
||||
static const char *liststart = NULL, *listend = NULL, *listquotestart = NULL, *listquoteend = NULL;
|
||||
static const char *liststart = nullptr, *listend = nullptr, *listquotestart = nullptr, *listquoteend = nullptr;
|
||||
|
||||
static inline void skiplist(const char *&p)
|
||||
{
|
||||
|
@ -3823,7 +3823,7 @@ ICOMMAND(loopfiles, "rsse", (ident *id, char *dir, char *ext, uint *body),
|
|||
if(id->type!=ID_ALIAS) return;
|
||||
identstack stack;
|
||||
vector<char *> files;
|
||||
listfiles(dir, ext[0] ? ext : NULL, files);
|
||||
listfiles(dir, ext[0] ? ext : nullptr, files);
|
||||
files.sort();
|
||||
files.uniquedeletearrays();
|
||||
loopv(files)
|
||||
|
@ -3911,7 +3911,7 @@ void sortlist(char *list, ident *x, ident *y, uint *body, uint *unique)
|
|||
for(int i = 1; i < items.length(); i++)
|
||||
{
|
||||
sortitem &item = items[i];
|
||||
if(f(items[i-1], item)) item.quotestart = NULL;
|
||||
if(f(items[i-1], item)) item.quotestart = nullptr;
|
||||
else { totalunique += item.quotelength(); numunique++; }
|
||||
}
|
||||
}
|
||||
|
@ -3927,7 +3927,7 @@ void sortlist(char *list, ident *x, ident *y, uint *body, uint *unique)
|
|||
loopj(i)
|
||||
{
|
||||
sortitem &prev = items[j];
|
||||
if(prev.quotestart && f(item, prev)) { item.quotestart = NULL; break; }
|
||||
if(prev.quotestart && f(item, prev)) { item.quotestart = nullptr; break; }
|
||||
}
|
||||
if(item.quotestart) { totalunique += item.quotelength(); numunique++; }
|
||||
}
|
||||
|
@ -3959,7 +3959,7 @@ void sortlist(char *list, ident *x, ident *y, uint *body, uint *unique)
|
|||
commandret->setstr(sorted);
|
||||
}
|
||||
COMMAND(sortlist, "srree");
|
||||
ICOMMAND(uniquelist, "srre", (char *list, ident *x, ident *y, uint *body), sortlist(list, x, y, NULL, body));
|
||||
ICOMMAND(uniquelist, "srre", (char *list, ident *x, ident *y, uint *body), sortlist(list, x, y, nullptr, body));
|
||||
|
||||
#define MATHCMD(name, fmt, type, op, initval, unaryop) \
|
||||
ICOMMANDS(name, #fmt "1V", (tagval *args, int numargs), \
|
||||
|
@ -4282,7 +4282,7 @@ void checksleep(int millis)
|
|||
if(millis - s.millis >= s.delay)
|
||||
{
|
||||
char *cmd = s.command; // execute might create more sleep commands
|
||||
s.command = NULL;
|
||||
s.command = nullptr;
|
||||
int oldflags = identflags;
|
||||
identflags = s.flags;
|
||||
execute(cmd);
|
||||
|
|
|
@ -8,7 +8,7 @@ extern hashnameset<ident> idents;
|
|||
extern int identflags;
|
||||
|
||||
void clearoverrides();
|
||||
void writecfg(const char *name = NULL);
|
||||
void writecfg(const char *name = nullptr);
|
||||
|
||||
void checksleep(int millis);
|
||||
void clearsleep(bool clearoverrides = true);
|
||||
|
|
|
@ -19,7 +19,7 @@ static reversequeue<cline, MAXCONLINES> conlines;
|
|||
|
||||
static int commandmillis = -1;
|
||||
static string commandbuf;
|
||||
static char *commandaction = NULL, *commandprompt = NULL;
|
||||
static char *commandaction = nullptr, *commandprompt = nullptr;
|
||||
enum { CF_COMPLETE = 1<<0, CF_EXECUTE = 1<<1 };
|
||||
static int commandflags = 0, commandpos = -1;
|
||||
|
||||
|
@ -187,7 +187,7 @@ struct keym
|
|||
char *actions[NUMACTIONS];
|
||||
bool pressed;
|
||||
|
||||
keym() : code(-1), name(NULL), pressed(false) { loopi(NUMACTIONS) actions[i] = newstring(""); }
|
||||
keym() : code(-1), name(nullptr), pressed(false) { loopi(NUMACTIONS) actions[i] = newstring(""); }
|
||||
~keym() { DELETEA(name); loopi(NUMACTIONS) DELETEA(actions[i]); }
|
||||
|
||||
void clear(int type);
|
||||
|
@ -207,14 +207,14 @@ static void keymap(int *code, char *key)
|
|||
|
||||
COMMAND(keymap, "is");
|
||||
|
||||
static keym *keypressed = NULL;
|
||||
static char *keyaction = NULL;
|
||||
static keym *keypressed = nullptr;
|
||||
static char *keyaction = nullptr;
|
||||
|
||||
#if 0
|
||||
static const char *getkeyname(int code)
|
||||
{
|
||||
keym *km = keyms.access(code);
|
||||
return km ? km->name : NULL;
|
||||
return km ? km->name : nullptr;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
@ -239,7 +239,7 @@ static keym *findbind(char *key)
|
|||
{
|
||||
if(!strcasecmp(km.name, key)) return &km;
|
||||
});
|
||||
return NULL;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
static void getbind(char *key, int type)
|
||||
|
@ -287,7 +287,7 @@ ICOMMAND(clearspecbinds, "", (), enumerate(keyms, keym, km, km.clear(keym::ACTIO
|
|||
ICOMMAND(cleareditbinds, "", (), enumerate(keyms, keym, km, km.clear(keym::ACTION_EDITING)));
|
||||
ICOMMAND(clearallbinds, "", (), enumerate(keyms, keym, km, km.clear()));
|
||||
|
||||
static void inputcommand(char *init, char *action = NULL, char *prompt = NULL, char *flags = NULL) // turns input to the command line on or off
|
||||
static void inputcommand(char *init, char *action = nullptr, char *prompt = nullptr, char *flags = nullptr) // turns input to the command line on or off
|
||||
{
|
||||
commandmillis = init ? totalmillis : -1;
|
||||
textinput(commandmillis >= 0, TI_CONSOLE);
|
||||
|
@ -328,7 +328,7 @@ struct hline
|
|||
char *buf, *action, *prompt;
|
||||
int flags;
|
||||
|
||||
hline() : buf(NULL), action(NULL), prompt(NULL), flags(0) {}
|
||||
hline() : buf(nullptr), action(nullptr), prompt(nullptr), flags(0) {}
|
||||
~hline()
|
||||
{
|
||||
DELETEA(buf);
|
||||
|
@ -350,8 +350,8 @@ struct hline
|
|||
bool shouldsave()
|
||||
{
|
||||
return strcmp(commandbuf, buf) ||
|
||||
(commandaction ? !action || strcmp(commandaction, action) : action!=NULL) ||
|
||||
(commandprompt ? !prompt || strcmp(commandprompt, prompt) : prompt!=NULL) ||
|
||||
(commandaction ? !action || strcmp(commandaction, action) : action!=nullptr) ||
|
||||
(commandprompt ? !prompt || strcmp(commandprompt, prompt) : prompt!=nullptr) ||
|
||||
commandflags != flags;
|
||||
}
|
||||
|
||||
|
@ -407,7 +407,7 @@ static vector<releaseaction> releaseactions;
|
|||
|
||||
const char *addreleaseaction(char *s)
|
||||
{
|
||||
if(!keypressed) { delete[] s; return NULL; }
|
||||
if(!keypressed) { delete[] s; return nullptr; }
|
||||
releaseaction &ra = releaseactions.add();
|
||||
ra.key = keypressed;
|
||||
ra.action = s;
|
||||
|
@ -417,7 +417,7 @@ const char *addreleaseaction(char *s)
|
|||
|
||||
tagval *addreleaseaction(ident *id, int numargs)
|
||||
{
|
||||
if(!keypressed || numargs > 3) return NULL;
|
||||
if(!keypressed || numargs > 3) return nullptr;
|
||||
releaseaction &ra = releaseactions.add();
|
||||
ra.key = keypressed;
|
||||
ra.id = id;
|
||||
|
@ -444,7 +444,7 @@ static void execbind(keym &k, bool isdown)
|
|||
if(!isdown) execute(ra.action);
|
||||
delete[] ra.action;
|
||||
}
|
||||
else execute(isdown ? NULL : ra.id, ra.args, ra.numargs);
|
||||
else execute(isdown ? nullptr : ra.id, ra.args, ra.numargs);
|
||||
releaseactions.remove(i--);
|
||||
}
|
||||
}
|
||||
|
@ -460,7 +460,7 @@ static void execbind(keym &k, bool isdown)
|
|||
keyaction = action;
|
||||
keypressed = &k;
|
||||
execute(keyaction);
|
||||
keypressed = NULL;
|
||||
keypressed = nullptr;
|
||||
if(keyaction!=action) delete[] keyaction;
|
||||
}
|
||||
k.pressed = isdown;
|
||||
|
@ -556,7 +556,7 @@ static bool consolekey(int code, bool isdown)
|
|||
case SDLK_TAB:
|
||||
if(commandflags&CF_COMPLETE)
|
||||
{
|
||||
complete(commandbuf, sizeof(commandbuf), commandflags&CF_EXECUTE ? "/" : NULL);
|
||||
complete(commandbuf, sizeof(commandbuf), commandflags&CF_EXECUTE ? "/" : nullptr);
|
||||
if(commandpos>=0 && commandpos>=(int)strlen(commandbuf)) commandpos = -1;
|
||||
}
|
||||
break;
|
||||
|
@ -570,7 +570,7 @@ static bool consolekey(int code, bool isdown)
|
|||
{
|
||||
if(code==SDLK_RETURN || code==SDLK_KP_ENTER)
|
||||
{
|
||||
hline *h = NULL;
|
||||
hline *h = nullptr;
|
||||
if(commandbuf[0])
|
||||
{
|
||||
if(history.empty() || history.last()->shouldsave())
|
||||
|
@ -585,13 +585,13 @@ static bool consolekey(int code, bool isdown)
|
|||
else h = history.last();
|
||||
}
|
||||
histpos = history.length();
|
||||
inputcommand(NULL);
|
||||
inputcommand(nullptr);
|
||||
if(h) h->run();
|
||||
}
|
||||
else if(code==SDLK_ESCAPE)
|
||||
{
|
||||
histpos = history.length();
|
||||
inputcommand(NULL);
|
||||
inputcommand(nullptr);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -670,7 +670,7 @@ struct filesval
|
|||
vector<char *> files;
|
||||
int millis;
|
||||
|
||||
filesval(int type, const char *dir, const char *ext) : type(type), dir(newstring(dir)), ext(ext && ext[0] ? newstring(ext) : NULL), millis(-1) {}
|
||||
filesval(int type, const char *dir, const char *ext) : type(type), dir(newstring(dir)), ext(ext && ext[0] ? newstring(ext) : nullptr), millis(-1) {}
|
||||
~filesval() { DELETEA(dir); DELETEA(ext); files.deletearrays(); }
|
||||
|
||||
void update()
|
||||
|
@ -698,7 +698,7 @@ static hashtable<fileskey, filesval *> completefiles;
|
|||
static hashtable<char *, filesval *> completions;
|
||||
|
||||
static int completesize = 0;
|
||||
static char *lastcomplete = NULL;
|
||||
static char *lastcomplete = nullptr;
|
||||
|
||||
static void resetcomplete() { completesize = 0; }
|
||||
|
||||
|
@ -712,7 +712,7 @@ static void addcomplete(char *command, int type, char *dir, char *ext)
|
|||
if(!dir[0])
|
||||
{
|
||||
filesval **hasfiles = completions.access(command);
|
||||
if(hasfiles) *hasfiles = NULL;
|
||||
if(hasfiles) *hasfiles = nullptr;
|
||||
return;
|
||||
}
|
||||
if(type==FILES_DIR)
|
||||
|
@ -723,7 +723,7 @@ static void addcomplete(char *command, int type, char *dir, char *ext)
|
|||
if(ext)
|
||||
{
|
||||
if(strchr(ext, '*')) ext[0] = '\0';
|
||||
if(!ext[0]) ext = NULL;
|
||||
if(!ext[0]) ext = nullptr;
|
||||
}
|
||||
}
|
||||
fileskey key(type, dir, ext);
|
||||
|
@ -747,7 +747,7 @@ static void addfilecomplete(char *command, char *dir, char *ext)
|
|||
|
||||
static void addlistcomplete(char *command, char *list)
|
||||
{
|
||||
addcomplete(command, FILES_LIST, list, NULL);
|
||||
addcomplete(command, FILES_LIST, list, nullptr);
|
||||
}
|
||||
|
||||
COMMANDN(complete, addfilecomplete, "sss");
|
||||
|
@ -764,14 +764,14 @@ static void complete(char *s, int maxlen, const char *cmdprefix)
|
|||
if(!s[cmdlen]) return;
|
||||
if(!completesize) { completesize = (int)strlen(&s[cmdlen]); DELETEA(lastcomplete); }
|
||||
|
||||
filesval *f = NULL;
|
||||
filesval *f = nullptr;
|
||||
if(completesize)
|
||||
{
|
||||
char *end = strchr(&s[cmdlen], ' ');
|
||||
if(end) f = completions.find(stringslice(&s[cmdlen], end), NULL);
|
||||
if(end) f = completions.find(stringslice(&s[cmdlen], end), nullptr);
|
||||
}
|
||||
|
||||
const char *nextcomplete = NULL;
|
||||
const char *nextcomplete = nullptr;
|
||||
if(f) // complete using filenames
|
||||
{
|
||||
int commandsize = strchr(&s[cmdlen], ' ')+1-s;
|
||||
|
|
|
@ -94,7 +94,7 @@ static void cleardynlights()
|
|||
|
||||
void removetrackeddynlights(physent *owner)
|
||||
{
|
||||
loopvrev(dynlights) if(owner ? dynlights[i].owner == owner : dynlights[i].owner != NULL) dynlights.remove(i);
|
||||
loopvrev(dynlights) if(owner ? dynlights[i].owner == owner : dynlights[i].owner != nullptr) dynlights.remove(i);
|
||||
}
|
||||
|
||||
void updatedynlights()
|
||||
|
|
|
@ -14,7 +14,7 @@ enum
|
|||
|
||||
void adddynlight(const vec &o, float radius, const vec &color, int fade = 0, int peak = 0, int flags = 0, float initradius = 0, const vec &initcolor = vec(0, 0, 0), physent *owner = NULL, const vec &dir = vec(0, 0, 0), int spot = 0);
|
||||
void dynlightreaching(const vec &target, vec &color, vec &dir, bool hud = false);
|
||||
void removetrackeddynlights(physent *owner = NULL);
|
||||
void removetrackeddynlights(physent *owner = nullptr);
|
||||
|
||||
void updatedynlights();
|
||||
int finddynlights();
|
||||
|
|
|
@ -38,7 +38,7 @@ struct extentity : entity // part of the entity that doesn
|
|||
int flags;
|
||||
extentity *attached;
|
||||
|
||||
extentity() : flags(0), attached(NULL) {}
|
||||
extentity() : flags(0), attached(nullptr) {}
|
||||
|
||||
bool spawned() const { return (flags&EF_SPAWNED) != 0; }
|
||||
void setspawned(bool val) { if(val) flags |= EF_SPAWNED; else flags &= ~EF_SPAWNED; }
|
||||
|
@ -162,7 +162,7 @@ struct animinterpinfo // used for animation blending of animated characters
|
|||
int lastswitch;
|
||||
void *lastmodel;
|
||||
|
||||
animinterpinfo() : lastswitch(-1), lastmodel(NULL) {}
|
||||
animinterpinfo() : lastswitch(-1), lastmodel(nullptr) {}
|
||||
|
||||
void reset() { lastswitch = -1; }
|
||||
};
|
||||
|
@ -181,7 +181,7 @@ struct dynent : physent // animated characters, or chara
|
|||
occludequery *query;
|
||||
int lastrendered;
|
||||
|
||||
dynent() : ragdoll(NULL), query(NULL), lastrendered(0)
|
||||
dynent() : ragdoll(nullptr), query(nullptr), lastrendered(0)
|
||||
{
|
||||
reset();
|
||||
}
|
||||
|
|
|
@ -7,8 +7,8 @@ namespace sphere
|
|||
{
|
||||
vec pos;
|
||||
ushort s, t;
|
||||
} *verts = NULL;
|
||||
GLushort *indices = NULL;
|
||||
} *verts = nullptr;
|
||||
GLushort *indices = nullptr;
|
||||
int numverts = 0, numindices = 0;
|
||||
GLuint vbuf = 0, ebuf = 0;
|
||||
|
||||
|
|
|
@ -211,7 +211,7 @@ static void gengrassquads(vtxarray *va)
|
|||
s.grasstex = textureload(s.grass, 2);
|
||||
}
|
||||
|
||||
grassgroup *group = NULL;
|
||||
grassgroup *group = nullptr;
|
||||
loopi(NUMGRASSWEDGES)
|
||||
{
|
||||
grasswedge &w = grasswedges[i];
|
||||
|
@ -250,12 +250,12 @@ void generategrass()
|
|||
gle::bindvbo(grassvbo);
|
||||
int size = grassverts.length()*sizeof(grassvert);
|
||||
grassvbosize = max(grassvbosize, size);
|
||||
glBufferData_(GL_ARRAY_BUFFER, grassvbosize, size == grassvbosize ? grassverts.getbuf() : NULL, GL_STREAM_DRAW);
|
||||
glBufferData_(GL_ARRAY_BUFFER, grassvbosize, size == grassvbosize ? grassverts.getbuf() : nullptr, GL_STREAM_DRAW);
|
||||
if(size != grassvbosize) glBufferSubData_(GL_ARRAY_BUFFER, 0, size, grassverts.getbuf());
|
||||
gle::clearvbo();
|
||||
}
|
||||
|
||||
static Shader *grassshader = NULL;
|
||||
static Shader *grassshader = nullptr;
|
||||
|
||||
static Shader *loadgrassshader()
|
||||
{
|
||||
|
@ -276,7 +276,7 @@ void loadgrassshaders()
|
|||
|
||||
static void cleargrassshaders()
|
||||
{
|
||||
grassshader = NULL;
|
||||
grassshader = nullptr;
|
||||
}
|
||||
|
||||
void rendergrass()
|
||||
|
|
|
@ -283,7 +283,7 @@ void skelbih::build(skelmodel::skelmeshgroup *m, ushort *indices, int numindices
|
|||
}
|
||||
|
||||
skelbih::skelbih(skelmodel::skelmeshgroup *m, int numtris, tri *tris)
|
||||
: nodes(NULL), numnodes(0), tris(tris), bbmin(1e16f, 1e16f, 1e16f), bbmax(-1e16f, -1e16f, -1e16f)
|
||||
: nodes(nullptr), numnodes(0), tris(tris), bbmin(1e16f, 1e16f, 1e16f), bbmax(-1e16f, -1e16f, -1e16f)
|
||||
{
|
||||
loopi(numtris)
|
||||
{
|
||||
|
@ -323,10 +323,10 @@ struct skelhitzone
|
|||
skelbih *bih;
|
||||
};
|
||||
|
||||
skelhitzone() : numparents(0), numchildren(0), parents(NULL), children(NULL), center(0, 0, 0), animcenter(0, 0, 0), radius(0), visited(-1)
|
||||
skelhitzone() : numparents(0), numchildren(0), parents(nullptr), children(nullptr), center(0, 0, 0), animcenter(0, 0, 0), radius(0), visited(-1)
|
||||
{
|
||||
blend = -1;
|
||||
bih = NULL;
|
||||
bih = nullptr;
|
||||
}
|
||||
|
||||
~skelhitzone()
|
||||
|
@ -561,7 +561,7 @@ struct skelhitdata
|
|||
int numblends;
|
||||
skelmodel::blendcacheentry blendcache;
|
||||
|
||||
skelhitdata() : numzones(0), rootzones(0), visited(0), zones(NULL), links(NULL), tris(NULL), numblends(0) {}
|
||||
skelhitdata() : numzones(0), rootzones(0), visited(0), zones(nullptr), links(nullptr), tris(nullptr), numblends(0) {}
|
||||
~skelhitdata()
|
||||
{
|
||||
DELETEA(zones);
|
||||
|
@ -666,7 +666,7 @@ void skelhitdata::build(skelmodel::skelmeshgroup *g, const uchar *ids)
|
|||
skelzonebounds *bounds = new skelzonebounds[g->skel->numbones];
|
||||
numblends = g->blendcombos.length();
|
||||
loopv(g->blendcombos) if(!g->blendcombos[i].weights[1]) { numblends = i; break; }
|
||||
blendcache.bdata = numblends > 0 ? new dualquat[numblends] : NULL;
|
||||
blendcache.bdata = numblends > 0 ? new dualquat[numblends] : nullptr;
|
||||
loopi(min(g->meshes.length(), 0x100))
|
||||
{
|
||||
skelmodel::skelmesh *m = (skelmodel::skelmesh *)g->meshes[i];
|
||||
|
@ -783,7 +783,7 @@ void skelhitdata::build(skelmodel::skelmeshgroup *g, const uchar *ids)
|
|||
}
|
||||
numzones = info.length();
|
||||
zones = new skelhitzone[numzones];
|
||||
links = numlinks ? new skelhitzone *[numlinks] : NULL;
|
||||
links = numlinks ? new skelhitzone *[numlinks] : nullptr;
|
||||
tris = new skelhitzone::tri[numtris];
|
||||
skelhitzone **curlink = links;
|
||||
skelhitzone::tri *curtris = tris;
|
||||
|
|
|
@ -115,8 +115,8 @@ struct iqm : skelloader<iqm>
|
|||
lilswap((uint *)&buf[hdr.ofs_joints], hdr.num_joints*sizeof(iqmjoint)/sizeof(uint));
|
||||
|
||||
const char *str = hdr.ofs_text ? (char *)&buf[hdr.ofs_text] : "";
|
||||
float *vpos = NULL, *vnorm = NULL, *vtan = NULL, *vtc = NULL;
|
||||
uchar *vindex = NULL, *vweight = NULL;
|
||||
float *vpos = nullptr, *vnorm = nullptr, *vtan = nullptr, *vtc = nullptr;
|
||||
uchar *vindex = nullptr, *vweight = nullptr;
|
||||
iqmvertexarray *vas = (iqmvertexarray *)&buf[hdr.ofs_vertexarrays];
|
||||
loopi(hdr.num_vertexarrays)
|
||||
{
|
||||
|
@ -187,10 +187,10 @@ struct iqm : skelloader<iqm>
|
|||
}
|
||||
int fv = im.first_vertex;
|
||||
float *mpos = vpos + 3*fv,
|
||||
*mnorm = vnorm ? vnorm + 3*fv : NULL,
|
||||
*mtan = vtan ? vtan + 4*fv : NULL,
|
||||
*mtc = vtc ? vtc + 2*fv : NULL;
|
||||
uchar *mindex = vindex ? vindex + 4*fv : NULL, *mweight = vweight ? vweight + 4*fv : NULL;
|
||||
*mnorm = vnorm ? vnorm + 3*fv : nullptr,
|
||||
*mtan = vtan ? vtan + 4*fv : nullptr,
|
||||
*mtc = vtc ? vtc + 2*fv : nullptr;
|
||||
uchar *mindex = vindex ? vindex + 4*fv : nullptr, *mweight = vweight ? vweight + 4*fv : nullptr;
|
||||
loopj(im.num_vertexes)
|
||||
{
|
||||
vert &v = m->verts[j];
|
||||
|
@ -325,7 +325,7 @@ struct iqm : skelloader<iqm>
|
|||
stream *f = openfile(filename, "rb");
|
||||
if(!f) return false;
|
||||
|
||||
uchar *buf = NULL;
|
||||
uchar *buf = nullptr;
|
||||
iqmheader hdr;
|
||||
if(f->read(&hdr, sizeof(hdr)) != sizeof(hdr) || memcmp(hdr.magic, "INTERQUAKEMODEL", sizeof(hdr.magic))) goto error;
|
||||
lilswap(&hdr.version, (sizeof(hdr) - sizeof(hdr.magic))/sizeof(uint));
|
||||
|
|
|
@ -156,7 +156,7 @@ struct flarerenderer : partrenderer
|
|||
}
|
||||
|
||||
//square per round hole - use addflare(..) instead
|
||||
particle *addpart(const vec &o, const vec &d, int fade, int color, float size, int gravity = 0) { return NULL; }
|
||||
particle *addpart(const vec &o, const vec &d, int fade, int color, float size, int gravity = 0) { return nullptr; }
|
||||
};
|
||||
static flarerenderer flares("<grey>media/particle/lensflares.png", 64);
|
||||
|
||||
|
|
|
@ -392,7 +392,7 @@ static void calcsurfaces(cube &c, const ivec &co, int size, int usefacemask, int
|
|||
}
|
||||
|
||||
VSlot &vslot = lookupvslot(c.texture[i], false),
|
||||
*layer = vslot.layer && !(c.material&MAT_ALPHA) ? &lookupvslot(vslot.layer, false) : NULL;
|
||||
*layer = vslot.layer && !(c.material&MAT_ALPHA) ? &lookupvslot(vslot.layer, false) : nullptr;
|
||||
Shader *shader = vslot.slot->shader;
|
||||
int shadertype = shader->type;
|
||||
if(layer) shadertype |= layer->slot->shader->type;
|
||||
|
@ -559,7 +559,7 @@ static bool previewblends(cube *c, const ivec &co, int size, const ivec &bo, con
|
|||
{
|
||||
changed = true;
|
||||
destroyva(ext->va);
|
||||
ext->va = NULL;
|
||||
ext->va = nullptr;
|
||||
invalidatemerges(c[i], co, size, true);
|
||||
}
|
||||
if(c[i].children ? previewblends(c[i].children, o, size/2, bo, bs) : previewblends(c[i], o, size))
|
||||
|
@ -569,7 +569,7 @@ static bool previewblends(cube *c, const ivec &co, int size, const ivec &bo, con
|
|||
if(ext && ext->va)
|
||||
{
|
||||
destroyva(ext->va);
|
||||
ext->va = NULL;
|
||||
ext->va = nullptr;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -600,7 +600,7 @@ void calclight()
|
|||
lightprogress = 0;
|
||||
calclight_canceled = false;
|
||||
check_calclight_progress = false;
|
||||
SDL_TimerID timer = SDL_AddTimer(250, calclighttimer, NULL);
|
||||
SDL_TimerID timer = SDL_AddTimer(250, calclighttimer, nullptr);
|
||||
Uint32 start = SDL_GetTicks();
|
||||
calcnormals(filltjoints > 0);
|
||||
calcsurfaces(worldroot, ivec(0, 0, 0), worldsize >> 1);
|
||||
|
|
|
@ -23,7 +23,7 @@
|
|||
#include "texture.hh"
|
||||
#include "world.hh"
|
||||
|
||||
static SDL_Window *screen = NULL;
|
||||
static SDL_Window *screen = nullptr;
|
||||
static int curvsync = -1;
|
||||
|
||||
static void swapbuffers(bool overlay = true);
|
||||
|
@ -49,7 +49,7 @@ void clearmainmenu()
|
|||
if(mainmenu && isconnected())
|
||||
{
|
||||
mainmenu = 0;
|
||||
//UI::hideui(NULL);
|
||||
//UI::hideui(nullptr);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -122,7 +122,7 @@ void fatal(const char *s, ...) // failure exit
|
|||
#endif
|
||||
}
|
||||
SDL_Quit();
|
||||
SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "Tesseract fatal error", msg, NULL);
|
||||
SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "Tesseract fatal error", msg, nullptr);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -132,11 +132,11 @@ void fatal(const char *s, ...) // failure exit
|
|||
VAR(desktopw, 1, 0, 0);
|
||||
VAR(desktoph, 1, 0, 0);
|
||||
int screenw = 0, screenh = 0;
|
||||
static SDL_GLContext glcontext = NULL;
|
||||
static SDL_GLContext glcontext = nullptr;
|
||||
|
||||
int curtime = 0, lastmillis = 1, elapsedtime = 0, totalmillis = 1;
|
||||
|
||||
dynent *player = NULL;
|
||||
dynent *player = nullptr;
|
||||
|
||||
int initing = NOT_INITING;
|
||||
|
||||
|
@ -184,9 +184,9 @@ static void getbackgroundres(int &w, int &h)
|
|||
}
|
||||
|
||||
static string backgroundcaption = "";
|
||||
static Texture *backgroundmapshot = NULL;
|
||||
static Texture *backgroundmapshot = nullptr;
|
||||
static string backgroundmapname = "";
|
||||
static char *backgroundmapinfo = NULL;
|
||||
static char *backgroundmapinfo = nullptr;
|
||||
|
||||
static void bgquad(float x, float y, float w, float h, float tx = 0, float ty = 0, float tw = 1, float th = 1)
|
||||
{
|
||||
|
@ -289,7 +289,7 @@ static void renderbackgroundview(int w, int h, const char *caption, Texture *map
|
|||
|
||||
VAR(menumute, 0, 1, 1);
|
||||
|
||||
static void setbackgroundinfo(const char *caption = NULL, Texture *mapshot = NULL, const char *mapname = NULL, const char *mapinfo = NULL)
|
||||
static void setbackgroundinfo(const char *caption = nullptr, Texture *mapshot = nullptr, const char *mapname = nullptr, const char *mapinfo = nullptr)
|
||||
{
|
||||
renderedframe = false;
|
||||
copystring(backgroundcaption, caption ? caption : "");
|
||||
|
@ -335,7 +335,7 @@ static void restorebackground(int w, int h, bool force = false)
|
|||
if(!force) return;
|
||||
setbackgroundinfo();
|
||||
}
|
||||
renderbackgroundview(w, h, backgroundcaption[0] ? backgroundcaption : NULL, backgroundmapshot, backgroundmapname[0] ? backgroundmapname : NULL, backgroundmapinfo);
|
||||
renderbackgroundview(w, h, backgroundcaption[0] ? backgroundcaption : nullptr, backgroundmapshot, backgroundmapname[0] ? backgroundmapname : nullptr, backgroundmapinfo);
|
||||
}
|
||||
|
||||
float loadprogress = 0;
|
||||
|
@ -574,12 +574,12 @@ static void setupscreen()
|
|||
if(glcontext)
|
||||
{
|
||||
SDL_GL_DeleteContext(glcontext);
|
||||
glcontext = NULL;
|
||||
glcontext = nullptr;
|
||||
}
|
||||
if(screen)
|
||||
{
|
||||
SDL_DestroyWindow(screen);
|
||||
screen = NULL;
|
||||
screen = nullptr;
|
||||
}
|
||||
curvsync = -1;
|
||||
|
||||
|
@ -950,10 +950,10 @@ static void stackdumper(unsigned int type, EXCEPTION_POINTERS *ep)
|
|||
CONTEXT *context = ep->ContextRecord;
|
||||
char out[512];
|
||||
formatstring(out, "Tesseract Win32 Exception: 0x%x [0x%x]\n\n", er->ExceptionCode, er->ExceptionCode==EXCEPTION_ACCESS_VIOLATION ? er->ExceptionInformation[1] : -1);
|
||||
SymInitialize(GetCurrentProcess(), NULL, TRUE);
|
||||
SymInitialize(GetCurrentProcess(), nullptr, TRUE);
|
||||
#ifdef _AMD64_
|
||||
STACKFRAME64 sf = {{context->Rip, 0, AddrModeFlat}, {}, {context->Rbp, 0, AddrModeFlat}, {context->Rsp, 0, AddrModeFlat}, 0};
|
||||
while(::StackWalk64(IMAGE_FILE_MACHINE_AMD64, GetCurrentProcess(), GetCurrentThread(), &sf, context, NULL, ::SymFunctionTableAccess, ::SymGetModuleBase, NULL))
|
||||
while(::StackWalk64(IMAGE_FILE_MACHINE_AMD64, GetCurrentProcess(), GetCurrentThread(), &sf, context, nullptr, ::SymFunctionTableAccess, ::SymGetModuleBase, nullptr))
|
||||
{
|
||||
union { IMAGEHLP_SYMBOL64 sym; char symext[sizeof(IMAGEHLP_SYMBOL64) + sizeof(string)]; };
|
||||
sym.SizeOfStruct = sizeof(sym);
|
||||
|
@ -965,7 +965,7 @@ static void stackdumper(unsigned int type, EXCEPTION_POINTERS *ep)
|
|||
if(SymGetSymFromAddr64(GetCurrentProcess(), sf.AddrPC.Offset, &symoff, &sym) && SymGetLineFromAddr64(GetCurrentProcess(), sf.AddrPC.Offset, &lineoff, &line))
|
||||
#else
|
||||
STACKFRAME sf = {{context->Eip, 0, AddrModeFlat}, {}, {context->Ebp, 0, AddrModeFlat}, {context->Esp, 0, AddrModeFlat}, 0};
|
||||
while(::StackWalk(IMAGE_FILE_MACHINE_I386, GetCurrentProcess(), GetCurrentThread(), &sf, context, NULL, ::SymFunctionTableAccess, ::SymGetModuleBase, NULL))
|
||||
while(::StackWalk(IMAGE_FILE_MACHINE_I386, GetCurrentProcess(), GetCurrentThread(), &sf, context, nullptr, ::SymFunctionTableAccess, ::SymGetModuleBase, nullptr))
|
||||
{
|
||||
union { IMAGEHLP_SYMBOL sym; char symext[sizeof(IMAGEHLP_SYMBOL) + sizeof(string)]; };
|
||||
sym.SizeOfStruct = sizeof(sym);
|
||||
|
@ -1081,7 +1081,7 @@ int main(int argc, char **argv)
|
|||
#endif
|
||||
#endif
|
||||
|
||||
char *initscript = NULL;
|
||||
char *initscript = nullptr;
|
||||
|
||||
initing = INIT_RESET;
|
||||
// set home dir first
|
||||
|
@ -1142,7 +1142,7 @@ int main(int argc, char **argv)
|
|||
|
||||
printf("init: world\n");
|
||||
camera1 = player = game::iterdynents(0);
|
||||
emptymap(0, true, NULL, false);
|
||||
emptymap(0, true, nullptr, false);
|
||||
|
||||
printf("init: sound\n");
|
||||
//initsound();
|
||||
|
|
|
@ -34,7 +34,7 @@ bool interceptkey(int sym);
|
|||
|
||||
struct Texture;
|
||||
|
||||
void renderbackground(const char *caption = NULL, Texture *mapshot = NULL, const char *mapname = NULL, const char *mapinfo = NULL, bool force = false);
|
||||
void renderbackground(const char *caption = nullptr, Texture *mapshot = nullptr, const char *mapname = nullptr, const char *mapinfo = nullptr, bool force = false);
|
||||
void renderprogress(float bar, const char *text, bool background = false);
|
||||
|
||||
void getfps(int &fps, int &bestdiff, int &worstdiff);
|
||||
|
|
|
@ -136,7 +136,7 @@ int findmaterial(const char *name)
|
|||
const char *findmaterialname(int mat)
|
||||
{
|
||||
loopi(sizeof(materials)/sizeof(materials[0])) if(materials[i].id == mat) return materials[i].name;
|
||||
return NULL;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
const char *getmaterialdesc(int mat, const char *prefix)
|
||||
|
@ -376,7 +376,7 @@ void setupmaterials(int start, int len)
|
|||
for(int i = start; i < len; i++)
|
||||
{
|
||||
vtxarray *va = valist[i];
|
||||
materialsurface *skip = NULL;
|
||||
materialsurface *skip = nullptr;
|
||||
loopj(va->matsurfs)
|
||||
{
|
||||
materialsurface &m = va->matbuf[j];
|
||||
|
@ -522,7 +522,7 @@ static void rendermatgrid()
|
|||
|
||||
static float glassxscale = 0, glassyscale = 0;
|
||||
|
||||
static void drawglass(const materialsurface &m, float offset, const vec *normal = NULL)
|
||||
static void drawglass(const materialsurface &m, float offset, const vec *normal = nullptr)
|
||||
{
|
||||
if(gle::attribbuf.empty())
|
||||
{
|
||||
|
|
|
@ -38,7 +38,7 @@ struct md5 : skelloader<md5>
|
|||
int numweights;
|
||||
md5vert *vertinfo;
|
||||
|
||||
md5mesh() : weightinfo(NULL), numweights(0), vertinfo(NULL)
|
||||
md5mesh() : weightinfo(nullptr), numweights(0), vertinfo(nullptr)
|
||||
{
|
||||
}
|
||||
|
||||
|
@ -103,7 +103,7 @@ struct md5 : skelloader<md5>
|
|||
}
|
||||
else if(strstr(buf, "shader"))
|
||||
{
|
||||
char *start = strchr(buf, '"'), *end = start ? strchr(start+1, '"') : NULL;
|
||||
char *start = strchr(buf, '"'), *end = start ? strchr(start+1, '"') : nullptr;
|
||||
if(start && end)
|
||||
{
|
||||
char *texname = newstring(start+1, end-(start+1));
|
||||
|
@ -267,28 +267,28 @@ struct md5 : skelloader<md5>
|
|||
if(sa) return sa;
|
||||
|
||||
stream *f = openfile(filename, "r");
|
||||
if(!f) return NULL;
|
||||
if(!f) return nullptr;
|
||||
|
||||
vector<md5hierarchy> hierarchy;
|
||||
vector<md5joint> basejoints;
|
||||
int animdatalen = 0, animframes = 0;
|
||||
float *animdata = NULL;
|
||||
dualquat *animbones = NULL;
|
||||
float *animdata = nullptr;
|
||||
dualquat *animbones = nullptr;
|
||||
char buf[512];
|
||||
while(f->getline(buf, sizeof(buf)))
|
||||
{
|
||||
int tmp;
|
||||
if(sscanf(buf, " MD5Version %d", &tmp)==1)
|
||||
{
|
||||
if(tmp!=10) { delete f; return NULL; }
|
||||
if(tmp!=10) { delete f; return nullptr; }
|
||||
}
|
||||
else if(sscanf(buf, " numJoints %d", &tmp)==1)
|
||||
{
|
||||
if(tmp!=skel->numbones) { delete f; return NULL; }
|
||||
if(tmp!=skel->numbones) { delete f; return nullptr; }
|
||||
}
|
||||
else if(sscanf(buf, " numFrames %d", &animframes)==1)
|
||||
{
|
||||
if(animframes<1) { delete f; return NULL; }
|
||||
if(animframes<1) { delete f; return nullptr; }
|
||||
}
|
||||
else if(sscanf(buf, " frameRate %d", &tmp)==1);
|
||||
else if(sscanf(buf, " numAnimatedComponents %d", &animdatalen)==1)
|
||||
|
@ -322,7 +322,7 @@ struct md5 : skelloader<md5>
|
|||
basejoints.add(j);
|
||||
}
|
||||
}
|
||||
if(basejoints.length()!=skel->numbones) { delete f; if(animdata) delete[] animdata; return NULL; }
|
||||
if(basejoints.length()!=skel->numbones) { delete f; if(animdata) delete[] animdata; return nullptr; }
|
||||
animbones = new dualquat[(skel->numframes+animframes)*skel->numbones];
|
||||
if(skel->framebones)
|
||||
{
|
||||
|
|
|
@ -181,7 +181,7 @@ struct aviwriter
|
|||
DELETEP(f);
|
||||
}
|
||||
|
||||
aviwriter(const char *name, uint w, uint h, uint fps, bool sound) : f(NULL), yuv(NULL), videoframes(0), totalsize(0), videow(w&~1), videoh(h&~1), videofps(fps), soundfrequency(0),soundchannels(0),soundformat(0)
|
||||
aviwriter(const char *name, uint w, uint h, uint fps, bool sound) : f(nullptr), yuv(nullptr), videoframes(0), totalsize(0), videow(w&~1), videoh(h&~1), videofps(fps), soundfrequency(0),soundchannels(0),soundformat(0)
|
||||
{
|
||||
copystring(filename, moviedir);
|
||||
if(moviedir[0])
|
||||
|
@ -771,7 +771,7 @@ namespace recorder
|
|||
{
|
||||
static enum { REC_OK = 0, REC_USERHALT, REC_TOOSLOW, REC_FILERROR } state = REC_OK;
|
||||
|
||||
static aviwriter *file = NULL;
|
||||
static aviwriter *file = nullptr;
|
||||
static int starttime = 0;
|
||||
|
||||
static int stats[1000];
|
||||
|
@ -785,7 +785,7 @@ namespace recorder
|
|||
uint size, maxsize;
|
||||
uint frame;
|
||||
|
||||
soundbuffer() : sound(NULL), maxsize(0) {}
|
||||
soundbuffer() : sound(nullptr), maxsize(0) {}
|
||||
~soundbuffer() { cleanup(); }
|
||||
|
||||
void load(uchar *stream, uint len, uint fnum)
|
||||
|
@ -804,7 +804,7 @@ namespace recorder
|
|||
void cleanup() { DELETEA(sound); maxsize = 0; }
|
||||
};
|
||||
static queue<soundbuffer, MAXSOUNDBUFFERS> soundbuffers;
|
||||
static SDL_mutex *soundlock = NULL;
|
||||
static SDL_mutex *soundlock = nullptr;
|
||||
|
||||
enum { MAXVIDEOBUFFERS = 2 }; // double buffer
|
||||
struct videobuffer
|
||||
|
@ -813,7 +813,7 @@ namespace recorder
|
|||
uint w, h, bpp, frame;
|
||||
int format;
|
||||
|
||||
videobuffer() : video(NULL){}
|
||||
videobuffer() : video(nullptr){}
|
||||
~videobuffer() { cleanup(); }
|
||||
|
||||
void init(int nw, int nh, int nbpp)
|
||||
|
@ -835,11 +835,11 @@ namespace recorder
|
|||
static uint scalew = 0, scaleh = 0;
|
||||
static GLuint encodefb = 0, encoderb = 0;
|
||||
|
||||
static SDL_Thread *thread = NULL;
|
||||
static SDL_mutex *videolock = NULL;
|
||||
static SDL_cond *shouldencode = NULL, *shouldread = NULL;
|
||||
static SDL_Thread *thread = nullptr;
|
||||
static SDL_mutex *videolock = nullptr;
|
||||
static SDL_cond *shouldencode = nullptr, *shouldread = nullptr;
|
||||
|
||||
static inline bool isrecording() { return file != NULL; }
|
||||
static inline bool isrecording() { return file != nullptr; }
|
||||
|
||||
static inline float calcquality()
|
||||
{
|
||||
|
@ -964,8 +964,8 @@ namespace recorder
|
|||
videolock = SDL_CreateMutex();
|
||||
shouldencode = SDL_CreateCond();
|
||||
shouldread = SDL_CreateCond();
|
||||
thread = SDL_CreateThread(videoencoder, "video encoder", NULL);
|
||||
//if(file->soundfrequency > 0) Mix_SetPostMix(soundencoder, NULL);
|
||||
thread = SDL_CreateThread(videoencoder, "video encoder", nullptr);
|
||||
//if(file->soundfrequency > 0) Mix_SetPostMix(soundencoder, nullptr);
|
||||
}
|
||||
|
||||
void cleanup()
|
||||
|
@ -981,13 +981,13 @@ namespace recorder
|
|||
{
|
||||
if(!file) return;
|
||||
if(state == REC_OK) state = REC_USERHALT;
|
||||
//if(file->soundfrequency > 0) Mix_SetPostMix(NULL, NULL);
|
||||
//if(file->soundfrequency > 0) Mix_SetPostMix(nullptr, nullptr);
|
||||
|
||||
SDL_LockMutex(videolock); // wakeup thread enough to kill it
|
||||
SDL_CondSignal(shouldencode);
|
||||
SDL_UnlockMutex(videolock);
|
||||
|
||||
SDL_WaitThread(thread, NULL); // block until thread is finished
|
||||
SDL_WaitThread(thread, nullptr); // block until thread is finished
|
||||
|
||||
cleanup();
|
||||
|
||||
|
@ -999,9 +999,9 @@ namespace recorder
|
|||
SDL_DestroyCond(shouldencode);
|
||||
SDL_DestroyCond(shouldread);
|
||||
|
||||
soundlock = videolock = NULL;
|
||||
shouldencode = shouldread = NULL;
|
||||
thread = NULL;
|
||||
soundlock = videolock = nullptr;
|
||||
shouldencode = shouldread = nullptr;
|
||||
thread = nullptr;
|
||||
|
||||
static const char * const mesgs[] = { "ok", "stopped", "computer too slow", "file error"};
|
||||
conoutf("movie recording halted: %s, %d frames", mesgs[state], file->videoframes);
|
||||
|
@ -1031,7 +1031,7 @@ namespace recorder
|
|||
loopi(2)
|
||||
{
|
||||
if(!scaletex[i]) glGenTextures(1, &scaletex[i]);
|
||||
createtexture(scaletex[i], tw, th, NULL, 3, 1, GL_RGB, GL_TEXTURE_RECTANGLE);
|
||||
createtexture(scaletex[i], tw, th, nullptr, 3, 1, GL_RGB, GL_TEXTURE_RECTANGLE);
|
||||
}
|
||||
scalew = tw;
|
||||
scaleh = th;
|
||||
|
|
|
@ -108,7 +108,7 @@ static inline void findnormal(const normalgroup &g, float lerpthreshold, const v
|
|||
static inline bool findtnormal(const normalgroup &g, float lerpthreshold, const vec &surface, vec &v)
|
||||
{
|
||||
float bestangle = lerpthreshold;
|
||||
tnormal *bestnorm = NULL;
|
||||
tnormal *bestnorm = nullptr;
|
||||
for(int cur = g.tnormals; cur >= 0;)
|
||||
{
|
||||
tnormal &o = tnormals[cur];
|
||||
|
|
|
@ -46,7 +46,7 @@ struct obj : vertloader<obj>
|
|||
#define STARTMESH do { \
|
||||
vertmesh &m = *new vertmesh; \
|
||||
m.group = this; \
|
||||
m.name = meshname[0] ? newstring(meshname) : NULL; \
|
||||
m.name = meshname[0] ? newstring(meshname) : nullptr; \
|
||||
meshes.add(&m); \
|
||||
curmesh = &m; \
|
||||
verthash.clear(); \
|
||||
|
@ -79,7 +79,7 @@ struct obj : vertloader<obj>
|
|||
} while(0)
|
||||
|
||||
string meshname = "";
|
||||
vertmesh *curmesh = NULL;
|
||||
vertmesh *curmesh = nullptr;
|
||||
while(file->getline(buf, sizeof(buf)))
|
||||
{
|
||||
char *c = buf;
|
||||
|
@ -102,7 +102,7 @@ struct obj : vertloader<obj>
|
|||
copystring(meshname, name, min(namelen+1, sizeof(meshname)));
|
||||
|
||||
if(curmesh) FLUSHMESH;
|
||||
curmesh = NULL;
|
||||
curmesh = nullptr;
|
||||
break;
|
||||
}
|
||||
case 'f':
|
||||
|
|
|
@ -48,8 +48,8 @@ static struct emptycube : cube
|
|||
{
|
||||
emptycube()
|
||||
{
|
||||
children = NULL;
|
||||
ext = NULL;
|
||||
children = nullptr;
|
||||
ext = nullptr;
|
||||
visible = 0;
|
||||
merged = 0;
|
||||
material = MAT_AIR;
|
||||
|
@ -72,8 +72,8 @@ cubeext *growcubeext(cubeext *old, int maxverts)
|
|||
}
|
||||
else
|
||||
{
|
||||
ext->va = NULL;
|
||||
ext->ents = NULL;
|
||||
ext->va = nullptr;
|
||||
ext->ents = nullptr;
|
||||
ext->tjoints = -1;
|
||||
}
|
||||
ext->maxverts = maxverts;
|
||||
|
@ -110,8 +110,8 @@ cube *newcubes(uint face, int mat)
|
|||
cube *c = new cube[8];
|
||||
loopi(8)
|
||||
{
|
||||
c->children = NULL;
|
||||
c->ext = NULL;
|
||||
c->children = nullptr;
|
||||
c->ext = nullptr;
|
||||
c->visible = 0;
|
||||
c->merged = 0;
|
||||
setfaces(*c, face);
|
||||
|
@ -143,7 +143,7 @@ void freecubeext(cube &c)
|
|||
if(c.ext)
|
||||
{
|
||||
delete[] (uchar *)c.ext;
|
||||
c.ext = NULL;
|
||||
c.ext = nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -157,7 +157,7 @@ void discardchildren(cube &c, bool fixtex, int depth)
|
|||
if(c.ext)
|
||||
{
|
||||
if(c.ext->va) destroyva(c.ext->va);
|
||||
c.ext->va = NULL;
|
||||
c.ext->va = nullptr;
|
||||
c.ext->tjoints = -1;
|
||||
freeoctaentities(c);
|
||||
freecubeext(c);
|
||||
|
@ -568,9 +568,9 @@ bool remip(cube &c, const ivec &co, int size)
|
|||
}
|
||||
|
||||
cube n = c;
|
||||
n.ext = NULL;
|
||||
n.ext = nullptr;
|
||||
forcemip(n);
|
||||
n.children = NULL;
|
||||
n.children = nullptr;
|
||||
if(!subdividecube(n, false, false))
|
||||
{ freeocta(n.children); return false; }
|
||||
|
||||
|
@ -783,7 +783,7 @@ static uint faceedges(const cube &c, int orient)
|
|||
}
|
||||
|
||||
|
||||
static inline int genfacevecs(const cube &cu, int orient, const ivec &pos, int size, bool solid, ivec2 *fvecs, const ivec *v = NULL)
|
||||
static inline int genfacevecs(const cube &cu, int orient, const ivec &pos, int size, bool solid, ivec2 *fvecs, const ivec *v = nullptr)
|
||||
{
|
||||
int i = 0;
|
||||
if(solid)
|
||||
|
@ -1884,7 +1884,7 @@ static void invalidatemerges(cube &c)
|
|||
{
|
||||
if(!(c.ext->va->hasmerges&(MERGE_PART | MERGE_ORIGIN))) return;
|
||||
destroyva(c.ext->va);
|
||||
c.ext->va = NULL;
|
||||
c.ext->va = nullptr;
|
||||
}
|
||||
if(c.ext->tjoints >= 0) c.ext->tjoints = -1;
|
||||
}
|
||||
|
|
|
@ -214,7 +214,7 @@ struct tjoint
|
|||
|
||||
struct cubeext
|
||||
{
|
||||
vtxarray *va; // vertex array for children, or NULL
|
||||
vtxarray *va; // vertex array for children, or nullptr
|
||||
octaentities *ents; // map entities inside cube
|
||||
surfaceinfo surfaces[6]; // render info for each surface
|
||||
int tjoints; // linked list of t-joints
|
||||
|
@ -225,7 +225,7 @@ struct cubeext
|
|||
|
||||
struct cube
|
||||
{
|
||||
cube *children; // points to 8 cube structures which are its children, or NULL. -Z first, then -Y, -X
|
||||
cube *children; // points to 8 cube structures which are its children, or nullptr. -Z first, then -Y, -X
|
||||
cubeext *ext; // extended info for the cube
|
||||
union
|
||||
{
|
||||
|
@ -256,7 +256,7 @@ struct block3
|
|||
struct editinfo
|
||||
{
|
||||
block3 *copy;
|
||||
editinfo() : copy(NULL) {}
|
||||
editinfo() : copy(nullptr) {}
|
||||
};
|
||||
|
||||
struct undoent { int i; entity e; };
|
||||
|
|
|
@ -587,7 +587,7 @@ static void readychanges(const ivec &bbmin, const ivec &bbmax, cube *c, const iv
|
|||
{
|
||||
int hasmerges = c[i].ext->va->hasmerges;
|
||||
destroyva(c[i].ext->va);
|
||||
c[i].ext->va = NULL;
|
||||
c[i].ext->va = nullptr;
|
||||
if(hasmerges) invalidatemerges(c[i], o, size, true);
|
||||
}
|
||||
freeoctaentities(c[i]);
|
||||
|
@ -646,7 +646,7 @@ static inline void copycube(const cube &src, cube &dst)
|
|||
dst = src;
|
||||
dst.visible = 0;
|
||||
dst.merged = 0;
|
||||
dst.ext = NULL; // src cube is responsible for va destruction
|
||||
dst.ext = nullptr; // src cube is responsible for va destruction
|
||||
if(src.children)
|
||||
{
|
||||
dst.children = newcubes(F_EMPTY);
|
||||
|
@ -670,7 +670,7 @@ static void blockcopy(const block3 &s, int rgrid, block3 *b)
|
|||
static block3 *blockcopy(const block3 &s, int rgrid)
|
||||
{
|
||||
int bsize = sizeof(block3)+sizeof(cube)*s.size();
|
||||
if(bsize <= 0 || bsize > (100<<20)) return NULL;
|
||||
if(bsize <= 0 || bsize > (100<<20)) return nullptr;
|
||||
block3 *b = (block3 *)new (false) uchar[bsize];
|
||||
if(b) blockcopy(s, rgrid, b);
|
||||
return b;
|
||||
|
@ -723,13 +723,13 @@ struct undolist
|
|||
{
|
||||
undoblock *first, *last;
|
||||
|
||||
undolist() : first(NULL), last(NULL) {}
|
||||
undolist() : first(nullptr), last(nullptr) {}
|
||||
|
||||
bool empty() { return !first; }
|
||||
|
||||
void add(undoblock *u)
|
||||
{
|
||||
u->next = NULL;
|
||||
u->next = nullptr;
|
||||
u->prev = last;
|
||||
if(!first) first = last = u;
|
||||
else
|
||||
|
@ -743,8 +743,8 @@ struct undolist
|
|||
{
|
||||
undoblock *u = first;
|
||||
first = first->next;
|
||||
if(first) first->prev = NULL;
|
||||
else last = NULL;
|
||||
if(first) first->prev = nullptr;
|
||||
else last = nullptr;
|
||||
return u;
|
||||
}
|
||||
|
||||
|
@ -752,8 +752,8 @@ struct undolist
|
|||
{
|
||||
undoblock *u = last;
|
||||
last = last->prev;
|
||||
if(last) last->next = NULL;
|
||||
else first = NULL;
|
||||
if(last) last->next = nullptr;
|
||||
else first = nullptr;
|
||||
return u;
|
||||
}
|
||||
};
|
||||
|
@ -788,9 +788,9 @@ static undoblock *newundocube(const selinfo &s)
|
|||
int ssize = s.size(),
|
||||
selgridsize = ssize,
|
||||
blocksize = sizeof(block3)+ssize*sizeof(cube);
|
||||
if(blocksize <= 0 || blocksize > (undomegs<<20)) return NULL;
|
||||
if(blocksize <= 0 || blocksize > (undomegs<<20)) return nullptr;
|
||||
undoblock *u = (undoblock *)new (false) uchar[sizeof(undoblock) + blocksize + selgridsize];
|
||||
if(!u) return NULL;
|
||||
if(!u) return nullptr;
|
||||
u->numents = 0;
|
||||
block3 *b = u->block();
|
||||
blockcopy(s, -s.grid, b);
|
||||
|
@ -894,7 +894,7 @@ static void editredo() { swapundo(redos, undos, EDIT_REDO); }
|
|||
#define protectsel(f) { undoblock *_u = newundocube(sel); f; if(_u) { pasteundo(_u); freeundo(_u); } }
|
||||
|
||||
static vector<editinfo *> editinfos;
|
||||
editinfo *localedit = NULL;
|
||||
editinfo *localedit = nullptr;
|
||||
|
||||
template<class B>
|
||||
static void packcube(cube &c, B &buf)
|
||||
|
@ -987,7 +987,7 @@ static void unpackcube(cube &c, B &buf)
|
|||
template<class B>
|
||||
static bool unpackblock(block3 *&b, B &buf)
|
||||
{
|
||||
if(b) { freeblock(b); b = NULL; }
|
||||
if(b) { freeblock(b); b = nullptr; }
|
||||
block3 hdr;
|
||||
if(buf.get((uchar *)&hdr, sizeof(hdr)) < int(sizeof(hdr))) return false;
|
||||
lilswap(hdr.o.v, 3);
|
||||
|
@ -1056,7 +1056,7 @@ static bool compresseditinfo(const uchar *inbuf, int inlen, uchar *&outbuf, int
|
|||
if(!outbuf || compress2((Bytef *)outbuf, &len, (const Bytef *)inbuf, inlen, Z_BEST_COMPRESSION) != Z_OK || len > (1<<16))
|
||||
{
|
||||
delete[] outbuf;
|
||||
outbuf = NULL;
|
||||
outbuf = nullptr;
|
||||
return false;
|
||||
}
|
||||
outlen = len;
|
||||
|
@ -1071,7 +1071,7 @@ static bool uncompresseditinfo(const uchar *inbuf, int inlen, uchar *&outbuf, in
|
|||
if(!outbuf || uncompress((Bytef *)outbuf, &len, (const Bytef *)inbuf, inlen) != Z_OK)
|
||||
{
|
||||
delete[] outbuf;
|
||||
outbuf = NULL;
|
||||
outbuf = nullptr;
|
||||
return false;
|
||||
}
|
||||
outlen = len;
|
||||
|
@ -1089,8 +1089,8 @@ bool packeditinfo(editinfo *e, int &inlen, uchar *&outbuf, int &outlen)
|
|||
|
||||
bool unpackeditinfo(editinfo *&e, const uchar *inbuf, int inlen, int outlen)
|
||||
{
|
||||
if(e && e->copy) { freeblock(e->copy); e->copy = NULL; }
|
||||
uchar *outbuf = NULL;
|
||||
if(e && e->copy) { freeblock(e->copy); e->copy = nullptr; }
|
||||
uchar *outbuf = nullptr;
|
||||
if(!uncompresseditinfo(inbuf, inlen, outbuf, outlen)) return false;
|
||||
ucharbuf buf(outbuf, outlen);
|
||||
if(!e) e = editinfos.add(new editinfo);
|
||||
|
@ -1110,7 +1110,7 @@ void freeeditinfo(editinfo *&e)
|
|||
editinfos.removeobj(e);
|
||||
if(e->copy) freeblock(e->copy);
|
||||
delete e;
|
||||
e = NULL;
|
||||
e = nullptr;
|
||||
}
|
||||
|
||||
static bool packundo(undoblock *u, int &inlen, uchar *&outbuf, int &outlen)
|
||||
|
@ -1143,7 +1143,7 @@ static bool packundo(undoblock *u, int &inlen, uchar *&outbuf, int &outlen)
|
|||
|
||||
bool unpackundo(const uchar *inbuf, int inlen, int outlen)
|
||||
{
|
||||
uchar *outbuf = NULL;
|
||||
uchar *outbuf = nullptr;
|
||||
if(!uncompresseditinfo(inbuf, inlen, outbuf, outlen)) return false;
|
||||
ucharbuf buf(outbuf, outlen);
|
||||
if(buf.remaining() < 2)
|
||||
|
@ -1170,7 +1170,7 @@ bool unpackundo(const uchar *inbuf, int inlen, int outlen)
|
|||
}
|
||||
else
|
||||
{
|
||||
block3 *b = NULL;
|
||||
block3 *b = nullptr;
|
||||
if(!unpackblock(b, buf) || b->grid >= worldsize || buf.remaining() < b->size())
|
||||
{
|
||||
freeblock(b);
|
||||
|
@ -1210,7 +1210,7 @@ struct prefab : editinfo
|
|||
GLuint ebo, vbo;
|
||||
int numtris, numverts;
|
||||
|
||||
prefab() : name(NULL), ebo(0), vbo(0), numtris(0), numverts(0) {}
|
||||
prefab() : name(nullptr), ebo(0), vbo(0), numtris(0), numverts(0) {}
|
||||
~prefab() { DELETEA(name); if(copy) freeblock(copy); }
|
||||
|
||||
void cleanup()
|
||||
|
@ -1286,14 +1286,14 @@ static prefab *loadprefab(const char *name, bool msg = true)
|
|||
defformatstring(filename, "media/prefab/%s.obr", name);
|
||||
path(filename);
|
||||
stream *f = opengzfile(filename, "rb");
|
||||
if(!f) { if(msg) conoutf(CON_ERROR, "could not read prefab %s", filename); return NULL; }
|
||||
if(!f) { if(msg) conoutf(CON_ERROR, "could not read prefab %s", filename); return nullptr; }
|
||||
prefabheader hdr;
|
||||
if(f->read(&hdr, sizeof(hdr)) != sizeof(prefabheader) || memcmp(hdr.magic, "OEBR", 4)) { delete f; if(msg) conoutf(CON_ERROR, "prefab %s has malformatted header", filename); return NULL; }
|
||||
if(f->read(&hdr, sizeof(hdr)) != sizeof(prefabheader) || memcmp(hdr.magic, "OEBR", 4)) { delete f; if(msg) conoutf(CON_ERROR, "prefab %s has malformatted header", filename); return nullptr; }
|
||||
lilswap(&hdr.version, 1);
|
||||
if(hdr.version != 0) { delete f; if(msg) conoutf(CON_ERROR, "prefab %s uses unsupported version", filename); return NULL; }
|
||||
if(hdr.version != 0) { delete f; if(msg) conoutf(CON_ERROR, "prefab %s uses unsupported version", filename); return nullptr; }
|
||||
streambuf<uchar> s(f);
|
||||
block3 *copy = NULL;
|
||||
if(!unpackblock(copy, s)) { delete f; if(msg) conoutf(CON_ERROR, "could not unpack prefab %s", filename); return NULL; }
|
||||
block3 *copy = nullptr;
|
||||
if(!unpackblock(copy, s)) { delete f; if(msg) conoutf(CON_ERROR, "could not unpack prefab %s", filename); return nullptr; }
|
||||
delete f;
|
||||
|
||||
b = &prefabs[name];
|
||||
|
@ -1519,16 +1519,16 @@ void previewprefab(const char *name, const vec &color)
|
|||
void mpcopy(editinfo *&e, selinfo &sel, bool local)
|
||||
{
|
||||
if(local) game::edittrigger(sel, EDIT_COPY);
|
||||
if(e==NULL) e = editinfos.add(new editinfo);
|
||||
if(e==nullptr) e = editinfos.add(new editinfo);
|
||||
if(e->copy) freeblock(e->copy);
|
||||
e->copy = NULL;
|
||||
e->copy = nullptr;
|
||||
protectsel(e->copy = blockcopy(block3(sel), sel.grid));
|
||||
changed(sel);
|
||||
}
|
||||
|
||||
void mppaste(editinfo *&e, selinfo &sel, bool local)
|
||||
{
|
||||
if(e==NULL) return;
|
||||
if(e==nullptr) return;
|
||||
if(local) game::edittrigger(sel, EDIT_PASTE);
|
||||
if(e->copy) pasteblock(*e->copy, sel, local);
|
||||
}
|
||||
|
@ -1661,11 +1661,11 @@ namespace hmap
|
|||
static cube *getcube(ivec t, int f)
|
||||
{
|
||||
t[d] += dcr*f*gridsize;
|
||||
if(t[d] > nz || t[d] < mz) return NULL;
|
||||
if(t[d] > nz || t[d] < mz) return nullptr;
|
||||
cube *c = &lookupcube(t, gridsize);
|
||||
if(c->children) forcemip(*c, false);
|
||||
discardchildren(*c, true);
|
||||
if(!isheightmap(sel.orient, d, true, c)) return NULL;
|
||||
if(!isheightmap(sel.orient, d, true, c)) return nullptr;
|
||||
if (t.x < changes.o.x) changes.o.x = t.x;
|
||||
else if(t.x > changes.s.x) changes.s.x = t.x;
|
||||
if (t.y < changes.o.y) changes.o.y = t.y;
|
||||
|
@ -1707,13 +1707,13 @@ namespace hmap
|
|||
makeundo(hundo);
|
||||
|
||||
cube **c = cmap[x][y];
|
||||
loopk(4) c[k] = NULL;
|
||||
loopk(4) c[k] = nullptr;
|
||||
c[1] = getcube(t, 0);
|
||||
if(!c[1] || !isempty(*c[1]))
|
||||
{ // try up
|
||||
c[2] = c[1];
|
||||
c[1] = getcube(t, 1);
|
||||
if(!c[1] || isempty(*c[1])) { c[0] = c[1]; c[1] = c[2]; c[2] = NULL; }
|
||||
if(!c[1] || isempty(*c[1])) { c[0] = c[1]; c[1] = c[2]; c[2] = nullptr; }
|
||||
else { z++; t[d]+=fg; }
|
||||
}
|
||||
else // drop down
|
||||
|
@ -1732,8 +1732,8 @@ namespace hmap
|
|||
if(!c[0]) c[0] = getcube(t, 1);
|
||||
if(!c[2]) c[2] = getcube(t, -1);
|
||||
c[3] = getcube(t, -2);
|
||||
c[2] = !c[2] || isempty(*c[2]) ? NULL : c[2];
|
||||
c[3] = !c[3] || isempty(*c[3]) ? NULL : c[3];
|
||||
c[2] = !c[2] || isempty(*c[2]) ? nullptr : c[2];
|
||||
c[3] = !c[3] || isempty(*c[3]) ? nullptr : c[3];
|
||||
|
||||
uint face = getface(c[1], d);
|
||||
if(face == 0x08080808 && (!c[0] || !isempty(*c[0]))) { flags[x][y] |= NOTHMAP; return; }
|
||||
|
@ -2123,8 +2123,8 @@ static VSlot *remapvslot(int index, bool delta, const VSlot &ds)
|
|||
{
|
||||
loopv(remappedvslots) if(remappedvslots[i].index == index) return remappedvslots[i].vslot;
|
||||
VSlot &vs = lookupvslot(index, false);
|
||||
if(vs.index < 0 || vs.index == DEFAULT_SKY) return NULL;
|
||||
VSlot *edit = NULL;
|
||||
if(vs.index < 0 || vs.index == DEFAULT_SKY) return nullptr;
|
||||
VSlot *edit = nullptr;
|
||||
if(delta)
|
||||
{
|
||||
VSlot ms;
|
||||
|
@ -2197,7 +2197,7 @@ void mpeditvslot(int delta, VSlot &ds, int allfaces, selinfo &sel, bool local)
|
|||
repsel = sel;
|
||||
}
|
||||
bool findrep = local && !allfaces && reptex < 0;
|
||||
VSlot *findedit = NULL;
|
||||
VSlot *findedit = nullptr;
|
||||
loopselxyz(remapvslots(c, delta != 0, ds, allfaces ? -1 : sel.orient, findrep, findedit));
|
||||
remappedvslots.setsize(0);
|
||||
if(local && findedit)
|
||||
|
@ -2847,9 +2847,9 @@ void rendertexturepanel(int w, int h)
|
|||
int s = (i == 3 ? 285 : 220), ti = curtexindex+i-3;
|
||||
if(texmru.inrange(ti))
|
||||
{
|
||||
VSlot &vslot = lookupvslot(texmru[ti]), *layer = NULL, *detail = NULL;
|
||||
VSlot &vslot = lookupvslot(texmru[ti]), *layer = nullptr, *detail = nullptr;
|
||||
Slot &slot = *vslot.slot;
|
||||
Texture *tex = slot.sts.empty() ? notexture : slot.sts[0].t, *glowtex = NULL, *layertex = NULL, *detailtex = NULL;
|
||||
Texture *tex = slot.sts.empty() ? notexture : slot.sts[0].t, *glowtex = nullptr, *layertex = nullptr, *detailtex = nullptr;
|
||||
if(slot.texmask&(1<<TEX_GLOW))
|
||||
{
|
||||
loopvj(slot.sts) if(slot.sts[j].type==TEX_GLOW) { glowtex = slot.sts[j].t; break; }
|
||||
|
|
|
@ -490,7 +490,7 @@ struct vacollect : verthash
|
|||
va->maxvert += va->voffset;
|
||||
}
|
||||
|
||||
va->matbuf = NULL;
|
||||
va->matbuf = nullptr;
|
||||
va->matsurfs = matsurfs.length();
|
||||
va->matmask = 0;
|
||||
if(va->matsurfs)
|
||||
|
@ -521,7 +521,7 @@ struct vacollect : verthash
|
|||
if(va->voffset) loopi(va->sky) skydata[i] += va->voffset;
|
||||
}
|
||||
|
||||
va->texelems = NULL;
|
||||
va->texelems = nullptr;
|
||||
va->texs = texs.length();
|
||||
va->blendtris = 0;
|
||||
va->blends = 0;
|
||||
|
@ -587,7 +587,7 @@ struct vacollect : verthash
|
|||
va->decalbuf = 0;
|
||||
va->decaldata = 0;
|
||||
va->decaloffset = 0;
|
||||
va->decalelems = NULL;
|
||||
va->decalelems = nullptr;
|
||||
va->decaltexs = decaltexs.length();
|
||||
va->decaltris = decaltris/3;
|
||||
if(va->decaltexs)
|
||||
|
@ -1110,7 +1110,7 @@ static void gencubeverts(cube &c, const ivec &co, int size, int csi)
|
|||
loopi(6) if(vismask&(1<<i) && (vis = visibletris(c, i, co, size)))
|
||||
{
|
||||
vec pos[MAXFACEVERTS];
|
||||
vertinfo *verts = NULL;
|
||||
vertinfo *verts = nullptr;
|
||||
int numverts = c.ext ? c.ext->surfaces[i].numverts&MAXFACEVERTS : 0, convex = 0;
|
||||
if(numverts)
|
||||
{
|
||||
|
@ -1133,14 +1133,14 @@ static void gencubeverts(cube &c, const ivec &co, int size, int csi)
|
|||
}
|
||||
|
||||
VSlot &vslot = lookupvslot(c.texture[i], true),
|
||||
*layer = vslot.layer && !(c.material&MAT_ALPHA) ? &lookupvslot(vslot.layer, true) : NULL;
|
||||
*layer = vslot.layer && !(c.material&MAT_ALPHA) ? &lookupvslot(vslot.layer, true) : nullptr;
|
||||
ushort envmap = vslot.slot->shader->type&SHADER_ENVMAP ? (vslot.slot->texmask&(1<<TEX_ENVMAP) ? EMID_CUSTOM : closestenvmap(i, co, size)) : EMID_NONE,
|
||||
envmap2 = layer && layer->slot->shader->type&SHADER_ENVMAP ? (layer->slot->texmask&(1<<TEX_ENVMAP) ? EMID_CUSTOM : closestenvmap(i, co, size)) : EMID_NONE;
|
||||
while(tj >= 0 && tjoints[tj].edge < i*(MAXFACEVERTS+1)) tj = tjoints[tj].next;
|
||||
int hastj = tj >= 0 && tjoints[tj].edge < (i+1)*(MAXFACEVERTS+1) ? tj : -1;
|
||||
int grassy = vslot.slot->grass && i!=O_BOTTOM ? (vis!=3 || convex ? 1 : 2) : 0;
|
||||
if(!c.ext)
|
||||
addcubeverts(vslot, i, size, pos, convex, c.texture[i], NULL, numverts, hastj, envmap, grassy, (c.material&MAT_ALPHA)!=0);
|
||||
addcubeverts(vslot, i, size, pos, convex, c.texture[i], nullptr, numverts, hastj, envmap, grassy, (c.material&MAT_ALPHA)!=0);
|
||||
else
|
||||
{
|
||||
const surfaceinfo &surf = c.ext->surfaces[i];
|
||||
|
@ -1161,12 +1161,12 @@ vector<vtxarray *> valist, varoot;
|
|||
static vtxarray *newva(const ivec &o, int size)
|
||||
{
|
||||
vtxarray *va = new vtxarray;
|
||||
va->parent = NULL;
|
||||
va->parent = nullptr;
|
||||
va->o = o;
|
||||
va->size = size;
|
||||
va->curvfc = VFC_NOT_VISIBLE;
|
||||
va->occluded = OCCLUDE_NOTHING;
|
||||
va->query = NULL;
|
||||
va->query = nullptr;
|
||||
va->bbmin = va->alphamin = va->refractmin = va->skymin = ivec(-1, -1, -1);
|
||||
va->bbmax = va->alphamax = va->refractmax = va->skymax = ivec(-1, -1, -1);
|
||||
va->hasmerges = 0;
|
||||
|
@ -1237,7 +1237,7 @@ void clearvas(cube *c)
|
|||
if(c[i].ext)
|
||||
{
|
||||
if(c[i].ext->va) destroyva(c[i].ext->va, false);
|
||||
c[i].ext->va = NULL;
|
||||
c[i].ext->va = nullptr;
|
||||
c[i].ext->tjoints = -1;
|
||||
}
|
||||
if(c[i].children) clearvas(c[i].children);
|
||||
|
@ -1343,7 +1343,7 @@ static int genmergedfaces(cube &c, const ivec &co, int size, int minlevel = -1)
|
|||
if(tj >= 0 && tjoints[tj].edge < (i+1)*(MAXFACEVERTS+1)) mf.tjoints = tj;
|
||||
|
||||
VSlot &vslot = lookupvslot(mf.tex, true),
|
||||
*layer = vslot.layer && !(c.material&MAT_ALPHA) ? &lookupvslot(vslot.layer, true) : NULL;
|
||||
*layer = vslot.layer && !(c.material&MAT_ALPHA) ? &lookupvslot(vslot.layer, true) : nullptr;
|
||||
if(vslot.slot->shader->type&SHADER_ENVMAP)
|
||||
mf.envmap = vslot.slot->texmask&(1<<TEX_ENVMAP) ? EMID_CUSTOM : closestenvmap(i, co, size);
|
||||
ushort envmap2 = layer && layer->slot->shader->type&SHADER_ENVMAP ? (layer->slot->texmask&(1<<TEX_ENVMAP) ? EMID_CUSTOM : closestenvmap(i, co, size)) : EMID_NONE;
|
||||
|
@ -1713,7 +1713,7 @@ void octarender() // creates va s for all leaf cub
|
|||
explicitsky += va->sky;
|
||||
}
|
||||
|
||||
visibleva = NULL;
|
||||
visibleva = nullptr;
|
||||
}
|
||||
|
||||
static void precachetextures()
|
||||
|
|
|
@ -263,7 +263,7 @@ static float shadowent(octaentities *oc, const vec &o, const vec &ray, float rad
|
|||
dent = min(dent, edist); \
|
||||
} \
|
||||
} \
|
||||
if(lc->children==NULL) break; \
|
||||
if(lc->children==nullptr) break; \
|
||||
lc = lc->children; \
|
||||
levels[lshift] = lc; \
|
||||
}
|
||||
|
@ -391,7 +391,7 @@ float rayent(const vec &o, const vec &ray, float radius, int mode, int size, int
|
|||
float dist = raycube(o, ray, radius, mode, size);
|
||||
if((mode&RAY_ENTS) == RAY_ENTS)
|
||||
{
|
||||
float dent = disttooutsideent(o, ray, dist < 0 ? 1e16f : dist, mode, NULL);
|
||||
float dent = disttooutsideent(o, ray, dist < 0 ? 1e16f : dist, mode, nullptr);
|
||||
if(dent < 1e15f && (dist < 0 || dent < dist)) dist = dent;
|
||||
}
|
||||
orient = hitorient;
|
||||
|
@ -612,7 +612,7 @@ static inline bool plcollide(physent *d, const vec &dir, physent *o)
|
|||
E entvol(d);
|
||||
O obvol(o);
|
||||
vec cp;
|
||||
if(mpr::collide(entvol, obvol, NULL, NULL, &cp))
|
||||
if(mpr::collide(entvol, obvol, nullptr, nullptr, &cp))
|
||||
{
|
||||
vec wn = vec(cp).sub(obvol.center());
|
||||
collidewall = obvol.contactface(wn, dir.iszero() ? vec(wn).neg() : dir);
|
||||
|
@ -640,7 +640,7 @@ static bool plcollide(physent *d, const vec &dir, bool insideplayercol) // co
|
|||
{
|
||||
if(d->type==ENT_CAMERA || d->state!=CS_ALIVE) return false;
|
||||
int lastinside = collideinside;
|
||||
physent *insideplayer = NULL;
|
||||
physent *insideplayer = nullptr;
|
||||
loopdynentcache(x, y, d->o, d->radius)
|
||||
{
|
||||
const vector<physent *> &dynents = checkdynentcache(x, y);
|
||||
|
@ -687,7 +687,7 @@ static inline bool mmcollide(physent *d, const vec &dir, const extentity &e, con
|
|||
E entvol(d);
|
||||
M mdlvol(e.o, center, radius, yaw, pitch, roll);
|
||||
vec cp;
|
||||
if(mpr::collide(entvol, mdlvol, NULL, NULL, &cp))
|
||||
if(mpr::collide(entvol, mdlvol, nullptr, nullptr, &cp))
|
||||
{
|
||||
vec wn = vec(cp).sub(mdlvol.center());
|
||||
collidewall = mdlvol.contactface(wn, dir.iszero() ? vec(wn).neg() : dir);
|
||||
|
@ -820,7 +820,7 @@ static bool mmcollide(physent *d, const vec &dir, float cutoff, octaentities &oc
|
|||
model *m = mmi.collide;
|
||||
if(!m)
|
||||
{
|
||||
if(!mmi.m && !loadmodel(NULL, e.attr1)) continue;
|
||||
if(!mmi.m && !loadmodel(nullptr, e.attr1)) continue;
|
||||
if(mmi.m->collidemodel) m = loadmodel(mmi.m->collidemodel);
|
||||
if(!m) m = mmi.m;
|
||||
mmi.collide = m;
|
||||
|
@ -1153,7 +1153,7 @@ static inline bool octacollide(physent *d, const vec &dir, float cutoff, const i
|
|||
bool collide(physent *d, const vec &dir, float cutoff, bool playercol, bool insideplayercol)
|
||||
{
|
||||
collideinside = 0;
|
||||
collideplayer = NULL;
|
||||
collideplayer = nullptr;
|
||||
collidewall = vec(0, 0, 0);
|
||||
ivec bo(int(d->o.x-d->radius), int(d->o.y-d->radius), int(d->o.z-d->eyeheight)),
|
||||
bs(int(d->o.x+d->radius), int(d->o.y+d->radius), int(d->o.z+d->aboveeye));
|
||||
|
@ -1602,7 +1602,7 @@ bool bounce(physent *d, float secs, float elasticity, float waterfric, float gra
|
|||
if(d->o == old) return !collideplayer;
|
||||
d->physstate = PHYS_BOUNCE;
|
||||
}
|
||||
return collideplayer!=NULL;
|
||||
return collideplayer!=nullptr;
|
||||
}
|
||||
|
||||
void avoidcollision(physent *d, const vec &dir, physent *obstacle, float space)
|
||||
|
|
|
@ -14,7 +14,7 @@ extern physent *collideplayer;
|
|||
|
||||
bool overlapsdynent(const vec &o, float radius);
|
||||
void rotatebb(vec ¢er, vec &radius, int yaw, int pitch, int roll = 0);
|
||||
float shadowray(const vec &o, const vec &ray, float radius, int mode, extentity *t = NULL);
|
||||
float shadowray(const vec &o, const vec &ray, float radius, int mode, extentity *t = nullptr);
|
||||
|
||||
void moveplayer(physent *pl, int moveres, bool local);
|
||||
bool moveplayer(physent *pl, int moveres, bool local, int curtime);
|
||||
|
|
|
@ -266,11 +266,11 @@ static inline bool htcmp(const pvsdata &x, const pvsdata &y)
|
|||
return x.len==y.len && !memcmp(&pvsbuf[x.offset], &pvsbuf[y.offset], x.len);
|
||||
}
|
||||
|
||||
static SDL_mutex *pvsmutex = NULL;
|
||||
static SDL_mutex *pvsmutex = nullptr;
|
||||
static hashtable<pvsdata, int> pvscompress;
|
||||
static vector<pvsdata> pvs;
|
||||
|
||||
static SDL_mutex *viewcellmutex = NULL;
|
||||
static SDL_mutex *viewcellmutex = nullptr;
|
||||
struct viewcellrequest
|
||||
{
|
||||
int *result;
|
||||
|
@ -297,7 +297,7 @@ static uint numwaterplanes = 0;
|
|||
|
||||
struct pvsworker
|
||||
{
|
||||
pvsworker() : thread(NULL), pvsnodes(new pvsnode[origpvsnodes.length()])
|
||||
pvsworker() : thread(nullptr), pvsnodes(new pvsnode[origpvsnodes.length()])
|
||||
{
|
||||
}
|
||||
~pvsworker()
|
||||
|
@ -321,7 +321,7 @@ struct pvsworker
|
|||
origin = ivec(0, 0, 0);
|
||||
}
|
||||
|
||||
int hasvoxel(const ivec &p, int coord, int dir, int ocoord = 0, int odir = 0, int *omin = NULL)
|
||||
int hasvoxel(const ivec &p, int coord, int dir, int ocoord = 0, int odir = 0, int *omin = nullptr)
|
||||
{
|
||||
uint diff = (origin.x^p.x)|(origin.y^p.y)|(origin.z^p.z);
|
||||
if(diff >= uint(worldsize)) return 0;
|
||||
|
@ -773,7 +773,7 @@ struct pvsworker
|
|||
serializepvs(pvsnodes[0]);
|
||||
}
|
||||
|
||||
uchar *testviewcell(const ivec &co, int size, int *waterpvs = NULL, int *len = NULL)
|
||||
uchar *testviewcell(const ivec &co, int size, int *waterpvs = nullptr, int *len = nullptr)
|
||||
{
|
||||
calcpvs(co, size);
|
||||
|
||||
|
@ -954,26 +954,26 @@ static void genviewcells(viewcellnode &p, cube *c, const ivec &co, int size, int
|
|||
}
|
||||
}
|
||||
|
||||
static viewcellnode *viewcells = NULL;
|
||||
static viewcellnode *viewcells = nullptr;
|
||||
static int lockedwaterplanes[MAXWATERPVS];
|
||||
static uchar *curpvs = NULL, *lockedpvs = NULL;
|
||||
static uchar *curpvs = nullptr, *lockedpvs = nullptr;
|
||||
static int curwaterpvs = 0, lockedwaterpvs = 0;
|
||||
|
||||
static inline pvsdata *lookupviewcell(const vec &p)
|
||||
{
|
||||
uint x = uint(floor(p.x)), y = uint(floor(p.y)), z = uint(floor(p.z));
|
||||
if(!viewcells || (x|y|z)>=uint(worldsize)) return NULL;
|
||||
if(!viewcells || (x|y|z)>=uint(worldsize)) return nullptr;
|
||||
viewcellnode *vc = viewcells;
|
||||
for(int scale = worldscale-1; scale>=0; scale--)
|
||||
{
|
||||
int i = octastep(x, y, z, scale);
|
||||
if(vc->leafmask&(1<<i))
|
||||
{
|
||||
return vc->children[i].pvs>=0 ? &pvs[vc->children[i].pvs] : NULL;
|
||||
return vc->children[i].pvs>=0 ? &pvs[vc->children[i].pvs] : nullptr;
|
||||
}
|
||||
vc = vc->children[i].node;
|
||||
}
|
||||
return NULL;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
static void lockpvs_(bool lock)
|
||||
|
@ -998,7 +998,7 @@ VARN(waterpvs, usewaterpvs, 0, 1, 1);
|
|||
|
||||
void setviewcell(const vec &p)
|
||||
{
|
||||
if(!usepvs) curpvs = NULL;
|
||||
if(!usepvs) curpvs = nullptr;
|
||||
else if(lockedpvs)
|
||||
{
|
||||
curpvs = lockedpvs;
|
||||
|
@ -1007,7 +1007,7 @@ void setviewcell(const vec &p)
|
|||
else
|
||||
{
|
||||
pvsdata *d = lookupviewcell(p);
|
||||
curpvs = d ? &pvsbuf[d->offset] : NULL;
|
||||
curpvs = d ? &pvsbuf[d->offset] : nullptr;
|
||||
curwaterpvs = 0;
|
||||
if(d)
|
||||
{
|
||||
|
@ -1022,7 +1022,7 @@ void clearpvs()
|
|||
DELETEP(viewcells);
|
||||
pvs.setsize(0);
|
||||
pvsbuf.setsize(0);
|
||||
curpvs = NULL;
|
||||
curpvs = nullptr;
|
||||
numwaterplanes = 0;
|
||||
lockpvs = 0;
|
||||
lockpvs_(false);
|
||||
|
@ -1138,7 +1138,7 @@ static void genpvs(int *viewcellsize)
|
|||
if(numthreads<=1)
|
||||
{
|
||||
pvsworkers.add(new pvsworker);
|
||||
timer = SDL_AddTimer(500, genpvs_timer, NULL);
|
||||
timer = SDL_AddTimer(500, genpvs_timer, nullptr);
|
||||
}
|
||||
viewcells = new viewcellnode;
|
||||
genviewcells(*viewcells, worldroot, ivec(0, 0, 0), worldsize>>1, *viewcellsize>0 ? *viewcellsize : 32);
|
||||
|
@ -1169,7 +1169,7 @@ static void genpvs(int *viewcellsize)
|
|||
SDL_LockMutex(viewcellmutex);
|
||||
viewcellrequests.setsize(0);
|
||||
SDL_UnlockMutex(viewcellmutex);
|
||||
loopv(pvsworkers) SDL_WaitThread(pvsworkers[i]->thread, NULL);
|
||||
loopv(pvsworkers) SDL_WaitThread(pvsworkers[i]->thread, nullptr);
|
||||
}
|
||||
pvsworkers.deletecontents();
|
||||
|
||||
|
@ -1235,12 +1235,12 @@ static inline bool pvsoccluded(uchar *buf, const ivec &bbmin, const ivec &bbmax)
|
|||
|
||||
bool pvsoccluded(const ivec &bbmin, const ivec &bbmax)
|
||||
{
|
||||
return curpvs!=NULL && pvsoccluded(curpvs, bbmin, bbmax);
|
||||
return curpvs!=nullptr && pvsoccluded(curpvs, bbmin, bbmax);
|
||||
}
|
||||
|
||||
bool pvsoccludedsphere(const vec ¢er, float radius)
|
||||
{
|
||||
if(curpvs==NULL) return false;
|
||||
if(curpvs==nullptr) return false;
|
||||
ivec bbmin(vec(center).sub(radius)), bbmax(vec(center).add(radius+1));
|
||||
return pvsoccluded(curpvs, bbmin, bbmax);
|
||||
}
|
||||
|
|
|
@ -152,8 +152,8 @@ struct ragdolldata
|
|||
scale(scale),
|
||||
verts(new vert[skel->verts.length()]),
|
||||
tris(new matrix3[skel->tris.length()]),
|
||||
animjoints(!skel->animjoints || skel->joints.empty() ? NULL : new matrix4x3[skel->joints.length()]),
|
||||
reljoints(skel->reljoints.empty() ? NULL : new dualquat[skel->reljoints.length()])
|
||||
animjoints(!skel->animjoints || skel->joints.empty() ? nullptr : new matrix4x3[skel->joints.length()]),
|
||||
reljoints(skel->reljoints.empty() ? nullptr : new dualquat[skel->reljoints.length()])
|
||||
{
|
||||
}
|
||||
|
||||
|
|
|
@ -39,238 +39,238 @@ VAR(glslversion, 1, 0, 0);
|
|||
VAR(glcompat, 1, 0, 0);
|
||||
|
||||
// GL_EXT_timer_query
|
||||
PFNGLGETQUERYOBJECTI64VEXTPROC glGetQueryObjecti64v_ = NULL;
|
||||
PFNGLGETQUERYOBJECTUI64VEXTPROC glGetQueryObjectui64v_ = NULL;
|
||||
PFNGLGETQUERYOBJECTI64VEXTPROC glGetQueryObjecti64v_ = nullptr;
|
||||
PFNGLGETQUERYOBJECTUI64VEXTPROC glGetQueryObjectui64v_ = nullptr;
|
||||
|
||||
// GL_EXT_framebuffer_object
|
||||
PFNGLBINDRENDERBUFFERPROC glBindRenderbuffer_ = NULL;
|
||||
PFNGLDELETERENDERBUFFERSPROC glDeleteRenderbuffers_ = NULL;
|
||||
PFNGLGENFRAMEBUFFERSPROC glGenRenderbuffers_ = NULL;
|
||||
PFNGLRENDERBUFFERSTORAGEPROC glRenderbufferStorage_ = NULL;
|
||||
PFNGLGETRENDERBUFFERPARAMETERIVPROC glGetRenderbufferParameteriv_ = NULL;
|
||||
PFNGLCHECKFRAMEBUFFERSTATUSPROC glCheckFramebufferStatus_ = NULL;
|
||||
PFNGLBINDFRAMEBUFFERPROC glBindFramebuffer_ = NULL;
|
||||
PFNGLDELETEFRAMEBUFFERSPROC glDeleteFramebuffers_ = NULL;
|
||||
PFNGLGENFRAMEBUFFERSPROC glGenFramebuffers_ = NULL;
|
||||
PFNGLFRAMEBUFFERTEXTURE1DPROC glFramebufferTexture1D_ = NULL;
|
||||
PFNGLFRAMEBUFFERTEXTURE2DPROC glFramebufferTexture2D_ = NULL;
|
||||
PFNGLFRAMEBUFFERTEXTURE3DPROC glFramebufferTexture3D_ = NULL;
|
||||
PFNGLFRAMEBUFFERRENDERBUFFERPROC glFramebufferRenderbuffer_ = NULL;
|
||||
PFNGLGENERATEMIPMAPPROC glGenerateMipmap_ = NULL;
|
||||
PFNGLBINDRENDERBUFFERPROC glBindRenderbuffer_ = nullptr;
|
||||
PFNGLDELETERENDERBUFFERSPROC glDeleteRenderbuffers_ = nullptr;
|
||||
PFNGLGENFRAMEBUFFERSPROC glGenRenderbuffers_ = nullptr;
|
||||
PFNGLRENDERBUFFERSTORAGEPROC glRenderbufferStorage_ = nullptr;
|
||||
PFNGLGETRENDERBUFFERPARAMETERIVPROC glGetRenderbufferParameteriv_ = nullptr;
|
||||
PFNGLCHECKFRAMEBUFFERSTATUSPROC glCheckFramebufferStatus_ = nullptr;
|
||||
PFNGLBINDFRAMEBUFFERPROC glBindFramebuffer_ = nullptr;
|
||||
PFNGLDELETEFRAMEBUFFERSPROC glDeleteFramebuffers_ = nullptr;
|
||||
PFNGLGENFRAMEBUFFERSPROC glGenFramebuffers_ = nullptr;
|
||||
PFNGLFRAMEBUFFERTEXTURE1DPROC glFramebufferTexture1D_ = nullptr;
|
||||
PFNGLFRAMEBUFFERTEXTURE2DPROC glFramebufferTexture2D_ = nullptr;
|
||||
PFNGLFRAMEBUFFERTEXTURE3DPROC glFramebufferTexture3D_ = nullptr;
|
||||
PFNGLFRAMEBUFFERRENDERBUFFERPROC glFramebufferRenderbuffer_ = nullptr;
|
||||
PFNGLGENERATEMIPMAPPROC glGenerateMipmap_ = nullptr;
|
||||
|
||||
// GL_EXT_framebuffer_blit
|
||||
PFNGLBLITFRAMEBUFFERPROC glBlitFramebuffer_ = NULL;
|
||||
PFNGLBLITFRAMEBUFFERPROC glBlitFramebuffer_ = nullptr;
|
||||
|
||||
// GL_EXT_framebuffer_multisample
|
||||
PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glRenderbufferStorageMultisample_ = NULL;
|
||||
PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glRenderbufferStorageMultisample_ = nullptr;
|
||||
|
||||
// GL_ARB_texture_multisample
|
||||
PFNGLTEXIMAGE2DMULTISAMPLEPROC glTexImage2DMultisample_ = NULL;
|
||||
PFNGLTEXIMAGE3DMULTISAMPLEPROC glTexImage3DMultisample_ = NULL;
|
||||
PFNGLGETMULTISAMPLEFVPROC glGetMultisamplefv_ = NULL;
|
||||
PFNGLSAMPLEMASKIPROC glSampleMaski_ = NULL;
|
||||
PFNGLTEXIMAGE2DMULTISAMPLEPROC glTexImage2DMultisample_ = nullptr;
|
||||
PFNGLTEXIMAGE3DMULTISAMPLEPROC glTexImage3DMultisample_ = nullptr;
|
||||
PFNGLGETMULTISAMPLEFVPROC glGetMultisamplefv_ = nullptr;
|
||||
PFNGLSAMPLEMASKIPROC glSampleMaski_ = nullptr;
|
||||
|
||||
// GL_ARB_sample_shading
|
||||
PFNGLMINSAMPLESHADINGPROC glMinSampleShading_ = NULL;
|
||||
PFNGLMINSAMPLESHADINGPROC glMinSampleShading_ = nullptr;
|
||||
|
||||
// GL_ARB_draw_buffers_blend
|
||||
PFNGLBLENDEQUATIONIPROC glBlendEquationi_ = NULL;
|
||||
PFNGLBLENDEQUATIONSEPARATEIPROC glBlendEquationSeparatei_ = NULL;
|
||||
PFNGLBLENDFUNCIPROC glBlendFunci_ = NULL;
|
||||
PFNGLBLENDFUNCSEPARATEIPROC glBlendFuncSeparatei_ = NULL;
|
||||
PFNGLBLENDEQUATIONIPROC glBlendEquationi_ = nullptr;
|
||||
PFNGLBLENDEQUATIONSEPARATEIPROC glBlendEquationSeparatei_ = nullptr;
|
||||
PFNGLBLENDFUNCIPROC glBlendFunci_ = nullptr;
|
||||
PFNGLBLENDFUNCSEPARATEIPROC glBlendFuncSeparatei_ = nullptr;
|
||||
|
||||
// OpenGL 1.3
|
||||
#ifdef WIN32
|
||||
PFNGLACTIVETEXTUREPROC glActiveTexture_ = NULL;
|
||||
PFNGLACTIVETEXTUREPROC glActiveTexture_ = nullptr;
|
||||
|
||||
PFNGLBLENDEQUATIONEXTPROC glBlendEquation_ = NULL;
|
||||
PFNGLBLENDCOLOREXTPROC glBlendColor_ = NULL;
|
||||
PFNGLBLENDEQUATIONEXTPROC glBlendEquation_ = nullptr;
|
||||
PFNGLBLENDCOLOREXTPROC glBlendColor_ = nullptr;
|
||||
|
||||
PFNGLTEXIMAGE3DPROC glTexImage3D_ = NULL;
|
||||
PFNGLTEXSUBIMAGE3DPROC glTexSubImage3D_ = NULL;
|
||||
PFNGLCOPYTEXSUBIMAGE3DPROC glCopyTexSubImage3D_ = NULL;
|
||||
PFNGLTEXIMAGE3DPROC glTexImage3D_ = nullptr;
|
||||
PFNGLTEXSUBIMAGE3DPROC glTexSubImage3D_ = nullptr;
|
||||
PFNGLCOPYTEXSUBIMAGE3DPROC glCopyTexSubImage3D_ = nullptr;
|
||||
|
||||
PFNGLCOMPRESSEDTEXIMAGE3DPROC glCompressedTexImage3D_ = NULL;
|
||||
PFNGLCOMPRESSEDTEXIMAGE2DPROC glCompressedTexImage2D_ = NULL;
|
||||
PFNGLCOMPRESSEDTEXIMAGE1DPROC glCompressedTexImage1D_ = NULL;
|
||||
PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glCompressedTexSubImage3D_ = NULL;
|
||||
PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glCompressedTexSubImage2D_ = NULL;
|
||||
PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glCompressedTexSubImage1D_ = NULL;
|
||||
PFNGLGETCOMPRESSEDTEXIMAGEPROC glGetCompressedTexImage_ = NULL;
|
||||
PFNGLCOMPRESSEDTEXIMAGE3DPROC glCompressedTexImage3D_ = nullptr;
|
||||
PFNGLCOMPRESSEDTEXIMAGE2DPROC glCompressedTexImage2D_ = nullptr;
|
||||
PFNGLCOMPRESSEDTEXIMAGE1DPROC glCompressedTexImage1D_ = nullptr;
|
||||
PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glCompressedTexSubImage3D_ = nullptr;
|
||||
PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glCompressedTexSubImage2D_ = nullptr;
|
||||
PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glCompressedTexSubImage1D_ = nullptr;
|
||||
PFNGLGETCOMPRESSEDTEXIMAGEPROC glGetCompressedTexImage_ = nullptr;
|
||||
|
||||
PFNGLDRAWRANGEELEMENTSPROC glDrawRangeElements_ = NULL;
|
||||
PFNGLDRAWRANGEELEMENTSPROC glDrawRangeElements_ = nullptr;
|
||||
#endif
|
||||
|
||||
// OpenGL 2.0
|
||||
#ifndef __APPLE__
|
||||
PFNGLMULTIDRAWARRAYSPROC glMultiDrawArrays_ = NULL;
|
||||
PFNGLMULTIDRAWELEMENTSPROC glMultiDrawElements_ = NULL;
|
||||
PFNGLMULTIDRAWARRAYSPROC glMultiDrawArrays_ = nullptr;
|
||||
PFNGLMULTIDRAWELEMENTSPROC glMultiDrawElements_ = nullptr;
|
||||
|
||||
PFNGLBLENDFUNCSEPARATEPROC glBlendFuncSeparate_ = NULL;
|
||||
PFNGLBLENDEQUATIONSEPARATEPROC glBlendEquationSeparate_ = NULL;
|
||||
PFNGLSTENCILOPSEPARATEPROC glStencilOpSeparate_ = NULL;
|
||||
PFNGLSTENCILFUNCSEPARATEPROC glStencilFuncSeparate_ = NULL;
|
||||
PFNGLSTENCILMASKSEPARATEPROC glStencilMaskSeparate_ = NULL;
|
||||
PFNGLBLENDFUNCSEPARATEPROC glBlendFuncSeparate_ = nullptr;
|
||||
PFNGLBLENDEQUATIONSEPARATEPROC glBlendEquationSeparate_ = nullptr;
|
||||
PFNGLSTENCILOPSEPARATEPROC glStencilOpSeparate_ = nullptr;
|
||||
PFNGLSTENCILFUNCSEPARATEPROC glStencilFuncSeparate_ = nullptr;
|
||||
PFNGLSTENCILMASKSEPARATEPROC glStencilMaskSeparate_ = nullptr;
|
||||
|
||||
PFNGLGENBUFFERSPROC glGenBuffers_ = NULL;
|
||||
PFNGLBINDBUFFERPROC glBindBuffer_ = NULL;
|
||||
PFNGLMAPBUFFERPROC glMapBuffer_ = NULL;
|
||||
PFNGLUNMAPBUFFERPROC glUnmapBuffer_ = NULL;
|
||||
PFNGLBUFFERDATAPROC glBufferData_ = NULL;
|
||||
PFNGLBUFFERSUBDATAPROC glBufferSubData_ = NULL;
|
||||
PFNGLDELETEBUFFERSPROC glDeleteBuffers_ = NULL;
|
||||
PFNGLGETBUFFERSUBDATAPROC glGetBufferSubData_ = NULL;
|
||||
PFNGLGENBUFFERSPROC glGenBuffers_ = nullptr;
|
||||
PFNGLBINDBUFFERPROC glBindBuffer_ = nullptr;
|
||||
PFNGLMAPBUFFERPROC glMapBuffer_ = nullptr;
|
||||
PFNGLUNMAPBUFFERPROC glUnmapBuffer_ = nullptr;
|
||||
PFNGLBUFFERDATAPROC glBufferData_ = nullptr;
|
||||
PFNGLBUFFERSUBDATAPROC glBufferSubData_ = nullptr;
|
||||
PFNGLDELETEBUFFERSPROC glDeleteBuffers_ = nullptr;
|
||||
PFNGLGETBUFFERSUBDATAPROC glGetBufferSubData_ = nullptr;
|
||||
|
||||
PFNGLGENQUERIESPROC glGenQueries_ = NULL;
|
||||
PFNGLDELETEQUERIESPROC glDeleteQueries_ = NULL;
|
||||
PFNGLBEGINQUERYPROC glBeginQuery_ = NULL;
|
||||
PFNGLENDQUERYPROC glEndQuery_ = NULL;
|
||||
PFNGLGETQUERYIVPROC glGetQueryiv_ = NULL;
|
||||
PFNGLGETQUERYOBJECTIVPROC glGetQueryObjectiv_ = NULL;
|
||||
PFNGLGETQUERYOBJECTUIVPROC glGetQueryObjectuiv_ = NULL;
|
||||
PFNGLGENQUERIESPROC glGenQueries_ = nullptr;
|
||||
PFNGLDELETEQUERIESPROC glDeleteQueries_ = nullptr;
|
||||
PFNGLBEGINQUERYPROC glBeginQuery_ = nullptr;
|
||||
PFNGLENDQUERYPROC glEndQuery_ = nullptr;
|
||||
PFNGLGETQUERYIVPROC glGetQueryiv_ = nullptr;
|
||||
PFNGLGETQUERYOBJECTIVPROC glGetQueryObjectiv_ = nullptr;
|
||||
PFNGLGETQUERYOBJECTUIVPROC glGetQueryObjectuiv_ = nullptr;
|
||||
|
||||
PFNGLCREATEPROGRAMPROC glCreateProgram_ = NULL;
|
||||
PFNGLDELETEPROGRAMPROC glDeleteProgram_ = NULL;
|
||||
PFNGLUSEPROGRAMPROC glUseProgram_ = NULL;
|
||||
PFNGLCREATESHADERPROC glCreateShader_ = NULL;
|
||||
PFNGLDELETESHADERPROC glDeleteShader_ = NULL;
|
||||
PFNGLSHADERSOURCEPROC glShaderSource_ = NULL;
|
||||
PFNGLCOMPILESHADERPROC glCompileShader_ = NULL;
|
||||
PFNGLGETSHADERIVPROC glGetShaderiv_ = NULL;
|
||||
PFNGLGETPROGRAMIVPROC glGetProgramiv_ = NULL;
|
||||
PFNGLATTACHSHADERPROC glAttachShader_ = NULL;
|
||||
PFNGLGETPROGRAMINFOLOGPROC glGetProgramInfoLog_ = NULL;
|
||||
PFNGLGETSHADERINFOLOGPROC glGetShaderInfoLog_ = NULL;
|
||||
PFNGLLINKPROGRAMPROC glLinkProgram_ = NULL;
|
||||
PFNGLGETUNIFORMLOCATIONPROC glGetUniformLocation_ = NULL;
|
||||
PFNGLUNIFORM1FPROC glUniform1f_ = NULL;
|
||||
PFNGLUNIFORM2FPROC glUniform2f_ = NULL;
|
||||
PFNGLUNIFORM3FPROC glUniform3f_ = NULL;
|
||||
PFNGLUNIFORM4FPROC glUniform4f_ = NULL;
|
||||
PFNGLUNIFORM1FVPROC glUniform1fv_ = NULL;
|
||||
PFNGLUNIFORM2FVPROC glUniform2fv_ = NULL;
|
||||
PFNGLUNIFORM3FVPROC glUniform3fv_ = NULL;
|
||||
PFNGLUNIFORM4FVPROC glUniform4fv_ = NULL;
|
||||
PFNGLUNIFORM1IPROC glUniform1i_ = NULL;
|
||||
PFNGLUNIFORM2IPROC glUniform2i_ = NULL;
|
||||
PFNGLUNIFORM3IPROC glUniform3i_ = NULL;
|
||||
PFNGLUNIFORM4IPROC glUniform4i_ = NULL;
|
||||
PFNGLUNIFORM1IVPROC glUniform1iv_ = NULL;
|
||||
PFNGLUNIFORM2IVPROC glUniform2iv_ = NULL;
|
||||
PFNGLUNIFORM3IVPROC glUniform3iv_ = NULL;
|
||||
PFNGLUNIFORM4IVPROC glUniform4iv_ = NULL;
|
||||
PFNGLUNIFORMMATRIX2FVPROC glUniformMatrix2fv_ = NULL;
|
||||
PFNGLUNIFORMMATRIX3FVPROC glUniformMatrix3fv_ = NULL;
|
||||
PFNGLUNIFORMMATRIX4FVPROC glUniformMatrix4fv_ = NULL;
|
||||
PFNGLBINDATTRIBLOCATIONPROC glBindAttribLocation_ = NULL;
|
||||
PFNGLGETACTIVEUNIFORMPROC glGetActiveUniform_ = NULL;
|
||||
PFNGLENABLEVERTEXATTRIBARRAYPROC glEnableVertexAttribArray_ = NULL;
|
||||
PFNGLDISABLEVERTEXATTRIBARRAYPROC glDisableVertexAttribArray_ = NULL;
|
||||
PFNGLCREATEPROGRAMPROC glCreateProgram_ = nullptr;
|
||||
PFNGLDELETEPROGRAMPROC glDeleteProgram_ = nullptr;
|
||||
PFNGLUSEPROGRAMPROC glUseProgram_ = nullptr;
|
||||
PFNGLCREATESHADERPROC glCreateShader_ = nullptr;
|
||||
PFNGLDELETESHADERPROC glDeleteShader_ = nullptr;
|
||||
PFNGLSHADERSOURCEPROC glShaderSource_ = nullptr;
|
||||
PFNGLCOMPILESHADERPROC glCompileShader_ = nullptr;
|
||||
PFNGLGETSHADERIVPROC glGetShaderiv_ = nullptr;
|
||||
PFNGLGETPROGRAMIVPROC glGetProgramiv_ = nullptr;
|
||||
PFNGLATTACHSHADERPROC glAttachShader_ = nullptr;
|
||||
PFNGLGETPROGRAMINFOLOGPROC glGetProgramInfoLog_ = nullptr;
|
||||
PFNGLGETSHADERINFOLOGPROC glGetShaderInfoLog_ = nullptr;
|
||||
PFNGLLINKPROGRAMPROC glLinkProgram_ = nullptr;
|
||||
PFNGLGETUNIFORMLOCATIONPROC glGetUniformLocation_ = nullptr;
|
||||
PFNGLUNIFORM1FPROC glUniform1f_ = nullptr;
|
||||
PFNGLUNIFORM2FPROC glUniform2f_ = nullptr;
|
||||
PFNGLUNIFORM3FPROC glUniform3f_ = nullptr;
|
||||
PFNGLUNIFORM4FPROC glUniform4f_ = nullptr;
|
||||
PFNGLUNIFORM1FVPROC glUniform1fv_ = nullptr;
|
||||
PFNGLUNIFORM2FVPROC glUniform2fv_ = nullptr;
|
||||
PFNGLUNIFORM3FVPROC glUniform3fv_ = nullptr;
|
||||
PFNGLUNIFORM4FVPROC glUniform4fv_ = nullptr;
|
||||
PFNGLUNIFORM1IPROC glUniform1i_ = nullptr;
|
||||
PFNGLUNIFORM2IPROC glUniform2i_ = nullptr;
|
||||
PFNGLUNIFORM3IPROC glUniform3i_ = nullptr;
|
||||
PFNGLUNIFORM4IPROC glUniform4i_ = nullptr;
|
||||
PFNGLUNIFORM1IVPROC glUniform1iv_ = nullptr;
|
||||
PFNGLUNIFORM2IVPROC glUniform2iv_ = nullptr;
|
||||
PFNGLUNIFORM3IVPROC glUniform3iv_ = nullptr;
|
||||
PFNGLUNIFORM4IVPROC glUniform4iv_ = nullptr;
|
||||
PFNGLUNIFORMMATRIX2FVPROC glUniformMatrix2fv_ = nullptr;
|
||||
PFNGLUNIFORMMATRIX3FVPROC glUniformMatrix3fv_ = nullptr;
|
||||
PFNGLUNIFORMMATRIX4FVPROC glUniformMatrix4fv_ = nullptr;
|
||||
PFNGLBINDATTRIBLOCATIONPROC glBindAttribLocation_ = nullptr;
|
||||
PFNGLGETACTIVEUNIFORMPROC glGetActiveUniform_ = nullptr;
|
||||
PFNGLENABLEVERTEXATTRIBARRAYPROC glEnableVertexAttribArray_ = nullptr;
|
||||
PFNGLDISABLEVERTEXATTRIBARRAYPROC glDisableVertexAttribArray_ = nullptr;
|
||||
|
||||
PFNGLVERTEXATTRIB1FPROC glVertexAttrib1f_ = NULL;
|
||||
PFNGLVERTEXATTRIB1FVPROC glVertexAttrib1fv_ = NULL;
|
||||
PFNGLVERTEXATTRIB1SPROC glVertexAttrib1s_ = NULL;
|
||||
PFNGLVERTEXATTRIB1SVPROC glVertexAttrib1sv_ = NULL;
|
||||
PFNGLVERTEXATTRIB2FPROC glVertexAttrib2f_ = NULL;
|
||||
PFNGLVERTEXATTRIB2FVPROC glVertexAttrib2fv_ = NULL;
|
||||
PFNGLVERTEXATTRIB2SPROC glVertexAttrib2s_ = NULL;
|
||||
PFNGLVERTEXATTRIB2SVPROC glVertexAttrib2sv_ = NULL;
|
||||
PFNGLVERTEXATTRIB3FPROC glVertexAttrib3f_ = NULL;
|
||||
PFNGLVERTEXATTRIB3FVPROC glVertexAttrib3fv_ = NULL;
|
||||
PFNGLVERTEXATTRIB3SPROC glVertexAttrib3s_ = NULL;
|
||||
PFNGLVERTEXATTRIB3SVPROC glVertexAttrib3sv_ = NULL;
|
||||
PFNGLVERTEXATTRIB4FPROC glVertexAttrib4f_ = NULL;
|
||||
PFNGLVERTEXATTRIB4FVPROC glVertexAttrib4fv_ = NULL;
|
||||
PFNGLVERTEXATTRIB4SPROC glVertexAttrib4s_ = NULL;
|
||||
PFNGLVERTEXATTRIB4SVPROC glVertexAttrib4sv_ = NULL;
|
||||
PFNGLVERTEXATTRIB4BVPROC glVertexAttrib4bv_ = NULL;
|
||||
PFNGLVERTEXATTRIB4IVPROC glVertexAttrib4iv_ = NULL;
|
||||
PFNGLVERTEXATTRIB4UBVPROC glVertexAttrib4ubv_ = NULL;
|
||||
PFNGLVERTEXATTRIB4UIVPROC glVertexAttrib4uiv_ = NULL;
|
||||
PFNGLVERTEXATTRIB4USVPROC glVertexAttrib4usv_ = NULL;
|
||||
PFNGLVERTEXATTRIB4NBVPROC glVertexAttrib4Nbv_ = NULL;
|
||||
PFNGLVERTEXATTRIB4NIVPROC glVertexAttrib4Niv_ = NULL;
|
||||
PFNGLVERTEXATTRIB4NUBPROC glVertexAttrib4Nub_ = NULL;
|
||||
PFNGLVERTEXATTRIB4NUBVPROC glVertexAttrib4Nubv_ = NULL;
|
||||
PFNGLVERTEXATTRIB4NUIVPROC glVertexAttrib4Nuiv_ = NULL;
|
||||
PFNGLVERTEXATTRIB4NUSVPROC glVertexAttrib4Nusv_ = NULL;
|
||||
PFNGLVERTEXATTRIBPOINTERPROC glVertexAttribPointer_ = NULL;
|
||||
PFNGLVERTEXATTRIB1FPROC glVertexAttrib1f_ = nullptr;
|
||||
PFNGLVERTEXATTRIB1FVPROC glVertexAttrib1fv_ = nullptr;
|
||||
PFNGLVERTEXATTRIB1SPROC glVertexAttrib1s_ = nullptr;
|
||||
PFNGLVERTEXATTRIB1SVPROC glVertexAttrib1sv_ = nullptr;
|
||||
PFNGLVERTEXATTRIB2FPROC glVertexAttrib2f_ = nullptr;
|
||||
PFNGLVERTEXATTRIB2FVPROC glVertexAttrib2fv_ = nullptr;
|
||||
PFNGLVERTEXATTRIB2SPROC glVertexAttrib2s_ = nullptr;
|
||||
PFNGLVERTEXATTRIB2SVPROC glVertexAttrib2sv_ = nullptr;
|
||||
PFNGLVERTEXATTRIB3FPROC glVertexAttrib3f_ = nullptr;
|
||||
PFNGLVERTEXATTRIB3FVPROC glVertexAttrib3fv_ = nullptr;
|
||||
PFNGLVERTEXATTRIB3SPROC glVertexAttrib3s_ = nullptr;
|
||||
PFNGLVERTEXATTRIB3SVPROC glVertexAttrib3sv_ = nullptr;
|
||||
PFNGLVERTEXATTRIB4FPROC glVertexAttrib4f_ = nullptr;
|
||||
PFNGLVERTEXATTRIB4FVPROC glVertexAttrib4fv_ = nullptr;
|
||||
PFNGLVERTEXATTRIB4SPROC glVertexAttrib4s_ = nullptr;
|
||||
PFNGLVERTEXATTRIB4SVPROC glVertexAttrib4sv_ = nullptr;
|
||||
PFNGLVERTEXATTRIB4BVPROC glVertexAttrib4bv_ = nullptr;
|
||||
PFNGLVERTEXATTRIB4IVPROC glVertexAttrib4iv_ = nullptr;
|
||||
PFNGLVERTEXATTRIB4UBVPROC glVertexAttrib4ubv_ = nullptr;
|
||||
PFNGLVERTEXATTRIB4UIVPROC glVertexAttrib4uiv_ = nullptr;
|
||||
PFNGLVERTEXATTRIB4USVPROC glVertexAttrib4usv_ = nullptr;
|
||||
PFNGLVERTEXATTRIB4NBVPROC glVertexAttrib4Nbv_ = nullptr;
|
||||
PFNGLVERTEXATTRIB4NIVPROC glVertexAttrib4Niv_ = nullptr;
|
||||
PFNGLVERTEXATTRIB4NUBPROC glVertexAttrib4Nub_ = nullptr;
|
||||
PFNGLVERTEXATTRIB4NUBVPROC glVertexAttrib4Nubv_ = nullptr;
|
||||
PFNGLVERTEXATTRIB4NUIVPROC glVertexAttrib4Nuiv_ = nullptr;
|
||||
PFNGLVERTEXATTRIB4NUSVPROC glVertexAttrib4Nusv_ = nullptr;
|
||||
PFNGLVERTEXATTRIBPOINTERPROC glVertexAttribPointer_ = nullptr;
|
||||
|
||||
PFNGLDRAWBUFFERSPROC glDrawBuffers_ = NULL;
|
||||
PFNGLDRAWBUFFERSPROC glDrawBuffers_ = nullptr;
|
||||
#endif
|
||||
|
||||
// OpenGL 3.0
|
||||
PFNGLGETSTRINGIPROC glGetStringi_ = NULL;
|
||||
PFNGLBINDFRAGDATALOCATIONPROC glBindFragDataLocation_ = NULL;
|
||||
PFNGLUNIFORM1UIPROC glUniform1ui_ = NULL;
|
||||
PFNGLUNIFORM2UIPROC glUniform2ui_ = NULL;
|
||||
PFNGLUNIFORM3UIPROC glUniform3ui_ = NULL;
|
||||
PFNGLUNIFORM4UIPROC glUniform4ui_ = NULL;
|
||||
PFNGLUNIFORM1UIVPROC glUniform1uiv_ = NULL;
|
||||
PFNGLUNIFORM2UIVPROC glUniform2uiv_ = NULL;
|
||||
PFNGLUNIFORM3UIVPROC glUniform3uiv_ = NULL;
|
||||
PFNGLUNIFORM4UIVPROC glUniform4uiv_ = NULL;
|
||||
PFNGLCLEARBUFFERIVPROC glClearBufferiv_ = NULL;
|
||||
PFNGLCLEARBUFFERUIVPROC glClearBufferuiv_ = NULL;
|
||||
PFNGLCLEARBUFFERFVPROC glClearBufferfv_ = NULL;
|
||||
PFNGLCLEARBUFFERFIPROC glClearBufferfi_ = NULL;
|
||||
PFNGLGETSTRINGIPROC glGetStringi_ = nullptr;
|
||||
PFNGLBINDFRAGDATALOCATIONPROC glBindFragDataLocation_ = nullptr;
|
||||
PFNGLUNIFORM1UIPROC glUniform1ui_ = nullptr;
|
||||
PFNGLUNIFORM2UIPROC glUniform2ui_ = nullptr;
|
||||
PFNGLUNIFORM3UIPROC glUniform3ui_ = nullptr;
|
||||
PFNGLUNIFORM4UIPROC glUniform4ui_ = nullptr;
|
||||
PFNGLUNIFORM1UIVPROC glUniform1uiv_ = nullptr;
|
||||
PFNGLUNIFORM2UIVPROC glUniform2uiv_ = nullptr;
|
||||
PFNGLUNIFORM3UIVPROC glUniform3uiv_ = nullptr;
|
||||
PFNGLUNIFORM4UIVPROC glUniform4uiv_ = nullptr;
|
||||
PFNGLCLEARBUFFERIVPROC glClearBufferiv_ = nullptr;
|
||||
PFNGLCLEARBUFFERUIVPROC glClearBufferuiv_ = nullptr;
|
||||
PFNGLCLEARBUFFERFVPROC glClearBufferfv_ = nullptr;
|
||||
PFNGLCLEARBUFFERFIPROC glClearBufferfi_ = nullptr;
|
||||
|
||||
// GL_EXT_draw_buffers2
|
||||
PFNGLCOLORMASKIPROC glColorMaski_ = NULL;
|
||||
PFNGLENABLEIPROC glEnablei_ = NULL;
|
||||
PFNGLDISABLEIPROC glDisablei_ = NULL;
|
||||
PFNGLCOLORMASKIPROC glColorMaski_ = nullptr;
|
||||
PFNGLENABLEIPROC glEnablei_ = nullptr;
|
||||
PFNGLDISABLEIPROC glDisablei_ = nullptr;
|
||||
|
||||
// GL_NV_conditional_render
|
||||
PFNGLBEGINCONDITIONALRENDERPROC glBeginConditionalRender_ = NULL;
|
||||
PFNGLENDCONDITIONALRENDERPROC glEndConditionalRender_ = NULL;
|
||||
PFNGLBEGINCONDITIONALRENDERPROC glBeginConditionalRender_ = nullptr;
|
||||
PFNGLENDCONDITIONALRENDERPROC glEndConditionalRender_ = nullptr;
|
||||
|
||||
// GL_EXT_texture_integer
|
||||
PFNGLTEXPARAMETERIIVPROC glTexParameterIiv_ = NULL;
|
||||
PFNGLTEXPARAMETERIUIVPROC glTexParameterIuiv_ = NULL;
|
||||
PFNGLGETTEXPARAMETERIIVPROC glGetTexParameterIiv_ = NULL;
|
||||
PFNGLGETTEXPARAMETERIUIVPROC glGetTexParameterIuiv_ = NULL;
|
||||
PFNGLCLEARCOLORIIEXTPROC glClearColorIi_ = NULL;
|
||||
PFNGLCLEARCOLORIUIEXTPROC glClearColorIui_ = NULL;
|
||||
PFNGLTEXPARAMETERIIVPROC glTexParameterIiv_ = nullptr;
|
||||
PFNGLTEXPARAMETERIUIVPROC glTexParameterIuiv_ = nullptr;
|
||||
PFNGLGETTEXPARAMETERIIVPROC glGetTexParameterIiv_ = nullptr;
|
||||
PFNGLGETTEXPARAMETERIUIVPROC glGetTexParameterIuiv_ = nullptr;
|
||||
PFNGLCLEARCOLORIIEXTPROC glClearColorIi_ = nullptr;
|
||||
PFNGLCLEARCOLORIUIEXTPROC glClearColorIui_ = nullptr;
|
||||
|
||||
// GL_ARB_uniform_buffer_object
|
||||
PFNGLGETUNIFORMINDICESPROC glGetUniformIndices_ = NULL;
|
||||
PFNGLGETACTIVEUNIFORMSIVPROC glGetActiveUniformsiv_ = NULL;
|
||||
PFNGLGETUNIFORMBLOCKINDEXPROC glGetUniformBlockIndex_ = NULL;
|
||||
PFNGLGETACTIVEUNIFORMBLOCKIVPROC glGetActiveUniformBlockiv_ = NULL;
|
||||
PFNGLUNIFORMBLOCKBINDINGPROC glUniformBlockBinding_ = NULL;
|
||||
PFNGLBINDBUFFERBASEPROC glBindBufferBase_ = NULL;
|
||||
PFNGLBINDBUFFERRANGEPROC glBindBufferRange_ = NULL;
|
||||
PFNGLGETUNIFORMINDICESPROC glGetUniformIndices_ = nullptr;
|
||||
PFNGLGETACTIVEUNIFORMSIVPROC glGetActiveUniformsiv_ = nullptr;
|
||||
PFNGLGETUNIFORMBLOCKINDEXPROC glGetUniformBlockIndex_ = nullptr;
|
||||
PFNGLGETACTIVEUNIFORMBLOCKIVPROC glGetActiveUniformBlockiv_ = nullptr;
|
||||
PFNGLUNIFORMBLOCKBINDINGPROC glUniformBlockBinding_ = nullptr;
|
||||
PFNGLBINDBUFFERBASEPROC glBindBufferBase_ = nullptr;
|
||||
PFNGLBINDBUFFERRANGEPROC glBindBufferRange_ = nullptr;
|
||||
|
||||
// GL_ARB_copy_buffer
|
||||
PFNGLCOPYBUFFERSUBDATAPROC glCopyBufferSubData_ = NULL;
|
||||
PFNGLCOPYBUFFERSUBDATAPROC glCopyBufferSubData_ = nullptr;
|
||||
|
||||
// GL_EXT_depth_bounds_test
|
||||
PFNGLDEPTHBOUNDSEXTPROC glDepthBounds_ = NULL;
|
||||
PFNGLDEPTHBOUNDSEXTPROC glDepthBounds_ = nullptr;
|
||||
|
||||
// GL_ARB_color_buffer_float
|
||||
PFNGLCLAMPCOLORPROC glClampColor_ = NULL;
|
||||
PFNGLCLAMPCOLORPROC glClampColor_ = nullptr;
|
||||
|
||||
// GL_ARB_debug_output
|
||||
PFNGLDEBUGMESSAGECONTROLPROC glDebugMessageControl_ = NULL;
|
||||
PFNGLDEBUGMESSAGEINSERTPROC glDebugMessageInsert_ = NULL;
|
||||
PFNGLDEBUGMESSAGECALLBACKPROC glDebugMessageCallback_ = NULL;
|
||||
PFNGLGETDEBUGMESSAGELOGPROC glGetDebugMessageLog_ = NULL;
|
||||
PFNGLDEBUGMESSAGECONTROLPROC glDebugMessageControl_ = nullptr;
|
||||
PFNGLDEBUGMESSAGEINSERTPROC glDebugMessageInsert_ = nullptr;
|
||||
PFNGLDEBUGMESSAGECALLBACKPROC glDebugMessageCallback_ = nullptr;
|
||||
PFNGLGETDEBUGMESSAGELOGPROC glGetDebugMessageLog_ = nullptr;
|
||||
|
||||
// GL_ARB_map_buffer_range
|
||||
PFNGLMAPBUFFERRANGEPROC glMapBufferRange_ = NULL;
|
||||
PFNGLFLUSHMAPPEDBUFFERRANGEPROC glFlushMappedBufferRange_ = NULL;
|
||||
PFNGLMAPBUFFERRANGEPROC glMapBufferRange_ = nullptr;
|
||||
PFNGLFLUSHMAPPEDBUFFERRANGEPROC glFlushMappedBufferRange_ = nullptr;
|
||||
|
||||
// GL_ARB_vertex_array_object
|
||||
PFNGLBINDVERTEXARRAYPROC glBindVertexArray_ = NULL;
|
||||
PFNGLDELETEVERTEXARRAYSPROC glDeleteVertexArrays_ = NULL;
|
||||
PFNGLGENVERTEXARRAYSPROC glGenVertexArrays_ = NULL;
|
||||
PFNGLISVERTEXARRAYPROC glIsVertexArray_ = NULL;
|
||||
PFNGLBINDVERTEXARRAYPROC glBindVertexArray_ = nullptr;
|
||||
PFNGLDELETEVERTEXARRAYSPROC glDeleteVertexArrays_ = nullptr;
|
||||
PFNGLGENVERTEXARRAYSPROC glGenVertexArrays_ = nullptr;
|
||||
PFNGLISVERTEXARRAYPROC glIsVertexArray_ = nullptr;
|
||||
|
||||
// GL_ARB_blend_func_extended
|
||||
PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glBindFragDataLocationIndexed_ = NULL;
|
||||
PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glBindFragDataLocationIndexed_ = nullptr;
|
||||
|
||||
// GL_ARB_copy_image
|
||||
PFNGLCOPYIMAGESUBDATAPROC glCopyImageSubData_ = NULL;
|
||||
PFNGLCOPYIMAGESUBDATAPROC glCopyImageSubData_ = nullptr;
|
||||
|
||||
static inline void *getprocaddress(const char *name)
|
||||
{
|
||||
|
@ -361,7 +361,7 @@ static void parseglexts()
|
|||
|
||||
static inline bool hasext(const char *ext)
|
||||
{
|
||||
return glexts.access(ext)!=NULL;
|
||||
return glexts.access(ext)!=nullptr;
|
||||
}
|
||||
|
||||
static bool checkdepthtexstencilrb()
|
||||
|
@ -373,7 +373,7 @@ static bool checkdepthtexstencilrb()
|
|||
|
||||
GLuint depthtex = 0;
|
||||
glGenTextures(1, &depthtex);
|
||||
createtexture(depthtex, w, h, NULL, 3, 0, GL_DEPTH_COMPONENT24, GL_TEXTURE_RECTANGLE);
|
||||
createtexture(depthtex, w, h, nullptr, 3, 0, GL_DEPTH_COMPONENT24, GL_TEXTURE_RECTANGLE);
|
||||
glBindTexture(GL_TEXTURE_RECTANGLE, 0);
|
||||
glFramebufferTexture2D_(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_RECTANGLE, depthtex, 0);
|
||||
|
||||
|
@ -1126,7 +1126,7 @@ static timer *findtimer(const char *name, bool gpu)
|
|||
|
||||
timer *begintimer(const char *name, bool gpu)
|
||||
{
|
||||
if(!usetimers || inbetweenframes || (gpu && (!hasTQ || deferquery))) return NULL;
|
||||
if(!usetimers || inbetweenframes || (gpu && (!hasTQ || deferquery))) return nullptr;
|
||||
timer *t = findtimer(name, gpu);
|
||||
if(t->gpu)
|
||||
{
|
||||
|
@ -1390,7 +1390,7 @@ VAR(thirdperson, 0, 0, 2);
|
|||
FVAR(thirdpersondistance, 0, 30, 50);
|
||||
FVAR(thirdpersonup, -25, 0, 25);
|
||||
FVAR(thirdpersonside, -25, 0, 25);
|
||||
physent *camera1 = NULL;
|
||||
physent *camera1 = nullptr;
|
||||
static bool detachedcamera = false;
|
||||
static bool isthirdperson() { return player!=camera1 || detachedcamera; }
|
||||
|
||||
|
@ -2165,7 +2165,7 @@ void drawminimap()
|
|||
camera1 = oldcamera;
|
||||
drawtex = 0;
|
||||
|
||||
createtexture(minimaptex, size, size, NULL, 3, 1, GL_RGB5, GL_TEXTURE_2D);
|
||||
createtexture(minimaptex, size, size, nullptr, 3, 1, GL_RGB5, GL_TEXTURE_2D);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
|
||||
GLfloat border[4] = { minimapcolour.x/255.0f, minimapcolour.y/255.0f, minimapcolour.z/255.0f, 1.0f };
|
||||
|
@ -2501,7 +2501,7 @@ void gl_drawview()
|
|||
|
||||
void gl_drawmainmenu()
|
||||
{
|
||||
renderbackground(NULL, NULL, NULL, NULL, true);
|
||||
renderbackground(nullptr, nullptr, nullptr, nullptr, true);
|
||||
}
|
||||
|
||||
VAR(hidestats, 0, 0, 1);
|
||||
|
@ -2510,7 +2510,7 @@ VAR(hidehud, 0, 0, 1);
|
|||
VARP(crosshairsize, 0, 15, 50);
|
||||
VARP(cursorsize, 0, 15, 30);
|
||||
|
||||
static Texture *crosshair = NULL;
|
||||
static Texture *crosshair = nullptr;
|
||||
|
||||
static void drawcrosshair(int w, int h)
|
||||
{
|
||||
|
@ -2521,7 +2521,7 @@ static void drawcrosshair(int w, int h)
|
|||
float cx = 0.5f, cy = 0.5f, chsize;
|
||||
if(windowhit)
|
||||
{
|
||||
static Texture *cursor = NULL;
|
||||
static Texture *cursor = nullptr;
|
||||
if(!cursor) cursor = textureload("media/interface/cursor.png", 3, true);
|
||||
crosshair = cursor;
|
||||
chsize = cursorsize*w/900.0f;
|
||||
|
@ -2613,7 +2613,7 @@ void gl_drawhud()
|
|||
|
||||
if(wallclock)
|
||||
{
|
||||
if(!walltime) { walltime = time(NULL); walltime -= totalmillis/1000; if(!walltime) walltime++; }
|
||||
if(!walltime) { walltime = time(nullptr); walltime -= totalmillis/1000; if(!walltime) walltime++; }
|
||||
time_t walloffset = walltime + totalmillis/1000;
|
||||
struct tm *localvals = localtime(&walloffset);
|
||||
static string buf;
|
||||
|
|
|
@ -72,22 +72,22 @@ void setupbloom(int w, int h)
|
|||
loopi(5) if(!bloomfbo[i]) glGenFramebuffers_(1, &bloomfbo[i]);
|
||||
|
||||
bloomformat = gethdrformat(bloomprec);
|
||||
createtexture(bloomtex[0], max(gw/2, bloomw), max(gh/2, bloomh), NULL, 3, 1, bloomformat, GL_TEXTURE_RECTANGLE);
|
||||
createtexture(bloomtex[1], max(gw/4, bloomw), max(gh/4, bloomh), NULL, 3, 1, bloomformat, GL_TEXTURE_RECTANGLE);
|
||||
createtexture(bloomtex[2], bloomw, bloomh, NULL, 3, 1, GL_RGB, GL_TEXTURE_RECTANGLE);
|
||||
createtexture(bloomtex[3], bloomw, bloomh, NULL, 3, 1, GL_RGB, GL_TEXTURE_RECTANGLE);
|
||||
createtexture(bloomtex[0], max(gw/2, bloomw), max(gh/2, bloomh), nullptr, 3, 1, bloomformat, GL_TEXTURE_RECTANGLE);
|
||||
createtexture(bloomtex[1], max(gw/4, bloomw), max(gh/4, bloomh), nullptr, 3, 1, bloomformat, GL_TEXTURE_RECTANGLE);
|
||||
createtexture(bloomtex[2], bloomw, bloomh, nullptr, 3, 1, GL_RGB, GL_TEXTURE_RECTANGLE);
|
||||
createtexture(bloomtex[3], bloomw, bloomh, nullptr, 3, 1, GL_RGB, GL_TEXTURE_RECTANGLE);
|
||||
if(bloomformat != GL_RGB)
|
||||
{
|
||||
if(!bloomtex[5]) glGenTextures(1, &bloomtex[5]);
|
||||
if(!bloomfbo[5]) glGenFramebuffers_(1, &bloomfbo[5]);
|
||||
createtexture(bloomtex[5], bloomw, bloomh, NULL, 3, 1, bloomformat, GL_TEXTURE_RECTANGLE);
|
||||
createtexture(bloomtex[5], bloomw, bloomh, nullptr, 3, 1, bloomformat, GL_TEXTURE_RECTANGLE);
|
||||
}
|
||||
|
||||
if(hwvtexunits < 4)
|
||||
{
|
||||
glGenBuffers_(1, &bloompbo);
|
||||
glBindBuffer_(GL_PIXEL_PACK_BUFFER, bloompbo);
|
||||
glBufferData_(GL_PIXEL_PACK_BUFFER, 4*(hasTF ? sizeof(GLfloat) : sizeof(GLushort))*(hasTRG ? 1 : 3), NULL, GL_DYNAMIC_COPY);
|
||||
glBufferData_(GL_PIXEL_PACK_BUFFER, 4*(hasTF ? sizeof(GLfloat) : sizeof(GLushort))*(hasTRG ? 1 : 3), nullptr, GL_DYNAMIC_COPY);
|
||||
glBindBuffer_(GL_PIXEL_PACK_BUFFER, 0);
|
||||
}
|
||||
|
||||
|
@ -118,7 +118,7 @@ void cleanupbloom()
|
|||
|
||||
extern int ao, aotaps, aoreduce, aoreducedepth, aonoise, aobilateral, aobilateralupscale, aopackdepth, aodepthformat, aoprec, aoderivnormal;
|
||||
|
||||
static Shader *bilateralshader[2] = { NULL, NULL };
|
||||
static Shader *bilateralshader[2] = { nullptr, nullptr };
|
||||
|
||||
Shader *loadbilateralshader(int pass)
|
||||
{
|
||||
|
@ -151,7 +151,7 @@ void loadbilateralshaders()
|
|||
|
||||
void clearbilateralshaders()
|
||||
{
|
||||
loopk(2) bilateralshader[k] = NULL;
|
||||
loopk(2) bilateralshader[k] = nullptr;
|
||||
}
|
||||
|
||||
void setbilateralparams(int radius, float depth)
|
||||
|
@ -166,7 +166,7 @@ void setbilateralshader(int radius, int pass, float depth)
|
|||
setbilateralparams(radius, depth);
|
||||
}
|
||||
|
||||
static Shader *ambientobscuranceshader = NULL;
|
||||
static Shader *ambientobscuranceshader = nullptr;
|
||||
|
||||
Shader *loadambientobscuranceshader()
|
||||
{
|
||||
|
@ -190,7 +190,7 @@ void loadaoshaders()
|
|||
|
||||
void clearaoshaders()
|
||||
{
|
||||
ambientobscuranceshader = NULL;
|
||||
ambientobscuranceshader = nullptr;
|
||||
}
|
||||
|
||||
void setupao(int w, int h)
|
||||
|
@ -216,7 +216,7 @@ void setupao(int w, int h)
|
|||
{
|
||||
if(!aotex[i]) glGenTextures(1, &aotex[i]);
|
||||
if(!aofbo[i]) glGenFramebuffers_(1, &aofbo[i]);
|
||||
createtexture(aotex[i], upscale && i ? w : aow, upscale && i >= 2 ? h : aoh, NULL, 3, i < 2 ? packfilter : 1, i < 2 ? packformat : format, GL_TEXTURE_RECTANGLE);
|
||||
createtexture(aotex[i], upscale && i ? w : aow, upscale && i >= 2 ? h : aoh, nullptr, 3, i < 2 ? packfilter : 1, i < 2 ? packformat : format, GL_TEXTURE_RECTANGLE);
|
||||
glBindFramebuffer_(GL_FRAMEBUFFER, aofbo[i]);
|
||||
glFramebufferTexture2D_(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE, aotex[i], 0);
|
||||
if(glCheckFramebufferStatus_(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
|
||||
|
@ -232,7 +232,7 @@ void setupao(int w, int h)
|
|||
{
|
||||
if(!aotex[3]) glGenTextures(1, &aotex[3]);
|
||||
if(!aofbo[3]) glGenFramebuffers_(1, &aofbo[3]);
|
||||
createtexture(aotex[3], aow, aoh, NULL, 3, 0, aodepthformat > 1 ? GL_R32F : (aodepthformat ? GL_R16F : GL_RGBA8), GL_TEXTURE_RECTANGLE);
|
||||
createtexture(aotex[3], aow, aoh, nullptr, 3, 0, aodepthformat > 1 ? GL_R32F : (aodepthformat ? GL_R16F : GL_RGBA8), GL_TEXTURE_RECTANGLE);
|
||||
glBindFramebuffer_(GL_FRAMEBUFFER, aofbo[3]);
|
||||
glFramebufferTexture2D_(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE, aotex[3], 0);
|
||||
if(glCheckFramebufferStatus_(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
|
||||
|
@ -416,7 +416,7 @@ void setupscale(int sw, int sh, int w, int h)
|
|||
|
||||
glBindFramebuffer_(GL_FRAMEBUFFER, scalefbo[i]);
|
||||
|
||||
createtexture(scaletex[i], sw, i ? h : sh, NULL, 3, gscalecubic || !gscalenearest ? 1 : 0, GL_RGB, GL_TEXTURE_RECTANGLE);
|
||||
createtexture(scaletex[i], sw, i ? h : sh, nullptr, 3, gscalecubic || !gscalenearest ? 1 : 0, GL_RGB, GL_TEXTURE_RECTANGLE);
|
||||
|
||||
glFramebufferTexture2D_(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE, scaletex[i], 0);
|
||||
if(!i) bindgdepth();
|
||||
|
@ -815,11 +815,11 @@ void setupgbuffer()
|
|||
|
||||
static const GLenum depthformats[] = { GL_RGBA8, GL_R16F, GL_R32F };
|
||||
GLenum depthformat = gdepthformat ? depthformats[gdepthformat-1] : (ghasstencil > 1 ? stencilformat : GL_DEPTH_COMPONENT24);
|
||||
createtexture(gdepthtex, gw, gh, NULL, 3, 0, depthformat, GL_TEXTURE_RECTANGLE);
|
||||
createtexture(gdepthtex, gw, gh, nullptr, 3, 0, depthformat, GL_TEXTURE_RECTANGLE);
|
||||
|
||||
createtexture(gcolortex, gw, gh, NULL, 3, 0, GL_RGBA8, GL_TEXTURE_RECTANGLE);
|
||||
createtexture(gnormaltex, gw, gh, NULL, 3, 0, GL_RGBA8, GL_TEXTURE_RECTANGLE);
|
||||
createtexture(gglowtex, gw, gh, NULL, 3, 0, hasAFBO ? hdrformat : GL_RGBA8, GL_TEXTURE_RECTANGLE);
|
||||
createtexture(gcolortex, gw, gh, nullptr, 3, 0, GL_RGBA8, GL_TEXTURE_RECTANGLE);
|
||||
createtexture(gnormaltex, gw, gh, nullptr, 3, 0, GL_RGBA8, GL_TEXTURE_RECTANGLE);
|
||||
createtexture(gglowtex, gw, gh, nullptr, 3, 0, hasAFBO ? hdrformat : GL_RGBA8, GL_TEXTURE_RECTANGLE);
|
||||
|
||||
bindgdepth();
|
||||
glFramebufferTexture2D_(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE, gcolortex, 0);
|
||||
|
@ -831,7 +831,7 @@ void setupgbuffer()
|
|||
{
|
||||
if(hasAFBO)
|
||||
{
|
||||
createtexture(gglowtex, gw, gh, NULL, 3, 0, GL_RGBA8, GL_TEXTURE_RECTANGLE);
|
||||
createtexture(gglowtex, gw, gh, nullptr, 3, 0, GL_RGBA8, GL_TEXTURE_RECTANGLE);
|
||||
glFramebufferTexture2D_(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT2, GL_TEXTURE_RECTANGLE, gglowtex, 0);
|
||||
if(glCheckFramebufferStatus_(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
|
||||
fatal("failed allocating g-buffer!");
|
||||
|
@ -848,7 +848,7 @@ void setupgbuffer()
|
|||
|
||||
glBindFramebuffer_(GL_FRAMEBUFFER, hdrfbo);
|
||||
|
||||
createtexture(hdrtex, gw, gh, NULL, 3, 1, hdrformat, GL_TEXTURE_RECTANGLE);
|
||||
createtexture(hdrtex, gw, gh, nullptr, 3, 1, hdrformat, GL_TEXTURE_RECTANGLE);
|
||||
|
||||
glFramebufferTexture2D_(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE, hdrtex, 0);
|
||||
bindgdepth();
|
||||
|
@ -863,7 +863,7 @@ void setupgbuffer()
|
|||
|
||||
glBindFramebuffer_(GL_FRAMEBUFFER, refractfbo);
|
||||
|
||||
createtexture(refracttex, gw, gh, NULL, 3, 0, GL_RGB, GL_TEXTURE_RECTANGLE);
|
||||
createtexture(refracttex, gw, gh, nullptr, 3, 0, GL_RGB, GL_TEXTURE_RECTANGLE);
|
||||
|
||||
glFramebufferTexture2D_(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE, refracttex, 0);
|
||||
bindgdepth();
|
||||
|
@ -902,7 +902,7 @@ void resolvemsaadepth(int w = vieww, int h = viewh)
|
|||
{
|
||||
if(!msaasamples || msaalight) return;
|
||||
|
||||
timer *resolvetimer = drawtex ? NULL : begintimer("msaa depth resolve");
|
||||
timer *resolvetimer = drawtex ? nullptr : begintimer("msaa depth resolve");
|
||||
|
||||
if(msaadepthblit)
|
||||
{
|
||||
|
@ -950,7 +950,7 @@ void resolvemsaacolor(int w = vieww, int h = viewh)
|
|||
{
|
||||
if(!msaalight) return;
|
||||
|
||||
timer *resolvetimer = drawtex ? NULL : begintimer("msaa resolve");
|
||||
timer *resolvetimer = drawtex ? nullptr : begintimer("msaa resolve");
|
||||
|
||||
glBindFramebuffer_(GL_READ_FRAMEBUFFER, mshdrfbo);
|
||||
glBindFramebuffer_(GL_DRAW_FRAMEBUFFER, hdrfbo);
|
||||
|
@ -1170,7 +1170,7 @@ void processhdr(GLuint outfbo, int aa)
|
|||
{
|
||||
glBindBuffer_(GL_PIXEL_PACK_BUFFER, bloompbo);
|
||||
glPixelStorei(GL_PACK_ALIGNMENT, 1);
|
||||
glReadPixels(0, 0, 4, 1, hasTRG ? GL_RED : GL_RGB, hasTF ? GL_FLOAT : GL_UNSIGNED_SHORT, NULL);
|
||||
glReadPixels(0, 0, 4, 1, hasTRG ? GL_RED : GL_RGB, hasTF ? GL_FLOAT : GL_UNSIGNED_SHORT, nullptr);
|
||||
glBindBuffer_(GL_PIXEL_PACK_BUFFER, 0);
|
||||
}
|
||||
|
||||
|
@ -1387,8 +1387,8 @@ GLuint rsmdepthtex = 0, rsmcolortex = 0, rsmnormaltex = 0, rsmfbo = 0;
|
|||
|
||||
extern int rhrect, rhgrid, rhsplits, rhborder, rhprec, rhtaps, rhcache, rhforce, rsmprec, rsmdepthprec, rsmsize;
|
||||
|
||||
static Shader *radiancehintsshader = NULL;
|
||||
Shader *rsmworldshader = NULL;
|
||||
static Shader *radiancehintsshader = nullptr;
|
||||
Shader *rsmworldshader = nullptr;
|
||||
|
||||
Shader *loadradiancehintsshader()
|
||||
{
|
||||
|
@ -1408,8 +1408,8 @@ void loadrhshaders()
|
|||
|
||||
void clearrhshaders()
|
||||
{
|
||||
radiancehintsshader = NULL;
|
||||
rsmworldshader = NULL;
|
||||
radiancehintsshader = nullptr;
|
||||
rsmworldshader = nullptr;
|
||||
}
|
||||
|
||||
void setupradiancehints()
|
||||
|
@ -1419,7 +1419,7 @@ void setupradiancehints()
|
|||
loopi(!rhrect && rhcache ? 8 : 4)
|
||||
{
|
||||
if(!rhtex[i]) glGenTextures(1, &rhtex[i]);
|
||||
create3dtexture(rhtex[i], rhgrid+2*rhborder, rhgrid+2*rhborder, (rhgrid+2*rhborder)*rhsplits, NULL, 7, 1, rhformat);
|
||||
create3dtexture(rhtex[i], rhgrid+2*rhborder, rhgrid+2*rhborder, (rhgrid+2*rhborder)*rhsplits, nullptr, 7, 1, rhformat);
|
||||
if(rhborder)
|
||||
{
|
||||
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
|
||||
|
@ -1459,9 +1459,9 @@ void setupradiancehints()
|
|||
|
||||
GLenum rsmformat = gethdrformat(rsmprec, GL_RGBA8);
|
||||
|
||||
createtexture(rsmdepthtex, rsmsize, rsmsize, NULL, 3, 0, rsmdepthprec > 1 ? GL_DEPTH_COMPONENT32 : (rsmdepthprec ? GL_DEPTH_COMPONENT24 : GL_DEPTH_COMPONENT16), GL_TEXTURE_RECTANGLE);
|
||||
createtexture(rsmcolortex, rsmsize, rsmsize, NULL, 3, 0, rsmformat, GL_TEXTURE_RECTANGLE);
|
||||
createtexture(rsmnormaltex, rsmsize, rsmsize, NULL, 3, 0, rsmformat, GL_TEXTURE_RECTANGLE);
|
||||
createtexture(rsmdepthtex, rsmsize, rsmsize, nullptr, 3, 0, rsmdepthprec > 1 ? GL_DEPTH_COMPONENT32 : (rsmdepthprec ? GL_DEPTH_COMPONENT24 : GL_DEPTH_COMPONENT16), GL_TEXTURE_RECTANGLE);
|
||||
createtexture(rsmcolortex, rsmsize, rsmsize, nullptr, 3, 0, rsmformat, GL_TEXTURE_RECTANGLE);
|
||||
createtexture(rsmnormaltex, rsmsize, rsmsize, nullptr, 3, 0, rsmformat, GL_TEXTURE_RECTANGLE);
|
||||
|
||||
glFramebufferTexture2D_(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_RECTANGLE, rsmdepthtex, 0);
|
||||
glFramebufferTexture2D_(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE, rsmcolortex, 0);
|
||||
|
@ -1589,7 +1589,7 @@ struct lightinfo
|
|||
lightinfo(const vec &o, const vec &color, float radius, int flags = 0, const vec &dir = vec(0, 0, 0), int spot = 0)
|
||||
: ent(-1), shadowmap(-1), flags(flags),
|
||||
o(o), color(color), radius(radius), dist(camera1->o.dist(o)),
|
||||
dir(dir), spot(spot), query(NULL)
|
||||
dir(dir), spot(spot), query(nullptr)
|
||||
{
|
||||
if(spot > 0) calcspot();
|
||||
calcscissor();
|
||||
|
@ -1597,7 +1597,7 @@ struct lightinfo
|
|||
lightinfo(int i, const extentity &e)
|
||||
: ent(i), shadowmap(-1), flags(e.attr5),
|
||||
o(e.o), color(vec(e.attr2, e.attr3, e.attr4).max(0)), radius(e.attr1), dist(camera1->o.dist(e.o)),
|
||||
dir(0, 0, 0), spot(0), query(NULL)
|
||||
dir(0, 0, 0), spot(0), query(nullptr)
|
||||
{
|
||||
if(e.attached && e.attached->type == ET_SPOTLIGHT)
|
||||
{
|
||||
|
@ -1771,7 +1771,7 @@ void setupshadowatlas()
|
|||
if(!shadowatlastex) glGenTextures(1, &shadowatlastex);
|
||||
|
||||
shadowatlastarget = usegatherforsm() ? GL_TEXTURE_2D : GL_TEXTURE_RECTANGLE;
|
||||
createtexture(shadowatlastex, shadowatlaspacker.w, shadowatlaspacker.h, NULL, 3, 1, smdepthprec > 1 ? GL_DEPTH_COMPONENT32 : (smdepthprec ? GL_DEPTH_COMPONENT24 : GL_DEPTH_COMPONENT16), shadowatlastarget);
|
||||
createtexture(shadowatlastex, shadowatlaspacker.w, shadowatlaspacker.h, nullptr, 3, 1, smdepthprec > 1 ? GL_DEPTH_COMPONENT32 : (smdepthprec ? GL_DEPTH_COMPONENT24 : GL_DEPTH_COMPONENT16), shadowatlastarget);
|
||||
glTexParameteri(shadowatlastarget, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
|
||||
glTexParameteri(shadowatlastarget, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);
|
||||
|
||||
|
@ -1955,7 +1955,7 @@ void clearshadowcache()
|
|||
clearshadowmeshes();
|
||||
}
|
||||
|
||||
static shadowmapinfo *addshadowmap(ushort x, ushort y, int size, int &idx, int light = -1, shadowcacheval *cached = NULL)
|
||||
static shadowmapinfo *addshadowmap(ushort x, ushort y, int size, int &idx, int light = -1, shadowcacheval *cached = nullptr)
|
||||
{
|
||||
idx = shadowmaps.length();
|
||||
shadowmapinfo *sm = &shadowmaps.add();
|
||||
|
@ -2423,13 +2423,13 @@ VAR(forcespotlights, 1, 0, 0);
|
|||
|
||||
extern int spotlights;
|
||||
|
||||
static Shader *volumetricshader = NULL, *volumetricbilateralshader[2] = { NULL, NULL };
|
||||
static Shader *volumetricshader = nullptr, *volumetricbilateralshader[2] = { nullptr, nullptr };
|
||||
|
||||
void clearvolumetricshaders()
|
||||
{
|
||||
volumetricshader = NULL;
|
||||
volumetricshader = nullptr;
|
||||
|
||||
loopi(2) volumetricbilateralshader[i] = NULL;
|
||||
loopi(2) volumetricbilateralshader[i] = nullptr;
|
||||
}
|
||||
|
||||
extern int volsteps, volbilateral, volblur, volreduce;
|
||||
|
@ -2477,7 +2477,7 @@ void setupvolumetric(int w, int h)
|
|||
|
||||
glBindFramebuffer_(GL_FRAMEBUFFER, volfbo[i]);
|
||||
|
||||
createtexture(voltex[i], volw, volh, NULL, 3, 1, hdrformat, GL_TEXTURE_RECTANGLE);
|
||||
createtexture(voltex[i], volw, volh, nullptr, 3, 1, hdrformat, GL_TEXTURE_RECTANGLE);
|
||||
|
||||
glFramebufferTexture2D_(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE, voltex[i], 0);
|
||||
|
||||
|
@ -2511,19 +2511,19 @@ FVAR(voldistclamp, 0, 0.99f, 2);
|
|||
CVAR1R(volcolour, 0x808080);
|
||||
FVARR(volscale, 0, 1, 16);
|
||||
|
||||
static Shader *deferredlightshader = NULL, *deferredminimapshader = NULL, *deferredmsaapixelshader = NULL, *deferredmsaasampleshader = NULL;
|
||||
static Shader *deferredlightshader = nullptr, *deferredminimapshader = nullptr, *deferredmsaapixelshader = nullptr, *deferredmsaasampleshader = nullptr;
|
||||
|
||||
void cleardeferredlightshaders()
|
||||
{
|
||||
deferredlightshader = NULL;
|
||||
deferredminimapshader = NULL;
|
||||
deferredmsaapixelshader = NULL;
|
||||
deferredmsaasampleshader = NULL;
|
||||
deferredlightshader = nullptr;
|
||||
deferredminimapshader = nullptr;
|
||||
deferredmsaapixelshader = nullptr;
|
||||
deferredmsaasampleshader = nullptr;
|
||||
}
|
||||
|
||||
extern int nospeclights;
|
||||
|
||||
Shader *loaddeferredlightshader(const char *type = NULL)
|
||||
Shader *loaddeferredlightshader(const char *type = nullptr)
|
||||
{
|
||||
string common, shadow, sun;
|
||||
int commonlen = 0, shadowlen = 0, sunlen = 0;
|
||||
|
@ -2665,8 +2665,8 @@ void resetlights()
|
|||
|
||||
namespace lightsphere
|
||||
{
|
||||
vec *verts = NULL;
|
||||
GLushort *indices = NULL;
|
||||
vec *verts = nullptr;
|
||||
GLushort *indices = nullptr;
|
||||
int numverts = 0, numindices = 0;
|
||||
GLuint vbuf = 0, ebuf = 0;
|
||||
|
||||
|
@ -3125,7 +3125,7 @@ static void renderlightbatches(Shader *s, int stencilref, bool transparent, floa
|
|||
}
|
||||
}
|
||||
|
||||
void renderlights(float bsx1 = -1, float bsy1 = -1, float bsx2 = 1, float bsy2 = 1, const uint *tilemask = NULL, int stencilmask = 0, int msaapass = 0, bool transparent = false)
|
||||
void renderlights(float bsx1 = -1, float bsy1 = -1, float bsx2 = 1, float bsy2 = 1, const uint *tilemask = nullptr, int stencilmask = 0, int msaapass = 0, bool transparent = false)
|
||||
{
|
||||
Shader *s = drawtex == DRAWTEX_MINIMAP ? deferredminimapshader : (msaapass <= 0 ? deferredlightshader : (msaapass > 1 ? deferredmsaasampleshader : deferredmsaapixelshader));
|
||||
if(!s || s == nullshader) return;
|
||||
|
@ -4379,7 +4379,7 @@ void rendershadowmaps(int offset = 0)
|
|||
if(sm.light < 0) continue;
|
||||
|
||||
lightinfo &l = lights[sm.light];
|
||||
extentity *e = l.ent >= 0 ? ents[l.ent] : NULL;
|
||||
extentity *e = l.ent >= 0 ? ents[l.ent] : nullptr;
|
||||
|
||||
int border, sidemask;
|
||||
if(l.spot)
|
||||
|
@ -4403,15 +4403,15 @@ void rendershadowmaps(int offset = 0)
|
|||
shadowdir = l.dir;
|
||||
shadowspot = l.spot;
|
||||
|
||||
shadowmesh *mesh = e ? findshadowmesh(l.ent, *e) : NULL;
|
||||
shadowmesh *mesh = e ? findshadowmesh(l.ent, *e) : nullptr;
|
||||
|
||||
findshadowvas();
|
||||
findshadowmms();
|
||||
|
||||
shadowmaskbatchedmodels(!(l.flags&L_NODYNSHADOW) && smdynshadow);
|
||||
batchshadowmapmodels(mesh != NULL);
|
||||
batchshadowmapmodels(mesh != nullptr);
|
||||
|
||||
shadowcacheval *cached = NULL;
|
||||
shadowcacheval *cached = nullptr;
|
||||
int cachemask = 0;
|
||||
if(smcache)
|
||||
{
|
||||
|
@ -4851,8 +4851,8 @@ void preparegbuffer(bool depthclear)
|
|||
|
||||
void rendergbuffer(bool depthclear)
|
||||
{
|
||||
timer *gcputimer = drawtex ? NULL : begintimer("g-buffer", false);
|
||||
timer *gtimer = drawtex ? NULL : begintimer("g-buffer");
|
||||
timer *gcputimer = drawtex ? nullptr : begintimer("g-buffer", false);
|
||||
timer *gtimer = drawtex ? nullptr : begintimer("g-buffer");
|
||||
|
||||
preparegbuffer(depthclear);
|
||||
|
||||
|
@ -4902,7 +4902,7 @@ void shademinimap(const vec &color)
|
|||
glClear(GL_COLOR_BUFFER_BIT);
|
||||
}
|
||||
|
||||
renderlights(-1, -1, 1, 1, NULL, 0, msaalight ? -1 : 0);
|
||||
renderlights(-1, -1, 1, 1, nullptr, 0, msaalight ? -1 : 0);
|
||||
GLERROR;
|
||||
}
|
||||
|
||||
|
@ -4964,8 +4964,8 @@ void shadegbuffer()
|
|||
|
||||
if(msaasamples && (msaalight || !drawtex))
|
||||
{
|
||||
if((ghasstencil && msaaedgedetect) || msaalight==2) loopi(2) renderlights(-1, -1, 1, 1, NULL, 0, i+1);
|
||||
else renderlights(-1, -1, 1, 1, NULL, 0, drawtex ? -1 : 3);
|
||||
if((ghasstencil && msaaedgedetect) || msaalight==2) loopi(2) renderlights(-1, -1, 1, 1, nullptr, 0, i+1);
|
||||
else renderlights(-1, -1, 1, 1, nullptr, 0, drawtex ? -1 : 3);
|
||||
}
|
||||
else renderlights();
|
||||
GLERROR;
|
||||
|
|
|
@ -19,7 +19,7 @@
|
|||
VAR(oqdynent, 0, 1, 1);
|
||||
VAR(animationinterpolationtime, 0, 200, 1000);
|
||||
|
||||
model *loadingmodel = NULL;
|
||||
model *loadingmodel = nullptr;
|
||||
|
||||
#include "ragdoll.hh"
|
||||
#include "animmodel.hh"
|
||||
|
@ -92,7 +92,7 @@ static void mdltricollide(char *collide)
|
|||
{
|
||||
checkmdl;
|
||||
DELETEA(loadingmodel->collidemodel);
|
||||
char *end = NULL;
|
||||
char *end = nullptr;
|
||||
int val = strtol(collide, &end, 0);
|
||||
if(*end) { val = 1; loadingmodel->collidemodel = newstring(collide); }
|
||||
loadingmodel->collide = val ? COLLIDE_TRI : COLLIDE_NONE;
|
||||
|
@ -140,7 +140,7 @@ COMMAND(mdlglow, "fff");
|
|||
static void mdlenvmap(float *envmapmax, float *envmapmin, char *envmap)
|
||||
{
|
||||
checkmdl;
|
||||
loadingmodel->setenvmap(*envmapmin, *envmapmax, envmap[0] ? cubemapload(envmap) : NULL);
|
||||
loadingmodel->setenvmap(*envmapmin, *envmapmax, envmap[0] ? cubemapload(envmap) : nullptr);
|
||||
}
|
||||
COMMAND(mdlenvmap, "ffs");
|
||||
|
||||
|
@ -333,7 +333,7 @@ static void mapmodel(char *name)
|
|||
mapmodelinfo &mmi = mapmodels.add();
|
||||
if(name[0]) formatstring(mmi.name, "%s%s", mmprefix, name);
|
||||
else mmi.name[0] = '\0';
|
||||
mmi.m = mmi.collide = NULL;
|
||||
mmi.m = mmi.collide = nullptr;
|
||||
}
|
||||
|
||||
static void mapmodelreset(int *n)
|
||||
|
@ -342,7 +342,7 @@ static void mapmodelreset(int *n)
|
|||
mapmodels.shrink(clamp(*n, 0, mapmodels.length()));
|
||||
}
|
||||
|
||||
const char *mapmodelname(int i) { return mapmodels.inrange(i) ? mapmodels[i].name : NULL; }
|
||||
const char *mapmodelname(int i) { return mapmodels.inrange(i) ? mapmodels[i].name : nullptr; }
|
||||
|
||||
ICOMMAND(mmodel, "s", (char *name), mapmodel(name));
|
||||
COMMAND(mapmodel, "s");
|
||||
|
@ -398,7 +398,7 @@ void preloadusedmapmodels(bool msg, bool bih)
|
|||
if(!mapmodels.inrange(mmindex)) { if(msg) conoutf(CON_WARN, "could not find map model: %d", mmindex); continue; }
|
||||
mapmodelinfo &mmi = mapmodels[mmindex];
|
||||
if(!mmi.name[0]) continue;
|
||||
model *m = loadmodel(NULL, mmindex, msg);
|
||||
model *m = loadmodel(nullptr, mmindex, msg);
|
||||
if(!m) { if(msg) conoutf(CON_WARN, "could not load map model: %s", mmi.name); }
|
||||
else
|
||||
{
|
||||
|
@ -425,7 +425,7 @@ model *loadmodel(const char *name, int i, bool msg)
|
|||
{
|
||||
if(!name)
|
||||
{
|
||||
if(!mapmodels.inrange(i)) return NULL;
|
||||
if(!mapmodels.inrange(i)) return nullptr;
|
||||
mapmodelinfo &mmi = mapmodels[i];
|
||||
if(mmi.m) return mmi.m;
|
||||
name = mmi.name;
|
||||
|
@ -435,7 +435,7 @@ model *loadmodel(const char *name, int i, bool msg)
|
|||
if(mm) m = *mm;
|
||||
else
|
||||
{
|
||||
if(!name[0] || loadingmodel || failedmodels.find(name, NULL)) return NULL;
|
||||
if(!name[0] || loadingmodel || failedmodels.find(name, nullptr)) return nullptr;
|
||||
if(msg)
|
||||
{
|
||||
defformatstring(filename, "media/model/%s", name);
|
||||
|
@ -449,11 +449,11 @@ model *loadmodel(const char *name, int i, bool msg)
|
|||
if(m->load()) break;
|
||||
DELETEP(m);
|
||||
}
|
||||
loadingmodel = NULL;
|
||||
loadingmodel = nullptr;
|
||||
if(!m)
|
||||
{
|
||||
failedmodels.add(newstring(name));
|
||||
return NULL;
|
||||
return nullptr;
|
||||
}
|
||||
models.access(m->name, m);
|
||||
}
|
||||
|
@ -473,13 +473,13 @@ void cleanupmodels()
|
|||
|
||||
static void clearmodel(char *name)
|
||||
{
|
||||
model *m = models.find(name, NULL);
|
||||
model *m = models.find(name, nullptr);
|
||||
if(!m) { conoutf("model %s is not loaded", name); return; }
|
||||
loopv(mapmodels)
|
||||
{
|
||||
mapmodelinfo &mmi = mapmodels[i];
|
||||
if(mmi.m == m) mmi.m = NULL;
|
||||
if(mmi.collide == m) mmi.collide = NULL;
|
||||
if(mmi.m == m) mmi.m = nullptr;
|
||||
if(mmi.collide == m) mmi.collide = nullptr;
|
||||
}
|
||||
models.remove(name);
|
||||
m->cleanup();
|
||||
|
@ -527,7 +527,7 @@ void resetmodelbatches()
|
|||
|
||||
static void addbatchedmodel(model *m, batchedmodel &bm, int idx)
|
||||
{
|
||||
modelbatch *b = NULL;
|
||||
modelbatch *b = nullptr;
|
||||
if(batches.inrange(m->batch))
|
||||
{
|
||||
b = &batches[m->batch];
|
||||
|
@ -549,7 +549,7 @@ foundbatch:
|
|||
|
||||
static inline void renderbatchedmodel(model *m, const batchedmodel &b)
|
||||
{
|
||||
modelattach *a = NULL;
|
||||
modelattach *a = nullptr;
|
||||
if(b.attached>=0) a = &modelattached[b.attached];
|
||||
|
||||
int anim = b.anim;
|
||||
|
@ -578,7 +578,7 @@ static inline void rendercullmodelquery(model *m, dynent *d, const vec ¢er,
|
|||
fabs(camera1->o.y-center.y) < radius+1 &&
|
||||
fabs(camera1->o.z-center.z) < radius+1)
|
||||
{
|
||||
d->query = NULL;
|
||||
d->query = nullptr;
|
||||
return;
|
||||
}
|
||||
d->query = newquery(d);
|
||||
|
@ -594,7 +594,7 @@ static inline void disablecullmodelquery()
|
|||
endbb();
|
||||
}
|
||||
|
||||
static inline int cullmodel(model *m, const vec ¢er, float radius, int flags, dynent *d = NULL)
|
||||
static inline int cullmodel(model *m, const vec ¢er, float radius, int flags, dynent *d = nullptr)
|
||||
{
|
||||
if(flags&MDL_CULL_DIST && center.dist(camera1->o)/radius>maxmodelradiusdistance) return MDL_CULL_DIST;
|
||||
if(flags&MDL_CULL_VFC && isfoggedsphere(radius, center)) return MDL_CULL_VFC;
|
||||
|
@ -850,7 +850,7 @@ void rendertransparentmodelbatches(int stencil)
|
|||
disableaamask();
|
||||
}
|
||||
|
||||
static occludequery *modelquery = NULL;
|
||||
static occludequery *modelquery = nullptr;
|
||||
static int modelquerybatches = -1, modelquerymodels = -1, modelqueryattached = -1;
|
||||
|
||||
void startmodelquery(occludequery *query)
|
||||
|
@ -866,7 +866,7 @@ void endmodelquery()
|
|||
if(batchedmodels.length() == modelquerymodels)
|
||||
{
|
||||
modelquery->fragments = 0;
|
||||
modelquery = NULL;
|
||||
modelquery = nullptr;
|
||||
return;
|
||||
}
|
||||
enableaamask();
|
||||
|
@ -889,7 +889,7 @@ void endmodelquery()
|
|||
b.m->endrender();
|
||||
}
|
||||
endquery(modelquery);
|
||||
modelquery = NULL;
|
||||
modelquery = nullptr;
|
||||
batches.setsize(modelquerybatches);
|
||||
batchedmodels.setsize(modelquerymodels);
|
||||
modelattached.setsize(modelqueryattached);
|
||||
|
@ -951,7 +951,7 @@ void rendermapmodel(int idx, int anim, const vec &o, float yaw, float pitch, flo
|
|||
b.colorscale = vec4(1, 1, 1, 1);
|
||||
b.flags = flags | MDL_MAPMODEL;
|
||||
b.visible = visible;
|
||||
b.d = NULL;
|
||||
b.d = nullptr;
|
||||
b.attached = -1;
|
||||
addbatchedmodel(m, b, batchedmodels.length()-1);
|
||||
}
|
||||
|
@ -1125,8 +1125,8 @@ static void loadskin(const char *dir, const char *altdir, Texture *&skin, Textur
|
|||
defformatstring(mdir, "media/model/%s", dir);
|
||||
defformatstring(maltdir, "media/model/%s", altdir);
|
||||
masks = notexture;
|
||||
tryload(skin, NULL, NULL, "skin");
|
||||
tryload(masks, NULL, NULL, "masks");
|
||||
tryload(skin, nullptr, nullptr, "skin");
|
||||
tryload(masks, nullptr, nullptr, "masks");
|
||||
}
|
||||
|
||||
void setbbfrommodel(dynent *d, const char *mdl)
|
||||
|
|
|
@ -35,15 +35,15 @@ struct model
|
|||
char *collidemodel;
|
||||
int collide, batch;
|
||||
|
||||
model(const char *name) : name(name ? newstring(name) : NULL), spinyaw(0), spinpitch(0), spinroll(0), offsetyaw(0), offsetpitch(0), offsetroll(0), shadow(true), alphashadow(true), depthoffset(false), scale(1.0f), translate(0, 0, 0), bih(0), bbcenter(0, 0, 0), bbradius(-1, -1, -1), bbextend(0, 0, 0), collidecenter(0, 0, 0), collideradius(-1, -1, -1), rejectradius(-1), eyeheight(0.9f), collidexyradius(0), collideheight(0), collidemodel(NULL), collide(COLLIDE_OBB), batch(-1) {}
|
||||
model(const char *name) : name(name ? newstring(name) : nullptr), spinyaw(0), spinpitch(0), spinroll(0), offsetyaw(0), offsetpitch(0), offsetroll(0), shadow(true), alphashadow(true), depthoffset(false), scale(1.0f), translate(0, 0, 0), bih(0), bbcenter(0, 0, 0), bbradius(-1, -1, -1), bbextend(0, 0, 0), collidecenter(0, 0, 0), collideradius(-1, -1, -1), rejectradius(-1), eyeheight(0.9f), collidexyradius(0), collideheight(0), collidemodel(nullptr), collide(COLLIDE_OBB), batch(-1) {}
|
||||
virtual ~model() { DELETEA(name); DELETEP(bih); }
|
||||
virtual void calcbb(vec ¢er, vec &radius) = 0;
|
||||
virtual void calctransform(matrix4x3 &m) = 0;
|
||||
virtual int intersect(int anim, int basetime, int basetime2, const vec &pos, float yaw, float pitch, float roll, dynent *d, modelattach *a, float size, const vec &o, const vec &ray, float &dist, int mode) = 0;
|
||||
virtual void render(int anim, int basetime, int basetime2, const vec &o, float yaw, float pitch, float roll, dynent *d, modelattach *a = NULL, float size = 1, const vec4 &color = vec4(1, 1, 1, 1)) = 0;
|
||||
virtual void render(int anim, int basetime, int basetime2, const vec &o, float yaw, float pitch, float roll, dynent *d, modelattach *a = nullptr, float size = 1, const vec4 &color = vec4(1, 1, 1, 1)) = 0;
|
||||
virtual bool load() = 0;
|
||||
virtual int type() const = 0;
|
||||
virtual BIH *setBIH() { return NULL; }
|
||||
virtual BIH *setBIH() { return nullptr; }
|
||||
virtual bool envmapped() const { return false; }
|
||||
virtual bool skeletal() const { return false; }
|
||||
virtual bool animated() const { return false; }
|
||||
|
@ -147,12 +147,12 @@ static inline model *loadmapmodel(int n)
|
|||
if(mapmodels.inrange(n))
|
||||
{
|
||||
model *m = mapmodels[n].m;
|
||||
return m ? m : loadmodel(NULL, n);
|
||||
return m ? m : loadmodel(nullptr, n);
|
||||
}
|
||||
return NULL;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
static inline mapmodelinfo *getmminfo(int n) { return mapmodels.inrange(n) ? &mapmodels[n] : NULL; }
|
||||
static inline mapmodelinfo *getmminfo(int n) { return mapmodels.inrange(n) ? &mapmodels[n] : nullptr; }
|
||||
|
||||
void flushpreloadedmodels(bool msg = true);
|
||||
|
||||
|
@ -165,13 +165,13 @@ struct modelattach
|
|||
vec *pos;
|
||||
model *m;
|
||||
|
||||
modelattach() : tag(NULL), name(NULL), anim(-1), basetime(0), pos(NULL), m(NULL) {}
|
||||
modelattach(const char *tag, const char *name, int anim = -1, int basetime = 0) : tag(tag), name(name), anim(anim), basetime(basetime), pos(NULL), m(NULL) {}
|
||||
modelattach(const char *tag, vec *pos) : tag(tag), name(NULL), anim(-1), basetime(0), pos(pos), m(NULL) {}
|
||||
modelattach() : tag(nullptr), name(nullptr), anim(-1), basetime(0), pos(nullptr), m(nullptr) {}
|
||||
modelattach(const char *tag, const char *name, int anim = -1, int basetime = 0) : tag(tag), name(name), anim(anim), basetime(basetime), pos(nullptr), m(nullptr) {}
|
||||
modelattach(const char *tag, vec *pos) : tag(tag), name(nullptr), anim(-1), basetime(0), pos(pos), m(nullptr) {}
|
||||
};
|
||||
|
||||
void rendermodel(const char *mdl, int anim, const vec &o, float yaw = 0, float pitch = 0, float roll = 0, int cull = MDL_CULL_VFC | MDL_CULL_DIST | MDL_CULL_OCCLUDED, dynent *d = NULL, modelattach *a = NULL, int basetime = 0, int basetime2 = 0, float size = 1, const vec4 &color = vec4(1, 1, 1, 1));
|
||||
int intersectmodel(const char *mdl, int anim, const vec &pos, float yaw, float pitch, float roll, const vec &o, const vec &ray, float &dist, int mode = 0, dynent *d = NULL, modelattach *a = NULL, int basetime = 0, int basetime2 = 0, float size = 1);
|
||||
void rendermodel(const char *mdl, int anim, const vec &o, float yaw = 0, float pitch = 0, float roll = 0, int cull = MDL_CULL_VFC | MDL_CULL_DIST | MDL_CULL_OCCLUDED, dynent *d = nullptr, modelattach *a = nullptr, int basetime = 0, int basetime2 = 0, float size = 1, const vec4 &color = vec4(1, 1, 1, 1));
|
||||
int intersectmodel(const char *mdl, int anim, const vec &pos, float yaw, float pitch, float roll, const vec &o, const vec &ray, float &dist, int mode = 0, dynent *d = nullptr, modelattach *a = nullptr, int basetime = 0, int basetime2 = 0, float size = 1);
|
||||
void abovemodel(vec &o, const char *mdl);
|
||||
void setbbfrommodel(dynent *d, const char *mdl);
|
||||
void preloadmodel(const char *name);
|
||||
|
|
|
@ -27,9 +27,9 @@ void particle_trail(int type, int fade, const vec &from, const vec &to, int colo
|
|||
void particle_text(const vec &s, const char *t, int type, int fade = 2000, int color = 0xFFFFFF, float size = 2.0f, int gravity = 0);
|
||||
void particle_icon(const vec &s, int ix, int iy, int type, int fade = 2000, int color = 0xFFFFFF, float size = 2.0f, int gravity = 0);
|
||||
void particle_meter(const vec &s, float val, int type, int fade = 1, int color = 0xFFFFFF, int color2 = 0xFFFFF, float size = 2.0f);
|
||||
void particle_flare(const vec &p, const vec &dest, int fade, int type, int color = 0xFFFFFF, float size = 0.28f, physent *owner = NULL);
|
||||
void particle_flare(const vec &p, const vec &dest, int fade, int type, int color = 0xFFFFFF, float size = 0.28f, physent *owner = nullptr);
|
||||
void particle_fireball(const vec &dest, float max, int type, int fade = -1, int color = 0xFFFFFF, float size = 4.0f);
|
||||
void removetrackedparticles(physent *owner = NULL);
|
||||
void removetrackedparticles(physent *owner = nullptr);
|
||||
#endif
|
||||
|
||||
enum
|
||||
|
@ -53,7 +53,7 @@ enum
|
|||
PART_LENS_FLARE
|
||||
};
|
||||
|
||||
Shader *particleshader = NULL, *particlenotextureshader = NULL, *particlesoftshader = NULL, *particletextshader = NULL;
|
||||
Shader *particleshader = nullptr, *particlenotextureshader = nullptr, *particlesoftshader = nullptr, *particletextshader = nullptr;
|
||||
|
||||
VARP(particlelayers, 0, 1, 1);
|
||||
FVARP(particlebright, 0, 2, 100);
|
||||
|
@ -120,7 +120,7 @@ struct particleemitter
|
|||
};
|
||||
|
||||
static vector<particleemitter> emitters;
|
||||
static particleemitter *seedemitter = NULL;
|
||||
static particleemitter *seedemitter = nullptr;
|
||||
|
||||
void clearparticleemitters()
|
||||
{
|
||||
|
@ -215,11 +215,11 @@ struct partrenderer
|
|||
string info;
|
||||
|
||||
partrenderer(const char *texname, int texclamp, int type, int stain = -1)
|
||||
: tex(NULL), texname(texname), texclamp(texclamp), type(type), stain(stain)
|
||||
: tex(nullptr), texname(texname), texclamp(texclamp), type(type), stain(stain)
|
||||
{
|
||||
}
|
||||
partrenderer(int type, int stain = -1)
|
||||
: tex(NULL), texname(NULL), texclamp(0), type(type), stain(stain)
|
||||
: tex(nullptr), texname(nullptr), texclamp(0), type(type), stain(stain)
|
||||
{
|
||||
}
|
||||
virtual ~partrenderer()
|
||||
|
@ -319,11 +319,11 @@ struct listrenderer : partrenderer
|
|||
listparticle *list;
|
||||
|
||||
listrenderer(const char *texname, int texclamp, int type, int stain = -1)
|
||||
: partrenderer(texname, texclamp, type, stain), list(NULL)
|
||||
: partrenderer(texname, texclamp, type, stain), list(nullptr)
|
||||
{
|
||||
}
|
||||
listrenderer(int type, int stain = -1)
|
||||
: partrenderer(type, stain), list(NULL)
|
||||
: partrenderer(type, stain), list(nullptr)
|
||||
{
|
||||
}
|
||||
|
||||
|
@ -347,7 +347,7 @@ struct listrenderer : partrenderer
|
|||
}
|
||||
p->next = parempty;
|
||||
parempty = list;
|
||||
list = NULL;
|
||||
list = nullptr;
|
||||
}
|
||||
|
||||
void resettracked(physent *owner)
|
||||
|
@ -385,7 +385,7 @@ struct listrenderer : partrenderer
|
|||
p->millis = lastmillis + emitoffset;
|
||||
p->color = bvec::hexcolor(color);
|
||||
p->size = size;
|
||||
p->owner = NULL;
|
||||
p->owner = nullptr;
|
||||
p->flags = 0;
|
||||
return p;
|
||||
}
|
||||
|
@ -400,7 +400,7 @@ struct listrenderer : partrenderer
|
|||
|
||||
bool haswork()
|
||||
{
|
||||
return (list != NULL);
|
||||
return (list != nullptr);
|
||||
}
|
||||
|
||||
virtual void startrender() = 0;
|
||||
|
@ -437,7 +437,7 @@ struct listrenderer : partrenderer
|
|||
}
|
||||
};
|
||||
|
||||
listparticle *listrenderer::parempty = NULL;
|
||||
listparticle *listrenderer::parempty = nullptr;
|
||||
|
||||
struct meterrenderer : listrenderer
|
||||
{
|
||||
|
@ -533,7 +533,7 @@ struct textrenderer : listrenderer
|
|||
|
||||
void endrender()
|
||||
{
|
||||
textshader = NULL;
|
||||
textshader = nullptr;
|
||||
|
||||
popfont();
|
||||
}
|
||||
|
@ -554,7 +554,7 @@ struct textrenderer : listrenderer
|
|||
|
||||
textmatrix = &m;
|
||||
draw_text(p->text, 0, 0, p->color.r, p->color.g, p->color.b, blend);
|
||||
textmatrix = NULL;
|
||||
textmatrix = nullptr;
|
||||
}
|
||||
};
|
||||
static textrenderer texts;
|
||||
|
@ -671,7 +671,7 @@ struct varenderer : partrenderer
|
|||
|
||||
varenderer(const char *texname, int type, int stain = -1)
|
||||
: partrenderer(texname, 3, type, stain),
|
||||
verts(NULL), parts(NULL), maxparts(0), numparts(0), lastupdate(-1), rndmask(0), vbo(0)
|
||||
verts(nullptr), parts(nullptr), maxparts(0), numparts(0), lastupdate(-1), rndmask(0), vbo(0)
|
||||
{
|
||||
if(type & PT_HFLIP) rndmask |= 0x01;
|
||||
if(type & PT_VFLIP) rndmask |= 0x02;
|
||||
|
@ -732,7 +732,7 @@ struct varenderer : partrenderer
|
|||
p->millis = lastmillis + emitoffset;
|
||||
p->color = bvec::hexcolor(color);
|
||||
p->size = size;
|
||||
p->owner = NULL;
|
||||
p->owner = nullptr;
|
||||
p->flags = 0x80 | (rndmask ? rnd(0x80) & rndmask : 0);
|
||||
lastupdate = -1;
|
||||
return p;
|
||||
|
@ -842,7 +842,7 @@ struct varenderer : partrenderer
|
|||
|
||||
if(!vbo) glGenBuffers_(1, &vbo);
|
||||
gle::bindvbo(vbo);
|
||||
glBufferData_(GL_ARRAY_BUFFER, maxparts*4*sizeof(partvert), NULL, GL_STREAM_DRAW);
|
||||
glBufferData_(GL_ARRAY_BUFFER, maxparts*4*sizeof(partvert), nullptr, GL_STREAM_DRAW);
|
||||
glBufferSubData_(GL_ARRAY_BUFFER, 0, numparts*4*sizeof(partvert), verts);
|
||||
gle::clearvbo();
|
||||
}
|
||||
|
@ -1429,7 +1429,7 @@ void seedparticles()
|
|||
seedemitter = &pe;
|
||||
for(int millis = 0; millis < seedmillis; millis += min(emitmillis, seedmillis/10))
|
||||
makeparticles(e);
|
||||
seedemitter = NULL;
|
||||
seedemitter = nullptr;
|
||||
pe.lastemit = -seedmillis;
|
||||
pe.finalize();
|
||||
}
|
||||
|
|
|
@ -41,7 +41,7 @@ static void loadsky(const char *basename, Texture *texs[6])
|
|||
}
|
||||
}
|
||||
|
||||
static Texture *cloudoverlay = NULL;
|
||||
static Texture *cloudoverlay = nullptr;
|
||||
|
||||
static Texture *loadskyoverlay(const char *basename)
|
||||
{
|
||||
|
@ -105,7 +105,7 @@ static void drawenvboxface(float s0, float t0, int x0, int y0, int z0,
|
|||
xtraverts += gle::end();
|
||||
}
|
||||
|
||||
static void drawenvbox(Texture **sky = NULL, float z1clip = 0.0f, float z2clip = 1.0f, int faces = 0x3F)
|
||||
static void drawenvbox(Texture **sky = nullptr, float z1clip = 0.0f, float z2clip = 1.0f, int faces = 0x3F)
|
||||
{
|
||||
if(z1clip >= z2clip) return;
|
||||
|
||||
|
@ -152,7 +152,7 @@ static void drawenvbox(Texture **sky = NULL, float z1clip = 0.0f, float z2clip =
|
|||
0.0f, 1.0f, w, -w, w, sky[5]);
|
||||
}
|
||||
|
||||
static void drawenvoverlay(Texture *overlay = NULL, float tx = 0, float ty = 0)
|
||||
static void drawenvoverlay(Texture *overlay = nullptr, float tx = 0, float ty = 0)
|
||||
{
|
||||
int w = farplane/2;
|
||||
float z = w*cloudheight, tsz = 0.5f*(1-cloudfade)/cloudscale, psz = w*(1-cloudfade);
|
||||
|
@ -212,8 +212,8 @@ namespace fogdome
|
|||
{
|
||||
if(v0.pos.z != v1.pos.z) color.a += uchar((v1.color.a - v0.color.a) * (pos.z - v0.pos.z) / (v1.pos.z - v0.pos.z));
|
||||
}
|
||||
} *verts = NULL;
|
||||
static GLushort *indices = NULL;
|
||||
} *verts = nullptr;
|
||||
static GLushort *indices = nullptr;
|
||||
static int numverts = 0, numindices = 0, capindices = 0;
|
||||
static GLuint vbuf = 0, ebuf = 0;
|
||||
static bvec lastcolor(0, 0, 0);
|
||||
|
|
|
@ -8,10 +8,10 @@
|
|||
#include "texture.hh"
|
||||
|
||||
static hashnameset<font> fonts;
|
||||
static font *fontdef = NULL;
|
||||
static font *fontdef = nullptr;
|
||||
static int fontdeftex = 0;
|
||||
|
||||
font *curfont = NULL;
|
||||
font *curfont = nullptr;
|
||||
|
||||
static void newfont(char *name, char *tex, int *defaultw, int *defaulth, int *scale)
|
||||
{
|
||||
|
@ -207,7 +207,7 @@ void draw_textf(const char *fstr, float left, float top, ...)
|
|||
draw_text(str, left, top);
|
||||
}
|
||||
|
||||
const matrix4x3 *textmatrix = NULL;
|
||||
const matrix4x3 *textmatrix = nullptr;
|
||||
float textscale = 1;
|
||||
|
||||
static float draw_char(Texture *&tex, int c, float x, float y, float scale)
|
||||
|
@ -392,7 +392,7 @@ void text_boundsf(const char *str, float &width, float &height, int maxwidth)
|
|||
#undef TEXTWORD
|
||||
}
|
||||
|
||||
Shader *textshader = NULL;
|
||||
Shader *textshader = nullptr;
|
||||
|
||||
void draw_text(const char *str, float left, float top, int r, int g, int b, int a, int cursor, int maxwidth)
|
||||
{
|
||||
|
|
|
@ -22,7 +22,7 @@ struct font
|
|||
int charoffset, defaultw, defaulth, scale;
|
||||
float bordermin, bordermax, outlinemin, outlinemax;
|
||||
|
||||
font() : name(NULL) {}
|
||||
font() : name(nullptr) {}
|
||||
~font() { DELETEA(name); }
|
||||
};
|
||||
|
||||
|
|
|
@ -41,7 +41,7 @@ static plane vfcP[5]; // perpindictular vectors to view frustrum bounding plane
|
|||
static float vfcDfog; // far plane culling distance (fog limit).
|
||||
static float vfcDnear[5], vfcDfar[5];
|
||||
|
||||
vtxarray *visibleva = NULL;
|
||||
vtxarray *visibleva = nullptr;
|
||||
|
||||
bool isfoggedsphere(float rad, const vec &cv)
|
||||
{
|
||||
|
@ -152,7 +152,7 @@ static inline void addvisibleva(vtxarray *va)
|
|||
|
||||
static void sortvisiblevas()
|
||||
{
|
||||
visibleva = NULL;
|
||||
visibleva = nullptr;
|
||||
vtxarray **last = &visibleva;
|
||||
loopi(VASORTSIZE) if(vasort[i])
|
||||
{
|
||||
|
@ -182,7 +182,7 @@ static inline void findvisiblevas(vector<vtxarray *> &vas)
|
|||
if(resetchildren)
|
||||
{
|
||||
v.occluded = !v.texs ? OCCLUDE_GEOM : OCCLUDE_NOTHING;
|
||||
v.query = NULL;
|
||||
v.query = nullptr;
|
||||
}
|
||||
addvisibleva(&v);
|
||||
if(v.children.length())
|
||||
|
@ -258,14 +258,14 @@ void visiblecubes(bool cull)
|
|||
vfcDfog = farplane;
|
||||
memset(vfcDnear, 0, sizeof(vfcDnear));
|
||||
memset(vfcDfar, 0, sizeof(vfcDfar));
|
||||
visibleva = NULL;
|
||||
visibleva = nullptr;
|
||||
loopv(valist)
|
||||
{
|
||||
vtxarray *va = valist[i];
|
||||
va->distance = 0;
|
||||
va->curvfc = VFC_FULL_VISIBLE;
|
||||
va->occluded = !va->texs ? OCCLUDE_GEOM : OCCLUDE_NOTHING;
|
||||
va->query = NULL;
|
||||
va->query = nullptr;
|
||||
va->next = visibleva;
|
||||
visibleva = va;
|
||||
}
|
||||
|
@ -288,10 +288,10 @@ struct queryframe
|
|||
|
||||
void flip()
|
||||
{
|
||||
loopi(cur) queries[i].owner = NULL;
|
||||
loopi(cur) queries[i].owner = nullptr;
|
||||
for(; defer > 0 && max < MAXQUERY; defer--)
|
||||
{
|
||||
queries[max].owner = NULL;
|
||||
queries[max].owner = nullptr;
|
||||
queries[max].fragments = -1;
|
||||
glGenQueries_(1, &queries[max++].id);
|
||||
}
|
||||
|
@ -302,11 +302,11 @@ struct queryframe
|
|||
{
|
||||
if(cur >= max)
|
||||
{
|
||||
if(max >= MAXQUERY) return NULL;
|
||||
if(max >= MAXQUERY) return nullptr;
|
||||
if(deferquery)
|
||||
{
|
||||
if(max + defer < MAXQUERY) defer++;
|
||||
return NULL;
|
||||
return nullptr;
|
||||
}
|
||||
glGenQueries_(1, &queries[max++].id);
|
||||
}
|
||||
|
@ -316,14 +316,14 @@ struct queryframe
|
|||
return query;
|
||||
}
|
||||
|
||||
void reset() { loopi(max) queries[i].owner = NULL; }
|
||||
void reset() { loopi(max) queries[i].owner = nullptr; }
|
||||
|
||||
void cleanup()
|
||||
{
|
||||
loopi(max)
|
||||
{
|
||||
glDeleteQueries_(1, &queries[i].id);
|
||||
queries[i].owner = NULL;
|
||||
queries[i].owner = nullptr;
|
||||
}
|
||||
cur = max = defer = 0;
|
||||
}
|
||||
|
@ -478,7 +478,7 @@ static octaentities *visiblemms, **lastvisiblemms;
|
|||
|
||||
static void findvisiblemms(const vector<extentity *> &ents, bool doquery)
|
||||
{
|
||||
visiblemms = NULL;
|
||||
visiblemms = nullptr;
|
||||
lastvisiblemms = &visiblemms;
|
||||
for(vtxarray *va = visibleva; va; va = va->next) if(va->occluded < OCCLUDE_BB && va->curvfc < VFC_FOGGED) loopv(va->mapmodels)
|
||||
{
|
||||
|
@ -490,7 +490,7 @@ static void findvisiblemms(const vector<extentity *> &ents, bool doquery)
|
|||
{
|
||||
oe->distance = -1;
|
||||
|
||||
oe->next = NULL;
|
||||
oe->next = nullptr;
|
||||
*lastvisiblemms = oe;
|
||||
lastvisiblemms = &oe->next;
|
||||
}
|
||||
|
@ -515,7 +515,7 @@ static void findvisiblemms(const vector<extentity *> &ents, bool doquery)
|
|||
cur = cur->next;
|
||||
}
|
||||
|
||||
if(*prev == NULL) lastvisiblemms = &oe->next;
|
||||
if(*prev == nullptr) lastvisiblemms = &oe->next;
|
||||
oe->next = *prev;
|
||||
*prev = oe;
|
||||
}
|
||||
|
@ -548,7 +548,7 @@ void rendermapmodels()
|
|||
if(!rendered)
|
||||
{
|
||||
rendered = true;
|
||||
oe->query = doquery && oe->distance>0 && !(++skipoq%oqmm) ? newquery(oe) : NULL;
|
||||
oe->query = doquery && oe->distance>0 && !(++skipoq%oqmm) ? newquery(oe) : nullptr;
|
||||
if(oe->query) startmodelquery(oe->query);
|
||||
}
|
||||
rendermapmodel(e);
|
||||
|
@ -562,7 +562,7 @@ void rendermapmodels()
|
|||
bool queried = false;
|
||||
for(octaentities *oe = visiblemms; oe; oe = oe->next) if(oe->distance<0)
|
||||
{
|
||||
oe->query = doquery && !camera1->o.insidebb(oe->bbmin, oe->bbmax, 1) ? newquery(oe) : NULL;
|
||||
oe->query = doquery && !camera1->o.insidebb(oe->bbmin, oe->bbmax, 1) ? newquery(oe) : nullptr;
|
||||
if(!oe->query) continue;
|
||||
if(!queried)
|
||||
{
|
||||
|
@ -645,7 +645,7 @@ void renderoutline()
|
|||
|
||||
if(!dtoutline) glDisable(GL_DEPTH_TEST);
|
||||
|
||||
vtxarray *prev = NULL;
|
||||
vtxarray *prev = nullptr;
|
||||
for(vtxarray *va = visibleva; va; va = va->next) if(va->occluded < OCCLUDE_BB)
|
||||
{
|
||||
if((!va->texs || va->occluded >= OCCLUDE_GEOM) && !va->alphaback && !va->alphafront && !va->refracttris) continue;
|
||||
|
@ -702,7 +702,7 @@ void renderblendbrush(GLuint tex, float x, float y, float w, float h)
|
|||
LOCALPARAMF(texgenS, 1.0f/w, 0, 0, -x/w);
|
||||
LOCALPARAMF(texgenT, 0, 1.0f/h, 0, -y/h);
|
||||
|
||||
vtxarray *prev = NULL;
|
||||
vtxarray *prev = nullptr;
|
||||
for(vtxarray *va = visibleva; va; va = va->next) if(va->texs && va->occluded < OCCLUDE_GEOM)
|
||||
{
|
||||
if(va->o.x + va->size <= x || va->o.y + va->size <= y || va->o.x >= x + w || va->o.y >= y + h) continue;
|
||||
|
@ -905,7 +905,7 @@ vec shadoworigin(0, 0, 0), shadowdir(0, 0, 0);
|
|||
float shadowradius = 0, shadowbias = 0;
|
||||
int shadowside = 0, shadowspot = 0;
|
||||
|
||||
static vtxarray *shadowva = NULL;
|
||||
static vtxarray *shadowva = nullptr;
|
||||
|
||||
static inline void addshadowva(vtxarray *va, float dist)
|
||||
{
|
||||
|
@ -926,7 +926,7 @@ static inline void addshadowva(vtxarray *va, float dist)
|
|||
|
||||
static void sortshadowvas()
|
||||
{
|
||||
shadowva = NULL;
|
||||
shadowva = nullptr;
|
||||
vtxarray **last = &shadowva;
|
||||
loopi(VASORTSIZE) if(vasort[i])
|
||||
{
|
||||
|
@ -1026,7 +1026,7 @@ void rendershadowmapworld()
|
|||
|
||||
gle::enablevertex();
|
||||
|
||||
vtxarray *prev = NULL;
|
||||
vtxarray *prev = nullptr;
|
||||
for(vtxarray *va = shadowva; va; va = va->rnext) if(va->tris && va->shadowmask&(1<<shadowside))
|
||||
{
|
||||
if(!prev || va->vbuf != prev->vbuf)
|
||||
|
@ -1045,7 +1045,7 @@ void rendershadowmapworld()
|
|||
|
||||
if(skyshadow)
|
||||
{
|
||||
prev = NULL;
|
||||
prev = nullptr;
|
||||
for(vtxarray *va = shadowva; va; va = va->rnext) if(va->sky && va->shadowmask&(1<<shadowside))
|
||||
{
|
||||
if(!prev || va->vbuf != prev->vbuf)
|
||||
|
@ -1068,11 +1068,11 @@ void rendershadowmapworld()
|
|||
gle::disablevertex();
|
||||
}
|
||||
|
||||
static octaentities *shadowmms = NULL;
|
||||
static octaentities *shadowmms = nullptr;
|
||||
|
||||
void findshadowmms()
|
||||
{
|
||||
shadowmms = NULL;
|
||||
shadowmms = nullptr;
|
||||
octaentities **lastmms = &shadowmms;
|
||||
for(vtxarray *va = shadowva; va; va = va->rnext) loopvj(va->mapmodels)
|
||||
{
|
||||
|
@ -1096,7 +1096,7 @@ void findshadowmms()
|
|||
continue;
|
||||
break;
|
||||
}
|
||||
oe->rnext = NULL;
|
||||
oe->rnext = nullptr;
|
||||
*lastmms = oe;
|
||||
lastmms = &oe->rnext;
|
||||
}
|
||||
|
@ -1144,7 +1144,7 @@ struct renderstate
|
|||
vec2 texgenscroll;
|
||||
int texgenorient, texgenmillis;
|
||||
|
||||
renderstate() : colormask(true), depthmask(true), alphaing(0), vbuf(0), vattribs(false), vquery(false), colorscale(1, 1, 1), alphascale(0), refractscale(0), refractcolor(1, 1, 1), blend(false), blendx(-1), blendy(-1), globals(-1), tmu(-1), slot(NULL), texgenslot(NULL), vslot(NULL), texgenvslot(NULL), texgenscroll(0, 0), texgenorient(-1), texgenmillis(lastmillis)
|
||||
renderstate() : colormask(true), depthmask(true), alphaing(0), vbuf(0), vattribs(false), vquery(false), colorscale(1, 1, 1), alphascale(0), refractscale(0), refractcolor(1, 1, 1), blend(false), blendx(-1), blendy(-1), globals(-1), tmu(-1), slot(nullptr), texgenslot(nullptr), vslot(nullptr), texgenvslot(nullptr), texgenscroll(0, 0), texgenorient(-1), texgenmillis(lastmillis)
|
||||
{
|
||||
loopk(7) textures[k] = 0;
|
||||
}
|
||||
|
@ -1238,7 +1238,7 @@ struct geombatch
|
|||
static vector<geombatch> geombatches;
|
||||
static int firstbatch = -1, numbatches = 0;
|
||||
|
||||
static void mergetexs(renderstate &cur, vtxarray *va, elementset *texs = NULL, int numtexs = 0, int offset = 0)
|
||||
static void mergetexs(renderstate &cur, vtxarray *va, elementset *texs = nullptr, int numtexs = 0, int offset = 0)
|
||||
{
|
||||
if(!texs)
|
||||
{
|
||||
|
@ -1373,7 +1373,7 @@ static void changebatchtmus(renderstate &cur, int pass, geombatch &b)
|
|||
if(!cur.blend)
|
||||
{
|
||||
cur.blend = true;
|
||||
cur.vslot = NULL;
|
||||
cur.vslot = nullptr;
|
||||
}
|
||||
if((cur.blendx != (b.va->o.x&~0xFFF) || cur.blendy != (b.va->o.y&~0xFFF)))
|
||||
{
|
||||
|
@ -1387,7 +1387,7 @@ static void changebatchtmus(renderstate &cur, int pass, geombatch &b)
|
|||
else if(cur.blend)
|
||||
{
|
||||
cur.blend = false;
|
||||
cur.vslot = NULL;
|
||||
cur.vslot = nullptr;
|
||||
}
|
||||
|
||||
if(cur.tmu != 0)
|
||||
|
@ -1589,8 +1589,8 @@ static void resetbatches()
|
|||
|
||||
static void renderbatches(renderstate &cur, int pass)
|
||||
{
|
||||
cur.slot = NULL;
|
||||
cur.vslot = NULL;
|
||||
cur.slot = nullptr;
|
||||
cur.vslot = nullptr;
|
||||
int curbatch = firstbatch;
|
||||
if(curbatch >= 0)
|
||||
{
|
||||
|
@ -1753,7 +1753,7 @@ void rendergeom()
|
|||
{
|
||||
if(va->parent && va->parent->occluded >= OCCLUDE_BB)
|
||||
{
|
||||
va->query = NULL;
|
||||
va->query = nullptr;
|
||||
va->occluded = OCCLUDE_PARENT;
|
||||
continue;
|
||||
}
|
||||
|
@ -1774,7 +1774,7 @@ void rendergeom()
|
|||
}
|
||||
else
|
||||
{
|
||||
va->query = NULL;
|
||||
va->query = nullptr;
|
||||
va->occluded = pvsoccluded(va->geommin, va->geommax) ? OCCLUDE_GEOM : OCCLUDE_NOTHING;
|
||||
if(va->occluded >= OCCLUDE_GEOM) continue;
|
||||
}
|
||||
|
@ -1828,7 +1828,7 @@ void rendergeom()
|
|||
resetbatches();
|
||||
for(vtxarray *va = visibleva; va; va = va->next) if(va->texs)
|
||||
{
|
||||
va->query = NULL;
|
||||
va->query = nullptr;
|
||||
va->occluded = pvsoccluded(va->geommin, va->geommax) ? OCCLUDE_GEOM : OCCLUDE_NOTHING;
|
||||
if(va->occluded >= OCCLUDE_GEOM) continue;
|
||||
blends += va->blends;
|
||||
|
@ -1898,7 +1898,7 @@ void renderrsmgeom(bool dyntex)
|
|||
{
|
||||
enablevattribs(cur, false);
|
||||
SETSHADER(rsmsky);
|
||||
vtxarray *prev = NULL;
|
||||
vtxarray *prev = nullptr;
|
||||
for(vtxarray *va = shadowva; va; va = va->rnext) if(va->sky)
|
||||
{
|
||||
if(!prev || va->vbuf != prev->vbuf)
|
||||
|
@ -2008,7 +2008,7 @@ void renderrefractmask()
|
|||
{
|
||||
gle::enablevertex();
|
||||
|
||||
vtxarray *prev = NULL;
|
||||
vtxarray *prev = nullptr;
|
||||
loopv(alphavas)
|
||||
{
|
||||
vtxarray *va = alphavas[i];
|
||||
|
@ -2063,7 +2063,7 @@ CVARP(explicitskycolour, 0x800080);
|
|||
|
||||
bool renderexplicitsky(bool outline)
|
||||
{
|
||||
vtxarray *prev = NULL;
|
||||
vtxarray *prev = nullptr;
|
||||
for(vtxarray *va = visibleva; va; va = va->next) if(va->sky && va->occluded < OCCLUDE_BB &&
|
||||
((va->skymax.x >= 0 && isvisiblebb(va->skymin, ivec(va->skymax).sub(va->skymin)) != VFC_NOT_VISIBLE) ||
|
||||
!insideworld(camera1->o)))
|
||||
|
@ -2130,7 +2130,7 @@ struct decalrenderer
|
|||
GLuint textures[7];
|
||||
DecalSlot *slot;
|
||||
|
||||
decalrenderer() : vbuf(0), colorscale(1, 1, 1), globals(-1), tmu(-1), slot(NULL)
|
||||
decalrenderer() : vbuf(0), colorscale(1, 1, 1), globals(-1), tmu(-1), slot(nullptr)
|
||||
{
|
||||
loopi(7) textures[i] = 0;
|
||||
}
|
||||
|
@ -2355,7 +2355,7 @@ static void renderdecalbatch(decalrenderer &cur, int pass, decalbatch &b)
|
|||
|
||||
static void renderdecalbatches(decalrenderer &cur, int pass)
|
||||
{
|
||||
cur.slot = NULL;
|
||||
cur.slot = nullptr;
|
||||
int curbatch = firstbatch;
|
||||
while(curbatch >= 0)
|
||||
{
|
||||
|
@ -2718,12 +2718,12 @@ void genshadowmeshes()
|
|||
shadowmesh *findshadowmesh(int idx, extentity &e)
|
||||
{
|
||||
shadowmesh *m = shadowmeshes.access(idx);
|
||||
if(!m || m->type != shadowmapping || m->origin != shadoworigin || m->radius < shadowradius) return NULL;
|
||||
if(!m || m->type != shadowmapping || m->origin != shadoworigin || m->radius < shadowradius) return nullptr;
|
||||
switch(m->type)
|
||||
{
|
||||
case SM_SPOT:
|
||||
if(!e.attached || e.attached->type != ET_SPOTLIGHT || m->spotloc != e.attached->o || m->spotangle < clamp(int(e.attached->attr1), 1, 89))
|
||||
return NULL;
|
||||
return nullptr;
|
||||
break;
|
||||
}
|
||||
return m;
|
||||
|
|
|
@ -13,14 +13,14 @@
|
|||
#include "rendermodel.hh" // cleanupmodels
|
||||
#include "texture.hh"
|
||||
|
||||
Shader *Shader::lastshader = NULL;
|
||||
Shader *Shader::lastshader = nullptr;
|
||||
|
||||
Shader *nullshader = NULL, *hudshader = NULL, *hudtextshader = NULL, *hudnotextureshader = NULL, *nocolorshader = NULL, *foggedshader = NULL, *foggednotextureshader = NULL, *ldrshader = NULL, *ldrnotextureshader = NULL, *stdworldshader = NULL;
|
||||
Shader *nullshader = nullptr, *hudshader = nullptr, *hudtextshader = nullptr, *hudnotextureshader = nullptr, *nocolorshader = nullptr, *foggedshader = nullptr, *foggednotextureshader = nullptr, *ldrshader = nullptr, *ldrnotextureshader = nullptr, *stdworldshader = nullptr;
|
||||
|
||||
static hashnameset<GlobalShaderParamState> globalparams(256);
|
||||
static hashtable<const char *, int> localparams(256);
|
||||
static hashnameset<Shader> shaders(256);
|
||||
static Shader *slotshader = NULL;
|
||||
static Shader *slotshader = nullptr;
|
||||
static vector<SlotShaderParam> slotparams;
|
||||
static bool standardshaders = false, forceshaders = true, loadedshaders = false;
|
||||
|
||||
|
@ -63,13 +63,13 @@ void loadshaders()
|
|||
Shader *lookupshaderbyname(const char *name)
|
||||
{
|
||||
Shader *s = shaders.access(name);
|
||||
return s && s->loaded() ? s : NULL;
|
||||
return s && s->loaded() ? s : nullptr;
|
||||
}
|
||||
|
||||
Shader *generateshader(const char *name, const char *fmt, ...)
|
||||
{
|
||||
if(!loadedshaders) return NULL;
|
||||
Shader *s = name ? lookupshaderbyname(name) : NULL;
|
||||
if(!loadedshaders) return nullptr;
|
||||
Shader *s = name ? lookupshaderbyname(name) : nullptr;
|
||||
if(!s)
|
||||
{
|
||||
defvformatstring(cmd, fmt, fmt);
|
||||
|
@ -77,13 +77,13 @@ Shader *generateshader(const char *name, const char *fmt, ...)
|
|||
standardshaders = true;
|
||||
execute(cmd);
|
||||
standardshaders = wasstandard;
|
||||
s = name ? lookupshaderbyname(name) : NULL;
|
||||
s = name ? lookupshaderbyname(name) : nullptr;
|
||||
if(!s) s = nullshader;
|
||||
}
|
||||
return s;
|
||||
}
|
||||
|
||||
static void showglslinfo(GLenum type, GLuint obj, const char *name, const char **parts = NULL, int numparts = 0)
|
||||
static void showglslinfo(GLenum type, GLuint obj, const char *name, const char **parts = nullptr, int numparts = 0)
|
||||
{
|
||||
GLint length = 0;
|
||||
if(type) glGetShaderiv_(obj, GL_INFO_LOG_LENGTH, &length);
|
||||
|
@ -134,7 +134,7 @@ static const char *finddecls(const char *line)
|
|||
do
|
||||
{
|
||||
start = strchr(start + 1, '\n');
|
||||
if(!start) return NULL;
|
||||
if(!start) return nullptr;
|
||||
} while(start[-1] == '\\');
|
||||
line = start + 1;
|
||||
continue;
|
||||
|
@ -143,12 +143,12 @@ static const char *finddecls(const char *line)
|
|||
{
|
||||
case '/':
|
||||
start = strchr(start + 2, '\n');
|
||||
if(!start) return NULL;
|
||||
if(!start) return nullptr;
|
||||
line = start + 1;
|
||||
continue;
|
||||
case '*':
|
||||
start = strstr(start + 2, "*/");
|
||||
if(!start) return NULL;
|
||||
if(!start) return nullptr;
|
||||
line = start + 2;
|
||||
continue;
|
||||
}
|
||||
|
@ -164,7 +164,7 @@ extern int amd_eal_bug;
|
|||
static void compileglslshader(Shader &s, GLenum type, GLuint &obj, const char *def, const char *name, bool msg = true)
|
||||
{
|
||||
const char *source = def + strspn(def, " \t\r\n");
|
||||
char *modsource = NULL;
|
||||
char *modsource = nullptr;
|
||||
const char *parts[16];
|
||||
int numparts = 0;
|
||||
static const struct { int version; const char * const header; } glslversions[] =
|
||||
|
@ -297,7 +297,7 @@ static void compileglslshader(Shader &s, GLenum type, GLuint &obj, const char *d
|
|||
parts[numparts++] = modsource ? modsource : source;
|
||||
|
||||
obj = glCreateShader_(type);
|
||||
glShaderSource_(obj, numparts, (const GLchar **)parts, NULL);
|
||||
glShaderSource_(obj, numparts, (const GLchar **)parts, nullptr);
|
||||
glCompileShader_(obj);
|
||||
GLint success;
|
||||
glGetShaderiv_(obj, GL_COMPILE_STATUS, &success);
|
||||
|
@ -618,7 +618,7 @@ void GlobalShaderParamState::resetversions()
|
|||
});
|
||||
}
|
||||
|
||||
static float *findslotparam(Slot &s, const char *name, float *noval = NULL)
|
||||
static float *findslotparam(Slot &s, const char *name, float *noval = nullptr)
|
||||
{
|
||||
loopv(s.params)
|
||||
{
|
||||
|
@ -633,7 +633,7 @@ static float *findslotparam(Slot &s, const char *name, float *noval = NULL)
|
|||
return noval;
|
||||
}
|
||||
|
||||
static float *findslotparam(VSlot &s, const char *name, float *noval = NULL)
|
||||
static float *findslotparam(VSlot &s, const char *name, float *noval = nullptr)
|
||||
{
|
||||
loopv(s.params)
|
||||
{
|
||||
|
@ -753,10 +753,10 @@ void Shader::cleanup(bool full)
|
|||
attriblocs.setsize(0);
|
||||
fragdatalocs.setsize(0);
|
||||
uniformlocs.setsize(0);
|
||||
reusevs = reuseps = NULL;
|
||||
reusevs = reuseps = nullptr;
|
||||
}
|
||||
else loopv(defaultparams) defaultparams[i].loc = -1;
|
||||
owner = NULL;
|
||||
owner = nullptr;
|
||||
}
|
||||
|
||||
static void genattriblocs(Shader &s, const char *vs, const char *ps, Shader *reusevs, Shader *reuseps)
|
||||
|
@ -788,12 +788,12 @@ static void genuniformlocs(Shader &s, const char *vs, const char *ps, Shader *re
|
|||
}
|
||||
}
|
||||
|
||||
Shader *newshader(int type, const char *name, const char *vs, const char *ps, Shader *variant = NULL, int row = 0)
|
||||
Shader *newshader(int type, const char *name, const char *vs, const char *ps, Shader *variant = nullptr, int row = 0)
|
||||
{
|
||||
if(Shader::lastshader)
|
||||
{
|
||||
glUseProgram_(0);
|
||||
Shader::lastshader = NULL;
|
||||
Shader::lastshader = nullptr;
|
||||
}
|
||||
|
||||
Shader *exists = shaders.access(name);
|
||||
|
@ -807,7 +807,7 @@ Shader *newshader(int type, const char *name, const char *vs, const char *ps, Sh
|
|||
s.variantshader = variant;
|
||||
s.standard = standardshaders;
|
||||
if(forceshaders) s.forced = true;
|
||||
s.reusevs = s.reuseps = NULL;
|
||||
s.reusevs = s.reuseps = nullptr;
|
||||
if(variant)
|
||||
{
|
||||
int row = 0, col = 0;
|
||||
|
@ -836,7 +836,7 @@ Shader *newshader(int type, const char *name, const char *vs, const char *ps, Sh
|
|||
{
|
||||
s.cleanup(true);
|
||||
if(variant) shaders.remove(rname);
|
||||
return NULL;
|
||||
return nullptr;
|
||||
}
|
||||
if(variant) variant->addvariant(row, &s);
|
||||
return &s;
|
||||
|
@ -845,7 +845,7 @@ Shader *newshader(int type, const char *name, const char *vs, const char *ps, Sh
|
|||
static const char *findglslmain(const char *s)
|
||||
{
|
||||
const char *main = strstr(s, "main");
|
||||
if(!main) return NULL;
|
||||
if(!main) return nullptr;
|
||||
for(; main >= s; main--) switch(*main) { case '\r': case '\n': case ';': return main + 1; }
|
||||
return s;
|
||||
}
|
||||
|
@ -960,7 +960,7 @@ static void genfogshader(vector<char> &vsbuf, vector<char> &psbuf, const char *v
|
|||
}
|
||||
}
|
||||
|
||||
static void genuniformdefs(vector<char> &vsbuf, vector<char> &psbuf, const char *vs, const char *ps, Shader *variant = NULL)
|
||||
static void genuniformdefs(vector<char> &vsbuf, vector<char> &psbuf, const char *vs, const char *ps, Shader *variant = nullptr)
|
||||
{
|
||||
if(variant ? variant->defaultparams.empty() : slotparams.empty()) return;
|
||||
const char *vsmain = findglslmain(vs), *psmain = findglslmain(ps);
|
||||
|
@ -1098,7 +1098,7 @@ void Shader::force()
|
|||
if(!deferred() || !defer) return;
|
||||
|
||||
char *cmd = defer;
|
||||
defer = NULL;
|
||||
defer = nullptr;
|
||||
bool wasstandard = standardshaders, wasforcing = forceshaders;
|
||||
int oldflags = identflags;
|
||||
standardshaders = standard;
|
||||
|
@ -1130,7 +1130,7 @@ int Shader::uniformlocversion()
|
|||
Shader *useshaderbyname(const char *name)
|
||||
{
|
||||
Shader *s = shaders.access(name);
|
||||
if(!s) return NULL;
|
||||
if(!s) return nullptr;
|
||||
if(s->deferred()) s->force();
|
||||
s->forced = true;
|
||||
return s;
|
||||
|
@ -1207,7 +1207,7 @@ COMMAND(setshader, "s");
|
|||
|
||||
void resetslotshader()
|
||||
{
|
||||
slotshader = NULL;
|
||||
slotshader = nullptr;
|
||||
slotparams.shrink(0);
|
||||
}
|
||||
|
||||
|
@ -1309,7 +1309,7 @@ static hashset<const char *> shaderparamnames(256);
|
|||
|
||||
const char *getshaderparamname(const char *name, bool insert)
|
||||
{
|
||||
const char *exists = shaderparamnames.find(name, NULL);
|
||||
const char *exists = shaderparamnames.find(name, nullptr);
|
||||
if(exists || !insert) return exists;
|
||||
return shaderparamnames.add(newstring(name));
|
||||
}
|
||||
|
@ -1360,7 +1360,7 @@ struct postfxpass
|
|||
uint inputs, freeinputs;
|
||||
int outputbind, outputscale;
|
||||
|
||||
postfxpass() : shader(NULL), inputs(1), freeinputs(1), outputbind(0), outputscale(0) {}
|
||||
postfxpass() : shader(nullptr), inputs(1), freeinputs(1), outputbind(0), outputscale(0) {}
|
||||
};
|
||||
vector<postfxpass> postfxpasses;
|
||||
|
||||
|
@ -1374,7 +1374,7 @@ static int allocatepostfxtex(int scale)
|
|||
postfxtex &t = postfxtexs.add();
|
||||
t.scale = scale;
|
||||
glGenTextures(1, &t.id);
|
||||
createtexture(t.id, max(postfxw>>scale, 1), max(postfxh>>scale, 1), NULL, 3, 1, GL_RGB, GL_TEXTURE_RECTANGLE);
|
||||
createtexture(t.id, max(postfxw>>scale, 1), max(postfxh>>scale, 1), nullptr, 3, 1, GL_RGB, GL_TEXTURE_RECTANGLE);
|
||||
return postfxtexs.length()-1;
|
||||
}
|
||||
|
||||
|
@ -1531,9 +1531,9 @@ void cleanupshaders()
|
|||
cleanuppostfx(true);
|
||||
|
||||
loadedshaders = false;
|
||||
nullshader = hudshader = hudnotextureshader = NULL;
|
||||
nullshader = hudshader = hudnotextureshader = nullptr;
|
||||
enumerate(shaders, Shader, s, s.cleanup());
|
||||
Shader::lastshader = NULL;
|
||||
Shader::lastshader = nullptr;
|
||||
glUseProgram_(0);
|
||||
}
|
||||
|
||||
|
@ -1606,8 +1606,8 @@ void setupblurkernel(int radius, float *weights, float *offsets)
|
|||
void setblurshader(int pass, int size, int radius, float *weights, float *offsets, GLenum target)
|
||||
{
|
||||
if(radius<1 || radius>MAXBLURRADIUS) return;
|
||||
static Shader *blurshader[7][2] = { { NULL, NULL }, { NULL, NULL }, { NULL, NULL }, { NULL, NULL }, { NULL, NULL }, { NULL, NULL }, { NULL, NULL } },
|
||||
*blurrectshader[7][2] = { { NULL, NULL }, { NULL, NULL }, { NULL, NULL }, { NULL, NULL }, { NULL, NULL }, { NULL, NULL }, { NULL, NULL } };
|
||||
static Shader *blurshader[7][2] = { { nullptr, nullptr }, { nullptr, nullptr }, { nullptr, nullptr }, { nullptr, nullptr }, { nullptr, nullptr }, { nullptr, nullptr }, { nullptr, nullptr } },
|
||||
*blurrectshader[7][2] = { { nullptr, nullptr }, { nullptr, nullptr }, { nullptr, nullptr }, { nullptr, nullptr }, { nullptr, nullptr }, { nullptr, nullptr }, { nullptr, nullptr } };
|
||||
Shader *&s = (target == GL_TEXTURE_RECTANGLE ? blurrectshader : blurshader)[radius-1][pass];
|
||||
if(!s)
|
||||
{
|
||||
|
|
|
@ -127,14 +127,14 @@ struct UniformLoc
|
|||
const char *name, *blockname;
|
||||
int loc, version, binding, stride, offset, size;
|
||||
void *data;
|
||||
UniformLoc(const char *name = NULL, const char *blockname = NULL, int binding = -1, int stride = -1) : name(name), blockname(blockname), loc(-1), version(-1), binding(binding), stride(stride), offset(-1), size(-1), data(NULL) {}
|
||||
UniformLoc(const char *name = nullptr, const char *blockname = nullptr, int binding = -1, int stride = -1) : name(name), blockname(blockname), loc(-1), version(-1), binding(binding), stride(stride), offset(-1), size(-1), data(nullptr) {}
|
||||
};
|
||||
|
||||
struct AttribLoc
|
||||
{
|
||||
const char *name;
|
||||
int loc;
|
||||
AttribLoc(const char *name = NULL, int loc = -1) : name(name), loc(loc) {}
|
||||
AttribLoc(const char *name = nullptr, int loc = -1) : name(name), loc(loc) {}
|
||||
};
|
||||
|
||||
struct FragDataLoc
|
||||
|
@ -143,7 +143,7 @@ struct FragDataLoc
|
|||
int loc;
|
||||
GLenum format;
|
||||
int index;
|
||||
FragDataLoc(const char *name = NULL, int loc = -1, GLenum format = GL_FALSE, int index = 0) : name(name), loc(loc), format(format), index(index) {}
|
||||
FragDataLoc(const char *name = nullptr, int loc = -1, GLenum format = GL_FALSE, int index = 0) : name(name), loc(loc), format(format), index(index) {}
|
||||
};
|
||||
|
||||
struct Shader
|
||||
|
@ -167,7 +167,7 @@ struct Shader
|
|||
vector<FragDataLoc> fragdatalocs;
|
||||
const void *owner;
|
||||
|
||||
Shader() : name(NULL), vsstr(NULL), psstr(NULL), defer(NULL), type(SHADER_DEFAULT), program(0), vsobj(0), psobj(0), variantshader(NULL), variantrows(NULL), standard(false), forced(false), used(false), reusevs(NULL), reuseps(NULL), owner(NULL)
|
||||
Shader() : name(nullptr), vsstr(nullptr), psstr(nullptr), defer(nullptr), type(SHADER_DEFAULT), program(0), vsobj(0), psobj(0), variantshader(nullptr), variantrows(nullptr), standard(false), forced(false), used(false), reusevs(nullptr), reuseps(nullptr), owner(nullptr)
|
||||
{
|
||||
}
|
||||
|
||||
|
@ -180,12 +180,12 @@ struct Shader
|
|||
DELETEA(variantrows);
|
||||
}
|
||||
|
||||
void allocparams(Slot *slot = NULL);
|
||||
void allocparams(Slot *slot = nullptr);
|
||||
void setslotparams(Slot &slot);
|
||||
void setslotparams(Slot &slot, VSlot &vslot);
|
||||
void bindprograms();
|
||||
|
||||
void flushparams(Slot *slot = NULL)
|
||||
void flushparams(Slot *slot = nullptr)
|
||||
{
|
||||
if(!used) { allocparams(slot); used = true; }
|
||||
loopv(globalparams) globalparams[i].flush();
|
||||
|
@ -213,9 +213,9 @@ struct Shader
|
|||
|
||||
Shader *getvariant(int col, int row) const
|
||||
{
|
||||
if(row < 0 || row >= MAXVARIANTROWS || col < 0 || !variantrows) return NULL;
|
||||
if(row < 0 || row >= MAXVARIANTROWS || col < 0 || !variantrows) return nullptr;
|
||||
int start = variantrows[row], end = variantrows[row+1];
|
||||
return col < end - start ? variants[start + col] : NULL;
|
||||
return col < end - start ? variants[start + col] : nullptr;
|
||||
}
|
||||
|
||||
void addvariant(int row, Shader *s)
|
||||
|
@ -299,7 +299,7 @@ struct GlobalShaderParam
|
|||
const char *name;
|
||||
GlobalShaderParamState *param;
|
||||
|
||||
GlobalShaderParam(const char *name) : name(name), param(NULL) {}
|
||||
GlobalShaderParam(const char *name) : name(name), param(nullptr) {}
|
||||
|
||||
GlobalShaderParamState *resolve()
|
||||
{
|
||||
|
@ -363,15 +363,15 @@ struct LocalShaderParam
|
|||
LocalShaderParamState *resolve()
|
||||
{
|
||||
Shader *s = Shader::lastshader;
|
||||
if(!s) return NULL;
|
||||
if(!s) return nullptr;
|
||||
if(!s->localparamremap.inrange(loc))
|
||||
{
|
||||
extern int getlocalparam(const char *name);
|
||||
if(loc == -1) loc = getlocalparam(name);
|
||||
if(!s->localparamremap.inrange(loc)) return NULL;
|
||||
if(!s->localparamremap.inrange(loc)) return nullptr;
|
||||
}
|
||||
uchar remap = s->localparamremap[loc];
|
||||
return s->localparams.inrange(remap) ? &s->localparams[remap] : NULL;
|
||||
return s->localparams.inrange(remap) ? &s->localparams[remap] : nullptr;
|
||||
}
|
||||
|
||||
void setf(float x = 0, float y = 0, float z = 0, float w = 0)
|
||||
|
@ -461,13 +461,13 @@ struct LocalShaderParam
|
|||
|
||||
#define SETSHADER(name, ...) \
|
||||
do { \
|
||||
static Shader *name##shader = NULL; \
|
||||
static Shader *name##shader = nullptr; \
|
||||
if(!name##shader) name##shader = lookupshaderbyname(#name); \
|
||||
name##shader->set(__VA_ARGS__); \
|
||||
} while(0)
|
||||
#define SETVARIANT(name, ...) \
|
||||
do { \
|
||||
static Shader *name##shader = NULL; \
|
||||
static Shader *name##shader = nullptr; \
|
||||
if(!name##shader) name##shader = lookupshaderbyname(#name); \
|
||||
name##shader->setvariant(__VA_ARGS__); \
|
||||
} while(0)
|
||||
|
|
|
@ -120,7 +120,7 @@ struct skelmodel : animmodel
|
|||
uchar *partmask;
|
||||
ragdolldata *ragdoll;
|
||||
|
||||
animcacheentry() : ragdoll(NULL)
|
||||
animcacheentry() : ragdoll(nullptr)
|
||||
{
|
||||
loopk(MAXANIMPARTS) as[k].cur.fr1 = as[k].prev.fr1 = -1;
|
||||
}
|
||||
|
@ -150,7 +150,7 @@ struct skelmodel : animmodel
|
|||
dualquat *bdata;
|
||||
int version;
|
||||
|
||||
skelcacheentry() : bdata(NULL), version(-1) {}
|
||||
skelcacheentry() : bdata(nullptr), version(-1) {}
|
||||
|
||||
void nextversion()
|
||||
{
|
||||
|
@ -176,7 +176,7 @@ struct skelmodel : animmodel
|
|||
int voffset, eoffset, elen;
|
||||
ushort minvert, maxvert;
|
||||
|
||||
skelmesh() : verts(NULL), tris(NULL), numverts(0), numtris(0), maxweights(0)
|
||||
skelmesh() : verts(nullptr), tris(nullptr), numverts(0), numtris(0), maxweights(0)
|
||||
{
|
||||
}
|
||||
|
||||
|
@ -371,7 +371,7 @@ struct skelmodel : animmodel
|
|||
int bone;
|
||||
matrix4x3 matrix;
|
||||
|
||||
tag() : name(NULL) {}
|
||||
tag() : name(nullptr) {}
|
||||
~tag() { DELETEA(name); }
|
||||
};
|
||||
|
||||
|
@ -380,7 +380,7 @@ struct skelmodel : animmodel
|
|||
char *name;
|
||||
int frame, range;
|
||||
|
||||
skelanimspec() : name(NULL), frame(0), range(0) {}
|
||||
skelanimspec() : name(nullptr), frame(0), range(0) {}
|
||||
~skelanimspec()
|
||||
{
|
||||
DELETEA(name);
|
||||
|
@ -394,7 +394,7 @@ struct skelmodel : animmodel
|
|||
float pitchscale, pitchoffset, pitchmin, pitchmax;
|
||||
dualquat base, invbase;
|
||||
|
||||
boneinfo() : name(NULL), parent(-1), children(-1), next(-1), group(INT_MAX), scheduled(-1), interpindex(-1), interpparent(-1), ragdollindex(-1), correctindex(-1), pitchscale(0), pitchoffset(0), pitchmin(0), pitchmax(0) {}
|
||||
boneinfo() : name(nullptr), parent(-1), children(-1), next(-1), group(INT_MAX), scheduled(-1), interpindex(-1), interpparent(-1), ragdollindex(-1), correctindex(-1), pitchscale(0), pitchoffset(0), pitchmin(0), pitchmax(0) {}
|
||||
~boneinfo()
|
||||
{
|
||||
DELETEA(name);
|
||||
|
@ -449,7 +449,7 @@ struct skelmodel : animmodel
|
|||
vector<skelcacheentry> skelcache;
|
||||
hashtable<GLuint, int> blendoffsets;
|
||||
|
||||
skeleton() : name(NULL), shared(0), bones(NULL), numbones(0), numinterpbones(0), numgpubones(0), numframes(0), framebones(NULL), ragdoll(NULL), usegpuskel(false), blendoffsets(32)
|
||||
skeleton() : name(nullptr), shared(0), bones(nullptr), numbones(0), numinterpbones(0), numgpubones(0), numframes(0), framebones(nullptr), ragdoll(nullptr), usegpuskel(false), blendoffsets(32)
|
||||
{
|
||||
}
|
||||
|
||||
|
@ -480,13 +480,13 @@ struct skelmodel : animmodel
|
|||
if(!strcmp(name, skelanims[i].name)) return &skelanims[i];
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
skelanimspec &addskelanim(const char *name)
|
||||
{
|
||||
skelanimspec &sa = skelanims.add();
|
||||
sa.name = name ? newstring(name) : NULL;
|
||||
sa.name = name ? newstring(name) : nullptr;
|
||||
return sa;
|
||||
}
|
||||
|
||||
|
@ -950,7 +950,7 @@ struct skelmodel : animmodel
|
|||
n.mul(m, t);
|
||||
}
|
||||
|
||||
void calctags(part *p, skelcacheentry *sc = NULL)
|
||||
void calctags(part *p, skelcacheentry *sc = nullptr)
|
||||
{
|
||||
loopv(p->links)
|
||||
{
|
||||
|
@ -999,7 +999,7 @@ struct skelmodel : animmodel
|
|||
|
||||
int numanimparts = ((skelpart *)as->owner)->numanimparts;
|
||||
uchar *partmask = ((skelpart *)as->owner)->partmask;
|
||||
skelcacheentry *sc = NULL;
|
||||
skelcacheentry *sc = nullptr;
|
||||
bool match = false;
|
||||
loopv(skelcache)
|
||||
{
|
||||
|
@ -1086,7 +1086,7 @@ struct skelmodel : animmodel
|
|||
|
||||
skelhitdata *hitdata;
|
||||
|
||||
skelmeshgroup() : skel(NULL), edata(NULL), ebuf(0), vlen(0), vertsize(0), vblends(0), vweights(0), vdata(NULL), hitdata(NULL)
|
||||
skelmeshgroup() : skel(nullptr), edata(nullptr), ebuf(0), vlen(0), vertsize(0), vblends(0), vweights(0), vdata(nullptr), hitdata(nullptr)
|
||||
{
|
||||
memset(numblends, 0, sizeof(numblends));
|
||||
}
|
||||
|
@ -1139,7 +1139,7 @@ struct skelmodel : animmodel
|
|||
void *animkey() { return skel; }
|
||||
int totalframes() const { return max(skel->numframes, 1); }
|
||||
|
||||
virtual skelanimspec *loadanim(const char *filename) { return NULL; }
|
||||
virtual skelanimspec *loadanim(const char *filename) { return nullptr; }
|
||||
|
||||
void genvbo(vbocacheentry &vc)
|
||||
{
|
||||
|
@ -1247,7 +1247,7 @@ struct skelmodel : animmodel
|
|||
bindbones(vverts);
|
||||
}
|
||||
|
||||
void bindvbo(const animstate *as, part *p, vbocacheentry &vc, skelcacheentry *sc = NULL, blendcacheentry *bc = NULL)
|
||||
void bindvbo(const animstate *as, part *p, vbocacheentry &vc, skelcacheentry *sc = nullptr, blendcacheentry *bc = nullptr)
|
||||
{
|
||||
if(!skel->numframes) bindvbo<vvertg>(as, p, vc);
|
||||
else if(skel->usegpuskel) bindvbo<vvertgw>(as, p, vc);
|
||||
|
@ -1390,7 +1390,7 @@ struct skelmodel : animmodel
|
|||
|
||||
if(skel->shouldcleanup()) skel->cleanup();
|
||||
|
||||
skelcacheentry &sc = skel->checkskelcache(p, as, pitch, axis, forward, !d || !d->ragdoll || d->ragdoll->skel != skel->ragdoll || d->ragdoll->millis == lastmillis ? NULL : d->ragdoll);
|
||||
skelcacheentry &sc = skel->checkskelcache(p, as, pitch, axis, forward, !d || !d->ragdoll || d->ragdoll->skel != skel->ragdoll || d->ragdoll->millis == lastmillis ? nullptr : d->ragdoll);
|
||||
|
||||
intersect(hitdata, p, sc, o, ray);
|
||||
|
||||
|
@ -1425,14 +1425,14 @@ struct skelmodel : animmodel
|
|||
return;
|
||||
}
|
||||
|
||||
skelcacheentry &sc = skel->checkskelcache(p, as, pitch, axis, forward, !d || !d->ragdoll || d->ragdoll->skel != skel->ragdoll || d->ragdoll->millis == lastmillis ? NULL : d->ragdoll);
|
||||
skelcacheentry &sc = skel->checkskelcache(p, as, pitch, axis, forward, !d || !d->ragdoll || d->ragdoll->skel != skel->ragdoll || d->ragdoll->millis == lastmillis ? nullptr : d->ragdoll);
|
||||
if(!(as->cur.anim&ANIM_NORENDER))
|
||||
{
|
||||
int owner = &sc-&skel->skelcache[0];
|
||||
vbocacheentry &vc = skel->usegpuskel ? *vbocache : checkvbocache(sc, owner);
|
||||
vc.millis = lastmillis;
|
||||
if(!vc.vbuf) genvbo(vc);
|
||||
blendcacheentry *bc = NULL;
|
||||
blendcacheentry *bc = nullptr;
|
||||
if(vblends)
|
||||
{
|
||||
bc = &checkblendcache(sc, owner);
|
||||
|
@ -1450,7 +1450,7 @@ struct skelmodel : animmodel
|
|||
(animcacheentry &)vc = sc;
|
||||
looprendermeshes(skelmesh, m,
|
||||
{
|
||||
m.interpverts(sc.bdata, bc ? bc->bdata : NULL, (vvert *)vdata, p->skins[i]);
|
||||
m.interpverts(sc.bdata, bc ? bc->bdata : nullptr, (vvert *)vdata, p->skins[i]);
|
||||
});
|
||||
gle::bindvbo(vc.vbuf);
|
||||
glBufferData_(GL_ARRAY_BUFFER, vlen*vertsize, vdata, GL_STREAM_DRAW);
|
||||
|
@ -1481,20 +1481,20 @@ struct skelmodel : animmodel
|
|||
|
||||
virtual skelmeshgroup *newmeshes() = 0;
|
||||
|
||||
meshgroup *loadmeshes(const char *name, const char *skelname = NULL, float smooth = 2)
|
||||
meshgroup *loadmeshes(const char *name, const char *skelname = nullptr, float smooth = 2)
|
||||
{
|
||||
skelmeshgroup *group = newmeshes();
|
||||
group->shareskeleton(skelname);
|
||||
if(!group->load(name, smooth)) { delete group; return NULL; }
|
||||
if(!group->load(name, smooth)) { delete group; return nullptr; }
|
||||
return group;
|
||||
}
|
||||
|
||||
meshgroup *sharemeshes(const char *name, const char *skelname = NULL, float smooth = 2)
|
||||
meshgroup *sharemeshes(const char *name, const char *skelname = nullptr, float smooth = 2)
|
||||
{
|
||||
if(!meshgroups.access(name))
|
||||
{
|
||||
meshgroup *group = loadmeshes(name, skelname, smooth);
|
||||
if(!group) return NULL;
|
||||
if(!group) return nullptr;
|
||||
meshgroups.add(group);
|
||||
}
|
||||
return meshgroups[name];
|
||||
|
@ -1513,7 +1513,7 @@ struct skelmodel : animmodel
|
|||
|
||||
uchar *partmask;
|
||||
|
||||
skelpart(animmodel *model, int index = 0) : part(model, index), buildingpartmask(NULL), partmask(NULL)
|
||||
skelpart(animmodel *model, int index = 0) : part(model, index), buildingpartmask(nullptr), partmask(nullptr)
|
||||
{
|
||||
}
|
||||
|
||||
|
@ -1524,7 +1524,7 @@ struct skelmodel : animmodel
|
|||
|
||||
uchar *sharepartmask(animpartmask *o)
|
||||
{
|
||||
static animpartmask *partmasks = NULL;
|
||||
static animpartmask *partmasks = nullptr;
|
||||
animpartmask *p = partmasks;
|
||||
for(; p; p = p->next) if(p->numbones==o->numbones && !memcmp(p->bones, o->bones, p->numbones))
|
||||
{
|
||||
|
@ -1564,7 +1564,7 @@ struct skelmodel : animmodel
|
|||
if(buildingpartmask)
|
||||
{
|
||||
partmask = sharepartmask(buildingpartmask);
|
||||
buildingpartmask = NULL;
|
||||
buildingpartmask = nullptr;
|
||||
}
|
||||
|
||||
((skelmeshgroup *)meshes)->skel->optimize();
|
||||
|
@ -1660,7 +1660,7 @@ template<class MDL> struct skelcommands : modelcommands<MDL, struct MDL::skelmes
|
|||
if(!MDL::loading) { conoutf("not loading an %s", MDL::formatname()); return; }
|
||||
defformatstring(filename, "%s/%s", MDL::dir, meshfile);
|
||||
part &mdl = MDL::loading->addpart();
|
||||
mdl.meshes = MDL::loading->sharemeshes(path(filename), skelname[0] ? skelname : NULL, *smooth > 0 ? cosf(clamp(*smooth, 0.0f, 180.0f)*RAD) : 2);
|
||||
mdl.meshes = MDL::loading->sharemeshes(path(filename), skelname[0] ? skelname : nullptr, *smooth > 0 ? cosf(clamp(*smooth, 0.0f, 180.0f)*RAD) : 2);
|
||||
if(!mdl.meshes) conoutf("could not load %s", filename);
|
||||
else
|
||||
{
|
||||
|
|
|
@ -145,7 +145,7 @@ struct smd : skelloader<smd>
|
|||
|
||||
void readtriangles(stream *f, char *buf, size_t bufsize)
|
||||
{
|
||||
smdmeshdata *curmesh = NULL;
|
||||
smdmeshdata *curmesh = nullptr;
|
||||
hashtable<const char *, smdmeshdata> materials(1<<6);
|
||||
hashset<int> verts(1<<12);
|
||||
while(f->getline(buf, bufsize))
|
||||
|
@ -354,7 +354,7 @@ struct smd : skelloader<smd>
|
|||
if(sa || skel->numbones <= 0) return sa;
|
||||
|
||||
stream *f = openfile(filename, "r");
|
||||
if(!f) return NULL;
|
||||
if(!f) return nullptr;
|
||||
|
||||
char buf[512];
|
||||
int version = -1;
|
||||
|
@ -366,12 +366,12 @@ struct smd : skelloader<smd>
|
|||
if(skipcomment(curbuf)) continue;
|
||||
if(sscanf(curbuf, " version %d", &version) == 1)
|
||||
{
|
||||
if(version != 1) { delete f; return NULL; }
|
||||
if(version != 1) { delete f; return nullptr; }
|
||||
}
|
||||
else if(!strncmp(curbuf, "nodes", 5))
|
||||
{
|
||||
readnodes(f, buf, sizeof(buf), bones);
|
||||
if(bones.length() != skel->numbones) { delete f; return NULL; }
|
||||
if(bones.length() != skel->numbones) { delete f; return nullptr; }
|
||||
}
|
||||
else if(!strncmp(curbuf, "triangles", 9))
|
||||
skipsection(f, buf, sizeof(buf));
|
||||
|
|
|
@ -49,7 +49,7 @@ struct stainbuffer
|
|||
GLuint vbo;
|
||||
bool dirty;
|
||||
|
||||
stainbuffer() : verts(NULL), maxverts(0), startvert(0), endvert(0), lastvert(0), availverts(0), vbo(0), dirty(false)
|
||||
stainbuffer() : verts(nullptr), maxverts(0), startvert(0), endvert(0), lastvert(0), availverts(0), vbo(0), dirty(false)
|
||||
{}
|
||||
|
||||
~stainbuffer()
|
||||
|
@ -134,7 +134,7 @@ struct stainbuffer
|
|||
int count = endvert < startvert ? maxverts - startvert : endvert - startvert;
|
||||
if(dirty)
|
||||
{
|
||||
glBufferData_(GL_ARRAY_BUFFER, maxverts*sizeof(stainvert), NULL, GL_STREAM_DRAW);
|
||||
glBufferData_(GL_ARRAY_BUFFER, maxverts*sizeof(stainvert), nullptr, GL_STREAM_DRAW);
|
||||
glBufferSubData_(GL_ARRAY_BUFFER, 0, count*sizeof(stainvert), &verts[startvert]);
|
||||
if(endvert < startvert)
|
||||
{
|
||||
|
@ -198,8 +198,8 @@ struct stainrenderer
|
|||
stainrenderer(const char *texname, int flags = 0, int fadeintime = 0, int fadeouttime = 1000, int timetolive = -1)
|
||||
: texname(texname), flags(flags),
|
||||
fadeintime(fadeintime), fadeouttime(fadeouttime), timetolive(timetolive),
|
||||
tex(NULL),
|
||||
stains(NULL), maxstains(0), startstain(0), endstain(0),
|
||||
tex(nullptr),
|
||||
stains(nullptr), maxstains(0), startstain(0), endstain(0),
|
||||
stainu(0), stainv(0)
|
||||
{
|
||||
}
|
||||
|
@ -269,7 +269,7 @@ struct stainrenderer
|
|||
int threshold = lastmillis - (timetolive>=0 ? timetolive : stainfade) - fadeouttime;
|
||||
staininfo *d = &stains[startstain],
|
||||
*end = &stains[endstain < startstain ? maxstains : endstain],
|
||||
*cleared[NUMSTAINBUFS] = { NULL };
|
||||
*cleared[NUMSTAINBUFS] = { nullptr };
|
||||
for(; d < end && d->millis <= threshold; d++)
|
||||
cleared[d->owner] = d;
|
||||
if(d >= end && endstain < startstain)
|
||||
|
@ -482,7 +482,7 @@ struct stainrenderer
|
|||
}
|
||||
}
|
||||
|
||||
void gentris(cube &cu, int orient, const ivec &o, int size, materialsurface *mat = NULL, int vismask = 0)
|
||||
void gentris(cube &cu, int orient, const ivec &o, int size, materialsurface *mat = nullptr, int vismask = 0)
|
||||
{
|
||||
vec pos[MAXFACEVERTS+4];
|
||||
int numverts = 0, numplanes = 1;
|
||||
|
@ -738,7 +738,7 @@ struct stainrenderer
|
|||
int vismask = cu.visible;
|
||||
if(vismask&0xC0)
|
||||
{
|
||||
if(vismask&0x80) loopj(6) gentris(cu, j, co, size, NULL, vismask);
|
||||
if(vismask&0x80) loopj(6) gentris(cu, j, co, size, nullptr, vismask);
|
||||
else loopj(6) if(vismask&(1<<j)) gentris(cu, j, co, size);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -805,7 +805,7 @@ static void uploadtexture(GLenum target, GLenum internal, int tw, int th, GLenum
|
|||
{
|
||||
int bpp = formatsize(format), row = 0, rowalign = 0;
|
||||
if(!pitch) pitch = pw*bpp;
|
||||
uchar *buf = NULL;
|
||||
uchar *buf = nullptr;
|
||||
if(pw!=tw || ph!=th)
|
||||
{
|
||||
buf = new uchar[tw*th*bpp];
|
||||
|
@ -922,7 +922,7 @@ static const GLint *swizzlemask(GLenum format)
|
|||
case GL_RED: return luminance;
|
||||
case GL_RG: return luminancealpha;
|
||||
}
|
||||
return NULL;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
static void setuptexparameters(int tnum, const void *pixels, int clamp, int filter, GLenum format, GLenum target, bool swizzle)
|
||||
|
@ -1115,7 +1115,7 @@ void create3dtexture(int tnum, int w, int h, int d, const void *pixels, int clam
|
|||
|
||||
static hashnameset<Texture> textures;
|
||||
|
||||
Texture *notexture = NULL; // used as default, ensured to be loaded
|
||||
Texture *notexture = nullptr; // used as default, ensured to be loaded
|
||||
|
||||
static GLenum texformat(int bpp, bool swizzle = false)
|
||||
{
|
||||
|
@ -1261,13 +1261,13 @@ static SDL_Surface *wrapsurface(void *data, int width, int height, int bpp)
|
|||
case 3: return SDL_CreateRGBSurfaceFrom(data, width, height, 8*bpp, bpp*width, RGBMASKS);
|
||||
case 4: return SDL_CreateRGBSurfaceFrom(data, width, height, 8*bpp, bpp*width, RGBAMASKS);
|
||||
}
|
||||
return NULL;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
static SDL_Surface *creatergbsurface(SDL_Surface *os)
|
||||
{
|
||||
SDL_Surface *ns = SDL_CreateRGBSurface(SDL_SWSURFACE, os->w, os->h, 24, RGBMASKS);
|
||||
if(ns) SDL_BlitSurface(os, NULL, ns, NULL);
|
||||
if(ns) SDL_BlitSurface(os, nullptr, ns, nullptr);
|
||||
SDL_FreeSurface(os);
|
||||
return ns;
|
||||
}
|
||||
|
@ -1278,7 +1278,7 @@ static SDL_Surface *creatergbasurface(SDL_Surface *os)
|
|||
if(ns)
|
||||
{
|
||||
SDL_SetSurfaceBlendMode(os, SDL_BLENDMODE_NONE);
|
||||
SDL_BlitSurface(os, NULL, ns, NULL);
|
||||
SDL_BlitSurface(os, nullptr, ns, nullptr);
|
||||
}
|
||||
SDL_FreeSurface(os);
|
||||
return ns;
|
||||
|
@ -1289,7 +1289,7 @@ static bool checkgrayscale(SDL_Surface *s)
|
|||
// gray scale images have 256 levels, no colorkey, and the palette is a ramp
|
||||
if(s->format->palette)
|
||||
{
|
||||
if(s->format->palette->ncolors != 256 || SDL_GetColorKey(s, NULL) >= 0) return false;
|
||||
if(s->format->palette->ncolors != 256 || SDL_GetColorKey(s, nullptr) >= 0) return false;
|
||||
const SDL_Color *colors = s->format->palette->colors;
|
||||
loopi(256) if(colors[i].r != i || colors[i].g != i || colors[i].b != i) return false;
|
||||
}
|
||||
|
@ -1298,17 +1298,17 @@ static bool checkgrayscale(SDL_Surface *s)
|
|||
|
||||
static SDL_Surface *fixsurfaceformat(SDL_Surface *s)
|
||||
{
|
||||
if(!s) return NULL;
|
||||
if(!s) return nullptr;
|
||||
if(!s->pixels || min(s->w, s->h) <= 0 || s->format->BytesPerPixel <= 0)
|
||||
{
|
||||
SDL_FreeSurface(s);
|
||||
return NULL;
|
||||
return nullptr;
|
||||
}
|
||||
static const uint rgbmasks[] = { RGBMASKS }, rgbamasks[] = { RGBAMASKS };
|
||||
switch(s->format->BytesPerPixel)
|
||||
{
|
||||
case 1:
|
||||
if(!checkgrayscale(s)) return SDL_GetColorKey(s, NULL) >= 0 ? creatergbasurface(s) : creatergbsurface(s);
|
||||
if(!checkgrayscale(s)) return SDL_GetColorKey(s, nullptr) >= 0 ? creatergbasurface(s) : creatergbsurface(s);
|
||||
break;
|
||||
case 3:
|
||||
if(s->format->Rmask != rgbmasks[0] || s->format->Gmask != rgbmasks[1] || s->format->Bmask != rgbmasks[2])
|
||||
|
@ -1473,7 +1473,7 @@ static bool canloadsurface(const char *name)
|
|||
|
||||
static SDL_Surface *loadsurface(const char *name)
|
||||
{
|
||||
SDL_Surface *s = NULL;
|
||||
SDL_Surface *s = nullptr;
|
||||
stream *z = openzipfile(name, "rb");
|
||||
if(z)
|
||||
{
|
||||
|
@ -1508,9 +1508,9 @@ VAR(usedds, 0, 1, 1);
|
|||
VAR(dbgdds, 0, 0, 1);
|
||||
VAR(scaledds, 0, 2, 4);
|
||||
|
||||
static bool texturedata(ImageData &d, const char *tname, bool msg = true, int *compress = NULL, int *wrap = NULL, const char *tdir = NULL, int ttype = TEX_DIFFUSE)
|
||||
static bool texturedata(ImageData &d, const char *tname, bool msg = true, int *compress = nullptr, int *wrap = nullptr, const char *tdir = nullptr, int ttype = TEX_DIFFUSE)
|
||||
{
|
||||
const char *cmds = NULL, *file = tname;
|
||||
const char *cmds = nullptr, *file = tname;
|
||||
if(tname[0]=='<')
|
||||
{
|
||||
cmds = tname;
|
||||
|
@ -1529,7 +1529,7 @@ static bool texturedata(ImageData &d, const char *tname, bool msg = true, int *c
|
|||
for(const char *pcmds = cmds; pcmds;)
|
||||
{
|
||||
#define PARSETEXCOMMANDS(cmds) \
|
||||
const char *cmd = NULL, *end = NULL, *arg[4] = { NULL, NULL, NULL, NULL }; \
|
||||
const char *cmd = nullptr, *end = nullptr, *arg[4] = { nullptr, nullptr, nullptr, nullptr }; \
|
||||
cmd = &cmds[1]; \
|
||||
end = strchr(cmd, '>'); \
|
||||
if(!end) break; \
|
||||
|
@ -1606,7 +1606,7 @@ static bool texturedata(ImageData &d, const char *tname, bool msg = true, int *c
|
|||
string srcname, maskname;
|
||||
COPYTEXARG(srcname, arg[0]);
|
||||
COPYTEXARG(maskname, arg[1]);
|
||||
if(srcname[0] && texturedata(src, srcname, false, NULL, NULL, tdir, ttype) && (!maskname[0] || texturedata(mask, maskname, false, NULL, NULL, tdir, ttype)))
|
||||
if(srcname[0] && texturedata(src, srcname, false, nullptr, nullptr, tdir, ttype) && (!maskname[0] || texturedata(mask, maskname, false, nullptr, nullptr, tdir, ttype)))
|
||||
texblend(d, src, maskname[0] ? mask : src);
|
||||
}
|
||||
else if(matchstring(cmd, len, "thumbnail"))
|
||||
|
@ -1641,7 +1641,7 @@ static bool texturedata(ImageData &d, const char *tname, bool msg = true, int *c
|
|||
return true;
|
||||
}
|
||||
|
||||
static inline bool texturedata(ImageData &d, Slot &slot, Slot::Tex &tex, bool msg = true, int *compress = NULL, int *wrap = NULL)
|
||||
static inline bool texturedata(ImageData &d, Slot &slot, Slot::Tex &tex, bool msg = true, int *compress = nullptr, int *wrap = nullptr)
|
||||
{
|
||||
return texturedata(d, tex.name, msg, compress, wrap, slot.texturedir(), tex.type);
|
||||
}
|
||||
|
@ -1649,9 +1649,9 @@ static inline bool texturedata(ImageData &d, Slot &slot, Slot::Tex &tex, bool ms
|
|||
uchar *loadalphamask(Texture *t)
|
||||
{
|
||||
if(t->alphamask) return t->alphamask;
|
||||
if(!(t->type&Texture::ALPHA)) return NULL;
|
||||
if(!(t->type&Texture::ALPHA)) return nullptr;
|
||||
ImageData s;
|
||||
if(!texturedata(s, t->name, false) || !s.data || s.compressed) return NULL;
|
||||
if(!texturedata(s, t->name, false) || !s.data || s.compressed) return nullptr;
|
||||
t->alphamask = new uchar[s.h * ((s.w+7)/8)];
|
||||
uchar *srcrow = s.data, *dst = t->alphamask-1;
|
||||
loop(y, s.h)
|
||||
|
@ -1677,7 +1677,7 @@ Texture *textureload(const char *name, int clamp, bool mipit, bool msg)
|
|||
if(t) return t;
|
||||
int compress = 0;
|
||||
ImageData s;
|
||||
if(texturedata(s, tname, msg, &compress, &clamp)) return newtexture(NULL, tname, s, clamp, mipit, false, false, compress);
|
||||
if(texturedata(s, tname, msg, &compress, &clamp)) return newtexture(nullptr, tname, s, clamp, mipit, false, false, compress);
|
||||
return notexture;
|
||||
}
|
||||
|
||||
|
@ -1696,7 +1696,7 @@ DecalSlot dummydecalslot;
|
|||
|
||||
static MatSlot materialslots[(MATF_VOLUME|MATF_INDEX)+1];
|
||||
static vector<DecalSlot *> decalslots;
|
||||
static Slot *defslot = NULL;
|
||||
static Slot *defslot = nullptr;
|
||||
|
||||
const char *Slot::name() const { return tempformatstring("slot %d", index); }
|
||||
|
||||
|
@ -1708,7 +1708,7 @@ const char *DecalSlot::name() const { return tempformatstring("decal slot %d", S
|
|||
static void texturereset(int *n)
|
||||
{
|
||||
if(!(identflags&IDF_OVERRIDDEN) && !game::allowedittoggle()) return;
|
||||
defslot = NULL;
|
||||
defslot = nullptr;
|
||||
resetslotshader();
|
||||
int limit = clamp(*n, 0, slots.length());
|
||||
for(int i = limit; i < slots.length(); i++)
|
||||
|
@ -1731,7 +1731,7 @@ COMMAND(texturereset, "i");
|
|||
static void materialreset()
|
||||
{
|
||||
if(!(identflags&IDF_OVERRIDDEN) && !game::allowedittoggle()) return;
|
||||
defslot = NULL;
|
||||
defslot = nullptr;
|
||||
loopi((MATF_VOLUME|MATF_INDEX)+1) materialslots[i].reset();
|
||||
}
|
||||
|
||||
|
@ -1740,7 +1740,7 @@ COMMAND(materialreset, "");
|
|||
static void decalreset(int *n)
|
||||
{
|
||||
if(!(identflags&IDF_OVERRIDDEN) && !game::allowedittoggle()) return;
|
||||
defslot = NULL;
|
||||
defslot = nullptr;
|
||||
resetslotshader();
|
||||
decalslots.deletecontents(*n);
|
||||
}
|
||||
|
@ -1752,7 +1752,7 @@ static bool markingvslots = false;
|
|||
|
||||
void clearslots()
|
||||
{
|
||||
defslot = NULL;
|
||||
defslot = nullptr;
|
||||
resetslotshader();
|
||||
slots.deletecontents();
|
||||
vslots.deletecontents();
|
||||
|
@ -1807,7 +1807,7 @@ void compactvslots(cube *c, int n)
|
|||
|
||||
int compactvslots(bool cull)
|
||||
{
|
||||
defslot = NULL;
|
||||
defslot = nullptr;
|
||||
clonedvslots = 0;
|
||||
markingvslots = cull;
|
||||
compactedvslots = 0;
|
||||
|
@ -1899,7 +1899,7 @@ ICOMMAND(compactvslots, "i", (int *cull),
|
|||
allchanged();
|
||||
});
|
||||
|
||||
static void clampvslotoffset(VSlot &dst, Slot *slot = NULL)
|
||||
static void clampvslotoffset(VSlot &dst, Slot *slot = nullptr)
|
||||
{
|
||||
if(!slot) slot = dst.slot;
|
||||
if(slot && slot->sts.inrange(0))
|
||||
|
@ -1954,7 +1954,7 @@ static void propagatevslot(VSlot *root, int changed)
|
|||
}
|
||||
}
|
||||
|
||||
static void mergevslot(VSlot &dst, const VSlot &src, int diff, Slot *slot = NULL)
|
||||
static void mergevslot(VSlot &dst, const VSlot &src, int diff, Slot *slot = nullptr)
|
||||
{
|
||||
if(diff & (1<<VSLOT_SHPARAM)) loopv(src.params)
|
||||
{
|
||||
|
@ -2149,7 +2149,7 @@ bool unpackvslot(ucharbuf &buf, VSlot &dst, bool delta)
|
|||
{
|
||||
string name;
|
||||
getstring(name, buf);
|
||||
SlotShaderParam p = { name[0] ? getshaderparamname(name) : NULL, -1, 0, { 0, 0, 0, 0 } };
|
||||
SlotShaderParam p = { name[0] ? getshaderparamname(name) : nullptr, -1, 0, { 0, 0, 0, 0 } };
|
||||
loopi(4) p.val[i] = getfloat(buf);
|
||||
if(p.name) dst.params.add(p);
|
||||
break;
|
||||
|
@ -2217,7 +2217,7 @@ VSlot *findvslot(Slot &slot, const VSlot &src, const VSlot &delta)
|
|||
comparevslot(*dst, delta, delta.changed))
|
||||
return dst;
|
||||
}
|
||||
return NULL;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
static VSlot *clonevslot(const VSlot &src, const VSlot &delta)
|
||||
|
@ -2239,7 +2239,7 @@ VSlot *editvslot(const VSlot &src, const VSlot &delta)
|
|||
{
|
||||
compactvslots();
|
||||
allchanged();
|
||||
if(vslots.length()>=0x10000) return NULL;
|
||||
if(vslots.length()>=0x10000) return nullptr;
|
||||
}
|
||||
if(autocompactvslots && ++clonedvslots >= autocompactvslots)
|
||||
{
|
||||
|
@ -2344,7 +2344,7 @@ static void texgrass(char *name)
|
|||
if(!defslot) return;
|
||||
Slot &s = *defslot;
|
||||
DELETEA(s.grass);
|
||||
s.grass = name[0] ? newstring(makerelpath("media/texture", name)) : NULL;
|
||||
s.grass = name[0] ? newstring(makerelpath("media/texture", name)) : nullptr;
|
||||
}
|
||||
COMMAND(texgrass, "s");
|
||||
|
||||
|
@ -2549,7 +2549,7 @@ bool DecalSlot::shouldpremul(int type) const
|
|||
}
|
||||
}
|
||||
|
||||
static void addname(vector<char> &key, Slot &slot, Slot::Tex &t, bool combined = false, const char *prefix = NULL)
|
||||
static void addname(vector<char> &key, Slot &slot, Slot::Tex &t, bool combined = false, const char *prefix = nullptr)
|
||||
{
|
||||
if(combined) key.add('&');
|
||||
if(prefix) { while(*prefix) key.add(*prefix++); }
|
||||
|
@ -2560,8 +2560,8 @@ static void addname(vector<char> &key, Slot &slot, Slot::Tex &t, bool combined =
|
|||
void Slot::load(int index, Slot::Tex &t)
|
||||
{
|
||||
vector<char> key;
|
||||
addname(key, *this, t, false, shouldpremul(t.type) ? "<premul>" : NULL);
|
||||
Slot::Tex *combine = NULL;
|
||||
addname(key, *this, t, false, shouldpremul(t.type) ? "<premul>" : nullptr);
|
||||
Slot::Tex *combine = nullptr;
|
||||
loopv(sts)
|
||||
{
|
||||
Slot::Tex &c = sts[i];
|
||||
|
@ -2604,7 +2604,7 @@ void Slot::load(int index, Slot::Tex &t)
|
|||
break;
|
||||
}
|
||||
if(!ts.compressed && shouldpremul(t.type)) texpremul(ts);
|
||||
t.t = newtexture(NULL, key.getbuf(), ts, wrap, true, true, true, compress);
|
||||
t.t = newtexture(nullptr, key.getbuf(), ts, wrap, true, true, true, compress);
|
||||
}
|
||||
|
||||
void Slot::load()
|
||||
|
@ -2740,7 +2740,7 @@ Texture *Slot::loadthumbnail()
|
|||
addname(name, *this, sts[glow], true, prefix);
|
||||
}
|
||||
}
|
||||
VSlot *layer = vslot.layer ? &lookupvslot(vslot.layer, false) : NULL;
|
||||
VSlot *layer = vslot.layer ? &lookupvslot(vslot.layer, false) : nullptr;
|
||||
if(layer)
|
||||
{
|
||||
if(layer->colorscale == vec(1, 1, 1)) addname(name, *layer->slot, layer->slot->sts[0], true, "<layer>");
|
||||
|
@ -2750,7 +2750,7 @@ Texture *Slot::loadthumbnail()
|
|||
addname(name, *layer->slot, layer->slot->sts[0], true, prefix);
|
||||
}
|
||||
}
|
||||
VSlot *detail = vslot.detail ? &lookupvslot(vslot.detail, false) : NULL;
|
||||
VSlot *detail = vslot.detail ? &lookupvslot(vslot.detail, false) : nullptr;
|
||||
if(detail) addname(name, *detail->slot, detail->slot->sts[0], true, "<detail>");
|
||||
name.add('\0');
|
||||
Texture *t = textures.access(path(name.getbuf()));
|
||||
|
@ -2786,7 +2786,7 @@ Texture *Slot::loadthumbnail()
|
|||
blitthumbnail(s, d, 0, 0);
|
||||
}
|
||||
if(s.bpp < 3) forcergbimage(s);
|
||||
t = newtexture(NULL, name.getbuf(), s, 0, false, false, true);
|
||||
t = newtexture(nullptr, name.getbuf(), s, 0, false, false, true);
|
||||
t->xs = xs;
|
||||
t->ys = ys;
|
||||
thumbnail = t;
|
||||
|
@ -2838,16 +2838,16 @@ static Texture *cubemaploadwildcard(Texture *t, const char *name, bool mipit, bo
|
|||
}
|
||||
ImageData &s = surface[i];
|
||||
texturedata(s, sname, msg, &compress);
|
||||
if(!s.data) return NULL;
|
||||
if(!s.data) return nullptr;
|
||||
if(s.w != s.h)
|
||||
{
|
||||
if(msg) conoutf(CON_ERROR, "cubemap texture %s does not have square size", sname);
|
||||
return NULL;
|
||||
return nullptr;
|
||||
}
|
||||
if(s.compressed ? s.compressed!=surface[0].compressed || s.w!=surface[0].w || s.h!=surface[0].h || s.levels!=surface[0].levels : surface[0].compressed || s.bpp!=surface[0].bpp)
|
||||
{
|
||||
if(msg) conoutf(CON_ERROR, "cubemap texture %s doesn't match other sides' format", sname);
|
||||
return NULL;
|
||||
return nullptr;
|
||||
}
|
||||
tsize = max(tsize, max(s.w, s.h));
|
||||
}
|
||||
|
@ -2924,19 +2924,19 @@ Texture *cubemapload(const char *name, bool mipit, bool msg, bool transient)
|
|||
string pname;
|
||||
copystring(pname, makerelpath("media/sky", name));
|
||||
path(pname);
|
||||
Texture *t = NULL;
|
||||
Texture *t = nullptr;
|
||||
if(!strchr(pname, '*'))
|
||||
{
|
||||
defformatstring(jpgname, "%s_*.jpg", pname);
|
||||
t = cubemaploadwildcard(NULL, jpgname, mipit, false, transient);
|
||||
t = cubemaploadwildcard(nullptr, jpgname, mipit, false, transient);
|
||||
if(!t)
|
||||
{
|
||||
defformatstring(pngname, "%s_*.png", pname);
|
||||
t = cubemaploadwildcard(NULL, pngname, mipit, false, transient);
|
||||
t = cubemaploadwildcard(nullptr, pngname, mipit, false, transient);
|
||||
if(!t && msg) conoutf(CON_ERROR, "could not load envmap %s", name);
|
||||
}
|
||||
}
|
||||
else t = cubemaploadwildcard(NULL, pname, mipit, msg, transient);
|
||||
else t = cubemaploadwildcard(nullptr, pname, mipit, msg, transient);
|
||||
return t;
|
||||
}
|
||||
|
||||
|
@ -2983,7 +2983,7 @@ static GLuint genenvmap(const vec &o, int envmapsize, int blur, bool onlysky)
|
|||
emtexsize = texsize;
|
||||
loopi(2)
|
||||
{
|
||||
createtexture(emtex[i], emtexsize, emtexsize, NULL, 3, 1, GL_RGB, GL_TEXTURE_RECTANGLE);
|
||||
createtexture(emtex[i], emtexsize, emtexsize, nullptr, 3, 1, GL_RGB, GL_TEXTURE_RECTANGLE);
|
||||
glBindFramebuffer_(GL_FRAMEBUFFER, emfbo[i]);
|
||||
glFramebufferTexture2D_(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE, emtex[i], 0);
|
||||
if(glCheckFramebufferStatus_(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
|
||||
|
@ -2994,7 +2994,7 @@ static GLuint genenvmap(const vec &o, int envmapsize, int blur, bool onlysky)
|
|||
glGenTextures(1, &tex);
|
||||
// workaround for Catalyst bug:
|
||||
// all texture levels must be specified before glCopyTexSubImage2D is called, otherwise it crashes
|
||||
loopi(6) createtexture(!i ? tex : 0, texsize, texsize, NULL, 3, 2, GL_RGB5, cubemapsides[i].target);
|
||||
loopi(6) createtexture(!i ? tex : 0, texsize, texsize, nullptr, 3, 2, GL_RGB5, cubemapsides[i].target);
|
||||
float yaw = 0, pitch = 0;
|
||||
loopi(6)
|
||||
{
|
||||
|
@ -3203,12 +3203,12 @@ bool reloadtexture(Texture &tex)
|
|||
{
|
||||
int compress = 0;
|
||||
ImageData s;
|
||||
if(!texturedata(s, tex.name, true, &compress) || !newtexture(&tex, NULL, s, tex.clamp, tex.mipmap, false, false, compress)) return false;
|
||||
if(!texturedata(s, tex.name, true, &compress) || !newtexture(&tex, nullptr, s, tex.clamp, tex.mipmap, false, false, compress)) return false;
|
||||
break;
|
||||
}
|
||||
|
||||
case Texture::CUBEMAP:
|
||||
if(!cubemaploadwildcard(&tex, NULL, tex.mipmap, true)) return false;
|
||||
if(!cubemaploadwildcard(&tex, nullptr, tex.mipmap, true)) return false;
|
||||
break;
|
||||
}
|
||||
return true;
|
||||
|
@ -3499,7 +3499,7 @@ static bool loaddds(const char *filename, ImageData &image, int force)
|
|||
case GL_COMPRESSED_RG_RGTC2: bpp = 16; break;
|
||||
|
||||
}
|
||||
image.setdata(NULL, d.dwWidth, d.dwHeight, bpp, !supported || force > 0 ? 1 : d.dwMipMapCount, 4, format);
|
||||
image.setdata(nullptr, d.dwWidth, d.dwHeight, bpp, !supported || force > 0 ? 1 : d.dwMipMapCount, 4, format);
|
||||
size_t size = image.calcsize();
|
||||
if(f->read(image.data, size) != size) { delete f; image.cleanup(); return false; }
|
||||
delete f;
|
||||
|
@ -3627,7 +3627,7 @@ static void gendds(char *infile, char *outfile)
|
|||
}
|
||||
COMMAND(gendds, "ss");
|
||||
|
||||
static void writepngchunk(stream *f, const char *type, uchar *data = NULL, uint len = 0)
|
||||
static void writepngchunk(stream *f, const char *type, uchar *data = nullptr, uint len = 0)
|
||||
{
|
||||
f->putbig<uint>(len);
|
||||
f->write(type, 4);
|
||||
|
@ -3672,9 +3672,9 @@ void savepng(const char *filename, ImageData &image, bool flip)
|
|||
crc = crc32(crc, (const Bytef *)"IDAT", 4);
|
||||
|
||||
z_stream z;
|
||||
z.zalloc = NULL;
|
||||
z.zfree = NULL;
|
||||
z.opaque = NULL;
|
||||
z.zalloc = nullptr;
|
||||
z.zfree = nullptr;
|
||||
z.opaque = nullptr;
|
||||
|
||||
if(deflateInit(&z, compresspng) != Z_OK)
|
||||
goto error;
|
||||
|
@ -3912,7 +3912,7 @@ static void screenshot(char *filename)
|
|||
else
|
||||
{
|
||||
string sstime;
|
||||
time_t t = time(NULL);
|
||||
time_t t = time(nullptr);
|
||||
size_t len = strftime(sstime, sizeof(sstime), "%Y-%m-%d_%H.%M.%S", localtime(&t));
|
||||
sstime[min(len, sizeof(sstime)-1)] = '\0';
|
||||
concatstring(buf, sstime);
|
||||
|
|
|
@ -15,17 +15,17 @@ struct ImageData
|
|||
void (*freefunc)(void *);
|
||||
|
||||
ImageData()
|
||||
: data(NULL), owner(NULL), freefunc(NULL)
|
||||
: data(nullptr), owner(nullptr), freefunc(nullptr)
|
||||
{}
|
||||
|
||||
|
||||
ImageData(int nw, int nh, int nbpp, int nlevels = 1, int nalign = 0, GLenum ncompressed = GL_FALSE)
|
||||
{
|
||||
setdata(NULL, nw, nh, nbpp, nlevels, nalign, ncompressed);
|
||||
setdata(nullptr, nw, nh, nbpp, nlevels, nalign, ncompressed);
|
||||
}
|
||||
|
||||
ImageData(int nw, int nh, int nbpp, uchar *data)
|
||||
: owner(NULL), freefunc(NULL)
|
||||
: owner(nullptr), freefunc(nullptr)
|
||||
{
|
||||
setdata(data, nw, nh, nbpp);
|
||||
}
|
||||
|
@ -43,7 +43,7 @@ struct ImageData
|
|||
pitch = align ? 0 : w*bpp;
|
||||
compressed = ncompressed;
|
||||
data = ndata ? ndata : new uchar[calcsize()];
|
||||
if(!ndata) { owner = this; freefunc = NULL; }
|
||||
if(!ndata) { owner = this; freefunc = nullptr; }
|
||||
}
|
||||
|
||||
int calclevelsize(int level) const { return ((max(w>>level, 1)+align-1)/align)*((max(h>>level, 1)+align-1)/align)*bpp; }
|
||||
|
@ -67,9 +67,9 @@ struct ImageData
|
|||
|
||||
void disown()
|
||||
{
|
||||
data = NULL;
|
||||
owner = NULL;
|
||||
freefunc = NULL;
|
||||
data = nullptr;
|
||||
owner = nullptr;
|
||||
freefunc = nullptr;
|
||||
}
|
||||
|
||||
void cleanup()
|
||||
|
@ -122,7 +122,7 @@ struct Texture
|
|||
GLuint id;
|
||||
uchar *alphamask;
|
||||
|
||||
Texture() : alphamask(NULL) {}
|
||||
Texture() : alphamask(nullptr) {}
|
||||
};
|
||||
|
||||
enum
|
||||
|
@ -174,7 +174,7 @@ struct VSlot
|
|||
float refractscale;
|
||||
vec refractcolor;
|
||||
|
||||
VSlot(Slot *slot = NULL, int index = -1) : slot(slot), next(NULL), index(index), changed(0)
|
||||
VSlot(Slot *slot = nullptr, int index = -1) : slot(slot), next(nullptr), index(index), changed(0)
|
||||
{
|
||||
reset();
|
||||
if(slot) addvariant(slot);
|
||||
|
@ -218,7 +218,7 @@ struct Slot
|
|||
string name;
|
||||
int combined;
|
||||
|
||||
Tex() : t(NULL), combined(-1) {}
|
||||
Tex() : t(nullptr), combined(-1) {}
|
||||
};
|
||||
|
||||
int index, smooth;
|
||||
|
@ -231,7 +231,7 @@ struct Slot
|
|||
char *grass;
|
||||
Texture *grasstex, *thumbnail;
|
||||
|
||||
Slot(int index = -1) : index(index), variants(NULL), grass(NULL) { reset(); }
|
||||
Slot(int index = -1) : index(index), variants(nullptr), grass(nullptr) { reset(); }
|
||||
virtual ~Slot() {}
|
||||
|
||||
virtual int type() const { return OCTA; }
|
||||
|
@ -254,24 +254,24 @@ struct Slot
|
|||
{
|
||||
smooth = -1;
|
||||
sts.setsize(0);
|
||||
shader = NULL;
|
||||
shader = nullptr;
|
||||
params.setsize(0);
|
||||
loaded = false;
|
||||
texmask = 0;
|
||||
DELETEA(grass);
|
||||
grasstex = NULL;
|
||||
thumbnail = NULL;
|
||||
grasstex = nullptr;
|
||||
thumbnail = nullptr;
|
||||
}
|
||||
|
||||
void cleanup()
|
||||
{
|
||||
loaded = false;
|
||||
grasstex = NULL;
|
||||
thumbnail = NULL;
|
||||
grasstex = nullptr;
|
||||
thumbnail = nullptr;
|
||||
loopv(sts)
|
||||
{
|
||||
Tex &t = sts[i];
|
||||
t.t = NULL;
|
||||
t.t = nullptr;
|
||||
t.combined = -1;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -155,8 +155,8 @@ struct vertmodel : animmodel
|
|||
vdata += voffset;
|
||||
const vert * RESTRICT vert1 = &verts[as.cur.fr1 * numverts],
|
||||
* RESTRICT vert2 = &verts[as.cur.fr2 * numverts],
|
||||
* RESTRICT pvert1 = as.interp<1 ? &verts[as.prev.fr1 * numverts] : NULL,
|
||||
* RESTRICT pvert2 = as.interp<1 ? &verts[as.prev.fr2 * numverts] : NULL;
|
||||
* RESTRICT pvert1 = as.interp<1 ? &verts[as.prev.fr1 * numverts] : nullptr,
|
||||
* RESTRICT pvert2 = as.interp<1 ? &verts[as.prev.fr2 * numverts] : nullptr;
|
||||
#define ipvert(attrib, type) v.attrib.lerp(vert1[i].attrib, vert2[i].attrib, as.cur.t)
|
||||
#define ipvertp(attrib, type) v.attrib.lerp(type().lerp(pvert1[i].attrib, pvert2[i].attrib, as.prev.t), type().lerp(vert1[i].attrib, vert2[i].attrib, as.cur.t), as.interp)
|
||||
if(as.interp<1) loopi(numverts) { T &v = vdata[i]; ipvertp(pos, vec); ipvertp(tangent, vec4); }
|
||||
|
@ -179,7 +179,7 @@ struct vertmodel : animmodel
|
|||
char *name;
|
||||
matrix4x3 matrix;
|
||||
|
||||
tag() : name(NULL) {}
|
||||
tag() : name(nullptr) {}
|
||||
~tag() { DELETEA(name); }
|
||||
};
|
||||
|
||||
|
@ -197,7 +197,7 @@ struct vertmodel : animmodel
|
|||
int vlen, vertsize;
|
||||
uchar *vdata;
|
||||
|
||||
vertmeshgroup() : numframes(0), tags(NULL), numtags(0), edata(NULL), ebuf(0), vlen(0), vertsize(0), vdata(NULL)
|
||||
vertmeshgroup() : numframes(0), tags(nullptr), numtags(0), edata(nullptr), ebuf(0), vlen(0), vertsize(0), vdata(nullptr)
|
||||
{
|
||||
}
|
||||
|
||||
|
@ -376,7 +376,7 @@ struct vertmodel : animmodel
|
|||
return;
|
||||
}
|
||||
|
||||
vbocacheentry *vc = NULL;
|
||||
vbocacheentry *vc = nullptr;
|
||||
if(numframes<=1) vc = vbocache;
|
||||
else
|
||||
{
|
||||
|
@ -424,7 +424,7 @@ struct vertmodel : animmodel
|
|||
meshgroup *loadmeshes(const char *name, float smooth = 2)
|
||||
{
|
||||
vertmeshgroup *group = newmeshes();
|
||||
if(!group->load(name, smooth)) { delete group; return NULL; }
|
||||
if(!group->load(name, smooth)) { delete group; return nullptr; }
|
||||
return group;
|
||||
}
|
||||
|
||||
|
@ -433,7 +433,7 @@ struct vertmodel : animmodel
|
|||
if(!meshgroups.access(name))
|
||||
{
|
||||
meshgroup *group = loadmeshes(name, smooth);
|
||||
if(!group) return NULL;
|
||||
if(!group) return nullptr;
|
||||
meshgroups.add(group);
|
||||
}
|
||||
return meshgroups[name];
|
||||
|
|
|
@ -79,7 +79,7 @@ VARFP(waterfallenv, 0, 1, 1, preloadwatershaders());
|
|||
|
||||
VARFP(vertwater, 0, 1, 1, allchanged());
|
||||
|
||||
static Texture *caustictex[NUMCAUSTICS] = { NULL };
|
||||
static Texture *caustictex[NUMCAUSTICS] = { nullptr };
|
||||
|
||||
void loadcaustics(bool force)
|
||||
{
|
||||
|
@ -98,7 +98,7 @@ void loadcaustics(bool force)
|
|||
#if 0
|
||||
static void cleanupcaustics()
|
||||
{
|
||||
loopi(NUMCAUSTICS) caustictex[i] = NULL;
|
||||
loopi(NUMCAUSTICS) caustictex[i] = nullptr;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
@ -442,7 +442,7 @@ void preloadwatershaders(bool force)
|
|||
|
||||
static float wfwave = 0.0f, wfscroll = 0.0f, wfxscale = 1.0f, wfyscale = 1.0f;
|
||||
|
||||
static void renderwaterfall(const materialsurface &m, float offset, const vec *normal = NULL)
|
||||
static void renderwaterfall(const materialsurface &m, float offset, const vec *normal = nullptr)
|
||||
{
|
||||
if(gle::attribbuf.empty())
|
||||
{
|
||||
|
@ -651,12 +651,12 @@ void renderwater()
|
|||
|
||||
#define SETWATERSHADER(which, name) \
|
||||
do { \
|
||||
static Shader *name##shader = NULL; \
|
||||
static Shader *name##shader = nullptr; \
|
||||
if(!name##shader) name##shader = lookupshaderbyname(#name); \
|
||||
which##shader = name##shader; \
|
||||
} while(0)
|
||||
|
||||
Shader *aboveshader = NULL;
|
||||
Shader *aboveshader = nullptr;
|
||||
if(drawtex == DRAWTEX_MINIMAP) SETWATERSHADER(above, waterminimap);
|
||||
else if(caustics && causticscale && causticmillis)
|
||||
{
|
||||
|
@ -671,7 +671,7 @@ void renderwater()
|
|||
else SETWATERSHADER(above, water);
|
||||
}
|
||||
|
||||
Shader *belowshader = NULL;
|
||||
Shader *belowshader = nullptr;
|
||||
if(drawtex != DRAWTEX_MINIMAP) SETWATERSHADER(below, underwater);
|
||||
|
||||
aboveshader->set();
|
||||
|
|
|
@ -101,13 +101,13 @@ enum
|
|||
MODOE_CHANGED = 1<<2
|
||||
};
|
||||
|
||||
static void modifyoctaentity(int flags, int id, extentity &e, cube *c, const ivec &cor, int size, const ivec &bo, const ivec &br, int leafsize, vtxarray *lastva = NULL)
|
||||
static void modifyoctaentity(int flags, int id, extentity &e, cube *c, const ivec &cor, int size, const ivec &bo, const ivec &br, int leafsize, vtxarray *lastva = nullptr)
|
||||
{
|
||||
loopoctabox(cor, size, bo, br)
|
||||
{
|
||||
ivec o(i, cor, size);
|
||||
vtxarray *va = c[i].ext && c[i].ext->va ? c[i].ext->va : lastva;
|
||||
if(c[i].children != NULL && size > leafsize)
|
||||
if(c[i].children != nullptr && size > leafsize)
|
||||
modifyoctaentity(flags, id, e, c[i].children, o, size>>1, bo, br, leafsize, va);
|
||||
else if(flags&MODOE_ADD)
|
||||
{
|
||||
|
@ -205,7 +205,7 @@ static void modifyoctaentity(int flags, int id, extentity &e, cube *c, const ive
|
|||
if(oe.mapmodels.empty() && oe.decals.empty() && oe.other.empty())
|
||||
freeoctaentities(c[i]);
|
||||
}
|
||||
if(c[i].ext && c[i].ext->ents) c[i].ext->ents->query = NULL;
|
||||
if(c[i].ext && c[i].ext->ents) c[i].ext->ents->query = nullptr;
|
||||
if(va && va!=lastva)
|
||||
{
|
||||
if(lastva)
|
||||
|
@ -282,7 +282,7 @@ void freeoctaentities(cube &c)
|
|||
if(c.ext->ents)
|
||||
{
|
||||
delete c.ext->ents;
|
||||
c.ext->ents = NULL;
|
||||
c.ext->ents = nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -387,7 +387,7 @@ static void entadd(int id)
|
|||
static undoblock *newundoent()
|
||||
{
|
||||
int numents = entgroup.length();
|
||||
if(numents <= 0) return NULL;
|
||||
if(numents <= 0) return nullptr;
|
||||
undoblock *u = (undoblock *)new uchar[sizeof(undoblock) + numents*sizeof(undoent)];
|
||||
u->numents = numents;
|
||||
undoent *e = (undoent *)(u + 1);
|
||||
|
@ -412,8 +412,8 @@ static void makeundoent()
|
|||
static void detachentity(extentity &e)
|
||||
{
|
||||
if(!e.attached) return;
|
||||
e.attached->attached = NULL;
|
||||
e.attached = NULL;
|
||||
e.attached->attached = nullptr;
|
||||
e.attached = nullptr;
|
||||
}
|
||||
|
||||
VAR(attachradius, 1, 100, 1000);
|
||||
|
@ -554,7 +554,7 @@ static void entrotate(int *cw)
|
|||
|
||||
void entselectionbox(const entity &e, vec &eo, vec &es)
|
||||
{
|
||||
model *m = NULL;
|
||||
model *m = nullptr;
|
||||
const char *mname = entities::entmodel(e);
|
||||
if(mname && (m = loadmodel(mname)))
|
||||
{
|
||||
|
@ -1072,7 +1072,7 @@ static extentity *newentity(bool local, const vec &o, int type, int v1, int v2,
|
|||
{
|
||||
idx = -1;
|
||||
for(int i = keepents; i < ents.length(); i++) if(ents[i]->type == ET_EMPTY) { idx = i; break; }
|
||||
if(idx < 0 && ents.length() >= MAXENTS) { conoutf("too many entities"); return NULL; }
|
||||
if(idx < 0 && ents.length() >= MAXENTS) { conoutf("too many entities"); return nullptr; }
|
||||
}
|
||||
else while(ents.length() < idx) ents.add(entities::newentity())->type = ET_EMPTY;
|
||||
extentity &e = *entities::newentity();
|
||||
|
@ -1424,7 +1424,7 @@ static void shrinkmap()
|
|||
|
||||
if(!worldroot[octant].children) subdividecube(worldroot[octant], false, false);
|
||||
cube *root = worldroot[octant].children;
|
||||
worldroot[octant].children = NULL;
|
||||
worldroot[octant].children = nullptr;
|
||||
freeocta(worldroot);
|
||||
worldroot = root;
|
||||
worldscale--;
|
||||
|
@ -1441,7 +1441,7 @@ static void shrinkmap()
|
|||
conoutf("shrunk map to size %d", worldscale);
|
||||
}
|
||||
|
||||
static void newmap(int *i) { bool force = !isconnected(); if(force) game::forceedit(""); if(emptymap(*i, force, NULL)) game::newmap(max(*i, 0)); }
|
||||
static void newmap(int *i) { bool force = !isconnected(); if(force) game::forceedit(""); if(emptymap(*i, force, nullptr)) game::newmap(max(*i, 0)); }
|
||||
static void mapenlarge() { if(enlargemap(false)) game::newmap(-1); }
|
||||
COMMAND(newmap, "i");
|
||||
COMMAND(mapenlarge, "");
|
||||
|
|
|
@ -50,7 +50,7 @@ struct mapheader
|
|||
|
||||
VARR(mapversion, 1, MAPVERSION, 0);
|
||||
|
||||
static void validmapname(char *dst, const char *src, const char *prefix = NULL, const char *alt = "untitled", size_t maxlen = 100)
|
||||
static void validmapname(char *dst, const char *src, const char *prefix = nullptr, const char *alt = "untitled", size_t maxlen = 100)
|
||||
{
|
||||
if(prefix) while(*prefix) *dst++ = *prefix++;
|
||||
const char *start = dst;
|
||||
|
@ -107,7 +107,7 @@ static bool loadmapheader(stream *f, const char *ogzname, mapheader &hdr, octahe
|
|||
|
||||
static string ogzname, cfgname, picname;
|
||||
|
||||
static void setmapfilenames(const char *fname, const char *cname = NULL)
|
||||
static void setmapfilenames(const char *fname, const char *cname = nullptr)
|
||||
{
|
||||
string name;
|
||||
validmapname(name, fname);
|
||||
|
@ -508,13 +508,13 @@ static void loadvslots(stream *f, int numvslots)
|
|||
int changed = f->getlil<int>();
|
||||
if(changed < 0)
|
||||
{
|
||||
loopi(-changed) vslots.add(new VSlot(NULL, vslots.length()));
|
||||
loopi(-changed) vslots.add(new VSlot(nullptr, vslots.length()));
|
||||
numvslots += changed;
|
||||
}
|
||||
else
|
||||
{
|
||||
prev[vslots.length()] = f->getlil<int>();
|
||||
loadvslot(f, *vslots.add(new VSlot(NULL, vslots.length())), changed);
|
||||
loadvslot(f, *vslots.add(new VSlot(nullptr, vslots.length())), changed);
|
||||
numvslots--;
|
||||
}
|
||||
}
|
||||
|
@ -654,7 +654,7 @@ bool load_world(const char *mname, const char *cname) // still supports a
|
|||
renderprogress(0, "clearing world...");
|
||||
|
||||
freeocta(worldroot);
|
||||
worldroot = NULL;
|
||||
worldroot = nullptr;
|
||||
|
||||
int worldscale = 0;
|
||||
while(1<<worldscale < hdr.worldsize) worldscale++;
|
||||
|
@ -742,7 +742,7 @@ bool load_world(const char *mname, const char *cname) // still supports a
|
|||
|
||||
vector<extentity *> &ents = entities::getents();
|
||||
int einfosize = entities::extraentinfosize();
|
||||
char *ebuf = einfosize > 0 ? new char[einfosize] : NULL;
|
||||
char *ebuf = einfosize > 0 ? new char[einfosize] : nullptr;
|
||||
loopi(min(hdr.numents, MAXENTS))
|
||||
{
|
||||
extentity &e = *entities::newentity();
|
||||
|
@ -951,7 +951,7 @@ static void writecollideobj(char *name)
|
|||
return;
|
||||
}
|
||||
vector<extentity *> &ents = entities::getents();
|
||||
extentity *mm = NULL;
|
||||
extentity *mm = nullptr;
|
||||
loopv(entgroup)
|
||||
{
|
||||
extentity &e = *ents[entgroup[i]];
|
||||
|
|
|
@ -5,6 +5,6 @@
|
|||
|
||||
uint getmapcrc();
|
||||
void clearmapcrc();
|
||||
bool load_world(const char *mname, const char *cname = NULL);
|
||||
bool load_world(const char *mname, const char *cname = nullptr);
|
||||
|
||||
#endif
|
||||
|
|
|
@ -11,7 +11,7 @@ extern void clearmainmenu();
|
|||
|
||||
namespace game
|
||||
{
|
||||
dynent *player1 = NULL; // our client
|
||||
dynent *player1 = nullptr; // our client
|
||||
string clientmap = "";
|
||||
bool connected = false;
|
||||
|
||||
|
@ -132,12 +132,12 @@ namespace game
|
|||
|
||||
const char *getmapinfo()
|
||||
{
|
||||
return NULL;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
const char *getscreenshotinfo()
|
||||
{
|
||||
return NULL;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
void physicstrigger(physent *d, bool local, int floorlevel, int waterlevel, int material)
|
||||
|
@ -153,7 +153,7 @@ namespace game
|
|||
dynent *iterdynents(int i)
|
||||
{
|
||||
if(!i) return player1;
|
||||
return NULL;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
bool needminimap() { return false; }
|
||||
|
@ -229,7 +229,7 @@ namespace game
|
|||
|
||||
void newmap(int size)
|
||||
{
|
||||
if(size>=0) emptymap(size, true, NULL);
|
||||
if(size>=0) emptymap(size, true, nullptr);
|
||||
else enlargemap(true);
|
||||
connected = true;
|
||||
}
|
||||
|
@ -288,7 +288,7 @@ namespace entities
|
|||
|
||||
const char *entmodel(const entity &e)
|
||||
{
|
||||
return NULL;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
void preloadentities()
|
||||
|
|
|
@ -75,7 +75,7 @@ uint randomMT()
|
|||
int cur = next;
|
||||
if(++next >= N)
|
||||
{
|
||||
if(next > N) { seedMT(5489U + time(NULL)); cur = next++; }
|
||||
if(next > N) { seedMT(5489U + time(nullptr)); cur = next++; }
|
||||
else next = 0;
|
||||
}
|
||||
uint y = (state[cur] & 0x80000000U) | (state[next] & 0x7FFFFFFFU);
|
||||
|
|
|
@ -11,11 +11,6 @@
|
|||
#include <SDL.h>
|
||||
#include <zlib.h>
|
||||
|
||||
#ifdef NULL
|
||||
#undef NULL
|
||||
#endif
|
||||
#define NULL 0
|
||||
|
||||
typedef unsigned char uchar;
|
||||
typedef unsigned short ushort;
|
||||
typedef unsigned int uint;
|
||||
|
@ -274,7 +269,7 @@ struct databuf
|
|||
int len, maxlen;
|
||||
uchar flags;
|
||||
|
||||
databuf() : buf(NULL), len(0), maxlen(0), flags(0) {}
|
||||
databuf() : buf(nullptr), len(0), maxlen(0), flags(0) {}
|
||||
|
||||
template<class U>
|
||||
databuf(T *buf, U maxlen) : buf(buf), len(0), maxlen((int)maxlen), flags(0) {}
|
||||
|
@ -559,11 +554,11 @@ template <class T> struct vector
|
|||
T *buf;
|
||||
int alen, ulen;
|
||||
|
||||
vector() : buf(NULL), alen(0), ulen(0)
|
||||
vector() : buf(nullptr), alen(0), ulen(0)
|
||||
{
|
||||
}
|
||||
|
||||
vector(const vector &v) : buf(NULL), alen(0), ulen(0)
|
||||
vector(const vector &v) : buf(nullptr), alen(0), ulen(0)
|
||||
{
|
||||
*this = v;
|
||||
}
|
||||
|
@ -629,7 +624,7 @@ template <class T> struct vector
|
|||
T &operator[](int i) { ASSERT(i>=0 && i<ulen); return buf[i]; }
|
||||
const T &operator[](int i) const { ASSERT(i >= 0 && i<ulen); return buf[i]; }
|
||||
|
||||
T *disown() { T *r = buf; buf = NULL; alen = ulen = 0; return r; }
|
||||
T *disown() { T *r = buf; buf = nullptr; alen = ulen = 0; return r; }
|
||||
|
||||
void shrink(int i) { ASSERT(i<=ulen); if(isclass<T>::no) ulen = i; else while(ulen>i) drop(); }
|
||||
void setsize(int i) { ASSERT(i<=ulen); ulen = i; }
|
||||
|
@ -882,8 +877,8 @@ template<class H, class E, class K, class T> struct hashbase
|
|||
: size(size)
|
||||
{
|
||||
numelems = 0;
|
||||
chunks = NULL;
|
||||
unused = NULL;
|
||||
chunks = nullptr;
|
||||
unused = nullptr;
|
||||
chains = new chain *[size];
|
||||
memset(chains, 0, size*sizeof(chain *));
|
||||
}
|
||||
|
@ -932,7 +927,7 @@ template<class H, class E, class K, class T> struct hashbase
|
|||
template<class U>
|
||||
T *access(const U &key)
|
||||
{
|
||||
HTFIND(&, NULL);
|
||||
HTFIND(&, nullptr);
|
||||
}
|
||||
|
||||
template<class U, class V>
|
||||
|
@ -994,7 +989,7 @@ template<class H, class E, class K, class T> struct hashbase
|
|||
}
|
||||
c->next = unused;
|
||||
unused = chains[i];
|
||||
chains[i] = NULL;
|
||||
chains[i] = nullptr;
|
||||
}
|
||||
numelems = 0;
|
||||
}
|
||||
|
@ -1013,7 +1008,7 @@ template<class H, class E, class K, class T> struct hashbase
|
|||
if(!numelems) return;
|
||||
memset(chains, 0, size*sizeof(chain *));
|
||||
numelems = 0;
|
||||
unused = NULL;
|
||||
unused = nullptr;
|
||||
deletechunks();
|
||||
}
|
||||
|
||||
|
@ -1297,12 +1292,12 @@ static inline uchar cubeupper(uchar c)
|
|||
extern const uchar cubeupperchars[256];
|
||||
return cubeupperchars[c];
|
||||
}
|
||||
extern size_t decodeutf8(uchar *dst, size_t dstlen, const uchar *src, size_t srclen, size_t *carry = NULL);
|
||||
extern size_t encodeutf8(uchar *dstbuf, size_t dstlen, const uchar *srcbuf, size_t srclen, size_t *carry = NULL);
|
||||
extern size_t decodeutf8(uchar *dst, size_t dstlen, const uchar *src, size_t srclen, size_t *carry = nullptr);
|
||||
extern size_t encodeutf8(uchar *dstbuf, size_t dstlen, const uchar *srcbuf, size_t srclen, size_t *carry = nullptr);
|
||||
|
||||
extern string homedir;
|
||||
|
||||
extern char *makerelpath(const char *dir, const char *file, const char *prefix = NULL, const char *cmd = NULL);
|
||||
extern char *makerelpath(const char *dir, const char *file, const char *prefix = nullptr, const char *cmd = nullptr);
|
||||
extern char *path(char *s);
|
||||
extern char *path(const char *s, bool copy);
|
||||
extern const char *parentdir(const char *directory);
|
||||
|
@ -1317,8 +1312,8 @@ extern stream *openrawfile(const char *filename, const char *mode);
|
|||
extern stream *openzipfile(const char *filename, const char *mode);
|
||||
extern stream *openfile(const char *filename, const char *mode);
|
||||
extern stream *opentempfile(const char *filename, const char *mode);
|
||||
extern stream *opengzfile(const char *filename, const char *mode, stream *file = NULL, int level = Z_BEST_COMPRESSION);
|
||||
extern stream *openutf8file(const char *filename, const char *mode, stream *file = NULL);
|
||||
extern stream *opengzfile(const char *filename, const char *mode, stream *file = nullptr, int level = Z_BEST_COMPRESSION);
|
||||
extern stream *openutf8file(const char *filename, const char *mode, stream *file = nullptr);
|
||||
extern char *loadfile(const char *fn, size_t *size, bool utf8 = true);
|
||||
extern bool listdir(const char *dir, bool rel, const char *ext, vector<char *> &files);
|
||||
extern int listfiles(const char *dir, const char *ext, vector<char *> &files);
|
||||
|
|
|
@ -147,35 +147,35 @@ struct ident
|
|||
|
||||
ident() {}
|
||||
// ID_VAR
|
||||
ident(int t, const char *n, int m, int x, int *s, void *f = NULL, int flags = 0)
|
||||
ident(int t, const char *n, int m, int x, int *s, void *f = nullptr, int flags = 0)
|
||||
: type(t), flags(flags | (m > x ? IDF_READONLY : 0)), name(n), minval(m), maxval(x), fun((identfun)f)
|
||||
{ storage.i = s; }
|
||||
// ID_FVAR
|
||||
ident(int t, const char *n, float m, float x, float *s, void *f = NULL, int flags = 0)
|
||||
ident(int t, const char *n, float m, float x, float *s, void *f = nullptr, int flags = 0)
|
||||
: type(t), flags(flags | (m > x ? IDF_READONLY : 0)), name(n), minvalf(m), maxvalf(x), fun((identfun)f)
|
||||
{ storage.f = s; }
|
||||
// ID_SVAR
|
||||
ident(int t, const char *n, char **s, void *f = NULL, int flags = 0)
|
||||
ident(int t, const char *n, char **s, void *f = nullptr, int flags = 0)
|
||||
: type(t), flags(flags), name(n), fun((identfun)f)
|
||||
{ storage.s = s; }
|
||||
// ID_ALIAS
|
||||
ident(int t, const char *n, char *a, int flags)
|
||||
: type(t), valtype(VAL_STR), flags(flags), name(n), code(NULL), stack(NULL)
|
||||
: type(t), valtype(VAL_STR), flags(flags), name(n), code(nullptr), stack(nullptr)
|
||||
{ val.s = a; }
|
||||
ident(int t, const char *n, int a, int flags)
|
||||
: type(t), valtype(VAL_INT), flags(flags), name(n), code(NULL), stack(NULL)
|
||||
: type(t), valtype(VAL_INT), flags(flags), name(n), code(nullptr), stack(nullptr)
|
||||
{ val.i = a; }
|
||||
ident(int t, const char *n, float a, int flags)
|
||||
: type(t), valtype(VAL_FLOAT), flags(flags), name(n), code(NULL), stack(NULL)
|
||||
: type(t), valtype(VAL_FLOAT), flags(flags), name(n), code(nullptr), stack(nullptr)
|
||||
{ val.f = a; }
|
||||
ident(int t, const char *n, int flags)
|
||||
: type(t), valtype(VAL_NULL), flags(flags), name(n), code(NULL), stack(NULL)
|
||||
: type(t), valtype(VAL_NULL), flags(flags), name(n), code(nullptr), stack(nullptr)
|
||||
{}
|
||||
ident(int t, const char *n, const tagval &v, int flags)
|
||||
: type(t), valtype(v.type), flags(flags), name(n), code(NULL), stack(NULL)
|
||||
: type(t), valtype(v.type), flags(flags), name(n), code(nullptr), stack(nullptr)
|
||||
{ val = v; }
|
||||
// ID_COMMAND
|
||||
ident(int t, const char *n, const char *args, uint argmask, int numargs, void *f = NULL, int flags = 0)
|
||||
ident(int t, const char *n, const char *args, uint argmask, int numargs, void *f = nullptr, int flags = 0)
|
||||
: type(t), numargs(numargs), flags(flags), name(n), args(args), argmask(argmask), fun((identfun)f)
|
||||
{}
|
||||
|
||||
|
@ -223,7 +223,7 @@ extern void result(const char *s);
|
|||
|
||||
static inline int parseint(const char *s)
|
||||
{
|
||||
return int(strtoul(s, NULL, 0));
|
||||
return int(strtoul(s, nullptr, 0));
|
||||
}
|
||||
|
||||
#define PARSEFLOAT(name, type) \
|
||||
|
@ -315,13 +315,13 @@ inline void ident::getcval(tagval &v) const
|
|||
}
|
||||
|
||||
// nasty macros for registering script functions, abuses globals to avoid excessive infrastructure
|
||||
#define KEYWORD(name, type) UNUSED static bool __dummy_##type = addcommand(#name, (identfun)NULL, NULL, type)
|
||||
#define KEYWORD(name, type) UNUSED static bool __dummy_##type = addcommand(#name, (identfun)nullptr, nullptr, type)
|
||||
#define COMMANDKN(name, type, fun, nargs) UNUSED static bool __dummy_##fun = addcommand(#name, (identfun)fun, nargs, type)
|
||||
#define COMMANDK(name, type, nargs) COMMANDKN(name, type, name, nargs)
|
||||
#define COMMANDN(name, fun, nargs) COMMANDKN(name, ID_COMMAND, fun, nargs)
|
||||
#define COMMAND(name, nargs) COMMANDN(name, name, nargs)
|
||||
|
||||
#define _VAR(name, global, min, cur, max, persist) int global = variable(#name, min, cur, max, &global, NULL, persist)
|
||||
#define _VAR(name, global, min, cur, max, persist) int global = variable(#name, min, cur, max, &global, nullptr, persist)
|
||||
#define VARN(name, global, min, cur, max) _VAR(name, global, min, cur, max, 0)
|
||||
#define VARNP(name, global, min, cur, max) _VAR(name, global, min, cur, max, IDF_PERSIST)
|
||||
#define VARNR(name, global, min, cur, max) _VAR(name, global, min, cur, max, IDF_OVERRIDE)
|
||||
|
@ -339,7 +339,7 @@ inline void ident::getcval(tagval &v) const
|
|||
#define VARMP(name, min, cur, max, scale) _VARM(name, min, cur, max, scale, IDF_PERSIST)
|
||||
#define VARMR(name, min, cur, max, scale) _VARM(name, min, cur, max, scale, IDF_OVERRIDE)
|
||||
|
||||
#define _HVAR(name, global, min, cur, max, persist) int global = variable(#name, min, cur, max, &global, NULL, persist | IDF_HEX)
|
||||
#define _HVAR(name, global, min, cur, max, persist) int global = variable(#name, min, cur, max, &global, nullptr, persist | IDF_HEX)
|
||||
#define HVARN(name, global, min, cur, max) _HVAR(name, global, min, cur, max, 0)
|
||||
#define HVARNP(name, global, min, cur, max) _HVAR(name, global, min, cur, max, IDF_PERSIST)
|
||||
#define HVARNR(name, global, min, cur, max) _HVAR(name, global, min, cur, max, IDF_OVERRIDE)
|
||||
|
@ -370,7 +370,7 @@ inline void ident::getcval(tagval &v) const
|
|||
#define CVAR1FP(name, cur, body) _CVAR1(name, cur, body, IDF_PERSIST)
|
||||
#define CVAR1FR(name, cur, body) _CVAR1(name, cur, body, IDF_OVERRIDE)
|
||||
|
||||
#define _FVAR(name, global, min, cur, max, persist) float global = fvariable(#name, min, cur, max, &global, NULL, persist)
|
||||
#define _FVAR(name, global, min, cur, max, persist) float global = fvariable(#name, min, cur, max, &global, nullptr, persist)
|
||||
#define FVARN(name, global, min, cur, max) _FVAR(name, global, min, cur, max, 0)
|
||||
#define FVARNP(name, global, min, cur, max) _FVAR(name, global, min, cur, max, IDF_PERSIST)
|
||||
#define FVARNR(name, global, min, cur, max) _FVAR(name, global, min, cur, max, IDF_OVERRIDE)
|
||||
|
@ -385,7 +385,7 @@ inline void ident::getcval(tagval &v) const
|
|||
#define FVARFNP(name, global, min, cur, max, body) _FVARF(name, global, min, cur, max, body, IDF_PERSIST)
|
||||
#define FVARFNR(name, global, min, cur, max, body) _FVARF(name, global, min, cur, max, body, IDF_OVERRIDE)
|
||||
|
||||
#define _SVAR(name, global, cur, persist) char *global = svariable(#name, cur, &global, NULL, persist)
|
||||
#define _SVAR(name, global, cur, persist) char *global = svariable(#name, cur, &global, nullptr, persist)
|
||||
#define SVARN(name, global, cur) _SVAR(name, global, cur, 0)
|
||||
#define SVARNP(name, global, cur) _SVAR(name, global, cur, IDF_PERSIST)
|
||||
#define SVARNR(name, global, cur) _SVAR(name, global, cur, IDF_OVERRIDE)
|
||||
|
|
|
@ -30,7 +30,7 @@ namespace gle
|
|||
int enabled = 0;
|
||||
static int numattribs = 0, attribmask = 0, numlastattribs = 0, lastattribmask = 0, vertexsize = 0, lastvertexsize = 0;
|
||||
static GLenum primtype = GL_TRIANGLES;
|
||||
static uchar *lastbuf = NULL;
|
||||
static uchar *lastbuf = nullptr;
|
||||
static bool changedattribs = false;
|
||||
static vector<GLint> multidrawstart;
|
||||
static vector<GLsizei> multidrawcount;
|
||||
|
@ -225,7 +225,7 @@ namespace gle
|
|||
len = min(len, MAXVBOSIZE);
|
||||
if(!vbo) glGenBuffers_(1, &vbo);
|
||||
glBindBuffer_(GL_ARRAY_BUFFER, vbo);
|
||||
glBufferData_(GL_ARRAY_BUFFER, MAXVBOSIZE, NULL, GL_STREAM_DRAW);
|
||||
glBufferData_(GL_ARRAY_BUFFER, MAXVBOSIZE, nullptr, GL_STREAM_DRAW);
|
||||
vbooffset = 0;
|
||||
}
|
||||
else if(!lastvertexsize) glBindBuffer_(GL_ARRAY_BUFFER, vbo);
|
||||
|
@ -266,11 +266,11 @@ namespace gle
|
|||
{
|
||||
if(!vbo) glGenBuffers_(1, &vbo);
|
||||
glBindBuffer_(GL_ARRAY_BUFFER, vbo);
|
||||
glBufferData_(GL_ARRAY_BUFFER, MAXVBOSIZE, NULL, GL_STREAM_DRAW);
|
||||
glBufferData_(GL_ARRAY_BUFFER, MAXVBOSIZE, nullptr, GL_STREAM_DRAW);
|
||||
vbooffset = 0;
|
||||
}
|
||||
else if(!lastvertexsize) glBindBuffer_(GL_ARRAY_BUFFER, vbo);
|
||||
void *dst = intel_mapbufferrange_bug ? NULL :
|
||||
void *dst = intel_mapbufferrange_bug ? nullptr :
|
||||
glMapBufferRange_(GL_ARRAY_BUFFER, vbooffset, attribbuf.length(), GL_MAP_WRITE_BIT|GL_MAP_INVALIDATE_RANGE_BIT|GL_MAP_UNSYNCHRONIZED_BIT);
|
||||
if(dst)
|
||||
{
|
||||
|
@ -317,7 +317,7 @@ namespace gle
|
|||
{
|
||||
for(int i = 0; enabled; i++) if(enabled&(1<<i)) { glDisableVertexAttribArray_(i); enabled &= ~(1<<i); }
|
||||
numlastattribs = lastattribmask = lastvertexsize = 0;
|
||||
lastbuf = NULL;
|
||||
lastbuf = nullptr;
|
||||
if(quadsenabled) disablequads();
|
||||
if(glversion >= 300) glBindBuffer_(GL_ARRAY_BUFFER, 0);
|
||||
}
|
||||
|
|
|
@ -61,7 +61,7 @@ namespace game
|
|||
extern void updateworld();
|
||||
extern void initclient();
|
||||
extern void physicstrigger(physent *d, bool local, int floorlevel, int waterlevel, int material = 0);
|
||||
extern void edittrigger(const selinfo &sel, int op, int arg1 = 0, int arg2 = 0, int arg3 = 0, const VSlot *vs = NULL);
|
||||
extern void edittrigger(const selinfo &sel, int op, int arg1 = 0, int arg2 = 0, int arg3 = 0, const VSlot *vs = nullptr);
|
||||
extern void vartrigger(ident *id);
|
||||
extern void dynentcollide(physent *d, physent *o, const vec &dir);
|
||||
extern const char *getclientmap();
|
||||
|
|
|
@ -281,7 +281,7 @@ char *path(char *s)
|
|||
curpart = file+1;
|
||||
}
|
||||
for(char *t = curpart; (t = strpbrk(t, "/\\")); *t++ = PATHDIV);
|
||||
for(char *prevdir = NULL, *curdir = curpart;;)
|
||||
for(char *prevdir = nullptr, *curdir = curpart;;)
|
||||
{
|
||||
prevdir = curdir[0]==PATHDIV ? curdir+1 : curdir;
|
||||
curdir = strchr(prevdir, PATHDIV);
|
||||
|
@ -352,7 +352,7 @@ bool createdir(const char *path)
|
|||
path = copystring(strip, path, len);
|
||||
}
|
||||
#ifdef WIN32
|
||||
return CreateDirectory(path, NULL)!=0;
|
||||
return CreateDirectory(path, nullptr)!=0;
|
||||
#else
|
||||
return mkdir(path, 0777)==0;
|
||||
#endif
|
||||
|
@ -379,7 +379,7 @@ bool subhomedir(char *dst, int len, const char *src)
|
|||
#ifdef WIN32
|
||||
char home[MAX_PATH+1];
|
||||
home[0] = '\0';
|
||||
if(SHGetFolderPath(NULL, CSIDL_PERSONAL, NULL, 0, home) != S_OK || !home[0]) return false;
|
||||
if(SHGetFolderPath(nullptr, CSIDL_PERSONAL, nullptr, 0, home) != S_OK || !home[0]) return false;
|
||||
#else
|
||||
const char *home = getenv("HOME");
|
||||
if(!home || !home[0]) return false;
|
||||
|
@ -395,7 +395,7 @@ const char *sethomedir(const char *dir)
|
|||
{
|
||||
string pdir;
|
||||
copystring(pdir, dir);
|
||||
if(!subhomedir(pdir, sizeof(pdir), dir) || !fixpackagedir(pdir)) return NULL;
|
||||
if(!subhomedir(pdir, sizeof(pdir), dir) || !fixpackagedir(pdir)) return nullptr;
|
||||
copystring(homedir, pdir);
|
||||
return homedir;
|
||||
}
|
||||
|
@ -404,7 +404,7 @@ const char *addpackagedir(const char *dir)
|
|||
{
|
||||
string pdir;
|
||||
copystring(pdir, dir);
|
||||
if(!subhomedir(pdir, sizeof(pdir), dir) || !fixpackagedir(pdir)) return NULL;
|
||||
if(!subhomedir(pdir, sizeof(pdir), dir) || !fixpackagedir(pdir)) return nullptr;
|
||||
char *filter = pdir;
|
||||
for(;;)
|
||||
{
|
||||
|
@ -417,7 +417,7 @@ const char *addpackagedir(const char *dir)
|
|||
packagedir &pf = packagedirs.add();
|
||||
pf.dir = filter ? newstring(pdir, filter-pdir) : newstring(pdir);
|
||||
pf.dirlen = filter ? filter-pdir : strlen(pdir);
|
||||
pf.filter = filter ? newstring(filter) : NULL;
|
||||
pf.filter = filter ? newstring(filter) : nullptr;
|
||||
pf.filterlen = filter ? strlen(filter) : 0;
|
||||
return pf.dir;
|
||||
}
|
||||
|
@ -452,7 +452,7 @@ const char *findfile(const char *filename, const char *mode)
|
|||
formatstring(s, "%s%s", pf.dir, filename);
|
||||
if(fileexists(s, mode)) return s;
|
||||
}
|
||||
if(mode[0]=='e') return NULL;
|
||||
if(mode[0]=='e') return nullptr;
|
||||
return filename;
|
||||
}
|
||||
|
||||
|
@ -487,7 +487,7 @@ bool listdir(const char *dirname, bool rel, const char *ext, vector<char *> &fil
|
|||
if(d)
|
||||
{
|
||||
struct dirent *de;
|
||||
while((de = readdir(d)) != NULL)
|
||||
while((de = readdir(d)) != nullptr)
|
||||
{
|
||||
if(!ext) files.add(newstring(de->d_name));
|
||||
else
|
||||
|
@ -565,7 +565,7 @@ static int rwopsclose(SDL_RWops *rw)
|
|||
SDL_RWops *stream::rwops()
|
||||
{
|
||||
SDL_RWops *rw = SDL_AllocRW();
|
||||
if(!rw) return NULL;
|
||||
if(!rw) return nullptr;
|
||||
rw->hidden.unknown.data1 = this;
|
||||
rw->seek = rwopsseek;
|
||||
rw->read = rwopsread;
|
||||
|
@ -628,14 +628,14 @@ struct filestream : stream
|
|||
{
|
||||
FILE *file;
|
||||
|
||||
filestream() : file(NULL) {}
|
||||
filestream() : file(nullptr) {}
|
||||
~filestream() { close(); }
|
||||
|
||||
bool open(const char *name, const char *mode)
|
||||
{
|
||||
if(file) return false;
|
||||
file = fopen(name, mode);
|
||||
return file!=NULL;
|
||||
return file!=nullptr;
|
||||
}
|
||||
|
||||
bool opentemp(const char *name, const char *mode)
|
||||
|
@ -646,12 +646,12 @@ struct filestream : stream
|
|||
#else
|
||||
file = tmpfile();
|
||||
#endif
|
||||
return file!=NULL;
|
||||
return file!=nullptr;
|
||||
}
|
||||
|
||||
void close()
|
||||
{
|
||||
if(file) { fclose(file); file = NULL; }
|
||||
if(file) { fclose(file); file = nullptr; }
|
||||
}
|
||||
|
||||
bool end() { return feof(file)!=0; }
|
||||
|
@ -687,7 +687,7 @@ struct filestream : stream
|
|||
bool flush() { return !fflush(file); }
|
||||
int getchar() { return fgetc(file); }
|
||||
bool putchar(int c) { return fputc(c, file)!=EOF; }
|
||||
bool getline(char *str, size_t len) { return fgets(str, len, file)!=NULL; }
|
||||
bool getline(char *str, size_t len) { return fgets(str, len, file)!=nullptr; }
|
||||
bool putstring(const char *str) { return fputs(str, file)!=EOF; }
|
||||
|
||||
size_t printf(const char *fmt, ...)
|
||||
|
@ -731,12 +731,12 @@ struct gzstream : stream
|
|||
uint crc;
|
||||
size_t headersize;
|
||||
|
||||
gzstream() : file(NULL), buf(NULL), reading(false), writing(false), autoclose(false), crc(0), headersize(0)
|
||||
gzstream() : file(nullptr), buf(nullptr), reading(false), writing(false), autoclose(false), crc(0), headersize(0)
|
||||
{
|
||||
zfile.zalloc = NULL;
|
||||
zfile.zfree = NULL;
|
||||
zfile.opaque = NULL;
|
||||
zfile.next_in = zfile.next_out = NULL;
|
||||
zfile.zalloc = nullptr;
|
||||
zfile.zfree = nullptr;
|
||||
zfile.opaque = nullptr;
|
||||
zfile.next_in = zfile.next_out = nullptr;
|
||||
zfile.avail_in = zfile.avail_out = 0;
|
||||
}
|
||||
|
||||
|
@ -816,7 +816,7 @@ struct gzstream : stream
|
|||
if(!reading && !writing) return false;
|
||||
|
||||
file = f;
|
||||
crc = crc32(0, NULL, 0);
|
||||
crc = crc32(0, nullptr, 0);
|
||||
buf = new uchar[BUFSIZE];
|
||||
|
||||
if(reading)
|
||||
|
@ -929,10 +929,10 @@ struct gzstream : stream
|
|||
else
|
||||
{
|
||||
zfile.avail_in = 0;
|
||||
zfile.next_in = NULL;
|
||||
zfile.next_in = nullptr;
|
||||
}
|
||||
inflateReset(&zfile);
|
||||
crc = crc32(0, NULL, 0);
|
||||
crc = crc32(0, nullptr, 0);
|
||||
}
|
||||
|
||||
uchar skip[512];
|
||||
|
@ -1009,7 +1009,7 @@ struct utf8stream : stream
|
|||
bool reading, writing, autoclose;
|
||||
uchar buf[BUFSIZE];
|
||||
|
||||
utf8stream() : file(NULL), pos(0), bufread(0), bufcarry(0), buflen(0), reading(false), writing(false), autoclose(false)
|
||||
utf8stream() : file(nullptr), pos(0), bufread(0), bufcarry(0), buflen(0), reading(false), writing(false), autoclose(false)
|
||||
{
|
||||
}
|
||||
|
||||
|
@ -1172,9 +1172,9 @@ struct utf8stream : stream
|
|||
stream *openrawfile(const char *filename, const char *mode)
|
||||
{
|
||||
const char *found = findfile(filename, mode);
|
||||
if(!found) return NULL;
|
||||
if(!found) return nullptr;
|
||||
filestream *file = new filestream;
|
||||
if(!file->open(found, mode)) { delete file; return NULL; }
|
||||
if(!file->open(found, mode)) { delete file; return nullptr; }
|
||||
return file;
|
||||
}
|
||||
|
||||
|
@ -1191,50 +1191,50 @@ stream *opentempfile(const char *name, const char *mode)
|
|||
{
|
||||
const char *found = findfile(name, mode);
|
||||
filestream *file = new filestream;
|
||||
if(!file->opentemp(found ? found : name, mode)) { delete file; return NULL; }
|
||||
if(!file->opentemp(found ? found : name, mode)) { delete file; return nullptr; }
|
||||
return file;
|
||||
}
|
||||
|
||||
stream *opengzfile(const char *filename, const char *mode, stream *file, int level)
|
||||
{
|
||||
stream *source = file ? file : openfile(filename, mode);
|
||||
if(!source) return NULL;
|
||||
if(!source) return nullptr;
|
||||
gzstream *gz = new gzstream;
|
||||
if(!gz->open(source, mode, !file, level)) { if(!file) delete source; delete gz; return NULL; }
|
||||
if(!gz->open(source, mode, !file, level)) { if(!file) delete source; delete gz; return nullptr; }
|
||||
return gz;
|
||||
}
|
||||
|
||||
stream *openutf8file(const char *filename, const char *mode, stream *file)
|
||||
{
|
||||
stream *source = file ? file : openfile(filename, mode);
|
||||
if(!source) return NULL;
|
||||
if(!source) return nullptr;
|
||||
utf8stream *utf8 = new utf8stream;
|
||||
if(!utf8->open(source, mode, !file)) { if(!file) delete source; delete utf8; return NULL; }
|
||||
if(!utf8->open(source, mode, !file)) { if(!file) delete source; delete utf8; return nullptr; }
|
||||
return utf8;
|
||||
}
|
||||
|
||||
char *loadfile(const char *fn, size_t *size, bool utf8)
|
||||
{
|
||||
stream *f = openfile(fn, "rb");
|
||||
if(!f) return NULL;
|
||||
if(!f) return nullptr;
|
||||
stream::offset fsize = f->size();
|
||||
if(fsize <= 0) { delete f; return NULL; }
|
||||
if(fsize <= 0) { delete f; return nullptr; }
|
||||
size_t len = fsize;
|
||||
char *buf = new (false) char[len+1];
|
||||
if(!buf) { delete f; return NULL; }
|
||||
if(!buf) { delete f; return nullptr; }
|
||||
size_t offset = 0;
|
||||
if(utf8 && len >= 3)
|
||||
{
|
||||
if(f->read(buf, 3) != 3) { delete f; delete[] buf; return NULL; }
|
||||
if(f->read(buf, 3) != 3) { delete f; delete[] buf; return nullptr; }
|
||||
if(((uchar *)buf)[0] == 0xEF && ((uchar *)buf)[1] == 0xBB && ((uchar *)buf)[2] == 0xBF) len -= 3;
|
||||
else offset += 3;
|
||||
}
|
||||
size_t rlen = f->read(&buf[offset], len-offset);
|
||||
delete f;
|
||||
if(rlen != len-offset) { delete[] buf; return NULL; }
|
||||
if(rlen != len-offset) { delete[] buf; return nullptr; }
|
||||
if(utf8) len = decodeutf8((uchar *)buf, len, (uchar *)buf, len);
|
||||
buf[len] = '\0';
|
||||
if(size!=NULL) *size = len;
|
||||
if(size!=nullptr) *size = len;
|
||||
return buf;
|
||||
}
|
||||
|
||||
|
|
|
@ -42,7 +42,7 @@ struct zipfile
|
|||
char *name;
|
||||
uint header, offset, size, compressedsize;
|
||||
|
||||
zipfile() : name(NULL), header(0), offset(~0U), size(0), compressedsize(0)
|
||||
zipfile() : name(nullptr), header(0), offset(~0U), size(0), compressedsize(0)
|
||||
{
|
||||
}
|
||||
~zipfile()
|
||||
|
@ -61,13 +61,13 @@ struct ziparchive
|
|||
int openfiles;
|
||||
zipstream *owner;
|
||||
|
||||
ziparchive() : name(NULL), data(NULL), files(512), openfiles(0), owner(NULL)
|
||||
ziparchive() : name(nullptr), data(nullptr), files(512), openfiles(0), owner(nullptr)
|
||||
{
|
||||
}
|
||||
~ziparchive()
|
||||
{
|
||||
DELETEA(name);
|
||||
if(data) { fclose(data); data = NULL; }
|
||||
if(data) { fclose(data); data = nullptr; }
|
||||
}
|
||||
};
|
||||
|
||||
|
@ -78,7 +78,7 @@ static bool findzipdirectory(FILE *f, zipdirectoryheader &hdr)
|
|||
long offset = ftell(f);
|
||||
if(offset < 0) return false;
|
||||
|
||||
uchar buf[1024], *src = NULL;
|
||||
uchar buf[1024], *src = nullptr;
|
||||
long end = max(offset - 0xFFFFL - ZIP_DIRECTORY_SIZE, 0L);
|
||||
size_t len = 0;
|
||||
const uint signature = lilswap<uint>(ZIP_DIRECTORY_SIGNATURE);
|
||||
|
@ -199,7 +199,7 @@ static vector<ziparchive *> archives;
|
|||
ziparchive *findzip(const char *name)
|
||||
{
|
||||
loopv(archives) if(!strcmp(name, archives[i]->name)) return archives[i];
|
||||
return NULL;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
static bool checkprefix(vector<zipfile> &files, const char *prefix, int prefixlen)
|
||||
|
@ -264,7 +264,7 @@ static void mountzip(ziparchive &arch, vector<zipfile> &files, const char *mount
|
|||
}
|
||||
}
|
||||
|
||||
bool addzip(const char *name, const char *mount = NULL, const char *strip = NULL)
|
||||
bool addzip(const char *name, const char *mount = nullptr, const char *strip = nullptr)
|
||||
{
|
||||
string pname;
|
||||
copystring(pname, name);
|
||||
|
@ -342,12 +342,12 @@ struct zipstream : stream
|
|||
uint reading;
|
||||
bool ended;
|
||||
|
||||
zipstream() : arch(NULL), info(NULL), buf(NULL), reading(~0U), ended(false)
|
||||
zipstream() : arch(nullptr), info(nullptr), buf(nullptr), reading(~0U), ended(false)
|
||||
{
|
||||
zfile.zalloc = NULL;
|
||||
zfile.zfree = NULL;
|
||||
zfile.opaque = NULL;
|
||||
zfile.next_in = zfile.next_out = NULL;
|
||||
zfile.zalloc = nullptr;
|
||||
zfile.zfree = nullptr;
|
||||
zfile.opaque = nullptr;
|
||||
zfile.next_in = zfile.next_out = nullptr;
|
||||
zfile.avail_in = zfile.avail_out = 0;
|
||||
}
|
||||
|
||||
|
@ -362,7 +362,7 @@ struct zipstream : stream
|
|||
size = min(size, uint(&buf[BUFSIZE] - &zfile.next_in[zfile.avail_in]));
|
||||
if(arch->owner != this)
|
||||
{
|
||||
arch->owner = NULL;
|
||||
arch->owner = nullptr;
|
||||
if(fseek(arch->data, reading, SEEK_SET) >= 0) arch->owner = this;
|
||||
else return;
|
||||
}
|
||||
|
@ -377,7 +377,7 @@ struct zipstream : stream
|
|||
if(f->offset == ~0U)
|
||||
{
|
||||
ziplocalfileheader h;
|
||||
a->owner = NULL;
|
||||
a->owner = nullptr;
|
||||
if(!readlocalfileheader(a->data, h, f->header)) return false;
|
||||
f->offset = f->header + ZIP_LOCAL_FILE_SIZE + h.namelength + h.extralength;
|
||||
}
|
||||
|
@ -407,7 +407,7 @@ struct zipstream : stream
|
|||
{
|
||||
stopreading();
|
||||
DELETEA(buf);
|
||||
if(arch) { arch->owner = NULL; arch->openfiles--; arch = NULL; }
|
||||
if(arch) { arch->owner = nullptr; arch->openfiles--; arch = nullptr; }
|
||||
}
|
||||
|
||||
offset size() { return info->size; }
|
||||
|
@ -427,7 +427,7 @@ struct zipstream : stream
|
|||
default: return false;
|
||||
}
|
||||
pos = clamp(pos, offset(info->offset), offset(info->offset + info->size));
|
||||
arch->owner = NULL;
|
||||
arch->owner = nullptr;
|
||||
if(fseek(arch->data, int(pos), SEEK_SET) < 0) return false;
|
||||
arch->owner = this;
|
||||
reading = pos;
|
||||
|
@ -450,7 +450,7 @@ struct zipstream : stream
|
|||
zfile.avail_in = 0;
|
||||
zfile.total_in = info->compressedsize;
|
||||
zfile.total_out = info->size;
|
||||
arch->owner = NULL;
|
||||
arch->owner = nullptr;
|
||||
ended = false;
|
||||
return true;
|
||||
}
|
||||
|
@ -466,9 +466,9 @@ struct zipstream : stream
|
|||
}
|
||||
else
|
||||
{
|
||||
arch->owner = NULL;
|
||||
arch->owner = nullptr;
|
||||
zfile.avail_in = 0;
|
||||
zfile.next_in = NULL;
|
||||
zfile.next_in = nullptr;
|
||||
reading = info->offset;
|
||||
}
|
||||
inflateReset(&zfile);
|
||||
|
@ -493,7 +493,7 @@ struct zipstream : stream
|
|||
{
|
||||
if(arch->owner != this)
|
||||
{
|
||||
arch->owner = NULL;
|
||||
arch->owner = nullptr;
|
||||
if(fseek(arch->data, reading, SEEK_SET) < 0) { stopreading(); return 0; }
|
||||
arch->owner = this;
|
||||
}
|
||||
|
@ -529,7 +529,7 @@ struct zipstream : stream
|
|||
|
||||
stream *openzipfile(const char *name, const char *mode)
|
||||
{
|
||||
for(; *mode; mode++) if(*mode=='w' || *mode=='a') return NULL;
|
||||
for(; *mode; mode++) if(*mode=='w' || *mode=='a') return nullptr;
|
||||
loopvrev(archives)
|
||||
{
|
||||
ziparchive *arch = archives[i];
|
||||
|
@ -539,7 +539,7 @@ stream *openzipfile(const char *name, const char *mode)
|
|||
if(s->open(arch, f)) return s;
|
||||
delete s;
|
||||
}
|
||||
return NULL;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
bool findzipfile(const char *name)
|
||||
|
@ -584,7 +584,7 @@ int listzipfiles(const char *dir, const char *ext, vector<char *> &files)
|
|||
}
|
||||
|
||||
#ifndef STANDALONE
|
||||
ICOMMAND(addzip, "sss", (const char *name, const char *mount, const char *strip), addzip(name, mount[0] ? mount : NULL, strip[0] ? strip : NULL));
|
||||
ICOMMAND(addzip, "sss", (const char *name, const char *mount, const char *strip), addzip(name, mount[0] ? mount : nullptr, strip[0] ? strip : nullptr));
|
||||
ICOMMAND(removezip, "s", (const char *name), removezip(name));
|
||||
#endif
|
||||
|
||||
|
|
Loading…
Reference in New Issue