use super::render_data_drawing_context::RecordedResource;
use super::{RenderDataStream, ServerCompositionRenderData};
use crate::media::{Geometry, IntersectionResult};
use crate::platform::LtrbRect;
use crate::rendering::composition::server::ServerObjectId;
use crate::rendering::composition::transport::BatchStreamWriter;
use crate::rendering::composition::{Compositor, ICompositorSerializable};
use crate::{Point, Ref};
use std::cell::{Cell, RefCell};
use std::rc::{Rc, Weak};
pub struct CompositionRenderData {
compositor: Weak<Compositor>,
stream: RefCell<RenderDataStream>,
resources: RefCell<Vec<RecordedResource>>,
items_sent: Cell<bool>,
server: ServerObjectId,
}
impl CompositionRenderData {
pub(crate) fn new(
compositor: &Rc<Compositor>,
stream: RenderDataStream,
resources: Vec<RecordedResource>,
) -> Rc<CompositionRenderData> {
let server = compositor.create_server_object(|server_compositor, _| ServerCompositionRenderData::new(server_compositor));
Rc::new(CompositionRenderData {
compositor: Rc::downgrade(compositor),
stream: RefCell::new(stream),
resources: RefCell::new(resources),
items_sent: Cell::new(false),
server,
})
}
pub(crate) fn has_recording(&self, stream: &RenderDataStream, resources: &[RecordedResource]) -> bool {
let mine = self.resources.borrow();
mine.len() == resources.len()
&& mine.iter().zip(resources).all(|(a, b)| a.identity() == b.identity())
&& self.stream.borrow().same_recording(stream)
}
pub(crate) fn replace_recording(
&self,
stream: RenderDataStream,
resources: Vec<RecordedResource>,
) -> RenderDataStream {
let mut old_stream = self.stream.replace(stream);
if !self.items_sent.get() {
old_stream.dispose_resources();
}
self.items_sent.set(false);
let old_resources = self.resources.replace(resources);
if let Some(compositor) = self.compositor.upgrade() {
for resource in old_resources {
resource.with_resource(|r| r.release_on_compositor(&compositor));
}
}
old_stream.recycle();
old_stream
}
pub(crate) fn is_of(&self, compositor: &Rc<Compositor>) -> bool {
std::ptr::eq(self.compositor.as_ptr(), Rc::as_ptr(compositor))
}
pub fn server(&self) -> ServerObjectId {
self.server
}
pub fn dispose(&self) {
let mut stream = self.stream.borrow_mut();
if !self.items_sent.get() {
stream.dispose_resources();
}
let compositor = self.compositor.upgrade();
for resource in self.resources.borrow_mut().drain(..) {
if let Some(compositor) = &compositor {
resource.with_resource(|r| r.release_on_compositor(compositor));
}
}
stream.dispose();
self.items_sent.set(false);
if let Some(compositor) = compositor {
compositor.dispose_on_next_batch(self.server);
}
}
pub(crate) fn bounds(&self) -> Option<LtrbRect> {
let bounds = self.stream.borrow().calculate_bounds();
ServerCompositionRenderData::apply_render_bounds_rounding(bounds.map(LtrbRect::from_rect))
}
pub fn hit_test(&self, pt: Point) -> bool {
self.stream.borrow().hit_test(pt)
}
pub fn hit_test_geometry(&self, geometry: &Ref<Geometry>) -> IntersectionResult {
self.stream.borrow().hit_test_geometry(geometry)
}
}
impl ICompositorSerializable for CompositionRenderData {
fn try_get_server(&self, _c: &Compositor) -> Option<ServerObjectId> {
Some(self.server)
}
fn serialize_changes(&self, _c: &Compositor, writer: &mut BatchStreamWriter<'_>) {
self.stream.borrow().serialize_to(writer);
self.items_sent.set(true);
}
}