mirror of
https://github.com/DarkflameUniverse/DarkflameServer.git
synced 2026-10-02 02:43:44 +00:00
7bba8344fc
Glitter colors (Materials.xml type glitter, glitter_colors 114,117) go into S21_Glitter_Model and, transparent, S21_GlitterAlpha_Model (shader_glitter, default 21, LEGO-AnimUV). Their shapes get box-projected UVs, an NiTexturingProperty with a stored 128 px mipmapped fleck texture (NiSourceTexture + NiPersistentSrcTextureRendererData, as the client's own env_ag_ocean-maelstrom.nif) and two NiTextureTransformControllers looping the base map's translation (glitter_size, glitter_density, glitter_speed). The shader lays the texture over the vertex color by its alpha and outputs the vertex alpha, so transparent glitter blends as S01_Alpha does. Satin colors (satin_colors, LEGO's opal colors) stay in S01_Alpha but get satin_opacity and are whitened by satin_whiten. NifFile reads the base map's scroll speed (uvScroll) from the controllers; the icon draws still flecks, the UGC 3D view and the LXFML viewers moving ones. stats.json counts the glitter groups. With shader_glitter 0 and no satin colors the files are the same bytes as before (tested). Also keeps glow_emissive for the icon (it was reset by the icon settings). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
83 lines
3.5 KiB
C++
83 lines
3.5 KiB
C++
#pragma once
|
|
|
|
#include <array>
|
|
|
|
#include <cstdint>
|
|
#include <string>
|
|
#include <string_view>
|
|
#include <vector>
|
|
|
|
#include "UgcGlitter.h"
|
|
#include "UgcModel.h"
|
|
#include "UgcRender.h"
|
|
|
|
/**
|
|
* The files the UGC server writes: the mesh as a Gamebryo .nif the client loads, icons as .png and .dds, and the
|
|
* client's .checksum files for its downloads. Pure (data in, bytes out).
|
|
*/
|
|
namespace UgcFormats {
|
|
struct NifShape {
|
|
std::string name;
|
|
const UgcModel::Mesh* mesh{};
|
|
bool transparent{};
|
|
};
|
|
|
|
/**
|
|
* A Gamebryo 20.3.0.9 file (user version 0, as the client's own meshes): a root NiNode named `rootName` with one
|
|
* NiTriShape per shape (at most 65535 vertices and triangles each: UgcModel::Split), with vertex colors that are
|
|
* the diffuse and ambient color (NiVertexColorProperty), a white NiMaterialProperty, and for transparent shapes an
|
|
* NiAlphaProperty blending with the vertex alpha.
|
|
*/
|
|
std::string WriteNif(const std::string& rootName, const std::vector<NifShape>& shapes);
|
|
|
|
struct NifLod {
|
|
float nearDistance{};
|
|
float farDistance{};
|
|
std::string name; // the level's node, e.g. LOD_0
|
|
std::vector<const UgcModel::Mesh*> pieces; // its shapes (UgcModel::Divide's pieces)
|
|
};
|
|
|
|
struct NifLodGroup {
|
|
std::string name; // S01_Opaque_Model: the NiLODNode and its shapes
|
|
bool transparent{};
|
|
std::vector<NifLod> lods;
|
|
// NiMaterialProperty's emissive color (grey) of the group's shapes; 0 the shared white material with none.
|
|
// The client's emissive shader (S46) lerps from the lit color to the vertex color by vertex alpha times its red.
|
|
float emissive{};
|
|
// The glitter of the UGC server's glitter groups (docs/UgcServer.md, "Metal and glow"): the shapes get UVs
|
|
// (UgcGlitter::Uv) and an NiTexturingProperty whose base map is the fleck texture stored in the file
|
|
// (NiSourceTexture, NiPersistentSrcTextureRendererData), its texture transform's translation looped by an
|
|
// NiTextureTransformController for U and one for V. Null: none.
|
|
const UgcGlitter::Params* glitter{};
|
|
};
|
|
|
|
/**
|
|
* The layout LU Toolbox exports (setup_lod_data) and the game's own brick models (res/BrickModels/ndmade) have:
|
|
* the root node, an NiLODNode per group with NiRangeLODData holding each level's distances, a node per level and
|
|
* the level's shapes under it, named like the group. Properties as WriteNif; a group with
|
|
* an emissive color gets a material of its own, a glitter group the glitter texture's NiTexturingProperty (one
|
|
* for every glitter group of the file).
|
|
*/
|
|
std::string WriteLodNif(const std::string& rootName, const std::vector<NifLodGroup>& groups);
|
|
|
|
// PNG (8-bit RGBA)
|
|
std::string EncodePng(const UgcRender::Image& image);
|
|
|
|
// DDS as the client's own icons are: DXT5 (BC3), without mipmaps, header flags caps|height|width|pixel format|linear
|
|
// size (0x81007), caps texture (0x1000)
|
|
std::string EncodeDds(const UgcRender::Image& image);
|
|
|
|
// One 4x4 block (RGBA, 64 bytes, row by row) as DXT5's 16 bytes: alpha endpoints and 3-bit indices, then the
|
|
// color's two RGB565 endpoints and 2-bit indices
|
|
std::array<uint8_t, 16> EncodeDxt5Block(const std::array<uint8_t, 64>& rgba);
|
|
|
|
// Lowercase hex MD5 of `data`
|
|
std::string Md5Hex(std::string_view data);
|
|
|
|
// What the client reads from a UGC file's .checksum: the MD5 and size of the file as it is after inflating it
|
|
std::string ChecksumXml(std::string_view data);
|
|
|
|
// The MD5 (lowercase hex) and size a .checksum (ChecksumXml) holds; false when it doesn't hold both
|
|
bool ReadChecksumXml(std::string_view xml, std::string& md5, uint32_t& size);
|
|
}
|