Merge PR 'Apply default lightstyle to to lightmap when using q3bsp'

See https://github.com/DarkPlacesEngine/darkplaces/pull/111

Fixes https://github.com/DarkPlacesEngine/darkplaces/issues/100

Signed-off-by: bones_was_here <bones_was_here@xonotic.au>

diff --git a/README.md b/README.md
index 72e7b8d6fc1902c4d24044b9d60aa14ec46d1cdc..c67c8be42bb2794670776e0f3220278ffd9ad371 100644 (file)
--- a/README.md
+++ b/README.md
@@ -19,7 +19,8 @@ Developed by LadyHavoc. See [CREDITS](CREDITS.md) for a list of contributors.
 
 ### Required packages
 
-These names are for Debian, you may need to find equivalents for your platform.
+The minimum SDL version is 2.0.18 for Linux and 2.24.0 for Windows.  
+The following package names are for Debian, see below for Windows and Mac.
 
 ##### Client
 Build (mandatory): `build-essential` `libjpeg-dev` `libsdl2-dev`  
@@ -62,7 +63,7 @@ If you get errors (that don't seem to be about missing dependencies) try `make c
 
 ### Windows (Visual Studio)
 
-Instructions coming soon.
+Instructions TODO.
 
 ## Contributing
 

diff --git a/cmd.c b/cmd.c
index 125488bfd74184259377a95397590ef031e91312..0343dd10582c83393f448d21a1a4827f38ccffc3 100644 (file)
--- a/cmd.c
+++ b/cmd.c
@@ -266,16 +266,18 @@ void Cbuf_AddText (cmd_state_t *cmd, const char *text)
        cmd_buf_t *cbuf = cmd->cbuf;
        llist_t llist = {&llist, &llist};
 
-       Cbuf_Lock(cbuf);
-
-       if (cbuf->maxsize - cbuf->size <= l)
-               Con_Print(CON_WARN "Cbuf_AddText: overflow\n");
-       else
+       if (cbuf->size + l > cbuf->maxsize)
        {
-               // If the string terminates but the (last) line doesn't, the node will be left in the pending state (to be continued).
-               Cbuf_ParseText(cmd, &llist, (List_Is_Empty(&cbuf->start) ? NULL : List_Entry(cbuf->start.prev, cmd_input_t, list)), text, true);
-               List_Splice_Tail(&llist, &cbuf->start);
+               Con_Printf(CON_WARN "Cbuf_AddText: input too large, %zuKB ought to be enough for anybody.\n", cbuf->maxsize / 1024);
+               return;
        }
+
+       Cbuf_Lock(cbuf);
+
+       // If the string terminates but the (last) line doesn't, the node will be left in the pending state (to be continued).
+       Cbuf_ParseText(cmd, &llist, (List_Is_Empty(&cbuf->start) ? NULL : List_Entry(cbuf->start.prev, cmd_input_t, list)), text, true);
+       List_Splice_Tail(&llist, &cbuf->start);
+
        Cbuf_Unlock(cbuf);
 }
 
@@ -292,19 +294,20 @@ void Cbuf_InsertText (cmd_state_t *cmd, const char *text)
        llist_t llist = {&llist, &llist};
        size_t l = strlen(text);
 
-       Cbuf_Lock(cbuf);
-
-       if (cbuf->size + l >= cbuf->maxsize)
-               Con_Print(CON_WARN "Cbuf_InsertText: overflow\n");
-       else
+       if (cbuf->size + l > cbuf->maxsize)
        {
-               // bones_was_here assertion: when prepending to the buffer it never makes sense to leave node(s) in the `pending` state,
-               // it would have been impossible to append to such text later in the old raw text buffer,
-               // and allowing it causes bugs when .cfg files lack \n at EOF (see: https://gitlab.com/xonotic/darkplaces/-/issues/378).
-               Cbuf_ParseText(cmd, &llist, (List_Is_Empty(&cbuf->start) ? NULL : List_Entry(cbuf->start.next, cmd_input_t, list)), text, false);
-               List_Splice(&llist, &cbuf->start);
+               Con_Printf(CON_WARN "Cbuf_InsertText: input too large, %zuKB ought to be enough for anybody.\n", cbuf->maxsize / 1024);
+               return;
        }
 
