diff --git a/src/components/app.rs b/src/components/app.rs index ef24c81..abf9f23 100644 --- a/src/components/app.rs +++ b/src/components/app.rs @@ -83,7 +83,7 @@ pub enum AppMsg { OpenDialog, LayerManager(LayerMsg), Layer, - NewElement(Rc), + NewElement(Rc>), DeleteElement(ElementKey), } type RcDispatcher = Rc; @@ -110,7 +110,7 @@ pub struct AppModel { #[do_not_track] file_pool: Arc>>, #[do_not_track] - elements: Vec>, + elements: Vec>>, #[do_not_track] setting: Controller, } @@ -283,6 +283,8 @@ impl Component for AppModel { let (lat_start, lat_end) = meta.lat_range.unwrap(); let (lon_start, lon_end) = meta.lon_range.unwrap(); let imp = tools(&data); + + dialog_file_pool.insert(path.clone(), Arc::new(data)); use femtovg::Color; let config = GridImpConfig { 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", dialog_cms.clone(), dialog_dispatcher.clone(), @@ -323,7 +325,7 @@ impl Component for AppModel { dialog_buffer.clone(), dialog_file_pool.clone(), imp, - )); + ))); dialog_sidebar_sender.emit(SideBarInputMsg::AddMetaItems(meta.to_map())); dialog_render_sender.emit(MonitorInputMsg::SetRenderRange( diff --git a/src/main.rs b/src/main.rs index f090608..6fa10a2 100644 --- a/src/main.rs +++ b/src/main.rs @@ -36,7 +36,6 @@ mod predefined; mod widgets; // mod element_imp; -#[cfg(target_env = "msvc")] declare_surfman!(); const APP_ID: &str = "org.tsuki.radar_g"; diff --git a/src/pipeline/new_element.rs b/src/pipeline/new_element.rs index 3d4aa13..09cf2cb 100644 --- a/src/pipeline/new_element.rs +++ b/src/pipeline/new_element.rs @@ -4,6 +4,7 @@ use super::element_imp::ElementImpl; use super::element_imp::ElementOutput; use super::offscreen_renderer; use super::offscreen_renderer::CanvasWrapper; +use super::runner; use super::runner::Runner; use super::Dispatcher; use crate::coords::cms::CMS; @@ -42,7 +43,9 @@ use tracing::subscriber; static ELEMENT_ID: AtomicI32 = AtomicI32::new(0); pub type ElementID = i32; pub type KVBuffer = Cache; -pub type Buffer = KVBuffer>>; +pub type Buffer = KVBuffer>>; + +pub type Data = Arc; #[derive(Debug, Hash, Eq, PartialEq, Clone)] pub struct Key { @@ -75,7 +78,6 @@ impl Target { height: f32, bounds: (Range, Range), thumbnail: Option, - // data: Option>, ) -> Self { Self { target, @@ -83,7 +85,6 @@ impl Target { height, bounds, thumbnail, - // data, } } @@ -107,7 +108,8 @@ impl Target { if let TargetType::NativeBuffer(ref mem) = self.target { use glow::*; 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.pixel_store_i32(glow::UNPACK_ALIGNMENT, 1); gl.pixel_store_i32(glow::UNPACK_ROW_LENGTH, 3000 as i32); @@ -257,26 +259,14 @@ impl Target { #[derive(Debug, Clone)] pub struct DataTarget { - data: Option, + pub data: Option, target: Target, } impl DataTarget { - pub fn new(data: Option, target: Target) -> Self { + pub fn new(data: Option, target: Target) -> Self { Self { data, target } } - - pub fn take_data(&mut self) -> Option { - 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)] @@ -307,17 +297,19 @@ pub struct Element { root: std::path::PathBuf, config: Arc, imp: ElementImpl, - subscribers: Arc>>>>>>, + subscribers: Arc>>>>>>, cancellers: Arc>>>, current_key: Option, dispatcher: Rc, buffer: Arc>, file_pool: Arc>>, + current_target: Option>>, cms: CMS, } pub enum ElementEvent<'a> { Init, + Draw, DateTime(DateTime), Key(&'a Key), } @@ -349,24 +341,53 @@ impl Element { current_key: None, buffer, file_pool, + current_target: None, 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 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 { ElementEvent::Init => { - let data = self.file_pool.get(&self.root); - if let Some(data) = data {} + _init(self, need_cache, output_type, render); } + 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) => { let path = self.dispatcher.get_single_path(&self.name, time, true); 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) { - match output_type { - ElementOutput::Target => {} + fn insert_target_to_buffer(&self, key: Key, render_result: RenderResult) { + let result = Arc::new(RwLock::new(render_result)); + self.buffer.insert(key, result); + } - _ => {} + fn _rrrr( + &self, + data: Data, + need_cache: bool, + output_type: ElementOutput, + render: &Render, + ) -> Option { + 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() } - async fn run(&self, key: Key) -> Option>> { - { - let cache = &self.buffer; - if cache.peek(&key).is_some() { - return Some(cache.get(&key).unwrap()); - } - } + // async fn run(&self, key: Key) -> Option>> { + // { + // let cache = &self.buffer; + // if cache.peek(&key).is_some() { + // 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 paths = dispatcher.get_path(&self.name, datetime, true, 3, &self.root); - if let Some(paths) = paths { - paths.iter().for_each(|(p, d)| { - let key = self.generate_key(d.to_owned()); - let f = self._run(p, &key); - let handle = tokio::task::spawn(f); - }); - } + // let current_path = dispatcher.get_single_path(&self.name, datetime, true); + // let paths = dispatcher.get_path(&self.name, datetime, true, 3, &self.root); + // if let Some(paths) = paths { + // paths.iter().for_each(|(p, d)| { + // let key = self.generate_key(d.to_owned()); + // let f = self._run(p, &key); + // let handle = tokio::task::spawn(f); + // }); + // } - if let Some(path) = current_path { - let key = self.generate_key(datetime); - let f = self._run(path, &key); - let handle = tokio::task::spawn(f); - let result = handle.await.unwrap(); - Some(result) - } else { - None - } - } + // if let Some(path) = current_path { + // let key = self.generate_key(datetime); + // let f = self._run(path, &key); + // let handle = tokio::task::spawn(f); + // let result = handle.await.unwrap(); + // Some(result) + // } else { + // None + // } + // } fn generate_key(&self, datetime: DateTime) -> Key { Key { id: self.id, @@ -502,79 +549,79 @@ impl Element { } } - fn _run( - &self, - p: impl AsRef, - key: &Key, - ) -> BoxFuture<'static, Arc>> { - let (tx, rx) = oneshot::channel(); - let buffer = self.buffer.clone(); - let config = self.config.clone(); - let canceller = self.cancellers.clone(); - let subscriber = self.subscribers.clone(); - let mut dialog_cms = self.cms.clone(); - let mut dialog_config = self.config.clone(); - let mut dialog_imp = self.imp.clone(); + // fn _run( + // &self, + // p: impl AsRef, + // key: &Key, + // ) -> BoxFuture<'static, Arc>> { + // let (tx, rx) = oneshot::channel(); + // let buffer = self.buffer.clone(); + // let config = self.config.clone(); + // let canceller = self.cancellers.clone(); + // let subscriber = self.subscribers.clone(); + // let mut dialog_cms = self.cms.clone(); + // let mut dialog_config = self.config.clone(); + // let mut dialog_imp = self.imp.clone(); - let _key = key.to_owned(); - Box::pin(async move { - let key = &_key; - let mut subscribers = subscriber.lock().await; - if subscribers.contains_key(key) { - subscribers.get_mut(key).unwrap().push(tx); - drop(subscribers); - } else { - let (canceller_tx, canceller_rx) = oneshot::channel(); - subscribers.insert(key.to_owned(), vec![tx]); - drop(subscribers); + // let _key = key.to_owned(); + // Box::pin(async move { + // let key = &_key; + // let mut subscribers = subscriber.lock().await; + // if subscribers.contains_key(key) { + // subscribers.get_mut(key).unwrap().push(tx); + // drop(subscribers); + // } else { + // let (canceller_tx, canceller_rx) = oneshot::channel(); + // subscribers.insert(key.to_owned(), vec![tx]); + // drop(subscribers); - let mut cancellers = canceller.lock().await; - cancellers.insert(key.clone(), canceller_tx); - drop(cancellers); + // let mut cancellers = canceller.lock().await; + // cancellers.insert(key.clone(), canceller_tx); + // drop(cancellers); - use tokio::task; + // use tokio::task; - let key = key.to_owned(); - tokio::spawn(async move { - let new_key = key.clone(); - tokio::select! { - _ = async move { - let handle = task::spawn_blocking(move || { - let mut offscreen_renderer = OffscreenRenderer::new(3000, 3000).unwrap(); - let mut canvas = offscreen_renderer.create_canvas(); - let mut context = Context::new(dialog_cms, &mut canvas); - let mut runner = Runner::new(dialog_imp, dialog_config, context); + // let key = key.to_owned(); + // tokio::spawn(async move { + // let new_key = key.clone(); + // tokio::select! { + // _ = async move { + // let handle = task::spawn_blocking(move || { + // let mut offscreen_renderer = OffscreenRenderer::new(3000, 3000).unwrap(); + // let mut canvas = offscreen_renderer.create_canvas(); + // let mut context = Context::new(dialog_cms, &mut canvas); + // let mut runner = Runner::new(dialog_imp, dialog_config, context); - let loader = PLUGIN_MANAGER.get_plugin_by_name("etws_loader").unwrap(); - let mut loaded_data = loader.load("".into()).unwrap(); - let meta = loaded_data.meta.clone().into(); + // let loader = PLUGIN_MANAGER.get_plugin_by_name("etws_loader").unwrap(); + // let mut loaded_data = loader.load("".into()).unwrap(); + // let meta = loaded_data.meta.clone().into(); - let target = runner.run(&loaded_data); + // let target = runner.run(&loaded_data); - RenderResult::new( - DataTarget::new(Some(loaded_data), target), - meta - ) - }); - let result = handle.await.unwrap(); - let bf = Arc::new(Mutex::new(result)); - buffer.insert(key.clone(), bf.clone()); - let mut subscribers = subscriber.lock().await; - for tx in subscribers.remove(&key).unwrap() { - let _ = tx.send(bf.clone()); - } + // RenderResult::new( + // DataTarget::new(Some(loaded_data), target), + // meta + // ) + // }); + // let result = handle.await.unwrap(); + // let bf = Arc::new(Mutex::new(result)); + // buffer.insert(key.clone(), bf.clone()); + // let mut subscribers = subscriber.lock().await; + // for tx in subscribers.remove(&key).unwrap() { + // let _ = tx.send(bf.clone()); + // } - } => {} - _ = canceller_rx => {} - } - let mut cancellers = canceller.lock().await; - cancellers.remove(&new_key); - }); - } + // } => {} + // _ = canceller_rx => {} + // } + // let mut cancellers = canceller.lock().await; + // cancellers.remove(&new_key); + // }); + // } - rx.await.unwrap() - }) - } + // rx.await.unwrap() + // }) + // } fn key(&self) -> String { format!("{}-{}", self.id, self.name) diff --git a/src/pipeline/offscreen_renderer.rs b/src/pipeline/offscreen_renderer.rs index 68b0701..9fef50e 100644 --- a/src/pipeline/offscreen_renderer.rs +++ b/src/pipeline/offscreen_renderer.rs @@ -37,7 +37,7 @@ impl OffscreenRenderer { let mut device = connection.create_device(&adapter)?; let descriptor = device.create_context_descriptor(&surfman::ContextAttributes { - version: surfman::GLVersion::new(3, 3), + version: surfman::GLVersion::new(4, 1), flags: ContextAttributeFlags::ALPHA .union(ContextAttributeFlags::DEPTH) .union(ContextAttributeFlags::STENCIL), diff --git a/src/widgets/render/imp.rs b/src/widgets/render/imp.rs index 88cc8c9..268fda1 100644 --- a/src/widgets/render/imp.rs +++ b/src/widgets/render/imp.rs @@ -15,6 +15,7 @@ use std::collections::HashMap; use std::num::NonZeroU32; use std::rc::Rc; use std::sync::{Arc, Mutex}; +use glow::HasContext; use tracing::info; #[derive(Debug, Default, Clone, Copy, PartialEq)] diff --git a/src/widgets/render/interior/layers.rs b/src/widgets/render/interior/layers.rs index 8f1c337..cc72b4d 100644 --- a/src/widgets/render/interior/layers.rs +++ b/src/widgets/render/interior/layers.rs @@ -9,6 +9,7 @@ use std::{ fmt::Debug, sync::{Arc, Mutex}, }; +use std::cell::RefCell; #[derive(Clone, Copy, Debug)] pub enum ElementType { @@ -22,7 +23,7 @@ pub struct Layer { pub alpha: f32, pub name: String, element_type: ElementType, - element: Rc, + element: Rc>, } impl Debug for Layer { @@ -37,7 +38,7 @@ impl Layer { pub fn new( visiable: bool, layer_name: String, - element: Rc, + element: Rc>, element_type: ElementType, ) -> Self { Layer { @@ -55,7 +56,8 @@ impl Layer { window_size: (f32, f32), ) -> Result<(), PipelineError> { if self.visiable { - self.element.r(ElementEvent::Init, render); + let mut element = self.element.borrow_mut(); + element.r(ElementEvent::Draw, render); return Ok(()); }