use std::collections::BTreeMap;
use crate::ebx::{Document, Object, Pointer, Value};
use crate::names::GuidNames;
use crate::{Rd, Result};
const W: &str = "shader parameter key";
pub const NAME_HASH_SEED: u32 = 0x6875_ca4d;
pub const LOW48: u64 = 0x0000_ffff_ffff_ffff;
pub fn name_hash(name: &[u8]) -> u32 {
name.iter().fold(NAME_HASH_SEED, |h, &c| {
h.wrapping_mul(33) ^ u32::from(c.to_ascii_lowercase())
})
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct ParamKey {
pub hash: u64,
pub type_key: u32,
pub count: u16,
pub identity: u16,
}
impl ParamKey {
pub fn from_bytes(b: &[u8; 16]) -> Result<ParamKey> {
let r = Rd::new(b, W);
Ok(ParamKey {
hash: r.u64le(0)?,
type_key: r.u32le(8)?,
count: r.u16le(12)?,
identity: r.u16le(14)?,
})
}
pub fn to_bytes(&self) -> [u8; 16] {
let mut out = [0u8; 16];
let (head, tail) = out.split_at_mut(8);
head.copy_from_slice(&self.hash.to_le_bytes());
let (ty, rest) = tail.split_at_mut(4);
ty.copy_from_slice(&self.type_key.to_le_bytes());
let (count, identity) = rest.split_at_mut(2);
count.copy_from_slice(&self.count.to_le_bytes());
identity.copy_from_slice(&self.identity.to_le_bytes());
out
}
pub fn from_parts(name_hash: u32, low48: u64, type_key: u32, count: u16) -> ParamKey {
let low = u64::from(name_hash & 0xffff);
ParamKey {
hash: (low << 48) | (low48 & LOW48),
type_key,
count,
identity: u16::try_from(name_hash >> 16).unwrap_or(u16::MAX),
}
}
pub fn name_hash(&self) -> u32 {
let low = u16::try_from(self.hash >> 48).unwrap_or(u16::MAX);
(u32::from(self.identity) << 16) | u32::from(low)
}
pub fn low48(&self) -> u64 {
self.hash & LOW48
}
pub fn is_named(&self, name: &[u8]) -> bool {
self.name_hash() == name_hash(name)
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct KeyUse {
pub key: ParamKey,
pub asset: Option<[u8; 16]>,
pub alias: Option<String>,
}
const KEY_TYPE: &str = "ParamDbKeySerialized";
const ALIAS_FIELDS: [&str; 3] = ["Name", "ParamName", "ParameterName"];
pub fn key_uses(doc: &Document) -> Vec<KeyUse> {
let mut out = Vec::new();
for o in doc.instances.iter().filter_map(|i| i.object.as_ref()) {
visit(doc, o, &mut out);
}
out
}
fn visit(doc: &Document, o: &Object, out: &mut Vec<KeyUse>) {
let keys: Vec<ParamKey> = o
.fields
.iter()
.filter_map(|f| key_of(doc, &f.value))
.filter(|k| *k != ParamKey::default())
.collect();
if !keys.is_empty() {
let asset = parameter_asset(doc, o);
let alias = ALIAS_FIELDS.iter().find_map(|name| match o.field(name) {
Some(Value::Str(b)) if !b.is_empty() => Some(String::from_utf8_lossy(b).into_owned()),
_ => None,
});
for key in keys {
out.push(KeyUse {
key,
asset,
alias: alias.clone(),
});
}
}
for f in &o.fields {
descend(doc, &f.value, out);
}
}
fn descend(doc: &Document, v: &Value, out: &mut Vec<KeyUse>) {
match v {
Value::Object(o) => visit(doc, o, out),
Value::Array(items, _) => {
for item in items {
descend(doc, item, out);
}
}
_ => {}
}
}
fn key_of(doc: &Document, v: &Value) -> Option<ParamKey> {
let Value::Object(o) = v else { return None };
if doc.types.get(o.descriptor)?.name != KEY_TYPE {
return None;
}
let Value::Guid(g) = o.field("Data")? else {
return None;
};
ParamKey::from_bytes(g).ok()
}
fn parameter_asset(doc: &Document, o: &Object) -> Option<[u8; 16]> {
let external = |v: Option<&Value>| match v {
Some(Value::Pointer(Pointer::External(i))) => doc.imports.get(*i).map(|imp| imp.file_guid),
_ => None,
};
external(o.field("Parameter")).or_else(|| {
o.fields.iter().find_map(|f| match &f.value {
Value::Object(inner) => external(inner.field("Parameter")),
_ => None,
})
})
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct Added {
pub added: usize,
pub repeated: usize,
pub unnamed: usize,
pub refused: usize,
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct ParamNames {
names: BTreeMap<ParamKey, String>,
}
impl ParamNames {
pub fn new() -> Self {
Self::default()
}
pub fn add(&mut self, uses: &[KeyUse], files: &GuidNames) -> Added {
let mut added = Added::default();
for u in uses {
let Some(guid) = u.asset else { continue };
let Some(name) = files.get(&guid) else {
added.unnamed = added.unnamed.saturating_add(1);
continue;
};
if !u.key.is_named(name.as_bytes()) {
added.refused = added.refused.saturating_add(1);
continue;
}
match self.names.get(&u.key) {
None => {
self.names.insert(u.key, name.to_string());
added.added = added.added.saturating_add(1);
}
Some(old) if old == name => added.repeated = added.repeated.saturating_add(1),
Some(_) => added.refused = added.refused.saturating_add(1),
}
}
added
}
pub fn get(&self, key: &ParamKey) -> Option<&str> {
self.names.get(key).map(String::as_str)
}
pub fn by_hash(&self, hash: u64) -> Option<&str> {
self.names
.iter()
.find(|(k, _)| k.hash == hash)
.map(|(_, n)| n.as_str())
}
pub fn len(&self) -> usize {
self.names.len()
}
pub fn is_empty(&self) -> bool {
self.names.is_empty()
}
pub fn iter(&self) -> impl Iterator<Item = (&ParamKey, &str)> + '_ {
self.names.iter().map(|(k, n)| (k, n.as_str()))
}
}