Add modules_metadata to dump

Utilizes ExtractModuleMetadata functionality and provides it as is

Author: GAMMACASE

README.md

@@ -14,10 +14,11 @@ This command supports the following arguments:
  * ``metatags``: Dump metatags.
  * ``atomics``: Dump atomics.
  * ``pulse_bindings``: Dump pulse bindings.
+ * ``module_metadata``: Dump module metadata. Only windows is currently supported!
  * ``split_atomics``: Splits templated atomic names and leaves only base name leaving templated stuff. (Makes ``CUtlVector<int>`` to be named as ``CUtlVector`` for example).
  * ``ignore_parents``: Ignores parent scope decls and removes inlined structs/classes converting them from A::B to A__B.
  * ``apply_netvar_overrides``: Applies netvar overrides to types (MNetworkVarTypeOverride metatags).
- * ``all``: Shorthand version of providing ``metatags``, ``atomics`` and ``pulse_bindings`` flags.
+ * ``all``: Shorthand version of providing ``metatags``, ``atomics``, ``pulse_bindings`` and ``module_metadata`` flags.
  * ``for_cpp``: Use optimal flags for cpp generation later, similar to providing ``split_atomics``, ``ignore_parents`` and ``apply_netvar_overrides`` flags.
 > [!NOTE]
 > Pulse bindings are heavily under development by valve, so these are expected to break with each engine update in the supported game list, and would require manual update to the code most likely!
@@ -231,6 +232,10 @@ class CUtlAbstractDelegate { char pad[16]; };
          * ``default_value``: Return default value (If it has one set);
          * Can also have metatags at ``traits/metatags``;
        * Can also have metatags at ``traits/metatags``;
+ * ``modules_metadata``: An array of module metadata provided by game binaries in the following format:
+   * ``module_name``: Name of the module;
+   * ``additional_info``: Additional info provided by the module;
+   * Other data is provided as is from the game binaries and may contain entries such as ``resource_manifests``, ``pulse_fingerprints``, ``pulse_bindings``, etc.
 
 ### Metatags
 

src/pulse_metadata.h

@@ -46,7 +46,8 @@ enum PulseValueType_t : int32
 	PVAL_TEST_HANDLE = 27,
 	PVAL_ARRAY = 28,
 	PVAL_TYPESAFE_INT64 = 29,
-	PVAL_COUNT = 30,
+	PVAL_PARTICLE_EHANDLE = 30,
+	PVAL_COUNT = 31,
 };
 
 struct PulseParamType
@@ -105,6 +106,8 @@ struct PulseParamType
 			case PVAL_SCHEMA_ENUM:	ss << "enum {" << m_LibraryClass << "}"; break;
 			case PVAL_PANORAMA_PANEL_HANDLE: ss << "panorama_panel_handle"; break;
 			case PVAL_TEST_HANDLE:	ss << "testhandle<" << (m_LibraryClass ? m_LibraryClass : "") << ">"; break;
+			case PVAL_PARTICLE_EHANDLE: ss << "particle_ehandle"; break;
+
 			default:
 			{
 				if(SchemaReader::IsVerboseLogging())

src/schemareader.cpp

@@ -8,6 +8,11 @@
 #include <filesystem>
 #include <ctime>
 
+#if PLATFORM_WINDOWS
+#include <windows.h>
+#include <tlhelp32.h>
+#endif
+
 CSchemaSystem *SchemaReader::SchemaSystem()
 {
 	static CSchemaSystem *s_SchemaSystem = nullptr;
@@ -163,6 +168,7 @@ void SchemaReader::ReadSchema( uint32 flags )
 	ReadDeclEnums();
 	ReadAtomics();
 	ReadPulseBindings();
+	ReadModuleMetadata();
 }
 
 void SchemaReader::SetOutDir( const std::filesystem::path &out_dir )
@@ -799,6 +805,58 @@ void SchemaReader::ReadPulseBindings()
 	ReadPulseDomainsInfo( pulse_bindings, domains );
 }
 
