Einführung und Verwendung der PhysicsRaycaster-Komponente (empfohlene Strahlenerkennung für physikalische Generalisierung) von Unity UGUI

Was ist die Laufzeit in Rust? Um es vollständig zu verstehen, habe ich eine Spielzeuglaufzeit implementiert, ohne Crates von Drittanbietern zu verwenden. Sie wird Spielzeug genannt, weil sie keinen komplexen Planungsalgorithmus hat (nur eine globale Aufgabenwarteschlange).

Mit Ausnahme von mpmc (Multi-Producer, Multi-Consumer), das einen Crate- Crossbeam eines Drittanbieters verwendet   , ist der Rest des Codes handgeschrieben.

So kann man spielen

fn main() {
    let toy = Toy::new();

    for i in 1..=20 {
        toy.spawn(async move {
            let ret = FakeIO::new(Duration::from_secs(i)).await;
            println!("{:?}: {:?}", thread::current().id(), ret);
        })
    }

    toy.run(4); // 4 threads
}

Unter diesen ist FakeIO auch einfach genug

pub struct FakeIO {
    finished: Arc<AtomicBool>,
    duration: Duration,
}

impl Future for FakeIO {
    type Output = Duration;

    fn poll(
        self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Self::Output> {
        if self.finished.load(Ordering::Acquire) {
            return Poll::Ready(self.duration);
        }

        let finished = self.finished.clone();
        let waker = cx.waker().clone();
        let duration = self.duration;

        thread::spawn(move || {
            thread::sleep(duration);

            finished.store(true, Ordering::Release);

            waker.wake();
        });

        Poll::Pending
    }
}

Datenstruktur

Die Datenstrukturen sind wie folgt (bezogen auf  Tokios  Design)

struct Task {
    raw: RawTask,
}

unsafe impl Send for Task {}
unsafe impl Sync for Task {}

struct RawTask {
    ptr: NonNull<Header>, // pointer to Cell<T> where T: Future
}

struct Header {
    // todo: maybe replace the Mutex<State> with AtomicUsize
    state: Mutex<State>,
    vtable: &'static Vtable,
    sender: crossbeam::channel::Sender<Task>,
}

#[derive(Default)]
struct State {
    running: bool,
    notified: bool,
    completed: bool,
}

/// #[repr(C)] make sure `*mut Cell<T>` can cast to valid `*mut Header`, and backwards. 
/// In the default situation, the data layout may not be the same as the order in which the fields are specified in the declaration of the type
/// 默认情况下 Rust 的数据布局不一定会按照 field 的声明顺序排列
/// [The Default Representation](https://doc.rust-lang.org/reference/type-layout.html?#the-default-representation)
///
/// [playground link](https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=39ac84782d121970598b91201b168f82)
/// 
/// you can easilly view the data layout with this crate https://github.com/hangj/layout-rs
#[repr(C)]
struct Cell<T: Future> {
    header: Header,
    future: T,
    output: Option<T::Output>,
}

struct Vtable {
    poll_task: unsafe fn(NonNull<Header>),
    clone_task: unsafe fn(NonNull<Header>) -> NonNull<Header>,
    drop_task: unsafe fn(NonNull<Header>),
}

Bemerkenswert unter ihnen sind:

• RawTask Der da drin  ptr zeigt tatsächlich darauf NonNull<Cell<T: Future>>
• Cell<T: Future> Markiert  #repr(C), Grund in den Kommentaren angegeben
• vtable Das Design bezieht sich auf   die vtable in Waker , was der Verwendung einer generischen Funktion zum Speichern von Typinformationen entspricht, wodurch es später einfacher wird, den Rohzeiger auf den ursprünglichen Typ wiederherzustellen.

Viel Spaß!