Merge branch 'master' of ssh://git.axiodl.com:6431/AxioDL/hecl

hecl/lib/Blender/Connection.cpp

@@ -13,10 +13,10 @@
 #include <thread>
 #include <tuple>
 
-#include <hecl/hecl.hpp>
-#include <hecl/Database.hpp>
 #include "hecl/Blender/Connection.hpp"
 #include "hecl/Blender/Token.hpp"
+#include "hecl/Database.hpp"
+#include "hecl/hecl.hpp"
 #include "hecl/SteamFinder.hpp"
 #include "MeshOptimizer.hpp"
 

hecl/lib/Blender/HMDL.cpp

@@ -2,6 +2,8 @@
 
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
+#include <vector>
 
 #include <athena/MemoryWriter.hpp>
 

hecl/lib/Blender/MeshOptimizer.cpp

@@ -1,7 +1,11 @@
 #include "MeshOptimizer.hpp"
-#include <numeric>
+
+#include <algorithm>
 #include <cfloat>
+#include <climits>
 #include <cmath>
+#include <numeric>
+#include <unordered_set>
 
 namespace hecl::blender {
 

hecl/lib/Blender/MeshOptimizer.hpp

@@ -1,6 +1,14 @@
 #pragma once
+
+#include <algorithm>
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
 #include "hecl/Blender/Connection.hpp"
-#include <unordered_set>
 
 namespace hecl::blender {
 

hecl/lib/Blender/SDNARead.cpp

@@ -1,5 +1,13 @@
 #include "hecl/Blender/SDNARead.hpp"
-#include "athena/FileReader.hpp"
+
+#include <cstring>
+#include <string>
+
+#include "hecl/hecl.hpp"
+
+#include <athena/FileReader.hpp>
+#include <athena/MemoryReader.hpp>
+
 #include <zlib.h>
 
 namespace hecl::blender {
@@ -69,7 +77,7 @@ SDNARead::SDNARead(SystemStringView path) {
   atUint64 length = r.length();
   char magicBuf[7];
   r.readUBytesToBuf(magicBuf, 7);
-  r.seek(0, athena::Begin);
+  r.seek(0, athena::SeekOrigin::Begin);
   if (strncmp(magicBuf, "BLENDER", 7)) {
     /* Try gzip decompression */
     std::unique_ptr<uint8_t[]> compBuf(new uint8_t[4096]);
@@ -161,15 +169,15 @@ BlendType GetBlendType(SystemStringView path) {
   r.enumerate(
       [idPropIdx, typeOffset, nameOffset, valOffset, &ret](const FileBlock& block, athena::io::MemoryReader& r) {
         if (block.type == FOURCC('DATA') && block.sdnaIdx == idPropIdx) {
-          r.seek(typeOffset, athena::Begin);
+          r.seek(typeOffset, athena::SeekOrigin::Begin);
           if (r.readUByte() != 1)
             return true;
 
-          r.seek(nameOffset, athena::Begin);
+          r.seek(nameOffset, athena::SeekOrigin::Begin);
           if (r.readString() != "hecl_type")
             return true;
 
-          r.seek(valOffset, athena::Begin);
+          r.seek(valOffset, athena::SeekOrigin::Begin);
           ret = BlendType(r.readUint32Little());
           return false;
         }

hecl/lib/CVar.cpp

@@ -1,10 +1,11 @@
-#include "hecl/hecl.hpp"
-#include "hecl/CVar.hpp"
+#include "hecl/CVar.hpp"
+
+#include <sstream>
+
 #include "hecl/CVarManager.hpp"
+#include "hecl/hecl.hpp"
 
 #include <athena/Utility.hpp>
-#include <algorithm>
-#include <sstream>
 
 namespace hecl {
 extern CVar* com_developer;
@@ -12,111 +13,70 @@ extern CVar* com_enableCheats;
 
 using namespace std::literals;
 
-CVar::CVar(std::string_view name, std::string_view value, std::string_view help, EType type, EFlags flags,
-           CVarManager& parent)
-: m_mgr(parent) {
-  m_name = std::string(name);
-  m_value = std::string(value);
-  m_defaultValue = std::string(value);
-  m_help = help;
-  m_type = type;
-  m_flags = flags;
-}
-
-CVar::CVar(std::string_view name, std::string_view value, std::string_view help, CVar::EFlags flags,
-           CVarManager& parent)
-: m_mgr(parent) {
-  m_flags = flags;
-  m_name = std::string(name);
-  m_help = help;
-  m_type = EType::Literal;
-
-  // Unlock the cvar for writing if readonly
-  unlock();
-
+CVar::CVar(std::string_view name, std::string_view value, std::string_view help, CVar::EFlags flags)
+: CVar(name, help, EType::Literal) {
   fromLiteral(value);
-  m_defaultValue = m_value;
-
-  // Lock the cvar
-  lock();
-  // Clear the modified flag, just incase lock didn't do it.
-  m_flags = flags;
+  init(flags);
 }
 
-CVar::CVar(std::string_view name, const atVec4f& value, std::string_view help, EFlags flags, CVarManager& parent)
-: m_mgr(parent) {
-  m_name = std::string(name);
-  m_help = help;
-  m_type = EType::Vec4f;
-  m_flags = flags;
+CVar::CVar(std::string_view name, const atVec2f& value, std::string_view help, EFlags flags)
+: CVar(name, help, EType::Vec2f) {
+  fromVec2f(value);
+  init(flags);
+}
 
-  // Unlock the cvar for writing if readonly
-  unlock();
+CVar::CVar(std::string_view name, const atVec2d& value, std::string_view help, EFlags flags)
+: CVar(name, help, EType::Vec2d) {
+  fromVec2d(value);
 
+  init(flags);
+}
+
+CVar::CVar(std::string_view name, const atVec3f& value, std::string_view help, EFlags flags)
+: CVar(name, help, EType::Vec3f) {
+  fromVec3f(value);
+  init(flags, false);
+}
+
+CVar::CVar(std::string_view name, const atVec3d& value, std::string_view help, EFlags flags)
+: CVar(name, help, EType::Vec3d) {
+  fromVec3d(value);
+  init(flags, false);
+}
+
+CVar::CVar(std::string_view name, const atVec4f& value, std::string_view help, EFlags flags)
+: CVar(name, help, EType::Vec4f) {
   fromVec4f(value);
-  m_defaultValue = m_value;
-
-  // Lock the cvar
-  lock();
-  // Clear the modified flag, just incase lock didn't do it.
-  m_flags = flags;
+  init(flags, false);
 }
 
-CVar::CVar(std::string_view name, float value, std::string_view help, EFlags flags, CVarManager& parent)
-: m_mgr(parent) {
-  m_name = std::string(name);
-  m_help = help;
-  m_type = EType::Float;
-  m_flags = flags;
-
-  // Unlock the cvar for writing if readonly
-  unlock();
-
-  fromFloat(value);
-  m_defaultValue = m_value;
-
-  // Lock the cvar
-  lock();
-  // Clear the modified flag, just incase lock didn't do it.
-  m_flags = flags;
+CVar::CVar(std::string_view name, const atVec4d& value, std::string_view help, EFlags flags)
+: CVar(name, help, EType::Vec4d) {
+  fromVec4d(value);
+  init(flags, false);
 }
 
-CVar::CVar(std::string_view name, bool value, std::string_view help, CVar::EFlags flags, CVarManager& parent)
-: m_mgr(parent) {
-  m_name = std::string(name);
-  m_help = help;
-  m_type = EType::Boolean;
-  m_flags = flags;
-
-  // Unlock the cvar for writing if readonly
-  unlock();
+CVar::CVar(std::string_view name, double value, std::string_view help, EFlags flags) : CVar(name, help, EType::Real) {
+  fromReal(value);
+  init(flags);
+}
 
+CVar::CVar(std::string_view name, bool value, std::string_view help, CVar::EFlags flags)
+: CVar(name, help, EType::Boolean) {
   fromBoolean(value);
-  m_defaultValue = m_value;
-
-  // Lock the cvar
-  lock();
-  // Clear the modified flag, just incase lock didn't do it.
-  m_flags = flags;
+  init(flags);
 }
 
-CVar::CVar(std::string_view name, int value, std::string_view help, CVar::EFlags flags, CVarManager& parent)
-: m_mgr(parent) {
-  m_name = std::string(name);
-  m_help = help;
-  m_type = EType::Integer;
-  m_flags = flags;
-
-  // Unlock the cvar for writing if readonly
-  unlock();
-
+CVar::CVar(std::string_view name, int32_t value, std::string_view help, CVar::EFlags flags)
+: CVar(name, help, EType::Signed) {
   fromInteger(value);
-  m_defaultValue = m_value;
+  init(flags);
+}
 
-  // Lock the cvar
-  lock();
-  // Clear the modified flag, just incase lock didn't do it.
-  m_flags = flags;
+CVar::CVar(std::string_view name, uint32_t value, std::string_view help, CVar::EFlags flags)
+: CVar(name, help, EType::Unsigned) {
+  fromInteger(value);
+  init(flags);
 }
 
 std::string CVar::help() const {
@@ -124,6 +84,82 @@ std::string CVar::help() const {
                      (isReadOnly() ? " [ReadOnly]" : ""));
 }
 
+atVec2f CVar::toVec2f(bool* isValid) const {
+  if (m_type != EType::Vec2f) {
+    if (isValid != nullptr)
+      *isValid = false;
+
+    return atVec2f{};
+  }
+
+  if (isValid != nullptr)
+    *isValid = true;
+
+  atVec2f vec{};
+  athena::simd_floats f;
+  std::sscanf(m_value.c_str(), "%g %g", &f[0], &f[1]);
+  vec.simd.copy_from(f);
+
+  return vec;
+}
+
+atVec2d CVar::toVec2d(bool* isValid) const {
+  if (m_type != EType::Vec2d) {
+    if (isValid != nullptr)
+      *isValid = false;
+
+    return atVec2d{};
+  }
+
+  if (isValid != nullptr)
+    *isValid = true;
+
+  atVec2d vec{};
+  athena::simd_doubles f;
+  std::sscanf(m_value.c_str(), "%lg %lg", &f[0], &f[1]);
+  vec.simd.copy_from(f);
+
+  return vec;
+}
+
+atVec3f CVar::toVec3f(bool* isValid) const {
+  if (m_type != EType::Vec3f) {
+    if (isValid != nullptr)
+      *isValid = false;
+
+    return atVec3f{};
+  }
+
+  if (isValid != nullptr)
+    *isValid = true;
+
+  atVec3f vec{};
+  athena::simd_floats f;
+  std::sscanf(m_value.c_str(), "%g %g %g", &f[0], &f[1], &f[2]);
+  vec.simd.copy_from(f);
+
+  return vec;
+}
+
+atVec3d CVar::toVec3d(bool* isValid) const {
+  if (m_type != EType::Vec3d) {
+    if (isValid != nullptr)
+      *isValid = false;
+
+    return atVec3d{};
+  }
+
+  if (isValid != nullptr)
+    *isValid = true;
+
+  atVec3d vec{};
+  athena::simd_doubles f;
+  std::sscanf(m_value.c_str(), "%lg %lg %lg", &f[0], &f[1], &f[2]);
+  vec.simd.copy_from(f);
+
+  return vec;
+}
+
 atVec4f CVar::toVec4f(bool* isValid) const {
   if (m_type != EType::Vec4f) {
     if (isValid != nullptr)
@@ -135,22 +171,44 @@ atVec4f CVar::toVec4f(bool* isValid) const {
   if (isValid != nullptr)
     *isValid = true;
 
-  atVec4f vec;
+  atVec4f vec{};
   athena::simd_floats f;
-  std::sscanf(m_value.c_str(), "%f %f %f %f", &f[0], &f[1], &f[2], &f[3]);
+  std::sscanf(m_value.c_str(), "%g %g %g %g", &f[0], &f[1], &f[2], &f[3]);
   vec.simd.copy_from(f);
 
   return vec;
 }
 
-float CVar::toFloat(bool* isValid) const {
-  if (m_type != EType::Float) {
+atVec4d CVar::toVec4d(bool* isValid) const {
+  if (m_type != EType::Vec4d) {
+    if (isValid != nullptr)
+      *isValid = false;
+
+    return atVec4d{};
+  }
+
+  if (isValid != nullptr)
+    *isValid = true;
+
+  atVec4d vec{};
+  athena::simd_doubles f;
+  std::sscanf(m_value.c_str(), "%lg %lg %lg %lg", &f[0], &f[1], &f[2], &f[3]);
+  vec.simd.copy_from(f);
+
+  return vec;
+}
+
+double CVar::toReal(bool* isValid) const {
+  if (m_type != EType::Real) {
     if (isValid)
       *isValid = false;
     return 0.0f;
   }
 
-  return strtof(m_value.c_str(), nullptr);
+  if (isValid != nullptr)
+    *isValid = true;
+
+  return strtod(m_value.c_str(), nullptr);
 }
 
 bool CVar::toBoolean(bool* isValid) const {
@@ -161,36 +219,38 @@ bool CVar::toBoolean(bool* isValid) const {
     return false;
   }
 
-  // We don't want to modify the original value;
-  std::string tmp = m_value;
-  athena::utility::tolower(tmp);
+  if (isValid != nullptr)
+    *isValid = true;
 
-  if (tmp == "yes" || tmp == "true" || tmp == "1") {
-    if (isValid)
-      *isValid = true;
-    return true;
-  } else if (tmp == "no" || tmp == "false" || tmp == "0") {
-    if (isValid)
-      *isValid = true;
-    return false;
-  }
-
-  if (isValid)
-    *isValid = false;
-
-  return false;
+  return athena::utility::parseBool(m_value);
 }
 
-int CVar::toInteger(bool* isValid) const {
-  if (m_type != EType::Integer) {
+int32_t CVar::toSigned(bool* isValid) const {
+  if (m_type != EType::Signed && m_type != EType::Unsigned) {
     if (isValid)
       *isValid = false;
     return 0;
   }
 
+  if (isValid != nullptr)
+    *isValid = true;
+
   return strtol(m_value.c_str(), nullptr, 0);
 }
 
+uint32_t CVar::toUnsigned(bool* isValid) const {
+  if (m_type != EType::Signed && m_type != EType::Unsigned) {
+    if (isValid)
+      *isValid = false;
+    return 0;
+  }
+
+  if (isValid != nullptr)
+    *isValid = true;
+
+  return strtoul(m_value.c_str(), nullptr, 0);
+}
+
 std::string CVar::toLiteral(bool* isValid) const {
   if (m_type != EType::Literal && (com_developer && com_developer->toBoolean())) {
     if (isValid != nullptr)
@@ -215,16 +275,48 @@ std::wstring CVar::toWideLiteral(bool* isValid) const {
   return hecl::UTF8ToWide(m_value);
 }
 
+bool CVar::fromVec2f(const atVec2f& val) {
+  if (!safeToModify(EType::Vec2f))
+    return false;
+
+  athena::simd_floats f(val.simd);
+  m_value.assign(fmt::format(fmt("{} {}"), f[0], f[1]));
+  m_flags |= EFlags::Modified;
+  return true;
+}
+
+bool CVar::fromVec2d(const atVec2d& val) {
+  if (!safeToModify(EType::Vec2d))
+    return false;
+
+  athena::simd_doubles f(val.simd);
+  m_value.assign(fmt::format(fmt("{} {}"), f[0], f[1]));
+  m_flags |= EFlags::Modified;
+  return true;
+}
+
+bool CVar::fromVec3f(const atVec3f& val) {
+  if (!safeToModify(EType::Vec3f))
+    return false;
+
+  athena::simd_floats f(val.simd);
+  m_value.assign(fmt::format(fmt("{} {} {}"), f[0], f[1], f[2]));
+  m_flags |= EFlags::Modified;
+  return true;
+}
+
+bool CVar::fromVec3d(const atVec3d& val) {
+  if (!safeToModify(EType::Vec3d))
+    return false;
+
+  athena::simd_doubles f(val.simd);
+  m_value.assign(fmt::format(fmt("{} {} {}"), f[0], f[1], f[2]));
+  m_flags |= EFlags::Modified;
+  return true;
+}
+
 bool CVar::fromVec4f(const atVec4f& val) {
-  if (isCheat() && (com_developer && !com_developer->toBoolean() && !com_enableCheats->toBoolean()))
-    return false;
-  else if (isCheat())
-    return false;
-
-  if (m_type != EType::Vec4f)
-    return false;
-
-  if (isReadOnly() && (com_developer && !com_developer->toBoolean()))
+  if (!safeToModify(EType::Vec4f))
     return false;
 
   athena::simd_floats f(val.simd);
@@ -233,16 +325,18 @@ bool CVar::fromVec4f(const atVec4f& val) {
   return true;
 }
 
-bool CVar::fromFloat(float val) {
-  if (isCheat() && (com_developer && !com_developer->toBoolean() && !com_enableCheats->toBoolean()))
-    return false;
-  else if (isCheat())
+bool CVar::fromVec4d(const atVec4d& val) {
+  if (!safeToModify(EType::Vec4d))
     return false;
 
-  if (m_type != EType::Float)
-    return false;
+  athena::simd_doubles f(val.simd);
+  m_value.assign(fmt::format(fmt("{} {} {} {}"), f[0], f[1], f[2], f[3]));
+  m_flags |= EFlags::Modified;
+  return true;
+}
 
-  if (isReadOnly() && (com_developer && !com_developer->toBoolean()))
+bool CVar::fromReal(double val) {
+  if (!safeToModify(EType::Real))
     return false;
 
   m_value.assign(fmt::format(fmt("{}"), val));
@@ -251,15 +345,7 @@ bool CVar::fromFloat(float val) {
 }
 
 bool CVar::fromBoolean(bool val) {
-  if (isCheat() && (com_developer && !com_developer->toBoolean() && !com_enableCheats->toBoolean()))
-    return false;
-  else if (isCheat())
-    return false;
-
-  if (m_type != EType::Boolean)
-    return false;
-
-  if (isReadOnly() && (com_developer && !com_developer->toBoolean()))
+  if (!safeToModify(EType::Boolean))
     return false;
 
   if (val)
@@ -271,33 +357,44 @@ bool CVar::fromBoolean(bool val) {
   return true;
 }
 
-bool CVar::fromInteger(int val) {
-  if (isCheat() && (com_developer && !com_developer->toBoolean() && !com_enableCheats->toBoolean()))
-    return false;
-  else if (isCheat())
+bool CVar::fromInteger(int32_t val) {
+  if ((com_developer && com_enableCheats) && (!com_developer->toBoolean() || !com_enableCheats->toBoolean()) &&
+      isCheat())
     return false;
 
-  if (m_type != EType::Integer)
+  // We'll accept both signed an unsigned input
+  if (m_type != EType::Signed && m_type != EType::Unsigned)
     return false;
 
   if (isReadOnly() && (com_developer && !com_developer->toBoolean()))
     return false;
 
-  m_value = fmt::format(fmt("{}"), val);
+  // Properly format based on signedness
+  m_value = fmt::format(fmt("{}"), (m_type == EType::Signed ? val : static_cast<uint32_t>(val)));
+  setModified();
+  return true;
+}
+
+bool CVar::fromInteger(uint32_t val) {
+  if ((com_developer && com_enableCheats) && (!com_developer->toBoolean() || !com_enableCheats->toBoolean()) &&
+      isCheat())
+    return false;
+
+  // We'll accept both signed an unsigned input
+  if (m_type != EType::Signed && m_type != EType::Unsigned)
+    return false;
+
+  if (isReadOnly() && (com_developer && !com_developer->toBoolean()))
+    return false;
+
+  // Properly format based on signedness
+  m_value = fmt::format(fmt("{}"), (m_type == EType::Unsigned ? val : static_cast<int32_t>(val)));
   setModified();
   return true;
 }
 
 bool CVar::fromLiteral(std::string_view val) {
-  if (isCheat() && (com_developer && !com_developer->toBoolean() && !com_enableCheats->toBoolean()))
-    return false;
-  else if (isCheat())
-    return false;
-
-  if (m_type != EType::Literal)
-    return false;
-
-  if (isReadOnly() && (com_developer && !com_developer->toBoolean()))
+  if (!safeToModify(EType::Literal))
     return false;
 
   m_value.assign(val);
@@ -306,15 +403,7 @@ bool CVar::fromLiteral(std::string_view val) {
 }
 
 bool CVar::fromLiteral(std::wstring_view val) {
-  if (isCheat() && (com_developer && !com_developer->toBoolean() && !com_enableCheats->toBoolean()))
-    return false;
-  else if (isCheat())
-    return false;
-
-  if (m_type != EType::Literal)
-    return false;
-
-  if (isReadOnly() && (com_developer && !com_developer->toBoolean()))
+  if (!safeToModify(EType::Literal))
     return false;
 
   m_value.assign(hecl::WideToUTF8(val));
@@ -322,94 +411,37 @@ bool CVar::fromLiteral(std::wstring_view val) {
   return true;
 }
 
-bool CVar::fromLiteralToType(std::string_view val, bool setDefault) {
-  switch (m_type) {
-  case EType::Literal:
-    return fromLiteral(val);
-  case EType::Boolean: {
-    std::stringstream ss;
-    ss << std::boolalpha << val;
-    bool v;
-    ss >> v;
-    return fromBoolean(v);
-  }
-  case EType::Float: {
-    std::stringstream ss;
-    ss << val;
-    float v;
-    ss >> v;
-    return fromFloat(v);
-  }
-  case EType::Integer: {
-    std::stringstream ss;
-    ss << val;
-    int v;
-    ss >> v;
-    return fromInteger(v);
-  }
-  case EType::Vec4f: {
-    atVec4f vec;
-    athena::simd_floats f;
-    std::sscanf(val.data(), "%f %f %f %f", &f[0], &f[1], &f[2], &f[3]);
-    vec.simd.copy_from(f);
-    return fromVec4f(vec);
-  }
-  }
-  if (setDefault)
-    m_value = m_defaultValue;
-  return false;
+bool CVar::fromLiteralToType(std::string_view val) {
+  if (!safeToModify(m_type) || !isValidInput(val))
+    return false;
+  m_value = val;
+  setModified();
+  return true;
 }
 
-bool CVar::fromLiteralToType(std::wstring_view val, bool setDefault) {
-  switch (m_type) {
-  case EType::Literal:
-    return fromLiteral(val);
-  case EType::Boolean: {
-    std::wstringstream ss;
-    ss << std::boolalpha << val;
-    bool v;
-    ss >> v;
-    return fromBoolean(v);
-  }
-  case EType::Float: {
-    std::wstringstream ss;
-    ss << val;
-    float v;
-    ss >> v;
-    return fromFloat(v);
-  }
-  case EType::Integer: {
-    std::wstringstream ss;
-    ss << val;
-    int v;
-    ss >> v;
-    return fromInteger(v);
-  }
-  case EType::Vec4f: {
-    atVec4f vec;
-    athena::simd_floats f;
-    std::swscanf(val.data(), L"%f %f %f %f", &f[0], &f[1], &f[2], &f[3]);
-    vec.simd.copy_from(f);
-    return fromVec4f(vec);
-  }
-  }
-  if (setDefault)
-    m_value = m_defaultValue;
-  return false;
+bool CVar::fromLiteralToType(std::wstring_view val) {
+  return fromLiteralToType(hecl::WideToUTF8(val));
 }
 
-bool CVar::isModified() const { return int(m_flags & EFlags::Modified) != 0; }
-bool CVar::modificationRequiresRestart() const { return int(m_flags & EFlags::ModifyRestart) != 0; }
+bool CVar::isModified() const { return True(m_flags & EFlags::Modified); }
+bool CVar::modificationRequiresRestart() const { return True(m_flags & EFlags::ModifyRestart); }
 
-bool CVar::isReadOnly() const { return int(m_flags & EFlags::ReadOnly) != 0; }
+bool CVar::isReadOnly() const { return True(m_flags & EFlags::ReadOnly); }
 
-bool CVar::isCheat() const { return int(m_flags & EFlags::Cheat) != 0; }
+bool CVar::isCheat() const { return True(m_flags & EFlags::Cheat); }
 
-bool CVar::isHidden() const { return int(m_flags & EFlags::Hidden) != 0; }
+bool CVar::isHidden() const { return True(m_flags & EFlags::Hidden); }
 
-bool CVar::isArchive() const { return int(m_flags & EFlags::Archive) != 0; }
+bool CVar::isArchive() const { return True(m_flags & EFlags::Archive); }
 
-bool CVar::isInternalArchivable() const { return int(m_flags & EFlags::InternalArchivable) != 0; }
+bool CVar::isInternalArchivable() const { return True(m_flags & EFlags::InternalArchivable); }
+
+bool CVar::isColor() const {
+  return True(m_flags & EFlags::Color) &&
+         (m_type == EType::Vec3f || m_type == EType::Vec3d || m_type == EType::Vec3f || m_type == EType::Vec4d);
+}
+
+bool CVar::isNoDeveloper() const { return True(m_flags & EFlags::NoDeveloper); }
 
 bool CVar::wasDeserialized() const { return m_wasDeserialized; }
 
@@ -441,4 +473,85 @@ void CVar::dispatch() {
   for (const ListenerFunc& listen : m_listeners)
     listen(this);
 }
+
+
+bool isReal(std::string_view v) {
+  char* p;
+  std::strtod(v.data(), &p);
+  return *p == 0;
+}
+bool isReal(const std::vector<std::string>& v) {
+  for (auto& s : v) {
+    if (!isReal(s))
+      return false;
+  }
+  return true;
+}
+
+bool CVar::isValidInput(std::string_view input) const {
+  std::vector<std::string> parts = athena::utility::split(input, ' ');
+  char* p;
+  switch(m_type) {
+  case EType::Boolean: {
+    bool valid = false;
+    athena::utility::parseBool(input, &valid);
+    return valid;
+  }
+  case EType::Signed:
+    std::strtol(input.data(), &p, 0);
+    return p == nullptr;
+  case EType::Unsigned:
+    std::strtoul(input.data(), &p, 0);
+    return p == nullptr;
+  case EType::Real: {
+    bool size = parts.size() == 1;
+    bool ret = isReal(input);
+    return ret && size;
+  }
+  case EType::Literal:
+    return true;
+  case EType::Vec2f:
+  case EType::Vec2d:
+    return parts.size() == 2 && isReal(parts);
+  case EType::Vec3f:
+  case EType::Vec3d:
+    return parts.size() == 3 && isReal(parts);
+  case EType::Vec4f:
+  case EType::Vec4d:
+    return parts.size() == 4 && isReal(parts);
+  }
+
+  return false;
+}
+
+bool CVar::isValidInput(std::wstring_view input) const {
+  return isValidInput(hecl::WideToUTF8(input));
+}
+
+bool CVar::safeToModify(EType type) const {
+  // Are we NoDevelper?
+  if (isNoDeveloper())
+    return false;
+
+  // Are we a cheat?
+  if (isCheat() && (com_developer && com_enableCheats) &&
+      (!com_developer->toBoolean() || !com_enableCheats->toBoolean()))
+    return false;
+
+  // Are we read only?
+  if (isReadOnly() && (com_developer && !com_developer->toBoolean()))
+    return false;
+
+  return m_type == type;
+}
+
+void CVar::init(EFlags flags, bool removeColor) {
+  m_defaultValue = m_value;
+  m_flags = flags;
+  if (removeColor) {
+    // If the user specifies color, we don't want it
+    m_flags &= ~EFlags::Color;
+  }
+}
+
 } // namespace hecl

hecl/lib/CVarManager.cpp

@@ -1,13 +1,16 @@
 #include "hecl/CVarManager.hpp"
-#include "hecl/Console.hpp"
-#include <athena/FileWriter.hpp>
-#include <athena/Utility.hpp>
-#include <hecl/Runtime.hpp>
-#include <hecl/hecl.hpp>
+
 #include <algorithm>
 #include <memory>
 #include <regex>
 
+#include "hecl/Console.hpp"
+#include "hecl/hecl.hpp"
+#include "hecl/Runtime.hpp"
+
+#include <athena/FileWriter.hpp>
+#include <athena/Utility.hpp>
+
 namespace hecl {
 
 CVar* com_developer = nullptr;
@@ -22,7 +25,9 @@ static logvisor::Module CVarLog("CVarManager");
 CVarManager::CVarManager(hecl::Runtime::FileStoreManager& store, bool useBinary)
 : m_store(store), m_useBinary(useBinary) {
   m_instance = this;
-  com_configfile = newCVar("config", "File to store configuration", std::string("config"), CVar::EFlags::System);
+  com_configfile =
+      newCVar("config", "File to store configuration", std::string("config"),
+              CVar::EFlags::System | CVar::EFlags::ReadOnly | CVar::EFlags::NoDeveloper | CVar::EFlags::Hidden);
   com_developer = newCVar("developer", "Enables developer mode", false,
                           (CVar::EFlags::System | CVar::EFlags::ReadOnly | CVar::EFlags::InternalArchivable));
   com_enableCheats = newCVar(
@@ -69,14 +74,15 @@ std::vector<CVar*> CVarManager::archivedCVars() const {
 std::vector<CVar*> CVarManager::cvars(CVar::EFlags filter) const {
   std::vector<CVar*> ret;
   for (const auto& pair : m_cvars)
-    if (filter == CVar::EFlags::None || (pair.second->flags() & filter) != 0)
+    if (filter == CVar::EFlags::Any || True(pair.second->flags() & filter))
       ret.push_back(pair.second.get());
 
   return ret;
 }
 
 void CVarManager::deserialize(CVar* cvar) {
-  if (!cvar)
+  /* Make sure we're not trying to deserialize a CVar that is invalid or not exposed */
+  if (!cvar || (!cvar->isArchive() && !cvar->isInternalArchivable()))
     return;
 
   /* First let's check for a deferred value */
@@ -90,9 +96,6 @@ void CVarManager::deserialize(CVar* cvar) {
   }
 
   /* We were either unable to find a deferred value or got an invalid value */
-  if (!cvar->isArchive() && !cvar->isInternalArchivable())
-    return;
-
 #if _WIN32
   hecl::SystemString filename =
       hecl::SystemString(m_store.getStoreRoot()) + _SYS_STR('/') + com_configfile->toWideLiteral();
@@ -119,10 +122,9 @@ void CVarManager::deserialize(CVar* cvar) {
         DNACVAR::CVar& tmp = *serialized;
 
         if (cvar->m_value != tmp.m_value) {
-          cvar->unlock();
-          cvar->fromLiteralToType(tmp.m_value, true);
+          CVarUnlocker lc(cvar);
+          cvar->fromLiteralToType(tmp.m_value);
           cvar->m_wasDeserialized = true;
-          cvar->lock();
         }
       }
     }
@@ -142,10 +144,9 @@ void CVarManager::deserialize(CVar* cvar) {
           const std::unique_ptr<athena::io::YAMLNode>& tmp = serialized->second;
 
           if (cvar->m_value != tmp->m_scalarString) {
-            cvar->unlock();
-            cvar->fromLiteralToType(tmp->m_scalarString, true);
+            CVarUnlocker lc(cvar);
+            cvar->fromLiteralToType(tmp->m_scalarString);
             cvar->m_wasDeserialized = true;
-            cvar->lock();
           }
         }
       }
@@ -326,5 +327,14 @@ void CVarManager::restoreDeveloper(bool oldDeveloper) {
   CVarUnlocker unlock(com_developer);
   com_developer->fromBoolean(oldDeveloper);
 }
+void CVarManager::proc() {
+  for (const auto& [name, cvar] : m_cvars) {
+    if (cvar->isModified() && !cvar->modificationRequiresRestart()) {
+      cvar->dispatch();
+      // Clear the modified flag now that we've informed everyone we've changed
+      cvar->clearModified();
+    }
+  }
+}
 
 } // namespace hecl

hecl/lib/ClientProcess.cpp

@@ -1,9 +1,14 @@
 #include "hecl/ClientProcess.hpp"
-#include "hecl/Database.hpp"
-#include "athena/FileReader.hpp"
+
+#include <algorithm>
+
 #include "hecl/Blender/Connection.hpp"
+#include "hecl/Database.hpp"
 #include "hecl/MultiProgressPrinter.hpp"
-#include "boo/IApplication.hpp"
+
+#include <athena/FileReader.hpp>
+#include <boo/IApplication.hpp>
+#include <logvisor/logvisor.hpp>
 
 #ifdef _WIN32
 #define WIN32_LEAN_AND_MEAN
@@ -63,7 +68,7 @@ void ClientProcess::BufferTransaction::run(blender::Token& btok) {
     return;
   }
   if (m_offset)
-    r.seek(m_offset, athena::Begin);
+    r.seek(m_offset, athena::SeekOrigin::Begin);
   r.readBytesToBuf(m_targetBuf, m_maxLen);
   m_complete = true;
 }

hecl/lib/Compilers.cpp

@@ -1,4 +1,8 @@
 #include "hecl/Compilers.hpp"
+
+#include <cstring>
+#include <utility>
+
 #include <boo/graphicsdev/GLSLMacros.hpp>
 #include <logvisor/logvisor.hpp>
 

hecl/lib/Console.cpp

@@ -1,12 +1,18 @@
-
 #include <hecl/Console.hpp>
 
-#include "hecl/Console.hpp"
-#include "hecl/CVarManager.hpp"
+#include <cstdio>
+#include <functional>
+#include <string>
+#include <vector>
+
 #include "hecl/CVar.hpp"
+#include "hecl/CVarManager.hpp"
 #include "hecl/hecl.hpp"
-#include "boo/graphicsdev/IGraphicsCommandQueue.hpp"
-#include "athena/Utility.hpp"
+
+#include <athena/Utility.hpp>
+#include <boo/IWindow.hpp>
+#include <boo/graphicsdev/IGraphicsCommandQueue.hpp>
+#include <logvisor/logvisor.hpp>
 
 namespace hecl {
 Console* Console::m_instance = nullptr;
@@ -168,13 +174,11 @@ void Console::init(boo::IWindow* window) {
 
 void Console::proc() {
   if (m_conHeight->isModified()) {
-    m_cachedConHeight = m_conHeight->toFloat();
-    m_conHeight->clearModified();
+    m_cachedConHeight = m_conHeight->toReal();
   }
 
   if (m_conSpeed->isModified()) {
-    m_cachedConSpeed = m_conSpeed->toFloat();
-    m_conSpeed->clearModified();
+    m_cachedConSpeed = m_conSpeed->toReal();
   }
 
   if (m_state == State::Opened) {

hecl/lib/MultiProgressPrinter.cpp

@@ -1,5 +1,10 @@
 #include "hecl/MultiProgressPrinter.hpp"
 
+#include <algorithm>
+#include <cstdio>
+
+#include "hecl/hecl.hpp"
+
 #define BOLD "\033[1m"
 #define NORMAL "\033[0m"
 #define PREV_LINE "\r\033[{:d}A"

hecl/lib/Pipeline.cpp

@@ -1,5 +1,6 @@
 #include "hecl/Pipeline.hpp"
-#include "athena/FileReader.hpp"
+
+#include <athena/FileReader.hpp>
 #include <zlib.h>
 
 namespace hecl {

hecl/lib/Project.cpp

@@ -2,6 +2,7 @@
 #include <cerrno>
 #include <cstdio>
 #include <cstring>
+#include <string>
 #include <system_error>
 
 #if _WIN32
@@ -9,11 +10,13 @@
 #include <unistd.h>
 #endif
 
+#include "hecl/ClientProcess.hpp"
 #include "hecl/Database.hpp"
 #include "hecl/Blender/Connection.hpp"
-#include "hecl/ClientProcess.hpp"
 #include "hecl/MultiProgressPrinter.hpp"
 
+#include <logvisor/logvisor.hpp>
+
 namespace hecl::Database {
 
 logvisor::Module LogModule("hecl::Database");

hecl/lib/ProjectPath.cpp

@@ -1,7 +1,10 @@
 #include "hecl/hecl.hpp"
-#include "hecl/Database.hpp"
+
 #include <regex>
 
+#include "hecl/Database.hpp"
+#include "hecl/FourCC.hpp"
+
 namespace hecl {
 static const SystemRegex regPATHCOMP(_SYS_STR("[/\\\\]*([^/\\\\]+)"), SystemRegex::ECMAScript | SystemRegex::optimize);
 static const SystemRegex regDRIVELETTER(_SYS_STR("^([^/]*)/"), SystemRegex::ECMAScript | SystemRegex::optimize);

hecl/lib/Runtime/FileStoreManager.cpp

@@ -1,5 +1,9 @@
 #include "hecl/Runtime.hpp"
-#include "logvisor/logvisor.hpp"
+
+#include "hecl/hecl.hpp"
+
+#include <logvisor/logvisor.hpp>
+
 #if _WIN32
 #include <ShlObj.h>
 #endif

hecl/lib/Runtime/HMDL_RT.cpp

@@ -1,6 +1,9 @@
 #include "hecl/HMDLMeta.hpp"
+
 #include "hecl/Runtime.hpp"
+
 #include <athena/MemoryReader.hpp>
+#include <logvisor/logvisor.hpp>
 
 namespace hecl::Runtime {
 static logvisor::Module HMDL_Log("HMDL");

hecl/lib/WideStringConvert.cpp

@@ -1,5 +1,5 @@
+#include <logvisor/logvisor.hpp>
 #include <utf8proc.h>
-#include "hecl/hecl.hpp"
 
 namespace hecl {
 static logvisor::Module Log("hecl-wsconv");