+void SchemaReader::ReadModuleMetadata()
+{
+	if(!IsDumpingModuleMetadata())
+		return;
+
+#ifndef PLATFORM_WINDOWS
+	META_CONPRINTF( "Reading module metadata is only supported on windows, skipping...\n" );
+#else
+	META_CONPRINTF( "Reading module metadata...\n" );
+
+	auto modules_metadata = GetRoot()->FindOrCreateMember( "modules_metadata" );
+	modules_metadata->SetArrayElementCount( 0 );
+
+	HANDLE snapshot = CreateToolhelp32Snapshot( TH32CS_SNAPMODULE | TH32CS_SNAPMODULE32, GetCurrentProcessId() );
+
+	if(snapshot != INVALID_HANDLE_VALUE)
+	{
+		MODULEENTRY32 module_entry = { sizeof( module_entry ) };
+		if(Module32First( snapshot, &module_entry ))
+		{
+			do
+			{
+				if(module_entry.hModule)
+				{
+					auto func = (KeyValues3 * (*)(CUtlString *))GetProcAddress( module_entry.hModule, "ExtractModuleMetadata" );
+					if(func)
+					{
+						CUtlString additional_info;
+						auto metadata = func( &additional_info );
+
+						if(metadata->IsNull())
+							continue;
+
+						auto entry = modules_metadata->ArrayAddElementToTail();
+
+						*entry = *metadata;
+						entry->SetMemberString( "module_name", module_entry.szModule );
+
+						if(!additional_info.IsEmpty())
+							entry->SetMemberString( "additional_info", additional_info );
+					}
+					
+				}
+
+			} while(Module32Next( snapshot, &module_entry ));
+		}
+
+		CloseHandle( snapshot );
+	}
+#endif
+}
+
 CSchemaType_DeclaredClass *SchemaReader::FindSchemaTypeInTypeScopes( const char *name )
 {
 	auto ci = SchemaSystem()->FindClassByScopedName( name ).Get();

src/schemareader.h

@@ -51,6 +51,7 @@ class SchemaReader
 	static bool IsDumpingMetaTags() { return (s_Flags & SR_DUMP_METATAGS) != 0; }
 	static bool IsDumpingAtomics() { return (s_Flags & SR_DUMP_ATOMICS) != 0; }
 	static bool IsDumpingPulseBindings() { return (s_Flags & SR_DUMP_PULSE_BINDINGS) != 0; }
+	static bool IsDumpingModuleMetadata() { return (s_Flags & SR_DUMP_MODULE_METADATA) != 0; }
 	static bool IsSplittingAtomicNames() { return (s_Flags & SR_SPLIT_ATOMIC_NAMES) != 0; }
 	static bool IsIgnoringParentScopes() { return (s_Flags & SR_IGNORE_PARENT_SCOPE) != 0; }
 	static bool IsApplyingNetVarOverrides() { return (s_Flags & SR_APPLY_NETVAR_OVERRIDES) != 0; }
@@ -71,6 +72,7 @@ class SchemaReader
 	void ReadMetaTags( KeyValues3 *root, SchemaMetadataEntryData_t *data, int count, bool append_traits = false );
 	void ReadFlags( KeyValues3 *root, CSchemaType *type );
 	void ReadPulseBindings();
+	void ReadModuleMetadata();
 
 	template <typename METATAG>
 	void ReadPulseDomains( KeyValues3 *root, std::map<std::string, KeyValues3 *> &domains );
@@ -131,15 +133,17 @@ class SchemaReader
 		// Dump pulse bindings
 		SR_DUMP_PULSE_BINDINGS = (1 << 5),
 
+		SR_DUMP_MODULE_METADATA = (1 << 6),
+
 		// Splits templated atomic names and leaves only base name leaving templated stuff
-		SR_SPLIT_ATOMIC_NAMES = (1 << 6),
+		SR_SPLIT_ATOMIC_NAMES = (1 << 7),
 
 		// Ignores parent scope decls and removes inlined structs/classes
 		// converting them from A::B to A__B
-		SR_IGNORE_PARENT_SCOPE = (1 << 7),
+		SR_IGNORE_PARENT_SCOPE = (1 << 8),
 
 		// Applies netvar overrides to types (MNetworkVarTypeOverride metatags)
-		SR_APPLY_NETVAR_OVERRIDES = (1 << 8)
+		SR_APPLY_NETVAR_OVERRIDES = (1 << 9)
 	};
 
 	struct DumpFlags_t
@@ -157,12 +161,13 @@ class SchemaReader
 		{ SR_DUMP_METATAGS, "metatags", "has_metatags", "Dump metatags" },
 		{ SR_DUMP_ATOMICS, "atomics", "has_atomics", "Dump atomics" },
 		{ SR_DUMP_PULSE_BINDINGS, "pulse_bindings", "has_pulse_bindings", "Dump pulse bindings" },
+		{ SR_DUMP_MODULE_METADATA, "module_metadata", "has_module_metadata", "Dump module metadata" },
 		{ SR_SPLIT_ATOMIC_NAMES, "split_atomics", "atomic_names_split", "Splits templated atomic names and leaves only base name leaving templated stuff" },
 		{ SR_IGNORE_PARENT_SCOPE, "ignore_parents", "no_parent_scope", "Ignores parent scope decls and removes inlined structs/classes converting them from A::B to A__B" },
 		{ SR_APPLY_NETVAR_OVERRIDES, "apply_netvar_overrides", "netvars_overriden", "Applies netvar overrides to types (MNetworkVarTypeOverride metatags)" },
 
 		// Supplementary definitions
-		{ SR_DUMP_METATAGS | SR_DUMP_ATOMICS | SR_DUMP_PULSE_BINDINGS, "all", nullptr, "Dumps everything" },
+		{ SR_DUMP_METATAGS | SR_DUMP_ATOMICS | SR_DUMP_PULSE_BINDINGS | SR_DUMP_MODULE_METADATA, "all", nullptr, "Dumps everything" },
 		{ SR_SPLIT_ATOMIC_NAMES | SR_IGNORE_PARENT_SCOPE | SR_APPLY_NETVAR_OVERRIDES, "for_cpp", nullptr, "Use optimal flags for cpp generation later" },
 	};
 };