Use en-us locale for typos (#16037)

# Objective

Bevy seems to want to standardize on "American English" spellings. Not
sure if this is laid out anywhere in writing, but see also #15947.

While perusing the docs for `typos`, I noticed that it has a `locale`
config option and tried it out.

## Solution

Switch to `en-us` locale in the `typos` config and run `typos -w`

## Migration Guide

The following methods or fields have been renamed from `*dependants*` to
`*dependents*`.

- `ProcessorAssetInfo::dependants`
- `ProcessorAssetInfos::add_dependant`
- `ProcessorAssetInfos::non_existent_dependants`
- `AssetInfo::dependants_waiting_on_load`
- `AssetInfo::dependants_waiting_on_recursive_dep_load`
- `AssetInfos::loader_dependants`
- `AssetInfos::remove_dependants_and_labels`
This commit is contained in:
Rob Parrett 2024-10-20 11:55:17 -07:00 committed by GitHub
parent 472bbaae26
commit 30d84519a2
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
58 changed files with 191 additions and 190 deletions

View file

@ -3327,11 +3327,11 @@ doc-scrape-examples = true
hidden = true
[[example]]
name = "minimising"
path = "tests/window/minimising.rs"
name = "minimizing"
path = "tests/window/minimizing.rs"
doc-scrape-examples = true
[package.metadata.example.minimising]
[package.metadata.example.minimizing]
hidden = true
[[example]]

View file

@ -24,7 +24,7 @@ pub(crate) fn trigger_animation_event(
/// An event that can be used with animations.
/// It can be derived to trigger as an observer event,
/// if you need more complex behaviour, consider
/// if you need more complex behavior, consider
/// a manual implementation.
///
/// # Example

View file

@ -52,7 +52,7 @@ fn js_value_to_err(context: &str) -> impl FnOnce(JsValue) -> std::io::Error + '_
impl HttpWasmAssetReader {
async fn fetch_bytes<'a>(&self, path: PathBuf) -> Result<impl Reader, AssetReaderError> {
// The JS global scope includes a self-reference via a specialising name, which can be used to determine the type of global context available.
// The JS global scope includes a self-reference via a specializing name, which can be used to determine the type of global context available.
let global: Global = js_sys::global().unchecked_into();
let promise = if !global.window().is_undefined() {
let window: web_sys::Window = global.unchecked_into();

View file

@ -670,7 +670,7 @@ impl AssetProcessor {
}
for dependency in dependencies {
asset_infos.add_dependant(&dependency, asset_path.clone());
asset_infos.add_dependent(&dependency, asset_path.clone());
}
}
}
@ -1137,7 +1137,7 @@ pub enum ProcessStatus {
pub(crate) struct ProcessorAssetInfo {
processed_info: Option<ProcessedInfo>,
/// Paths of assets that depend on this asset when they are being processed.
dependants: HashSet<AssetPath<'static>>,
dependents: HashSet<AssetPath<'static>>,
status: Option<ProcessStatus>,
/// A lock that controls read/write access to processed asset files. The lock is shared for both the asset bytes and the meta bytes.
/// _This lock must be locked whenever a read or write to processed assets occurs_
@ -1161,7 +1161,7 @@ impl Default for ProcessorAssetInfo {
status_sender.set_overflow(true);
Self {
processed_info: Default::default(),
dependants: Default::default(),
dependents: Default::default(),
file_transaction_lock: Default::default(),
status: None,
status_sender,
@ -1187,13 +1187,13 @@ pub struct ProcessorAssetInfos {
/// The "current" in memory view of the asset space. During processing, if path does not exist in this, it should
/// be considered non-existent.
/// NOTE: YOU MUST USE `Self::get_or_insert` or `Self::insert` TO ADD ITEMS TO THIS COLLECTION TO ENSURE
/// `non_existent_dependants` DATA IS CONSUMED
/// `non_existent_dependents` DATA IS CONSUMED
infos: HashMap<AssetPath<'static>, ProcessorAssetInfo>,
/// Dependants for assets that don't exist. This exists to track "dangling" asset references due to deleted / missing files.
/// If the dependant asset is added, it can "resolve" these dependencies and re-compute those assets.
/// Dependents for assets that don't exist. This exists to track "dangling" asset references due to deleted / missing files.
/// If the dependent asset is added, it can "resolve" these dependencies and re-compute those assets.
/// Therefore this _must_ always be consistent with the `infos` data. If a new asset is added to `infos`, it should
/// check this maps for dependencies and add them. If an asset is removed, it should update the dependants here.
non_existent_dependants: HashMap<AssetPath<'static>, HashSet<AssetPath<'static>>>,
/// check this maps for dependencies and add them. If an asset is removed, it should update the dependents here.
non_existent_dependents: HashMap<AssetPath<'static>, HashSet<AssetPath<'static>>>,
check_reprocess_queue: VecDeque<AssetPath<'static>>,
}
@ -1201,9 +1201,9 @@ impl ProcessorAssetInfos {
fn get_or_insert(&mut self, asset_path: AssetPath<'static>) -> &mut ProcessorAssetInfo {
self.infos.entry(asset_path.clone()).or_insert_with(|| {
let mut info = ProcessorAssetInfo::default();
// track existing dependants by resolving existing "hanging" dependants.
if let Some(dependants) = self.non_existent_dependants.remove(&asset_path) {
info.dependants = dependants;
// track existing dependents by resolving existing "hanging" dependents.
if let Some(dependents) = self.non_existent_dependents.remove(&asset_path) {
info.dependents = dependents;
}
info
})
@ -1217,15 +1217,15 @@ impl ProcessorAssetInfos {
self.infos.get_mut(asset_path)
}
fn add_dependant(&mut self, asset_path: &AssetPath<'static>, dependant: AssetPath<'static>) {
fn add_dependent(&mut self, asset_path: &AssetPath<'static>, dependent: AssetPath<'static>) {
if let Some(info) = self.get_mut(asset_path) {
info.dependants.insert(dependant);
info.dependents.insert(dependent);
} else {
let dependants = self
.non_existent_dependants
let dependents = self
.non_existent_dependents
.entry(asset_path.clone())
.or_default();
dependants.insert(dependant);
dependents.insert(dependent);
}
}
@ -1238,7 +1238,7 @@ impl ProcessorAssetInfos {
match result {
Ok(ProcessResult::Processed(processed_info)) => {
debug!("Finished processing \"{:?}\"", asset_path);
// clean up old dependants
// clean up old dependents
let old_processed_info = self
.infos
.get_mut(&asset_path)
@ -1247,15 +1247,15 @@ impl ProcessorAssetInfos {
self.clear_dependencies(&asset_path, old_processed_info);
}
// populate new dependants
// populate new dependents
for process_dependency_info in &processed_info.process_dependencies {
self.add_dependant(&process_dependency_info.path, asset_path.to_owned());
self.add_dependent(&process_dependency_info.path, asset_path.to_owned());
}
let info = self.get_or_insert(asset_path);
info.processed_info = Some(processed_info);
info.update_status(ProcessStatus::Processed).await;
let dependants = info.dependants.iter().cloned().collect::<Vec<_>>();
for path in dependants {
let dependents = info.dependents.iter().cloned().collect::<Vec<_>>();
for path in dependents {
self.check_reprocess_queue.push_back(path);
}
}
@ -1298,7 +1298,7 @@ impl ProcessorAssetInfos {
full_hash: AssetHash::default(),
process_dependencies: vec![],
});
self.add_dependant(dependency.path(), asset_path.to_owned());
self.add_dependent(dependency.path(), asset_path.to_owned());
}
let info = self.get_mut(&asset_path).expect("info should exist");
@ -1319,13 +1319,13 @@ impl ProcessorAssetInfos {
.broadcast(ProcessStatus::NonExistent)
.await
.unwrap();
if !info.dependants.is_empty() {
if !info.dependents.is_empty() {
error!(
"The asset at {asset_path} was removed, but it had assets that depend on it to be processed. Consider updating the path in the following assets: {:?}",
info.dependants
info.dependents
);
self.non_existent_dependants
.insert(asset_path.clone(), info.dependants);
self.non_existent_dependents
.insert(asset_path.clone(), info.dependents);
}
}
}
@ -1334,31 +1334,31 @@ impl ProcessorAssetInfos {
async fn rename(&mut self, old: &AssetPath<'static>, new: &AssetPath<'static>) {
let info = self.infos.remove(old);
if let Some(mut info) = info {
if !info.dependants.is_empty() {
if !info.dependents.is_empty() {
// TODO: We can't currently ensure "moved" folders with relative paths aren't broken because AssetPath
// doesn't distinguish between absolute and relative paths. We have "erased" relativeness. In the short term,
// we could do "remove everything in a folder and re-add", but that requires full rebuilds / destroying the cache.
// If processors / loaders could enumerate dependencies, we could check if the new deps line up with a rename.
// If deps encoded "relativeness" as part of loading, that would also work (this seems like the right call).
// TODO: it would be nice to log an error here for dependants that aren't also being moved + fixed.
// TODO: it would be nice to log an error here for dependents that aren't also being moved + fixed.
// (see the remove impl).
error!(
"The asset at {old} was removed, but it had assets that depend on it to be processed. Consider updating the path in the following assets: {:?}",
info.dependants
info.dependents
);
self.non_existent_dependants
.insert(old.clone(), core::mem::take(&mut info.dependants));
self.non_existent_dependents
.insert(old.clone(), core::mem::take(&mut info.dependents));
}
if let Some(processed_info) = &info.processed_info {
// Update "dependant" lists for this asset's "process dependencies" to use new path.
// Update "dependent" lists for this asset's "process dependencies" to use new path.
for dep in &processed_info.process_dependencies {
if let Some(info) = self.infos.get_mut(&dep.path) {
info.dependants.remove(old);
info.dependants.insert(new.clone());
} else if let Some(dependants) = self.non_existent_dependants.get_mut(&dep.path)
info.dependents.remove(old);
info.dependents.insert(new.clone());
} else if let Some(dependents) = self.non_existent_dependents.get_mut(&dep.path)
{
dependants.remove(old);
dependants.insert(new.clone());
dependents.remove(old);
dependents.insert(new.clone());
}
}
}
@ -1367,7 +1367,7 @@ impl ProcessorAssetInfos {
.broadcast(ProcessStatus::NonExistent)
.await
.unwrap();
let dependants: Vec<AssetPath<'static>> = {
let dependents: Vec<AssetPath<'static>> = {
let new_info = self.get_or_insert(new.clone());
new_info.processed_info = info.processed_info;
new_info.status = info.status;
@ -1375,13 +1375,13 @@ impl ProcessorAssetInfos {
if let Some(status) = new_info.status {
new_info.status_sender.broadcast(status).await.unwrap();
}
new_info.dependants.iter().cloned().collect()
new_info.dependents.iter().cloned().collect()
};
// Queue the asset for a reprocess check, in case it needs new meta.
self.check_reprocess_queue.push_back(new.clone());
for dependant in dependants {
// Queue dependants for reprocessing because they might have been waiting for this asset.
self.check_reprocess_queue.push_back(dependant);
for dependent in dependents {
// Queue dependents for reprocessing because they might have been waiting for this asset.
self.check_reprocess_queue.push_back(dependent);
}
}
}
@ -1389,11 +1389,11 @@ impl ProcessorAssetInfos {
fn clear_dependencies(&mut self, asset_path: &AssetPath<'static>, removed_info: ProcessedInfo) {
for old_load_dep in removed_info.process_dependencies {
if let Some(info) = self.infos.get_mut(&old_load_dep.path) {
info.dependants.remove(asset_path);
} else if let Some(dependants) =
self.non_existent_dependants.get_mut(&old_load_dep.path)
info.dependents.remove(asset_path);
} else if let Some(dependents) =
self.non_existent_dependents.get_mut(&old_load_dep.path)
{
dependants.remove(asset_path);
dependents.remove(asset_path);
}
}
}

View file

@ -24,8 +24,8 @@ pub(crate) struct AssetInfo {
failed_dependencies: HashSet<UntypedAssetId>,
loading_rec_dependencies: HashSet<UntypedAssetId>,
failed_rec_dependencies: HashSet<UntypedAssetId>,
dependants_waiting_on_load: HashSet<UntypedAssetId>,
dependants_waiting_on_recursive_dep_load: HashSet<UntypedAssetId>,
dependents_waiting_on_load: HashSet<UntypedAssetId>,
dependents_waiting_on_recursive_dep_load: HashSet<UntypedAssetId>,
/// The asset paths required to load this asset. Hashes will only be set for processed assets.
/// This is set using the value from [`LoadedAsset`].
/// This will only be populated if [`AssetInfos::watching_for_changes`] is set to `true` to
@ -53,8 +53,8 @@ impl AssetInfo {
loading_rec_dependencies: HashSet::default(),
failed_rec_dependencies: HashSet::default(),
loader_dependencies: HashMap::default(),
dependants_waiting_on_load: HashSet::default(),
dependants_waiting_on_recursive_dep_load: HashSet::default(),
dependents_waiting_on_load: HashSet::default(),
dependents_waiting_on_recursive_dep_load: HashSet::default(),
handle_drops_to_skip: 0,
waiting_tasks: Vec::new(),
}
@ -65,12 +65,12 @@ impl AssetInfo {
pub(crate) struct AssetInfos {
path_to_id: HashMap<AssetPath<'static>, TypeIdMap<UntypedAssetId>>,
infos: HashMap<UntypedAssetId, AssetInfo>,
/// If set to `true`, this informs [`AssetInfos`] to track data relevant to watching for changes (such as `load_dependants`)
/// If set to `true`, this informs [`AssetInfos`] to track data relevant to watching for changes (such as `load_dependents`)
/// This should only be set at startup.
pub(crate) watching_for_changes: bool,
/// Tracks assets that depend on the "key" asset path inside their asset loaders ("loader dependencies")
/// This should only be set when watching for changes to avoid unnecessary work.
pub(crate) loader_dependants: HashMap<AssetPath<'static>, HashSet<AssetPath<'static>>>,
pub(crate) loader_dependents: HashMap<AssetPath<'static>, HashSet<AssetPath<'static>>>,
/// Tracks living labeled assets for a given source asset.
/// This should only be set when watching for changes to avoid unnecessary work.
pub(crate) living_labeled_assets: HashMap<AssetPath<'static>, HashSet<Box<str>>>,
@ -372,7 +372,7 @@ impl AssetInfos {
Self::process_handle_drop_internal(
&mut self.infos,
&mut self.path_to_id,
&mut self.loader_dependants,
&mut self.loader_dependents,
&mut self.living_labeled_assets,
&mut self.pending_tasks,
self.watching_for_changes,
@ -380,7 +380,7 @@ impl AssetInfos {
)
}
/// Updates [`AssetInfo`] / load state for an asset that has finished loading (and relevant dependencies / dependants).
/// Updates [`AssetInfo`] / load state for an asset that has finished loading (and relevant dependencies / dependents).
pub(crate) fn process_asset_load(
&mut self,
loaded_asset_id: UntypedAssetId,
@ -407,7 +407,7 @@ impl AssetInfos {
| RecursiveDependencyLoadState::NotLoaded => {
// If dependency is loading, wait for it.
dep_info
.dependants_waiting_on_recursive_dep_load
.dependents_waiting_on_recursive_dep_load
.insert(loaded_asset_id);
}
RecursiveDependencyLoadState::Loaded => {
@ -425,7 +425,7 @@ impl AssetInfos {
match dep_info.load_state {
LoadState::NotLoaded | LoadState::Loading => {
// If dependency is loading, wait for it.
dep_info.dependants_waiting_on_load.insert(loaded_asset_id);
dep_info.dependents_waiting_on_load.insert(loaded_asset_id);
true
}
LoadState::Loaded => {
@ -469,7 +469,7 @@ impl AssetInfos {
(_loading, _failed) => RecursiveDependencyLoadState::Failed(rec_dep_error.unwrap()),
};
let (dependants_waiting_on_load, dependants_waiting_on_rec_load) = {
let (dependents_waiting_on_load, dependents_waiting_on_rec_load) = {
let watching_for_changes = self.watching_for_changes;
// if watching for changes, track reverse loader dependencies for hot reloading
if watching_for_changes {
@ -479,11 +479,11 @@ impl AssetInfos {
.expect("Asset info should always exist at this point");
if let Some(asset_path) = &info.path {
for loader_dependency in loaded_asset.loader_dependencies.keys() {
let dependants = self
.loader_dependants
let dependents = self
.loader_dependents
.entry(loader_dependency.clone())
.or_default();
dependants.insert(asset_path.clone());
dependents.insert(asset_path.clone());
}
}
}
@ -501,22 +501,22 @@ impl AssetInfos {
info.loader_dependencies = loaded_asset.loader_dependencies;
}
let dependants_waiting_on_rec_load =
let dependents_waiting_on_rec_load =
if rec_dep_load_state.is_loaded() || rec_dep_load_state.is_failed() {
Some(core::mem::take(
&mut info.dependants_waiting_on_recursive_dep_load,
&mut info.dependents_waiting_on_recursive_dep_load,
))
} else {
None
};
(
core::mem::take(&mut info.dependants_waiting_on_load),
dependants_waiting_on_rec_load,
core::mem::take(&mut info.dependents_waiting_on_load),
dependents_waiting_on_rec_load,
)
};
for id in dependants_waiting_on_load {
for id in dependents_waiting_on_load {
if let Some(info) = self.get_mut(id) {
info.loading_dependencies.remove(&loaded_asset_id);
if info.loading_dependencies.is_empty() && !info.dep_load_state.is_failed() {
@ -526,20 +526,20 @@ impl AssetInfos {
}
}
if let Some(dependants_waiting_on_rec_load) = dependants_waiting_on_rec_load {
if let Some(dependents_waiting_on_rec_load) = dependents_waiting_on_rec_load {
match rec_dep_load_state {
RecursiveDependencyLoadState::Loaded => {
for dep_id in dependants_waiting_on_rec_load {
for dep_id in dependents_waiting_on_rec_load {
Self::propagate_loaded_state(self, loaded_asset_id, dep_id, sender);
}
}
RecursiveDependencyLoadState::Failed(ref error) => {
for dep_id in dependants_waiting_on_rec_load {
for dep_id in dependents_waiting_on_rec_load {
Self::propagate_failed_state(self, loaded_asset_id, dep_id, error);
}
}
RecursiveDependencyLoadState::Loading | RecursiveDependencyLoadState::NotLoaded => {
// dependants_waiting_on_rec_load should be None in this case
// dependents_waiting_on_rec_load should be None in this case
unreachable!("`Loading` and `NotLoaded` state should never be propagated.")
}
}
@ -553,7 +553,7 @@ impl AssetInfos {
waiting_id: UntypedAssetId,
sender: &Sender<InternalAssetEvent>,
) {
let dependants_waiting_on_rec_load = if let Some(info) = infos.get_mut(waiting_id) {
let dependents_waiting_on_rec_load = if let Some(info) = infos.get_mut(waiting_id) {
info.loading_rec_dependencies.remove(&loaded_id);
if info.loading_rec_dependencies.is_empty() && info.failed_rec_dependencies.is_empty() {
info.rec_dep_load_state = RecursiveDependencyLoadState::Loaded;
@ -563,7 +563,7 @@ impl AssetInfos {
.unwrap();
}
Some(core::mem::take(
&mut info.dependants_waiting_on_recursive_dep_load,
&mut info.dependents_waiting_on_recursive_dep_load,
))
} else {
None
@ -572,8 +572,8 @@ impl AssetInfos {
None
};
if let Some(dependants_waiting_on_rec_load) = dependants_waiting_on_rec_load {
for dep_id in dependants_waiting_on_rec_load {
if let Some(dependents_waiting_on_rec_load) = dependents_waiting_on_rec_load {
for dep_id in dependents_waiting_on_rec_load {
Self::propagate_loaded_state(infos, waiting_id, dep_id, sender);
}
}
@ -586,19 +586,19 @@ impl AssetInfos {
waiting_id: UntypedAssetId,
error: &Arc<AssetLoadError>,
) {
let dependants_waiting_on_rec_load = if let Some(info) = infos.get_mut(waiting_id) {
let dependents_waiting_on_rec_load = if let Some(info) = infos.get_mut(waiting_id) {
info.loading_rec_dependencies.remove(&failed_id);
info.failed_rec_dependencies.insert(failed_id);
info.rec_dep_load_state = RecursiveDependencyLoadState::Failed(error.clone());
Some(core::mem::take(
&mut info.dependants_waiting_on_recursive_dep_load,
&mut info.dependents_waiting_on_recursive_dep_load,
))
} else {
None
};
if let Some(dependants_waiting_on_rec_load) = dependants_waiting_on_rec_load {
for dep_id in dependants_waiting_on_rec_load {
if let Some(dependents_waiting_on_rec_load) = dependents_waiting_on_rec_load {
for dep_id in dependents_waiting_on_rec_load {
Self::propagate_failed_state(infos, waiting_id, dep_id, error);
}
}
@ -611,7 +611,7 @@ impl AssetInfos {
}
let error = Arc::new(error);
let (dependants_waiting_on_load, dependants_waiting_on_rec_load) = {
let (dependents_waiting_on_load, dependents_waiting_on_rec_load) = {
let Some(info) = self.get_mut(failed_id) else {
// The asset was already dropped.
return;
@ -623,12 +623,12 @@ impl AssetInfos {
waker.wake();
}
(
core::mem::take(&mut info.dependants_waiting_on_load),
core::mem::take(&mut info.dependants_waiting_on_recursive_dep_load),
core::mem::take(&mut info.dependents_waiting_on_load),
core::mem::take(&mut info.dependents_waiting_on_recursive_dep_load),
)
};
for waiting_id in dependants_waiting_on_load {
for waiting_id in dependents_waiting_on_load {
if let Some(info) = self.get_mut(waiting_id) {
info.loading_dependencies.remove(&failed_id);
info.failed_dependencies.insert(failed_id);
@ -639,20 +639,20 @@ impl AssetInfos {
}
}
for waiting_id in dependants_waiting_on_rec_load {
for waiting_id in dependents_waiting_on_rec_load {
Self::propagate_failed_state(self, failed_id, waiting_id, &error);
}
}
fn remove_dependants_and_labels(
fn remove_dependents_and_labels(
info: &AssetInfo,
loader_dependants: &mut HashMap<AssetPath<'static>, HashSet<AssetPath<'static>>>,
loader_dependents: &mut HashMap<AssetPath<'static>, HashSet<AssetPath<'static>>>,
path: &AssetPath<'static>,
living_labeled_assets: &mut HashMap<AssetPath<'static>, HashSet<Box<str>>>,
) {
for loader_dependency in info.loader_dependencies.keys() {
if let Some(dependants) = loader_dependants.get_mut(loader_dependency) {
dependants.remove(path);
if let Some(dependents) = loader_dependents.get_mut(loader_dependency) {
dependents.remove(path);
}
}
@ -676,7 +676,7 @@ impl AssetInfos {
fn process_handle_drop_internal(
infos: &mut HashMap<UntypedAssetId, AssetInfo>,
path_to_id: &mut HashMap<AssetPath<'static>, TypeIdMap<UntypedAssetId>>,
loader_dependants: &mut HashMap<AssetPath<'static>, HashSet<AssetPath<'static>>>,
loader_dependents: &mut HashMap<AssetPath<'static>, HashSet<AssetPath<'static>>>,
living_labeled_assets: &mut HashMap<AssetPath<'static>, HashSet<Box<str>>>,
pending_tasks: &mut HashMap<UntypedAssetId, Task<()>>,
watching_for_changes: bool,
@ -703,9 +703,9 @@ impl AssetInfos {
};
if watching_for_changes {
Self::remove_dependants_and_labels(
Self::remove_dependents_and_labels(
&info,
loader_dependants,
loader_dependents,
path,
living_labeled_assets,
);
@ -735,7 +735,7 @@ impl AssetInfos {
Self::process_handle_drop_internal(
&mut self.infos,
&mut self.path_to_id,
&mut self.loader_dependants,
&mut self.loader_dependents,
&mut self.living_labeled_assets,
&mut self.pending_tasks,
self.watching_for_changes,

View file

@ -1523,10 +1523,10 @@ pub fn handle_internal_asset_events(world: &mut World) {
infos: &AssetInfos,
paths_to_reload: &mut HashSet<AssetPath<'static>>,
) {
if let Some(dependants) = infos.loader_dependants.get(asset_path) {
for dependant in dependants {
paths_to_reload.insert(dependant.to_owned());
queue_ancestors(dependant, infos, paths_to_reload);
if let Some(dependents) = infos.loader_dependents.get(asset_path) {
for dependent in dependents {
paths_to_reload.insert(dependent.to_owned());
queue_ancestors(dependent, infos, paths_to_reload);
}
}
}

View file

@ -66,7 +66,7 @@ fn fragment(
// This means that for a frame time of 20ms, the shutter is only open for 10ms.
//
// Using a shutter angle larger than 1.0 is non-physical, objects would need to move further
// than they physically travelled during a frame, which is not possible. Note: we allow values
// than they physically traveled during a frame, which is not possible. Note: we allow values
// larger than 1.0 because it may be desired for artistic reasons.
let exposure_vector = shutter_angle * this_motion_vector;

View file

@ -119,7 +119,7 @@ pub mod internal {
let thread_pool = AsyncComputeTaskPool::get();
// Only queue a new system refresh task when necessary
// Queueing earlier than that will not give new data
// Queuing earlier than that will not give new data
if last_refresh.elapsed() > sysinfo::MINIMUM_CPU_UPDATE_INTERVAL
// These tasks don't yield and will take up all of the task pool's
// threads if we don't limit their amount.

View file

@ -32,7 +32,7 @@ use core::{any::TypeId, ptr::NonNull};
///
/// Each bundle represents a static set of [`Component`] types.
/// Currently, bundles can only contain one of each [`Component`], and will
/// panic once initialised if this is not met.
/// panic once initialized if this is not met.
///
/// ## Insertion
///

View file

@ -153,7 +153,7 @@ type IdCursor = isize;
reflect(Serialize, Deserialize)
)]
// Alignment repr necessary to allow LLVM to better output
// optimised codegen for `to_bits`, `PartialEq` and `Ord`.
// optimized codegen for `to_bits`, `PartialEq` and `Ord`.
#[repr(C, align(8))]
pub struct Entity {
// Do not reorder the fields here. The ordering is explicitly used by repr(C)
@ -170,7 +170,7 @@ pub struct Entity {
impl PartialEq for Entity {
#[inline]
fn eq(&self, other: &Entity) -> bool {
// By using `to_bits`, the codegen can be optimised out even
// By using `to_bits`, the codegen can be optimized out even
// further potentially. Relies on the correct alignment/field
// order of `Entity`.
self.to_bits() == other.to_bits()
@ -179,10 +179,10 @@ impl PartialEq for Entity {
impl Eq for Entity {}
// The derive macro codegen output is not optimal and can't be optimised as well
// The derive macro codegen output is not optimal and can't be optimized as well
// by the compiler. This impl resolves the issue of non-optimal codegen by relying
// on comparing against the bit representation of `Entity` instead of comparing
// the fields. The result is then LLVM is able to optimise the codegen for Entity
// the fields. The result is then LLVM is able to optimize the codegen for Entity
// far beyond what the derive macro can.
// See <https://github.com/rust-lang/rust/issues/106107>
impl PartialOrd for Entity {
@ -193,10 +193,10 @@ impl PartialOrd for Entity {
}
}
// The derive macro codegen output is not optimal and can't be optimised as well
// The derive macro codegen output is not optimal and can't be optimized as well
// by the compiler. This impl resolves the issue of non-optimal codegen by relying
// on comparing against the bit representation of `Entity` instead of comparing
// the fields. The result is then LLVM is able to optimise the codegen for Entity
// the fields. The result is then LLVM is able to optimize the codegen for Entity
// far beyond what the derive macro can.
// See <https://github.com/rust-lang/rust/issues/106107>
impl Ord for Entity {
@ -310,7 +310,7 @@ impl Entity {
match id {
Ok(entity) => entity,
Err(_) => panic!("Attempted to initialise invalid bits as an entity"),
Err(_) => panic!("Attempted to initialize invalid bits as an entity"),
}
}

View file

@ -8,7 +8,7 @@ use core::fmt;
#[derive(Debug, PartialEq, Eq, Clone, Copy)]
#[non_exhaustive]
pub enum IdentifierError {
/// A given ID has an invalid value for initialising to a [`crate::identifier::Identifier`].
/// A given ID has an invalid value for initializing to a [`crate::identifier::Identifier`].
InvalidIdentifier,
/// A given ID has an invalid configuration of bits for converting to an [`crate::entity::Entity`].
InvalidEntityId(u64),

View file

@ -23,7 +23,7 @@ pub(crate) mod masks;
#[cfg_attr(feature = "bevy_reflect", reflect(opaque))]
#[cfg_attr(feature = "bevy_reflect", reflect(Debug, Hash, PartialEq))]
// Alignment repr necessary to allow LLVM to better output
// optimised codegen for `to_bits`, `PartialEq` and `Ord`.
// optimized codegen for `to_bits`, `PartialEq` and `Ord`.
#[repr(C, align(8))]
pub struct Identifier {
// Do not reorder the fields here. The ordering is explicitly used by repr(C)
@ -49,7 +49,7 @@ impl Identifier {
let packed_high = IdentifierMask::pack_kind_into_high(masked_value, kind);
// If the packed high component ends up being zero, that means that we tried
// to initialise an Identifier into an invalid state.
// to initialize an Identifier into an invalid state.
if packed_high == 0 {
Err(IdentifierError::InvalidIdentifier)
} else {
@ -107,7 +107,7 @@ impl Identifier {
match id {
Ok(id) => id,
Err(_) => panic!("Attempted to initialise invalid bits as an id"),
Err(_) => panic!("Attempted to initialize invalid bits as an id"),
}
}
@ -133,7 +133,7 @@ impl Identifier {
impl PartialEq for Identifier {
#[inline]
fn eq(&self, other: &Self) -> bool {
// By using `to_bits`, the codegen can be optimised out even
// By using `to_bits`, the codegen can be optimized out even
// further potentially. Relies on the correct alignment/field
// order of `Entity`.
self.to_bits() == other.to_bits()
@ -142,10 +142,10 @@ impl PartialEq for Identifier {
impl Eq for Identifier {}
// The derive macro codegen output is not optimal and can't be optimised as well
// The derive macro codegen output is not optimal and can't be optimized as well
// by the compiler. This impl resolves the issue of non-optimal codegen by relying
// on comparing against the bit representation of `Entity` instead of comparing
// the fields. The result is then LLVM is able to optimise the codegen for Entity
// the fields. The result is then LLVM is able to optimize the codegen for Entity
// far beyond what the derive macro can.
// See <https://github.com/rust-lang/rust/issues/106107>
impl PartialOrd for Identifier {
@ -156,10 +156,10 @@ impl PartialOrd for Identifier {
}
}
// The derive macro codegen output is not optimal and can't be optimised as well
// The derive macro codegen output is not optimal and can't be optimized as well
// by the compiler. This impl resolves the issue of non-optimal codegen by relying
// on comparing against the bit representation of `Entity` instead of comparing
// the fields. The result is then LLVM is able to optimise the codegen for Entity
// the fields. The result is then LLVM is able to optimize the codegen for Entity
// far beyond what the derive macro can.
// See <https://github.com/rust-lang/rust/issues/106107>
impl Ord for Identifier {

View file

@ -88,7 +88,7 @@ impl Component for ObserverState {
/// Type for function that is run when an observer is triggered.
///
/// Typically refers to the default runner that runs the system stored in the associated [`Observer`] component,
/// but can be overridden for custom behaviour.
/// but can be overridden for custom behavior.
pub type ObserverRunner = fn(DeferredWorld, ObserverTrigger, PtrMut, propagate: &mut bool);
/// An [`Observer`] system. Add this [`Component`] to an [`Entity`] to turn it into an "observer".

View file

@ -315,7 +315,7 @@ where
/// If you configure two [`System`]s like `(GameSystem::A).after(GameSystem::B)` or `(GameSystem::A).before(GameSystem::B)`, the `GameSystem::B` will not be automatically scheduled.
///
/// This means that the system `GameSystem::A` and the system or systems in `GameSystem::B` will run independently of each other if `GameSystem::B` was never explicitly scheduled with [`configure_sets`]
/// If that is the case, `.after`/`.before` will not provide the desired behaviour
/// If that is the case, `.after`/`.before` will not provide the desired behavior
/// and the systems can run in parallel or in any order determined by the scheduler.
/// Only use `after(GameSystem::B)` and `before(GameSystem::B)` when you know that `B` has already been scheduled for you,
/// e.g. when it was provided by Bevy or a third-party dependency,

View file

@ -1138,7 +1138,7 @@ impl ScheduleGraph {
Ok(self.build_schedule_inner(dependency_flattened_dag, hier_results.reachable))
}
// modify the graph to have sync nodes for any dependants after a system with deferred system params
// modify the graph to have sync nodes for any dependents after a system with deferred system params
fn auto_insert_apply_deferred(
&mut self,
dependency_flattened: &mut GraphMap<NodeId, (), Directed>,

View file

@ -735,10 +735,10 @@ impl<'w, 's> Commands<'w, 's> {
/// # high_score: u32,
/// # }
/// #
/// # fn initialise_scoreboard(mut commands: Commands) {
/// # fn initialize_scoreboard(mut commands: Commands) {
/// commands.init_resource::<Scoreboard>();
/// # }
/// # bevy_ecs::system::assert_is_system(initialise_scoreboard);
/// # bevy_ecs::system::assert_is_system(initialize_scoreboard);
/// ```
#[track_caller]
pub fn init_resource<R: Resource + FromWorld>(&mut self) {

View file

@ -659,7 +659,7 @@ impl<Marker, F> FunctionSystem<Marker, F>
where
F: SystemParamFunction<Marker>,
{
/// Message shown when a system isn't initialised
/// Message shown when a system isn't initialized
// When lines get too long, rustfmt can sometimes refuse to format them.
// Work around this by storing the message separately.
const PARAM_MESSAGE: &'static str = "System's param_state was not found. Did you forget to initialize this system before running it?";

View file

@ -1190,7 +1190,7 @@ pub trait SystemBuffer: FromWorld + Send + 'static {
///
/// use bevy_ecs::system::{Deferred, SystemBuffer, SystemMeta};
///
/// // Uses deferred mutations to allow signalling the alarm from multiple systems in parallel.
/// // Uses deferred mutations to allow signaling the alarm from multiple systems in parallel.
/// #[derive(Resource, Default)]
/// struct AlarmFlag(bool);
///

View file

@ -3257,7 +3257,7 @@ impl World {
let id = self
.bundles
.register_info::<B>(&mut self.components, &mut self.storages);
// SAFETY: We just initialised the bundle so its id should definitely be valid.
// SAFETY: We just initialized the bundle so its id should definitely be valid.
unsafe { self.bundles.get(id).debug_checked_unwrap() }
}
}

View file

@ -1836,7 +1836,7 @@ async fn load_buffers(
/// Iterator for a Gltf tree.
///
/// It resolves a Gltf tree and allows for a safe Gltf nodes iteration,
/// putting dependant nodes before dependencies.
/// putting dependent nodes before dependencies.
struct GltfTreeIterator<'a> {
nodes: Vec<Node<'a>>,
}

View file

@ -112,7 +112,7 @@ impl Image {
Vec::with_capacity(width as usize * height as usize * format.pixel_size());
for pixel in image.into_raw().chunks_exact(3) {
// TODO: use the array_chunks method once stabilised
// TODO: use the array_chunks method once stabilized
// https://github.com/rust-lang/rust/issues/74985
let r = pixel[0];
let g = pixel[1];

View file

@ -395,7 +395,7 @@ pub enum KeyCode {
/// Japanese: <kbd>無変換</kbd> (muhenkan)
NonConvert,
/// <kbd>⌦</kbd>. The forward delete key.
/// Note that on Apple keyboards, the key labelled <kbd>Delete</kbd> on the main part of
/// Note that on Apple keyboards, the key labeled <kbd>Delete</kbd> on the main part of
/// the keyboard is encoded as [`Backspace`].
///
/// [`Backspace`]: Self::Backspace
@ -532,9 +532,9 @@ pub enum KeyCode {
/// <kbd>Eject</kbd> or <kbd>⏏</kbd>. This key is placed in the function section on some Apple
/// keyboards.
Eject,
/// Sometimes labelled <kbd>My Computer</kbd> on the keyboard
/// Sometimes labeled <kbd>My Computer</kbd> on the keyboard
LaunchApp1,
/// Sometimes labelled <kbd>Calculator</kbd> on the keyboard
/// Sometimes labeled <kbd>Calculator</kbd> on the keyboard
LaunchApp2,
/// LaunchMail
LaunchMail,
@ -927,7 +927,7 @@ pub enum Key {
/// be restored. The computer will then shutdown.
Hibernate,
/// The Standby key. This key turns off the display and places the computer into a low-power
/// mode without completely shutting down. It is sometimes labelled `Suspend` or `Sleep` key.
/// mode without completely shutting down. It is sometimes labeled `Suspend` or `Sleep` key.
/// (`KEYCODE_SLEEP`)
Standby,
/// The WakeUp key. (`KEYCODE_WAKEUP`)

View file

@ -108,7 +108,7 @@ pub(crate) struct FlushGuard(SyncCell<tracing_chrome::FlushGuard>);
/// If you define the `RUST_LOG` environment variable, the [`LogPlugin`] settings
/// will be ignored.
///
/// Also, to disable colour terminal output (ANSI escape codes), you can
/// Also, to disable color terminal output (ANSI escape codes), you can
/// set the environment variable `NO_COLOR` to any value. This common
/// convention is documented at [no-color.org](https://no-color.org/).
/// For example:

View file

@ -83,7 +83,7 @@ impl IRect {
/// Create a new rectangle from its center and size.
///
/// # Rounding Behaviour
/// # Rounding Behavior
///
/// If the size contains odd numbers they will be rounded down to the nearest whole number.
///
@ -190,7 +190,7 @@ impl IRect {
/// Rectangle half-size.
///
/// # Rounding Behaviour
/// # Rounding Behavior
///
/// If the full size contains odd numbers they will be rounded down to the nearest whole number when calculating the half size.
///
@ -208,7 +208,7 @@ impl IRect {
/// The center point of the rectangle.
///
/// # Rounding Behaviour
/// # Rounding Behavior
///
/// If the (min + max) contains odd numbers they will be rounded down to the nearest whole number when calculating the center.
///

View file

@ -83,7 +83,7 @@ impl URect {
/// Create a new rectangle from its center and size.
///
/// # Rounding Behaviour
/// # Rounding Behavior
///
/// If the size contains odd numbers they will be rounded down to the nearest whole number.
///
@ -187,7 +187,7 @@ impl URect {
/// Rectangle half-size.
///
/// # Rounding Behaviour
/// # Rounding Behavior
///
/// If the full size contains odd numbers they will be rounded down to the nearest whole number when calculating the half size.
///
@ -205,7 +205,7 @@ impl URect {
/// The center point of the rectangle.
///
/// # Rounding Behaviour
/// # Rounding Behavior
///
/// If the (min + max) contains odd numbers they will be rounded down to the nearest whole number when calculating the center.
///

View file

@ -420,7 +420,7 @@ impl ShapeSample for Cylinder {
}
fn sample_boundary<R: Rng + ?Sized>(&self, rng: &mut R) -> Vec3 {
// This uses the area of the ends divided by the overall surface area (optimised)
// This uses the area of the ends divided by the overall surface area (optimized)
// [2 (\pi r^2)]/[2 (\pi r^2) + 2 \pi r h] = r/(r + h)
if self.radius + 2.0 * self.half_height > 0.0 {
if rng.gen_bool((self.radius / (self.radius + 2.0 * self.half_height)) as f64) {

View file

@ -87,7 +87,7 @@ pub const VERTEX_ATTRIBUTE_BUFFER_ID: u64 = 10;
/// other APIs can have other conventions, `OpenGL` starts at bottom-left.
/// - It is possible and sometimes useful for multiple vertices to have the same
/// [position attribute](Mesh::ATTRIBUTE_POSITION) value,
/// it's a common technique in 3D modelling for complex UV mapping or other calculations.
/// it's a common technique in 3D modeling for complex UV mapping or other calculations.
/// - Bevy performs frustum culling based on the `Aabb` of meshes, which is calculated
/// and added automatically for new meshes only. If a mesh is modified, the entity's `Aabb`
/// needs to be updated manually or deleted so that it is re-calculated.

View file

@ -86,7 +86,7 @@ impl MeshBuilder for ConeMeshBuilder {
// The tip doesn't have a singular normal that works correctly.
// We use an invalid normal here so that it becomes NaN in the fragment shader
// and doesn't affect the overall shading. This might seem hacky, but it's one of
// the only ways to get perfectly smooth cones without creases or other shading artefacts.
// the only ways to get perfectly smooth cones without creases or other shading artifacts.
//
// Note that this requires that normals are not normalized in the vertex shader,
// as that would make the entire triangle invalid and make the cone appear as black.

View file

@ -12,11 +12,11 @@ pub enum PerimeterSegment {
///
/// This has the effect of rendering the segment's faces with softened edges, so it is appropriate for curved shapes.
///
/// The normals for the vertices that are part of this segment will be calculated based on the positions of their neighbours.
/// Each normal is interpolated between the normals of the two line segments connecting it with its neighbours.
/// The normals for the vertices that are part of this segment will be calculated based on the positions of their neighbors.
/// Each normal is interpolated between the normals of the two line segments connecting it with its neighbors.
/// Closer vertices have a stronger effect on the normal than more distant ones.
///
/// Since the vertices corresponding to the first and last indices do not have two neighbouring vertices, their normals must be provided manually.
/// Since the vertices corresponding to the first and last indices do not have two neighboring vertices, their normals must be provided manually.
Smooth {
/// The normal of the first vertex.
first_normal: Vec2,
@ -348,8 +348,8 @@ where
uvs.push([uv_x, uv_y]);
}
// The normal for the current vertices can be calculated based on the two neighbouring vertices.
// The normal is interpolated between the normals of the two line segments connecting the current vertex with its neighbours.
// The normal for the current vertices can be calculated based on the two neighboring vertices.
// The normal is interpolated between the normals of the two line segments connecting the current vertex with its neighbors.
// Closer vertices have a stronger effect on the normal than more distant ones.
let n = {
let ab = Vec2::from_slice(&b) - Vec2::from_slice(&a);

View file

@ -5,7 +5,7 @@
//! modification to Morten S. Mikkelsen's original tangent space algorithm
//! implementation written in C. The original source code can be found at
//! <https://archive.blender.org/wiki/index.php/Dev:Shading/Tangent_Space_Normal_Maps>
//! and includes the following licence:
//! and includes the following license:
//!
//! Copyright (C) 2011 by Morten S. Mikkelsen
//!

View file

@ -51,7 +51,7 @@ pub mod light_consts {
/// Predefined for lux values in several locations.
///
/// The **lux** (symbol: **lx**) is the unit of [illuminance], or [luminous flux] per unit area,
/// in the [International System of Units] (SI). It is equal to one lumen per square metre.
/// in the [International System of Units] (SI). It is equal to one lumen per square meter.
///
/// For more information, see [wikipedia](https://en.wikipedia.org/wiki/Lux)
///

View file

@ -387,7 +387,7 @@ pub struct StandardMaterial {
/// Specifies the level of exposure to ambient light.
///
/// This is usually generated and stored automatically ("baked") by 3D-modelling software.
/// This is usually generated and stored automatically ("baked") by 3D-modeling software.
///
/// Typically, steep concave parts of a model (such as the armpit of a shirt) are darker,
/// because they have little exposure to light.
@ -913,7 +913,7 @@ pub struct StandardMaterialUniform {
// Use a color for user-friendliness even though we technically don't use the alpha channel
// Might be used in the future for exposure correction in HDR
pub emissive: Vec4,
/// Color white light takes after travelling through the attenuation distance underneath the material surface
/// Color white light takes after traveling through the attenuation distance underneath the material surface
pub attenuation_color: Vec4,
/// The transform applied to the UVs corresponding to `ATTRIBUTE_UV_0` on the mesh before sampling. Default is identity.
pub uv_transform: Mat3,

View file

@ -77,7 +77,7 @@ fn cluster_debug_visualization(
// Cluster allocation debug (using 'over' alpha blending)
#ifdef CLUSTERED_FORWARD_DEBUG_Z_SLICES
// NOTE: This debug mode visualises the z-slices
// NOTE: This debug mode visualizes the z-slices
let cluster_overlay_alpha = 0.1;
var z_slice: u32 = view_z_to_z_slice(view_z, is_orthographic);
// A hack to make the colors alternate a bit more
@ -96,7 +96,7 @@ fn cluster_debug_visualization(
);
#endif // CLUSTERED_FORWARD_DEBUG_Z_SLICES
#ifdef CLUSTERED_FORWARD_DEBUG_CLUSTER_COMPLEXITY
// NOTE: This debug mode visualises the number of clusterable objects within
// NOTE: This debug mode visualizes the number of clusterable objects within
// the cluster that contains the fragment. It shows a sort of cluster
// complexity measure.
let cluster_overlay_alpha = 0.1;

View file

@ -537,7 +537,7 @@ pub const fn dangling_with_align(align: NonZeroUsize) -> NonNull<u8> {
debug_assert!(align.is_power_of_two(), "Alignment must be power of two.");
// SAFETY: The pointer will not be null, since it was created
// from the address of a `NonZero<usize>`.
// TODO: use https://doc.rust-lang.org/std/ptr/struct.NonNull.html#method.with_addr once stabilised
// TODO: use https://doc.rust-lang.org/std/ptr/struct.NonNull.html#method.with_addr once stabilized
unsafe { NonNull::new_unchecked(ptr::null_mut::<u8>().wrapping_add(align.get())) }
}

View file

@ -1001,7 +1001,7 @@ impl<'a> ReflectTypePath<'a> {
///
/// Returns [`None`] if the type is [primitive] or [anonymous].
///
/// For non-customised [internal] paths this is created from [`module_path`].
/// For non-customized [internal] paths this is created from [`module_path`].
///
/// For `Option<PhantomData>`, this is `"core"`.
///
@ -1131,7 +1131,7 @@ impl<'a> ReflectTypePath<'a> {
///
/// Returns [`None`] if the type is [primitive] or [anonymous].
///
/// For non-customised [internal] paths this is created from [`module_path`].
/// For non-customized [internal] paths this is created from [`module_path`].
///
/// For `Option<PhantomData>`, this is `"std::option"`.
///

View file

@ -51,7 +51,7 @@
//! `dyn Reflect` trait objects can be used similarly to `dyn PartialReflect`,
//! but `Reflect` is also often used in trait bounds (like `T: Reflect`).
//!
//! The distinction between `PartialReflect` and `Reflect` is summarised in the following:
//! The distinction between `PartialReflect` and `Reflect` is summarized in the following:
//! * `PartialReflect` is a trait for interacting with values under `bevy_reflect`'s data model.
//! This means values implementing `PartialReflect` can be dynamically constructed and introspected.
//! * The `Reflect` trait, however, ensures that the interface exposed by `PartialReflect`

View file

@ -159,7 +159,7 @@ impl<'a, T: ShaderType + WriteInto> IntoBinding<'a> for &'a StorageBuffer<T> {
///
/// The contained data is stored in system RAM. [`write_buffer`](DynamicStorageBuffer::write_buffer)
/// queues copying of the data from system RAM to VRAM. The data within a storage buffer binding must conform to
/// [std430 alignment/padding requirements]. `DynamicStorageBuffer` takes care of serialising the inner type to conform to
/// [std430 alignment/padding requirements]. `DynamicStorageBuffer` takes care of serializing the inner type to conform to
/// these requirements. Each item [`push`](DynamicStorageBuffer::push)ed into this structure
/// will additionally be aligned to meet dynamic offset alignment requirements.
///

View file

@ -55,7 +55,7 @@ impl RenderDevice {
.contains(wgpu::Features::SPIRV_SHADER_PASSTHROUGH) =>
{
// SAFETY:
// This call passes binary data to the backend as-is and can potentially result in a driver crash or bogus behaviour.
// This call passes binary data to the backend as-is and can potentially result in a driver crash or bogus behavior.
// No attempt is made to ensure that data is valid SPIR-V.
unsafe {
self.device

View file

@ -9,9 +9,9 @@ use bevy_transform::components::{GlobalTransform, Transform};
/// A [`Bundle`] of components for drawing a single sprite from an image.
///
/// # Extra behaviours
/// # Extra behaviors
///
/// You may add one or both of the following components to enable additional behaviours:
/// You may add one or both of the following components to enable additional behaviors:
/// - [`ImageScaleMode`](crate::ImageScaleMode) to enable either slicing or tiling of the texture
/// - [`TextureAtlas`](crate::TextureAtlas) to draw a specific section of the texture
#[derive(Bundle, Clone, Debug, Default)]

View file

@ -56,7 +56,7 @@ pub trait StateSet: StateSetSealed {
///
/// The isolation works because it is implemented for both S & [`Option<S>`], and has the `RawState` associated type
/// that allows it to know what the resource in the world should be. We can then essentially "unwrap" it in our
/// `StateSet` implementation - and the behaviour of that unwrapping will depend on the arguments expected by the
/// `StateSet` implementation - and the behavior of that unwrapping will depend on the arguments expected by the
/// the [`ComputedStates`] & [`SubStates]`.
trait InnerStateSet: Sized {
type RawState: States;

View file

@ -161,7 +161,7 @@ pub trait SubStates: States + FreelyMutableState {
/// it will be created from the returned [`Some`] as the initial state.
///
/// Value within [`Some`] is ignored if the state already exists in the world
/// and only symbolises that the state should still exist.
/// and only symbolizes that the state should still exist.
///
/// Initial value can also be overwritten by [`NextState`](crate::state::NextState).
fn should_exist(sources: Self::SourceStates) -> Option<Self>;

View file

@ -135,7 +135,7 @@ pub(crate) fn internal_apply_state_transition<S: States>(
Some(entered) => {
match current_state {
// If the [`State<S>`] resource exists, and the state is not the one we are
// entering - we need to set the new value, compute dependant states, send transition events
// entering - we need to set the new value, compute dependent states, send transition events
// and register transition schedules.
Some(mut state_resource) => {
let exited = match *state_resource == entered {
@ -151,7 +151,7 @@ pub(crate) fn internal_apply_state_transition<S: States>(
});
}
None => {
// If the [`State<S>`] resource does not exist, we create it, compute dependant states, send a transition event and register the `OnEnter` schedule.
// If the [`State<S>`] resource does not exist, we create it, compute dependent states, send a transition event and register the `OnEnter` schedule.
commands.insert_resource(State(entered.clone()));
event.send(StateTransitionEvent {
@ -162,7 +162,7 @@ pub(crate) fn internal_apply_state_transition<S: States>(
};
}
None => {
// We first remove the [`State<S>`] resource, and if one existed we compute dependant states, send a transition event and run the `OnExit` schedule.
// We first remove the [`State<S>`] resource, and if one existed we compute dependent states, send a transition event and run the `OnExit` schedule.
if let Some(resource) = current_state {
commands.remove_resource::<State<S>>();

View file

@ -537,7 +537,7 @@ mod test {
// Time will wrap to modulo duration from full `elapsed()`, not to what
// is left in `elapsed_wrapped()`. This test of values is here to ensure
// that we notice if we change that behaviour.
// that we notice if we change that behavior.
assert_eq!(time.elapsed_wrapped(), Duration::from_secs(0));
assert_eq!(time.elapsed_secs_wrapped(), 0.0);
assert_eq!(time.elapsed_secs_wrapped_f64(), 0.0);

View file

@ -58,9 +58,9 @@ pub struct NodeBundle {
/// A UI node that is an image
///
/// # Extra behaviours
/// # Extra behaviors
///
/// You may add one or both of the following components to enable additional behaviours:
/// You may add one or both of the following components to enable additional behaviors:
/// - [`ImageScaleMode`](bevy_sprite::ImageScaleMode) to enable either slicing or tiling of the texture
/// - [`TextureAtlas`](bevy_sprite::TextureAtlas) to draw a specific section of the texture
#[derive(Bundle, Debug, Default)]
@ -111,9 +111,9 @@ pub struct ImageBundle {
/// A UI node that is a button
///
/// # Extra behaviours
/// # Extra behaviors
///
/// You may add one or both of the following components to enable additional behaviours:
/// You may add one or both of the following components to enable additional behaviors:
/// - [`ImageScaleMode`](bevy_sprite::ImageScaleMode) to enable either slicing or tiling of the texture
/// - [`TextureAtlas`](bevy_sprite::TextureAtlas) to draw a specific section of the texture
#[derive(Bundle, Clone, Debug)]

View file

@ -138,7 +138,7 @@ pub struct WindowDestroyed {
/// Not to be confused with the `MouseMotion` event from `bevy_input`.
///
/// Because the range of data is limited by the window area and it may have been transformed by the OS to implement certain effects like acceleration,
/// you should not use it for non-cursor-like behaviour such as 3D camera control. Please see `MouseMotion` instead.
/// you should not use it for non-cursor-like behavior such as 3D camera control. Please see `MouseMotion` instead.
///
/// [`WindowEvent::CursorMoved`]: https://docs.rs/winit/latest/winit/event/enum.WindowEvent.html#variant.CursorMoved
#[derive(Event, Debug, Clone, PartialEq, Reflect)]
@ -250,7 +250,7 @@ pub struct WindowFocused {
/// The window has been occluded (completely hidden from view).
///
/// This is different to window visibility as it depends on
/// whether the window is closed, minimised, set invisible,
/// whether the window is closed, minimized, set invisible,
/// or fully occluded by another window.
///
/// It is the translated version of [`WindowEvent::Occluded`] from the `winit` crate.

View file

@ -3,7 +3,7 @@
## Cargo Features
Bevy exposes many features to customise the engine. Enabling them add functionalities but often come at the cost of longer compilation times and extra dependencies.
Bevy exposes many features to customize the engine. Enabling them add functionalities but often come at the cost of longer compilation times and extra dependencies.
### Default Features

View file

@ -3,7 +3,7 @@
## Cargo Features
Bevy exposes many features to customise the engine. Enabling them add functionalities but often come at the cost of longer compilation times and extra dependencies.
Bevy exposes many features to customize the engine. Enabling them add functionalities but often come at the cost of longer compilation times and extra dependencies.
### Default Features

View file

@ -254,7 +254,7 @@ fn example_control_system(
camera: Single<(&mut Camera, &mut Transform, &GlobalTransform), With<Camera3d>>,
mut labels: Query<(&mut Node, &ExampleLabel)>,
mut display: Single<&mut Text, With<ExampleDisplay>>,
labelled: Query<&GlobalTransform>,
labeled: Query<&GlobalTransform>,
mut state: Local<ExampleState>,
time: Res<Time>,
input: Res<ButtonInput<KeyCode>>,
@ -308,7 +308,7 @@ fn example_control_system(
camera_transform.rotate_around(Vec3::ZERO, Quat::from_rotation_y(rotation));
for (mut node, label) in &mut labels {
let world_position = labelled.get(label.entity).unwrap().translation() + Vec3::Y;
let world_position = labeled.get(label.entity).unwrap().translation() + Vec3::Y;
let viewport_position = camera
.world_to_viewport(camera_global_transform, world_position)

View file

@ -58,7 +58,7 @@ fn setup(mut commands: Commands) {
// Other color spaces like `Srgba` or `Hsva` are neither perceptually nor physically linear.
// As such, we cannot use curves in these spaces.
// However, we can still mix these colours and animate that way. In fact, mixing colors works in any color space.
// However, we can still mix these colors and animate that way. In fact, mixing colors works in any color space.
// Spawn a spritre using the provided colors for mixing.
spawn_mixed_sprite(&mut commands, -75., colors.map(Hsla::from));

View file

@ -212,7 +212,7 @@ fn alter_mesh(
position[2] *= scale_factor;
}
// Flip the local value to reverse the behaviour next time the key is pressed.
// Flip the local value to reverse the behavior next time the key is pressed.
*is_mesh_scaled = !*is_mesh_scaled;
}
}

View file

@ -135,7 +135,7 @@ fn orbit(
camera.rotation = Quat::from_euler(EulerRot::YXZ, yaw, pitch, roll);
// Adjust the translation to maintain the correct orientation toward the orbit target.
// In our example it's a static target, but this could easily be customised.
// In our example it's a static target, but this could easily be customized.
let target = Vec3::ZERO;
camera.translation = target - camera.forward() * camera_settings.orbit_distance;
}

View file

@ -20,7 +20,7 @@ use bevy::{
use std::collections::HashMap;
#[derive(Debug)]
/// Hooks can also be registered during component initialisation by
/// Hooks can also be registered during component initialization by
/// using [`Component`] derive macro:
/// ```no_run
/// #[derive(Component)]
@ -31,7 +31,7 @@ struct MyComponent(KeyCode);
impl Component for MyComponent {
const STORAGE_TYPE: StorageType = StorageType::Table;
/// Hooks can also be registered during component initialisation by
/// Hooks can also be registered during component initialization by
/// implementing `register_component_hooks`
fn register_component_hooks(_hooks: &mut ComponentHooks) {
// Register hooks...

View file

@ -254,7 +254,7 @@ fn update_config(
if keyboard.just_pressed(KeyCode::KeyB) {
// AABB gizmos are normally only drawn on entities with a ShowAabbGizmo component
// We can change this behaviour in the configuration of AabbGizmoGroup
// We can change this behavior in the configuration of AabbGizmoGroup
config_store.config_mut::<AabbGizmoConfigGroup>().1.draw_all ^= true;
}
}

View file

@ -541,7 +541,7 @@ fn handle_mouse(
let displacement = accumulated_mouse_motion.delta;
camera_rig.yaw += displacement.x / 90.;
camera_rig.pitch += displacement.y / 90.;
// The extra 0.01 is to disallow weird behaviour at the poles of the rotation
// The extra 0.01 is to disallow weird behavior at the poles of the rotation
camera_rig.pitch = camera_rig.pitch.clamp(-PI / 2.01, PI / 2.01);
}
}

View file

@ -122,7 +122,7 @@ impl ComputedStates for IsPaused {
// Lastly, we have our tutorial, which actually has a more complex derivation.
//
// Like `IsPaused`, the tutorial has a few fully distinct possible states, so we want to represent them
// as an Enum. However - in this case they are all dependant on multiple states: the root [`TutorialState`],
// as an Enum. However - in this case they are all dependent on multiple states: the root [`TutorialState`],
// and both [`InGame`] and [`IsPaused`] - which are in turn derived from [`AppState`].
#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
enum Tutorial {

View file

@ -179,7 +179,7 @@ fn spawn_layout(mut commands: Commands, asset_server: Res<AssetServer>) {
});
}
/// Create a coloured rectangle node. The node has size as it is assumed that it will be
/// Create a colored rectangle node. The node has size as it is assumed that it will be
/// spawned as a child of a Grid container with `AlignItems::Stretch` and `JustifyItems::Stretch`
/// which will allow it to take its size from the size of the grid area it occupies.
fn item_rect(builder: &mut ChildBuilder, color: Srgba) {

View file

@ -1,4 +1,4 @@
//! A test to confirm that `bevy` allows minimising the window
//! A test to confirm that `bevy` allows minimizing the window
//! This is run in CI to ensure that this doesn't regress again.
use bevy::{core::FrameCount, prelude::*};
@ -8,17 +8,17 @@ fn main() {
App::new()
.add_plugins(DefaultPlugins.set(WindowPlugin {
primary_window: Some(Window {
title: "Minimising".into(),
title: "Minimizing".into(),
..default()
}),
..default()
}))
.add_systems(Startup, (setup_3d, setup_2d))
.add_systems(Update, minimise_automatically)
.add_systems(Update, minimize_automatically)
.run();
}
fn minimise_automatically(mut window: Single<&mut Window>, frames: Res<FrameCount>) {
fn minimize_automatically(mut window: Single<&mut Window>, frames: Res<FrameCount>) {
if frames.0 != 60 {
return;
}

View file

@ -28,6 +28,7 @@ LOD = "LOD" # Level of detail
TOI = "TOI" # Time of impact
[default]
locale = "en-us"
extend-ignore-identifiers-re = [
"NDK", # NDK - Native Development Kit
"inventario", # Inventory in Portuguese