+       Cbuf_Lock(cbuf);
+
+       // bones_was_here assertion: when prepending to the buffer it never makes sense to leave node(s) in the `pending` state,
+       // it would have been impossible to append to such text later in the old raw text buffer,
+       // and allowing it causes bugs when .cfg files lack \n at EOF (see: https://gitlab.com/xonotic/darkplaces/-/issues/378).
+       Cbuf_ParseText(cmd, &llist, (List_Is_Empty(&cbuf->start) ? NULL : List_Entry(cbuf->start.next, cmd_input_t, list)), text, false);
+       List_Splice(&llist, &cbuf->start);
+
        Cbuf_Unlock(cbuf);
 }
 
@@ -321,7 +324,7 @@ static void Cbuf_Execute_Deferred (cmd_buf_t *cbuf)
        if (host.realtime - cbuf->deferred_oldtime < 0 || host.realtime - cbuf->deferred_oldtime > 1800)
                cbuf->deferred_oldtime = host.realtime;
        eat = host.realtime - cbuf->deferred_oldtime;
-       if (eat < 1/128)
+       if (eat < 1.0/128.0)
                return;
        cbuf->deferred_oldtime = host.realtime;
 

diff --git a/cvar.c b/cvar.c
index 83bf6f529c1b3d629a776d5c9baf36ed489ab487..3008bb2088bba4d056f38c5ac48b92094e6fe078 100644 (file)
--- a/cvar.c
+++ b/cvar.c
@@ -33,9 +33,9 @@ cvar_state_t cvars_null;
 Cvar_FindVar
 ============
 */
-cvar_t *Cvar_FindVar(cvar_state_t *cvars, const char *var_name, int neededflags)
+cvar_t *Cvar_FindVar(cvar_state_t *cvars, const char *var_name, unsigned neededflags)
 {
-       int hashindex;
+       unsigned hashindex;
        cvar_hash_t *hash;
 
        // use hash lookup to minimize search time
@@ -50,7 +50,7 @@ cvar_t *Cvar_FindVar(cvar_state_t *cvars, const char *var_name, int neededflags)
        return NULL;
 }
 
