tsuki/radar-g
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

sync

Browse Source
This commit is contained in:
Tsuki 2024-04-30 14:34:06 +08:00
parent cf3b1fabfc
commit e4445a4f47
6 changed files with 180 additions and 129 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/components/app.rs
View File

@ -83,7 +83,7 @@ pub enum AppMsg {
OpenDialog, OpenDialog,
LayerManager(LayerMsg), LayerManager(LayerMsg),
Layer, Layer,
NewElement(Rc<Element>), NewElement(Rc<RefCell<Element>>),
DeleteElement(ElementKey), DeleteElement(ElementKey),
} }
type RcDispatcher = Rc<Dispatcher>; type RcDispatcher = Rc<Dispatcher>;
@ -110,7 +110,7 @@ pub struct AppModel {
#[do_not_track] #[do_not_track]
file_pool: Arc<KVBuffer<PathBuf, Arc<PluginResult>>>, file_pool: Arc<KVBuffer<PathBuf, Arc<PluginResult>>>,
#[do_not_track] #[do_not_track]
elements: Vec<Rc<Element>>, elements: Vec<Rc<RefCell<Element>>>,
#[do_not_track] #[do_not_track]
setting: Controller<SettingModel>, setting: Controller<SettingModel>,
} }
@ -283,6 +283,8 @@ impl Component for AppModel {
let (lat_start, lat_end) = meta.lat_range.unwrap(); let (lat_start, lat_end) = meta.lat_range.unwrap();
let (lon_start, lon_end) = meta.lon_range.unwrap(); let (lon_start, lon_end) = meta.lon_range.unwrap();
let imp = tools(&data); let imp = tools(&data);
dialog_file_pool.insert(path.clone(), Arc::new(data));
use femtovg::Color; use femtovg::Color;
let config = GridImpConfig { let config = GridImpConfig {
color_map: ColorMapperComb::BoundaryNormDiscrete(ColorMapper::new( color_map: ColorMapperComb::BoundaryNormDiscrete(ColorMapper::new(
@ -313,7 +315,7 @@ impl Component for AppModel {
), ),
)), )),
}; };
let element = Rc::new(Element::new( let element = Rc::new(RefCell::new(Element::new(
"CR", "CR",
dialog_cms.clone(), dialog_cms.clone(),
dialog_dispatcher.clone(), dialog_dispatcher.clone(),
@ -323,7 +325,7 @@ impl Component for AppModel {
dialog_buffer.clone(), dialog_buffer.clone(),
dialog_file_pool.clone(), dialog_file_pool.clone(),
imp, imp,
)); )));
dialog_sidebar_sender.emit(SideBarInputMsg::AddMetaItems(meta.to_map())); dialog_sidebar_sender.emit(SideBarInputMsg::AddMetaItems(meta.to_map()));
dialog_render_sender.emit(MonitorInputMsg::SetRenderRange( dialog_render_sender.emit(MonitorInputMsg::SetRenderRange(

1
src/main.rs
View File

@ -36,7 +36,6 @@ mod predefined;
mod widgets; mod widgets;
// mod element_imp; // mod element_imp;
#[cfg(target_env = "msvc")]
declare_surfman!(); declare_surfman!();
const APP_ID: &str = "org.tsuki.radar_g"; const APP_ID: &str = "org.tsuki.radar_g";

287
src/pipeline/new_element.rs
View File

@ -4,6 +4,7 @@ use super::element_imp::ElementImpl;
use super::element_imp::ElementOutput; use super::element_imp::ElementOutput;
use super::offscreen_renderer; use super::offscreen_renderer;
use super::offscreen_renderer::CanvasWrapper; use super::offscreen_renderer::CanvasWrapper;
use super::runner;
use super::runner::Runner; use super::runner::Runner;
use super::Dispatcher; use super::Dispatcher;
use crate::coords::cms::CMS; use crate::coords::cms::CMS;
@ -42,7 +43,9 @@ use tracing::subscriber;
static ELEMENT_ID: AtomicI32 = AtomicI32::new(0); static ELEMENT_ID: AtomicI32 = AtomicI32::new(0);
pub type ElementID = i32; pub type ElementID = i32;
pub type KVBuffer<T, V> = Cache<T, V>; pub type KVBuffer<T, V> = Cache<T, V>;
pub type Buffer<T> = KVBuffer<T, Arc<Mutex<RenderResult>>>; pub type Buffer<T> = KVBuffer<T, Arc<RwLock<RenderResult>>>;
pub type Data = Arc<PluginResult>;
#[derive(Debug, Hash, Eq, PartialEq, Clone)] #[derive(Debug, Hash, Eq, PartialEq, Clone)]
pub struct Key { pub struct Key {
@ -75,7 +78,6 @@ impl Target {
height: f32, height: f32,
bounds: (Range, Range), bounds: (Range, Range),
thumbnail: Option<gtk::gdk::Texture>, thumbnail: Option<gtk::gdk::Texture>,
// data: Option<Arc<dyn Any + Send + Sync + 'static>>,
) -> Self { ) -> Self {
Self { Self {
target, target,
@ -83,7 +85,6 @@ impl Target {
height, height,
bounds, bounds,
thumbnail, thumbnail,
// data,
} }
} }
@ -107,7 +108,8 @@ impl Target {
if let TargetType::NativeBuffer(ref mem) = self.target { if let TargetType::NativeBuffer(ref mem) = self.target {
use glow::*; use glow::*;
let texture = unsafe { let texture = unsafe {
let id = gl.create_texture().unwrap(); // let id = gl.create_texture().unwrap();
let id = gl.create_named_texture(1).unwrap();
gl.bind_texture(glow::TEXTURE_2D, Some(id)); gl.bind_texture(glow::TEXTURE_2D, Some(id));
gl.pixel_store_i32(glow::UNPACK_ALIGNMENT, 1); gl.pixel_store_i32(glow::UNPACK_ALIGNMENT, 1);
gl.pixel_store_i32(glow::UNPACK_ROW_LENGTH, 3000 as i32); gl.pixel_store_i32(glow::UNPACK_ROW_LENGTH, 3000 as i32);
@ -257,26 +259,14 @@ impl Target {
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
pub struct DataTarget { pub struct DataTarget {
data: Option<PluginResult>, pub data: Option<Data>,
target: Target, target: Target,
} }
impl DataTarget { impl DataTarget {
pub fn new(data: Option<PluginResult>, target: Target) -> Self { pub fn new(data: Option<Data>, target: Target) -> Self {
Self { data, target } Self { data, target }
} }
pub fn take_data(&mut self) -> Option<PluginResult> {
self.data.take()
}
pub fn data(&self) -> Option<&PluginResult> {
self.data.as_ref()
}
pub fn mut_data(&mut self) -> Option<&mut PluginResult> {
self.data.as_mut()
}
} }
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
@ -307,17 +297,19 @@ pub struct Element {
root: std::path::PathBuf, root: std::path::PathBuf,
config: Arc<dyn Any + Send + Sync>, config: Arc<dyn Any + Send + Sync>,
imp: ElementImpl, imp: ElementImpl,
subscribers: Arc<Mutex<HashMap<Key, Vec<oneshot::Sender<Arc<Mutex<RenderResult>>>>>>>, subscribers: Arc<Mutex<HashMap<Key, Vec<oneshot::Sender<Arc<Mutex<PluginResult>>>>>>>,
cancellers: Arc<Mutex<HashMap<Key, oneshot::Sender<()>>>>, cancellers: Arc<Mutex<HashMap<Key, oneshot::Sender<()>>>>,
current_key: Option<Key>, current_key: Option<Key>,
dispatcher: Rc<Dispatcher>, dispatcher: Rc<Dispatcher>,
buffer: Arc<Buffer<Key>>, buffer: Arc<Buffer<Key>>,
file_pool: Arc<KVBuffer<PathBuf, Arc<PluginResult>>>, file_pool: Arc<KVBuffer<PathBuf, Arc<PluginResult>>>,
current_target: Option<Arc<RwLock<RenderResult>>>,
cms: CMS, cms: CMS,
} }
pub enum ElementEvent<'a> { pub enum ElementEvent<'a> {
Init, Init,
Draw,
DateTime(DateTime<Utc>), DateTime(DateTime<Utc>),
Key(&'a Key), Key(&'a Key),
} }
@ -349,24 +341,53 @@ impl Element {
current_key: None, current_key: None,
buffer, buffer,
file_pool, file_pool,
current_target: None,
dispatcher, dispatcher,
} }
} }
pub fn r<'a>(&self, event: ElementEvent<'a>, render: &Render) { pub fn r<'b>(&mut self, event: ElementEvent<'b>, render: &Render) {
let need_cache = self.cache; let need_cache = self.cache;
let format = self.imp.output_type(); let output_type = self.imp.output_type();
fn _init(this: &mut Element, need_cache: bool, output_type: ElementOutput, render: &Render) {
let data = this.file_pool.get(&this.root);
if let Some(data) = data {
let target = this._rrrr(data, need_cache, output_type, render);
if let Some(target) = target {
let time = target.meta_info.datetime.unwrap();
let key = this.generate_key(time);
let target = Arc::new(RwLock::new(target));
this.buffer.insert(key, target.clone());
this.current_target = Some(target);
}
}
}
match event { match event {
ElementEvent::Init => { ElementEvent::Init => {
let data = self.file_pool.get(&self.root); _init(self, need_cache, output_type, render);
if let Some(data) = data {}
} }
ElementEvent::Draw => {
if let Some(current) = self.current_target.as_ref(){
let mut img = current.write().unwrap();
let mut img = img.get_mut_target();
render.draw_img(img);
} else {
_init(self, need_cache, output_type, render);
if let ElementOutput::Target = output_type {
let mut _img = self.current_target.as_ref().unwrap();
let mut img = _img.write().unwrap();
let mut img = img.get_mut_target();
render.draw_img(img);
}
}
}
ElementEvent::DateTime(time) => { ElementEvent::DateTime(time) => {
let path = self.dispatcher.get_single_path(&self.name, time, true); let path = self.dispatcher.get_single_path(&self.name, time, true);
path.map(|path| { path.map(|path| {
let data = self.file_pool.get(&path); // let data = self.file_pool.get(&path);
}); });
} }
@ -441,11 +462,37 @@ impl Element {
// } // }
} }
fn _rrrr(&self, data: &PluginResult, need_cache: bool, output_type: ElementOutput) { fn insert_target_to_buffer(&self, key: Key, render_result: RenderResult) {
match output_type { let result = Arc::new(RwLock::new(render_result));
ElementOutput::Target => {} self.buffer.insert(key, result);
}
_ => {} fn _rrrr(
&self,
data: Data,
need_cache: bool,
output_type: ElementOutput,
render: &Render,
) -> Option<RenderResult> {
match output_type {
ElementOutput::Target => {
let mut offscreen_renderer = OffscreenRenderer::new(3000, 3000).unwrap();
let mut canvas = offscreen_renderer.create_canvas();
let mut context = Context::new(self.cms.clone(), &mut canvas);
let mut runner = Runner::new(self.imp, self.config.clone(), context);
let target = runner.run(&data);
let meta = data.meta.clone().into();
Some(RenderResult::new(DataTarget::new(Some(data), target), meta))
}
_ => {
let mut canvas = render.get_canvas();
let mut canvas = canvas.as_mut().unwrap();
let mut context = Context::new(self.cms.clone(), &mut canvas);
let mut runner = Runner::new(self.imp, self.config.clone(), context);
runner.run_without_target(&data);
None
}
} }
} }
@ -461,38 +508,38 @@ impl Element {
self.current_key.clone().unwrap() self.current_key.clone().unwrap()
} }
async fn run(&self, key: Key) -> Option<Arc<Mutex<RenderResult>>> { // async fn run(&self, key: Key) -> Option<Arc<Mutex<RenderResult>>> {
{ // {
let cache = &self.buffer; // let cache = &self.buffer;
if cache.peek(&key).is_some() { // if cache.peek(&key).is_some() {
return Some(cache.get(&key).unwrap()); // return Some(cache.get(&key).unwrap());
} // }
} // }
let datetime = key.datetime.unwrap(); // let datetime = key.datetime.unwrap();
let dispatcher = (&*self.dispatcher); // let dispatcher = (&*self.dispatcher);
let current_path = dispatcher.get_single_path(&self.name, datetime, true); // let current_path = dispatcher.get_single_path(&self.name, datetime, true);
let paths = dispatcher.get_path(&self.name, datetime, true, 3, &self.root); // let paths = dispatcher.get_path(&self.name, datetime, true, 3, &self.root);
if let Some(paths) = paths { // if let Some(paths) = paths {
paths.iter().for_each(|(p, d)| { // paths.iter().for_each(|(p, d)| {
let key = self.generate_key(d.to_owned()); // let key = self.generate_key(d.to_owned());
let f = self._run(p, &key); // let f = self._run(p, &key);
let handle = tokio::task::spawn(f); // let handle = tokio::task::spawn(f);
}); // });
} // }
if let Some(path) = current_path { // if let Some(path) = current_path {
let key = self.generate_key(datetime); // let key = self.generate_key(datetime);
let f = self._run(path, &key); // let f = self._run(path, &key);
let handle = tokio::task::spawn(f); // let handle = tokio::task::spawn(f);
let result = handle.await.unwrap(); // let result = handle.await.unwrap();
Some(result) // Some(result)
} else { // } else {
None // None
} // }
} // }
fn generate_key(&self, datetime: DateTime<Utc>) -> Key { fn generate_key(&self, datetime: DateTime<Utc>) -> Key {
Key { Key {
id: self.id, id: self.id,
@ -502,79 +549,79 @@ impl Element {
} }
} }
fn _run( // fn _run(
&self, // &self,
p: impl AsRef<std::path::Path>, // p: impl AsRef<std::path::Path>,
key: &Key, // key: &Key,
) -> BoxFuture<'static, Arc<Mutex<RenderResult>>> { // ) -> BoxFuture<'static, Arc<Mutex<RenderResult>>> {
let (tx, rx) = oneshot::channel(); // let (tx, rx) = oneshot::channel();
let buffer = self.buffer.clone(); // let buffer = self.buffer.clone();
let config = self.config.clone(); // let config = self.config.clone();
let canceller = self.cancellers.clone(); // let canceller = self.cancellers.clone();
let subscriber = self.subscribers.clone(); // let subscriber = self.subscribers.clone();
let mut dialog_cms = self.cms.clone(); // let mut dialog_cms = self.cms.clone();
let mut dialog_config = self.config.clone(); // let mut dialog_config = self.config.clone();
let mut dialog_imp = self.imp.clone(); // let mut dialog_imp = self.imp.clone();
let _key = key.to_owned(); // let _key = key.to_owned();
Box::pin(async move { // Box::pin(async move {
let key = &_key; // let key = &_key;
let mut subscribers = subscriber.lock().await; // let mut subscribers = subscriber.lock().await;
if subscribers.contains_key(key) { // if subscribers.contains_key(key) {
subscribers.get_mut(key).unwrap().push(tx); // subscribers.get_mut(key).unwrap().push(tx);
drop(subscribers); // drop(subscribers);
} else { // } else {
let (canceller_tx, canceller_rx) = oneshot::channel(); // let (canceller_tx, canceller_rx) = oneshot::channel();
subscribers.insert(key.to_owned(), vec![tx]); // subscribers.insert(key.to_owned(), vec![tx]);
drop(subscribers); // drop(subscribers);
let mut cancellers = canceller.lock().await; // let mut cancellers = canceller.lock().await;
cancellers.insert(key.clone(), canceller_tx); // cancellers.insert(key.clone(), canceller_tx);
drop(cancellers); // drop(cancellers);
use tokio::task; // use tokio::task;
let key = key.to_owned(); // let key = key.to_owned();
tokio::spawn(async move { // tokio::spawn(async move {
let new_key = key.clone(); // let new_key = key.clone();
tokio::select! { // tokio::select! {
_ = async move { // _ = async move {
let handle = task::spawn_blocking(move || { // let handle = task::spawn_blocking(move || {
let mut offscreen_renderer = OffscreenRenderer::new(3000, 3000).unwrap(); // let mut offscreen_renderer = OffscreenRenderer::new(3000, 3000).unwrap();
let mut canvas = offscreen_renderer.create_canvas(); // let mut canvas = offscreen_renderer.create_canvas();
let mut context = Context::new(dialog_cms, &mut canvas); // let mut context = Context::new(dialog_cms, &mut canvas);
let mut runner = Runner::new(dialog_imp, dialog_config, context); // let mut runner = Runner::new(dialog_imp, dialog_config, context);
let loader = PLUGIN_MANAGER.get_plugin_by_name("etws_loader").unwrap(); // let loader = PLUGIN_MANAGER.get_plugin_by_name("etws_loader").unwrap();
let mut loaded_data = loader.load("".into()).unwrap(); // let mut loaded_data = loader.load("".into()).unwrap();
let meta = loaded_data.meta.clone().into(); // let meta = loaded_data.meta.clone().into();
let target = runner.run(&loaded_data); // let target = runner.run(&loaded_data);
RenderResult::new( // RenderResult::new(
DataTarget::new(Some(loaded_data), target), // DataTarget::new(Some(loaded_data), target),
meta // meta
) // )
}); // });
let result = handle.await.unwrap(); // let result = handle.await.unwrap();
let bf = Arc::new(Mutex::new(result)); // let bf = Arc::new(Mutex::new(result));
buffer.insert(key.clone(), bf.clone()); // buffer.insert(key.clone(), bf.clone());
let mut subscribers = subscriber.lock().await; // let mut subscribers = subscriber.lock().await;
for tx in subscribers.remove(&key).unwrap() { // for tx in subscribers.remove(&key).unwrap() {
let _ = tx.send(bf.clone()); // let _ = tx.send(bf.clone());
} // }
} => {} // } => {}
_ = canceller_rx => {} // _ = canceller_rx => {}
} // }
let mut cancellers = canceller.lock().await; // let mut cancellers = canceller.lock().await;
cancellers.remove(&new_key); // cancellers.remove(&new_key);
}); // });
} // }
rx.await.unwrap() // rx.await.unwrap()
}) // })
} // }
fn key(&self) -> String { fn key(&self) -> String {
format!("{}-{}", self.id, self.name) format!("{}-{}", self.id, self.name)

2
src/pipeline/offscreen_renderer.rs
View File

@ -37,7 +37,7 @@ impl OffscreenRenderer {
let mut device = connection.create_device(&adapter)?; let mut device = connection.create_device(&adapter)?;
let descriptor = device.create_context_descriptor(&surfman::ContextAttributes { let descriptor = device.create_context_descriptor(&surfman::ContextAttributes {
version: surfman::GLVersion::new(3, 3), version: surfman::GLVersion::new(4, 1),
flags: ContextAttributeFlags::ALPHA flags: ContextAttributeFlags::ALPHA
.union(ContextAttributeFlags::DEPTH) .union(ContextAttributeFlags::DEPTH)
.union(ContextAttributeFlags::STENCIL), .union(ContextAttributeFlags::STENCIL),

1
src/widgets/render/imp.rs
View File

@ -15,6 +15,7 @@ use std::collections::HashMap;
use std::num::NonZeroU32; use std::num::NonZeroU32;
use std::rc::Rc; use std::rc::Rc;
use std::sync::{Arc, Mutex}; use std::sync::{Arc, Mutex};
use glow::HasContext;
use tracing::info; use tracing::info;
#[derive(Debug, Default, Clone, Copy, PartialEq)] #[derive(Debug, Default, Clone, Copy, PartialEq)]

8
src/widgets/render/interior/layers.rs
View File

@ -9,6 +9,7 @@ use std::{
fmt::Debug, fmt::Debug,
sync::{Arc, Mutex}, sync::{Arc, Mutex},
}; };
use std::cell::RefCell;
#[derive(Clone, Copy, Debug)] #[derive(Clone, Copy, Debug)]
pub enum ElementType { pub enum ElementType {
@ -22,7 +23,7 @@ pub struct Layer {
pub alpha: f32, pub alpha: f32,
pub name: String, pub name: String,
element_type: ElementType, element_type: ElementType,
element: Rc<Element>, element: Rc<RefCell<Element>>,
} }
impl Debug for Layer { impl Debug for Layer {
@ -37,7 +38,7 @@ impl Layer {
pub fn new( pub fn new(
visiable: bool, visiable: bool,
layer_name: String, layer_name: String,
element: Rc<Element>, element: Rc<RefCell<Element>>,
element_type: ElementType, element_type: ElementType,
) -> Self { ) -> Self {
Layer { Layer {
@ -55,7 +56,8 @@ impl Layer {
window_size: (f32, f32), window_size: (f32, f32),
) -> Result<(), PipelineError> { ) -> Result<(), PipelineError> {
if self.visiable { if self.visiable {
self.element.r(ElementEvent::Init, render); let mut element = self.element.borrow_mut();
element.r(ElementEvent::Draw, render);
return Ok(()); return Ok(());
} }