Merge remote-tracking branch 'Paril/sin_support' into sin_support_ericw

Author: ericwa

bsputil/bsputil.cc

@@ -74,7 +74,7 @@ bsputil_settings::bsputil_settings()
           [&](const std::string &name, parser_base_t &parser, settings::source src) {
               return this->load_setting<settings::setting_bool>(name, parser, src, "");
           },
-          nullptr, "Extract BSP texutres to the given wad file"},
+          nullptr, "Extract BSP textures to the given wad file"},
       replace_textures{this, "replace-textures",
           [&](const std::string &name, parser_base_t &parser, settings::source src) {
               return this->load_setting<settings::setting_string>(name, parser, src, "");
@@ -131,11 +131,7 @@ bsputil_settings::bsputil_settings()
               return this->load_setting(name, src);
           },
           nullptr, "Decompile to the given .map file"},
-      sin_anims{this, "sin_anims",
-          [&](const std::string &name, parser_base_t &parser, settings::source src) {
-              return this->load_setting(name, src);
-          },
-          nullptr, "Use for decompiling; creates a .srf file for a decompiled map for animations"},
+      decompile_suffix{this, "decompile-suffix", ".decompile", "\"str\"", nullptr, "Suffix to add to decompiled map name"},
       decompile_geomonly{this, "decompile-geomonly",
           [&](const std::string &name, parser_base_t &parser, settings::source src) {
               return this->load_setting(name, src);
@@ -1539,59 +1535,75 @@ int bsputil_main(int _argc, const char **_argv)
 
             // generate output filename
             if (hull) {
-                source.replace_extension(fmt::format(".decompile.hull{}.map", hullnum));
+                source.replace_extension(fmt::format("{}.hull{}.map", bsputil_options.decompile_suffix.value(), hullnum));
             } else {
-                source.replace_extension(".decompile.map");
+                source.replace_extension(fmt::format("{}.map", bsputil_options.decompile_suffix.value()));
             }
 
-            logging::print("-> writing {}...\n", source);
-
-            std::ofstream f(source);
-
-            if (!f)
-                Error("couldn't open {} for writing\n", source);
-
-            mbsp_t &bsp = std::get<mbsp_t>(bspdata.bsp);
-
             decomp_options options;
             options.geometryOnly = geomOnly;
             options.ignoreBrushes = ignoreBrushes;
             options.hullnum = hullnum;
 
-            DecompileBSP(&bsp, options, f);
+            if (bspdata.loadversion->game->id == GAME_SIN) {
+                source.replace_extension(".srf");
 
-            f.close();
+                logging::print("-> writing surface file {}...\n", source);
 
-            if (!f)
-                Error("{}", strerror(errno));
-        }else if (operation->primary_name() == "sin_anims") {
-            source.replace_extension(".srf");
+                std::ofstream f;
 
-            logging::print("-> writing {}...\n", source);
+                mbsp_t &bsp = std::get<mbsp_t>(bspdata.bsp);
 
-            std::ofstream f(source);
+                std::map<std::string_view, std::string_view, natural_case_insensitive_less> written;
 
-            if (!f)
-                Error("couldn't open {} for writing\n", source);
+                for (auto &tex : bsp.texinfo) {
+                    if (tex.nexttexinfo != -1) {
+                        auto &next = bsp.texinfo[tex.nexttexinfo];
 
-            mbsp_t &bsp = std::get<mbsp_t>(bspdata.bsp);
+                        if (auto exists = written.find(tex.texturename); exists != written.end()) {
+                            if (!string_iequals(next.texturename, exists->second)) {
+                                logging::print("WARNING: animation for {} is specified twice but doesn't lead to {}, leads to {} instead\n", tex.texturename, exists->second, next.texturename);
+                                continue;
+                            } else {
+                                // already written
+                                continue;
+                            }
+                        }
 
-            std::set<std::string_view, natural_less> written;
+                        if (options.sin_srfName.empty()) {
+                            options.sin_srfName = fs::path(source.filename()).generic_string();
+                            f.open(source);
 
-            for (auto &tex : bsp.texinfo) {
-                if (written.find(tex.texturename) != written.end()) {
-                    continue;
+                            if (!f)
+                                Error("couldn't open {} for writing\n", source);
+                        }
+
+                        f << tex.texturename << " date 0 anim " << next.texturename << std::endl;
+                        written.insert(std::make_pair(tex.texturename, next.texturename));
+                    }
                 }
 
-                if (tex.nexttexinfo != -1) {
-                    auto &next = bsp.texinfo[tex.nexttexinfo];
+                if (!options.sin_srfName.empty()) {
+                    f.close();
 
-                    f << tex.texturename << " date 0 anim " << next.texturename << std::endl;
+                    if (!f)
+                        Error("{}", strerror(errno));
                 }
 
-                written.insert(tex.texturename);
+                source.replace_extension(".map");
             }
 
+            logging::print("-> writing {}...\n", source);
+
+            std::ofstream f(source);
+
+            if (!f)
+                Error("couldn't open {} for writing\n", source);
+
+            mbsp_t &bsp = std::get<mbsp_t>(bspdata.bsp);
+
+            DecompileBSP(&bsp, options, f);
+
             f.close();
 
             if (!f)

common/bspfile.cc

@@ -1397,10 +1397,11 @@ struct gamedef_sin_t : public gamedef_t
                     basedir = gamedir.parent_path() / default_base_dir;
                 }
             }
-
+            
+            std::error_code ec;
             if (!exists(basedir)) {
                 logging::print("WARNING: failed to find basedir '{}'\n", basedir);
-            } else if (!exists(gamedir) || !equivalent(gamedir, basedir)) {
+            } else if (!exists(gamedir) || !equivalent(gamedir, basedir, ec)) {
                 addArchive(basedir);
                 logging::print("using basedir: '{}'\n", basedir);
             }

common/decompile.cc

@@ -243,7 +243,6 @@ struct compiled_brush_t
                 if (side.lightinfo.directangle) {
                     ewt::print(stream, " directangle {}", side.lightinfo.directangle);
                 }
-                // nb: directstyle is unused
                 if (side.translucence) {
                     ewt::print(stream, " translucence {}", side.translucence);
                 }
@@ -263,7 +262,10 @@ struct compiled_brush_t
                     ewt::print(stream, " nonlitvalue {}", side.nonlit);
                 }
                 // nb: groupname is copied to directstyle by qbsp3, they should be identical
-                // but they might not be in the case of consoles
+                // but they might not be in the case of consoles.
+                // the original lightinfo directstyle is only really used for
+                // the controllable lights *or* setting a lightstyle on a surface as an integer
+                // but the latter should just work:tm:
                 if (side.lightinfo.directstylename[0]) {
                     ewt::print(stream, " directstyle \"{}\"", side.lightinfo.directstylename.data());
                 } else if (side.groupname[0]) {
@@ -943,7 +945,19 @@ static std::vector<compiled_brush_t> DecompileLeafTaskGeometryOnly(
     compiled_brush_t brush;
     brush.source = task.brush;
     brush.brush_offset = brush_offset;
-    brush.contents = bsp->loadversion->game->create_contents_from_native(task.brush  ? task.brush->contents
+
+    int native_contents = task.brush->contents;
+
+    if (bsp->loadversion->game->id == GAME_SIN) {
+        // SiN cleanup
+        if (native_contents & SIN_CONTENTS_DUMMYFENCE) {
+            native_contents &= ~SIN_CONTENTS_DUMMYFENCE;
+            native_contents &= ~SIN_CONTENTS_WINDOW;
+            native_contents |= SIN_CONTENTS_FENCE;
+        }
+    }
+
+    brush.contents = bsp->loadversion->game->create_contents_from_native(task.brush  ? native_contents
                                                                          : task.leaf ? task.leaf->contents
                                                                                      : task.contents.value());
 
@@ -1005,7 +1019,19 @@ static std::vector<compiled_brush_t> DecompileLeafTask(const mbsp_t *bsp, const
         compiled_brush_t brush;
         brush.source = task.brush;
         brush.brush_offset = brush_offset;
-        brush.contents = bsp->loadversion->game->create_contents_from_native(task.brush  ? task.brush->contents
+
+        int native_contents = task.brush->contents;
+
+        if (bsp->loadversion->game->id == GAME_SIN) {
+            // SiN cleanup
+            if (native_contents & SIN_CONTENTS_DUMMYFENCE) {
+                native_contents &= ~SIN_CONTENTS_DUMMYFENCE;
+                native_contents &= ~SIN_CONTENTS_WINDOW;
+                native_contents |= SIN_CONTENTS_FENCE;
+            }
+        }
+
+        brush.contents = bsp->loadversion->game->create_contents_from_native(task.brush  ? native_contents
                                                                              : task.leaf ? task.leaf->contents
                                                                                          : task.contents.value());
 
@@ -1264,12 +1290,20 @@ static std::vector<compiled_brush_t> DecompileBrushTask(const mbsp_t *bsp, const
 #include "common/parser.hh"
 
 static void DecompileEntity(
-    const mbsp_t *bsp, const decomp_options &options, std::ofstream &file, entdict_t &dict, bool isWorld)
+    const mbsp_t *bsp, const decomp_options &options, std::ofstream &file, std::vector<entdict_t> &dicts, int entityNum)
 {
+    auto &dict = dicts[entityNum];
+
     // we use -1 to indicate it's not a brush model
     int modelNum = -1;
-    if (isWorld) {
+    if (entityNum == 0) {
         modelNum = 0;
+
+        dict.remove(std::string_view{"surfacefile"});
+
+        if (!options.sin_srfName.empty()) {
+            dict.set(std::string_view{"surfacefile"}, options.sin_srfName);
+        }
     }
 
     const dbrush_t *areaportal_brush = nullptr;
@@ -1304,7 +1338,76 @@ static void DecompileEntity(
         return;
     }
 
+    // in SiN, custom light styles can be set on certain entities
+    // to be controlled by scripts (basically just `trigger_SetLightStyle`). These are set on the entity as a string "style",
+    // which is converted to a style ID on compilation and then the directstyle lightinfo
+    // value is set with the equivalent value.
+    // To reverse this, find entities with the integral style key, then scan all of
+    // the lightinfo in the map to find the matching directstyle ID and write its
+    // name here instead.
+    if (bsp->loadversion->game->id == GAME_SIN && dict.has("style")) {
+        if (dict.find("classname")->second != "func_areaportal" &&
+            !dict.find("classname")->second.starts_with("light")) {
+            int styleId = dict.get_int("style");
+            
+            if (styleId >= 32) {
+                dict.remove("style");
+                
+                std::string face_style;
+                std::string targetname_style;
+
+                // find matching face style
+                for (auto &lightinfo : bsp->dlightinfo) {
+                    if (lightinfo.directstyle == styleId) {
+                        // found it; set the style ID.
+                        // we don't have to unset the `directstyle` since we don't
+                        // bother writing it.
+                        face_style = lightinfo.directstylename.data();
+                        break;
+                    }
+                }
+
+                // find matching light style
+                for (auto &ent : dicts) {
+                    if (!ent.has("classname") || !ent.get("classname").starts_with("light"))
+                        continue;
+
+                    if (ent.has("style") && ent.get_int("style") == styleId) {
+                        std::string targetname = ent.get("targetname");
+
+                        if (!targetname_style.empty() && targetname_style != targetname) {
+                            logging::print("WARNING: lightstyle @ {} has conflicting light targetname/style\n{} resolved to both {} and {}\n", dict.get("origin"), styleId, targetname_style, targetname);
+                        } else {
+                            targetname_style = targetname;
+                        }
+                    }
+                }
+
+                if (face_style.empty() && targetname_style.empty()) {
+                    logging::print("WARNING: light style {} @ {} exists on an entity but no matching directstyle lightinfo or light targetname was found\n", styleId, dict.get("origin"));
+                } else if (!face_style.empty() && !targetname_style.empty() &&
+                    face_style != targetname_style) {
+                    logging::print("WARNING: light style {} @ {} exists on an entity, and both a matching lightinfo ({}) and light targetname ({}) was found. We can't figure out which one was intended.\n", styleId, dict.get("origin"), face_style, targetname_style);
+                } else if (!face_style.empty()) {
+                    logging::print("Remapped light style {} @ {} to {}\n", styleId, dict.get("origin"), face_style);
+                    dict.set("style", face_style);
+                } else {
+                    logging::print("Remapped light style {} @ {} to {}\n", styleId, dict.get("origin"), targetname_style);
+                    dict.set("style", targetname_style);
+                }
+            }
+        } else if (dict.find("classname")->second.starts_with("light")) {
+            // remove controllable style IDs from lights just in case
+            int styleId = dict.get_int("style");
+
+            if (styleId >= 32) {
+                dict.remove("style");
+            }
+        }
+    }
+
     // First, print the key/values for this entity
+    ewt::print(file, "// entity {}\n", entityNum);
     ewt::print(file, "{{\n");
     for (const auto &keyValue : dict) {
         if (keyValue.first == "model" && !keyValue.second.empty() && keyValue.second[0] == '*') {
@@ -1549,15 +1652,16 @@ static void DecompileEntity(
     }
 
     ewt::print(file, "}}\n");
+    if (modelNum != -1)
+        ewt::print(file, "// was brush model {}\n", modelNum);
 }
 
 void DecompileBSP(const mbsp_t *bsp, const decomp_options &options, std::ofstream &file)
 {
     auto entdicts = EntData_Parse(*bsp);
 
     for (size_t i = 0; i < entdicts.size(); ++i) {
-        // entity 0 is implicitly worldspawn (model 0)
-        DecompileEntity(bsp, options, file, entdicts[i], i == 0);
+        DecompileEntity(bsp, options, file, entdicts, i);
     }
 }
 

common/entdata.cc

@@ -161,6 +161,11 @@ void entdict_t::parse(parser_base_t &parser)
 
         std::string keystr = parser.token;
 
+        if (keystr == "surfacefile" ||
+            keystr == "menufile") {
+            parser.ignore_escapes = true;
+        }
+
         /* parse value */
         if (!parser.parse_token())
             FError("EOF without closing brace");
@@ -177,6 +182,7 @@ void entdict_t::parse(parser_base_t &parser)
         }
 
         set(keystr, parser.token);
+        parser.ignore_escapes = false;
     }
 }
 void EntData_ParseInto(parser_t &parser, std::vector<entdict_t> &vector)

common/parser.cc

@@ -184,7 +184,9 @@ bool parser_t::parse_token(parseflags flags)
                         }
                         break;
                     default:
-                        logging::print("WARNING: {}: Unrecognised string escape - \\{}\n", location, pos[1]);
+                        if (!ignore_escapes) {
+                            logging::print("WARNING: {}: Unrecognised string escape - \\{}\n", location, pos[1]);
+                        }
                         break;
                 }
             }

include/bsputil/bsputil.hh

@@ -82,7 +82,7 @@ public:
     settings::setting_func findleaf;
     settings::setting_func settexinfo;
     settings::setting_func decompile;
-    settings::setting_func sin_anims;
+    settings::setting_string decompile_suffix;
     settings::setting_func decompile_geomonly;
     settings::setting_func decompile_ignore_brushes;
     settings::setting_func decompile_hull;

include/common/decompile.hh

@@ -26,6 +26,8 @@ struct decomp_options
     bool ignoreBrushes = false;
 
     int hullnum = 0;
+
+    std::string sin_srfName = "";
 };
 
 void DecompileBSP(const mbsp_t *bsp, const decomp_options &options, std::ofstream &file);

include/common/parser.hh

@@ -121,6 +121,7 @@ struct parser_base_t
     std::string token; // the last token parsed by parse_token
     bool was_quoted = false; // whether the current token was from a quoted string or not
     parser_source_location location; // parse location, if any
+    bool ignore_escapes = false; // ignore invalid escape sequences
 
     inline parser_base_t(parser_source_location base_location)
         : location(base_location)

include/common/polylib.hh

@@ -1210,6 +1210,13 @@ public:
         return result;
     }
 
+    void translateInPlace(const vec3_type &offset)
+    {
+        for (auto it = begin(); it != end(); it++) {
+            *it += offset;
+        }
+    }
+
     winding_base_t translate(const vec3_type &offset) const
     {
         winding_base_t result = this->clone();