-cvar_t *Cvar_FindVarAfter(cvar_state_t *cvars, const char *prev_var_name, int neededflags)
+cvar_t *Cvar_FindVarAfter(cvar_state_t *cvars, const char *prev_var_name, unsigned neededflags)
 {
        cvar_t *var;
 
@@ -74,37 +74,44 @@ cvar_t *Cvar_FindVarAfter(cvar_state_t *cvars, const char *prev_var_name, int ne
        return var;
 }
 
-static cvar_t *Cvar_FindVarLink(cvar_state_t *cvars, const char *var_name, cvar_t **parent, cvar_t ***link, cvar_t **prev_alpha, int neededflags)
+/**
+ * Returns a pointer to the pointer stored in hashtable[] (or the one it links to)
+ * because we'll need to update that when deleting a cvar as other cvar(s) may share its hashindex.
+ */
+static cvar_hash_t **Cvar_FindVarLink(cvar_state_t *cvars, const char *var_name, cvar_t **parent, cvar_t ***link, cvar_t **prev_alpha, unsigned neededflags)
 {
-       int hashindex;
-       cvar_hash_t *hash;
+       unsigned hashindex;
+       cvar_t *cvar;
+       cvar_hash_t **hashlinkptr;
 
        // use hash lookup to minimize search time
        hashindex = CRC_Block((const unsigned char *)var_name, strlen(var_name)) % CVAR_HASHSIZE;
        if(parent) *parent = NULL;
        if(prev_alpha) *prev_alpha = NULL;
        if(link) *link = &cvars->hashtable[hashindex]->cvar;
-       for (hash = cvars->hashtable[hashindex];hash;hash = hash->next)
+       hashlinkptr = &cvars->hashtable[hashindex];
+       for (hashlinkptr = &cvars->hashtable[hashindex]; *hashlinkptr; hashlinkptr = &(*hashlinkptr)->next)
        {
-               if (!strcmp (var_name, hash->cvar->name) && (hash->cvar->flags & neededflags))
+               cvar = (*hashlinkptr)->cvar;
+               if (!strcmp (var_name, cvar->name) && (cvar->flags & neededflags))
                        goto match;
                else
-                       for (char **alias = hash->cvar->aliases; alias && *alias; alias++)
-                               if (!strcmp (var_name, *alias) && (hash->cvar->flags & neededflags))
+                       for (char **alias = cvar->aliases; alias && *alias; alias++)
+                               if (!strcmp (var_name, *alias) && (cvar->flags & neededflags))
                                        goto match;
-               if(parent) *parent = hash->cvar;
+               if(parent) *parent = cvar;
        }
        return NULL;
 match:
-       if(!prev_alpha || hash->cvar == cvars->vars)
-               return hash->cvar;
+       if(!prev_alpha || cvar == cvars->vars)
+               return hashlinkptr;
 
        *prev_alpha = cvars->vars;
        // if prev_alpha happens to become NULL then there has been some inconsistency elsewhere
        // already - should I still insert '*prev_alpha &&' in the loop?
-       while((*prev_alpha)->next != hash->cvar)
+       while((*prev_alpha)->next != cvar)
                *prev_alpha = (*prev_alpha)->next;
-       return hash->cvar;
+       return hashlinkptr;
 }
 
 /*
@@ -112,7 +119,7 @@ match:
 Cvar_VariableValue
 ============
 */
-float Cvar_VariableValueOr(cvar_state_t *cvars, const char *var_name, float def, int neededflags)
+float Cvar_VariableValueOr(cvar_state_t *cvars, const char *var_name, float def, unsigned neededflags)
 {
        cvar_t *var;
 
@@ -122,7 +129,7 @@ float Cvar_VariableValueOr(cvar_state_t *cvars, const char *var_name, float def,
        return atof (var->string);
 }
 
-float Cvar_VariableValue(cvar_state_t *cvars, const char *var_name, int neededflags)
+float Cvar_VariableValue(cvar_state_t *cvars, const char *var_name, unsigned neededflags)
 {
        return Cvar_VariableValueOr(cvars, var_name, 0, neededflags);
 }
@@ -132,7 +139,7 @@ float Cvar_VariableValue(cvar_state_t *cvars, const char *var_name, int neededfl
 Cvar_VariableString
 ============
 */
-const char *Cvar_VariableStringOr(cvar_state_t *cvars, const char *var_name, const char *def, int neededflags)
+const char *Cvar_VariableStringOr(cvar_state_t *cvars, const char *var_name, const char *def, unsigned neededflags)
 {
        cvar_t *var;
 
@@ -142,7 +149,7 @@ const char *Cvar_VariableStringOr(cvar_state_t *cvars, const char *var_name, con
        return var->string;
 }
 
-const char *Cvar_VariableString(cvar_state_t *cvars, const char *var_name, int neededflags)
+const char *Cvar_VariableString(cvar_state_t *cvars, const char *var_name, unsigned neededflags)
 {
        return Cvar_VariableStringOr(cvars, var_name, cvar_null_string, neededflags);
 }
@@ -152,7 +159,7 @@ const char *Cvar_VariableString(cvar_state_t *cvars, const char *var_name, int n
 Cvar_VariableDefString
 ============
 */
-const char *Cvar_VariableDefString(cvar_state_t *cvars, const char *var_name, int neededflags)
+const char *Cvar_VariableDefString(cvar_state_t *cvars, const char *var_name, unsigned neededflags)
 {
        cvar_t *var;
 
@@ -167,7 +174,7 @@ const char *Cvar_VariableDefString(cvar_state_t *cvars, const char *var_name, in
 Cvar_VariableDescription
 ============
 */
-const char *Cvar_VariableDescription(cvar_state_t *cvars, const char *var_name, int neededflags)
+const char *Cvar_VariableDescription(cvar_state_t *cvars, const char *var_name, unsigned neededflags)
 {
        cvar_t *var;
 
@@ -183,7 +190,7 @@ const char *Cvar_VariableDescription(cvar_state_t *cvars, const char *var_name,
 Cvar_CompleteVariable
 ============
 */
-const char *Cvar_CompleteVariable(cvar_state_t *cvars, const char *partial, int neededflags)
+const char *Cvar_CompleteVariable(cvar_state_t *cvars, const char *partial, unsigned neededflags)
 {
        cvar_t          *cvar;
        size_t          len;
@@ -210,7 +217,7 @@ const char *Cvar_CompleteVariable(cvar_state_t *cvars, const char *partial, int
        Thanks to Fett erich@heintz.com
 
 */
-int Cvar_CompleteCountPossible(cvar_state_t *cvars, const char *partial, int neededflags)
+int Cvar_CompleteCountPossible(cvar_state_t *cvars, const char *partial, unsigned neededflags)
 {
        cvar_t  *cvar;
        size_t  len;
@@ -243,7 +250,7 @@ int Cvar_CompleteCountPossible(cvar_state_t *cvars, const char *partial, int nee
        Thanks to taniwha
 
 */
-const char **Cvar_CompleteBuildList(cvar_state_t *cvars, const char *partial, int neededflags)
+const char **Cvar_CompleteBuildList(cvar_state_t *cvars, const char *partial, unsigned neededflags)
 {
        const cvar_t *cvar;
        size_t len = 0;
@@ -281,7 +288,7 @@ void Cvar_PrintHelp(cvar_t *cvar, const char *name, qbool full)
 }
 
 // written by LadyHavoc
-void Cvar_CompleteCvarPrint(cvar_state_t *cvars, const char *partial, int neededflags)
+void Cvar_CompleteCvarPrint(cvar_state_t *cvars, const char *partial, unsigned neededflags)
 {
        cvar_t *cvar;
        size_t len = strlen(partial);
@@ -509,7 +516,7 @@ void Cvar_RegisterVirtual(cvar_t *variable, const char *name )
 {
        cvar_state_t *cvars = &cvars_all;
        cvar_hash_t *hash;
-       int hashindex;
+       unsigned hashindex;
 
        if (!(variable->flags & cmd_local->cvars_flagsmask))
        {
@@ -563,7 +570,7 @@ static void Cvar_Link(cvar_t *variable, cvar_state_t *cvars)
 {
        cvar_t *current, *next;
        cvar_hash_t *hash;
-       int hashindex;
+       unsigned hashindex;
        /*
         * Link the variable in
         * alphanumerical order
@@ -847,7 +854,7 @@ void Cvar_SaveInitState(cvar_state_t *cvars)
 
 void Cvar_RestoreInitState(cvar_state_t *cvars)
 {
-       int hashindex;
+       unsigned hashindex;
        cvar_t *c, **cp;
        cvar_t *c2, **cp2;
        for (cp = &cvars->vars;(c = *cp);)
@@ -1095,10 +1102,10 @@ void Cvar_SetA_f(cmd_state_t *cmd)
 void Cvar_Del_f(cmd_state_t *cmd)
 {
        cvar_state_t *cvars = cmd->cvars;
-       int neededflags = ~0;
        int i;
        cvar_t *parent, **link;
        cvar_t *cvar, *prev;
+       cvar_hash_t **hashlinkptr, *oldhashlink;
 
        if(Cmd_Argc(cmd) < 2)
        {
@@ -1107,20 +1114,23 @@ void Cvar_Del_f(cmd_state_t *cmd)
        }
        for(i = 1; i < Cmd_Argc(cmd); ++i)
        {
-               cvar = Cvar_FindVarLink(cvars, Cmd_Argv(cmd, i), &parent, &link, &prev, neededflags);
+               hashlinkptr = Cvar_FindVarLink(cvars, Cmd_Argv(cmd, i), &parent, &link, &prev, ~0);
 
-               if(!cvar)
+               if(!hashlinkptr)
                {
                        Con_Printf("%s: %s is not defined\n", Cmd_Argv(cmd, 0), Cmd_Argv(cmd, i));
                        continue;
                }
+               cvar = (*hashlinkptr)->cvar;
+
                if(Cvar_Readonly(cvar, Cmd_Argv(cmd, 0)))
                        continue;
                if(!(cvar->flags & CF_ALLOCATED))
                {
-                       Con_Printf("%s: %s is static and cannot be deleted\n", Cmd_Argv(cmd, 0), cvar->name);
+                       Con_Printf(CON_WARN "%s: %s is static and cannot be deleted\n", Cmd_Argv(cmd, 0), cvar->name);
                        continue;
                }
+
                if(cvar == cvars->vars)
                {
                        cvars->vars = cvar->next;
@@ -1143,6 +1153,10 @@ void Cvar_Del_f(cmd_state_t *cmd)
                Z_Free((char *)cvar->string);
                Z_Free((char *)cvar->defstring);
                Z_Free(cvar);
+
+               oldhashlink = *hashlinkptr;
+               *hashlinkptr = (*hashlinkptr)->next;
+               Z_Free(oldhashlink);
        }
 }
 

diff --git a/cvar.h b/cvar.h
index 92ea81cdc54ee26ce172ce63e5ee429cb8d235b9..709bc6aaf7a296fb49493128c401eed34995d057 100644 (file)
--- a/cvar.h
+++ b/cvar.h
@@ -64,7 +64,7 @@ struct qfile_s;
 
 typedef struct cvar_s
 {
-       int flags;
+       unsigned flags;
 
        const char *name;
 
@@ -126,31 +126,31 @@ void Cvar_SetValue (cvar_state_t *cvars, const char *var_name, float value);
 void Cvar_SetQuick (cvar_t *var, const char *value);
 void Cvar_SetValueQuick (cvar_t *var, float value);
 
-float Cvar_VariableValueOr (cvar_state_t *cvars, const char *var_name, float def, int neededflags);
+float Cvar_VariableValueOr (cvar_state_t *cvars, const char *var_name, float def, unsigned neededflags);
 // returns def if not defined
 
-float Cvar_VariableValue (cvar_state_t *cvars, const char *var_name, int neededflags);
+float Cvar_VariableValue (cvar_state_t *cvars, const char *var_name, unsigned neededflags);
 // returns 0 if not defined or non numeric
 
-const char *Cvar_VariableStringOr (cvar_state_t *cvars, const char *var_name, const char *def, int neededflags);
+const char *Cvar_VariableStringOr (cvar_state_t *cvars, const char *var_name, const char *def, unsigned neededflags);
 // returns def if not defined
 
-const char *Cvar_VariableString (cvar_state_t *cvars, const char *var_name, int neededflags);
+const char *Cvar_VariableString (cvar_state_t *cvars, const char *var_name, unsigned neededflags);
 // returns an empty string if not defined
 
-const char *Cvar_VariableDefString (cvar_state_t *cvars, const char *var_name, int neededflags);
+const char *Cvar_VariableDefString (cvar_state_t *cvars, const char *var_name, unsigned neededflags);
 // returns an empty string if not defined
 
-const char *Cvar_VariableDescription (cvar_state_t *cvars, const char *var_name, int neededflags);
+const char *Cvar_VariableDescription (cvar_state_t *cvars, const char *var_name, unsigned neededflags);
 // returns an empty string if not defined
 
-const char *Cvar_CompleteVariable (cvar_state_t *cvars, const char *partial, int neededflags);
+const char *Cvar_CompleteVariable (cvar_state_t *cvars, const char *partial, unsigned neededflags);
 // attempts to match a partial variable name for command line completion
 // returns NULL if nothing fits
 
 void Cvar_PrintHelp(cvar_t *cvar, const char *name, qbool full);
 
-void Cvar_CompleteCvarPrint (cvar_state_t *cvars, const char *partial, int neededflags);
+void Cvar_CompleteCvarPrint (cvar_state_t *cvars, const char *partial, unsigned neededflags);
 
 qbool Cvar_Command (struct cmd_state_s *cmd);
 // called by Cmd_ExecuteString when Cmd_Argv(cmd, 0) doesn't match a known
@@ -170,11 +170,11 @@ void Cvar_WriteVariables (cvar_state_t *cvars, struct qfile_s *f);
 // Writes lines containing "set variable value" for all variables
 // with the archive flag set to true.
 
-cvar_t *Cvar_FindVar(cvar_state_t *cvars, const char *var_name, int neededflags);
-cvar_t *Cvar_FindVarAfter(cvar_state_t *cvars, const char *prev_var_name, int neededflags);
+cvar_t *Cvar_FindVar(cvar_state_t *cvars, const char *var_name, unsigned neededflags);
+cvar_t *Cvar_FindVarAfter(cvar_state_t *cvars, const char *prev_var_name, unsigned neededflags);
 
-int Cvar_CompleteCountPossible(cvar_state_t *cvars, const char *partial, int neededflags);
-const char **Cvar_CompleteBuildList(cvar_state_t *cvars, const char *partial, int neededflags);
+int Cvar_CompleteCountPossible(cvar_state_t *cvars, const char *partial, unsigned neededflags);
+const char **Cvar_CompleteBuildList(cvar_state_t *cvars, const char *partial, unsigned neededflags);
 // Added by EvilTypeGuy - functions for tab completion system
 // Thanks to Fett erich@heintz.com
 // Thanks to taniwha