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,
LayerManager(LayerMsg),
Layer,
NewElement(Rc<Element>),
NewElement(Rc<RefCell<Element>>),
DeleteElement(ElementKey),
}
type RcDispatcher = Rc<Dispatcher>;
@ -110,7 +110,7 @@ pub struct AppModel {
#[do_not_track]
file_pool: Arc<KVBuffer<PathBuf, Arc<PluginResult>>>,
#[do_not_track]
elements: Vec<Rc<Element>>,
elements: Vec<Rc<RefCell<Element>>>,
#[do_not_track]
setting: Controller<SettingModel>,
}
@ -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(

1
src/main.rs
View File

@ -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";

287
src/pipeline/new_element.rs
View File

@ -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<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)]
pub struct Key {
@ -75,7 +78,6 @@ impl Target {
height: f32,
bounds: (Range, Range),
thumbnail: Option<gtk::gdk::Texture>,
// data: Option<Arc<dyn Any + Send + Sync + 'static>>,
) -> 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<PluginResult>,
pub data: Option<Data>,
target: Target,
}
impl DataTarget {
pub fn new(data: Option<PluginResult>, target: Target) -> Self {
pub fn new(data: Option<Data>, target: Target) -> Self {
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)]
@ -307,17 +297,19 @@ pub struct Element {
root: std::path::PathBuf,
config: Arc<dyn Any + Send + Sync>,
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<()>>>>,
current_key: Option<Key>,
dispatcher: Rc<Dispatcher>,
buffer: Arc<Buffer<Key>>,
file_pool: Arc<KVBuffer<PathBuf, Arc<PluginResult>>>,
current_target: Option<Arc<RwLock<RenderResult>>>,
cms: CMS,
}
pub enum ElementEvent<'a> {
Init,
Draw,
DateTime(DateTime<Utc>),
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<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()
}
async fn run(&self, key: Key) -> Option<Arc<Mutex<RenderResult>>> {
{
let cache = &self.buffer;
if cache.peek(&key).is_some() {
return Some(cache.get(&key).unwrap());
}
}
// async fn run(&self, key: Key) -> Option<Arc<Mutex<RenderResult>>> {
// {
// 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<Utc>) -> Key {
Key {
id: self.id,
@ -502,79 +549,79 @@ impl Element {
}
}
fn _run(
&self,
p: impl AsRef<std::path::Path>,
key: &Key,
) -> BoxFuture<'static, Arc<Mutex<RenderResult>>> {
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<std::path::Path>,
// key: &Key,
// ) -> BoxFuture<'static, Arc<Mutex<RenderResult>>> {
// 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)

2
src/pipeline/offscreen_renderer.rs
View File

@ -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),

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

@ -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)]

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

@ -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>,
element: Rc<RefCell<Element>>,
}
impl Debug for Layer {
@ -37,7 +38,7 @@ impl Layer {
pub fn new(
visiable: bool,
layer_name: String,
element: Rc<Element>,
element: Rc<RefCell<Element>>,
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(());
}