// Ported from Draco 1.5.7 (compression/attributes/prediction_schemes/: the tex coords decoders,
// portable and deprecated): Apache License 2.0, Copyright 2016 The Draco Authors. See NOTICE.
///|
fn abs64(x : Int64) -> Int64 {
if x < 0L {
-x
} else {
x
}
}
///|
fn max64(a : Int64, b : Int64) -> Int64 {
if a > b {
a
} else {
b
}
}
///|
/// `MeshPredictionSchemeTexCoordsPortablePredictor::ComputePredictedValue` into `pred`.
fn Scheme::tex_portable_prediction(
self : Scheme,
t : Table,
corner : Int32,
data : FixedArray[Int32],
id : Int32,
points : Array[Int32],
pred : FixedArray[Int32],
) -> Bool {
let next_id = vmap_at(self.enc, t.vertex(next(corner)))
let prev_id = vmap_at(self.enc, t.vertex(previous(corner)))
if prev_id < id && next_id < id {
let nu = data[next_id * 2].to_int64()
let nv = data[next_id * 2 + 1].to_int64()
let pu = data[prev_id * 2].to_int64()
let pv = data[prev_id * 2 + 1].to_int64()
if pu == nu && pv == nv {
pred[0] = pu.to_int()
pred[1] = pv.to_int()
return true
}
guard self.parent is Some(parent) else { return false }
let tip = FixedArray::make(3, 0L)
let np = FixedArray::make(3, 0L)
let pp = FixedArray::make(3, 0L)
guard id < points.length() &&
parent.position(points[id], tip) &&
parent.position(points[next_id], np) &&
parent.position(points[prev_id], pp) else {
return false
}
let pn0 = pp[0] - np[0]
let pn1 = pp[1] - np[1]
let pn2 = pp[2] - np[2]
let pn_norm2 = (pn0 * pn0 + pn1 * pn1 + pn2 * pn2).reinterpret_as_uint64()
if pn_norm2 != 0UL {
let cn0 = tip[0] - np[0]
let cn1 = tip[1] - np[1]
let cn2 = tip[2] - np[2]
let cn_dot_pn = pn0 * cn0 + pn1 * cn1 + pn2 * cn2
let pnu = pu - nu
let pnv = pv - nv
let n_absmax = max64(abs64(nu), abs64(nv))
if n_absmax.reinterpret_as_uint64() > 0x7fffffffffffffffUL / pn_norm2 {
return false
}
let pn_uv_absmax = max64(abs64(pnu), abs64(pnv))
if abs64(cn_dot_pn) > 0x7fffffffffffffffL / pn_uv_absmax {
return false
}
let norm = pn_norm2.reinterpret_as_int64()
let xu = nu * norm + cn_dot_pn * pnu
let xv = nv * norm + cn_dot_pn * pnv
let pn_absmax = max64(max64(abs64(pn0), abs64(pn1)), abs64(pn2))
if abs64(cn_dot_pn) > 0x7fffffffffffffffL / pn_absmax {
return false
}
let xp0 = np[0] + cn_dot_pn * pn0 / norm
let xp1 = np[1] + cn_dot_pn * pn1 / norm
let xp2 = np[2] + cn_dot_pn * pn2 / norm
let d0 = tip[0] - xp0
let d1 = tip[1] - xp1
let d2 = tip[2] - xp2
let cx_norm2 = (d0 * d0 + d1 * d1 + d2 * d2).reinterpret_as_uint64()
let s = int_sqrt(cx_norm2 * pn_norm2).reinterpret_as_int64()
let cxu = pnv * s
let cxv = -pnu * s
guard self.pop_orientation() is Some(orientation) else { return false }
let (u, v) = if orientation {
(xu + cxu, xv + cxv)
} else {
(xu - cxu, xv - cxv)
}
pred[0] = (u / norm).to_int()
pred[1] = (v / norm).to_int()
return true
}
}
fallback(data, id, prev_id, next_id, 2, pred)
}
///|
/// The predictions' fallback when not every neighbour is decoded: the last of them that is, or
/// the previous entry.
fn fallback(
data : FixedArray[Int32],
id : Int32,
prev_id : Int32,
next_id : Int32,
nc : Int32,
pred : FixedArray[Int32],
) -> Bool {
let mut offset = 0
if prev_id < id {
offset = prev_id * nc
}
if next_id < id {
offset = next_id * nc
} else if id > 0 {
offset = (id - 1) * nc
} else {
for i in 0.. UInt64 {
if number == 0UL {
return 0
}
let mut act = number
let mut root = 1UL
while act >= 2UL {
root = root * 2
act = act / 4
}
while true {
root = (root + number / root) / 2
if root * root <= number {
break
}
}
root
}
///|
/// The deprecated tex coords scheme's prediction (`MeshPredictionSchemeTexCoordsDecoder`).
fn Scheme::tex_deprecated_prediction(
self : Scheme,
t : Table,
corner : Int32,
data : FixedArray[Int32],
id : Int32,
points : Array[Int32],
pred : FixedArray[Int32],
) -> Bool {
let next_id = vmap_at(self.enc, t.vertex(next(corner)))
let prev_id = vmap_at(self.enc, t.vertex(previous(corner)))
if prev_id < id && next_id < id {
let nu = Float::from_int(data[next_id * 2])
let nv = Float::from_int(data[next_id * 2 + 1])
let pu = Float::from_int(data[prev_id * 2])
let pv = Float::from_int(data[prev_id * 2 + 1])
if pu == nu && pv == nv {
pred[0] = to_int_or_min(pu.to_double())
pred[1] = to_int_or_min(pv.to_double())
return true
}
guard self.parent is Some(parent) else { return false }
let tip = FixedArray::make(3, 0L)
let np = FixedArray::make(3, 0L)
let pp = FixedArray::make(3, 0L)
guard id < points.length() &&
parent.position(points[id], tip) &&
parent.position(points[next_id], np) &&
parent.position(points[prev_id], pp) else {
return false
}
let f = fn(x : Int64) { Float::from_int(x.to_int()) }
let pn0 = f(pp[0]) - f(np[0])
let pn1 = f(pp[1]) - f(np[1])
let pn2 = f(pp[2]) - f(np[2])
let cn0 = f(tip[0]) - f(np[0])
let cn1 = f(tip[1]) - f(np[1])
let cn2 = f(tip[2]) - f(np[2])
let pn_norm2 = pn0 * pn0 + pn1 * pn1 + pn2 * pn2
let mut s : Float = 0.0
let mut tt : Float = 0.0
if pn_norm2 > 0.0 {
s = ((0.0 : Float) + pn0 * cn0 + pn1 * cn1 + pn2 * cn2) / pn_norm2
let r0 = cn0 - pn0 * s
let r1 = cn1 - pn1 * s
let r2 = cn2 - pn2 * s
tt = ((r0 * r0 + r1 * r1 + r2 * r2) / pn_norm2).sqrt()
}
let pnu = pu - nu
let pnv = pv - nv
let pnus = pnu * s + nu
let pnut = pnu * tt
let pnvs = pnv * s + nv
let pnvt = pnv * tt
guard self.pop_orientation() is Some(orientation) else { return false }
let (u, v) = if orientation {
(pnus - pnvt, pnvs + pnut)
} else {
(pnus + pnvt, pnvs - pnut)
}
pred[0] = to_int_or_min((u.to_double() + 0.5).floor())
pred[1] = to_int_or_min((v.to_double() + 0.5).floor())
return true
}
fallback(data, id, prev_id, next_id, 2, pred)
}
///|
/// `static_cast` of a double, or `INT_MIN` for NaN and values out of range (as the
/// deprecated tex coords scheme guards it).
fn to_int_or_min(x : Double) -> Int32 {
if x.is_nan() || x > 2147483647.0 || x < -2147483648.0 {
-2147483648
} else {
x.to_int()
}
}
///|
fn Scheme::tex_coords(
self : Scheme,
t : Table,
data : FixedArray[Int32],
nc : Int32,
points : Array[Int32],
) -> Bool {
guard nc == 2 else { return false }
self.transform.init(nc)
let pred = FixedArray::make(2, 0)
let corners = self.enc.corners
for p in 0..