Cool_Tools/ImHex
1
0
Fork 0
mirror of synced 2025-01-29 19:17:28 +01:00
Code Releases Wiki Activity

sys: First attempt at reducing build times

Browse Source
This commit is contained in:
WerWolv 2021-08-29 14:18:45 +02:00
parent f60f9f9fc9
commit 02d31d2d2a
38 changed files with 2885 additions and 1535 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3811
external/nlohmann_json/include/nlohmann/json.hpp vendored
View File

File diff suppressed because it is too large Load Diff

78
external/nlohmann_json/include/nlohmann/json_fwd.hpp vendored Normal file
View File

@ -0,0 +1,78 @@
#ifndef INCLUDE_NLOHMANN_JSON_FWD_HPP_
#define INCLUDE_NLOHMANN_JSON_FWD_HPP_
#include <cstdint> // int64_t, uint64_t
#include <map> // map
#include <memory> // allocator
#include <string> // string
#include <vector> // vector
/*!
@brief namespace for Niels Lohmann
@see https://github.com/nlohmann
@since version 1.0.0
*/
namespace nlohmann
{
/*!
@brief default JSONSerializer template argument
This serializer ignores the template arguments and uses ADL
([argument-dependent lookup](https://en.cppreference.com/w/cpp/language/adl))
for serialization.
*/
template<typename T = void, typename SFINAE = void>
struct adl_serializer;
template<template<typename U, typename V, typename... Args> class ObjectType =
std::map,
template<typename U, typename... Args> class ArrayType = std::vector,
class StringType = std::string, class BooleanType = bool,
class NumberIntegerType = std::int64_t,
class NumberUnsignedType = std::uint64_t,
class NumberFloatType = double,
template<typename U> class AllocatorType = std::allocator,
template<typename T, typename SFINAE = void> class JSONSerializer =
adl_serializer,
class BinaryType = std::vector<std::uint8_t>>
class basic_json;
/*!
@brief JSON Pointer
A JSON pointer defines a string syntax for identifying a specific value
within a JSON document. It can be used with functions `at` and
`operator[]`. Furthermore, JSON pointers are the base for JSON patches.
@sa [RFC 6901](https://tools.ietf.org/html/rfc6901)
@since version 2.0.0
*/
template<typename BasicJsonType>
class json_pointer;
/*!
@brief default JSON class
This type is the default specialization of the @ref basic_json class which
uses the standard template types.
@since version 1.0.0
*/
using json = basic_json<>;
template<class Key, class T, class IgnoredLess, class Allocator>
struct ordered_map;
/*!
@brief ordered JSON class
This type preserves the insertion order of object keys.
@since version 3.9.0
*/
using ordered_json = basic_json<nlohmann::ordered_map>;
} // namespace nlohmann
#endif // INCLUDE_NLOHMANN_JSON_FWD_HPP_

14
plugins/builtin/source/content/command_palette_commands.cpp
View File

