use super::ServerCompositionVisual;
use crate::platform::LtrbRect;
use crate::rendering::composition::server::ReadbackQueueEntry;
use crate::Matrix;
use std::sync::atomic::{AtomicI64, AtomicU64, Ordering};
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct ReadbackData {
pub matrix: Matrix,
pub revision: u64,
pub target_id: i64,
pub visible: bool,
pub transformed_subtree_bounds: Option<LtrbRect>,
pub subtree_bounds: Option<LtrbRect>,
}
const FLAG_VISIBLE: u64 = 1;
const FLAG_TRANSFORMED_SUBTREE_BOUNDS: u64 = 1 << 1;
const FLAG_SUBTREE_BOUNDS: u64 = 1 << 2;
struct Slot {
matrix: [AtomicU64; 9],
target_id: AtomicI64,
flags: AtomicU64,
transformed_subtree_bounds: [AtomicU64; 4],
subtree_bounds: [AtomicU64; 4],
}
fn store_rect(slot: &[AtomicU64; 4], rect: Option<LtrbRect>) {
if let Some(rect) = rect {
for (value, part) in slot.iter().zip([rect.left, rect.top, rect.right, rect.bottom]) {
value.store(part.to_bits(), Ordering::Relaxed);
}
}
}
fn load_rect(slot: &[AtomicU64; 4], present: bool) -> Option<LtrbRect> {
present.then(|| {
let [left, top, right, bottom] = slot.each_ref().map(|value| f64::from_bits(value.load(Ordering::Relaxed)));
LtrbRect { left, top, right, bottom }
})
}
impl Slot {
fn new() -> Self {
Self {
matrix: Default::default(),
target_id: AtomicI64::new(0),
flags: AtomicU64::new(0),
transformed_subtree_bounds: Default::default(),
subtree_bounds: Default::default(),
}
}
fn read(&self, revision: u64) -> ReadbackData {
let [m11, m12, m13, m21, m22, m23, m31, m32, m33] =
self.matrix.each_ref().map(|value| f64::from_bits(value.load(Ordering::Relaxed)));
let flags = self.flags.load(Ordering::Relaxed);
ReadbackData {
matrix: Matrix::new_3x3(m11, m12, m13, m21, m22, m23, m31, m32, m33),
revision,
target_id: self.target_id.load(Ordering::Relaxed),
visible: flags & FLAG_VISIBLE != 0,
transformed_subtree_bounds: load_rect(
&self.transformed_subtree_bounds,
flags & FLAG_TRANSFORMED_SUBTREE_BOUNDS != 0,
),
subtree_bounds: load_rect(&self.subtree_bounds, flags & FLAG_SUBTREE_BOUNDS != 0),
}
}
fn write(&self, data: &ReadbackData) {
let m = &data.matrix;
for (value, part) in self.matrix.iter().zip([m.m11, m.m12, m.m13, m.m21, m.m22, m.m23, m.m31, m.m32, m.m33]) {
value.store(part.to_bits(), Ordering::Relaxed);
}
self.target_id.store(data.target_id, Ordering::Relaxed);
let mut flags = 0;
if data.visible {
flags |= FLAG_VISIBLE;
}
if data.transformed_subtree_bounds.is_some() {
flags |= FLAG_TRANSFORMED_SUBTREE_BOUNDS;
}
if data.subtree_bounds.is_some() {
flags |= FLAG_SUBTREE_BOUNDS;
}
self.flags.store(flags, Ordering::Relaxed);
store_rect(&self.transformed_subtree_bounds, data.transformed_subtree_bounds);
store_rect(&self.subtree_bounds, data.subtree_bounds);
}
}
pub struct VisualReadback {
revisions: [AtomicU64; 2],
slots: [Slot; 2],
}
impl Default for VisualReadback {
fn default() -> Self {
Self::new()
}
}
impl VisualReadback {
pub fn new() -> Self {
Self { revisions: [AtomicU64::new(u64::MAX), AtomicU64::new(u64::MAX)], slots: [Slot::new(), Slot::new()] }
}
pub fn key(&self) -> usize {
self as *const Self as usize
}
fn slot_for_read(&self, reader_revision: u64) -> Option<(usize, u64)> {
let slot0_revision = self.revisions[0].load(Ordering::SeqCst);
let slot1_revision = self.revisions[1].load(Ordering::SeqCst);
match (slot0_revision <= reader_revision, slot1_revision <= reader_revision) {
(true, true) if slot1_revision > slot0_revision => Some((1, slot1_revision)),
(true, _) => Some((0, slot0_revision)),
(false, true) => Some((1, slot1_revision)),
(false, false) => None,
}
}
pub fn get_readback(&self, reader_revision: u64) -> Option<ReadbackData> {
let (slot, revision) = self.slot_for_read(reader_revision)?;
Some(self.slots[slot].read(revision))
}
pub fn readback_revision(&self, reader_revision: u64) -> Option<u64> {
self.slot_for_read(reader_revision).map(|(_, revision)| revision)
}
pub fn update_readback(&self, writer_revision: u64, reader_revision: u64, data: ReadbackData) {
let revision0 = self.revisions[0].load(Ordering::SeqCst);
let revision1 = self.revisions[1].load(Ordering::SeqCst);
let slot = if revision0 > reader_revision {
0
} else if revision1 > reader_revision {
1
} else if revision0 < revision1 {
0
} else {
1
};
self.revisions[slot].store(writer_revision, Ordering::SeqCst);
self.slots[slot].write(&data);
}
}
impl ServerCompositionVisual {
pub(super) fn enqueue_for_readback_update(&self) {
let Some(compositor) = self.compositor() else { return };
let pass = compositor.readback_pass();
if self.readback_enqueued_pass.get() == pass {
if self.readback_snapshot.get() {
let Some(this) = self.rc() else { return };
let index = self.readback_queue_index.get() as usize;
compositor.set_readback_entry(index, ReadbackQueueEntry::Visual(this));
self.readback_snapshot.set(false);
}
return;
}
let Some(this) = self.rc() else { return };
self.readback_queue_index.set(compositor.push_readback_entry(ReadbackQueueEntry::Visual(this)) as u32);
self.readback_enqueued_pass.set(pass);
self.readback_snapshot.set(false);
}
pub(super) fn snapshot_for_readback_update(&self) {
let Some(compositor) = self.compositor() else { return };
let pass = compositor.readback_pass();
let data = self.readback_data(0);
if self.readback_enqueued_pass.get() == pass {
compositor.set_readback_snapshot(self.readback_queue_index.get() as usize, &self.readback, data);
} else {
let entry = ReadbackQueueEntry::Snapshot(self.readback.clone(), data);
self.readback_queue_index.set(compositor.push_readback_entry(entry) as u32);
self.readback_enqueued_pass.set(pass);
}
self.readback_snapshot.set(true);
}
pub(super) fn set_own_transform(&self, transform: Option<Matrix>) {
self.own_transform.set(transform);
if self.readback_snapshot.get() {
self.enqueue_for_readback_update();
}
}
pub fn get_readback(&self, reader_revision: u64) -> Option<ReadbackData> {
self.readback.get_readback(reader_revision)
}
pub(crate) fn readback_key(&self) -> usize {
self.readback.key()
}
fn readback_data(&self, revision: u64) -> ReadbackData {
ReadbackData {
matrix: self.own_transform.get().unwrap_or(Matrix::IDENTITY),
revision,
target_id: self.root().map_or(-1, |root| root.id()),
transformed_subtree_bounds: self.transformed_sub_tree_bounds.get(),
subtree_bounds: self.sub_tree_bounds.get(),
visible: self.visible(),
}
}
pub fn update_readback(&self, writer_revision: u64, reader_revision: u64) {
self.readback.update_readback(writer_revision, reader_revision, self.readback_data(writer_revision));
}
}