path: root/src/world.cpp

// world.cpp — world/sky material colour modulation.
//
// Same mechanism Amalgam uses for its "World modulation": walk every material
// in the material system and call IMaterial::ColorModulate on the ones whose
// texture group is the world (or the skybox). This multiplies the material's
// albedo; it does not touch lightmaps, so it is cheap and does not recompile
// shaders.
//
// HL2's materialsystem.so registers "VMaterialSystem080" (the SDK 2013 name
// for the modern layout) and exports CreateInterface, so the interface is
// obtained exactly like VClient017/VGUI_Surface030 elsewhere in this cheat.
//
// Vtable slots are taken from the 2013 SDK headers:
//   IMaterialSystem: FirstMaterial=73 NextMaterial=74 InvalidMaterial=75
//                    GetMaterial=76 GetNumMaterials=77
//   IMaterial:       GetName=0 GetTextureGroupName=1 ColorModulate=28

#include "hl2h.h"
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <dlfcn.h>

namespace {

constexpr int MATSYS_FirstMaterial = 73;
constexpr int MATSYS_NextMaterial = 74;
constexpr int MATSYS_InvalidMaterial = 75;
constexpr int MATSYS_GetMaterial = 76;
constexpr int MATSYS_GetNumMaterials = 77;

constexpr int MAT_GetName = 0;
constexpr int MAT_GetTextureGroupName = 1;
constexpr int MAT_ColorModulate = 28;

constexpr const char *GROUP_WORLD = "World textures";
constexpr const char *GROUP_SKYBOX = "SkyBox textures";

void *g_matsys = nullptr;
bool g_matsys_tried = false;
bool g_matsys_failed = false;
bool g_matsys_logged = false;

// Last state handed to the material system. Colour changes are applied when
// this differs from the desired state, so the all-material walk runs only on
// toggles/colour edits/level changes, never every frame.
struct Tint {
  bool valid;
  int world_r, world_g, world_b;
  int sky_r, sky_g, sky_b;
  int prop_r, prop_g, prop_b;
};
Tint g_applied{false, 255, 255, 255, 255, 255, 255, 255, 255, 255};

// Static props and prop_physics share their model materials; every stock HL2
// map prop lives under models/props*, which keeps NPC/player/weapon materials
// out of the prop pass.
bool is_prop_material(const char *name) {
  return name && strncmp(name, "models/props", 12) == 0;
}

struct MatCalls {
  using FirstFn = unsigned short (*)(void *);
  using NextFn = unsigned short (*)(void *, unsigned short);
  using InvalidFn = unsigned short (*)(void *);
  using GetFn = void *(*)(void *, unsigned short);
  using CountFn = int (*)(void *);
  using NameFn = const char *(*)(void *);
  using GroupFn = const char *(*)(void *);
  using ModulateFn = void (*)(void *, float, float, float);
};

// Reject obviously bogus strings returned by a mis-mapped vtable slot instead
// of walking thousands of materials with garbage pointers.
bool plausible_name(const char *s) {
  if (!s || !*s)
    return false;
  size_t n = strnlen(s, 512);
  if (n == 0 || n >= 512)
    return false;
  for (size_t i = 0; i < n; i++) {
    unsigned char c = (unsigned char)s[i];
    if (c < 0x20 || c == 0x7f)
      return false;
  }
  return true;
}

std::string find_loaded_module(const char *needle) {
  FILE *maps = fopen("/proc/self/maps", "r");
  if (!maps)
    return {};
  char line[1024];
  std::string found;
  while (fgets(line, sizeof(line), maps)) {
    char *p = strchr(line, '/');
    if (!p)
      continue;
    size_t pl = strlen(p);
    while (pl && (p[pl - 1] == '\n' || p[pl - 1] == '\r'))
      p[--pl] = 0;
    if (!strstr(p, needle) || !strstr(p, ".so"))
      continue;
    found = p;
    if (!strstr(p, "(deleted)"))
      break;
  }
  fclose(maps);
  return found;
}

void *material_system() {
  if (g_matsys_tried)
    return g_matsys;
  g_matsys_tried = true;

  std::string path = find_loaded_module("materialsystem");
  void *h = nullptr;
  if (!path.empty())
    h = dlopen(path.c_str(), RTLD_NOLOAD | RTLD_LAZY | RTLD_GLOBAL);
  // The engine always dlopens the module by name; NOLOAD only attaches to the
  // already-mapped copy, so we never spawn a second material system.
  if (!h)
    h = dlopen("materialsystem.so", RTLD_NOLOAD | RTLD_LAZY | RTLD_GLOBAL);
  if (!h) {
    g_matsys_failed = true;
    logf("tint: materialsystem.so not loaded");
    return nullptr;
  }
  auto cf = (CreateInterfaceFn)dlsym(h, "CreateInterface");
  if (!cf) {
    g_matsys_failed = true;
    logf("tint: materialsystem CreateInterface missing");
    return nullptr;
  }
  static const char *names[] = {"VMaterialSystem080", "VMaterialSystem082",
                                "VMaterialSystem081", nullptr};
  for (const char **n = names; *n; n++) {
    int ret = 0;
    void *ms = cf(*n, &ret);
    if (!ms)
      continue;
    g_matsys = ms;
    logf("tint: %s = %p via %s", *n, ms,
         path.empty() ? "materialsystem.so" : path.c_str());
    return ms;
  }
  g_matsys_failed = true;
  logf("tint: material system interface not exposed");
  return nullptr;
}

// Push one colour pair over all materials. Groups that are off get white so a
// previously tinted world is restored.
bool apply_tint(int world_r, int world_g, int world_b, int sky_r, int sky_g,
                int sky_b, int prop_r, int prop_g, int prop_b) {
  void *ms = material_system();
  if (!ms)
    return false;

  auto invalid = vfunc<MatCalls::InvalidFn>(ms, MATSYS_InvalidMaterial);
  auto first = vfunc<MatCalls::FirstFn>(ms, MATSYS_FirstMaterial);
  auto next = vfunc<MatCalls::NextFn>(ms, MATSYS_NextMaterial);
  auto get = vfunc<MatCalls::GetFn>(ms, MATSYS_GetMaterial);
  auto count = vfunc<MatCalls::CountFn>(ms, MATSYS_GetNumMaterials);

  int total = count(ms);
  if (total <= 0 || total > 200000) {
    logf("tint: GetNumMaterials() = %d (unexpected; disabled)", total);
    g_matsys_failed = true;
    toastf(TOAST_ERROR, "World tint: material system layout mismatch");
    return false;
  }

  float wr = world_r / 255.0f, wg = world_g / 255.0f, wb = world_b / 255.0f;
  float sr = sky_r / 255.0f, sg = sky_g / 255.0f, sb = sky_b / 255.0f;
  float pr = prop_r / 255.0f, pg = prop_g / 255.0f, pb = prop_b / 255.0f;

  unsigned short inv = invalid(ms);
  int seen = 0, world_hits = 0, sky_hits = 0, prop_hits = 0;
  for (unsigned short h = first(ms); h != inv; h = next(ms, h)) {
    if (++seen > total + 16) {
      logf("tint: material walk runaway (%d > %d); stopped", seen, total);
      break;
    }
    void *mat = get(ms, h);
    if (!mat)
      continue;
    auto name_fn = vfunc<MatCalls::NameFn>(mat, MAT_GetName);
    auto group_fn = vfunc<MatCalls::GroupFn>(mat, MAT_GetTextureGroupName);
    auto mod_fn = vfunc<MatCalls::ModulateFn>(mat, MAT_ColorModulate);
    const char *name = name_fn(mat);
    const char *group = group_fn(mat);
    if (!plausible_name(name) || !plausible_name(group))
      continue;
    // The first material's name also validates the IMaterial vtable mapping
    // before we poke any colour state.
    if (!g_matsys_logged) {
      g_matsys_logged = true;
      logf("tint: first material \"%s\" group \"%s\"", name, group);
    }
    bool is_world = strncmp(group, GROUP_WORLD, strlen(GROUP_WORLD)) == 0;
    bool is_sky = strncmp(group, GROUP_SKYBOX, strlen(GROUP_SKYBOX)) == 0 ||
                  strstr(name, "sky") != nullptr;
    if (is_world && !strstr(name, "sky")) {
      mod_fn(mat, wr, wg, wb);
      world_hits++;
    } else if (is_sky) {
      mod_fn(mat, sr, sg, sb);
      sky_hits++;
    } else if (is_prop_material(name)) {
      mod_fn(mat, pr, pg, pb);
      prop_hits++;
    }
  }
  logf("tint: applied world=%d(%d,%d,%d) sky=%d(%d,%d,%d) props=%d(%d,%d,%d) "
       "of %d materials",
       world_hits, world_r, world_g, world_b, sky_hits, sky_r, sky_g, sky_b,
       prop_hits, prop_r, prop_g, prop_b, total);
  return true;
}

} // namespace

