use whisker_protocol::{
ApplyResult, FramePacket, RenderCapabilities, SceneProjection, SurfaceId, ValidationError,
};
pub trait FrameSink {
type Error;
fn capabilities(&self) -> RenderCapabilities;
fn present(&mut self, packet: &FramePacket) -> Result<ApplyResult, Self::Error>;
}
#[derive(Clone, Debug, PartialEq)]
pub struct RecordedFrame {
pub packet: FramePacket,
pub result: Result<ApplyResult, ValidationError>,
}
#[derive(Debug)]
pub struct RecordingRenderer {
projection: SceneProjection,
frames: Vec<RecordedFrame>,
}
impl RecordingRenderer {
pub fn new(surface: SurfaceId) -> Self {
Self {
projection: SceneProjection::new(surface),
frames: Vec::new(),
}
}
pub const fn projection(&self) -> &SceneProjection {
&self.projection
}
pub fn frames(&self) -> &[RecordedFrame] {
&self.frames
}
}
impl FrameSink for RecordingRenderer {
type Error = ValidationError;
fn capabilities(&self) -> RenderCapabilities {
RenderCapabilities::all_frame_native()
}
fn present(&mut self, packet: &FramePacket) -> Result<ApplyResult, Self::Error> {
let result = self.projection.apply(packet);
self.frames.push(RecordedFrame {
packet: packet.clone(),
result: result.clone(),
});
result
}
}
#[cfg(test)]
mod tests {
use super::*;
use whisker_protocol::{FrameHeader, FrameMode, ProtocolVersion, SurfaceId, ValidationError};
fn surface(value: u64) -> SurfaceId {
SurfaceId::new(value).expect("test surface")
}
#[test]
fn records_accepted_and_rejected_packets() {
let mut renderer = RecordingRenderer::new(surface(1));
assert_eq!(
renderer.capabilities(),
RenderCapabilities::all_frame_native()
);
let packet = FramePacket {
header: FrameHeader {
version: ProtocolVersion::CURRENT,
surface: surface(1),
scene_epoch: 1,
frame_id: 1,
base_revision: 0,
target_revision: 1,
viewport_epoch: 1,
mode: FrameMode::Snapshot,
},
operations: Vec::new(),
};
assert_eq!(
renderer.present(&packet),
Ok(ApplyResult::Accepted { revision: 1 })
);
let mut malformed = packet;
malformed.header.scene_epoch = 2;
malformed.header.surface = surface(2);
assert_eq!(
renderer.present(&malformed),
Err(ValidationError::SurfaceMismatch {
expected: surface(1),
received: surface(2),
})
);
assert_eq!(renderer.projection().revision(), 1);
assert_eq!(renderer.frames().len(), 2);
assert_eq!(
renderer.frames()[0].result,
Ok(ApplyResult::Accepted { revision: 1 })
);
assert!(renderer.frames()[1].result.is_err());
}
}