tracy_full 1.7.0

Fully featured bindings for the Tracy profiler
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

//! Bevy related profiling.

use std::{any::TypeId, borrow::Cow, ffi::CString};

use bevy_ecs::{
	archetype::ArchetypeComponentId,
	component::{ComponentId, Tick},
	prelude::World,
	query::Access,
	system::{IntoSystem, System},
	world::unsafe_world_cell::UnsafeWorldCell,
};

/// Create a system that appears as a separate fiber in the profiler.
#[inline(always)]
pub fn timeline<In, Out, Params, T: IntoSystem<In, Out, Params>>(sys: T) -> SystemWrapper<T::System> {
	let sys = T::into_system(sys);
	SystemWrapper {
		name: CString::new::<Vec<u8>>(match sys.name() {
			Cow::Borrowed(b) => b.into(),
			Cow::Owned(o) => o.into(),
		})
		.expect("System name must not have null bytes"),
		inner: sys,
	}
}

/// A wrapper around a system that appears as a separate fiber in the profiler.
pub struct SystemWrapper<T> {
	inner: T,
	name: CString,
}

impl<T, In, Out> System for SystemWrapper<T>
where
	T: System<In = In, Out = Out>,
{
	type In = T::In;
	type Out = T::Out;

	#[inline(always)]
	fn name(&self) -> Cow<'static, str> { self.inner.name() }

	#[inline(always)]
	fn component_access(&self) -> &Access<ComponentId> { self.inner.component_access() }

	#[inline(always)]
	fn archetype_component_access(&self) -> &Access<ArchetypeComponentId> { self.inner.archetype_component_access() }

	#[inline(always)]
	fn is_send(&self) -> bool { self.inner.is_send() }

	#[inline(always)]
	unsafe fn run_unsafe(&mut self, input: Self::In, world: UnsafeWorldCell) -> Self::Out {
		#[cfg(feature = "enable")]
		sys::___tracy_fiber_enter(self.name.as_ptr());
		let out = self.inner.run_unsafe(input, world);
		#[cfg(feature = "enable")]
		sys::___tracy_fiber_leave();
		out
	}

	#[inline(always)]
	fn run(&mut self, input: Self::In, world: &mut World) -> Self::Out { self.inner.run(input, world) }

	#[inline(always)]
	fn initialize(&mut self, _world: &mut World) { self.inner.initialize(_world) }

	#[inline(always)]
	fn update_archetype_component_access(&mut self, world: UnsafeWorldCell) {
		self.inner.update_archetype_component_access(world)
	}

	#[inline(always)]
	fn check_change_tick(&mut self, change_tick: Tick) { self.inner.check_change_tick(change_tick) }

	#[inline(always)]
	fn is_exclusive(&self) -> bool { self.inner.is_exclusive() }

	fn type_id(&self) -> TypeId { self.inner.type_id() }

	fn apply_deferred(&mut self, world: &mut World) { self.inner.apply_deferred(world) }

	fn get_last_run(&self) -> Tick { self.inner.get_last_run() }

	fn set_last_run(&mut self, last_run: Tick) { self.inner.set_last_run(last_run) }
}