fn is_reserved(c: char) -> bool {
matches!(c, '[' | ']' | '.' | ':' | '/')
}
fn is_word_char(c: char) -> bool {
!is_reserved(c)
}
fn is_word_char_or_dot(c: char) -> bool {
!matches!(c, '[' | ']' | ':' | '/')
}
fn is_dot_any(c: char) -> bool {
!matches!(c, '\n' | '\r' | '\u{2028}' | '\u{2029}')
}
fn is_js_space(c: char) -> bool {
matches!(
c,
'\u{0009}' | '\u{000A}' | '\u{000B}' | '\u{000C}' | '\u{000D}' | '\u{0020}'
| '\u{00A0}'
| '\u{1680}'
| '\u{2000}'
..='\u{200A}'
| '\u{2028}'
| '\u{2029}'
| '\u{202F}'
| '\u{205F}'
| '\u{3000}'
| '\u{FEFF}'
)
}
const SUPPORTED_OBJECT_NAMES: [&str; 4] = ["material", "materials", "bones", "map"];
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct ParsedTrackName {
pub node_name: Option<String>,
pub object_name: Option<String>,
pub object_index: Option<String>,
pub property_name: String,
pub property_index: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum ParseTrackNameError {
CannotParse(String),
NoPropertyName(String),
}
impl std::fmt::Display for ParseTrackNameError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::CannotParse(track_name) => write!(
f,
"THREE.PropertyBinding: Cannot parse trackName: {track_name}"
),
Self::NoPropertyName(track_name) => write!(
f,
"THREE.PropertyBinding: can not parse propertyName from trackName: {track_name}"
),
}
}
}
impl std::error::Error for ParseTrackNameError {}
pub fn sanitize_node_name(name: &str) -> String {
name.chars()
.map(|c| if is_js_space(c) { '_' } else { c })
.filter(|&c| !is_reserved(c))
.collect()
}
struct Segment {
end: usize,
name: (usize, usize),
index: Option<(usize, usize)>,
}
fn segment_candidates(s: &[char], pos: usize) -> Vec<Segment> {
let mut out = Vec::new();
if pos >= s.len() || s[pos] != '.' {
return out;
}
let begin = pos + 1;
let mut max_len = 0;
while begin + max_len < s.len() && is_word_char(s[begin + max_len]) {
max_len += 1;
}
for len in (1..=max_len).rev() {
let after_name = begin + len;
if after_name < s.len() && s[after_name] == '[' {
let index_begin = after_name + 1;
let mut max_index_len = 0;
while index_begin + max_index_len < s.len()
&& is_dot_any(s[index_begin + max_index_len])
{
max_index_len += 1;
}
for index_len in (1..=max_index_len).rev() {
let index_end = index_begin + index_len;
if index_end < s.len() && s[index_end] == ']' {
out.push(Segment {
end: index_end + 1,
name: (begin, after_name),
index: Some((index_begin, index_end)),
});
}
}
}
out.push(Segment {
end: after_name,
name: (begin, after_name),
index: None,
});
}
out
}
struct TrackCaptures {
node_name: Option<(usize, usize)>,
object_name: Option<(usize, usize)>,
object_index: Option<(usize, usize)>,
property_name: (usize, usize),
property_index: Option<(usize, usize)>,
}
fn exec_track_re(s: &[char]) -> Option<TrackCaptures> {
let mut directory_ends = vec![0usize];
let mut p = 0;
loop {
let mut q = p;
while q < s.len() && is_word_char(s[q]) {
q += 1;
}
if q > p && q < s.len() && (s[q] == '/' || s[q] == ':') {
p = q + 1;
directory_ends.push(p);
} else {
break;
}
}
for &start in directory_ends.iter().rev() {
let mut max_len = 0;
while start + max_len < s.len() && is_word_char_or_dot(s[start + max_len]) {
max_len += 1;
}
let node_candidates = (1..=max_len)
.rev()
.map(|len| Some((start, start + len)))
.chain(std::iter::once(None));
for node_name in node_candidates {
let after_node = node_name.map_or(start, |(_, end)| end);
for object in segment_candidates(s, after_node) {
for property in segment_candidates(s, object.end) {
if property.end == s.len() {
return Some(TrackCaptures {
node_name,
object_name: Some(object.name),
object_index: object.index,
property_name: property.name,
property_index: property.index,
});
}
}
}
for property in segment_candidates(s, after_node) {
if property.end == s.len() {
return Some(TrackCaptures {
node_name,
object_name: None,
object_index: None,
property_name: property.name,
property_index: property.index,
});
}
}
}
}
None
}
pub fn parse_track_name(track_name: &str) -> Result<ParsedTrackName, ParseTrackNameError> {
let chars: Vec<char> = track_name.chars().collect();
let matches = exec_track_re(&chars)
.ok_or_else(|| ParseTrackNameError::CannotParse(track_name.to_string()))?;
let slice = |(begin, end): (usize, usize)| chars[begin..end].iter().collect::<String>();
let mut results = ParsedTrackName {
node_name: matches.node_name.map(slice),
object_name: matches.object_name.map(slice),
object_index: matches.object_index.map(slice),
property_name: slice(matches.property_name),
property_index: matches.property_index.map(slice),
};
if let Some(node_name) = results.node_name.clone() {
if let Some(last_dot) = node_name.rfind('.') {
let object_name = &node_name[last_dot + 1..];
if SUPPORTED_OBJECT_NAMES.contains(&object_name) {
results.object_name = Some(object_name.to_string());
results.node_name = Some(node_name[..last_dot].to_string());
}
}
}
if results.property_name.is_empty() {
return Err(ParseTrackNameError::NoPropertyName(track_name.to_string()));
}
Ok(results)
}