void world_tint_invalidate() { g_applied.valid = false; }

void world_tint_update() {
  bool on = feature_active(FEAT_WORLD_TINT);
  bool world_on = on && g_tint_world_on;
  bool sky_on = on && g_tint_sky_on;
  bool prop_on = on && g_tint_prop_on;

  int wr = world_on ? g_tint_world_rgb[0] : 255;
  int wg = world_on ? g_tint_world_rgb[1] : 255;
  int wb = world_on ? g_tint_world_rgb[2] : 255;
  int sr = sky_on ? g_tint_sky_rgb[0] : 255;
  int sg = sky_on ? g_tint_sky_rgb[1] : 255;
  int sb = sky_on ? g_tint_sky_rgb[2] : 255;
  int pr = prop_on ? g_tint_prop_rgb[0] : 255;
  int pg = prop_on ? g_tint_prop_rgb[1] : 255;
  int pb = prop_on ? g_tint_prop_rgb[2] : 255;

  bool white = wr == 255 && wg == 255 && wb == 255 && sr == 255 &&
               sg == 255 && sb == 255 && pr == 255 && pg == 255 && pb == 255;
  if (g_applied.valid && g_applied.world_r == wr && g_applied.world_g == wg &&
      g_applied.world_b == wb && g_applied.sky_r == sr &&
      g_applied.sky_g == sg && g_applied.sky_b == sb &&
      g_applied.prop_r == pr && g_applied.prop_g == pg &&
      g_applied.prop_b == pb)
    return;
  // Nothing was ever tinted and nothing is requested: no need to walk the
  // material list just to write white over white.
  if (!g_applied.valid && white) {
    g_applied = {true, wr, wg, wb, sr, sg, sb, pr, pg, pb};
    return;
  }
  if (g_matsys_failed && !world_on && !sky_on && !prop_on) {
    g_applied = {true, wr, wg, wb, sr, sg, sb, pr, pg, pb};
    return;
  }
  if (!apply_tint(wr, wg, wb, sr, sg, sb, pr, pg, pb)) {
    if (g_matsys_failed)
      g_applied = {true, wr, wg, wb, sr, sg, sb, pr, pg, pb};
    return;
  }
  g_applied = {true, wr, wg, wb, sr, sg, sb, pr, pg, pb};
}

