feat: UGC server that makes and serves player models' meshes and icons

A new server (dUgcServer, started by master with enable_ugc_server=1) that
takes unprocessed ugc and ugc_modular_build rows from the database and makes
what the client downloads with UGCUSE3DSERVICES: an optimized NIF (hidden
faces removed, ambient occlusion baked into vertex colors) and a 128px DDS
icon for player models, rendered by a software rasterizer from the client's
LDD brick primitives, and icons for cars and rockets assembled from their
modules per ModularBuildComponent/ModuleComponent. It serves them, with the
models' LXFML, over HTTP in the client's UGCC<dc>/3DOPTIMIZED and
IMAGE128DDS layout with .gz and .checksum files, and keeps its folder under
a size cap.

Processing state lives in ugc.is_optimized plus new processed_at,
process_attempts and process_error columns (and the same on
ugc_modular_build). ServiceType::UGC is appended. NifFile moves to dCommon
and records named node transforms for the modules' attach points.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

dDatabase/GameDatabase/ITables/IUgc.h

@@ -6,6 +6,7 @@
 #include <optional>
 #include <string>
 #include <string_view>
+#include <vector>
 
 class IUgc {
 public:
@@ -31,5 +32,53 @@ public:
 	virtual void UpdateUgcModelData(const LWOOBJID& modelId, std::stringstream& lxfml) = 0;
 
 	virtual std::optional<IUgc::Model> GetUgcModel(const LWOOBJID ugcId) = 0;
+
+	// ---- Processing by the UGC server (is_optimized, processed_at, process_attempts, process_error) ----
+
+	// is_optimized's values
+	enum class eProcessState : int32_t {
+		PENDING = 0, // not made yet (or to be made again)
+		DONE = 1,    // the UGC server's files are made
+		FAILED = 2,  // gave up after the allowed attempts
+	};
+
+	// A row's processing state, for the UGC server and the dashboard
+	struct ProcessInfo {
+		LWOOBJID id{};
+		LWOOBJID characterId{};
+		std::string characterName; // empty when the character is gone
+		eProcessState state{};
+		uint32_t attempts{};
+		int64_t processedAt{}; // Unix seconds of the last attempt, 0 for none
+		std::string error;
+		bool bakeAo{};
+		std::string details; // modular builds: the modules (ldf_config)
+	};
+
+	// A model waiting to be made: its id, stored LXFML (sd0) and the attempts so far
+	struct PendingModel {
+		LWOOBJID id{};
+		std::string lxfml;
+		uint32_t attempts{};
+	};
+
+	// Up to `limit` pending models, the least tried and then the newest first
+	virtual std::vector<PendingModel> GetUgcModelsToProcess(const uint32_t limit) = 0;
+
+	// Records an attempt: the new state, how many attempts there have been, why it failed (empty when it didn't) and
+	// whether lighting was baked in; processed_at becomes now
+	virtual void SetUgcModelProcessed(const LWOOBJID id, const eProcessState state, const uint32_t attempts, const std::string_view error, const bool bakeAo) = 0;
+
+	virtual std::optional<ProcessInfo> GetUgcProcessInfo(const LWOOBJID id) = 0;
+
+	// Sets models back to pending with no attempts: one (`id`), or all of them (`id` nullopt; only the failed ones
+	// with `failedOnly`). Returns how many rows changed.
+	virtual uint64_t ResetUgcModelProcessing(const std::optional<LWOOBJID> id, const bool failedOnly) = 0;
+
+	// A page of models (all, or those in `state`), the newest first
+	virtual std::vector<ProcessInfo> GetUgcProcessList(const std::optional<eProcessState> state, const uint32_t offset, const uint32_t limit) = 0;
+
+	// How many models are in each state
+	virtual std::vector<std::pair<eProcessState, uint64_t>> GetUgcProcessCounts() = 0;
 };
 #endif  //!__IUGC__H__

dDatabase/GameDatabase/ITables/IUgcModularBuild.h

@@ -4,11 +4,30 @@
 #include <cstdint>
 #include <optional>
 #include <string>
+#include <vector>
+
+#include "IUgc.h"
 
 class IUgcModularBuild {
 public:
 	virtual void InsertUgcBuild(const std::string& modules, const LWOOBJID bigId, const std::optional<LWOOBJID> characterId) = 0;
 	virtual void DeleteUgcBuild(const LWOOBJID bigId) = 0;
+
+	// ---- Icons made by the UGC server; the same columns and meanings as IUgc's processing ----
+
+	// A modular build waiting for its icon: its id, modules (ldf_config) and the attempts so far
+	struct PendingBuild {
+		LWOOBJID id{};
+		std::string modules;
+		uint32_t attempts{};
+	};
+
+	virtual std::vector<PendingBuild> GetModularBuildsToProcess(const uint32_t limit) = 0;
+	virtual void SetModularBuildProcessed(const LWOOBJID id, const IUgc::eProcessState state, const uint32_t attempts, const std::string_view error) = 0;
+	virtual std::optional<IUgc::ProcessInfo> GetModularBuildProcessInfo(const LWOOBJID id) = 0;
+	virtual uint64_t ResetModularBuildProcessing(const std::optional<LWOOBJID> id, const bool failedOnly) = 0;
+	virtual std::vector<IUgc::ProcessInfo> GetModularBuildProcessList(const std::optional<IUgc::eProcessState> state, const uint32_t offset, const uint32_t limit) = 0;
+	virtual std::vector<std::pair<IUgc::eProcessState, uint64_t>> GetModularBuildProcessCounts() = 0;
 };
 
 #endif  //!IUGCMODULARBUILD_H