AxioDL
/
metaforce
mirror of https://github.com/AxioDL/metaforce.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge commit 'c46f861'

This commit is contained in:
Phillip Stephens 2018-01-13 23:38:17 -08:00
parent 7a815e2962 52c14848d9
commit 4543e2a87e
7 changed files with 132 additions and 89 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
hecl/include/hecl/CVar.hpp
View File

@ -22,17 +22,17 @@ enum class EType : atUint8
enum EFlags enum EFlags
{ {
All = -1, // NOTE: is this really necessary? It seems rather overkill System = (1 << 0),
System = (1 << 0), Game = (1 << 1),
Game = (1 << 1), Editor = (1 << 2),
Editor = (1 << 2), Gui = (1 << 3),
Gui = (1 << 3), Cheat = (1 << 4),
Cheat = (1 << 4), Hidden = (1 << 5),
Hidden = (1 << 5), ReadOnly = (1 << 6),
ReadOnly = (1 << 6), Archive = (1 << 7),
Archive = (1 << 7), InternalArchivable = (1 << 8),
Modified = (1 << 8), Modified = (1 << 9),
ModifyRestart = (1 << 9) /*!< If this bit is set, any modification will inform the user that a restart is required */ ModifyRestart = (1 << 10) /*!< If this bit is set, any modification will inform the user that a restart is required */
}; };
ENABLE_BITWISE_ENUM(EFlags) ENABLE_BITWISE_ENUM(EFlags)
@ -42,7 +42,6 @@ public:
DECL_YAML DECL_YAML
String<-1> m_name; String<-1> m_name;
String<-1> m_value; String<-1> m_value;
Value<EType> m_type;
}; };
struct CVarContainer : public athena::io::DNAYaml<athena::BigEndian> struct CVarContainer : public athena::io::DNAYaml<athena::BigEndian>
@ -93,8 +92,8 @@ public:
bool fromInteger(int val); bool fromInteger(int val);
bool fromLiteral(std::string_view val); bool fromLiteral(std::string_view val);
bool fromLiteral(std::wstring_view val); bool fromLiteral(std::wstring_view val);
bool fromLiteralToType(std::string_view val); bool fromLiteralToType(std::string_view val, bool setDefault = false);
bool fromLiteralToType(std::wstring_view val); bool fromLiteralToType(std::wstring_view val, bool setDefault = false);
bool isFloat() const { return m_type == EType::Float; } bool isFloat() const { return m_type == EType::Float; }
bool isBoolean() const { return m_type == EType::Boolean; } bool isBoolean() const { return m_type == EType::Boolean; }
@ -107,6 +106,9 @@ public:
bool isCheat() const; bool isCheat() const;
bool isHidden() const; bool isHidden() const;
bool isArchive() const; bool isArchive() const;
bool isInternalArchivable() const;
bool wasDeserialized() const;
bool hasDefaultValue() const;
void clearModified(); void clearModified();
void setModified(); void setModified();
@ -132,11 +134,13 @@ public:
private: private:
void dispatch(); void dispatch();
EType m_type;
std::string m_help; std::string m_help;
std::string m_defaultValue; std::string m_defaultValue;
EFlags m_flags; EFlags m_flags;
EFlags m_oldFlags; EFlags m_oldFlags;
bool m_unlocked = false; bool m_unlocked = false;
bool m_wasDeserialized = false;
CVarManager& m_mgr; CVarManager& m_mgr;

7
hecl/include/hecl/CVarManager.hpp
View File