// ---------------------------------------------------------------------------
// Fog override (engine console commands; no render hooks)
// ---------------------------------------------------------------------------

namespace {

struct FogState {
  bool valid;
  bool on;
  bool disable;
  int r, g, b;
  int start, end;
  bool skybox;
};
FogState g_fog_applied{false, false, false, 0, 0, 0, 0, 0, false};

} // namespace

void fog_invalidate() { g_fog_applied.valid = false; }

void fog_update() {
  bool on = feature_active(FEAT_FOG);
  bool disable = on && g_fog_disable;
  int r = g_fog_rgb[0], g = g_fog_rgb[1], b = g_fog_rgb[2];
  int start = g_fog_start;
  int end = g_fog_end;
  if (end <= start)
    end = start + 1;
  bool skybox = on && g_fog_skybox;

  if (g_fog_applied.valid && g_fog_applied.on == on &&
      g_fog_applied.disable == disable && g_fog_applied.r == r &&
      g_fog_applied.g == g && g_fog_applied.b == b &&
      g_fog_applied.start == start && g_fog_applied.end == end &&
      g_fog_applied.skybox == skybox)
    return;

  if (!on) {
    if (g_fog_applied.valid && g_fog_applied.on)
      console_cmd("fog_override 0");
    g_fog_applied = {true, false, false, 0, 0, 0, 0, 0, false};
    return;
  }

  console_cmd("fog_override 1");
  char cmd[128];
  if (disable) {
    console_cmd("fog_enable 0");
    if (skybox)
      console_cmd("fog_enableskybox 0");
  } else {
    console_cmd("fog_enable 1");
    snprintf(cmd, sizeof(cmd), "fog_color %d %d %d", r, g, b);
    console_cmd(cmd);
    snprintf(cmd, sizeof(cmd), "fog_start %d", start);
    console_cmd(cmd);
    snprintf(cmd, sizeof(cmd), "fog_end %d", end);
    console_cmd(cmd);
    if (skybox) {
      console_cmd("fog_enableskybox 1");
      snprintf(cmd, sizeof(cmd), "fog_colorskybox %d %d %d", r, g, b);
      console_cmd(cmd);
      snprintf(cmd, sizeof(cmd), "fog_startskybox %d", start);
      console_cmd(cmd);
      snprintf(cmd, sizeof(cmd), "fog_endskybox %d", end);
      console_cmd(cmd);
    } else {
      console_cmd("fog_enableskybox 0");
    }
  }
  g_fog_applied = {true, on, disable, r, g, b, start, end, skybox};
  logf("fog: %s colour=(%d,%d,%d) start=%d end=%d skybox=%d", disable ? "off"
       : "on", r, g, b, start, end, (int)skybox);
}