@ -1,4 +1,4 @@
#include <hex/plugin.hpp>
#include <hex/api/content_registry.hpp>
#include "math_evaluator.hpp"
@ -6,8 +6,8 @@ namespace hex::plugin::builtin {
void registerCommandPaletteCommands() {
hex::ContentRegistry::CommandPaletteCommands::add(
hex::ContentRegistry::CommandPaletteCommands::Type::SymbolCommand,
ContentRegistry::CommandPaletteCommands::add(
ContentRegistry::CommandPaletteCommands::Type::SymbolCommand,
"#", "hex.builtin.command.calc.desc",
[](auto input) {
hex::MathEvaluator evaluator;
@ -27,8 +27,8 @@ namespace hex::plugin::builtin {
return hex::format("#{0} = ???", input.data());
});
hex::ContentRegistry::CommandPaletteCommands::add(
hex::ContentRegistry::CommandPaletteCommands::Type::KeywordCommand,
ContentRegistry::CommandPaletteCommands::add(
ContentRegistry::CommandPaletteCommands::Type::KeywordCommand,
"/web", "hex.builtin.command.web.desc",
[](auto input) {
return hex::format("hex.builtin.command.web.result"_lang, input.data());
@ -37,8 +37,8 @@ namespace hex::plugin::builtin {
hex::openWebpage(input);
});
hex::ContentRegistry::CommandPaletteCommands::add(
hex::ContentRegistry::CommandPaletteCommands::Type::SymbolCommand,
ContentRegistry::CommandPaletteCommands::add(
ContentRegistry::CommandPaletteCommands::Type::SymbolCommand,
"$", "hex.builtin.command.cmd.desc",
[](auto input) {
return hex::format("hex.builtin.command.cmd.result"_lang, input.data());

42
plugins/builtin/source/content/data_inspector.cpp
View File

@ -1,4 +1,4 @@
#include <hex/plugin.hpp>
#include <hex/api/content_registry.hpp>
#include <hex/helpers/utils.hpp>
@ -18,9 +18,9 @@ namespace hex::plugin::builtin {
void registerDataInspectorEntries() {
using Style = hex::ContentRegistry::DataInspector::NumberDisplayStyle;
using Style = ContentRegistry::DataInspector::NumberDisplayStyle;
hex::ContentRegistry::DataInspector::add("hex.builtin.inspector.binary", sizeof(u8), [](auto buffer, auto endian, auto style) {
ContentRegistry::DataInspector::add("hex.builtin.inspector.binary", sizeof(u8), [](auto buffer, auto endian, auto style) {
std::string binary;
for (u8 i = 0; i < 8; i++)
binary += ((buffer[0] << i) & 0x80) == 0 ? '0' : '1';
@ -31,76 +31,76 @@ namespace hex::plugin::builtin {
};
});
hex::ContentRegistry::DataInspector::add("hex.builtin.inspector.u8", sizeof(u8), [](auto buffer, auto endian, auto style) {
ContentRegistry::DataInspector::add("hex.builtin.inspector.u8", sizeof(u8), [](auto buffer, auto endian, auto style) {
auto format = (style == Style::Decimal) ? "{0:d}" : ((style == Style::Hexadecimal) ? "0x{0:X}" : "{0:#o}");
auto value = hex::format(format, *reinterpret_cast<u8*>(buffer.data()));
return [value] { ImGui::TextUnformatted(value.c_str()); return value; };
});
hex::ContentRegistry::DataInspector::add("hex.builtin.inspector.s8", sizeof(s8), [](auto buffer, auto endian, auto style) {
ContentRegistry::DataInspector::add("hex.builtin.inspector.s8", sizeof(s8), [](auto buffer, auto endian, auto style) {
auto format = (style == Style::Decimal) ? "{0:d}" : ((style == Style::Hexadecimal) ? "0x{0:X}" : "{0:#o}");
auto value = hex::format(format, *reinterpret_cast<s8*>(buffer.data()));
return [value] { ImGui::TextUnformatted(value.c_str()); return value; };
});
hex::ContentRegistry::DataInspector::add("hex.builtin.inspector.u16", sizeof(u16), [](auto buffer, auto endian, auto style) {
ContentRegistry::DataInspector::add("hex.builtin.inspector.u16", sizeof(u16), [](auto buffer, auto endian, auto style) {
auto format = (style == Style::Decimal) ? "{0:d}" : ((style == Style::Hexadecimal) ? "0x{0:X}" : "{0:#o}");
auto value = hex::format(format, hex::changeEndianess(*reinterpret_cast<u16*>(buffer.data()), endian));
return [value] { ImGui::TextUnformatted(value.c_str()); return value; };
});
hex::ContentRegistry::DataInspector::add("hex.builtin.inspector.s16", sizeof(s16), [](auto buffer, auto endian, auto style) {
ContentRegistry::DataInspector::add("hex.builtin.inspector.s16", sizeof(s16), [](auto buffer, auto endian, auto style) {
auto format = (style == Style::Decimal) ? "{0:d}" : ((style == Style::Hexadecimal) ? "0x{0:X}" : "{0:#o}");
auto value = hex::format(format, hex::changeEndianess(*reinterpret_cast<s16*>(buffer.data()), endian));
return [value] { ImGui::TextUnformatted(value.c_str()); return value; };
});
hex::ContentRegistry::DataInspector::add("hex.builtin.inspector.u32", sizeof(u32), [](auto buffer, auto endian, auto style) {
ContentRegistry::DataInspector::add("hex.builtin.inspector.u32", sizeof(u32), [](auto buffer, auto endian, auto style) {
auto format = (style == Style::Decimal) ? "{0:d}" : ((style == Style::Hexadecimal) ? "0x{0:X}" : "{0:#o}");
auto value = hex::format(format, hex::changeEndianess(*reinterpret_cast<u32*>(buffer.data()), endian));
return [value] { ImGui::TextUnformatted(value.c_str()); return value; };
});
hex::ContentRegistry::DataInspector::add("hex.builtin.inspector.s32", sizeof(s32), [](auto buffer, auto endian, auto style) {
ContentRegistry::DataInspector::add("hex.builtin.inspector.s32", sizeof(s32), [](auto buffer, auto endian, auto style) {
auto format = (style == Style::Decimal) ? "{0:d}" : ((style == Style::Hexadecimal) ? "0x{0:X}" : "{0:#o}");
auto value = hex::format(format, hex::changeEndianess(*reinterpret_cast<s32*>(buffer.data()), endian));
return [value] { ImGui::TextUnformatted(value.c_str()); return value; };
});
hex::ContentRegistry::DataInspector::add("hex.builtin.inspector.u64", sizeof(u64), [](auto buffer, auto endian, auto style) {
ContentRegistry::DataInspector::add("hex.builtin.inspector.u64", sizeof(u64), [](auto buffer, auto endian, auto style) {
auto format = (style == Style::Decimal) ? "{0:d}" : ((style == Style::Hexadecimal) ? "0x{0:X}" : "{0:#o}");
auto value = hex::format(format, hex::changeEndianess(*reinterpret_cast<u64*>(buffer.data()), endian));
return [value] { ImGui::TextUnformatted(value.c_str()); return value; };
});
hex::ContentRegistry::DataInspector::add("hex.builtin.inspector.s64", sizeof(s64), [](auto buffer, auto endian, auto style) {
ContentRegistry::DataInspector::add("hex.builtin.inspector.s64", sizeof(s64), [](auto buffer, auto endian, auto style) {
auto format = (style == Style::Decimal) ? "{0:d}" : ((style == Style::Hexadecimal) ? "0x{0:X}" : "{0:#o}");
auto value = hex::format(format, hex::changeEndianess(*reinterpret_cast<s64*>(buffer.data()), endian));
return [value] { ImGui::TextUnformatted(value.c_str()); return value; };
});
hex::ContentRegistry::DataInspector::add("hex.builtin.inspector.float", sizeof(float), [](auto buffer, auto endian, auto style) {
ContentRegistry::DataInspector::add("hex.builtin.inspector.float", sizeof(float), [](auto buffer, auto endian, auto style) {
auto value = hex::format("{0:G}", hex::changeEndianess(*reinterpret_cast<float*>(buffer.data()), endian));
return [value] { ImGui::TextUnformatted(value.c_str()); return value; };
});
hex::ContentRegistry::DataInspector::add("hex.builtin.inspector.double", sizeof(double), [](auto buffer, auto endian, auto style) {
ContentRegistry::DataInspector::add("hex.builtin.inspector.double", sizeof(double), [](auto buffer, auto endian, auto style) {
auto value = hex::format("{0:G}", hex::changeEndianess(*reinterpret_cast<float*>(buffer.data()), endian));
return [value] { ImGui::TextUnformatted(value.c_str()); return value; };
});
hex::ContentRegistry::DataInspector::add("hex.builtin.inspector.ascii", sizeof(char8_t), [](auto buffer, auto endian, auto style) {
ContentRegistry::DataInspector::add("hex.builtin.inspector.ascii", sizeof(char8_t), [](auto buffer, auto endian, auto style) {
auto value = hex::format("'{0}'", makePrintable(*reinterpret_cast<char8_t*>(buffer.data())).c_str());
return [value] { ImGui::TextUnformatted(value.c_str()); return value; };
});
hex::ContentRegistry::DataInspector::add("hex.builtin.inspector.wide", sizeof(char16_t), [](auto buffer, auto endian, auto style) {
ContentRegistry::DataInspector::add("hex.builtin.inspector.wide", sizeof(char16_t), [](auto buffer, auto endian, auto style) {
auto c = *reinterpret_cast<char16_t*>(buffer.data());
auto value = hex::format("'{0}'", c == 0 ? '\x01' : char16_t(hex::changeEndianess(c, endian)));
return [value] { ImGui::TextUnformatted(value.c_str()); return value; };
});
hex::ContentRegistry::DataInspector::add("hex.builtin.inspector.utf8", sizeof(char8_t) * 4, [](auto buffer, auto endian, auto style) {
ContentRegistry::DataInspector::add("hex.builtin.inspector.utf8", sizeof(char8_t) * 4, [](auto buffer, auto endian, auto style) {
char utf8Buffer[5] = { 0 };
char codepointString[5] = { 0 };
u32 codepoint = 0;
@ -119,7 +119,7 @@ namespace hex::plugin::builtin {
#if defined(OS_WINDOWS) && defined(ARCH_64_BIT)
hex::ContentRegistry::DataInspector::add("hex.builtin.inspector.time32", sizeof(__time32_t), [](auto buffer, auto endian, auto style) {
ContentRegistry::DataInspector::add("hex.builtin.inspector.time32", sizeof(__time32_t), [](auto buffer, auto endian, auto style) {
auto endianAdjustedTime = hex::changeEndianess(*reinterpret_cast<__time32_t*>(buffer.data()), endian);
struct tm *ptm = _localtime32(&endianAdjustedTime);
std::string value;
@ -131,7 +131,7 @@ namespace hex::plugin::builtin {
return [value] { ImGui::TextUnformatted(value.c_str()); return value; };
});
hex::ContentRegistry::DataInspector::add("hex.builtin.inspector.time64", sizeof(__time64_t), [](auto buffer, auto endian, auto style) {
ContentRegistry::DataInspector::add("hex.builtin.inspector.time64", sizeof(__time64_t), [](auto buffer, auto endian, auto style) {
auto endianAdjustedTime = hex::changeEndianess(*reinterpret_cast<__time64_t*>(buffer.data()), endian);
struct tm *ptm = _localtime64(&endianAdjustedTime);
std::string value;
@ -145,7 +145,7 @@ namespace hex::plugin::builtin {
#else
hex::ContentRegistry::DataInspector::add("hex.builtin.inspector.time", sizeof(time_t), [](auto buffer, auto endian, auto style) {
ContentRegistry::DataInspector::add("hex.builtin.inspector.time", sizeof(time_t), [](auto buffer, auto endian, auto style) {
auto endianAdjustedTime = hex::changeEndianess(*reinterpret_cast<time_t*>(buffer.data()), endian);
struct tm *ptm = localtime(&endianAdjustedTime);
std::string value;
@ -159,7 +159,7 @@ namespace hex::plugin::builtin {
#endif
hex::ContentRegistry::DataInspector::add("hex.builtin.inspector.guid", sizeof(GUID), [](auto buffer, auto endian, auto style) {
ContentRegistry::DataInspector::add("hex.builtin.inspector.guid", sizeof(GUID), [](auto buffer, auto endian, auto style) {
GUID guid;
std::memcpy(&guid, buffer.data(), sizeof(GUID));
auto value = hex::format("{}{{{:08X}-{:04X}-{:04X}-{:02X}{:02X}-{:02X}{:02X}{:02X}{:02X}{:02X}{:02X}}}",
@ -173,7 +173,7 @@ namespace hex::plugin::builtin {
return [value] { ImGui::TextUnformatted(value.c_str()); return value; };
});
hex::ContentRegistry::DataInspector::add("hex.builtin.inspector.rgba8", sizeof(u32), [](auto buffer, auto endian, auto style) {
ContentRegistry::DataInspector::add("hex.builtin.inspector.rgba8", sizeof(u32), [](auto buffer, auto endian, auto style) {
ImColor value(hex::changeEndianess(*reinterpret_cast<u32*>(buffer.data()), endian));
auto stringValue = hex::format("(0x{:02X}, 0x{:02X}, 0x{:02X}, 0x{:02X})", u8(0xFF * (value.Value.x)), u8(0xFF * (value.Value.y)), u8(0xFF * (value.Value.z)), u8(0xFF * (value.Value.w)));

79
plugins/builtin/source/content/data_processor_nodes.cpp
View File

@ -1,9 +1,15 @@
#include <hex/plugin.hpp>
#include <hex/api/content_registry.hpp>
#include <hex/data_processor/node.hpp>
#include <hex/helpers/crypto.hpp>
#include <hex/helpers/shared_data.hpp>
#include <cctype>
#include <nlohmann/json.hpp>
#include <imgui.h>
namespace hex::plugin::builtin {
class NodeNullptr : public dp::Node {
@ -38,13 +44,11 @@ namespace hex::plugin::builtin {
this->setBufferOnOutput(0, this->m_buffer);
}
nlohmann::json store() override {
auto output = nlohmann::json::object();
void store(nlohmann::json &j) override {
j = nlohmann::json::object();
output["size"] = this->m_size;
output["data"] = this->m_buffer;
return output;
j["size"] = this->m_size;
j["data"] = this->m_buffer;
}
void load(nlohmann::json &j) override {
@ -80,12 +84,10 @@ namespace hex::plugin::builtin {
this->setBufferOnOutput(0, output);
}
nlohmann::json store() override {
auto output = nlohmann::json::object();
void store(nlohmann::json &j) override {
j = nlohmann::json::object();
output["data"] = this->m_value;
return output;
j["data"] = this->m_value;
}
void load(nlohmann::json &j) override {
@ -115,12 +117,10 @@ namespace hex::plugin::builtin {
this->setBufferOnOutput(0, data);
}
nlohmann::json store() override {
auto output = nlohmann::json::object();
void store(nlohmann::json &j) override {
j = nlohmann::json::object();
output["data"] = this->m_value;
return output;
j["data"] = this->m_value;
}
void load(nlohmann::json &j) override {
@ -151,12 +151,10 @@ namespace hex::plugin::builtin {
this->setBufferOnOutput(0, data);
}
nlohmann::json store() override {
auto output = nlohmann::json::object();
void store(nlohmann::json &j) override {
j = nlohmann::json::object();
output["data"] = this->m_value;
return output;
j["data"] = this->m_value;
}
void load(nlohmann::json &j) override {
@ -189,16 +187,14 @@ namespace hex::plugin::builtin {
}
nlohmann::json store() override {
auto output = nlohmann::json::object();
void store(nlohmann::json &j) override {
j = nlohmann::json::object();
output["data"] = nlohmann::json::object();
output["data"]["r"] = this->m_color.Value.x;
output["data"]["g"] = this->m_color.Value.y;
output["data"]["b"] = this->m_color.Value.z;
output["data"]["a"] = this->m_color.Value.w;
return output;
j["data"] = nlohmann::json::object();
j["data"]["r"] = this->m_color.Value.x;
j["data"]["g"] = this->m_color.Value.y;
j["data"]["b"] = this->m_color.Value.z;
j["data"]["a"] = this->m_color.Value.w;
}
void load(nlohmann::json &j) override {
@ -223,12 +219,10 @@ namespace hex::plugin::builtin {
}
nlohmann::json store() override {
auto output = nlohmann::json::object();
void store(nlohmann::json &j) override {
j = nlohmann::json::object();
output["comment"] = this->m_comment;
return output;
j["comment"] = this->m_comment;
}
void load(nlohmann::json &j) override {
@ -751,15 +745,12 @@ namespace hex::plugin::builtin {
this->setBufferOnOutput(4, output);
}
nlohmann::json store() override {
auto output = nlohmann::json::object();
void store(nlohmann::json &j) override {
j = nlohmann::json::object();
output["data"] = nlohmann::json::object();
output["data"]["mode"] = this->m_mode;
output["data"]["key_length"] = this->m_keyLength;
return output;
j["data"] = nlohmann::json::object();
j["data"]["mode"] = this->m_mode;
j["data"]["key_length"] = this->m_keyLength;
}
void load(nlohmann::json &j) override {

2
plugins/builtin/source/content/lang_builtin_functions.cpp
View File

@ -1,4 +1,4 @@
#include <hex/plugin.hpp>
#include <hex/api/content_registry.hpp>
#include <hex/lang/ast_node.hpp>
#include <hex/lang/log_console.hpp>

7
plugins/builtin/source/content/settings_entries.cpp
View File

@ -1,4 +1,9 @@
#include <hex/plugin.hpp>
#include <hex/api/content_registry.hpp>
#include <hex/api/imhex_api.hpp>
#include <imgui.h>
#include <nlohmann/json.hpp>
namespace hex::plugin::builtin {

9
plugins/builtin/source/content/tools_entries.cpp
View File

@ -1,6 +1,7 @@
#include <hex/plugin.hpp>
#include <hex/api/content_registry.hpp>
#include <hex/helpers/net.hpp>
#include <hex/helpers/shared_data.hpp>
#include <regex>
#include <chrono>
@ -8,6 +9,12 @@
#include <llvm/Demangle/Demangle.h>
#include "math_evaluator.hpp"
#include <imgui.h>
#define IMGUI_DEFINE_MATH_OPERATORS
#include <imgui_internal.h>
#include <nlohmann/json.hpp>
namespace hex::plugin::builtin {
namespace {

4
plugins/builtin/source/content/ui_items.cpp
View File

@ -1,8 +1,10 @@
#include <hex/plugin.hpp>
#include <hex/api/content_registry.hpp>
#include <hex/helpers/shared_data.hpp>
#include <codicons_font.h>
#include <imgui.h>
#include <imgui_internal.h>
#include <imgui_imhex_extensions.h>
namespace hex::plugin::builtin {

2
plugins/builtin/source/lang/de_DE.cpp
View File

@ -1,4 +1,4 @@
#include <hex/plugin.hpp>
#include <hex/api/content_registry.hpp>
namespace hex::plugin::builtin {

2
plugins/builtin/source/lang/en_US.cpp
View File

@ -1,4 +1,4 @@
#include <hex/plugin.hpp>
#include <hex/api/content_registry.hpp>
namespace hex::plugin::builtin {

2
plugins/builtin/source/lang/it_IT.cpp
View File

@ -1,4 +1,4 @@
#include <hex/plugin.hpp>
#include <hex/api/content_registry.hpp>
namespace hex::plugin::builtin {

4
plugins/libimhex/CMakeLists.txt
View File

@ -41,6 +41,10 @@ set(LIBIMHEX_SOURCES
source/api/imhex_api.cpp
source/api/content_registry.cpp
source/data_processor/attribute.cpp
source/data_processor/link.cpp
source/data_processor/node.cpp
source/helpers/utils.cpp
source/helpers/shared_data.cpp
source/helpers/crypto.cpp

3
plugins/libimhex/include/hex.hpp
View File

@ -7,6 +7,9 @@
#include <hex/helpers/logger.hpp>
using namespace hex::lang_literals;
constexpr static const auto ImHexApiURL = "https://api.werwolv.net/imhex";
constexpr static const auto GitHubApiURL = "https://api.github.com/repos/WerWolv/ImHex";
using u8 = std::uint8_t;
using u16 = std::uint16_t;
using u32 = std::uint32_t;

2
plugins/libimhex/include/hex/api/content_registry.hpp
View File

@ -10,7 +10,7 @@
#include <string_view>
#include <vector>
#include <nlohmann/json.hpp>
#include <nlohmann/json_fwd.hpp>
namespace hex {

13
plugins/libimhex/include/hex/data_processor/attribute.hpp
View File

@ -1,4 +1,7 @@
#pragma once
#include <hex.hpp>
#include <string_view>
namespace hex::dp {
@ -16,14 +19,8 @@ namespace hex::dp {
In, Out
};
Attribute(IOType ioType, Type type, std::string_view unlocalizedName) : m_id(SharedData::dataProcessorAttrIdCounter++), m_ioType(ioType), m_type(type), m_unlocalizedName(unlocalizedName) {
}
~Attribute() {
for (auto &[linkId, attr] : this->getConnectedAttributes())
attr->removeConnectedAttribute(linkId);
}
Attribute(IOType ioType, Type type, std::string_view unlocalizedName);
~Attribute();
[[nodiscard]] u32 getID() const { return this->m_id; }
void setID(u32 id) { this->m_id = id; }

4
plugins/libimhex/include/hex/data_processor/link.hpp
View File

@ -1,10 +1,12 @@
#pragma once
#include <hex.hpp>
namespace hex::dp {
class Link {
public:
Link(u32 from, u32 to) : m_id(SharedData::dataProcessorLinkIdCounter++), m_from(from), m_to(to) { }
Link(u32 from, u32 to);
[[nodiscard]] u32 getID() const { return this->m_id; }
void setID(u32 id) { this->m_id = id; }

134
plugins/libimhex/include/hex/data_processor/node.hpp
View File

@ -1,20 +1,22 @@
#pragma once
#include <hex.hpp>
#include <hex/data_processor/attribute.hpp>
#include <hex/helpers/utils.hpp>
#include <set>
#include <string_view>
#include <vector>
#include <nlohmann/json.hpp>
#include <nlohmann/json_fwd.hpp>
namespace hex::prv { class Provider; class Overlay; }
namespace hex::dp {
class Node {
public:
Node(std::string_view unlocalizedTitle, std::vector<Attribute> attributes) : m_id(SharedData::dataProcessorNodeIdCounter++), m_unlocalizedTitle(unlocalizedTitle), m_attributes(std::move(attributes)) {
for (auto &attr : this->m_attributes)
attr.setParentNode(this);
}
Node(std::string_view unlocalizedTitle, std::vector<Attribute> attributes);
virtual ~Node() = default;
@ -34,7 +36,7 @@ namespace hex::dp {
virtual void drawNode() { }
virtual void process() = 0;
virtual nlohmann::json store() { return nullptr; }
virtual void store(nlohmann::json &j) { }
virtual void load(nlohmann::json &j) { }
using NodeError = std::pair<Node*, std::string>;
@ -79,121 +81,15 @@ namespace hex::dp {
throw NodeError(this, message);
}
std::vector<u8> getBufferOnInput(u32 index) {
auto attribute = this->getConnectedInputAttribute(index);
std::vector<u8> getBufferOnInput(u32 index);
u64 getIntegerOnInput(u32 index);
float getFloatOnInput(u32 index);
if (attribute == nullptr)
throwNodeError(hex::format("Nothing connected to input '{0}'", static_cast<const char*>(LangEntry(this->m_attributes[index].getUnlocalizedName()))));
void setBufferOnOutput(u32 index, std::vector<u8> data);
void setIntegerOnOutput(u32 index, u64 integer);
void setFloatOnOutput(u32 index, float floatingPoint);
if (attribute->getType() != Attribute::Type::Buffer)
throwNodeError("Tried to read buffer from non-buffer attribute");
markInputProcessed(index);
attribute->getParentNode()->process();
auto &outputData = attribute->getOutputData();
if (!outputData.has_value())
throw std::runtime_error("No data available at connected attribute");
return outputData.value();
}
u64 getIntegerOnInput(u32 index) {
auto attribute = this->getConnectedInputAttribute(index);
if (attribute == nullptr)
throwNodeError(hex::format("Nothing connected to input '{0}'", static_cast<const char*>(LangEntry(this->m_attributes[index].getUnlocalizedName()))));
if (attribute->getType() != Attribute::Type::Integer)
throwNodeError("Tried to read integer from non-integer attribute");
markInputProcessed(index);
attribute->getParentNode()->process();
auto &outputData = attribute->getOutputData();
if (!outputData.has_value())
throw std::runtime_error("No data available at connected attribute");
if (outputData->size() < sizeof(u64))
throw std::runtime_error("Not enough data provided for integer");
return *reinterpret_cast<u64*>(outputData->data());
}
float getFloatOnInput(u32 index) {
auto attribute = this->getConnectedInputAttribute(index);
if (attribute == nullptr)
throwNodeError(hex::format("Nothing connected to input '{0}'", static_cast<const char*>(LangEntry(this->m_attributes[index].getUnlocalizedName()))));
if (attribute->getType() != Attribute::Type::Float)
throwNodeError("Tried to read float from non-float attribute");
markInputProcessed(index);
attribute->getParentNode()->process();
auto &outputData = attribute->getOutputData();
if (!outputData.has_value())
throw std::runtime_error("No data available at connected attribute");
if (outputData->size() < sizeof(float))
throw std::runtime_error("Not enough data provided for float");
return *reinterpret_cast<float*>(outputData->data());
}
void setBufferOnOutput(u32 index, std::vector<u8> data) {
if (index >= this->getAttributes().size())
throw std::runtime_error("Attribute index out of bounds!");
auto &attribute = this->getAttributes()[index];
if (attribute.getIOType() != Attribute::IOType::Out)
throw std::runtime_error("Tried to set output data of an input attribute!");
attribute.getOutputData() = data;
}
void setIntegerOnOutput(u32 index, u64 integer) {
if (index >= this->getAttributes().size())
throw std::runtime_error("Attribute index out of bounds!");
auto &attribute = this->getAttributes()[index];
if (attribute.getIOType() != Attribute::IOType::Out)
throw std::runtime_error("Tried to set output data of an input attribute!");
std::vector<u8> buffer(sizeof(u64), 0);
std::memcpy(buffer.data(), &integer, sizeof(u64));
attribute.getOutputData() = buffer;
}
void setFloatOnOutput(u32 index, float floatingPoint) {
if (index >= this->getAttributes().size())
throw std::runtime_error("Attribute index out of bounds!");
auto &attribute = this->getAttributes()[index];
if (attribute.getIOType() != Attribute::IOType::Out)
throw std::runtime_error("Tried to set output data of an input attribute!");
std::vector<u8> buffer(sizeof(float), 0);
std::memcpy(buffer.data(), &floatingPoint, sizeof(float));
attribute.getOutputData() = buffer;
}
void setOverlayData(u64 address, const std::vector<u8> &data) {
if (this->m_overlay == nullptr)
throw std::runtime_error("Tried setting overlay data on a node that's not the end of a chain!");
this->m_overlay->setAddress(address);
this->m_overlay->getData() = data;
}
void setOverlayData(u64 address, const std::vector<u8> &data);
};

2
plugins/libimhex/include/hex/helpers/net.hpp
View File

@ -6,7 +6,7 @@
#include <filesystem>
#include <atomic>
#include <nlohmann/json.hpp>
#include <nlohmann/json_fwd.hpp>
#include <curl/curl.h>

2
plugins/libimhex/include/hex/helpers/shared_data.hpp
View File

@ -13,7 +13,7 @@
#include <imgui.h>
#include <nlohmann/json.hpp>
#include <nlohmann/json_fwd.hpp>
namespace hex { class SharedData; }

6
plugins/libimhex/include/hex/plugin.hpp
View File

@ -5,12 +5,6 @@
#include <imgui_internal.h>
#include <hex.hpp>
#include <hex/api/imhex_api.hpp>
#include <hex/api/content_registry.hpp>
#include <hex/views/view.hpp>
#include <hex/providers/provider.hpp>
#include <hex/helpers/shared_data.hpp>
#include <hex/data_processor/node.hpp>
#define IMHEX_PLUGIN_SETUP(name, author, description) IMHEX_PLUGIN_SETUP_IMPL(IMHEX_PLUGIN_NAME, name, author, description)

2
plugins/libimhex/source/api/content_registry.cpp
View File

@ -5,6 +5,8 @@
#include <filesystem>
#include <fstream>
#include <nlohmann/json.hpp>
namespace hex {
/* Settings */

16
plugins/libimhex/source/data_processor/attribute.cpp Normal file
View File

@ -0,0 +1,16 @@
#include <hex/data_processor/attribute.hpp>
#include <hex/helpers/shared_data.hpp>
namespace hex::dp {
Attribute::Attribute(IOType ioType, Type type, std::string_view unlocalizedName) : m_id(SharedData::dataProcessorAttrIdCounter++), m_ioType(ioType), m_type(type), m_unlocalizedName(unlocalizedName) {
}
Attribute::~Attribute() {
for (auto &[linkId, attr] : this->getConnectedAttributes())
attr->removeConnectedAttribute(linkId);
}
}

10
plugins/libimhex/source/data_processor/link.cpp Normal file
View File

@ -0,0 +1,10 @@
#include <hex/data_processor/link.hpp>
#include <hex/helpers/shared_data.hpp>
namespace hex::dp {
Link::Link(u32 from, u32 to) : m_id(SharedData::dataProcessorLinkIdCounter++), m_from(from), m_to(to) { }
}

128
plugins/libimhex/source/data_processor/node.cpp Normal file
View File

@ -0,0 +1,128 @@
#include <hex/data_processor/node.hpp>
#include <hex/helpers/shared_data.hpp>
namespace hex::dp {
Node::Node(std::string_view unlocalizedTitle, std::vector<Attribute> attributes) : m_id(SharedData::dataProcessorNodeIdCounter++), m_unlocalizedTitle(unlocalizedTitle), m_attributes(std::move(attributes)) {
for (auto &attr : this->m_attributes)
attr.setParentNode(this);
}
std::vector<u8> Node::getBufferOnInput(u32 index) {
auto attribute = this->getConnectedInputAttribute(index);
if (attribute == nullptr)
throwNodeError(hex::format("Nothing connected to input '{0}'", static_cast<const char*>(LangEntry(this->m_attributes[index].getUnlocalizedName()))));
if (attribute->getType() != Attribute::Type::Buffer)
throwNodeError("Tried to read buffer from non-buffer attribute");
markInputProcessed(index);
attribute->getParentNode()->process();
auto &outputData = attribute->getOutputData();
if (!outputData.has_value())
throw std::runtime_error("No data available at connected attribute");
return outputData.value();
}
u64 Node::getIntegerOnInput(u32 index) {
auto attribute = this->getConnectedInputAttribute(index);
if (attribute == nullptr)
throwNodeError(hex::format("Nothing connected to input '{0}'", static_cast<const char*>(LangEntry(this->m_attributes[index].getUnlocalizedName()))));
if (attribute->getType() != Attribute::Type::Integer)
throwNodeError("Tried to read integer from non-integer attribute");
markInputProcessed(index);
attribute->getParentNode()->process();
auto &outputData = attribute->getOutputData();
if (!outputData.has_value())
throw std::runtime_error("No data available at connected attribute");
if (outputData->size() < sizeof(u64))
throw std::runtime_error("Not enough data provided for integer");
return *reinterpret_cast<u64*>(outputData->data());
}
float Node::getFloatOnInput(u32 index) {
auto attribute = this->getConnectedInputAttribute(index);
if (attribute == nullptr)
throwNodeError(hex::format("Nothing connected to input '{0}'", static_cast<const char*>(LangEntry(this->m_attributes[index].getUnlocalizedName()))));
if (attribute->getType() != Attribute::Type::Float)
throwNodeError("Tried to read float from non-float attribute");
markInputProcessed(index);
attribute->getParentNode()->process();
auto &outputData = attribute->getOutputData();
if (!outputData.has_value())
throw std::runtime_error("No data available at connected attribute");
if (outputData->size() < sizeof(float))
throw std::runtime_error("Not enough data provided for float");
return *reinterpret_cast<float*>(outputData->data());
}
void Node::setBufferOnOutput(u32 index, std::vector<u8> data) {
if (index >= this->getAttributes().size())
throw std::runtime_error("Attribute index out of bounds!");
auto &attribute = this->getAttributes()[index];
if (attribute.getIOType() != Attribute::IOType::Out)
throw std::runtime_error("Tried to set output data of an input attribute!");
attribute.getOutputData() = data;
}
void Node::setIntegerOnOutput(u32 index, u64 integer) {
if (index >= this->getAttributes().size())
throw std::runtime_error("Attribute index out of bounds!");
auto &attribute = this->getAttributes()[index];
if (attribute.getIOType() != Attribute::IOType::Out)
throw std::runtime_error("Tried to set output data of an input attribute!");
std::vector<u8> buffer(sizeof(u64), 0);
std::memcpy(buffer.data(), &integer, sizeof(u64));
attribute.getOutputData() = buffer;
}
void Node::setFloatOnOutput(u32 index, float floatingPoint) {
if (index >= this->getAttributes().size())
throw std::runtime_error("Attribute index out of bounds!");
auto &attribute = this->getAttributes()[index];
if (attribute.getIOType() != Attribute::IOType::Out)
throw std::runtime_error("Tried to set output data of an input attribute!");
std::vector<u8> buffer(sizeof(float), 0);
std::memcpy(buffer.data(), &floatingPoint, sizeof(float));
attribute.getOutputData() = buffer;
}
void Node::setOverlayData(u64 address, const std::vector<u8> &data) {
if (this->m_overlay == nullptr)
throw std::runtime_error("Tried setting overlay data on a node that's not the end of a chain!");
this->m_overlay->setAddress(address);
this->m_overlay->getData() = data;
}
}

2
plugins/libimhex/source/helpers/net.cpp
View File

@ -8,6 +8,8 @@
#include <mbedtls/ssl.h>
#include <mbedtls/error.h>
#include <nlohmann/json.hpp>
#include <hex/resources.hpp>
namespace hex {

2
plugins/libimhex/source/helpers/shared_data.cpp
View File

@ -1,5 +1,7 @@
#include <hex/helpers/shared_data.hpp>
#include <nlohmann/json.hpp>
namespace hex {
std::vector<std::function<void()>> SharedData::deferredCalls;

6
plugins/windows/source/content/footer_items.cpp
View File

@ -1,8 +1,12 @@
#include <hex/plugin.hpp>
#include <hex/api/content_registry.hpp>
#include <windows.h>
#include <psapi.h>
#include <imgui.h>
#include <imgui_imhex_extensions.h>
#include <fontawesome_font.h>
namespace hex::plugin::windows {
static ULONGLONG subtractTimes(const FILETIME &left, const FILETIME &right) {

2
plugins/windows/source/lang/en_US.cpp
View File

@ -1,4 +1,4 @@
#include <hex/plugin.hpp>
#include <hex/api/content_registry.hpp>
namespace hex::plugin::windows {

2
plugins/windows/source/plugin_windows.cpp
View File

@ -1,6 +1,4 @@
#include <hex/plugin.hpp>
#include <imgui.h>
#include <imgui_internal.h>
#include "views/view_tty_console.hpp"

3
source/init/splash_window.cpp
View File

@ -15,8 +15,9 @@
#include <unistd.h>
#include <future>
#include <chrono>
#include <future>
#include <numeric>
using namespace std::literals::chrono_literals;

8
source/init/tasks.cpp
View File

@ -26,12 +26,16 @@
#include <filesystem>
#include <nlohmann/json.hpp>
namespace hex::init {
using namespace std::literals::string_literals;
static bool checkForUpdates() {
hex::Net net;
auto releases = net.getJson("https://api.github.com/repos/WerWolv/ImHex/releases/latest").get();
auto releases = net.getJson(GitHubApiURL + "/releases/latest"s).get();
if (releases.code != 200)
return false;
@ -50,7 +54,7 @@ namespace hex::init {
static bool downloadInformation() {
hex::Net net;
auto tip = net.getString("https://api.werwolv.net/imhex/tip").get();
auto tip = net.getString(ImHexApiURL + "/tip"s).get();
if (tip.code != 200)
return false;

4
source/views/view_data_processor.cpp
View File

@ -388,7 +388,9 @@ namespace hex {
currNodeOutput["attrs"] = json::array();
currNodeOutput["id"] = id;
currNodeOutput["data"] = node->store();
json nodeData;
node->store(nodeData);
currNodeOutput["data"] = nodeData;
u32 attrIndex = 0;
for (auto &attr : node->getAttributes()) {

6
source/views/view_hexeditor.cpp
View File

@ -4,13 +4,15 @@
#include <hex/api/imhex_api.hpp>
#include <hex/helpers/crypto.hpp>
#include <GLFW/glfw3.h>
#include "providers/file_provider.hpp"
#include "helpers/patches.hpp"
#include "helpers/project_file_handler.hpp"
#include "helpers/loader_script_handler.hpp"
#include <GLFW/glfw3.h>
#include <nlohmann/json.hpp>
#undef __STRICT_ANSI__
#include <cstdio>

1
source/views/view_information.cpp
View File

@ -6,6 +6,7 @@
#include <cstring>
#include <cmath>
#include <filesystem>
#include <numeric>
#include <span>
#include <thread>
#include <vector>

2
source/views/view_pattern_editor.cpp
View File

@ -8,6 +8,8 @@
#include <imgui_imhex_extensions.h>
#include <nlohmann/json.hpp>
namespace hex {
static const TextEditor::LanguageDefinition& PatternLanguage() {

2
source/views/view_settings.cpp
View File

@ -2,6 +2,8 @@
#include <hex/api/content_registry.hpp>
#include <nlohmann/json.hpp>
namespace hex {
ViewSettings::ViewSettings() : View("hex.view.settings.name") {

2
source/window/window.cpp
View File

@ -32,6 +32,8 @@
#include <GLFW/glfw3.h>
#include <nlohmann/json.hpp>
namespace hex {
using namespace std::literals::chrono_literals;