@ -11,7 +11,9 @@ namespace Runtime
{ {
class FileStoreManager; class FileStoreManager;
} }
extern CVar* com_developer;
extern CVar* com_configfile;
extern CVar* com_enableCheats;
class CVarManager final class CVarManager final
{ {
using CVarContainer = DNACVAR::CVarContainer; using CVarContainer = DNACVAR::CVarContainer;
@ -21,8 +23,7 @@ class CVarManager final
CVar* ret(new CVar(name, value, help, flags, *this)); CVar* ret(new CVar(name, value, help, flags, *this));
if (registerCVar(ret)) if (registerCVar(ret))
{ {
if (ret->isArchive()) deserialize(ret);
deserialize(ret);
return ret; return ret;
} }
delete ret; delete ret;

9
hecl/include/hecl/Console.hpp
View File

@ -10,7 +10,7 @@
namespace hecl namespace hecl
{ {
class CVar;
struct SConsoleCommand struct SConsoleCommand
{ {
std::string m_displayName; std::string m_displayName;
@ -67,11 +67,14 @@ private:
std::vector<std::string> m_commandHistory; std::vector<std::string> m_commandHistory;
int m_cursorPosition = -1; int m_cursorPosition = -1;
int m_currentCommand = -1; int m_currentCommand = -1;
int m_maxLines = 0; size_t m_maxLines = 0;
bool m_overwrite : 1; bool m_overwrite : 1;
bool m_cursorAtEnd : 1; bool m_cursorAtEnd : 1;
State m_state = State::Closed; State m_state = State::Closed;
CVar* m_conSpeed;
CVar* m_conHeight;
float m_cachedConSpeed;
float m_cachedConHeight;
public: public:
Console(class CVarManager*); Console(class CVarManager*);
void registerCommand(std::string_view name, std::string_view helpText, std::string_view usage, const std::function<void(Console*, const std::vector<std::string>&)>&& func); void registerCommand(std::string_view name, std::string_view helpText, std::string_view usage, const std::function<void(Console*, const std::vector<std::string>&)>&& func);

16
hecl/lib/CVar.cpp
View File

@ -140,7 +140,7 @@ atVec4f CVar::toVec4f(bool* isValid) const
return atVec4f{}; return atVec4f{};
} }
if (isValid != NULL) if (isValid != nullptr)
*isValid = true; *isValid = true;
atVec4f vec; atVec4f vec;
@ -346,7 +346,7 @@ bool CVar::fromLiteral(std::wstring_view val)
return true; return true;
} }
bool CVar::fromLiteralToType(std::string_view val) bool CVar::fromLiteralToType(std::string_view val, bool setDefault)
{ {
switch (m_type) switch (m_type)
{ {
@ -382,10 +382,12 @@ bool CVar::fromLiteralToType(std::string_view val)
return fromVec4f(vec); return fromVec4f(vec);
} }
} }
if (setDefault)
m_value = m_defaultValue;
return false; return false;
} }
bool CVar::fromLiteralToType(std::wstring_view val) bool CVar::fromLiteralToType(std::wstring_view val, bool setDefault)
{ {
switch (m_type) switch (m_type)
{ {
@ -421,6 +423,8 @@ bool CVar::fromLiteralToType(std::wstring_view val)
return fromVec4f(vec); return fromVec4f(vec);
} }
} }
if (setDefault)
m_value = m_defaultValue;
return false; return false;
} }
@ -435,6 +439,12 @@ bool CVar::isHidden() const { return int(m_flags & EFlags::Hidden) != 0; }
bool CVar::isArchive() const { return int(m_flags & EFlags::Archive) != 0; } bool CVar::isArchive() const { return int(m_flags & EFlags::Archive) != 0; }
bool CVar::isInternalArchivable() const { return int(m_flags & EFlags::InternalArchivable) != 0; }
bool CVar::wasDeserialized() const { return m_wasDeserialized; }
bool CVar::hasDefaultValue() const { return m_defaultValue == m_value; }
void CVar::clearModified() void CVar::clearModified()
{ {
if (!modificationRequiresRestart()) if (!modificationRequiresRestart())

24
hecl/lib/CVarManager.cpp
View File

@ -15,14 +15,14 @@ CVar* com_enableCheats = nullptr;
CVarManager* CVarManager::m_instance = nullptr; CVarManager* CVarManager::m_instance = nullptr;
logvisor::Module CVarLog("CVarManager"); static logvisor::Module CVarLog("CVarManager");
CVarManager::CVarManager(hecl::Runtime::FileStoreManager& store, bool useBinary) CVarManager::CVarManager(hecl::Runtime::FileStoreManager& store, bool useBinary)
: m_store(store), : m_store(store),
m_useBinary(useBinary) m_useBinary(useBinary)
{ {
m_instance = this; 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);
com_developer = newCVar("developer", "Enables developer mode", false, (CVar::EFlags::System | CVar::EFlags::Cheat | CVar::EFlags::ReadOnly)); com_developer = newCVar("developer", "Enables developer mode", false, (CVar::EFlags::System | CVar::EFlags::ReadOnly | CVar::EFlags::InternalArchivable));
com_enableCheats = newCVar("iamaweiner", "Enable cheats", false, (CVar::EFlags::System | CVar::EFlags::ReadOnly | CVar::EFlags::Hidden)); com_enableCheats = newCVar("iamaweiner", "Enable cheats", false, (CVar::EFlags::System | CVar::EFlags::ReadOnly | CVar::EFlags::Hidden));
} }
@ -83,7 +83,7 @@ std::vector<CVar*> CVarManager::cvars() const
void CVarManager::deserialize(CVar* cvar) void CVarManager::deserialize(CVar* cvar)
{ {
if (!cvar || !cvar->isArchive()) if (!cvar || (!cvar->isArchive() && !cvar->isInternalArchivable()))
return; return;
CVarContainer container; CVarContainer container;
@ -122,14 +122,14 @@ void CVarManager::deserialize(CVar* cvar)
if (serialized != container.cvars.end()) if (serialized != container.cvars.end())
{ {
DNACVAR::CVar& tmp = *serialized; DNACVAR::CVar& tmp = *serialized;
if (tmp.m_type != cvar->type())
{
CVarLog.report(logvisor::Error, _S("Stored type for %s does not match actual type!"), tmp.m_name.c_str());
return;
}
if (cvar->m_value != tmp.m_value) if (cvar->m_value != tmp.m_value)
cvar->m_value = tmp.m_value; {
cvar->unlock();
cvar->fromLiteralToType(tmp.m_value, true);
cvar->m_wasDeserialized = true;
cvar->lock();
}
} }
} }
} }
@ -138,13 +138,13 @@ void CVarManager::serialize()
{ {
CVarContainer container; CVarContainer container;
for (const std::pair<std::string, CVar*>& pair : m_cvars) for (const std::pair<std::string, CVar*>& pair : m_cvars)
if (pair.second->isArchive()) if (pair.second->isArchive() || (pair.second->isInternalArchivable() && pair.second->wasDeserialized() && !pair.second->hasDefaultValue()))
{ {
CVar tmp = *pair.second; CVar tmp = *pair.second;
container.cvars.push_back(tmp); container.cvars.push_back(tmp);
} }
container.cvarCount = container.cvars.size(); container.cvarCount = atUint32(container.cvars.size());
#if _WIN32 #if _WIN32
hecl::SystemString filename = hecl::SystemString(m_store.getStoreRoot()) + _S('/') + com_configfile->toWideLiteral(); hecl::SystemString filename = hecl::SystemString(m_store.getStoreRoot()) + _S('/') + com_configfile->toWideLiteral();
@ -173,7 +173,7 @@ CVarManager* CVarManager::instance()
return m_instance; return m_instance;
} }
void CVarManager::list(Console* con, const std::vector<std::string> &args) void CVarManager::list(Console* con, const std::vector<std::string>& /*args*/)
{ {
for (const auto& cvar : m_cvars) for (const auto& cvar : m_cvars)
{ {

86
hecl/lib/Console.cpp
View File

@ -16,6 +16,10 @@ Console::Console(CVarManager* cvarMgr)
registerCommand("listCVars", "Lists all available CVars", "", std::bind(&CVarManager::list, cvarMgr, std::placeholders::_1, std::placeholders::_2)); registerCommand("listCVars", "Lists all available CVars", "", std::bind(&CVarManager::list, cvarMgr, std::placeholders::_1, std::placeholders::_2));
registerCommand("setCVar", "Sets a given Console Variable to the specified value", "<cvar> <value>", std::bind(&CVarManager::setCVar, cvarMgr, std::placeholders::_1, std::placeholders::_2)); registerCommand("setCVar", "Sets a given Console Variable to the specified value", "<cvar> <value>", std::bind(&CVarManager::setCVar, cvarMgr, std::placeholders::_1, std::placeholders::_2));
registerCommand("getCVar", "Prints the value stored in the specified Console Variable", "<cvar>", std::bind(&CVarManager::getCVar, cvarMgr, std::placeholders::_1, std::placeholders::_2)); registerCommand("getCVar", "Prints the value stored in the specified Console Variable", "<cvar>", std::bind(&CVarManager::getCVar, cvarMgr, std::placeholders::_1, std::placeholders::_2));
m_conSpeed = cvarMgr->findOrMakeCVar("con_speed", "Speed at which the console opens and closes, calculated as pixels per second", 1.f,
hecl::CVar::EFlags::System | hecl::CVar::EFlags::Archive);
m_conHeight = cvarMgr->findOrMakeCVar("con_height", "Maximum absolute height of the console, height is calculated from the top of the window, expects values ranged from [0.f,1.f]", 0.5f,
hecl::CVar::EFlags::System | hecl::CVar::EFlags::Archive);
} }
void Console::registerCommand(std::string_view name, std::string_view helpText, std::string_view usage, const std::function<void(Console*, const std::vector<std::string> &)>&& func) void Console::registerCommand(std::string_view name, std::string_view helpText, std::string_view usage, const std::function<void(Console*, const std::vector<std::string> &)>&& func)
@ -110,6 +114,18 @@ void Console::report(Level level, const char* fmt, ...)
void Console::proc() void Console::proc()
{ {
if (m_conHeight->isModified())
{
m_cachedConHeight = m_conHeight->toFloat();
m_conHeight->clearModified();
}
if (m_conSpeed->isModified())
{
m_cachedConSpeed = m_conSpeed->toFloat();
m_conSpeed->clearModified();
}
if (m_state == State::Opened) if (m_state == State::Opened)
{ {
printf("\r%s ", m_commandString.c_str()); printf("\r%s ", m_commandString.c_str());
@ -121,22 +137,22 @@ void Console::proc()
m_state = State::Closed; m_state = State::Closed;
if (m_cursorPosition > (int)m_commandString.size() - 1) if (m_cursorPosition > int(m_commandString.size() - 1))
m_cursorPosition = (int)m_commandString.size() - 1; m_cursorPosition = int(m_commandString.size() - 1);
if (m_cursorPosition < -1) if (m_cursorPosition < -1)
m_cursorPosition = -1; m_cursorPosition = -1;
if (m_logOffset > (int)m_log.size() - 1) if (m_logOffset > int(m_log.size() - 1))
m_logOffset = (int)m_log.size() - 1; m_logOffset = int(m_log.size() - 1);
if (m_logOffset < 0) if (m_logOffset < 0)
m_logOffset = 0; m_logOffset = 0;
} }
void Console::draw(boo::IGraphicsCommandQueue* gfxQ) void Console::draw(boo::IGraphicsCommandQueue* /*gfxQ*/)
{ {
} }
void Console::handleCharCode(unsigned long chr, boo::EModifierKey mod, bool repeat) void Console::handleCharCode(unsigned long chr, boo::EModifierKey /*mod*/, bool /*repeat*/)
{ {
if (chr == U'`' || chr == U'~') if (chr == U'`' || chr == U'~')
{ {
@ -148,21 +164,21 @@ void Console::handleCharCode(unsigned long chr, boo::EModifierKey mod, bool repe
if (m_state == State::Opened) if (m_state == State::Opened)
{ {
if (!m_commandString.empty() && m_cursorPosition + 1 < m_commandString.size()) if (!m_commandString.empty() && m_cursorPosition + 1 < int(m_commandString.size()))
{ {
if (m_overwrite) if (m_overwrite)
m_commandString[m_cursorPosition + 1] = chr; m_commandString[unsigned(m_cursorPosition + 1)] = char(chr);
else else
m_commandString.insert(m_commandString.begin() + m_cursorPosition + 1, chr); m_commandString.insert(m_commandString.begin() + m_cursorPosition + 1, char(chr));
} }
else else
m_commandString += chr; m_commandString += char(chr);
++m_cursorPosition; ++m_cursorPosition;
} }
} }
void Console::handleSpecialKeyDown(boo::ESpecialKey sp, boo::EModifierKey mod, bool repeat) void Console::handleSpecialKeyDown(boo::ESpecialKey sp, boo::EModifierKey mod, bool /*repeat*/)
{ {
if (m_state != Opened) if (m_state != Opened)
return; return;
@ -178,9 +194,9 @@ void Console::handleSpecialKeyDown(boo::ESpecialKey sp, boo::EModifierKey mod, b
{ {
if (int(mod & boo::EModifierKey::Ctrl) != 0) if (int(mod & boo::EModifierKey::Ctrl) != 0)
{ {
int index = m_commandString.rfind(' ', m_cursorPosition - 1); size_t index = m_commandString.rfind(' ', size_t(m_cursorPosition - 1));
if (index == (int)std::string::npos) if (index == std::string::npos)
{ {
m_commandString.clear(); m_commandString.clear();
m_cursorPosition = -1; m_cursorPosition = -1;
@ -188,14 +204,14 @@ void Console::handleSpecialKeyDown(boo::ESpecialKey sp, boo::EModifierKey mod, b
else else
{ {
m_commandString.erase(index, (index - m_commandString.size())); m_commandString.erase(index, (index - m_commandString.size()));
m_cursorPosition = index; m_cursorPosition = int(index);
} }
break; break;
} }
if (m_cursorPosition < 0) if (m_cursorPosition < 0)
break; break;
m_commandString.erase(m_cursorPosition, 1); m_commandString.erase(size_t(m_cursorPosition), 1);
--m_cursorPosition; --m_cursorPosition;
} }
break; break;
@ -205,25 +221,25 @@ void Console::handleSpecialKeyDown(boo::ESpecialKey sp, boo::EModifierKey mod, b
if (!m_commandString.empty()) if (!m_commandString.empty())
{ {
// Don't try to delete if the cursor is at the end of the line // Don't try to delete if the cursor is at the end of the line
if ((m_cursorPosition + 1) >= (int)m_commandString.size()) if ((m_cursorPosition + 1) >= int(m_commandString.size()))
break; break;
if (int(mod & boo::EModifierKey::Ctrl) != 0) if (int(mod & boo::EModifierKey::Ctrl) != 0)
{ {
int index = m_commandString.find_first_of(' ', m_cursorPosition + 1); size_t index = m_commandString.find_first_of(' ', size_t(m_cursorPosition + 1));
if (index != std::string::npos) if (index != std::string::npos)
m_commandString.erase(m_cursorPosition + 1, index + 1); m_commandString.erase(size_t(m_cursorPosition + 1), index + 1);
else else
m_commandString.erase(m_cursorPosition + 1, (m_cursorPosition + 1) - m_commandString.size()); m_commandString.erase(size_t(m_cursorPosition + 1), size_t(m_cursorPosition + 1) - m_commandString.size());
break; break;
} }
m_commandString.erase(m_cursorPosition + 1, 1); m_commandString.erase(size_t(m_cursorPosition + 1), 1);
} }
break; break;
} }
case boo::ESpecialKey::PgUp: case boo::ESpecialKey::PgUp:
{ {
if (m_logOffset < (int)(m_log.size() - m_maxLines) - 1) if (m_logOffset < int(m_log.size() - m_maxLines) - 1)
m_logOffset++; m_logOffset++;
break; break;
} }
@ -250,7 +266,7 @@ void Console::handleSpecialKeyDown(boo::ESpecialKey sp, boo::EModifierKey mod, b
break; break;
if (int(mod & boo::EModifierKey::Ctrl) != 0) if (int(mod & boo::EModifierKey::Ctrl) != 0)
m_cursorPosition = (int)m_commandString.rfind(' ', m_cursorPosition) - 1; m_cursorPosition = int(m_commandString.rfind(' ', size_t(m_cursorPosition) - 1));
else else
m_cursorPosition--; m_cursorPosition--;
@ -260,19 +276,19 @@ void Console::handleSpecialKeyDown(boo::ESpecialKey sp, boo::EModifierKey mod, b
} }
case boo::ESpecialKey::Right: case boo::ESpecialKey::Right:
{ {
if (m_cursorPosition >= (int)m_commandString.size() - 1) if (m_cursorPosition >= int(m_commandString.size() - 1))
break; break;
if (int(mod & boo::EModifierKey::Ctrl) != 0) if (int(mod & boo::EModifierKey::Ctrl) != 0)
{ {
if (m_commandString[m_cursorPosition] == ' ') if (m_commandString[size_t(m_cursorPosition)] == ' ')
m_cursorPosition++; m_cursorPosition++;
int tmpPos = m_commandString.find(' ', m_cursorPosition); size_t tmpPos = m_commandString.find(' ', size_t(m_cursorPosition));
if (tmpPos == std::string::npos) if (tmpPos == std::string::npos)
m_cursorPosition = m_commandString.size() - 1; m_cursorPosition = int(m_commandString.size() - 1);
else else
m_cursorPosition = tmpPos; m_cursorPosition = int(tmpPos);
} }
else else
m_cursorPosition++; m_cursorPosition++;
@ -289,11 +305,11 @@ void Console::handleSpecialKeyDown(boo::ESpecialKey sp, boo::EModifierKey mod, b
m_currentCommand++; m_currentCommand++;
if (m_currentCommand > (int)m_commandHistory.size() - 1) if (m_currentCommand > int(m_commandHistory.size() - 1))
m_currentCommand = (int)m_commandHistory.size() - 1; m_currentCommand = int(m_commandHistory.size() - 1);
m_commandString = m_commandHistory[m_currentCommand]; m_commandString = m_commandHistory[size_t(m_currentCommand)];
m_cursorPosition = m_commandString.size(); m_cursorPosition = int(m_commandString.size() - 1);
break; break;
} }
case boo::ESpecialKey::Down: case boo::ESpecialKey::Down:
@ -303,28 +319,28 @@ void Console::handleSpecialKeyDown(boo::ESpecialKey sp, boo::EModifierKey mod, b
m_currentCommand--; m_currentCommand--;
if (m_currentCommand >= 0) if (m_currentCommand >= 0)
{ {
m_commandString = m_commandHistory[m_currentCommand]; m_commandString = m_commandHistory[size_t(m_currentCommand)];
} }
else if (m_currentCommand <= -1) else if (m_currentCommand <= -1)
{ {
m_currentCommand = -1; m_currentCommand = -1;
m_commandString.clear(); m_commandString.clear();
} }
m_cursorPosition = m_commandString.size(); m_cursorPosition = int(m_commandString.size());
break; break;
} }
case boo::ESpecialKey::Home: case boo::ESpecialKey::Home:
m_cursorPosition = -1; m_cursorPosition = -1;
break; break;
case boo::ESpecialKey::End: case boo::ESpecialKey::End:
m_cursorPosition = m_commandString.size() - 1; m_cursorPosition = int(m_commandString.size() - 1);
break; break;
default: default:
break; break;
} }
} }
void Console::handleSpecialKeyUp(boo::ESpecialKey sp, boo::EModifierKey mod) void Console::handleSpecialKeyUp(boo::ESpecialKey /*sp*/, boo::EModifierKey /*mod*/)
{ {
} }

47
hecl/test/main.cpp
View File

@ -12,16 +12,12 @@
using namespace std::literals; using namespace std::literals;
namespace hecl::Database
{
std::vector<const struct DataSpecEntry*> DATA_SPEC_REGISTRY;
}
struct HECLWindowCallback : boo::IWindowCallback struct HECLWindowCallback : boo::IWindowCallback
{ {
bool m_sizeDirty = false; bool m_sizeDirty = false;
boo::SWindowRect m_latestSize; boo::SWindowRect m_latestSize;
void resized(const boo::SWindowRect& rect, bool sync) virtual ~HECLWindowCallback();
void resized(const boo::SWindowRect& rect, bool /*sync*/)
{ {
m_sizeDirty = true; m_sizeDirty = true;
m_latestSize = rect; m_latestSize = rect;
@ -47,6 +43,11 @@ struct HECLWindowCallback : boo::IWindowCallback
} }
}; };
HECLWindowCallback::~HECLWindowCallback()
{
}
struct HECLApplicationCallback : boo::IApplicationCallback struct HECLApplicationCallback : boo::IApplicationCallback
{ {
HECLWindowCallback m_windowCb; HECLWindowCallback m_windowCb;
@ -57,13 +58,15 @@ struct HECLApplicationCallback : boo::IApplicationCallback
bool m_running = true; bool m_running = true;
HECLApplicationCallback() HECLApplicationCallback()
: m_fileStoreMgr("heclTest"), : m_fileStoreMgr(_S("heclTest")),
m_cvarManager(m_fileStoreMgr), m_cvarManager(m_fileStoreMgr),
m_console(&m_cvarManager) m_console(&m_cvarManager)
{ {
m_console.registerCommand("quit"sv, "Quits application"sv, "", std::bind(&HECLApplicationCallback::quit, this, std::placeholders::_1, std::placeholders::_2)); m_console.registerCommand("quit"sv, "Quits application"sv, "", std::bind(&HECLApplicationCallback::quit, this, std::placeholders::_1, std::placeholders::_2));
} }
virtual ~HECLApplicationCallback();
int appMain(boo::IApplication* app) int appMain(boo::IApplication* app)
{ {
hecl::VerbosityLevel = 2; hecl::VerbosityLevel = 2;
@ -123,7 +126,7 @@ struct HECLApplicationCallback : boo::IApplicationCallback
gfxF->commitTransaction([&](boo::IGraphicsDataFactory::Context& ctx) -> bool gfxF->commitTransaction([&](boo::IGraphicsDataFactory::Context& ctx) -> bool
{ {
boo::SWindowRect mainWindowRect = m_mainWindow->getWindowFrame(); boo::SWindowRect mainWindowRect = m_mainWindow->getWindowFrame();
renderTex = ctx.newRenderTexture(mainWindowRect.size[0], mainWindowRect.size[1], renderTex = ctx.newRenderTexture(size_t(mainWindowRect.size[0]), size_t(mainWindowRect.size[1]),
boo::TextureClampMode::Repeat, 0, 0); boo::TextureClampMode::Repeat, 0, 0);
/* Generate meta structure (usually statically serialized) */ /* Generate meta structure (usually statically serialized) */
@ -169,8 +172,8 @@ struct HECLApplicationCallback : boo::IApplicationCallback
for (int i=0 ; i<256 ; ++i) for (int i=0 ; i<256 ; ++i)
for (int j=0 ; j<256 ; ++j) for (int j=0 ; j<256 ; ++j)
{ {
tex[i][j][0] = i; tex[i][j][0] = uint8_t(i);
tex[i][j][1] = j; tex[i][j][1] = uint8_t(i);
tex[i][j][2] = 0; tex[i][j][2] = 0;
tex[i][j][3] = 0xff; tex[i][j][3] = 0xff;
} }
@ -217,8 +220,8 @@ struct HECLApplicationCallback : boo::IApplicationCallback
if (m_windowCb.m_sizeDirty) if (m_windowCb.m_sizeDirty)
{ {
gfxQ->resizeRenderTexture(renderTex, gfxQ->resizeRenderTexture(renderTex,
m_windowCb.m_latestSize.size[0], size_t(m_windowCb.m_latestSize.size[0]),
m_windowCb.m_latestSize.size[1]); size_t(m_windowCb.m_latestSize.size[1]));
m_windowCb.m_sizeDirty = false; m_windowCb.m_sizeDirty = false;
} }
@ -230,12 +233,12 @@ struct HECLApplicationCallback : boo::IApplicationCallback
r.location[1] = 0; r.location[1] = 0;
gfxQ->setViewport(r); gfxQ->setViewport(r);
gfxQ->setScissor(r); gfxQ->setScissor(r);
float rgba[] = {sinf(frameIdx / 60.0), cosf(frameIdx / 60.0), 0.0, 1.0}; float rgba[] = {sinf(frameIdx / 60.0f), cosf(frameIdx / 60.0f), 0.0f, 1.0f};
gfxQ->setClearColor(rgba); gfxQ->setClearColor(rgba);
gfxQ->clearTarget(); gfxQ->clearTarget();
vuboData.modelview[3][0] = sinf(frameIdx / 60.0) * 0.5; vuboData.modelview[3][0] = sinf(frameIdx / 60.0f) * 0.5f;
vuboData.modelview[3][1] = cosf(frameIdx / 60.0) * 0.5; vuboData.modelview[3][1] = cosf(frameIdx / 60.0f) * 0.5f;
vubo.cast<boo::IGraphicsBufferD>()->load(&vuboData, sizeof(vuboData)); vubo.cast<boo::IGraphicsBufferD>()->load(&vuboData, sizeof(vuboData));
gfxQ->setShaderDataBinding(binding); gfxQ->setShaderDataBinding(binding);
@ -248,31 +251,32 @@ struct HECLApplicationCallback : boo::IApplicationCallback
} }
std::unique_lock<std::mutex> finallk(loadmt); std::unique_lock<std::mutex> finallk(loadmt);
m_cvarManager.serialize();
finallk.unlock(); finallk.unlock();
gfxQ->stopRenderer(); gfxQ->stopRenderer();
loadcv.notify_one(); loadcv.notify_one();
loaderThr.join(); loaderThr.join();
return 0; return 0;
} }
void appQuitting(boo::IApplication* app) void appQuitting(boo::IApplication* /*app*/)
{ {
m_running = false; m_running = false;
} }
void quit(hecl::Console* con, const std::vector<std::string>& args) void quit(hecl::Console* /*con*/, const std::vector<std::string>& /*args*/)
{ {
m_running = false; m_running = false;
} }
}; };
void AthenaExcHandler(athena::error::Level level, void AthenaExcHandler(athena::error::Level level,
const char* file, const char* function, const char* file, const char* /*function*/,
int line, const char* fmt, ...) int line, const char* fmt, ...)
{ {
static logvisor::Module Log("heclTest::AthenaExcHandler"); static logvisor::Module Log("heclTest::AthenaExcHandler");
va_list ap; va_list ap;
va_start(ap, fmt); va_start(ap, fmt);
Log.reportSource(logvisor::Level(level), file, line, fmt, ap); Log.reportSource(logvisor::Level(level), file, uint32_t(line), fmt, ap);
va_end(ap); va_end(ap);
} }
@ -324,3 +328,8 @@ int APIENTRY wWinMain(HINSTANCE hInstance, HINSTANCE, LPWSTR lpCmdLine, int)
return wmain(argc+1, booArgv); return wmain(argc+1, booArgv);
} }
#endif #endif
HECLApplicationCallback::~HECLApplicationCallback()
{
}