// ---------------------------------------------------------------------------
// Skybox changer (sv_skyname; same mechanism as the skybox_swapper entity)
// ---------------------------------------------------------------------------

namespace {

// HL2's skybox set. Index 0 means "do not force a sky"; the rest are the
// base names the engine expands to skybox/<name>{rt,bk,lf,ft,up,dn}.
const char *const kSkyboxLabels[] = {
    "Map default",     "sky_day01_01", "sky_day01_04", "sky_day01_05",
    "sky_day01_06",    "sky_day01_07", "sky_day01_08", "sky_day01_09",
    "sky_day02_01",    "sky_day02_02", "sky_day02_03", "sky_day02_04",
    "sky_day02_05",    "sky_day02_06", "sky_day02_07", "sky_day02_09",
    "sky_day02_10",    "sky_day03_01", "sky_day03_02", "sky_day03_03",
    "sky_day03_04",    "sky_day03_05", "sky_day03_06", "sky_day03_06b",
    "sky_day03_06c",   "sky_wasteland02", "sky_borealis01", "sky_fog_002",
    "sky_fake_white"};

std::string g_sky_original;      // map's own sky, captured before overriding
bool g_sky_original_valid = false;
std::string g_sky_active;        // value we forced, empty when not forcing

// "skybox/sky_day01_01_hdrrt" -> "sky_day01_01"
bool parse_sky_material(const char *mat, char *out, size_t outn) {
  if (!mat)
    return false;
  const char *n = mat;
  if (strncmp(n, "skybox/", 7) == 0)
    n += 7;
  size_t len = strlen(n);
  if (len < 4)
    return false;
  static const char *faces[] = {"rt", "bk", "lf", "ft", "up", "dn", nullptr};
  const char *suf = n + len - 2;
  bool face = false;
  for (int i = 0; faces[i]; i++) {
    if (strcmp(suf, faces[i]) == 0) {
      face = true;
      break;
    }
  }
  if (!face)
    return false;
  size_t blen = len - 2;
  if (blen > 4 && (strncmp(n + blen - 4, "_hdr", 4) == 0 ||
                   strncmp(n + blen - 4, "_ldr", 4) == 0))
    blen -= 4;
  if (blen == 0 || blen >= outn)
    return false;
  memcpy(out, n, blen);
  out[blen] = 0;
  return true;
}

void capture_map_sky() {
  if (g_sky_original_valid)
    return;
  g_sky_original_valid = true; // one attempt per map, even on failure
  void *ms = material_system();
  if (!ms)
    return;
  auto invalid = vfunc<MatCalls::InvalidFn>(ms, MATSYS_InvalidMaterial);
  auto first = vfunc<MatCalls::FirstFn>(ms, MATSYS_FirstMaterial);
  auto next = vfunc<MatCalls::NextFn>(ms, MATSYS_NextMaterial);
  auto get = vfunc<MatCalls::GetFn>(ms, MATSYS_GetMaterial);
  auto count = vfunc<MatCalls::CountFn>(ms, MATSYS_GetNumMaterials);
  int total = count(ms);
  if (total <= 0 || total > 200000)
    return;
  unsigned short inv = invalid(ms);
  int seen = 0;
  std::string last;
  for (unsigned short h = first(ms); h != inv; h = next(ms, h)) {
    if (++seen > total + 16)
      break;
    void *mat = get(ms, h);
    if (!mat)
      continue;
    const char *name = vfunc<MatCalls::NameFn>(mat, MAT_GetName)(mat);
    const char *group =
        vfunc<MatCalls::GroupFn>(mat, MAT_GetTextureGroupName)(mat);
    if (!plausible_name(name) || !plausible_name(group))
      continue;
    if (strncmp(group, GROUP_SKYBOX, strlen(GROUP_SKYBOX)) != 0)
      continue;
    char base[128];
    if (parse_sky_material(name, base, sizeof(base)))
      last = base; // newest loaded sky materials win after a level change
  }
  if (last.empty()) {
    logd("skybox: could not capture the map sky");
    return;
  }
  g_sky_original = last;
  logf("skybox: map sky is %s", g_sky_original.c_str());
}

} // namespace

