Mirrored_Repos/DarkflameServer
1
0
Fork 0
mirror of https://github.com/DarkflameUniverse/DarkflameServer.git synced 2026-10-02 02:43:44 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
992abf9d8a5ca33a523f75f9b023000037071366
DarkflameServer/dCommon/NifFile.cpp
Aaron Kimbrell 602acc0fe7 fix(nif): leave out a root node's rotation and translation 
The client's render component sets the object's own position and
rotation on the root node it loads, over the stored ones, so a root's
turn never shows in game (its scale stays). NifFile now reads roots the
same way. LU Toolbox's .nif (root turned 90 degrees about X, the
NiLODNodes turned back) now stands up in icons and the dashboard's
views; every game .nif has an unturned root and reads as before.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-29 18:13:45 -05:00

1019 lines
47 KiB
C++
Raw Blame History

#include "NifFile.h"
#include <algorithm>
#include <cmath>
#include <cstring>
#include <functional>
#include <limits>
#include <set>
#include "json.hpp"
namespace {
constexpr uint32_t Version(uint32_t a, uint32_t b, uint32_t c, uint32_t d) { return (a << 24) | (b << 16) | (c << 8) | d; }
constexpr uint32_t MIN_VERSION = Version(20, 2, 0, 5); // strings in a table and block sizes in the header
constexpr uint32_t MAX_VERSION = Version(20, 3, 0, 9);
constexpr uint32_t MAX_BLOCKS = 200000;
constexpr uint32_t MAX_DEPTH = 64;
constexpr uint16_t APP_CULLED = 1; // NiAVObject flag: hidden
// Little-endian reads that fail (and stay failed) instead of running past the end
class Reader {
public:
explicit Reader(std::string_view data) : m_Data(data) {}
template<typename T>
T Read() {
T value{};
if (!m_Ok || sizeof(T) > m_Data.size() - m_Pos) {
m_Ok = false;
return value;
}
std::memcpy(&value, m_Data.data() + m_Pos, sizeof(T));
m_Pos += sizeof(T);
return value;
}
float Float() { return Read<float>(); }
uint8_t U8() { return Read<uint8_t>(); }
uint16_t U16() { return Read<uint16_t>(); }
uint32_t U32() { return Read<uint32_t>(); }
int32_t I32() { return Read<int32_t>(); }
void Skip(uint64_t bytes) {
if (!m_Ok || bytes > m_Data.size() - m_Pos) {
m_Ok = false;
return;
}
m_Pos += static_cast<size_t>(bytes);
}
// `count` values of T, or empty (and failed) if there aren't that many
template<typename T>
std::vector<T> Array(uint64_t count) {
std::vector<T> values;
if (!m_Ok || count > (m_Data.size() - m_Pos) / sizeof(T)) {
m_Ok = false;
return values;
}
values.resize(static_cast<size_t>(count));
std::memcpy(values.data(), m_Data.data() + m_Pos, static_cast<size_t>(count) * sizeof(T));
m_Pos += static_cast<size_t>(count) * sizeof(T);
return values;
}
std::string SizedString() {
const auto length = U32();
if (!m_Ok || length > m_Data.size() - m_Pos) {
m_Ok = false;
return {};
}
std::string value(m_Data.substr(m_Pos, length));
m_Pos += length;
return value;
}
bool Ok() const { return m_Ok; }
size_t Position() const { return m_Pos; }
private:
std::string_view m_Data;
size_t m_Pos = 0;
bool m_Ok = true;
};
// Rotation (row-major, for column vectors), translation and uniform scale: p' = t + s * R p
struct Transform {
std::array<float, 9> r{ 1, 0, 0, 0, 1, 0, 0, 0, 1 };
std::array<float, 3> t{};
float s{ 1.0f };
std::array<float, 3> Rotate(const std::array<float, 3>& v) const {
return { r[0] * v[0] + r[1] * v[1] + r[2] * v[2], r[3] * v[0] + r[4] * v[1] + r[5] * v[2], r[6] * v[0] + r[7] * v[1] + r[8] * v[2] };
}
std::array<float, 3> Apply(const std::array<float, 3>& v) const {
const auto rotated = Rotate(v);
return { t[0] + s * rotated[0], t[1] + s * rotated[1], t[2] + s * rotated[2] };
}
// This transform, then `local` inside it (parent * child)
Transform Then(const Transform& local) const {
Transform out;
for (int row = 0; row < 3; row++) {
for (int col = 0; col < 3; col++) {
out.r[row * 3 + col] = r[row * 3] * local.r[col] + r[row * 3 + 1] * local.r[3 + col] + r[row * 3 + 2] * local.r[6 + col];
}
}
out.t = Apply(local.t);
out.s = s * local.s;
return out;
}
};
// The properties in effect at a point of the tree: a child's own property of a type replaces its parent's
struct Properties {
int32_t material = -1;
int32_t alpha = -1;
int32_t texturing = -1;
int32_t vertexColor = -1;
int32_t stencil = -1;
int32_t shaderTag = -1; // the nearest multishader tag ("S05__...") on the way down the tree
};
struct NetHeader {
std::string name;
int32_t controller{ -1 };
};
struct AvHeader {
std::string name;
uint16_t flags{};
Transform transform;
std::vector<int32_t> properties;
};
class Parser {
public:
Parser(std::string_view data, uint32_t lod) : m_Data(data), m_Lod(lod) {}
std::optional<NifFile::Model> Run(std::string& error) {
if (!ReadHeader(error)) return std::nullopt;
m_Model.version = m_Version;
// The footer lists the roots; the first block is the root when it can't be read
std::vector<int32_t> roots;
Reader footer(m_Data.substr(m_FooterStart));
const auto count = footer.U32();
if (footer.Ok() && count <= m_Blocks.size()) roots = footer.Array<int32_t>(count);
if (roots.empty() && !m_Blocks.empty()) roots.push_back(0);
for (const auto root : roots) Visit(root, Transform{}, Properties{}, 0);
for (size_t i = 0; i < m_Blocks.size(); i++) {
if (!m_Used.contains(static_cast<int32_t>(i))) {
const auto& type = m_Types[m_Blocks[i].type];
if (!IsDrawnType(type)) m_Model.skipped[type]++;
}
}
bool first = true;
for (const auto& mesh : m_Model.meshes) {
for (size_t i = 0; i + 2 < mesh.positions.size(); i += 3) {
for (int axis = 0; axis < 3; axis++) {
const auto value = mesh.positions[i + axis];
m_Model.min[axis] = first ? value : std::min(m_Model.min[axis], value);
m_Model.max[axis] = first ? value : std::max(m_Model.max[axis], value);
}
first = false;
}
}
return std::move(m_Model);
}
// The DDS file for pixel data block `index` (see NifFile::EmbeddedTexture)
std::optional<std::string> Dds(int32_t index, std::string& error) {
if (!ReadHeader(error)) return std::nullopt;
const auto* type = TypeOf(index);
if (!type || (*type != "NiPixelData" && *type != "NiPersistentSrcTextureRendererData")) return std::nullopt;
auto reader = BlockReader(index);
const auto format = reader.U32();
reader.U8(); // bits per pixel
reader.U32(); // renderer hint
reader.U32(); // extra data
reader.U8(); // flags
const auto tiling = reader.U32();
if (m_Version >= Version(20, 3, 0, 4)) reader.U8(); // sRGB
reader.Skip(4 * 10); // channels
reader.I32(); // palette
const auto mipCount = reader.U32();
const auto bytesPerPixel = reader.U32();
if (!reader.Ok() || mipCount == 0 || mipCount > 16 || tiling != 0) return std::nullopt;
std::vector<std::array<uint32_t, 3>> mips; // width, height, offset
for (uint32_t i = 0; i < mipCount; i++) mips.push_back({ reader.U32(), reader.U32(), reader.U32() });
const auto pixelCount = reader.U32();
if (*type == "NiPersistentSrcTextureRendererData") {
reader.U32(); // padded pixel count
reader.U32(); // faces
reader.U32(); // platform
} else {
reader.U32(); // faces
}
std::string_view pixels;
if (reader.Ok() && pixelCount <= m_Blocks[index].size - reader.Position()) pixels = m_Data.substr(m_Blocks[index].offset + reader.Position(), pixelCount);
const auto width = mips[0][0], height = mips[0][1];
if (pixels.empty() || width == 0 || height == 0 || width > 8192 || height > 8192 || mips[0][2] != 0) return std::nullopt;
// DDS header (Microsoft's DDS_HEADER and DDS_PIXELFORMAT)
std::array<uint32_t, 31> header{};
header[0] = 124;
header[1] = 0x1 | 0x2 | 0x4 | 0x1000 | 0x20000; // caps, height, width, pixel format, mipmap count
header[2] = height;
header[3] = width;
header[6] = mipCount;
header[18] = 32; // pixel format size
if (format >= 4 && format <= 6) {
header[19] = 0x4; // four CC
const char* fourCc = format == 4 ? "DXT1" : format == 5 ? "DXT3" : "DXT5";
std::memcpy(&header[20], fourCc, 4);
} else if ((format == 0 && bytesPerPixel == 3) || (format == 1 && bytesPerPixel == 4)) {
header[19] = format == 1 ? 0x41 : 0x40; // RGB, with alpha
header[21] = bytesPerPixel * 8;
header[22] = 0x000000FF; // red first in memory
header[23] = 0x0000FF00;
header[24] = 0x00FF0000;
header[25] = format == 1 ? 0xFF000000 : 0;
} else {
return std::nullopt;
}
header[26] = 0x1000 | (mipCount > 1 ? 0x400008 : 0); // texture, mipmaps
std::string out = "DDS ";
out.append(reinterpret_cast<const char*>(header.data()), header.size() * 4);
out.append(pixels);
return out;
}
private:
struct Block {
uint16_t type{};
size_t offset{};
uint32_t size{};
};
std::string_view m_Data;
uint32_t m_Lod;
uint32_t m_Version{};
std::vector<std::string> m_Types;
std::vector<std::string> m_Strings;
std::vector<Block> m_Blocks;
size_t m_FooterStart{};
std::set<int32_t> m_Used;
std::set<int32_t> m_Visiting;
std::vector<std::vector<float>> m_UvSets; // the UV sets of the geometry being read
NifFile::Model m_Model;
static bool IsDrawnType(const std::string& type) {
return type == "NiNode" || type == "NiLODNode" || type == "NiBillboardNode" || type == "NiSwitchNode" ||
type == "NiTriShape" || type == "NiTriStrips" || type == "NiTriShapeData" || type == "NiTriStripsData" ||
type == "NiMaterialProperty" || type == "NiAlphaProperty" || type == "NiTexturingProperty" || type == "NiSourceTexture" ||
type == "NiVertexColorProperty" || type == "NiStencilProperty" || type == "NiRangeLODData" ||
// Read and ignored: they change nothing a still picture shows
type == "NiSpecularProperty" || type == "NiZBufferProperty" || type == "NiShadeProperty" || type == "NiStringExtraData";
}
bool ReadHeader(std::string& error) {
const auto newline = m_Data.substr(0, 128).find('\n');
if (newline == std::string_view::npos || !(m_Data.starts_with("Gamebryo File Format") || m_Data.starts_with("NetImmerse File Format"))) {
error = "not a Gamebryo file";
return false;
}
Reader header(m_Data.substr(newline + 1));
m_Version = header.U32();
if (m_Version < MIN_VERSION || m_Version > MAX_VERSION) {
error = "unsupported version";
return false;
}
const auto endian = header.U8();
const auto userVersion = header.U32();
const auto blockCount = header.U32();
if (!header.Ok() || endian != 1 || userVersion != 0 || blockCount > MAX_BLOCKS) {
error = "unsupported header (big-endian or another game's user version)";
return false;
}
const auto typeCount = header.U16();
for (uint32_t i = 0; i < typeCount && header.Ok(); i++) m_Types.push_back(header.SizedString());
const auto typeIndex = header.Array<uint16_t>(blockCount);
const auto sizes = header.Array<uint32_t>(blockCount);
const auto stringCount = header.U32();
header.U32(); // longest string
for (uint32_t i = 0; i < stringCount && header.Ok(); i++) m_Strings.push_back(header.SizedString());
const auto groupCount = header.U32();
header.Skip(static_cast<uint64_t>(groupCount) * 4);
if (!header.Ok()) {
error = "truncated header";
return false;
}
size_t offset = newline + 1 + header.Position();
m_Blocks.reserve(blockCount);
for (uint32_t i = 0; i < blockCount; i++) {
const uint16_t type = typeIndex[i] & 0x7FFF; // the high bit marks PhysX blocks
if (type >= m_Types.size() || sizes[i] > m_Data.size() - offset) {
error = "block " + std::to_string(i) + " is out of range";
return false;
}
m_Blocks.push_back({ type, offset, sizes[i] });
offset += sizes[i];
}
m_FooterStart = offset;
return true;
}
const std::string* TypeOf(int32_t index) const {
if (index < 0 || static_cast<size_t>(index) >= m_Blocks.size()) return nullptr;
return &m_Types[m_Blocks[index].type];
}
Reader BlockReader(int32_t index) const {
const auto& block = m_Blocks[index];
return Reader(m_Data.substr(block.offset, block.size));
}
std::string String(uint32_t index) const {
return index < m_Strings.size() ? m_Strings[index] : std::string{};
}
NetHeader ReadNet(Reader& reader) {
NetHeader net;
net.name = String(reader.U32());
const auto extra = reader.U32();
reader.Skip(static_cast<uint64_t>(extra) * 4);
net.controller = reader.I32();
return net;
}
AvHeader ReadAv(Reader& reader) {
AvHeader av;
av.name = ReadNet(reader).name;
av.flags = reader.U16();
for (auto& value : av.transform.t) value = reader.Float();
// Matrix33 is stored m11, m21, m31, m12, ... (nif.xml): column by column
std::array<float, 9> stored{};
for (auto& value : stored) value = reader.Float();
for (int row = 0; row < 3; row++) {
for (int col = 0; col < 3; col++) av.transform.r[row * 3 + col] = stored[col * 3 + row];
}
av.transform.s = reader.Float();
const auto count = reader.U32();
av.properties = reader.Array<int32_t>(count);
reader.I32(); // collision object
return av;
}
Properties Inherit(Properties properties, const std::vector<int32_t>& own) {
for (const auto ref : own) {
const auto* type = TypeOf(ref);
if (!type) continue;
if (*type == "NiMaterialProperty") properties.material = ref;
else if (*type == "NiAlphaProperty") properties.alpha = ref;
else if (*type == "NiTexturingProperty") properties.texturing = ref;
else if (*type == "NiVertexColorProperty") properties.vertexColor = ref;
else if (*type == "NiStencilProperty") properties.stencil = ref;
m_Used.insert(ref);
}
return properties;
}
void Visit(int32_t index, const Transform& parent, Properties properties, uint32_t depth) {
const auto* type = TypeOf(index);
if (!type || depth > MAX_DEPTH || m_Visiting.contains(index)) return;
m_Visiting.insert(index);
if (*type == "NiNode" || *type == "NiLODNode" || *type == "NiBillboardNode" || *type == "NiSwitchNode") {
m_Used.insert(index);
VisitNode(index, *type, parent, properties, depth);
} else if (*type == "NiTriShape" || *type == "NiTriStrips") {
m_Used.insert(index);
VisitGeometry(index, parent, properties);
}
m_Visiting.erase(index);
}
void VisitNode(int32_t index, const std::string& type, const Transform& parent, Properties properties, uint32_t depth) {
auto reader = BlockReader(index);
const auto av = ReadAv(reader);
const auto childCount = reader.U32();
const auto children = reader.Array<int32_t>(childCount);
const auto effectCount = reader.U32();
reader.Skip(static_cast<uint64_t>(effectCount) * 4);
if (!reader.Ok()) return;
// The client puts the object's own position and rotation in place of the root node's (the render component
// sets them on the loaded root), so a root's stored rotation and translation are never seen; its scale is kept
auto local = av.transform;
if (depth == 0) {
local.r = Transform{}.r;
local.t = {};
}
const auto world = parent.Then(local);
// Recorded even when hidden: attach points often are
if (!av.name.empty() && !m_Model.nodes.contains(av.name)) {
NifFile::NodeTransform node;
for (int i = 0; i < 9; i++) node.rotation[i] = world.r[i] * world.s;
node.translation = world.t;
m_Model.nodes.emplace(av.name, node);
}
if (av.flags & APP_CULLED) return;
properties = Inherit(properties, av.properties);
if (const auto tag = NifFile::ShaderTag(av.name); tag >= 0) properties.shaderTag = tag;
std::vector<int32_t> drawn = children;
if (type == "NiSwitchNode" || type == "NiLODNode") {
reader.U16(); // switch flags
const auto active = reader.U32();
drawn.clear();
if (type == "NiSwitchNode") {
if (reader.Ok() && active < children.size()) drawn.push_back(children[active]);
} else if (const auto chosen = ChooseLod(reader.I32(), children)) {
drawn.push_back(*chosen);
}
}
for (const auto child : drawn) Visit(child, world, properties, depth + 1);
}
// The child of an NiLODNode for m_Lod: children ordered nearest range first (the most detailed)
std::optional<int32_t> ChooseLod(int32_t dataRef, const std::vector<int32_t>& children) {
if (children.empty()) return std::nullopt;
std::vector<std::pair<float, int32_t>> order;
const auto* dataType = TypeOf(dataRef);
if (dataType && *dataType == "NiRangeLODData") {
m_Used.insert(dataRef);
auto data = BlockReader(dataRef);
data.Skip(12); // center
const auto levels = data.U32();
for (uint32_t i = 0; i < levels && data.Ok() && i < children.size(); i++) {
const auto nearExtent = data.Float();
data.Float(); // far extent
if (data.Ok()) order.emplace_back(nearExtent, children[i]);
}
}
if (order.size() != children.size()) {
order.clear();
for (size_t i = 0; i < children.size(); i++) order.emplace_back(static_cast<float>(i), children[i]);
}
std::stable_sort(order.begin(), order.end(), [](const auto& a, const auto& b) { return a.first < b.first; });
return order[std::min<size_t>(m_Lod, order.size() - 1)].second;
}
void VisitGeometry(int32_t index, const Transform& parent, Properties properties) {
auto reader = BlockReader(index);
const auto av = ReadAv(reader);
const auto dataRef = reader.I32();
const auto skin = reader.I32();
if (!reader.Ok() || (av.flags & APP_CULLED)) return;
properties = Inherit(properties, av.properties);
if (const auto tag = NifFile::ShaderTag(av.name); tag >= 0) properties.shaderTag = tag;
const auto* dataType = TypeOf(dataRef);
if (!dataType || (*dataType != "NiTriShapeData" && *dataType != "NiTriStripsData")) return;
m_Used.insert(dataRef);
NifFile::Mesh mesh;
m_UvSets.clear();
if (!ReadGeometryData(dataRef, *dataType == "NiTriStripsData", parent.Then(av.transform), mesh) || mesh.indices.empty()) return;
uint8_t baseSet = 0, darkSet = 0;
mesh.material = ReadMaterial(properties, baseSet, darkSet);
// Each texture reads the UV set its flags name (TexturingMapFlags' low byte), the first when that's missing
const auto set = [this](uint8_t index) { return index < m_UvSets.size() ? m_UvSets[index] : m_UvSets.empty() ? std::vector<float>{} : m_UvSets[0]; };
mesh.uvs = set(baseSet);
if (!mesh.material.darkTexture.empty() || mesh.material.embeddedDarkTexture >= 0) mesh.uvs2 = set(darkSet);
mesh.material.shaderTag = properties.shaderTag;
if (skin >= 0) {
m_Model.skinned++;
m_Used.insert(skin);
}
m_Model.meshes.push_back(std::move(mesh));
}
bool ReadGeometryData(int32_t index, bool strips, const Transform& transform, NifFile::Mesh& mesh) {
auto reader = BlockReader(index);
reader.I32(); // group ID
const auto count = reader.U16();
reader.U8(); // keep flags
reader.U8(); // compress flags
if (reader.U8()) {
const auto vertices = reader.Array<float>(static_cast<uint64_t>(count) * 3);
mesh.positions.reserve(vertices.size());
for (size_t i = 0; i + 2 < vertices.size(); i += 3) {
const auto p = transform.Apply({ vertices[i], vertices[i + 1], vertices[i + 2] });
mesh.positions.insert(mesh.positions.end(), p.begin(), p.end());
}
}
const auto dataFlags = reader.U16();
if (reader.U8()) {
const auto normals = reader.Array<float>(static_cast<uint64_t>(count) * 3);
mesh.normals.reserve(normals.size());
for (size_t i = 0; i + 2 < normals.size(); i += 3) {
auto n = transform.Rotate({ normals[i], normals[i + 1], normals[i + 2] });
const auto length = std::sqrt(n[0] * n[0] + n[1] * n[1] + n[2] * n[2]);
if (length > 0.0f) for (auto& value : n) value /= length;
mesh.normals.insert(mesh.normals.end(), n.begin(), n.end());
}
if (dataFlags & 4096) reader.Skip(static_cast<uint64_t>(count) * 24); // tangents and bitangents
}
reader.Skip(16); // bounding sphere
if (reader.U8()) {
const auto colors = reader.Array<float>(static_cast<uint64_t>(count) * 4);
mesh.colors.reserve(colors.size());
for (const auto value : colors) mesh.colors.push_back(static_cast<uint8_t>(std::lround(std::clamp(value, 0.0f, 1.0f) * 255.0f)));
}
const auto uvSets = dataFlags & 63;
for (int set = 0; set < uvSets; set++) m_UvSets.push_back(reader.Array<float>(static_cast<uint64_t>(count) * 2));
reader.U16(); // consistency flags
reader.I32(); // additional data
const auto triangles = reader.U16();
if (!strips) {
reader.U32(); // triangle points
if (reader.U8()) mesh.indices = reader.Array<uint16_t>(static_cast<uint64_t>(triangles) * 3);
} else {
const auto stripCount = reader.U16();
const auto lengths = reader.Array<uint16_t>(stripCount);
if (reader.U8()) {
for (const auto length : lengths) {
const auto points = reader.Array<uint16_t>(length);
for (size_t i = 2; i < points.size(); i++) {
const auto a = points[i - 2], b = points[i - 1], c = points[i];
if (a == b || b == c || a == c) continue;
if (i % 2 == 0) mesh.indices.insert(mesh.indices.end(), { a, b, c });
else mesh.indices.insert(mesh.indices.end(), { a, c, b });
}
}
}
}
if (!reader.Ok() || mesh.positions.size() != static_cast<size_t>(count) * 3) return false;
if (mesh.normals.size() != mesh.positions.size()) mesh.normals.clear();
if (mesh.colors.size() != static_cast<size_t>(count) * 4) mesh.colors.clear();
std::erase_if(m_UvSets, [count](const std::vector<float>& set) { return set.size() != static_cast<size_t>(count) * 2; });
// Drop triangles pointing past the vertices
std::vector<uint16_t> valid;
valid.reserve(mesh.indices.size());
for (size_t i = 0; i + 2 < mesh.indices.size(); i += 3) {
if (mesh.indices[i] < count && mesh.indices[i + 1] < count && mesh.indices[i + 2] < count) {
valid.insert(valid.end(), { mesh.indices[i], mesh.indices[i + 1], mesh.indices[i + 2] });
}
}
mesh.indices = std::move(valid);
return true;
}
// A texture slot's NiSourceTexture: an external file name or the block of pixels stored in the file
void ReadSource(int32_t source, std::string& file, int32_t& embedded) {
const auto* type = TypeOf(source);
if (!type || *type != "NiSourceTexture") return;
m_Used.insert(source);
auto texture = BlockReader(source);
ReadNet(texture);
const auto external = texture.U8();
const auto name = String(texture.U32());
const auto pixels = texture.I32();
const auto* pixelType = TypeOf(pixels);
if (texture.Ok() && external == 1) file = name;
else if (texture.Ok() && pixelType && (*pixelType == "NiPixelData" || *pixelType == "NiPersistentSrcTextureRendererData")) {
embedded = pixels;
m_Used.insert(pixels);
}
}
// An NiFloatInterpolator's keys (its NiFloatData's) as time, value pairs; empty without data
std::vector<std::array<float, 2>> FloatKeys(int32_t interpolator) {
std::vector<std::array<float, 2>> out;
const auto* interpolatorType = TypeOf(interpolator);
if (!interpolatorType || *interpolatorType != "NiFloatInterpolator") return out;
m_Used.insert(interpolator);
auto value = BlockReader(interpolator);
value.Float();
const auto data = value.I32();
const auto* dataType = TypeOf(data);
if (!value.Ok() || !dataType || *dataType != "NiFloatData") return out;
m_Used.insert(data);
auto keys = BlockReader(data);
const auto count = keys.U32();
const auto keyType = count > 0 ? keys.U32() : 0;
// Linear keys are time and value; quadratic add two tangents; TBC three floats
const uint32_t floats = keyType == 1 ? 2 : keyType == 2 ? 4 : keyType == 3 ? 5 : 0;
if (count == 0 || floats == 0 || count > 100000) return out;
const auto values = keys.Array<float>(static_cast<uint64_t>(count) * floats);
if (!keys.Ok()) return out;
for (uint32_t key = 0; key < count; key++) out.push_back({ values[key * floats], values[key * floats + 1] });
return out;
}
// The highest alpha an NiAlphaController among the controllers from `first` on (an NiMaterialProperty's) gives
// the material: flickering and fading effects often rest at 0 in the file and only show while animated
std::optional<float> AnimatedAlpha(int32_t first) {
std::optional<float> highest;
std::set<int32_t> seen;
for (int32_t index = first; index >= 0 && !seen.contains(index);) {
seen.insert(index);
const auto* type = TypeOf(index);
if (!type) break;
auto reader = BlockReader(index);
const auto next = reader.I32();
if (*type == "NiAlphaController") {
m_Used.insert(index);
reader.Skip(2 + 16); // flags, frequency, phase, start, stop
reader.I32(); // target
const auto interpolator = reader.I32();
if (reader.Ok()) {
for (const auto& [time, value] : FloatKeys(interpolator)) highest = std::max(highest.value_or(value), value);
}
}
if (!reader.Ok()) break;
index = next;
}
return highest;
}
// Tiles a second the controllers from `first` on (an NiTexturingProperty's) move its base map in U and V: each
// NiTextureTransformController translating the base map, from its NiFloatInterpolator's NiFloatData's first key
// to its last, times its frequency
std::array<float, 2> BaseMapScroll(int32_t first) {
std::array<float, 2> scroll{};
std::set<int32_t> seen;
for (int32_t index = first; index >= 0 && !seen.contains(index);) {
seen.insert(index);
const auto* type = TypeOf(index);
if (!type || *type != "NiTextureTransformController") break;
m_Used.insert(index);
auto reader = BlockReader(index);
const auto next = reader.I32();
reader.U16(); // flags
const auto frequency = reader.Float();
reader.Skip(12); // phase, start, stop
reader.I32(); // target
const auto interpolator = reader.I32();
const auto shaderMap = reader.U8();
const auto slot = reader.U32();
const auto operation = reader.U32();
if (reader.Ok() && !shaderMap && slot == 0 && operation <= 1) {
const auto keys = FloatKeys(interpolator);
if (keys.size() >= 2) {
const float duration = keys.back()[0] - keys.front()[0];
if (duration > 0.0f) scroll[operation] = (keys.back()[1] - keys.front()[1]) / duration * frequency;
}
}
index = next;
}
return scroll;
}
NifFile::Material ReadMaterial(const Properties& properties, uint8_t& baseSet, uint8_t& darkSet) {
NifFile::Material material;
if (properties.material >= 0) {
auto reader = BlockReader(properties.material);
const auto controller = ReadNet(reader).controller;
reader.Skip(12); // ambient
std::array<float, 3> diffuse{}, emissive{};
for (auto& value : diffuse) value = reader.Float();
reader.Skip(12); // specular
for (auto& value : emissive) value = reader.Float();
reader.Float(); // glossiness
const auto alpha = reader.Float();
if (reader.Ok()) {
material.diffuse = diffuse;
material.emissive = emissive;
material.alpha = std::clamp(alpha, 0.0f, 1.0f);
}
// An animated alpha is drawn at its highest (the views don't play the controller)
if (const auto animated = AnimatedAlpha(controller)) material.alpha = std::clamp(*animated, 0.0f, 1.0f);
}
if (properties.alpha >= 0) {
auto reader = BlockReader(properties.alpha);
ReadNet(reader);
const auto flags = reader.U16();
const auto threshold = reader.U8();
if (reader.Ok()) {
material.alphaBlend = flags & 1;
material.alphaTest = flags & 0x200;
material.alphaThreshold = threshold;
}
}
if (properties.vertexColor >= 0) {
auto reader = BlockReader(properties.vertexColor);
ReadNet(reader);
const auto flags = reader.U16();
if (reader.Ok()) material.vertexColorMode = static_cast<uint8_t>((flags >> 4) & 3);
}
if (properties.stencil >= 0) {
auto reader = BlockReader(properties.stencil);
ReadNet(reader);
const auto flags = reader.U16();
if (reader.Ok()) material.doubleSided = ((flags >> 10) & 3) == 3; // DRAW_BOTH
}
if (properties.texturing >= 0) {
auto reader = BlockReader(properties.texturing);
material.uvScroll = BaseMapScroll(ReadNet(reader).controller);
reader.U16(); // flags
reader.U32(); // texture count
// TexDesc (nif.xml, 20.1.0.3 on): source, TexturingMapFlags (clamp in bits 12-15, UV set in 0-7), whether a
// texture transform follows (translation, scale, rotation, method, center: 32 bytes)
const auto texDesc = [&reader](int32_t& source, uint16_t& flags) {
source = reader.I32();
flags = reader.U16();
if (reader.U8()) reader.Skip(32);
};
int32_t source = -1;
uint16_t flags = 0;
if (reader.U8()) { // has base texture
texDesc(source, flags);
if (reader.Ok()) {
ReadSource(source, material.texture, material.embeddedTexture);
const auto clamp = (flags >> 12) & 0xF;
material.clampU = clamp == 0 || clamp == 1;
material.clampV = clamp == 0 || clamp == 2;
baseSet = static_cast<uint8_t>(flags & 0xFF);
}
}
if (reader.U8()) { // has dark texture
texDesc(source, flags);
if (reader.Ok()) {
ReadSource(source, material.darkTexture, material.embeddedDarkTexture);
darkSet = static_cast<uint8_t>(flags & 0xFF);
}
}
}
return material;
}
};
void Append(std::string& out, const void* data, size_t bytes) {
out.append(static_cast<const char*>(data), bytes);
}
void Pad(std::string& out) {
while (out.size() % 4) out.push_back('\0');
}
nlohmann::json Color(const std::array<float, 3>& color) {
return { std::round(color[0] * 1000.0f) / 1000.0f, std::round(color[1] * 1000.0f) / 1000.0f, std::round(color[2] * 1000.0f) / 1000.0f };
}
}
namespace NifFile {
int32_t ShaderTag(std::string_view name) {
// The client reads the tag with sscanf: "S%d" at the start of the name, else "_S%d" after the first "_S"
const auto number = [](std::string_view digits) -> int32_t {
size_t i = 0;
while (i < digits.size() && (digits[i] == ' ' || digits[i] == '\t')) i++;
// A signed number names no mapShaders row, like no number at all
if (i >= digits.size() || digits[i] < '0' || digits[i] > '9') return -1;
int32_t value = 0;
for (; i < digits.size() && digits[i] >= '0' && digits[i] <= '9' && value < 100000; i++) value = value * 10 + (digits[i] - '0');
return value;
};
if (name.starts_with('S')) {
const auto tag = number(name.substr(1));
if (tag >= 0) return tag;
}
const auto at = name.find("_S");
if (at == std::string_view::npos || at + 3 >= name.size()) return -1;
return number(name.substr(at + 2));
}
int32_t MultishaderPart(std::optional<int32_t> tagShader) {
return tagShader && *tagShader >= 3 && *tagShader <= 0x6C ? *tagShader : LEGO_SHADER;
}
namespace {
using F = eShaderFamily;
constexpr auto OPACITY = eTextureAlpha::OPACITY, DECAL = eTextureAlpha::DECAL, IGNORED = eTextureAlpha::IGNORED;
struct TechniqueRow {
int32_t shader;
ShaderTechnique technique;
};
/**
* Every mapShaders gameValue, by the technique its shader class sets up (ShaderManager's factory table at
* 0x01889608, indexed by gameValue; the class's technique setup names it) and the client's res/shaders/*.fx.
* Checked in the client: 33 and 82 Technique_Basic_NoLighting_VertColor_NoTexture, 35 and 84
* Technique_Basic_NoLighting_VertColor, 37 Technique_Basic_Lighting_VertColor_NoTexture, 38 and 94
* Technique_Basic_Lighting_VertColor (94 "Basic": the vtable slot at +0x90 of the class made at 0x0045f240 names
* it), 70 Technique_AlphaAsAlpha_UVScrolling_SimpleV_NoLighting_AlphaAnim, 105
* Technique_TwoLayersBlended_NoLighting_VertColor_UVScrolling. The rest follow their mapShaders labels ("NL" no
* lighting, "NT" no texture, "VC" vertex colors, "AnimUV"/"ScrollingUV" the texture transform, "OneSidedAlpha"
* AlphaAsAlpha culled) and the technique of that name in res/shaders.
*/
constexpr TechniqueRow TECHNIQUES[] = {
{ -1, { F::FIXED_FUNCTION, 0, OPACITY, 0 } },
// TerrainDiffuse.fx's mesh techniques: the texture times the vertex colors and the light, alpha only the fade
{ 2, { F::TERRAIN, 0, OPACITY, NO_BLEND } }, // Terrain Mesh
{ 3, { F::TERRAIN, 0, IGNORED, RIM_LIGHT | NO_BLEND } }, // Terrain Mesh Rim Light
{ 97, { F::TERRAIN, 0, OPACITY, DIFFUSE_ONLY | NO_BLEND } }, // Terrain Diffuse Map Only
// LEGOPPLighting: textured alone the texture's alpha is forced to 1; with vertex colors it only lays the
// texture over them (lerp by its alpha) and the vertex alpha is what shows through
{ 4, { F::LEGO, 0, DECAL, 0 } }, // LEGO (No LOD)
{ 5, { F::LEGO, 0, DECAL, 0 } }, // LEGO
{ 12, { F::LEGO, 0, DECAL, 0 } }, // LEGO-Reveal (the reveal mask left out)
{ 14, { F::LEGO, 0, OPACITY, NON_DECAL } }, // LEGO Masked NonDecal (the specular mask left out)
{ 19, { F::LEGO, 0, DECAL, 0 } }, // Powerups (their own effect, drawn as LEGO)
{ 20, { F::LEGO, 0, DECAL, 0 } }, // Orb (Powerups.fx, drawn as LEGO)
{ 22, { F::LEGO, EMISSIVE, OPACITY, SUPER_EMISSIVE } }, // LEGO-SuperEmissive
{ 25, { F::LEGO, 0, DECAL, 0 } }, // LEGO_FrontEnd
{ 26, { F::LEGO, 0, OPACITY, NON_DECAL } }, // LEGO_FaceCreate
{ 27, { F::LEGO, 0, DECAL, GLOW } }, // LEGO-Glow
{ 28, { F::LEGO, 0, DECAL, GRAYSCALE } }, // LEGO-Grayscale
{ 29, { F::LEGO, 0, DECAL, GLOW | IGNORE_VERTEX_ALPHA } }, // LEGO-Glow-IgnoreVertAlpha
{ 30, { F::LEGO, 0, DECAL, UV_ANIM } }, // LEGO-AnimUV
// LEGOPPLighting_Item: texture alpha forced to 1, multiplied by the vertex colors
{ 31, { F::LEGO, 0, IGNORED, NON_DECAL } }, // LEGO-Item
{ 48, { F::LEGO, 0, IGNORED, NON_DECAL | GLOW } }, // LEGO-ItemGlow
{ 50, { F::LEGO, 0, DECAL, 0 } }, // LEGO-FadeUp (as when faded in)
{ 53, { F::LEGO, EMISSIVE, OPACITY, 0 } }, // LEGO-Emissive
{ 72, { F::LEGO, 0, DECAL, SHINY_GLINT } }, // ShinyGlint
{ 88, { F::LEGO, 0, DECAL, NO_AMBIENT } }, // LEGO NoAmbient
{ 92, { F::LEGO, 0, DECAL, 0 } }, // Pet Taming LEGO In Cloud
// LEGOPPLighting's NL pixel shaders: the vertex color or texture as it is
{ 52, { F::BASIC, UNLIT, OPACITY, ANIM_ALPHA } }, // LEGO-No Light
// Darkling: the same lay-over; the dark texture on the second UV set through a window of vertex alphas
{ 75, { F::DARKLING, 0, DECAL, 0 } }, // Darkling
{ 76, { F::DARKLING, 0, DECAL, SPECULAR } }, // Darkling /w Specular
{ 77, { F::DARKLING, 0, DECAL, NON_DECAL } }, // Darkling Structure
{ 102, { F::DARKLING, 0, DECAL, SHINY_GLINT } }, // Darking Shiny Glint
{ 103, { F::DARKLING, 0, DECAL, SPECULAR | SHINY_GLINT } }, // Darkling /w Specular Shiny Glint
{ 104, { F::DARKLING, 0, DECAL, NON_DECAL | SHINY_GLINT } }, // Darkling Structure Shiny Glint
// AlphaAsAlpha: texture times the (lit) vertex color, both sides
{ 7, { F::BASIC, 0, OPACITY, DOUBLE_SIDED } }, // VertColor_Alpha
{ 8, { F::BASIC, UNLIT, OPACITY, DOUBLE_SIDED | ANIM_ALPHA } }, // VertColor_NoLighting_Alpha
{ 9, { F::BASIC, 0, OPACITY, DOUBLE_SIDED } }, // VertColor_Alpha_Fade
{ 10, { F::BASIC, UNLIT, OPACITY, DOUBLE_SIDED | ANIM_ALPHA | BLEND } }, // VertColorTex_NoLight_AlphaBlend
{ 54, { F::BASIC, UNLIT, OPACITY, DOUBLE_SIDED | ANIM_ALPHA | ALPHA_TEST } }, // VertColorTex_NoLight_AlphaTest
{ 13, { F::BASIC, 0, OPACITY, UV_ANIM } }, // ScrollingUV
{ 70, { F::BASIC, UNLIT, OPACITY, UV_ANIM | ANIM_ALPHA } }, // ScrollingUV_NoLight_AnimAlpha
{ 73, { F::BASIC, UNLIT, OPACITY, UV_ANIM | ANIM_ALPHA } }, // ScrollingUV_NoLight_AimAlpha_Post
{ 81, { F::BASIC, UNLIT, OPACITY, UV_ANIM | ANIM_ALPHA | NO_FOG } }, // ScrollingUV NL AnimAlpha NoFog
// OneSidedAlpha: the same, culled
{ 55, { F::BASIC, 0, OPACITY, 0 } }, // OneSidedAlpha VC
{ 56, { F::BASIC, UNLIT | NO_VERTEX_COLORS, OPACITY, 0 } }, // OneSidedAlpha NL
{ 57, { F::BASIC, UNLIT, OPACITY, ANIM_ALPHA } }, // OneSidedAlpha NL VC
{ 58, { F::BASIC, UNLIT | NO_TEXTURE, OPACITY, ANIM_ALPHA } }, // OneSidedAlpha NL VC NT
{ 59, { F::BASIC, 0, OPACITY, UV_ANIM } }, // OneSidedAlpha AnimUV V Skinned
{ 60, { F::BASIC, 0, OPACITY, 0 } }, // OneSidedAlpha VC Skinned
{ 61, { F::BASIC, UNLIT | NO_VERTEX_COLORS, OPACITY, 0 } }, // OneSidedAlpha NL Skinned
{ 62, { F::BASIC, UNLIT, OPACITY, ANIM_ALPHA } }, // OneSidedAlpha NL VC Skinned
{ 63, { F::BASIC, UNLIT | NO_TEXTURE, OPACITY, ANIM_ALPHA } }, // OneSidedAlpha NL VC NT Skinned
{ 64, { F::BASIC, 0, OPACITY, UV_ANIM } }, // OneSidedAlpha AnimUV V
{ 68, { F::BASIC, UNLIT, OPACITY, ANIM_ALPHA } }, // OneSidedAlpha NL AnimAlpha
// BasicShaders
{ 11, { F::BASIC, UNLIT | NO_TEXTURE, OPACITY, ANIM_ALPHA } }, // VertColor_NoLight_NoTex_AnimAlpha
{ 15, { F::BASIC, UNLIT, OPACITY, 0 } }, // VC_NoLighting_2D
{ 16, { F::BASIC, UNLIT | NO_TEXTURE, OPACITY, 0 } }, // VC_NL_NoTex_2D
{ 17, { F::BASIC, UNLIT, OPACITY, 0 } }, // TV Screen (its static and flicker left out)
{ 18, { F::BASIC, UNLIT, OPACITY, 0 } }, // Head Icon
{ 23, { F::BASIC, UNLIT, OPACITY, 0 } }, // Over Everything (Unlit)
{ 24, { F::BASIC, UNLIT, OPACITY, NO_FOG | BLEND } }, // Fogless GrayBubble
{ 32, { F::BASIC, UNLIT | NO_VERTEX_COLORS | MATERIAL_COLOR, OPACITY, 0 } }, // Basic NL Material
{ 33, { F::BASIC, UNLIT | NO_TEXTURE, OPACITY, ANIM_ALPHA } }, // Basic NL VC NT
{ 34, { F::BASIC, UNLIT | NO_VERTEX_COLORS, OPACITY, 0 } }, // Basic NL
{ 35, { F::BASIC, UNLIT, OPACITY, 0 } }, // Basic NL VC
{ 36, { F::BASIC, UNLIT | NO_VERTEX_COLORS, OPACITY, UV_ANIM } }, // Basic NL UVAnim
{ 37, { F::BASIC, NO_TEXTURE, OPACITY, 0 } }, // Basic VC NT
{ 38, { F::BASIC, 0, OPACITY, 0 } }, // Basic VC
{ 39, { F::BASIC, 0, OPACITY, UV_ANIM } }, // Basic VC UVAnim
{ 49, { F::BASIC, 0, OPACITY, 0 } }, // Experimental Stub
{ 65, { F::BASIC, 0, OPACITY, BASIC_EMISSIVE } }, // VC_Texture_Emissive
{ 80, { F::BASIC, UNLIT | NO_TEXTURE, OPACITY, 0 } }, // Basic NL NT
{ 82, { F::BASIC, UNLIT | NO_TEXTURE, OPACITY, NO_BLEND | NO_FOG } }, // Opaque NL VC NT NoFog
{ 83, { F::BASIC, UNLIT | NO_VERTEX_COLORS, OPACITY, NO_BLEND | NO_FOG } }, // Opaque NL NoFog
{ 84, { F::BASIC, UNLIT, OPACITY, NO_BLEND | NO_FOG } }, // Opaque NL VC NoFog
{ 85, { F::BASIC, NO_TEXTURE, OPACITY, NO_BLEND | NO_FOG } }, // Opaque VC NT NoFog
{ 86, { F::BASIC, 0, OPACITY, NO_BLEND | NO_FOG } }, // Opaque VC NoFog
{ 87, { F::BASIC, UNLIT, OPACITY, ADDITIVE } }, // Additive NoLight VertColor
{ 91, { F::BASIC, UNLIT, OPACITY, BLEND } }, // Pet Taming Imagination Cloud
{ 94, { F::BASIC, 0, OPACITY, 0 } }, // Basic
{ 108, { F::BASIC, UNLIT | NO_VERTEX_COLORS | MATERIAL_COLOR, OPACITY, 0 } }, // Over Everything Material Unlit
// Two layers (TwoLayersAdded_PS in BasicShaders.fx; the client ships no Technique_TwoLayersBlended_* shader,
// so the blended ones follow the meshes' data: the dark texture under the base one by the vertex alpha, as
// Avant Gardens' snow caps and grass fade into rock by it)
{ 93, { F::BASIC, UNLIT | TWO_LAYERS_ADDED, OPACITY, UV_ANIM } }, // Two Textures Added NL VC AnimUV
{ 105, { F::BASIC, UNLIT | TWO_LAYERS_BLENDED, OPACITY, UV_ANIM } }, // Two Layers Blended NL VC AnimUV
{ 106, { F::BASIC, TWO_LAYERS_BLENDED, OPACITY, UV_ANIM } }, // Two Layers Blended VC AnimUV
{ 107, { F::BASIC, TWO_LAYERS_ADDED, OPACITY, UV_ANIM } }, // Two Layers Added VC AnimUV
// Metallic.fx: both load their reflection cubes themselves (textures/metal)
{ 98, { F::METAL, REFLECTIVE, OPACITY, 0 } }, // Polished Metal
{ 99, { F::METAL, REFLECTIVE | BRUSHED, OPACITY, 0 } }, // Brushed Steel
{ 100, { F::METAL, REFLECTIVE | BRUSHED, OPACITY, 0 } }, // Brushed Steel Item
{ 6, { F::CLEAR_PLASTIC, 0, OPACITY, BLEND } }, // Clear Plastic
{ 51, { F::BRICK_WATER, 0, OPACITY, 0 } }, // BrickWater
// Ocean.fx
{ 69, { F::OCEAN, 0, OPACITY, UV_ANIM } }, // Distortion (Ocean)
{ 89, { F::OCEAN, 0, OPACITY, UV_ANIM } }, // Distortion Directional (Ocean)
{ 90, { F::OCEAN, UNLIT, OPACITY, UV_ANIM | OCEAN_FX } }, // Distortion FX (Ocean)
{ 95, { F::OCEAN, 0, OPACITY, UV_ANIM | BLEND } }, // Distortion NoDepth (Ocean) (Alpha)
{ 101, { F::OCEAN, UNLIT, OPACITY, UV_ANIM } }, // Distortion (Ocean) Unlit
{ 78, { F::FLAT_SURF, 0, OPACITY, UV_ANIM } }, // Flat Surf
// Drawn by other passes, not in the world: footprints, post-processing, drop shadows, Technique_Undefined
{ 21, { F::BASIC, 0, OPACITY, NOT_DRAWN } }, // Model Footprint
{ 71, { F::BASIC, 0, OPACITY, NOT_DRAWN } }, // PostProcess Gray Bubble
{ 74, { F::BASIC, 0, OPACITY, NOT_DRAWN } }, // Drop Shadow
{ 79, { F::BASIC, 0, OPACITY, NOT_DRAWN } }, // Post Process Gray Bubble Interior Ghost
{ 96, { F::BASIC, 0, OPACITY, NOT_DRAWN } }, // Undefined
};
}
const char* FamilyName(eShaderFamily family) {
switch (family) {
case eShaderFamily::FIXED_FUNCTION: return "fixed";
case eShaderFamily::LEGO: return "lego";
case eShaderFamily::BASIC: return "basic";
case eShaderFamily::METAL: return "metal";
case eShaderFamily::CLEAR_PLASTIC: return "clearPlastic";
case eShaderFamily::OCEAN: return "ocean";
case eShaderFamily::FLAT_SURF: return "flatSurf";
case eShaderFamily::BRICK_WATER: return "brickWater";
case eShaderFamily::DARKLING: return "darkling";
case eShaderFamily::TERRAIN: return "terrain";
}
return "lego";
}
ShaderTechnique TechniqueFor(int32_t shader) {
for (const auto& row : TECHNIQUES) {
if (row.shader == shader) return row.technique;
}
return ShaderTechnique{}; // the LEGO shader, as the client falls back to
}
std::string TechniquesJson(const std::vector<int32_t>& shaders) {
nlohmann::json out = nlohmann::json::object();
for (const auto shader : shaders) {
const auto technique = TechniqueFor(shader);
const char* alpha = technique.textureAlpha == eTextureAlpha::DECAL ? "decal" : technique.textureAlpha == eTextureAlpha::IGNORED ? "ignored" : "opacity";
out[std::to_string(shader)] = { {"family", FamilyName(technique.family)}, {"look", technique.look}, {"alpha", alpha}, {"flags", technique.flags} };
}
return out.dump();
}
eTextureAlpha TextureAlphaFor(int32_t shader) {
return TechniqueFor(shader).textureAlpha;
}
uint16_t ShaderLookFor(int32_t shader) {
return TechniqueFor(shader).look;
}
std::optional<Model> Parse(std::string_view data, uint32_t lod, std::string& error) {
return Parser(data, lod).Run(error);
}
std::optional<std::string> EmbeddedTexture(std::string_view data, int32_t block) {
std::string error;
return Parser(data, 0).Dds(block, error);
}
std::string Encode(const Model& model, const std::vector<std::string>& textures, const std::vector<std::string>& darkTextures, const std::vector<uint16_t>& looks) {
std::string body;
nlohmann::json meshes = nlohmann::json::array();
std::vector<std::string> names;
for (size_t m = 0; m < model.meshes.size(); m++) {
const auto& mesh = model.meshes[m];
const auto& material = mesh.material;
const auto vertices = mesh.positions.size() / 3;
const std::string texture = m < textures.size() ? textures[m] : std::string{};
const auto indexOf = [&names](const std::string& name) {
if (name.empty()) return -1;
const auto it = std::find(names.begin(), names.end(), name);
const auto index = static_cast<int32_t>(it - names.begin());
if (it == names.end()) names.push_back(name);
return index;
};
const int32_t textureIndex = indexOf(texture);
const int32_t darkIndex = indexOf(m < darkTextures.size() ? darkTextures[m] : std::string{});
const bool uv2 = darkIndex >= 0 && mesh.uvs2.size() == vertices * 2;
nlohmann::json entry{
{"offset", body.size()}, {"vertices", vertices}, {"indices", mesh.indices.size()},
{"normals", !mesh.normals.empty()}, {"uv", !mesh.uvs.empty() && textureIndex >= 0}, {"colors", !mesh.colors.empty()},
{"diffuse", Color(material.diffuse)}, {"emissive", Color(material.emissive)}, {"alpha", std::round(material.alpha * 1000.0f) / 1000.0f},
{"blend", material.alphaBlend}, {"test", material.alphaTest ? material.alphaThreshold : -1}, {"doubleSided", material.doubleSided},
{"vertexColors", material.vertexColorMode}, {"texture", textureIndex}, {"clampU", material.clampU}, {"clampV", material.clampV},
{"shaderTag", material.shaderTag}, {"darkTexture", uv2 ? darkIndex : -1}, {"uv2", uv2}
};
if (m < looks.size()) entry["look"] = looks[m];
if (material.uvScroll[0] != 0.0f || material.uvScroll[1] != 0.0f) entry["uvScroll"] = { material.uvScroll[0], material.uvScroll[1] };
Append(body, mesh.positions.data(), mesh.positions.size() * sizeof(float));
if (!mesh.normals.empty()) {
std::vector<int8_t> packed(mesh.normals.size());
for (size_t i = 0; i < packed.size(); i++) packed[i] = static_cast<int8_t>(std::lround(std::clamp(mesh.normals[i], -1.0f, 1.0f) * 127.0f));
Append(body, packed.data(), packed.size());
Pad(body);
}
if (entry["uv"].get<bool>()) Append(body, mesh.uvs.data(), mesh.uvs.size() * sizeof(float));
if (uv2) Append(body, mesh.uvs2.data(), mesh.uvs2.size() * sizeof(float));
if (!mesh.colors.empty()) Append(body, mesh.colors.data(), mesh.colors.size());
Append(body, mesh.indices.data(), mesh.indices.size() * sizeof(uint16_t));
Pad(body);
meshes.push_back(std::move(entry));
}
nlohmann::json header{
{"version", 1}, {"meshes", meshes}, {"textures", names},
{"min", { model.min[0], model.min[1], model.min[2] }}, {"max", { model.max[0], model.max[1], model.max[2] }}
};
auto text = header.dump();
while (text.size() % 4) text.push_back(' ');
std::string out;
const auto length = static_cast<uint32_t>(text.size());
Append(out, &length, sizeof(length));
out += text;
out += body;
return out;
}
std::optional<std::string> KfmModelPath(std::string_view data) {
const auto newline = data.substr(0, 128).find('\n');
if (newline == std::string_view::npos || data.substr(0, newline).find("KFM") == std::string_view::npos) return std::nullopt;
Reader reader(data.substr(newline + 1));
reader.U8(); // little endian
auto path = reader.SizedString();
if (!reader.Ok() || path.empty()) return std::nullopt;
return path;
}
}
Reference in New Issue View Git Blame Copy Permalink