int skybox_option_count() {
  return (int)(sizeof(kSkyboxLabels) / sizeof(kSkyboxLabels[0]));
}

const char *skybox_option_name(int i) {
  int n = skybox_option_count();
  return (i >= 0 && i < n) ? kSkyboxLabels[i] : kSkyboxLabels[0];
}

const char *const *skybox_options() { return kSkyboxLabels; }

void skybox_invalidate() {
  // Level change: the engine sets sv_skyname from worldspawn again, so there is
  // nothing to restore. Forget the captured base and let it recapture.
  g_sky_original.clear();
  g_sky_original_valid = false;
  g_sky_active.clear();
}

void skybox_update() {
  bool on = feature_active(FEAT_SKYBOX);
  int choice = g_skybox_choice;
  int n = skybox_option_count();
  if (choice < 0 || choice >= n)
    choice = 0;

  if (!on || choice == 0) {
    if (g_sky_active.empty())
      return;
    if (g_sky_original_valid && !g_sky_original.empty() &&
        g_sky_original != g_sky_active) {
      char cmd[160];
      snprintf(cmd, sizeof(cmd), "sv_skyname %s", g_sky_original.c_str());
      console_cmd(cmd);
      logf("skybox: restored %s", g_sky_original.c_str());
      world_tint_invalidate(); // the new sky materials need the sky tint
    }
    g_sky_active.clear();
    return;
  }

  capture_map_sky(); // before the first override of this map
  const char *want = skybox_option_name(choice);
  if (g_sky_active == want)
    return;
  char cmd[160];
  snprintf(cmd, sizeof(cmd), "sv_skyname %s", want);
  console_cmd(cmd);
  logf("skybox: %s", want);
  g_sky_active = want;
  world_tint_invalidate(); // tint materials for the freshly loaded sky
}